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);
}
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 async Task Run_WhenNoMonitorOptionIsSelected_ReturnsValidationError()
{
var activity = New <Monitor_Channel_v2>();
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = AuthorizationToken
};
var executionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
await activity.Configure(activityContext);
var configurationControls = activityContext.ActivityPayload.CrateStorage.FirstCrate <StandardConfigurationControlsCM>().Content;
configurationControls.FindByNameNested <CheckBox>("MonitorChannelsOption").Selected = false;
configurationControls.FindByNameNested <RadioButtonOption>("AllChannelsOption").Selected = false;
await activity.Run(activityContext, executionContext);
var operationalState = executionContext.PayloadStorage.FirstCrateContentOrDefault <OperationalStateCM>();
Assert.AreEqual(ActivityResponse.Error.ToString(), operationalState.CurrentActivityResponse.Type, "Error response was not produced when no monitor option was selected");
}
public async Task Run_WhenPayloadHasEventAndItPassFilters_ReturnsSuccess()
{
var activity = New <Monitor_Channel_v2>();
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = AuthorizationToken
};
var executionContext = new ContainerExecutionContext
{
PayloadStorage = HealthMonitor_FixtureData.GetDirectMessageEventPayload()
};
await activity.Configure(activityContext);
activityContext.ActivityPayload.CrateStorage.UpdateControls <Monitor_Channel_v2.ActivityUi>(x =>
{
x.MonitorDirectMessagesOption.Selected = true;
x.MonitorChannelsOption.Selected = false;
});
await activity.Run(activityContext, executionContext);
var operationalState = executionContext.PayloadStorage.FirstCrateContentOrDefault <OperationalStateCM>();
Assert.AreEqual(ActivityResponse.Success.ToString(), operationalState.CurrentActivityResponse.Type, "RequestTerminate response was not produced when event didn't match monitoring options");
Assert.IsNotNull(executionContext.PayloadStorage.FirstCrateOrDefault <StandardPayloadDataCM>(), "Activity didn't produce crate with payload data");
}
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");
}
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 async Task Run_ShouldTerminateExecutionWhenItCantFindPost()
{
var fbIntegrationService = new Mock <IFacebookIntegration>();
fbIntegrationService.Setup(x => x.GetPostById(It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(null);
ObjectFactory.Container.Inject(typeof(IFacebookIntegration), fbIntegrationService.Object);
var activity = New <Monitor_Feed_Posts_v1>();
//Arrage
var activityContext = await ConfigureMonitorFeedPosts(activity);
var fbEventCM = new FacebookUserEventCM
{
Id = "123",
ChangedFields = new string[] { "feed" },
Time = "123",
UserId = "123"
};
var eventReportCrate = new EventReportCM
{
EventNames = "feed",
EventPayload = new CrateStorage(Crate.FromContent("Facebook user event", fbEventCM))
};
var containerExecutionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()), Crate.FromContent("Facebook user event", eventReportCrate))
};
//Act
containerExecutionContext = await RunMonitorFeedPosts(activity, activityContext, containerExecutionContext);
var operationalStateCM = containerExecutionContext.PayloadStorage.CrateContentsOfType <OperationalStateCM>().Single();
Assert.True(operationalStateCM.CurrentActivityResponse.Type == ActivityResponse.RequestTerminate.ToString(), "Monitor_Feed_Posts_v1 doesn't terminate container execution when activity can't find related post on facebook");
}
public async Task Run_ShouldTerminateExecutionWhenChangedFieldIsNotFeed()
{
var activity = New <Monitor_Feed_Posts_v1>();
//Arrage
var activityContext = await ConfigureMonitorFeedPosts(activity);
var fbEventCM = new FacebookUserEventCM
{
Id = "123",
ChangedFields = new string[] { "test" },
Time = "123",
UserId = "123"
};
var eventReportCrate = new EventReportCM
{
EventNames = "feed",
EventPayload = new CrateStorage(Crate.FromContent("Facebook user event", fbEventCM))
};
var containerExecutionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()), Crate.FromContent("Facebook user event", eventReportCrate))
};
//Act
containerExecutionContext = await RunMonitorFeedPosts(activity, activityContext, containerExecutionContext);
var operationalStateCM = containerExecutionContext.PayloadStorage.CrateContentsOfType <OperationalStateCM>().Single();
Assert.True(operationalStateCM.CurrentActivityResponse.Type == ActivityResponse.RequestTerminate.ToString(), "Monitor_Feed_Posts_v1 doesn't terminate container execution when changed field doesn't contain feed");
}
public static ContainerExecutionContext ExecutionContextWithOnlyOperationalState()
{
var result = new ContainerExecutionContext()
{
ContainerId = Guid.NewGuid(),
PayloadStorage = new CrateStorage(Crate.FromContent("Operational State", new OperationalStateCM()))
};
return(result);
}
public async Task Run_SecondTimeForSameLog_WithOneUpstreamLogedMessage_LoggedAlready_ShouldLogOnlyOneTime()
{
//Arrange
//create initial and follow up configuration
var testAction = new ActivityContext()
{
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = null,
UserId = null
};
await _activity_under_test.Configure(testAction);
await _activity_under_test.Configure(testAction);
var executionContext = new ContainerExecutionContext();
executionContext.PayloadStorage = new CrateStorage(Crate.FromContent("", new OperationalStateCM()));
executionContext.PayloadStorage.Add("Log Messages", new StandardLoggingCM
{
Item = new List <LogItemDTO>()
{
new LogItemDTO()
{
Activity = "A", Data = "Test Log Message"
}
}
});
//log first time
await _activity_under_test.Run(testAction, executionContext);
//Act
//try to log the same message again
await _activity_under_test.Run(testAction, executionContext);
//Assert
var loggedMessge = executionContext.PayloadStorage.CrateContentsOfType <StandardLoggingCM>().Single();
Assert.IsNotNull(loggedMessge, "Logged message is missing from the payload");
Assert.AreEqual(1, loggedMessge.Item.Count, "Logged message is missing from the payload");
Assert.IsTrue(loggedMessge.Item[0].IsLogged, "Log did not happen");
Mock <IPapertrailLogger> papertrailLogger = Mock.Get(ObjectFactory.GetInstance <IPapertrailLogger>());
papertrailLogger.Verify(logger => logger.LogToPapertrail(It.IsAny <string>(), It.IsAny <int>(), "Test Log Message"), Times.Exactly(1));
papertrailLogger.VerifyAll();
}
public async Task Run_CheckSendCalledOnlyOnce()
{
//Arrage
_sendSmsActivity = New <Send_SMS_v1>();
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = new AuthorizationToken
{
Token = "1"
}
};
var containerExecutionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
await _sendSmsActivity.Configure(activityContext);
var controls = activityContext.ActivityPayload.CrateStorage.CratesOfType <StandardConfigurationControlsCM>().Single();
var smsNumber = controls.Content.Controls.OfType <TextSource>().Single(t => t.Name.Equals("SmsNumber"));
smsNumber.TextValue = "+918055967968"; //This is some dummy number. This number is not valid
var smsBody = controls.Content.Controls.OfType <TextSource>().Single(t => t.Name.Equals("SmsBody"));
smsBody.TextValue = "some body";
smsBody.ValueSource = smsNumber.ValueSource = "specific";
//Act
await _sendSmsActivity.Run(activityContext, containerExecutionContext);
//Assert
var messageDataCrate = containerExecutionContext.PayloadStorage.CratesOfType <StandardPayloadDataCM>().Single(p => p.Label.Equals("Message Data"));
Assert.IsNotNull(messageDataCrate, "Send SMS activity is not run.");
Assert.AreEqual(4, messageDataCrate.Content.AllValues().ToList().Count, "Message fields are not getting populated when Send SMS is executed.");
var twilioService = Mock.Get(ObjectFactory.GetInstance <ITwilioService>());
twilioService.Verify(t => t.SendSms(It.IsAny <string>(), It.IsAny <string>()));
}
public async Task Run_CheckSendCalledOnlyOnce()
{
//Arrage
_sendEmailActivity = New <Send_Email_v1>();
var activityContext = new ActivityContext
{
HubCommunicator = ObjectFactory.GetInstance <IHubCommunicator>(),
ActivityPayload = new ActivityPayload
{
CrateStorage = new CrateStorage()
},
AuthorizationToken = new AuthorizationToken
{
Token = "1"
}
};
var executionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
await _sendEmailActivity.Configure(activityContext);
var storage = activityContext.ActivityPayload.CrateStorage;
var controls = storage.CratesOfType <StandardConfigurationControlsCM>().Single();
var emailAddressControl = controls.Content.Controls.OfType <TextSource>().Single(t => t.Name.Equals("EmailAddress"));
emailAddressControl.TextValue = "*****@*****.**";
var subjectControl = controls.Content.Controls.OfType <TextSource>().Single(t => t.Name.Equals("EmailSubject"));
subjectControl.TextValue = "some subject";
var bodyControl = controls.Content.Controls.OfType <TextSource>().Single(t => t.Name.Equals("EmailBody"));
bodyControl.TextValue = "some body";
subjectControl.ValueSource = bodyControl.ValueSource = emailAddressControl.ValueSource = "specific";
//Act
await _sendEmailActivity.Run(activityContext, executionContext);
//Assert
var emailPackagerMock = Mock.Get(ObjectFactory.GetInstance <IEmailPackager>());
emailPackagerMock.Verify(p => p.Send(It.IsAny <TerminalMailerDO>()), Times.Once());
}
[Ignore] // this test expects that real SalesforceManager is created. Previouse is was the case because of inaccurate code
public async Task Run_CheckTheObjectIsCreated()
{
//Arrange
//perform initial and follow up config, activate
var result = await PerformInitialConfig();
var executionContext = new ContainerExecutionContext {
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
var authorizationToken = await FixtureData.Salesforce_AuthToken();
await _saveToSFDotCom_v1.Configure(result);
await _saveToSFDotCom_v1.Activate(result);
//make last name as Unit and Company Name as Test
var requiredControls = result.ActivityPayload.CrateStorage
.CratesOfType <StandardConfigurationControlsCM>().Single().Content
.Controls;
var lastNameControl = (TextSource)requiredControls.Single(c => c.Name.Equals("LastName"));
lastNameControl.ValueSource = "specific";
lastNameControl.TextValue = "Unit";
var companyControl = (TextSource)requiredControls.Single(c => c.Name.Equals("Company"));
companyControl.ValueSource = "specific";
companyControl.TextValue = "Text";
//Act
await _saveToSFDotCom_v1.Run(result, executionContext);
var payload = executionContext.PayloadStorage;
//Assert
var newlyCreatedLead = payload.CratesOfType <StandardPayloadDataCM>()
.Single().Content.PayloadObjects[0].PayloadObject;
Assert.IsNotNull(newlyCreatedLead, "Lead is not saved successfully in Save to SF.com");
Assert.IsTrue(newlyCreatedLead.Count == 1, "Lead is not saved successfully in Save to SF.com");
Assert.IsTrue(!string.IsNullOrEmpty(newlyCreatedLead[0].Value), "Lead is not saved successfully in Save to SF.com");
var isDeleted = await ObjectFactory.GetInstance <SalesforceManager>().Delete(SalesforceObjectType.Lead, newlyCreatedLead[0].Value, authorizationToken);
Assert.IsTrue(isDeleted, "The newly created lead is not deleted upon completion");
}
/**********************************************************************************/
// Functions
/**********************************************************************************/
private void InitializeInternalState(ActivityContext activityContext, ContainerExecutionContext containerExecutionContext)
{
_activityContext = activityContext;
_containerExecutionContext = containerExecutionContext;
if (_containerExecutionContext != null)
{
_operationalState = Payload.CrateContentsOfType <OperationalStateCM>().FirstOrDefault();
if (_operationalState == null)
{
throw new InvalidOperationException("Operational state crate is not found");
}
}
InitializeInternalState();
}
public async Task Run_WhenQueriesSalesforceAndNothingIsReturned_ReturnsSuccessButNoPayload()
{
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);
activity = New <Post_To_Chatter_v2>();
activityContext.ActivityPayload.CrateStorage.UpdateControls <Post_To_Chatter_v2.ActivityUi>(x =>
{
x.FeedTextSource.TextValue = "message";
x.FeedTextSource.ValueSource = "specific";
x.QueryForChatterOption.Selected = true;
x.ChatterFilter.Value = string.Empty;
x.ChatterSelector.selectedKey = SalesforceObjectType.Account.ToString();
});
ObjectFactory.GetInstance <Mock <ISalesforceManager> >().Setup(x => x.Query(It.IsAny <SalesforceObjectType>(), It.IsAny <IList <FieldDTO> >(), It.IsAny <string>(), It.IsAny <AuthorizationToken>()))
.Returns(Task.FromResult(new StandardTableDataCM {
Table = new List <TableRowDTO>()
}));
await activity.Run(activityContext, executionContext);
var payloadStorage = executionContext.PayloadStorage;
var operationalState = payloadStorage.FirstCrate <OperationalStateCM>().Content;
Assert.AreEqual(ActivityResponse.Success.ToString(), operationalState.CurrentActivityResponse.Type, "Run must return success if all values are specified");
var resultPayload = payloadStorage.FirstCrateOrDefault <StandardPayloadDataCM>();
Assert.IsNull(resultPayload, "Successfull run should not create standard payload data crate when no Salesforce objects exist");
}
public async Task Run_WhenQueriesSalesforceAndObjectsAreReturned_PostsToTheirChatters()
{
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);
activity = New <Post_To_Chatter_v2>();
activityContext.ActivityPayload.CrateStorage.UpdateControls <Post_To_Chatter_v2.ActivityUi>(x =>
{
x.FeedTextSource.TextValue = "message";
x.FeedTextSource.ValueSource = "specific";
x.QueryForChatterOption.Selected = true;
x.ChatterFilter.Value = string.Empty;
x.ChatterSelector.selectedKey = SalesforceObjectType.Account.ToString();
});
await activity.Run(activityContext, executionContext);
var payloadStorage = executionContext.PayloadStorage;
var operationalState = payloadStorage.FirstCrate <OperationalStateCM>().Content;
Assert.AreEqual(ActivityResponse.Success.ToString(), operationalState.CurrentActivityResponse.Type, "Run must return success if all values are specified");
var resultPayload = payloadStorage.FirstCrateOrDefault <StandardPayloadDataCM>();
Assert.IsNotNull(resultPayload, "Successfull run should create standard payload data crate when Salesforce objects exist");
Assert.AreEqual("feedid", resultPayload.Content.PayloadObjects[0].PayloadObject[0].Value, "Run didn't produce crate with proper posted feed Id");
}
public static ContainerExecutionContext FalseInstagramContainerExecutionContext()
{
var instagramEventCM = new InstagramUserEventCM
{
MediaId = "123",
UserId = "123",
ChangedAspect = "test",
Time = "123",
SubscriptionId = "123"
};
var eventReportCrate = new EventReportCM
{
EventNames = "media",
EventPayload = new CrateStorage(Crate.FromContent("Instagram user event", instagramEventCM))
};
var containerExecutionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()), Crate.FromContent("Instagram user event", eventReportCrate))
};
return(containerExecutionContext);
}
public async Task Run_Check_PayloadDTO_ForObjectData()
{
//Arrange
var activityContext = await FixtureData.GetFileListTestActivityContext2();
var executionContext = new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
//perform initial configuration
await postToChatter_v1.Configure(activityContext);
activityContext = SetValues(activityContext);
//Act
await postToChatter_v1.Run(activityContext, executionContext);
//Assert
var storage = executionContext.PayloadStorage;
Assert.IsNotNull(storage.FirstCrateOrDefault <StandardPayloadDataCM>(), "Payload doesn't contain crate with posted feed Id");
}
public static CrateStorageDTO CrateStorageDTOResolver(ContainerExecutionContext executionContext)
{
return(CrateStorageSerializer.Default.ConvertToDto(executionContext.PayloadStorage));
}
private async Task <ContainerExecutionContext> RunMonitorForNewMediaPosted(Monitor_For_New_Media_Posted_v1 activity,
ActivityContext context, ContainerExecutionContext containerExecutionContext = null)
{
containerExecutionContext = containerExecutionContext ?? new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
await activity.Run(context, containerExecutionContext);
return(containerExecutionContext);
}
/**********************************************************************************/
public Task RunChildActivities(ActivityContext activityContext, ContainerExecutionContext containerExecutionContext)
{
InitializeInternalState(activityContext, containerExecutionContext);
return(Run(RunChildActivities));
}
private async Task <ContainerExecutionContext> RunPostToTimeline(Post_To_Timeline_v1 activity,
ActivityContext context, ContainerExecutionContext containerExecutionContext = null)
{
containerExecutionContext = containerExecutionContext ?? new ContainerExecutionContext
{
PayloadStorage = new CrateStorage(Crate.FromContent(string.Empty, new OperationalStateCM()))
};
await activity.Run(context, containerExecutionContext);
return(containerExecutionContext);
}
private PayloadDTO SerializeResponse(ContainerExecutionContext activityContext)
{
return(Mapper.Map <PayloadDTO>(activityContext));
}
public static CrateStorageDTO CrateStorageDTOResolver(ContainerExecutionContext executionContext)
{
var crateManager = ObjectFactory.GetInstance <ICrateManager>();
return(crateManager.ToDto(executionContext.PayloadStorage));
}
