@Override
public void removeClaimedUser(Context context, XmlWorkflowItem wfi, EPerson user, String stepID)
throws SQLException, IOException, WorkflowConfigurationException, AuthorizeException {
// Check if we had reached our max number @ this moment
int totalUsers =
inProgressUserService.getNumberOfInProgressUsers(context, wfi)
+ inProgressUserService.getNumberOfFinishedUsers(context, wfi);
// Then remove the current user from the inProgressUsers
inProgressUserService.delete(
context, inProgressUserService.findByWorkflowItemAndEPerson(context, wfi, user));
Workflow workflow = workflowFactory.getWorkflow(wfi.getCollection());
Step step = workflow.getStep(stepID);
// WorkflowManager.deleteOwnedTask(c, user, wfi, step, step.getActionConfig());
// We had reached our total user, so recreate tasks for the user who don't have one
if (totalUsers == step.getRequiredUsers()) {
// Create a list of the users we are to ignore
List<InProgressUser> toIgnore = inProgressUserService.findByWorkflowItem(context, wfi);
// Remove the users to ignore
RoleMembers roleMembers = step.getRole().getMembers(context, wfi);
// Create a list out all the users we are to pool a task for
for (InProgressUser ipu : toIgnore) {
roleMembers.removeEperson(ipu.getUser());
}
step.getUserSelectionMethod()
.getProcessingAction()
.regenerateTasks(context, wfi, roleMembers);
} else {
// If the user previously had a personal PoolTask, this must be regenerated. Therefore we call
// the regeneration method
// with only one EPerson
RoleMembers role = step.getRole().getMembers(context, wfi);
List<EPerson> epersons = role.getEPersons();
for (EPerson eperson : epersons) {
if (eperson.getID().equals(user.getID())) {
RoleMembers memberToRegenerateTasksFor = new RoleMembers();
memberToRegenerateTasksFor.addEPerson(user);
step.getUserSelectionMethod()
.getProcessingAction()
.regenerateTasks(context, wfi, memberToRegenerateTasksFor);
break;
}
}
}
// Update our item
itemService.update(context, wfi.getItem());
}
@Override
public XmlWorkflowItem start(Context context, WorkspaceItem wsi)
throws SQLException, AuthorizeException, IOException, WorkflowException {
try {
Item myitem = wsi.getItem();
Collection collection = wsi.getCollection();
Workflow wf = xmlWorkflowFactory.getWorkflow(collection);
XmlWorkflowItem wfi = xmlWorkflowItemService.create(context, myitem, collection);
wfi.setMultipleFiles(wsi.hasMultipleFiles());
wfi.setMultipleTitles(wsi.hasMultipleTitles());
wfi.setPublishedBefore(wsi.isPublishedBefore());
xmlWorkflowItemService.update(context, wfi);
removeUserItemPolicies(context, myitem, myitem.getSubmitter());
grantSubmitterReadPolicies(context, myitem);
context.turnOffAuthorisationSystem();
Step firstStep = wf.getFirstStep();
if (firstStep.isValidStep(context, wfi)) {
activateFirstStep(context, wf, firstStep, wfi);
} else {
// Get our next step, if none is found, archive our item
firstStep = wf.getNextStep(context, wfi, firstStep, ActionResult.OUTCOME_COMPLETE);
if (firstStep == null) {
archive(context, wfi);
} else {
activateFirstStep(context, wf, firstStep, wfi);
}
}
// remove the WorkspaceItem
workspaceItemService.deleteWrapper(context, wsi);
context.restoreAuthSystemState();
return wfi;
} catch (WorkflowConfigurationException e) {
throw new WorkflowException(e);
}
}
/*
* Executes an action and returns the next.
*/
@Override
public WorkflowActionConfig doState(
Context c,
EPerson user,
HttpServletRequest request,
int workflowItemId,
Workflow workflow,
WorkflowActionConfig currentActionConfig)
throws SQLException, AuthorizeException, IOException, MessagingException, WorkflowException {
try {
XmlWorkflowItem wi = xmlWorkflowItemService.find(c, workflowItemId);
Step currentStep = currentActionConfig.getStep();
if (currentActionConfig.getProcessingAction().isAuthorized(c, request, wi)) {
ActionResult outcome =
currentActionConfig.getProcessingAction().execute(c, wi, currentStep, request);
return processOutcome(
c, user, workflow, currentStep, currentActionConfig, outcome, wi, false);
} else {
throw new AuthorizeException("You are not allowed to to perform this task.");
}
} catch (WorkflowConfigurationException e) {
log.error(
LogManager.getHeader(
c,
"error while executing state",
"workflow: "
+ workflow.getID()
+ " action: "
+ currentActionConfig.getId()
+ " workflowItemId: "
+ workflowItemId),
e);
WorkflowUtils.sendAlert(request, e);
throw new WorkflowException(e);
}
}
@Override
public WorkflowActionConfig processOutcome(
Context c,
EPerson user,
Workflow workflow,
Step currentStep,
WorkflowActionConfig currentActionConfig,
ActionResult currentOutcome,
XmlWorkflowItem wfi,
boolean enteredNewStep)
throws IOException, AuthorizeException, SQLException, WorkflowException {
if (currentOutcome.getType() == ActionResult.TYPE.TYPE_PAGE
|| currentOutcome.getType() == ActionResult.TYPE.TYPE_ERROR) {
// Our outcome is a page or an error, so return our current action
c.restoreAuthSystemState();
return currentActionConfig;
} else if (currentOutcome.getType() == ActionResult.TYPE.TYPE_CANCEL
|| currentOutcome.getType() == ActionResult.TYPE.TYPE_SUBMISSION_PAGE) {
// We either pressed the cancel button or got an order to return to the submission page, so
// don't return an action
// By not returning an action we ensure ourselfs that we go back to the submission page
c.restoreAuthSystemState();
return null;
} else if (currentOutcome.getType() == ActionResult.TYPE.TYPE_OUTCOME) {
Step nextStep = null;
WorkflowActionConfig nextActionConfig = null;
try {
// We have completed our action search & retrieve the next action
if (currentOutcome.getResult() == ActionResult.OUTCOME_COMPLETE) {
nextActionConfig = currentStep.getNextAction(currentActionConfig);
}
if (nextActionConfig != null) {
// We remain in the current step since an action is found
nextStep = currentStep;
nextActionConfig.getProcessingAction().activate(c, wfi);
if (nextActionConfig.requiresUI() && !enteredNewStep) {
createOwnedTask(c, wfi, currentStep, nextActionConfig, user);
return nextActionConfig;
} else if (nextActionConfig.requiresUI() && enteredNewStep) {
// We have entered a new step and have encountered a UI, return null since the current
// user doesn't have anything to do with this
c.restoreAuthSystemState();
return null;
} else {
ActionResult newOutcome =
nextActionConfig.getProcessingAction().execute(c, wfi, currentStep, null);
return processOutcome(
c, user, workflow, currentStep, nextActionConfig, newOutcome, wfi, enteredNewStep);
}
} else if (enteredNewStep) {
// If the user finished his/her step, we keep processing until there is a UI step action
// or no step at all
nextStep = workflow.getNextStep(c, wfi, currentStep, currentOutcome.getResult());
c.turnOffAuthorisationSystem();
nextActionConfig = processNextStep(c, user, workflow, currentOutcome, wfi, nextStep);
// If we require a user interface return null so that the user is redirected to the
// "submissions page"
if (nextActionConfig == null || nextActionConfig.requiresUI()) {
return null;
} else {
return nextActionConfig;
}
} else {
ClaimedTask task = claimedTaskService.findByWorkflowIdAndEPerson(c, wfi, user);
// Check if we have a task for this action (might not be the case with automatic steps)
// First add it to our list of finished users, since no more actions remain
workflowRequirementsService.addFinishedUser(c, wfi, user);
c.turnOffAuthorisationSystem();
// Check if our requirements have been met
if ((currentStep.isFinished(c, wfi)
&& currentOutcome.getResult() == ActionResult.OUTCOME_COMPLETE)
|| currentOutcome.getResult() != ActionResult.OUTCOME_COMPLETE) {
// Delete all the table rows containing the users who performed this task
workflowRequirementsService.clearInProgressUsers(c, wfi);
// Remove all the tasks
deleteAllTasks(c, wfi);
nextStep = workflow.getNextStep(c, wfi, currentStep, currentOutcome.getResult());
nextActionConfig = processNextStep(c, user, workflow, currentOutcome, wfi, nextStep);
// If we require a user interface return null so that the user is redirected to the
// "submissions page"
if (nextActionConfig == null || nextActionConfig.requiresUI()) {
return null;
} else {
return nextActionConfig;
}
} else {
// We are done with our actions so go to the submissions page but remove action
// ClaimedAction first
deleteClaimedTask(c, wfi, task);
c.restoreAuthSystemState();
nextStep = currentStep;
nextActionConfig = currentActionConfig;
return null;
}
}
} catch (Exception e) {
log.error("error while processing workflow outcome", e);
e.printStackTrace();
} finally {
if ((nextStep != null && currentStep != null && nextActionConfig != null)
|| (wfi.getItem().isArchived() && currentStep != null)) {
logWorkflowEvent(
c,
currentStep.getWorkflow().getID(),
currentStep.getId(),
currentActionConfig.getId(),
wfi,
user,
nextStep,
nextActionConfig);
}
}
}
log.error(LogManager.getHeader(c, "Invalid step outcome", "Workflow item id: " + wfi.getID()));
throw new WorkflowException("Invalid step outcome");
}