private IUserInfo GetUser(IExecutionEntity execution, string authenticatedUserId)
{
IUserInfo starter;
IUserServiceProxy userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
try
{
starter = userService.GetUser(authenticatedUserId)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
starter.TenantId = execution.TenantId;
}
catch (Exception ex)
{
logger.LogError(ex, ex.Message);
starter = new UserInfo
{
Id = execution.StartUserId,
FullName = execution.StartUserId,
TenantId = execution.TenantId
};
}
return(starter);
}
/// <summary>
/// Cache which has a hard limit: no more elements will be cached than the limit. </summary>
public ProcessDefinitionInfoCache(ICommandExecutor commandExecutor, int limit)
{
this.commandExecutor = commandExecutor;
sizeLimit = limit;
cache = ProcessEngineServiceProvider.Resolve <MemoryCacheProvider>().Create(limit);
}
/// <summary>
/// 侦听接收通知处理
/// </summary>
/// <param name="execution"></param>
public void Notify(IExecutionEntity execution)
{
if (execution.CurrentFlowElement is UserTask userTask && userTask.HasMultiInstanceLoopCharacteristics())
{
var varName = userTask.LoopCharacteristics.GetCollectionVarName();
if (execution.GetVariable(varName) == null)
{
List <IUserInfo> users = new List <IUserInfo>();
string getUserPolicy = userTask.GetUsersPolicy();
if (string.IsNullOrWhiteSpace(getUserPolicy) == false)
{
QueryBookmark[] actors = JsonConvert.DeserializeObject <QueryBookmark[]>(getUserPolicy);
IGetBookmarkRuleProvider ruleProvider = ProcessEngineServiceProvider.Resolve <IGetBookmarkRuleProvider>();
foreach (QueryBookmark query in actors)
{
IGetBookmarkRule rule = ruleProvider.CreateBookmarkRule(query.RuleType.ToString());
rule.Execution = execution;
rule.Condition = query;
users.AddRange(Context.ProcessEngineConfiguration.CommandExecutor.Execute(rule));
}
}
//if (users.Count == 0)
//{
// throw new NoneCountersignUsersException(execution.CurrentFlowElement.Name);
//}
execution.SetVariable(varName, users.Count == 0 ? new string[] { "" } : users.Select(x => x.Id).Distinct().ToArray());
}
}
}
public void Notify(IDelegateTask task)
{
string assignee = task.Assignee;
if (string.IsNullOrWhiteSpace(assignee))
{
return;
}
IUserInfo user = task.GetVariableLocal <IUserInfo>($"{assignee}");
if (!(user is null) && user.Id == assignee)
{
return;
}
IUserServiceProxy userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
user = AsyncHelper.RunSync(() => userService.GetUser(assignee));
if (user == null)
{
logger.LogError($"找不到执行人{assignee}");
}
else
{
user.TenantId = task.TenantId;
task.AssigneeUser = user.FullName;
}
task.SetVariableLocal($"{assignee}", user);
}
/// <inheritdoc />
public override IList <IUserInfo> Execute(ICommandContext commandContext)
{
IUserServiceProxy proxy = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
string id = Condition.QueryCondition.FirstOrDefault().Id;
string[] users = null;
var hisService = commandContext.ProcessEngineConfiguration.HistoryService;
if (string.IsNullOrWhiteSpace(id))
{
var uid = hisService.CreateHistoricProcessInstanceQuery()
.SetProcessInstanceId(this.Execution.ProcessInstanceId)
.SingleResult().StartUserId;
users = new string[] { uid };
}
else
{
users = hisService.CreateHistoricTaskInstanceQuery()
.SetProcessInstanceId(this.Execution.ProcessInstanceId)
.SetTaskDefinitionKey(id)
.List()
.Select(x => x.Assignee)
.ToArray();
}
return(proxy.GetUsers(externalConnector.GetUserByDirectReporter, new RequestUserParameter
{
IdList = users,
Category = RequestUserCategory.GETUSER_DIRECTREPOT
}).ConfigureAwait(false).GetAwaiter().GetResult());
}
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 static void WriteDebugLog(this IExecutionEntity execution)
{
string doc = execution.CurrentFlowElement.Documentation;
if (string.IsNullOrWhiteSpace(doc) == false && Context.ProcessEngineConfiguration.EnableVerboseExecutionTreeLogging)
{
string root = AppDomain.CurrentDomain.BaseDirectory;
string file = Path.Combine(new string[] { root, "task_logs", $"{DateTime.Now:yyyyMMdd}.txt" });
Directory.CreateDirectory(Path.GetDirectoryName(file));
IExpression expression = Context.ProcessEngineConfiguration.ExpressionManager.CreateExpression(doc);
doc = expression.GetValue(execution)?.ToString();
string log = $"{(File.Exists(file) ? "\r\n" : "")}Task '{execution.ActivityId}' debug_logger {DateTime.Now:yyyy-MM-dd HH:mm:ss}:{doc}";
File.AppendAllText(file, log);
ILogger logger = ProcessEngineServiceProvider.Resolve <ILoggerFactory>().CreateLogger(execution.GetType());
if (logger.IsEnabled(LogLevel.Information))
{
logger.LogInformation(log);
}
}
}
/// <summary>
/// Cache which has a hard limit: no more elements will be cached than the limit.
/// </summary>
public DefaultDeploymentCache(int limit)
{
this.sizeLimit = limit;
memoryCacheProvider = ProcessEngineServiceProvider.Resolve <MemoryCacheProvider>();
cache = memoryCacheProvider.Create(limit);
}
public AddCountersignCmd(string taskId, string[] assignees, string tenantId)
{
this.taskId = taskId;
this.assignees = assignees;
this.tenantId = tenantId;
userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
}
/// <inheritdoc />
public override IList <IUserInfo> Execute(ICommandContext commandContext)
{
IUserServiceProxy proxy = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
return(AsyncHelper.RunSync(() => proxy.GetUsers(externalConnector.GetUserByDeptLeader, new
{
idList = Condition.QueryCondition.Select(x => x.Id).ToArray()
})));
}
public AddIdentityLinkCmd(string taskId, string identityId, int identityIdType, string identityType) : base(taskId)
{
ValidateParams(taskId, identityId, identityIdType, identityType);
this.taskId = taskId;
this.identityId = identityId;
this.identityIdType = identityIdType;
this.identityType = identityType;
userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
}
/// <inheritdoc />
public override IList <IUserInfo> Execute(ICommandContext commandContext)
{
IUserServiceProxy proxy = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
return(proxy.GetUsers(externalConnector.GetUserByDuty, new RequestUserParameter
{
IdList = Condition.QueryCondition.Select(x => x.Id).ToArray(),
Category = RequestUserCategory.GETUSERS_DUTY
}).ConfigureAwait(false).GetAwaiter().GetResult());
}
public CreateNewSubtaskCmd(string taskName, string description, DateTime?dueDate, int?priority, string parentTaskId, string assignee, string tenantId)
{
this.taskName = taskName;
this.description = description;
this.dueDate = dueDate;
this.parentTaskId = parentTaskId;
this.priority = priority;
this.assignee = assignee;
this.tenantId = tenantId;
this.userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
}
private async Task SendMessageAsync(IExecutionEntity execution, string msg, string msgServiceUrl)
{
var httpProxy = ProcessEngineServiceProvider.Resolve <IServiceWebApiHttpProxy>();
HttpResponseMessage response = await httpProxy.PostAsync <HttpResponseMessage>(msgServiceUrl, new
{
MessageId = msg,
execution.BusinessKey
}, CancellationToken.None).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
}
private IProcessEngine BuildProcessEngine()
{
try
{
ProcessEngineConfiguration engineConfig = ProcessEngineServiceProvider.Resolve <ProcessEngineConfiguration>();
return(engineConfig.BuildProcessEngine());
}
catch (Exception ex)
{
log.LogError(ex, $"buld process engine failed.{ex.Message}");
throw ex;
}
}
/// <summary>
/// 侦听接收通知处理
/// </summary>
/// <param name="execution"></param>
public void Notify(IExecutionEntity execution)
{
if (execution.CurrentFlowElement is UserTask userTask && userTask.HasMultiInstanceLoopCharacteristics())
{
var varName = userTask.LoopCharacteristics.GetCollectionVarName();
if (execution.GetVariable(varName) == null)
{
List <IUserInfo> users = new List <IUserInfo>();
string getUserPolicy = userTask.GetUsersPolicy();
if (string.IsNullOrWhiteSpace(getUserPolicy) == false)
{
if (EXPR_PATTERN.IsMatch(getUserPolicy))
{
getUserPolicy = EXPR_PATTERN.Replace(getUserPolicy, (m) =>
{
var value = m.Groups[1].Value;
var variables = execution.Variables;
object roles = ExpressionManager.GetValue(variables, value, variables);
return(roles.ToString());
});
}
QueryBookmark[] actors = JsonConvert.DeserializeObject <QueryBookmark[]>(getUserPolicy);
IGetBookmarkRuleProvider ruleProvider = ProcessEngineServiceProvider.Resolve <IGetBookmarkRuleProvider>();
foreach (QueryBookmark query in actors)
{
IGetBookmarkRule rule = ruleProvider.CreateBookmarkRule(query.RuleType.ToString());
rule.Execution = execution;
rule.Condition = query;
var us = Context.ProcessEngineConfiguration.CommandExecutor.Execute(rule);
users.AddRange(us);
}
}
if (users.Count == 0)
{
users.Add(Authentication.AuthenticatedUser);
logger.LogWarning($"调用查询人员服务失败,分组没有人,重新指到当前提交人,Duty={getUserPolicy}");
//throw new NoneCountersignUsersException(execution.CurrentFlowElement.Name);
}
execution.SetVariable(varName, users.Count == 0 ? new string[] { "" } : users.Select(x => x.Id).Distinct().ToArray());
}
}
}
/// <summary>
///
/// </summary>
/// <param name="sequenceFlowId"></param>
/// <param name="execution"></param>
/// <returns></returns>
public virtual bool Evaluate(string sequenceFlowId, IExecutionEntity execution)
{
IScriptingEnginesProvider scriptingEnginesProvider = ProcessEngineServiceProvider.Resolve <IScriptingEnginesProvider>();
IScriptingEngines scriptingEngines = scriptingEnginesProvider.Create(language);
object result = scriptingEngines.Evaluate(expression, execution);
if (result is null)
{
throw new ActivitiException("condition script returns null: " + expression);
}
if (!(result is bool))
{
throw new ActivitiException("condition script returns non-Boolean: " + result + " (" + result.GetType().FullName + ")");
}
return(Convert.ToBoolean(result));
}
public override void Execute(IExecutionEntity execution)
{
execution.CurrentFlowElement.ExtensionElements.TryGetValue(BpmnXMLConstants.ELEMENT_EXTENSIONS_PROPERTY,
out IList <ExtensionElement> pElements);
if (pElements != null)
{
try
{
WebApiParameter parameter = new WebApiParameter(execution, pElements);
string url = parameter.Url;
string dataObj = parameter.VariableName;
string method = parameter.Method;
var httpProxy = ProcessEngineServiceProvider.Resolve <IServiceWebApiHttpProxy>();
HttpContext httpContext = ProcessEngineServiceProvider.Resolve <IHttpContextAccessor>()?.HttpContext;
if (httpContext == null)
{
IAccessTokenProvider accessTokenProvider = ProcessEngineServiceProvider.Resolve <IAccessTokenProvider>();
accessTokenProvider.SetHttpClientRequestAccessToken(httpProxy.HttpClient, null, execution.TenantId);
}
switch (method?.ToLower())
{
default:
case "get":
ExecuteGet(execution, url, parameter.Request, dataObj, httpProxy);
break;
case "post":
ExecutePost(execution, url, parameter.Request, dataObj, httpProxy);
break;
}
Leave(execution);
}
catch (Exception ex)
{
throw new BpmnError(Context.CommandContext.ProcessEngineConfiguration.WebApiErrorCode, ex.Message);
}
}
}
/// <summary>
///
/// </summary>
public void EnsureInitialized()
{
var ctx = Context.CommandContext;
if (id != null && entity == null)
{
if (ctx == null)
{
if (!(ProcessEngineServiceProvider.Resolve <IProcessEngine>().ProcessEngineConfiguration is ProcessEngineConfigurationImpl pi))
{
return;
}
ctx = pi.CommandContextFactory.CreateCommandContext(new ByteArrayRefCmd(id));
Context.CommandContext = ctx;
}
entity = ctx.ByteArrayEntityManager.FindById <IByteArrayEntity>(new KeyValuePair <string, object>("id", id));
name = entity.Name;
}
}
public void Notify(IDelegateTask task)
{
string assignee = task.Assignee;
if (string.IsNullOrWhiteSpace(assignee))
{
return;
}
IUserInfo user;
if (task.HasVariableLocal(assignee))
{
user = task.GetVariableLocal <IUserInfo>(assignee);
if (user is object && string.Equals(user.Id, assignee, StringComparison.OrdinalIgnoreCase))
{
return;
}
}
IUserServiceProxy userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
user = userService.GetUser(assignee)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
if (user == null)
{
logger.LogError($"找不到执行人{assignee}");
}
else
{
user.TenantId = task.TenantId;
task.AssigneeUser = user.FullName;
}
task.SetVariableLocal($"{assignee}", user);
}
/// <inheritdoc />
public override IList <IUserInfo> Execute(ICommandContext commandContext)
{
IList <IHistoricTaskInstance> hisTasks = commandContext.ProcessEngineConfiguration.HistoryService
.CreateHistoricTaskInstanceQuery()
.SetExecutionId(this.Execution.Id)
.List();
IList <IUserInfo> users = hisTasks.Where(x => Condition.QueryCondition.Any(y => y.Id == x.TaskDefinitionKey))
.Select(x => new UserInfo
{
Id = x.Assignee
})
.ToList <IUserInfo>();
if (Condition.QueryCondition.Any(x => string.Equals("", x.Id)))
{
var hisInst = commandContext.ProcessEngineConfiguration.HistoryService
.CreateHistoricProcessInstanceQuery()
.SetProcessInstanceId(this.Execution.ProcessInstanceId)
.SingleResult();
string uid = hisInst == null ? this.Execution.Parent.StartUserId : hisInst.StartUserId;
users.Add(new UserInfo
{
Id = uid
});
}
IUserServiceProxy proxy = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
return(proxy.GetUsers(externalConnector.GetUser, new RequestUserParameter
{
IdList = users.Select(x => x.Id).ToArray(),
Category = RequestUserCategory.GETUSER_EXECUTOR
}).ConfigureAwait(false).GetAwaiter().GetResult());
}
public virtual TableMetaData GetTableMetaData(string tableName)
{
TableMetaData result = new TableMetaData();
try
{
result.TableName = tableName;
//DatabaseMetaData metaData = DbSqlSession.SqlSession.Connection.MetaData;
if ("postgres".Equals(DbSqlSession.DbSqlSessionFactory.DatabaseType))
{
tableName = tableName.ToLower();
}
string catalog = null;
if (ProcessEngineConfiguration.DatabaseCatalog is object && ProcessEngineConfiguration.DatabaseCatalog.Length > 0)
{
catalog = ProcessEngineConfiguration.DatabaseCatalog;
}
string schema = null;
if (ProcessEngineConfiguration.DatabaseSchema is object && ProcessEngineConfiguration.DatabaseSchema.Length > 0)
{
if ("oracle".Equals(DbSqlSession.DbSqlSessionFactory.DatabaseType))
{
schema = ProcessEngineConfiguration.DatabaseSchema.ToUpper();
}
else
{
schema = ProcessEngineConfiguration.DatabaseSchema;
}
}
var dbreader = ProcessEngineServiceProvider.Resolve <IDatabaseReader>();
DatabaseTable table = dbreader.AllTables().FirstOrDefault(x => string.Compare(tableName, x.Name, true) == 0) ?? new DatabaseTable();
foreach (var col in table.Columns)
{
//bool wrongSchema = false;
//if (!string.ReferenceEquals(schema, null) && schema.Length > 0)
//{
// string columnName = col.Name;
// if ("TABLE_SCHEM".Equals(columnName, StringComparison.CurrentCultureIgnoreCase) || "TABLE_SCHEMA".Equals(columnName, StringComparison.CurrentCultureIgnoreCase))
// {
// if (!schema.Equals(resultSet.getString(resultSet.MetaData.getColumnName(i + 1)), StringComparison.CurrentCultureIgnoreCase))
// {
// wrongSchema = true;
// }
// break;
// }
//}
//if (!wrongSchema)
//{
string name = col.Name.ToUpper();
string type = col.DbDataType.ToUpper();// resultSet.getString("TYPE_NAME").ToUpper();
result.addColumnMetaData(name, type);
//}
}
}
catch (Exception e)
{
throw new ActivitiException("Could not retrieve database metadata: " + e.Message);
}
if (result.ColumnNames.Count == 0)
{
// According to API, when a table doesn't exist, null should be returned
result = null;
}
return(result);
}
public static string Url(string url)
{
ExternalConnectorProvider provider = ProcessEngineServiceProvider.Resolve <ExternalConnectorProvider>();
return(provider.ResolveUrl(url));
}
public SendTaskActivityBehavior()
{
externalConnector = ProcessEngineServiceProvider.Resolve <ExternalConnectorProvider>();
}
/// <summary>
///
/// </summary>
/// <param name="taskEntityManager"></param>
/// <param name="assignee"></param>
/// <param name="owner"></param>
/// <param name="candidateUsers"></param>
/// <param name="candidateGroups"></param>
/// <param name="task"></param>
/// <param name="expressionManager"></param>
/// <param name="execution"></param>
protected internal virtual void HandleAssignments(ITaskEntityManager taskEntityManager, string assignee, string owner, IList <string> candidateUsers, IList <string> candidateGroups, ITaskEntity task, ExpressionManager expressionManager, IExecutionEntity execution)
{
if (!string.IsNullOrWhiteSpace(assignee))
{
object assigneeExpressionValue = expressionManager.CreateExpression(assignee).GetValue(execution);
string assigneeValue = null;
if (assigneeExpressionValue != null)
{
assigneeValue = assigneeExpressionValue.ToString();
}
string assigneeUser = null;
if (string.IsNullOrWhiteSpace(assigneeValue) == false)
{
IUserServiceProxy userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
var user = userService.GetUser(assigneeValue)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
assigneeUser = user?.FullName;
task.SetVariableLocal(assigneeValue, user);
}
taskEntityManager.ChangeTaskAssigneeNoEvents(task, assigneeValue, assigneeUser);
}
if (!string.IsNullOrWhiteSpace(owner))
{
object ownerExpressionValue = expressionManager.CreateExpression(owner).GetValue(execution);
string ownerValue = null;
if (ownerExpressionValue != null)
{
ownerValue = ownerExpressionValue.ToString();
}
taskEntityManager.ChangeTaskOwner(task, ownerValue);
}
if (candidateGroups != null && candidateGroups.Count > 0)
{
foreach (string candidateGroup in candidateGroups)
{
IExpression groupIdExpr = expressionManager.CreateExpression(candidateGroup);
object value = groupIdExpr.GetValue(execution);
if (value is string @string)
{
IList <string> candidates = ExtractCandidates(@string);
task.AddCandidateGroups(candidates);
}
else if (value is ICollection)
{
task.AddCandidateGroups((ICollection <string>)value);
}
else
{
throw new ActivitiIllegalArgumentException("Expression did not resolve to a string or collection of strings");
}
}
}
if (candidateUsers != null && candidateUsers.Count > 0)
{
foreach (string candidateUser in candidateUsers)
{
IExpression userIdExpr = expressionManager.CreateExpression(candidateUser);
object value = userIdExpr.GetValue(execution);
if (value is string @string)
{
IList <string> candidates = ExtractCandidates(@string);
task.AddCandidateUsers(candidates);
}
else if (value is ICollection)
{
task.AddCandidateUsers((ICollection <string>)value);
}
else
{
throw new ActivitiException("Expression did not resolve to a string or collection of strings");
}
}
}
if (userTask.CustomUserIdentityLinks != null && userTask.CustomUserIdentityLinks.Count > 0)
{
foreach (string customUserIdentityLinkType in userTask.CustomUserIdentityLinks.Keys)
{
foreach (string userIdentityLink in userTask.CustomUserIdentityLinks[customUserIdentityLinkType])
{
IExpression idExpression = expressionManager.CreateExpression(userIdentityLink);
object value = idExpression.GetValue(execution);
if (value is string @string)
{
IList <string> userIds = ExtractCandidates(@string);
foreach (string userId in userIds)
{
task.AddUserIdentityLink(userId, customUserIdentityLinkType);
}
}
else if (value is ICollection collection)
{
IEnumerator userIdSet = collection.GetEnumerator();
while (userIdSet.MoveNext())
{
task.AddUserIdentityLink((string)userIdSet.Current, customUserIdentityLinkType);
}
}
else
{
throw new ActivitiException("Expression did not resolve to a string or collection of strings");
}
}
}
}
if (userTask.CustomGroupIdentityLinks != null && userTask.CustomGroupIdentityLinks.Count > 0)
{
foreach (string customGroupIdentityLinkType in userTask.CustomGroupIdentityLinks.Keys)
{
foreach (string groupIdentityLink in userTask.CustomGroupIdentityLinks[customGroupIdentityLinkType])
{
IExpression idExpression = expressionManager.CreateExpression(groupIdentityLink);
object value = idExpression.GetValue(execution);
if (value is string @string)
{
IList <string> groupIds = ExtractCandidates(@string);
foreach (string groupId in groupIds)
{
task.AddGroupIdentityLink(groupId, customGroupIdentityLinkType);
}
}
else if (value is ICollection collection)
{
IEnumerator groupIdSet = collection.GetEnumerator();
while (groupIdSet.MoveNext())
{
task.AddGroupIdentityLink((string)groupIdSet.Current, customGroupIdentityLinkType);
}
}
else
{
throw new ActivitiException("Expression did not resolve to a string or collection of strings");
}
}
}
}
}
/// <inheritdoc />
public GetDeptLeaderBookmarkRuleCmd()
{
externalConnector = ProcessEngineServiceProvider.Resolve <ExternalConnectorProvider>();
}
public UpdateTaskCmd(IUpdateTaskCmd cmd)
{
this.updateTaskCmd = cmd;
userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
}
// CREATE METHODS
public virtual IExecutionEntity CreateProcessInstanceExecution(IProcessDefinition processDefinition, string businessKey, string tenantId, string initiatorVariableName)
{
IExecutionEntity processInstanceExecution = executionDataManager.Create();
if (ExecutionRelatedEntityCountEnabledGlobally)
{
((ICountingExecutionEntity)processInstanceExecution).IsCountEnabled = true;
}
processInstanceExecution.ProcessDefinitionId = processDefinition.Id;
processInstanceExecution.ProcessDefinitionKey = processDefinition.Key;
processInstanceExecution.ProcessDefinitionName = processDefinition.Name;
processInstanceExecution.ProcessDefinitionVersion = processDefinition.Version;
processInstanceExecution.BusinessKey = businessKey;
processInstanceExecution.IsScope = true; // process instance is always a scope for all child executions
// Inherit tenant id (if any)
if (tenantId is object)
{
processInstanceExecution.TenantId = tenantId;
}
string authenticatedUserId = Authentication.AuthenticatedUser.Id;
processInstanceExecution.StartTime = Context.ProcessEngineConfiguration.Clock.CurrentTime;
processInstanceExecution.StartUserId = authenticatedUserId;
processInstanceExecution.StartUser = Authentication.AuthenticatedUser.FullName;
// Store in database
Insert(processInstanceExecution, false);
if (string.IsNullOrWhiteSpace(processInstanceExecution.StartUserId) == false)
{
IUserInfo starter = null;
IUserServiceProxy userService = ProcessEngineServiceProvider.Resolve <IUserServiceProxy>();
ExternalConnectorProvider externalConnector = ProcessEngineServiceProvider.Resolve <ExternalConnectorProvider>();
starter = new UserInfo
{
Id = processInstanceExecution.StartUserId,
FullName = processInstanceExecution.StartUserId
};
//TODO: 考虑性能问题，暂时不要获取人员信息
//try
//{
// starter = AsyncHelper.RunSync<IUserInfo>(() => userService.GetUser(processInstanceExecution.StartUserId));
// starter.TenantId = processInstanceExecution.TenantId;
//}
//catch (Exception ex)
//{
// logger.LogError(ex, ex.Message);
// starter = new UserInfo
// {
// Id = processInstanceExecution.StartUserId,
// FullName = processInstanceExecution.StartUserId
// };
//}
//保存调用用户变量
processInstanceExecution.SetVariable(processInstanceExecution.StartUserId, starter);
}
if (initiatorVariableName is object)
{
processInstanceExecution.SetVariable(initiatorVariableName, authenticatedUserId);
}
// Need to be after insert, cause we need the id
processInstanceExecution.ProcessInstanceId = processInstanceExecution.Id;
processInstanceExecution.RootProcessInstanceId = processInstanceExecution.Id;
//TODO: 当没有用户任务的时候，添加identity会报错
if (authenticatedUserId is object)
{
IdentityLinkEntityManager.AddIdentityLink(processInstanceExecution, authenticatedUserId, null, IdentityLinkType.STARTER);
}
// Fire events
if (EventDispatcher.Enabled)
{
EventDispatcher.DispatchEvent(ActivitiEventBuilder.CreateEntityEvent(ActivitiEventType.ENTITY_CREATED, processInstanceExecution));
}
return(processInstanceExecution);
}
public override void Execute(IExecutionEntity execution)
{
execution.CurrentFlowElement.ExtensionElements.TryGetValue(BpmnXMLConstants.ELEMENT_EXTENSIONS_PROPERTY,
out IList <ExtensionElement> pElements);
if (pElements != null)
{
Exception exception = null;
Stopwatch sw = new Stopwatch();
string url = null;
string dataObj = null;
object request = null;
try
{
sw.Start();
WebApiParameter parameter = new WebApiParameter(execution, pElements);
url = parameter.Url;
dataObj = parameter.VariableName;
request = parameter.Request;
string method = parameter.Method;
var httpProxy = ProcessEngineServiceProvider.Resolve <IHttpClientProxy>();
HttpContext httpContext = ProcessEngineServiceProvider.Resolve <IHttpContextAccessor>()?.HttpContext;
if (httpContext == null)
{
httpProxy.SetHttpClientRequestAccessToken(execution.StartUserId, execution.TenantId);
//IAccessTokenProvider accessTokenProvider = ProcessEngineServiceProvider.Resolve<IAccessTokenProvider>();
//accessTokenProvider.SetHttpClientRequestAccessToken(httpProxy.HttpClient, execution.StartUserId, execution.TenantId);
}
switch (method?.ToLower())
{
default:
case "get":
ExecuteGet(execution, url, request, dataObj, httpProxy);
break;
case "post":
ExecutePost(execution, url, request, dataObj, httpProxy);
break;
}
sw.Stop();
logger.LogInformation($"调用外部服务共计({sw.ElapsedMilliseconds}ms) url={url} request={(request is null ? "" : JsonConvert.SerializeObject(request))}");
Leave(execution);
}
catch (Exception ex)
{
sw.Stop();
logger.LogError($"调用外部服务失败({sw.ElapsedMilliseconds}ms) url={url} request={(request is null ? "" : JsonConvert.SerializeObject(request))}：\r\n" + ex.Message + ex.StackTrace);
throw new BpmnError(Context.CommandContext.ProcessEngineConfiguration.WebApiErrorCode, ex.Message);
}
}
}
public virtual void Clear()
{
cache.Dispose();
cache = ProcessEngineServiceProvider.Resolve <MemoryCacheProvider>().Create(sizeLimit);
}
