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); }