/**********************************************************************************/
/// <summary>
/// Convert crate to DTO
/// </summary>
/// <param name="crate"></param>
/// <returns></returns>
public CrateDTO ConvertToDto(Crate crate)
{
if (crate == null)
{
return(null);
}
IManifestSerializer serializer = GetSerializer(crate.ManifestType);
CrateDTO crateDto = new CrateDTO
{
Id = crate.Id,
Label = crate.Label,
ManifestId = crate.ManifestType.Id,
ManifestType = crate.ManifestType.Type,
SourceActivityId = crate.SourceActivityId
};
if (serializer != null)
{
crateDto.Contents = serializer.Serialize(crate.Get <object>());
}
else
{
crateDto.Contents = crate.GetRaw();
}
return(crateDto);
}
public async Task Events_NotStandardEventReport_ThrowsException()
{
var crateDTO = new CrateDTO();
var result = await _eventController.Post(crateDTO);
Assert.IsTrue(result is BadRequestErrorMessageResult, "Post method was expected to return BadRequest (code 400) for empty payload");
}
/**********************************************************************************/
/// <summary>
/// Convert DTO to Crate instance
/// </summary>
/// <param name="proxy"></param>
/// <returns></returns>
public Crate ConvertFromDto(CrateDTO proxy)
{
if (proxy == null)
{
return(null);
}
var manifestType = new CrateManifestType(proxy.ManifestType, proxy.ManifestId);
IManifestSerializer serializer = GetSerializer(manifestType);
Crate crate;
if (serializer != null)
{
var content = proxy.Contents != null?serializer.Deserialize(proxy.Contents) : null;
if (content != null)
{
crate = Crate.FromContent(content, proxy.Id);
}
else
{
crate = new Crate(manifestType, proxy.Id);
}
}
else
{
crate = Crate.FromJson(manifestType, proxy.Id, proxy.Contents);
}
crate.Label = proxy.Label;
crate.SourceActivityId = proxy.SourceActivityId;
return(crate);
}
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 async Task RunPlan(Guid planId, IEnumerable <Crate> payload)
{
var url = $"{GetHubUrlWithApiVersion()}/plans/run?planId=" + planId;
var uri = new Uri(url);
var cratesDto = new CrateDTO[0];
if (payload != null)
{
cratesDto = payload.Select(x => CrateStorageSerializer.Default.ConvertToDto(x)).ToArray();
}
await _restfulServiceClient.PostAsync(uri, cratesDto);
}
public static ProcessTemplateDO TestProcessTemplateWithSubscribeEvent()
{
ProcessTemplateDO processTemplateDO;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
DockyardAccountDO testUser = TestDockyardAccount1();
uow.UserRepository.Add(testUser);
processTemplateDO = new ProcessTemplateDO()
{
Id = 23,
Description = "HealthDemo Integration Test",
Name = "StandardEventTesting",
ProcessTemplateState = ProcessTemplateState.Active,
DockyardAccount = testUser
};
uow.ProcessTemplateRepository.Add(processTemplateDO);
var actionTemplate = ActionTemplate();
var processDo = new ContainerDO()
{
Id = 1,
CrateStorage = EnvelopeIdCrateJson(),
ProcessTemplateId = processTemplateDO.Id,
ContainerState = 1
};
uow.ContainerRepository.Add(processDo);
ProcessNodeTemplateDO processNodeTemplateDO = new ProcessNodeTemplateDO()
{
ParentActivity = processTemplateDO,
StartingProcessNodeTemplate = true
};
uow.ProcessNodeTemplateRepository.Add(processNodeTemplateDO);
processTemplateDO.Activities = new List <ActivityDO> {
processNodeTemplateDO
};
processTemplateDO.StartingProcessNodeTemplate = processNodeTemplateDO;
var actionDo = new ActionDO()
{
ParentActivity = processTemplateDO,
ParentActivityId = processTemplateDO.Id,
ActionState = ActionState.Unstarted,
Name = "testaction",
Id = 1,
ActivityTemplateId = actionTemplate.Id,
ActivityTemplate = actionTemplate,
Ordering = 1
};
ICrate crate = ObjectFactory.GetInstance <ICrate>();
var serializer = new JsonSerializer();
EventSubscriptionCM eventSubscriptionMS = new EventSubscriptionCM();
eventSubscriptionMS.Subscriptions = new List <string>();
eventSubscriptionMS.Subscriptions.Add("DocuSign Envelope Sent");
eventSubscriptionMS.Subscriptions.Add("Write to SQL AZure");
var eventReportJSON = serializer.Serialize(eventSubscriptionMS);
CrateDTO crateDTO = crate.Create("Standard Event Subscriptions", eventReportJSON, "Standard Event Subscriptions");
actionDo.UpdateCrateStorageDTO(new List <CrateDTO>()
{
crateDTO
});
uow.ActionRepository.Add(actionDo);
processNodeTemplateDO.Activities.Add(actionDo);
uow.SaveChanges();
}
return(processTemplateDO);
}
public Crate FromDto(CrateDTO crate)
{
return(crate != null?CrateStorageSerializer.Default.ConvertFromDto(crate) : null);
}
public static Task ProcessEventsInternal(CrateDTO raw)
{
var curCrateStandardEventReport = ObjectFactory.GetInstance <ICrateManager>().FromDto(raw);
return(ObjectFactory.GetInstance <IEvent>().ProcessInboundEvents(curCrateStandardEventReport));
}
