Clover Coverage Report - KS Common 1.3.0-SNAPSHOT (Aggregated)
Coverage timestamp: Thu Apr 28 2011 06:00:36 EDT
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../../../img/srcFileCovDistChart0.png 0% of files have more coverage
162   638   95   3.86
84   373   0.59   42
42     2.26  
1    
 
  Controller       Line # 57 162 0% 95 288 0% 0.0
 
No Tests
 
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.mvc;
17   
18    import java.util.ArrayList;
19    import java.util.HashMap;
20    import java.util.Iterator;
21    import java.util.Map;
22   
23    import org.kuali.student.common.assembly.data.Data;
24    import org.kuali.student.common.rice.authorization.PermissionType;
25    import org.kuali.student.common.ui.client.application.KSAsyncCallback;
26    import org.kuali.student.common.ui.client.application.ViewContext;
27    import org.kuali.student.common.ui.client.configurable.mvc.LayoutController;
28    import org.kuali.student.common.ui.client.configurable.mvc.views.SectionView;
29    import org.kuali.student.common.ui.client.mvc.breadcrumb.BreadcrumbSupport;
30    import org.kuali.student.common.ui.client.mvc.history.HistoryManager;
31    import org.kuali.student.common.ui.client.mvc.history.HistorySupport;
32    import org.kuali.student.common.ui.client.mvc.history.NavigationEvent;
33    import org.kuali.student.common.ui.client.reporting.ReportExport;
34    import org.kuali.student.common.ui.client.security.AuthorizationCallback;
35    import org.kuali.student.common.ui.client.security.RequiresAuthorization;
36    import org.kuali.student.common.ui.client.service.GwtExportRpcService;
37    import org.kuali.student.common.ui.client.service.GwtExportRpcServiceAsync;
38    import org.kuali.student.common.ui.client.util.ExportElement;
39    import org.kuali.student.common.ui.client.util.ExportUtils;
40    import org.kuali.student.common.ui.client.widgets.progress.BlockingTask;
41    import org.kuali.student.common.ui.client.widgets.progress.KSBlockingProgressIndicator;
42   
43    import com.google.gwt.core.client.GWT;
44    import com.google.gwt.event.shared.GwtEvent.Type;
45    import com.google.gwt.event.shared.HandlerManager;
46    import com.google.gwt.event.shared.HandlerRegistration;
47    import com.google.gwt.user.client.Window;
48    import com.google.gwt.user.client.ui.Composite;
49    import com.google.gwt.user.client.ui.Widget;
50   
51    /**
52    * Abstract Controller composite. Provides basic controller operations, and defines abstract methods that a composite must
53    * implement in order to be a controller.
54    *
55    * @author Kuali Student Team
56    */
 
