internal static void CloneScheduledTasks(WorkflowEventEntity oldEvent, WorkflowEventEntity newEvent)
{
var task = Database.Query <WorkflowEventTaskEntity>().SingleOrDefault(a => a.Event.RefersTo(oldEvent));
if (task == null)
{
return;
}
var st = Database.Query <ScheduledTaskEntity>().SingleOrDefaultEx(a => a.Task == task);
if (st == null)
{
return;
}
var newTask = new WorkflowEventTaskEntity()
{
Workflow = newEvent.Lane.Pool.Workflow.ToLite(),
fullWorkflow = newEvent.Lane.Pool.Workflow,
Event = newEvent.ToLite(),
TriggeredOn = task.TriggeredOn,
Condition = task.Condition != null ? new WorkflowEventTaskConditionEval()
{
Script = task.Condition.Script
} : null,
Action = new WorkflowEventTaskActionEval()
{
Script = task.Action.Script
},
}.Execute(WorkflowEventTaskOperation.Save);
new ScheduledTaskEntity()
{
Suspended = st.Suspended,
Rule = st.Rule.Clone(),
Task = newTask,
User = AuthLogic.SystemUser.ToLite(),
}.Execute(ScheduledTaskOperation.Save);
}
public static WorkflowEventTaskEntity WorkflowEventTask(this WorkflowEventEntity e)
{
return(WorkflowEventTaskExpression.Evaluate(e));
}
public static ScheduledTaskEntity ScheduledTask(this WorkflowEventEntity e)
{
return(ScheduledTaskExpression.Evaluate(e));
}
public static WorkflowEventTaskEntity WorkflowEventTask(this WorkflowEventEntity e) => As.Expression(() => Database.Query <WorkflowEventTaskEntity>().SingleOrDefault(et => et.Event.Is(e)));
public static ScheduledTaskEntity ScheduledTask(this WorkflowEventEntity e) => As.Expression(() => Database.Query <ScheduledTaskEntity>().SingleOrDefault(s => ((WorkflowEventTaskEntity)s.Task).Event.Is(e)));
public static CaseFlow GetCaseFlow(CaseEntity @case)
{
var averages = @case.Workflow.WorkflowActivities().Select(w => KVP.Create(w.ToLite(), w.CaseActivities().Average(a => a.Duration))).ToDictionary();
var caseActivities = @case.CaseActivities().Select(ca => new CaseActivityStats
{
CaseActivity = ca.ToLite(),
PreviousActivity = ca.Previous,
WorkflowActivity = ca.WorkflowActivity.ToLite(),
WorkflowActivityType = ca.WorkflowActivity.Type,
SubWorkflow = ca.WorkflowActivity.SubWorkflow.Workflow.ToLite(),
BpmnElementId = ca.WorkflowActivity.BpmnElementId,
Notifications = ca.Notifications().Count(),
StartDate = ca.StartDate,
DoneDate = ca.DoneDate,
DoneType = ca.DoneType,
DoneBy = ca.DoneBy,
Duration = ca.Duration,
AverageDuration = averages.TryGetS(ca.WorkflowActivity.ToLite()),
EstimatedDuration = ca.WorkflowActivity.EstimatedDuration,
}).ToDictionary(a => a.CaseActivity);
var gr = WorkflowLogic.GetWorkflowNodeGraph(@case.Workflow.ToLite());
var connections = caseActivities.Values
.Where(cs => cs.PreviousActivity != null && caseActivities.ContainsKey(cs.PreviousActivity))
.SelectMany(cs =>
{
var prev = caseActivities.GetOrThrow(cs.PreviousActivity);
var from = gr.Activities.GetOrThrow(prev.WorkflowActivity);
var to = gr.Activities.GetOrThrow(cs.WorkflowActivity);
if (IsNormal(prev.DoneType.Value))
{
var conns = GetAllConnections(gr, from, to);
if (conns.Any())
{
return(conns.Select(c => new CaseConnectionStats
{
BpmnElementId = c.BpmnElementId,
Connection = c.ToLite(),
FromBpmnElementId = c.From.BpmnElementId,
ToBpmnElementId = c.To.BpmnElementId,
DoneBy = prev.DoneBy,
DoneDate = prev.DoneDate.Value,
DoneType = prev.DoneType.Value
}));
}
}
return(new[]
{
new CaseConnectionStats
{
FromBpmnElementId = from.BpmnElementId,
ToBpmnElementId = to.BpmnElementId,
DoneBy = prev.DoneBy,
DoneDate = prev.DoneDate.Value,
DoneType = prev.DoneType.Value
}
});
}).ToList();
var firsts = caseActivities.Values.Where(a => (a.PreviousActivity == null || !caseActivities.ContainsKey(a.PreviousActivity)));
foreach (var f in firsts)
{
WorkflowEventEntity start = GetStartEvent(@case, f.CaseActivity, gr);
connections.AddRange(GetAllConnections(gr, start, gr.Activities.GetOrThrow(f.WorkflowActivity)).Select(c => new CaseConnectionStats
{
BpmnElementId = c.BpmnElementId,
Connection = c.ToLite(),
FromBpmnElementId = c.From.BpmnElementId,
ToBpmnElementId = c.To.BpmnElementId,
DoneBy = f.DoneBy,
DoneDate = f.StartDate,
}));
}
if (@case.FinishDate != null)
{
var lasts = caseActivities.Values.Where(last => !caseActivities.Values.Any(a => a.PreviousActivity.Is(last.CaseActivity))).ToList();
var ends = gr.Events.Values.Where(a => a.Type == WorkflowEventType.Finish);
foreach (var last in lasts)
{
foreach (var end in ends)
{
connections.AddRange(GetAllConnections(gr, gr.Activities.GetOrThrow(last.WorkflowActivity), end).Select(c => new CaseConnectionStats
{
BpmnElementId = c.BpmnElementId,
Connection = c.ToLite(),
FromBpmnElementId = c.From.BpmnElementId,
ToBpmnElementId = c.To.BpmnElementId,
DoneBy = last.DoneBy,
DoneDate = last.DoneDate.Value,
}));
}
}
}
return(new CaseFlow
{
Activities = caseActivities.Values.GroupToDictionary(a => a.BpmnElementId),
Connections = connections.Where(a => a.BpmnElementId != null).GroupToDictionary(a => a.BpmnElementId),
Jumps = connections.Where(a => a.BpmnElementId == null).ToList(),
AllNodes = connections.Select(a => a.FromBpmnElementId).Union(connections.Select(a => a.ToBpmnElementId)).ToList()
});
}
