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