parr_api/PARR.EsppApi/EsppApiService.cs

using Microsoft.Extensions.Logging;
using PARR.EsppApi.Constants;
using PARR.EsppApi.Models;
using PARR.EsppApi.Models.Query;
using PARR.EsppApi.Requests;
using PARR.EsppApi.Settings;
using System.Text.Encodings.Web;
using System.Text.Json;
using System.Text.Unicode;

namespace PARR.EsppApi
{
    internal class EsppApiService : IEsppApiService
    {
        private readonly ILogger<EsppApiService> logger;
        private readonly EsppOrderSettings esppOrderSettings;
        private readonly EsppHttpService esppHttpService;

        public EsppApiService(ILogger<EsppApiService> logger, EsppOrderSettings esppOrderSettings, EsppHttpService esppHttpService)
        {
            this.logger = logger;
            this.esppOrderSettings = esppOrderSettings;
            this.esppHttpService = esppHttpService;
        }


        public Task<EsppResultBase<EsppResponse>> SetStatusInWorkAsync(string recordId, string resultMsg)
        {
            logger.LogDebug("Установка статуса 'В работе' для наряда {RecordId}", recordId);
            return SetStatusAsync(recordId, "2-В работе", resultMsg);
        }


        public Task<EsppResultBase<EsppResponse>> SetStatusIsDoneAsync(string recordId, string resultMsg, EsppOrderClosingCodeEnum closingCode)
        {
            logger.LogDebug("Установка статуса 'Выполнен' для наряда {RecordId} с кодом закрытия {ClosingCode}", recordId, closingCode);
            return SetStatusAsync(recordId, "4-Выполнен", resultMsg, closingCode);
        }


        private async Task<EsppResultBase<EsppResponse>> SetStatusAsync(
            string recordId,
            string newStatusStr,
            string resultMsg,
            EsppOrderClosingCodeEnum? closingCode = null
            )
        {
            logger.LogDebug("Выполнение запроса на изменение статуса для наряда {RecordId} в статус {NewStatus}", recordId, newStatusStr);

            var request = new SetStatusRequest(closingCode ?? EsppOrderClosingCodeEnum.Complete)
            {
                recordid = recordId,
                status = newStatusStr,
                assignee = esppOrderSettings.AccountName,
                resolution = resultMsg,
                rzdEventCode = esppOrderSettings.CodeRRO,
                rzdKeRobot = esppOrderSettings.RobotEk
            };

            var result = await esppHttpService.SendAsync<EsppResponse>(GenerateRequest(EsppOperationsEnum.SaveTask, request));

            if (result.Data != null && result.Data.ErrorCode != "0")
            {
                logger.LogError("Ошибка при установке статуса для наряда {RecordId}: {ErrorMessage}", recordId, result.Data.Message);
                return new EsppResultBase<EsppResponse>(null, false, new Exception(result.Data.Message));
            }

            logger.LogDebug("Статус для наряда {RecordId} успешно установлен", recordId);
            return result;
        }


        public async Task<EsppResultBase<EsppOrder>> FindOrderByRecordIdAsync(string recordId)
        {
            logger.LogDebug("Поиск наряда по ID: {RecordId}", recordId);

            var request = new GetTaskRequest { recordid = recordId };
            var result = await esppHttpService.SendAsync<EsppOrder>(GenerateRequest(EsppOperationsEnum.GetTask, request));

            if (result.IsSuccess)
            {
                logger.LogDebug("Наряд {RecordId} успешно найден", recordId);
            }
            else
            {
                logger.LogWarning("Наряд {RecordId} не найден", recordId);
            }

            return result;
        }


