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