//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup()
public virtual void setup()
{
modelInstance = Cmmn.createEmptyModel();
definitions = modelInstance.newInstance(typeof(Definitions));
definitions.TargetNamespace = "http://camunda.org/examples";
modelInstance.Definitions = definitions;
caseDefinition = createElement(definitions, "aCaseDefinition", typeof(Case));
casePlanModel = createElement(caseDefinition, "aCasePlanModel", typeof(CasePlanModel));
context = new CmmnHandlerContext();
CaseDefinitionEntity caseDefinition = new CaseDefinitionEntity();
caseDefinition.TaskDefinitions = new Dictionary <string, TaskDefinition>();
context.CaseDefinition = caseDefinition;
ExpressionManager expressionManager = new ExpressionManager();
context.ExpressionManager = expressionManager;
DeploymentEntity deployment = new DeploymentEntity();
deployment.Id = "foo";
context.Deployment = deployment;
}
protected internal override void initializeActivity(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context)
{
// execute standard initialization
base.initializeActivity(element, activity, context);
// create a taskDefinition
TaskDefinition taskDefinition = createTaskDefinition(element, context);
// get the caseDefinition...
CaseDefinitionEntity caseDefinition = (CaseDefinitionEntity)context.CaseDefinition;
// ... and taskDefinition to caseDefinition
caseDefinition.TaskDefinitions[taskDefinition.Key] = taskDefinition;
ExpressionManager expressionManager = context.ExpressionManager;
// create decorator
TaskDecorator taskDecorator = new TaskDecorator(taskDefinition, expressionManager);
// set taskDecorator on behavior
HumanTaskActivityBehavior behavior = (HumanTaskActivityBehavior)activity.ActivityBehavior;
behavior.TaskDecorator = taskDecorator;
// task listeners
initializeTaskListeners(element, activity, context, taskDefinition);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: @Override public java.io.InputStream execute(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext)
public virtual Stream execute(CommandContext commandContext)
{
CaseDefinitionEntity caseDefinition = Context.ProcessEngineConfiguration.DeploymentCache.findDeployedCaseDefinitionById(caseDefinitionId);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkReadCaseDefinition(caseDefinition);
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String deploymentId = caseDefinition.getDeploymentId();
string deploymentId = caseDefinition.DeploymentId;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final String resourceName = caseDefinition.getDiagramResourceName();
string resourceName = caseDefinition.DiagramResourceName;
Stream caseDiagramStream = null;
if (!string.ReferenceEquals(resourceName, null))
{
caseDiagramStream = commandContext.runWithoutAuthorization(new CallableAnonymousInnerClass(this, commandContext, deploymentId, resourceName));
}
return(caseDiagramStream);
}
///
/// <summary>
/// +-----------------+ +-----------------+
/// | Case1 \ | aCaseDefinition |
/// +-------------------+---+ +-----------------+
/// | | |
/// | +-------+ | ==> +-----------------+
/// | | A | | | aCasePlanModel |
/// | +-------+ | +-----------------+
/// | | |
/// +-----------------------+ +-----------------+
/// | A |
/// +-----------------+
///
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testActivityTreeWithOneHumanTask()
public virtual void testActivityTreeWithOneHumanTask()
{
// given
HumanTask humanTask = createElement(casePlanModel, "A", typeof(HumanTask));
PlanItem planItem = createElement(casePlanModel, "PI_A", typeof(PlanItem));
planItem.Definition = humanTask;
// when
IList <CaseDefinitionEntity> caseDefinitions = transform();
// then
assertEquals(1, caseDefinitions.Count);
CaseDefinitionEntity caseDefinition = caseDefinitions[0];
IList <CmmnActivity> activities = caseDefinition.Activities;
CmmnActivity casePlanModelActivity = activities[0];
IList <CmmnActivity> planItemActivities = casePlanModelActivity.Activities;
assertEquals(1, planItemActivities.Count);
CmmnActivity child = planItemActivities[0];
assertEquals(planItem.Id, child.Id);
assertTrue(child.Activities.Count == 0);
}
protected internal virtual CaseDefinitionEntity createActivity(CmmnElement element, CmmnHandlerContext context)
{
CaseDefinitionEntity definition = new CaseDefinitionEntity();
definition.CmmnElement = element;
return(definition);
}
public virtual CmmnCaseDefinition handleElement(Case element, CmmnHandlerContext context)
{
CaseDefinitionEntity definition = createActivity(element, context);
initializeActivity(element, definition, context);
return(definition);
}
public ProcessApplicationReference execute(CommandContext commandContext)
{
ProcessEngineConfigurationImpl configuration = commandContext.ProcessEngineConfiguration;
DeploymentCache deploymentCache = configuration.DeploymentCache;
CaseDefinitionEntity definition = deploymentCache.findDeployedCaseDefinitionById(definitionId);
return(ProcessApplicationContextUtil.getTargetProcessApplication(definition));
}
public virtual void transformRootElement <T1>(Definitions definitions, IList <T1> caseDefinitions) where T1 : org.camunda.bpm.engine.impl.cmmn.model.CmmnCaseDefinition
{
modelElementInstances.Add(definitions);
foreach (CmmnCaseDefinition caseDefinition in caseDefinitions)
{
CaseDefinitionEntity entity = (CaseDefinitionEntity)caseDefinition;
entity.Key = entity.Key + "-modified";
}
}
protected internal virtual void ensureCaseDefinitionInitialized()
{
if ((caseDefinition == null) && (!string.ReferenceEquals(caseDefinitionId, null)))
{
CaseDefinitionEntity deployedCaseDefinition = Context.ProcessEngineConfiguration.DeploymentCache.getCaseDefinitionById(caseDefinitionId);
CaseDefinition = deployedCaseDefinition;
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testHistoryTimeToLiveNull()
public virtual void testHistoryTimeToLiveNull()
{
// given: a caseDefinition
// when
CaseDefinitionEntity activity = (CaseDefinitionEntity)handler.handleElement(caseDefinition, context);
// then
assertNull(activity.HistoryTimeToLive);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testCaseDefinitionKey()
public virtual void testCaseDefinitionKey()
{
// given: a caseDefinition
// when
CaseDefinitionEntity activity = (CaseDefinitionEntity)handler.handleElement(caseDefinition, context);
// then
assertEquals(caseDefinition.Id, activity.Key);
}
private CaseExecutionEntity prepareCaseExecution(CaseDefinitionEntity caseDefinitionEntity1)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.cmmn.entity.runtime.CaseExecutionEntity caseExecutionEntity = new org.camunda.bpm.engine.impl.cmmn.entity.runtime.CaseExecutionEntity();
CaseExecutionEntity caseExecutionEntity = new CaseExecutionEntity();
caseExecutionEntity.Id = System.Guid.randomUUID().ToString();
caseExecutionEntity.CaseDefinition = caseDefinitionEntity1;
return(caseExecutionEntity);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testDeploymentId()
public virtual void testDeploymentId()
{
// given: a caseDefinition
// when
CaseDefinitionEntity activity = (CaseDefinitionEntity)handler.handleElement(caseDefinition, context);
// then
string deploymentId = context.Deployment.Id;
assertEquals(deploymentId, activity.DeploymentId);
}
private CaseDefinitionEntity prepareCaseDefinition(string id)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity caseDefinitionEntity = new org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity();
CaseDefinitionEntity caseDefinitionEntity = new CaseDefinitionEntity();
caseDefinitionEntity.Id = id;
caseDefinitionEntity.Key = System.Guid.randomUUID().ToString();
caseDefinitionEntity.DeploymentId = System.Guid.randomUUID().ToString();
createCaseDefinition(caseDefinitionEntity);
return(caseDefinitionEntity);
}
public virtual CaseDefinition execute(CommandContext commandContext)
{
ensureNotNull("caseDefinitionId", caseDefinitionId);
CaseDefinitionEntity caseDefinition = Context.ProcessEngineConfiguration.DeploymentCache.findDeployedCaseDefinitionById(caseDefinitionId);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkReadCaseDefinition(caseDefinition);
}
return(caseDefinition);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testHistoryTimeToLive()
public virtual void testHistoryTimeToLive()
{
// given: a caseDefinition
int?historyTimeToLive = 6;
caseDefinition.CamundaHistoryTimeToLive = historyTimeToLive;
// when
CaseDefinitionEntity activity = (CaseDefinitionEntity)handler.handleElement(caseDefinition, context);
// then
assertEquals(Convert.ToInt32(historyTimeToLive), activity.HistoryTimeToLive);
}
protected internal virtual string getCaseDefinitionKey(CaseExecutionEntity execution)
{
CaseDefinitionEntity definition = (CaseDefinitionEntity)execution.CaseDefinition;
if (definition != null)
{
return(definition.Key);
}
else
{
return(null);
}
}
///
/// <summary>
/// +-----------------+ +-----------------+
/// | Case1 \ | aCaseDefinition |
/// +-------------------+-----------------+ +-----------------+
/// | | |
/// | +------------------------+ | +-----------------+
/// | / X \ | | aCasePlanModel |
/// | + +-------+ +-------+ + | +-----------------+
/// | | | A | | B | | | ==> |
/// | + +-------+ +-------+ + | +-----------------+
/// | \ / | | X |
/// | +------------------------+ | +-----------------+
/// | | / \
/// +-------------------------------------+ / \
/// +-----------------+ +-----------------+
/// | A | | B |
/// +-----------------+ +-----------------+
/// </summary>
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void testActivityTreeWithOneStageAndNestedHumanTasks()
public virtual void testActivityTreeWithOneStageAndNestedHumanTasks()
{
// given
Stage stage = createElement(casePlanModel, "X", typeof(Stage));
HumanTask humanTaskA = createElement(casePlanModel, "A", typeof(HumanTask));
HumanTask humanTaskB = createElement(casePlanModel, "B", typeof(HumanTask));
PlanItem planItemX = createElement(casePlanModel, "PI_X", typeof(PlanItem));
PlanItem planItemA = createElement(stage, "PI_A", typeof(PlanItem));
PlanItem planItemB = createElement(stage, "PI_B", typeof(PlanItem));
planItemX.Definition = stage;
planItemA.Definition = humanTaskA;
planItemB.Definition = humanTaskB;
// when
IList <CaseDefinitionEntity> caseDefinitions = transform();
// then
assertEquals(1, caseDefinitions.Count);
CaseDefinitionEntity caseDefinition = caseDefinitions[0];
IList <CmmnActivity> activities = caseDefinition.Activities;
CmmnActivity casePlanModelActivity = activities[0];
IList <CmmnActivity> children = casePlanModelActivity.Activities;
assertEquals(1, children.Count);
CmmnActivity planItemStage = children[0];
assertEquals(planItemX.Id, planItemStage.Id);
children = planItemStage.Activities;
assertEquals(2, children.Count);
CmmnActivity childPlanItem = children[0];
assertEquals(planItemA.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
childPlanItem = children[1];
assertEquals(planItemB.Id, childPlanItem.Id);
assertTrue(childPlanItem.Activities.Count == 0);
}
public virtual CaseInstance execute(CommandContext commandContext)
{
ensureAtLeastOneNotNull("caseDefinitionId and caseDefinitionKey are null", caseDefinitionId, caseDefinitionKey);
CaseDefinitionEntity caseDefinition = find(commandContext);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkCreateCaseInstance(caseDefinition);
}
// Start the case instance
CaseExecutionEntity caseInstance = (CaseExecutionEntity)caseDefinition.createCaseInstance(businessKey);
caseInstance.create(variables);
return(caseInstance);
}
protected internal virtual void initializeActivity(Case element, CmmnActivity activity, CmmnHandlerContext context)
{
CaseDefinitionEntity definition = (CaseDefinitionEntity)activity;
Deployment deployment = context.Deployment;
definition.Key = element.Id;
definition.Name = element.Name;
definition.DeploymentId = deployment.Id;
definition.TaskDefinitions = new Dictionary <string, TaskDefinition>();
definition.HistoryTimeToLive = ParseUtil.parseHistoryTimeToLive(element.CamundaHistoryTimeToLiveString);
CmmnModelInstance model = context.Model;
Definitions definitions = model.Definitions;
string category = definitions.TargetNamespace;
definition.Category = category;
}
public virtual void testUpdateCaseDefinitionIdInCaseExecutionEntity()
{
// given
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity caseDefinitionEntity1 = prepareCaseDefinition(java.util.UUID.randomUUID().toString());
CaseDefinitionEntity caseDefinitionEntity1 = prepareCaseDefinition(System.Guid.randomUUID().ToString());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity caseDefinitionEntity2 = prepareCaseDefinition(java.util.UUID.randomUUID().toString());
CaseDefinitionEntity caseDefinitionEntity2 = prepareCaseDefinition(System.Guid.randomUUID().ToString());
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.cmmn.entity.runtime.CaseExecutionEntity caseExecutionEntity = prepareCaseExecution(caseDefinitionEntity1);
CaseExecutionEntity caseExecutionEntity = prepareCaseExecution(caseDefinitionEntity1);
assertThat(caseExecutionEntity.CaseDefinitionId).isEqualTo(caseDefinitionEntity1.Id);
createCaseExecution(caseExecutionEntity);
caseExecutionEntity.CaseDefinition = caseDefinitionEntity2;
// Create
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.history.event.HistoricCaseActivityInstanceEventEntity historicCaseActivityInstanceEntity = prepareHistoricCaseActivityInstance(caseDefinitionEntity1);
HistoricCaseActivityInstanceEventEntity historicCaseActivityInstanceEntity = prepareHistoricCaseActivityInstance(caseDefinitionEntity1);
createCaseExecutionHistory(historicCaseActivityInstanceEntity);
// when
// Set new caseDefinitionId and update
historicCaseActivityInstanceEntity.CaseDefinitionId = caseDefinitionEntity2.Id;
historicCaseActivityInstanceEntity.EventType = HistoryEventTypes.CASE_ACTIVITY_INSTANCE_UPDATE.EventName;
updateCaseExecutionHistory(historicCaseActivityInstanceEntity);
// then
// Read from DB and assert
HistoricCaseActivityInstanceEntity updatedInstance = findHistoricCaseActivityInstance(historicCaseActivityInstanceEntity.Id);
assertThat(updatedInstance.CaseDefinitionId).isEqualTo(caseDefinitionEntity2.Id);
deleteHistoricCaseActivityInstance(historicCaseActivityInstanceEntity);
deleteCaseExecution(caseExecutionEntity);
deleteCaseDefinition(caseDefinitionEntity1);
deleteCaseDefinition(caseDefinitionEntity2);
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test public void getPreviousCaseDefinitionWithTenantId()
public virtual void getPreviousCaseDefinitionWithTenantId()
{
testRule.deployForTenant(TENANT_ONE, CMMN);
testRule.deployForTenant(TENANT_ONE, CMMN);
testRule.deployForTenant(TENANT_ONE, CMMN);
testRule.deployForTenant(TENANT_TWO, CMMN);
testRule.deployForTenant(TENANT_TWO, CMMN);
IList <CaseDefinition> latestCaseDefinitions = repositoryService.createCaseDefinitionQuery().latestVersion().orderByTenantId().asc().list();
CaseDefinitionEntity previousDefinitionTenantOne = getPreviousDefinition((CaseDefinitionEntity)latestCaseDefinitions[0]);
CaseDefinitionEntity previousDefinitionTenantTwo = getPreviousDefinition((CaseDefinitionEntity)latestCaseDefinitions[1]);
assertThat(previousDefinitionTenantOne.Version, @is(2));
assertThat(previousDefinitionTenantOne.TenantId, @is(TENANT_ONE));
assertThat(previousDefinitionTenantTwo.Version, @is(1));
assertThat(previousDefinitionTenantTwo.TenantId, @is(TENANT_TWO));
}
public virtual Void execute(CommandContext commandContext)
{
ensureNotNull(typeof(BadUserRequestException), "caseDefinitionId", caseDefinitionId);
if (historyTimeToLive != null)
{
ensureGreaterThanOrEqual(typeof(BadUserRequestException), "", "historyTimeToLive", historyTimeToLive, 0);
}
CaseDefinitionEntity caseDefinitionEntity = commandContext.CaseDefinitionManager.findLatestDefinitionById(caseDefinitionId);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkUpdateCaseDefinition(caseDefinitionEntity);
}
logUserOperation(commandContext, caseDefinitionEntity);
caseDefinitionEntity.HistoryTimeToLive = historyTimeToLive;
return(null);
}
protected internal virtual CaseDefinitionEntity find(CommandContext commandContext)
{
DeploymentCache deploymentCache = commandContext.ProcessEngineConfiguration.DeploymentCache;
// Find the case definition
CaseDefinitionEntity caseDefinition = null;
if (!string.ReferenceEquals(caseDefinitionId, null))
{
caseDefinition = findById(deploymentCache, caseDefinitionId);
ensureNotNull(typeof(CaseDefinitionNotFoundException), "No case definition found for id = '" + caseDefinitionId + "'", "caseDefinition", caseDefinition);
}
else
{
caseDefinition = findByKey(deploymentCache, caseDefinitionKey);
ensureNotNull(typeof(CaseDefinitionNotFoundException), "No case definition found for key '" + caseDefinitionKey + "'", "caseDefinition", caseDefinition);
}
return(caseDefinition);
}
private HistoricCaseActivityInstanceEventEntity prepareHistoricCaseActivityInstance(CaseDefinitionEntity caseDefinitionEntity1)
{
HistoricCaseActivityInstanceEventEntity historicCaseActivityInstanceEntity = new HistoricCaseActivityInstanceEventEntity();
historicCaseActivityInstanceEntity.Id = System.Guid.randomUUID().ToString();
historicCaseActivityInstanceEntity.CaseDefinitionId = caseDefinitionEntity1.Id;
historicCaseActivityInstanceEntity.CaseInstanceId = System.Guid.randomUUID().ToString();
historicCaseActivityInstanceEntity.CaseActivityId = System.Guid.randomUUID().ToString();
historicCaseActivityInstanceEntity.CreateTime = DateTime.Now;
return(historicCaseActivityInstanceEntity);
}
public CommandAnonymousInnerClass7(CaseDefinitionIdHistoryUpdateTest outerInstance, CaseDefinitionEntity caseDefinitionEntity)
{
this.outerInstance = outerInstance;
this.caseDefinitionEntity = caseDefinitionEntity;
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: private Void deleteCaseDefinition(final org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity caseDefinitionEntity)
private Void deleteCaseDefinition(CaseDefinitionEntity caseDefinitionEntity)
{
return(processEngineConfiguration.CommandExecutorTxRequiresNew.execute(new CommandAnonymousInnerClass7(this, caseDefinitionEntity)));
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: private void createCaseDefinition(final org.camunda.bpm.engine.impl.cmmn.entity.repository.CaseDefinitionEntity caseDefinitionEntity)
private void createCaseDefinition(CaseDefinitionEntity caseDefinitionEntity)
{
processEngineConfiguration.CommandExecutorTxRequiresNew.execute(new CommandAnonymousInnerClass6(this, caseDefinitionEntity));
}
public virtual void addCaseDefinition(CaseDefinitionEntity caseDefinition)
{
caseDefinitionCache.addDefinition(caseDefinition);
}
protected internal virtual void logUserOperation(CommandContext commandContext, CaseDefinitionEntity caseDefinitionEntity)
{
IList <PropertyChange> propertyChanges = new List <PropertyChange>();
propertyChanges.Add(new PropertyChange("historyTimeToLive", caseDefinitionEntity.HistoryTimeToLive, historyTimeToLive));
propertyChanges.Add(new PropertyChange("caseDefinitionKey", null, caseDefinitionEntity.Key));
commandContext.OperationLogManager.logCaseDefinitionOperation(org.camunda.bpm.engine.history.UserOperationLogEntry_Fields.OPERATION_TYPE_UPDATE_HISTORY_TIME_TO_LIVE, caseDefinitionId, propertyChanges);
}
