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.lu.ui.course.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.dialog.ConfirmationDialog;
 import org.kuali.student.common.ui.client.widgets.notification.KSNotification;
 import org.kuali.student.common.ui.client.widgets.notification.KSNotifier;
 import org.kuali.student.common.ui.client.widgets.rules.RulesUtil;
 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.lu.ui.course.client.service.CourseRpcService;
 import org.kuali.student.lum.lu.ui.course.client.service.CourseRpcServiceAsync;
 import org.kuali.student.lum.program.client.rpc.StatementRpcService;
 import org.kuali.student.lum.program.client.rpc.StatementRpcServiceAsync;
 
 import com.google.gwt.core.client.GWT;
 import com.google.gwt.event.dom.client.ClickEvent;
 import com.google.gwt.event.dom.client.ClickHandler;
 import com.google.gwt.user.client.Window;
 
 public class CourseRequirementsDataModel {
 
     private final CourseRpcServiceAsync courseRemoteService = GWT.create(CourseRpcService.class);
     private final StatementRpcServiceAsync statementRpcServiceAsync = GWT.create(StatementRpcService.class);
     private Controller parentController;
 
     //keeping track of rules and rule state
     public enum requirementState {STORED, ADDED, EDITED, DELETED;}
     private Map<Integer, StatementTreeViewInfo> courseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
     private Map<Integer, StatementTreeViewInfo> origCourseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
     private Map<Integer, requirementState> courseReqState = new HashMap<Integer, requirementState>();
     private Map<Integer, requirementState> origCourseReqState = new HashMap<Integer, requirementState>();
     private static List<StatementTypeInfo> stmtTypes = new ArrayList<StatementTypeInfo>();
     private boolean isInitialized = false;
     private static Integer courseReqIDs = 111111;
 
     public CourseRequirementsDataModel(Controller parentController) {
         this.parentController = parentController;
     }
 
     //retrieve rules based on IDs associated with this course
     public void retrieveCourseRequirements(String modelId, final Callback<Boolean> onReadyCallback) {
         //initialize data
         courseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
         origCourseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
         courseReqState = new HashMap<Integer, requirementState>();
         origCourseReqState = new HashMap<Integer, requirementState>();
         isInitialized = false;
 
         parentController.requestModel(modelId, new ModelRequestCallback() {
 
             @Override
             public void onRequestFail(Throwable cause) {
                 Window.alert(cause.getMessage());
                 GWT.log("Unable to retrieve model for course requirements view", cause);
                 onReadyCallback.exec(false);
             }
 
             @Override
             public void onModelReady(Model model) {
                 String courseId = ((DataModel)model).getRoot().get("id");
                 retrieveStatementTypes(courseId, onReadyCallback);
             }
         });    
     }
 
     public void retrieveStatementTypes(final String courseId, final Callback<Boolean> onReadyCallback) {
 
         getStatementTypes(new Callback<List<StatementTypeInfo>>() {
             @Override
             public void exec(List<StatementTypeInfo> stmtTypes) {
                 //now retrieve the actual rules
                 retrieveRules(courseId, onReadyCallback);
             }
         });
     }
 
     private void retrieveRules(String courseId, final Callback<Boolean> onReadyCallback) {
 
         //true if no course exists yet
         if ((courseId == null) || courseId.isEmpty()) {
             isInitialized = true;
             onReadyCallback.exec(true);
             return;
         }
 
         courseRemoteService.getCourseStatements(courseId, CourseRequirementsManageView.RULEEDIT_TEMLATE,
                                                     CourseRequirementsManageView.TEMLATE_LANGUAGE, new KSAsyncCallback<List<StatementTreeViewInfo>>() {
             @Override
             public void handleFailure(Throwable caught) {
                 Window.alert(caught.getMessage());
                 GWT.log("getCourseStatements failed", caught);
                 onReadyCallback.exec(false);
             }
 
             @Override
             public void onSuccess(List<StatementTreeViewInfo> foundRules) {
                 //update rules list with new course requirements
                     if (foundRules != null) {
                             for (StatementTreeViewInfo foundRule : foundRules) {
 
                                     if (getStmtTypeInfo(foundRule.getType()) == null) {
                                             // Window.alert("Did not find corresponding statement type for course requirement of type: " + foundRule.getType());
                                             GWT.log("Did not find corresponding statement type for course requirement of type: " + foundRule.getType(), null);
                                     }
 
                                     origCourseReqInfos.put(courseReqIDs, RulesUtil.clone(foundRule));
                                     origCourseReqState.put(courseReqIDs, requirementState.STORED);
                                     courseReqInfos.put(courseReqIDs, foundRule);
                                     courseReqState.put(courseReqIDs++, requirementState.STORED);
                             }
                     }
 
                 isInitialized = true;
                 onReadyCallback.exec(true);
             }
         });     
     }
 
     public StatementTreeViewInfo updateRules(StatementTreeViewInfo newSubRule, Integer internalCourseReqID, boolean isNewRule) {
 
         StatementTreeViewInfo affectedRule = courseReqInfos.get(internalCourseReqID);
 
         if (affectedRule == null) {
             Window.alert("Cannot find course requisite with a statement that has id: '" + newSubRule.getId() + "'");
             GWT.log("Cannot find course requisite with a statement that has id: '" + newSubRule.getId() + "'", null);
             return null;
         }
 
         if (courseReqState.get(internalCourseReqID) == CourseRequirementsDataModel.requirementState.STORED) {
             courseReqState.put(internalCourseReqID, CourseRequirementsDataModel.requirementState.EDITED);
         }
 
         courseReqInfos.put(internalCourseReqID, newSubRule);
 
         return newSubRule;
     }
 
     public void updateCourseRequisites(final String courseId, final Callback<List<StatementTreeViewInfo>> callback) {
 
         //course proposal has to be in the database before we can save rules
         if (courseId == null) {
             final ConfirmationDialog dialog = new ConfirmationDialog("Submit Course Title", "Before saving rules please submit course proposal title");
             dialog.getConfirmButton().addClickHandler(new ClickHandler(){
                 @Override
                 public void onClick(ClickEvent event) {
                     dialog.hide();    
                 }
             });
             dialog.show();
             return;
         }
 
         final List<String> referencedProgReqIds = new ArrayList<String>();
 
         courseRemoteService.storeCourseStatements(courseId.toString(), courseReqState, courseReqInfos, new KSAsyncCallback<Map<Integer, StatementTreeViewInfo>>() {
             @Override
             public void handleFailure(Throwable caught) {
                 Window.alert(caught.getMessage());
                 GWT.log("storeProgramRequirements failed", caught);
             }
             @Override
             public void onSuccess(Map<Integer, StatementTreeViewInfo> storedRules) {
 
                 for (Integer internalProgReqID : storedRules.keySet()) {
                     StatementTreeViewInfo storedRule = storedRules.get(internalProgReqID);
                     switch (courseReqState.get(internalProgReqID)) {
                         case STORED:
                             //rule was not changed so continue
                             referencedProgReqIds.add(internalProgReqID.toString());
                             break;
                         case ADDED:
                             referencedProgReqIds.add(storedRule.getId());
                             courseReqInfos.put(internalProgReqID, storedRule);
                             origCourseReqInfos.put(internalProgReqID, RulesUtil.clone(storedRule));
                             origCourseReqState.put(internalProgReqID, requirementState.STORED);
                             courseReqState.put(internalProgReqID, requirementState.STORED);
                             break;
                         case EDITED:
                             referencedProgReqIds.add(storedRule.getId());
                             courseReqInfos.put(internalProgReqID, storedRule);
                             origCourseReqInfos.put(internalProgReqID, RulesUtil.clone(storedRule));
                             origCourseReqState.put(internalProgReqID, requirementState.STORED);
                             courseReqState.put(internalProgReqID, requirementState.STORED);
                             break;
                         case DELETED:
                             courseReqInfos.remove(internalProgReqID);
                             origCourseReqInfos.remove(internalProgReqID);
                             origCourseReqState.remove(internalProgReqID);
                             courseReqState.remove(internalProgReqID);
                             break;
                         default:
                             break;
                     }
                 }
 
                 KSNotifier.add(new KSNotification("Save Successful", false, 4000));
                 //MajorManager.getEventBus().fireEvent(new StoreRequirementIDsEvent(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(CourseRequirementsSummaryView.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(CourseRequirementsSummaryView.NEW_REQ_COMP_ID) >= 0)) {
                     reqComponent.setId(null);
                 }
 
                 for (ReqCompFieldInfo field : reqComponent.getReqCompFields()) {
                     field.setId(null);
                 }
 
                 reqComponent.setState("Active");
             }
         }
     }
 
     public List<StatementTreeViewInfo> getCourseReqInfo(String stmtTypeId) {
         List<StatementTreeViewInfo> rules = new ArrayList<StatementTreeViewInfo>();
         for(StatementTreeViewInfo rule : courseReqInfos.values()) {
             if (rule.getType().equals(stmtTypeId)) {
                 rules.add(rule);
             }
         }
         return rules;
     }
 
     public Integer getInternalCourseReqID(StatementTreeViewInfo rule) {
         for(Integer key : courseReqInfos.keySet()) {
             if (courseReqInfos.get(key) ==  rule) {
                 return key;
             }
         }
 
         Window.alert("Problem retrieving key for course requisite: " +  rule.getId());
         GWT.log("Problem retrieving key for course requisite: " +  rule.getId(), null);        
 
         return null;
     }
 
     public StatementTypeInfo getStmtTypeInfo(String stmtTypeId) {
         for (StatementTypeInfo stmtInfo : stmtTypes) {
             if (stmtInfo.getId().equals(stmtTypeId)) {
                 return stmtInfo;
             }
         }
 
         try {
 
         Window.alert("Did not find StatementTypeInfo based on typeA: " + stmtTypeId + new Throwable().getStackTrace().toString());
         GWT.log("Did not find StatementTypeInfo based on type: " + stmtTypeId + new Throwable().getStackTrace());
 
 
         throw new Exception();
 
         } catch (Exception e) {
             Window.alert("Exception" + e.getStackTrace().toString());   
         }
         return null;
     }
 
     public void deleteRule(Integer internalProgReqID) {
         if (courseReqState.get(internalProgReqID) == requirementState.ADDED) {
             //user added a rule, didn't save it and now wants to delete it
             courseReqState.remove(internalProgReqID);
             courseReqInfos.remove(internalProgReqID);
         } else {
             markRuleAsDeleted(internalProgReqID);
         }
     }
 
     public void addRule(StatementTreeViewInfo rule) {
         courseReqInfos.put(courseReqIDs, rule);
         courseReqState.put(courseReqIDs++, requirementState.ADDED);
     }
 
     public void updateRule(Integer internalProgReqID, StatementTreeViewInfo rule) {
         courseReqInfos.put(internalProgReqID, rule);
         markRuleAsEdited(internalProgReqID);
     }    
 
     public void markRuleAsDeleted(Integer internalCourseReqID) {
         if ((courseReqState.get(internalCourseReqID) == requirementState.STORED) ||
             (courseReqState.get(internalCourseReqID) == requirementState.EDITED)) {
             courseReqState.put(internalCourseReqID, requirementState.DELETED);
         }
     }
 
     public void markRuleAsEdited(Integer internalCourseReqID) {
         if (courseReqState.get(internalCourseReqID) == requirementState.STORED) {
             courseReqState.put(internalCourseReqID, 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(StatementTreeViewInfo ruleInfo : courseReqInfos.values()) {
             if ((ruleInfo.getType().equals(stmtTypeId)) && (courseReqState.get(getInternalCourseReqID(ruleInfo)) != requirementState.DELETED)) {
                 showNoRuleText = false;
             }
         }
         return showNoRuleText;
     }
 
     public void removeEmptyRules() {
         for(StatementTreeViewInfo rule : courseReqInfos.values()) {
             if (isEmpty(rule)) {
                 Integer ruleId = getInternalCourseReqID(rule);
                 courseReqInfos.remove(ruleId);
                 courseReqState.remove(ruleId);
             }
         }
     }
 
     public boolean isDirty() {
 
         if (courseReqState.size() != origCourseReqState.size()) {
             return true;
         }
 
         for(Integer key : courseReqState.keySet()) {
             if (!courseReqState.get(key).equals(origCourseReqState.get(key))) {
                 return true;
             }
         }
 
         return false;
     }
 
     public void revertRuleChanges() {
         courseReqInfos = new HashMap<Integer, StatementTreeViewInfo>();
         courseReqState = new HashMap<Integer, requirementState>();
         for(Integer key : origCourseReqInfos.keySet()) {
             courseReqInfos.put(key, RulesUtil.clone(origCourseReqInfos.get(key)));
             courseReqState.put(key, origCourseReqState.get(key));
         }
     }
     
     public StatementTreeViewInfo getRule(Integer internalCourseReqID) {
         return courseReqInfos.get(internalCourseReqID);
     }
 
     public static void getStatementTypes(final Callback<List<StatementTypeInfo>> onReadyCallback) {
 
         //avoid loading statement types if we retrieved them already before
         if (!stmtTypes.isEmpty()) {
             onReadyCallback.exec(stmtTypes);
             return;
         }        
 
         StatementRpcServiceAsync statementRpcServiceAsync = GWT.create(StatementRpcService.class);
 
         //retrieve available course requirement types
         statementRpcServiceAsync.getStatementTypesForStatementTypeForCourse("kuali.statement.type.course", new KSAsyncCallback<List<StatementTypeInfo>>() {
             @Override
             public void handleFailure(Throwable caught) {
                     Window.alert(caught.getMessage());
                     GWT.log("getStatementTypes failed", caught);
                 onReadyCallback.exec(new ArrayList<StatementTypeInfo>());
             }
 
             @Override
             public void onSuccess(List<StatementTypeInfo> stmtInfoTypes) {
                 //store the statement types
                 stmtTypes = new ArrayList<StatementTypeInfo>();
                 for (StatementTypeInfo stmtInfoType : stmtInfoTypes) {
                     stmtTypes.add(stmtInfoType);
                 }
                 onReadyCallback.exec(stmtTypes);
             }
         });
     }
 
     public static boolean isEmpty(StatementTreeViewInfo rule) {
         return (((rule.getStatements() == null) || rule.getStatements().isEmpty()) && ((rule.getReqComponents() == null) || rule.getReqComponents().isEmpty()));
     }
 
     public boolean isInitialized() {
         return isInitialized;
     }
 
     public void setInitialized(boolean initialized) {
         isInitialized = initialized;
     }
 
     public List<StatementTypeInfo> getStmtTypes() {
         return stmtTypes;
     }
 }

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.lu.ui.course.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.dialog.ConfirmationDialog;
22		import org.kuali.student.common.ui.client.widgets.notification.KSNotification;
23		import org.kuali.student.common.ui.client.widgets.notification.KSNotifier;
24		import org.kuali.student.common.ui.client.widgets.rules.RulesUtil;
25		import org.kuali.student.core.statement.dto.ReqCompFieldInfo;
26		import org.kuali.student.core.statement.dto.ReqComponentInfo;
27		import org.kuali.student.core.statement.dto.StatementTreeViewInfo;
28		import org.kuali.student.core.statement.dto.StatementTypeInfo;
29		import org.kuali.student.lum.lu.ui.course.client.service.CourseRpcService;
30		import org.kuali.student.lum.lu.ui.course.client.service.CourseRpcServiceAsync;
31		import org.kuali.student.lum.program.client.rpc.StatementRpcService;
32		import org.kuali.student.lum.program.client.rpc.StatementRpcServiceAsync;
33
34		import com.google.gwt.core.client.GWT;
35		import com.google.gwt.event.dom.client.ClickEvent;
36		import com.google.gwt.event.dom.client.ClickHandler;
37		import com.google.gwt.user.client.Window;
38
39	0	public class CourseRequirementsDataModel {
40
41	0	private final CourseRpcServiceAsync courseRemoteService = GWT.create(CourseRpcService.class);
42	0	private final StatementRpcServiceAsync statementRpcServiceAsync = GWT.create(StatementRpcService.class);
43		private Controller parentController;
44
45		//keeping track of rules and rule state
46	0	public enum requirementState {STORED, ADDED, EDITED, DELETED;}
47	0	private Map<Integer, StatementTreeViewInfo> courseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
48	0	private Map<Integer, StatementTreeViewInfo> origCourseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
49	0	private Map<Integer, requirementState> courseReqState = new HashMap<Integer, requirementState>();
50	0	private Map<Integer, requirementState> origCourseReqState = new HashMap<Integer, requirementState>();
51	0	private static List<StatementTypeInfo> stmtTypes = new ArrayList<StatementTypeInfo>();
52	0	private boolean isInitialized = false;
53	0	private static Integer courseReqIDs = 111111;
54
55	0	public CourseRequirementsDataModel(Controller parentController) {
56	0	this.parentController = parentController;
57	0	}
58
59		//retrieve rules based on IDs associated with this course
60		public void retrieveCourseRequirements(String modelId, final Callback<Boolean> onReadyCallback) {
61		//initialize data
62	0	courseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
63	0	origCourseReqInfos = new LinkedHashMap<Integer, StatementTreeViewInfo>();
64	0	courseReqState = new HashMap<Integer, requirementState>();
65	0	origCourseReqState = new HashMap<Integer, requirementState>();
66	0	isInitialized = false;
67
68	0	parentController.requestModel(modelId, new ModelRequestCallback() {
69
70		@Override
71		public void onRequestFail(Throwable cause) {
72	0	Window.alert(cause.getMessage());
73	0	GWT.log("Unable to retrieve model for course requirements view", cause);
74	0	onReadyCallback.exec(false);
75	0	}
76
77		@Override
78		public void onModelReady(Model model) {
79	0	String courseId = ((DataModel)model).getRoot().get("id");
80	0	retrieveStatementTypes(courseId, onReadyCallback);
81	0	}
82		});
83	0	}
84
85		public void retrieveStatementTypes(final String courseId, final Callback<Boolean> onReadyCallback) {
86
87	0	getStatementTypes(new Callback<List<StatementTypeInfo>>() {
88		@Override
89		public void exec(List<StatementTypeInfo> stmtTypes) {
90		//now retrieve the actual rules
91	0	retrieveRules(courseId, onReadyCallback);
92	0	}
93		});
94	0	}
95
96		private void retrieveRules(String courseId, final Callback<Boolean> onReadyCallback) {
97
98		//true if no course exists yet
99	0	if ((courseId == null) \|\| courseId.isEmpty()) {
100	0	isInitialized = true;
101	0	onReadyCallback.exec(true);
102	0	return;
103		}
104
105	0	courseRemoteService.getCourseStatements(courseId, CourseRequirementsManageView.RULEEDIT_TEMLATE,
106	0	CourseRequirementsManageView.TEMLATE_LANGUAGE, new KSAsyncCallback<List<StatementTreeViewInfo>>() {
107		@Override
108		public void handleFailure(Throwable caught) {
109	0	Window.alert(caught.getMessage());
110	0	GWT.log("getCourseStatements failed", caught);
111	0	onReadyCallback.exec(false);
112	0	}
113
114		@Override
115		public void onSuccess(List<StatementTreeViewInfo> foundRules) {
116		//update rules list with new course requirements
117	0	if (foundRules != null) {
118	0	for (StatementTreeViewInfo foundRule : foundRules) {
119
120	0	if (getStmtTypeInfo(foundRule.getType()) == null) {
121		// Window.alert("Did not find corresponding statement type for course requirement of type: " + foundRule.getType());
122	0	GWT.log("Did not find corresponding statement type for course requirement of type: " + foundRule.getType(), null);
123		}
124
125	0	origCourseReqInfos.put(courseReqIDs, RulesUtil.clone(foundRule));
126	0	origCourseReqState.put(courseReqIDs, requirementState.STORED);
127	0	courseReqInfos.put(courseReqIDs, foundRule);
128	0	courseReqState.put(courseReqIDs++, requirementState.STORED);
129		}
130		}
131
132	0	isInitialized = true;
133	0	onReadyCallback.exec(true);
134	0	}
135		});
136	0	}
137
138		public StatementTreeViewInfo updateRules(StatementTreeViewInfo newSubRule, Integer internalCourseReqID, boolean isNewRule) {
139
140	0	StatementTreeViewInfo affectedRule = courseReqInfos.get(internalCourseReqID);
141
142	0	if (affectedRule == null) {
143	0	Window.alert("Cannot find course requisite with a statement that has id: '" + newSubRule.getId() + "'");
144	0	GWT.log("Cannot find course requisite with a statement that has id: '" + newSubRule.getId() + "'", null);
145	0	return null;
146		}
147
148	0	if (courseReqState.get(internalCourseReqID) == CourseRequirementsDataModel.requirementState.STORED) {
149	0	courseReqState.put(internalCourseReqID, CourseRequirementsDataModel.requirementState.EDITED);
150		}
151
152	0	courseReqInfos.put(internalCourseReqID, newSubRule);
153
154	0	return newSubRule;
155		}
156
157		public void updateCourseRequisites(final String courseId, final Callback<List<StatementTreeViewInfo>> callback) {
158
159		//course proposal has to be in the database before we can save rules
160	0	if (courseId == null) {
161	0	final ConfirmationDialog dialog = new ConfirmationDialog("Submit Course Title", "Before saving rules please submit course proposal title");
162	0	dialog.getConfirmButton().addClickHandler(new ClickHandler(){
163		@Override
164		public void onClick(ClickEvent event) {
165	0	dialog.hide();
166	0	}
167		});
168	0	dialog.show();
169	0	return;
170		}
171
172	0	final List<String> referencedProgReqIds = new ArrayList<String>();
173
174	0	courseRemoteService.storeCourseStatements(courseId.toString(), courseReqState, courseReqInfos, new KSAsyncCallback<Map<Integer, StatementTreeViewInfo>>() {
175		@Override
176		public void handleFailure(Throwable caught) {
177	0	Window.alert(caught.getMessage());
178	0	GWT.log("storeProgramRequirements failed", caught);
179	0	}
180		@Override
181		public void onSuccess(Map<Integer, StatementTreeViewInfo> storedRules) {
182
183	0	for (Integer internalProgReqID : storedRules.keySet()) {
184	0	StatementTreeViewInfo storedRule = storedRules.get(internalProgReqID);
185	0	switch (courseReqState.get(internalProgReqID)) {
186		case STORED:
187		//rule was not changed so continue
188	0	referencedProgReqIds.add(internalProgReqID.toString());
189	0	break;
190		case ADDED:
191	0	referencedProgReqIds.add(storedRule.getId());
192	0	courseReqInfos.put(internalProgReqID, storedRule);
193	0	origCourseReqInfos.put(internalProgReqID, RulesUtil.clone(storedRule));
194	0	origCourseReqState.put(internalProgReqID, requirementState.STORED);
195	0	courseReqState.put(internalProgReqID, requirementState.STORED);
196	0	break;
197		case EDITED:
198	0	referencedProgReqIds.add(storedRule.getId());
199	0	courseReqInfos.put(internalProgReqID, storedRule);
200	0	origCourseReqInfos.put(internalProgReqID, RulesUtil.clone(storedRule));
201	0	origCourseReqState.put(internalProgReqID, requirementState.STORED);
202	0	courseReqState.put(internalProgReqID, requirementState.STORED);
203	0	break;
204		case DELETED:
205	0	courseReqInfos.remove(internalProgReqID);
206	0	origCourseReqInfos.remove(internalProgReqID);
207	0	origCourseReqState.remove(internalProgReqID);
208	0	courseReqState.remove(internalProgReqID);
209	0	break;
210		default:
211		break;
212		}
213	0	}
214
215	0	KSNotifier.add(new KSNotification("Save Successful", false, 4000));
216		//MajorManager.getEventBus().fireEvent(new StoreRequirementIDsEvent(referencedProgReqIds));
217	0	callback.exec(new ArrayList(storedRules.values())); //update display widgets
218	0	}
219		});
220	0	}
221
222		public static void stripStatementIds(StatementTreeViewInfo tree) {
223	0	List<StatementTreeViewInfo> statements = tree.getStatements();
224	0	List<ReqComponentInfo> reqComponentInfos = tree.getReqComponents();
225
226	0	if ((tree.getId() != null) && (tree.getId().indexOf(CourseRequirementsSummaryView.NEW_STMT_TREE_ID)) >= 0) {
227	0	tree.setId(null);
228		}
229	0	tree.setState("Active");
230
231	0	if ((statements != null) && (statements.size() > 0)) {
232		// retrieve all statements
233	0	for (StatementTreeViewInfo statement : statements) {
234	0	stripStatementIds(statement); // inside set the children of this statementTreeViewInfo
235		}
236	0	} else if ((reqComponentInfos != null) && (reqComponentInfos.size() > 0)) {
237		// retrieve all req. component LEAFS
238	0	for (ReqComponentInfo reqComponent : reqComponentInfos) {
239	0	if ((reqComponent.getId() != null) && (reqComponent.getId().indexOf(CourseRequirementsSummaryView.NEW_REQ_COMP_ID) >= 0)) {
240	0	reqComponent.setId(null);
241		}
242
243	0	for (ReqCompFieldInfo field : reqComponent.getReqCompFields()) {
244	0	field.setId(null);
245		}
246
247	0	reqComponent.setState("Active");
248		}
249		}
250	0	}
251
252		public List<StatementTreeViewInfo> getCourseReqInfo(String stmtTypeId) {
253	0	List<StatementTreeViewInfo> rules = new ArrayList<StatementTreeViewInfo>();
254	0	for(StatementTreeViewInfo rule : courseReqInfos.values()) {
255	0	if (rule.getType().equals(stmtTypeId)) {
256	0	rules.add(rule);
257		}
258		}
259	0	return rules;
260		}
261
262		public Integer getInternalCourseReqID(StatementTreeViewInfo rule) {
263	0	for(Integer key : courseReqInfos.keySet()) {
264	0	if (courseReqInfos.get(key) == rule) {
265	0	return key;
266		}
267		}
268
269	0	Window.alert("Problem retrieving key for course requisite: " + rule.getId());
270	0	GWT.log("Problem retrieving key for course requisite: " + rule.getId(), null);
271
272	0	return null;
273		}
274
275		public StatementTypeInfo getStmtTypeInfo(String stmtTypeId) {
276	0	for (StatementTypeInfo stmtInfo : stmtTypes) {
277	0	if (stmtInfo.getId().equals(stmtTypeId)) {
278	0	return stmtInfo;
279		}
280		}
281
282		try {
283
284	0	Window.alert("Did not find StatementTypeInfo based on typeA: " + stmtTypeId + new Throwable().getStackTrace().toString());
285	0	GWT.log("Did not find StatementTypeInfo based on type: " + stmtTypeId + new Throwable().getStackTrace());
286
287
288	0	throw new Exception();
289
290	0	} catch (Exception e) {
291	0	Window.alert("Exception" + e.getStackTrace().toString());
292		}
293	0	return null;
294		}
295
296		public void deleteRule(Integer internalProgReqID) {
297	0	if (courseReqState.get(internalProgReqID) == requirementState.ADDED) {
298		//user added a rule, didn't save it and now wants to delete it
299	0	courseReqState.remove(internalProgReqID);
300	0	courseReqInfos.remove(internalProgReqID);
301		} else {
302	0	markRuleAsDeleted(internalProgReqID);
303		}
304	0	}
305
306		public void addRule(StatementTreeViewInfo rule) {
307	0	courseReqInfos.put(courseReqIDs, rule);
308	0	courseReqState.put(courseReqIDs++, requirementState.ADDED);
309	0	}
310
311		public void updateRule(Integer internalProgReqID, StatementTreeViewInfo rule) {
312	0	courseReqInfos.put(internalProgReqID, rule);
313	0	markRuleAsEdited(internalProgReqID);
314	0	}
315
316		public void markRuleAsDeleted(Integer internalCourseReqID) {
317	0	if ((courseReqState.get(internalCourseReqID) == requirementState.STORED) \|\|
318		(courseReqState.get(internalCourseReqID) == requirementState.EDITED)) {
319	0	courseReqState.put(internalCourseReqID, requirementState.DELETED);
320		}
321	0	}
322
323		public void markRuleAsEdited(Integer internalCourseReqID) {
324	0	if (courseReqState.get(internalCourseReqID) == requirementState.STORED) {
325	0	courseReqState.put(internalCourseReqID, requirementState.EDITED);
326		}
327	0	}
328
329		public String getStmtTypeName(String stmtTypeId) {
330	0	String name = getStmtTypeInfo(stmtTypeId).getName();
331	0	return (name == null ? "" : name);
332		}
333
334		public boolean isRuleExists(String stmtTypeId) {
335	0	boolean showNoRuleText = true;
336	0	for(StatementTreeViewInfo ruleInfo : courseReqInfos.values()) {
337	0	if ((ruleInfo.getType().equals(stmtTypeId)) && (courseReqState.get(getInternalCourseReqID(ruleInfo)) != requirementState.DELETED)) {
338	0	showNoRuleText = false;
339		}
340		}
341	0	return showNoRuleText;
342		}
343
344		public void removeEmptyRules() {
345	0	for(StatementTreeViewInfo rule : courseReqInfos.values()) {
346	0	if (isEmpty(rule)) {
347	0	Integer ruleId = getInternalCourseReqID(rule);
348	0	courseReqInfos.remove(ruleId);
349	0	courseReqState.remove(ruleId);
350	0	}
351		}
352	0	}
353
354		public boolean isDirty() {
355
356	0	if (courseReqState.size() != origCourseReqState.size()) {
357	0	return true;
358		}
359
360	0	for(Integer key : courseReqState.keySet()) {
361	0	if (!courseReqState.get(key).equals(origCourseReqState.get(key))) {
362	0	return true;
363		}
364		}
365
366	0	return false;
367		}
368
369		public void revertRuleChanges() {
370	0	courseReqInfos = new HashMap<Integer, StatementTreeViewInfo>();
371	0	courseReqState = new HashMap<Integer, requirementState>();
372	0	for(Integer key : origCourseReqInfos.keySet()) {
373	0	courseReqInfos.put(key, RulesUtil.clone(origCourseReqInfos.get(key)));
374	0	courseReqState.put(key, origCourseReqState.get(key));
375		}
376	0	}
377
378		public StatementTreeViewInfo getRule(Integer internalCourseReqID) {
379	0	return courseReqInfos.get(internalCourseReqID);
380		}
381
382		public static void getStatementTypes(final Callback<List<StatementTypeInfo>> onReadyCallback) {
383
384		//avoid loading statement types if we retrieved them already before
385	0	if (!stmtTypes.isEmpty()) {
386	0	onReadyCallback.exec(stmtTypes);
387	0	return;
388		}
389
390	0	StatementRpcServiceAsync statementRpcServiceAsync = GWT.create(StatementRpcService.class);
391
392		//retrieve available course requirement types
393	0	statementRpcServiceAsync.getStatementTypesForStatementTypeForCourse("kuali.statement.type.course", new KSAsyncCallback<List<StatementTypeInfo>>() {
394		@Override
395		public void handleFailure(Throwable caught) {
396	0	Window.alert(caught.getMessage());
397	0	GWT.log("getStatementTypes failed", caught);
398	0	onReadyCallback.exec(new ArrayList<StatementTypeInfo>());
399	0	}
400
401		@Override
402		public void onSuccess(List<StatementTypeInfo> stmtInfoTypes) {
403		//store the statement types
404	0	stmtTypes = new ArrayList<StatementTypeInfo>();
405	0	for (StatementTypeInfo stmtInfoType : stmtInfoTypes) {
406	0	stmtTypes.add(stmtInfoType);
407		}
408	0	onReadyCallback.exec(stmtTypes);
409	0	}
410		});
411	0	}
412
413		public static boolean isEmpty(StatementTreeViewInfo rule) {
414	0	return (((rule.getStatements() == null) \|\| rule.getStatements().isEmpty()) && ((rule.getReqComponents() == null) \|\| rule.getReqComponents().isEmpty()));
415		}
416
417		public boolean isInitialized() {
418	0	return isInitialized;
419		}
420
421		public void setInitialized(boolean initialized) {
422	0	isInitialized = initialized;
423	0	}
424
425		public List<StatementTypeInfo> getStmtTypes() {
426	0	return stmtTypes;
427		}
428		}