private async Task ConfigureSolutionActivityUi()
{
var selectedObject = ActivityUI.SalesforceObjectSelector.selectedKey;
if (string.IsNullOrEmpty(selectedObject))
{
Storage.RemoveByLabel(QueryFilterCrateLabel);
this[nameof(ActivityUi.SalesforceObjectSelector)] = selectedObject;
return;
}
//If the same object is selected we shouldn't do anything
if (selectedObject == this[nameof(ActivityUi.SalesforceObjectSelector)])
{
return;
}
//Prepare new query filters from selected object properties
var selectedObjectProperties = await _salesforceManager.GetProperties(selectedObject.ToEnum <SalesforceObjectType>(), AuthorizationToken);
var queryFilterCrate = Crate <FieldDescriptionsCM> .FromContent(
QueryFilterCrateLabel,
new FieldDescriptionsCM(selectedObjectProperties)
);
Storage.ReplaceByLabel(queryFilterCrate);
this[nameof(ActivityUi.SalesforceObjectSelector)] = selectedObject;
}
public override async Task Run()
{
var authToken = JsonConvert.DeserializeObject <DocuSignAuthTokenDTO>(AuthorizationToken.Token);
Debug.WriteLine($"Running PrepareDocuSignEventForStorage: {ActivityId} - view viewhere!!!{0} - label {ActivityPayload.Label}");
Debug.WriteLine($"for container {ExecutionContext.ContainerId} and authToken {AuthorizationToken}");
var curEventReport = Payload.CrateContentsOfType <EventReportCM>().First();
if (curEventReport.EventNames.Contains("Envelope"))
{
var crate = curEventReport.EventPayload.CrateContentsOfType <DocuSignEnvelopeCM_v2>().First();
Payload.Add(Crate.FromContent("DocuSign Envelope", crate));
foreach (var recipient in crate.Recipients)
{
var recManifest = new DocuSignRecipientCM()
{
DocuSignAccountId = authToken.AccountId,
EnvelopeId = crate.EnvelopeId,
RecipientEmail = recipient.Email,
RecipientId = recipient.RecipientId,
RecipientUserName = recipient.Name,
RecipientStatus = recipient.Status
};
Payload.Add(Crate.FromContent("DocuSign Recipient " + recManifest.RecipientEmail, recManifest));
}
}
Payload.RemoveByManifestId((int)MT.StandardEventReport);
Debug.WriteLine($"Returning success for payload {ExecutionContext.ContainerId} - {Payload}");
Success();
}
private void SetFilterUsingRunTimeActivityFields(ActivityPayload filterUsingRunTimeAction, string status)
{
var crateStorage = filterUsingRunTimeAction.CrateStorage;
var configControlCM = crateStorage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.First();
var filterPane = (FilterPane)configControlCM.Controls.First(c => c.Name == "Selected_Filter");
var conditions = new List <FilterConditionDTO>
{
new FilterConditionDTO {
Field = "Status", Operator = "neq", Value = status
}
};
filterPane.Value = JsonConvert.SerializeObject(new FilterDataDTO
{
ExecutionType = FilterExecutionType.WithFilter,
Conditions = conditions
});
var queryableCriteria = new FieldDescriptionsCM(
new FieldDTO()
{
Name = "Status",
Label = "Status",
FieldType = FieldType.String
});
var queryFieldsCrate = Crate.FromContent("Queryable Criteria", queryableCriteria);
crateStorage.RemoveByLabel("Queryable Criteria");
crateStorage.Add(queryFieldsCrate);
}
public override Task Run()
{
var resultFields = new List <KeyValueDTO>();
var delayActivity = ActivityPayload.ChildrenActivities.FirstOrDefault(x => x.ActivityTemplate.Name == "Set_Delay" && x.ActivityTemplate.Version == "1");
if (delayActivity != null)
{
var delayControl = delayActivity.CrateStorage.FirstCrate <StandardConfigurationControlsCM>().Content.Controls.OfType <Duration>().First();
resultFields.Add(new KeyValueDTO {
Key = DelayTimeProperty, Value = GetDelayDescription(delayControl)
});
}
var filterActivity = ActivityPayload.ChildrenActivities.FirstOrDefault(x => x.ActivityTemplate.Name == "Test_Incoming_Data" && x.ActivityTemplate.Version == "1");
if (filterActivity != null)
{
var filterPane = filterActivity.CrateStorage.FirstCrate <StandardConfigurationControlsCM>().Content.Controls.OfType <FilterPane>().First();
var conditions = JsonConvert.DeserializeObject <FilterDataDTO>(filterPane.Value);
var statusField = conditions.Conditions.FirstOrDefault(c => c.Field == "Status");
if (statusField != null)
{
resultFields.Add(new KeyValueDTO {
Key = ActionBeingTrackedProperty, Value = statusField.Value
});
}
}
Payload.Add(Crate <StandardPayloadDataCM> .FromContent(RuntimeCrateLabel, new StandardPayloadDataCM(resultFields)));
return(Task.FromResult(0));
}
public override async Task FollowUp()
{
var selectedObject = ActivityUI.AvailableObjects.Value;
var hasSelectedObject = !string.IsNullOrEmpty(selectedObject);
var properties = new List <FieldDTO>();
if (hasSelectedObject)
{
Guid selectedObjectId;
if (Guid.TryParse(ActivityUI.AvailableObjects.Value, out selectedObjectId))
{
using (var uow = _container.GetInstance <IUnitOfWork>())
{
properties = MTTypesHelper.GetFieldsByTypeId(uow, selectedObjectId, AvailabilityType.RunTime).ToList();
Storage.ReplaceByLabel(
Crate.FromContent("Queryable Criteria", new FieldDescriptionsCM(properties)));
}
}
}
ActivityUI.QueryBuilder.IsHidden = !hasSelectedObject;
ActivityUI.SelectObjectLabel.IsHidden = hasSelectedObject;
if (!string.IsNullOrEmpty(selectedObject))
{
using (var uow = _container.GetInstance <IUnitOfWork>())
{
CrateSignaller.MarkAvailableAtRuntime <StandardTableDataCM>(RunTimeCrateLabel).AddFields(properties);
}
}
await Task.Yield();
}
public async Task CanDeactivate()
{
var activity = New <ActivityOverrideCheckMock>();
await activity.Deactivate(CreateActivityContext(Crate.FromContent(ExplicitTerminalActivity.ConfigurationControlsLabel, new StandardConfigurationControlsCM())));
Assert.IsTrue(activity.CalledMethods == (CalledMethod.Deactivate));
}
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");
}
protected override async Task <bool> BeforeConfigure(ConfigurationRequestType configurationRequestType)
{
if (configurationRequestType == ConfigurationRequestType.Initial)
{
return(true);
}
Storage.Remove <ValidationResultsCM>();
ValidationManager = CreateValidationManager();
ValidationManager.Reset();
if (!DisableValidationOnFollowup)
{
await Validate();
}
if (ValidationManager.HasErrors)
{
Storage.Add(Crate.FromContent(ValidationCrateLabel, ValidationManager.ValidationResults));
return(false);
}
return(true);
}
public async Task Run_Check_PayloadDTO_ForObjectData()
{
//Arrange
var authToken = await FixtureData.Salesforce_AuthToken();
var activityContext = await FixtureData.GetFileListTestActivityContext1();
var executionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
//perform initial configuration
await _getData_v1.Configure(activityContext);
activityContext = SelectSalesforceAccount(activityContext);
//perform follow up configuration
await _getData_v1.Configure(activityContext);
activityContext.ActivityPayload.CrateStorage.CratesOfType <StandardConfigurationControlsCM>()
.Single()
.Content.Controls.Single(control => control.Type == ControlTypes.QueryBuilder)
//.Value = JsonConvert.SerializeObject(new FilterDataDTO() {Conditions = new List<FilterConditionDTO>()});
.Value = JsonConvert.SerializeObject(new List <FilterConditionDTO>());
//Act
await _getData_v1.Run(activityContext, executionContext);
//Assert
var stroage = executionContext.PayloadStorage;
Assert.AreEqual(2, stroage.Count, "Number of Payload crates not populated correctly");
Assert.IsNotNull(stroage.CratesOfType <StandardTableDataCM>().Single(), "Not able to get the required salesforce object");
}
public override async Task RunChildActivities()
{
if (ConfigurationControls == null)
{
RaiseError("Action was not configured correctly");
}
var actionUi = new ActivityUi();
actionUi.ClonePropertiesFrom(ConfigurationControls);
// Real-time search.
var criteria = JsonConvert.DeserializeObject <List <FilterConditionDTO> >(actionUi.QueryBuilder.Value);
var existingEnvelopes = new HashSet <string>();
var searchResult = new StandardPayloadDataCM {
Name = "Docusign Report"
};
// Merge data from QueryMT action.
var queryMTResult = Payload.CrateContentsOfType <StandardPayloadDataCM>(x => x.Label == "Found MT Objects")
.FirstOrDefault();
MergeMtQuery(queryMTResult, existingEnvelopes, searchResult);
// Update report crate.
Payload.Add(Crate.FromContent("Sql Query Result", searchResult));
RequestClientActivityExecution("ShowTableReport");
}
private Crate <StandardQueryCM> ExtractQueryCrate(ICrateStorage storage)
{
var configurationControls = storage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.SingleOrDefault();
if (configurationControls == null)
{
throw new ApplicationException("Action was not configured correctly");
}
var actionUi = new ActivityUi();
actionUi.ClonePropertiesFrom(configurationControls);
var criteria = JsonConvert.DeserializeObject <List <FilterConditionDTO> >(
actionUi.QueryBuilder.Value
);
// This is weird to use query's name as the way to address MT type.
// MT type has unique ID that should be used for this reason. Query name is something that is displayed to user. It should not contain any internal data.
var queryCM = new StandardQueryCM(
new QueryDTO()
{
Name = MT.DocuSignEnvelope.GetEnumDisplayName(),
Criteria = criteria
}
);
return(Crate <StandardQueryCM> .FromContent(QueryCrateLabel, queryCM));
}
public static PayloadDTO PayloadDTO1()
{
var curFields = new List <KeyValueDTO>
{
new KeyValueDTO {
Key = "EnvelopeId", Value = "EnvelopeIdValue"
}
};
EventReportCM curEventReportMS = new EventReportCM();
curEventReportMS.EventNames = "DocuSign Envelope Sent";
curEventReportMS.Manufacturer = "DocuSign";
curEventReportMS.EventPayload.Add(Crate.FromContent("Standard Event Report", new StandardPayloadDataCM(curFields)));
var payload = new PayloadDTO(TestContainer_Id_1());
using (var crateStorage = ObjectFactory.GetInstance <ICrateManager>().GetUpdatableStorage(payload))
{
crateStorage.Add(Crate.FromContent("Standard Event Report", curEventReportMS));
}
AddOperationalStateCrate(payload);
return(payload);
}
public async Task <Crate> ProcessUserEvents(IContainer container, string curExternalEventPayload)
{
var media = JsonConvert.DeserializeObject <InstagramMedia>(curExternalEventPayload.Substring(1, curExternalEventPayload.Length - 2));
if (media.Object != "user")
{
throw new Exception("Unknown event source");
}
var instagramEventCM = new InstagramUserEventCM
{
MediaId = media.MediaData.MediaId,
UserId = media.ObjectId,
Time = media.Time,
SubscriptionId = media.SubscriptionId,
ChangedAspect = media.ChangedAspect
};
var eventReportContent = new EventReportCM
{
EventNames = string.Join(",", instagramEventCM.ChangedAspect),
ExternalAccountId = instagramEventCM.UserId,
EventPayload = new CrateStorage(Crate.FromContent("Instagram user event", instagramEventCM)),
Manufacturer = "Instagram"
};
////prepare the event report
var curEventReport = Crate.FromContent("Instagram user event", eventReportContent);
return(curEventReport);
}
public StandardTableDataCM GetExcelFile(byte[] fileAsByteArray, string selectedFilePath, bool isFirstRowAsColumnNames = true, string sheetName = null)
{
var ext = Path.GetExtension(selectedFilePath);
// Read file from repository
// Fetch column headers in Excel file
var headersArray = GetColumnHeaders(fileAsByteArray, ext, sheetName);
// Fetch rows in Excel file
var rowsDictionary = GetTabularData(fileAsByteArray, ext, isFirstRowAsColumnNames, sheetName);
Crate curExcelPayloadRowsCrateDTO = null;
if (rowsDictionary != null && rowsDictionary.Count > 0)
{
var rows = CreateTableCellPayloadObjects(rowsDictionary, headersArray, isFirstRowAsColumnNames);
if (rows != null && rows.Count > 0)
{
curExcelPayloadRowsCrateDTO = Crate.FromContent("Excel Payload Rows", new StandardTableDataCM(isFirstRowAsColumnNames, rows.ToArray()));
}
}
var curStandardTableDataMS = (curExcelPayloadRowsCrateDTO != null) ?
curExcelPayloadRowsCrateDTO.Get <StandardTableDataCM>()
: new StandardTableDataCM();
return(curStandardTableDataMS);
}
public async Task <List <Crate> > ProcessUserEvents(IContainer container, string curExternalEventPayload)
{
var notification = JsonConvert.DeserializeObject <UserNotification>(curExternalEventPayload);
if (notification.Object != "user")
{
throw new Exception("Unknown event source");
}
var eventList = new List <Crate>();
foreach (var entry in notification.Entry)
{
var fbEventCM = new FacebookUserEventCM
{
Id = entry.Id,
ChangedFields = entry.ChangedFields,
Time = entry.Time,
UserId = entry.Uid
};
var eventReportContent = new EventReportCM
{
EventNames = string.Join(",", fbEventCM.ChangedFields),
EventPayload = new CrateStorage(Crate.FromContent("Facebook user event", fbEventCM)),
Manufacturer = "Facebook",
ExternalAccountId = fbEventCM.UserId
};
////prepare the event report
var curEventReport = Crate.FromContent("Facebook user event", eventReportContent);
eventList.Add(curEventReport);
}
return(eventList);
}
public static ICrateStorage GetEnvelopePayload()
{
var curDocuSignEnvelopeInfo = DocuSignEventParser.GetEnvelopeInformation(EnvelopePayload);
var content = DocuSignEventParser.ParseXMLintoCM(curDocuSignEnvelopeInfo);
return(new CrateStorage(Crate.FromContent("DocuSign Connect Event", content)));
}
public override async Task Run()
{
try
{
var message = await _basecampApiClient.CreateMessage(
ActivityUI.AccountSelector.Value,
ActivityUI.ProjectSelector.Value,
ActivityUI.MessageSubject.TextValue,
ActivityUI.MessageContent.TextValue,
AuthorizationToken)
.ConfigureAwait(false);
Payload.Add(Crate.FromContent(RuntimeCrateLabel, new StandardPayloadDataCM(new KeyValueDTO {
Key = "id", Value = message.Id.ToString()
},
new KeyValueDTO {
Key = "subject", Value = message.Subject
},
new KeyValueDTO {
Key = "content", Value = message.Content
})));
}
catch (Exception ex)
{
Logger.GetLogger().Error($"Failed to create new message. Basecamp user - {AuthorizationToken.ExternalAccountName}, Fr8 User Id - {CurrentUserId}, Details - {ex}");
throw;
}
}
private Crate <StandardQueryCM> ExtractQueryCrate(string mtObject)
{
var configurationControls = Storage
.CrateContentsOfType <StandardConfigurationControlsCM>()
.SingleOrDefault();
if (configurationControls == null)
{
throw new ApplicationException("Action was not configured correctly");
}
var actionUi = new ActionUi();
actionUi.ClonePropertiesFrom(configurationControls);
var criteria = JsonConvert.DeserializeObject <List <FilterConditionDTO> >(
actionUi.QueryBuilder.Value
);
var queryCM = new StandardQueryCM(
new QueryDTO()
{
Name = mtObject,
Criteria = criteria
}
);
return(Crate <StandardQueryCM> .FromContent(QueryCrateLabel, queryCM));
}
private ContainerExecutionContext CreateContainerExecutionContext()
{
return(new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent("", new OperationalStateCM()))
});
}
public Task <Crate> Process(string externalEventPayload)
{
if (string.IsNullOrEmpty(externalEventPayload))
{
return(null);
}
externalEventPayload = externalEventPayload.Trim('\"');
var payloadFields = ParseSlackPayloadData(externalEventPayload);
//This is for backwards compatibility. Messages received from Slack RTM mechanism will contain the owner of subscription whereas messegas received from WebHooks not
var userName = payloadFields.FirstOrDefault(x => x.Key == "owner_name")?.Value ?? payloadFields.FirstOrDefault(x => x.Key == "user_name")?.Value;
var teamId = payloadFields.FirstOrDefault(x => x.Key == "team_id")?.Value;
if (string.IsNullOrEmpty(userName) && string.IsNullOrEmpty(teamId))
{
return(null);
}
var eventReportContent = new EventReportCM
{
EventNames = "Slack Outgoing Message",
EventPayload = WrapPayloadDataCrate(payloadFields),
ExternalAccountId = userName,
//Now plans won't be run for entire team but rather for specific user again
//ExternalDomainId = teamId,
Manufacturer = "Slack",
};
var curEventReport = Crate.FromContent("Standard Event Report", eventReportContent);
return(Task.FromResult((Crate)curEventReport));
}
public async Task Run_WhenNoChatterSourceIsSelected_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);
activityContext.ActivityPayload.CrateStorage.UpdateControls <Post_To_Chatter_v2.ActivityUi>(x =>
{
x.FeedTextSource.TextValue = "message";
x.FeedTextSource.ValueSource = "specific";
});
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 chatter is not specified is empty");
}
public override Task Run()
{
var selectedForm = ActivityUI.FormsList.Value;
if (string.IsNullOrEmpty(selectedForm))
{
RaiseError("Form is not selected", ActivityErrorCode.DESIGN_TIME_DATA_MISSING);
}
var payloadFields = ExtractPayloadFields(Payload);
// once we activate the plan we run it. When we run the plan manualy there is no payload with event data.
// Just return Success as a quick fix to avoid "Plan Failed" message.
if (payloadFields == null)
{
RequestPlanExecutionTermination();
return(Task.FromResult(0));
}
var formResponseFields = CreatePayloadFormResponseFields(payloadFields);
// once we activate the plan we run it. When we run the plan manualy there is no payload with event data.
// Just return Success as a quick fix to avoid "Plan Failed" message.
if (formResponseFields == null)
{
RequestPlanExecutionTermination();
return(Task.FromResult(0));;
}
Payload.Add(Crate.FromContent(RunTimeCrateLabel, new StandardPayloadDataCM(formResponseFields)));
return(Task.FromResult(0));
}
public override async Task Run()
{
var findObjectHelper = new FindObjectHelper();
var columnTypes = await findObjectHelper.ExtractColumnTypes(HubCommunicator, ActivityContext);
if (columnTypes == null)
{
RaiseError("No column types crate found.");
return;
}
var queryPayloadValue = ExtractSqlQuery();
if (queryPayloadValue == null)
{
RaiseError("No Sql Query payload crate found.");
return;
}
var connectionString = await ExtractConnectionString();
var query = BuildQuery(connectionString, queryPayloadValue, columnTypes);
var dbProvider = DbProvider.GetDbProvider(DefaultDbProvider);
var data = dbProvider.ExecuteQuery(query);
var payloadCM = BuildStandardPayloadData(data, columnTypes);
var payloadCMCrate = Crate.FromContent("Sql Query Result", payloadCM);
Payload.Add(payloadCMCrate);
Success();
}
//if the user provides a file name, this action attempts to load the excel file and extracts the column headers from the first sheet in the file.
public override async Task FollowUp()
{
var uploadFilePath = GetUploadFilePath();
string fileName = null;
if (!string.IsNullOrEmpty(uploadFilePath))
{
fileName = ExtractFileName(uploadFilePath);
}
else
{
var labelControl = Storage.CrateContentsOfType <StandardConfigurationControlsCM>()
.First()
.Controls
.FirstOrDefault(x => x.Value != null && x.Value.StartsWith("Uploaded file: "));
if (labelControl != null)
{
fileName = labelControl.Value.Substring("Uploaded file: ".Length);
}
}
Storage.Remove <StandardConfigurationControlsCM>();
AddControls(new ActivityUi(fileName, uploadFilePath).Controls);
if (!string.IsNullOrEmpty(uploadFilePath))
{
var generatedTable = CreateStandardTableDataCM();
var tableCrate = Crate.FromContent(DataTableLabel, generatedTable);
Storage.Add(tableCrate);
}
}
public static List <Crate> TestCrateDTO3()
{
return(new List <Crate>
{
Crate.FromContent("Crate1", new CrateDescriptionCM
{
CrateDescriptions =
{
new CrateDescriptionDTO
{
Label = "Crate2",
Availability = AvailabilityType.Always,
Fields =
{
new FieldDTO("Text 5"),
new FieldDTO("Doctor"),
new FieldDTO("Condition"),
}
}
}
}),
Crate.FromContent("CrateId2", new StandardConfigurationControlsCM()),
Crate.FromContent("CrateId3", new DocuSignRecipientCM()),
Crate.FromContent("CrateId4", new EventSubscriptionCM()),
Crate.FromContent("CrateId5", new StandardFileListCM())
});
}
public async Task Run_WhenValidationSucceeds_MapsControlsValuesToDocuSignTemplateFieldsAndSendEmail()
{
var activity = ObjectFactory.GetInstance <Send_DocuSign_Envelope_v2>();
var context = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload {
CrateStorage = new CrateStorage()
},
AuthorizationToken = FakeToken
};
await activity.Configure(context);
context.ActivityPayload.CrateStorage.UpdateControls <Send_DocuSign_Envelope_v2.ActivityUi>(x => x.TemplateSelector.SelectByValue("1"));
await activity.Configure(context);
context.ActivityPayload.CrateStorage.UpdateControls <Send_DocuSign_Envelope_v2.ActivityUi>(x =>
{
x.CheckBoxFields[0].Selected = true;
x.DropDownListFields[0].SelectByKey("Value");
x.RadioButtonGroupFields[0].Radios[0].Selected = true;
x.RolesFields[0].TextValue = "*****@*****.**";
x.TextFields[0].TextValue = "value";
});
ObjectFactory.GetInstance <Mock <IDocuSignManager> >().Setup(x => x.SendAnEnvelopeFromTemplate(It.IsAny <DocuSignApiConfiguration>(), It.IsAny <List <KeyValueDTO> >(), It.IsAny <List <KeyValueDTO> >(), It.IsAny <string>(), It.IsAny <StandardFileDescriptionCM>()))
.Callback <DocuSignApiConfiguration, List <KeyValueDTO>, List <KeyValueDTO>, string, StandardFileDescriptionCM>(AssertEnvelopeParameters);
await activity.Run(context, new ContainerExecutionContext()
{
ContainerId = Guid.NewGuid(), PayloadStorage = new CrateStorage(Crate.FromContent("", new OperationalStateCM()))
});
ObjectFactory.GetInstance <Mock <IDocuSignManager> >().Verify(x => x.SendAnEnvelopeFromTemplate(It.IsAny <DocuSignApiConfiguration>(), It.IsAny <List <KeyValueDTO> >(), It.IsAny <List <KeyValueDTO> >(), It.IsAny <string>(), null),
Times.Once(),
"Run didn't send DocuSign envelope");
}
/// <summary>
/// Get or sets value of configuration field with the given key stored in current activity storage
/// </summary>
/// <param name="key"></param>
/// <returns></returns>
protected string this[string key]
{
get
{
CheckCurrentActivityStorageAvailability();
var crate = Storage.FirstCrateOrDefault <FieldDescriptionsCM>(x => x.Label == ConfigurationValuesCrateLabel);
return(crate?.Content.Fields.FirstOrDefault(x => x.Key == key)?.Value);
}
set
{
CheckCurrentActivityStorageAvailability();
var crate = Storage.FirstCrateOrDefault <FieldDescriptionsCM>(x => x.Label == ConfigurationValuesCrateLabel);
if (crate == null)
{
crate = Crate <FieldDescriptionsCM> .FromContent(ConfigurationValuesCrateLabel, new FieldDescriptionsCM(), AvailabilityType.Configuration);
Storage.Add(crate);
}
var field = crate.Content.Fields.FirstOrDefault(x => x.Key == key);
if (field == null)
{
field = new FieldDTO(key, AvailabilityType.Configuration);
crate.Content.Fields.Add(field);
}
field.Value = value;
Storage.ReplaceByLabel(crate);
}
}
public async Task Run_ShouldPostToFacebook()
{
var fbIntegrationService = new Mock <IFacebookIntegration>();
fbIntegrationService.Setup(x => x.PostToTimeline(It.IsAny <string>(), It.IsAny <string>())).Returns(Task.FromResult(0));
ObjectFactory.Container.Inject(typeof(IFacebookIntegration), fbIntegrationService.Object);
var activity = New <Post_To_Timeline_v1>();
//Arrage
var activityContext = await ConfigurePostToTimeline(activity);
var containerExecutionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
var controls = activityContext.ActivityPayload.CrateStorage.CratesOfType <StandardConfigurationControlsCM>().Single();
var smsNumber = controls.Content.Controls.OfType <TextSource>().Single(t => t.Name.Equals("Message"));
smsNumber.TextValue = "Test";
//Act
containerExecutionContext = await RunPostToTimeline(activity, activityContext, containerExecutionContext);
var operationalStateCM = containerExecutionContext.PayloadStorage.CrateContentsOfType <OperationalStateCM>().Single();
Assert.True(operationalStateCM.CurrentActivityResponse.Type == ActivityResponse.Success.ToString(), "Post_To_Timeline_v1 doesn't return success when everything is ok");
fbIntegrationService.Verify(x => x.PostToTimeline(It.IsAny <string>(), It.IsAny <string>()), Times.Once);
}
private async Task ProcessFilePickers(IEnumerable <ControlDefinitionDTO> filepickers)
{
int labeless_pickers = 0;
foreach (FilePicker filepicker in filepickers)
{
var uploadFilePath = filepicker.Value;
byte[] file = null;
switch (GetUriFileExtension(uploadFilePath))
{
case ".xlsx":
file = await ProcessExcelFile(uploadFilePath);
break;
}
if (file == null)
{
continue;
}
string crate_label = GetFileDescriptionLabel(filepicker, labeless_pickers);
var fileDescription = new StandardFileDescriptionCM
{
Filename = Path.GetFileName(uploadFilePath),
TextRepresentation = Convert.ToBase64String(file),
Filetype = Path.GetExtension(uploadFilePath)
};
Payload.Add(Crate.FromContent(crate_label, fileDescription));
}
}
public override async Task Run()
{
ActivityUI.RestoreCustomFields(Storage);
var issueInfo = ExtractIssueInfo();
await _atlassianService.CreateIssue(issueInfo, AuthorizationToken);
var credentialsDTO = JsonConvert.DeserializeObject <CredentialsDTO>(AuthorizationToken.Token);
var jiraUrl = $"{credentialsDTO.Domain}/browse/{issueInfo.Key}";
Payload.Add(Crate.FromContent("jira issue", new StandardPayloadDataCM(new KeyValueDTO()
{
Key = "jira issue key", Value = issueInfo.Key
})));
Payload.Add(Crate.FromContent("jira issue", new StandardPayloadDataCM(new KeyValueDTO()
{
Key = "jira domain", Value = credentialsDTO.Domain
})));
await _pushNotificationService.PushUserNotification(MyTemplate, "Jira Issue Created", $"Created new jira issue: {jiraUrl}");
Payload.Add(Crate <KeyValueListCM> .FromContent(RuntimeCrateLabel, new KeyValueListCM(
new KeyValueDTO(JiraIdField, issueInfo.Key),
new KeyValueDTO(JiraUrlField, jiraUrl))));
}
