internal static void UpdateTaskStatesForFeatureDependendies(FeatureDependencyDto linkedTaskData, CMFeatureDto trackedFeature) { var cmTaskInstance = CMDataProvider.DataStore.Value.CMTasks.Value.Get(linkedTaskData.TaskId); if (cmTaskInstance == null) { // If the task this data links to is null then somehow the task was deleted without deleting the data, // Do so now FeatureDependencyDataProvider.Delete(linkedTaskData.Id); return; } if (trackedFeature == null && linkedTaskData.InstancedCMFeatureId != 0) { trackedFeature = CMDataProvider.DataStore.Value.CMFeatures.Value.Get(linkedTaskData.InstancedCMFeatureId); } // Figure out what the task (that is associated with the dependency data) state should be CMTaskStateDto shouldBeState = null; if (linkedTaskData.PathOptionChosen == false) { shouldBeState = FeatureDependency_TaskState_WaitingOnChoice; } else { shouldBeState = trackedFeature == null || linkedTaskData.InstancedTargetCMSystemStateId == trackedFeature.CMSystemStateId ? FeatureDependency_TaskState_Closed : FeatureDependency_TaskState_WaitingOnDependency; } // Now check to see if the dependency task actually is in that state if (cmTaskInstance.CMTaskStateId != shouldBeState.Id) { // If it's not in the state it should be, then do the update so it is. // All of the checks to avoid doing an update are to avoid chain reactions with the CUD events cmTaskInstance.CMTaskStateId = shouldBeState.Id; CMDataProvider.DataStore.Value.CMTasks.Value.Update(cmTaskInstance); } }
/// <summary> /// Taskes care of scanning for task factories and registering them in the database if needed. /// </summary> /// <returns></returns> private static string RegisterTaskFactories_InDatabase() { var taskFactories = TaskFactoriesCatalog.Instance.TaskFactories.ToList(); var currentFactoriesFromDisk = new List <string>(); var currentTaskTypesFromDisk = new List <string>(); // Check to make sure each task factory is available by its name foreach (var taskFactory in taskFactories) { var cmTaskFactory = CMDataProvider.DataStore.Value.CMTaskFactories.Value.Get_ForName(taskFactory.Name); if (cmTaskFactory == null) { var newTaskFactoryDto = new CMTaskFactoryDto() { Name = taskFactory.Name, Version = taskFactory.Version }; var opResult = CMDataProvider.DataStore.Value.CMTaskFactories.Value.Insert(newTaskFactoryDto); if (opResult.Errors.Any()) { return(opResult.ErrorsCombined); } cmTaskFactory = CMDataProvider.DataStore.Value.CMTaskFactories.Value.Get_ForName(taskFactory.Name); } if (currentFactoriesFromDisk.Contains(cmTaskFactory.Name)) { return($"There is more than 1 task factory registering with the same name {cmTaskFactory.Name}. Please resolve this before running the program."); } currentFactoriesFromDisk.Add(cmTaskFactory.Name); // Make sure all of the task types that this task factory provides are registered in the database foreach (var taskTypeName in taskFactory.GetTaskTypes()) { var cmTaskType = CMDataProvider.DataStore.Value.CMTaskTypes.Value.Get_ForName(taskTypeName); if (cmTaskType == null) { var newTaskTypeDto = new CMTaskTypeDto() { Name = taskTypeName }; var opResult = CMDataProvider.DataStore.Value.CMTaskTypes.Value.Insert(newTaskTypeDto); if (opResult.Errors.Any()) { return(opResult.ErrorsCombined); } cmTaskType = CMDataProvider.DataStore.Value.CMTaskTypes.Value.Get_ForName(taskTypeName); } if (currentTaskTypesFromDisk.Contains(cmTaskType.Name)) { return($"There is more than 1 task type registering with the same name {cmTaskType.Name}. Please resolve this before running the program."); } currentTaskTypesFromDisk.Add(cmTaskType.Name); // Make sure the task states for this task type are registered // First make sure the built in states are present var reservedInternalTaskStates = ReservedTaskStates.States; var reservedTaskPluginStates = taskFactory.GetRequiredTaskStates(cmTaskType); var invalidPluginStates = reservedTaskPluginStates.Intersect(reservedInternalTaskStates); if (invalidPluginStates.Any()) { var allInvalidStates = string.Join(",", invalidPluginStates); return($"The task factory {taskFactory.Name} is attempting to use reserved state(s) {allInvalidStates}. Please remove this task factory and try again."); } var allReservedTaskStates = reservedInternalTaskStates.Union(reservedTaskPluginStates); int priority = 0; foreach (var taskState in allReservedTaskStates) { var dbTaskState = CMDataProvider.DataStore.Value.CMTaskStates.Value.Get_ForInternalName(taskState, cmTaskType.Id); if (dbTaskState == null) { var newTaskStateDto = new CMTaskStateDto() { DisplayName = taskState, InternalName = taskState, Reserved = true, TaskTypeId = cmTaskType.Id, Priority = ++priority }; var opResult = CMDataProvider.DataStore.Value.CMTaskStates.Value.Insert(newTaskStateDto); if (opResult.Errors.Any()) { return(opResult.ErrorsCombined); } } else { dbTaskState.InternalName = taskState; dbTaskState.DisplayName = taskState; dbTaskState.Reserved = true; var opResult = CMDataProvider.DataStore.Value.CMTaskStates.Value.Update(dbTaskState); if (opResult.Errors.Any()) { return(opResult.ErrorsCombined); } } } // Un-reserve states that are not required to be reserved now, just in case we are upgrading the db var dbTaskStates = CMDataProvider.DataStore.Value.CMTaskStates.Value.GetAll_ForTaskType(cmTaskType.Id); foreach (var dbTaskState in dbTaskStates) { if (dbTaskState.Reserved && !allReservedTaskStates.Contains(dbTaskState.InternalName)) { dbTaskState.Reserved = false; var opResult = CMDataProvider.DataStore.Value.CMTaskStates.Value.Update(dbTaskState); if (opResult.Errors.Any()) { return(opResult.ErrorsCombined); } } } } } // Go through everything that is currently registered in the db and check for things that are now missing on disk // mcbtodo: for now I'm just showing an error here, but there should be a way to either automatically resolve this // mcbtodo: issue or give instructions to the user on how to clean up any references to the removed taskfactory/tasktype. // mcbtodo: nothing referenced the factories yet, add this back in or delete as some point //var dbTaskFactories = CMDataProvider.DataStore.Value.CMTaskFactories.Value.GetAll(); //foreach (var dbTaskFactory in dbTaskFactories) //{ // if (!currentFactoriesFromDisk.Contains(dbTaskFactory.Name)) // { // return $"Task factory with name {dbTaskFactory.Name} that was previously registered has been removed. Please put this task factory back in place so the program can run properly."; // } //} var dbTaskTypes = CMDataProvider.DataStore.Value.CMTaskTypes.Value.GetAll(); foreach (var dbTaskType in dbTaskTypes) { // The only restriction is that task types are named uniquely across the collection. It is acceptable if a task type moves from one factory to another. if (!currentTaskTypesFromDisk.Contains(dbTaskType.Name)) { return($"Task type {dbTaskType.Name} that was previously registered has been removed. Please restore the previous configuration so the program can run properly."); } } return(null); }