Source code

001/**
002 * Copyright 2005-2016 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.krad.web.controller;
017
018import javax.servlet.http.HttpServletRequest;
019import javax.servlet.http.HttpServletResponse;
020
021import org.apache.commons.lang.ArrayUtils;
022import org.apache.log4j.Logger;
023import org.kuali.rice.core.api.config.property.Config;
024import org.kuali.rice.core.api.config.property.ConfigContext;
025import org.kuali.rice.core.api.config.property.ConfigurationService;
026import org.kuali.rice.kew.api.KewApiConstants;
027import org.kuali.rice.krad.bo.PersistableAttachment;
028import org.kuali.rice.krad.bo.PersistableBusinessObject;
029import org.kuali.rice.krad.datadictionary.DocumentEntry;
030import org.kuali.rice.krad.exception.UnknownDocumentIdException;
031import org.kuali.rice.krad.maintenance.MaintenanceDocument;
032import org.kuali.rice.krad.maintenance.Maintainable;
033import org.kuali.rice.krad.maintenance.MaintenanceUtils;
034import org.kuali.rice.krad.service.KRADServiceLocator;
035import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
036import org.kuali.rice.krad.service.MaintenanceDocumentService;
037import org.kuali.rice.krad.uif.UifConstants;
038import org.kuali.rice.krad.uif.UifParameters;
039import org.kuali.rice.krad.util.GlobalVariables;
040import org.kuali.rice.krad.util.KRADConstants;
041import org.kuali.rice.krad.web.form.DocumentFormBase;
042import org.kuali.rice.krad.web.form.InitiatedDocumentInfoForm;
043import org.kuali.rice.krad.web.form.MaintenanceForm;
044import org.kuali.rice.krad.web.form.UifFormBase;
045import org.springframework.stereotype.Controller;
046import org.springframework.validation.BindingResult;
047import org.springframework.web.bind.annotation.ModelAttribute;
048import org.springframework.web.bind.annotation.RequestMapping;
049import org.springframework.web.servlet.ModelAndView;
050
051import java.net.URL;
052import java.util.Enumeration;
053import java.util.Iterator;
054import java.util.Map;
055import java.util.Properties;
056
057/**
058 * Controller for <code>MaintenanceView</code> screens which operate on
059 * <code>MaintenanceDocument</code> instances
060 *
061 * @author Kuali Rice Team (rice.collab@kuali.org)
062 */
063@Controller
064@RequestMapping(value = "/maintenance")
065public class MaintenanceDocumentController extends DocumentControllerBase {
066    protected static final Logger LOG = Logger.getLogger(MaintenanceDocumentController.class);
067
068    /**
069     * @see org.kuali.rice.krad.web.controller.UifControllerBase#createInitialForm(javax.servlet.http.HttpServletRequest)
070     */
071    @Override
072    protected MaintenanceForm createInitialForm(HttpServletRequest request) {
073        return new MaintenanceForm();
074    }
075
076    /**
077     * After the document is loaded calls method to setup the maintenance object
078     */
079    @Override
080    @RequestMapping(params = "methodToCall=docHandler")
081    public ModelAndView docHandler(@ModelAttribute("KualiForm") DocumentFormBase formBase, BindingResult result,
082            HttpServletRequest request, HttpServletResponse response) throws Exception {
083
084        // TODO getting double view if we call base, not sure how to handle
085        // so pasting in superclass code
086        // super.docHandler(formBase, request, response);
087        // * begin copy/paste from the base
088        MaintenanceForm form = (MaintenanceForm) formBase;
089
090        // in all of the following cases we want to load the document
091        if (ArrayUtils.contains(DOCUMENT_LOAD_COMMANDS, form.getCommand()) && form.getDocId() != null) {
092            try {
093                loadDocument(form);
094            } catch (UnknownDocumentIdException udie) {
095                ConfigurationService kualiConfigurationService = KRADServiceLocator.getKualiConfigurationService();
096                StringBuffer sb = new StringBuffer();
097                sb.append(kualiConfigurationService.getPropertyValueAsString(KRADConstants.KRAD_URL_KEY));
098                sb.append(kualiConfigurationService.getPropertyValueAsString(KRADConstants.KRAD_INITIATED_DOCUMENT_URL_KEY));
099                Properties props = new Properties();
100                props.put(UifParameters.METHOD_TO_CALL, UifConstants.MethodToCallNames.START);
101                GlobalVariables.getUifFormManager().removeForm(form);
102                return performRedirect(new InitiatedDocumentInfoForm(), sb.toString(), props);
103            }
104        } else if (KewApiConstants.INITIATE_COMMAND.equals(form.getCommand())) {
105            createDocument(form);
106        } else {
107            LOG.error("docHandler called with invalid parameters");
108            throw new IllegalArgumentException("docHandler called with invalid parameters");
109        }
110        // * end copy/paste from the base
111
112        if (KewApiConstants.ACTIONLIST_COMMAND.equals(form.getCommand()) ||
113                KewApiConstants.DOCSEARCH_COMMAND.equals(form.getCommand()) ||
114                KewApiConstants.SUPERUSER_COMMAND.equals(form.getCommand()) ||
115                KewApiConstants.HELPDESK_ACTIONLIST_COMMAND.equals(form.getCommand()) && form.getDocId() != null) {
116            // TODO: set state in view
117            // form.setReadOnly(true);
118            form.setMaintenanceAction((form.getDocument()).getNewMaintainableObject().getMaintenanceAction());
119
120            // Retrieving the FileName from BO table
121            Maintainable tmpMaintainable = form.getDocument().getNewMaintainableObject();
122            if (tmpMaintainable.getDataObject() instanceof PersistableAttachment) {
123                PersistableAttachment bo = (PersistableAttachment) getBusinessObjectService()
124                        .retrieve((PersistableBusinessObject) tmpMaintainable.getDataObject());
125                if (bo != null) {
126                    request.setAttribute("fileName", bo.getFileName());
127                }
128            }
129        } else if (KewApiConstants.INITIATE_COMMAND.equals(form.getCommand())) {
130            // form.setReadOnly(false);
131            setupMaintenance(form, request, KRADConstants.MAINTENANCE_NEW_ACTION);
132        } else {
133            LOG.error("We should never have gotten to here");
134            throw new IllegalArgumentException("docHandler called with invalid parameters");
135        }
136
137        return getUIFModelAndView(form);
138    }
139
140    /**
141     * Default method for controller that setups a new
142     * <code>MaintenanceView</code> with the default new action
143     */
144    @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_NEW)
145    @Override
146    public ModelAndView start(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
147            HttpServletRequest request, HttpServletResponse response) {
148        MaintenanceForm maintenanceForm = (MaintenanceForm) form;
149
150        setupMaintenance(maintenanceForm, request, KRADConstants.MAINTENANCE_NEW_ACTION);
151
152        return getUIFModelAndView(maintenanceForm);
153    }
154
155    /**
156     * Setups a new <code>MaintenanceView</code> with the edit maintenance
157     * action
158     */
159    @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_EDIT)
160    public ModelAndView maintenanceEdit(@ModelAttribute("KualiForm") MaintenanceForm form, BindingResult result,
161            HttpServletRequest request, HttpServletResponse response) throws Exception {
162
163        setupMaintenance(form, request, KRADConstants.MAINTENANCE_EDIT_ACTION);
164
165        return getUIFModelAndView(form);
166    }
167
168    /**
169     * Setups a new <code>MaintenanceView</code> with the copy maintenance
170     * action
171     */
172    @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_COPY)
173    public ModelAndView maintenanceCopy(@ModelAttribute("KualiForm") MaintenanceForm form, BindingResult result,
174            HttpServletRequest request, HttpServletResponse response) throws Exception {
175
176        setupMaintenance(form, request, KRADConstants.MAINTENANCE_COPY_ACTION);
177
178        return getUIFModelAndView(form);
179    }
180
181    /**
182     * Setups a new <code>MaintenanceView</code> with the new with existing
183     * maintenance action
184     */
185    @RequestMapping(params = "methodToCall=" + KRADConstants.Maintenance.METHOD_TO_CALL_NEW_WITH_EXISTING)
186    public ModelAndView maintenanceNewWithExisting(@ModelAttribute("KualiForm") MaintenanceForm form,
187            BindingResult result, HttpServletRequest request, HttpServletResponse response) throws Exception {
188
189        setupMaintenance(form, request, KRADConstants.MAINTENANCE_NEWWITHEXISTING_ACTION);
190
191        return getUIFModelAndView(form);
192    }
193
194    /**
195     * Sets up the <code>MaintenanceDocument</code> on initial get request
196     *
197     * <p>
198     * First step is to create a new document instance based on the query
199     * parameters (document type name or object class name). Then call the
200     * <code>Maintainable</code> to do setup on the object being maintained.
201     * </p>
202     *
203     * @param form - <code>MaintenanceForm</code> instance
204     * @param request - HTTP request object
205     * @param maintenanceAction - the maintenance action (new, new from existing, edit, copy)
206     * being request
207     * @throws Exception
208     */
209    protected void setupMaintenance(MaintenanceForm form, HttpServletRequest request, String maintenanceAction) {
210        MaintenanceDocument document = form.getDocument();
211
212        // create a new document object, if required
213        if (document == null) {
214            document = getMaintenanceDocumentService()
215                    .setupNewMaintenanceDocument(form.getDataObjectClassName(), form.getDocTypeName(),
216                            maintenanceAction);
217
218            form.setDocument(document);
219            form.setDocTypeName(document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName());
220        }
221
222        // set action on form
223        form.setMaintenanceAction(maintenanceAction);
224
225        // invoke maintenance document service to setup the object for maintenance
226        getMaintenanceDocumentService().setupMaintenanceObject(document, maintenanceAction, request.getParameterMap());
227
228        // for new maintainable check if a maintenance lock exists and if so
229        // warn the user
230        if (KRADConstants.MAINTENANCE_NEW_ACTION.equals(maintenanceAction)) {
231            MaintenanceUtils.checkForLockingDocument(document, false);
232        }
233
234        // Retrieve notes topic display flag from data dictionary and add to
235        // document
236        // TODO: should be in the view as permission
237        DocumentEntry entry = KRADServiceLocatorWeb.getDocumentDictionaryService()
238                .getMaintenanceDocumentEntry(document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName());
239        document.setDisplayTopicFieldInNotes(entry.getDisplayTopicFieldInNotes());
240    }
241
242    /**
243     * Override route to retrieve the maintenance object if it is an attachment
244     *
245     * @see DocumentControllerBase.route
246     *      (DocumentFormBase, HttpServletRequest, HttpServletResponse)
247     */
248    @Override
249    @RequestMapping(params = "methodToCall=route")
250    public ModelAndView route(@ModelAttribute("KualiForm") DocumentFormBase form, BindingResult result,
251            HttpServletRequest request, HttpServletResponse response) {
252
253        ModelAndView modelAndView;
254
255        modelAndView = super.route(form, result, request, response);
256
257        MaintenanceDocument document = (MaintenanceDocument) form.getDocument();
258        if (document.getNewMaintainableObject().getDataObject() instanceof PersistableAttachment) {
259            PersistableAttachment bo = (PersistableAttachment) getBusinessObjectService()
260                    .retrieve((PersistableBusinessObject) document.getNewMaintainableObject().getDataObject());
261            request.setAttribute("fileName", bo.getFileName());
262        }
263
264        modelAndView = getUIFModelAndView(form);
265
266        return modelAndView;
267    }
268
269    protected MaintenanceDocumentService getMaintenanceDocumentService() {
270        return KRADServiceLocatorWeb.getMaintenanceDocumentService();
271    }
272
273}