public bool IsMonitoringPlan(IUnitOfWork uow, PlanDO plan)
{
var solutionId = ActivityCategories.SolutionId;
var monitorId = ActivityCategories.MonitorId;
var initialActivity = plan.StartingSubplan.GetDescendantsOrdered()
.OfType <ActivityDO>()
.FirstOrDefault(x => !uow.ActivityTemplateRepository.GetByKey(x.ActivityTemplateId).Categories.Any(y => y.ActivityCategoryId == solutionId));
if (initialActivity == null)
{
return(false);
}
var activityTemplate = uow.ActivityTemplateRepository.GetByKey(initialActivity.ActivityTemplateId);
if (activityTemplate.Categories.Any(y => y.ActivityCategoryId == monitorId))
{
return(true);
}
var storage = _crate.GetStorage(initialActivity.CrateStorage);
// First activity has event subsribtions. This means that this plan can be triggered by external event
if (storage.CrateContentsOfType <EventSubscriptionCM>().Any(x => x.Subscriptions?.Count > 0))
{
return(true);
}
return(false);
}
/**********************************************************************************/
private void LoadAndRunPlan(Guid planId)
{
var plan = ObjectFactory.GetInstance <IPlan>();
var planDO = _uow.PlanRepository.GetById <PlanDO>(planId);
if (planDO == null)
{
throw new InvalidOperationException($"Plan {planId} was not found");
}
var crateStorage = _crate.GetStorage(_container.CrateStorage);
var operationStateCrate = crateStorage.CrateContentsOfType <OperationalStateCM>().Single();
operationStateCrate.CurrentActivityResponse = ActivityResponseDTO.Create(ActivityResponse.Null);
operationStateCrate.History.Add(new OperationalStateCM.HistoryElement
{
Description = "Launch Triggered by Container ID " + _container.Id
});
crateStorage.Remove <OperationalStateCM>();
var payloadCrates = crateStorage.AsEnumerable().ToArray();
plan.Enqueue(planDO.Id, payloadCrates);
}
public async Task <ActivityDTO> Activate(ActivityDO submittedActivity)
{
using (await _configureLock.Lock(submittedActivity.Id))
{
try
{
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var existingAction = uow.PlanRepository.GetById <ActivityDO>(submittedActivity.Id);
if (existingAction == null)
{
throw new Exception("Action was not found");
}
if (existingAction.ActivationState == ActivationState.Activated)
{
return(Mapper.Map <ActivityDTO>(submittedActivity));
}
Logger.GetLogger().Info($"Before calling terminal activation of activity (Id - {submittedActivity.Id})");
var activatedActivityDTO = await CallTerminalActivityAsync <ActivityDTO>(uow, "activate", null, submittedActivity, Guid.Empty);
Logger.GetLogger().Info($"Call to terminal activation of activity (Id - {submittedActivity.Id}) completed");
var activatedActivityDo = Mapper.Map <ActivityDO>(activatedActivityDTO);
var storage = _crateManager.GetStorage(activatedActivityDo);
var validationCrate = storage.CrateContentsOfType <ValidationResultsCM>().FirstOrDefault();
if (validationCrate == null || !validationCrate.HasErrors)
{
existingAction.ActivationState = ActivationState.Activated;
}
UpdateActivityProperties(existingAction, activatedActivityDo);
uow.SaveChanges();
EventManager.ActionActivated(activatedActivityDo);
return(Mapper.Map <ActivityDTO>(activatedActivityDo));
}
}
catch (Exception e)
{
ReportActivityInvocationError(submittedActivity, e.Message, null, submittedActivity.Id.ToString(), EventManager.TerminalActionActivationFailed);
throw;
}
}
}
private async Task <ActivityDTO> ConfigureFollowUp(bool setFileName = false, string fileUri = null, ActivityDTO existingActivity = null)
{
if (string.IsNullOrEmpty(fileUri))
{
fileUri = HealthMonitor_FixtureData.GetFilePath();
}
var configureUrl = GetTerminalConfigureUrl();
var dataDTO = HealthMonitor_FixtureData.Load_Excel_File_v1_InitialConfiguration_Fr8DataDTO(Guid.NewGuid());
if (existingActivity == null)
{
existingActivity = await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO);
}
if (setFileName)
{
using (var storage = _crateManager.GetUpdatableStorage(existingActivity))
{
var activityUi = new Load_Excel_File_v1.ActivityUi();
var controlsCrate = _crateManager.GetStorage(existingActivity).FirstCrate <StandardConfigurationControlsCM>();
activityUi.SyncWith(controlsCrate.Content);
activityUi.FilePicker.Value = fileUri;
storage.ReplaceByLabel(Fr8.Infrastructure.Data.Crates.Crate.FromContent(controlsCrate.Label, new StandardConfigurationControlsCM(activityUi.Controls.ToArray())));
}
}
dataDTO.ActivityDTO = existingActivity;
return(await HttpPostAsync <Fr8DataDTO, ActivityDTO>(configureUrl, dataDTO));
}
public List <CrateDescriptionCM> GetCrateManifestsByDirection(
Guid activityId,
CrateDirection direction,
AvailabilityType availability,
bool includeCratesFromActivity = true
)
{
Func <Crate <CrateDescriptionCM>, bool> cratePredicate;
//validation errors don't need to be present as available data, so remove Validation Errors
cratePredicate = f => f.Label != ValidationErrorsLabel;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
var activityDO = uow.PlanRepository.GetById <ActivityDO>(activityId);
var activities = GetActivitiesByDirection(uow, direction, activityDO)
.OfType <ActivityDO>();
if (!includeCratesFromActivity)
{
activities = activities.Where(x => x.Id != activityId);
}
// else
// {
// if (!activities.Any(x => x.Id == activityId))
// {
// var activitiesToAdd = activities.ToList();
// activitiesToAdd.Insert(0, activityDO);
// activities = activitiesToAdd;
// }
// }
var result = activities
.SelectMany(x => _crate.GetStorage(x).CratesOfType <CrateDescriptionCM>().Where(cratePredicate))
.Select(x =>
{
foreach (var crateDescription in x.Content.CrateDescriptions)
{
crateDescription.Label = crateDescription.Label ?? crateDescription.ProducedBy;
}
return(x.Content);
})
.ToList();
return(result);
}
}
public static ICrateStorage GetStorage(this ICrateManager crateManager, ActivityDO activity)
{
return(crateManager.GetStorage(activity.CrateStorage));
}
public async Task Run(IUnitOfWork uow, ContainerDO container)
{
if (container == null)
{
throw new ArgumentNullException("ContainerDO is null");
}
if (container.State == State.Failed ||
container.State == State.Completed)
{
throw new ApplicationException("Attempted to Launch a Container that was Failed or Completed");
}
var plan = uow.PlanRepository.GetById <PlanDO>(container.PlanId);
if (plan.PlanState == PlanState.Deleted)
{
throw new InvalidOperationException("Can't executue container that belongs to deleted plan");
}
var storage = _crate.GetStorage(container.CrateStorage);
var operationalState = storage.CrateContentsOfType <OperationalStateCM>().Single();
if (operationalState == null)
{
throw new InvalidOperationException("Can't run container without properly intialized OperationalStateCM crate.");
}
// this is something that can't be changed by running activities. So we store current call stack for the entire run session.
var callStack = operationalState.CallStack;
if (callStack == null || callStack.Count == 0)
{
// try to convert old CurrentPlanNodeId driven logic into call stack
if (container.CurrentActivityId == null)
{
throw new InvalidOperationException("Current container has empty call stack that usually means that execution is completed. We can't run it again.");
}
callStack = RecoverCallStack(uow, container);
}
container.State = State.Executing;
uow.SaveChanges();
var executionSession = new ExecutionSession(uow, callStack, container, _activity, _crate, _utilizationMonitoringService, _activityRateLimiter);
EventManager.ContainerLaunched(container);
try
{
await executionSession.Run();
}
catch (InvalidTokenRuntimeException ex)
{
var user = uow.UserRepository.GetByKey(plan.Fr8AccountId);
ReportAuthError(uow, user, ex);
EventManager.ContainerFailed(plan, ex, container.Id.ToString());
throw;
}
catch (Exception ex)
{
EventManager.ContainerFailed(plan, ex, container.Id.ToString());
throw;
}
EventManager.ContainerExecutionCompleted(container);
}
