Merge pull request #584 from doganc/ProjenBTEApps

add RunRepeatedly/DecisionOptionName  to WorkflowEventEntity

Author: olmobrutall

Signum.Engine.Extensions/Workflow/CaseActivityLogic.cs

@@ -83,11 +83,14 @@ public static IQueryable<CaseTagEntity> Tags(this CaseEntity e) =>
     public static IQueryable<CaseNotificationEntity> Notifications(this CaseActivityEntity e) =>
         As.Expression(() => Database.Query<CaseNotificationEntity>().Where(a => a.CaseActivity.Is(e)));
 
-
     [AutoExpressionField]
     public static IQueryable<CaseActivityExecutedTimerEntity> ExecutedTimers(this CaseActivityEntity e) =>
         As.Expression(() => Database.Query<CaseActivityExecutedTimerEntity>().Where(a => a.CaseActivity.Is(e)));
 
+    [AutoExpressionField]
+    public static CaseActivityExecutedTimerEntity? LastExecutedTimer(this CaseActivityEntity ca, Lite<WorkflowEventEntity> we) =>
+        As.Expression(() => ca.ExecutedTimers().Where(a => a.BoundaryEvent.Is(we)).OrderByDescending(a => a.CreationDate).FirstOrDefault());
+
     public static void Start(SchemaBuilder sb)
     {
         if (sb.NotDefined(MethodInfo.GetCurrentMethod()))
@@ -291,11 +294,10 @@ IQueryable<CaseActivityEntity> CancelledCases(CaseEntity c)
                  where ca.State == CaseActivityState.Pending
                  from we in ((WorkflowActivityEntity)ca.WorkflowActivity).BoundaryTimers
                  where we.Type == WorkflowEventType.BoundaryInterruptingTimer ? true :
-                 we.Type == WorkflowEventType.BoundaryForkTimer ? !ca.ExecutedTimers().Any(t => t.BoundaryEvent.Is(we)) :
+                 we.Type == WorkflowEventType.BoundaryForkTimer ? (we.RunRepeatedly || !ca.ExecutedTimers().Any(t => t.BoundaryEvent.Is(we))) :
                  false
                  select new ActivityEvent(ca, we)).ToList();
 
-
                 var intermediateCandidates =
                 (from ca in Database.Query<CaseActivityEntity>()
                  where !ca.Workflow().HasExpired()
@@ -306,12 +308,20 @@ from we in ((WorkflowActivityEntity)ca.WorkflowActivity).BoundaryTimers
 
                 var candidates = boundaryCandidates.Concat(intermediateCandidates).Distinct().ToList();
                 var conditions = candidates.Select(a => a.Event.Timer!.Condition).Distinct().ToList();
+                var lastExecutions = boundaryCandidates
+                    .Where(a => a.Event.Type == WorkflowEventType.BoundaryForkTimer && a.Event.RunRepeatedly)
+                    .Select(a => new { ActivityEvent = a, LastExecution = a.Activity.LastExecutedTimer(a.Event.ToLite()) })
+                    .ToList();
 
                 var now = Clock.Now;
                 var activities = conditions.SelectMany(cond =>
                 {
                     if (cond == null)
-                        return candidates.Where(a => a.Event.Timer!.Duration != null && a.Event.Timer!.Duration!.Add(a.Activity.StartDate) < now).Select(a => a.Activity.ToLite()).ToList();
+                        return candidates.Where(a =>
+                        {
+                            var startDate = lastExecutions.SingleOrDefaultEx(le => le.ActivityEvent.Is(a))?.LastExecution?.CreationDate ?? a.Activity.StartDate;
+                            return a.Event.Timer!.Duration != null && a.Event.Timer!.Duration!.Add(startDate) < now;
+                        }).Select(a => a.Activity.ToLite()).ToList();
 
                     return candidates.Where(a => a.Event.Timer!.Condition.Is(cond) && cond.Evaluate(a.Activity, now)).Select(a => a.Activity.ToLite()).ToList();
                 }).Distinct().ToList();
@@ -426,6 +436,11 @@ public ActivityEvent(CaseActivityEntity activity, WorkflowEventEntity @event)
             Event = @event;
         }
 
+        public bool Is(ActivityEvent other)
+        {
+            return this.Activity.Is(other.Activity) && this.Event.Is(other.Event);
+        }
+
         public CaseActivityEntity Activity { get; set; }
         public WorkflowEventEntity Event { get; set; }
     }
