/// <summary>
/// Charge les scénarios.
/// </summary>
/// <param name="context">Le contexte EF.</param>
/// <param name="projectId">L'identifiant du projet.</param>
/// <param name="referentialsUsed">Les référentiels utilisés.</param>
/// <param name="natureFilter">Le filtre sur les codes de nature de scénario.</param>
/// <returns>Les scénarios.</returns>
private static async Task <Scenario[]> LoadScenarios(KsmedEntities context, int projectId, IDictionary <ProcessReferentialIdentifier, bool> referentialsUsed, GetDataScenarioNatures natureFilter)
{
Scenario[] scenarios;
ObjectQuery <Scenario> query = context.Scenarios.Include(nameof(Scenario.State));
switch (natureFilter)
{
case GetDataScenarioNatures.InitialAndTarget:
scenarios = await query
.Where(s => s.ProjectId == projectId && (s.NatureCode == KnownScenarioNatures.Initial || s.NatureCode == KnownScenarioNatures.Target))
.ToArrayAsync();
break;
case GetDataScenarioNatures.Realized:
scenarios = await query
.Where(s => s.ProjectId == projectId && s.NatureCode == KnownScenarioNatures.Realized)
.ToArrayAsync();
break;
case GetDataScenarioNatures.All:
scenarios = await query
.Where(s => s.ProjectId == projectId)
.ToArrayAsync();
break;
default:
throw new ArgumentOutOfRangeException();
}
await Queries.LoadScenariosDetails(context, scenarios, referentialsUsed);
return(scenarios);
}
/// <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 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);
}