        public async Task<EsppResultBase<IEnumerable<EsppOrder>>> FindOrdersAsync(FindOrdersQuery query)
        {
            logger.LogDebug("Поиск нарядов в ЕСПП с фильтром");

            DateTime? generateDateStartWOTimeZone = query.GenerateDateStart.HasValue ? query.GenerateDateStart.Value.AddHours(esppOrderSettings.EsppUserTimeZone) : null;
            DateTime? generateDateEndWOTimeZone = query.GenerateDateEnd.HasValue ? query.GenerateDateEnd.Value.AddHours(esppOrderSettings.EsppUserTimeZone) : null;

            var conditions = new List<string>();

            if (!string.IsNullOrEmpty(query.StatusIs))
                conditions.Add($"status=\"{query.StatusIs}\"");

            if (!string.IsNullOrEmpty(query.DescriptionContains))
                conditions.Add($"description like \"*{query.DescriptionContains}*\"");

            if (generateDateStartWOTimeZone.HasValue)
                conditions.Add($"open.time>='{generateDateStartWOTimeZone.Value.ToString(@"dd\/MM\/yyyy HH:mm:ss")}'");

            if (generateDateEndWOTimeZone.HasValue)
                conditions.Add($"open.time<='{generateDateEndWOTimeZone.Value.ToString(@"dd\/MM\/yyyy HH:mm:ss")}'");

            if (!conditions.Any())
            {
                logger.LogWarning("Пустой запрос в EsppApiService.FindOrdersAsync - все условия фильтрации пустые");
                return new EsppResultBase<IEnumerable<EsppOrder>>(null, false);
            }

            logger.LogDebug("Формирование запроса к ЕСПП с условиями: {Conditions}", string.Join(" and ", conditions));

            var request = new GetTaskListRequest { VIEW_QUERY = string.Join(" and ", conditions) };

            // костыль. так как в ЕСПП не json а какой-то свой модерновый формат. формируем запрос вручную
            var viewQueryStr = $"{{\"VIEW_QUERY\":\"{request.VIEW_QUERY}\"}}";
            var result = await esppHttpService.SendAsync<IEnumerable<EsppOrder>>(GenerateRequest(EsppOperationsEnum.GetTaskList, viewQueryStr));

            if (result.IsSuccess)
            {
                var count = result.Data?.Count() ?? 0;
                logger.LogInformation("Успешно получено {Count} нарядов из ЕСПП", count);
            }
            else
            {
                logger.LogError(result.Exception, "Ошибка при получении нарядов из ЕСПП");
            }

            return result;
        }


        public async Task<EsppResultBase<EsppResponse>> AddMTnkAsync(AddMtnkQuery mtnk)
        {
            logger.LogDebug("Добавление МТНК для наряда {RecordId}", mtnk.RecordId);

            var request = new AddMTNKRequest
            {
                recordid = mtnk.RecordId,
                joboperation = mtnk.JobOperation,
                time = mtnk.Time,
                workscope = mtnk.Workspace.ToString()
            };

            var result = await esppHttpService.SendAsync<EsppResponse>(GenerateRequest(EsppOperationsEnum.AddMTNK, request));

            if (result.Data != null && result.Data.ErrorCode != "0")
            {
                logger.LogError("Ошибка при добавлении МТНК для наряда {RecordId}: {ErrorMessage}", mtnk.RecordId, result.Data.Message);
                return new EsppResultBase<EsppResponse>(null, false, new Exception(result.Data.Message));
            }

            logger.LogDebug("МТНК успешно добавлена для наряда {RecordId}", mtnk.RecordId);
            return result;
        }


        /// <summary>
        /// Формирует запрос в ЕСПП из строки
        /// </summary>
        /// <param name="operation"></param>
        /// <param name="query"></param>
        /// <returns></returns>
        private string GenerateRequest(EsppOperationsEnum operation, string query)
        {
            logger.LogDebug("Генерация запроса к ЕСПП: операция {Operation}", operation);

            var baseRequest = $"<ROOT operation=\"operationValue\" returnFormat=\"json\">requestValue</ROOT>";

            return baseRequest.Replace("operationValue", operation.ToString()).Replace("requestValue", query);
        }


        /// <summary>
        /// Формирует запрос в ЕСПП из jsonQuery 
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="operation"></param>
        /// <param name="jsonQuery"></param>
        /// <returns></returns>
        private string GenerateRequest<T>(EsppOperationsEnum operation, T jsonQuery)
        {
            logger.LogDebug("Генерация JSON-запроса к ЕСПП: операция {Operation}", operation);

            var jsonOptions = new JsonSerializerOptions { Encoder = JavaScriptEncoder.Create(UnicodeRanges.All, UnicodeRanges.Cyrillic) };
            var strQuery = JsonSerializer.Serialize(jsonQuery, jsonOptions);

            return GenerateRequest(operation, strQuery);
        }
    }
}