/// <summary> /// Obtient les données pour l'écran Simuler. /// </summary> /// <param name="context">le contexte EF.</param> /// <param name="projectId">L'identifiant du projet.</param> /// <param name="natureFilter">Le filtre des codes de nature.</param> /// <returns> /// Les données /// </returns> public static async Task <SimulateData> GetSimulateData(KsmedEntities context, int projectId, GetDataScenarioNatures natureFilter) { IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed = await GetReferentialsUse(context, projectId); await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed); await context.Projects .Include(nameof(Project.Process)) .Include($"{nameof(Project.Process)}.{nameof(Procedure.Videos)}") .Where(p => p.ProjectId == projectId) .SelectMany(p => p.Process.Videos) .ToArrayAsync(); Scenario[] scenarios = await LoadScenarios(context, projectId, referentialsUsed, natureFilter); Project project = await context.Projects.SingleAsync(p => p.ProjectId == projectId); ScenarioActionHierarchyHelper.MapScenariosActionsOriginals(scenarios); SimulateData data = new SimulateData() { Scenarios = scenarios, ActionTypes = await context.ActionTypes.ToArrayAsync(), CustomFieldsLabels = GetCustomFieldsLabels(project), }; return(data); }
/// <summary> /// Obtient les données pour l'écran Construire. /// </summary> /// <param name="context">Le contexte EF.</param> /// <param name="projectId">L'identifiant du projet.</param> /// <param name="natureFilter">Le filtre sur les codes de nature de scénario.</param> /// <returns>Les données</returns> public static async Task <BuildData> GetBuildData(KsmedEntities context, int projectId, GetDataScenarioNatures natureFilter) { IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed = await GetReferentialsUse(context, projectId); Referentials referentials = await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed); BuildData data = new BuildData { Categories = referentials.Categories, Skills = referentials.Skills, Resources = referentials.Resources, Videos = await context.Projects .Include(nameof(Project.Process)) .Include($"{nameof(Project.Process)}.{nameof(Procedure.Videos)}") .Where(p => p.ProjectId == projectId) .SelectMany(p => p.Process.Videos) .ToArrayAsync(), ActionTypes = (await context.ActionTypes.ToArrayAsync()).OrderBy(a => a.ActionTypeCode, new KnownActionCategoryTypes.ActionCategoryTypeDefaultOrderComparer()).ToArray() }; Project project = await context.Projects.SingleAsync(p => p.ProjectId == projectId); data.CustomFieldsLabels = GetCustomFieldsLabels(project); Scenario[] scenarios = await LoadScenarios(context, projectId, referentialsUsed, natureFilter); ScenarioActionHierarchyHelper.MapScenariosActionsOriginals(scenarios); data.Scenarios = scenarios; return(data); }
/// <summary> /// Obtient les données pour l'écran Restituer. /// </summary> /// <param name="context">le contexte EF.</param> /// <param name="projectId">L'identifiant du projet.</param> /// <returns> /// Les données /// </returns> public static async Task <RestitutionData> GetRestitutionData(KsmedEntities context, int projectId) { IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed = await GetReferentialsUse(context, projectId); Referentials referentials = await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed); ActionCategory[] categories = referentials.Categories; await context.Projects .Include(nameof(Project.Process)) .Include($"{nameof(Project.Process)}.{nameof(Procedure.Videos)}") .Where(p => p.ProjectId == projectId) .SelectMany(p => p.Process.Videos) .ToArrayAsync(); Scenario[] scenarios = await context.Scenarios .Where(s => s.ProjectId == projectId) .ToArrayAsync(); await Queries.LoadScenariosDetails(context, scenarios, referentialsUsed); ILookup <int, KAction> actionsToLoad = scenarios .SelectMany(a => a.Actions) .Where(a => a.IsReduced && a.OriginalActionId.HasValue) .ToLookup(a => a.OriginalActionId.Value, a => a); if (actionsToLoad.Any()) { foreach (ActionDuration duration in await GetActionsBuildDurations(context, actionsToLoad.Select(g => g.Key))) { foreach (KAction action in actionsToLoad[duration.ActionId]) { action.Reduced.Saving = duration.BuildDuration - action.BuildDuration; } } } ScenarioActionHierarchyHelper.MapScenariosActionsOriginals(scenarios); foreach (Scenario scenario in scenarios) { UpdateIsGroup(scenario); } RestitutionData data = new RestitutionData() { Scenarios = scenarios, ActionCategories = categories, }; return(data); }
/// <summary> /// Obtient les données pour l'écran Acquérir. /// </summary> /// <param name="context">Le contexte EF.</param> /// <param name="projectId">L'identifiant du projet.</param> /// <param name="natureFilter">Le filtre sur les codes de nature de scénario.</param> /// <returns> /// Les données /// </returns> public static async Task <AcquireData> GetAcquireData(KsmedEntities context, int projectId, GetDataScenarioNatures natureFilter) { IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed = await GetReferentialsUse(context, projectId); int processId = (await context.Projects.SingleAsync(p => p.ProjectId == projectId)).ProcessId; AcquireData data = new AcquireData { Categories = await Queries.FilterReferentials(context.ActionCategories, processId, ProcessReferentialIdentifier.Category).ToArrayAsync(), Skills = await Queries.FilterReferentials(context.Skills, processId, ProcessReferentialIdentifier.Skill).ToArrayAsync(), Resources = await Queries.FilterResources(context, processId).ToArrayAsync(), Videos = await context.Projects .Include(nameof(Project.Process)) .Include($"{nameof(Project.Process)}.{nameof(Procedure.Videos)}") .Where(p => p.ProjectId == projectId) .SelectMany(p => p.Process.Videos) .OrderBy(v => v.CameraName).OrderBy(v => v.DefaultResourceId).OrderBy(v => v.ResourceView).OrderBy(v => v.ShootingDate) .ToArrayAsync() }; if (referentialsUsed[ProcessReferentialIdentifier.Ref1]) { data.Ref1s = await Queries.FilterReferentials(context.Refs1, processId, ProcessReferentialIdentifier.Ref1).ToArrayAsync(); } if (referentialsUsed[ProcessReferentialIdentifier.Ref2]) { data.Ref2s = await Queries.FilterReferentials(context.Refs2, processId, ProcessReferentialIdentifier.Ref2).ToArrayAsync(); } if (referentialsUsed[ProcessReferentialIdentifier.Ref3]) { data.Ref3s = await Queries.FilterReferentials(context.Refs3, processId, ProcessReferentialIdentifier.Ref3).ToArrayAsync(); } if (referentialsUsed[ProcessReferentialIdentifier.Ref4]) { data.Ref4s = await Queries.FilterReferentials(context.Refs4, processId, ProcessReferentialIdentifier.Ref4).ToArrayAsync(); } if (referentialsUsed[ProcessReferentialIdentifier.Ref5]) { data.Ref5s = await Queries.FilterReferentials(context.Refs5, processId, ProcessReferentialIdentifier.Ref5).ToArrayAsync(); } if (referentialsUsed[ProcessReferentialIdentifier.Ref6]) { data.Ref6s = await Queries.FilterReferentials(context.Refs6, processId, ProcessReferentialIdentifier.Ref6).ToArrayAsync(); } if (referentialsUsed[ProcessReferentialIdentifier.Ref7]) { data.Ref7s = await Queries.FilterReferentials(context.Refs7, processId, ProcessReferentialIdentifier.Ref7).ToArrayAsync(); } Project project = await context.Projects.Include(nameof(Project.Process)).SingleAsync(p => p.ProjectId == projectId); data.CustomFieldsLabels = GetCustomFieldsLabels(project); Scenario[] scenarios = null; Scenario[] scenariosUsedForMapping = null; if (natureFilter == GetDataScenarioNatures.InitialAndTarget) { // Il y a tout ce qu'il faut pour faire le mapping dans les scenarii chargés scenariosUsedForMapping = await LoadScenarios(context, projectId, referentialsUsed, GetDataScenarioNatures.InitialAndTarget); scenarios = scenariosUsedForMapping; } else if (natureFilter == GetDataScenarioNatures.Realized) { // Il faut charger au moins les scenarii cibles également scenariosUsedForMapping = await LoadScenarios(context, projectId, referentialsUsed, GetDataScenarioNatures.All); scenarios = scenariosUsedForMapping.Where(scenario => scenario.NatureCode == KnownScenarioNatures.Realized).ToArray(); } else { // Le cas all à priori, on considère de toute façon qu'il s'agit du cas par défaut scenariosUsedForMapping = await LoadScenarios(context, projectId, referentialsUsed, natureFilter); scenarios = scenariosUsedForMapping; } ScenarioActionHierarchyHelper.MapScenariosActionsOriginals(scenariosUsedForMapping); data.Scenarios = scenarios; return(data); }
/// <summary> /// Obtient toutes les données du projet spécifié. /// </summary> /// <param name="projectId">L'identifiant du projet.</param> public virtual async Task <RestitutionData> GetFullProjectDetails(int projectId) => await Task.Run(async() => { using (var context = ContextFactory.GetNewContext(_securityContext.CurrentUser, _localizationManager)) { IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed = await _sharedScenarioActionsOperations.GetReferentialsUse(context, projectId); Referentials referentials = await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed); //await context.Videos.Where(v => v.ProjectId == projectId).ToArrayAsync(); await context.ScenarioNatures.ToArrayAsync(); await context.ScenarioStates.ToArrayAsync(); await context.ActionTypes.ToArrayAsync(); await context.ActionValues.ToArrayAsync(); Project project = await context.Projects .Include(nameof(Project.Process)) .Include($"{nameof(Project.Process)}.{nameof(Procedure.Videos)}") .Include($"{nameof(Project.Process)}.{nameof(Procedure.UserRoleProcesses)}") .Include($"{nameof(Project.Process)}.{nameof(Procedure.UserRoleProcesses)}.{nameof(UserRoleProcess.User)}") .Include($"{nameof(Project.Process)}.{nameof(Procedure.UserRoleProcesses)}.{nameof(UserRoleProcess.User)}.{nameof(User.DefaultLanguage)}") .Include(nameof(Project.Scenarios)) .Include($"{nameof(Project.Scenarios)}.{nameof(Scenario.Actions)}") .Include(nameof(Project.Objective)) .FirstAsync(s => s.ProjectId == projectId); project.ScenariosCriticalPath = PrepareService.GetSummary(project, true); // Scénarios foreach (Scenario scenario in project.Scenarios.Where(s => s.OriginalScenarioId.HasValue)) { // Remapper l'original scenario.Original = project.Scenarios.Single(s => s.ScenarioId == scenario.OriginalScenarioId); ScenarioCriticalPath matchingCriticalItem = project.ScenariosCriticalPath.FirstOrDefault(i => i.Id == scenario.ScenarioId); if (matchingCriticalItem != null) { matchingCriticalItem.OriginalLabel = scenario.Original.Label; } } ProjectReferential[] projectReferentials = await context.ProjectReferentials.Where(pr => pr.ProjectId == projectId).ToArrayAsync(); User user = await context.Users.FirstAsync(u => u.UserId == project.CreatedByUserId); ModificationsUsers modificationsUsers = new ModificationsUsers { CreatedByFullName = (await context.Users.FirstAsync(u => u.UserId == project.ModifiedByUserId)).FullName, LastModifiedByFullName = (await context.Users.FirstAsync(u => u.UserId == project.ModifiedByUserId)).FullName }; Scenario[] scenarios = await context.Scenarios .Where(s => s.ProjectId == projectId) .ToArrayAsync(); await Queries.LoadScenariosDetails(context, scenarios, referentialsUsed); ILookup <int, KAction> actionsToLoad = scenarios .SelectMany(a => a.Actions) .Where(a => a.IsReduced && a.OriginalActionId.HasValue) .ToLookup(a => a.OriginalActionId.Value, a => a); if (actionsToLoad.Any()) { foreach (var duration in await _sharedScenarioActionsOperations.GetActionsBuildDurations(context, actionsToLoad.Select(g => g.Key))) { foreach (KAction action in actionsToLoad[duration.ActionId]) { action.Reduced.Saving = duration.BuildDuration - action.BuildDuration; } } } ScenarioActionHierarchyHelper.MapScenariosActionsOriginals(scenarios); return(new RestitutionData() { Project = project, ProjectCreatedByUser = user, Scenarios = scenarios, ActionCategories = referentials.Categories, ModificationsUsers = modificationsUsers, ReferentialsUse = projectReferentials, }); } });