private async Task ExecuteTriggerActions(IEnumerable <Trigger> triggers, IEntity source)
{
foreach (var trigger in triggers)
{
if (trigger.Disabled)
{
logger.LogInformation($"Trigger.Fire :: {trigger.ID} :: Status:Disabled");
continue;
}
bool meetConditions = await evaluateConditionService.MeetConditions(trigger, trigger.Conditions);
if (!meetConditions)
{
logger.LogInformation($"Trigger.Fire :: {trigger.ID} :: Status:ConditionsNotMet");
continue;
}
logger.LogInformation($"Trigger.Fire :: {trigger.ID}");
List <Task> triggerActionTasks = new(trigger.Actions.Length);
foreach (int action in trigger.Actions)
{
triggerActionTasks.Add(actionExecutionService.Execute(action, source ?? trigger));
}
await Task.WhenAll(triggerActionTasks);
}
}
void IActionCoordinationService.Run(Dictionary <string, Configuration.Action> declaredActions, XmlElement coordinationData)
{
IActionExecutionService execution = GetService <IActionExecutionService>(true);
foreach (Config.Action config in declaredActions.Values)
{
execution.Execute(config.Name);
}
}
/// <exclude />
public void ExecuteAction(EntityToken entityToken, ActionToken actionToken)
{
var flowControllerServicesContainer = GetFlowControllerServicesContainer();
IActionExecutionService actionExecutionService = flowControllerServicesContainer.GetService <IActionExecutionService>();
var taskManagerEvent = new WorkflowCreationTaskManagerEvent(_instanceId);
actionExecutionService.Execute(entityToken, actionToken, taskManagerEvent);
}
/// <exclude />
protected void ExecuteAction(EntityToken entityToken, ActionToken actionToken)
{
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IActionExecutionService actionExecutionService = flowControllerServicesContainer.GetService <IActionExecutionService>();
var taskManagerEvent = new WorkflowCreationTaskManagerEvent(_instanceId);
actionExecutionService.Execute(entityToken, actionToken, taskManagerEvent);
}
/// <summary>
/// Runs the coordination using the configuration data specified in the configuration file.
/// </summary>
/// <param name="declaredActions">Actions defined in the package configuration file for the currently executing recipe.</param>
/// <param name="coordinationData">The configuration data used to setup the coordination.</param>
public void Run(Dictionary <string, Microsoft.Practices.RecipeFramework.Configuration.Action> declaredActions,
XmlElement coordinationData)
{
IActionExecutionService exec = GetService <IActionExecutionService>(true);
int amountCompleted = 0;
try
{
foreach (Microsoft.Practices.RecipeFramework.Configuration.Action action in declaredActions.Values)
{
amountCompleted++;
visualStudio.StatusBar.Progress(true, Properties.Resources.StatusBarProgressMessage, amountCompleted, declaredActions.Values.Count);
bool execute = (action.AnyAttr == null || action.AnyAttr.Length == 0);
if (!execute)
{
IDictionaryService dictservice = (IDictionaryService)GetService(typeof(IDictionaryService));
ExpressionEvaluationService evaluator = new ExpressionEvaluationService();
execute = true;
foreach (XmlAttribute att in action.AnyAttr)
{
if (att.Name.Equals(ConditionalCoordinator.ConditionalAttributeName, StringComparison.InvariantCultureIgnoreCase))
{
try
{
execute = (bool)evaluator.Evaluate(att.Value, new ServiceAdapterDictionary(dictservice));
}
catch (Exception e)
{
execute = false;
System.Diagnostics.Trace.TraceWarning(Properties.Resources.InvalidConditionException, e.Message, e.StackTrace);
}
break;
}
}
}
if (execute)
{
Trace.TraceInformation(Properties.Resources.ExecutingAction, action.Name);
exec.Execute(action.Name);
}
}
}
finally
{
visualStudio.StatusBar.Progress(false, "", 0, 0);
}
}
/// <exclude />
protected sealed override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)
{
FormsWorkflow formsWorkflow = this.GetRoot <FormsWorkflow>();
FlowControllerServicesContainer flowControllerServicesContainer = WorkflowFacade.GetFlowControllerServicesContainer(WorkflowEnvironment.WorkflowInstanceId);
IActionExecutionService actionExecutionService = flowControllerServicesContainer.GetService <IActionExecutionService>();
WorkflowActionToken workflowActionToken = new WorkflowActionToken(this.ChildWorkflowType)
{
Payload = this.ChildWorkflowPayload,
ParentWorkflowInstanceId = formsWorkflow.InstanceId
};
actionExecutionService.Execute(formsWorkflow.EntityToken, workflowActionToken, null);
return(ActivityExecutionStatus.Closed);
}
public void Run(Dictionary <string, Microsoft.Practices.RecipeFramework.Configuration.Action> declaredActions, XmlElement coordinationData)
{
IActionExecutionService service = base.GetService <IActionExecutionService>(true);
int amountCompleted = 0;
try
{
foreach (Microsoft.Practices.RecipeFramework.Configuration.Action action in declaredActions.Values)
{
amountCompleted++;
bool flag = (action.AnyAttr == null) || (action.AnyAttr.Length == 0);
if (!flag)
{
IDictionaryService serviceToAdapt = (IDictionaryService)this.GetService(typeof(IDictionaryService));
ExpressionEvaluationService service3 = new ExpressionEvaluationService();
flag = true;
foreach (XmlAttribute attribute in action.AnyAttr)
{
if (attribute.Name.Equals("Condition", StringComparison.InvariantCultureIgnoreCase))
{
try
{
flag = (bool)service3.Evaluate(attribute.Value, new ServiceAdapterDictionary(serviceToAdapt));
}
catch (Exception exception)
{
flag = false;
Trace.TraceWarning("InvalidConditionException", new object[] { exception.Message, exception.StackTrace });
}
break;
}
}
}
if (flag)
{
service.Execute(action.Name);
}
}
}
finally
{
this.visualStudio.StatusBar.Progress(false, "", 0, 0);
}
}
/// <summary>
/// Runs the coordination using the configuration data specified in the configuration file.
/// </summary>
/// <param name="declaredActions">Actions defined in the package configuration file for the currently executing recipe.</param>
/// <param name="coordinationData">The configuration data used to setup the coordination.</param>
public void Run(Dictionary <string, Config.Action> declaredActions, XmlElement coordinationData)
{
IActionExecutionService exec = GetService <IActionExecutionService>(true);
string currentAction = null;
try
{
foreach (Config.Action action in declaredActions.Values)
{
currentAction = action.Name;
exec.Execute(action.Name);
}
}
catch (Exception e)
{
IConfigurationService config = GetService <IConfigurationService>(true);
DteHelperEx.ShowMessageInOutputWindow(
GetService <DTE>(true),
string.Format(CultureInfo.CurrentCulture,
Properties.Resources.FailSafeCoordinatorExceptionMessage,
config.CurrentRecipe.Caption, config.CurrentRecipe.Name, currentAction, e.Message),
DteHelperEx.GetPackageFriendlyName(this.Site));
}
}
