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