private void FixupImportedActions()
{
var sortedActions = _targetScenario.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
ActionsTimingsMoveManagement.FixPredecessorsSuccessorsTimings(sortedActions, false);
ActionsTimingsMoveManagement.UpdateVideoGroupsTiming(sortedActions);
ActionsTimingsMoveManagement.UpdateBuildGroupsTiming(sortedActions);
_targetScenario.CriticalPathIDuration = ActionsTimingsMoveManagement.GetInternalCriticalPathDuration(_targetScenario);
ActionsTimingsMoveManagement.DebugCheckAllWBS(_targetScenario);
}
public void Delete_Random_Consistency()
{
var random = new Random();
var testEnd = DateTime.Now.AddSeconds(30);
while (DateTime.Now < testEnd)
{
var tasks = new List <KAction>();
var rootTasksCount = random.Next(10);
var currentWbsParts = new Stack <int>();
currentWbsParts.Push(0);
PopulateRandom(random, tasks, currentWbsParts, 5, false);
WriteTasksWBS(tasks);
ActionsTimingsMoveManagement.DebugCheckAllWBS(tasks);
if (CheckWBS(tasks) != null)
{
throw new InvalidOperationException("Wrong generation");
}
while (tasks.Count > 0)
{
var index = random.Next(tasks.Count);
var countToDelete = Math.Min(random.Next(1, 10), tasks.Count);
var toDelete = tasks[index];
var currentStatus = Clone(tasks).ToArray();
ActionsTimingsMoveManagement.DeleteUpdateWBS(tasks.ToArray(), toDelete);
tasks.Remove(toDelete);
TestContext.WriteLine("Deleted: {0} {1}.", toDelete.WBS, toDelete.Label);
var wrongWbs = CheckWBS(tasks);
if (wrongWbs != null)
{
// Rappeler l'état d'origine et l'élément supprimé
TestContext.WriteLine("Fail!");
TestContext.WriteLine("--- Before deletion, indented format:");
WriteTasksWBS(currentStatus);
TestContext.WriteLine("--- Before deletion, appended format: {0}", string.Join(" ", currentStatus.Select(t => t.WBS)));
TestContext.WriteLine("--- Deleted element {0} {1}", toDelete.WBS, toDelete.Label);
TestContext.WriteLine("--- After deletion, indented format:");
WriteTasksWBS(tasks);
Assert.Fail("The WBS {0} is invalid", wrongWbs);
}
ActionsTimingsMoveManagement.DebugCheckAllWBS(tasks);
}
}
}
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>
/// Sauvegarde le scénario spécifié.
/// </summary>
/// <param name="context">Le contexte EF.</param>
/// <param name="allScenarios">Tous les scénarios liés.</param>
/// <param name="recursive"><c>true</c> pour appliquer les changements récursivement sur les scénarios dérivés.</param>
public static Task SaveBuildScenario(KsmedEntities context, Scenario[] allScenarios, Scenario updatedScenario, bool recursive)
{
// Consolider les solutions
string[] distinctSolutionsLabels = updatedScenario.Actions
.Where(a => a.IsReduced && !string.IsNullOrWhiteSpace(a.Reduced.Solution))
.Select(a => a.Reduced.Solution)
.Distinct()
.ToArray();
// Ajouter les nouvelles solutions
foreach (string solutionLabel in distinctSolutionsLabels)
{
if (!updatedScenario.Solutions.Any(s => s.SolutionDescription == solutionLabel))
{
// Créer une nouvelle solution
Solution solution = new Solution()
{
SolutionDescription = solutionLabel,
};
updatedScenario.Solutions.Add(solution);
}
}
EnsureEmptySolutionExists(updatedScenario);
// Supprimer les anciennes solutions
Solution[] allSolutions = updatedScenario.Solutions.Where(s => !s.IsEmpty).ToArray();
foreach (Solution sol in allSolutions)
{
if (!distinctSolutionsLabels.Contains(sol.SolutionDescription))
{
sol.MarkAsDeleted();
updatedScenario.Solutions.Remove(sol);
}
}
// Copier le temps original
foreach (KActionReduced reduced in updatedScenario.Actions
.Where(a => a.IsReduced)
.Select(a => a.Reduced)
.Where(r => r.OriginalBuildDuration == default(long)))
{
reduced.OriginalBuildDuration = reduced.Action.BuildDuration;
}
// Appliquer l'état Approved
UdpateSolutionsApprovedState(updatedScenario);
ActionsRecursiveUpdate.UpdateActions(context, updatedScenario, allScenarios, out KAction[] actionsToDelete, out IList <KAction> actionsWithOriginal);
KAction[] allActions = allScenarios
.SelectMany(s => s.Actions)
.Where(a => a.IsNotMarkedAsUnchanged || (a.IsReduced && a.Reduced.IsNotMarkedAsUnchanged))
.ToArray();
foreach (KAction action in allActions)
{
context.KActions.ApplyChanges(action);
if (action.IsReduced)
{
context.KActionsReduced.ApplyChanges(action.Reduced);
}
}
foreach (KAction action in actionsWithOriginal)
{
SetActionsOriginalReference(context, action);
}
foreach (Scenario scenario in allScenarios.Where(s => s.IsNotMarkedAsUnchanged))
{
context.Scenarios.ApplyChanges(scenario);
}
foreach (Solution solution in updatedScenario.Solutions)
{
context.Solutions.ApplyChanges(solution);
}
// Vérifier que tout est correct
ActionsTimingsMoveManagement.DebugCheckAllWBS(allScenarios.Where(s => s.IsNotMarkedAsUnchanged));
return(context.SaveChangesAsync());
}
/// <summary>
/// Sauvegarde les actions spécifiées.
/// </summary>
/// <param name="context">Le contexte.</param>
/// <param name="allScenarios">Tous les scénarios liés.</param>
/// <param name="updatedScenario">Le scénario qui a été mis à jour.</param>
/// <param name="recursive"><c>true</c> pour appliquer les changements récursivement sur les scénarios dérivés.</param>
public static Task SaveAcquireData(KsmedEntities context, Scenario[] allScenarios, Scenario updatedScenario, bool recursive)
{
KAction[] actionsToDelete;
IList <KAction> actionsWithOriginal;
if (recursive)
{
ActionsRecursiveUpdate.UpdateActions(context, updatedScenario, allScenarios, out actionsToDelete, out actionsWithOriginal);
}
else
{
actionsWithOriginal = null;
actionsToDelete = updatedScenario.Actions.Where(a => a.IsMarkedAsDeleted).ToArray();
updatedScenario.CriticalPathIDuration = ActionsTimingsMoveManagement.GetInternalCriticalPathDuration(updatedScenario);
}
// Consolider les solutions vides
EnsureEmptySolutionExists(updatedScenario);
UdpateSolutionsApprovedState(updatedScenario);
KAction[] allActions = allScenarios
.SelectMany(s => s.Actions)
.Where(a => a.IsNotMarkedAsUnchanged)
.ToArray();
foreach (KAction action in allActions)
{
if (!action.IsReduced)
{
ApplyNewReduced(action, KnownActionCategoryTypes.I);
}
context.KActions.ApplyChanges(action);
context.KActionsReduced.ApplyChanges(action.Reduced);
}
if (actionsWithOriginal != null)
{
foreach (KAction action in actionsWithOriginal)
{
SetActionsOriginalReference(context, action);
}
}
foreach (Scenario scenario in allScenarios.Where(s => s.IsNotMarkedAsUnchanged))
{
context.Scenarios.ApplyChanges(scenario);
}
context.Scenarios.ApplyChanges(updatedScenario);
foreach (KAction action in actionsToDelete)
{
action.Predecessors.Clear();
action.Successors.Clear();
action.MarkAsDeleted();
// Ne pas appeler ApplyChanges car les self tracking le gèrent mal (plantage lors de la sauvegarde)
// Ajouter l'action au contexte si elle n'y est pas attachée
if (!context.ObjectStateManager.TryGetObjectStateEntry(action, out ObjectStateEntry entry))
{
context.AddObject(KsmedEntities.KActionsEntitySetName, action);
context.ObjectStateManager.ChangeObjectState(action, EntityState.Deleted);
}
else
{
context.KActions.DeleteObject(action);
}
}
// Vérifier que tout est correct
if (recursive)
{
ActionsTimingsMoveManagement.DebugCheckAllWBS(allScenarios.Where(s => s.IsNotMarkedAsUnchanged));
}
return(context.SaveChangesAsync());
}
/// <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);
}
/// <summary>
/// Met à jour les actions récursivement sur les scénarios dérivés de celui spécifié.
/// </summary>
/// <param name="context">Le contexte EF.</param>
/// <param name="sourceScenario">Le scénario source.</param>
/// <param name="allScenarios">Tous les scénarios qui peuvent être impactés.</param>
/// <param name="actionsToRemove">Les actions à supprimer manuellement.</param>
internal static void UpdateActions(KsmedEntities context, Scenario sourceScenario, Scenario[] allScenarios,
out KAction[] actionsToRemove, out IList <KAction> actionsWithOriginal)
{
var derivedScenarios = ScenarioActionHierarchyHelper.GetDerivedScenarios(sourceScenario, allScenarios);
var actions = GetActionsSortedWBS(sourceScenario);
actionsWithOriginal = new List <KAction>();
foreach (var scenario in derivedScenarios)
{
// Mettre à jour IsGroup
foreach (var action in scenario.Actions)
{
action.IsGroup = WBSHelper.HasChildren(action, scenario.Actions);
}
}
foreach (var originalAction in actions)
{
// J'enlève le IsMArkedAsModified car les 2 références sont la sauvegarde des actions depuis la construction et depuis l'optimisation
// Or depuis la construction, en modification, le bout de code cidessous est déjà appelé
// Et depuis l'optimisation, il n'y a pas de changement de temps video
if (originalAction.IsMarkedAsAdded /*|| originalAction.IsMarkedAsModified*/)
{
var originalValues = originalAction.ChangeTracker.OriginalValues;
var modifiedValues = originalAction.ChangeTracker.ModifiedValues;
if (originalAction.IsMarkedAsAdded || modifiedValues.ContainsKey(ActionsTimingsMoveManagement.KActionStartPropertyName) || modifiedValues.ContainsKey(ActionsTimingsMoveManagement.KActionFinishPropertyName))
{
// Vérifier si le temps vidéo a changé
ActionsTimingsMoveManagement.GetOrignalModifiedVideoDurations(originalAction, out long originalDuration, out long modifiedDuration);
bool hasVideoDurationChanged = originalDuration != modifiedDuration;
// Si c'est une tâche créée et non dupliquée, le buildDuration est à 0, donc on doit le mettre à jour
//Sinon, si c'est une tâche dupliquée, on le laisse tel quel.
if (originalAction.BuildDuration == 0)
{
var paceRating = originalAction.Resource != null ? originalAction.Resource.PaceRating : 1d;
originalAction.BuildDuration = Convert.ToInt64(modifiedDuration * paceRating);
}
}
}
if (originalAction.IsMarkedAsAdded)
{
// Si l'action est une action nouvelle dans un scénario cible, définir automatiquement la partie réduite
if (sourceScenario.NatureCode == KnownScenarioNatures.Target && originalAction.Reduced == null)
{
SharedScenarioActionsOperations.ApplyNewReduced(originalAction);
}
var originalActionKey = context.CreateEntityKey(KsmedEntities.KActionsEntitySetName, originalAction);
var parentOriginalAction = WBSHelper.GetParent(originalAction, actions);
foreach (var derivedScenario in derivedScenarios)
{
var derivedActions = GetActionsSortedWBS(derivedScenario);
// Rechercher le parent dans le scénario dérivé
var parentDerivedAction = ScenarioActionHierarchyHelper.GetDerivedAction(parentOriginalAction, derivedScenario);
// Cloner l'action originale
var newAction = ScenarioCloneManager.CloneAction(originalAction, ActionCloneBehavior.Cascade);
// Assigner l'original
var originalActionForCurrentDerivedScenario = derivedScenario.Original == sourceScenario ? originalAction :
ScenarioActionHierarchyHelper.GetDerivedAction(originalAction, derivedScenario.Original);
newAction.Original = originalActionForCurrentDerivedScenario;
actionsWithOriginal.Add(newAction);
// Insérer l'action clonée dans le scénario dérivé
ActionsTimingsMoveManagement.InsertUpdateWBS(
derivedActions, newAction, parentDerivedAction, WBSHelper.GetParts(originalAction.WBS).Last(),
(a, wbs) => EnsureTracking(a));
// Rafraichir les actions
derivedScenario.Actions.Add(newAction);
derivedActions = GetActionsSortedWBS(derivedScenario);
// Ajouter les mêmes prédécesseurs et successeurs
foreach (var originalPredecessor in originalAction.Predecessors)
{
var derivedPredecessor = ScenarioActionHierarchyHelper.GetDerivedAction(originalPredecessor, derivedScenario);
if (derivedPredecessor != null)
{
EnsureTracking(derivedPredecessor);
ActionsTimingsMoveManagement.AddPredecessor(derivedActions, newAction, derivedPredecessor);
}
}
foreach (var originalSuccessor in originalAction.Successors)
{
var derivedSuccessor = ScenarioActionHierarchyHelper.GetDerivedAction(originalSuccessor, derivedScenario);
if (derivedSuccessor != null)
{
EnsureTracking(derivedSuccessor);
ActionsTimingsMoveManagement.AddPredecessor(derivedActions, derivedSuccessor, newAction);
}
}
EnsureTracking(derivedScenario);
SharedScenarioActionsOperations.EnsureEmptySolutionExists(derivedScenario);
SharedScenarioActionsOperations.UdpateSolutionsApprovedState(derivedScenario);
ActionsTimingsMoveManagement.DebugCheckAllWBS(derivedActions);
}
}
else if (originalAction.IsMarkedAsModified)
{
var originalValues = originalAction.ChangeTracker.OriginalValues;
var modifiedValues = originalAction.ChangeTracker.ModifiedValues;
var propertiesToCopyValues = new Dictionary <string, object>();
foreach (var propertyName in _kActionPropertyNamesToCopy)
{
if (modifiedValues.ContainsKey(propertyName))
{
propertiesToCopyValues[propertyName] = modifiedValues[propertyName];
}
}
// Vérifier si les reduced doit être impactés également
ActionsTimingsMoveManagement.GetOrignalModifiedBuildDurations(originalAction, out long originalDuration, out long modifiedDuration);
bool hasBuildDurationChanged = originalDuration != modifiedDuration;
foreach (var derivedScenario in derivedScenarios)
{
var derivedAction = ScenarioActionHierarchyHelper.GetDerivedAction(originalAction, derivedScenario);
if (derivedAction != null)
{
EnsureTracking(derivedAction);
foreach (var kvp in propertiesToCopyValues)
{
derivedAction.SetPropertyValue(kvp.Key, kvp.Value);
}
if (hasBuildDurationChanged)
{
if (derivedAction.IsReduced)
{
// Modifier l'original duration et recalculer le temps final en fonction du gain
EnsureTracking(derivedAction.Reduced);
derivedAction.Reduced.OriginalBuildDuration = modifiedDuration;
ActionsTimingsMoveManagement.UpdateTimingsFromReducedReduction(derivedAction);
}
else
{
// Simplement recopier la durée
derivedAction.BuildDuration = modifiedDuration;
}
}
}
}
}
}
var toRemove = new List <KAction>();
// Gérer les actions supprimées
// EF gérant mal l'ordre des suppressions, ça créer une ConstraintException sur la FK OriginalActionId
// Malheureusement un CascadeDelete est impossible puisque la FK est sur un même table
if (sourceScenario.ChangeTracker.ObjectsRemovedFromCollectionProperties.ContainsKey("Actions"))
{
var removedActions = sourceScenario.ChangeTracker.ObjectsRemovedFromCollectionProperties["Actions"].ToArray();
foreach (KAction originalAction in removedActions)
{
EnsureTracking(originalAction);
toRemove.Add(originalAction);
originalAction.MarkAsUnchanged();
foreach (var derivedScenario in derivedScenarios)
{
var derivedAction = ScenarioActionHierarchyHelper.GetDerivedAction(originalAction, derivedScenario);
if (derivedAction != null)
{
var derivedActions = GetActionsSortedWBS(derivedScenario);
// Mettre à jour les WBS des autres actions
ActionsTimingsMoveManagement.DeleteUpdateWBS(derivedActions, derivedAction,
(a, wbs) => EnsureTracking(a));
EnsureTracking(derivedAction);
toRemove.Add(derivedAction);
}
}
}
// Il faut maintenant trier les actions à supprimer pour que la suppression se fasse dans le bon ordre
toRemove.Reverse();
actionsToRemove = toRemove.ToArray();
}
else
{
actionsToRemove = new KAction[] { }
};
sourceScenario.CriticalPathIDuration = ActionsTimingsMoveManagement.GetInternalCriticalPathDuration(sourceScenario);
foreach (var scenario in derivedScenarios)
{
EnsureTracking(scenario);
ActionsTimingsMoveManagement.FixPredecessorsSuccessorsTimings(scenario.Actions.ToArray(), false);
ActionsTimingsMoveManagement.UpdateVideoGroupsTiming(scenario.Actions.ToArray());
ActionsTimingsMoveManagement.UpdateBuildGroupsTiming(scenario.Actions.ToArray());
scenario.CriticalPathIDuration = ActionsTimingsMoveManagement.GetInternalCriticalPathDuration(scenario);
}
}
/// <summary>
/// Enregistre des actions déjà existantes et construit les éléments.
/// </summary>
/// <param name="allActions">Toutes les actions.</param>
/// <param name="filter">Les filtre I/E/S.</param>
public void RegisterInitialActions(IEnumerable <KAction> allActions, IESFilterValue filter)
{
Func <ActionsDisplayResults> displayedActions;
bool isCriticalPathEnabled;
bool useManagedPredSucc;
bool useGanttItemsTimingsOnly;
bool fixPredSuccTimings;
bool refreshTimings;
foreach (var action in allActions)
{
action.IsGroup = WBSHelper.HasChildren(action, allActions);
action.IsLinkToProcess = action.LinkedProcessId != null;
}
switch (filter)
{
case IESFilterValue.IES:
useManagedPredSucc = false;
isCriticalPathEnabled = true;
displayedActions = () => new ActionsDisplayResults {
Actions = allActions
};
useGanttItemsTimingsOnly = false;
fixPredSuccTimings = true;
refreshTimings = true;
break;
case IESFilterValue.I:
useManagedPredSucc = true;
isCriticalPathEnabled = true;
displayedActions = () => FilterActionsUpdatePredSuccManaged(allActions,
a => ActionsTimingsMoveManagement.IsActionExternal(a) || ActionsTimingsMoveManagement.IsActionDeleted(a),
a => ActionsTimingsMoveManagement.IsActionInternal(a));
useGanttItemsTimingsOnly = true;
fixPredSuccTimings = true;
refreshTimings = false;
break;
case IESFilterValue.IE:
useManagedPredSucc = true;
isCriticalPathEnabled = false;
displayedActions = () => FilterActionsUpdatePredSuccManaged(allActions,
a => ActionsTimingsMoveManagement.IsActionDeleted(a),
a => ActionsTimingsMoveManagement.IsActionExternal(a) || ActionsTimingsMoveManagement.IsActionInternal(a));
useGanttItemsTimingsOnly = true;
fixPredSuccTimings = true;
refreshTimings = false;
break;
default:
throw new ArgumentOutOfRangeException("filter");
}
_useGanttItemsTimingsOnly = useGanttItemsTimingsOnly;
this.IsCriticalPathEnabled = isCriticalPathEnabled;
var results = displayedActions();
this.UseManagedPredecessorsSuccessors = useManagedPredSucc;
if (filter == IESFilterValue.IES && useManagedPredSucc)
{
ActionsTimingsMoveManagement.DebugCheckAllWBS(results.Actions);
}
this.RegisterInitialActionsImpl(results.Actions);
if (results.NewTimings != null)
{
foreach (var timing in results.NewTimings)
{
SetBuildStart(timing.Action, timing.Start);
SetBuildFinish(timing.Action, timing.Finish);
}
}
if (refreshTimings)
{
foreach (var item in this.ItemsOfTypeAction)
{
_updatingitem = item;
item.Start = GanttDates.ToDateTime(item.Action.BuildStart);
item.Finish = GanttDates.ToDateTime(item.Action.BuildFinish);
_updatingitem = null;
}
}
if (fixPredSuccTimings)
{
this.FixPredecessorsSuccessorsTimings();
this.UpdateResourcesLoad();
}
}
/// <summary>
/// Sauvegarde les actions spécifiées.
/// </summary>
/// <param name="context">Le contexte.</param>
/// <param name="allScenarios">Tous les scénarios liés.</param>
/// <param name="updatedScenario">Le scénario qui a été mis à jour.</param>
/// <param name="recursive"><c>true</c> pour appliquer les changements récursivement sur les scénarios dérivés.</param>
public async Task <Scenario> SaveAcquireData(KsmedEntities context, Scenario[] allScenarios, Scenario updatedScenario, bool recursive)
{
try
{
// Don't insert a thumbnail that already exists
var actionsWithNewThumbnail = updatedScenario.Actions.Where(_ =>
(_.IsMarkedAsAdded && _.Thumbnail != null) ||
(_.IsMarkedAsModified && _.ChangeTracker.ModifiedValues.ContainsKey(nameof(KAction.Thumbnail)) && _.Thumbnail != null));
foreach (var action in actionsWithNewThumbnail)
{
CloudFile thumbnail = updatedScenario.Actions.Where(_ => _.Thumbnail != null && _.ActionId != action.ActionId).Select(_ => _.Thumbnail).FirstOrDefault(_ => _.Hash == action.ThumbnailHash);
if (thumbnail == null)
{
thumbnail = await context.CloudFiles.SingleOrDefaultAsync(_ => _.Hash == action.Thumbnail.Hash);
}
if (thumbnail != null)
{
action.Thumbnail = thumbnail;
}
}
KAction[] actionsToDelete;
IList <KAction> actionsWithOriginal;
if (recursive)
{
ActionsRecursiveUpdate.UpdateActions(context, updatedScenario, allScenarios, out actionsToDelete, out actionsWithOriginal);
}
else
{
actionsWithOriginal = null;
actionsToDelete = updatedScenario.Actions.Where(a => a.IsMarkedAsDeleted).ToArray();
updatedScenario.CriticalPathIDuration = ActionsTimingsMoveManagement.GetInternalCriticalPathDuration(updatedScenario);
}
// Consolider les solutions vides
EnsureEmptySolutionExists(updatedScenario);
UdpateSolutionsApprovedState(updatedScenario);
// Update InheritedAction if original will be deleted
var actionIdsToDelete = actionsToDelete.Select(_ => _.ActionId).ToList();
var inheritedActions = await context.KActions
.Where(_ => _.OriginalActionId != null && actionIdsToDelete.Contains(_.OriginalActionId.Value))
.ToListAsync();
foreach (var inheritedAction in inheritedActions)
{
inheritedAction.OriginalActionId = null;
context.KActions.ApplyChanges(inheritedAction);
}
KAction[] allActions = allScenarios
.SelectMany(s => s.Actions)
.Where(a => a.IsNotMarkedAsUnchanged)
.ToArray();
foreach (KAction action in allActions)
{
if (!action.IsReduced)
{
ApplyNewReduced(action, KnownActionCategoryTypes.I);
}
context.KActions.ApplyChanges(action);
context.KActionsReduced.ApplyChanges(action.Reduced);
}
if (actionsWithOriginal != null)
{
foreach (KAction action in actionsWithOriginal)
{
SetActionsOriginalReference(context, action);
}
}
foreach (Scenario scenario in allScenarios.Where(s => s.IsNotMarkedAsUnchanged))
{
context.Scenarios.ApplyChanges(scenario);
}
context.Scenarios.ApplyChanges(updatedScenario);
foreach (KAction action in actionsToDelete)
{
action.Predecessors.Clear();
action.Successors.Clear();
action.MarkAsDeleted();
// Ne pas appeler ApplyChanges car les self tracking le gèrent mal (plantage lors de la sauvegarde)
// Ajouter l'action au contexte si elle n'y est pas attachée
if (!context.ObjectStateManager.TryGetObjectStateEntry(action, out ObjectStateEntry entry))
{
context.AddObject(KsmedEntities.KActionsEntitySetName, action);
context.ObjectStateManager.ChangeObjectState(action, EntityState.Deleted);
}
else
{
context.KActions.DeleteObject(action);
}
}
// Vérifier que tout est correct
if (recursive)
{
ActionsTimingsMoveManagement.DebugCheckAllWBS(allScenarios.Where(s => s.IsNotMarkedAsUnchanged));
}
await context.SaveChangesAsync();
return(updatedScenario);
}
catch (Exception ex)
{
TraceManager.TraceError(ex, $"Error while saving scenario {updatedScenario.ScenarioId}");
throw;
}
}
public void Delete_From_Input_TestCases()
{
var jsonObject = JObject.Parse(File.ReadAllText("ActionsTimingsMoveManagement_DeleteTestCases.json"));
JArray cases = (JArray)jsonObject["delete"];
var testCases = JsonConvert.DeserializeObject <DeleteTestCase[]>(cases.ToString());
foreach (var tc in testCases)
{
TestContext.WriteLine("---------------------------------");
TestContext.WriteLine("Analyzing Test Case {0}", tc.Label);
var inputTasks = new List <KAction>();
var wbses = tc.Input.Split(' ');
foreach (var wbs in wbses)
{
var task = new KAction
{
Label = "T" + wbs,
WBS = wbs,
};
inputTasks.Add(task);
}
TestContext.WriteLine("Input :", tc.Label);
WriteTasksWBS(inputTasks);
TestContext.WriteLine("Delete : {0}", tc.Delete);
var tasksToDelete = inputTasks.Where(t => tc.Delete.Any(wbs => wbs == t.WBS)).ToArray();
var outputTasks = inputTasks.ToList();
foreach (var task in tasksToDelete)
{
TestContext.WriteLine("Deleting : {0}", tc.Delete);
ActionsTimingsMoveManagement.DeleteUpdateWBS(outputTasks.ToArray(), task);
outputTasks.Remove(task);
WriteTasksWBS(outputTasks);
ActionsTimingsMoveManagement.DebugCheckAllWBS(outputTasks);
}
TestContext.WriteLine("Output :", tc.Label);
WriteTasksWBS(outputTasks);
TestContext.WriteLine("Expected :", tc.Label);
WriteTasksWBS(tc.Expected);
int i = 0;
foreach (var expectedWbs in tc.Expected.Keys)
{
var expectedLabel = tc.Expected[expectedWbs];
if (outputTasks.Count - 1 < i)
{
Assert.Fail("The actual has less tasks than expected");
}
var task = outputTasks[i];
var actualWbs = task.WBS;
var actuallabel = task.Label;
Assert.AreEqual(expectedWbs, task.WBS, string.Format("Expected {0}: {1}, Found {2}: {3}", expectedWbs, expectedLabel, actualWbs, actuallabel));
Assert.AreEqual(expectedLabel, actuallabel, string.Format("Expected {0}: {1}, Found {2}: {3}", expectedWbs, expectedLabel, actualWbs, actuallabel));
i++;
}
if (i != outputTasks.Count)
{
Assert.Fail("The actual has more tasks than expected");
}
}
}
