public void Null_argument_tests()
{
IWorkflowItem item = null;
Assert.Throws <ArgumentNullException>(() => item.Events <ActivityCompletedEvent>());
Assert.Throws <ArgumentNullException>(() => item.Events(typeof(ActivityCompletedEvent)));
}
/// <summary>
/// Find the parent lambda by given parameters. Returns null if not found.
/// </summary>
/// <param name="workflowItem"></param>
/// <param name="name"></param>
/// <param name="positionalName"></param>
/// <returns></returns>
public static ILambdaItem ParentLambda(this IWorkflowItem workflowItem, string name,
string positionalName = "")
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.ParentLambdas.OfType <LambdaItem>()
.FirstOrDefault(a => a.Has(Identity.Lambda(name, positionalName))));
}
/// <summary>
/// Helps in trigger the scheduling the joint item.
/// </summary>
/// <param name="workflowItem"></param>
/// <returns></returns>
protected TriggerActions Trigger(IWorkflowItem workflowItem)
{
var item = workflowItem as WorkflowItem;
Ensure.NotNull(item, nameof(workflowItem));
return(new TriggerActions(item));
}
public static IActivityItem ParentActivity <TActivity>(this IWorkflowItem workflowItem, string positionalName = "") where TActivity : Activity
{
Ensure.NotNull(workflowItem, "workflowItem");
var description = ActivityDescription.FindOn <TActivity>();
return(workflowItem.ParentActivity(description.Name, description.Version, positionalName));
}
public int InsertWorkItem(IWorkflowItem entity)
{
return(LockExecute <int>(() =>
{
if (!string.IsNullOrEmpty(entity.Alias) && entity.Alias.IndexOf('.') > 0)
{
entity.Alias = entity.Alias.Substring(entity.Alias.LastIndexOf('.') + 1);
}
if (entity.ItemId >= 10000)
{
WorkItemsRead.Add(entity);
return Dao.Get().Insert <WorkflowItemRead>(entity);
}
else
{
WorkflowEventManager.RaiseWorkItemEvent(EventStep.Before, ItemActionType.Insert, this, entity);
WorkItems.Add(entity);
int result = Dao.Get().Insert <WorkflowItem>(entity);
if (result > 0)
{
WorkflowEventManager.RaiseWorkItemEvent(EventStep.After, ItemActionType.Insert, this, entity);
}
return result;
}
}));
}
/// <summary>
/// Returns parent activity by given parameters. Returns null not if not exists.
/// </summary>
/// <param name="workflowItem"></param>
/// <param name="name"></param>
/// <param name="version"></param>
/// <param name="positionalName"></param>
/// <returns></returns>
public static IActivityItem ParentActivity(this IWorkflowItem workflowItem, string name, string version, string positionalName = "")
{
Ensure.NotNull(workflowItem, "workflowItem");
Ensure.NotNull(name, nameof(name));
Ensure.NotNull(version, nameof(version));
return(workflowItem.ParentActivities.OfType <ActivityItem>()
.FirstOrDefault(a => a.Has(Identity.New(name, version, positionalName))));
}
/// <summary>
/// Returns the parent child-workflow for <see cref="TWorkflow"/> and positional name. Returns null if not
/// </summary>
/// <typeparam name="TWorkflow"></typeparam>
/// <param name="workflowItem"></param>
/// <param name="positionalName"></param>
/// <returns></returns>
public static IChildWorkflowItem ParentChildWorkflow <TWorkflow>(this IWorkflowItem workflowItem, string positionalName = "")
where TWorkflow : Workflow
{
Ensure.NotNull(workflowItem, nameof(workflowItem));
var desc = WorkflowDescription.FindOn <TWorkflow>();
return(workflowItem.ParentChildWorkflow(desc.Name, desc.Version, positionalName));
}
public static void PopulateItemDefaults(this IWorkflowItem <WorkflowBase, InventoryLocation, Item> Item)
{
Item.Description = Item.Item.Description;
Item.CostPrice = Item.Item.CostPrice;
Item.SellingPrice = Item.Item.SellingPrice;
Item.VAT = Item.Item.VAT;
Item.Quantity = Item.Item.DefaultQuantity == 0 ? 1 : Item.Item.DefaultQuantity;
Item.VatPercentage = Item.Item.VAT ? Constants.VatPercentage((Item as BaseObject).Session) : 0;
}
/// <summary>
/// Returns the parent child-workflow by given parameter. Returns null if it can find the parent child workflow for given parameters.
/// </summary>
/// <param name="workflowItem"></param>
/// <param name="name"></param>
/// <param name="version"></param>
/// <param name="positionalName"></param>
/// <returns></returns>
public static IChildWorkflowItem ParentChildWorkflow(this IWorkflowItem workflowItem, string name, string version,
string positionalName = "")
{
Ensure.NotNull(workflowItem, nameof(workflowItem));
Ensure.NotNullAndEmpty(name, nameof(name));
Ensure.NotNullAndEmpty(version, nameof(version));
return(workflowItem.ParentChildWorkflows.OfType <ChildWorkflowItem>()
.FirstOrDefault(a => a.Has(Identity.New(name, version, positionalName))));
}
private void Close_MouseDown(object sender, MouseButtonEventArgs e)
{
dynamic view = ((Image)sender).DataContext;
dynamic viewModel = view.DataContext;
IWorkflowItem item = (IWorkflowItem)DataContext;
if (item != null && viewModel != null && view != null)
{
viewModel.DeleteWorkflowItem(item);
}
}
internal WorkflowAction FirstJoint(IWorkflowItem beforeItem)
{
var workflowItem = beforeItem as WorkflowItem;
Ensure.NotNull(workflowItem, nameof(beforeItem));
var trigger = new TriggerWorkflowAction(_triggeringItem);
trigger.SetJumpedItem(workflowItem);
return(trigger);
}
//FIXME
private void Open()
{
var dialog = new OpenFileDialogViewModel
{
Title = "Open Workflow",
Filter = "W3Tools Workflow (*.rwx)|*.rwx",
Owner = this,
};
var result = DialogService.ShowDialog(dialog);
if (result == true)
{
foreach (var file in dialog.FilePaths)
{
//check if file exists?
if (!File.Exists(file))
{
continue;
}
//check if it is workflow file
// FIXME
var data = RwxData.Deserialize(file);
if (data is null)
{
continue;
}
WF_Settings settings = new WF_Settings(ConfigService, Logger); //FIXME
settings.FromXElement(data.Xsettings); //FIXMEEEE
var Workflow = new ObservableCollection <IWorkflowItem>();
foreach (var item in data.WorkflowItems)
{
//we have all commands stored in Commands, no need for assembly qualified names // FIXME
var cmd = Commands.FirstOrDefault(x => x.GetType().Name == item);
if (cmd is null)
{
continue;
}
IWorkflowItem emptyCopy = (IWorkflowItem)Activator.CreateInstance(cmd.GetType());
emptyCopy.CustomTag = settings;
Workflow.Add(emptyCopy);
}
var vm = AddDocument(data.Title);
vm.Settings = settings;
vm.Workflow = Workflow;
vm.DocumentPath = file;
}
}
}
public int UpdateWorkItem(IWorkflowItem entity)
{
return(LockExecute <int>(() =>
{
if (entity.ItemId >= 10000)
{
WorkItemsRead.Remove(entity);
WorkItemsRead.Add(entity);
return Dao.Get().Update <WorkflowItemRead>(entity);
}
else
{
WorkItems.Remove(entity);
WorkItems.Add(entity);
return Dao.Get().Update <WorkflowItem>(entity);
}
}));
}
/// <summary>
/// Return all events of a specific event type. e.g. ActivityFailedEvent, ActivityTimedoutEvent
/// </summary>
/// <typeparam name="TEvent"></typeparam>
/// <param name="workflowItem"></param>
/// <param name="includeRescheduleTimerEvents"></param>
/// <returns></returns>
public static IEnumerable <TEvent> Events <TEvent>(this IWorkflowItem workflowItem, bool includeRescheduleTimerEvents = false) where TEvent : WorkflowItemEvent
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.AllEvents(includeRescheduleTimerEvents).OfType <TEvent>());
}
/// <summary>
/// Назначить стартовый элемент
/// </summary>
/// <param name="item">Стартовый элемент</param>
public void SetStartItem(IWorkflowItem item)
{
_objects.Remove(_startItem);
SetItemDiagram(item);
_startItem = item;
if (!_objects.Contains(item))
{
_objects.Add(item);
}
if (!_items.Contains(item))
{
_items.Add(item);
}
}
public SequentialWorkflowModel(IWorkflowItem activity1)
{
_activity = new IWorkflowItem[1]; //Sequential activiy 1
ActivityModel1 = activity1;
}
private bool AnyOneTimedout(IWorkflowItem item)
{
return(item.ParentLambda("ApplyToCouncil").IsSignalTimedout("CRejected") ||
item.ParentLambda("ApplyToFireDept").IsSignalTimedout("FRejected") ||
item.ParentLambda("ApplyToForestDept").IsSignalTimedout("FrRejected"));
}
public static ITimerItem ParentTimer(this IWorkflowItem workflowItem, string name)
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.ParentTimers.OfType <TimerItem>()
.FirstOrDefault(a => a.Has(Identity.Timer(name))));
}
public static ITimerItem ParentTimer(this IWorkflowItem workflowItem)
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.ParentTimers.Single());
}
public static void RaiseWorkItemEvent(EventStep step, ItemActionType type, IWorkflowInstance instance, IWorkflowItem item)
{
string key = KeyTemplate.FormatTo(step.ToString(), type.ToString());
if (WorkItemEventList.ContainsKey(key))
{
try
{
Logger.GetLogger("Workflow").Info("{0}:Raise WorkflowItemEvent:{1}".FormatTo(instance.Id, key));
WorkItemEventList[key](instance, item);
}
catch (Exception ex)
{
Logger.GetLogger("Workflow").Info("{0}:Raise WorkflowEvent:{1} Error:{2},{3}".FormatTo(instance.Id, key, ex.Message, ex.StackTrace));
}
}
}
public ParallelWorkflowModel(IWorkflowItem activity1, IWorkflowItem activity2)
{
_activity = new IWorkflowItem[2]; //Sequential model only has an activity
_activity[0] = activity1;
_activity[1] = activity2;
}
public static IEnumerable <WorkflowItemEvent> AllEventsOf(this IWorkflowItem workflowItem, Type eventType)
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.AllEvents.Where(e => e.GetType() == eventType));
}
public static IEnumerable <TEvent> AllEventsOf <TEvent>(this IWorkflowItem workflowItem) where TEvent : WorkflowItemEvent
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.AllEvents.OfType <TEvent>());
}
/// <summary>
/// Returns the parent child-workflow of item. Throws exception if none or more than one parent child-workflows are found.
/// </summary>
/// <param name="workflowItem"></param>
/// <returns></returns>
public static IChildWorkflowItem ParentChildWorkflow(this IWorkflowItem workflowItem)
{
Ensure.NotNull(workflowItem, nameof(workflowItem));
return(workflowItem.ParentChildWorkflows.OfType <ChildWorkflowItem>().Single());
}
/// <summary>
/// Returns parent lambda. Throws exception if more than one parent lambda exists.
/// </summary>
/// <param name="workflowItem"></param>
/// <returns></returns>
public static ILambdaItem ParentLambda(this IWorkflowItem workflowItem)
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.ParentLambdas.Single());
}
/// <summary>
/// Добавить объект
/// </summary>
/// <param name="item"></param>
public void AddWorkflowItem(IWorkflowItem item)
{
if (!_items.Contains(item))
{
SetItemDiagram(item);
_items.Add(item);
if (!_objects.Contains(item))
{
_objects.Add(item);
}
}
}
/// <summary>
/// Return all events of a specific event type. e.g. ActivityFailedEvent, ActivityTimedoutEvent
/// </summary>
/// <param name="workflowItem"></param>
/// <param name="eventType"></param>
/// <param name="includeRescheduleTimerEvents"></param>
/// <returns></returns>
public static IEnumerable <WorkflowItemEvent> Events(this IWorkflowItem workflowItem, Type eventType, bool includeRescheduleTimerEvents = false)
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.AllEvents(includeRescheduleTimerEvents).Where(e => e.GetType() == eventType));
}
/// <summary>
/// Удалить объект
/// </summary>
/// <param name="item"></param>
public void RemoveWorkflowItem(IWorkflowItem item)
{
_items.Remove(item);
_objects.Remove(item);
}
public static IActivityItem ParentActivity(this IWorkflowItem workflowItem)
{
Ensure.NotNull(workflowItem, "workflowItem");
return(workflowItem.ParentActivities.Single());
}
private void SetItemDiagram(IWorkflowItem item)
{
if (item == null)
{
return;
}
item.Diagram = this;
}
public virtual void Add(IWorkflowItem item)
{
this.Items.Enqueue(item);
}
/// <summary>
/// Получить линки связаные с объектом диаграммы
/// </summary>
/// <param name="item">Объект диаграммы</param>
/// <returns>Список линков</returns>
public List<IWorkflowLink> GetItemLinks(IWorkflowItem item)
{
List<IWorkflowLink> list = _links.Where(x => x.FirstItem == item).ToList();
return list;
}
