Java Code Examples for org.activiti.engine.delegate.Expression#getValue()

@Override
public void execute(DelegateExecution execution) {
  
  // just a quick check to avoid creating a specific test for it
  int nrOfFieldExtensions = DelegateHelper.getFields(execution).size();
  if (nrOfFieldExtensions != 3) {
    throw new RuntimeException("Error: 3 field extensions expected, but was " + nrOfFieldExtensions);
  }
  
  Expression fieldAExpression = DelegateHelper.getFieldExpression(execution, "fieldA");
  Number fieldA = (Number) fieldAExpression.getValue(execution);
  
  Expression fieldBExpression = DelegateHelper.getFieldExpression(execution, "fieldB");
  Number fieldB = (Number) fieldBExpression.getValue(execution);
  
  int result = fieldA.intValue() + fieldB.intValue();
  
  String resultVariableName = DelegateHelper.getFieldExpression(execution, "resultVariableName").getValue(execution).toString();
  execution.setVariable(resultVariableName, result);
}
 

public void completing(DelegateExecution execution, DelegateExecution subProcessInstance) throws Exception {
  // only data. no control flow available on this execution.

  ExpressionManager expressionManager = Context.getProcessEngineConfiguration().getExpressionManager();

  // copy process variables
  ExecutionEntity executionEntity = (ExecutionEntity) execution;
  CallActivity callActivity = (CallActivity) executionEntity.getCurrentFlowElement();
  for (IOParameter ioParameter : callActivity.getOutParameters()) {
    Object value = null;
    if (StringUtils.isNotEmpty(ioParameter.getSourceExpression())) {
      Expression expression = expressionManager.createExpression(ioParameter.getSourceExpression().trim());
      value = expression.getValue(subProcessInstance);

    } else {
      value = subProcessInstance.getVariable(ioParameter.getSource());
    }
    execution.setVariable(ioParameter.getTarget(), value);
  }
}
 

public boolean evaluate(String sequenceFlowId, DelegateExecution execution) {
  String conditionExpression = null;
  if (Context.getProcessEngineConfiguration().isEnableProcessDefinitionInfoCache()) {
    ObjectNode elementProperties = Context.getBpmnOverrideElementProperties(sequenceFlowId, execution.getProcessDefinitionId());
    conditionExpression = getActiveValue(initialConditionExpression, DynamicBpmnConstants.SEQUENCE_FLOW_CONDITION, elementProperties);
  } else {
    conditionExpression = initialConditionExpression;
  }
  
  Expression expression = Context.getProcessEngineConfiguration().getExpressionManager().createExpression(conditionExpression);
  Object result = expression.getValue(execution);
  
  if (result==null) {
    throw new ActivitiException("condition expression returns null");
  }
  if (! (result instanceof Boolean)) {
    throw new ActivitiException("condition expression returns non-Boolean: "+result+" ("+result.getClass().getName()+")");
  }
  return (Boolean) result;
}
 

public static Object resolveDelegateExpression(Expression expression, 
    VariableScope variableScope, List<FieldDeclaration> fieldDeclarations) {
  
  // Note: we can't cache the result of the expression, because the
  // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'
  Object delegate = expression.getValue(variableScope);
  
  if (fieldDeclarations != null && fieldDeclarations.size() > 0) {
    
    DelegateExpressionFieldInjectionMode injectionMode = Context.getProcessEngineConfiguration().getDelegateExpressionFieldInjectionMode();
    if (injectionMode.equals(DelegateExpressionFieldInjectionMode.COMPATIBILITY)) {
      ClassDelegate.applyFieldDeclaration(fieldDeclarations, delegate, true);
    } else if (injectionMode.equals(DelegateExpressionFieldInjectionMode.MIXED)) {
      ClassDelegate.applyFieldDeclaration(fieldDeclarations, delegate, false);
    }
    
  }
  
  return delegate;
}
 

public static Object resolveDelegateExpression(Expression expression, 
    VariableScope variableScope, List<FieldDeclaration> fieldDeclarations) {
  
  // Note: we can't cache the result of the expression, because the
  // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}'
  Object delegate = expression.getValue(variableScope);
  
  if (fieldDeclarations != null && fieldDeclarations.size() > 0) {
    
    DelegateExpressionFieldInjectionMode injectionMode = Context.getProcessEngineConfiguration().getDelegateExpressionFieldInjectionMode();
    if (injectionMode.equals(DelegateExpressionFieldInjectionMode.COMPATIBILITY)) {
      ClassDelegate.applyFieldDeclaration(fieldDeclarations, delegate, true);
    } else if (injectionMode.equals(DelegateExpressionFieldInjectionMode.MIXED)) {
      ClassDelegate.applyFieldDeclaration(fieldDeclarations, delegate, false);
    }
    
  }
  
  return delegate;
}
 

