protected override bool ActionBody(BaseProcess action)
        {
            bool    isProcessed  = true;
            IAction updateAction = null;


            try
            {
                Guid enterpriseId         = GetValue <Guid>(ARG_PAGE_ENTERPRISE_ID);
                bool removeIsAbsent       = GetValue <bool>(ARG_REMOVE_IS_ABSENT);
                var  stockEntriesOutbound = GetValue <IEnumerable <Guid> >(ARG_STOCK_ENTRY_IDS);

                LocalContext.SaveLog(
                    $"{MoscowDateTimeOffset().ToString()} Начало обработки ответов от системы Меркурий.");

                // Получение последнего номера шага
                IList <MercuryQueueStepModel> responses = StepService.GetStepsByStatus(QueryId, null, 0, "0.0", null);

                IList <MercuryQueueStepModel> completed = responses.Where(r =>
                                                                          r.StatusName == MQSStatus.COMPLETE.ToString() && r.ProcessMark != Consts.PROCESSED_MARK).ToList();

                bool        anyError   = responses.Any(x => x.StatusName != MQSStatus.COMPLETE.ToString());
                List <Guid> updIds     = GetValue <List <Guid> >(ARG_UPDATED_STOCK_ENTRY_IDS);
                List <Guid> skippedIds = GetValue <List <Guid> >(ARG_SKIPEED_STOCK_ENTRY_IDS);

                // Обработка успешных ответов
                if (completed.Count > 0)
                {
                    foreach (MercuryQueueStepModel step in completed)
                    {
                        if (NeedStopSteps())
                        {
                            LocalContext.SaveLog(
                                $" Выполннение прервано (StopQueueSteps). Выполнение будет продолжено после запуска очереди.");
                            SetValue("Status", MQSStatus.STOPPED);
                            return(true);
                        }

                        MercuryNS.Body body =
                            ParseMercuryHelper.ParseBodyResponseFile(Path.Combine(MercurySettings.ResponseDirectory,
                                                                                  step.FileResponse));
                        if (body.ReceiveApplicationResultResponse != null &&
                            body.ReceiveApplicationResultResponse.Application != null)
                        {
                            MercuryNS.GetStockEntryListResponse response =
                                body.ReceiveApplicationResultResponse.Application.Result as
                                MercuryNS.GetStockEntryListResponse;
                            MercuryNS.StockEntryList stockEntriesFromMerc = response?.StockEntryList;
                            if (stockEntriesFromMerc != null && stockEntriesFromMerc.Count > 0)
                            {
                                LocalContext.SaveLog(
                                    $" Обработка файла ответа от Меркурия. Имя файла {step.FileResponse}.");

                                var queryForPullStockEntryGuids = new DocumentQuery(GetService <IMethaStorage>(), GetService <IQueryGenerator>(), GetService <ICacheManager>());
                                queryForPullStockEntryGuids
                                .ResultField("SE", "@Id")
                                .ResultField("SE", "GUID")
                                .Using("StockEntry", "SE", ObjectStatus.osActive);
                                queryForPullStockEntryGuids.Where(w => w.Or(o =>
                                {
                                    foreach (var seId in stockEntriesOutbound)
                                    {
                                        o.EQ("@Id", seId);
                                    }
                                }));

                                var seOutboundIds = LocalReader.QueryDocuments(queryForPullStockEntryGuids).Result.Select(d => d["GUID"]);

                                var stockEntriesFromMip = LoadStockEntriesFromMIP(stockEntriesFromMerc);

                                foreach (var se in stockEntriesFromMerc.Where(d => seOutboundIds.Contains(d.GUID)))
                                {
                                    var seFromMIP = stockEntriesFromMip.FirstOrDefault(d => (string)d["GUID"] == (string)se.GUID);

                                    if ((double)se.Batch.Volume < (double)seFromMIP["Volume"])
                                    {
                                        isProcessed = false;
                                        LocalContext.SaveLog(
                                            $" Выписка уже производилась");
                                    }

                                    if ((string)se.UUID != (string)seFromMIP["UUID"])
                                    {
                                        isProcessed = false;
                                        LocalContext.SaveLog(
                                            $" Выписка уже производилась");
                                    }
                                }
                            }
                            else
                            {
                                LocalContext.SaveLog(
                                    $" Файл ответа {step.FileResponse} от системы 'Меркурий' не содержит информацию о складских записях.");
                            }
                        }
                        else
                        {
                            anyError = true;
                            body.Fault.ToString();
                            // TODO сохранить ошибку в логе
                            //body.Fault
                            ResultDescription = "Система 'Меркурий' вернула исключение";
                        }
                    }
                }
                else
                {
                    isProcessed       = false;
                    ResultDescription = "Нет успешно обработанных ответов";
                    LocalContext.SaveLog(ResultDescription);
                }

                var notCompleted = responses.Where(r => r.StatusName != MQSStatus.COMPLETE.ToString());
                foreach (var nc in notCompleted)
                {
                    AppendUserErrorInfoFromXML(nc, Guid.Empty, null, null);
                }

                if (string.IsNullOrWhiteSpace(ResultDescription))
                {
                    ResultDescription = "Обработаны ответы от системы 'Меркурий'.";
                }
            }
            catch (ConcurrencyDocException except)
            {
                isProcessed = false;
                DefaultConcurrentExceptionLog(except);
            }
            catch (Exception e)
            {
                AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_MIP,
                                    UserErrorConsts.StockList.RTE_PROCESS_RESPONSE, UserErrorConsts.DEFAULT_LAS_SUPPRT_ERROR);
                isProcessed = false;
                LocalContext.SaveLog(e.ToString());
                ResultDescription = "Ошибка анализа результатов";
            }

            LocalContext.SaveLog(
                $"{MoscowDateTimeOffset().ToString()} Окончание обработки ответов от системы 'Меркурий'.");
            return(isProcessed);
        }
        protected override bool ActionBody(BaseProcess action)
        {
            bool isProcessed = true;

            SetValue(ARG_PAGE_COUNT, 0);
            try {
                LocalContext.SaveLog($"{MoscowDateTimeOffset().ToString()} Начало обработки ответов от системы 'Меркурий'.");

                IList <MercuryQueueStepModel> responses = StepService.GetStepsByStatus(QueryId, null, 0, "0.0_001", Consts.OP_GROUP_CHECK_FOR_COMPLETED_OUTBOUND);
                MercuryQueueStepModel         completed = responses.Where(r => r.StatusName == MQSStatus.COMPLETE.ToString()).FirstOrDefault();

                IList <Guid> updIds = new List <Guid>();
                // Обработка успешных ответов
                if (completed != null)
                {
                    MercuryNS.Body body = ParseMercuryHelper.ParseBodyResponseFile(Path.Combine(MercurySettings.ResponseDirectory, completed.FileResponse));
                    if (body.ReceiveApplicationResultResponse != null && body.ReceiveApplicationResultResponse.Application != null)
                    {
                        MercuryNS.GetStockEntryListResponse response = body.ReceiveApplicationResultResponse.Application.Result as MercuryNS.GetStockEntryListResponse;
                        MercuryNS.StockEntryList            list     = response?.StockEntryList;
                        if (list != null)
                        {
                            int totalItems = list.Total;
                            if (totalItems > 0)
                            {
                                ISystemSettingManager systemSettings = GetService <ISystemSettingManager>();
                                int maxPageCount = systemSettings.GetByPrefix <int>("MIP_OP_GET_STOCK_ENTRY_LIST_PAGE_COUNT", 10);
                                if (maxPageCount < 1)
                                {
                                    maxPageCount = 1;
                                    LocalContext.SaveLog($"Минимальное количество запрашиваемых страниц: 1.");
                                }
                                int pageSize = systemSettings.GetByPrefix <int>("MIP_OP_GET_STOCK_ENTRY_LIST_PAGE_SIZE", 250);
                                if (pageSize < 1)   // проверка отрицательного значения и = 0
                                {
                                    pageSize = 1;
                                    LocalContext.SaveLog($"Минимальное количество элементов при зпросе 1.");
                                }
                                int currentPageCount = totalItems / pageSize + ((totalItems % pageSize) > 0 ? 1 : 0);
                                if (currentPageCount > maxPageCount)
                                {
                                    LocalContext.SaveLog($"Количество страниц первышает максимально возможное в запросе. Расчитанне количество страниц: {currentPageCount}");
                                    currentPageCount = maxPageCount;
                                }
                                LocalContext.SaveLog($"Будет запрошено {currentPageCount} страниц с количеством элементов на страницу {pageSize}");
                                SetValue(ARG_PAGE_SIZE, pageSize);
                                SetValue(ARG_PAGE_COUNT, currentPageCount);
                                SetValue(ARG_PAGE_START, 1);
                                ResultDescription = "Количество страниц расчитанно.";
                            }
                            else
                            {
                                LocalContext.SaveLog("Площадка не содержит складских записей.");
                                ResultDescription = "Площадка не содержит складских записей.";
                            }
                        }
                    }
                    else
                    {
                        isProcessed = false;
                        AppendUserErrorInfoFromXML(completed, Guid.Empty, null, null);
                        LocalContext.SaveLog("Ошибка при ответе системы 'Меркурий'. Смотри файл ответа от системы 'Меркурий'.");
                        ResultDescription = "Система 'Меркурий' вернула исключение";
                    }
                }
                else
                {
                    MercuryQueueStepModel notcompleted = responses.Where(r => r.StatusName != MQSStatus.COMPLETE.ToString()).FirstOrDefault();
                    if (notcompleted != null)
                    {
                        AppendUserErrorInfoFromXML(notcompleted, Guid.Empty, null, null);
                    }

                    isProcessed       = false;
                    ResultDescription = "Ошибка анализа числа страниц.";
                    LocalContext.SaveLog("Ошибка автоматического вычисления количества страниц для запроса.");
                }
            } catch (Exception e) {
                AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_MIP, UserErrorConsts.StockList.RTE_CALC_PAGES, UserErrorConsts.DEFAULT_LAS_SUPPRT_ERROR);
                isProcessed = false;
                LocalContext.SaveLog(e.ToString());
                ResultDescription = "Ошибка анализа числа страниц.";
            }
            LocalContext.SaveLog($"{MoscowDateTimeOffset().ToString()} Окончание обработки ответов от системы 'Меркурий'.");
            return(isProcessed);
        }
