Java Code Examples for org.camunda.bpm.engine.variable.Variables#untypedValue()

protected List<HistoricDecisionInputInstance> createHistoricDecisionInputInstances(DmnDecisionTableEvaluationEvent evaluationEvent, String rootProcessInstanceId, Date removalTime) {
  List<HistoricDecisionInputInstance> inputInstances = new ArrayList<HistoricDecisionInputInstance>();

  for(DmnEvaluatedInput inputClause : evaluationEvent.getInputs()) {

    HistoricDecisionInputInstanceEntity inputInstance = new HistoricDecisionInputInstanceEntity(rootProcessInstanceId, removalTime);
    inputInstance.setClauseId(inputClause.getId());
    inputInstance.setClauseName(inputClause.getName());
    inputInstance.setCreateTime(ClockUtil.getCurrentTime());

    TypedValue typedValue = Variables.untypedValue(inputClause.getValue());
    inputInstance.setValue(typedValue);

    inputInstances.add(inputInstance);
  }

  return inputInstances;
}
 

@Test
public void shouldConvertToTypedValue() {
  // given
  UntypedValueImpl untypedValue = (UntypedValueImpl) Variables.untypedValue(VARIABLE_VALUE_DATE);

  // when
  DateValue dateValue = dateValueMapper.convertToTypedValue(untypedValue);

  // then
  assertThat(dateValue.getType()).isInstanceOf(PrimitiveValueTypeImpl.DateTypeImpl.class);
  assertThat(dateValue.getValue()).isEqualTo(VARIABLE_VALUE_DATE);
}
 

public void handleSubmit(VariableScope variableScope, VariableMap values, VariableMap allValues) {
  TypedValue submittedValue = (TypedValue) values.getValueTyped(id);
  values.remove(id);

  // perform validation
  for (FormFieldValidationConstraintHandler validationHandler : validationHandlers) {
    Object value = null;
    if(submittedValue != null) {
      value = submittedValue.getValue();
    }
    validationHandler.validate(value, allValues, this, variableScope);
  }

  // update variable(s)
  TypedValue modelValue = null;
  if (submittedValue != null) {
    if (type != null) {
      modelValue = type.convertToModelValue(submittedValue);
    }
    else {
      modelValue = submittedValue;
    }
  }
  else if (defaultValueExpression != null) {
    final TypedValue expressionValue = Variables.untypedValue(defaultValueExpression.getValue(variableScope));
    if (type != null) {
      // first, need to convert to model value since the default value may be a String Constant specified in the model xml.
      modelValue = type.convertToModelValue(Variables.untypedValue(expressionValue));
    }
    else if (expressionValue != null) {
      modelValue = Variables.stringValue(expressionValue.getValue().toString());
    }
  }

  if (modelValue != null) {
    if (id != null) {
      variableScope.setVariable(id, modelValue);
    }
  }
}
 

public void initializeVariableStore(Map<String, Object> variables) {
  for (String variableName : variables.keySet()) {
    TypedValue value = Variables.untypedValue(variables.get(variableName));
    CoreVariableInstance variableValue = getVariableInstanceFactory().build(variableName, value, false);
    getVariableStore().addVariable(variableValue);
  }
}
 

/**
 * Sets a variable in the local scope. In contrast to
 * {@link #setVariableLocal(String, Object)}, the variable is transient that
 * means it will not be stored in the data base. For example, a transient
 * variable can be used for a result variable that is only available for
 * output mapping.
 */
public void setVariableLocalTransient(String variableName, Object value) {
  TypedValue typedValue = Variables.untypedValue(value, true);

  checkJavaSerialization(variableName, typedValue);

  CoreVariableInstance coreVariableInstance = getVariableInstanceFactory().build(variableName, typedValue, true);
  getVariableStore().addVariable(coreVariableInstance);
}
 

public QueryVariableValue(String name, Object value, QueryOperator operator, boolean local, boolean variableNameIgnoreCase, boolean variableValueIgnoreCase) {
  this.name = name;
  this.value = Variables.untypedValue(value);
  this.operator = operator;
  this.local = local;
  this.variableNameIgnoreCase = variableNameIgnoreCase;
  this.variableValueIgnoreCase = variableValueIgnoreCase;
}
 

public Object put(String key, Object value) {

    TypedValue typedValue = Variables.untypedValue(value);

    TypedValue prevValue = variables.put(key, typedValue);

    if(prevValue != null) {
      return prevValue.getValue();
    }
    else {
      return null;
    }
  }
 

@Override
public TypedValue transform(Object value) throws IllegalArgumentException {
  return Variables.untypedValue(value);
}
 

@Override
public TypedValue transform(Object value) throws IllegalArgumentException {
  return Variables.untypedValue(value);
}
 

@Override
public TypedValue transform(Object value) throws IllegalArgumentException {
  return Variables.untypedValue(value);
}
 

@Override
public TypedValue transform(Object value) throws IllegalArgumentException {
  return Variables.untypedValue(value);
}
 

public void setVariable(String variableName, Object value) {
  TypedValue typedValue = Variables.untypedValue(value);
  setVariable(variableName, typedValue, getSourceActivityVariableScope());

}
 

public void setVariableLocal(String variableName, Object value) {
  TypedValue typedValue = Variables.untypedValue(value);
  setVariableLocal(variableName, typedValue, getSourceActivityVariableScope());

}
 

public TypedValue toTypedValue(ProcessEngine processEngine, ObjectMapper objectMapper) {
  ValueTypeResolver valueTypeResolver = processEngine.getProcessEngineConfiguration().getValueTypeResolver();

  if (type == null) {
    if (valueInfo != null && valueInfo.get(ValueType.VALUE_INFO_TRANSIENT) instanceof Boolean) {
      return Variables.untypedValue(value, (Boolean) valueInfo.get(ValueType.VALUE_INFO_TRANSIENT));
    }
    return Variables.untypedValue(value);
  }

  ValueType valueType = valueTypeResolver.typeForName(fromRestApiTypeName(type));
  if(valueType == null) {
    throw new RestException(Status.BAD_REQUEST, String.format("Unsupported value type '%s'", type));
  }
  else {
    if(valueType instanceof PrimitiveValueType) {
      PrimitiveValueType primitiveValueType = (PrimitiveValueType) valueType;
      Class<?> javaType = primitiveValueType.getJavaType();
      Object mappedValue = null;
      try {
        if(value != null) {
          if(javaType.isAssignableFrom(value.getClass())) {
            mappedValue = value;
          }
          else {
            // use jackson to map the value to the requested java type
            mappedValue = objectMapper.readValue("\""+value+"\"", javaType);
          }
        }
        return valueType.createValue(mappedValue, valueInfo);
      }
      catch (Exception e) {
        throw new InvalidRequestException(Status.BAD_REQUEST, e,
            String.format("Cannot convert value '%s' of type '%s' to java type %s", value, type, javaType.getName()));
      }
    }
    else if(valueType instanceof SerializableValueType) {
      if(value != null && !(value instanceof String)) {
        throw new InvalidRequestException(Status.BAD_REQUEST, "Must provide 'null' or String value for value of SerializableValue type '"+type+"'.");
      }
      return ((SerializableValueType) valueType).createValueFromSerialized((String) value, valueInfo);
    }
    else if(valueType instanceof FileValueType) {

      if (value instanceof String) {
        value = Base64.decodeBase64((String) value);
      }

      return valueType.createValue(value, valueInfo);
    } else {
      return valueType.createValue(value, valueInfo);
    }
  }

}