@@ -835,15 +850,22 @@ public static void Register()
                 {
                     var now = Clock.Now;
 
-                    var alreadyExecuted = ca.ExecutedTimers().Select(a => a.BoundaryEvent).ToHashSet();
-
                     var candidateEvents = ca.WorkflowActivity is WorkflowEventEntity @event ? new WorkflowEventEntity[] { @event } :
                     ((WorkflowActivityEntity)ca.WorkflowActivity).BoundaryTimers.ToArray();
 
-                    var timer = candidateEvents.Where(e => e.Type == WorkflowEventType.BoundaryInterruptingTimer || !alreadyExecuted.Contains(e.ToLite())).FirstOrDefault(t =>
+                    var lastExecutions = (
+                        from et in ca.ExecutedTimers()
+                        group et by et.BoundaryEvent into g
+                        select new { Event = g.Key, LastExecution = g.OrderByDescending(a => a.CreationDate).FirstOrDefault() }
+                        ).ToDictionary(a => a.Event, a => a.LastExecution);
+
+                    var timer = candidateEvents.Where(e => e.Type == WorkflowEventType.BoundaryInterruptingTimer || e.RunRepeatedly || !lastExecutions.ContainsKey(e.ToLite())).FirstOrDefault(t =>
                     {
                         if (t.Timer!.Duration != null)
-                            return t.Timer!.Duration!.Add(ca.StartDate) < now;
+                        {
+                            var startDate = lastExecutions.GetValueOrDefault(t.ToLite())?.CreationDate ?? ca.StartDate;
+                            return t.Timer!.Duration!.Add(startDate) < now;
+                        }
 
                         return t.Timer!.Condition!.Evaluate(ca, now);
                     });
@@ -1098,7 +1120,7 @@ private static void ExecuteBoundaryTimer(CaseActivityEntity ca, WorkflowEventEnt
                     }.Save();
                     break;
                 case WorkflowEventType.BoundaryInterruptingTimer:
-                    ca.MakeDone(DoneType.Timeout, null);
+                    ca.MakeDone(DoneType.Timeout, boundaryEvent.DecisionOptionName);
                     break;
                 default:
                     throw new InvalidOperationException("Unexpected Boundary Timer Type " + boundaryEvent.Type);

Signum.Engine.Extensions/Workflow/CaseFlowLogic.cs

@@ -43,7 +43,14 @@ public static CaseFlow GetCaseFlow(CaseEntity @case)
                 if (from is WorkflowActivityEntity wa)
                 {
                     var conns = wa.BoundaryTimers.Where(a => a.Type == WorkflowEventType.BoundaryInterruptingTimer)
-                    .SelectMany(e => gr.GetAllConnections(e, to, path => path.All(a => a.Type == ConnectionType.Normal)));
+                    .SelectMany(e => gr.GetAllConnections(e, to, path =>
+                    {
+                        if (prev.DoneDecision != null)
+                            return IsValidPath(DoneType.Timeout, prev.DoneDecision, path);
+
+                        return path.All(a => a.Type == ConnectionType.Normal);
+                    }));
+
                     if (conns.Any())
                         return conns.Select(c => new CaseConnectionStats().WithConnection(c).WithDone(prev));
                 }
@@ -192,10 +199,10 @@ private static bool IsValidPath(DoneType doneType, string? doneDecision, Stack<W
             case DoneType.Next: 
             case DoneType.ScriptSuccess:
             case DoneType.Recompose:
+            case DoneType.Timeout:
                 return path.All(a => a.Type == ConnectionType.Normal || doneDecision != null && (a.DoneDecision() == doneDecision));
             case DoneType.Jump: return path.All(a => a.Is(path.FirstEx()) ? a.Type == ConnectionType.Jump : a.Type == ConnectionType.Normal);
             case DoneType.ScriptFailure: return path.All(a => a.Is(path.FirstEx()) ? a.Type == ConnectionType.ScriptException : a.Type == ConnectionType.Normal);
-            case DoneType.Timeout:
             default:
                 throw new InvalidOperationException();
         }

Signum.Engine.Extensions/Workflow/WorkflowLogic.cs

@@ -297,6 +297,8 @@ from e in Database.Query<WorkflowEntity>()
                     e.BpmnElementId,
                     e.Lane,
                     e.Lane.Pool.Workflow,
+                    e.RunRepeatedly,
+                    e.DecisionOptionName,
                 });
 
 

Signum.Engine.Extensions/Workflow/WorkflowNodeGraph.cs

@@ -2,6 +2,7 @@
 using Signum.Utilities.DataStructures;
 using Signum.Entities.Authorization;
 using Signum.Engine.Authorization;
+using Signum.Entities.Reflection;
 
 namespace Signum.Engine.Workflow;
 
