protected override void Run(Guid id, ActivityExecutionMode executionMode)
{
if (executionMode == ActivityExecutionMode.InitialRun)
{
int?index = OperationalState.CallStack.GetLocalData <int?>("Loop");
if (index == null)
{
index = 0;
}
else
{
index++;
}
OperationalState.CallStack.StoreLocalData("Loop", index);
if (index >= _count)
{
RequestSkipChildren();
}
}
else
{
RequestJumpToActivity(id);
}
}
/**********************************************************************************/
public void Run(Guid id, ActivityExecutionMode executionMode, PayloadDTO payloadDto)
{
using (var storage = _crateManager.UpdateStorage(() => payloadDto.CrateStorage))
{
OperationalState = storage.CrateContentsOfType <OperationalStateCM>().First();
Run(id, executionMode);
}
}
protected override void Run(Guid id, ActivityExecutionMode executionMode)
{
if (_firstCall)
{
_firstCall = false;
OperationalState.CallStack.StoreLocalData("Suspend", "data");
RequestHubExecutionSuspension("Hey, wait for me!");
}
else
{
Assert.AreEqual("data", OperationalState.CallStack.GetLocalData <string>("Suspend"), "Local data is missing");
}
}
protected override void Run(Guid id, ActivityExecutionMode executionMode)
{
_index++;
if (_index <= 1)
{
OperationalState.CallStack.StoreLocalData("Jump", "data");
RequestJumpToActivity(id);
}
else
{
Assert.AreEqual("data", OperationalState.CallStack.GetLocalData <string>("Jump"), "Local data is missing");
}
}
public Task <PayloadDTO> Run(IUnitOfWork uow, ActivityDO curActivityDO, ActivityExecutionMode curActionExecutionMode, ContainerDO curContainerDO)
{
ActivityMockBase activity;
var payload = new PayloadDTO(curContainerDO.Id)
{
CrateStorage = CrateStorageSerializer.Default.ConvertToDto(CrateStorageSerializer.Default.ConvertFromDto(JsonConvert.DeserializeObject <CrateStorageDTO>(curContainerDO.CrateStorage)))
};
ExecutedActivities.Add(new ActivityExecutionCall(curActionExecutionMode, curActivityDO.Id));
if (CustomActivities.TryGetValue(curActivityDO.Id, out activity))
{
activity.Run(curActivityDO.Id, curActionExecutionMode, payload);
}
return(Task.FromResult(payload));
}
public async Task <PayloadDTO> Run(IUnitOfWork uow, ActivityDO curActivityDO, ActivityExecutionMode curActionExecutionMode, ContainerDO curContainerDO)
{
if (PlanTreeHelper.Linearize(_planNodes[curActivityDO.Id]).OfType <ActivityDO>().Any(x => x.Id == curActivityDO.Id))
{
Processed++;
}
await Task.Delay(1);
return(await _activity.Run(uow, curActivityDO, curActionExecutionMode, curContainerDO));
}
protected override void Run(Guid id, ActivityExecutionMode executionMode)
{
RequestCall(_jumopTo);
}
/**********************************************************************************/
// Executes node is passed if it is an activity
private async Task ExecuteNode(PlanNodeDO currentNode, IUpdatableCrateStorage payloadStorage, ActivityExecutionMode mode)
{
var currentActivity = currentNode as ActivityDO;
if (currentActivity == null)
{
return;
}
_utilizationMonitoringService.TrackActivityExecution(currentActivity, _container);
var payload = await _activity.Run(_uow, currentActivity, mode, _container);
if (payload != null)
{
var activityPayloadStroage = _crate.FromDto(payload.CrateStorage);
SyncPayload(activityPayloadStroage, payloadStorage, currentActivity.Id.ToString());
}
}
/**********************************************************************************/
protected virtual void Run(Guid id, ActivityExecutionMode executionMode)
{
}
public ActivityExecutionCall(ActivityExecutionMode mode, Guid id)
{
Mode = mode;
Id = id;
}
protected override void Run(Guid id, ActivityExecutionMode executionMode)
{
RequestJumpToSubplan(_jumopTo);
}
public async Task <PayloadDTO> Run(IUnitOfWork uow, ActivityDO curActivityDO, ActivityExecutionMode curActionExecutionMode, ContainerDO curContainerDO)
{
if (curActivityDO == null)
{
throw new ArgumentNullException(nameof(curActivityDO));
}
//FR-2642 Logic to skip execution of activities with "SkipAtRunTime" Tag
var template = _activityTemplate.GetByKey(curActivityDO.ActivityTemplateId);
if (template.Tags != null && template.Tags.Contains("SkipAtRunTime", StringComparison.InvariantCultureIgnoreCase))
{
return(null);
}
EventManager.ActionStarted(curActivityDO, curContainerDO);
// Explicitly extract authorization token to make AuthTokenDTO pass to activities.
curActivityDO.AuthorizationToken = uow.AuthorizationTokenRepository.FindTokenById(curActivityDO.AuthorizationTokenId);
try
{
IEnumerable <KeyValuePair <string, string> > parameters = null;
if (curActionExecutionMode != ActivityExecutionMode.InitialRun)
{
parameters = new List <KeyValuePair <string, string> >()
{
new KeyValuePair <string, string>("scope", "childActivities")
};
}
if (curActionExecutionMode != ActivityExecutionMode.ReturnFromChildren)
{
EventManager.ActivityRunRequested(curActivityDO, curContainerDO);
}
var activtiyClone = (ActivityDO)curActivityDO.Clone();
using (var storage = _crateManager.UpdateStorage(() => activtiyClone.CrateStorage))
{
var configurationControls = storage.CrateContentsOfType <StandardConfigurationControlsCM>().FirstOrDefault();
if (configurationControls != null)
{
var payloadStorage = _crateManager.GetStorage(curContainerDO.CrateStorage);
_upstreamDataExtractionService.ExtactAndAssignValues(configurationControls, payloadStorage);
}
}
var payloadDTO = await CallTerminalActivityAsync <PayloadDTO>(uow, "run", parameters, activtiyClone, curContainerDO.Id);
EventManager.ActivityResponseReceived(curActivityDO, ActivityResponse.RequestSuspend);
return(payloadDTO);
}
catch (Exception e)
{
ReportActivityInvocationError(curActivityDO, e.Message, curContainerDO.Id.ToString(), curActivityDO.Id.ToString(), EventManager.TerminalRunFailed);
throw;
}
}
