1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.student.lum.lu.ui.course.client.controllers;
17
18 import java.text.DateFormat;
19 import java.util.ArrayList;
20 import java.util.Date;
21 import java.util.HashMap;
22 import java.util.List;
23 import java.util.Map;
24
25 import org.kuali.student.common.ui.client.application.Application;
26 import org.kuali.student.common.ui.client.application.KSAsyncCallback;
27 import org.kuali.student.common.ui.client.application.ViewContext;
28 import org.kuali.student.common.ui.client.configurable.mvc.FieldDescriptor;
29 import org.kuali.student.common.ui.client.configurable.mvc.layouts.MenuEditableSectionController;
30 import org.kuali.student.common.ui.client.configurable.mvc.sections.BaseSection;
31 import org.kuali.student.common.ui.client.configurable.mvc.sections.Section;
32 import org.kuali.student.common.ui.client.configurable.mvc.views.SectionView;
33 import org.kuali.student.common.ui.client.event.ActionEvent;
34 import org.kuali.student.common.ui.client.event.ContentDirtyEvent;
35 import org.kuali.student.common.ui.client.event.ContentDirtyEventHandler;
36 import org.kuali.student.common.ui.client.event.SaveActionEvent;
37 import org.kuali.student.common.ui.client.event.SaveActionHandler;
38 import org.kuali.student.common.ui.client.mvc.ActionCompleteCallback;
39 import org.kuali.student.common.ui.client.mvc.Callback;
40 import org.kuali.student.common.ui.client.mvc.Controller;
41 import org.kuali.student.common.ui.client.mvc.DataModel;
42 import org.kuali.student.common.ui.client.mvc.DataModelDefinition;
43 import org.kuali.student.common.ui.client.mvc.HasCrossConstraints;
44 import org.kuali.student.common.ui.client.mvc.ModelProvider;
45 import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;
46 import org.kuali.student.common.ui.client.mvc.View;
47 import org.kuali.student.common.ui.client.mvc.WorkQueue;
48 import org.kuali.student.common.ui.client.mvc.WorkQueue.WorkItem;
49 import org.kuali.student.common.ui.client.mvc.dto.ReferenceModel;
50 import org.kuali.student.common.ui.client.mvc.history.HistoryManager;
51 import org.kuali.student.common.ui.client.security.AuthorizationCallback;
52 import org.kuali.student.common.ui.client.security.RequiresAuthorization;
53 import org.kuali.student.common.ui.client.service.BaseDataOrchestrationRpcServiceAsync;
54 import org.kuali.student.common.ui.client.service.DataSaveResult;
55 import org.kuali.student.common.ui.client.util.ExportElement;
56 import org.kuali.student.common.ui.client.util.ExportUtils;
57 import org.kuali.student.common.ui.client.util.WindowTitleUtils;
58 import org.kuali.student.common.ui.client.validator.ValidatorClientUtils;
59 import org.kuali.student.common.ui.client.widgets.KSButton;
60 import org.kuali.student.common.ui.client.widgets.KSButtonAbstract.ButtonStyle;
61 import org.kuali.student.common.ui.client.widgets.KSCheckBox;
62 import org.kuali.student.common.ui.client.widgets.KSDropDown;
63 import org.kuali.student.common.ui.client.widgets.KSLabel;
64 import org.kuali.student.common.ui.client.widgets.buttongroups.ButtonEnumerations.YesNoCancelEnum;
65 import org.kuali.student.common.ui.client.widgets.dialog.ButtonMessageDialog;
66 import org.kuali.student.common.ui.client.widgets.field.layout.button.ButtonGroup;
67 import org.kuali.student.common.ui.client.widgets.field.layout.button.YesNoCancelGroup;
68 import org.kuali.student.common.ui.client.widgets.menus.KSMenuItemData;
69 import org.kuali.student.common.ui.client.widgets.notification.KSNotification;
70 import org.kuali.student.common.ui.client.widgets.notification.KSNotifier;
71 import org.kuali.student.common.ui.client.widgets.progress.BlockingTask;
72 import org.kuali.student.common.ui.client.widgets.progress.KSBlockingProgressIndicator;
73 import org.kuali.student.common.ui.client.widgets.search.KSPicker;
74 import org.kuali.student.common.ui.client.widgets.table.summary.SummaryTableSection;
75 import org.kuali.student.common.ui.shared.IdAttributes;
76 import org.kuali.student.common.ui.shared.IdAttributes.IdType;
77 import org.kuali.student.core.workflow.ui.client.widgets.WorkflowEnhancedNavController;
78 import org.kuali.student.core.workflow.ui.client.widgets.WorkflowUtilities;
79 import org.kuali.student.lum.common.client.helpers.RecentlyViewedHelper;
80 import org.kuali.student.lum.common.client.lu.LUUIConstants;
81 import org.kuali.student.lum.common.client.widgets.AppLocations;
82 import org.kuali.student.lum.lu.assembly.data.client.constants.orch.CreditCourseConstants;
83 import org.kuali.student.lum.lu.ui.course.client.configuration.CourseProposalConfigurer;
84 import org.kuali.student.lum.lu.ui.course.client.configuration.CourseProposalConfigurer.CourseSections;
85 import org.kuali.student.lum.lu.ui.course.client.configuration.CourseSummaryConfigurer;
86 import org.kuali.student.lum.lu.ui.course.client.requirements.CourseRequirementsDataModel;
87 import org.kuali.student.lum.lu.ui.course.client.requirements.HasRequirements;
88 import org.kuali.student.lum.lu.ui.course.client.service.CourseRpcService;
89 import org.kuali.student.lum.lu.ui.course.client.service.CourseRpcServiceAsync;
90 import org.kuali.student.lum.lu.ui.course.client.service.CreditCourseProposalRpcService;
91 import org.kuali.student.lum.lu.ui.course.client.service.CreditCourseProposalRpcServiceAsync;
92 import org.kuali.student.r1.common.assembly.data.Data;
93 import org.kuali.student.r1.common.assembly.data.Metadata;
94 import org.kuali.student.r1.common.assembly.data.QueryPath;
95 import org.kuali.student.r1.common.rice.StudentIdentityConstants;
96 import org.kuali.student.r1.common.rice.authorization.PermissionType;
97 import org.kuali.student.r1.core.statement.dto.StatementTypeInfo;
98 import org.kuali.student.r2.common.dto.DtoConstants;
99 import org.kuali.student.r2.common.dto.ValidationResultInfo;
100 import org.kuali.student.r2.lum.clu.CLUConstants;
101
102 import com.google.gwt.core.client.GWT;
103 import com.google.gwt.event.dom.client.ClickEvent;
104 import com.google.gwt.event.dom.client.ClickHandler;
105 import com.google.gwt.event.logical.shared.ValueChangeEvent;
106 import com.google.gwt.event.logical.shared.ValueChangeHandler;
107 import com.google.gwt.user.client.Window;
108 import com.google.gwt.user.client.rpc.AsyncCallback;
109
110
111
112
113
114
115
116
117
118
119
120 public class CourseProposalController extends MenuEditableSectionController implements RequiresAuthorization, WorkflowEnhancedNavController, HasRequirements {
121
122
123 protected CreditCourseProposalRpcServiceAsync cluProposalRpcServiceAsync = GWT.create(CreditCourseProposalRpcService.class);
124 protected CourseRpcServiceAsync courseServiceAsync = GWT.create(CourseRpcService.class);
125
126 protected final DataModel cluProposalModel = new DataModel("Proposal");
127 protected final DataModel comparisonModel = new DataModel(Application.getApplicationContext().getMessage("course",
128 "proposalDataModuleTitle"));
129
130 protected CourseProposalConfigurer cfg;
131
132 protected WorkQueue modelRequestQueue;
133
134 protected WorkflowUtilities workflowUtil;
135
136 protected boolean initialized = false;
137 protected boolean isNew = false;
138
139 private static final String UPDATED_KEY = "meta/updateTime";
140 private static final String VERSION_KEY = "version/versionedFromId";
141 private static final String MSG_GROUP = "course";
142
143 protected String currentDocType = CLUConstants.PROPOSAL_TYPE_COURSE_CREATE;
144 protected String proposalPath = "";
145 protected String currentTitle;
146
147 private final DateFormat df = DateFormat.getInstance();
148
149 private final BlockingTask initializingTask = new BlockingTask("Loading");
150 protected final BlockingTask loadDataTask = new BlockingTask("Retrieving Data");
151 private final BlockingTask saving = new BlockingTask("Saving");
152
153 protected CourseRequirementsDataModel reqDataModel;
154 protected CourseRequirementsDataModel reqDataModelComp;
155
156 public CourseProposalController(){
157 super();
158 initializeController();
159 }
160
161 protected void initializeController() {
162 cfg = GWT.create(CourseProposalConfigurer.class);
163 proposalPath = cfg.getProposalPath();
164 workflowUtil = GWT.create(WorkflowUtilities.class);
165 workflowUtil.init(CourseProposalController.this, proposalPath, "Proposal Actions",
166 CourseProposalConfigurer.CourseSections.WF_APPROVE_DIALOG, "", cfg.getModelId());
167 cfg.setState(DtoConstants.STATE_DRAFT);
168
169
170 workflowUtil.getAdditionalItems().add(new KSMenuItemData(this.getMessage("cluCopyItem"), new ClickHandler() {
171 @Override
172 public void onClick(ClickEvent event) {
173 if (getViewContext() != null && getViewContext().getId() != null && !getViewContext().getId().isEmpty()) {
174 getViewContext().setId((String) cluProposalModel.get(cfg.getProposalPath() + "/id"));
175 getViewContext().setIdType(IdType.COPY_OF_KS_KEW_OBJECT_ID);
176 getViewContext().getAttributes().remove(StudentIdentityConstants.DOCUMENT_TYPE_NAME);
177 cluProposalModel.resetRoot();
178 }
179 HistoryManager.navigate("/HOME/CURRICULUM_HOME/COURSE_PROPOSAL", getViewContext());
180 }
181 }));
182
183 super.setDefaultModelId(cfg.getModelId());
184 registerModelsAndHandlers();
185
186 addStyleName("courseProposal");
187 setViewContext(getViewContext());
188 }
189
190 protected void registerModelsAndHandlers(){
191 reqDataModel = new CourseRequirementsDataModel(this);
192 reqDataModelComp = new CourseRequirementsDataModel(this);
193
194 super.registerModel(super.getDefaultModelId(), new ModelProvider<DataModel>() {
195
196 @Override
197 public void requestModel(final ModelRequestCallback<DataModel> callback) {
198 if (modelRequestQueue == null){
199 modelRequestQueue = new WorkQueue();
200 }
201
202 WorkItem workItem = new WorkItem(){
203 @Override
204 public void exec(Callback<Boolean> workCompleteCallback) {
205 if (cluProposalModel.getRoot() == null || initialized == false){
206 populateModel(callback, workCompleteCallback);
207 } else {
208 callback.onModelReady(cluProposalModel);
209 workCompleteCallback.exec(true);
210 }
211 }
212 };
213 modelRequestQueue.submit(workItem);
214
215 }
216
217 });
218 super.registerModel("ComparisonModel", new ModelProvider<DataModel>() {
219 @Override
220 public void requestModel(final ModelRequestCallback<DataModel> callback) {
221 if(comparisonModel.getRoot() != null && comparisonModel.getRoot().size() != 0){
222 callback.onModelReady(comparisonModel);
223
224 }
225 else{
226 callback.onModelReady(null);
227 }
228
229 }
230 });
231 super.addApplicationEventHandler(ContentDirtyEvent.TYPE, new ContentDirtyEventHandler(){
232 public void onContentDirty(ContentDirtyEvent event) {
233 setContentWarning("You have unsaved changes");
234 }
235 });
236
237 super.addApplicationEventHandler(SaveActionEvent.TYPE, new SaveActionHandler(){
238 public void doSave(SaveActionEvent saveAction) {
239 GWT.log("CluProposalController received save action request.", null);
240 doSaveAction(saveAction);
241 }
242 });
243 }
244
245
246
247
248
249
250
251 protected void populateModel(final ModelRequestCallback<DataModel> callback, Callback<Boolean> workCompleteCallback){
252 if(getViewContext().getIdType() == IdType.DOCUMENT_ID){
253 getCluProposalFromWorkflowId(callback, workCompleteCallback);
254 } else if (getViewContext().getIdType() == IdType.KS_KEW_OBJECT_ID || getViewContext().getIdType() == IdType.OBJECT_ID){
255
256 getCluProposalFromProposalId(getViewContext().getId(), callback, workCompleteCallback);
257 } else if (getViewContext().getIdType() == IdType.COPY_OF_OBJECT_ID){
258 if(CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY.equals(getViewContext().getAttribute(StudentIdentityConstants.DOCUMENT_TYPE_NAME))||
259 CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY_ADMIN.equals(getViewContext().getAttribute(StudentIdentityConstants.DOCUMENT_TYPE_NAME))){
260 createModifyCluProposalModel("versionComment", callback, workCompleteCallback);
261 }else{
262 createCopyCourseModel(getViewContext().getId(), callback, workCompleteCallback);
263 }
264 } else if (getViewContext().getIdType() == IdType.COPY_OF_KS_KEW_OBJECT_ID){
265
266 createCopyCourseProposalModel(getViewContext().getId(), callback, workCompleteCallback);
267 } else{
268 createNewCluProposalModel(callback, workCompleteCallback);
269 }
270 }
271
272 protected void getCurrentModel(final ModelRequestCallback<DataModel> callback, Callback<Boolean> workCompleteCallback){
273 if (cluProposalModel.getRoot() != null && cluProposalModel.getRoot().size() > 0){
274 String id = cluProposalModel.get(cfg.getProposalPath()+"/id");
275 if(id != null){
276 getCluProposalFromProposalId(id, callback, workCompleteCallback);
277 }
278 else{
279 populateModel(callback, workCompleteCallback);
280 }
281 }
282 else{
283 populateModel(callback, workCompleteCallback);
284 }
285 }
286
287 private void intializeView(final Callback<Boolean> onReadyCallback) {
288 if (initialized) {
289 onReadyCallback.exec(true);
290 } else {
291 initialized = true;
292 KSBlockingProgressIndicator.addTask(initializingTask);
293 setContentWarning("");
294 this.requestModel(new ModelRequestCallback<DataModel>(){
295
296 @Override
297 public void onModelReady(DataModel model) {
298
299
300 String idType = null;
301 String viewContextId = "";
302 if(getViewContext().getIdType() != null){
303 idType = getViewContext().getIdType().toString();
304 viewContextId = getViewContext().getId();
305 if(getViewContext().getIdType()==IdAttributes.IdType.COPY_OF_OBJECT_ID){
306 viewContextId = null;
307 }
308
309 }
310
311
312
313 if ((currentDocType.equals(CLUConstants.PROPOSAL_TYPE_COURSE_CREATE)) &&
314 (cluProposalModel.get(VERSION_KEY) != null) && (!(cluProposalModel.get(VERSION_KEY).equals(""))))
315 {
316 currentDocType = CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY;
317 }
318
319 if(CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY_ADMIN.equals(cluProposalModel.get(cfg.getProposalPath()+"/type"))){
320 currentDocType = CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY_ADMIN;
321 }
322
323
324 String dtoState = getStateforSaveAction(cluProposalModel);
325
326
327 String workflowNode = cluProposalModel.get(cfg.getProposalPath()+"/workflowNode");
328
329
330 HashMap<String, String> idAttributes = new HashMap<String, String>();
331 if(idType != null){
332 idAttributes.put(IdAttributes.ID_TYPE, idType);
333 }
334 idAttributes.put(StudentIdentityConstants.DOCUMENT_TYPE_NAME, currentDocType);
335 idAttributes.put(DtoConstants.DTO_STATE, dtoState);
336 idAttributes.put(DtoConstants.DTO_NEXT_STATE, cfg.getNextState());
337 if (CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY.equalsIgnoreCase(currentDocType) ||
338 CLUConstants.PROPOSAL_TYPE_COURSE_CREATE.equals(currentDocType)){
339 idAttributes.put(DtoConstants.DTO_WORKFLOW_NODE, workflowNode);
340 }
341
342
343
344 getCourseProposalRpcService().getMetadata(viewContextId, idAttributes, new KSAsyncCallback<Metadata>(){
345 @Override
346 public void handleTimeout(Throwable caught) {
347 initializeFailed();
348 }
349
350 @Override
351 public void handleFailure(Throwable caught) {
352 initializeFailed();
353 throw new RuntimeException("Failed to get model definition.", caught);
354 }
355
356 public void initializeFailed(){
357 initialized = false;
358 onReadyCallback.exec(false);
359 KSBlockingProgressIndicator.removeTask(initializingTask);
360 }
361
362 public void onSuccess(Metadata result) {
363 DataModelDefinition def = new DataModelDefinition(result);
364 cluProposalModel.setDefinition(def);
365 comparisonModel.setDefinition(def);
366
367 configureScreens(def, onReadyCallback);
368
369 }
370 });
371
372 }
373
374 @Override
375 public void onRequestFail(Throwable cause) {
376 GWT.log("Failed to get modeld for proposal controller init");
377 onReadyCallback.exec(false);
378 }
379 });
380
381 }
382 }
383
384 @Override
385 public void getMetadataForFinalState(final KSAsyncCallback<Metadata> callback){
386
387 String idType = null;
388 String viewContextId = "";
389 if(getViewContext().getIdType() != null){
390 idType = getViewContext().getIdType().toString();
391 viewContextId = getViewContext().getId();
392 if(getViewContext().getIdType()==IdAttributes.IdType.COPY_OF_OBJECT_ID){
393 viewContextId = null;
394 }
395 }
396 HashMap<String, String> idAttributes = new HashMap<String, String>();
397 if(idType != null){
398 idAttributes.put(IdAttributes.ID_TYPE, idType);
399 }
400
401 idAttributes.put(StudentIdentityConstants.DOCUMENT_TYPE_NAME, currentDocType);
402 idAttributes.put(DtoConstants.DTO_STATE, cfg.getState());
403 idAttributes.put(DtoConstants.DTO_NEXT_STATE, cfg.getNextState());
404 idAttributes.put(DtoConstants.DTO_WORKFLOW_NODE, "Publication Review");
405
406
407 getCourseProposalRpcService().getMetadata(viewContextId, idAttributes, new KSAsyncCallback<Metadata>(){
408 @Override
409 public void onSuccess(Metadata result) {
410 callback.onSuccess(result);
411 }
412 });
413 }
414
415 protected void configureScreens(final DataModelDefinition modelDefinition, final Callback<Boolean> onReadyCallback){
416 if (workflowUtil != null){
417 workflowUtil.requestAndSetupModel(NO_OP_CALLBACK);
418 }
419
420 CourseRequirementsDataModel.getStatementTypes(new Callback<List<StatementTypeInfo>>() {
421
422 @Override
423 public void exec(List<StatementTypeInfo> stmtTypes) {
424 List<StatementTypeInfo> stmtTypesOut = new ArrayList<StatementTypeInfo>();
425 if (stmtTypes != null) {
426 for (StatementTypeInfo stmtType : stmtTypes) {
427 if (stmtType.getId().contains("kuali.statement.type.course.enrollmentEligibility") ||
428 stmtType.getId().contains("kuali.statement.type.course.creditConstraints")) {
429 continue;
430 }
431 stmtTypesOut.add(stmtType);
432 }
433 }
434
435 cfg.setStatementTypes(stmtTypesOut);
436 cfg.setModelDefinition(modelDefinition);
437 cfg.configure(CourseProposalController.this);
438
439
440
441 if(workflowUtil!=null){
442
443 CourseSummaryConfigurer summary = cfg.getSummaryConfigurer();
444 if (summary != null){
445 workflowUtil.setTableSection(summary.getTableSection());
446 }
447
448 requestModel(new ModelRequestCallback<DataModel>() {
449 public void onModelReady(DataModel model) {
450
451 String proposalType = model.get("proposal/type");
452 if ((proposalType != null) && (proposalType.equals(CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY))) {
453 KSLabel descLabel = new KSLabel();
454 descLabel.setText(Application.getApplicationContext().getUILabel("course", LUUIConstants.FINAL_APPROVAL_DIALOG));
455 if (workflowUtil.getApproveDialogue() != null) {
456
457 workflowUtil.getApproveDialogue().addWidget(descLabel);
458 }
459 workflowUtil.addApproveDialogField("", "startTerm", cfg.generateMessageInfo(LUUIConstants.PROPOSAL_START_TERM), modelDefinition, true, true);
460 workflowUtil.addApproveDialogField("proposal", "prevEndTerm", cfg.generateMessageInfo(LUUIConstants.PROPOSAL_PREV_END_TERM), modelDefinition, false);
461
462 workflowUtil.updateApproveFields();
463 workflowUtil.progressiveEnableFields();
464 } else {
465
466
467
468 workflowUtil.addIgnoreDialogField("proposal/prevEndTerm");
469 }
470 }
471
472 public void onRequestFail(Throwable cause) {
473 }
474 });
475 }
476
477 progressiveEnableFields();
478
479 onReadyCallback.exec(true);
480 KSBlockingProgressIndicator.removeTask(initializingTask);
481 }
482 });
483 }
484
485
486
487
488
489
490 protected void progressiveEnableFields(){
491 final FieldDescriptor endTerm = Application.getApplicationContext().getPathToFieldMapping(null,CreditCourseConstants.END_TERM);
492 final FieldDescriptor pilotCourse = Application.getApplicationContext().getPathToFieldMapping(null,CreditCourseConstants.PILOT_COURSE);
493
494 if (pilotCourse != null && endTerm != null){
495
496 Boolean enableEndTerm = Boolean.TRUE.equals(cluProposalModel.get(CreditCourseConstants.PILOT_COURSE))
497 || DtoConstants.STATE_RETIRED.equalsIgnoreCase((String)cluProposalModel.get(CreditCourseConstants.STATE));
498
499 BaseSection.progressiveEnableAndRequireFields(enableEndTerm, endTerm);
500
501
502 KSCheckBox pilotCheckbox = ((KSCheckBox)pilotCourse.getFieldWidget());
503 pilotCheckbox.addValueChangeHandler(new ValueChangeHandler<Boolean>() {
504 @Override
505 public void onValueChange(ValueChangeEvent<Boolean> event) {
506
507 BaseSection.progressiveEnableAndRequireFields(event.getValue(), endTerm);
508
509
510 if (!event.getValue()){
511 ((KSDropDown)((KSPicker)endTerm.getFieldWidget()).getInputWidget()).clear();
512 }
513 }
514 });
515 }
516 }
517
518 @Override
519 @SuppressWarnings("unchecked")
520 public void requestModel(Class modelType, final ModelRequestCallback callback) {
521 if(modelType == ReferenceModel.class){
522 if (cluProposalModel != null){
523 ReferenceModel ref = new ReferenceModel();
524
525 if(cluProposalModel.get(cfg.getProposalPath()) != null){
526 ref.setReferenceId((String)cluProposalModel.get(cfg.getProposalPath()+"/id"));
527 } else {
528 ref.setReferenceId(null);
529 }
530
531
532 if(cluProposalModel.get(cfg.getProposalPath()) != null){
533 Map<String, String> attributes = new HashMap<String, String>();
534 attributes.put("name", (String)cluProposalModel.get(cfg.getProposalPath()+"/name"));
535 ref.setReferenceAttributes(attributes);
536 } else {
537 ref.setReferenceAttributes(null);
538 }
539
540 ref.setReferenceTypeKey(cfg.getProposalReferenceTypeKey());
541 ref.setReferenceType(cfg.getProposalReferenceObjectType());
542 ref.setReferenceState(getViewContext().getState());
543
544 callback.onModelReady(ref);
545 }
546 } else if (modelType == Data.class){
547 requestModel(cfg.getModelId(), callback);
548 } else {
549 super.requestModel(modelType, callback);
550 }
551
552 }
553
554 protected void getCluProposalFromWorkflowId(@SuppressWarnings("rawtypes") final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){
555 KSBlockingProgressIndicator.addTask(loadDataTask);
556 workflowUtil.getDataIdFromWorkflowId(getViewContext().getId(), new KSAsyncCallback<String>(){
557 @Override
558 public void handleFailure(Throwable caught) {
559 Window.alert("Error loading Proposal from Workflow Document: "+caught.getMessage());
560 createNewCluProposalModel(callback, workCompleteCallback);
561 KSBlockingProgressIndicator.removeTask(loadDataTask);
562 }
563
564 @Override
565 public void onSuccess(String proposalId) {
566 KSBlockingProgressIndicator.removeTask(loadDataTask);
567 getCluProposalFromProposalId(proposalId, callback, workCompleteCallback);
568 }
569 });
570 }
571
572 protected void getCluProposalFromProposalId(String id, @SuppressWarnings("rawtypes") final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){
573 KSBlockingProgressIndicator.addTask(loadDataTask);
574 getCourseProposalRpcService().getData(id, new KSAsyncCallback<Data>(){
575
576 @Override
577 public void handleFailure(Throwable caught) {
578 Window.alert("Error loading Proposal: "+caught.getMessage());
579 createNewCluProposalModel(callback, workCompleteCallback);
580 KSBlockingProgressIndicator.removeTask(loadDataTask);
581 }
582
583 @Override
584 public void onSuccess(Data result) {
585 cluProposalModel.setRoot(result);
586 setHeaderTitle();
587 setLastUpdated();
588 reqDataModel.retrieveStatementTypes(cluProposalModel.<String>get("id"), new Callback<Boolean>() {
589 @Override
590 public void exec(Boolean result) {
591 if(result){
592 getCourseComparisonModelAndReqs(callback, workCompleteCallback);
593 }
594 }
595 });
596 }
597
598 });
599 }
600
601 @SuppressWarnings("unchecked")
602 protected void getCourseComparisonModelAndReqs(final ModelRequestCallback proposalModelRequestCallback, final Callback<Boolean> workCompleteCallback){
603 if(cluProposalModel.get(VERSION_KEY) != null && !((String)cluProposalModel.get(VERSION_KEY)).equals("")){
604 courseServiceAsync.getData((String)cluProposalModel.get(VERSION_KEY), new KSAsyncCallback<Data>(){
605
606 @Override
607 public void handleFailure(Throwable caught) {
608 Window.alert("Error loading Proposal: "+caught.getMessage());
609 createNewCluProposalModel(proposalModelRequestCallback, workCompleteCallback);
610 KSBlockingProgressIndicator.removeTask(loadDataTask);
611 }
612
613 @Override
614 public void onSuccess(Data result) {
615
616 if (result != null)
617 comparisonModel.setRoot(result);
618
619 reqDataModel.retrieveStatementTypes(cluProposalModel.<String>get("id"), new Callback<Boolean>() {
620 @Override
621 public void exec(Boolean result) {
622 if (result) {
623 KSBlockingProgressIndicator.removeTask(loadDataTask);
624 reqDataModelComp.retrieveStatementTypes(comparisonModel.<String>get("id"), new Callback<Boolean>() {
625 @Override
626 public void exec(Boolean result) {
627 if (result) {
628 KSBlockingProgressIndicator.removeTask(loadDataTask);
629 }
630 }
631 });
632 proposalModelRequestCallback.onModelReady(cluProposalModel);
633 workCompleteCallback.exec(true);
634 }
635 }
636 });
637 }
638 });
639 } else {
640 proposalModelRequestCallback.onModelReady(cluProposalModel);
641 workCompleteCallback.exec(true);
642 KSBlockingProgressIndicator.removeTask(loadDataTask);
643 }
644 }
645
646 @SuppressWarnings("unchecked")
647 protected void createNewCluProposalModel(final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){
648 Data data = new Data();
649 cluProposalModel.setRoot(data);
650
651 Data proposalData = new Data();
652 proposalData.set(new Data.StringKey("type"), currentDocType);
653 data.set(new Data.StringKey("proposal"), proposalData);
654 if (cfg != null) {
655 if (cfg.getNextState() == null || cfg.getNextState().isEmpty()){
656 proposalData.set(new Data.StringKey("workflowNode"), "PreRoute");
657 }
658 }
659
660 isNew = true;
661 setHeaderTitle();
662 setLastUpdated();
663 callback.onModelReady(cluProposalModel);
664 workCompleteCallback.exec(true);
665 }
666
667 protected void createModifyCluProposalModel(String versionComment, final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){
668 Data data = new Data();
669 cluProposalModel.setRoot(data);
670
671 this.currentDocType = getViewContext().getAttribute(StudentIdentityConstants.DOCUMENT_TYPE_NAME);
672 Data proposalData = new Data();
673 proposalData.set(new Data.StringKey("type"), currentDocType);
674 data.set(new Data.StringKey("proposal"), proposalData);
675 if (cfg != null) {
676 if (cfg.getNextState() == null && cfg.getNextState().isEmpty()){
677 proposalData.set(new Data.StringKey("workflowNode"), "PreRoute");
678 }
679 }
680
681 Data versionData = new Data();
682 versionData.set(new Data.StringKey("versionIndId"), getViewContext().getId());
683 versionData.set(new Data.StringKey("versionComment"), versionComment);
684 data.set(new Data.StringKey("version"), versionData);
685
686 cluProposalRpcServiceAsync.saveData(cluProposalModel.getRoot(), new AsyncCallback<DataSaveResult>() {
687 public void onSuccess(DataSaveResult result) {
688 cluProposalModel.setRoot(result.getValue());
689 setHeaderTitle();
690 setLastUpdated();
691
692 ViewContext docContext = new ViewContext();
693 docContext.setId((String) cluProposalModel.get(cfg.getProposalPath()+"/id"));
694 docContext.setIdType(IdType.KS_KEW_OBJECT_ID);
695
696
697
698 getCourseComparisonModelAndReqs(callback, workCompleteCallback);
699
700
701
702 getViewContext().setIdType(docContext.getIdType());
703 getViewContext().setId(docContext.getId());
704
705 }
706
707 public void onFailure(Throwable caught) {
708 Window.alert("Error loading Proposal: "+caught.getMessage());
709 createNewCluProposalModel(callback, workCompleteCallback);
710 KSBlockingProgressIndicator.removeTask(loadDataTask);
711 }
712 });
713 }
714
715 @SuppressWarnings("unchecked")
716 protected void createCopyCourseModel(String originalCluId, final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){
717
718 cluProposalRpcServiceAsync.createCopyCourse(originalCluId, new AsyncCallback<DataSaveResult>() {
719 public void onSuccess(DataSaveResult result) {
720 cluProposalModel.setRoot(result.getValue());
721
722
723 Data proposalData = new Data();
724 cluProposalModel.getRoot().set(new Data.StringKey("proposal"), proposalData);
725 if (cfg.getNextState() == null || cfg.getNextState().isEmpty()){
726 proposalData.set(new Data.StringKey("workflowNode"), "PreRoute");
727 }
728
729 isNew = true;
730 setHeaderTitle();
731 setLastUpdated();
732
733 callback.onModelReady(cluProposalModel);
734 workCompleteCallback.exec(true);
735 }
736
737 public void onFailure(Throwable caught) {
738 Window.alert("Error loading Proposal: "+caught.getMessage());
739 createNewCluProposalModel(callback, workCompleteCallback);
740 KSBlockingProgressIndicator.removeTask(loadDataTask);
741 }
742 });
743 }
744
745 @SuppressWarnings("unchecked")
746 protected void createCopyCourseProposalModel(String originalProposalId, final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){
747
748 cluProposalRpcServiceAsync.createCopyCourseProposal(originalProposalId, currentDocType, new AsyncCallback<DataSaveResult>() {
749 public void onSuccess(DataSaveResult result) {
750 cluProposalModel.setRoot(result.getValue());
751 setHeaderTitle();
752 setLastUpdated();
753
754 ViewContext docContext = new ViewContext();
755 docContext.setId((String) cluProposalModel.get(cfg.getProposalPath()+"/id"));
756 docContext.setIdType(IdType.KS_KEW_OBJECT_ID);
757 RecentlyViewedHelper.addDocument(getProposalTitle(),
758 HistoryManager.appendContext(AppLocations.Locations.COURSE_PROPOSAL.getLocation(), docContext)
759 + "/COURSE_INFO");
760
761
762
763 getViewContext().setIdType(docContext.getIdType());
764 getViewContext().setId(docContext.getId());
765
766 callback.onModelReady(cluProposalModel);
767 workCompleteCallback.exec(true);
768 }
769
770 public void onFailure(Throwable caught) {
771 Window.alert("Error loading Proposal: "+caught.getMessage());
772 createNewCluProposalModel(callback, workCompleteCallback);
773 KSBlockingProgressIndicator.removeTask(loadDataTask);
774 }
775 });
776 }
777
778 public void doSaveAction(final SaveActionEvent saveActionEvent){
779 requestModel(new ModelRequestCallback<DataModel>() {
780 @Override
781 public void onModelReady(DataModel model) {
782 CourseProposalController.this.updateModelFromCurrentView();
783
784 if (isStartViewShowing()){
785
786
787 getStartPopupView().updateModel();
788 }
789
790 model.validate(new Callback<List<ValidationResultInfo>>() {
791 @Override
792 public void exec(List<ValidationResultInfo> result) {
793
794 boolean isSectionValid = isValid(result, true);
795
796 if(isSectionValid){
797 if (startSectionRequired()){
798 showStartPopup(NO_OP_CALLBACK);
799 saveActionEvent.doActionComplete();
800 }
801 else{
802 saveProposalClu(saveActionEvent);
803 }
804 }
805 else{
806
807 KSNotifier.add(new KSNotification("Unable to save, please check fields for errors.", false, true, 5000));
808 }
809
810 }
811 });
812 }
813
814 @Override
815 public void onRequestFail(Throwable cause) {
816 saveActionEvent.doActionComplete();
817 GWT.log("Unable to retrieve model for validation and save", cause);
818 }
819
820 });
821
822 }
823
824 public boolean startSectionRequired(){
825 String proposalId = cluProposalModel.get(cfg.getProposalPath()+"/id");
826
827
828
829 String proposalTitle = cluProposalModel.get(cfg.getProposalTitlePath());
830 String courseTitle = cluProposalModel.get(cfg.getCourseTitlePath());
831 if (proposalTitle == null || proposalTitle.isEmpty()){
832 cluProposalModel.set(QueryPath.parse(cfg.getProposalTitlePath()), courseTitle);
833 }
834
835 return proposalId==null && !CourseProposalController.this.isStartViewShowing() && !hasTitles(proposalTitle, courseTitle);
836 }
837
838 private boolean hasTitles(String proposalTitle, String courseTitle){
839 return (proposalTitle != null && !proposalTitle.isEmpty()) && (courseTitle != null && !courseTitle.isEmpty());
840 }
841
842 public void saveProposalClu(final SaveActionEvent saveActionEvent){
843 KSBlockingProgressIndicator.addTask(saving);
844 getCourseProposalRpcService().saveData(cluProposalModel.getRoot(), new KSAsyncCallback<DataSaveResult>(){
845
846 @Override
847 public void handleFailure(Throwable caught) {
848 GWT.log("Save Failed.", caught);
849 KSBlockingProgressIndicator.removeTask(saving);
850 KSNotifier.add(new KSNotification("Save Failed on server. Please try again.", false, true, 5000));
851 }
852
853 @Override
854 public void handleVersionMismatch(Throwable caught) {
855 super.handleVersionMismatch(caught);
856 KSBlockingProgressIndicator.removeTask(saving);
857 }
858
859 public void onSuccess(DataSaveResult result) {
860 KSBlockingProgressIndicator.removeTask(saving);
861
862 Application.getApplicationContext().clearValidationWarnings();
863 Application.getApplicationContext().addValidationWarnings(result.getValidationResults());
864
865 if(ValidatorClientUtils.hasErrors(result.getValidationResults())){
866 isValid(result.getValidationResults(), false, true);
867 saveActionEvent.setGotoNextView(false);
868 saveActionEvent.doActionComplete();
869 KSNotifier.add(new KSNotification("Save Failed. There were validation errors.", false, true, 5000));
870 }else{
871
872 saveActionEvent.setSaveSuccessful(true);
873 cluProposalModel.setRoot(result.getValue());
874 String title = getProposalTitle();
875 View currentView = getCurrentView();
876 if (currentView instanceof SectionView){
877 ((SectionView)currentView).updateView(cluProposalModel);
878 ((SectionView) currentView).resetDirtyFlags();
879 }
880 saveActionEvent.doActionComplete();
881
882 ViewContext context = CourseProposalController.this.getViewContext();
883 context.setId((String)cluProposalModel.get(proposalPath+"/id"));
884 context.setIdType(IdType.KS_KEW_OBJECT_ID);
885
886
887 if(workflowUtil != null){
888 workflowUtil.refresh();
889 }
890
891 setHeaderTitle();
892 setLastUpdated();
893 HistoryManager.logHistoryChange();
894 if(isNew){
895 RecentlyViewedHelper.addDocument(getProposalTitle(),
896 HistoryManager.appendContext(AppLocations.Locations.COURSE_PROPOSAL.getLocation(), context)
897 + "/SUMMARY");
898 }
899 else if(!currentTitle.equals(title)){
900 RecentlyViewedHelper.updateTitle(currentTitle, title, (String)cluProposalModel.get(proposalPath+"/id"));
901 }
902 isNew = false;
903
904 if(saveActionEvent.gotoNextView()){
905 CourseProposalController.this.showNextViewOnMenu();
906 }
907
908 if (ValidatorClientUtils.hasWarnings(result.getValidationResults())){
909 if (!saveActionEvent.gotoNextView()){
910
911 isValid(result.getValidationResults(), false, true);
912 }
913 KSNotifier.show("Saved with Warnings");
914 } else {
915 KSNotifier.show("Save Successful");
916 }
917 }
918 }
919 });
920
921 }
922
923 public void setLastUpdated(){
924 Date lastUpdated = (Date)cluProposalModel.get(UPDATED_KEY);
925 if(lastUpdated != null){
926 setContentInfo("Last Updated: " + df.format(lastUpdated));
927 }
928 else{
929 setContentInfo("");
930 }
931 }
932
933 @Override
934 public void beforeShow(final Callback<Boolean> onReadyCallback){
935 Application.getApplicationContext().clearCrossConstraintMap(null);
936 Application.getApplicationContext().clearPathToFieldMapping(null);
937 Application.getApplicationContext().clearValidationWarnings();
938 Application.getApplicationContext().setParentPath("");
939
940 intializeView(onReadyCallback);
941 }
942
943
944
945
946 @Override
947 public <V extends Enum<?>> void showView(final V viewType, final Callback<Boolean> onReadyCallback) {
948 Callback<Boolean> finalizeView = new Callback<Boolean>(){
949
950 public void exec(Boolean result) {
951
952
953 for(HasCrossConstraints crossConstraint:Application.getApplicationContext().getCrossConstraints(null)){
954 crossConstraint.reprocessWithUpdatedConstraints();
955 }
956
957
958
959 if (viewType == CourseSections.SUMMARY){
960
961 KSBlockingProgressIndicator.addTask(initializingTask);
962
963 courseServiceAsync.validate(cluProposalModel.getRoot(), new KSAsyncCallback<List<ValidationResultInfo>>(){
964
965 @Override
966 public void onSuccess(List<ValidationResultInfo> result) {
967
968 Application.getApplicationContext().clearValidationWarnings();
969 Application.getApplicationContext().addValidationWarnings(result);
970
971 showWarnings();
972
973 KSBlockingProgressIndicator.removeTask(initializingTask);
974 }
975 });
976 } else {
977
978 showWarnings();
979 }
980
981 onReadyCallback.exec(result);
982 }
983 };
984
985 super.showView(viewType, finalizeView);
986 }
987
988
989 @Override
990 public void showDefaultView(Callback<Boolean> onReadyCallback) {
991 if(isNew){
992 super.showFirstView(onReadyCallback);
993 }
994 else{
995 super.showDefaultView(onReadyCallback);
996 }
997 }
998
999 @Override
1000 public void setParentController(Controller controller) {
1001 super.setParentController(controller);
1002 }
1003
1004 @Override
1005
1006
1007
1008
1009
1010 public void checkAuthorization(final AuthorizationCallback authCallback) {
1011 GWT.log("Attempting Auth Check.", null);
1012
1013
1014 Map<String,String> attributes = new HashMap<String,String>();
1015 addPermissionAttributes(attributes);
1016
1017
1018
1019
1020 cluProposalRpcServiceAsync.isAuthorized(getViewContext().getPermissionType(), attributes, new KSAsyncCallback<Boolean>(){
1021
1022 @Override
1023 public void handleFailure(Throwable caught) {
1024 authCallback.isNotAuthorized("Error checking authorization.");
1025 GWT.log("Error checking proposal authorization.", caught);
1026 Window.alert("Error Checking Proposal Authorization: "+caught.getMessage());
1027 }
1028
1029 @Override
1030 public void onSuccess(Boolean result) {
1031 GWT.log("Succeeded checking auth for permission type '" + getViewContext().getPermissionType().toString() + "' with result: " + result, null);
1032 if (Boolean.TRUE.equals(result)) {
1033 authCallback.isAuthorized();
1034 }
1035 else {
1036 authCallback.isNotAuthorized("User is not authorized: " + getViewContext().getPermissionType().toString());
1037 }
1038 }
1039 });
1040 }
1041
1042 @Override
1043 public void setViewContext(ViewContext viewContext) {
1044
1045
1046
1047
1048
1049
1050 if (viewContext.getId() != null && !viewContext.getId().isEmpty()) {
1051 if (viewContext.getIdType() != IdType.COPY_OF_OBJECT_ID
1052 && viewContext.getIdType() != IdType.COPY_OF_KS_KEW_OBJECT_ID) {
1053
1054 viewContext.setPermissionType(PermissionType.OPEN);
1055 } else {
1056
1057 viewContext.setPermissionType(PermissionType.INITIATE);
1058 }
1059 } else {
1060
1061 viewContext.setPermissionType(PermissionType.INITIATE);
1062 }
1063
1064 context = viewContext;
1065 }
1066
1067
1068
1069
1070 public void addPermissionAttributes(Map<String, String> attributes){
1071 ViewContext viewContext = getViewContext();
1072
1073
1074
1075 if ((viewContext.getId() != null) && (!"".equals(viewContext.getId()))) {
1076 attributes.put(viewContext.getIdType().toString(), viewContext.getId());
1077 }
1078
1079
1080 if (viewContext.getId() != null && !viewContext.getId().isEmpty()) {
1081 if (viewContext.getIdType() != IdType.COPY_OF_OBJECT_ID
1082 && viewContext.getIdType() != IdType.COPY_OF_KS_KEW_OBJECT_ID) {
1083
1084 attributes.put(StudentIdentityConstants.DOCUMENT_TYPE_NAME, CLUConstants.PROPOSAL_TYPE_COURSE_CREATE);
1085 }
1086
1087 else if (currentDocType.equals(CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY)) {
1088 attributes.put(StudentIdentityConstants.DOCUMENT_TYPE_NAME, CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY);
1089 } else if (currentDocType.equals(CLUConstants.PROPOSAL_TYPE_COURSE_RETIRE)) {
1090 attributes.put(StudentIdentityConstants.DOCUMENT_TYPE_NAME, CLUConstants.PROPOSAL_TYPE_COURSE_RETIRE);
1091 } else {
1092
1093 attributes.put(StudentIdentityConstants.DOCUMENT_TYPE_NAME, CLUConstants.PROPOSAL_TYPE_COURSE_CREATE);
1094 }
1095 }
1096 }
1097
1098 @Override
1099 public boolean isAuthorizationRequired() {
1100 return true;
1101 }
1102
1103 @Override
1104 public void setAuthorizationRequired(boolean required) {
1105 throw new UnsupportedOperationException();
1106 }
1107
1108 protected void setHeaderTitle(){
1109 String title;
1110 if (cluProposalModel.get(cfg.getProposalTitlePath()) != null){
1111 title = getProposalTitle();
1112 }
1113 else{
1114 title = "New Course (Proposal)";
1115 }
1116 this.setContentTitle(title);
1117 this.setName(title);
1118 WindowTitleUtils.setContextTitle(title);
1119 currentTitle = title;
1120 }
1121
1122 @Override
1123 public WorkflowUtilities getWfUtilities() {
1124 return workflowUtil;
1125 }
1126
1127 @Override
1128 public void beforeViewChange(final Enum<?> viewChangingTo, final Callback<Boolean> okToChange) {
1129
1130 final Callback<Boolean> reallyOkToChange = new Callback<Boolean>(){
1131 @Override
1132 public void exec(Boolean result) {
1133 if(result){
1134 if(CourseSections.GOVERNANCE.equals(viewChangingTo)){
1135 getView(CourseSections.COURSE_INFO, new Callback<View>(){
1136 @Override
1137 public void exec(final View view) {
1138 if(view!=null && view instanceof SectionView){
1139 requestModel(new ModelRequestCallback<DataModel>(){
1140 public void onModelReady(DataModel model) {
1141 ((SectionView)view).updateWidgetData(model);
1142 okToChange.exec(true);
1143 }
1144 public void onRequestFail(Throwable cause) {
1145 okToChange.exec(false);
1146 }
1147 });
1148 }else{
1149 okToChange.exec(true);
1150 }
1151 }});
1152 } else
1153 okToChange.exec(true);
1154 } else
1155 okToChange.exec(false);
1156 }
1157 };
1158
1159
1160
1161
1162
1163 super.beforeViewChange(viewChangingTo, new Callback<Boolean>(){
1164
1165 @Override
1166 public void exec(Boolean result) {
1167 if(result){
1168 if(getCurrentView() instanceof SectionView && ((SectionView)getCurrentView()).isDirty()){
1169 ButtonGroup<YesNoCancelEnum> buttonGroup = new YesNoCancelGroup();
1170 final ButtonMessageDialog<YesNoCancelEnum> dialog = new ButtonMessageDialog<YesNoCancelEnum>("Warning", "You may have unsaved changes. Save changes?", buttonGroup);
1171 buttonGroup.addCallback(new Callback<YesNoCancelEnum>(){
1172
1173 @Override
1174 public void exec(YesNoCancelEnum result) {
1175 switch(result){
1176 case YES:
1177 dialog.hide();
1178 final SaveActionEvent e = new SaveActionEvent();
1179 e.setActionCompleteCallback(new ActionCompleteCallback(){
1180
1181 @Override
1182 public void onActionComplete(ActionEvent action) {
1183 if(e.isSaveSuccessful()){
1184 reallyOkToChange.exec(true);
1185 }
1186 else{
1187 reallyOkToChange.exec(false);
1188 }
1189 }
1190
1191 });
1192 fireApplicationEvent(e);
1193 break;
1194 case NO:
1195
1196 getCurrentModel(new ModelRequestCallback<DataModel>(){
1197
1198 @Override
1199 public void onModelReady(DataModel model) {
1200 if (getCurrentView()instanceof Section){
1201 ((Section) getCurrentView()).resetFieldInteractionFlags();
1202 }
1203 reallyOkToChange.exec(true);
1204 dialog.hide();
1205 }
1206
1207 @Override
1208 public void onRequestFail(Throwable cause) {
1209
1210
1211 reallyOkToChange.exec(false);
1212 dialog.hide();
1213 GWT.log("Unable to retrieve model for data restore on view change with no save", cause);
1214 }},
1215 NO_OP_CALLBACK);
1216
1217 break;
1218 case CANCEL:
1219 reallyOkToChange.exec(false);
1220 dialog.hide();
1221
1222 HistoryManager.logHistoryChange();
1223 break;
1224 }
1225 }
1226 });
1227 dialog.addCloseLinkClickHandler(new ClickHandler() {
1228
1229 @Override
1230 public void onClick(ClickEvent event) {
1231 okToChange.exec(false);
1232 dialog.hide();
1233
1234 HistoryManager.logHistoryChange();
1235 }
1236 });
1237 dialog.show();
1238 }
1239 else{
1240 reallyOkToChange.exec(true);
1241 }
1242 }
1243 else{
1244 reallyOkToChange.exec(false);
1245 }
1246 }
1247 });
1248 }
1249
1250 public KSButton getSaveButton(){
1251 if(currentDocType != CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY && currentDocType != CLUConstants.PROPOSAL_TYPE_COURSE_MODIFY_ADMIN){
1252 return new KSButton("Save and Continue", new ClickHandler(){
1253 public void onClick(ClickEvent event) {
1254 CourseProposalController.this.fireApplicationEvent(new SaveActionEvent(true));
1255 }
1256 });
1257 }
1258 else{
1259 return new KSButton("Save", new ClickHandler(){
1260 public void onClick(ClickEvent event) {
1261 CourseProposalController.this.fireApplicationEvent(new SaveActionEvent(false));
1262 }
1263 });
1264 }
1265 }
1266
1267 public KSButton getCancelButton(final Enum<?> summaryView){
1268
1269 return new KSButton("Cancel", ButtonStyle.ANCHOR_LARGE_CENTERED, new ClickHandler(){
1270 public void onClick(ClickEvent event) {
1271 if(!isNew){
1272 CourseProposalController.this.showView(summaryView);
1273 }
1274 else{
1275 Application.navigate(AppLocations.Locations.CURRICULUM_MANAGEMENT.getLocation());
1276 }
1277 }
1278 });
1279
1280 }
1281
1282 @Override
1283 public void onHistoryEvent(String historyStack) {
1284 super.onHistoryEvent(historyStack);
1285
1286
1287 if(cluProposalModel.get(cfg.getProposalTitlePath()) != null &&
1288 this.getViewContext().getIdType() != IdType.COPY_OF_OBJECT_ID){
1289 RecentlyViewedHelper.addCurrentDocument(getProposalTitle());
1290 }
1291 }
1292
1293 private String getProposalTitle(){
1294 StringBuffer sb = new StringBuffer();
1295 sb.append(cluProposalModel.get(cfg.getProposalTitlePath()));
1296 sb.append(" (Proposal)");
1297 return sb.toString();
1298 }
1299
1300 public String getCourseId(){
1301 return cluProposalModel.<String>get("id");
1302 }
1303
1304 public String getCourseState(){
1305 return cluProposalModel.<String>get("stateKey");
1306 }
1307
1308 public boolean isNew() {
1309 return isNew;
1310 }
1311
1312 public CourseRequirementsDataModel getReqDataModel() {
1313 return reqDataModel;
1314 }
1315
1316 public CourseRequirementsDataModel getReqDataModelComp() {
1317 return reqDataModelComp;
1318 }
1319
1320 @Override
1321 public DataModel getExportDataModel() {
1322 return cluProposalModel;
1323 }
1324
1325
1326
1327
1328
1329 @Override
1330 public String getExportTemplateName() {
1331 if (CLUConstants.PROPOSAL_TYPE_COURSE_CREATE.equals(currentDocType)){
1332 return "base.template";
1333 }
1334 return "proposal.template";
1335 }
1336
1337 @Override
1338 public List<ExportElement> getExportElementsFromView() {
1339 List<ExportElement> exportElements = new ArrayList<ExportElement>();
1340 if (this.getCurrentViewEnum().equals(CourseSections.SUMMARY)) {
1341 SummaryTableSection tableSection = this.cfg.getSummaryConfigurer().getTableSection();
1342 ExportElement heading = GWT.create(ExportElement.class);
1343 heading.setFieldLabel("");
1344 heading.setFieldValue(cluProposalModel.getModelName());
1345 heading.setFieldValue2(comparisonModel.getModelName());
1346 exportElements.add(heading);
1347 exportElements.addAll(ExportUtils.getDetailsForWidget(tableSection.getSummaryTable()));
1348 }
1349 return exportElements;
1350 }
1351
1352 @Override
1353 public boolean isExportButtonActive() {
1354 if (this.getCurrentViewEnum() != null && this.getCurrentViewEnum().equals(CourseSections.SUMMARY)) {
1355 return true;
1356 } else {
1357 return false;
1358 }
1359
1360 }
1361
1362
1363
1364
1365
1366
1367 protected String getStateforSaveAction(DataModel model){
1368
1369 String state = (String)model.get(CreditCourseConstants.STATE);
1370
1371
1372
1373 if (state == null){
1374 state = cfg.getState();
1375 }
1376
1377 return state;
1378 }
1379
1380 public String getMessage(String courseMessageKey) {
1381 String msg = Application.getApplicationContext().getMessage(MSG_GROUP, courseMessageKey);
1382 if (msg == null) {
1383 msg = courseMessageKey;
1384 }
1385 return msg;
1386 }
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397 protected BaseDataOrchestrationRpcServiceAsync getCourseProposalRpcService(){
1398 return cluProposalRpcServiceAsync;
1399 }
1400
1401 public CourseProposalConfigurer getCourseProposalConfigurer() {
1402 return cfg;
1403 }
1404 }