public void Construct2()
{
TransitionDefinition definition = new TransitionDefinition(DxtSubObjects.FadeTransition);
Assert.AreEqual(DxtSubObjects.FadeTransition, definition.TransitionId);
Assert.AreEqual(0, definition.Parameters.Count);
}
public void SetValues()
{
var definition = new TransitionDefinition();
definition.TransitionId = StandardTransitions.FadeTransition;
Assert.AreEqual(StandardTransitions.FadeTransition, definition.TransitionId);
}
public void AddTransitionsToTrack()
{
using (ITimeline timeline = new DefaultTimeline())
{
IGroup group = timeline.AddVideoGroup(24, 320, 200);
ITrack track = group.AddTrack();
TransitionDefinition definition = StandardTransitions.CreateFade();
ITransition transition = track.AddTransition("test", 1, 3, definition, false);
Assert.AreEqual(1, track.Transitions.Count);
Assert.AreSame(transition, track.Transitions[0]);
Assert.AreEqual("test", transition.Name);
Assert.AreSame(definition, transition.TransitionDefinition);
PrepareToExecute(timeline,
@"<timeline framerate=""30.0000000"">
<group type=""video"" bitdepth=""24"" height=""200"" framerate=""30.0000000"" previewmode=""0"">
<track>
<transition start=""1"" stop=""4"" clsid=""{16B280C5-EE70-11D1-9066-00C04FD9189D}"" username=""test"" />
</track>
</group>
</timeline>");
}
}
public void GetTransitionsReturnsOneAddedTransition()
{
var testee = new TransitionDictionary <States, Events>(A.Fake <StateDefinition <States, Events> >());
var fakeAction = A.Fake <IActionHolder>();
var fakeGuard = A.Fake <IGuardHolder>();
var fakeSource = A.Fake <StateDefinition <States, Events> >();
var fakeTarget = A.Fake <StateDefinition <States, Events> >();
var transition = new TransitionDefinition <States, Events>();
testee.Add(Events.A, transition);
transition.ActionsModifiable.Add(fakeAction);
transition.Guard = fakeGuard;
transition.Source = fakeSource;
transition.Target = fakeTarget;
var transitionInfos = testee.GetTransitions().ToList();
transitionInfos.Should().HaveCount(1);
var transitionInfo = transitionInfos.Single();
transitionInfo.EventId.Should().Be(Events.A);
transitionInfo.Actions.Should().ContainSingle(x => x == fakeAction);
transitionInfo.Guard.Should().BeSameAs(fakeGuard);
transitionInfo.Source.Should().BeSameAs(fakeSource);
transitionInfo.Target.Should().BeSameAs(fakeTarget);
}
public void Construct1()
{
var definition = new TransitionDefinition();
Assert.AreEqual(Guid.Empty, definition.TransitionId);
Assert.AreEqual(0, definition.Parameters.Count);
}
public void Construct2()
{
var definition = new TransitionDefinition(StandardTransitions.FadeTransition);
Assert.AreEqual(StandardTransitions.FadeTransition, definition.TransitionId);
Assert.AreEqual(0, definition.Parameters.Count);
}
public void UpdatePersistenceState(ProcessInstance processInstance, TransitionDefinition transition)
{
var paramIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterIdentityId.Name);
var paramImpIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterImpersonatedIdentityId.Name);
var identityId = paramIdentityId == null ? string.Empty : (string)paramIdentityId.Value;
var impIdentityId = paramImpIdentityId == null ? identityId : (string)paramImpIdentityId.Value;
using (MySqlConnection connection = new MySqlConnection(ConnectionString))
{
WorkflowProcessInstance inst = WorkflowProcessInstance.SelectByKey(connection, processInstance.ProcessId);
if (inst != null)
{
if (!string.IsNullOrEmpty(transition.To.State))
inst.StateName = transition.To.State;
inst.ActivityName = transition.To.Name;
inst.PreviousActivity = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
inst.PreviousState = transition.From.State;
if (transition.Classifier == TransitionClassifier.Direct)
{
inst.PreviousActivityForDirect = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
inst.PreviousStateForDirect = transition.From.State;
}
else if (transition.Classifier == TransitionClassifier.Reverse)
{
inst.PreviousActivityForReverse = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
inst.PreviousStateForReverse = transition.From.State;
}
inst.Update(connection);
}
var history = new WorkflowProcessTransitionHistory()
{
ActorIdentityId = impIdentityId,
ExecutorIdentityId = identityId,
Id = Guid.NewGuid(),
IsFinalised = false,
ProcessId = processInstance.ProcessId,
FromActivityName = transition.From.Name,
FromStateName = transition.From.State,
ToActivityName = transition.To.Name,
ToStateName = transition.To.State,
TransitionClassifier =
transition.Classifier.ToString(),
TransitionTime = _runtime.RuntimeDateTimeNow,
TriggerName = string.IsNullOrEmpty(processInstance.ExecutedTimer) ? processInstance.CurrentCommand : processInstance.ExecutedTimer
};
history.Insert(connection);
}
}
private static Transition Convert(this TransitionDefinition definition, ParsedStatenode source, Func <OneOf <StatenodeId, string>, ParsedStatenode> getStatenode, ServiceDefinition serviceDefinition, int serviceIndex) =>
definition.Match(
forbidden => new Transition(forbidden.Event, source, Enumerable.Empty <ParsedStatenode>(), Actionblock.Empty(), Option.None <Guard>(), true),
unguarded => new Transition(unguarded.Event.Convert(source, serviceDefinition, serviceIndex), source, unguarded.Targets.GetTargetStatenodes(source.Id, getStatenode), unguarded.Actions.Convert(), Option.None <Guard>(), false),
unguarded => new Transition(unguarded.Event.Convert(source, serviceDefinition, serviceIndex), source, unguarded.Targets.GetTargetStatenodes(source.Id, getStatenode), unguarded.Actions.Convert(), Option.None <Guard>(), false),
unguarded => new Transition(unguarded.Event.Convert(source, serviceDefinition, serviceIndex), source, unguarded.Targets.GetTargetStatenodes(source.Id, getStatenode), unguarded.Actions.Convert(), Option.None <Guard>(), false),
guarded => new Transition(guarded.Event.Convert(source, serviceDefinition, serviceIndex), source, guarded.Targets.GetTargetStatenodes(source.Id, getStatenode), guarded.Actions.Convert(), (guarded.Guard as Guard).ToOption(), false),
guarded => new Transition(guarded.Event.Convert(source, serviceDefinition, serviceIndex), source, guarded.Targets.GetTargetStatenodes(source.Id, getStatenode), guarded.Actions.Convert(), guarded.Guard.AsBase().ToOption(), false),
guarded => new Transition(guarded.Event.Convert(source, serviceDefinition, serviceIndex), source, guarded.Targets.GetTargetStatenodes(source.Id, getStatenode), guarded.Actions.Convert(), guarded.Guard.AsBase().ToOption(), false));
public void SetValues()
{
TransitionDefinition definition = new TransitionDefinition();
List <Parameter> newParams = new List <Parameter>();
definition.Parameters = newParams;
Assert.AreSame(newParams, definition.Parameters);
definition.TransitionId = DxtSubObjects.FadeTransition;
Assert.AreEqual(DxtSubObjects.FadeTransition, definition.TransitionId);
}
public static TransitionDefinition CreateEaseOutEffect()
{
var definition = new TransitionDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.5));
definition.Parameters.Add(new Parameter("ScaleA", 0.5));
definition.Parameters.Add(new Parameter("ExponentialProgressDuration", 0.01));
return(definition);
}
public static TransitionDefinition FlipOut()
{
var definition = new TransitionDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.00));
definition.Parameters.Add(new Parameter("ScaleA", 1.0));
definition.Parameters.Add(new Parameter("RotateA", "out"));
definition.Parameters.Add(new Parameter("ExponentialProgressScale", 1));
return(definition);
}
public static TransitionDefinition RotateAndZoomOut()
{
var definition = new TransitionDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.00));
definition.Parameters.Add(new Parameter("ScaleA", "smaller"));
definition.Parameters.Add(new Parameter("RotateA", "right"));
definition.Parameters.Add(new Parameter("ExponentialProgressDuration", 1));
return(definition);
}
public static TransitionDefinition PanRight()
{
var definition = new TransitionDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.00));
definition.Parameters.Add(new Parameter("ScaleA", 1.00));
definition.Parameters.Add(new Parameter("MoveA", "right"));
definition.Parameters.Add(new Parameter("MoveSpeedA", 0.4));
return(definition);
}
public static TransitionDefinition PinWheelZoomOut()
{
var definition = new TransitionDefinition(WMTFX);
definition.Parameters.Add(new Parameter("InternalName", "Simple3D"));
definition.Parameters.Add(new Parameter("InitialScaleA", 1.5));
definition.Parameters.Add(new Parameter("ScaleA", 0.5));
definition.Parameters.Add(new Parameter("RotateA", "right"));
definition.Parameters.Add(new Parameter("ExponentialProgressScale", 0.5));
return(definition);
}
public void AddTransitionSetsSwappedInputsProperly()
{
using (ITimeline timeline = new DefaultTimeline())
{
TransitionDefinition def = StandardTransitions.CreateIris();
IGroup group = timeline.AddAudioGroup();
ITransition groupTransition1 = group.AddTransition(0, 5, def, false);
Assert.IsFalse(groupTransition1.SwapInputs);
ITransition groupTransition2 = group.AddTransition(5, 5, def, true);
Assert.IsTrue(groupTransition2.SwapInputs);
}
}
public void AddingTransitionsChecksForOverlap()
{
using (ITimeline timeline = new DefaultTimeline())
{
TransitionDefinition def = StandardTransitions.CreateIris();
IGroup group = timeline.AddAudioGroup();
ITransition groupTransition1 = group.AddTransition(0, 5, def, false);
Assert.IsFalse(groupTransition1.SwapInputs);
ITransition groupTransition2 = group.AddTransition(1, 7, def, true);
Assert.IsTrue(groupTransition2.SwapInputs);
}
}
public static TransitionDefinition <TEntity, TState, TStateEnum> FindTransition <TEntity, TState, TStateEnum>(
this List <TransitionDefinition <TEntity, TState, TStateEnum> > transitions,
TEntity entity,
Expression <Func <TState, TState> > transition
)
where TEntity : IStatedEntity <TState>, new()
where TState : IState <TState, TStateEnum>
{
TransitionDefinition <TEntity, TState, TStateEnum> requestedTransition = default;
MethodCallExpression needleMember;
try
{
var needleType = entity.State.GetType();
needleMember = transition?.Body as MethodCallExpression;
if (needleMember == null)
{
throw new TransitionFailedException($"Transition '{transition?.Body.ToString() ?? "[null]"}' failed on {typeof(TEntity)}");
}
transitions?.ForEach(t =>
{
var transitionMember = t.StateTransitionOnSuccess.Body as MethodCallExpression;
if (needleType == t.From.GetType() &&
needleMember.Method.Name == (transitionMember?.Method.Name ?? "[undefined member]") &&
needleMember.Method.ReflectedType == transitionMember?.Method.ReflectedType)
{
requestedTransition = t;
}
});
}
catch (Exception ex)
{
throw new TransitionFailedException(ex);
}
if (requestedTransition == default)
{
throw new UndefinedTransitionException(needleMember.Method.Name, entity.State.GetType().Name);
}
return(requestedTransition);
}
public void AddTransitionSetsAppropriateContainerAndGroup()
{
using (ITimeline timeline = new DefaultTimeline())
{
TransitionDefinition def = StandardTransitions.CreateIris();
IGroup group = timeline.AddAudioGroup();
ITransition groupTransition = group.AddTransition(0, 0, def);
Assert.AreSame(group, groupTransition.Container);
Assert.AreSame(group, groupTransition.Group);
ITrack track = group.AddTrack();
ITransition trackTransition = track.AddTransition(0, 0, def);
Assert.AreSame(track, trackTransition.Container);
Assert.AreSame(group, trackTransition.Group);
IComposition composition = group.AddComposition();
ITransition compositionTransition = composition.AddTransition(0, 0, def);
Assert.AreSame(composition, compositionTransition.Container);
Assert.AreSame(group, compositionTransition.Group);
}
}
public static TransitionDefinition CreateWMTFX_Move_SmallerImage(string direction)
{
var transitionDefinition = new TransitionDefinition(new Guid("B4DC8DD9-2CC1-4081-9B2B-20D7030234EF"));
var param1 = new Parameter("InternalName", "Simple3D");
transitionDefinition.Parameters.Add(param1);
param1 = new Parameter("InitialScaleA", "0.70");
transitionDefinition.Parameters.Add(param1);
param1 = new Parameter("ScaleA", "0.70");
transitionDefinition.Parameters.Add(param1);
param1 = new Parameter("MoveA", direction);
transitionDefinition.Parameters.Add(param1);
param1 = new Parameter("MoveSpeedA", "0.50");
transitionDefinition.Parameters.Add(param1);
return(transitionDefinition);
}
/// <summary>
/// 序列化TransitionDefinition的内容到WorkflowProcessTransitionHistory
/// </summary>
/// <param name="processInstance"></param>
/// <param name="transition"></param>
public void UpdatePersistenceState(ProcessInstance processInstance, TransitionDefinition transition)
{
using (WorkflowPersistenceModelDataContext workflowPersistenceModelDataContext = base.CreateContext())
{
WorkflowProcessTransitionHistory entity = new WorkflowProcessTransitionHistory
{
ActorIdentityId = Guid.NewGuid(),
ExecutorIdentityId = Guid.NewGuid(),
Id = Guid.NewGuid(),
IsFinalised = false,
ProcessId = processInstance.ProcessId,
FromActivityName = transition.From.Name,
FromStateName = transition.From.State,
ToActivityName = transition.To.Name,
ToStateName = transition.To.State,
TransitionClassifier = transition.Classifier.ToString(),
TransitionTime = DateTime.Now
};
workflowPersistenceModelDataContext.WorkflowProcessTransitionHistories.InsertOnSubmit(entity);
workflowPersistenceModelDataContext.SubmitChanges();
}
}
public static WorkflowCommand Create(Guid processId, TransitionDefinition transitionDefinition)
{
if (transitionDefinition.Trigger.Type != TriggerType.Command || transitionDefinition.Trigger.Command == null)
{
throw new InvalidOperationException();
}
var parametrs = new List <CommandParameter>(transitionDefinition.Trigger.Command.InputParameters.Count);
parametrs.AddRange(
transitionDefinition.Trigger.Command.InputParameters.Select(
p => new CommandParameter {
Name = p.Key, Type = p.Value.Type, Value = null
}));
return(new WorkflowCommand
{
CommandName = transitionDefinition.Trigger.Command.Name,
Parameters = parametrs,
ProcessId = processId,
ValidForActivityName = transitionDefinition.From.Name
});
}
private void SetStateWithoutExecution(ActivityDefinition activityToSet, ProcessInstance processInstance)
{
SetProcessNewStatus(processInstance, ProcessStatus.Running);
IEnumerable <TransitionDefinition> transitions;
try
{
PersistenceProvider.FillSystemProcessParameters(processInstance);
var from = processInstance.CurrentActivity;
var to = activityToSet;
PersistenceProvider.UpdatePersistenceState(processInstance, TransitionDefinition.Create(from, to));
}
catch (Exception ex)
{
Logger.Log.Error(string.Format("Workflow Id={0}", processInstance.ProcessId), ex);
throw;
}
finally
{
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
}
}
public void UpdatePersistenceState(ProcessInstance processInstance, TransitionDefinition transition)
{
var paramIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterIdentityId.Name);
var paramImpIdentityId =
processInstance.GetParameter(DefaultDefinitions.ParameterImpersonatedIdentityId.Name);
var identityId = paramIdentityId == null ? string.Empty : (string)paramIdentityId.Value;
var impIdentityId = paramImpIdentityId == null ? identityId : (string)paramImpIdentityId.Value;
var cache =
Store.GetOrCreateCache <Guid, WorkflowProcessInstance>(IgniteConstants.WorkflowProcessInstanceCacheName);
var inst = cache.Get(processInstance.ProcessId);
if (inst != null)
{
if (!string.IsNullOrEmpty(transition.To.State))
{
inst.StateName = transition.To.State;
}
inst.ActivityName = transition.To.Name;
inst.PreviousActivity = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousState = transition.From.State;
}
if (transition.Classifier == TransitionClassifier.Direct)
{
inst.PreviousActivityForDirect = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForDirect = transition.From.State;
}
}
else if (transition.Classifier == TransitionClassifier.Reverse)
{
inst.PreviousActivityForReverse = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForReverse = transition.From.State;
}
}
inst.ParentProcessId = processInstance.ParentProcessId;
inst.RootProcessId = processInstance.RootProcessId;
cache.Put(inst.Id, inst);
}
var history = new WorkflowProcessTransitionHistory
{
ActorIdentityId = impIdentityId,
ExecutorIdentityId = identityId,
Id = Guid.NewGuid(),
IsFinalised = false,
ProcessId = processInstance.ProcessId,
FromActivityName = transition.From.Name,
FromStateName = transition.From.State,
ToActivityName = transition.To.Name,
ToStateName = transition.To.State,
TransitionClassifier =
transition.Classifier.ToString(),
TransitionTime = _runtime.RuntimeDateTimeNow,
TriggerName =
string.IsNullOrEmpty(processInstance.ExecutedTimer)
? processInstance.CurrentCommand
: processInstance.ExecutedTimer
};
var cacheTransition =
Store.GetOrCreateCache <Guid, WorkflowProcessTransitionHistory>(
IgniteConstants.WorkflowProcessTransitionHistoryCacheName);
cacheTransition.Put(history.Id, history);
}
public void UpdatePersistenceState(ProcessInstance processInstance, TransitionDefinition transition)
{
var paramIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterIdentityId.Name);
var paramImpIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterImpersonatedIdentityId.Name);
var identityId = paramIdentityId == null ? string.Empty : (string)paramIdentityId.Value;
var impIdentityId = paramImpIdentityId == null ? identityId : (string)paramImpIdentityId.Value;
var dbcoll = Store.GetCollection <WorkflowProcessInstance>(MongoDBConstants.WorkflowProcessInstanceCollectionName);
var inst = dbcoll.Find(x => x.Id == processInstance.ProcessId).FirstOrDefault();
if (inst != null)
{
if (!string.IsNullOrEmpty(transition.To.State))
{
inst.StateName = transition.To.State;
}
inst.ActivityName = transition.To.Name;
inst.PreviousActivity = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousState = transition.From.State;
}
if (transition.Classifier == TransitionClassifier.Direct)
{
inst.PreviousActivityForDirect = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForDirect = transition.From.State;
}
}
else if (transition.Classifier == TransitionClassifier.Reverse)
{
inst.PreviousActivityForReverse = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForReverse = transition.From.State;
}
}
inst.ParentProcessId = processInstance.ParentProcessId;
inst.RootProcessId = processInstance.RootProcessId;
Save(dbcoll, inst, doc => doc.Id == inst.Id);
}
var history = new WorkflowProcessTransitionHistory
{
ActorIdentityId = impIdentityId,
ExecutorIdentityId = identityId,
Id = Guid.NewGuid(),
IsFinalised = transition.To.IsFinal,
ProcessId = processInstance.ProcessId,
FromActivityName = transition.From.Name,
FromStateName = transition.From.State,
ToActivityName = transition.To.Name,
ToStateName = transition.To.State,
TransitionClassifier =
transition.Classifier.ToString(),
TransitionTime = _runtime.RuntimeDateTimeNow,
TriggerName = string.IsNullOrEmpty(processInstance.ExecutedTimer) ? processInstance.CurrentCommand : processInstance.ExecutedTimer
};
var dbcollTransition = Store.GetCollection <WorkflowProcessTransitionHistory>(MongoDBConstants.WorkflowProcessTransitionHistoryCollectionName);
dbcollTransition.InsertOne(history);
}
private bool ValidateActor(Guid processId, Guid identityId, TransitionDefinition transition)
{
if (transition.Restrictions.Count() < 1)
{
return(true);
}
foreach (var restrictionDefinition in transition.Restrictions)
{
var actorDefinitionIsIdentity = restrictionDefinition.Actor as ActorDefinitionIsIdentity;
if (actorDefinitionIsIdentity != null)
{
if ((actorDefinitionIsIdentity.IdentityId != identityId &&
restrictionDefinition.Type == RestrictionType.Allow) ||
(actorDefinitionIsIdentity.IdentityId == identityId &&
restrictionDefinition.Type == RestrictionType.Restrict))
{
return(false);
}
continue;
}
var actorDefinitionIsInRole = restrictionDefinition.Actor as ActorDefinitionIsInRole;
if (actorDefinitionIsInRole != null)
{
if ((restrictionDefinition.Type == RestrictionType.Allow &&
!RoleProvider.IsInRole(identityId, actorDefinitionIsInRole.RoleId)) ||
(restrictionDefinition.Type == RestrictionType.Restrict &&
RoleProvider.IsInRole(identityId, actorDefinitionIsInRole.RoleId)))
{
return(false);
}
continue;
}
var actorDefinitionExecute = restrictionDefinition.Actor as ActorDefinitionExecuteRule;
if (actorDefinitionExecute != null && actorDefinitionExecute.Parameters.Count < 1)
{
if ((restrictionDefinition.Type == RestrictionType.Allow &&
!RuleProvider.CheckRule(processId, identityId, actorDefinitionExecute.RuleName)) ||
(restrictionDefinition.Type == RestrictionType.Restrict &&
RuleProvider.CheckRule(processId, identityId, actorDefinitionExecute.RuleName)))
{
return(false);
}
continue;
}
if (actorDefinitionExecute != null && actorDefinitionExecute.Parameters.Count > 0)
{
if ((restrictionDefinition.Type == RestrictionType.Allow &&
!RuleProvider.CheckRule(processId, identityId, actorDefinitionExecute.RuleName,
actorDefinitionExecute.Parameters)) ||
(restrictionDefinition.Type == RestrictionType.Restrict &&
RuleProvider.CheckRule(processId, identityId, actorDefinitionExecute.RuleName,
actorDefinitionExecute.Parameters)))
{
return(false);
}
continue;
}
}
return(true);
}
private IEnumerable <Guid> GetActors(Guid processId, TransitionDefinition transition)
{
if (transition.Restrictions.Count() < 1)
{
return(new List <Guid>());
}
List <Guid> result = null;
//TODO Здесь возможно обрабатывать случай - запрещено только одному
foreach (var restrictionDefinition in transition.Restrictions.Where(r => r.Type == RestrictionType.Allow))
{
var allowed = new List <Guid>();
var actorDefinitionIsIdentity = restrictionDefinition.Actor as ActorDefinitionIsIdentity;
if (actorDefinitionIsIdentity != null)
{
allowed.Add(actorDefinitionIsIdentity.IdentityId);
}
var actorDefinitionIsInRole = restrictionDefinition.Actor as ActorDefinitionIsInRole;
if (actorDefinitionIsInRole != null)
{
allowed.AddRange(RoleProvider.GetAllInRole(actorDefinitionIsInRole.RoleId));
}
var actorDefinitionExecute = restrictionDefinition.Actor as ActorDefinitionExecuteRule;
if (actorDefinitionExecute != null && actorDefinitionExecute.Parameters.Count < 1)
{
allowed.AddRange(RuleProvider.GetIdentitiesForRule(processId, actorDefinitionExecute.RuleName));
}
else if (actorDefinitionExecute != null && actorDefinitionExecute.Parameters.Count > 0)
{
allowed.AddRange(RuleProvider.GetIdentitiesForRule(processId, actorDefinitionExecute.RuleName, actorDefinitionExecute.Parameters));
}
if (result == null || result.Count() < 1)
{
result = allowed;
}
else
{
result = result.Intersect(allowed).ToList();
}
}
if (result == null)
{
return(new List <Guid>());
}
if (result.Count() < 1)
{
return(result);
}
foreach (var restrictionDefinition in transition.Restrictions.Where(r => r.Type == RestrictionType.Restrict))
{
var restricted = new List <Guid>();
var actorDefinitionIsIdentity = restrictionDefinition.Actor as ActorDefinitionIsIdentity;
if (actorDefinitionIsIdentity != null)
{
restricted.Add(actorDefinitionIsIdentity.IdentityId);
}
var actorDefinitionIsInRole = restrictionDefinition.Actor as ActorDefinitionIsInRole;
if (actorDefinitionIsInRole != null)
{
restricted.AddRange(RoleProvider.GetAllInRole(actorDefinitionIsInRole.RoleId));
}
var actorDefinitionExecute = restrictionDefinition.Actor as ActorDefinitionExecuteRule;
if (actorDefinitionExecute != null && actorDefinitionExecute.Parameters.Count < 1)
{
restricted.AddRange(RuleProvider.GetIdentitiesForRule(processId, actorDefinitionExecute.RuleName));
}
else if (actorDefinitionExecute != null && actorDefinitionExecute.Parameters.Count > 0)
{
restricted.AddRange(RuleProvider.GetIdentitiesForRule(processId, actorDefinitionExecute.RuleName, actorDefinitionExecute.Parameters));
}
result.RemoveAll(p => restricted.Contains(p));
if (result.Count() < 1)
{
return(result);
}
}
return(result);
}
//通过注入的规则(IWorkflowBus)，方法执行完成后调用本方法。
internal void BusExecutionComplete(object sender, ExecutionResponseEventArgs e)
{
var executionResponseParameters = e.Parameters;
var processInstance = Builder.GetProcessInstance(executionResponseParameters.ProcessId);
PersistenceProvider.FillSystemProcessParameters(processInstance);
//TODO Сделать метод филл CurrentActivity
if (executionResponseParameters.IsEmplty)
{
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
//var timerTransitions =
// processInstance.ProcessScheme.GetTimerTransitionForActivity(processInstance.CurrentActivity).ToList();
//timerTransitions.ForEach(p=>_runtimeTimer.UpdateTimer(processInstance.ProcessId,p.Trigger.Timer));
return;
}
if (executionResponseParameters.IsError)
{
var executionErrorParameters = executionResponseParameters as ExecutionResponseParametersError;
Logger.Log.Error(string.Format("Error Execution Complete Workflow Id={0}", processInstance.ProcessId), executionErrorParameters.Exception);
if (string.IsNullOrEmpty(executionErrorParameters.ExecutedTransitionName))
{
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
throw executionErrorParameters.Exception;
}
var transition = processInstance.ProcessScheme.FindTransition(executionErrorParameters.ExecutedTransitionName);
var onErrorDefinition = transition.OnErrors.Where(
oe => executionErrorParameters.Exception.GetType().Equals(oe.ExceptionType)).
OrderBy(oe => oe.Priority).FirstOrDefault() ??
transition.OnErrors.Where(
oe => oe.ExceptionType.IsAssignableFrom(executionErrorParameters.Exception.GetType())).
OrderBy(oe => oe.Priority).FirstOrDefault();
if (onErrorDefinition == null)
{
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
throw executionErrorParameters.Exception;
}
if (onErrorDefinition.ActionType == OnErrorActionType.SetActivity)
{
var from = processInstance.CurrentActivity;
var to = processInstance.ProcessScheme.FindActivity((onErrorDefinition as SetActivityOnErrorDefinition).NameRef);
PersistenceProvider.UpdatePersistenceState(processInstance, TransitionDefinition.Create(from, to));
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
}
throw executionErrorParameters.Exception;
//return;
}
try
{
ActivityDefinition newCurrentActivity;
if (string.IsNullOrEmpty(executionResponseParameters.ExecutedTransitionName))
{
if (executionResponseParameters.ExecutedActivityName == processInstance.ProcessScheme.InitialActivity.Name)
{
newCurrentActivity = processInstance.ProcessScheme.InitialActivity;
}
else
{
var from = processInstance.CurrentActivity;
var to = processInstance.ProcessScheme.FindActivity(executionResponseParameters.ExecutedActivityName);
newCurrentActivity = to;
PersistenceProvider.UpdatePersistenceState(processInstance, TransitionDefinition.Create(from, to));
}
}
else
{
var executedTransition =
processInstance.ProcessScheme.FindTransition(executionResponseParameters.ExecutedTransitionName);
newCurrentActivity = executedTransition.To;
PersistenceProvider.UpdatePersistenceState(processInstance, executedTransition);
}
FillParameters(processInstance, (executionResponseParameters as ExecutionResponseParametersComplete));
PersistenceProvider.SavePersistenceParameters(processInstance);
var autoTransitions =
processInstance.ProcessScheme.GetAutoTransitionForActivity(newCurrentActivity).ToList();
if (autoTransitions.Count() < 1)
{
SetProcessNewStatus(processInstance,
newCurrentActivity.IsFinal ? ProcessStatus.Finalized : ProcessStatus.Idled);
//var timerTransitions =
//processInstance.ProcessScheme.GetTimerTransitionForActivity(newCurrentActivity).ToList();
//timerTransitions.ForEach(p => _runtimeTimer.SetTimer(processInstance.ProcessId, p.Trigger.Timer));
return;
}
PersistenceProvider.FillProcessParameters(processInstance);
var newExecutionParameters = new List <ExecutionRequestParameters>();
newExecutionParameters.AddRange(
autoTransitions.Select(
at =>
ExecutionRequestParameters.Create(processInstance.ProcessId, processInstance.ProcessParameters,
at)));
Bus.QueueExecution(newExecutionParameters);
}
catch (ActivityNotFoundException)
{
SetProcessNewStatus(processInstance, ProcessStatus.Terminated);
}
//TODO Обработка ошибок
catch (Exception ex)
{
Logger.Log.Error(string.Format("Error Execution Complete Workflow Id={0}", processInstance.ProcessId), ex);
SetProcessNewStatus(processInstance, ProcessStatus.Idled);
}
}
public void SetValues()
{
var definition = new TransitionDefinition();
definition.TransitionId = StandardTransitions.FadeTransition;
Assert.AreEqual(StandardTransitions.FadeTransition, definition.TransitionId);
}
public void Construct2()
{
var definition = new TransitionDefinition(StandardTransitions.FadeTransition);
Assert.AreEqual(StandardTransitions.FadeTransition, definition.TransitionId);
Assert.AreEqual(0, definition.Parameters.Count);
}
public void UpdatePersistenceState(ProcessInstance processInstance, TransitionDefinition transition)
{
var paramIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterIdentityId.Name);
var paramImpIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterImpersonatedIdentityId.Name);
string identityId = paramIdentityId == null ? string.Empty : (string)paramIdentityId.Value;
string impIdentityId = paramImpIdentityId == null ? identityId : (string)paramImpIdentityId.Value;
using (var session = Store.OpenSession())
{
WorkflowProcessInstance inst = session.Load <WorkflowProcessInstance>(processInstance.ProcessId);
if (inst != null)
{
if (!string.IsNullOrEmpty(transition.To.State))
{
inst.StateName = transition.To.State;
}
inst.ActivityName = transition.To.Name;
inst.PreviousActivity = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousState = transition.From.State;
}
if (transition.Classifier == TransitionClassifier.Direct)
{
inst.PreviousActivityForDirect = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForDirect = transition.From.State;
}
}
else if (transition.Classifier == TransitionClassifier.Reverse)
{
inst.PreviousActivityForReverse = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForReverse = transition.From.State;
}
}
}
var history = new WorkflowProcessTransitionHistory()
{
ActorIdentityId = impIdentityId,
ExecutorIdentityId = identityId,
Id = Guid.NewGuid(),
IsFinalised = false,
ProcessId = processInstance.ProcessId,
FromActivityName = transition.From.Name,
FromStateName = transition.From.State,
ToActivityName = transition.To.Name,
ToStateName = transition.To.State,
TransitionClassifier =
transition.Classifier.ToString(),
TransitionTime = _runtime.RuntimeDateTimeNow,
TriggerName = string.IsNullOrEmpty(processInstance.ExecutedTimer) ? processInstance.CurrentCommand : processInstance.ExecutedTimer
};
session.Store(history);
session.SaveChanges();
}
}
public override IEnumerable <TransitionDefinition> ParseTransitions(XElement schemeMedium, IEnumerable <ActorDefinition> actorDefinitions, IEnumerable <CommandDefinition> commandDefinitions, IEnumerable <ActionDefinition> actionDefinitions, IEnumerable <ActivityDefinition> activityDefinitions, IEnumerable <TimerDefinition> timerDefinitions)
{
if (schemeMedium == null)
{
throw new ArgumentNullException("schemeMedium");
}
if (commandDefinitions == null)
{
throw new ArgumentNullException("commandDefinitions");
}
if (actionDefinitions == null)
{
throw new ArgumentNullException("actionDefinitions");
}
if (activityDefinitions == null)
{
throw new ArgumentNullException("activityDefinitions");
}
var transitionElements = schemeMedium.SingleOrDefault("Transitions");
if (transitionElements == null)
{
throw new ArgumentNullException("");
}
var commandDefinitionsList = commandDefinitions.ToList();
var actionDefinitionsList = actionDefinitions.ToList();
var activityDefinitionsList = activityDefinitions.ToList();
var actorDefinitionsList = actorDefinitions.ToList();
var timerDefinitionsList = timerDefinitions.ToList();
var transitions = new List <TransitionDefinition>();
foreach (var transitionElement in transitionElements.Elements().ToList())
{
var fromActivity = activityDefinitionsList.Single(ad => ad.Name == GetFrom(transitionElement));
var toActivity = activityDefinitionsList.Single(ad => ad.Name == GetTo(transitionElement));
TriggerDefinition trigger = null;
var triggersElement = transitionElement.Element("Triggers");
if (triggersElement != null)
{
var triggerElement = triggersElement.Element("Trigger");
if (triggerElement != null)
{
trigger = TriggerDefinition.Create(GetType(triggerElement));
if (trigger.Type == TriggerType.Command)
{
(trigger as CommandTriggerDefinition).Command =
commandDefinitionsList.Single(cd => cd.Name == GetNameRef(triggerElement));
}
else if (trigger.Type == TriggerType.Timer)
{
(trigger as TimerTriggerDefinition).Timer =
timerDefinitionsList.Single(cd => cd.Name == GetNameRef(triggerElement));
}
}
}
ConditionDefinition condition = null;
var conditionsElement = transitionElement.Element("Conditions");
if (conditionsElement != null)
{
var conditionElement = conditionsElement.Element("Condition");
if (conditionElement != null)
{
condition = !string.IsNullOrEmpty(GetNameRefNullable(conditionElement))
? ConditionDefinition.Create(GetType(conditionElement), actionDefinitionsList.Single(ad => ad.Name == GetNameRef(conditionElement)), GetResultOnPreExecution(conditionElement))
: ConditionDefinition.Create(GetType(conditionElement), GetResultOnPreExecution(conditionElement));
}
}
var transition = TransitionDefinition.Create(GetName(transitionElement), GetClassifier(transitionElement), fromActivity,
toActivity, trigger, condition);
var restrictionsElement = transitionElement.Element("Restrictions");
if (restrictionsElement != null)
{
foreach (var element in restrictionsElement.Elements("Restriction"))
{
transition.AddRestriction(RestrictionDefinition.Create(GetType(element), actorDefinitionsList.Single(ad => ad.Name == GetNameRef(element))));
}
}
var onErrorsElement = transitionElement.Element("OnErrors");
if (onErrorsElement != null)
{
foreach (var element in onErrorsElement.Elements("OnError"))
{
//TODO Only One Type Of OnErrorHandler
transition.AddOnError(OnErrorDefinition.CreateSetActivityOnError(GetName(element), GetNameRef(element), GetPriority(element), GetTypeName(element) /*, GetIsExecuteImplementation(element),GetIsRethrow(element)*/));
}
}
transitions.Add(transition);
}
return(transitions);
}
/// <summary>
/// Updates system parameters of the process in the store
/// </summary>
/// <param name="processInstance">Instance of the process</param>
/// <param name="transition">Last executed transition</param>
public void UpdatePersistenceState(ProcessInstance processInstance, TransitionDefinition transition)
{
var db = _connector.GetDatabase();
var key = GetKeyForProcessInstance(processInstance.ProcessId);
var processInstanceValue = db.StringGet(key);
if (!processInstanceValue.HasValue)
{
throw new ProcessNotFoundException(processInstance.ProcessId);
}
var inst = JsonConvert.DeserializeObject <WorkflowProcessInstance>(processInstanceValue);
var paramIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterIdentityId.Name);
var paramImpIdentityId = processInstance.GetParameter(DefaultDefinitions.ParameterImpersonatedIdentityId.Name);
var identityId = paramIdentityId == null ? string.Empty : (string)paramIdentityId.Value;
var impIdentityId = paramImpIdentityId == null ? identityId : (string)paramImpIdentityId.Value;
if (!string.IsNullOrEmpty(transition.To.State))
{
inst.StateName = transition.To.State;
}
inst.ActivityName = transition.To.Name;
inst.PreviousActivity = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousState = transition.From.State;
}
if (transition.Classifier == TransitionClassifier.Direct)
{
inst.PreviousActivityForDirect = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForDirect = transition.From.State;
}
}
else if (transition.Classifier == TransitionClassifier.Reverse)
{
inst.PreviousActivityForReverse = transition.From.Name;
if (!string.IsNullOrEmpty(transition.From.State))
{
inst.PreviousStateForReverse = transition.From.State;
}
}
inst.ParentProcessId = processInstance.ParentProcessId;
inst.RootProcessId = processInstance.RootProcessId;
var history = new WorkflowProcessTransitionHistory()
{
ActorIdentityId = impIdentityId,
ExecutorIdentityId = identityId,
IsFinalised = false,
FromActivityName = transition.From.Name,
FromStateName = transition.From.State,
ToActivityName = transition.To.Name,
ToStateName = transition.To.State,
TransitionClassifier =
transition.Classifier.ToString(),
TransitionTime = _runtime.RuntimeDateTimeNow,
TriggerName = string.IsNullOrEmpty(processInstance.ExecutedTimer) ? processInstance.CurrentCommand : processInstance.ExecutedTimer
};
var batch = db.CreateBatch();
batch.StringSetAsync(key, JsonConvert.SerializeObject(inst));
batch.ListRightPushAsync(GetKeyForProcessHistory(processInstance.ProcessId), JsonConvert.SerializeObject(history));
batch.Execute();
}
public void Construct1()
{
var definition = new TransitionDefinition();
Assert.AreEqual(Guid.Empty, definition.TransitionId);
Assert.AreEqual(0, definition.Parameters.Count);
}
