//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private java.util.Map<String, Object> extractVariables(org.camunda.bpm.engine.cdi.annotation.StartProcess startProcessAnnotation, javax.interceptor.InvocationContext ctx) throws Exception
private IDictionary <string, object> extractVariables(StartProcess startProcessAnnotation, InvocationContext ctx)
{
VariableMap variables = new VariableMapImpl();
foreach (System.Reflection.FieldInfo field in ctx.Method.DeclaringClass.DeclaredFields)
{
if (!field.isAnnotationPresent(typeof(ProcessVariable)) && !field.isAnnotationPresent(typeof(ProcessVariableTyped)))
{
continue;
}
field.Accessible = true;
string fieldName = null;
ProcessVariable processStartVariable = field.getAnnotation(typeof(ProcessVariable));
if (processStartVariable != null)
{
fieldName = processStartVariable.value();
}
else
{
ProcessVariableTyped processStartVariableTyped = field.getAnnotation(typeof(ProcessVariableTyped));
fieldName = processStartVariableTyped.value();
}
if (string.ReferenceEquals(fieldName, null) || fieldName.Length == 0)
{
fieldName = field.Name;
}
object value = field.get(ctx.Target);
variables.put(fieldName, value);
}
return(variables);
}
public virtual void submitFormVariables(VariableMap properties, VariableScope variableScope)
{
bool userOperationLogEnabled = Context.CommandContext.UserOperationLogEnabled;
Context.CommandContext.enableUserOperationLog();
VariableMap propertiesCopy = new VariableMapImpl(properties);
// support legacy form properties
foreach (FormPropertyHandler formPropertyHandler in formPropertyHandlers)
{
// submitFormProperty will remove all the keys which it takes care of
formPropertyHandler.submitFormProperty(variableScope, propertiesCopy);
}
// support form data:
foreach (FormFieldHandler formFieldHandler in formFieldHandlers)
{
if (!formFieldHandler.BusinessKey)
{
formFieldHandler.handleSubmit(variableScope, propertiesCopy, properties);
}
}
// any variables passed in which are not handled by form-fields or form
// properties are added to the process as variables
foreach (string propertyId in propertiesCopy.Keys)
{
variableScope.setVariable(propertyId, propertiesCopy.getValueTyped(propertyId));
}
fireFormPropertyHistoryEvents(properties, variableScope);
Context.CommandContext.LogUserOperationEnabled = userOperationLogEnabled;
}
public virtual void SubmitFormVariables(IVariableMap properties, IVariableScope variableScope)
{
VariableMapImpl propertiesCopy = new VariableMapImpl(properties);
// support legacy form properties
foreach (var formPropertyHandler in FormPropertyHandlers)
{
formPropertyHandler.SubmitFormProperty(variableScope, propertiesCopy);
}
// support form data:
foreach (var formFieldHandler in FormFieldHandlers)
{
formFieldHandler.HandleSubmit(variableScope, propertiesCopy, properties);
}
// any variables passed in which are not handled by form-fields or form
// properties are added to the process as variables
foreach (var propertyId in propertiesCopy.KeySet())
{
variableScope.SetVariable(propertyId, propertiesCopy.GetValueTyped <ITypedValue>(propertyId));
}
FireFormPropertyHistoryEvents(properties, variableScope);
}
public virtual IVariableMap GetVariablesTyped(bool deserializeValues)
{
var variableMap = new VariableMapImpl();
CollectVariables(variableMap, null, false, deserializeValues);
return(variableMap);
}
public override VariableMap execute(CommandContext commandContext)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.camunda.bpm.engine.impl.persistence.entity.TaskManager taskManager = commandContext.getTaskManager();
TaskManager taskManager = commandContext.TaskManager;
TaskEntity task = taskManager.findTaskById(resourceId);
ensureNotNull(typeof(BadUserRequestException), "Cannot find task with id '" + resourceId + "'.", "task", task);
checkGetTaskFormVariables(task, commandContext);
VariableMapImpl result = new VariableMapImpl();
// first, evaluate form fields
TaskDefinition taskDefinition = task.TaskDefinition;
if (taskDefinition != null)
{
TaskFormData taskFormData = taskDefinition.TaskFormHandler.createTaskForm(task);
foreach (FormField formField in taskFormData.FormFields)
{
if (formVariableNames == null || formVariableNames.Contains(formField.Id))
{
result.put(formField.Id, createVariable(formField, task));
}
}
}
// collect remaining variables from task scope and parent scopes
task.collectVariables(result, formVariableNames, false, deserializeObjectValues);
return(result);
}
protected internal virtual void ensureVariablesLocalInitialized()
{
if (this.variablesLocal == null)
{
this.variablesLocal = new VariableMapImpl();
}
}
public override IVariableMap Execute(CommandContext commandContext)
{
ITaskManager taskManager = commandContext.TaskManager;
TaskEntity task = taskManager.FindTaskById(ResourceId);
EnsureUtil.EnsureNotNull(typeof(BadUserRequestException), "Cannot find ITask with id '" + ResourceId + "'.", "ITask", task);
CheckGetTaskFormVariables(task, commandContext);
VariableMapImpl result = new VariableMapImpl();
// first, evaluate form fields
TaskDefinition taskDefinition = task.TaskDefinition;
if (taskDefinition != null)
{
ITaskFormData taskFormData = taskDefinition.TaskFormHandler.CreateTaskForm(task);
foreach (IFormField formField in taskFormData.FormFields)
{
if (FormVariableNames == null || FormVariableNames.Contains(formField.Id))
{
result.PutValue(formField.Id, CreateVariable(formField, task));
}
}
}
// collect remaining variables from ITask scope and parent scopes
task.CollectVariables(result, FormVariableNames, false, DeserializeObjectValues);
return(result);
}
public virtual IVariableMap GetVariablesLocalTyped(bool deserializeObjectValues)
{
var variables = new VariableMapImpl();
CollectVariables(variables, null, true, deserializeObjectValues);
return(variables);
}
public virtual VariableMapImpl getVariablesTyped(bool deserializeValues)
{
VariableMapImpl variableMap = new VariableMapImpl();
collectVariables(variableMap, null, false, deserializeValues);
return(variableMap);
}
protected internal virtual VariableMap collectLastVariables(CommandContext commandContext, HistoricProcessInstance processInstance)
{
HistoryService historyService = commandContext.ProcessEngineConfiguration.HistoryService;
IList <HistoricVariableInstance> historicVariables = historyService.createHistoricVariableInstanceQuery().executionIdIn(processInstance.Id).list();
VariableMap variables = new VariableMapImpl();
foreach (HistoricVariableInstance variable in historicVariables)
{
variables.putValueTyped(variable.Name, variable.TypedValue);
}
return(variables);
}
public virtual IVariableMap Execute(CommandContext commandContext)
{
EnsureUtil.EnsureNotNull("taskId", TaskId);
TaskEntity task = context.Impl.Context.CommandContext.TaskManager.FindTaskById(TaskId);
EnsureUtil.EnsureNotNull("ITask " + TaskId + " doesn't exist", "ITask", task);
CheckGetTaskVariables(task, commandContext);
var variables = new VariableMapImpl();
//collect variables from ITask
task.CollectVariables(variables, VariableNames, IsLocal, DeserializeValues);
return(variables);
}
public virtual VariableMap execute(CommandContext commandContext)
{
ensureNotNull("taskId", taskId);
TaskEntity task = Context.CommandContext.TaskManager.findTaskById(taskId);
ensureNotNull("task " + taskId + " doesn't exist", "task", task);
checkGetTaskVariables(task, commandContext);
VariableMapImpl variables = new VariableMapImpl();
// collect variables from task
task.collectVariables(variables, variableNames, isLocal, deserializeValues);
return(variables);
}
public virtual IVariableMap Execute(CommandContext commandContext)
{
EnsureUtil.EnsureNotNull("executionId", ExecutionId);
ExecutionEntity execution = commandContext.ExecutionManager.FindExecutionById(ExecutionId);
EnsureUtil.EnsureNotNull("execution " + ExecutionId + " doesn't exist", "execution", execution);
CheckGetExecutionVariables(execution, commandContext);
var executionVariables = new VariableMapImpl();
//collect variables from execution
execution.CollectVariables(executionVariables, VariableNames, IsLocal, DeserializeValues);
return(executionVariables);
}
public virtual VariableMap execute(CommandContext commandContext)
{
ensureNotNull("executionId", executionId);
ExecutionEntity execution = commandContext.ExecutionManager.findExecutionById(executionId);
ensureNotNull("execution " + executionId + " doesn't exist", "execution", execution);
checkGetExecutionVariables(execution, commandContext);
VariableMapImpl executionVariables = new VariableMapImpl();
// collect variables from execution
execution.collectVariables(executionVariables, variableNames, isLocal, deserializeValues);
return(executionVariables);
}
protected internal virtual IVariableMap CollectLastVariables(CommandContext commandContext,
IHistoricProcessInstance processInstance)
{
var historyService = commandContext.ProcessEngineConfiguration.HistoryService;
IList <IHistoricVariableInstance> historicVariables = historyService
.CreateHistoricVariableInstanceQuery(c => c.ExecutionId == processInstance.Id)
.ToList();
IVariableMap variables = new VariableMapImpl();
foreach (var variable in historicVariables)
{
variables.PutValueTyped(variable.Name, variable.TypedValue);
}
return(variables);
}
//JAVA TO C# CONVERTER WARNING: 'final' parameters are not available in .NET:
//ORIGINAL LINE: public org.camunda.bpm.engine.variable.VariableMap execute(final org.camunda.bpm.engine.impl.interceptor.CommandContext commandContext)
public override VariableMap execute(CommandContext commandContext)
{
StartFormData startFormData = commandContext.runWithoutAuthorization(new CallableAnonymousInnerClass(this, commandContext));
ProcessDefinition definition = startFormData.ProcessDefinition;
checkGetStartFormVariables((ProcessDefinitionEntity)definition, commandContext);
VariableMap result = new VariableMapImpl();
foreach (FormField formField in startFormData.FormFields)
{
if (formVariableNames == null || formVariableNames.Contains(formField.Id))
{
result.put(formField.Id, createVariable(formField, null));
}
}
return(result);
}
public virtual VariableMap execute(CommandContext commandContext)
{
ensureNotNull("caseExecutionId", caseExecutionId);
CaseExecutionEntity caseExecution = commandContext.CaseExecutionManager.findCaseExecutionById(caseExecutionId);
ensureNotNull(typeof(CaseExecutionNotFoundException), "case execution " + caseExecutionId + " doesn't exist", "caseExecution", caseExecution);
foreach (CommandChecker checker in commandContext.ProcessEngineConfiguration.CommandCheckers)
{
checker.checkReadCaseInstance(caseExecution);
}
VariableMapImpl result = new VariableMapImpl();
// collect variables
caseExecution.collectVariables(result, variableNames, isLocal, deserializeValues);
return(result);
}
protected internal virtual VariableMap collectInitialVariables(CommandContext commandContext, HistoricProcessInstance processInstance)
{
HistoryService historyService = commandContext.ProcessEngineConfiguration.HistoryService;
HistoricActivityInstance startActivityInstance = resolveStartActivityInstance(processInstance);
HistoricDetailQueryImpl query = (HistoricDetailQueryImpl)historyService.createHistoricDetailQuery().variableUpdates().executionId(processInstance.Id).activityInstanceId(startActivityInstance.Id);
IList <HistoricDetail> historicDetails = query.sequenceCounter(1).list();
VariableMap variables = new VariableMapImpl();
foreach (HistoricDetail detail in historicDetails)
{
HistoricVariableUpdate variableUpdate = (HistoricVariableUpdate)detail;
variables.putValueTyped(variableUpdate.VariableName, variableUpdate.TypedValue);
}
return(variables);
}
public override IVariableMap Execute(CommandContext commandContext)
{
IStartFormData startFormData = commandContext.RunWithoutAuthorization(() => new GetStartFormCmd(ResourceId).Execute(commandContext));
IProcessDefinition definition = startFormData.ProcessDefinition;
CheckGetStartFormVariables((ProcessDefinitionEntity)definition, commandContext);
IVariableMap result = new VariableMapImpl();
foreach (IFormField formField in startFormData.FormFields)
{
if (FormVariableNames == null || FormVariableNames.Contains(formField.Id))
{
result.PutValue(formField.Id, CreateVariable(formField, null));
}
}
return(result);
}
protected internal virtual IVariableMap CollectInitialVariables(CommandContext commandContext,
IHistoricProcessInstance processInstance)
{
var historyService = commandContext.ProcessEngineConfiguration.HistoryService;
var startActivityInstance = ResolveStartActivityInstance(processInstance);
var query = historyService.CreateHistoricDetailQuery(c => c.EventType == "VariableUpdate" && c.ExecutionId == processInstance.Id && c.ActivityInstanceId == startActivityInstance.Id);
//IList<IHistoricDetail> historicDetails = query.Where(c => c.SequenceCounter == 1)
// .ToList();
IVariableMap variables = new VariableMapImpl();
foreach (var detail in query /*historicDetails*/)
{
var variableUpdate = (IHistoricVariableUpdate)detail;
variables.PutValueTyped(variableUpdate.VariableName, variableUpdate.TypedValue);
}
return(variables);
}
public virtual void collectVariables(VariableMapImpl resultVariables, ICollection <string> variableNames, bool isLocal, bool deserializeValues)
{
bool collectAll = (variableNames == null);
IList <CoreVariableInstance> localVariables = getVariableInstancesLocal(variableNames);
foreach (CoreVariableInstance var in localVariables)
{
if (!resultVariables.containsKey(var.Name) && (collectAll || variableNames.Contains(var.Name)))
{
resultVariables.put(var.Name, var.getTypedValue(deserializeValues));
}
}
if (!isLocal)
{
AbstractVariableScope parentScope = ParentVariableScope;
// Do not propagate to parent if all variables in 'variableNames' are already collected!
if (parentScope != null && (collectAll || !resultVariables.Keys.Equals(variableNames)))
{
parentScope.collectVariables(resultVariables, variableNames, isLocal, deserializeValues);
}
}
}
public virtual void CollectVariables(VariableMapImpl resultVariables, ICollection <string> variableNames,
bool isLocal, bool deserializeValues)
{
var collectAll = variableNames == null;
var localVariables = VariableInstancesLocal;
foreach (var var in localVariables)
{
if (!resultVariables.ContainsKey(var.Name) && (collectAll || variableNames.Contains(var.Name)))
{
resultVariables.Put(@var.Name, @var.GetTypedValue(deserializeValues));
}
}
if (!isLocal)
{
var parentScope = ParentVariableScope;
// Do not propagate to parent if all variables in 'variableNames' are already collected!
if ((parentScope != null) && (collectAll || !resultVariables.KeySet().Equals(variableNames)))
{
parentScope.CollectVariables(resultVariables, variableNames, isLocal, deserializeValues);
}
}
}