Example #3
0
        protected override bool ActionBody(BaseProcess action)
        {
            bool isProcessed = true;

            try {
                messageGenerator = GetService <IMercuryMessageBodyGenerator>();

                int  pageSize     = GetValue <int>(ARG_PAGE_SIZE);
                int  pageCount    = GetValue <int>(ARG_PAGE_COUNT);
                int  pageStart    = GetValue <int>(ARG_PAGE_START);
                Guid enterpriseId = GetValue <Guid>(ARG_PAGE_ENTERPRISE_ID);
                operationName = GetValue <string>(ARG_OPERATION_NAME);
                mercuryLogin  = GetValue <string>(ARG_MERCURY_LOGIN);
                string suffix    = GetValue <string>(ARG_SUFFIX);
                int?   iteration = GetValue <int?>(ARG_ITERATION);

                DateTimeOffset?beginDate = GetValue <DateTimeOffset?>(ARG_BEGIN_DATE);
                DateTimeOffset?endDate   = GetValue <DateTimeOffset?>(ARG_END_DATE);

                LocalContext.SaveLog($"{MoscowDateTimeOffset().ToString()} Начало формирования запросов в систему Меркурий.");

                #region Проверка параметров
                if (pageCount <= 0)
                {
                    isProcessed = false;
                    LocalContext.SaveLog($" Количество страниц должно быть > 0.");
                    AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_VALIDATION, UserErrorConsts.StockList.RTE_MAKE_REQUEST, "Количество страниц должно быть > 0");
                }
                if (pageSize <= 0)
                {
                    isProcessed = false;
                    LocalContext.SaveLog($" Размер страниц должно быть > 0.");
                    AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_VALIDATION, UserErrorConsts.StockList.RTE_MAKE_REQUEST, "Размер страниц должно быть > 0");
                }
                if (pageStart <= 0)
                {
                    isProcessed = false;
                    LocalContext.SaveLog($" Начальная страница должна быть > 0.");
                    AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_VALIDATION, UserErrorConsts.StockList.RTE_MAKE_REQUEST, "Начальная страница должна быть > 0");
                }
                Document enterpriseDoc = LocalReader.LoadDocumentByType(enterpriseId, "Enterprise");

                string enterpriseGUID = (string)enterpriseDoc["GUID"];
                string enterpriseCode = (string)enterpriseDoc["Code"];

                if (enterpriseDoc == null)
                {
                    isProcessed = false;
                    AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_VALIDATION, UserErrorConsts.StockList.VALID_NO_ENTERPRISE, $"Не найдена площадка с ИД {enterpriseId.ToString()}/{enterpriseId.ToStringNumber()}");
                    LocalContext.SaveLog($" Не найдена площадка с ИД {enterpriseId.ToString()}/{enterpriseId.ToStringNumber()}.");
                }
                #endregion

                if (isProcessed)
                {
                    List <StepContext> steps = new List <StepContext>();
                    LocalContext.SaveLog($" Площадка для формирования запросов {enterpriseCode}.");
                    LocalContext.SaveLog($" Стартовая страница {pageStart}, количество страниц для получения {pageCount}, размер страницы {pageSize}.");
                    for (int i = 0; i < pageCount; i++)
                    {
                        LocalContext.SaveLog($" Формирование страницы {(i + pageStart - 1) * pageSize} - {(i + pageStart) * pageSize}.");

                        StepContext requestContext = CreateStep(QueryId, MQSOperationType.COMMUNICATE);
                        requestContext.MercuryQueueStep.Status = MQSStatus.NEW;
                        if (iteration.HasValue)
                        {
                            requestContext.MercuryQueueStep.StepId = "0.0_" + iteration.Value.ToString("D3");
                        }
                        else
                        {
                            requestContext.MercuryQueueStep.StepId = "0.0";
                        }
                        requestContext.MercuryQueueStep.StepNo         = LocalContext.MercuryQueueStep.StepNo + 1;
                        requestContext.MercuryQueueStep.StepName       = Consts.STEP_NAME_MERCURY_COMMUNICATE;
                        requestContext.MercuryQueueStep.Description    = "Сформирован запрос";
                        requestContext.MercuryQueueStep.OperationGroup = Consts.OP_GROUP_CHECK_FOR_COMPLETED_OUTBOUND + suffix;
                        requestContext.GenerateFileNames(operationName);
                        var req = GenerateRequest(i + pageStart, pageSize, LocalContext.MercurySettings, mercuryLogin,
                                                  enterpriseGUID, enterpriseCode, beginDate, endDate);
                        requestContext.SaveRequest(req);
                        var args = new Dictionary <string, ActionArgument>();
                        args.Add("PageNo", new ActionArgument(typeof(int), "PageNo", i));
                        requestContext.MercuryQueueStep.Parameters = ArgumentSerializer.SerializeArguments(args);
                        steps.Add(requestContext);
                        LocalContext.SaveLog($" Страница {i + pageStart - 1} сформирована.");
                    }

                    // Сохранение информации о сгенерированных запросах
                    using (IDatabaseConnector connector = GetService <IDatabaseConnector>()) {
                        IMercuryQueueStepService transactionPersist = this.GetService <IMercuryQueueStepService>(connector);
                        transactionPersist.RegisterSteps(steps);
                        transactionPersist.SaveFinish(LocalContext.MercuryQueueStep.Id, MQSStatus.COMPLETE, "Выполнено формирование запросов.", DateTimeOffset.UtcNow);
                        connector.Commit();
                        breakAutosave = true;
                        SetValue("Status", MQSStatus.COMPLETE);
                    }
                }
                else
                {
                    LocalContext.SaveLog($" Заданы не все параметры для формирования запроса(-ов).");
                    LocalContext.SaveLog($" Операция отменена.");
                    ResultDescription = "Ошибка. Не верные параметры.";
                }
            } catch (Exception e) {
                isProcessed = false;
                AppendUserErrorInfo(Guid.Empty, null, UserErrorConsts.ET_MIP, UserErrorConsts.StockList.RTE_MAKE_REQUEST, UserErrorConsts.DEFAULT_LAS_SUPPRT_ERROR);
                ResultDescription = "Ошибка процесса формирования запросов в систему 'Меркурий'.";
                LocalContext.SaveLog(e.ToString());
            }
            LocalContext.SaveLog($"{MoscowDateTimeOffset().ToString()} Окончание формирования запросов в систему 'Меркурий'.");
            return(isProcessed);
        }