public async Task <IActionResult> Start(long idWorkflowConfig, long idDataSet, long idUserSet) { try { _logger.LogInformation("Start of workflow process..."); HttpResponseMessageResult res = await _processAdapter.ProcessStart(idWorkflowConfig, idDataSet, idUserSet); if (res.IsSuccess) { _logger.LogInformation("Starting workflow process with success."); return(Ok(res)); } else { _logger.LogWarning(LoggingEvents.WARNING_ERROR, res.Message); return(StatusCode(500, res.Message)); } } catch (Exception ex) { _logger.LogError(LoggingEvents.CRITICAL_ERROR, ex.Message, ex); return(StatusCode(500, ex.Message)); } }
/// <summary> /// Permet de vérifier toutes les contraintes dans l'ordre d'une séquence de contraintes sur un SelectorInstance. /// </summary> /// <param name="sequences">Sequences de contraintes</param> /// <param name="selectorInstance">SelectorInstance cible</param> /// <param name="workflowInstance">WorkflowInstance</param> /// <param name="values">Valeurs à modifier</param> /// <returns>Message de retour</returns> public async Task <HttpResponseMessageResult> CheckConstraint(Constraint contrainte, long referenceSequence, int ordreSequence, ConstraintLevelEnum level, SelectorInstance selectorInstance, WorkflowInstance workflowInstance, IEnumerable <KeyValuePair <long, double> > values) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; if (contrainte.Type == ConstraintTypeEnum.Hardcode) { if (contrainte.Name == Constant.CONSTRAINT_TREESUM) { return(await CheckTreeSum(referenceSequence, ordreSequence, level, selectorInstance, workflowInstance)); } //if (contrainte.Name == Constant.ACTION_SPLIT_COPY) // ; //if (contrainte.Name == Constant.ACTION_AGREGATE_PRIMEUM) // ; } if (contrainte.Type == ConstraintTypeEnum.Dynamic) { // TODO } return(res); }
/// <summary> /// Démarre et initialise les SelectorConfig associés au WorkflowConfig original. /// </summary> /// <param name="wfInstance">WorkflowInstance nouvellement démarré</param> /// <returns>Message en cas de warning</returns> public async Task <HttpResponseMessageResult> StartSelectorsIntances(WorkflowInstance wfInstance) { if ((wfInstance == null) || (wfInstance.WorkflowConfig == null)) { throw new InitialiseWorkflowException("Process: can't find an instance of WorkflowInstance or WorkflowConfig!"); } if (wfInstance.DataSetId == 0) { throw new InitialiseWorkflowException("Process: no DataSet in Workflow!"); } if (wfInstance.UserSetId == 0) { throw new InitialiseWorkflowException("Process: no UserSet in Workflow!"); } ICollection <SelectorConfig> lstSelectConf = wfInstance.WorkflowConfig.SelectorConfig; HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; foreach (SelectorConfig selector in lstSelectConf) { HttpResponseMessageResult resLocal = await SelectorEngine.GenerateSelectorsInstances(selector, wfInstance); res.Append(resLocal); } return(res); }
/// <summary> /// Déclenche le PrevPropagate sur l'ensemble des selectorInstances issus du SelectorConfig original. /// </summary> /// <param name="selectIns">SelectorInstance</param> /// <param name="wfInstance">Workflow instance</param> /// <returns>Message</returns> public async Task <HttpResponseMessageResult> PrevPropagate(SelectorInstance selectIns, WorkflowInstance wfInstance) { if ((selectIns == null) || (selectIns.SelectorConfig == null)) { throw new SequenceException("Process.SelectorInstance.PrevPropagate: SelectorInstance or SelectorInstance.SelectorConfig is null."); } SelectorConfig selectConf = selectIns.SelectorConfig; // S'il y a d'autres SelectorConfig en PrevPropagate, on les lance avant if (selectConf.PrevPropagateId > 0) { SelectorConfig prevSelectConf = await UnitOfWork.GetDbContext() .SelectorConfig .Include(sc => sc.Criterias) .ThenInclude(c => c.Dimension) .Where(sc => sc.Id == selectConf.PrevPropagateId) .AsNoTracking() .ToAsyncEnumerable() .FirstOrDefault(); if (prevSelectConf == null) { throw new SequenceException("Process.SelectorConfig.Init: Bad PrevPropagate Id."); } HttpResponseMessageResult prevRes = await GenerateSelectorsInstances(prevSelectConf, wfInstance, selectIns); return(prevRes); } return(await NextStep(selectIns, wfInstance)); }
/// <summary> /// This function permits to do a MODIFY action. /// </summary> /// <param name="selectorInstance">SelectorInstance</param> /// <param name="wfInstance">Workflow instance</param> /// <param name="values">Valeurs à modifier</param> /// <returns>Message</returns> public async Task <HttpResponseMessageResult> Modify(SelectorInstance selectorInstance, WorkflowInstance wfInstance, IEnumerable <KeyValuePair <long, double> > values) { // Mise à jour de la table ValueObject IEnumerable <long> idsUpdated = values.Select(v => v.Key); List <ValueObject> lstVO = await UnitOfWork.GetDbContext().ValueObject .Where(vo => idsUpdated.Contains(vo.Id)) .ToAsyncEnumerable() .ToList(); Dictionary <long, double> dicVO = values.ToDictionary(k => k.Key, v => v.Value); foreach (ValueObject vo in lstVO) { if (!dicVO.ContainsKey(vo.Id)) { continue; } UnitOfWork.ValueObjectRepository.PrepareUpdateForObject(vo); vo.FutureValue = dicVO[vo.Id]; } int nbr = await UnitOfWork.GetDbContext().SaveChangesAsync(); // Mise à jour de la table temporaire HttpResponseMessageResult res = await GridConfigurationDomain.SaveDataInTemporyTable(selectorInstance, selectorInstance.WorkflowInstance, values); return(res); }
/// <summary> /// Génére tous les SelectorInstance depuis les criteria donnés. /// </summary> /// <param name="selectConf">SelectorConfig cible</param> /// <param name="wfInstance">WorkflowInstance nouvellement démarré</param> /// <param name="parent">Eventuel SelectorInstance pouvant être à l'origine de la création de nouvelles instances</param> /// <returns>Message de résultat</returns> public async Task <HttpResponseMessageResult> GenerateSelectorsInstances(SelectorConfig selectConf, WorkflowInstance wfInstance, SelectorInstance parent = null) { if (selectConf == null) { throw new SequenceException("Process.SelectorConfig.Init: SelectorConfig are null."); } if (selectConf.Criterias == null) { throw new DataLoadingException("SelectorConfig : Criterias not loaded!"); } // WOR-174 - Créer en chaine les SelectorInstance selon la liste de Criterias... // On passe directement les criteria valorisés dans la requête de sélection... IEnumerable <IEnumerable <CriteriaValues> > lstCV = await CriteriaDomain.ExtractAllCriteriaValues(selectConf.Criterias, wfInstance); IEnumerable <IEnumerable <CriteriaValues> > lstCrit = await GetValueObjectsFromCriteria(lstCV, wfInstance.DataSetId); HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; foreach (IEnumerable <CriteriaValues> cvs in lstCrit) { SelectorInstance si = await SelectorInstanceDomain.Create(selectConf, cvs, parent, wfInstance); UnitOfWork.SelectorInstanceRepository.PrepareUpdateForObject(si); res.Append(await NextStep(si, wfInstance)); } return(res); }
/// <summary> /// Modifie les données d'un SelectorInstance. Les données sont d'abord sauvées, puis le SelectorInstance passe en Act et en Constraints. /// </summary> /// <param name="selectorInstanceId">Id du SelectorInstance</param> /// <param name="values">Valeurs à modifier</param> /// <remarks>Les valeurs à modifier sont au format suivant : {id de la cellule}:{nouvelle valeur}</remarks> /// <returns>Message à modifier</returns> public async Task <HttpResponseMessageResult> SaveData(long selectorInstanceId, IEnumerable <KeyValuePair <long, double> > values) { // Création de la transaction using (IDbContextTransaction transaction = UnitOfWork.GetDbContext().Database.BeginTransaction()) { SessionStatsHelper.HttpHitSaveDBTransaction(transaction, _serviceProvider); // Recherche du selectorInstance List <SelectorInstance> lstSelectInst = await UnitOfWork.GetDbContext().SelectorInstance .Where(si => si.Id == selectorInstanceId) .Include(si => si.SelectorConfig) .Include(si => si.WorkflowInstance) .ThenInclude(wfi => wfi.WorkflowConfig) .ToAsyncEnumerable() .ToList(); SelectorInstance selectorInstance = lstSelectInst.FirstOrDefault(); if (selectorInstance == null) { throw new WrongParameterException($"SelectorEngine.SaveData: bad SelectorInstance Id ({selectorInstanceId})."); } // On pousse les valeurs volatiles vers les futures valeurs. HttpResponseMessageResult res = await SelectorInstanceDomain.PushVolatileToFuture(selectorInstance); // Passage aux étapes suivantes UnitOfWork.SelectorInstanceRepository.PrepareUpdateForObject(selectorInstance); res.Append(await NextStep(selectorInstance, selectorInstance.WorkflowInstance, SelectorStateEnum.Init, values)); transaction.Commit(); return(res); } }
/// <summary> /// This function permits to build a success response. /// </summary> /// <param name="response">HttpResponseMessage</param> /// <returns>HttpResponseMessageResult</returns> protected async Task <HttpResponseMessageResult> SuccessResponse(HttpResponseMessage response) { string body = await response.Content.ReadAsStringAsync(); HttpResponseMessageResult responseResult = null; try { responseResult = JsonConvert.DeserializeObject <HttpResponseMessageResult>(body); } catch { } if (responseResult == null) { responseResult = new HttpResponseMessageResult() { IsSuccess = response.StatusCode == HttpStatusCode.OK, Json = body } } ; // Déjà testé //responseResult.IsSuccess = response.StatusCode == HttpStatusCode.OK; responseResult.StatusCode = (int)response.StatusCode; return(responseResult); } }
public async Task <IActionResult> Filter( string[] select = null, string[] where = null, string[] sort_asc = null, string[] sort_desc = null, bool grouping = false, int?page = null, int?pageSize = null) { try { IEnumerable <ValueObject> lst = await Adapter.Filter(select, where, sort_asc, sort_desc, grouping, page, pageSize); HttpResponseMessageResult data = new HttpResponseMessageResult() { IsSuccess = true, Json = JsonConvert.SerializeObject(lst) }; return(Ok(data)); } catch (Exception ex) { Logger.LogError(LoggingEvents.PROCESS_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
public async Task <IActionResult> Import([FromBody] IEnumerable <ValueObject> valueObjects) { try { if (ModelState.IsValid) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; IEnumerable <long> data = await Adapter.Import(valueObjects); res.GetObjectForJson(data); return(Ok(res)); } HttpResponseMessageResult err = new HttpResponseMessageResult() { IsSuccess = false }; foreach (ModelError mdErr in ModelState.Values.SelectMany(v => v.Errors)) { err.Message += $"{mdErr?.ErrorMessage} : {mdErr?.Exception?.Message}"; } return(StatusCode(500, err)); } catch (Exception ex) { Logger.LogError(LoggingEvents.PROCESS_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
public async Task <IActionResult> Add([FromBody] WorkflowConfig workflowConfig) { try { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; workflowConfig = await Adapter.Post(workflowConfig); if (workflowConfig != null) { res.Json = JsonConvert.SerializeObject(workflowConfig); } else { res.IsSuccess = false; res.Message = "Unable to create WorkflowConfig object."; } return(Ok(res)); } catch (Exception ex) { Logger.LogError(LoggingEvents.CRITICAL_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
/// <summary> /// Exécute une action sur un SelectorInstance /// </summary> /// <param name="action">Action</param> /// <param name="referenceSequence">Référence de la séquence d'action</param> /// <param name="OrderSequence">Numéro d'ordre de l'action dans la séquence</param> /// <param name="selectorInstance">SelectorInstance</param> /// <param name="wfInstance">WorkflowInstance</param> /// <param name="values">Valeurs à modifier</param> /// <returns>Message de retour</returns> public async Task <HttpResponseMessageResult> ExecuteAction(ENT.Action action, long referenceSequence, int OrderSequence, SelectorInstance selectorInstance, WorkflowInstance wfInstance, IEnumerable <KeyValuePair <long, double> > values) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; if (action.Type == ActionTypeEnum.Hardcode) { if (action.Name == Constant.ACTION_SPLIT_PRIMEUM) { return(await ExecuteSplitPrimeum(referenceSequence, OrderSequence, selectorInstance, wfInstance)); } if (action.Name == Constant.ACTION_SPLIT_COPY) { return(await ExecuteSplitCopy(referenceSequence, OrderSequence, selectorInstance, wfInstance)); } if (action.Name == Constant.ACTION_AGREGATE_PRIMEUM) { return(await ExecuteAggregatePrimeum(referenceSequence, OrderSequence, selectorInstance, wfInstance)); } } if (action.Type == ActionTypeEnum.Dynamic) { // TODO } return(res); }
/// <summary> /// Prend un texte json contenant la configuration et le prépare pour le traitement. /// </summary> /// <param name="plainText">Texte contenant le json</param> public HttpResponseMessageResult GetJson(string plainText) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; try { JToken jsonTokens = JToken.Parse(plainText); int cpt = 1; foreach (JToken token in jsonTokens.Children()) { try { string serviceName = token[JSON_KEY_SERVICENAME].ToString(); string httpVerb = token[JSON_KEY_HTTPVERB]?.ToString() ?? HTTP_VERB_POST; string subServiceName = token[JSON_KEY_SUBSERVICENAME]?.ToString(); List <KeyValuePair <string, string> > lstQuery = null; if (token[JSON_KEY_QUERYSTRING]?.HasValues ?? false) { lstQuery = DeserializeListKeyValuePair(token[JSON_KEY_QUERYSTRING] as JObject); } string jsonBody = null; if (token[JSON_KEY_BODY] != null) { jsonBody = token[JSON_KEY_BODY].ToString(); } KeyValuePair <string, string> pairedReturn = new KeyValuePair <string, string>(null, null); // Type struct, la variable garde en mémoire les valeurs précédentes si on ne l'initialise pas. if (token[JSON_KEY_RETURN]?.HasValues ?? false) { pairedReturn = DeserializeKeyValuePair(token[JSON_KEY_RETURN] as JObject); } _jsonServiceObjects.Add(Tuple.Create(serviceName, httpVerb, subServiceName, lstQuery as IEnumerable <KeyValuePair <string, string> >, pairedReturn, jsonBody)); } catch (Exception ex) { res.IsSuccess = false; res.Message += $"Service n° {cpt} - Erreur sur la lecture d'un service : {ex.Message}"; } cpt++; } } catch (Exception glEx) { res.IsSuccess = false; res.Message += $"Erreur sur la lecture du fichier : {glEx.Message}"; } return(res); }
public async Task <HttpResponseMessageResult> Finish(SelectorInstance selectorInstance, WorkflowInstance wfInstance) { HttpResponseMessageResult res = new HttpResponseMessageResult(); if (selectorInstance.ParentSelectorInstanceId != 0) { // Construire l'appel pour passer en NoWait le parent. } return(res); }
/// <summary> /// This function permits to build an exception response. /// </summary> /// <param name="exception">HttpRequestException</param> /// <returns>HttpResponseMessageResult</returns> protected static HttpResponseMessageResult ExceptionResponse(HttpRequestException exception) { HttpResponseMessageResult responseResult = new HttpResponseMessageResult() { ErrorHasDisplay = true, Message = string.Format("{0}({1})", exception?.Message ?? "", exception?.Source ?? ""), StatusCode = (int)(((WebException)exception?.InnerException)?.Status ?? 0), }; return(responseResult); }
/// <summary> /// Etabli l'étape Constraint. /// </summary> /// <param name="selectorInstance">SelectorInstance</param> /// <param name="wfInstance">Workflow Instance</param> /// <param name="values">Valeurs à modifier</param> /// <returns>Message de retour</returns> public async Task <HttpResponseMessageResult> Constraint(SelectorInstance selectorInstance, WorkflowInstance wfInstance, IEnumerable <KeyValuePair <long, double> > values) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; if (selectorInstance == null) { throw new WrongParameterException("SelectorEngine.Constraint : SelectorInstance is null."); } if (selectorInstance.SelectorConfig == null) { throw new DataLoadingException($"SelectorEngine.Constraint : SelectorConfig of SelectorInstance (Id = {selectorInstance.Id}) is null."); } if (wfInstance == null) { throw new WrongParameterException("SelectorEngine.Constraint : WorkflowInstance is null."); } if (wfInstance.WorkflowConfig == null) { throw new DataLoadingException($"SelectorEngine.Constraint : WorkflowConfig of WorkflowInstance (Id = {wfInstance.Id}) is null."); } long refSeq = -1; if (selectorInstance.SelectorConfig.ConstraintSequenceRef >= 0) { refSeq = selectorInstance.SelectorConfig.ConstraintSequenceRef; } else if (wfInstance.WorkflowConfig.ConstraintSequenceRef >= 0) { refSeq = wfInstance.WorkflowConfig.ConstraintSequenceRef; } if (refSeq >= 0) { List <ConstraintSequence> lstSeqConstraints = await UnitOfWork.GetDbContext().ConstraintSequence .Where(a => a.Reference == refSeq) .OrderBy(a => a.Order) .Include(a => a.Constraint) .AsNoTracking() .ToAsyncEnumerable() .ToList(); res.Append(await ConstraintSequenceDomain.CheckConstraintSequence(lstSeqConstraints, selectorInstance, wfInstance, values)); } return(res); }
public async Task <IActionResult> ReadData(long selectorInstanceId, string[] filter, int start, int length, int sortCol, string sortDir) { try { HttpResponseMessageResult data = await Adapter.ReadData(selectorInstanceId, filter, start, length, sortCol, sortDir); return(Ok(data)); } catch (Exception ex) { Logger.LogError(LoggingEvents.PROCESS_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
/// <summary> /// Remplie la liste where donnée en paramétre d'expression permettant de filtrer la table ValueObject selon les listes de CriteriaValues. /// </summary> /// <param name="where">Liste d'expression qui va recevoir les filtres (Sortie)</param> /// <param name="lstCriteriaValues">Listes des CriteriaValues utilisées pour les filtres</param> /// <param name="idsDimensionDS">Dictionnaire des DimensionDataSet par Id.</param> /// <param name="isLargeSearch">Créé une recherche stricte ou large (dans le cas d'arbre notamment)</param> /// <returns>Message de retour</returns> public HttpResponseMessageResult BuildFilterRequest(List <Expression <Func <ValueObject, bool> > > where, IEnumerable <IEnumerable <CriteriaValues> > lstCriteriaValues, Dictionary <long, DataSetDimension> idsDimensionDS, bool isLargeSearch) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; Dictionary <long, IEnumerable <CriteriaValues> > dico = CriteriaValuesDomain.GetCriteriaValuesByDimension(lstCriteriaValues); foreach (long dimensionId in dico.Keys) { DataSetDimension dsd = idsDimensionDS.Where(k => k.Value.Dimension.Id == dimensionId).Select(k => k.Value).FirstOrDefault(); if (dsd == null) { res.Message += $"ValueObjectDomain:BuildFilterRequest: Error, no Dimension column for this id ({dimensionId})!"; res.IsSuccess = false; continue; } string nomDimension = idsDimensionDS[dsd.Id].ColumnName; IEnumerable <string> values = dico[dimensionId].Select(cv => cv.Value); if (isLargeSearch && (idsDimensionDS[dsd.Id].Dimension.TypeDimension == DimensionTypeEnum.Tree)) { if (values.Count() > 1) { where.Add(HelperGetFilterByTreeDimension(nomDimension, values)); } else if (values.Count() == 1) { where.Add(HelperGetFilterByTreeDimension(nomDimension, values.ElementAt(0))); } } else { if (values.Count() > 1) { where.Add(HelperGetFilterByDimension(nomDimension, values)); } else if (values.Count() == 1) { where.Add(HelperGetFilterByDimension(nomDimension, values.ElementAt(0))); } } } return(res); }
public async Task <IActionResult> BindUserToUserSet(long userSetId, [FromBody] IEnumerable <DTO.UserSetUser> userSetUser) { try { HttpResponseMessageResult res = await Adapter.BindUserToUserSet(userSetId, userSetUser); return(Ok(res)); } catch (Exception ex) { Logger.LogError(LoggingEvents.PROCESS_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
public async Task <IActionResult> InitializeDistinctValue(long dataSetId) { try { HttpResponseMessageResult res = await Adapter.InitializeDistinctValue(dataSetId); return(Ok(res)); } catch (Exception ex) { Logger.LogError(LoggingEvents.CRITICAL_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
public async Task <IActionResult> BindValueObjectToDataSet(long dataSetId, [FromBody] IEnumerable <long> valueObjectIds) { try { HttpResponseMessageResult res = await Adapter.BindValueObjectToDataSet(dataSetId, valueObjectIds); return(Ok(res)); } catch (Exception ex) { Logger.LogError(LoggingEvents.CRITICAL_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
/// <summary> /// Ajoute un commentaire en base /// </summary> /// <param name="comment">Commentaire</param> /// <returns>Message de retour</returns> public async Task <HttpResponseMessageResult> Post(DTO.Comment comment) { ENT.Comment element = Mapper.Map <DTO.Comment, ENT.Comment>(comment); comment = Mapper.Map <ENT.Comment, DTO.Comment>(await CommentDomain.Add(element)); HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; res.Json = JsonConvert.SerializeObject(comment); return(res); }
public void SetUp() { httpResponseMessage = new HttpResponseMessage { StatusCode = (System.Net.HttpStatusCode) 200, ReasonPhrase = Reason, }; httpResponseMessage.Headers.Add("my-custom-header", "val 1"); httpResponseMessage.Content = new StringContent("Your response text"); httpResponseMessage.Content.Headers.Add("my-custom-content-header", "val 1"); httpResponseMessageResult = new HttpResponseMessageResult(httpResponseMessage); }
/// <summary> /// Lie les utilisateurs donnés en entrée à un UserSet. /// </summary> /// <param name="userSetId">Id de l'UserSet</param> /// <param name="userSetUser">Liste des liens d'utilisateur</param> /// <returns>Message de retour</returns> public async Task <HttpResponseMessageResult> BindUserToUserSet(long userSetId, IEnumerable <UserSetUser> userSetUser) { if (userSetUser == null) { throw new WrongParameterException("UserSetDoamin.BindUserToUserSet : List's UserSetUser is null."); } UserSet userSet = await UnitOfWork.UserSetRepository.GetById(userSetId); if (userSet == null) { throw new WrongParameterException($"UserSetDoamin.BindUserToUserSet : no UserSet for id = {userSetId}"); } HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; foreach (UserSetUser usu in userSetUser) { if (usu.User == null) { res.Message += $"UserSetUser (id = {usu.Id}) has not set User id."; continue; } User u = await UnitOfWork.UserRepository.GetById(usu.User.Id); if (u == null) { res.Message += $"UserSetUser's User (id = {usu.User.Id}) don't exist."; continue; } UnitOfWork.UserSetUserRepository.PrepareAddForObject(usu); usu.UserSet = userSet; usu.User = u; } int nbr = await UnitOfWork.GetDbContext().SaveChangesAsync(); if (nbr <= 0) { throw new DatabaseException("UserSetDoamin.BindUserToUserSet : impossible to save UserSetUser."); } return(res); }
/// <summary> /// Sélectionne les données modifiables du SelectorInstance. /// </summary> /// <param name="selectorInstance">SelectorInstance</param> /// <param name="wfInstance">WorkflowInstance</param> /// <param name="idsDimensionDS">Dictionnaire de DimensionDataSet par Id</param> /// <returns>Message de retour</returns> public async Task <HttpResponseMessageResult> SetModifyData(SelectorInstance selectorInstance, WorkflowInstance wfInstance, Dictionary <long, DataSetDimension> idsDimensionDS) { if (selectorInstance == null) { throw new WrongParameterException($"SelectorInstanceDomain.SetModifyData: SelectorInstance is null."); } if (selectorInstance.SelectorConfig == null) { throw new WrongParameterException($"SelectorInstanceDomain.SetModifyData: SelectorConfig is null (Id SelectorInstance : {selectorInstance.Id})."); } if (selectorInstance.SelectorConfig.ModifyCriterias == null) { throw new SequenceException($"SelectorInstance.SetModifyData : no ModifyCriterias for values found, error in SelectorConfig. Id SelectorConfig : {selectorInstance.SelectorConfig.Id}"); } HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; IEnumerable <IEnumerable <CriteriaValues> > lstCv = await CriteriaDomain.ExtractAllCriteriaValues(selectorInstance.SelectorConfig.ModifyCriterias, wfInstance); List <Expression <Func <ValueObject, bool> > > where = new List <Expression <Func <ValueObject, bool> > >(); res.Append(ValueObjectDomain.BuildFilterRequest(where, lstCv, idsDimensionDS, false)); if (where.Count > 0) { IQueryable <ValueObject> dbQuery = UnitOfWork.GetDbContext().Set <ValueObject>(); IEnumerable <long> lstIdsValueObject = await where .Aggregate(dbQuery, (current, predicate) => current.Where(predicate)) .Include(vo => vo.SelectorInstanceValueObject) .Where(vo => vo.SelectorInstanceValueObject.Any(sivo => sivo.SelectorInstanceId == selectorInstance.Id)) .Select(vo => vo.Id) .ToAsyncEnumerable() .ToList(); foreach (SelectorInstanceValueObject subSivo in selectorInstance.SelectorInstanceValueObject.Where(sivo => lstIdsValueObject.Contains(sivo.ValueObjectId))) { subSivo.IsEditable = true; } int nbr = await UnitOfWork.GetDbContext().SaveChangesAsync(); } return(res); }
public async Task <IActionResult> Get(long workflowConfigId, long datasetId) { string culture = CultureInfo.CurrentCulture.Name; HttpResponseMessageResult rm = new HttpResponseMessageResult() { IsSuccess = false, ErrorHasDisplay = true, //AdditionalMessage = HttpContext.Request.QueryString.ToString(), //AdditionalMessage = _localizer["HelloTest"] + " " + culture, StatusCode = 500 }; try { if (Request.QueryString.HasValue) { _logger.LogInformation("Start of workflow process..."); //await _processAdapter.ProcessStart(workflowConfigId, datasetId); rm.IsSuccess = true; rm.ErrorHasDisplay = false; rm.StatusCode = 200; _logger.LogInformation("End of workflow process."); } else { throw new Exception(); } } catch (Exception ex) { rm.Message = ex.Message; _logger.LogError(LoggingEvents.PROCESS_ERROR, ex.Message, ex); } if (rm.IsSuccess) { return(Ok(rm)); } else { return(StatusCode(500, rm)); } }
/// <summary> /// Méthode de split hardcodé /// </summary> /// <param name="referenceSequence">Référence de la séquence d'action</param> /// <param name="OrderSequence">Numéro d'ordre de l'action dans la séquence</param> /// <param name="selectorInstance">SelectorInstance</param> /// <param name="wfInstance">WorkflowInstance</param> /// <returns>Message de retour</returns> private async Task <HttpResponseMessageResult> ExecuteSplitPrimeum(long referenceSequence, int OrderSequence, SelectorInstance selectorInstance, WorkflowInstance wfInstance) { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; // Récupération du nom de la dimension de la secto et du dictionnaire des objects. string nomDimension = await Split_GetDimensionName(referenceSequence, OrderSequence, wfInstance); Dictionary <long, Tuple <ValueObject, int, string, bool> > dicAllVo = await ValueObjectDomain.CreateDictionaryVO(nomDimension, selectorInstance); HashSet <KeyValuePair <long, double> > modifiedValues = new HashSet <KeyValuePair <long, double> >(); // On créé la queue pour parcourir l'arbre procéduralement. Queue <ValueObject> voToSplit = new Queue <ValueObject>(); foreach (ValueObject vo in dicAllVo.Values.Where(val => val.Item4).OrderBy(val => val.Item2).Select(val => val.Item1).ToList()) { voToSplit.Enqueue(vo); } // Parcours des noeuds while (voToSplit.Count > 0) { ValueObject node = voToSplit.Dequeue(); IEnumerable <ValueObject> children = GetChildren(node, nomDimension, dicAllVo); string format = await ValueObjectDomain.GetNumericalFormat(node.TypeValue, wfInstance.DataSetId); if ((children != null) && (children.Count() > 0)) { Split_ApplyDivisionOnChildren(node, children, voToSplit, dicAllVo, modifiedValues, format); } } // On sauve les modifications int nbr = await UnitOfWork.GetDbContext().SaveChangesAsync(); // Mise à jour de la table temporaire res.Append(await GridConfigurationDomain.SaveDataInTemporyTable(selectorInstance, wfInstance, modifiedValues)); return(res); }
/// <summary> /// Build the dashBoard grid /// </summary> /// <param name="userId">Id from User</param> public async Task BuildStructureGrid(long userId) { List <DashBoardWorkflowModel> _dashBoardWorkflows = new List <DashBoardWorkflowModel>(); AbstractServiceFactory service = _serviceFacade[ServiceFacade.SERVICENAME_USER]; HttpResponseMessageResult result = await service.Get("GetWorkflowInstance", new List <KeyValuePair <string, string> >() { new KeyValuePair <string, string>("userId", userId.ToString()) }); if (result != null && !string.IsNullOrWhiteSpace(result.Json)) { IEnumerable <WorkflowInstance> workflowInstances = JsonConvert.DeserializeObject <List <WorkflowInstance> >(result.Json); foreach (WorkflowInstance workflowInstance in workflowInstances) { _dashBoardWorkflows.Add(await SetDashBoardWorkflowModel(workflowInstance)); } } DashBoardWorkflows = _dashBoardWorkflows; }
public async Task <IActionResult> Add([FromBody] ConstraintParameter constraintParameter, long constraintSequenceId) { try { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; constraintParameter = await Adapter.AddConstraintParameter(constraintParameter, constraintSequenceId); res.GetObjectForJson(constraintParameter); return(Ok(res)); } catch (Exception ex) { Logger.LogError(LoggingEvents.CRITICAL_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }
public async Task <IActionResult> AddDataSetDimension([FromBody] DataSetDimension dataSetDimension, long dataSetId, long dimensionId) { try { HttpResponseMessageResult res = new HttpResponseMessageResult() { IsSuccess = true }; dataSetDimension = await Adapter.AddDataSetDimension(dataSetDimension, dataSetId, dimensionId); res.GetObjectForJson(dataSetDimension); return(Ok(res)); } catch (Exception ex) { Logger.LogError(LoggingEvents.CRITICAL_ERROR, ex, ex.Message); return(StatusCode(500, ex.Message)); } }