/*

  * Copyright 2007 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.opensource.org/licenses/ecl2.php

  *

  * 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.rice.ken.web.spring;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import javax.servlet.ServletException;

 import javax.servlet.http.HttpServletRequest;

 import javax.servlet.http.HttpServletResponse;

 import org.apache.commons.lang.StringUtils;

 import org.apache.log4j.Logger;

 import org.kuali.rice.ken.bo.Notification;

 import org.kuali.rice.ken.bo.NotificationChannelReviewer;

 import org.kuali.rice.ken.document.kew.NotificationWorkflowDocument;

 import org.kuali.rice.ken.service.NotificationMessageContentService;

 import org.kuali.rice.ken.service.NotificationRecipientService;

 import org.kuali.rice.ken.service.NotificationWorkflowDocumentService;

 import org.kuali.rice.ken.util.NotificationConstants;

 import org.kuali.rice.ken.util.Util;

 import org.kuali.rice.kew.dto.NetworkIdDTO;

 import org.kuali.rice.kew.dto.WorkflowIdDTO;

 import org.kuali.rice.kew.service.WorkflowDocument;

 import org.kuali.rice.kim.bo.Person;

 import org.kuali.rice.kim.service.KIMServiceLocator;

 import org.kuali.rice.kim.util.KimConstants.KimGroupMemberTypes;

 import org.springframework.validation.BindException;

 import org.springframework.validation.ValidationUtils;

 import org.springframework.web.bind.ServletRequestBindingException;

 import org.springframework.web.servlet.ModelAndView;

 import org.springframework.web.servlet.mvc.multiaction.MultiActionController;

 /**

  * Implements reviewer Approve/Disapprove and initiator Acknowledge of a Notification requests

  * sent to channels configured with reviewers

  * @author Kuali Rice Team (rice.collab@kuali.org)

  */

 public class AdministerNotificationRequestController extends MultiActionController {

     private static final Logger LOG = Logger.getLogger(AdministerNotificationRequestController.class);

     /**

      * Command object for this controller

      */

     public static class AdministerNotificationRequestCommand {

         // incoming

         private Long docId;

         // outgoing

         private NotificationWorkflowDocument document;

         private Notification notification;

         private String renderedContent;

         private boolean valid = true;

         private String message;

         public Long getDocId() {

             return docId;

         }

         public void setDocId(Long docId) {

             this.docId = docId;

         }

         public NotificationWorkflowDocument getDocument() {

             return document;

         }

         public void setDocument(NotificationWorkflowDocument document) {

             this.document = document;

         }

         public Notification getNotification() {

             return notification;

         }

         public void setNotification(Notification notification) {

             this.notification = notification;

         }

         public String getRenderedContent() {

             return renderedContent;

         }

         public void setRenderedContent(String renderedContent) {

             this.renderedContent = renderedContent;

         }

         public boolean isValid() {

             return valid;

         }

         public void setValid(boolean valid) {

             this.valid = valid;

         }

         public String getMessage() {

             return message;

         }

         public void setMessage(String message) {

             this.message = message;

         }

     }

     protected NotificationMessageContentService messageContentService;

     protected NotificationWorkflowDocumentService workflowDocumentService;

     protected NotificationRecipientService recipientService;

     /**

      * Sets the messageContentService attribute value.

      * @param messageContentService the NotificationMessageContentService impl

      */

     public void setMessageContentService(

             NotificationMessageContentService notificationMessageContentService) {

         this.messageContentService = notificationMessageContentService;

     }

     /**

      * Sets the workflowDocumentService attribute value.

      * @param workflowDocumentService the NotificationWorkflowDocumentService impl

      */

     public void setWorkflowDocumentService(

             NotificationWorkflowDocumentService notificationWorkflowDocumentService) {

         this.workflowDocumentService = notificationWorkflowDocumentService;

     }

     /**

      * Sets the recipientService attribute value.

      * @param recipientService the NotificationRecipientService impl

      */

     public void setRecipientService(

             NotificationRecipientService notificationRecipientService) {

         this.recipientService = notificationRecipientService;

     }

     /**

      * Parses the serialized Notification xml from the workflow document application content into a reconstituted

      * Notification BO

      * @param document the WorkflowDocument

      * @return a Notification BO reconstituted from the serialized XML form in the workflow document

      * @throws Exception if parsing fails

      */

     private Notification retrieveNotificationForWorkflowDocument(WorkflowDocument document) throws Exception {

         String notificationAsXml = document.getApplicationContent();

         //parse out the application content into a Notification BO

         Notification notification = messageContentService.parseSerializedNotificationXml(notificationAsXml.getBytes());

         return notification;

     }

     /**

      * View action that displays an approve/disapprove/acknowledge view

      * @param request the HttpServletRequest

      * @param response the HttpServletResponse

      * @param command the command object bound for this MultiActionController

      * @return a view ModelAndView

      */

     public ModelAndView view(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) {

         // obtain a workflow user object first

         WorkflowIdDTO initiator = new WorkflowIdDTO(request.getRemoteUser());

         // now construct the workflow document, which will interact with workflow

         if (command.getDocId() == null) {

             throw new RuntimeException("An invalid document ID was recieved from KEW's action list.");

         }

         //check to see which view is being passed to us from the notification list - pop up or inline

         String view = request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.COMMAND);

         String standaloneWindow = "true";

         if(view != null && view.equals(NotificationConstants.NOTIFICATION_DETAIL_VIEWS.INLINE)) {

             standaloneWindow = "false";

         }

         NotificationWorkflowDocument document;

         Map<String, Object> model = new HashMap<String, Object>();

         // set into model whether we are dealing with a pop up or an inline window

         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, standaloneWindow);

         try {

             document = new NotificationWorkflowDocument(initiator, new Long(command.getDocId()));

             Notification notification = retrieveNotificationForWorkflowDocument(document);

             // set up model

             command.setDocument(document);

             command.setNotification(notification);

             // render the event content according to registered XSLT stylesheet

             command.setRenderedContent(Util.transformContent(notification));

             LOG.info("notification auto remove date time: " + notification.getAutoRemoveDateTime());

             if (document.stateIsApproved()) {

                 command.setValid(false);

                 command.setMessage("This notification request has been approved.");

             } else if (document.stateIsDisapproved()) {

                 command.setMessage("This notification request has been disapproved.");

             } else if (notification.getAutoRemoveDateTime() != null && notification.getAutoRemoveDateTime().before(new Date(System.currentTimeMillis()))) {

                 /*if (!document.stateIsCanceled()) {

                 workflowDocumentService.terminateWorkflowDocument(new WorkflowDocument(new NetworkIdVO("notsys"), new Long(command.getDocId())));

                 }*/

                 // the autoremove date time has already passed...this notification request is null and void at this time

                 boolean disapproved = document.stateIsDisapproved();

                 if (!document.stateIsDisapproved()) {

                     List<NotificationChannelReviewer> reviewers = notification.getChannel().getReviewers();

                     String user = null;

                     for (NotificationChannelReviewer reviewer: reviewers) {

                         if (KimGroupMemberTypes.PRINCIPAL_MEMBER_TYPE.equals(reviewer.getReviewerType())) {

                             if (reviewer.getReviewerId().equals(request.getRemoteUser())) {

                                 user = request.getRemoteUser();

                             }

                         } else if (KimGroupMemberTypes.GROUP_MEMBER_TYPE.equals(reviewer.getReviewerType())) {

                             // if it's a group

                             String[] members = recipientService.getGroupMembers(reviewer.getReviewerId());

                             for (String member: members) {

                                 if (StringUtils.equals(member, request.getRemoteUser())) {

                                     user = request.getRemoteUser();

                                     break;

                                 }

                             }

                         }

                     }

                     // if the current user is a reviewer, then disapprove as that user

                     if (user != null) {

                         new WorkflowDocument(new NetworkIdDTO(user), new Long(command.getDocId())).disapprove("Disapproving notification request.  Auto-remove datetime has already passed.");

                         disapproved = true;

                     }

                 }

                 command.setValid(false);

                 if (disapproved) {

                     command.setMessage("This notification request is no longer valid because the Auto-Remove date has already passed.  It has been disapproved.  Please refresh your action list.");

                 } else {

                     command.setMessage("This notification request is no longer valid because the Auto-Remove date has already passed.");

                 }

             }

             model.put(getCommandName(command), command);

         } catch (Exception e) {

             throw new RuntimeException(e);

         }

         return new ModelAndView("ViewNotificationRequestDetails", model);

     }

     /**

      * Approve action that approves a notification request

      * @param request the HttpServletRequest

      * @param response the HttpServletResponse

      * @param command the command object bound for this MultiActionController

      * @return a view ModelAndView

      * @throws ServletException if an error occurs during approval

      */

     public ModelAndView approve(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) throws ServletException {

         administerEventNotificationMessage(request, response, command, "approve");

         Map<String, Object> model = new HashMap<String, Object>();

         model.put("workflowActionTaken", "Approved");

         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW));

         return new ModelAndView("SendNotificationRequestActionTakenWindow", model);

     }

     /**

      * Disapprove action that disapproves a notification request

      * @param request the HttpServletRequest

      * @param response the HttpServletResponse

      * @param command the command object bound for this MultiActionController

      * @return a view ModelAndView

      * @throws ServletException if an error occurs during disapproval

      */

     public ModelAndView disapprove(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) throws ServletException {

         administerEventNotificationMessage(request, response, command, "disapprove");

         Map<String, Object> model = new HashMap<String, Object>();

         model.put("workflowActionTaken", "Disapproved");

         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW));

         return new ModelAndView("SendNotificationRequestActionTakenWindow", model);

     }

     /**

      * Acknowledge action that acknowledges a notification request disapproval

      * @param request the HttpServletRequest

      * @param response the HttpServletResponse

      * @param command the command object bound for this MultiActionController

      * @return a view ModelAndView

      * @throws ServletException if an error occurs during acknowledgement

      */

     public ModelAndView acknowledge(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command) throws ServletException {

         administerEventNotificationMessage(request, response, command, "acknowledge");

         Map<String, Object> model = new HashMap<String, Object>();

         model.put(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW, request.getParameter(NotificationConstants.NOTIFICATION_CONTROLLER_CONSTANTS.STANDALONE_WINDOW));

         model.put("workflowActionTaken", "Acknowledged");

         return new ModelAndView("SendNotificationRequestActionTakenWindow", model);

     }

     /**

      * This method handles approval/disapproval/acknowledgement of the notification request

      * @param request the HttpServletRequest

      * @param response the HttpServletResponse

      * @param command the command object bound for this MultiActionController

      * @throws ServletException

      */

     private void administerEventNotificationMessage(HttpServletRequest request, HttpServletResponse response, AdministerNotificationRequestCommand command, String action) throws ServletException {

         LOG.debug("remoteUser: " + request.getRemoteUser());

         BindException bindException = new BindException(command, "command");

         ValidationUtils.rejectIfEmpty(bindException, "docId", "Document id must be specified");

         if (bindException.hasErrors()) {

             throw new ServletRequestBindingException("Document id must be specified", bindException);

         }

         // obtain a workflow user object first

         WorkflowIdDTO user = new WorkflowIdDTO(request.getRemoteUser());

         try {

             // now construct the workflow document, which will interact with workflow

             NotificationWorkflowDocument document = new NotificationWorkflowDocument(user, command.getDocId());

             Notification notification = retrieveNotificationForWorkflowDocument(document);

             String initiatorPrincipalId = document.getRouteHeader().getInitiatorPrincipalId();

             Person initiator = KIMServiceLocator.getPersonService().getPerson(initiatorPrincipalId);

             String notificationBlurb =  notification.getContentType().getName() + " notification submitted by " + initiator.getName() + " for channel " + notification.getChannel().getName();

             if ("disapprove".equals(action)) {

                 document.disapprove("User " + user.getWorkflowId() + " disapproving " + notificationBlurb);

             } else if ("approve".equals(action)) {

                 document.approve("User " + user.getWorkflowId() + " approving " + notificationBlurb);

             } else if ("acknowledge".equals(action)) {

                 document.acknowledge("User " + user.getWorkflowId() + " acknowledging " + notificationBlurb);

             }

         } catch (Exception e) {

             LOG.error("Exception occurred taking action on notification request", e);

             throw new ServletException("Exception occurred taking action on notification request", e);

         }

     }

 }