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); }