public static HistoricVariableInstanceDto fromHistoricVariableInstance(HistoricVariableInstance historicVariableInstance)
{
HistoricVariableInstanceDto dto = new HistoricVariableInstanceDto();
dto.id = historicVariableInstance.Id;
dto.name = historicVariableInstance.Name;
dto.processDefinitionKey = historicVariableInstance.ProcessDefinitionKey;
dto.processDefinitionId = historicVariableInstance.ProcessDefinitionId;
dto.processInstanceId = historicVariableInstance.ProcessInstanceId;
dto.executionId = historicVariableInstance.ExecutionId;
dto.activityInstanceId = historicVariableInstance.ActivityInstanceId;
dto.caseDefinitionKey = historicVariableInstance.CaseDefinitionKey;
dto.caseDefinitionId = historicVariableInstance.CaseDefinitionId;
dto.caseInstanceId = historicVariableInstance.CaseInstanceId;
dto.caseExecutionId = historicVariableInstance.CaseExecutionId;
dto.taskId = historicVariableInstance.TaskId;
dto.tenantId = historicVariableInstance.TenantId;
dto.state = historicVariableInstance.State;
dto.createTime = historicVariableInstance.CreateTime;
dto.removalTime = historicVariableInstance.RemovalTime;
dto.rootProcessInstanceId = historicVariableInstance.RootProcessInstanceId;
if (string.ReferenceEquals(historicVariableInstance.ErrorMessage, null))
{
VariableValueDto.fromTypedValue(dto, historicVariableInstance.TypedValue);
}
else
{
dto.errorMessage = historicVariableInstance.ErrorMessage;
dto.type = VariableValueDto.toRestApiTypeName(historicVariableInstance.TypeName);
}
return(dto);
}
protected internal static void fromHistoricVariableUpdate(HistoricVariableUpdateDto dto, HistoricVariableUpdate historicVariableUpdate)
{
dto.revision = historicVariableUpdate.Revision;
dto.variableName = historicVariableUpdate.VariableName;
dto.variableInstanceId = historicVariableUpdate.VariableInstanceId;
if (string.ReferenceEquals(historicVariableUpdate.ErrorMessage, null))
{
try
{
VariableValueDto variableValueDto = VariableValueDto.fromTypedValue(historicVariableUpdate.TypedValue);
dto.value = variableValueDto.Value;
dto.variableType = variableValueDto.Type;
dto.valueInfo = variableValueDto.ValueInfo;
}
catch (Exception e)
{
dto.errorMessage = e.Message;
dto.variableType = VariableValueDto.toRestApiTypeName(historicVariableUpdate.TypeName);
}
}
else
{
dto.errorMessage = historicVariableUpdate.ErrorMessage;
dto.variableType = VariableValueDto.toRestApiTypeName(historicVariableUpdate.TypeName);
}
}
public static HistoricDecisionOutputInstanceDto fromHistoricDecisionOutputInstance(HistoricDecisionOutputInstance historicDecisionOutputInstance)
{
HistoricDecisionOutputInstanceDto dto = new HistoricDecisionOutputInstanceDto();
dto.id = historicDecisionOutputInstance.Id;
dto.decisionInstanceId = historicDecisionOutputInstance.DecisionInstanceId;
dto.clauseId = historicDecisionOutputInstance.ClauseId;
dto.clauseName = historicDecisionOutputInstance.ClauseName;
dto.ruleId = historicDecisionOutputInstance.RuleId;
dto.ruleOrder = historicDecisionOutputInstance.RuleOrder;
dto.variableName = historicDecisionOutputInstance.VariableName;
dto.createTime = historicDecisionOutputInstance.CreateTime;
dto.removalTime = historicDecisionOutputInstance.RemovalTime;
dto.rootProcessInstanceId = historicDecisionOutputInstance.RootProcessInstanceId;
if (string.ReferenceEquals(historicDecisionOutputInstance.ErrorMessage, null))
{
VariableValueDto.fromTypedValue(dto, historicDecisionOutputInstance.TypedValue);
}
else
{
dto.errorMessage = historicDecisionOutputInstance.ErrorMessage;
dto.type = VariableValueDto.toRestApiTypeName(historicDecisionOutputInstance.TypeName);
}
return(dto);
}
public static VariableInstanceDto fromVariableInstance(VariableInstance variableInstance)
{
VariableInstanceDto dto = new VariableInstanceDto();
dto.id = variableInstance.Id;
dto.name = variableInstance.Name;
dto.processInstanceId = variableInstance.ProcessInstanceId;
dto.executionId = variableInstance.ExecutionId;
dto.caseExecutionId = variableInstance.CaseExecutionId;
dto.caseInstanceId = variableInstance.CaseInstanceId;
dto.taskId = variableInstance.TaskId;
dto.activityInstanceId = variableInstance.ActivityInstanceId;
dto.tenantId = variableInstance.TenantId;
if (string.ReferenceEquals(variableInstance.ErrorMessage, null))
{
VariableValueDto.fromTypedValue(dto, variableInstance.TypedValue);
}
else
{
dto.errorMessage = variableInstance.ErrorMessage;
dto.type = VariableValueDto.toRestApiTypeName(variableInstance.TypeName);
}
return(dto);
}
public virtual void modifyVariables(PatchVariablesDto patch)
{
VariableMap variableModifications = null;
try
{
variableModifications = VariableValueDto.toMap(patch.Modifications, engine, objectMapper);
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot modify variables for {0}: {1}", ResourceTypeName, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
IList <string> variableDeletions = patch.Deletions;
try
{
updateVariableEntities(variableModifications, variableDeletions);
}
catch (AuthorizationException e)
{
throw e;
}
catch (ProcessEngineException e)
{
string errorMessage = string.Format("Cannot modify variables for {0} {1}: {2}", ResourceTypeName, resourceId, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
}
protected internal virtual void verifyStringValue(IDictionary <string, object> stringValue)
{
StringValue exampleValue = MockProvider.EXAMPLE_HISTORIC_DECISION_STRING_VALUE;
assertThat(stringValue, hasEntry("type", (object)VariableValueDto.toRestApiTypeName(exampleValue.Type.Name)));
assertThat(stringValue, hasEntry("value", (object)exampleValue.Value));
assertThat(stringValue, hasEntry("valueInfo", (object)Collections.emptyMap()));
}
public static ProcessInstanceDto fromProcessInstance(ProcessInstanceWithVariables instance)
{
ProcessInstanceWithVariablesDto result = new ProcessInstanceWithVariablesDto(instance);
VariableMap variables = instance.Variables;
result.variables = VariableValueDto.fromMap(variables, true);
return(result);
}
protected internal virtual void verifyByteArrayValue(IDictionary <string, object> byteArrayValue)
{
BytesValue exampleValue = MockProvider.EXAMPLE_HISTORIC_DECISION_BYTE_ARRAY_VALUE;
assertThat(byteArrayValue, hasEntry("type", (object)VariableValueDto.toRestApiTypeName(exampleValue.Type.Name)));
string byteString = Base64.encodeBase64String(exampleValue.Value).Trim();
assertThat(byteArrayValue, hasEntry("value", (object)byteString));
assertThat(byteArrayValue, hasEntry("valueInfo", (object)Collections.emptyMap()));
}
public virtual void setBinaryVariable(string variableKey, MultipartFormData payload)
{
MultipartFormData.FormPart dataPart = payload.getNamedPart("data");
MultipartFormData.FormPart objectTypePart = payload.getNamedPart("type");
MultipartFormData.FormPart valueTypePart = payload.getNamedPart("valueType");
if (objectTypePart != null)
{
object @object = null;
if (!string.ReferenceEquals(dataPart.ContentType, null) && dataPart.ContentType.ToLower().Contains(MediaType.APPLICATION_JSON))
{
@object = deserializeJsonObject(objectTypePart.TextContent, dataPart.BinaryContent);
}
else
{
throw new InvalidRequestException(Response.Status.BAD_REQUEST, "Unrecognized content type for serialized java type: " + dataPart.ContentType);
}
if (@object != null)
{
setVariableEntity(variableKey, Variables.objectValue(@object).create());
}
}
else
{
string valueTypeName = DEFAULT_BINARY_VALUE_TYPE;
if (valueTypePart != null)
{
if (string.ReferenceEquals(valueTypePart.TextContent, null))
{
throw new InvalidRequestException(Response.Status.BAD_REQUEST, "Form part with name 'valueType' must have a text/plain value");
}
valueTypeName = valueTypePart.TextContent;
}
VariableValueDto valueDto = VariableValueDto.fromFormPart(valueTypeName, dataPart);
try
{
TypedValue typedValue = valueDto.toTypedValue(engine, objectMapper);
setVariableEntity(variableKey, typedValue);
}
catch (AuthorizationException e)
{
throw e;
}
catch (ProcessEngineException e)
{
string errorMessage = string.Format("Cannot put {0} variable {1}: {2}", ResourceTypeName, variableKey, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") protected void verifySerializedValue(java.util.Map<String, Object> serializedValue)
protected internal virtual void verifySerializedValue(IDictionary <string, object> serializedValue)
{
ObjectValue exampleValue = MockProvider.EXAMPLE_HISTORIC_DECISION_SERIALIZED_VALUE;
assertThat(serializedValue, hasEntry("type", (object)VariableValueDto.toRestApiTypeName(exampleValue.Type.Name)));
assertThat(serializedValue, hasEntry("value", exampleValue.Value));
IDictionary <string, string> valueInfo = (IDictionary <string, string>)serializedValue["valueInfo"];
assertThat(valueInfo, hasEntry("serializationDataFormat", exampleValue.SerializationDataFormat));
assertThat(valueInfo, hasEntry("objectTypeName", exampleValue.ObjectTypeName));
}
protected internal virtual IDictionary <string, VariableValueDto> createResultEntriesDto(DmnDecisionResultEntries entries)
{
VariableMap variableMap = Variables.createVariables();
foreach (string key in entries.Keys)
{
TypedValue typedValue = entries.getEntryTyped(key);
variableMap.putValueTyped(key, typedValue);
}
return(VariableValueDto.fromMap(variableMap));
}
public static HalVariableValue fromVariableInstance(VariableInstance variableInstance)
{
HalVariableValue dto = new HalVariableValue();
VariableValueDto variableValueDto = VariableValueDto.fromTypedValue(variableInstance.TypedValue);
dto.name = variableInstance.Name;
dto.value = variableValueDto.Value;
dto.type = variableValueDto.Type;
dto.valueInfo = variableValueDto.ValueInfo;
return(dto);
}
public virtual void resolve(CompleteTaskDto dto)
{
TaskService taskService = engine.TaskService;
try
{
VariableMap variables = VariableValueDto.toMap(dto.Variables, engine, objectMapper);
taskService.resolveTask(taskId, variables);
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot resolve task {0}: {1}", taskId, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
}
public virtual CaseInstanceDto createCaseInstance(UriInfo context, CreateCaseInstanceDto parameters)
{
CaseService caseService = engine.CaseService;
CaseInstance instance = null;
try
{
string businessKey = parameters.BusinessKey;
VariableMap variables = VariableValueDto.toMap(parameters.Variables, engine, objectMapper);
instance = caseService.withCaseDefinition(caseDefinitionId).businessKey(businessKey).setVariables(variables).create();
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot instantiate case definition {0}: {1}", caseDefinitionId, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
catch (NotFoundException e)
{
string errorMessage = string.Format("Cannot instantiate case definition {0}: {1}", caseDefinitionId, e.Message);
throw new InvalidRequestException(Response.Status.NOT_FOUND, e, errorMessage);
}
catch (NotValidException e)
{
string errorMessage = string.Format("Cannot instantiate case definition {0}: {1}", caseDefinitionId, e.Message);
throw new InvalidRequestException(Response.Status.BAD_REQUEST, e, errorMessage);
}
catch (NotAllowedException e)
{
string errorMessage = string.Format("Cannot instantiate case definition {0}: {1}", caseDefinitionId, e.Message);
throw new InvalidRequestException(Response.Status.FORBIDDEN, e, errorMessage);
}
catch (ProcessEngineException e)
{
string errorMessage = string.Format("Cannot instantiate case definition {0}: {1}", caseDefinitionId, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
CaseInstanceDto result = CaseInstanceDto.fromCaseInstance(instance);
URI uri = context.BaseUriBuilder.path(rootResourcePath).path(org.camunda.bpm.engine.rest.CaseInstanceRestService_Fields.PATH).path(instance.Id).build();
result.addReflexiveLink(uri, HttpMethod.GET, "self");
return(result);
}
public virtual ProcessInstanceDto submitForm(UriInfo context, StartProcessInstanceDto parameters)
{
FormService formService = engine.FormService;
ProcessInstance instance = null;
try
{
IDictionary <string, object> variables = VariableValueDto.toMap(parameters.Variables, engine, objectMapper);
string businessKey = parameters.BusinessKey;
if (!string.ReferenceEquals(businessKey, null))
{
instance = formService.submitStartForm(processDefinitionId, businessKey, variables);
}
else
{
instance = formService.submitStartForm(processDefinitionId, variables);
}
}
catch (AuthorizationException e)
{
throw e;
}
catch (FormFieldValidationException e)
{
string errorMessage = string.Format("Cannot instantiate process definition {0}: {1}", processDefinitionId, e.Message);
throw new RestException(Response.Status.BAD_REQUEST, e, errorMessage);
}
catch (ProcessEngineException e)
{
string errorMessage = string.Format("Cannot instantiate process definition {0}: {1}", processDefinitionId, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot instantiate process definition {0}: {1}", processDefinitionId, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
ProcessInstanceDto result = ProcessInstanceDto.fromProcessInstance(instance);
URI uri = context.BaseUriBuilder.path(rootResourcePath).path(org.camunda.bpm.engine.rest.ProcessInstanceRestService_Fields.PATH).path(instance.Id).build();
result.addReflexiveLink(uri, HttpMethod.GET, "self");
return(result);
}
public virtual IDictionary <string, VariableValueDto> getFormVariables(string variableNames, bool deserializeValues)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.FormService formService = engine.getFormService();
FormService formService = engine.FormService;
IList <string> formVariables = null;
if (!string.ReferenceEquals(variableNames, null))
{
StringListConverter stringListConverter = new StringListConverter();
formVariables = stringListConverter.convertQueryParameterToType(variableNames);
}
VariableMap startFormVariables = formService.getTaskFormVariables(taskId, formVariables, deserializeValues);
return(VariableValueDto.fromMap(startFormVariables));
}
protected internal virtual ProcessInstanceWithVariables startProcessInstanceAtActivities(StartProcessInstanceDto dto)
{
IDictionary <string, object> processInstanceVariables = VariableValueDto.toMap(dto.Variables, engine, objectMapper);
string businessKey = dto.BusinessKey;
string caseInstanceId = dto.CaseInstanceId;
ProcessInstantiationBuilder instantiationBuilder = engine.RuntimeService.createProcessInstanceById(processDefinitionId).businessKey(businessKey).caseInstanceId(caseInstanceId).setVariables(processInstanceVariables);
if (dto.StartInstructions != null && dto.StartInstructions.Count > 0)
{
foreach (ProcessInstanceModificationInstructionDto instruction in dto.StartInstructions)
{
instruction.applyTo(instantiationBuilder, engine, objectMapper);
}
}
return(instantiationBuilder.executeWithVariablesInReturn(dto.SkipCustomListeners, dto.SkipIoMappings));
}
public static MessageCorrelationResultWithVariableDto fromMessageCorrelationResultWithVariables(MessageCorrelationResultWithVariables result)
{
MessageCorrelationResultWithVariableDto dto = new MessageCorrelationResultWithVariableDto();
if (result != null)
{
dto.ResultType = result.ResultType;
if (result.ProcessInstance != null)
{
dto.ProcessInstance = ProcessInstanceDto.fromProcessInstance(result.ProcessInstance);
}
else if (result.Execution != null)
{
dto.Execution = ExecutionDto.fromExecution(result.Execution);
}
dto.variables = VariableValueDto.fromMap(result.Variables, true);
}
return(dto);
}
public virtual Response complete(CompleteTaskDto dto)
{
TaskService taskService = engine.TaskService;
try
{
VariableMap variables = VariableValueDto.toMap(dto.Variables, engine, objectMapper);
if (dto.WithVariablesInReturn)
{
VariableMap taskVariables = taskService.completeWithVariablesInReturn(taskId, variables, false);
IDictionary <string, VariableValueDto> body = VariableValueDto.fromMap(taskVariables, true);
return(Response.ok(body).type(MediaType.APPLICATION_JSON).build());
}
else
{
taskService.complete(taskId, variables);
return(Response.noContent().build());
}
}
catch (RestException e)
{
string errorMessage = string.Format("Cannot complete task {0}: {1}", taskId, e.Message);
throw new InvalidRequestException(e.Status, e, errorMessage);
}
catch (AuthorizationException e)
{
throw e;
}
catch (FormFieldValidationException e)
{
string errorMessage = string.Format("Cannot complete task {0}: {1}", taskId, e.Message);
throw new RestException(Response.Status.BAD_REQUEST, e, errorMessage);
}
catch (ProcessEngineException e)
{
string errorMessage = string.Format("Cannot complete task {0}: {1}", taskId, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
}
protected internal virtual SignalEventReceivedBuilder createSignalEventReceivedBuilder(SignalDto dto)
{
RuntimeService runtimeService = processEngine.RuntimeService;
string name = dto.Name;
SignalEventReceivedBuilder signalEvent = runtimeService.createSignalEvent(name);
string executionId = dto.ExecutionId;
if (!string.ReferenceEquals(executionId, null))
{
signalEvent.executionId(executionId);
}
IDictionary <string, VariableValueDto> variablesDto = dto.Variables;
if (variablesDto != null)
{
IDictionary <string, object> variables = VariableValueDto.toMap(variablesDto, processEngine, objectMapper);
signalEvent.Variables = variables;
}
string tenantId = dto.TenantId;
if (!string.ReferenceEquals(tenantId, null))
{
signalEvent.tenantId(tenantId);
}
bool isWithoutTenantId = dto.WithoutTenantId;
if (isWithoutTenantId)
{
signalEvent.withoutTenantId();
}
return(signalEvent);
}
public virtual IList <IDictionary <string, VariableValueDto> > evaluateDecision(UriInfo context, EvaluateDecisionDto parameters)
{
DecisionService decisionService = engine.DecisionService;
IDictionary <string, object> variables = VariableValueDto.toMap(parameters.Variables, engine, objectMapper);
try
{
DmnDecisionResult decisionResult = decisionService.evaluateDecisionById(decisionDefinitionId).variables(variables).evaluate();
return(createDecisionResultDto(decisionResult));
}
catch (AuthorizationException e)
{
throw e;
}
catch (NotFoundException e)
{
string errorMessage = string.Format("Cannot evaluate decision {0}: {1}", decisionDefinitionId, e.Message);
throw new InvalidRequestException(Response.Status.NOT_FOUND, e, errorMessage);
}
catch (NotValidException e)
{
string errorMessage = string.Format("Cannot evaluate decision {0}: {1}", decisionDefinitionId, e.Message);
throw new InvalidRequestException(Response.Status.BAD_REQUEST, e, errorMessage);
}
catch (ProcessEngineException e)
{
string errorMessage = string.Format("Cannot evaluate decision {0}: {1}", decisionDefinitionId, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
catch (DmnEngineException e)
{
string errorMessage = string.Format("Cannot evaluate decision {0}: {1}", decisionDefinitionId, e.Message);
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, errorMessage);
}
}
public static LockedExternalTaskDto fromLockedExternalTask(LockedExternalTask task)
{
LockedExternalTaskDto dto = new LockedExternalTaskDto();
dto.activityId = task.ActivityId;
dto.activityInstanceId = task.ActivityInstanceId;
dto.errorMessage = task.ErrorMessage;
dto.errorDetails = task.ErrorDetails;
dto.executionId = task.ExecutionId;
dto.id = task.Id;
dto.lockExpirationTime = task.LockExpirationTime;
dto.processDefinitionId = task.ProcessDefinitionId;
dto.processDefinitionKey = task.ProcessDefinitionKey;
dto.processInstanceId = task.ProcessInstanceId;
dto.retries = task.Retries;
dto.topicName = task.TopicName;
dto.workerId = task.WorkerId;
dto.tenantId = task.TenantId;
dto.variables = VariableValueDto.fromMap(task.Variables);
dto.priority = task.Priority;
dto.businessKey = task.BusinessKey;
return(dto);
}
public virtual void putVariable(string variableName, VariableValueDto variable)
{
try
{
TypedValue typedValue = variable.toTypedValue(engine, objectMapper);
setVariableEntity(variableName, typedValue);
}
catch (RestException e)
{
throw new InvalidRequestException(e.Status, e, string.Format("Cannot put {0} variable {1}: {2}", ResourceTypeName, variableName, e.Message));
}
catch (BadUserRequestException e)
{
throw new RestException(Response.Status.BAD_REQUEST, e, string.Format("Cannot put {0} variable {1}: {2}", ResourceTypeName, variableName, e.Message));
}
catch (AuthorizationException e)
{
throw e;
}
catch (ProcessEngineException e)
{
throw new RestException(Response.Status.INTERNAL_SERVER_ERROR, e, string.Format("Cannot put {0} variable {1}: {2}", ResourceTypeName, variableName, e.Message));
}
}
protected internal virtual ConditionEvaluationBuilder createConditionEvaluationBuilder(EvaluationConditionDto conditionDto)
{
RuntimeService runtimeService = processEngine.RuntimeService;
ObjectMapper objectMapper = ObjectMapper;
VariableMap variables = VariableValueDto.toMap(conditionDto.Variables, processEngine, objectMapper);
ConditionEvaluationBuilder builder = runtimeService.createConditionEvaluation();
if (variables != null && !variables.Empty)
{
builder.Variables = variables;
}
if (!string.ReferenceEquals(conditionDto.BusinessKey, null))
{
builder.processInstanceBusinessKey(conditionDto.BusinessKey);
}
if (!string.ReferenceEquals(conditionDto.ProcessDefinitionId, null))
{
builder.processDefinitionId(conditionDto.ProcessDefinitionId);
}
if (!string.ReferenceEquals(conditionDto.TenantId, null))
{
builder.tenantId(conditionDto.TenantId);
}
else if (conditionDto.WithoutTenantId)
{
builder.withoutTenantId();
}
return(builder);
}
public virtual IDictionary <string, VariableValueDto> getVariables(bool deserializeValues)
{
VariableMap variables = getVariableEntities(deserializeValues);
return(VariableValueDto.fromMap(variables));
}
public virtual VariableValueDto getVariable(string variableName, bool deserializeValue)
{
TypedValue value = getTypedValueForVariable(variableName, deserializeValue);
return(VariableValueDto.fromTypedValue(value));
}
protected internal virtual MessageCorrelationBuilder createMessageCorrelationBuilder(CorrelationMessageDto messageDto)
{
RuntimeService runtimeService = processEngine.RuntimeService;
ObjectMapper objectMapper = ObjectMapper;
IDictionary <string, object> correlationKeys = VariableValueDto.toMap(messageDto.CorrelationKeys, processEngine, objectMapper);
IDictionary <string, object> localCorrelationKeys = VariableValueDto.toMap(messageDto.LocalCorrelationKeys, processEngine, objectMapper);
IDictionary <string, object> processVariables = VariableValueDto.toMap(messageDto.ProcessVariables, processEngine, objectMapper);
IDictionary <string, object> processVariablesLocal = VariableValueDto.toMap(messageDto.ProcessVariablesLocal, processEngine, objectMapper);
MessageCorrelationBuilder builder = runtimeService.createMessageCorrelation(messageDto.MessageName);
if (processVariables != null)
{
builder.Variables = processVariables;
}
if (processVariablesLocal != null)
{
builder.VariablesLocal = processVariablesLocal;
}
if (!string.ReferenceEquals(messageDto.BusinessKey, null))
{
builder.processInstanceBusinessKey(messageDto.BusinessKey);
}
if (correlationKeys != null && correlationKeys.Count > 0)
{
foreach (KeyValuePair <string, object> correlationKey in correlationKeys.SetOfKeyValuePairs())
{
string name = correlationKey.Key;
object value = correlationKey.Value;
builder.processInstanceVariableEquals(name, value);
}
}
if (localCorrelationKeys != null && localCorrelationKeys.Count > 0)
{
foreach (KeyValuePair <string, object> correlationKey in localCorrelationKeys.SetOfKeyValuePairs())
{
string name = correlationKey.Key;
object value = correlationKey.Value;
builder.localVariableEquals(name, value);
}
}
if (!string.ReferenceEquals(messageDto.TenantId, null))
{
builder.tenantId(messageDto.TenantId);
}
else if (messageDto.WithoutTenantId)
{
builder.withoutTenantId();
}
string processInstanceId = messageDto.ProcessInstanceId;
if (!string.ReferenceEquals(processInstanceId, null))
{
builder.processInstanceId(processInstanceId);
}
return(builder);
}
