/// <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;
}
public static ReferentialCategory GetReferentialCategory(this ProcessReferentialIdentifier identifier)
{
switch (identifier)
{
case ProcessReferentialIdentifier.Operator:
case ProcessReferentialIdentifier.Equipment:
case ProcessReferentialIdentifier.Category:
return(ReferentialCategory.Other);
case ProcessReferentialIdentifier.Ref1:
case ProcessReferentialIdentifier.Ref2:
case ProcessReferentialIdentifier.Ref3:
case ProcessReferentialIdentifier.Ref4:
case ProcessReferentialIdentifier.Ref5:
case ProcessReferentialIdentifier.Ref6:
case ProcessReferentialIdentifier.Ref7:
return(ReferentialCategory.Referential);
case ProcessReferentialIdentifier.CustomTextLabel:
case ProcessReferentialIdentifier.CustomTextLabel2:
case ProcessReferentialIdentifier.CustomTextLabel3:
case ProcessReferentialIdentifier.CustomTextLabel4:
return(ReferentialCategory.CustomTextField);
case ProcessReferentialIdentifier.CustomNumericLabel:
case ProcessReferentialIdentifier.CustomNumericLabel2:
case ProcessReferentialIdentifier.CustomNumericLabel3:
case ProcessReferentialIdentifier.CustomNumericLabel4:
return(ReferentialCategory.CustomNumericField);
case ProcessReferentialIdentifier.Skill:
default:
return(ReferentialCategory.Other);
}
}
public string GetLabelPlural(ProcessReferentialIdentifier refe)
{
dynamic param = new ExpandoObject();
param.refe = refe;
return(_apiHttpClient.Service <string>(KL2_Server.API, nameof(ReferentialsService), nameof(GetLabelPlural), param));
}
/// <inheritdoc />
public async Task UpdateReferentialLabel(ProcessReferentialIdentifier refId, string label) =>
await Task.Run(async() =>
{
dynamic param = new ExpandoObject();
param.refId = refId;
param.label = label;
await _apiHttpClient.ServiceAsync(KL2_Server.API, nameof(ReferentialsService), nameof(UpdateReferentialLabel), param);
});
/// <summary>
/// Vide la collection de liens action - référentiel.
/// </summary>
/// <param name="referential">Le type de référentiel.</param>
/// <param name="action">L'action.</param>
public static void ClearReferentialActionLinks(ProcessReferentialIdentifier referential, KAction action, bool cancelChanges = false)
{
switch (referential)
{
case ProcessReferentialIdentifier.Ref1:
foreach (Ref1Action refe in action.Ref1.ToArray())
{
Delete(action.Ref1, refe.Referential, cancelChanges);
}
break;
case ProcessReferentialIdentifier.Ref2:
foreach (Ref2Action refe in action.Ref2.ToArray())
{
Delete(action.Ref2, refe.Referential, cancelChanges);
}
break;
case ProcessReferentialIdentifier.Ref3:
foreach (Ref3Action refe in action.Ref3.ToArray())
{
Delete(action.Ref3, refe.Referential, cancelChanges);
}
break;
case ProcessReferentialIdentifier.Ref4:
foreach (Ref4Action refe in action.Ref4.ToArray())
{
Delete(action.Ref4, refe.Referential, cancelChanges);
}
break;
case ProcessReferentialIdentifier.Ref5:
foreach (Ref5Action refe in action.Ref5.ToArray())
{
Delete(action.Ref5, refe.Referential, cancelChanges);
}
break;
case ProcessReferentialIdentifier.Ref6:
foreach (Ref6Action refe in action.Ref6.ToArray())
{
Delete(action.Ref6, refe.Referential, cancelChanges);
}
break;
case ProcessReferentialIdentifier.Ref7:
foreach (Ref7Action refe in action.Ref7.ToArray())
{
Delete(action.Ref7, refe.Referential, cancelChanges);
}
break;
default:
throw new ArgumentOutOfRangeException(nameof(referential));
}
}
/// <summary>
/// Obtient le libellé d'un référentiel.
/// </summary>
/// <param name="id">L'identifiant du référentiel.</param>
/// <returns>Le libellé.</returns>
public static string GetLabelPlural(ProcessReferentialIdentifier id)
{
if (DesignMode.IsInDesignMode)
{
return(id.ToString() + " All");
}
else
{
return(IoC.Resolve <IReferentialsUseService>().GetLabelPlural(id));
}
}
public IHttpActionResult GetLabelPlural([DynamicBody] dynamic param)
{
try
{
ProcessReferentialIdentifier refe = (ProcessReferentialIdentifier)param.refe;
var result = _referentialService.GetLabelPlural(refe);
return(Ok(result));
}
catch (Exception ex)
{
_traceManager.TraceError(ex, ex.Message);
return(InternalServerError(ex));
}
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
try
{
TrackableCollection <PublicationLocalization> localizations = ((TrackableCollection <PublishedAction>)value)?.FirstOrDefault()?.Publication?.Localizations;
ProcessReferentialIdentifier refID = (ProcessReferentialIdentifier)parameter;
string refName = refID.ToString();
var result = localizations?.SingleOrDefault(_ => _.ResourceKey == refName)?.Value;
return(result);
}
catch
{
return(Binding.DoNothing);
}
}
public async Task <IHttpActionResult> ReferentialUsed([DynamicBody] dynamic param)
{
try
{
ProcessReferentialIdentifier processReferentialId = (ProcessReferentialIdentifier)param.processReferentialId;
int referentialId = (int)param.referentialId;
var result = await _referentialService.ReferentialUsed(processReferentialId, referentialId);
return(Ok(result));
}
catch (Exception ex)
{
_traceManager.TraceError(ex, ex.Message);
return(InternalServerError(ex));
}
}
public async Task <IHttpActionResult> UpdateReferentialLabel([DynamicBody] dynamic param)
{
try
{
ProcessReferentialIdentifier refId = (ProcessReferentialIdentifier)param.refId;
string label = param.label;
await _referentialService.UpdateReferentialLabel(refId, label);
return(Ok());
}
catch (Exception ex)
{
_traceManager.TraceError(ex, ex.Message);
return(InternalServerError(ex));
}
}
public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
{
try
{
Publication publication = (Publication)value;
ProcessReferentialIdentifier refID = (ProcessReferentialIdentifier)parameter;
bool result = false;
switch (refID)
{
case ProcessReferentialIdentifier.Ref1:
result = publication?.PublishedActions.Any(p => p.Action.Ref1.Any()) ?? false;
break;
case ProcessReferentialIdentifier.Ref2:
result = publication?.PublishedActions.Any(p => p.Action.Ref2.Any()) ?? false;
break;
case ProcessReferentialIdentifier.Ref3:
result = publication?.PublishedActions.Any(p => p.Action.Ref3.Any()) ?? false;
break;
case ProcessReferentialIdentifier.Ref4:
result = publication?.PublishedActions.Any(p => p.Action.Ref4.Any()) ?? false;
break;
case ProcessReferentialIdentifier.Ref5:
result = publication?.PublishedActions.Any(p => p.Action.Ref5.Any()) ?? false;
break;
case ProcessReferentialIdentifier.Ref6:
result = publication?.PublishedActions.Any(p => p.Action.Ref6.Any()) ?? false;
break;
case ProcessReferentialIdentifier.Ref7:
result = publication?.PublishedActions.Any(p => p.Action.Ref7.Any()) ?? false;
break;
}
return(result ? Visibility.Visible : Visibility.Collapsed);
}
catch
{
return(Visibility.Visible);
}
}
public static List <TRefAction> GetDocumentationRefs <TRefAction>(this List <ReferentialFieldValues> referentialFieldValues) where TRefAction : IReferentialActionLink, new()
{
ProcessReferentialIdentifier refIdentifier = ProcessReferentialIdentifier.Skill;
if (typeof(TRefAction) == typeof(Ref1Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref1;
}
else if (typeof(TRefAction) == typeof(Ref2Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref2;
}
else if (typeof(TRefAction) == typeof(Ref3Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref3;
}
else if (typeof(TRefAction) == typeof(Ref4Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref4;
}
else if (typeof(TRefAction) == typeof(Ref5Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref5;
}
else if (typeof(TRefAction) == typeof(Ref6Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref6;
}
else if (typeof(TRefAction) == typeof(Ref7Action))
{
refIdentifier = ProcessReferentialIdentifier.Ref7;
}
return(referentialFieldValues
.Where(u => u.ReferentialFieldId == refIdentifier)
.SelectMany(reference => reference.Values,
(reference, fieldValue) => new TRefAction
{
ReferentialId = fieldValue.ReferentialId,
Quantity = fieldValue.Quantity ?? 1
})
.ToList());
}
/// <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>
/// Obtient la visibilité liées à l'activation d'un référentiel.
/// </summary>
/// <param name="id">L'identifiant du référentiel.</param>
/// <returns>la visibilité</returns>
private static Visibility GetVisiblity(ProcessReferentialIdentifier id)
{
bool isEnabled;
if (DesignMode.IsInDesignMode)
{
isEnabled = true;
}
else
{
var referentials = IoC.Resolve <IReferentialsUseService>().Referentials;
if (referentials != null)
{
isEnabled = referentials[id].IsEnabled;
}
else
{
isEnabled = true;
}
}
return(isEnabled ? Visibility.Visible : Visibility.Collapsed);
}
public static List <ActionValueViewModel> BuildMultiValueRefs(GenericActionViewModel action, ProcessReferentialIdentifier refId)
{
var model = new List <ActionValueViewModel>();
var actionRefs = action.ReferentialFieldValues.FirstOrDefault(r => r.ReferentialFieldId == refId);
var refField = action.ReferentialsFields.FirstOrDefault(r => r.ReferentialFieldId == refId);
if (actionRefs != null && actionRefs.Values.Count != 0 && refField != null)
{
var refFieldElements = refField.ReferentialsFieldElements;
var refValues = actionRefs.Values;
foreach (var refValue in refValues)
{
var refe = refFieldElements.FirstOrDefault(r => r.Id == refValue.ReferentialId);
if (refe != null)
{
var fileModel = BuildFile(null, refe.Label, refValue.Quantity);
model.Add(fileModel);
}
}
}
return(model);
}
public static async Task <IList <ReferentialFieldElement> > GetReferentialValues(ProcessReferentialIdentifier identifier, bool hasQuantity, int processId)
{
var LocalizedStrings = DependencyResolver.Current.GetService <ILocalizationManager>();
var referentialService = DependencyResolver.Current.GetService <IReferentialsService>();
IEnumerable <IActionReferential> refs = new List <IActionReferential>();
switch (identifier)
{
case ProcessReferentialIdentifier.Operator:
case ProcessReferentialIdentifier.Equipment:
case ProcessReferentialIdentifier.Category:
case ProcessReferentialIdentifier.Skill:
case ProcessReferentialIdentifier.Ref1:
case ProcessReferentialIdentifier.Ref2:
case ProcessReferentialIdentifier.Ref3:
case ProcessReferentialIdentifier.Ref4:
case ProcessReferentialIdentifier.Ref5:
case ProcessReferentialIdentifier.Ref6:
case ProcessReferentialIdentifier.Ref7:
var(Referentials, _) = await referentialService.GetAllReferentials(identifier, processId);
refs = Referentials;
break;
default:
break;
}
if (identifier == ProcessReferentialIdentifier.Operator || identifier == ProcessReferentialIdentifier.Equipment)
{
return(refs.Select(u => new ReferentialFieldElement
{
Id = u.Id,
Label = u.Label,
HasQuantity = hasQuantity,
CategoryAsLabel = u.ProcessReferentialId == ProcessReferentialIdentifier.Operator ? LocalizedStrings.GetString("Common_Referential_Operator") : LocalizedStrings.GetString("Common_Referential_Equipment"),
Category = u.ProcessReferentialId == ProcessReferentialIdentifier.Operator ? 0 : 1,
CloudFile = u.CloudFile,
Description = u.Description
}).OrderBy(u => u.Category).ToList());
}
else if (identifier == ProcessReferentialIdentifier.Skill)
{
return(refs.Select(u => new ReferentialFieldElement
{
Id = u.Id,
Label = u.Label,
HasQuantity = hasQuantity,
CategoryAsLabel = LocalizedStrings.GetString("VM_ReferentialsGroupSortDescription_Standard"),
Category = 0,
CloudFile = u.CloudFile,
Description = u.Description
}).OrderBy(u => u.Category).ToList());
}
else
{
return(refs.Select(u => new ReferentialFieldElement
{
Id = u.Id,
Label = u.Label,
HasQuantity = hasQuantity,
CategoryAsLabel = ((IActionReferentialProcess)u).ProcessId == null ? LocalizedStrings.GetString("VM_ReferentialsGroupSortDescription_Standard") : ((IActionReferentialProcess)u).Process.Label,
Category = ((IActionReferentialProcess)u).ProcessId == null ? 0 : 1,
CloudFile = u.CloudFile,
Description = u.Description
}).OrderBy(u => u.Category).ToList());
}
}
/// <summary>
/// Filtre les référentiels pour un projet au travers d'une requête ESQL modifiée.
/// </summary>
/// <typeparam name="T">Le type du référentiel</typeparam>
/// <param name="query">La requête.</param>
/// <param name="processId">L'identifiant du process.</param>
/// <param name="refId">L'identifiant du référentiel.</param>
/// <returns>Les éléments filtrés</returns>
internal static ObjectQuery <T> FilterReferentials <T>(ObjectQuery <T> query, int processId, ProcessReferentialIdentifier refId)
where T : IActionReferential
{
string typeName;
string where = @"it IS OF ({0}) AND it.IsDeleted = FALSE AND (it.ProcessId IS NULL OR it.ProcessId = @ProcessId)";
switch (refId)
{
case ProcessReferentialIdentifier.Operator:
case ProcessReferentialIdentifier.Equipment:
throw new InvalidOperationException("Utiliser FilterResources à la place");
case ProcessReferentialIdentifier.Category:
typeName = ActionCategory.TypeFullName;
break;
case ProcessReferentialIdentifier.Skill:
typeName = Skill.TypeFullName;
where = @"it IS OF ({0}) AND it.IsDeleted = FALSE";
break;
case ProcessReferentialIdentifier.Ref1:
typeName = Ref1.TypeFullName;
break;
case ProcessReferentialIdentifier.Ref2:
typeName = Ref2.TypeFullName;
break;
case ProcessReferentialIdentifier.Ref3:
typeName = Ref3.TypeFullName;
break;
case ProcessReferentialIdentifier.Ref4:
typeName = Ref4.TypeFullName;
break;
case ProcessReferentialIdentifier.Ref5:
typeName = Ref5.TypeFullName;
break;
case ProcessReferentialIdentifier.Ref6:
typeName = Ref6.TypeFullName;
break;
case ProcessReferentialIdentifier.Ref7:
typeName = Ref7.TypeFullName;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(query.Where(string.Format(where, typeName), new ObjectParameter("ProcessId", processId)));
}
/// <summary> /// Obtient le libellé pour un référentiel, au pluriel. /// </summary> /// <param name="refe">Le référentiel.</param> /// <returns>Le libellé.</returns> public string GetLabelPlural(ProcessReferentialIdentifier refe) => IoC.Resolve <IServiceBus>().Get <IReferentialsService>().GetLabelPlural(refe);
public static bool IsCustomTextLabel(this ProcessReferentialIdentifier identifier) => GetReferentialCategory(identifier) == ReferentialCategory.CustomTextField;
public static bool IsOthers(this ProcessReferentialIdentifier identifier) => GetReferentialCategory(identifier) == ReferentialCategory.Other;
/// <summary> /// Obtient une valeur indiquant si le référentiel spécifié est activé. /// </summary> /// <param name="refe">Le référentiel.</param> /// <returns><c>true</c> si le référentiel est activé.</returns> public bool IsReferentialEnabled(ProcessReferentialIdentifier refe) => ReferentialsEnabled[refe];
/// <summary>
/// Obtient les libellés des référentiels de l'action concaténés, en fonction de leur utilisation et de leurs options.
/// </summary>
/// <param name="links">Les liens Référentiel - Action.</param>
/// <param name="refeId">L'identifiant de chaque référentiel utilisé.</param>
/// <returns>La chaîne concaténée.</returns>
private string GetMultiReferentialLabels(IEnumerable <IReferentialActionLink> links, ProcessReferentialIdentifier refeId)
{
if (_referentialsUse[refeId].IsEnabled)
{
var useQuantity = _referentialsUse[refeId].HasQuantity;
IEnumerable <string> values;
if (useQuantity)
{
values = links.Select(al => string.Format(LocalizationManager.GetString("Common_Referentials_QuantityDescription"), al.Quantity, al.Referential.Label));
}
else
{
values = links.Select(al => al.Referential.Label);
}
return(string.Join(Environment.NewLine, values));
}
else
{
return(null);
}
}
public static bool IsCustomLabel(this ProcessReferentialIdentifier identifier) => IsCustomNumericLabel(identifier) || IsCustomTextLabel(identifier);
