protected internal virtual VariableMap getVariables(object input)
{
VariableMap variables = Variables.createVariables();
variables.put("input1", input);
return(variables);
}
public virtual void resultIsSortedByEvaluationTime()
{
// given start process and evaluate decision
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
DateTime now = DateTime.Now;
DateTime nowMinus2Seconds = new DateTime(now.Ticks - 2000L);
DateTime nowPlus2Seconds = new DateTime(now.Ticks + 2000L);
ClockUtil.CurrentTime = nowMinus2Seconds;
ProcessInstance firstProcessInstance = runtimeService.startProcessInstanceByKey("testProcess", variables);
ClockUtil.CurrentTime = now;
ProcessInstance secondProcessInstance = runtimeService.startProcessInstanceByKey("testProcess", variables);
ClockUtil.CurrentTime = nowPlus2Seconds;
ProcessInstance thirdProcessInstance = runtimeService.startProcessInstanceByKey("testProcess", variables);
// when
IList <HistoricDecisionInstance> decisionInstances = optimizeService.getHistoricDecisionInstances(pastDate(), null, 3);
// then
assertThat(decisionInstances.Count, @is(3));
assertThat(decisionInstances[0].ProcessInstanceId, @is(firstProcessInstance.Id));
assertThat(decisionInstances[1].ProcessInstanceId, @is(secondProcessInstance.Id));
assertThat(decisionInstances[2].ProcessInstanceId, @is(thirdProcessInstance.Id));
}
public virtual MessageCorrelationBuilder setVariableLocal(string variableName, object variableValue)
{
ensureNotNull("variableName", variableName);
ensurePayloadProcessInstanceVariablesLocalInitialized();
payloadProcessInstanceVariablesLocal.put(variableName, variableValue);
return(this);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testPurgeWithAsyncProcessInstance()
public virtual void testPurgeWithAsyncProcessInstance()
{
// given process with variable and async process instance
BpmnModelInstance test = Bpmn.createExecutableProcess(PROCESS_DEF_KEY).startEvent().camundaAsyncBefore().userTask().userTask().endEvent().done();
engineRule.RepositoryService.createDeployment().addModelInstance(PROCESS_MODEL_NAME, test).deploy();
VariableMap variables = Variables.createVariables();
variables.put("key", "value");
engineRule.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY, variables);
Job job = engineRule.ManagementService.createJobQuery().singleResult();
engineRule.ManagementService.executeJob(job.Id);
Task task = engineRule.TaskService.createTaskQuery().singleResult();
engineRule.TaskService.complete(task.Id);
// when purge is executed
ManagementServiceImpl managementService = (ManagementServiceImpl)engineRule.ManagementService;
managementService.purge();
// then no more data exist
assertAndEnsureCleanDbAndCache(engineRule.ProcessEngine, true);
}
private void executeComplexBpmnProcess(bool complete)
{
VariableMap variables = Variables.createVariables();
variables.put("key", "value");
engineRule.RuntimeService.startProcessInstanceByKey(PROCESS_DEF_KEY, variables);
//execute start event
Job job = engineRule.ManagementService.createJobQuery().singleResult();
engineRule.ManagementService.executeJob(job.Id);
//fetch tasks and jobs
IList <LockedExternalTask> externalTasks = engineRule.ExternalTaskService.fetchAndLock(1, "worker").topic("external", 1500).execute();
job = engineRule.ManagementService.createJobQuery().singleResult();
Task task = engineRule.TaskService.createTaskQuery().singleResult();
//complete
if (complete)
{
engineRule.ManagementService.setJobRetries(job.Id, 0);
engineRule.ManagementService.executeJob(job.Id);
engineRule.ExternalTaskService.complete(externalTasks[0].Id, "worker");
engineRule.TaskService.complete(task.Id);
}
}
public virtual void decisionOutputInstanceProperties()
{
// given start process and evaluate decision
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
runtimeService.startProcessInstanceByKey("testProcess", variables);
// when
IList <HistoricDecisionInstance> decisionInstances = optimizeService.getHistoricDecisionInstances(pastDate(), null, 10);
// then
assertThat(decisionInstances.Count, @is(1));
HistoricDecisionInstance decisionInstance = decisionInstances[0];
IList <HistoricDecisionOutputInstance> outputs = decisionInstance.Outputs;
assertThat(outputs, @is(notNullValue()));
assertThat(outputs.Count, @is(1));
HistoricDecisionOutputInstance output = outputs[0];
assertThat(output.DecisionInstanceId, @is(decisionInstance.Id));
assertThat(output.ClauseId, @is("out"));
assertThat(output.ClauseName, @is("output"));
assertThat(output.RuleId, @is("rule"));
assertThat(output.RuleOrder, @is(1));
assertThat(output.VariableName, @is("result"));
}
public override ProcessInstanceModificationInstantiationBuilder setVariable(string name, object value)
{
ensureNotNull(typeof(NotValidException), "Variable name must not be null", "name", name);
AbstractInstantiationCmd currentInstantiation = CurrentInstantiation;
if (currentInstantiation != null)
{
currentInstantiation.addVariable(name, value);
}
else
{
processVariables.put(name, value);
}
return(this);
}
public virtual MessageCorrelationBuilder processInstanceVariableEquals(string variableName, object variableValue)
{
ensureNotNull("variableName", variableName);
ensureCorrelationProcessInstanceVariablesInitialized();
correlationProcessInstanceVariables.put(variableName, variableValue);
return(this);
}
public virtual void getCompletedHistoricDecisionInstances()
{
// given start process and evaluate decision
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
runtimeService.startProcessInstanceByKey("testProcess", variables);
// when
IList <HistoricDecisionInstance> decisionInstances = optimizeService.getHistoricDecisionInstances(pastDate(), null, 10);
// then
assertThat(decisionInstances.Count, @is(1));
assertThatDecisionsHaveAllImportantInformation(decisionInstances);
}
public virtual void testGetDecisionInstancesWithAuthorization()
{
// given
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
startProcessInstanceByKey("testProcess", variables);
createGrantAuthorization(DECISION_DEFINITION, "*", userId, READ_HISTORY);
// when
IList <HistoricDecisionInstance> decisionInstances = optimizeService.getHistoricDecisionInstances(new DateTime(0L), null, 10);
// then
assertThat(decisionInstances.Count, @is(1));
}
public virtual void maxResultsParameterWorks()
{
// given start process and evaluate decision
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
runtimeService.startProcessInstanceByKey("testProcess", variables);
runtimeService.startProcessInstanceByKey("testProcess", variables);
runtimeService.startProcessInstanceByKey("testProcess", variables);
// when
IList <HistoricDecisionInstance> decisionInstances = optimizeService.getHistoricDecisionInstances(null, null, 2);
// then
assertThat(decisionInstances.Count, @is(2));
}
public static VariableMap toMap(IDictionary <string, VariableValueDto> variables, ProcessEngine processEngine, ObjectMapper objectMapper)
{
if (variables == null)
{
return(null);
}
VariableMap result = Variables.createVariables();
foreach (KeyValuePair <string, VariableValueDto> variableEntry in variables.SetOfKeyValuePairs())
{
result.put(variableEntry.Key, variableEntry.Value.toTypedValue(processEngine, objectMapper));
}
return(result);
}
public virtual void applyTo(VariableScope variableScope, VariableMap variables)
{
if (readLocal)
{
variableScope = new VariableScopeLocalAdapter(variableScope);
}
if (allVariables)
{
IDictionary <string, object> allVariables = variableScope.Variables;
variables.putAll(allVariables);
}
else
{
object value = getSource(variableScope);
variables.put(target, value);
}
}
// CMMN //////////////////////////////////////////////////////////////////////////////////////////////////////////////
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testPurgeCmmnProcess()
public virtual void testPurgeCmmnProcess()
{
// given cmmn process which is not managed by process engine rule
engineRule.RepositoryService.createDeployment().addClasspathResource("org/camunda/bpm/engine/test/standalone/db/entitymanager/PurgeDatabaseTest.testPurgeCmmnProcess.cmmn").deploy();
VariableMap variables = Variables.createVariables();
variables.put("key", "value");
engineRule.CaseService.createCaseInstanceByKey(PROCESS_DEF_KEY, variables);
// when purge is executed
ManagementServiceImpl managementService = (ManagementServiceImpl)engineRule.ManagementService;
PurgeReport purge = managementService.purge();
// then database and cache is cleaned
assertAndEnsureCleanDbAndCache(engineRule.ProcessEngine, true);
// and report contains deleted entities
assertFalse(purge.Empty);
CachePurgeReport cachePurgeReport = purge.CachePurgeReport;
assertEquals(1, cachePurgeReport.getReportValue(CachePurgeReport.CASE_DEF_CACHE).Count);
DatabasePurgeReport databasePurgeReport = purge.DatabasePurgeReport;
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_RE_DEPLOYMENT"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_RU_TASK"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_GE_BYTEARRAY"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_RE_CASE_DEF"));
assertEquals(3, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_RU_CASE_EXECUTION"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_RU_VARIABLE"));
assertEquals(2, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_RU_CASE_SENTRY_PART"));
if (processEngineConfiguration.HistoryLevel.Equals(org.camunda.bpm.engine.impl.history.HistoryLevel_Fields.HISTORY_LEVEL_FULL))
{
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_HI_DETAIL"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_HI_TASKINST"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_HI_VARINST"));
assertEquals(1, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_HI_CASEINST"));
assertEquals(2, (long)databasePurgeReport.getReportValue(databaseTablePrefix + "ACT_HI_CASEACTINST"));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void createVariablesUsingVariableMap()
public virtual void createVariablesUsingVariableMap()
{
// given
BpmnModelInstance simpleInstanceWithListener = Bpmn.createExecutableProcess("Process").startEvent().camundaExecutionListenerClass([email protected]_Fields.EVENTNAME_END, typeof(ReadTransientVariableExecutionListener)).userTask().endEvent().done();
testRule.deploy(simpleInstanceWithListener);
// when
VariableMap variables = Variables.createVariables();
variables.put(VARIABLE_NAME, Variables.untypedValue(true, true));
runtimeService.startProcessInstanceByKey("Process", variables);
// then
IList <VariableInstance> variableInstances = runtimeService.createVariableInstanceQuery().list();
IList <HistoricVariableInstance> historicVariableInstances = historyService.createHistoricVariableInstanceQuery().list();
assertEquals(0, variableInstances.Count);
assertEquals(0, historicVariableInstances.Count);
}
public virtual void testHappyPathV2()
{
Stream invoiceInputStream = typeof(InvoiceProcessApplication).ClassLoader.getResourceAsStream("invoice.pdf");
VariableMap variables = Variables.createVariables().putValue("creditor", "Great Pizza for Everyone Inc.").putValue("amount", 300.0d).putValue("invoiceCategory", "Travel Expenses").putValue("invoiceNumber", "GPFE-23232323").putValue("invoiceDocument", fileValue("invoice.pdf").file(invoiceInputStream).mimeType("application/pdf").create());
ProcessInstance pi = runtimeService.startProcessInstanceByKey("invoice", variables);
Task task = taskService.createTaskQuery().processInstanceId(pi.Id).singleResult();
assertEquals("approveInvoice", task.TaskDefinitionKey);
IList <IdentityLink> links = taskService.getIdentityLinksForTask(task.Id);
ISet <string> approverGroups = new HashSet <string>();
foreach (IdentityLink link in links)
{
approverGroups.Add(link.GroupId);
}
assertEquals(2, approverGroups.Count);
assertTrue(approverGroups.Contains("accounting"));
assertTrue(approverGroups.Contains("sales"));
variables.clear();
variables.put("approved", true);
taskService.complete(task.Id, variables);
task = taskService.createTaskQuery().processInstanceId(pi.Id).singleResult();
assertEquals("prepareBankTransfer", task.TaskDefinitionKey);
taskService.complete(task.Id);
Job archiveInvoiceJob = managementService.createJobQuery().singleResult();
assertNotNull(archiveInvoiceJob);
managementService.executeJob(archiveInvoiceJob.Id);
assertProcessEnded(pi.Id);
}
public virtual void testGetDecisionInstancesWithoutAuthorization()
{
// given
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
startProcessInstanceByKey("testProcess", variables);
try
{
// when
optimizeService.getHistoricDecisionInstances(new DateTime(0L), null, 10);
fail("Exception expected: It should not be possible to retrieve the decision instances");
}
catch (AuthorizationException e)
{
// then
string exceptionMessage = e.Message;
assertTextPresent(userId, exceptionMessage);
assertTextPresent(READ_HISTORY.Name, exceptionMessage);
assertTextPresent(DECISION_DEFINITION.resourceName(), exceptionMessage);
}
}
public virtual void fishedAfterAndFinishedAtParameterWorks()
{
// given start process and evaluate decision
VariableMap variables = Variables.createVariables();
variables.put("input1", null);
DateTime now = DateTime.Now;
DateTime nowMinus2Seconds = new DateTime(now.Ticks - 2000L);
DateTime nowPlus2Seconds = new DateTime(now.Ticks + 2000L);
ClockUtil.CurrentTime = nowMinus2Seconds;
runtimeService.startProcessInstanceByKey("testProcess", variables);
ClockUtil.CurrentTime = now;
runtimeService.startProcessInstanceByKey("testProcess", variables);
ClockUtil.CurrentTime = nowPlus2Seconds;
runtimeService.startProcessInstanceByKey("testProcess", variables);
// when
IList <HistoricDecisionInstance> decisionInstances = optimizeService.getHistoricDecisionInstances(now, now, 10);
// then
assertThat(decisionInstances.Count, @is(0));
}