/// <summary> /// Crée un scénario cible à partir d'un autre scénario, initial ou cible. /// </summary> /// <param name="context">Le contexte.</param> /// <param name="projectId">L'identifiant du projet.</param> /// <param name="sourceScenarioId">L'identifiant du scénario source.</param> /// <param name="natureCode">Le code de la nature.</param> /// <param name="save"><c>true</c> pour sauvegarder le scénario créé.</param> /// <returns> /// Le scénario créé /// </returns> public static async Task <Scenario> CreateDerivatedScenario(KsmedEntities context, int projectId, int sourceScenarioId, string natureCode, bool save) { Scenario fromScenario; using (var tempContext = ContextFactory.GetNewContext()) { // Charger les référentiels var referentialsUsed = await SharedScenarioActionsOperations.GetReferentialsUse(context, projectId); await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed); var 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(); fromScenario = await context.Scenarios.FirstAsync(s => s.ScenarioId == sourceScenarioId); await Queries.LoadScenariosDetails(context, EnumerableExt.Concat(fromScenario), referentialsUsed); } return(await CreateDerivatedScenario(context, fromScenario, natureCode, save)); }
public bool Match(byte[] machineHash) { _traceManager?.TraceDebug("MachineIdentifierProvider.Match(stored hash: {0})", machineHash != null ? Convert.ToBase64String(machineHash) : "null"); var identifiers = EnumerableExt.Concat(NewMachineIdentifier).Concat(OldMachineIdentifiersCheck); using (MemoryStream stream = new MemoryStream(machineHash)) { byte[] hash = new byte[16]; if (stream.Read(hash, 0, 16) != 16) { return(false); } foreach (var identifier in identifiers) { if (identifier.Match(hash)) { return(true); } } } return(false); }
/// <summary> /// Importe décomposition d'une vidéo d'un scénario dans le scénario initial existant d'un projet. /// </summary> /// <param name="videoDecomposition">Les données à importer.</param> /// <param name="mergeReferentials"><c>true</c> pour fusionner les référentiels.</param> /// <param name="videosDirectory">Le dossier qui contient les vidéos.</param> /// <param name="targetProjectId">L'identifiant du projet cible.</param> public virtual async Task <bool> ImportVideoDecomposition(VideoDecompositionImport videoDecomposition, bool mergeReferentials, string videosDirectory, int targetProjectId) => await Task.Run(async() => { using (var context = ContextFactory.GetNewContext()) { var scenario = await context.Scenarios .Include("Project") .FirstOrDefaultAsync(s => s.ProjectId == targetProjectId && s.StateCode == KnownScenarioStates.Draft && s.NatureCode == KnownScenarioNatures.Initial); await Queries.LoadScenariosDetails(context, EnumerableExt.Concat(scenario), null); if (scenario == null) { return(false); } await new VideoDecompositionImporter(context, videoDecomposition, scenario).ImportVideoDecomposition(mergeReferentials, videosDirectory); return(true); } });
public void BulkScenarioCloneTests() { SampleData.ClearDatabaseThenImportDefaultProject(); var service = new PrepareService(); int[] projectIds; using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext()) { projectIds = context.Projects.Select(p => p.ProjectId).ToArray(); } foreach (var pid in projectIds) { var mre = new System.Threading.ManualResetEvent(false); Exception e = null; ScenariosData data = null; service.GetScenarios(pid, d => { data = d; mre.Set(); }, ex => { e = ex; mre.Set(); }); mre.WaitOne(); AssertExt.IsExceptionNull(e); Assert.IsNotNull(data); foreach (var scenario in data.Scenarios.Where(s => s.NatureCode != KnownScenarioNatures.Realized)) { if (scenario.NatureCode == KnownScenarioNatures.Target && scenario.Actions.Any(a => !a.IsReduced)) { // Il s'agit d'un vieux projet. Tous les actions d'un scénario cible doivent aujourd'hui avoir une partie réduite continue; } mre.Reset(); Scenario newScenario = null; service.CreateScenario(pid, scenario, true, s => { newScenario = s; mre.Set(); }, ex => { e = ex; mre.Set(); }); mre.WaitOne(); AssertExt.IsExceptionNull(e); Assert.IsNotNull(newScenario); // Vérification de l'intégrité du scénario ActionsTimingsMoveManagement.DebugCheckAllWBS(EnumerableExt.Concat(newScenario)); // Vérifier qu'il n'y ai pas de tâche avec un temps process nul if (scenario.NatureCode != KnownScenarioNatures.Initial && newScenario.Actions.Any(a => a.BuildDuration <= 0)) { Assert.Fail("Une action a un temps invalide"); } } } }
/// <summary> /// Supprime les actions dont la durée est 0 du scénario. /// Supprime également les groupes vides qui pourraient résulter des suppressions précédentes. /// </summary> /// <param name="scenario">Le scénario.</param> internal static void RemoveEmptyDurationActionsAndGroupsFromNewScenario(Scenario scenario) { var emptyDurationActionsToDelete = new List <KAction>(); var newTimings = new List <ActionTiming>(); var derivedActions = GetActionsSortedWBS(scenario); // Mettre à jour IsGroup foreach (var action in derivedActions) { action.IsGroup = WBSHelper.HasChildren(action, derivedActions); } foreach (var action in derivedActions) { //On ne supprime pas si: la catégorie de type à supprimer && pas de parent dans le scenario n && originalBuildDuration!=0 if (action.BuildDuration == 0 && !action.IsGroup && !(action.Category != null && action.Category.ActionTypeCode != null && action.Category.ActionTypeCode == KnownActionCategoryTypes.S && action.Original.Original == null && action.Reduced != null && action.Reduced.OriginalBuildDuration != 0)) { // Déplacer tous les pred vers ses succ ActionsTimingsMoveManagement.MapAllPredToSucc(action, a => a.BuildDuration != 0 && !action.IsGroup, newTimings, false); emptyDurationActionsToDelete.Add(action); scenario.Actions.Remove(action); action.Predecessors.Clear(); action.Successors.Clear(); action.MarkAsDeleted(); } } //foreach (var action in actionsToDelete) //{ // // Mettre à jour les WBS des autres actions // ActionsTimingsMoveManagement.DeleteUpdateWBS(derivedActions, action); //} if (scenario.NatureCode == KnownScenarioNatures.Realized) { foreach (var timing in newTimings) { timing.Action.Start = timing.Start; timing.Action.Finish = timing.Finish; } } //actionsToDelete.Clear(); var emptyGroupActionsToDelete = new List <KAction>(); var actionsFiltered = GetActionsSortedWBS(scenario); foreach (var action in actionsFiltered) { if (action.IsGroup && !WBSHelper.HasChildren(action, actionsFiltered)) { emptyGroupActionsToDelete.Add(action); scenario.Actions.Remove(action); action.MarkAsDeleted(); } } //foreach (var action in emptyGroupActionsToDelete) //{ // // Mettre à jour les WBS des autres actions // ActionsTimingsMoveManagement.DeleteUpdateWBS(derivedActions, action); //} // Mettre à jour les WBS des autres actions var tree = derivedActions.VirtualizeTree(); emptyDurationActionsToDelete .Union(emptyGroupActionsToDelete) .ForEach(_ => tree.Remove(_)); tree.ApplyWBS(); ActionsTimingsMoveManagement.DebugCheckAllWBS(EnumerableExt.Concat(scenario)); ActionsTimingsMoveManagement.DebugCheckPredSucc(scenario.Actions, false); }