protected internal virtual void InitializeTaskPriority(TaskEntity task, IVariableScope variableScope) { var priorityExpression = taskDefinition.PriorityExpression; if (priorityExpression != null) { var priority = priorityExpression.GetValue(variableScope); if (priority != null) { if (priority is string) { try { task.Priority = Convert.ToInt32((string)priority); } catch (FormatException e) { throw new ProcessEngineException("Priority does not resolve to a number: " + priority, e); } } else if (priority is decimal || priority is int) { task.Priority = Convert.ToInt32(priority); } else { throw new ProcessEngineException("Priority expression does not resolve to a number: " + priorityExpression.ExpressionText); } } } }
public static ProcessDefinitionImpl GetProcessDefinitionToCall(IVariableScope execution, BaseCallableElement callableElement) { var processDefinitionKey = callableElement.GetDefinitionKey(execution); var tenantId = callableElement.GetDefinitionTenantId(execution); DeploymentCache deploymentCache = DeploymentCache; ProcessDefinitionImpl processDefinition = null; if (callableElement.LatestBinding) { processDefinition = deploymentCache.FindDeployedLatestProcessDefinitionByKeyAndTenantId(processDefinitionKey, tenantId); } else if (callableElement.DeploymentBinding) { var deploymentId = callableElement.DeploymentId; processDefinition = deploymentCache.FindDeployedProcessDefinitionByDeploymentAndKey(deploymentId, processDefinitionKey); } else if (callableElement.VersionBinding) { var version = callableElement.GetVersion(execution); processDefinition = deploymentCache.FindDeployedProcessDefinitionByKeyVersionAndTenantId(processDefinitionKey, version, tenantId); } return(processDefinition); }
//public static CmmnCaseDefinition getCaseDefinitionToCall(IVariableScope execution, BaseCallableElement callableElement) //{ // string caseDefinitionKey = callableElement.getDefinitionKey(execution); // string tenantId = callableElement.getDefinitionTenantId(execution); // DeploymentCache deploymentCache = DeploymentCache; // CmmnCaseDefinition caseDefinition = null; // if (callableElement.LatestBinding) // { // caseDefinition = deploymentCache.findDeployedLatestCaseDefinitionByKeyAndTenantId(caseDefinitionKey, tenantId); // } // else if (callableElement.DeploymentBinding) // { // string deploymentId = callableElement.DeploymentId; // caseDefinition = deploymentCache.findDeployedCaseDefinitionByDeploymentAndKey(deploymentId, caseDefinitionKey); // } // else if (callableElement.VersionBinding) // { // int? version = callableElement.getVersion(execution); // caseDefinition = deploymentCache.findDeployedCaseDefinitionByKeyVersionAndTenantId(caseDefinitionKey, version, tenantId); // } // return caseDefinition; //} public static IDecisionDefinition GetDecisionDefinitionToCall(IVariableScope execution, BaseCallableElement callableElement) { var decisionDefinitionKey = callableElement.GetDefinitionKey(execution); var tenantId = callableElement.GetDefinitionTenantId(execution); DeploymentCache deploymentCache = DeploymentCache; IDecisionDefinition decisionDefinition = null; if (callableElement.LatestBinding) { decisionDefinition = deploymentCache.FindDeployedLatestDecisionDefinitionByKeyAndTenantId(decisionDefinitionKey, tenantId); } else if (callableElement.DeploymentBinding) { var deploymentId = callableElement.DeploymentId; decisionDefinition = deploymentCache.FindDeployedDecisionDefinitionByDeploymentAndKey(deploymentId, decisionDefinitionKey); } else if (callableElement.VersionBinding) { var version = callableElement.GetVersion(execution); decisionDefinition = deploymentCache.FindDeployedDecisionDefinitionByKeyVersionAndTenantId(decisionDefinitionKey, version, tenantId); } return(decisionDefinition); }
protected internal virtual object ExecuteScript(string scriptSrc, IVariableScope scope) { var processEngineConfiguration = Context.ProcessEngineConfiguration; //ScriptFactory scriptFactory = processEngineConfiguration.ScriptFactory; //ExecutableScript script = scriptFactory.createScriptFromSource(ScriptingEngines.DEFAULT_SCRIPTING_LANGUAGE, // scriptSrc); //var invocation = new ScriptInvocation(script, scope); try { //processEngineConfiguration.DelegateInterceptor.handleInvocation(invocation); } //catch (Exception e) //{ // throw e; //} catch (System.Exception e) { throw new ProcessEngineException(e); } //return invocation.InvocationResult; return(null); }
public virtual object GetValue(IVariableScope variableScope, IBaseDelegateExecution contextExecution) { var elContext = ExpressionManager.GetElContext(variableScope); try { var invocation = new ExpressionGetInvocation(ValueExpression, elContext, contextExecution); Context.ProcessEngineConfiguration.DelegateInterceptor.HandleInvocation(invocation); return(invocation.InvocationResult); } catch (PropertyNotFoundException pnfe) { throw new ProcessEngineException( "Unknown property used in expression: " + ExpressionText + ". Cause: " + pnfe.Message, pnfe); } catch (MethodNotFoundException mnfe) { throw new ProcessEngineException( "Unknown method used in expression: " + ExpressionText + ". Cause: " + mnfe.Message, mnfe); } catch (ELException ele) { throw new ProcessEngineException( "Error while evaluating expression: " + ExpressionText + ". Cause: " + ele.Message, ele); } catch (System.Exception e) { throw new ProcessEngineException( "Error while evaluating expression: " + ExpressionText + ". Cause: " + e.Message, e); } }
public SubmitFormVariablesInvocation(IFormHandler formHandler, IVariableMap properties, IVariableScope variableScope) : base(null, null) { this.FormHandler = formHandler; this.Properties = properties; this.VariableScope = variableScope; }
public virtual void Notify(IDelegateTask delegateTask) { // Note: we can't cache the result of the expression, because the // execution can change: eg. delegateExpression='${mySpringBeanFactory.randomSpringBean()}' IVariableScope variableScope = delegateTask.Execution; if (variableScope == null) { variableScope = delegateTask.CaseExecution; } var @delegate = Expression.GetValue(variableScope); ClassDelegateUtil.ApplyFieldDeclaration(FieldDeclarations, @delegate); if (@delegate is ITaskListener) { try { Context.ProcessEngineConfiguration.DelegateInterceptor.HandleInvocation( new TaskListenerInvocation((ITaskListener)@delegate, delegateTask)); } catch (System.Exception e) { throw new ProcessEngineException("Exception while invoking TaskListener: " + e.Message, e); } } else { throw new ProcessEngineException("Delegate expression " + Expression + " did not resolve to an implementation of " + typeof(ITaskListener)); } }
private object GetValue(ELContext context, IVariableScope variableScope) { string expstr = ExpressionString; if ((VariableScopeElResolver.EXECUTION_KEY.Equals(expstr) && variableScope is IExecutionEntity) || (VariableScopeElResolver.TASK_KEY.Equals(expstr) && variableScope is ITaskEntity)) { context.IsPropertyResolved = true; return(variableScope); } else if (VariableScopeElResolver.EXECUTION_KEY.Equals(expstr) && variableScope is ITaskEntity entity) { context.IsPropertyResolved = true; return(entity.Execution); } else if (VariableScopeElResolver.LOGGED_IN_USER_KEY.Equals(expstr)) { context.IsPropertyResolved = true; return(Authentication.AuthenticatedUser.Id); } IScriptingEnginesProvider scriptingEnginesProvider = ProcessEngineServiceProvider.Resolve <IScriptingEnginesProvider>(); IScriptingEngines scriptingEngines = scriptingEnginesProvider.Create(language); var execution = variableScope is ITaskEntity te ? te.Execution : variableScope as IExecutionEntity; return(scriptingEngines.Evaluate(expstr, execution)); }
public Calculator(IVariableScope variables = null, IFunctionScope functions = null) { this.variables = variables; this.functions = functions; this.simplifier = new SimplifyBinary(variables, functions); }
protected internal virtual void InitializeTaskDueDate(TaskEntity task, IVariableScope variableScope) { var dueDateExpression = taskDefinition.DueDateExpression; if (dueDateExpression != null) { var dueDate = dueDateExpression.GetValue(variableScope); if (dueDate != null) { if (dueDate is DateTime) { task.DueDate = (DateTime)dueDate; } else if (dueDate is string) { var businessCalendar = BusinessCalender; task.DueDate = businessCalendar.ResolveDuedate((string)dueDate); } else { throw new ProcessEngineException( "Due date expression does not resolve to a Date or Date string: " + dueDateExpression.ExpressionText); } } } }
/// <summary> /// Initializes a new instance of the <see cref="TemplateContext"/> class /// </summary> /// <param name="data">The <see cref="IVariableScope"/>.</param> /// <param name="hostEnvironment"></param> internal TemplateContext(IVariableScope data, IHostEnvironment hostEnvironment) : base(hostEnvironment) { this.TempData = data; this.AllErrors = new List <Exception>(); }
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); }
/// <summary> /// /// </summary> /// <param name="variableScope"></param> /// <returns></returns> public virtual object GetValue(IVariableScope variableScope) { ELContext elContext = Context.ProcessEngineConfiguration.ExpressionManager.GetElContext(variableScope); try { ExpressionGetInvocation invocation = new ExpressionGetInvocation(valueExpression, elContext); Context.ProcessEngineConfiguration.DelegateInterceptor.HandleInvocation(invocation); return(invocation.InvocationResult); } //catch (PropertyNotFoundException pnfe) //{ // throw new ActivitiException("Unknown property used in expression: " + expressionText, pnfe); //} //catch (MethodNotFoundException mnfe) //{ // throw new ActivitiException("Unknown method used in expression: " + expressionText, mnfe); //} //catch (ELException ele) //{ // throw new ActivitiException("Error while evaluating expression: " + expressionText, ele); //} catch (Exception e) { throw new ActivitiException("Error while evaluating expression: " + expressionText, e); } }
public ScriptBindings(IList <IResolver> scriptResolvers, IVariableScope variableScope, IBindings wrappedBindings) { this.scriptResolvers = scriptResolvers; this.variableScope = variableScope; this.wrappedBindings = wrappedBindings; autoStoreScriptVariables = IsAutoStoreScriptVariablesEnabled(); }
public virtual bool Evaluate(IVariableScope scope, IDelegateExecution execution) { var result = Expression.GetValue(scope, execution); EnsureUtil.EnsureNotNull("condition expression returns null", "result", result); EnsureUtil.EnsureInstanceOf("condition expression returns non-Boolean", "result", result, typeof(bool)); return((bool)result); }
public DefaultFormFieldValidatorContext(IVariableScope variableScope, string configuration, IVariableMap submittedValues, FormFieldHandler formFieldHandler) { this.variableScope = variableScope; this.configuration = configuration; this.submittedValues = submittedValues; this.formFieldHandler = formFieldHandler; }
protected override object Evaluate(IScriptEngine engine, IVariableScope variableScope, IBindings bindings) { if (scriptSource == null) { LoadScriptSource(); } return(base.Evaluate(engine, variableScope, bindings)); }
public IResolver CreateResolver(IVariableScope variableScope) { if (variableScope != null) { return(new VariableScopeResolver(variableScope)); } return(null); }
protected internal virtual void InitializeConfiguration(ExecutionEntity context, TimerEntity job) { var businessCalendar = Context.ProcessEngineConfiguration.BusinessCalendarManager.GetBusinessCalendar(Type.GetDescription()); if (Description == null) { throw new ProcessEngineException("Timer '" + context.ActivityId + "' was not configured with a valid duration/time"); } string dueDateString = null; //throw new NotImplementedException(); DateTime?duedate = null; // ACT-1415: timer-declaration on start-event may contain expressions NOT // evaluating variables but other context, evaluating should happen nevertheless IVariableScope scopeForExpression = context; if (scopeForExpression == null) { scopeForExpression = StartProcessVariableScope.SharedInstance; } var dueDateValue = Description.GetValue(scopeForExpression); if (dueDateValue is string) { dueDateString = (string)dueDateValue; } else if (dueDateValue is DateTime) { duedate = (DateTime)dueDateValue; } else { throw new ProcessEngineException("Timer '" + context.ActivityId + "' was not configured with a valid duration/time, either hand in a java.Util.Date or a String in format 'yyyy-MM-dd'T'hh:mm:ss'"); } //throw new NotImplementedException(); if (duedate == null) { duedate = businessCalendar.ResolveDuedate(dueDateString); } job.Duedate = (DateTime)duedate; if (Type == TimerDeclarationType.Cycle && !ReferenceEquals(jobHandlerType, TimerCatchIntermediateEventJobHandler.TYPE)) { // See ACT-1427: A boundary timer with a cancelActivity='true', doesn't need to repeat itself if (!IsInterruptingTimer) { var prepared = PrepareRepeat(dueDateString); job.Repeat = prepared; } } }
public static bool DropVariable(this IVariableScope scope, string variableName) { if (scope == null || scope.VariableManager == null) { throw new InvalidOperationException("The scope is invalid or the variable manager has been disposed"); } return(scope.VariableManager.DropVariable(variableName)); }
public DelegateInvocationAnonymousInnerClass2(CallableElementActivityBehavior outerInstance, IActivityExecution execution, IVariableScope subInstance, IDelegateVariableMapping varMapping) : base(execution, null) { this._outerInstance = outerInstance; this._execution = execution; this._subInstance = subInstance; this._varMapping = varMapping; }
public void SubmitFormVariables(IVariableMap properties, IVariableScope variableScope) { ProcessEngineConfigurationImpl processEngineConfiguration = ESS.FW.Bpm.Engine.context.Impl.Context.ProcessEngineConfiguration; IIdentityService identityService = processEngineConfiguration.IdentityService; IRuntimeService runtimeService = processEngineConfiguration.RuntimeService; logAuthentication(identityService); logInstancesCount(runtimeService); }
protected internal virtual IDictionary <string, object> CreateBindings(IVariableScope variableScope) { if (variableScope == null) { return(null); } return(variableScope.Variables); }
protected internal virtual void InitializeTaskAssignments(TaskEntity task, IVariableScope variableScope) { // assignee InitializeTaskAssignee(task, variableScope); // candidateUsers InitializeTaskCandidateUsers(task, variableScope); // candidateGroups InitializeTaskCandidateGroups(task, variableScope); }
public virtual IVariableInstance GetVariableInstance(string variableName, bool fetchAllVariables) { // Transient variable if (transientVariabes != null && transientVariabes.ContainsKey(variableName)) { return(transientVariabes[variableName]); } // Check the local single-fetch cache if (usedVariablesCache.ContainsKey(variableName)) { return(usedVariablesCache[variableName]); } if (fetchAllVariables == true) { EnsureVariableInstancesInitialized(); variableInstances.TryGetValue(variableName, out IVariableInstanceEntity variableInstance); if (variableInstance != null) { return(variableInstance); } // Go up the hierarchy IVariableScope parentScope = ParentVariableScope; if (parentScope != null) { return(parentScope.GetVariableInstance(variableName, true)); } return(null); } else { if (variableInstances != null && variableInstances.ContainsKey(variableName)) { return(variableInstances[variableName]); } IVariableInstanceEntity variable = GetSpecificVariable(variableName); if (variable != null) { usedVariablesCache[variableName] = variable; return(variable); } // Go up the hierarchy IVariableScope parentScope = ParentVariableScope; if (parentScope != null) { return(parentScope.GetVariableInstance(variableName, false)); } return(null); } }
public virtual object GetValue(IVariableScope variableScope) { IList <object> valueList = new List <object>(); foreach (var provider in providerList) { valueList.Add(provider.GetValue(variableScope)); } return(valueList); }
protected internal virtual void InitializeTaskAssignee(TaskEntity task, IVariableScope variableScope) { var assigneeExpression = taskDefinition.AssigneeExpression; if (assigneeExpression != null) { //TODO 表达式相关 task.Assignee = (string)assigneeExpression.GetValue(variableScope); } }
protected internal virtual void InitializeTaskName(TaskEntity task, IVariableScope variableScope) { var nameExpression = taskDefinition.NameExpression; if (nameExpression != null) { var name = (string)nameExpression.GetValue(variableScope); task.Name = name; } }
protected internal virtual void InitializeTaskDescription(TaskEntity task, IVariableScope variableScope) { var descriptionExpression = taskDefinition.DescriptionExpression; if (descriptionExpression != null) { var description = (string)descriptionExpression.GetValue(variableScope); task.Description = description; } }
public virtual object GetValue(IVariableScope variableScope) { IDictionary <string, object> valueMap = new SortedDictionary <string, object>(); foreach (var entry in providerMap) { valueMap[entry.Key] = entry.Value.GetValue(variableScope); } return(valueMap); }
public Context(IWorkflow workflow, IVariableScope variableScope) : this(workflow) { if (variableScope == null) return; foreach (var variable in variableScope.Variables) { Variables.Add(variable); _values[variable] = new ValueStore(); } }
public Context(IContext context, IVariableScope variableScope) : this(context.Workflow, variableScope) { var contextVariableScope = context as Context; if (contextVariableScope == null) return; foreach (var argument in Workflow.Arguments) { _values[argument] = contextVariableScope._values[argument]; } foreach (var variable in contextVariableScope.Variables) { Variables.Add(variable); _values[variable] = contextVariableScope._values[variable]; } }
public static Expression Apply(IEnumerable<Type> transformations, Expression expr, IVariableScope variables, IFunctionScope functions) { Expression result = expr; foreach (Type type in transformations) { result = (new EliminateSubtractions(result)).Result; result = (new BinaryToLinear(result)).Result; RuleOrientedTransformation transformation = (RuleOrientedTransformation)Activator.CreateInstance(type); result = transformation.Transform(result, e => Apply(e, variables, functions)); result = (new LinearToBinary(result)).Result; result = (new SimplifyBinary(result, variables, functions)).Result; } return result; }
public Calculator(Expression expr, IVariableScope variables = null, IFunctionScope functions = null) : this(variables, functions) { this.result = Calculate(expr); }
public SimplifyBinary(IVariableScope variables = null, IFunctionScope functions = null) { this.variables = variables; this.functions = functions; }
public VariableManager(IVariableScope scope) { Scope = scope; variables = new Dictionary<string, Variable>(); }
public static Expression Apply(Expression expr, IVariableScope variables, IFunctionScope functions) { return Apply(transformations, expr, variables, functions); }
// Note: A local scope can only be defined inside a variable scope // (another block or a method body). public LocalScope(IVariableScope enclosingScope) : base(enclosingScope, true) { }
public Expression Differentiate(string var, IVariableScope variables, IFunctionScope functions, IDifferentiationScope derivatives) { return Differentiate(this, var, variables, functions, derivatives); }
public Expression Evaluate(IVariableScope variables, IFunctionScope functions) { return Evaluate(this, variables, functions); }
public static Expression Differentiate(Expression expr, string var, IVariableScope variables, IFunctionScope functions, IDifferentiationScope derivatives) { Expression derivative = (new Differentiation(expr, var, derivatives)).Result; return Evaluate(derivative, variables, functions); }
internal static VariableSymbol CreateAndDefineVariable(string name, IType type, IVariableScope scope) { var sym = new VariableSymbol(name, type, scope); scope.Define(sym); return sym; }
public static Expression Evaluate(IEnumerable<Type> transformations, Expression expr, IVariableScope variables, IFunctionScope functions) { Expression result = (new EliminateSubtractions(expr)).Result; result = (new SimplifyBinary(result, variables, functions)).Result; Expression presult = null; int count = 0; while (!result.Equals(presult) && count < 10) { presult = result; result = Apply(transformations, result, variables, functions); count++; } return (new ReturnSubtractions(result)).Result; }
public Expression Apply(IEnumerable<Type> transformations, IVariableScope variables, IFunctionScope functions) { return Apply(transformations, this, variables, functions); }
public SimplifyBinary(Expression expr, IVariableScope variables = null, IFunctionScope functions = null) : this(variables, functions) { this.result = Simplify(expr); }