protected String getStringFromField(Expression expression, DelegateExecution execution) {
  if (expression != null) {
    Object value = expression.getValue(execution);
    if (value != null) {
      return value.toString();
    }
  }
  return null;
}
 

@Override
public void notify(DelegateExecution execution) {
  Expression inputExpression = DelegateHelper.getFieldExpression(execution, "input");
  Number input = (Number) inputExpression.getValue(execution);
  
  int result = input.intValue() * 100;
  
  Expression resultVarExpression = DelegateHelper.getFieldExpression(execution, "resultVar");
  execution.setVariable(resultVarExpression.getValue(execution).toString(), result);
}
 

private Object checkAllowedTypes(Expression expression, DelegateExecution execution) {
  if (expression == null) {
    return null;
  }
  Object value = expression.getValue(execution);
  if (value == null) {
    return null;
  }
  for (Class<?> allowedType : ALLOWED_ATT_TYPES) {
    if (allowedType.isInstance(value)) {
      return value;
    }
  }
  throw new ActivitiException("Invalid attachment type: " + value.getClass());
}
 

public static boolean shouldSkipFlowElement(DelegateExecution execution, Expression skipExpression) {
  Object value = skipExpression.getValue(execution);

  if (value instanceof Boolean) {
    return ((Boolean) value).booleanValue();

  } else {
    throw new ActivitiIllegalArgumentException("Skip expression does not resolve to a boolean: " + skipExpression.getExpressionText());
  }
}
 

public static boolean shouldSkipFlowElement(CommandContext commandContext, DelegateExecution execution, String skipExpressionString) {
  Expression skipExpression = commandContext.getProcessEngineConfiguration().getExpressionManager().createExpression(skipExpressionString);
  Object value = skipExpression.getValue(execution);

  if (value instanceof Boolean) {
    return ((Boolean) value).booleanValue();

  } else {
    throw new ActivitiIllegalArgumentException("Skip expression does not resolve to a boolean: " + skipExpression.getExpressionText());
  }
}
 

protected String getStringFromField(Expression expression, DelegateExecution execution) {
  if (expression != null) {
    Object value = expression.getValue(execution);
    if (value != null) {
      return value.toString();
    }
  }
  return null;
}
 

protected String getExpressionString(Expression expression, VariableScope variableScope) 
{
    if (expression != null) 
    {
        return (String) expression.getValue(variableScope);
    }
    return null;
}
 

private Object checkAllowedTypes(Expression expression, DelegateExecution execution) {
  if (expression == null) {
    return null;
  }
  Object value = expression.getValue(execution);
  if (value == null) {
    return null;
  }
  for (Class<?> allowedType : ALLOWED_ATT_TYPES) {
    if (allowedType.isInstance(value)) {
      return value;
    }
  }
  throw new ActivitiException("Invalid attachment type: " + value.getClass());
}
 

protected String getStringFromField(Expression expression, DelegateExecution execution) {
  if (expression != null) {
    Object value = expression.getValue(execution);
    if (value != null) {
      return value.toString();
    }
  }
  return null;
}
 

public static boolean shouldSkipFlowElement(ActivityExecution execution, Expression skipExpression) {
  Object value = skipExpression.getValue(execution);
  
  if (value instanceof Boolean) {
    return ((Boolean)value).booleanValue();
    
  } else {
    throw new ActivitiIllegalArgumentException("Skip expression does not resolve to a boolean: " + skipExpression.getExpressionText());
  }
}
 

protected String getStringFromField(Expression expression, DelegateExecution execution) {
  if (expression != null) {
    Object value = expression.getValue(execution);
    if (value != null) {
      return value.toString();
    }
  }
  return null;
}
 

@Override
public void notify(DelegateTask delegateTask) {
  Expression inputExpression = DelegateHelper.getFieldExpression(delegateTask, "input");
  Number input = (Number) inputExpression.getValue(delegateTask);
  
  int result = input.intValue() / 2;
  
  Expression resultVarExpression = DelegateHelper.getFieldExpression(delegateTask, "resultVar");
  delegateTask.setVariable(resultVarExpression.getValue(delegateTask).toString(), result);
}
 