@@ -224,7 +225,6 @@ public void Validate(List<WorkflowIssue> issuesContainer, Action<WorkflowGateway
             if (e.Type.IsTimer())
             {
                 var boundaryOutput = NextConnections(e).Only();
-
                 if (boundaryOutput == null || boundaryOutput.Type != ConnectionType.Normal)
                 {
                     if (e.Type == WorkflowEventType.IntermediateTimer)
@@ -238,6 +238,19 @@ public void Validate(List<WorkflowIssue> issuesContainer, Action<WorkflowGateway
 
                 if (e.Type == WorkflowEventType.IntermediateTimer && !e.Name.HasText())
                     issues.AddError(e, WorkflowValidationMessage.IntermediateTimer0ShouldHaveName.NiceToString(e));
+
+                if (e.Type == WorkflowEventType.BoundaryInterruptingTimer)
+                {
+                    var parentActivity = Activities.Values.Where(a => a.BoundaryTimers.Contains(e)).SingleEx();
+                    if (string.IsNullOrWhiteSpace(e.DecisionOptionName) && parentActivity.Type == WorkflowActivityType.Decision)
+                        issues.AddError(e, WorkflowValidationMessage.BoundaryTimer0OfActivity1ShouldHave2BecauseActivityIs3.NiceToString(e, parentActivity, e.NicePropertyName(a => a.DecisionOptionName), WorkflowActivityType.Decision.NiceToString()));
+
+                    if (!string.IsNullOrWhiteSpace(e.DecisionOptionName) && parentActivity.Type != WorkflowActivityType.Decision)
+                        issues.AddError(e, WorkflowValidationMessage.BoundaryTimer0OfActivity1CanNotHave2BecauseActivityIsNot3.NiceToString(e, parentActivity, e.NicePropertyName(a => a.DecisionOptionName), WorkflowActivityType.Decision.NiceToString()));
+
+                    if (!string.IsNullOrWhiteSpace(e.DecisionOptionName) && !parentActivity.DecisionOptions.Any(a => a.Name == e.DecisionOptionName))
+                        issues.AddError(e, WorkflowValidationMessage.BoundaryTimer0OfActivity1HasInvalid23.NiceToString(e, parentActivity, e.NicePropertyName(a => a.DecisionOptionName), e.DecisionOptionName));
+                }
             }
         });
 

Signum.Entities.Extensions/Workflow/Workflow.cs

@@ -280,6 +280,12 @@ public enum WorkflowValidationMessage
     DecisionOption0IsDeclaredButNeverUsedInAConnection,
     [Description("Decision option name '{0}' is not declared in any activity")]
     DecisionOptionName0IsNotDeclaredInAnyActivity,
+    [Description("Boundary timer '{0}' of activity '{1}' can not have {2} because activity is not {3}")]
+    BoundaryTimer0OfActivity1CanNotHave2BecauseActivityIsNot3,
+    [Description("Boundary timer '{0}' of activity '{1}' should have {2} because activity is {3}")]
+    BoundaryTimer0OfActivity1ShouldHave2BecauseActivityIs3,
+    [Description("Boundary timer '{0}' of activity '{1}' has invalid {2}: '{3}'")]
+    BoundaryTimer0OfActivity1HasInvalid23,
 }
 
 public enum WorkflowActivityMonitorMessage

Signum.Entities.Extensions/Workflow/WorkflowActivity.cs

@@ -125,6 +125,8 @@ public ModelEntity GetModel()
             Name = we.Name,
             MainEntityType = we.Lane.Pool.Workflow.MainEntityType,
             Type = we.Type,
+            RunRepeatedly = we.RunRepeatedly,
+            DecisionOptionName = we.DecisionOptionName,
             Timer = we.Timer,
             BpmnElementId = we.BpmnElementId
         }).ToMList());

Signum.Entities.Extensions/Workflow/WorkflowEvent.cs

@@ -17,7 +17,13 @@ public class WorkflowEventEntity : Entity, IWorkflowNodeEntity, IWithModel
 
     public WorkflowEventType Type { get; set; }
 
-    public WorkflowTimerEmbedded? Timer { get; set; }
+    public bool RunRepeatedly { get; set; }
+
+    [StringLengthValidator(Min = 3, Max = 100)] 
+    public string? DecisionOptionName { get; set; }
+
+
+     public WorkflowTimerEmbedded? Timer { get; set; }
 
     public Lite<WorkflowActivityEntity>? BoundaryOf { get; set; }
 
@@ -34,6 +40,8 @@ public ModelEntity GetModel()
             MainEntityType = this.Lane.Pool.Workflow.MainEntityType,
             Name = this.Name,
             Type = this.Type,
+            RunRepeatedly = this.RunRepeatedly,
+            DecisionOptionName = this.DecisionOptionName,
             Task = WorkflowEventTaskModel.GetModel(this),
             Timer = this.Timer,
             BpmnElementId = this.BpmnElementId,
@@ -47,11 +55,24 @@ public void SetModel(ModelEntity model)
         var wModel = (WorkflowEventModel)model;
         this.Name = wModel.Name;
         this.Type = wModel.Type;
