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.common.ui.client.configurable.mvc;
 
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
 import org.kuali.student.common.ui.client.application.Application;
 import org.kuali.student.common.ui.client.configurable.mvc.layouts.MenuSectionController;
 import org.kuali.student.common.ui.client.configurable.mvc.layouts.TabMenuController;
 import org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController;
 import org.kuali.student.common.ui.client.configurable.mvc.sections.Section;
 import org.kuali.student.common.ui.client.configurable.mvc.views.SectionView;
 import org.kuali.student.common.ui.client.event.ActionEvent;
 import org.kuali.student.common.ui.client.event.SaveActionEvent;
 import org.kuali.student.common.ui.client.event.SectionUpdateEvent;
 import org.kuali.student.common.ui.client.event.SectionUpdateHandler;
 import org.kuali.student.common.ui.client.event.ValidateRequestEvent;
 import org.kuali.student.common.ui.client.event.ValidateRequestHandler;
 import org.kuali.student.common.ui.client.mvc.ActionCompleteCallback;
 import org.kuali.student.common.ui.client.mvc.Callback;
 import org.kuali.student.common.ui.client.mvc.Controller;
 import org.kuali.student.common.ui.client.mvc.DataModel;
 import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;
 import org.kuali.student.common.ui.client.mvc.View;
 import org.kuali.student.common.ui.client.mvc.history.HistoryManager;
 import org.kuali.student.common.ui.client.widgets.KSButton;
 import org.kuali.student.common.ui.client.widgets.KSLightBox;
 import org.kuali.student.common.ui.client.widgets.field.layout.element.FieldElement;
 import org.kuali.student.common.validation.dto.ValidationResultInfo;
 import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
 
 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.ui.FlowPanel;
 import com.google.gwt.user.client.ui.Widget;
 
 /**
  * The LayoutController is a central piece of the UIF.  This controller is also itself a view.
  * As such, LayoutControllers can also have other LayoutControllers as their views.  
  * 
  * @see Controller
  * @author Kuali Student Team
  *
  */
 public abstract class LayoutController extends Controller implements ViewLayoutController, View {
 
         protected Map<Enum<?>, View> viewMap = new LinkedHashMap<Enum<?>, View>();
         protected Map<String, Enum<?>> viewEnumMap = new HashMap<String, Enum<?>>();
         protected Enum<?> defaultView;
         
         protected String name;
         protected Enum<?> viewType;
 
     protected View startPopupView;
     protected KSLightBox startViewWindow;
         
     /**
      * Constructor
      * Sets up event handlers fro section update events and validation request events.
      */
     public LayoutController(){
         super();
         //Global section update Event handling
                 addApplicationEventHandler(SectionUpdateEvent.TYPE, new SectionUpdateHandler(){
 
                         @Override
                         public void onSectionUpdate(final SectionUpdateEvent event) {
                                 LayoutController.this.requestModel(new ModelRequestCallback<DataModel>(){
 
                                         @Override
                                         public void onRequestFail(Throwable cause) {
                                                 GWT.log("Unable to retrieve model for section update", cause);
                                         }
 
                                         @Override
                                         public void onModelReady(DataModel model) {
                                                 event.getSection().updateModel(model);
                                                 event.getSection().updateWidgetData(model);
                                                 
                                         }
                                 });
                                 
                         }
                 });
                 //Global validation Event handling
         addApplicationEventHandler(ValidateRequestEvent.TYPE, new ValidateRequestHandler() {
 
             @Override
             public void onValidateRequest(final ValidateRequestEvent event) {
                     FieldDescriptor originatingField = event.getFieldDescriptor();
                     String modelId = null;
                     if (originatingField != null) {
                             modelId = originatingField.getModelId();
                     }
                     if (modelId == null) {
                             requestModel(new ModelRequestCallback<DataModel>() {
                                     @Override
                                     public void onModelReady(DataModel model) {
                                             validate(model, event);
                                     }
 
                                     @Override
                                     public void onRequestFail(Throwable cause) {
                                             GWT.log("Unable to retrieve model for validation", cause);
                                     }
 
                             });
                     } else {
                             requestModel(modelId, new ModelRequestCallback<DataModel>() {
                                     @Override
                                     public void onModelReady(DataModel model) {
                                             validate(model, event);
                                     }
 
                                     @Override
                                     public void onRequestFail(Throwable cause) {
                                             GWT.log("Unable to retrieve model for validation", cause);
                                     }
 
                             });
                     }
             }
 
         });
     }
     
     private void validate(DataModel model, final ValidateRequestEvent event) {
             if(event.validateSingleField()){
                     model.validateField(event.getFieldDescriptor(), new Callback<List<ValidationResultInfo>>() {
                 @Override
                 public void exec(List<ValidationResultInfo> result) {
                         if(event.getFieldDescriptor() != null){
                                 //We dont need to traverse since it is single field, so don't do isValid call here
                                 //instead add the error messages directly
                                 FieldElement element = event.getFieldDescriptor().getFieldElement();
                                 if(element != null){
                                         element.clearValidationErrors();
                                         for(int i = 0; i < result.size(); i++){
                                             ValidationResultInfo vr = result.get(i);
                                             if(vr.getElement().equals(event.getFieldDescriptor().getFieldKey()) 
                                                             && event.getFieldDescriptor().hasHadFocus()){
                                                                     element.processValidationResult(vr);
                                             }
                                     }
                                 }
                         }
                         
                 }
                     });
             }
             else{
             model.validate(new Callback<List<ValidationResultInfo>>() {
                 @Override
                 public void exec(List<ValidationResultInfo> result) {
                     isValid(result, false, true);
                 }
             });
             }
     }
     
     /**
      * Check to see if the list of validation results have an error.
      * @param list
      * @return
      */
     public ErrorLevel checkForErrors(List<ValidationResultInfo> list){
                 ErrorLevel errorLevel = ErrorLevel.OK;
                 
                 for(ValidationResultInfo vr: list){
                         if(vr.getErrorLevel().getLevel() > errorLevel.getLevel()){
                                 errorLevel = vr.getErrorLevel();
                         }
                         if(errorLevel.equals(ErrorLevel.ERROR)){
                                 break;
                         }
                 }
             
             return errorLevel;
             
     }
     
     /**
      * Finds the first parent LayoutController of this LayoutController, returns null if this
      * is the top level LayoutController.
      * @param w
      * @return
      */
     public static LayoutController findParentLayout(Widget w){
         LayoutController result = null;
         while (true) {
             if (w == null) {
                 break;
             } else if (w instanceof HasLayoutController) {
                     result = ((HasLayoutController)w).getLayoutController();
                     if (result != null) {
                             break;
                     }
             } else if (w instanceof LayoutController) {
                 result = (LayoutController) w;
                 break;
             }
             w = w.getParent();
             
         }
         return result;
     }
     
         /**
          * @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addStartViewPopup(org.kuali.student.common.ui.client.mvc.View)
          */
         public void addStartViewPopup(final View view){
             startPopupView = view;
             if(startViewWindow == null){
                     startViewWindow = new KSLightBox();
             }
 
             FlowPanel panel = new FlowPanel();
             panel.add(view.asWidget());
             KSButton save = new KSButton("Save",new ClickHandler(){
             public void onClick(ClickEvent event) {
                 view.updateModel();
                 SaveActionEvent saveActionEvent = new SaveActionEvent(true);
 
                 saveActionEvent.setActionCompleteCallback(new ActionCompleteCallback(){
                     public void onActionComplete(ActionEvent action) {
                         startViewWindow.hide();
                     }
                 });
                 
 
                 fireApplicationEvent(saveActionEvent);
             }
             });
             startViewWindow.addButton(save);
             
             KSButton cancel = new KSButton("Cancel", new ClickHandler(){
             public void onClick(ClickEvent event) {
                 startViewWindow.hide();
             }
             });
             startViewWindow.addButton(cancel);
 
             if(view instanceof SectionView){
                     ((SectionView) view).setController(this);
             }
             startViewWindow.setWidget(panel);
         }
         
     /**
      * @return true if the start popup is showing
      */
     public boolean isStartViewShowing(){
         if(startViewWindow == null){
             return false;
         }
             return startViewWindow.isShowing();
     }
 
     public View getStartPopupView(){
         return startPopupView;
     }
     
     public void showStartPopup(final Callback<Boolean> onReadyCallback){
         startPopupView.beforeShow(new Callback<Boolean>() {
                         @Override
                         public void exec(Boolean result) {
                                 if (result) {
                                         startViewWindow.show();
                                 }
                                 onReadyCallback.exec(result);
                         }
         });
     }
     
     public KSLightBox getStartPopup(){
         return startViewWindow;
     }
 
 
     /*New methods*/
         
         /**
          * @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addView(org.kuali.student.common.ui.client.mvc.View)
          */
         public void addView(View view){
                 viewMap.put(view.getViewEnum(), view);
                 viewEnumMap.put(view.getViewEnum().toString(), view.getViewEnum());
                 if(view instanceof SectionView){
                         ((SectionView) view).setController(this);
                 }
                 else if(view instanceof ToolView){
                         ((ToolView) view).setController(this);
                 }
         }
         
         /**
          * @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#setDefaultView(java.lang.Enum)
          */
         public <V extends Enum<?>> void setDefaultView(V viewType){
                 this.defaultView = viewType;
         }
         
         public Enum<?> getDefaultView(){
                 return this.defaultView;
         }
         
         /**
          * @see org.kuali.student.common.ui.client.mvc.View#updateModel()
          */
         public abstract void updateModel();
         
         /**
          * Update the model with a single views information
          * @param viewType
          */
         public void updateModelFromView(Enum<?> viewType){
                 View v = viewMap.get(viewType);
                 if(v != null){
                         v.updateModel();
                 }
         }
         
         /**
          * Update a the model from the view that is currently being shown by this controller
          */
         public void updateModelFromCurrentView(){
         if(this.getCurrentView() != null){
                     this.getCurrentView().updateModel();
         }
         }
 
         @Override
         public <V extends Enum<?>> void getView(V viewType, Callback<View> callback) {
                 callback.exec(viewMap.get(viewType));
         }
 
         @Override
         public Enum<?> getViewEnumValue(String enumValue) {
                 return viewEnumMap.get(enumValue);
         }
 
         @Override
         public void showDefaultView(final Callback<Boolean> onReadyCallback) {
                 HistoryManager.setLogNavigationHistory(false);
                 //turn of history support for default showing until view is ready
                 if(defaultView != null){
                         showView(defaultView, onReadyCallback);
                 }
                 else if(!viewMap.isEmpty()){                
                         if(defaultView == null){
                                 showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
                         }        
                 }
                 
         }
         
         /**
          * Show the view that was the first one added and will likely be the first one in a layout's menu, for
          * example.  Note that this is different than show default view.
          * 
          * @param onReadyCallback
          */
         public void showFirstView(Callback<Boolean> onReadyCallback){
                 HistoryManager.setLogNavigationHistory(false);
                 if(!viewMap.isEmpty()){        
                         showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
                 }
                 else{
                         showDefaultView(onReadyCallback);
                 }
         }
         
         /**
           * Check to see if current/all section(s) is valid (ie. does not contain any errors) - also displays
           * them in the ui if possible
           *
          * @param validationResults List of validation results for the layouts model.
          * @param checkCurrentSectionOnly true if errors should be checked on current section only, false if all sections should be checked
          * @return true if the specified sections (all or current) has any validation errors
          */
         public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly){
                 return isValid(validationResults, checkCurrentSectionOnly, true);
         }
         
         /**
          * @see LayoutController#isValid(List, boolean)
          * @param validationResults
          * @param checkCurrentSectionOnly
          * @param allFields
          * @return
          */
         public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly, boolean allFields){
                 
                 boolean isValid = true;
 
                 if (checkCurrentSectionOnly){
                         //Check for validation errors on the currently displayed section only
                     View v = getCurrentView();
                 if(v instanceof Section){
                         isValid = isValid(validationResults, (Section)v, allFields);
                     }
                      if(this.isStartViewShowing()){
                              if(startPopupView instanceof Section){
                                      isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
                              }
                      }
                 } else {
                         //Check for validation errors on all sections
                         String errorSections = "";
                         StringBuilder errorSectionsbuffer = new StringBuilder();
                         errorSectionsbuffer.append(errorSections);
                         for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
                                 View v = entry.getValue();
                                 if (v instanceof Section){
                                         if (!isValid(validationResults, (Section)v, allFields)){
                                                 isValid = false;
                                                 errorSectionsbuffer.append(((SectionView)v).getName() + ", ");
                                         }
                                 }
                         }
                      if(this.isStartViewShowing()){
                              if(startPopupView instanceof Section){
                                      isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
                              }
                      }
                         errorSections = errorSectionsbuffer.toString();
                         if (!errorSections.isEmpty()){
                                 errorSections = errorSections.substring(0, errorSections.length()-2);
                                 //container.addMessage("Following section(s) has errors & must be corrected: " + errorSections);
                         }
                 }
 
                 return isValid;
         }
 
         private boolean isValid(List<ValidationResultInfo> validationResults, Section section, boolean allFields){                
                 ErrorLevel status;
                 if(allFields){
                         section.setFieldHasHadFocusFlags(true);
                         status = section.processValidationResults(validationResults);
                 }
                 else{
                         status = section.processValidationResults(validationResults, false);
                 }
 
                 return (status != ErrorLevel.ERROR);
         }
         
         /**
          * This clears all warnings that currently displayed on all fields and sections.
          */
         protected void clearAllWarnings(){
                 for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
                         View v = entry.getValue();
                         if (v instanceof Section){
                                 ((Section)v).clearValidationWarnings();
                         }
                 }
         }
         
         /**
          * This particular implementation of beforeViewChange checks to see if all its view contains a Controller
          * and if it does checks with that controller to see if it is ok to change the view.  OkToChange callback
          * will be exec with true if the view is allowed to be changed at this time.  This method can be overriden
          * to provide additional functionality to stop a view from being changed when there is some additional
          * processing that needs to occur in the ui before the view changes.
          * 
          * @see org.kuali.student.common.ui.client.mvc.Controller#beforeViewChange(java.lang.Enum, org.kuali.student.common.ui.client.mvc.Callback)
          */
         @Override
         public void beforeViewChange(Enum<?> viewChangingTo, Callback<Boolean> okToChange) {
             
             if(this.getCurrentView() instanceof Controller){
                         ((Controller)this.getCurrentView()).beforeViewChange(viewChangingTo, okToChange);
             }
                 else{
                         okToChange.exec(true);
                 }
             
             this.showExport(isExportButtonActive());
         }
 
         /**
          * Shows warnings stored to the application context
          */
         protected void showWarnings(){
                 clearAllWarnings();                
                 if (!Application.getApplicationContext().getValidationWarnings().isEmpty()){
                         isValid(Application.getApplicationContext().getValidationWarnings(), true);
             }                                
         }
         
         @Override
         public Widget asWidget() {
                 return this;
         }
 
         @Override
         public boolean beforeHide() {
                 return true;
         }
 
         /**
          * Default implementation does nothing on before show.  Override to do other things before THIS view is
          * shown.
          * @see org.kuali.student.common.ui.client.mvc.View#beforeShow(org.kuali.student.common.ui.client.mvc.Callback)
          */
         @Override
         public void beforeShow(Callback<Boolean> onReadyCallback) {
                 onReadyCallback.exec(true);
         }
 
         @Override
         public Controller getController() {
                 return parentController;
         }
 
         @Override
         public String getName() {
                 if(name == null && viewType != null){
                         return viewType.toString();
                 }
                 else{
                         return name;
                 }
         }
 
         @Override
         public Enum<?> getViewEnum() {
                 return viewType;
         }
         
         public void setViewEnum(Enum<?> viewType){
                 this.viewType= viewType;
         }
         
         /**
          * Sets the name of this LayoutController.  This name is used in the breadcrumb and window's title.
          * Setting the name to the empty string will omit the breadcrumb - this is sometimes desired.
          * @param name
          */
         public void setName(String name){
                 this.name = name;
         }
         
         public void setController(Controller controller){
                 parentController = controller;
         }
         
         @Override
         public void collectBreadcrumbNames(List<String> names) {
                 names.add(this.getName());
                 if(this.getCurrentView() != null){
                         this.getCurrentView().collectBreadcrumbNames(names);
                 }
         }
         
         @Override
         public void clear() {
                 
         }
 
         public boolean isExportButtonActive() {
             return false;
         }
 
         @Override
         public void showExport(boolean show) {
                 // TODO Auto-generated method stub
                 
         }
 }

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
16		package org.kuali.student.common.ui.client.configurable.mvc;
17
18		import java.util.HashMap;
19		import java.util.LinkedHashMap;
20		import java.util.List;
21		import java.util.Map;
22		import java.util.Map.Entry;
23
24		import org.kuali.student.common.ui.client.application.Application;
25		import org.kuali.student.common.ui.client.configurable.mvc.layouts.MenuSectionController;
26		import org.kuali.student.common.ui.client.configurable.mvc.layouts.TabMenuController;
27		import org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController;
28		import org.kuali.student.common.ui.client.configurable.mvc.sections.Section;
29		import org.kuali.student.common.ui.client.configurable.mvc.views.SectionView;
30		import org.kuali.student.common.ui.client.event.ActionEvent;
31		import org.kuali.student.common.ui.client.event.SaveActionEvent;
32		import org.kuali.student.common.ui.client.event.SectionUpdateEvent;
33		import org.kuali.student.common.ui.client.event.SectionUpdateHandler;
34		import org.kuali.student.common.ui.client.event.ValidateRequestEvent;
35		import org.kuali.student.common.ui.client.event.ValidateRequestHandler;
36		import org.kuali.student.common.ui.client.mvc.ActionCompleteCallback;
37		import org.kuali.student.common.ui.client.mvc.Callback;
38		import org.kuali.student.common.ui.client.mvc.Controller;
39		import org.kuali.student.common.ui.client.mvc.DataModel;
40		import org.kuali.student.common.ui.client.mvc.ModelRequestCallback;
41		import org.kuali.student.common.ui.client.mvc.View;
42		import org.kuali.student.common.ui.client.mvc.history.HistoryManager;
43		import org.kuali.student.common.ui.client.widgets.KSButton;
44		import org.kuali.student.common.ui.client.widgets.KSLightBox;
45		import org.kuali.student.common.ui.client.widgets.field.layout.element.FieldElement;
46		import org.kuali.student.common.validation.dto.ValidationResultInfo;
47		import org.kuali.student.common.validation.dto.ValidationResultInfo.ErrorLevel;
48
49		import com.google.gwt.core.client.GWT;
50		import com.google.gwt.event.dom.client.ClickEvent;
51		import com.google.gwt.event.dom.client.ClickHandler;
52		import com.google.gwt.user.client.ui.FlowPanel;
53		import com.google.gwt.user.client.ui.Widget;
54
55		/**
56		* The LayoutController is a central piece of the UIF. This controller is also itself a view.
57		* As such, LayoutControllers can also have other LayoutControllers as their views.
58		*
59		* @see Controller
60		* @author Kuali Student Team
61		*
62		*/
63	0	public abstract class LayoutController extends Controller implements ViewLayoutController, View {
64
65	0	protected Map<Enum<?>, View> viewMap = new LinkedHashMap<Enum<?>, View>();
66	0	protected Map<String, Enum<?>> viewEnumMap = new HashMap<String, Enum<?>>();
67		protected Enum<?> defaultView;
68
69		protected String name;
70		protected Enum<?> viewType;
71
72		protected View startPopupView;
73		protected KSLightBox startViewWindow;
74
75		/**
76		* Constructor
77		* Sets up event handlers fro section update events and validation request events.
78		*/
79		public LayoutController(){
80	0	super();
81		//Global section update Event handling
82	0	addApplicationEventHandler(SectionUpdateEvent.TYPE, new SectionUpdateHandler(){
83
84		@Override
85		public void onSectionUpdate(final SectionUpdateEvent event) {
86	0	LayoutController.this.requestModel(new ModelRequestCallback<DataModel>(){
87
88		@Override
89		public void onRequestFail(Throwable cause) {
90	0	GWT.log("Unable to retrieve model for section update", cause);
91	0	}
92
93		@Override
94		public void onModelReady(DataModel model) {
95	0	event.getSection().updateModel(model);
96	0	event.getSection().updateWidgetData(model);
97
98	0	}
99		});
100
101	0	}
102		});
103		//Global validation Event handling
104	0	addApplicationEventHandler(ValidateRequestEvent.TYPE, new ValidateRequestHandler() {
105
106		@Override
107		public void onValidateRequest(final ValidateRequestEvent event) {
108	0	FieldDescriptor originatingField = event.getFieldDescriptor();
109	0	String modelId = null;
110	0	if (originatingField != null) {
111	0	modelId = originatingField.getModelId();
112		}
113	0	if (modelId == null) {
114	0	requestModel(new ModelRequestCallback<DataModel>() {
115		@Override
116		public void onModelReady(DataModel model) {
117	0	validate(model, event);
118	0	}
119
120		@Override
121		public void onRequestFail(Throwable cause) {
122	0	GWT.log("Unable to retrieve model for validation", cause);
123	0	}
124
125		});
126		} else {
127	0	requestModel(modelId, new ModelRequestCallback<DataModel>() {
128		@Override
129		public void onModelReady(DataModel model) {
130	0	validate(model, event);
131	0	}
132
133		@Override
134		public void onRequestFail(Throwable cause) {
135	0	GWT.log("Unable to retrieve model for validation", cause);
136	0	}
137
138		});
139		}
140	0	}
141
142		});
143	0	}
144
145		private void validate(DataModel model, final ValidateRequestEvent event) {
146	0	if(event.validateSingleField()){
147	0	model.validateField(event.getFieldDescriptor(), new Callback<List<ValidationResultInfo>>() {
148		@Override
149		public void exec(List<ValidationResultInfo> result) {
150	0	if(event.getFieldDescriptor() != null){
151		//We dont need to traverse since it is single field, so don't do isValid call here
152		//instead add the error messages directly
153	0	FieldElement element = event.getFieldDescriptor().getFieldElement();
154	0	if(element != null){
155	0	element.clearValidationErrors();
156	0	for(int i = 0; i < result.size(); i++){
157	0	ValidationResultInfo vr = result.get(i);
158	0	if(vr.getElement().equals(event.getFieldDescriptor().getFieldKey())
159		&& event.getFieldDescriptor().hasHadFocus()){
160	0	element.processValidationResult(vr);
161		}
162		}
163		}
164		}
165
166	0	}
167		});
168		}
169		else{
170	0	model.validate(new Callback<List<ValidationResultInfo>>() {
171		@Override
172		public void exec(List<ValidationResultInfo> result) {
173	0	isValid(result, false, true);
174	0	}
175		});
176		}
177	0	}
178
179		/**
180		* Check to see if the list of validation results have an error.
181		* @param list
182		* @return
183		*/
184		public ErrorLevel checkForErrors(List<ValidationResultInfo> list){
185	0	ErrorLevel errorLevel = ErrorLevel.OK;
186
187	0	for(ValidationResultInfo vr: list){
188	0	if(vr.getErrorLevel().getLevel() > errorLevel.getLevel()){
189	0	errorLevel = vr.getErrorLevel();
190		}
191	0	if(errorLevel.equals(ErrorLevel.ERROR)){
192	0	break;
193		}
194		}
195
196	0	return errorLevel;
197
198		}
199
200		/**
201		* Finds the first parent LayoutController of this LayoutController, returns null if this
202		* is the top level LayoutController.
203		* @param w
204		* @return
205		*/
206		public static LayoutController findParentLayout(Widget w){
207	0	LayoutController result = null;
208		while (true) {
209	0	if (w == null) {
210	0	break;
211	0	} else if (w instanceof HasLayoutController) {
212	0	result = ((HasLayoutController)w).getLayoutController();
213	0	if (result != null) {
214	0	break;
215		}
216	0	} else if (w instanceof LayoutController) {
217	0	result = (LayoutController) w;
218	0	break;
219		}
220	0	w = w.getParent();
221
222		}
223	0	return result;
224		}
225
226		/**
227		* @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addStartViewPopup(org.kuali.student.common.ui.client.mvc.View)
228		*/
229		public void addStartViewPopup(final View view){
230	0	startPopupView = view;
231	0	if(startViewWindow == null){
232	0	startViewWindow = new KSLightBox();
233		}
234
235	0	FlowPanel panel = new FlowPanel();
236	0	panel.add(view.asWidget());
237	0	KSButton save = new KSButton("Save",new ClickHandler(){
238		public void onClick(ClickEvent event) {
239	0	view.updateModel();
240	0	SaveActionEvent saveActionEvent = new SaveActionEvent(true);
241
242	0	saveActionEvent.setActionCompleteCallback(new ActionCompleteCallback(){
243		public void onActionComplete(ActionEvent action) {
244	0	startViewWindow.hide();
245	0	}
246		});
247
248
249	0	fireApplicationEvent(saveActionEvent);
250	0	}
251		});
252	0	startViewWindow.addButton(save);
253
254	0	KSButton cancel = new KSButton("Cancel", new ClickHandler(){
255		public void onClick(ClickEvent event) {
256	0	startViewWindow.hide();
257	0	}
258		});
259	0	startViewWindow.addButton(cancel);
260
261	0	if(view instanceof SectionView){
262	0	((SectionView) view).setController(this);
263		}
264	0	startViewWindow.setWidget(panel);
265	0	}
266
267		/**
268		* @return true if the start popup is showing
269		*/
270		public boolean isStartViewShowing(){
271	0	if(startViewWindow == null){
272	0	return false;
273		}
274	0	return startViewWindow.isShowing();
275		}
276
277		public View getStartPopupView(){
278	0	return startPopupView;
279		}
280
281		public void showStartPopup(final Callback<Boolean> onReadyCallback){
282	0	startPopupView.beforeShow(new Callback<Boolean>() {
283		@Override
284		public void exec(Boolean result) {
285	0	if (result) {
286	0	startViewWindow.show();
287		}
288	0	onReadyCallback.exec(result);
289	0	}
290		});
291	0	}
292
293		public KSLightBox getStartPopup(){
294	0	return startViewWindow;
295		}
296
297
298		/New methods/
299
300		/**
301		* @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#addView(org.kuali.student.common.ui.client.mvc.View)
302		*/
303		public void addView(View view){
304	0	viewMap.put(view.getViewEnum(), view);
305	0	viewEnumMap.put(view.getViewEnum().toString(), view.getViewEnum());
306	0	if(view instanceof SectionView){
307	0	((SectionView) view).setController(this);
308		}
309	0	else if(view instanceof ToolView){
310	0	((ToolView) view).setController(this);
311		}
312	0	}
313
314		/**
315		* @see org.kuali.student.common.ui.client.configurable.mvc.layouts.ViewLayoutController#setDefaultView(java.lang.Enum)
316		*/
317		public <V extends Enum<?>> void setDefaultView(V viewType){
318	0	this.defaultView = viewType;
319	0	}
320
321		public Enum<?> getDefaultView(){
322	0	return this.defaultView;
323		}
324
325		/**
326		* @see org.kuali.student.common.ui.client.mvc.View#updateModel()
327		*/
328		public abstract void updateModel();
329
330		/**
331		* Update the model with a single views information
332		* @param viewType
333		*/
334		public void updateModelFromView(Enum<?> viewType){
335	0	View v = viewMap.get(viewType);
336	0	if(v != null){
337	0	v.updateModel();
338		}
339	0	}
340
341		/**
342		* Update a the model from the view that is currently being shown by this controller
343		*/
344		public void updateModelFromCurrentView(){
345	0	if(this.getCurrentView() != null){
346	0	this.getCurrentView().updateModel();
347		}
348	0	}
349
350		@Override
351		public <V extends Enum<?>> void getView(V viewType, Callback<View> callback) {
352	0	callback.exec(viewMap.get(viewType));
353	0	}
354
355		@Override
356		public Enum<?> getViewEnumValue(String enumValue) {
357	0	return viewEnumMap.get(enumValue);
358		}
359
360		@Override
361		public void showDefaultView(final Callback<Boolean> onReadyCallback) {
362	0	HistoryManager.setLogNavigationHistory(false);
363		//turn of history support for default showing until view is ready
364	0	if(defaultView != null){
365	0	showView(defaultView, onReadyCallback);
366		}
367	0	else if(!viewMap.isEmpty()){
368	0	if(defaultView == null){
369	0	showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
370		}
371		}
372
373	0	}
374
375		/**
376		* Show the view that was the first one added and will likely be the first one in a layout's menu, for
377		* example. Note that this is different than show default view.
378		*
379		* @param onReadyCallback
380		*/
381		public void showFirstView(Callback<Boolean> onReadyCallback){
382	0	HistoryManager.setLogNavigationHistory(false);
383	0	if(!viewMap.isEmpty()){
384	0	showView(viewMap.entrySet().iterator().next().getKey(), onReadyCallback);
385		}
386		else{
387	0	showDefaultView(onReadyCallback);
388		}
389	0	}
390
391		/**
392		* Check to see if current/all section(s) is valid (ie. does not contain any errors) - also displays
393		* them in the ui if possible
394		*
395		* @param validationResults List of validation results for the layouts model.
396		* @param checkCurrentSectionOnly true if errors should be checked on current section only, false if all sections should be checked
397		* @return true if the specified sections (all or current) has any validation errors
398		*/
399		public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly){
400	0	return isValid(validationResults, checkCurrentSectionOnly, true);
401		}
402
403		/**
404		* @see LayoutController#isValid(List, boolean)
405		* @param validationResults
406		* @param checkCurrentSectionOnly
407		* @param allFields
408		* @return
409		*/
410		public boolean isValid(List<ValidationResultInfo> validationResults, boolean checkCurrentSectionOnly, boolean allFields){
411
412	0	boolean isValid = true;
413
414	0	if (checkCurrentSectionOnly){
415		//Check for validation errors on the currently displayed section only
416	0	View v = getCurrentView();
417	0	if(v instanceof Section){
418	0	isValid = isValid(validationResults, (Section)v, allFields);
419		}
420	0	if(this.isStartViewShowing()){
421	0	if(startPopupView instanceof Section){
422	0	isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
423		}
424		}
425	0	} else {
426		//Check for validation errors on all sections
427	0	String errorSections = "";
428	0	StringBuilder errorSectionsbuffer = new StringBuilder();
429	0	errorSectionsbuffer.append(errorSections);
430	0	for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
431	0	View v = entry.getValue();
432	0	if (v instanceof Section){
433	0	if (!isValid(validationResults, (Section)v, allFields)){
434	0	isValid = false;
435	0	errorSectionsbuffer.append(((SectionView)v).getName() + ", ");
436		}
437		}
438	0	}
439	0	if(this.isStartViewShowing()){
440	0	if(startPopupView instanceof Section){
441	0	isValid = isValid(validationResults, ((Section) startPopupView), allFields) && isValid;
442		}
443		}
444	0	errorSections = errorSectionsbuffer.toString();
445	0	if (!errorSections.isEmpty()){
446	0	errorSections = errorSections.substring(0, errorSections.length()-2);
447		//container.addMessage("Following section(s) has errors & must be corrected: " + errorSections);
448		}
449		}
450
451	0	return isValid;
452		}
453
454		private boolean isValid(List<ValidationResultInfo> validationResults, Section section, boolean allFields){
455		ErrorLevel status;
456	0	if(allFields){
457	0	section.setFieldHasHadFocusFlags(true);
458	0	status = section.processValidationResults(validationResults);
459		}
460		else{
461	0	status = section.processValidationResults(validationResults, false);
462		}
463
464	0	return (status != ErrorLevel.ERROR);
465		}
466
467		/**
468		* This clears all warnings that currently displayed on all fields and sections.
469		*/
470		protected void clearAllWarnings(){
471	0	for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
472	0	View v = entry.getValue();
473	0	if (v instanceof Section){
474	0	((Section)v).clearValidationWarnings();
475		}
476	0	}
477	0	}
478
479		/**
480		* This particular implementation of beforeViewChange checks to see if all its view contains a Controller
481		* and if it does checks with that controller to see if it is ok to change the view. OkToChange callback
482		* will be exec with true if the view is allowed to be changed at this time. This method can be overriden
483		* to provide additional functionality to stop a view from being changed when there is some additional
484		* processing that needs to occur in the ui before the view changes.
485		*
486		* @see org.kuali.student.common.ui.client.mvc.Controller#beforeViewChange(java.lang.Enum, org.kuali.student.common.ui.client.mvc.Callback)
487		*/
488		@Override
489		public void beforeViewChange(Enum<?> viewChangingTo, Callback<Boolean> okToChange) {
490
491	0	if(this.getCurrentView() instanceof Controller){
492	0	((Controller)this.getCurrentView()).beforeViewChange(viewChangingTo, okToChange);
493		}
494		else{
495	0	okToChange.exec(true);
496		}
497
498	0	this.showExport(isExportButtonActive());
499	0	}
500
501		/**
502		* Shows warnings stored to the application context
503		*/
504		protected void showWarnings(){
505	0	clearAllWarnings();
506	0	if (!Application.getApplicationContext().getValidationWarnings().isEmpty()){
507	0	isValid(Application.getApplicationContext().getValidationWarnings(), true);
508		}
509	0	}
510
511		@Override
512		public Widget asWidget() {
513	0	return this;
514		}
515
516		@Override
517		public boolean beforeHide() {
518	0	return true;
519		}
520
521		/**
522		* Default implementation does nothing on before show. Override to do other things before THIS view is
523		* shown.
524		* @see org.kuali.student.common.ui.client.mvc.View#beforeShow(org.kuali.student.common.ui.client.mvc.Callback)
525		*/
526		@Override
527		public void beforeShow(Callback<Boolean> onReadyCallback) {
528	0	onReadyCallback.exec(true);
529	0	}
530
531		@Override
532		public Controller getController() {
533	0	return parentController;
534		}
535
536		@Override
537		public String getName() {
538	0	if(name == null && viewType != null){
539	0	return viewType.toString();
540		}
541		else{
542	0	return name;
543		}
544		}
545
546		@Override
547		public Enum<?> getViewEnum() {
548	0	return viewType;
549		}
550
551		public void setViewEnum(Enum<?> viewType){
552	0	this.viewType= viewType;
553	0	}
554
555		/**
556		* Sets the name of this LayoutController. This name is used in the breadcrumb and window's title.
557		* Setting the name to the empty string will omit the breadcrumb - this is sometimes desired.
558		* @param name
559		*/
560		public void setName(String name){
561	0	this.name = name;
562	0	}
563
564		public void setController(Controller controller){
565	0	parentController = controller;
566	0	}
567
568		@Override
569		public void collectBreadcrumbNames(List<String> names) {
570	0	names.add(this.getName());
571	0	if(this.getCurrentView() != null){
572	0	this.getCurrentView().collectBreadcrumbNames(names);
573		}
574	0	}
575
576		@Override
577		public void clear() {
578
579	0	}
580
581		public boolean isExportButtonActive() {
582	0	return false;
583		}
584
585		@Override
586		public void showExport(boolean show) {
587		// TODO Auto-generated method stub
588
589	0	}
590		}