/*

  * Copyright 2005-2008 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.kew.actionitem.dao.impl;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.HashMap;

 import java.util.Iterator;

 import java.util.List;

 import java.util.Map;

 import javax.persistence.EntityManager;

 import javax.persistence.PersistenceContext;

 import org.apache.commons.collections.CollectionUtils;

 import org.kuali.rice.core.jpa.criteria.Criteria;

 import org.kuali.rice.core.jpa.criteria.QueryByCriteria;

 import org.kuali.rice.core.util.OrmUtils;

 import org.kuali.rice.kew.actionitem.ActionItem;

 import org.kuali.rice.kew.actionitem.OutboxItemActionListExtension;

 import org.kuali.rice.kew.actionitem.dao.ActionItemDAO;

 import org.kuali.rice.kew.actionrequest.KimGroupRecipient;

 import org.kuali.rice.kew.actionrequest.Recipient;

 import org.kuali.rice.kew.util.KEWConstants;

 import org.kuali.rice.kew.util.WebFriendlyRecipient;

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

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

 /**

  * OJB implementation of {@link ActionItemDAO}.

  *

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

  */

 public class ActionItemDAOJpaImpl implements ActionItemDAO {

         @PersistenceContext(unitName="kew-unit")

         private EntityManager entityManager;

     public ActionItem findByActionItemId(Long actionItemId) {

             return entityManager.find(ActionItem.class, actionItemId);

     }

     public void deleteActionItems(Long actionRequestId) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("actionRequestId", actionRequestId);

         for(Object actionItem:new QueryByCriteria(entityManager,crit).toQuery().getResultList()){

             if( ! (actionItem instanceof OutboxItemActionListExtension)) {

                 entityManager.remove(actionItem);

             }

         }

     }

     public void deleteActionItem(ActionItem actionItem) {

             entityManager.remove(findByActionItemId(actionItem.getActionItemId()));

     }

     public void deleteByRouteHeaderIdWorkflowUserId(Long routeHeaderId, String workflowUserId) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("routeHeader.routeHeaderId", routeHeaderId);

         crit.eq("principalId", workflowUserId);

         for(Object actionItem: new QueryByCriteria(entityManager,crit).toQuery().getResultList()){

             if( ! (actionItem instanceof OutboxItemActionListExtension)) {

                 entityManager.remove(actionItem);

             }

         }

     }

     public void deleteByRouteHeaderId(Long routeHeaderId) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("routeHeader.routeHeaderId", routeHeaderId);

         for(Object actionItem: new QueryByCriteria(entityManager,crit).toQuery().getResultList()){

             if( ! (actionItem instanceof OutboxItemActionListExtension)) {

                 entityManager.remove(actionItem);

             }

         }

     }

     /**

          * This method replaces findByWorkflowUser

          *

          * @see org.kuali.rice.kew.actionitem.dao.ActionItemDAO#findByPrincipalId(java.lang.String)

          */

         public Collection<ActionItem> findByPrincipalId(String principalId) {

                 Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("principalId", principalId);

         crit.orderBy("routeHeader.routeHeaderId", true);

         List<ActionItem> results = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         return removeOutBoxItems(results);

         }

     public Collection<ActionItem> findByWorkflowUserRouteHeaderId(String workflowId, Long routeHeaderId) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("principalId", workflowId);

         crit.eq("routeHeader.routeHeaderId", routeHeaderId);

         List<ActionItem> results = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         return removeOutBoxItems(results);

     }

     public Collection<ActionItem> findByDocumentTypeName(String documentTypeName) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("docName", documentTypeName);

         List<ActionItem> results = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         return removeOutBoxItems(results);

     }

     public Collection<ActionItem> getOutboxItemsByDocumentType(String documentTypeName) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("docName", documentTypeName);

         List<ActionItem> results = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         Iterator<ActionItem> iterator = results.iterator();

         while (iterator.hasNext()) {

             if (!(iterator.next() instanceof OutboxItemActionListExtension)) {

                 iterator.remove();

             }

         }

         return results;

     }

     public Collection<ActionItem> findByRouteHeaderId(Long routeHeaderId) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("routeHeader.routeHeaderId", routeHeaderId);

         List<ActionItem> results = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         return removeOutBoxItems(results);

     }

     public Collection<ActionItem> findByActionRequestId(Long actionRequestId) {

         Criteria crit = new Criteria(ActionItem.class.getName());

         crit.eq("actionRequestId", actionRequestId);

         List<ActionItem> results = new QueryByCriteria(entityManager, crit).toQuery().getResultList();

         return removeOutBoxItems(results);

     }

     public void saveActionItem(ActionItem actionItem) {

             if(actionItem.getActionItemId()==null){

                 entityManager.persist(actionItem);

             }else{

                     OrmUtils.merge(entityManager, actionItem);

             }

     }

     public Collection<Recipient> findSecondaryDelegators(String principalId) {

         Criteria notNullWorkflowCriteria = new Criteria(ActionItem.class.getName());

         notNullWorkflowCriteria.notNull("delegatorWorkflowId");

         Criteria notNullWorkgroupCriteria = new Criteria(ActionItem.class.getName());

         notNullWorkgroupCriteria.notNull("delegatorGroupId");

         Criteria orCriteria = new Criteria(ActionItem.class.getName());

         orCriteria.or(notNullWorkflowCriteria);

         orCriteria.or(notNullWorkgroupCriteria);

         Criteria criteria = new Criteria(ActionItem.class.getName());

         criteria.eq("principalId", principalId);

         criteria.eq("delegationType", KEWConstants.DELEGATION_SECONDARY);

         criteria.and(orCriteria);

         Map<Object, Recipient> delegators = new HashMap<Object, Recipient>();

         for(Object actionItem:new QueryByCriteria(entityManager, criteria).toQuery().getResultList()){

                 final String delegatorWorkflowId = ((ActionItem)actionItem).getDelegatorWorkflowId();

                 String delegatorGroupId = ((ActionItem)actionItem).getDelegatorGroupId();

                 if (delegatorWorkflowId != null && !delegators.containsKey(delegatorWorkflowId)) {

                 delegators.put(delegatorWorkflowId,new WebFriendlyRecipient(KIMServiceLocator.getPersonService().getPerson(delegatorWorkflowId)));

             }else if (delegatorGroupId != null) {

                 if (!delegators.containsKey(delegatorGroupId)) {

                     delegators.put(delegatorGroupId, new KimGroupRecipient(getIdentityManagementService().getGroup(delegatorGroupId)));

                 }

             }

         }

          return delegators.values();

     }

     public Collection<Recipient> findPrimaryDelegationRecipients(String principalId) {

             List<String> workgroupIds = KIMServiceLocator.getIdentityManagementService().getGroupIdsForPrincipal(principalId);

         Criteria orCriteria = new Criteria(ActionItem.class.getName());

         Criteria delegatorWorkflowIdCriteria = new Criteria(ActionItem.class.getName());

         delegatorWorkflowIdCriteria.eq("delegatorWorkflowId", principalId);

         if (CollectionUtils.isNotEmpty(workgroupIds)) {

             Criteria delegatorWorkgroupCriteria = new Criteria(ActionItem.class.getName());

             delegatorWorkgroupCriteria.in("delegatorGroupId", new ArrayList<String>(workgroupIds));

             orCriteria.or(delegatorWorkgroupCriteria);

             orCriteria.or(delegatorWorkflowIdCriteria);

         }

         else {

             orCriteria.and(delegatorWorkflowIdCriteria);

         }

         Criteria criteria = new Criteria(ActionItem.class.getName());

         criteria.eq("delegationType", KEWConstants.DELEGATION_PRIMARY);

         criteria.and(orCriteria);

         Map<Object, Recipient> delegators = new HashMap<Object, Recipient>();

         for(Object actionItem:new QueryByCriteria(entityManager, criteria).toQuery().getResultList()){

                 String princlId = ((ActionItem)actionItem).getPrincipalId();

             if (princlId != null && !delegators.containsKey(princlId)) {

                 delegators.put(princlId, new WebFriendlyRecipient(KIMServiceLocator.getPersonService().getPerson(princlId)));

             }

         }

         return delegators.values();

     }

     private List<ActionItem> removeOutBoxItems(List<ActionItem> results) {

         Iterator<ActionItem> iterator = results.iterator();

         while(iterator.hasNext()) {

             if(iterator.next() instanceof OutboxItemActionListExtension) {

                 iterator.remove();

             }

         }

         return results;

     }

     private IdentityManagementService getIdentityManagementService() {

         return (IdentityManagementService) KIMServiceLocator.getService(KIMServiceLocator.KIM_IDENTITY_MANAGEMENT_SERVICE);

     }

     public EntityManager getEntityManager() {

         return this.entityManager;

     }

     public void setEntityManager(EntityManager entityManager) {

         this.entityManager = entityManager;

     }

 }