+        this.RunRepeatedly = wModel.RunRepeatedly;
+        this.DecisionOptionName = wModel.DecisionOptionName;
         this.Timer = wModel.Timer;
         this.BpmnElementId = wModel.BpmnElementId;
         this.CopyMixinsFrom(wModel);
         //WorkflowEventTaskModel.ApplyModel(this, wModel.Task);
     }
+
+    protected override void PreSaving(PreSavingContext ctx)
+    {
+        if (Type != WorkflowEventType.BoundaryForkTimer && RunRepeatedly)
+            RunRepeatedly = false;
+
+        if (Type != WorkflowEventType.BoundaryInterruptingTimer && !string.IsNullOrWhiteSpace(DecisionOptionName))
+            DecisionOptionName = null;
+
+        base.PreSaving(ctx);
+    }
 }
 
 public class WorkflowTimerEmbedded : EmbeddedEntity
@@ -132,6 +153,11 @@ public class WorkflowEventModel : ModelEntity
 
     public WorkflowEventType Type { get; set; }
 
+    public bool RunRepeatedly { get; set; }
+
+    [StringLengthValidator(Min = 3, Max = 100)]
+    public string? DecisionOptionName { get; set; }
+
     public WorkflowEventTaskModel? Task { get; set; }
 
     public WorkflowTimerEmbedded? Timer { get; set; }

Signum.React.Extensions/Workflow/Signum.Entities.Workflow.ts

@@ -502,6 +502,8 @@ export interface WorkflowEventEntity extends Entities.Entity, IWorkflowNodeEntit
   bpmnElementId: string;
   lane: WorkflowLaneEntity;
   type: WorkflowEventType;
+  runRepeatedly: boolean;
+  decisionOptionName: string | null;
   timer: WorkflowTimerEmbedded | null;
   boundaryOf: Entities.Lite<WorkflowActivityEntity> | null;
   xml: WorkflowXmlEmbedded;
@@ -513,6 +515,8 @@ export interface WorkflowEventModel extends Entities.ModelEntity {
   mainEntityType: Basics.TypeEntity;
   name: string | null;
   type: WorkflowEventType;
+  runRepeatedly: boolean;
+  decisionOptionName: string | null;
   task: WorkflowEventTaskModel | null;
   timer: WorkflowTimerEmbedded | null;
   bpmnElementId: string;
@@ -846,6 +850,9 @@ export module WorkflowValidationMessage {
   export const Join0OfType1DoesNotMatchWithItsPairTheSplit2OfType3 = new MessageKey("WorkflowValidationMessage", "Join0OfType1DoesNotMatchWithItsPairTheSplit2OfType3");
   export const DecisionOption0IsDeclaredButNeverUsedInAConnection = new MessageKey("WorkflowValidationMessage", "DecisionOption0IsDeclaredButNeverUsedInAConnection");
   export const DecisionOptionName0IsNotDeclaredInAnyActivity = new MessageKey("WorkflowValidationMessage", "DecisionOptionName0IsNotDeclaredInAnyActivity");
+  export const BoundaryTimer0OfActivity1CanNotHave2BecauseActivityIsNot3 = new MessageKey("WorkflowValidationMessage", "BoundaryTimer0OfActivity1CanNotHave2BecauseActivityIsNot3");
+  export const BoundaryTimer0OfActivity1ShouldHave2BecauseActivityIs3 = new MessageKey("WorkflowValidationMessage", "BoundaryTimer0OfActivity1ShouldHave2BecauseActivityIs3");
+  export const BoundaryTimer0OfActivity1HasInvalid23 = new MessageKey("WorkflowValidationMessage", "BoundaryTimer0OfActivity1HasInvalid23");
 }
 
 export const WorkflowXmlEmbedded = new Type<WorkflowXmlEmbedded>("WorkflowXmlEmbedded");

Signum.React.Extensions/Workflow/Workflow/WorkflowEventModel.tsx

@@ -61,6 +61,8 @@ export default function WorkflowEventModelComponent(p: WorkflowEventModelCompone
     <div>
       <ValueLine ctx={ctx.subCtx(we => we.name)} />
       <ValueLine ctx={ctx.subCtx(we => we.type)} readOnly={isTimer(ctx.value.type!)} optionItems={getTypeComboItems()} onChange={loadTask} />
+      {ctx.value.type == "BoundaryForkTimer" && <ValueLine ctx={ctx.subCtx(a => a.runRepeatedly)} />}
+      {ctx.value.type == "BoundaryInterruptingTimer" && <ValueLine ctx={ctx.subCtx(a => a.decisionOptionName)} />}
       {ctx.value.task && <WorkflowEventTask ctx={ctx.subCtx(a => a.task!)} mainEntityType={ctx.value.mainEntityType} isConditional={isConditional()} />}
       {ctx.value.timer && <WorkflowTimer ctx={ctx.subCtx(a => a.timer!)} mainEntityType={ctx.value.mainEntityType}/>}
     </div>