57    public abstract class Controller extends Composite implements HistorySupport, BreadcrumbSupport, ReportExport{
58    public static final Callback<Boolean> NO_OP_CALLBACK = new Callback<Boolean>() {
 
59  0 toggle @Override
60    public void exec(Boolean result) {
61    // do nothing
62    }
63    };
64   
65    // TODO Nina how do you do loggin in GWT?
66    // final static Logger logger = Logger.getLogger(Controller.class);
67    protected Controller parentController = null;
68    private View currentView = null;
69    private Enum<?> currentViewEnum = null;
70    private String defaultModelId = null;
71    protected ViewContext context = new ViewContext();
72    private final Map<String, ModelProvider<? extends Model>> models = new HashMap<String, ModelProvider<? extends Model>>();
73    private boolean fireNavEvents = true;
74    private HandlerManager applicationEventHandlers = new HandlerManager(this);
75    private GwtExportRpcServiceAsync reportExportRpcService = GWT.create(GwtExportRpcService.class);
76   
 
77  0 toggle protected Controller() {
78    }
79   
80    /**
81    * Simple Version of showView, no callback
82    * @param <V>
83    * view enum type
84    * @param viewType
85    * enum value representing the view to show
86    */
 
87  0 toggle public <V extends Enum<?>> void showView(final V viewType){
88  0 this.showView(viewType, NO_OP_CALLBACK);
89    }
90   
91   
92   
93    /**
94    * Directs the controller to display the specified view. The parameter must be an enum value, based on an enum defined in
95    * the controller implementation. For example, a "Search" controller might have an enumeration of: <code>
96    * public enum SearchViews {
97    * SIMPLE_SEARCH,
98    * ADVANCED_SEARCH,
99    * SEARCH_RESULTS
100    * }
101    * </code> The implementing class must define a getView(V viewType) method that will cast the generic enum to the view
102    * specific enum.
103    *
104    * @param <V>
105    * view enum type
106    * @param viewType
107    * enum value representing the view to show
108    * @param onReadyCallback the callback to invoke when the method has completed execution
109    * @return false if the current view cancels the operation
110    */
 
111  0 toggle public <V extends Enum<?>> void showView(final V viewType, final Callback<Boolean> onReadyCallback) {
112  0 GWT.log("showView " + viewType.toString(), null);
113  0 getView(viewType, new Callback<View>(){
114   
 
115  0 toggle @Override
116    public void exec(View result) {
117  0 View view = result;
118  0 if (view == null) {
119  0 onReadyCallback.exec(false);
120    //throw new ControllerException("View not registered: " + viewType.toString());
121    }
122  0 beginShowView(view, viewType, onReadyCallback);
123   
124    }});
125    }
126   
 
127  0 toggle private <V extends Enum<?>> void beginShowView(final View view, final V viewType, final Callback<Boolean> onReadyCallback){
128  0 beforeViewChange(viewType, new Callback<Boolean>(){
129   
 
130  0 toggle @Override
131    public void exec(Boolean result) {
132  0 if(result){
133  0 boolean requiresAuthz = (view instanceof RequiresAuthorization) && ((RequiresAuthorization)view).isAuthorizationRequired();
134   
135  0 if (requiresAuthz){
136  0 ViewContext tempContext = new ViewContext();
137  0 if(view instanceof LayoutController){
138  0 tempContext = ((LayoutController) view).getViewContext();
139    }
140    else{
141  0 tempContext = view.getController().getViewContext();
142    }
143   
144  0 PermissionType permType = (tempContext != null) ? tempContext.getPermissionType() : null;
145  0 if (permType != null) {
146  0 GWT.log("Checking permission type '" + permType.getPermissionTemplateName() + "' for view '" + view.toString() + "'", null);
147    //A callback is required if async rpc call is required for authz check
148  0 ((RequiresAuthorization)view).checkAuthorization(permType, new AuthorizationCallback(){
 
149  0 toggle public void isAuthorized() {
150  0 finalizeShowView(view, viewType, onReadyCallback);
151    }
152   
 
153  0 toggle public void isNotAuthorized(String msg) {
154  0 Window.alert(msg);
155  0 onReadyCallback.exec(false);
156    }
157    });
158    }
159    else {
160  0 GWT.log("Cannot find PermissionType for view '" + view.toString() + "' which requires authorization", null);
161  0 finalizeShowView(view, viewType, onReadyCallback);
162    }
163    } else {
164  0 GWT.log("Not Requiring Auth.", null);
165  0 finalizeShowView(view, viewType, onReadyCallback);
166    }
167    }
168    else{
169  0 onReadyCallback.exec(false);
170    }
171   
172    }
173    });
174    }
175   
 
176  0 toggle private <V extends Enum<?>> void finalizeShowView(final View view, final V viewType, final Callback<Boolean> onReadyCallback){
177  0 if ((currentView == null) || currentView.beforeHide()) {
178  0 view.beforeShow(new Callback<Boolean>() {
 
179  0 toggle @Override
180    public void exec(Boolean result) {
181  0 if (!result) {
182  0 GWT.log("showView: beforeShow yielded false " + viewType, null);
183  0 onReadyCallback.exec(false);
184    } else {
185  0 if (currentView != null) {
186  0 hideView(currentView);
187    }
188   
189  0 currentViewEnum = viewType;
190  0 currentView = view;
191  0 GWT.log("renderView " + viewType.toString(), null);
192  0 if(fireNavEvents){
193  0 fireNavigationEvent();
194    }
195  0 renderView(view);
196  0 onReadyCallback.exec(true);
197   
198    }
199    }
200    });
201    } else {
202  0 onReadyCallback.exec(false);
203  0 GWT.log("Current view canceled hide action", null);
204    }
205    }
206   
 
207  0 toggle protected void fireNavigationEvent() {
208    //DeferredCommand.addCommand(new Command() {
209    // @Override
210    //public void execute() {
211  0 fireApplicationEvent(new NavigationEvent(Controller.this));
212    //}
213    //});
214    }
215   
216    /**
217    * Returns the currently displayed view
218    *
219    * @return the currently displayed view
220    */
 
221  0 toggle public View getCurrentView() {
222  0 return currentView;
223    }
224   
 
225  0 toggle public Enum<?> getCurrentViewEnum() {
226  0 return currentViewEnum;
227    }
228   
 
229  0 toggle public void setCurrentViewEnum(Enum<?> currentViewEnum) {
230  0 this.currentViewEnum = currentViewEnum;
231    }
232   
233    /**
234    * Sets the controller's parent controller. In most cases, this can be omitted as the controller will be automatically
235    * detected via the DOM in cases where it is not specified. The only time that the controller needs to be manually set is
236    * in cases where the logical controller hierarchy differs from the physical DOM hierarchy. For example, if a nested
237    * controller is rendered in a PopupPanel, then the parent controller must be set manually using this method
238    *
239    * @param controller
240    * the parent controller
241    */
 
242  0 toggle public void setParentController(Controller controller) {
243  0 parentController = controller;
244    }
245   
246    /**
247    * Returns the parent controller. If the current parent controller is not set, then the controller will attempt to
248    * automatically locate the parent controller via the DOM.
249    *
250    * @return
251    */
 
252  0 toggle public Controller getParentController() {
253  0 if (parentController == null) {
254  0 parentController = Controller.findController(this);
255    }
256  0 return parentController;
257    }
258   
259    /**
260    * Attempts to find the parent controller of a given widget via the DOM
261    *
262    * @param w
263    * the widget for which to find the parent controller
264    * @return the controller, or null if not found
265    */
 
266  0 toggle public static Controller findController(Widget w) {
267  0 Controller result = null;
268  0 while (true) {
269  0 w = w.getParent();
270  0 if (w == null) {
271  0 break;
272  0 } else if (w instanceof Controller) {
273  0 result = (Controller) w;
274  0 break;
275  0 } else if (w instanceof View) {
276    // this is in the event that a parent/child relationship is broken by a view being rendered in a lightbox,
277    // etc
278  0 result = ((View) w).getController();
279  0 break;
280    }
281    }
282  0 return result;
283    }
284   
285    /**
286    * Called by child views and controllers to request a model reference. By default it delegates calls to the parent
287    * controller if one is found. Override this method to declare a model local to the controller. Always make sure to
288    * delegate the call to the superclass if the requested type is not one which is defined locally. For example: <code>
289    *
290    * @Override
291    * @SuppressWarnings("unchecked") public void requestModel(Class<? extends Idable> modelType, ModelRequestCallback
292    * callback) { if (modelType.equals(Address.class)) { callback.onModelReady(addresses); }
293    * else { super.requestModel(modelType, callback); } } </code>
294    * @param modelType
295    * @param callback
296    */
 
297  0 toggle @SuppressWarnings("unchecked")
298    public void requestModel(final Class modelType, final ModelRequestCallback callback) {
299  0 requestModel((modelType == null) ? null : modelType.getName(), callback);
300    }
301   
 
302  0 toggle @SuppressWarnings("unchecked")
303    public void requestModel(final String modelId, final ModelRequestCallback callback) {
304  0 String id = (modelId == null) ? defaultModelId : modelId;
305   
306  0 ModelProvider<? extends Model> p = models.get(id);
307  0 if (p != null) {
308  0 p.requestModel(callback);
309  0 } else if (getParentController() != null) {
310  0 parentController.requestModel(modelId, callback);
311    } else {
312  0 if (callback != null) {
313  0 callback.onRequestFail(new RuntimeException("The requested model was not found: " + modelId));
314    }
315    }
316    }
317   
 
318  0 toggle @SuppressWarnings("unchecked")
319    public void requestModel(final ModelRequestCallback callback) {
320  0 requestModel((String)null, callback);
321    }
322   
 
323  0 toggle public <T extends Model> void registerModel(String modelId, ModelProvider<T> provider) {
324  0 models.put(modelId, provider);
325    }
326   
 
327  0 toggle public String getDefaultModelId() {
328  0 return defaultModelId;
329    }
 
330  0 toggle public void setDefaultModelId(String defaultModelId) {
331  0 this.defaultModelId = defaultModelId;
332    }
333   
334    /**
335    * Registers an application eventhandler. The controller will try to propagate "unchecked" handlers to the parent
336    * controller if a parent controller exists. This method can be overridden to handle unchecked locally if they are fired
337    * locally.
338    *
339    * @param type
340    * @param handler
341    * @return
342    */
 
343  0 toggle @SuppressWarnings("unchecked")
344    public HandlerRegistration addApplicationEventHandler(Type type, ApplicationEventHandler handler) {
345  0 if ((handler instanceof UncheckedApplicationEventHandler) && (getParentController() != null)) {
346  0 return parentController.addApplicationEventHandler(type, handler);
347    }
348  0 return applicationEventHandlers.addHandler(type, handler);
349    }
350   
351    /**
352    * Fires an application event.
353    *
354    * @param event
355    */
 
356  0 toggle @SuppressWarnings("unchecked")
357    public void fireApplicationEvent(ApplicationEvent event) {
358    // TODO this logic needs to be reworked a bit... if an unchecked event has been bound locally, do we want to still
359    // fire it externally as well?
360  0 if ((event instanceof UncheckedApplicationEvent) && (getParentController() != null)) {
361  0 parentController.fireApplicationEvent(event);
362    }
363    // dispatch to local "checked" handlers, and to any unchecked handlers that have been bound to local
364  0 applicationEventHandlers.fireEvent(event);
365   
366    }
367   
368    /**
369    * Must be implemented by the subclass to render the view.
370    *
371    * @param view
372    */
373    protected abstract void renderView(View view);
374   
375    /**
376    * Must be implemented by the subclass to hide the view.
377    *
378    * @param view
379    */
380    protected abstract void hideView(View view);
381   
382    /**
383    * Returns the view associated with the specified enum value. See showView(V viewType) above for a full description
384    *
385    * @param <V>
386    * @param viewType
387    * @return
388    */
389    protected abstract <V extends Enum<?>> void getView(V viewType, Callback<View> callback);
390   
391    /**
392    * If a controller which extends this class must perform some action or check before a view
393    * is changed, then override this method. Do not call super() in the override, as it will
394    * allow the view to continue to change.
395    * @param okToChangeCallback
396    */
 
397  0 toggle public void beforeViewChange(Enum<?> viewChangingTo, Callback<Boolean> okToChangeCallback) {
398  0 okToChangeCallback.exec(true);
399    }
400   
401    /**
402    * Shows the default view. Must be implemented by subclass, in order to define the default view.
403    */
404    public abstract void showDefaultView(Callback<Boolean> onReadyCallback);
405   
406    public abstract Enum<?> getViewEnumValue(String enumValue);
407   
408    /**
409    * This particular implementation appends to the history stack the name of the current view shown by
410    * this controller and view context (in string format) to that historyStack and passes the stack to
411    * be processed to the currentView.
412    * @see org.kuali.student.common.ui.client.mvc.history.HistorySupport#collectHistory(java.lang.String)
413    */
 
414  0 toggle @Override
415    public String collectHistory(String historyStack) {
416  0 String token = getHistoryToken();
417  0 historyStack = historyStack + "/" + token;
418   
419  0 if(currentView != null){
420  0 String tempHistoryStack = historyStack;
421  0 historyStack = currentView.collectHistory(historyStack);
422   
423    //Sanity check, if collectHistory returns null or empty string, restore
424  0 if(historyStack == null){
425  0 historyStack = tempHistoryStack;
426    }
427  0 else if(historyStack != null && historyStack.isEmpty()){
428  0 historyStack = tempHistoryStack;
429    }
430    }
431  0 return historyStack;
432    }
433   
 
434  0 toggle protected String getHistoryToken() {
435  0 String historyToken = "";
436  0 if (currentViewEnum != null) {
437  0 historyToken = currentViewEnum.toString();
438  0 if(currentView != null && currentView instanceof Controller
439    && ((Controller)currentView).getViewContext() != null){
440  0 ViewContext context = ((Controller) currentView).getViewContext();
441  0 historyToken = HistoryManager.appendContext(historyToken, context);
442    }
443   
444    }
445  0 return historyToken;
446    }
447   
448    /**
449    * The onHistoryEvent implementation in controller reads the history stack it receives and determines
450    * if the next token/view to be processed is a controller, if it is, it hands off the rest of the history stack
451    * to that controller after showing it. Otherwise, it shows the view
452    * and allows that view to perform any onHistoryEvent actions it may need to take.
453    * <br><br>For example the historyStack /HOME/CURRICULUM_HOME/COURSE_PROPOSAL would start at the root controller,
454    * and hand it off to the home controller, then the curriculum home controller, then the course proposal controller
455    * and stop there. Along the way each of those controller would show themselves visually in the UI,
456    * if they contain any layout (some do not).
457    *
458    * @see org.kuali.student.common.ui.client.mvc.history.HistorySupport#onHistoryEvent(java.lang.String)
459    */
 
460  0 toggle @Override
461    public void onHistoryEvent(String historyStack) {
462  0 final String nextHistoryStack = HistoryManager.nextHistoryStack(historyStack);
463  0 String[] tokens = HistoryManager.splitHistoryStack(nextHistoryStack);
464  0 if (tokens.length >= 1 && tokens[0] != null && !tokens[0].isEmpty()) {
465  0 final Map<String, String> tokenMap = HistoryManager.getTokenMap(tokens[0]);
466    //TODO add some automatic view context setting here, get and set
467  0 String viewEnumString = tokenMap.get("view");
468  0 if (viewEnumString != null) {
469  0 final Enum<?> viewEnum = getViewEnumValue(viewEnumString);
470   
471  0 if (viewEnum != null) {
472  0 getView(viewEnum, new Callback<View>(){
473   
 
474  0 toggle @Override
475    public void exec(View result) {
476  0 View theView = result;
477  0 boolean sameContext = true;
478  0 if(theView instanceof Controller){
479   
480  0 ViewContext newContext = new ViewContext();
481  0 Iterator<String> tokenIt = tokenMap.keySet().iterator();
482  0 while(tokenIt.hasNext()){
483  0 String key = tokenIt.next();
484  0 if(key.equals(ViewContext.ID_ATR)){
485  0 newContext.setId(tokenMap.get(ViewContext.ID_ATR));
486    }
487  0 else if(key.equals(ViewContext.ID_TYPE_ATR)){
488  0 newContext.setIdType(tokenMap.get(ViewContext.ID_TYPE_ATR));
489    }
490    //do not add view attribute from the token map to the context
491  0 else if(!key.equals("view")){
492  0 newContext.setAttribute(key, tokenMap.get(key));
493    }
494    }
495   
496  0 ViewContext viewContext = ((Controller) theView).getViewContext();
497  0 if(viewContext.compareTo(newContext) != 0){
498  0 ((Controller) theView).setViewContext(newContext);
499  0 sameContext = false;
500    }
501    }
502  0 if (currentViewEnum == null || !viewEnum.equals(currentViewEnum)
503    || !sameContext) {
504  0 beginShowView(theView, viewEnum, new Callback<Boolean>() {
 
505  0 toggle @Override
506    public void exec(Boolean result) {
507  0 if (result) {
508  0 currentView.onHistoryEvent(nextHistoryStack);
509    }
510    }
511    });
512  0 } else if (currentView != null) {
513  0 currentView.onHistoryEvent(nextHistoryStack);
514    }
515    }
516    });
517   
518    }
519    }
520    }
521    else{
522  0 this.showDefaultView(new Callback<Boolean>(){
523   
 
524  0 toggle @Override
525    public void exec(Boolean result) {
526  0 if(result){
527  0 currentView.onHistoryEvent(nextHistoryStack);
528    }
529   
530    }
531    });
532    }
533   
534    }
535   
536    /**
537    * Sets the view context. This is important for determining the permission for seeing views under
538    * this controllers scope, what the id and id type of the model the controller handles are defined here.
539    * Additional attributes that the controller and it's views need to know about are also defined in the
540    * viewContext.
541    * @param viewContext
542    */
 
543  0 toggle public void setViewContext(ViewContext viewContext){
544  0 this.context = viewContext;
545    }
546   
 
547  0 toggle public ViewContext getViewContext() {
548  0 return this.context;
549    }
550   
 
551  0 toggle public void resetCurrentView(){
552  0 currentView = null;
553    }
554   
555    /**
556    *
557    * This method implement the "Generic Export" of a windows content to Jasper based on the format the user selected.
558    * This method can be overwritten on a subclass to do specific export to the specific view
559    *
560    * @see org.kuali.student.common.ui.client.reporting.ReportExport#doReportExport(java.util.ArrayList)
561    */
 
562  0 toggle @Override
563    public void doReportExport(ArrayList<ExportElement> exportElements, final String format, final String reportTitle) {
564    // Service call...
565  0 final BlockingTask loadDataTask = new BlockingTask("Generating Export File");
566   
567  0 DataModel dataModel = getExportDataModel();
568  0 Data modelDataObject = null;
569  0 if (dataModel != null) {
570  0 modelDataObject = dataModel.getRoot();
571    }
572   
573   
574    // we want to show that something is happening while the files are generated.
575  0 KSBlockingProgressIndicator.addTask(loadDataTask);
576   
577  0 reportExportRpcService.reportExport(exportElements, modelDataObject, getExportTemplateName(), format, reportTitle, new KSAsyncCallback<String>() {
 
578  0 toggle @Override
579    public void onSuccess(String result) {
580    // On success get documentID back from GWT Servlet//
581   
582    // We need to get the base url and strip the gwt module name .
583  0 String baseUrl = GWT.getHostPageBaseURL();
584  0 baseUrl = baseUrl.replaceFirst(GWT.getModuleName() + "/", "");
585   
586  0 KSBlockingProgressIndicator.removeTask(loadDataTask);
587   
588  0 Window.open(baseUrl + "exportDownloadHTTPServlet?exportId="+result + "&format=" + format, "", "");
589    }
590   
 
591  0 toggle @Override
592    public void handleFailure(Throwable caught) {
593  0 KSBlockingProgressIndicator.removeTask(loadDataTask);
594  0 super.handleFailure(caught);
595    }
596   
597    });
598   
599   
600   
601    }
602   
603    // TODO Nina ??? Do we want to keep this seen in the light of the exportElements parameter
 
604  0 toggle @Override
605    public DataModel getExportDataModel() {
606  0 return null;
607    }
608   
609    /**
610    *
611    * @see org.kuali.student.common.ui.client.reporting.ReportExport#getExportTemplateName()
612    */
 
613  0 toggle @Override
614    public String getExportTemplateName() {
615  0 return exportTemplateName;
616    }
617   
 
618  0 toggle @Override
619    public ArrayList<ExportElement> getExportElementsFromView() {
620  0 String viewName = null;
621  0 View currentView = this.getCurrentView();
622  0 if (currentView != null) {
623   
624  0 ArrayList<ExportElement> exportElements = null;
625   
626  0 if (currentView != null && currentView instanceof SectionView) {
627  0 viewName = currentView.getName();
628  0 exportElements = ExportUtils.getExportElementsFromView((SectionView)currentView, exportElements, viewName, "Sectionname");
629  0 return exportElements;
630    } else {
631    // logger.warn("ExportUtils.getExportElementsFromView not implemented for :" + this.getCurrentView());
632    }
633    } else {
634    // logger.warn("ExportUtils.getExportElementsFromView controller currentView is null :" + this.getClass().getName());
635    }
636  0 return null;
637    }
638    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Thu Apr 28 2011 06:00:46 EDT.		   Clover: Open Source License registered to University of Arizona.