import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
public void removeNotification(List<ActionItem> actionItems) {
	String enableKENNotificationValue = ConfigContext.getCurrentContextConfig().getProperty(KewApiConstants.ENABLE_KEN_NOTIFICATION);
    boolean enableKENNotification = Boolean.parseBoolean(enableKENNotificationValue);
    if (!enableKENNotification) {
    	return;
    }
    MessagingService ms = (MessagingService) GlobalResourceLoader.getService(new QName(KCBConstants.SERVICE_NAMESPACE, KCBServiceNames.KCB_MESSAGING));

    for (ActionItem actionItem: actionItems) {
    	LOG.debug("Removing KCB messages for action item: " + actionItem.getId() + " " + actionItem.getActionRequestCd() + " " + actionItem.getPrincipalId());
        try {
            // we don't have the action takens at this point...? :(
            ms.removeByOriginId(String.valueOf(actionItem.getId()), null, null);
        } catch (Exception e) {
            throw new RuntimeException("could not remove message from KCB", e);
        }
    }
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
/**
 * tests custom stylesheet
 * @throws Exception
 */
@Test
public void testGenerateRemindersCustomStyleSheet() throws Exception {
    loadXmlFile("customEmailStyleData.xml");
    assertNotNull(CoreServiceApiServiceLocator.getStyleService().getStyle("kew.email.style"));

    Person user = KimApiServiceLocator.getPersonService().getPersonByPrincipalName("arh14");
    int count = generateDocs(new String[] { "PingDocument", "PingDocumentWithEmailAttrib" }, user);

    Collection<ActionItem> actionItems = org.kuali.rice.kew.actionitem.ActionItem.to(new ArrayList<org.kuali.rice.kew.actionitem.ActionItem>(KEWServiceLocator.getActionListService().getActionList(user.getPrincipalId(), null)));
    assertEquals("user should have " + count + " items in his action list.", count, actionItems.size());

    EmailContent content = styleableContentService.generateImmediateReminder(user, actionItems.iterator().next(), KEWServiceLocator.getDocumentTypeService().findByName(actionItems.iterator().next().getDocName()));
    assertTrue("Unexpected subject", content.getSubject().startsWith("CUSTOM:"));
    assertTrue("Unexpected body", content.getBody().startsWith("CUSTOM:"));

    content = styleableContentService.generateDailyReminder(user, actionItems);
    assertTrue("Unexpected subject", content.getSubject().startsWith("CUSTOM:"));
    assertTrue("Unexpected body", content.getBody().startsWith("CUSTOM:"));

    content = styleableContentService.generateWeeklyReminder(user, actionItems);
    assertTrue("Unexpected subject", content.getSubject().startsWith("CUSTOM:"));
    assertTrue("Unexpected body", content.getBody().startsWith("CUSTOM:"));
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
/**
 * This overridden method will perform the standard operations from org.kuali.rice.kew.mail.ActionListEmailServiceImpl but will also keep track of action
 * items processed
 */
@Override
public void sendImmediateReminder(ActionItem actionItem, Boolean skipOnApprovals) {
    if (skipOnApprovals != null && skipOnApprovals.booleanValue()
            && actionItem.getActionRequestCd().equals(KewApiConstants.ACTION_REQUEST_APPROVE_REQ)) {
        LOG.debug("As requested, skipping immediate reminder notification on action item approval for " + actionItem.getPrincipalId());
        return;
    }
    List actionItemsSentUser = (List)immediateReminders.get(actionItem.getPrincipalId());
    Preferences preferences = getPreferencesService().getPreferences(actionItem.getPrincipalId());

    boolean shouldNotify = checkEmailNotificationPreferences(actionItem, preferences, KewApiConstants.EMAIL_RMNDR_IMMEDIATE);
    if(shouldNotify) {
        if (actionItemsSentUser == null) {
            actionItemsSentUser = new ArrayList();
            immediateReminders.put(actionItem.getPrincipalId(), actionItemsSentUser);
        }
        actionItemsSentUser.add(actionItem);
    }
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
public int immediateReminderEmailsSent(String networkId, String documentId, String actionRequestCd) {
    Principal principal = KimApiServiceLocator.getIdentityService().getPrincipalByPrincipalName(networkId);
    List actionItemsSentUser = immediateReminders.get(principal.getPrincipalId());
    if (actionItemsSentUser == null) {
        LOG.info("There are no immediate reminders for Principal " + networkId + " and Document ID " + documentId);
        return 0;
    }
    else {
        LOG.info("There are " + actionItemsSentUser.size() + " immediate reminders for Principal " + networkId + " and Document ID " + documentId);
    }
    int emailsSent = 0;
    for (Iterator iter = actionItemsSentUser.iterator(); iter.hasNext();) {
        ActionItem actionItem = (ActionItem) iter.next();
        if (actionItem.getDocumentId().equals(documentId) && actionItem.getActionRequestCd().equals(actionRequestCd)) {
            emailsSent++;
        }
    }
    LOG.info(emailsSent + "No immediate e-mails were sent to Principal " + networkId + " and Document ID " + documentId);
    return emailsSent;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
/**
 * Queries workflow to get users who have an approval request for this effort certification.
 * 
 * @return String - names of users (seperated by comma) who have an approval request
 */
public String getNextApprovers() {
    String nextApprovers = "";


    List<ActionItem> actionList = KewApiServiceLocator.getActionListService().getAllActionItems(getDocumentHeader().getDocumentNumber());
    for (ActionItem actionItem : actionList) {
        if (actionItem.getActionRequestCd().equals(KewApiConstants.ACTION_REQUEST_APPROVE_REQ)) {
            String principalId = actionItem.getPrincipalId();
            if (principalId != null) {
                Person person = KimApiServiceLocator.getPersonService().getPerson(actionItem.getPrincipalId());
                if (StringUtils.isBlank(nextApprovers)) {
                    nextApprovers = person.getName();
                }
                else {
                    nextApprovers += "; " + person.getName();
                }

            }
        }
    }

    return nextApprovers;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
public ActionSet getLegalActions(String principalId, ActionItem actionItem) throws Exception {
	ActionSet actionSet = ActionSet.Builder.create().build();
	actionSet.addAcknowledge();
	actionSet.addApprove();
	actionSet.addFyi();
	actionSet.addComplete();
	return actionSet;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
public Map<String,DocumentRouteHeaderValue> getRouteHeadersForActionItems(Collection<ActionItem> actionItems) {
	Map<String,DocumentRouteHeaderValue> routeHeaders = new HashMap<String,DocumentRouteHeaderValue>();
	List<String> documentIds = new ArrayList<String>(actionItems.size());
	for (ActionItem actionItem : actionItems) {
		documentIds.add(actionItem.getDocumentId());
	}
	Collection<DocumentRouteHeaderValue> actionItemRouteHeaders = getRouteHeaders(documentIds);
	if (actionItemRouteHeaders != null) {
		for (DocumentRouteHeaderValue routeHeader : actionItemRouteHeaders) {
			routeHeaders.put(routeHeader.getDocumentId(), routeHeader);
		}
	}
	return routeHeaders;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
protected static CustomEmailAttribute getCustomEmailAttribute(Person user, ActionItem actionItem) throws WorkflowException {
	DocumentRouteHeaderValue routeHeader = KEWServiceLocator.getRouteHeaderService().getRouteHeader(actionItem.getDocumentId());
    CustomEmailAttribute customEmailAttribute = routeHeader.getCustomEmailAttribute();
    if (customEmailAttribute != null) {
        Document routeHeaderVO = DocumentRouteHeaderValue.to(routeHeader);
        ActionRequestValue actionRequest = KEWServiceLocator.getActionRequestService().findByActionRequestId(actionItem.getActionRequestId());
        ActionRequest actionRequestVO = ActionRequestValue.to(actionRequest);
        customEmailAttribute.setRouteHeaderVO(routeHeaderVO);
        customEmailAttribute.setActionRequestVO(actionRequestVO);
    }
    return customEmailAttribute;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
protected static void addDelegatorElement(Document doc, Element baseElement, ActionItem actionItem) {
    Element delegatorElement = doc.createElement("delegator");
    if ( (actionItem.getDelegatorPrincipalId() != null) ) {
        // add empty delegator element
        baseElement.appendChild(delegatorElement);
        return;
    }
    String delegatorType = "";
    String delegatorId = "";
    String delegatorDisplayValue = "";
    if (actionItem.getDelegatorPrincipalId() != null) {
        delegatorType = "user";
        delegatorId = actionItem.getDelegatorPrincipalId();
        Principal delegator = KimApiServiceLocator.getIdentityService().getPrincipal(delegatorId);
        
        if (delegator == null) {
        	LOG.error("Cannot find user for id " + delegatorId);
        	delegatorDisplayValue = "USER NOT FOUND";
        } else {
        	delegatorDisplayValue = UserUtils.getTransposedName(GlobalVariables.getUserSession(), delegator);
        }
    } else if (actionItem.getDelegatorPrincipalId() != null) {
        delegatorType = "workgroup";
        delegatorId = actionItem.getDelegatorGroupId();
        delegatorDisplayValue = KimApiServiceLocator.getGroupService().getGroup(actionItem.getDelegatorGroupId()).getName();
    }
    delegatorElement.setAttribute("type", delegatorType);
    // add the id element
    Element idElement = doc.createElement("id");
    idElement.appendChild(doc.createTextNode(delegatorId));
    delegatorElement.appendChild(idElement);
    // add the display value element
    Element displayValElement = doc.createElement("displayValue");
    displayValElement.appendChild(doc.createTextNode(delegatorDisplayValue));
    delegatorElement.appendChild(displayValElement);
    baseElement.appendChild(delegatorElement);
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
protected static void addWorkgroupRequestElement(Document doc, Element baseElement, ActionItem actionItem) {
    Element workgroupElement = doc.createElement("workgroupRequest");
    if (actionItem.getGroupId() != null) {
        // add the id element
        Element idElement = doc.createElement("id");
        idElement.appendChild(doc.createTextNode(actionItem.getGroupId()));
        workgroupElement.appendChild(idElement);
        // add the display value element
        Element displayValElement = doc.createElement("displayValue");
        displayValElement.appendChild(doc.createTextNode(actionItem.getGroupId()));
        workgroupElement.appendChild(displayValElement);
    }
    baseElement.appendChild(workgroupElement);
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
/**
 * This method is used to add the given {@link ActionItem} to the given {@link org.w3c.dom.Document} in a summarized
 * form for use in weekly or daily type reminder e-mails.
 *
 * @param doc - Document to have the ActionItem added to
 * @param actionItem - the action item being added
 * @param user - the current user
 * @param node - the node object to add the actionItem XML to (defaults to the doc variable if null is passed in)
 * @throws Exception
 */
protected void addSummarizedActionItem(Document doc, ActionItem actionItem, Person user, Node node, DocumentRouteHeaderValue routeHeader) throws Exception {
    if (node == null) {
        node = doc;
    }

    Element root = doc.createElement("summarizedActionItem");

    // add in all items from action list as preliminary default dataset
    addTextElement(doc, root, "documentId", actionItem.getDocumentId());
    addTextElement(doc, root, "docName", actionItem.getDocName());
    addCDataElement(doc, root, "docLabel", actionItem.getDocLabel());
    addCDataElement(doc, root, "docTitle", actionItem.getDocTitle());
    //DocumentRouteHeaderValue routeHeader = getRouteHeader(actionItem);
    addTextElement(doc, root, "docRouteStatus", routeHeader.getDocRouteStatus());
    addCDataElement(doc, root, "routeStatusLabel", routeHeader.getRouteStatusLabel());
    addTextElement(doc, root, "actionRequestCd", actionItem.getActionRequestCd());
    addTextElement(doc, root, "actionRequestLabel", CodeTranslator.getActionRequestLabel(
            actionItem.getActionRequestCd()));
    addDelegatorElement(doc, root, actionItem);
    addTimestampElement(doc, root, "createDate", routeHeader.getCreateDate());
    addWorkgroupRequestElement(doc, root, actionItem);
    if (actionItem.getDateTimeAssigned() != null)
        addTimestampElement(doc, root, "dateAssigned", actionItem.getDateTimeAssigned().toDate());

    node.appendChild(root);
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
public void sendReminder(ActionItem actionItem, Boolean skipOnApprovals) {
      if (actionItem == null) {
	throw new RiceIllegalArgumentException("actionItem was null");
}

      if (skipOnApprovals == null) {
          skipOnApprovals = false;
}

      getActionListEmailService().sendImmediateReminder(actionItem, skipOnApprovals);
  }
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
public List<ActionItemCustomization> customizeActionList(String principalId, List<ActionItem> actionItems)
        throws RiceIllegalArgumentException {
    if (StringUtils.isBlank(principalId)) {
        throw new RiceIllegalArgumentException("principalId was null or blank");
    }
    if (actionItems == null) { actionItems = Collections.emptyList(); }

    List<ActionItemCustomization> actionItemCustomizations =
            new ArrayList<ActionItemCustomization>(actionItems.size());

    for (ActionItem actionItem : actionItems) {
        DocumentType documentType = getDocumentTypeService().findByName(actionItem.getDocName());

        try { // try to get the custom action list attribute and convert it to an ActionItemCustomization
            CustomActionListAttribute customActionListAttribute = null;
            if (documentType != null) {
                customActionListAttribute = documentType.getCustomActionListAttribute();
            }

            if (customActionListAttribute == null) {
                customActionListAttribute = getDefaultCustomActionListAttribute();
            }

            ActionItemCustomization actionItemCustomization = ActionItemCustomization.Builder.create(
                    actionItem.getId(),
                    customActionListAttribute.getLegalActions(principalId, actionItem),
                    customActionListAttribute.getDocHandlerDisplayParameters(principalId, actionItem)).build();
            // add to our results
            actionItemCustomizations.add(actionItemCustomization);

        } catch (Exception e) {
            LOG.error("Problem loading custom action list attribute for action item " + actionItem.getId(), e);
        }
    }

    return actionItemCustomizations;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
public List<ActionItem> getActionItemsForPrincipal(String principalId) {
    incomingParamCheck(principalId, "principalId");
    Collection<org.kuali.rice.kew.actionitem.ActionItem> actionItems
            = KEWServiceLocator.getActionListService().getActionList(principalId, null);
    List<ActionItem> actionItemVOs = new ArrayList<ActionItem>(actionItems.size());
    for (org.kuali.rice.kew.actionitem.ActionItem actionItem : actionItems) {
        actionItemVOs.add(org.kuali.rice.kew.actionitem.ActionItem.to(actionItem));
    }
    return actionItemVOs;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
public List<ActionItem> getAllActionItems(String documentId) {
    incomingParamCheck(documentId, "documentId");
    Collection<org.kuali.rice.kew.actionitem.ActionItem> actionItems
            = KEWServiceLocator.getActionListService().getActionListForSingleDocument(documentId);
    List<ActionItem> actionItemVOs = new ArrayList<ActionItem>(actionItems.size());
    for (org.kuali.rice.kew.actionitem.ActionItem actionItem : actionItems) {
        actionItemVOs.add(org.kuali.rice.kew.actionitem.ActionItem.to(actionItem));
    }
    return actionItemVOs;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
public List<ActionItem> getActionItems(String documentId, List<String> actionRequestedCodes) {
    incomingParamCheck(documentId, "documentId");
    List<ActionItem> actionItems = getAllActionItems(documentId);
    List<ActionItem> matchingActionitems = new ArrayList<ActionItem>();
    for (ActionItem actionItemVO : actionItems) {
        if (actionRequestedCodes.contains(actionItemVO.getActionRequestCd())) {
            matchingActionitems.add(actionItemVO);
        }
    }
    return matchingActionitems;
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Override
protected void sendNotification(ActionItem actionItem) {
    super.sendNotification(actionItem);

    String enableKENNotificationValue = ConfigContext.getCurrentContextConfig().getProperty(KewApiConstants.ENABLE_KEN_NOTIFICATION);
    boolean enableKENNotification = Boolean.parseBoolean(enableKENNotificationValue);
    // we only send per-user messages to KCB
    if (!enableKENNotification || actionItem.getPrincipalId() != null)
        return;


    // send it off to KCB if available
    MessagingService ms = (MessagingService) GlobalResourceLoader.getService(new QName(KCBConstants.SERVICE_NAMESPACE, KCBServiceNames.KCB_MESSAGING));
    if (ms == null) {
    	LOG.info("Could not locate KCB MessagingService.  Message will not be forwarded to the KCB.");
    	return;
    }
    MessageDTO mvo = new MessageDTO();
    mvo.setChannel("KEW");
    mvo.setContent("i'm a kew notification");
    mvo.setContentType("KEW notification");
    mvo.setDeliveryType(actionItem.getActionRequestCd());
    mvo.setProducer("[email protected]");
    mvo.setTitle(actionItem.getDocLabel() + " - " + actionItem.getDocName() + " - " + actionItem.getDocTitle());
    if (StringUtils.isNotBlank(actionItem.getDocHandlerURL())) {
    	mvo.setUrl(actionItem.getDocHandlerURL() + "?docId=" + actionItem.getDocumentId());
    }
    mvo.setOriginId(String.valueOf(actionItem.getId()));
    try {
        // just assume it's a user at this point...
        mvo.setRecipient(actionItem.getPrincipalId());
        LOG.debug("Sending message to KCB: " + mvo);
        ms.deliver(mvo);
    } catch (Exception e) {
        throw new WorkflowRuntimeException("could not deliver message to KCB", e);
    }
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
/**
 * Queues up immediate email processors for ActionItem notification.  Prioritizes the list of
 * Action Items passed in and attempts to not send out multiple emails to the same user.
 */
public void notify(List<ActionItem> actionItems) {
	// sort the list of action items using the same comparator as the Action List
	Collections.sort(actionItems, notificationPriorityComparator);
	Set sentNotifications = new HashSet();
	for (Iterator iterator = actionItems.iterator(); iterator.hasNext();) {
		ActionItem actionItem = (ActionItem) iterator.next();
           if (!sentNotifications.contains(actionItem.getPrincipalId()) && shouldNotify(actionItem)) {
               sentNotifications.add(actionItem.getPrincipalId());
			sendNotification(actionItem);
		}
	}
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
protected boolean shouldNotify(ActionItem actionItem) {
	try {
           boolean sendEmail = true;
           // Removed preferences items since they will be checked before it sends
           // the email in the action list email service

		// don't send notification if this action item came from a SAVE action and the NOTIFY_ON_SAVE policy is not set
		if (sendEmail && isItemOriginatingFromSave(actionItem) && !shouldNotifyOnSave(actionItem)) {
			sendEmail = false;
		}
		return sendEmail;
	} catch (Exception e) {
		throw new WorkflowRuntimeException("Error loading user with workflow id " + actionItem.getPrincipalId() + " for notification.", e);
	}
}
 

import org.kuali.rice.kew.api.action.ActionItem; //导入依赖的package包/类
@Test public void testApplicationServiceMediation() {

        //
        // Create our test ActionItems to customize
        //

        ActionItem.Builder fooActionItemBuilder = ActionItem.Builder.create(
                "321", "A", "234", DateTime.now(), "Foo Doc Label", "http://asdf.com/", "FooDocType", "345", "gilesp"
        );
        fooActionItemBuilder.setId(FOO_ACTION_ITEM_ID);

        ActionItem.Builder barActionItemBuilder = ActionItem.Builder.create(
                "322", "A", "235", DateTime.now(), "Bar Doc Label", "http://asdf.com/", "BarDocType", "346", "gilesp"
        );
        fooActionItemBuilder.setId(DEFAULT_ACTION_ITEM_ID);

        ArrayList<ActionItem> actionItems = new ArrayList<ActionItem>();
        actionItems.add(fooActionItemBuilder.build());
        actionItems.add(barActionItemBuilder.build());

        Map<String, ActionItemCustomization> customizations = mediator.getActionListCustomizations("gilesp", actionItems);

        assertTrue(customizations.size() == 2);
        // this proves that the appropriate services were called by the mediator
        assertEquals(fooResult, customizations.get(fooResult.getActionItemId()));
        assertEquals(defaultResult, customizations.get(defaultResult.getActionItemId()));
    }