protected void restoreExtraData(JobEntity timerEntity, VariableScope variableScope) {
  String activityId = timerEntity.getJobHandlerConfiguration();

  if (timerEntity.getJobHandlerType().equalsIgnoreCase(TimerStartEventJobHandler.TYPE) ||
      timerEntity.getJobHandlerType().equalsIgnoreCase(TriggerTimerEventJobHandler.TYPE)) {

    activityId = TimerEventHandler.getActivityIdFromConfiguration(timerEntity.getJobHandlerConfiguration());
    String endDateExpressionString = TimerEventHandler.getEndDateFromConfiguration(timerEntity.getJobHandlerConfiguration());

    if (endDateExpressionString != null) {
      Expression endDateExpression = processEngineConfiguration.getExpressionManager().createExpression(endDateExpressionString);

      String endDateString = null;

      BusinessCalendar businessCalendar = processEngineConfiguration.getBusinessCalendarManager().getBusinessCalendar(
          getBusinessCalendarName(TimerEventHandler.geCalendarNameFromConfiguration(timerEntity.getJobHandlerConfiguration()), variableScope));

      if (endDateExpression != null) {
        Object endDateValue = endDateExpression.getValue(variableScope);
        if (endDateValue instanceof String) {
          endDateString = (String) endDateValue;
        } else if (endDateValue instanceof Date) {
          timerEntity.setEndDate((Date) endDateValue);
        } else {
          throw new ActivitiException("Timer '" + ((ExecutionEntity) variableScope).getActivityId()
              + "' was not configured with a valid duration/time, either hand in a java.util.Date or a String in format 'yyyy-MM-dd'T'hh:mm:ss'");
        }

        if (timerEntity.getEndDate() == null) {
          timerEntity.setEndDate(businessCalendar.resolveEndDate(endDateString));
        }
      }
    }
  }

  int maxIterations = 1;
  if (timerEntity.getProcessDefinitionId() != null) {
    org.activiti.bpmn.model.Process process = ProcessDefinitionUtil.getProcess(timerEntity.getProcessDefinitionId());
    maxIterations = getMaxIterations(process, activityId);
    if (maxIterations <= 1) {
      maxIterations = getMaxIterations(process, activityId);
    }
  }
  timerEntity.setMaxIterations(maxIterations);
}
 

protected void restoreExtraData(CommandContext commandContext, String jobHandlerConfiguration) {
  String embededActivityId = jobHandlerConfiguration;

  if (jobHandlerType.equalsIgnoreCase(TimerExecuteNestedActivityJobHandler.TYPE) ||
          jobHandlerType.equalsIgnoreCase(TimerCatchIntermediateEventJobHandler.TYPE) ||
          jobHandlerType.equalsIgnoreCase(TimerStartEventJobHandler.TYPE)) {

    embededActivityId = TimerEventHandler.getActivityIdFromConfiguration(jobHandlerConfiguration);

    String endDateExpressionString = TimerEventHandler.getEndDateFromConfiguration(jobHandlerConfiguration);

    if (endDateExpressionString!=null) {
       Expression endDateExpression = Context.getProcessEngineConfiguration().getExpressionManager().createExpression(endDateExpressionString);

      String endDateString = null;

      BusinessCalendar businessCalendar = Context.getProcessEngineConfiguration().getBusinessCalendarManager()
          .getBusinessCalendar(getBusinessCalendarName(TimerEventHandler.geCalendarNameFromConfiguration(jobHandlerConfiguration)));

      VariableScope executionEntity = null;
      if (executionId != null) {
        executionEntity = commandContext.getExecutionEntityManager().findExecutionById(executionId);
      }
      
      if (executionEntity == null) {
        executionEntity = NoExecutionVariableScope.getSharedInstance();
      }

      if (endDateExpression != null) {
        Object endDateValue = endDateExpression.getValue(executionEntity);
        if (endDateValue instanceof String) {
          endDateString = (String) endDateValue;
        } else if (endDateValue instanceof Date) {
          endDate = (Date) endDateValue;
        } else {
          throw new ActivitiException("Timer '" + ((ExecutionEntity) executionEntity).getActivityId()
                  + "' was not configured with a valid duration/time, either hand in a java.util.Date or a String in format 'yyyy-MM-dd'T'hh:mm:ss'");
        }

        if (endDate == null) {
          endDate = businessCalendar.resolveEndDate(endDateString);
        }
      }
    }
  }

   if (processDefinitionId != null) {
    ProcessDefinition def = Context.getProcessEngineConfiguration().getRepositoryService().getProcessDefinition(processDefinitionId);
    maxIterations = checkStartEventDefinitions(def, embededActivityId);
    if (maxIterations <= 1) {
      maxIterations = checkBoundaryEventsDefinitions(def, embededActivityId);
    }
  } else {
    maxIterations = 1;
  }
}
 

/**
 * Gets an expression variable from the execution. This method will return null if the expression is null (i.e. when a workflow doesn't define the
 * expression).
 *
 * @param expression the expression variable to get.
 * @param execution the execution that contains the variable value.
 *
 * @return the variable value or null if the expression is null.
 */
public Object getExpressionVariable(Expression expression, DelegateExecution execution)
{
    return (expression == null ? null : expression.getValue(execution));
}