public async Task <IHttpActionResult> Post(CrateDTO raw)
{
if (raw == null)
{
return(BadRequest("Crate object is not specified"));
}
var curCrateStandardEventReport = _crate.FromDto(raw);
if (!curCrateStandardEventReport.IsOfType <EventReportCM>())
{
return(BadRequest("Crate object doesn't contain EventReportCM manifest"));
}
if (curCrateStandardEventReport.Get() == null)
{
return(BadRequest("Crate content is empty"));
}
var eventReportMS = curCrateStandardEventReport.Get <EventReportCM>();
Logger.GetLogger().Info($"Crate {raw.Id} with incoming event '{eventReportMS.EventNames}' is received for external account '{eventReportMS.ExternalAccountId}'");
if (eventReportMS.EventPayload == null)
{
return(BadRequest("EventReport can't have a null payload"));
}
if (string.IsNullOrEmpty(eventReportMS.ExternalAccountId) && string.IsNullOrEmpty(eventReportMS.ExternalDomainId))
{
return(BadRequest("EventReport can't have both ExternalAccountId and ExternalDomainId empty"));
}
_jobDispatcher.Enqueue(() => ProcessEventsInternal(raw));
return(Ok());
}
public static ICrateStorage GetStorage(this ICrateManager crateManager, string crateStorageRaw)
{
if (string.IsNullOrWhiteSpace(crateStorageRaw))
{
return(new CrateStorage());
}
return(crateManager.FromDto(StringToCrateStorageDTOConverter.Convert(crateStorageRaw)));
}
public static ICrateStorage GetStorage(this ICrateManager crateManager, CrateStorageDTO crateStorageDTO)
{
if (crateStorageDTO == null)
{
return(new CrateStorage());
}
return(crateManager.FromDto(crateStorageDTO));
}
public async Task HandleFr8Request_Configure_ReturnsActivityDTO()
{
var result = await _activityExecutor.HandleFr8Request(
"configure",
null,
Fixture_HandleRequest.terminalMockFr8DataDTO()
);
Assert.IsNotNull(result);
Assert.IsInstanceOf(typeof(ActivityDTO), result);
var crateStorage = CrateManagerHelper.FromDto(((ActivityDTO)result).CrateStorage);
Assert.NotNull(crateStorage);
//var crateResult = crateStorage.CrateContentsOfType<StandardConfigurationControlsCM>().SingleOrDefault();
//Assert.Greater(crateResult.Controls.Count(x => x.Label.ToLower() == "configure"), 0);
}
public async Task <List <Crate <TManifest> > > GetCratesByDirection <TManifest>(Guid activityId, CrateDirection direction)
{
var directionSuffix = direction == CrateDirection.Upstream
? "upstream"
: "downstream";
var uri = new Uri($"{GetHubUrlWithApiVersion()}/plan_nodes?id={activityId}&direction={directionSuffix}", UriKind.Absolute);
var curActivities = await _restfulServiceClient.GetAsync <List <ActivityDTO> >(uri, null, await GetHMACHeader(uri));
var curCrates = new List <Crate <TManifest> >();
foreach (var curAction in curActivities)
{
var storage = _crate.FromDto(curAction.CrateStorage);
curCrates.AddRange(storage.CratesOfType <TManifest>());
}
return(curCrates);
}
public async Task <IHttpActionResult> Run(Guid planId, [FromBody] CrateDTO[] payload)
{
Crate[] crates = null;
if (payload != null)
{
crates = payload.Select(c => _crate.FromDto(c)).ToArray();
}
var result = await _plan.Run(planId, crates, null);
if (result == null)
{
return(BadRequest());
}
return(Ok(result));
}
/**********************************************************************************/
// 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());
}
}
public static ICrateStorage GetStorage(this ICrateManager crateManager, PayloadDTO payload)
{
return(crateManager.FromDto(payload.CrateStorage));
}
public static ICrateStorage GetStorage(this ICrateManager crateManager, ActivityDTO activity)
{
return(crateManager.FromDto(activity.CrateStorage));
}
public void FromNullCrateStorageDTO_ReturnsEmptyStorage()
{
Assert.AreEqual(_crateManager.FromDto((CrateStorageDTO)null).Count, 0);
}
