public Activity(Engine engine, ActivityEntity entity, ProcessContext context = null)
{
this.Engine = engine;
this.FlowRepository = engine.ResolveFlowRepository(context);
this.entity = entity;
this.id = entity.Id;
}
void Postdicate(ProcessContext processContext, ITransaction trans = null)
{
// 已处理，且状态有变化的才能执行结束检查
if (this.Status != ActivityStates.Dealed || !this.statesChanged || results == null)
{
return;
}
if (!this.Action.Postdicate(this, processContext))
{
return;
}
this.Status = ActivityStates.Done;
this.Entity.DoneTime = DateTime.Now;
if (this.Graph.Exports != null && this.Graph.Exports.Count > 0)
{
var parent = this.Parent as Activity;
var parentStates = parent.States as JObject;
foreach (var pair in this.Graph.Exports)
{
var value = JSON.GetPathValue(this.states, pair.Key);
JSON.SetPathValue(parentStates, pair.Value, value);
parent.statesChanged = true;
}
parent.SaveChanges(trans);
this.Todo(parent, null);
}
this.SaveChanges(trans);
}
Activity ResolveNextActivity(IAssociation assoc, NavigateResults navResults, ProcessContext processContext)
{
var parent = this.FromActivity.Parent as Activity;
if (parent.Graph.Nodes == null)
{
throw new InvalidGraphException("父级节点{0}的图形不正确，没有nodes", parent.Id.ToString());
}
var node = parent.Graph.Nodes.FirstOrDefault(node => node.Name == assoc.To);
if (node == null)
{
throw new InvalidGraphException("未在父级节点{0}找到名称为{1}的节点", parent.Id.ToString(), assoc.To);
}
var nextActivity = parent.FindUndealedChild(node.Name);
if (nextActivity != null)
{
return(nextActivity);
}
nextActivity = new Activity(this.FromActivity.Engine, parent, node, this.FromActivity.Version, navResults.NextInputs, processContext.Dealer, navResults.NextDealer, processContext);
this.FromActivity.Todo(nextActivity, navResults.NextInputs);
this.ToActivities.Add(nextActivity);
this.ActivityEntities.Add(nextActivity.Entity);
return(nextActivity);
}
public ActivityStates Deal(object inputs, IUser dealer, object context)
{
//创建上下文
var processContext = new ProcessContext(this, inputs, dealer, context);
return(this.Deal(inputs, processContext));
}
public virtual object Execute(IActivity activity, object inputs, ProcessContext processContext)
{
string[] starts = activity.Graph.Starts;
if (starts == null || starts.Length == 0)
{
if (activity.Graph.Start != null)
{
starts = new string[] { activity.Graph.Start }
}
;
}
var nodes = activity.Graph.Nodes;
if (starts == null || starts.Length == 0)
{
if (nodes != null && nodes.Count != 0)
{
throw new InvalidGraphException("活动{0}未配置start/starts,却没有配置nodes", this.ToString());
}
}
if (nodes == null && nodes.Count == 0)
{
throw new InvalidGraphException("活动{0}配置了start/starts,却没有配置nodes", this.ToString());
}
var nextEntities = new List <ActivityEntity>();
foreach (var startName in starts)
{
var startNode = activity.Graph.Nodes.FirstOrDefault(p => p.Name == startName);
if (startNode == null)
{
throw new InvalidGraphException("活动{0}无法找到起始节点{1}", this.ToString(), startName);
}
IUser startOwner = null;
if (processContext.StartOwners != null)
{
processContext.StartOwners.TryGetValue(startName, out startOwner);
}
if (startOwner == null)
{
startOwner = processContext.StartOwner;
}
if (startOwner == null)
{
throw new ArgumentException("未指定开始节点的所有者，请给owner/owners参数赋值");
}
var startActivity = new Activity(processContext.Engine, activity as Activity, startNode, activity.Version, inputs, processContext.Dealer, startOwner, processContext);
nextEntities.Add(startActivity.Entity);
processContext.Todo(startActivity, inputs);
}
processContext.FlowRepository.InsertActivities(nextEntities, processContext.FlowTransaction);
return(null);
}
public virtual IAction LoadAction(string actionTypeName, ProcessContext context)
{
var actionType = LoadActionType(actionTypeName);
if (actionType == null)
{
return(null);
}
return(Activator.CreateInstance(actionType) as IAction);
}
void Todo(ProcessContext processContext)
{
while (this.todos != null)
{
var todos = this.todos;
this.todos = null;
foreach (var pair in todos)
{
pair.Key.Deal(pair.Value, processContext);
}
}
}
internal ActivityStates Deal(object inputs, ProcessContext processContext)
{
//终态，直接返回
if (this.IsFulfilled)
{
return(this.Status);
}
// 用户检查
if (this.Status != ActivityStates.Created &&
processContext.Dealer != null &&
this.Owner != null &&
this.owner.Id != processContext.Dealer.Id
)
{
return(this.Status);
}
// 合并Inputs到状态中
this.CombineInputsToStates(inputs);
// 处理者
this.Dealer = processContext.Dealer;
// 加载活动
this.Action = this.Engine.LoadAction(this.Graph.InstanceType, processContext) ?? new Action();
if (this.Predicate(inputs, processContext))
{
var trans = this.FlowRepository.CreateTransaction(processContext.UserContext);
try {
trans.TryBegin();
// 执行得到执行结果
var executeResult = this.Execute(inputs, processContext);
// 试图结束当前活动
this.Postdicate(processContext, trans);
// 根据执行结果看是否执行下一步
this.ResolveNexts(executeResult, processContext, trans);
} catch (Exception ex) {
trans.TryRollback();
throw ex;
}
this.Todo(processContext);
}
return(this.Status);
}
Navigations ResolveNexts(object executeResults, ProcessContext processConext, ITransaction trans)
{
// 已处理，且状态有变化的才能开始寻找下一步
if (this.Status != ActivityStates.Dealed || !this.statesChanged || executeResults == null)
{
return(null);
}
if (this.Graph.Nexts == null || this.Graph.Nexts.Count == 0)
{
return(null);
}
var navs = new Navigations(this, executeResults);
foreach (var assoc in this.Graph.Nexts)
{
navs.AddIfPass(assoc, processConext);
}
return(navs.Save(trans));
}
public virtual bool Postdicate(IActivity activity, ProcessContext processContext)
{
var nodes = activity.Graph.Nodes;
//如果是活动容器，要首先检查是否还有活着的子活动
if (nodes != null &&
nodes.Count != 0 &&
activity.Children.Any(p => !p.IsFulfilled))
{
return(false);
}
if (!string.IsNullOrEmpty(activity.Graph.Key))
{
var value = activity.State <string>(activity.Graph.Key);
return(value == activity.Graph.Value);
}
return(true);
}
bool Predicate(object inputs, ProcessContext context)
{
// 已创建，但尚未开始的可以做执行检查
if (this.Status != ActivityStates.Creating && this.Status != ActivityStates.Created)
{
return(true);
}
// 创建事务
var trans = this.FlowRepository.CreateTransaction(context.UserContext);
try {
// 开始事务
trans.TryBegin();
// 执行Action的predicate获取到owner
var owner = this.Action.Predicate(this, inputs, context);
// 返回null，表示活动的进入检查不成功，返回false
if (owner == null)
{
// 活动状态变更为处理中
this.Status = ActivityStates.Created;
this.SaveChanges(trans);
trans.TryCommitAsync();
return(false);
}
// 指定了有效所有者才会赋值
if (!string.IsNullOrEmpty(owner.Id))
{
this.Owner = owner;
}
// 活动对象的状态变更为处理中
this.Status = ActivityStates.Dealing;
this.SaveChanges(trans);
trans.TryCommit();
return(true);
} catch (Exception ex) {
trans.TryRollback();
throw ex;
}
}
object Execute(object inputs, ProcessContext protecssContext)
{
//正在处理/已处理还未完成的活动可以被执行
if (this.Status != ActivityStates.Dealing && this.Status != ActivityStates.Dealed)
{
return(null);
}
var executeResults = this.results = this.Action.Execute(this, inputs, protecssContext);
if (executeResults == null)
{
return(null);
}
var jobj = JObject.FromObject(executeResults);
this.results = jobj;
foreach (var pair in jobj)
{
this.State(pair.Key, pair.Value);
}
this.Status = ActivityStates.Dealed;
return(executeResults);
}
public bool AddIfPass(IAssociation assoc, ProcessContext processConext)
{
// 该连线已经有了
if (this.FromActivity.Nexts.ContainsKey(assoc.Name))
{
return(false);
}
// 获取到导航器
var navigator = this.FromActivity.Engine.ResolveNavigator(this.FromActivity, assoc, processConext);
// 用导航器得到导航结果
NavigateResults navResults = navigator.Navigate(this.FromActivity, assoc, this.ExecuteResults, processConext);
//检查没通过，不会走该线路
if (navResults == null)
{
return(false);
}
var nextActivity = this.ResolveNextActivity(assoc, navResults, processConext);
this.CreateNavigation(nextActivity, assoc, navResults, processConext);
return(true);
}
public virtual Task <object> ExecuteAsync(IActivity activity, object inputs, ProcessContext processContext)
{
throw new NotImplementedException();
}
public virtual async Task <IUser> PredicateAsync(IActivity activity, object inputs, ProcessContext processContext)
{
return(activity.Owner ?? User.Anyone);
}
public INavigator ResolveNavigator(Activity activity, IAssociation assoc, ProcessContext processContext)
{
return(activity.Action);
}
public virtual Task <bool> PostdicateAsync(IActivity activity, ProcessContext processContext)
{
throw new NotImplementedException();
}
public virtual IUser Predicate(IActivity activity, object inputs, ProcessContext processContext)
{
return(activity.Owner ?? User.Anyone);
}
public virtual NavigateResults Navigate(IActivity activity, IAssociation assoc, object executeResults, ProcessContext processContext)
{
//未指定Key,看是否已经完成
if (string.IsNullOrEmpty(assoc.Key))
{
// 未完成，不能进行下一步
if (activity.Status != ActivityStates.Done)
{
return(null);
}
}
// 看是状态是否满足
else
{
if (activity.State <string>(assoc.Key) != assoc.Value)
{
return(null);
}
}
var nextDealerIdPath = assoc.NextDealerIdPath;
if (string.IsNullOrEmpty(nextDealerIdPath))
{
nextDealerIdPath = processContext.Engine.DefaultNextDealerIdPath;
}
var nextDealerNamePath = assoc.NextDealerNamePath;
if (string.IsNullOrEmpty(nextDealerNamePath))
{
nextDealerNamePath = processContext.Engine.DefaultNextDealerNamePath;
}
var nextDealerId = activity.State <string>(nextDealerIdPath);
if (string.IsNullOrEmpty(nextDealerId))
{
throw new Exception(string.Format("活动对象{0}在执行导航{1}时，已经通过，但未能找到下一处理人", activity.Id, assoc.Name));
}
var nextDealer = new User(nextDealerId, activity.State <string>(nextDealerNamePath));
object nextInputs;
if (assoc.NextInputsMaps != null)
{
var jObj = new JObject();
foreach (var pair in assoc.NextInputsMaps)
{
var value = activity.State(pair.Key);
JSON.SetPathValue(jObj, pair.Value, value);
}
nextInputs = jObj;
}
else
{
nextInputs = executeResults;
}
return(new NavigateResults(nextDealer, nextInputs));
}
public Activity(Activity parent, INode node, ProcessContext context = null)
{
}
/// <summary>
/// 根据id创建活动对象
/// </summary>
/// <param name="id"></param>
/// <param name="engine"></param>
public Activity(Engine engine, Guid id, ProcessContext context = null)
{
this.Engine = engine;
this.FlowRepository = engine.ResolveFlowRepository(context);
this.id = id;
}
NavigationEntity CreateNavigation(Activity toActivity, IAssociation assoc, NavigateResults navResults, ProcessContext processContext)
{
var entity = new NavigationEntity()
{
FromActivityId = this.FromActivity.Id,
ToActivityId = toActivity.Id,
ParentActivityId = this.FromActivity.ParentId.Value,
FlowId = toActivity.FlowId,
NavigatorType = assoc.InstanceType,
NextDealerId = navResults.NextDealer?.Id,
NextDealerName = navResults.NextDealer?.Name,
NextInputs = JSON.Stringify(navResults.NextInputs),
CreateTime = DateTime.Now,
CreatorId = processContext.Dealer.Id,
CreatorName = processContext.Dealer.Name
};
this.NavigationEntities.Add(entity);
this.FromActivity.AddNexts(assoc.Name, toActivity.Id);
return(entity);
}
public virtual Task <NavigateResults> NavigateAsync(IActivity activity, IAssociation assoc, object executeResults, ProcessContext processContext)
{
throw new NotImplementedException();
}
public Activity(Engine engine, Activity parent, INode node, string version, object inputs, IUser creator, IUser owner, ProcessContext processContext)
{
this.Engine = engine;
this.graph = node;
this.parent = parent;
#region init entity
var entity = new ActivityEntity()
{
Id = Guid.NewGuid(),
NodeName = node.Name,
NodePath = parent == null ? node.Name : parent.NodePath + "/" + node.Name,
Status = ActivityStates.Creating,
Version = version ?? parent?.Version,
Domain = engine.Name,
ActionType = node.InstanceType ?? engine.DefaultActionType,
Graph = JSON.Stringify(node),
HasChildren = node.Nodes != null && node.Nodes.Count > 0,
Inputs = JSON.Stringify(inputs),
CreateTime = DateTime.Now,
CreatorId = creator.Id,
CreatorName = creator.Name
};
this.entity = entity;
this.Owner = owner;
#endregion
if (parent != null)
{
this.FlowRepository = parent.FlowRepository;
this.AddChild(this);
}
else
{
this.FlowRepository = engine.ResolveFlowRepository(processContext);
}
#region init states
var states = new JObject();
var metas = (node as Node).Metas;
if (metas != null)
{
foreach (var pair in metas)
{
states.Add(pair.Key, pair.Value.DeepClone());
}
}
if (parent != null && node.Imports != null)
{
var pStates = parent.States as JObject;
foreach (var pair in node.Imports)
{
var value = JSON.GetPathValue(pStates, pair.Value);
JSON.SetPathValue(states, pair.Key, value);
}
}
this.entity.States = states.ToString();
this.states = states;
#endregion
}
public virtual IFlowRepository ResolveFlowRepository(ProcessContext processContext)
{
return(this.FlowRepository);
}
