internal override Action Clone(IDocumentEssential owner)
{
PDFDictionary dict = new PDFDictionary();
dict.AddItem("Type", new PDFName("Action"));
dict.AddItem("S", new PDFName("Trans"));
PDFDictionary trans = _dictionary["Trans"] as PDFDictionary;
if (trans != null)
{
dict.AddItem("Trans", TransitionBase.Copy(trans));
}
TransitionAction action = new TransitionAction(dict, owner);
IPDFObject next = _dictionary["Next"];
if (next != null)
{
for (int i = 0; i < Next.Count; ++i)
{
action.Next.Add(Next[i]);
}
}
return(action);
}
private List <string> GetTransitionsFromActivity(Activity activity, TransitionAction action)
{
List <string> activities = new List <string>();
switch (action)
{
case TransitionAction.Join:
case TransitionAction.None:
var transitionId = GetSingleTransitionFromActivity(activity.Id);
if (!string.IsNullOrEmpty(transitionId))
{
activities.Add(GetNextActivityFromTransition(transitionId));
}
break;
case TransitionAction.SplitParallel:
case TransitionAction.SplitExclusive:
foreach (var transition in activity.TransitionRestrictions.TransitionRestriction[0].Split.TransitionRefs.TransitionRef)
{
var nextActivity = GetNextActivityFromTransition(transition.Id);
activities.Add(nextActivity);
}
break;
}
return(activities);
}
//------------------------------------------------------------------------/
// Events
//------------------------------------------------------------------------/
private void ProcessTransitionEvent(BaseTransitionEvent e, Action startAction, Action endAction)
{
this.Log($"Received transition {e.GetType().GetNiceName()}. Window open ? {open}");
TransitionAction action = new TransitionAction(e, startAction, endAction);
transitions.Enqueue(action);
// If not opened yet
if (!open)
{
if (e.clearSelection)
{
ClearSelectedObject();
}
OpenWindow(new StratusCanvasWindowOpenArguments()
{
transitionSpeed = e.speed
});
}
// If already open
else
{
if (currentTransition.canContinue)
{
this.Log("Moving onto next transition");
Continue();
}
}
}
private void ConstructSwipeObjects()
{
ActiveRectTransform = CurrentView.GetComponent <RectTransform>();
swipedTransforms.ForEach(trs => {
if (trs != ActiveRectTransform)
{
cache.PushObject(trs.gameObject);
}
});
swipedTransforms.Clear();
swipedTransforms.Add(ActiveRectTransform);
if (HasLeft(CurrentData))
{
GameObject obj = cache.PopObject();
RectTransform leftTrs = obj.GetComponent <RectTransform>();
SetupView(LeftData(CurrentData), leftTrs.GetComponent <TView>());
leftTrs.anchoredPosition = new Vector2(ActiveRectTransform.anchoredPosition.x - ScreenSize,
ActiveRectTransform.anchoredPosition.y);
swipedTransforms.Insert(0, leftTrs);
}
if (HasRight(CurrentData))
{
GameObject obj = cache.PopObject();
RectTransform rightTrs = obj.GetComponent <RectTransform>();
SetupView(RightData(CurrentData), rightTrs.GetComponent <TView>());
rightTrs.anchoredPosition = new Vector2(ActiveRectTransform.anchoredPosition.x + ScreenSize,
ActiveRectTransform.anchoredPosition.y);
swipedTransforms.Add(rightTrs);
}
TransitionAction?.Invoke();
}
public FadeTransition(Atom a, int layer, float animationSpeed, bool skipFadeOut, TransitionAction midAction, TransitionAction endAction = null)
: base(a, layer)
{
this.animationSpeed = animationSpeed;
this.skipFadeOut = skipFadeOut;
this.midAction = midAction;
this.endAction = endAction;
}
public FadeTransition(Atom a, int layer, float animationSpeed, bool skipFadeOut, State nextState)
: base(a, layer)
{
this.animationSpeed = animationSpeed;
this.skipFadeOut = skipFadeOut;
this.midAction = delegate() { a.stateManager.AddState(nextState); };
this.endAction = delegate() { a.stateManager.AddFocus(nextState); };
}
public void AddTransition(TransitionAction action, State destination)
{
if (transitions == null)
{
transitions = new List <Transition> ();
}
transitions.Add(new Transition(action, this, destination));
}
public FadeTransition(Atom a, int layer, float animationSpeed, bool skipFadeOut, State nextState)
: base(a, layer)
{
this.animationSpeed = animationSpeed;
this.skipFadeOut = skipFadeOut;
this.midAction = delegate() { a.stateManager.AddState(nextState); };
this.endAction = delegate() { a.stateManager.AddFocus(nextState); };
}
public FadeTransition(Atom a, int layer, float animationSpeed, bool skipFadeOut, TransitionAction midAction, TransitionAction endAction = null)
: base(a, layer)
{
this.animationSpeed = animationSpeed;
this.skipFadeOut = skipFadeOut;
this.midAction = midAction;
this.endAction = endAction;
}
/// <summary>
/// Change the current state to the state at stateID and calls the transition functions
/// </summary>
/// <param name="stateID">The key of the desired state</param>
/// /// <param name="transitionAction">The function to call as the state changes</param>
public void ChangeState(String stateID, TransitionAction transitionAction)
{
if (states.ContainsKey(stateID) & currentStateID != stateID)
{
currentState = states[stateID];
currentStateID = stateID;
transitionAction(this);
}
}
public TransitionActionDTO ToTransitionAction(DR_Requester requester, TransitionAction dbTransitionAction, bool withDetails)
{
BizAction bizAction = new BizAction();
BizFormula bizFormula = new BizFormula();
BizEntityGroup bizEntityGroup = new BizEntityGroup();
BizTransition bizTransition = new BizTransition();
var result = new TransitionActionDTO();
result.ID = dbTransitionAction.ID;
if (dbTransitionAction.ActionTypeID != null)
{
result.ActionType = (ActionType)dbTransitionAction.ActionTypeID;
}
else
{
result.ActionType = ActionType.Approve;
}
result.MultipleUserEnabled = dbTransitionAction.MultipleUserEnabled;
result.Name = dbTransitionAction.Name;
if (withDetails)
{
// result.Action = bizAction.ToActionDTO(dbTransitionAction.Action);
result.Transition = bizTransition.ToSimpleTransitionDTO(dbTransitionAction.Transition);
BizTarget bizTarget = new BizTarget();
BizRoleType bizRoleType = new BizRoleType();
foreach (var target in dbTransitionAction.TransitionActionTarget)
{
TransitionActionTargetDTO at = new TransitionActionTargetDTO();
at.ID = target.ID;
// at.CanSendOtherOrganizations = target.CanSendOtherOrganizations==true;
at.TargetType = (TargetType)target.TargetType;
if (target.RoleTypeID != null)
{
at.RoleTypeID = target.RoleTypeID.Value;
at.RoleType = bizRoleType.ToRoleTypeDTO(target.RoleType);
}
result.Targets.Add(at);
}
foreach (var sbsf in dbTransitionAction.TransitionAction_Formula)
{
var sf = new TransitionActionFormulaDTO();
sf.FormulaID = sbsf.FormulaID;
sf.Message = sbsf.Message;
sf.TrueFalse = sbsf.TrueFalse;
result.Formulas.Add(sf);
}
foreach (var entityGroup in dbTransitionAction.TransitionAction_EntityGroup)
{
result.EntityGroups.Add(bizEntityGroup.ToEntityGroupDTO(requester, entityGroup.EntityGroup, withDetails));
}
}
return(result);
}
public bool SetTransitionAction(Transition <T> otherTransition, TransitionAction <T> transitionAction)
{
Transition <T> transition = GetTransition(otherTransition);
if (transition == null)
{
return(false);
}
transition.TAction = transitionAction;
return(true);
}
public bool SetTransitionAction(State <T> stateFrom, State <T> stateTo, TransitionAction <T> transitionAction)
{
Transition <T> transition = GetTransition(stateFrom, stateTo);
if (transition == null)
{
return(false);
}
transition.TAction = transitionAction;
return(true);
}
public bool SetTransitionAction(T identifierFrom, T identifierTo, TransitionAction <T> transitionAction)
{
Transition <T> transition = GetTransition(identifierFrom, identifierTo);
if (transition == null)
{
return(false);
}
transition.TAction = transitionAction;
return(true);
}
public (TransitionAction transitionAction, List <string> nextActivities) GetActivityStatus(string activityId)
{
var activity = FindActivityById(activityId);
if (activity == null)
{
throw new ReaderException($"Activity with specified Id : {activityId}, not found");
}
TransitionAction transitionAction = this.CheckActivityTransitionAction(activity);
var nextActivities = this.GetTransitionsFromActivity(activity, transitionAction);
return(transitionAction : transitionAction, nextActivities : nextActivities);
}
public UniqueTransition SetInteractionController(ITransitionInteractionController interactionController, Type fromViewController, TransitionAction action)
{
return(SetInteractionController(
interactionController,
fromViewController == null ? null : new ObjCRuntime.Class(fromViewController),
null,
action));
}
public UniqueTransition SetInteractionController <TFrom, TTo> (ITransitionInteractionController interactionController, TransitionAction action)
where TFrom : UIViewController
where TTo : UIViewController
{
return(SetInteractionController(
interactionController,
new ObjCRuntime.Class(typeof(TFrom)),
new ObjCRuntime.Class(typeof(TTo)),
action));
}
public UniqueTransition(TransitionAction action, Type fromViewController, Type toViewController)
: this(action, new ObjCRuntime.Class(fromViewController), new ObjCRuntime.Class(toViewController))
{
}
public StatechartTransition(TransitionAttribute transition, MethodInfo method, IState context)
{
_Transition = transition;
Action = (TransitionAction)Delegate.CreateDelegate(typeof(TransitionAction), context, method);
}
public bool AddTransition(State <T> otherStateFrom, State <T> otherStateTo, TransitionTracer <T> transitionTracer, TransitionAction <T> transitionAction)
{
State <T> stateFrom = GetState(otherStateFrom);
State <T> stateTo = GetState(otherStateTo);
if (stateFrom == null | stateTo == null)
{
return(false);
}
return(transitions.Add(new Transition <T>
{
StateFrom = stateFrom,
StateTo = stateTo,
Tracer = transitionTracer,
TAction = transitionAction
}));
}
/// <summary>
/// Register a new transition inside the state machine.
/// </summary>
/// <param name="previousState">The state being transitioned out of.</param>
/// <param name="eventPacket">The type of packet received over the network.</param>
/// <param name="nextState">The state to transition into.</param>
/// <param name="action">An action to perform before transitioning.</param>
public void RegisterTransition(NetworkState previousState, TransitionEvent transEvent, NetworkState nextState, TransitionAction action)
{
TransitionTable.Add(new Tuple<NetworkState, TransitionEvent>(previousState, transEvent), new Tuple<NetworkState, TransitionAction>(nextState, action));
return;
}
public TransitionAction Exec(Action<char> action)
{
TransitionAction = new TransitionAction(this, action);
return TransitionAction;
}
public bool UpdateTransitions(int ProcessID, List <TransitionDTO> list, string flowSTR)
{
try
{
//مهم و پیچیده نسبتا؟ اگر از جریان کار استفاده شده باشد امکان تغییر جریان کار بررسی شود
using (var projectContext = new MyProjectEntities())
{
var dbProcess = projectContext.Process.FirstOrDefault(x => x.ID == ProcessID);
dbProcess.TransitionFlowSTR = flowSTR;
var existingTransitions = list.Where(x => x.ID != 0).Select(x => x.ID).ToList();
var listRemove = dbProcess.Transition.Where(x => !existingTransitions.Contains(x.ID));
foreach (var item in listRemove.ToList())
{
while (item.TransitionActivity.Any())
{
projectContext.TransitionActivity.Remove(item.TransitionActivity.First());
}
while (item.TransitionAction.Any())
{
while (item.TransitionAction.First().TransitionAction_EntityGroup.Any())
{
projectContext.TransitionAction_EntityGroup.Remove(item.TransitionAction.First().TransitionAction_EntityGroup.First());
}
while (item.TransitionAction.First().TransitionAction_Formula.Any())
{
projectContext.TransitionAction_Formula.Remove(item.TransitionAction.First().TransitionAction_Formula.First());
}
while (item.TransitionAction.First().TransitionActionTarget.Any())
{
projectContext.TransitionActionTarget.Remove(item.TransitionAction.First().TransitionActionTarget.First());
}
projectContext.TransitionAction.Remove(item.TransitionAction.First());
}
//item.TransitionAction.Clear();
//item.TransitionActivity.Clear();
projectContext.Transition.Remove(item);
}
foreach (var message in list)
{
Transition dbTransition = null;
if (message.ID == 0)
{
dbTransition = new Transition();
projectContext.Transition.Add(dbTransition);
}
else
{
dbTransition = projectContext.Transition.FirstOrDefault(x => x.ID == message.ID);
}
dbTransition.CurrentStateID = message.CurrentStateID;
dbTransition.ProcessID = message.ProcessID;
dbTransition.NextStateID = message.NextStateID;
dbTransition.Name = message.Name;
List <TransitionActivity> removeActivity = new List <TransitionActivity>();
foreach (var dbActivity in dbTransition.TransitionActivity)
{
if (!message.TransitionActivities.Any(x => x.ID == dbActivity.ActivityID))
{
removeActivity.Add(dbActivity);
}
}
foreach (var citem in removeActivity)
{
projectContext.TransitionActivity.Remove(citem);
}
foreach (var msgActivity in message.TransitionActivities)
{
TransitionActivity dbTransitionActivity = null;
if (!dbTransition.TransitionActivity.Any(x => msgActivity.ID != 0 && x.ActivityID == msgActivity.ID))
{
dbTransitionActivity = new TransitionActivity();
dbTransition.TransitionActivity.Add(dbTransitionActivity);
}
else
{
dbTransitionActivity = dbTransition.TransitionActivity.FirstOrDefault(x => x.ActivityID == msgActivity.ID);
}
dbTransitionActivity.ActivityID = msgActivity.ID;
}
List <TransitionAction> removeAction = new List <TransitionAction>();
foreach (var dbAction in dbTransition.TransitionAction)
{
if (!message.TransitionActions.Any(x => x.ID == dbAction.ID))
{
removeAction.Add(dbAction);
}
}
foreach (var citem in removeAction)
{
while (citem.TransitionAction_EntityGroup.Any())
{
projectContext.TransitionAction_EntityGroup.Remove(citem.TransitionAction_EntityGroup.First());
}
while (citem.TransitionAction_Formula.Any())
{
projectContext.TransitionAction_Formula.Remove(citem.TransitionAction_Formula.First());
}
while (citem.TransitionActionTarget.Any())
{
projectContext.TransitionActionTarget.Remove(citem.TransitionActionTarget.First());
}
projectContext.TransitionAction.Remove(citem);
}
foreach (var msgTransitionAction in message.TransitionActions)
{
TransitionAction dbTransitionAction = null;
if (!dbTransition.TransitionAction.Any(x => msgTransitionAction.ID != 0 && x.ID == msgTransitionAction.ID))
{
dbTransitionAction = new TransitionAction();
dbTransition.TransitionAction.Add(dbTransitionAction);
}
else
{
dbTransitionAction = dbTransition.TransitionAction.FirstOrDefault(x => x.ID == msgTransitionAction.ID);
}
dbTransitionAction.ActionTypeID = (short)msgTransitionAction.ActionType;
dbTransitionAction.MultipleUserEnabled = msgTransitionAction.MultipleUserEnabled;
dbTransitionAction.Name = msgTransitionAction.Name;
List <TransitionActionTarget> removeTransitionActionTarget = new List <TransitionActionTarget>();
foreach (var dbTransitionAction_Target in dbTransitionAction.TransitionActionTarget)
{
if (!msgTransitionAction.Targets.Any(x => x.ID == dbTransitionAction_Target.ID))
{
removeTransitionActionTarget.Add(dbTransitionAction_Target);
}
}
foreach (var citem in removeTransitionActionTarget)
{
projectContext.TransitionActionTarget.Remove(citem);
}
foreach (var item in msgTransitionAction.Targets)
{
TransitionActionTarget dbTransitionActionTarget = dbTransitionAction.TransitionActionTarget.FirstOrDefault(x => item.ID != 0 && x.ID == item.ID);
if (dbTransitionActionTarget == null)
{
dbTransitionActionTarget = new TransitionActionTarget();
dbTransitionAction.TransitionActionTarget.Add(dbTransitionActionTarget);
}
dbTransitionActionTarget.TargetType = (Int16)item.TargetType;
// dbTransitionActionTarget.CanSendOtherOrganizations = item.CanSendOtherOrganizations;
if (dbTransitionActionTarget.RoleTypeID != 0)
{
dbTransitionActionTarget.RoleTypeID = item.RoleTypeID;
}
else
{
dbTransitionActionTarget.RoleTypeID = null;
}
}
List <TransitionAction_Formula> removeTransitionAction_Formula = new List <TransitionAction_Formula>();
foreach (var dbTransitionAction_Formula in dbTransitionAction.TransitionAction_Formula)
{
if (!msgTransitionAction.Formulas.Any(x => x.FormulaID == dbTransitionAction_Formula.FormulaID))
{
removeTransitionAction_Formula.Add(dbTransitionAction_Formula);
}
}
foreach (var citem in removeTransitionAction_Formula)
{
projectContext.TransitionAction_Formula.Remove(citem);
}
foreach (var item in msgTransitionAction.Formulas)
{
TransitionAction_Formula dbTransitionAction_Formula = dbTransitionAction.TransitionAction_Formula.FirstOrDefault(x => item.FormulaID != 0 && x.FormulaID == item.FormulaID);
if (dbTransitionAction_Formula == null)
{
dbTransitionAction_Formula = new TransitionAction_Formula();
dbTransitionAction.TransitionAction_Formula.Add(dbTransitionAction_Formula);
}
dbTransitionAction_Formula.TrueFalse = item.TrueFalse;
dbTransitionAction_Formula.FormulaID = item.FormulaID;
dbTransitionAction_Formula.Message = item.Message;
}
List <TransitionAction_EntityGroup> removeTransitionAction_EntityGroup = new List <TransitionAction_EntityGroup>();
foreach (var dbTransitionAction_EntityGroup in dbTransitionAction.TransitionAction_EntityGroup)
{
if (!msgTransitionAction.EntityGroups.Any(x => x.ID == dbTransitionAction_EntityGroup.EntityGroupID))
{
removeTransitionAction_EntityGroup.Add(dbTransitionAction_EntityGroup);
}
}
foreach (var citem in removeTransitionAction_EntityGroup)
{
projectContext.TransitionAction_EntityGroup.Remove(citem);
}
foreach (var item in msgTransitionAction.EntityGroups)
{
TransitionAction_EntityGroup dbTransitionAction_EntityGroup = dbTransitionAction.TransitionAction_EntityGroup.FirstOrDefault(x => item.ID != 0 && x.EntityGroupID == item.ID);
if (dbTransitionAction_EntityGroup == null)
{
dbTransitionAction_EntityGroup = new TransitionAction_EntityGroup();
dbTransitionAction.TransitionAction_EntityGroup.Add(dbTransitionAction_EntityGroup);
}
dbTransitionAction_EntityGroup.EntityGroupID = item.ID;
}
}
}
projectContext.SaveChanges();
return(true);
}
}
catch (Exception ex)
{
return(false);
}
}
public Transition(TransitionAction transitionAction, State nextState)
{
TransitionAction = transitionAction;
NextState = nextState;
}
public TransitionEvent(TStateId from, TStateId to, TransitionAction action)
{
this.from = from;
this.to = to;
this.action = action;
}
public Transition(TransitionAction doTransition, State start, State destination)
{
this.doTransition = doTransition;
this.start = start;
this.destination = destination;
}
public UniqueTransition SetAnimationController <T> (IAnimationController animationController, TransitionAction action)
where T : UIViewController
{
return(SetAnimationController(
animationController,
new ObjCRuntime.Class(typeof(T)),
action));
}
public UniqueTransition SetAnimationController(IAnimationController animationController, Type fromViewController, Type toViewController, TransitionAction action)
{
return(SetAnimationController(
animationController,
fromViewController == null ? null : new ObjCRuntime.Class(fromViewController),
toViewController == null ? null : new ObjCRuntime.Class(toViewController),
action));
}
/// <summary>
/// Invokes TransitionAction event.
/// </summary>
/// <param name="symbol"></param>
public void OnTransitionAction(TInSymbol symbol)
{
TransitionAction?.Invoke(this, new ActionEventArgs(symbol));
}
/// <summary>
/// Register a new transition inside the state machine.
/// </summary>
/// <param name="previousState">The state being transitioned out of.</param>
/// <param name="eventPacket">The type of packet received over the network.</param>
/// <param name="nextState">The state to transition into.</param>
/// <param name="action">An action to perform before transitioning.</param>
public void RegisterTransition(GameServerState previousState, GameServerTransition transEvent, GameServerState nextState, TransitionAction action)
{
TransitionTable.Add(new Tuple<GameServerState, GameServerTransition>(previousState, transEvent), new Tuple<GameServerState, TransitionAction>(nextState, action));
return;
}
