private async Task <ActivityPayload> ConfigureQueryFr8Activity(List <ActivityTemplateDTO> activityTemplates)
{
var template = activityTemplates.Single(x => x.Terminal.Name == "terminalFr8Core" && x.Name == "Get_Data_From_Fr8_Warehouse" && x.Version == "1");
var activity = await HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, template, order : 3);
var crateStorage = activity.CrateStorage;
var configControlCM = ActivityConfigurator.GetConfigurationControls(activity);
var objectList = (DropDownList)configControlCM.Controls.First(x => x.Name == "AvailableObjects");
var selectedObject = objectList.ListItems.Where(a => a.Key == (ActivityUI.BasedOnTemplateOption.Selected ? MT.DocuSignEnvelope_v2.GetEnumDisplayName() : MT.DocuSignRecipient.GetEnumDisplayName())).FirstOrDefault();
if (selectedObject == null)
{
return(activity);
}
objectList.SelectByKey(selectedObject.Key);
var queryBuilder = (QueryBuilder)configControlCM.Controls.First(c => c.Name == "QueryBuilder");
var conditions = new List <FilterConditionDTO>();
if (ActivityUI.SentToSpecificRecipientOption.Selected)
{
conditions.Add(new FilterConditionDTO {
Field = "RecipientEmail", Operator = "eq", Value = ActivityUI.SpecificRecipientEmailText.Value
});
}
conditions.Add(new FilterConditionDTO {
Field = "EnvelopeId", Operator = "eq", Value = "FromPayload"
});
queryBuilder.Value = JsonConvert.SerializeObject(conditions);
return(await HubCommunicator.ConfigureActivity(activity));
}
public async Task Run_WhenMessageIsEmpty_ReturnsError()
{
var activity = New <Post_To_Chatter_v2>();
var executionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = new AuthorizationToken {
Token = Token.Token
}
};
await activity.Configure(activityContext);
ActivityConfigurator.GetControl <ControlDefinitionDTO>(activityContext.ActivityPayload, "FeedTextSource").Value = null;
activity = New <Post_To_Chatter_v2>();
await activity.Run(activityContext, executionContext);
var operationalState = executionContext.PayloadStorage.FirstCrateContentOrDefault <OperationalStateCM>();
Assert.AreEqual(ActivityResponse.Error.ToString(), operationalState.CurrentActivityResponse.Type, "Run must fail if message is empty");
}
private async Task ConfigureSetDelayActivity(List <ActivityTemplateDTO> activityTemplates)
{
var template = activityTemplates.Single(x => x.Terminal.Name == "terminalFr8Core" && x.Name == "Set_Delay" && x.Version == "1");
var activity = await HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, template, order : 2);
ActivityConfigurator.SetControlValue(activity, "Delay_Duration", ActivityUI.TimePeriod.Value);
}
private async Task <ActivityPayload> CreateProcessingActivity(ReconfigurationContext context)
{
var loopActivity = await HubCommunicator.AddAndConfigureChildActivity(context.SolutionActivity, await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Loop"), "Loop", "Loop", 2);
var loopConfigControls = ActivityConfigurator.GetConfigurationControls(loopActivity);
var crateChooser = loopConfigControls.Controls.OfType <CrateChooser>().Single();
var firstActivity = context.SolutionActivity.ChildrenActivities.OrderBy(x => x.Ordering).First();
var firstActivityCrates = firstActivity.CrateStorage.CrateContentsOfType <CrateDescriptionCM>().FirstOrDefault();
crateChooser.CrateDescriptions = firstActivityCrates?.CrateDescriptions;
var tableDescription = crateChooser.CrateDescriptions?.FirstOrDefault(x => x.ManifestId == (int)MT.StandardTableData);
if (tableDescription != null)
{
tableDescription.Selected = true;
}
var solutionActivityUi = new ActivityUi().ClonePropertiesFrom(context.SolutionActivity.CrateStorage.FirstCrate <StandardConfigurationControlsCM>().Content) as ActivityUi;
var mailSenderActivityTemplate = await HubCommunicator.GetActivityTemplate(Guid.Parse(solutionActivityUi.MailSenderActivitySelector.Value));
var sendEmailActivity = await HubCommunicator.AddAndConfigureChildActivity(loopActivity, mailSenderActivityTemplate, order : 1);
return(loopActivity);
}
private void SetNotifierActivityBody(ActivityPayload notifierActivity)
{
var activityConfigurator = new ActivityConfigurator(notifierActivity);
if (notifierActivity.ActivityTemplate.Name == "Send_Email_Via_SendGrid")
{
var emailBodyField = activityConfigurator.GetControl <TextSource>("EmailBody", ControlTypes.TextSource);
emailBodyField.ValueSource = "upstream";
emailBodyField.Value = "NotificationMessage";
emailBodyField.selectedKey = "NotificationMessage";
var emailSubjectField = activityConfigurator.GetControl <TextSource>("EmailSubject", ControlTypes.TextSource);
emailSubjectField.ValueSource = "specific";
emailSubjectField.TextValue = "Fr8 Notification Message";
}
else if (notifierActivity.ActivityTemplate.Name == "Send_Via_Twilio")
{
var emailBodyField = activityConfigurator.GetControl <TextSource>("SMS_Body", ControlTypes.TextSource);
emailBodyField.ValueSource = "upstream";
emailBodyField.Value = "NotificationMessage";
emailBodyField.selectedKey = "NotificationMessage";
}
else if (notifierActivity.ActivityTemplate.Name == "Publish_To_Slack")
{
var messageField = activityConfigurator.GetControl <TextSource>("Select_Message_Field", ControlTypes.TextSource);
if (messageField == null)
{
//user is not authenticated yet - there is nothing we can do now
return;
}
messageField.ValueSource = "upstream";
messageField.Value = "NotificationMessage";
messageField.selectedKey = "NotificationMessage";
}
}
private void SetSelectedTemplate(ActivityPayload docuSignActivity, DropDownList selectedTemplateDd)
{
var actionDdlb = ActivityConfigurator.GetControl <DropDownList>(docuSignActivity, "Available_Templates", ControlTypes.DropDownList);
actionDdlb.selectedKey = selectedTemplateDd.selectedKey;
actionDdlb.Value = selectedTemplateDd.Value;
}
private void SetToConversion(ActivityPayload convertCratesActivity)
{
var toDropdown = ActivityConfigurator.GetControl <DropDownList>(convertCratesActivity, "Available_To_Manifests", ControlTypes.DropDownList);
toDropdown.Value = ((int)MT.StandardFileHandle).ToString(CultureInfo.InvariantCulture);
toDropdown.selectedKey = MT.StandardFileHandle.GetEnumDisplayName();
}
private void SetFromConversion(ActivityPayload convertCratesActivity)
{
var fromDropdown = ActivityConfigurator.GetControl <DropDownList>(convertCratesActivity, "Available_From_Manifests", ControlTypes.DropDownList);
fromDropdown.Value = ((int)MT.DocuSignTemplate).ToString(CultureInfo.InvariantCulture);
fromDropdown.selectedKey = MT.DocuSignTemplate.GetEnumDisplayName();
}
private async Task SetQueryFr8WarehouseActivityFields(ActivityPayload queryFr8Warehouse, string recipientEmail)
{
//update action's duration value
var crateStorage = queryFr8Warehouse.CrateStorage;
var configControlCM = ActivityConfigurator.GetConfigurationControls(queryFr8Warehouse);
var radioButtonGroup = (configControlCM.Controls.First() as RadioButtonGroup);
radioButtonGroup.Radios[0].Selected = false;
radioButtonGroup.Radios[1].Selected = true;
var objectList = (DropDownList)(radioButtonGroup.Radios[1].Controls.FirstOrDefault(c => c.Name == "AvailableObjects"));
MtTypeReference selectedObject;
if (string.IsNullOrEmpty(recipientEmail))
{
selectedObject = GetMtType(typeof(DocuSignEnvelopeCM_v2));
}
else
{
selectedObject = GetMtType(typeof(DocuSignRecipientStatus));
}
if (selectedObject == null)
{
return;
}
objectList.Value = selectedObject.Id.ToString("N");
objectList.selectedKey = selectedObject.Alias;
var filterPane = (FilterPane)radioButtonGroup.Radios[1].Controls.First(c => c.Name == "Filter");
var conditions = new List <FilterConditionDTO>
{
new FilterConditionDTO {
Field = "EnvelopeId", Operator = "eq", Value = "FromPayload"
}
};
if (recipientEmail != null)
{
conditions.Add(new FilterConditionDTO {
Field = "Email", Operator = "eq", Value = recipientEmail
});
}
filterPane.Value = JsonConvert.SerializeObject(new FilterDataDTO
{
ExecutionType = FilterExecutionType.WithFilter,
Conditions = conditions
});
using (var uow = _container.GetInstance <IUnitOfWork>())
{
var queryCriteria = Crate.FromContent("Queryable Criteria", new FieldDescriptionsCM(MTTypesHelper.GetFieldsByTypeId(uow, selectedObject.Id)));
crateStorage.Add(queryCriteria);
}
}
private void SetFileDetails(ActivityPayload storeFileActivity, string fileName)
{
var fileNameTextbox = ActivityConfigurator.GetControl <TextBox>(storeFileActivity, "File_Name", ControlTypes.TextBox);
var fileCrateTextSource = ActivityConfigurator.GetControl <TextSource>(storeFileActivity, "File Crate label", ControlTypes.TextSource);
fileNameTextbox.Value = fileName;
fileCrateTextSource.ValueSource = "specific";
fileCrateTextSource.TextValue = "From DocuSignTemplate To StandardFileDescription";
}
private async Task <ActivityPayload> ConfigureSecondChildActivity(ReconfigurationContext context)
{
var curActivityTemplates = (await HubCommunicator.GetActivityTemplates(null, true))
.ToList();
var selectedReceiver = curActivityTemplates.Single(x => x.Name == _dataSourceValue);
ActivityPayload parentActivity;
int activityIndex;
if (DoesActivityTemplateGenerateTableData(selectedReceiver))
{
var loopActivity = context.SolutionActivity.ChildrenActivities
.OfType <ActivityPayload>()
.SingleOrDefault(x => x.ActivityTemplate.Name == "Loop" && x.Ordering == 2);
if (loopActivity == null)
{
throw new ApplicationException("Invalid solution structure, no Loop activity found.");
}
loopActivity = await HubCommunicator.ConfigureChildActivity(context.SolutionActivity, loopActivity);
var crateChooser = ActivityConfigurator.GetControl <CrateChooser>(loopActivity, "Available_Crates");
var tableDescription = crateChooser.CrateDescriptions.FirstOrDefault(c => c.ManifestId == (int)MT.StandardTableData);
if (tableDescription != null)
{
tableDescription.Selected = true;
}
parentActivity = loopActivity;
activityIndex = 1;
}
else
{
parentActivity = context.SolutionActivity;
activityIndex = 2;
}
var sendDocuSignEnvelope = parentActivity.ChildrenActivities
.OfType <ActivityPayload>()
.Single(x => x.ActivityTemplate.Name == "Send_DocuSign_Envelope" &&
x.Ordering == activityIndex
);
sendDocuSignEnvelope.CrateStorage = new CrateStorage();
sendDocuSignEnvelope = await HubCommunicator.ConfigureChildActivity(parentActivity, sendDocuSignEnvelope);
ActivityConfigurator.SetControlValue(
sendDocuSignEnvelope,
"target_docusign_template",
_docuSignTemplate.ListItems
.FirstOrDefault(a => a.Key == _docuSignTemplate.selectedKey)
);
sendDocuSignEnvelope = await HubCommunicator.ConfigureChildActivity(parentActivity, sendDocuSignEnvelope);
return(sendDocuSignEnvelope);
}
private async Task ConfigureBuildMessageActivity(List <ActivityTemplateDTO> activityTemplates)
{
var template = activityTemplates.Single(x => x.Terminal.Name == "terminalFr8Core" && x.Name == "Build_Message" && x.Version == "1");
var activity = await HubCommunicator.AddAndConfigureChildActivity(ActivityPayload.RootPlanNodeId.Value, template, order : 2);
ActivityConfigurator.SetControlValue(activity, "Body", MessageBody);
ActivityConfigurator.SetControlValue(activity, "Name", "NotificationMessage");
await HubCommunicator.ConfigureActivity(activity);
}
/// <summary>
/// Transition the state machine workflow to the Final state
/// </summary>
/// <typeparam name="TWorkflow"></typeparam>
/// <typeparam name="TInstance"></typeparam>
/// <param name="activityConfigurator"></param>
/// <returns></returns>
public static ActivityConfigurator <TWorkflow, TInstance> Finalize <TWorkflow, TInstance>(
this ActivityConfigurator <TWorkflow, TInstance> activityConfigurator)
where TWorkflow : class
where TInstance : class
{
var configurator = new TransitionConfigurator <TWorkflow, TInstance>(StateMachineWorkflow.FinalStateName);
activityConfigurator.AddConfigurator(configurator);
return(activityConfigurator);
}
public static MessageExceptionConfigurator <TWorkflow, TInstance, TBody> InCaseOf <TWorkflow, TInstance, TBody>(
this ActivityConfigurator <TWorkflow, TInstance, TBody> activityConfigurator)
where TWorkflow : class
where TInstance : class
{
var configurator = new MessageExceptionConfiguratorImpl <TWorkflow, TInstance, TBody>(activityConfigurator);
activityConfigurator.AddConfigurator(configurator);
return(configurator);
}
public static ActivityConfigurator <TWorkflow, TInstance, TBody> Then <TWorkflow, TInstance, TBody>(
this ActivityConfigurator <TWorkflow, TInstance, TBody> activityConfigurator, Action <TInstance> action)
where TWorkflow : class
where TInstance : class
{
var configurator = new DelegateInstanceConfigurator <TWorkflow, TInstance>(action);
activityConfigurator.AddConfigurator(configurator);
return(activityConfigurator);
}
public static ActivityConfigurator <TWorkflow, TInstance, TBody> TransitionTo <TWorkflow, TInstance, TBody>(
this ActivityConfigurator <TWorkflow, TInstance, TBody> activityConfigurator,
Expression <Func <TWorkflow, State> > targetStateExpression)
where TWorkflow : class
where TInstance : class
{
var configurator = new TransitionConfigurator <TWorkflow, TInstance>(targetStateExpression);
activityConfigurator.AddConfigurator(configurator);
return(activityConfigurator);
}
public static ActivityConfigurator <TWorkflow, TInstance, TBody> Then <TWorkflow, TInstance, TBody>(
this ActivityConfigurator <TWorkflow, TInstance, TBody> activityConfigurator,
Expression <Func <TInstance, Action <TBody> > > methodExpression)
where TWorkflow : class
where TInstance : class
{
var configurator = new MethodBodyConfigurator <TWorkflow, TInstance, TBody>(methodExpression);
activityConfigurator.AddConfigurator(configurator);
return(activityConfigurator);
}
private async Task <ActivityPayload> CreateSecondChildActivity(ReconfigurationContext context)
{
var curActivityTemplates = (await HubCommunicator.GetActivityTemplates(null, true))
.ToList();
var selectedReceiver = curActivityTemplates.Single(x => x.Name == _dataSourceValue);
ActivityPayload parentActivity;
int activityIndex;
if (DoesActivityTemplateGenerateTableData(selectedReceiver))
{
var loopAT = await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Loop");
var loopActivity = await HubCommunicator.AddAndConfigureChildActivity(context.SolutionActivity, loopAT, "Loop", "Loop", 2);
var crateChooser = ActivityConfigurator.GetControl <CrateChooser>(loopActivity, "Available_Crates");
var firstActivity = context.SolutionActivity.ChildrenActivities.OrderBy(x => x.Ordering).First();
var firstActivityCrates = firstActivity.CrateStorage.CrateContentsOfType <CrateDescriptionCM>().FirstOrDefault();
crateChooser.CrateDescriptions = firstActivityCrates?.CrateDescriptions;
var tableDescription = crateChooser.CrateDescriptions?.FirstOrDefault(c => c.ManifestId == (int)MT.StandardTableData);
if (tableDescription != null)
{
tableDescription.Selected = true;
}
parentActivity = loopActivity;
activityIndex = 1;
}
else
{
parentActivity = context.SolutionActivity;
activityIndex = 2;
}
var sendDocusignEnvelopeAT = await HubCommunicator.GetActivityTemplate("terminalDocuSign", "Send_DocuSign_Envelope", activityTemplateVersion : "2");
var sendDocuSignActivity = await HubCommunicator.AddAndConfigureChildActivity(parentActivity, sendDocusignEnvelopeAT, order : activityIndex);
// Set docusign template
ActivityConfigurator.SetControlValue(sendDocuSignActivity, "TemplateSelector",
_docuSignTemplate.ListItems.FirstOrDefault(a => a.Key == _docuSignTemplate.selectedKey)
);
await HubCommunicator.ConfigureChildActivity(parentActivity, sendDocuSignActivity);
return(activityIndex == 1 ? sendDocuSignActivity : parentActivity);
}
public static ActivityConfigurator <TWorkflow, TInstance, Request <TRequest> > Respond
<TWorkflow, TInstance, TRequest>(
this ActivityConfigurator <TWorkflow, TInstance, Request <TRequest> > activityConfigurator)
where TWorkflow : class
where TInstance : class
{
var configurator =
new DelegateInstanceBodyConfigurator <TWorkflow, TInstance, Request <TRequest> >((instance, request) =>
{
request.Respond();
});
activityConfigurator.AddConfigurator(configurator);
return(activityConfigurator);
}
public static ActivityConfigurator <TWorkflow, TInstance, Request <TRequest> > Respond
<TWorkflow, TInstance, TRequest, TResponse>(
this ActivityConfigurator <TWorkflow, TInstance, Request <TRequest> > activityConfigurator,
Func <Request <TRequest>, TResponse> getResponse)
where TWorkflow : class
where TInstance : class
{
var configurator =
new DelegateInstanceBodyConfigurator <TWorkflow, TInstance, Request <TRequest> >((instance, request) =>
{
TResponse response = getResponse(request);
request.Respond(response);
});
activityConfigurator.AddConfigurator(configurator);
return(activityConfigurator);
}
private async Task <Guid> ConfigureNotifierActivity(List <ActivityTemplateDTO> activityTemplates, int previousNotifierOrdering)
{
var template = activityTemplates.First(x => x.Id == NotifierActivityTemplateId);
var activity = await HubCommunicator.AddAndConfigureChildActivity(ActivityPayload.RootPlanNodeId.Value, template, order : previousNotifierOrdering);
if (activity.ActivityTemplate.Name == "Send_Email_Via_SendGrid" && activity.ActivityTemplate.Version == "1")
{
//var configControls = ControlHelper.GetConfigurationControls(activity.CrateStorage);
var emailBodyField = ActivityConfigurator.GetControl <TextSource>(activity, "EmailBody", ControlTypes.TextSource);
emailBodyField.ValueSource = "upstream";
emailBodyField.Value = NotificationMessageLabel;
emailBodyField.selectedKey = NotificationMessageLabel;
var emailSubjectField = ActivityConfigurator.GetControl <TextSource>(activity, "EmailSubject", ControlTypes.TextSource);
emailSubjectField.ValueSource = "specific";
emailSubjectField.TextValue = "Fr8 Notification Message";
await HubCommunicator.ConfigureActivity(activity);
}
else if (activity.ActivityTemplate.Name == "Send_Via_Twilio" && activity.ActivityTemplate.Version == "1")
{
var emailBodyField = ActivityConfigurator.GetControl <TextSource>(activity, "SMS_Body", ControlTypes.TextSource);
emailBodyField.ValueSource = "upstream";
emailBodyField.Value = NotificationMessageLabel;
emailBodyField.selectedKey = NotificationMessageLabel;
}
else if (activity.ActivityTemplate.Name == "Publish_To_Slack" && activity.ActivityTemplate.Version == "2")
{
if (activity.CrateStorage.FirstCrateOrDefault <StandardAuthenticationCM>() == null)
{
var messageField = ActivityConfigurator.GetControl <TextSource>(activity, "MessageSource", ControlTypes.TextSource);
messageField.ValueSource = "upstream";
messageField.Value = NotificationMessageLabel;
messageField.selectedKey = NotificationMessageLabel;
messageField.SelectedItem = new FieldDTO {
Name = NotificationMessageLabel
};
activity = await HubCommunicator.ConfigureActivity(activity);
}
}
return(activity.Id);
}
private async Task <ActivityPayload> ConfigureMonitorActivity(List <ActivityTemplateDTO> activityTemplates)
{
var template = activityTemplates.Single(x => x.Terminal.Name == "terminalDocuSign" && x.Name == "Monitor_DocuSign_Envelope_Activity" && x.Version == "1");
var activity = await HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, template, order : 1);
await HubCommunicator.ApplyNewToken(activity.Id, Guid.Parse(AuthorizationToken.Id));
activity = await HubCommunicator.ConfigureActivity(activity);
ActivityConfigurator.SetControlValue(activity, "EnvelopeSent", "true");
if (ActivityUI.SentToSpecificRecipientOption.Selected)
{
ActivityConfigurator.SetControlValue(activity, "TemplateRecipientPicker.recipient.RecipientValue", ActivityUI.SpecificRecipientEmailText.Value);
ActivityConfigurator.SetControlValue(activity, "TemplateRecipientPicker.recipient", true);
ActivityConfigurator.SetControlValue(activity, "TemplateRecipientPicker.template", false);
}
else if (ActivityUI.BasedOnTemplateOption.Selected)
{
ActivityConfigurator.SetControlValue(activity, "TemplateRecipientPicker.template.UpstreamCrate", ActivityUI.TemplateSelector.ListItems.Single(x => x.Key == ActivityUI.TemplateSelector.selectedKey));
ActivityConfigurator.SetControlValue(activity, "TemplateRecipientPicker.recipient", false);
ActivityConfigurator.SetControlValue(activity, "TemplateRecipientPicker.template", true);
}
return(await HubCommunicator.ConfigureActivity(activity));
}
public override async Task FollowUp()
{
var specificRecipientOption = ((RadioButtonGroup)ConfigurationControls.Controls[0]).Radios[0];
var specificTemplateOption = ((RadioButtonGroup)ConfigurationControls.Controls[0]).Radios[1];
var howToBeNotifiedDdl = (DropDownList)ConfigurationControls.FindByName("NotificationHandler");
//let's don't add child actions to solution until how to be notified option is selected
//FR-1873
if (string.IsNullOrEmpty(howToBeNotifiedDdl.Value))
{
return;
}
var specificRecipient = specificRecipientOption.Controls.Single();
if (specificRecipientOption.Selected && string.IsNullOrEmpty(specificRecipient.Value))
{
return;
}
var specificTemplate = specificTemplateOption.Controls.Single();
if (specificTemplateOption.Selected && string.IsNullOrEmpty(specificTemplate.Value))
{
return;
}
bool hasChildren = false;
if (ActivityPayload.ChildrenActivities.Any())
{
hasChildren = true;
ActivityPayload.ChildrenActivities.Clear();
}
var monitorDocusignAT = await HubCommunicator.GetActivityTemplate("terminalDocuSign", "Monitor_DocuSign_Envelope_Activity");
var setDelayAT = await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Set_Delay");
var queryFr8WareHouseAT = await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Query_Fr8_Warehouse");
var testIncomingDataAT = await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Test_Incoming_Data");
var buildMessageAT = await HubCommunicator.GetActivityTemplate("terminalFr8Core", "Build_Message");
//DocuSign
var tasks = new List <Task>();
var monitorDocuSignActionTask = HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, monitorDocusignAT, "Monitor Docusign Envelope Activity", "Monitor Docusign Envelope Activity", 1);
tasks.Add(monitorDocuSignActionTask);
var setDelayActionTask = HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, setDelayAT, "Set Delay", "Set Delay", 2);
tasks.Add(setDelayActionTask);
var queryFr8WarehouseActionTask = HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, queryFr8WareHouseAT, "Query Fr8 Warehouse", "Query Fr8 Warehouse", 3);
tasks.Add(queryFr8WarehouseActionTask);
var filterActionTask = HubCommunicator.AddAndConfigureChildActivity(ActivityPayload, testIncomingDataAT, "Test Incoming Data", "Test Incoming Data", 4);
tasks.Add(filterActionTask);
Task <ActivityPayload> buildMessageActivityTask = null;
if (!hasChildren)
{
buildMessageActivityTask = HubCommunicator.AddAndConfigureChildActivity((Guid)ActivityPayload.ParentPlanNodeId, buildMessageAT, "Build a Message", "Build a Message", 2);
tasks.Add(buildMessageActivityTask);
}
await Task.WhenAll(tasks);
var monitorDocuSignAction = monitorDocuSignActionTask.Result;
var setDelayAction = setDelayActionTask.Result;
var queryFr8WarehouseAction = queryFr8WarehouseActionTask.Result;
var filterAction = filterActionTask.Result;
// var notifierActivity = notifierActivityTask.Result;
if (specificRecipientOption.Selected)
{
ActivityConfigurator.SetControlValue(monitorDocuSignAction, "TemplateRecipientPicker.recipient.RecipientValue", specificRecipientOption.Controls[0].Value);
}
else if (specificTemplateOption.Selected)
{
var ddlbTemplate = (specificTemplateOption.Controls[0] as DropDownList);
ActivityConfigurator.SetControlValue(monitorDocuSignAction, "TemplateRecipientPicker.template.UpstreamCrate",
ddlbTemplate.ListItems.Single(a => a.Key == ddlbTemplate.selectedKey));
}
if (buildMessageActivityTask != null)
{
var buildMessageActivity = buildMessageActivityTask.Result;
ActivityConfigurator.SetControlValue(buildMessageActivity, "Body", MessageBody);
ActivityConfigurator.SetControlValue(buildMessageActivity, "Name", "NotificationMessage");
buildMessageActivity = await HubCommunicator.ConfigureActivity(buildMessageActivity);
}
if (!hasChildren)
{
var notifierAT = await HubCommunicator.GetActivityTemplate(Guid.Parse(howToBeNotifiedDdl.Value));
var notifierActivity = await HubCommunicator.AddAndConfigureChildActivity((Guid)ActivityPayload.ParentPlanNodeId, notifierAT, howToBeNotifiedDdl.selectedKey, howToBeNotifiedDdl.selectedKey, 3);
SetNotifierActivityBody(notifierActivity);
await HubCommunicator.ConfigureActivity(notifierActivity);
}
ActivityConfigurator.SetControlValue(monitorDocuSignAction, "EnvelopeSent", "true");
//let's make followup configuration for monitorDocuSignEventAction
//followup call places EventSubscription crate in storage
var configureMonitorDocusignTask = HubCommunicator.ConfigureActivity(monitorDocuSignAction);
var durationControl = (Duration)ConfigurationControls.FindByName("TimePeriod");
ActivityConfigurator.SetControlValue(setDelayAction, "Delay_Duration", durationControl.Value);
await SetQueryFr8WarehouseActivityFields(queryFr8WarehouseAction, specificRecipientOption.Controls[0].Value);
//let's make a followup configuration to fill criteria fields
var configureQueryMTTask = HubCommunicator.ConfigureActivity(queryFr8WarehouseAction);
var recipientEventStatus = (DropDownList)ConfigurationControls.FindByName("RecipientEvent");
SetFilterUsingRunTimeActivityFields(filterAction, recipientEventStatus.Value);
await Task.WhenAll(configureMonitorDocusignTask, configureQueryMTTask);
monitorDocuSignAction = configureMonitorDocusignTask.Result;
ActivityPayload.ChildrenActivities = ActivityPayload.ChildrenActivities.OrderBy(a => a.Ordering).ToList();
ActivityPayload.ChildrenActivities[0] = monitorDocuSignAction;
}
public static ActivityConfigurator <IServiceWorkflow, IServiceController, ServiceFault> LogFault(
this ActivityConfigurator <IServiceWorkflow, IServiceController, ServiceFault> configurator)
{
return(configurator
.Then((i, m) => _log.ErrorFormat("[{0}] Fault: {1}", i.Name, m.ToLogString())));
}
public ExceptionConfiguratorImpl(ActivityConfigurator <TWorkflow, TInstance> activityConfigurator)
{
_activityConfigurator = activityConfigurator;
_configurators = new List <ActivityBuilderConfigurator <TWorkflow, TInstance> >();
}
