Coverage Report

 /**
  * Copyright 2010 The Kuali Foundation Licensed under the
  * Educational Community License, Version 2.0 (the "License"); you may
  * not use this file except in compliance with the License. You may
  * obtain a copy of the License at
  *
  * http://www.osedu.org/licenses/ECL-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an "AS IS"
  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
  * or implied. See the License for the specific language governing
  * permissions and limitations under the License.
  */
 package org.kuali.student.lum.program.client.requirements;
 
 import java.util.*;
 
 import org.kuali.student.common.ui.client.application.KSAsyncCallback;
 import org.kuali.student.common.ui.client.mvc.*;
 import org.kuali.student.common.ui.client.widgets.rules.RulesUtil;
 import org.kuali.student.core.assembly.data.Data;
 import org.kuali.student.core.statement.dto.ReqCompFieldInfo;
 import org.kuali.student.core.statement.dto.ReqComponentInfo;
 import org.kuali.student.core.statement.dto.StatementTreeViewInfo;
 import org.kuali.student.core.statement.dto.StatementTypeInfo;
 import org.kuali.student.lum.program.client.ProgramConstants;
 import org.kuali.student.lum.program.client.events.StoreRequirementIDsEvent;
 import org.kuali.student.lum.program.client.events.StoreSpecRequirementIDsEvent;
 import org.kuali.student.lum.program.client.rpc.MajorDisciplineRpcService;
 import org.kuali.student.lum.program.client.rpc.MajorDisciplineRpcServiceAsync;
 import org.kuali.student.lum.program.client.rpc.StatementRpcService;
 import org.kuali.student.lum.program.client.rpc.StatementRpcServiceAsync;
 import org.kuali.student.lum.program.dto.ProgramRequirementInfo;
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.event.shared.HandlerManager;
 import com.google.gwt.user.client.Window;
 
 public class ProgramRequirementsDataModel {
 
     private final MajorDisciplineRpcServiceAsync programRemoteService = GWT.create(MajorDisciplineRpcService.class);
     private StatementRpcServiceAsync statementRpcServiceAsync = GWT.create(StatementRpcService.class);
     private Model model = null;
     private HandlerManager eventBus;
 
     //keeping track of rules and rule state
     public enum requirementState {STORED, ADDED, EDITED, DELETED;}
     private Map<Integer, ProgramRequirementInfo> progReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
     private Map<Integer, ProgramRequirementInfo> origProgReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
     private Map<Integer, requirementState> progReqState = new HashMap<Integer, requirementState>();
     private Map<Integer, requirementState> origProgReqState = new HashMap<Integer, requirementState>();
     private List<StatementTypeInfo> stmtTypes = new ArrayList<StatementTypeInfo>();
     private boolean isInitialized = false;
     private static Integer progReqIDs = 111111;
 
     public ProgramRequirementsDataModel(HandlerManager eventBus) {
         this.eventBus = eventBus;
     }
 
     //find out whether we need to reset rules based on whether we have a new program ID or not
     public void setupRules(Controller parentController, final Callback<Boolean> onReadyCallback) {
         parentController.requestModel(ProgramConstants.PROGRAM_MODEL_ID, new ModelRequestCallback() {
 
             @Override
             public void onRequestFail(Throwable cause) {
                 GWT.log("Unable to retrieve program model for program summary view", cause);
                 onReadyCallback.exec(false);
             }
 
             @Override
             public void onModelReady(Model modelIn) {
                 //TODO how can we reliably know that we need to reload rules (or not)
                 //String programId = (model == null ? null : (String)((DataModel)model).getRoot().get("id"));
                 //String modelProgramId = ((DataModel)modelIn).getRoot().get(ProgramConstants.ID);
                 //if ((modelProgramId == null) || (!modelProgramId.equals(programId))) {
                     resetRules();
                 //}
                 model = modelIn;
                 onReadyCallback.exec(true);
             }
         });
     }
 
     private void resetRules() {
         progReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
         origProgReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
         progReqState = new HashMap<Integer, requirementState>();
         origProgReqState = new HashMap<Integer, requirementState>();
         stmtTypes = new ArrayList<StatementTypeInfo>();
         model = null;
         isInitialized = false;
     }
 
     //retrieve rules based on IDs stored in this program
     public void retrieveProgramRequirements(Controller parentController, final Callback<Boolean> onReadyCallback) {
         
         setupRules(parentController, new Callback<Boolean>() {
             @Override
             public void exec(Boolean result) {
                 Data program = ((DataModel)model).getRoot().get(ProgramConstants.PROGRAM_REQUIREMENTS);
 
                 Iterator<Data.Property> realPropertyIterator = program.realPropertyIterator();
                 ArrayList<String> programRequirementIds = new ArrayList<String>();
                 while(realPropertyIterator.hasNext()) {
                     programRequirementIds.add((String)realPropertyIterator.next().getValue());
                 }
                 retrieveStatementTypes(programRequirementIds, onReadyCallback);
             }
         });               
     }
 
     private void retrieveStatementTypes(final List<String> programRequirementIds, final Callback<Boolean> onReadyCallback) {
 
         //retrieve available program requirement types
         statementRpcServiceAsync.getStatementTypesForStatementType("kuali.statement.type.program", new KSAsyncCallback<List<StatementTypeInfo>>() {
             @Override
             public void handleFailure(Throwable caught) {
                     Window.alert(caught.getMessage());
                     GWT.log("getStatementTypes failed", caught);
                 onReadyCallback.exec(false);
             }
 
             @Override
             public void onSuccess(List<StatementTypeInfo> stmtInfoTypes) {
                 //store the statement types
                 for (StatementTypeInfo stmtInfoType : stmtInfoTypes) {
                     stmtTypes.add(stmtInfoType);
                 }
 
                 //now retrieve the actual rules
                 retrieveRules(programRequirementIds, onReadyCallback);
             }
         });
     }
 
     private void retrieveRules(List<String> programRequirementIds, final Callback<Boolean> onReadyCallback) {
 
         //true if no program requirements exist yet
         if ((programRequirementIds == null) || programRequirementIds.isEmpty()) {
             isInitialized = true;
             onReadyCallback.exec(true);
             return;
         }
 
         programRemoteService.getProgramRequirements(programRequirementIds, new KSAsyncCallback<List<ProgramRequirementInfo>>() {
             @Override
             public void handleFailure(Throwable caught) {
                 Window.alert(caught.getMessage());
                 GWT.log("getProgramRequirement failed", caught);
                 onReadyCallback.exec(false);
             }
 
             @Override
             public void onSuccess(List<ProgramRequirementInfo> programReqInfos) {
                 //update rules list with new program requirements
                 origProgReqInfos.clear();
                 origProgReqState.clear();
                 progReqInfos.clear();
                 progReqState.clear();
                 for (ProgramRequirementInfo programReqInfo : programReqInfos) {
 
                     if (getStmtTypeInfo(programReqInfo.getStatement().getType()) == null) {
                         Window.alert("Did not find corresponding statement type for program requirement of type: " + programReqInfo.getStatement().getType());
                         GWT.log("Did not find corresponding statement type for program requirement of type: " + programReqInfo.getStatement().getType(), null);
                     }
 
                     setRuleState(programReqInfo);
                     origProgReqInfos.put(progReqIDs, cloneProgReq(programReqInfo));
                     origProgReqState.put(progReqIDs, requirementState.STORED);
                     progReqInfos.put(progReqIDs, programReqInfo);
                     progReqState.put(progReqIDs++, requirementState.STORED);
                 }
 
                 isInitialized = true;
                 onReadyCallback.exec(true);
             }
         });     
     }
 
     public ProgramRequirementInfo updateRules(StatementTreeViewInfo newSubRule, Integer internalProgReqID, boolean isNewRule) {
 
         ProgramRequirementInfo affectedRule = progReqInfos.get(internalProgReqID);
 
         if (affectedRule == null) {
             Window.alert("Cannot find program requirement with a statement that has id: '" + newSubRule.getId() + "'");
             GWT.log("Cannot find program requirement with a statement that has id: '" + newSubRule.getId() + "'", null);
             return null;
         }
 
         if (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.STORED) {
             progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.EDITED);
         }
 
         //if we don't have top level req. components wrapped in statement, do so before we add another statement
         StatementTreeViewInfo affectedTopTree = affectedRule.getStatement();
         if ((affectedTopTree.getReqComponents() != null) && !affectedTopTree.getReqComponents().isEmpty()) {
             StatementTreeViewInfo stmtTree = new StatementTreeViewInfo();
             stmtTree.setId(ProgramRequirementsSummaryView.generateStatementTreeId());
             stmtTree.setType( affectedRule.getStatement().getType());
             stmtTree.setReqComponents(affectedTopTree.getReqComponents());
             List<StatementTreeViewInfo> stmtList = new ArrayList<StatementTreeViewInfo>();
             stmtList.add(stmtTree);
             affectedTopTree.setStatements(stmtList);
         }
 
         //now update the actual rule
         List<StatementTreeViewInfo> affectedSubRules = affectedTopTree.getStatements();
         if (isNewRule) {
             affectedSubRules.add(newSubRule);
         } else {
             //update rule
             if (affectedSubRules == null || affectedSubRules.isEmpty()) {
                 affectedRule.setStatement(newSubRule);
             } else { //replace the related stored subrule with a new version
                 for (StatementTreeViewInfo subRule : affectedSubRules) {
                     if (subRule.getId().equals(newSubRule.getId())) {
                         int treeIx = affectedSubRules.indexOf(subRule);
                         //only update if the rule is not empty
                         if (!isEmptyRule(newSubRule)) {
                             affectedSubRules.add(treeIx, newSubRule);
                         }
                         affectedSubRules.remove(subRule);
                         break;
                     }
                 }
             }
         }
 
         return affectedRule;
     }
 
     public void updateProgramEntities(final Callback<List<ProgramRequirementInfo>> callback) {
 
         final List<String> referencedProgReqIds = new ArrayList<String>();
 
         programRemoteService.storeProgramRequirements(progReqState, progReqInfos, new KSAsyncCallback<Map<Integer, ProgramRequirementInfo>>() {
             @Override
             public void handleFailure(Throwable caught) {
                 Window.alert(caught.getMessage());
                 GWT.log("storeProgramRequirements failed", caught);
             }
             @Override
             public void onSuccess(Map<Integer, ProgramRequirementInfo> storedRules) {
 
                 for (Integer internalProgReqID : storedRules.keySet()) {
                     ProgramRequirementInfo storedRule = storedRules.get(internalProgReqID);
                     switch (progReqState.get(internalProgReqID)) {
                         case STORED:
                             //rule was not changed so continue
                             referencedProgReqIds.add(progReqInfos.get(internalProgReqID).getId());
                             break;
                         case ADDED:
                             referencedProgReqIds.add(storedRule.getId());
                             progReqInfos.put(internalProgReqID, storedRule);
                             origProgReqInfos.put(internalProgReqID, cloneProgReq(storedRule));
                             origProgReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
                             progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
                             break;
                         case EDITED:
                             referencedProgReqIds.add(storedRule.getId());
                             progReqInfos.put(internalProgReqID, storedRule);
                             origProgReqInfos.put(internalProgReqID, cloneProgReq(storedRule));
                             origProgReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
                             progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
                             break;
                         case DELETED:
                             progReqInfos.remove(internalProgReqID);
                             origProgReqInfos.remove(internalProgReqID);
                             origProgReqState.remove(internalProgReqID);                            
                             progReqState.remove(internalProgReqID);
                             break;
                         default:
                             break;
                     }
                 }
 
                 saveRequirementIds(referencedProgReqIds, storedRules, callback);
             }
         });        
     }
 
     private void saveRequirementIds(final List<String> referencedProgReqIds, final Map<Integer, ProgramRequirementInfo> storedRules, final Callback<List<ProgramRequirementInfo>> callback) {
         String programId = ((DataModel)model).getRoot().get("id");
         String programType = ((DataModel)model).getRoot().get("type");
 
         //for some reason, credential program has type stored in 'credentialProgramType'
         if (programType == null) {
             programType = ((DataModel)model).getRoot().get("credentialProgramType");    
         }
 
         //specializations will be handled differently from Major
         if (programType.equals(ProgramConstants.VARIATION_TYPE_KEY)) {
             eventBus.fireEvent(new StoreSpecRequirementIDsEvent(programId, programType, referencedProgReqIds));
         } else {
             eventBus.fireEvent(new StoreRequirementIDsEvent(programId, programType, referencedProgReqIds));
         }
 
         callback.exec(new ArrayList(storedRules.values()));  //update display widgets
     }
 
     public static void stripStatementIds(StatementTreeViewInfo tree) {
         List<StatementTreeViewInfo> statements = tree.getStatements();
         List<ReqComponentInfo> reqComponentInfos = tree.getReqComponents();
 
         if ((tree.getId() != null) && (tree.getId().indexOf(ProgramRequirementsSummaryView.NEW_STMT_TREE_ID) >= 0)) {
             tree.setId(null);
         }
         tree.setState("Active");
 
         if ((statements != null) && (statements.size() > 0)) {
             // retrieve all statements
             for (StatementTreeViewInfo statement : statements) {
                 stripStatementIds(statement); // inside set the children of this statementTreeViewInfo
             }
         } else if ((reqComponentInfos != null) && (reqComponentInfos.size() > 0)) {
             // retrieve all req. component LEAFS
             for (ReqComponentInfo reqComponent : reqComponentInfos) {
                 if ((reqComponent.getId() != null) && (reqComponent.getId().indexOf(ProgramRequirementsSummaryView.NEW_REQ_COMP_ID) >= 0)) {
                     reqComponent.setId(null);
                 }
 
                 for (ReqCompFieldInfo field : reqComponent.getReqCompFields()) {
                     field.setId(null);
                 }
 
                 reqComponent.setState("Active");
             }
         }
     }
 
     public List<ProgramRequirementInfo> getProgReqInfo(String stmtTypeId) {
         List<ProgramRequirementInfo> rules = new ArrayList<ProgramRequirementInfo>();
         for(ProgramRequirementInfo progReqInfo : progReqInfos.values()) {
             if (progReqInfo.getStatement().getType().equals(stmtTypeId)) {
                 rules.add(progReqInfo);
             }
         }
         return rules;
     }
 
     public Integer getInternalProgReqID(ProgramRequirementInfo progReqInfo) {
         for(Integer key : progReqInfos.keySet()) {
             if (progReqInfos.get(key) == progReqInfo) {
                 return key;
             }
         }
 
         Window.alert("Problem retrieving key for program requirement: " + progReqInfo.getId());
         GWT.log("Problem retrieving key for program requirement: " + progReqInfo.getId(), null);        
 
         return null;
     }
 
     public StatementTypeInfo getStmtTypeInfo(String stmtTypeId) {
         for (StatementTypeInfo stmtInfo : stmtTypes) {
             if (stmtInfo.getId().equals(stmtTypeId)) {
                 return stmtInfo;
             }
         }
 
         Window.alert("Did not find StatementTypeInfo based on type: " + stmtTypeId);
         GWT.log("Did not find StatementTypeInfo based on type: " + stmtTypeId);
 
         return null;
     }
 
     public void deleteRule(Integer internalProgReqID) {
         if (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.ADDED) {
             //user added a rule, didn't save it and now wants to delete it
             progReqState.remove(internalProgReqID);
             progReqInfos.remove(internalProgReqID);
         } else {
             markRuleAsDeleted(internalProgReqID);
         }
     }
 
     public void addRule(ProgramRequirementInfo programReqInfo) { 
             setRuleState(programReqInfo);
         progReqInfos.put(progReqIDs, programReqInfo);
         progReqState.put(progReqIDs++, requirementState.ADDED);
     }
 
     public void updateRule(Integer internalProgReqID, ProgramRequirementInfo programReqInfo) {
             setRuleState(programReqInfo);            
         progReqInfos.put(internalProgReqID, programReqInfo);
         markRuleAsEdited(internalProgReqID);
     }
     
     /**
      * Set the state of the program requirement to state of the program.
      * 
      * @param programReqInfo
      */
     protected void setRuleState(ProgramRequirementInfo programReqInfo){
             String programState = ((DataModel)model).get(ProgramConstants.STATE);
             programReqInfo.setState(programState);            
     }
 
     public void markRuleAsDeleted(Integer internalProgReqID) {
         if ((progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.STORED) ||
             (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.EDITED)) {
             progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.DELETED);
         }
     }
 
     public void markRuleAsEdited(Integer internalProgReqID) {
         if (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.STORED) {
             progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.EDITED);
         }
     }
 
     public String getStmtTypeName(String stmtTypeId) {
         String name = getStmtTypeInfo(stmtTypeId).getName();
         return (name == null ? "" : name);
     }
     
     public boolean isRuleExists(String stmtTypeId) {
         boolean showNoRuleText = true;
         for(ProgramRequirementInfo ruleInfo : progReqInfos.values()) {
             if ((ruleInfo.getStatement().getType().equals(stmtTypeId)) && (progReqState.get(getInternalProgReqID(ruleInfo)) != ProgramRequirementsDataModel.requirementState.DELETED)) {
                 showNoRuleText = false;
             }
         }
         return showNoRuleText;
     }
 
     public boolean isDirty() {
 
         if (progReqState.size() != origProgReqState.size()) {
             return true;
         }
 
         for(Integer key : progReqState.keySet()) {
             if (!progReqState.get(key).equals(origProgReqState.get(key))) {
                 return true;
             }
         }
 
         /*
         for(Integer key : progReqInfos.keySet()) {
             if (!progReqInfos.get(key).equals(origProgReqInfos.get(key))) {
                 return true;
             }
         } */
         return false;
     }
 
     public void revertRuleChanges() {
         progReqInfos = new HashMap<Integer, ProgramRequirementInfo>();
         progReqState = new HashMap<Integer, requirementState>();
         for(Integer key : origProgReqInfos.keySet()) {
             progReqInfos.put(key, cloneProgReq(origProgReqInfos.get(key)));
             progReqState.put(key, origProgReqState.get(key));
         }
     }
 
     public ProgramRequirementInfo getProgReqByInternalId(Integer internalProgReqID) {
         return progReqInfos.get(internalProgReqID);
     }
 
     public boolean isEmptyRule(StatementTreeViewInfo tree) {
         return (tree.getStatements() == null || tree.getStatements().isEmpty() && (tree.getReqComponents() == null || tree.getReqComponents().isEmpty()));
     }  
 
     public boolean isInitialized() {
         return isInitialized;
     }
 
     public void setInitialized(boolean initialized) {
         isInitialized = initialized;
     }
 
     public List<StatementTypeInfo> getStmtTypes() {
         return stmtTypes;
     }
 
     private ProgramRequirementInfo cloneProgReq(ProgramRequirementInfo inProgReqInfo) {
         ProgramRequirementInfo clonedProgReqInfo = null;
         if (inProgReqInfo != null) {
             clonedProgReqInfo = new ProgramRequirementInfo();
             clonedProgReqInfo.setId(inProgReqInfo.getId());
             clonedProgReqInfo.setShortTitle(inProgReqInfo.getShortTitle());
             clonedProgReqInfo.setLongTitle(inProgReqInfo.getLongTitle());
             clonedProgReqInfo.setDescr(inProgReqInfo.getDescr());
             clonedProgReqInfo.setMinCredits(inProgReqInfo.getMinCredits());
             clonedProgReqInfo.setMaxCredits(inProgReqInfo.getMaxCredits());
             clonedProgReqInfo.setState(inProgReqInfo.getState());
             clonedProgReqInfo.setType(inProgReqInfo.getType());
             clonedProgReqInfo.setStatement(RulesUtil.clone(inProgReqInfo.getStatement()));
             //TODO clonedProgReqInfo.setAttributes();
             //TODO clonedProgReqInfo.setLearningObjectives();
             //TODO clonedProgReqInfo.setMetaInfo();
         }
         return clonedProgReqInfo;
     }  
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15		package org.kuali.student.lum.program.client.requirements;
16
17		import java.util.*;
18
19		import org.kuali.student.common.ui.client.application.KSAsyncCallback;
20		import org.kuali.student.common.ui.client.mvc.*;
21		import org.kuali.student.common.ui.client.widgets.rules.RulesUtil;
22		import org.kuali.student.core.assembly.data.Data;
23		import org.kuali.student.core.statement.dto.ReqCompFieldInfo;
24		import org.kuali.student.core.statement.dto.ReqComponentInfo;
25		import org.kuali.student.core.statement.dto.StatementTreeViewInfo;
26		import org.kuali.student.core.statement.dto.StatementTypeInfo;
27		import org.kuali.student.lum.program.client.ProgramConstants;
28		import org.kuali.student.lum.program.client.events.StoreRequirementIDsEvent;
29		import org.kuali.student.lum.program.client.events.StoreSpecRequirementIDsEvent;
30		import org.kuali.student.lum.program.client.rpc.MajorDisciplineRpcService;
31		import org.kuali.student.lum.program.client.rpc.MajorDisciplineRpcServiceAsync;
32		import org.kuali.student.lum.program.client.rpc.StatementRpcService;
33		import org.kuali.student.lum.program.client.rpc.StatementRpcServiceAsync;
34		import org.kuali.student.lum.program.dto.ProgramRequirementInfo;
35
36		import com.google.gwt.core.client.GWT;
37		import com.google.gwt.event.shared.HandlerManager;
38		import com.google.gwt.user.client.Window;
39
40	0	public class ProgramRequirementsDataModel {
41
42	0	private final MajorDisciplineRpcServiceAsync programRemoteService = GWT.create(MajorDisciplineRpcService.class);
43	0	private StatementRpcServiceAsync statementRpcServiceAsync = GWT.create(StatementRpcService.class);
44	0	private Model model = null;
45		private HandlerManager eventBus;
46
47		//keeping track of rules and rule state
48	0	public enum requirementState {STORED, ADDED, EDITED, DELETED;}
49	0	private Map<Integer, ProgramRequirementInfo> progReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
50	0	private Map<Integer, ProgramRequirementInfo> origProgReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
51	0	private Map<Integer, requirementState> progReqState = new HashMap<Integer, requirementState>();
52	0	private Map<Integer, requirementState> origProgReqState = new HashMap<Integer, requirementState>();
53	0	private List<StatementTypeInfo> stmtTypes = new ArrayList<StatementTypeInfo>();
54	0	private boolean isInitialized = false;
55	0	private static Integer progReqIDs = 111111;
56
57	0	public ProgramRequirementsDataModel(HandlerManager eventBus) {
58	0	this.eventBus = eventBus;
59	0	}
60
61		//find out whether we need to reset rules based on whether we have a new program ID or not
62		public void setupRules(Controller parentController, final Callback<Boolean> onReadyCallback) {
63	0	parentController.requestModel(ProgramConstants.PROGRAM_MODEL_ID, new ModelRequestCallback() {
64
65		@Override
66		public void onRequestFail(Throwable cause) {
67	0	GWT.log("Unable to retrieve program model for program summary view", cause);
68	0	onReadyCallback.exec(false);
69	0	}
70
71		@Override
72		public void onModelReady(Model modelIn) {
73		//TODO how can we reliably know that we need to reload rules (or not)
74		//String programId = (model == null ? null : (String)((DataModel)model).getRoot().get("id"));
75		//String modelProgramId = ((DataModel)modelIn).getRoot().get(ProgramConstants.ID);
76		//if ((modelProgramId == null) \|\| (!modelProgramId.equals(programId))) {
77	0	resetRules();
78		//}
79	0	model = modelIn;
80	0	onReadyCallback.exec(true);
81	0	}
82		});
83	0	}
84
85		private void resetRules() {
86	0	progReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
87	0	origProgReqInfos = new LinkedHashMap<Integer, ProgramRequirementInfo>();
88	0	progReqState = new HashMap<Integer, requirementState>();
89	0	origProgReqState = new HashMap<Integer, requirementState>();
90	0	stmtTypes = new ArrayList<StatementTypeInfo>();
91	0	model = null;
92	0	isInitialized = false;
93	0	}
94
95		//retrieve rules based on IDs stored in this program
96		public void retrieveProgramRequirements(Controller parentController, final Callback<Boolean> onReadyCallback) {
97
98	0	setupRules(parentController, new Callback<Boolean>() {
99		@Override
100		public void exec(Boolean result) {
101	0	Data program = ((DataModel)model).getRoot().get(ProgramConstants.PROGRAM_REQUIREMENTS);
102
103	0	Iterator<Data.Property> realPropertyIterator = program.realPropertyIterator();
104	0	ArrayList<String> programRequirementIds = new ArrayList<String>();
105	0	while(realPropertyIterator.hasNext()) {
106	0	programRequirementIds.add((String)realPropertyIterator.next().getValue());
107		}
108	0	retrieveStatementTypes(programRequirementIds, onReadyCallback);
109	0	}
110		});
111	0	}
112
113		private void retrieveStatementTypes(final List<String> programRequirementIds, final Callback<Boolean> onReadyCallback) {
114
115		//retrieve available program requirement types
116	0	statementRpcServiceAsync.getStatementTypesForStatementType("kuali.statement.type.program", new KSAsyncCallback<List<StatementTypeInfo>>() {
117		@Override
118		public void handleFailure(Throwable caught) {
119	0	Window.alert(caught.getMessage());
120	0	GWT.log("getStatementTypes failed", caught);
121	0	onReadyCallback.exec(false);
122	0	}
123
124		@Override
125		public void onSuccess(List<StatementTypeInfo> stmtInfoTypes) {
126		//store the statement types
127	0	for (StatementTypeInfo stmtInfoType : stmtInfoTypes) {
128	0	stmtTypes.add(stmtInfoType);
129		}
130
131		//now retrieve the actual rules
132	0	retrieveRules(programRequirementIds, onReadyCallback);
133	0	}
134		});
135	0	}
136
137		private void retrieveRules(List<String> programRequirementIds, final Callback<Boolean> onReadyCallback) {
138
139		//true if no program requirements exist yet
140	0	if ((programRequirementIds == null) \|\| programRequirementIds.isEmpty()) {
141	0	isInitialized = true;
142	0	onReadyCallback.exec(true);
143	0	return;
144		}
145
146	0	programRemoteService.getProgramRequirements(programRequirementIds, new KSAsyncCallback<List<ProgramRequirementInfo>>() {
147		@Override
148		public void handleFailure(Throwable caught) {
149	0	Window.alert(caught.getMessage());
150	0	GWT.log("getProgramRequirement failed", caught);
151	0	onReadyCallback.exec(false);
152	0	}
153
154		@Override
155		public void onSuccess(List<ProgramRequirementInfo> programReqInfos) {
156		//update rules list with new program requirements
157	0	origProgReqInfos.clear();
158	0	origProgReqState.clear();
159	0	progReqInfos.clear();
160	0	progReqState.clear();
161	0	for (ProgramRequirementInfo programReqInfo : programReqInfos) {
162
163	0	if (getStmtTypeInfo(programReqInfo.getStatement().getType()) == null) {
164	0	Window.alert("Did not find corresponding statement type for program requirement of type: " + programReqInfo.getStatement().getType());
165	0	GWT.log("Did not find corresponding statement type for program requirement of type: " + programReqInfo.getStatement().getType(), null);
166		}
167
168	0	setRuleState(programReqInfo);
169	0	origProgReqInfos.put(progReqIDs, cloneProgReq(programReqInfo));
170	0	origProgReqState.put(progReqIDs, requirementState.STORED);
171	0	progReqInfos.put(progReqIDs, programReqInfo);
172	0	progReqState.put(progReqIDs++, requirementState.STORED);
173		}
174
175	0	isInitialized = true;
176	0	onReadyCallback.exec(true);
177	0	}
178		});
179	0	}
180
181		public ProgramRequirementInfo updateRules(StatementTreeViewInfo newSubRule, Integer internalProgReqID, boolean isNewRule) {
182
183	0	ProgramRequirementInfo affectedRule = progReqInfos.get(internalProgReqID);
184
185	0	if (affectedRule == null) {
186	0	Window.alert("Cannot find program requirement with a statement that has id: '" + newSubRule.getId() + "'");
187	0	GWT.log("Cannot find program requirement with a statement that has id: '" + newSubRule.getId() + "'", null);
188	0	return null;
189		}
190
191	0	if (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.STORED) {
192	0	progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.EDITED);
193		}
194
195		//if we don't have top level req. components wrapped in statement, do so before we add another statement
196	0	StatementTreeViewInfo affectedTopTree = affectedRule.getStatement();
197	0	if ((affectedTopTree.getReqComponents() != null) && !affectedTopTree.getReqComponents().isEmpty()) {
198	0	StatementTreeViewInfo stmtTree = new StatementTreeViewInfo();
199	0	stmtTree.setId(ProgramRequirementsSummaryView.generateStatementTreeId());
200	0	stmtTree.setType( affectedRule.getStatement().getType());
201	0	stmtTree.setReqComponents(affectedTopTree.getReqComponents());
202	0	List<StatementTreeViewInfo> stmtList = new ArrayList<StatementTreeViewInfo>();
203	0	stmtList.add(stmtTree);
204	0	affectedTopTree.setStatements(stmtList);
205		}
206
207		//now update the actual rule
208	0	List<StatementTreeViewInfo> affectedSubRules = affectedTopTree.getStatements();
209	0	if (isNewRule) {
210	0	affectedSubRules.add(newSubRule);
211		} else {
212		//update rule
213	0	if (affectedSubRules == null \|\| affectedSubRules.isEmpty()) {
214	0	affectedRule.setStatement(newSubRule);
215		} else { //replace the related stored subrule with a new version
216	0	for (StatementTreeViewInfo subRule : affectedSubRules) {
217	0	if (subRule.getId().equals(newSubRule.getId())) {
218	0	int treeIx = affectedSubRules.indexOf(subRule);
219		//only update if the rule is not empty
220	0	if (!isEmptyRule(newSubRule)) {
221	0	affectedSubRules.add(treeIx, newSubRule);
222		}
223	0	affectedSubRules.remove(subRule);
224	0	break;
225		}
226		}
227		}
228		}
229
230	0	return affectedRule;
231		}
232
233		public void updateProgramEntities(final Callback<List<ProgramRequirementInfo>> callback) {
234
235	0	final List<String> referencedProgReqIds = new ArrayList<String>();
236
237	0	programRemoteService.storeProgramRequirements(progReqState, progReqInfos, new KSAsyncCallback<Map<Integer, ProgramRequirementInfo>>() {
238		@Override
239		public void handleFailure(Throwable caught) {
240	0	Window.alert(caught.getMessage());
241	0	GWT.log("storeProgramRequirements failed", caught);
242	0	}
243		@Override
244		public void onSuccess(Map<Integer, ProgramRequirementInfo> storedRules) {
245
246	0	for (Integer internalProgReqID : storedRules.keySet()) {
247	0	ProgramRequirementInfo storedRule = storedRules.get(internalProgReqID);
248	0	switch (progReqState.get(internalProgReqID)) {
249		case STORED:
250		//rule was not changed so continue
251	0	referencedProgReqIds.add(progReqInfos.get(internalProgReqID).getId());
252	0	break;
253		case ADDED:
254	0	referencedProgReqIds.add(storedRule.getId());
255	0	progReqInfos.put(internalProgReqID, storedRule);
256	0	origProgReqInfos.put(internalProgReqID, cloneProgReq(storedRule));
257	0	origProgReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
258	0	progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
259	0	break;
260		case EDITED:
261	0	referencedProgReqIds.add(storedRule.getId());
262	0	progReqInfos.put(internalProgReqID, storedRule);
263	0	origProgReqInfos.put(internalProgReqID, cloneProgReq(storedRule));
264	0	origProgReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
265	0	progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.STORED);
266	0	break;
267		case DELETED:
268	0	progReqInfos.remove(internalProgReqID);
269	0	origProgReqInfos.remove(internalProgReqID);
270	0	origProgReqState.remove(internalProgReqID);
271	0	progReqState.remove(internalProgReqID);
272	0	break;
273		default:
274		break;
275		}
276	0	}
277
278	0	saveRequirementIds(referencedProgReqIds, storedRules, callback);
279	0	}
280		});
281	0	}
282
283		private void saveRequirementIds(final List<String> referencedProgReqIds, final Map<Integer, ProgramRequirementInfo> storedRules, final Callback<List<ProgramRequirementInfo>> callback) {
284	0	String programId = ((DataModel)model).getRoot().get("id");
285	0	String programType = ((DataModel)model).getRoot().get("type");
286
287		//for some reason, credential program has type stored in 'credentialProgramType'
288	0	if (programType == null) {
289	0	programType = ((DataModel)model).getRoot().get("credentialProgramType");
290		}
291
292		//specializations will be handled differently from Major
293	0	if (programType.equals(ProgramConstants.VARIATION_TYPE_KEY)) {
294	0	eventBus.fireEvent(new StoreSpecRequirementIDsEvent(programId, programType, referencedProgReqIds));
295		} else {
296	0	eventBus.fireEvent(new StoreRequirementIDsEvent(programId, programType, referencedProgReqIds));
297		}
298
299	0	callback.exec(new ArrayList(storedRules.values())); //update display widgets
300	0	}
301
302		public static void stripStatementIds(StatementTreeViewInfo tree) {
303	0	List<StatementTreeViewInfo> statements = tree.getStatements();
304	0	List<ReqComponentInfo> reqComponentInfos = tree.getReqComponents();
305
306	0	if ((tree.getId() != null) && (tree.getId().indexOf(ProgramRequirementsSummaryView.NEW_STMT_TREE_ID) >= 0)) {
307	0	tree.setId(null);
308		}
309	0	tree.setState("Active");
310
311	0	if ((statements != null) && (statements.size() > 0)) {
312		// retrieve all statements
313	0	for (StatementTreeViewInfo statement : statements) {
314	0	stripStatementIds(statement); // inside set the children of this statementTreeViewInfo
315		}
316	0	} else if ((reqComponentInfos != null) && (reqComponentInfos.size() > 0)) {
317		// retrieve all req. component LEAFS
318	0	for (ReqComponentInfo reqComponent : reqComponentInfos) {
319	0	if ((reqComponent.getId() != null) && (reqComponent.getId().indexOf(ProgramRequirementsSummaryView.NEW_REQ_COMP_ID) >= 0)) {
320	0	reqComponent.setId(null);
321		}
322
323	0	for (ReqCompFieldInfo field : reqComponent.getReqCompFields()) {
324	0	field.setId(null);
325		}
326
327	0	reqComponent.setState("Active");
328		}
329		}
330	0	}
331
332		public List<ProgramRequirementInfo> getProgReqInfo(String stmtTypeId) {
333	0	List<ProgramRequirementInfo> rules = new ArrayList<ProgramRequirementInfo>();
334	0	for(ProgramRequirementInfo progReqInfo : progReqInfos.values()) {
335	0	if (progReqInfo.getStatement().getType().equals(stmtTypeId)) {
336	0	rules.add(progReqInfo);
337		}
338		}
339	0	return rules;
340		}
341
342		public Integer getInternalProgReqID(ProgramRequirementInfo progReqInfo) {
343	0	for(Integer key : progReqInfos.keySet()) {
344	0	if (progReqInfos.get(key) == progReqInfo) {
345	0	return key;
346		}
347		}
348
349	0	Window.alert("Problem retrieving key for program requirement: " + progReqInfo.getId());
350	0	GWT.log("Problem retrieving key for program requirement: " + progReqInfo.getId(), null);
351
352	0	return null;
353		}
354
355		public StatementTypeInfo getStmtTypeInfo(String stmtTypeId) {
356	0	for (StatementTypeInfo stmtInfo : stmtTypes) {
357	0	if (stmtInfo.getId().equals(stmtTypeId)) {
358	0	return stmtInfo;
359		}
360		}
361
362	0	Window.alert("Did not find StatementTypeInfo based on type: " + stmtTypeId);
363	0	GWT.log("Did not find StatementTypeInfo based on type: " + stmtTypeId);
364
365	0	return null;
366		}
367
368		public void deleteRule(Integer internalProgReqID) {
369	0	if (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.ADDED) {
370		//user added a rule, didn't save it and now wants to delete it
371	0	progReqState.remove(internalProgReqID);
372	0	progReqInfos.remove(internalProgReqID);
373		} else {
374	0	markRuleAsDeleted(internalProgReqID);
375		}
376	0	}
377
378		public void addRule(ProgramRequirementInfo programReqInfo) {
379	0	setRuleState(programReqInfo);
380	0	progReqInfos.put(progReqIDs, programReqInfo);
381	0	progReqState.put(progReqIDs++, requirementState.ADDED);
382	0	}
383
384		public void updateRule(Integer internalProgReqID, ProgramRequirementInfo programReqInfo) {
385	0	setRuleState(programReqInfo);
386	0	progReqInfos.put(internalProgReqID, programReqInfo);
387	0	markRuleAsEdited(internalProgReqID);
388	0	}
389
390		/**
391		* Set the state of the program requirement to state of the program.
392		*
393		* @param programReqInfo
394		*/
395		protected void setRuleState(ProgramRequirementInfo programReqInfo){
396	0	String programState = ((DataModel)model).get(ProgramConstants.STATE);
397	0	programReqInfo.setState(programState);
398	0	}
399
400		public void markRuleAsDeleted(Integer internalProgReqID) {
401	0	if ((progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.STORED) \|\|
402		(progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.EDITED)) {
403	0	progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.DELETED);
404		}
405	0	}
406
407		public void markRuleAsEdited(Integer internalProgReqID) {
408	0	if (progReqState.get(internalProgReqID) == ProgramRequirementsDataModel.requirementState.STORED) {
409	0	progReqState.put(internalProgReqID, ProgramRequirementsDataModel.requirementState.EDITED);
410		}
411	0	}
412
413		public String getStmtTypeName(String stmtTypeId) {
414	0	String name = getStmtTypeInfo(stmtTypeId).getName();
415	0	return (name == null ? "" : name);
416		}
417
418		public boolean isRuleExists(String stmtTypeId) {
419	0	boolean showNoRuleText = true;
420	0	for(ProgramRequirementInfo ruleInfo : progReqInfos.values()) {
421	0	if ((ruleInfo.getStatement().getType().equals(stmtTypeId)) && (progReqState.get(getInternalProgReqID(ruleInfo)) != ProgramRequirementsDataModel.requirementState.DELETED)) {
422	0	showNoRuleText = false;
423		}
424		}
425	0	return showNoRuleText;
426		}
427
428		public boolean isDirty() {
429
430	0	if (progReqState.size() != origProgReqState.size()) {
431	0	return true;
432		}
433
434	0	for(Integer key : progReqState.keySet()) {
435	0	if (!progReqState.get(key).equals(origProgReqState.get(key))) {
436	0	return true;
437		}
438		}
439
440		/*
441		for(Integer key : progReqInfos.keySet()) {
442		if (!progReqInfos.get(key).equals(origProgReqInfos.get(key))) {
443		return true;
444		}
445		} */
446	0	return false;
447		}
448
449		public void revertRuleChanges() {
450	0	progReqInfos = new HashMap<Integer, ProgramRequirementInfo>();
451	0	progReqState = new HashMap<Integer, requirementState>();
452	0	for(Integer key : origProgReqInfos.keySet()) {
453	0	progReqInfos.put(key, cloneProgReq(origProgReqInfos.get(key)));
454	0	progReqState.put(key, origProgReqState.get(key));
455		}
456	0	}
457
458		public ProgramRequirementInfo getProgReqByInternalId(Integer internalProgReqID) {
459	0	return progReqInfos.get(internalProgReqID);
460		}
461
462		public boolean isEmptyRule(StatementTreeViewInfo tree) {
463	0	return (tree.getStatements() == null \|\| tree.getStatements().isEmpty() && (tree.getReqComponents() == null \|\| tree.getReqComponents().isEmpty()));
464		}
465
466		public boolean isInitialized() {
467	0	return isInitialized;
468		}
469
470		public void setInitialized(boolean initialized) {
471	0	isInitialized = initialized;
472	0	}
473
474		public List<StatementTypeInfo> getStmtTypes() {
475	0	return stmtTypes;
476		}
477
478		private ProgramRequirementInfo cloneProgReq(ProgramRequirementInfo inProgReqInfo) {
479	0	ProgramRequirementInfo clonedProgReqInfo = null;
480	0	if (inProgReqInfo != null) {
481	0	clonedProgReqInfo = new ProgramRequirementInfo();
482	0	clonedProgReqInfo.setId(inProgReqInfo.getId());
483	0	clonedProgReqInfo.setShortTitle(inProgReqInfo.getShortTitle());
484	0	clonedProgReqInfo.setLongTitle(inProgReqInfo.getLongTitle());
485	0	clonedProgReqInfo.setDescr(inProgReqInfo.getDescr());
486	0	clonedProgReqInfo.setMinCredits(inProgReqInfo.getMinCredits());
487	0	clonedProgReqInfo.setMaxCredits(inProgReqInfo.getMaxCredits());
488	0	clonedProgReqInfo.setState(inProgReqInfo.getState());
489	0	clonedProgReqInfo.setType(inProgReqInfo.getType());
490	0	clonedProgReqInfo.setStatement(RulesUtil.clone(inProgReqInfo.getStatement()));
491		//TODO clonedProgReqInfo.setAttributes();
492		//TODO clonedProgReqInfo.setLearningObjectives();
493		//TODO clonedProgReqInfo.setMetaInfo();
494		}
495	0	return clonedProgReqInfo;
496		}
497		}