/// <summary>
/// Met à jour l'état de la synthèse.
/// </summary>
/// <typeparam name="TReferential">Le type de référentiel.</typeparam>
/// <param name="vm">Le viewModel.</param>
public void UpdateRestitutionState <TReferential>(IRestitutionViewByResourceViewModel <TReferential> vm)
where TReferential : IActionReferential
{
ProcessReferentialIdentifier id = ReferentialsHelper.GetIdentifier <TReferential>();
_restitutionState.Referential = id;
_restitutionState.Solutions = false;
_restitutionState.RestitutionValueMode = (int)vm.SelectedValueMode;
switch (vm.SelectedViewIndex)
{
case 0: // Vue Globale
_restitutionState.ViewMode = RestitutionStateViewMode.Global;
_restitutionState.ResourceId = null;
break;
case 1: // Vue par opérateur
_restitutionState.ViewMode = RestitutionStateViewMode.PerOperator;
_restitutionState.ResourceId = vm.SelectedResource != null ? (int?)vm.SelectedResource.Id : null;
break;
case 2: // Vue par équipement
_restitutionState.ViewMode = RestitutionStateViewMode.PerEquipment;
_restitutionState.ResourceId = vm.SelectedResource != null ? (int?)vm.SelectedResource.Id : null;
break;
default:
throw new ArgumentOutOfRangeException(nameof(vm));
}
ServiceBus.Get <IProjectManagerService>().RestitutionState[_currentProjectId] = _restitutionState;
}
/// <summary>
/// Crée une instance de <see cref="ProjectExport"/>.
/// </summary>
/// <param name="context">Le contexte.</param>
/// <param name="projectId">L'identifiant du projet.</param>
/// <returns>Le <see cref="ProjectExport"/></returns>
internal async Task <ProjectExport> CreateProjectExport(KsmedEntities context, int projectId)
{
var referentialsUsed = await SharedScenarioActionsOperations.GetReferentialsUse(context, projectId);
await Queries.LoadAllReferentialsOfProject(context, projectId, referentialsUsed);
var project = await context.Projects
.Include("Videos")
.Include("Referentials")
.FirstAsync(s => s.ProjectId == projectId);
var scenarios = await context.Scenarios
.Where(s => s.ProjectId == projectId &&
(s.NatureCode == KnownScenarioNatures.Initial || s.NatureCode == KnownScenarioNatures.Target || s.NatureCode == KnownScenarioNatures.Realized))
.ToArrayAsync();
await Queries.LoadScenariosDetails(context, scenarios, referentialsUsed);
return(new ProjectExport()
{
AppVersion = System.Reflection.Assembly.GetExecutingAssembly().GetName().Version.ToString(),
Project = project,
ReferentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(project).ToArray(),
ReferentialsProject = ReferentialsHelper.GetAllReferentialsProject(project).ToArray(),
});
}
/// <summary>
/// Charge les référentiels pour les tâches.
/// </summary>
/// <param name="actions">Les tâches.</param>
private void LoadReferentials(IEnumerable <KAction> actions)
{
Queries.LoadAllReferentials(_context, actions);
_refStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(actions);
_refProject = ReferentialsHelper.GetAllReferentialsProject(actions);
if (_video.DefaultResource != null)
{
if ((_video.DefaultResource as IActionReferentialProcess)?.ProcessId != null)
{
_refProject = _refProject.Concat((IActionReferentialProcess)_video.DefaultResource);
}
else if ((_video.DefaultResource as IActionReferentialProcess)?.ProcessId == null)
{
_refStandard = _refStandard.Concat((IActionReferential)_video.DefaultResource);
}
}
var allResources = _refStandard.OfType <Resource>().Union(_refProject.OfType <Resource>());
// Filtrer les actions : supprimer les actions liés aux ressources qui ne sont pas dans la liste
foreach (var resource in allResources)
{
resource.Actions.RemoveWhere(p => !actions.Contains(p));
}
}
private void RemapReferentials()
{
foreach (var oldReferential in _referentialsToRemap.Keys)
{
// Remapper la res par défaut de la vidéo
if (oldReferential is Resource)
{
ReferentialsHelper.UpdateReferentialReferences(new Video[] { _import.ExportedVideoDecomposition.Video }, oldReferential, _referentialsToRemap[oldReferential]);
}
// Remapper les actions
ReferentialsHelper.UpdateReferentialReferences(_actions, oldReferential, _referentialsToRemap[oldReferential]);
}
}
public void ExportVideoDefaultResource_Bug1547Test()
{
var resourceStandard = new EquipmentStandard()
{
Label = "Res"
};
var project = new Project();
var video = new Video()
{
Name = "Video",
DefaultResource = resourceStandard,
};
project.Videos.Add(video);
Assert.IsTrue(ReferentialsHelper.GetAllReferentialsStandardUsed(project).Contains(resourceStandard));
}
private void AssertProject(Project p1, Project p2)
{
Assert.IsTrue(new EntityComparer <Project>(TestContext)
.MustBeDifferent(
"ProjectId",
"CreationDate", "LastModificationDate")
.Ignore(
"CreatedByUserId", "ModifiedByUserId")
.Compare(p1, p2));
var p1RerentialsProject = ReferentialsHelper.GetAllReferentialsProject(p1).ToArray();
var p1RerentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(p1).ToArray();
var p2RerentialsProject = ReferentialsHelper.GetAllReferentialsProject(p2).ToArray();
var p2RerentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(p2).ToArray();
Assert.IsTrue(p1RerentialsProject.Length <= p2RerentialsProject.Length);
Assert.AreEqual(p1RerentialsProject.Length + p1RerentialsStandard.Length, p2RerentialsProject.Length);
Assert.AreEqual(0, p2RerentialsStandard.Length);
}
/// <summary>
/// Affiche le sous menu de vue par ressource spécifié.
/// </summary>
/// <typeparam name="TViewModel"></typeparam>
/// <typeparam name="TReferential"></typeparam>
void ShowSubMenuByResource <TViewModel, TReferential>()
where TViewModel : IRestitutionViewByResourceViewModel <TReferential>
where TReferential : IActionReferential
{
IView view = CreateViewModel <TViewModel>();
ProcessReferentialIdentifier id = ReferentialsHelper.GetIdentifier <TReferential>();
if (_restitutionState.Referential != id)
{
_restitutionState.Referential = id;
_restitutionState.ResourceId = null;
_restitutionState.Solutions = false;
_restitutionState.ViewMode = RestitutionStateViewMode.Global;
ServiceBus.Get <IProjectManagerService>().RestitutionState[_currentProjectId] = _restitutionState;
}
_currentViewModel.Load();
CurrentView = view;
}
/// <summary>
/// Exporte les référentiels utilisés.
/// </summary>
/// <param name="project">Le projet.</param>
/// <param name="sheet">La feuille.</param>
private void ExportReferentials(Project project, WorksheetPart sheet)
{
var cellReference = new CellReference();
var allReferentials = ReferentialsHelper.GetAllReferentialsStandardUsed(project).Cast <IActionReferential>().Concat(ReferentialsHelper.GetAllReferentialsProject(project)).ToArray();
var refUseService = IoC.Resolve <IReferentialsUseService>();
foreach (var pr in project.Referentials.Where(r => r.IsEnabled))
{
// Nom
_file.SetCellValue(sheet, cellReference, refUseService.GetLabel((ProcessReferentialIdentifier)pr.ReferentialId));
cellReference.NewLine();
IEnumerable <IActionReferential> referentials;
switch ((ProcessReferentialIdentifier)pr.ReferentialId)
{
case ProcessReferentialIdentifier.Operator:
referentials = allReferentials.OfType <Operator>();
break;
case ProcessReferentialIdentifier.Equipment:
referentials = allReferentials.OfType <Equipment>();
break;
case ProcessReferentialIdentifier.Category:
referentials = allReferentials.OfType <ActionCategory>();
break;
case ProcessReferentialIdentifier.Ref1:
referentials = allReferentials.OfType <Ref1>();
break;
case ProcessReferentialIdentifier.Ref2:
referentials = allReferentials.OfType <Ref2>();
break;
case ProcessReferentialIdentifier.Ref3:
referentials = allReferentials.OfType <Ref3>();
break;
case ProcessReferentialIdentifier.Ref4:
referentials = allReferentials.OfType <Ref4>();
break;
case ProcessReferentialIdentifier.Ref5:
referentials = allReferentials.OfType <Ref5>();
break;
case ProcessReferentialIdentifier.Ref6:
referentials = allReferentials.OfType <Ref6>();
break;
case ProcessReferentialIdentifier.Ref7:
referentials = allReferentials.OfType <Ref7>();
break;
default:
throw new ArgumentOutOfRangeException();
}
foreach (var referential in referentials)
{
_file.SetCellValue(sheet, cellReference, referential.Label);
cellReference.MoveRight();
if (referential.CloudFile != null)
{
_file.SetCellValue(sheet, cellReference, referential.CloudFile.LocalUri.AbsoluteUri);
}
cellReference.MoveRight();
if (!string.IsNullOrWhiteSpace(referential.Description))
{
_file.SetCellValue(sheet, cellReference, referential.Description);
}
cellReference.NewLine();
}
cellReference.NewLine();
}
}
/// <summary>
/// Importe le projet spécifié.
/// </summary>
/// <param name="context">Le contexte.</param>
/// <param name="import">Le projet exporté.</param>
/// <param name="mergeReferentials"><c>true</c> pour fusionner les référentiels.</param>
/// <param name="videosDirectory">Le dossier où se situent les vidéos.</param>
/// <returns>Le projet créé.</returns>
private async Task <Project> ImportProject(KsmedEntities context, ProjectImport import, bool mergeReferentials, string videosDirectory)
{
// Projet
var p = import.ExportedProject.Project;
p.ProjectId = default(int);
MarkAsAdded(p);
// Ajouter l'utilisateur courant en tant qu'analyste créateur
var owner = await context.Users.FirstAsync(u => !u.IsDeleted && u.Username == _securityContext.CurrentUser.Username);
p.Process.Owner = owner;
p.Process.UserRoleProcesses.Add(new UserRoleProcess()
{
User = owner,
RoleCode = KnownRoles.Analyst,
});
// Videos
foreach (var video in p.Process.Videos)
{
if (video.DefaultResourceId.HasValue && video.DefaultResource == null)
{
// Bug présent dans certains exports de la version 2.5.0.0. Supprimer le lien vers la ressource par défaut.
video.DefaultResourceId = null;
}
video.VideoId = default(int);
MarkAsAdded(video);
video.FilePath = IOHelper.ChangeDirectory(video.FilePath, videosDirectory);
}
var referentialsToRemap = new Dictionary <IActionReferential, IActionReferential>();
if (!mergeReferentials)
{
// Référentiels process
foreach (var refe in import.ExportedProject.ReferentialsProject)
{
MarkAsAdded(refe);
}
// Référentiels standard
foreach (var refe in import.ExportedProject.ReferentialsStandard)
{
var refProject = ReferentialsFactory.CopyToNewProject(refe);
// Associer au process
refProject.Process = p.Process;
referentialsToRemap[refe] = refProject;
}
}
else
{
// Référentiels process
foreach (var refe in import.ExportedProject.ReferentialsProject)
{
// Ajouter au tableau de remap s'il y a une correspondance.
if (import.ProjectReferentialsMergeCandidates.ContainsKey(refe))
{
referentialsToRemap[refe] = import.ProjectReferentialsMergeCandidates[refe];
}
else
{
MarkAsAdded(refe);
}
}
// Référentiels standard
foreach (var refe in import.ExportedProject.ReferentialsStandard)
{
if (import.StandardReferentialsMergeCandidates.ContainsKey(refe))
{
referentialsToRemap[refe] = import.StandardReferentialsMergeCandidates[refe];
}
else
{
var refProject = ReferentialsFactory.CopyToNewProject(refe);
// Associer au process
refProject.Process = p.Process;
referentialsToRemap[refe] = refProject;
}
}
}
// Scénarios
foreach (var scenario in p.Scenarios.Where(s => s.OriginalScenarioId.HasValue))
{
// Remapper l'original
scenario.Original = p.Scenarios.Single(s => s.ScenarioId == scenario.OriginalScenarioId);
}
foreach (var scenario in p.Scenarios)
{
foreach (var action in scenario.Actions.Where(a => a.OriginalActionId.HasValue))
{
// Remapper l'original
action.Original = p.Scenarios.SelectMany(s => s.Actions).Single(a => a.ActionId == action.OriginalActionId);
}
}
foreach (var scenario in p.Scenarios)
{
scenario.ScenarioId = default(int);
MarkAsAdded(scenario);
// Supprimer le WebPublicationGuid
scenario.WebPublicationGuid = null;
// Actions
foreach (var action in scenario.Actions)
{
action.ActionId = default(int);
MarkAsAdded(action);
// Actions réduites
if (action.IsReduced)
{
MarkAsAdded(action.Reduced);
}
}
}
// Remapper les référentiels du projet, des actions et des vidéos
foreach (var oldReferential in referentialsToRemap.Keys)
{
ReferentialsHelper.UpdateReferentialReferences(p, oldReferential, referentialsToRemap[oldReferential]);
}
foreach (var scenario in p.Scenarios)
{
if (scenario.Original != null)
{
context.Scenarios.ApplyChanges(scenario);
ObjectContextExt.SetRelationShipReferenceValue(context, scenario, scenario.Original, s => s.OriginalScenarioId);
foreach (var action in scenario.Actions)
{
if (action.Original != null)
{
context.KActions.ApplyChanges(action);
ObjectContextExt.SetRelationShipReferenceValue(context, action, action.Original, a => a.OriginalActionId);
}
}
}
}
var resources = p.Scenarios.SelectMany(s => s.Actions).Select(a => a.Resource).Distinct().ToArray();
context.Projects.ApplyChanges(p);
if (mergeReferentials)
{
ServicesDiagnosticsDebug.CheckNotInContext(context, referentialsToRemap.Keys);
ServicesDiagnosticsDebug.CheckObjectStateManagerState(context, EntityState.Unchanged, referentialsToRemap.Values);
}
ServicesDiagnosticsDebug.CheckReferentialsState();
await context.SaveChangesAsync();
return(p);
}
/// <summary>
/// Exporte le projet spécifié.
/// </summary>
private void ExportVideoDecomposition(int projectId, int scenarioId, int videoId, int targetProjectId, bool merge)
{
var service = new ImportExportService();
string fileName = string.Format("out{0}.xml", fileNumber++);
KProcess.Ksmed.Business.Dtos.Export.VideoDecompositionExport oldVideoExport;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
oldVideoExport = new VideoDecompositionExporter(context, projectId, scenarioId, videoId).CreateExport();
}
var mre = new System.Threading.ManualResetEvent(false);
Stream stream = null;
Exception e = null;
service.ExportVideoDecomposition(projectId, scenarioId, videoId, d =>
{
stream = d;
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
Assert.IsNotNull(stream);
using (var reader = new StreamReader(stream))
{
string xml = reader.ReadToEnd();
File.WriteAllText(fileName, xml);
Assert.IsNotNull(xml);
}
stream.Close();
Initialization.SetCurrentUser("paula");
// Ouvrir le fichier
mre.Reset();
service.PredictMergedReferentialsVideoDecomposition(targetProjectId, File.OpenRead(fileName), vdi =>
{
service.ImportVideoDecomposition(vdi, merge, TestContext.DeploymentDirectory, targetProjectId, success =>
{
Assert.IsTrue(success);
mre.Set();
}, ex =>
{
e = ex;
mre.Set();
});
}, ex =>
{
e = ex;
mre.Set();
});
mre.WaitOne();
AssertExt.IsExceptionNull(e);
// Récupérer le numéro de scénario initial du projet
Scenario targetScenario;
int newVideoId;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
targetScenario = context.Scenarios.Single(s => s.ProjectId == targetProjectId && s.StateCode == KnownScenarioStates.Draft && s.NatureCode == KnownScenarioNatures.Initial);
var oldVideoName = context.Videos.Single(v => v.VideoId == videoId).Name;
newVideoId = context.Videos.Where(v => v.ProjectId == targetProjectId && v.Name == oldVideoName)
.AsEnumerable().Last().VideoId;
}
//Réexporter la décompo
KProcess.Ksmed.Business.Dtos.Export.VideoDecompositionExport newVideoExport;
using (var context = KProcess.Ksmed.Data.ContextFactory.GetNewContext())
{
newVideoExport = new VideoDecompositionExporter(context, targetScenario.ProjectId, targetScenario.ScenarioId, newVideoId).CreateExport();
}
// Comparer les valeurs
// Vidéo
var oldVideo = oldVideoExport.Video;
var newVideo = newVideoExport.Video;
AssertVideo(oldVideo, newVideo);
// Référentiels
var p1RerentialsProject = ReferentialsHelper.GetAllReferentialsProject(oldVideoExport.Actions).ToArray();
var p1RerentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(oldVideoExport.Actions).ToArray();
var p2RerentialsProject = ReferentialsHelper.GetAllReferentialsProject(newVideoExport.Actions).ToArray();
var p2RerentialsStandard = ReferentialsHelper.GetAllReferentialsStandardUsed(newVideoExport.Actions).ToArray();
Assert.IsTrue(p1RerentialsProject.Length <= p2RerentialsProject.Length);
Assert.AreEqual(p1RerentialsProject.Length + p1RerentialsStandard.Length, p2RerentialsProject.Length);
Assert.AreEqual(0, p2RerentialsStandard.Length);
// Vérifier que toutes les actions de l'ancien export soient également maintenant dans le projet de destination
var oldActions = oldVideoExport.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
var newActions = newVideoExport.Actions.OrderBy(a => WBSHelper.GetParts(a.WBS), new WBSHelper.WBSComparer()).ToArray();
Assert.AreEqual(oldActions.Length, newActions.Length);
// Actions
for (int j = 0; j < oldActions.Length; j++)
{
var oldAction = oldActions[j];
var newAction = newActions[j];
AssertAction(oldAction, newAction);
// Actions réduites
AssertActionReduced(oldAction.Reduced, newAction.Reduced);
}
ServicesDiagnosticsDebug.CheckReferentialsState();
}
