Java ActionItem类代码示例

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
protected boolean activateRequest(RouteContext context, ActionRequestValue actionRequest,
        RouteNodeInstance nodeInstance, List<ActionItem> generatedActionItems) {
    if (actionRequest.isRoleRequest()) {
        List<ActionRequestValue> actionRequests =
                KEWServiceLocator.getActionRequestService().findPendingRootRequestsByDocIdAtRouteNode(
                        actionRequest.getDocumentId(), nodeInstance.getRouteNodeInstanceId());
        for (ActionRequestValue siblingRequest : actionRequests) {
            if (actionRequest.getRoleName().equals(siblingRequest.getRoleName())) {
                KEWServiceLocator.getActionRequestService().activateRequestNoNotification(siblingRequest,
                        context.getActivationContext());
                // the generated action items can be found in the activation context
                generatedActionItems.addAll(context.getActivationContext().getGeneratedActionItems());
            }
        }
    }
    actionRequest = KEWServiceLocator.getActionRequestService().activateRequestNoNotification(actionRequest,
            context.getActivationContext());
    // the generated action items can be found in the activation context
    generatedActionItems.addAll(context.getActivationContext().getGeneratedActionItems());
    return actionRequest.isApproveOrCompleteRequest() && !actionRequest.isDone();
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
public void takeMassActions(String principalId, List<ActionInvocation> actionInvocations) {
		Principal principal = loadPrincipal(principalId);
		for (ActionInvocation invocation : actionInvocations) {
			ActionItem actionItem = KEWServiceLocator.getActionListService().findByActionItemId(invocation.getActionItemId());
			if (actionItem == null) {
				LOG.warn("Could not locate action item for the given action item id [" + invocation.getActionItemId() + "], not taking mass action on it.");
				continue;
			}
			KEWServiceLocator.getActionListService().deleteActionItem(actionItem, true);
            DocumentRouteHeaderValue document = KEWServiceLocator.getRouteHeaderService().getRouteHeader(actionItem.getDocumentId());
            String applicationId = document.getDocumentType().getApplicationId();
			ActionInvocationQueue actionInvocQueue = KewApiServiceLocator.getActionInvocationProcessorService(
                    document.getDocumentId(), applicationId);
			actionInvocQueue.invokeAction(principalId, actionItem.getDocumentId(), invocation);
//			ActionInvocationQueueImpl.queueActionInvocation(user, actionItem.getDocumentId(), invocation);
		}
	}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
@Override
protected void sendPeriodicReminder(String principalId, Collection<ActionItem> actionItems, String emailSetting) {
    actionItems = filterActionItemsToNotify(principalId, actionItems, emailSetting);
    Collection<org.kuali.rice.kew.api.action.ActionItem> apiActionItems = new ArrayList<org.kuali.rice.kew.api.action.ActionItem>();
    for(ActionItem actionItem : actionItems) {
        apiActionItems.add(ActionItem.to(actionItem));
    }
    // if there are no action items after being filtered, there's no
    // reason to send the email
    if (actionItems.isEmpty()) {
        return;
    }
    EmailContent content;
    Person person = KimApiServiceLocator.getPersonService().getPerson(principalId);
    if (KewApiConstants.EMAIL_RMNDR_DAY_VAL.equals(emailSetting)) {
        content = getEmailContentGenerator().generateDailyReminder(person, apiActionItems);
    } else if (KewApiConstants.EMAIL_RMNDR_WEEK_VAL.equals(emailSetting)) {
        content = getEmailContentGenerator().generateWeeklyReminder(person, apiActionItems);
    } else {
        // else...refactor this...
        throw new RuntimeException("invalid email setting. this code needs refactoring");
    }
    sendEmail(person, new EmailSubject(content.getSubject()), new EmailBody(content.getBody()));
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
@Override
public void sendDailyReminder() {
    LOG.info("Starting SendDailyReminder");
    if (sendActionListEmailNotification()) {
        Collection<String> users = getUsersWithEmailSetting(KewApiConstants.EMAIL_RMNDR_DAY_VAL);
        for (Iterator<String> userIter = users.iterator(); userIter.hasNext();) {
        	String principalId = userIter.next();
            try {
                Collection<ActionItem> actionItems = getActionListService().getActionList(principalId, null);
                if (actionItems != null && actionItems.size() > 0) {
                    sendPeriodicReminder(principalId, actionItems,
                            KewApiConstants.EMAIL_RMNDR_DAY_VAL);
                }
            } catch (Exception e) {
                LOG.error("Error sending daily action list reminder to user: " + principalId, e);
            }
        }
    }
    LOG.info("Daily action list emails successfully sent");
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
@Override
public void sendWeeklyReminder() {
    LOG.info("Starting sendWeeklyReminder");
    if (sendActionListEmailNotification()) {
        Collection<String> users = getUsersWithEmailSetting(KewApiConstants.EMAIL_RMNDR_WEEK_VAL);
        for (Iterator<String> userIter = users.iterator(); userIter.hasNext();) {
        	String principalId = userIter.next();
            try {
                Collection<ActionItem> actionItems = getActionListService().getActionList(principalId, null);
                if (actionItems != null && actionItems.size() > 0) {
                    sendPeriodicReminder(principalId, actionItems,
                            KewApiConstants.EMAIL_RMNDR_WEEK_VAL);
                }
            } catch (Exception e) {
                LOG.error("Error sending weekly action list reminder to user: " + principalId, e);
            }
        }
    }
    LOG.info("Weekly action list emails successfully sent");
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
protected void sendPeriodicReminder(String principalId, Collection<ActionItem> actionItems, String emailSetting) {
    String emailBody = null;
    actionItems = filterActionItemsToNotify(principalId, actionItems, emailSetting);
    // if there are no action items after being filtered, there's no
    // reason to send the email
    if (actionItems.isEmpty()) {
        return;
    }
    if (KewApiConstants.EMAIL_RMNDR_DAY_VAL.equals(emailSetting)) {
        emailBody = buildDailyReminderBody(actionItems);
    } else if (KewApiConstants.EMAIL_RMNDR_WEEK_VAL.equals(emailSetting)) {
        emailBody = buildWeeklyReminderBody(actionItems);
    }
    Person person = KimApiServiceLocator.getPersonService().getPerson(principalId);
    sendEmail(person, getEmailSubject(), new EmailBody(emailBody));
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
/**
 * Returns a filtered Collection of {@link ActionItem}s which are filtered according to the
 * user's preferences. If they have opted not to recieve secondary or primary delegation emails
 * then they will not be included.
 */
protected Collection<ActionItem> filterActionItemsToNotify(String principalId, Collection<ActionItem> actionItems, String emailSetting) {
    List<ActionItem> filteredItems = new ArrayList<ActionItem>();
    Preferences preferences = KewApiServiceLocator.getPreferencesService().getPreferences(principalId);
    for (ActionItem actionItem : actionItems) {
        if (!actionItem.getPrincipalId().equals(principalId)) {
            LOG.warn("Encountered an ActionItem with an incorrect workflow ID.  Was " + actionItem.getPrincipalId()
                    +
                    " but expected " + principalId);
            continue;
        }
        if (checkEmailNotificationPreferences(actionItem, preferences, emailSetting)) {
            filteredItems.add(actionItem);
        }
    }
    return filteredItems;
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
String getDailyWeeklyMessageBody(Collection<ActionItem> actionItems) {
    StringBuffer sf = new StringBuffer();
    HashMap<String, Integer> docTypes = getActionListItemsStat(actionItems);

    sf
            .append("Your Action List has "
                    + actionItems.size()
                    + " eDocs(electronic documents) that need your attention: \n\n");
    for(String docTypeName : docTypes.keySet()) {
        sf.append("\t" + ((Integer) docTypes.get(docTypeName)).toString()
                + "\t" + docTypeName + "\n");
    }
    sf.append("\n\n");
    sf.append("To respond to each of these eDocs: \n");
    sf
            .append("\tGo to "
                    + getActionListUrl()
                    + ", and then click on its numeric Document ID in the first column of the List.\n");
    sf.append("\n\n\n");
    return sf.toString();
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
private HashMap<String, Integer> getActionListItemsStat(Collection<ActionItem> actionItems) {
    HashMap<String, Integer> docTypes = new LinkedHashMap<String, Integer>();
    Collection<org.kuali.rice.kew.api.action.ActionItem> apiActionItems = new ArrayList<org.kuali.rice.kew.api.action.ActionItem>();
    for(ActionItem actionItem : actionItems) {
        apiActionItems.add(ActionItem.to(actionItem));
    }
    Map<String, DocumentRouteHeaderValue> routeHeaders = KEWServiceLocator.getRouteHeaderService().getRouteHeadersForActionItems(apiActionItems);
    Iterator<ActionItem> iter = actionItems.iterator();

    while (iter.hasNext()) {
        String docTypeName = routeHeaders.get(iter.next().getDocumentId()).getDocumentType().getName();
        if (docTypes.containsKey(docTypeName)) {
            docTypes.put(docTypeName, new Integer(docTypes.get(docTypeName).intValue() + 1));
        } else {
            docTypes.put(docTypeName, new Integer(1));
        }
    }
    return docTypes;
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
private String performReleaseWorkgroupAuthority(boolean forValidationOnly) {
    if (!KimApiServiceLocator.getGroupService().isMemberOfGroup(getPrincipal().getPrincipalId(), groupId)){
        return (getPrincipal().getPrincipalName() + " not a member of workgroup " + groupId);
    }

    List<ActionRequestValue> actionRequests = getActionRequestService().findPendingByDoc(getDocumentId());
    //List groupRequestsToActivate = new ArrayList();//requests for this group that need action items
    for (ActionRequestValue actionRequest : actionRequests)
    {
        //we left the group active from take authority action.  pending havent been normally activated yet
        if (actionRequest.isGroupRequest() && actionRequest.isActive() && actionRequest.getGroupId().equals(groupId)) {
        	List<ActionItem> actionItems = actionRequest.getActionItems();
            if (actionItems.size() == 1) {
                ActionItem actionItem = actionItems.get(0);
                if (! actionItem.getPrincipalId().equals(getPrincipal().getPrincipalId())) {
                    return "User attempting to release workgroup authority did not take it.";
                } else if (!forValidationOnly)
                {
                    actionRequest.setStatus(ActionRequestStatus.INITIALIZED.getCode());//to circumvent check in service during activation
                    getActionRequestService().activateRequest(actionRequest);
                }
            }
        }
    }
    return "";
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
/**
 * Update the user's Action List to reflect their addition to the given Workgroup.
 */
private void updateActionListForUserAddedToGroup(String principalId, String groupId) {
    List<ActionRequestValue> actionRequests = new ArrayList<ActionRequestValue>();
    List<String> parentGroupIds = KimApiServiceLocator.getGroupService().getParentGroupIds(groupId);
    List<String> allGroupsToCheck = new ArrayList<String>();
    allGroupsToCheck.add(0, groupId);
    allGroupsToCheck.addAll(parentGroupIds);
    for (String groupToCheckId : allGroupsToCheck) {
        actionRequests.addAll(getActionRequestService().findActivatedByGroup(groupToCheckId));
    }
    for (ActionRequestValue request : actionRequests) {
        ActionItem item = getActionListService().createActionItemForActionRequest(request);
        item.setPrincipalId(principalId);
        getActionListService().saveActionItem(item);
    }
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
private void updateActionListForUserRemovedFromGroup(String principalId, String groupId) {
    List<String> parentGroupIds = KimApiServiceLocator.getGroupService().getParentGroupIds(groupId);
    List<String> allGroupsToCheck = new ArrayList<String>();
    allGroupsToCheck.add(0, groupId);
    allGroupsToCheck.addAll(parentGroupIds);
    Collection<ActionItem> actionItems = getActionListService().findByPrincipalId(principalId);
    for (Iterator<ActionItem> itemIt = actionItems.iterator(); itemIt.hasNext();) {
        ActionItem item = itemIt.next();
        if (item.isWorkgroupItem()) {
            for (String groupIdToCheck : allGroupsToCheck) {
                if (item.getGroupId().equals(groupIdToCheck)) {
                    getActionListService().deleteActionItem(item);
                }
            }
        }
    }
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
/**
 * Deletes the action items for the action request
 * @param actionRequest the action request whose action items to delete
 */
private void deleteActionItems(ActionRequestValue actionRequest, boolean populateOutbox) {
	List<ActionItem> actionItems = actionRequest.getActionItems();
	if ( LOG.isDebugEnabled() ) {
		LOG.debug("deleting " + actionItems.size() + " action items for action request: " + actionRequest);
	}
    for (ActionItem actionItem: actionItems) {
    	if ( LOG.isDebugEnabled() ) {
    		LOG.debug("deleting action item: " + actionItem);
    	}
        if (populateOutbox) {
            getActionListService().deleteActionItem(actionItem);
        } else {
            getActionListService().deleteActionItemNoOutbox(actionItem);
        }
    }
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
/**
 * Deletes the action items for the *root* action request.
 *
 * @param actionRequest the action request whose action items to delete
 */
private void deleteActionItemsFromGraph(ActionRequestValue actionRequest, boolean populateOutbox) {
    if (actionRequest.getParentActionRequest() != null) {
        throw new IllegalArgumentException("Must delete action item from root of action request graph!");
    }
    List<ActionItem> actionItemsToDelete = new ArrayList<ActionItem>();
    accumulateActionItemsFromGraph(actionRequest, actionItemsToDelete);
    if ( LOG.isDebugEnabled() ) {
        LOG.debug("deleting " + actionItemsToDelete.size() + " action items for action request graph: " + actionRequest);
    }
    for (ActionItem actionItem : actionItemsToDelete) {
        if ( LOG.isDebugEnabled() ) {
            LOG.debug("deleting action item: " + actionItem);
        }
        if (populateOutbox) {
            getActionListService().deleteActionItem(actionItem);
        } else {
            getActionListService().deleteActionItemNoOutbox(actionItem);
        }
    }
}
 

import org.kuali.rice.kew.actionitem.ActionItem; //导入依赖的package包/类
@Override
public Collection<Recipient> findUserSecondaryDelegators(String principalId) {

    QueryByCriteria query = QueryByCriteria.Builder.fromPredicates(
            equal("principalId", principalId),
            equal("delegationType", DelegationType.SECONDARY.getCode()),
            or(isNotNull("delegatorPrincipalId"), isNotNull("delegatorGroupId")));

    QueryResults<ActionItem> results = dataObjectService.findMatching(ActionItem.class, query);

    Map<Object, Recipient> delegators = new HashMap<Object, Recipient>(results.getResults().size());

    for ( ActionItem actionItem : results.getResults() ) {
        String delegatorPrincipalId = actionItem.getDelegatorPrincipalId();
        String delegatorGroupId = actionItem.getDelegatorGroupId();

        if (delegatorPrincipalId != null && !delegators.containsKey(delegatorPrincipalId)) {
            delegators.put(delegatorPrincipalId,new WebFriendlyRecipient(KimApiServiceLocator.getPersonService().getPerson(delegatorPrincipalId)));
        } else if (delegatorGroupId != null && !delegators.containsKey(delegatorGroupId)) {
            delegators.put(delegatorGroupId, new KimGroupRecipient(KimApiServiceLocator.getGroupService().getGroup(delegatorGroupId)));
        }
    }

    return delegators.values();
}