Esempio n. 1
0
 /*
  * Creates a task pool for a given step
  */
 @Override
 public void createPoolTasks(
     Context context,
     XmlWorkflowItem wi,
     RoleMembers assignees,
     Step step,
     WorkflowActionConfig action)
     throws SQLException, AuthorizeException {
   // create a tasklist entry for each eperson
   for (EPerson anEpa : assignees.getEPersons()) {
     PoolTask task = poolTaskService.create(context);
     task.setStepID(step.getId());
     task.setWorkflowID(step.getWorkflow().getID());
     task.setEperson(anEpa);
     task.setActionID(action.getId());
     task.setWorkflowItem(wi);
     poolTaskService.update(context, task);
     // Make sure this user has a task
     grantUserAllItemPolicies(context, wi.getItem(), anEpa);
   }
   for (Group group : assignees.getGroups()) {
     PoolTask task = poolTaskService.create(context);
     task.setStepID(step.getId());
     task.setWorkflowID(step.getWorkflow().getID());
     task.setGroup(group);
     task.setActionID(action.getId());
     task.setWorkflowItem(wi);
     poolTaskService.update(context, task);
     // Make sure this user has a task
     grantGroupAllItemPolicies(context, wi.getItem(), group);
   }
 }
Esempio n. 2
0
 /*
  * Claims an action for a given eperson
  */
 @Override
 public void createOwnedTask(
     Context context, XmlWorkflowItem wi, Step step, WorkflowActionConfig action, EPerson e)
     throws SQLException, AuthorizeException {
   ClaimedTask task = claimedTaskService.create(context);
   task.setWorkflowItem(wi);
   task.setStepID(step.getId());
   task.setActionID(action.getId());
   task.setOwner(e);
   task.setWorkflowID(step.getWorkflow().getID());
   claimedTaskService.update(context, task);
   // Make sure this user has a task
   grantUserAllItemPolicies(context, wi.getItem(), e);
 }
Esempio n. 3
0
  protected WorkflowActionConfig processNextStep(
      Context c,
      EPerson user,
      Workflow workflow,
      ActionResult currentOutcome,
      XmlWorkflowItem wfi,
      Step nextStep)
      throws SQLException, IOException, AuthorizeException, WorkflowException,
          WorkflowConfigurationException {
    WorkflowActionConfig nextActionConfig;
    if (nextStep != null) {
      nextActionConfig = nextStep.getUserSelectionMethod();
      nextActionConfig.getProcessingAction().activate(c, wfi);
      //                nextActionConfig.getProcessingAction().generateTasks();

      if (nextActionConfig.requiresUI()) {
        // Since a new step has been started, stop executing actions once one with a user interface
        // is present.
        c.restoreAuthSystemState();
        return nextActionConfig;
      } else {
        ActionResult newOutcome =
            nextActionConfig.getProcessingAction().execute(c, wfi, nextStep, null);
        c.restoreAuthSystemState();
        return processOutcome(c, user, workflow, nextStep, nextActionConfig, newOutcome, wfi, true);
      }
    } else {
      if (currentOutcome.getResult() != ActionResult.OUTCOME_COMPLETE) {
        c.restoreAuthSystemState();
        throw new WorkflowException(
            "No alternate step was found for outcome: " + currentOutcome.getResult());
      }
      archive(c, wfi);
      c.restoreAuthSystemState();
      return null;
    }
  }
Esempio n. 4
0
 /*
  * 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);
   }
 }
Esempio n. 5
0
  protected void activateFirstStep(
      Context context, Workflow wf, Step firstStep, XmlWorkflowItem wfi)
      throws AuthorizeException, IOException, SQLException, WorkflowException,
          WorkflowConfigurationException {
    WorkflowActionConfig firstActionConfig = firstStep.getUserSelectionMethod();
    firstActionConfig.getProcessingAction().activate(context, wfi);
    log.info(
        LogManager.getHeader(
            context,
            "start_workflow",
            firstActionConfig.getProcessingAction()
                + " workflow_item_id="
                + wfi.getID()
                + "item_id="
                + wfi.getItem().getID()
                + "collection_id="
                + wfi.getCollection().getID()));

    // record the start of the workflow w/provenance message
    recordStart(context, wfi.getItem(), firstActionConfig.getProcessingAction());

    // Fire an event !
    logWorkflowEvent(
        context,
        firstStep.getWorkflow().getID(),
        null,
        null,
        wfi,
        null,
        firstStep,
        firstActionConfig);

    // If we don't have a UI activate it
    if (!firstActionConfig.requiresUI()) {
      ActionResult outcome =
          firstActionConfig.getProcessingAction().execute(context, wfi, firstStep, null);
      processOutcome(context, null, wf, firstStep, firstActionConfig, outcome, wfi, true);
    }
  }
Esempio n. 6
0
  protected void logWorkflowEvent(
      Context c,
      String workflowId,
      String previousStepId,
      String previousActionConfigId,
      XmlWorkflowItem wfi,
      EPerson actor,
      Step newStep,
      WorkflowActionConfig newActionConfig)
      throws SQLException {
    try {
      // Fire an event so we can log our action !
      Item item = wfi.getItem();
      Collection myCollection = wfi.getCollection();
      String workflowStepString = null;

      List<EPerson> currentEpersonOwners = new ArrayList<EPerson>();
      List<Group> currentGroupOwners = new ArrayList<Group>();
      // These are only null if our item is sent back to the submission
      if (newStep != null && newActionConfig != null) {
        workflowStepString = workflowId + "." + newStep.getId() + "." + newActionConfig.getId();

        // Retrieve the current owners of the task
        List<ClaimedTask> claimedTasks = claimedTaskService.find(c, wfi, newStep.getId());
        List<PoolTask> pooledTasks = poolTaskService.find(c, wfi);
        for (PoolTask poolTask : pooledTasks) {
          if (poolTask.getEperson() != null) {
            currentEpersonOwners.add(poolTask.getEperson());
          } else {
            currentGroupOwners.add(poolTask.getGroup());
          }
        }
        for (ClaimedTask claimedTask : claimedTasks) {
          currentEpersonOwners.add(claimedTask.getOwner());
        }
      }
      String previousWorkflowStepString = null;
      if (previousStepId != null && previousActionConfigId != null) {
        previousWorkflowStepString =
            workflowId + "." + previousStepId + "." + previousActionConfigId;
      }

      // Fire our usage event !
      UsageWorkflowEvent usageWorkflowEvent =
          new UsageWorkflowEvent(
              c, item, wfi, workflowStepString, previousWorkflowStepString, myCollection, actor);

      usageWorkflowEvent.setEpersonOwners(
          currentEpersonOwners.toArray(new EPerson[currentEpersonOwners.size()]));
      usageWorkflowEvent.setGroupOwners(
          currentGroupOwners.toArray(new Group[currentGroupOwners.size()]));

      DSpaceServicesFactory.getInstance().getEventService().fireEvent(usageWorkflowEvent);
    } catch (Exception e) {
      // Catch all errors we do not want our workflow to crash because the logging threw an
      // exception
      log.error(
          LogManager.getHeader(
              c, "Error while logging workflow event", "Workflow Item: " + wfi.getID()),
          e);
    }
  }
Esempio n. 7
0
  @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");
  }