Exemplo n.º 1
0
        /// <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);
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// This method permits to open and start the workflow
        /// </summary>
        /// <param name="workflowConfig">WorkflowConfig Id</param>
        /// <param name="dataSet">DataSet Id</param>
        public async Task <HttpResponseMessageResult> Open(long workflowConfigId, long dataSetId, long idUserSet)
        {
            // Création de la transaction
            using (IDbContextTransaction transaction = UnitOfWork.GetDbContext().Database.BeginTransaction())
            {
                SessionStatsHelper.HttpHitSaveDBTransaction(transaction, _serviceProvider);

                // On récupére les entités
                WorkflowConfig wfConf = await UnitOfWork.GetDbContext().WorkflowConfig
                                        .Include(wf => wf.SelectorConfig)
                                        .ThenInclude(sc => sc.Criterias)
                                        .ThenInclude(c => c.Dimension)
                                        .Include(wf => wf.SelectorConfig)
                                        .ThenInclude(sc => sc.Modifiers)
                                        .ThenInclude(c => c.Dimension)
                                        .Include(wf => wf.SelectorConfig)
                                        .ThenInclude(sc => sc.Validators)
                                        .ThenInclude(c => c.Dimension)
                                        .Include(wf => wf.SelectorConfig)
                                        .ThenInclude(sc => sc.ModifyCriterias)
                                        .ThenInclude(c => c.Dimension)
                                        .Include(wf => wf.WorkflowDimension)
                                        .ThenInclude(wd => wd.Dimension)
                                        .Where(wf => wf.Id == workflowConfigId)
                                        .AsNoTracking()
                                        .ToAsyncEnumerable()
                                        .FirstOrDefault();

                DataSet dtSet = await UnitOfWork.GetDbContext().DataSet
                                .Include(d => d.DataSetDimensions)
                                .Where(d => d.Id == dataSetId)
                                .AsNoTracking()
                                .ToAsyncEnumerable()
                                .FirstOrDefault();

                UserSet usrSet = await UnitOfWork.GetDbContext().UserSet
                                 .Where(u => u.Id == idUserSet)
                                 .AsNoTracking()
                                 .ToAsyncEnumerable()
                                 .FirstOrDefault();

                if ((wfConf == null) || (dtSet == null) || (usrSet == null))
                {
                    return new HttpResponseMessageResult()
                           {
                               IsSuccess = false, Message = $"Can't get WorkflowConfig with id {workflowConfigId}, DataSet with id {dataSetId}, UserSet with id {idUserSet}"
                           }
                }
                ;

                if (!CheckDimensions(wfConf, dtSet, usrSet))
                {
                    throw new SequenceException("Process.Open: WorkflowDimensions are not equals to DataSetDimensions.");
                }

                // Create the workflow instance
                WorkflowInstance workflowInstance = await WorkflowInstanceDomain.CreateInstance(wfConf, dtSet, usrSet);

                // Générer les SelectorInstance.
                HttpResponseMessageResult res = await WorkflowInstanceDomain.StartSelectorsIntances(workflowInstance);

                transaction.Commit();
                return(res);
            }
        }