feat(esppOrderManager): доработка логики. EsppApi - запросы переделаны под модели.

PARR.EsppApi/Constants/EsppOperationsEnum.cs

@@ -0,0 +1,28 @@
+namespace PARR.EsppApi.Constants
+{
+    /// <summary>
+    /// Операции в ЕСПП
+    /// </summary>
+    internal enum EsppOperationsEnum
+    {
+        /// <summary>
+        /// Списать трудозатраты (ТНК)
+        /// </summary>
+        AddMTNK,
+
+        /// <summary>
+        /// Получить список нарядов
+        /// </summary>
+        GetTaskList,
+
+        /// <summary>
+        /// Получить наряд
+        /// </summary>
+        GetTask,
+
+        /// <summary>
+        /// Сохранить наряд
+        /// </summary>
+        SaveTask
+    }
+}

PARR.EsppApi/EsppApiService.cs

@@ -1,7 +1,10 @@
 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.Json;
 
 namespace PARR.EsppApi
 {
@@ -18,27 +21,40 @@ namespace PARR.EsppApi
             this.esppHttpService = esppHttpService;
         }
 
+
         public Task<EsppResultBase<EsppResponse>> SetStatusInWorkAsync(string recordId, string resultMsg)//TODO упростить можно без RecordIdQuery
         {
             return SetStatusAsync(recordId, "2-В работе", resultMsg);
         }
 
+
         public Task<EsppResultBase<EsppResponse>> SetStatusIsDoneAsync(string recordId, string resultMsg)//TODO упростить можно без RecordIdQuery
         {
             return SetStatusAsync(recordId, "4-Выполнен", resultMsg);
         }
 
+
         private async Task<EsppResultBase<EsppResponse>> SetStatusAsync(string recordId, string newStatusStr, string resultMsg)
         {
             //TODO assignee сразу назначаем принудительно, чтобы было понятно кто менял объект
-            var query = $"<ROOT operation=\"SaveTask\" returnFormat=\"json\">{{" +
+            //var query = $"<ROOT operation=\"SaveTask\" returnFormat=\"json\">{{" +
-                $"\"recordid\":\"{recordId}\"," +
+            //    $"\"recordid\":\"{recordId}\"," +
-                $"\"status\":\"{newStatusStr}\"," +
+            //    $"\"status\":\"{newStatusStr}\"," +
-                $"\"assignee\":\"{esppOrderSettings.AccountName}\"," +
+            //    $"\"assignee\":\"{esppOrderSettings.AccountName}\"," +
-                $"\"resolution\":\"{resultMsg}\"" +
+            //    $"\"resolution\":\"{resultMsg}\"" +
-                $"}}</ROOT>";
+            //    $"}}</ROOT>";
 
-            var result = await esppHttpService.SendAsync<EsppResponse>(query);
+            //var result = await esppHttpService.SendAsync<EsppResponse>(QuerySanitize(query));
+
+            var request = new SetStatusRequest
+            {
+                recordid = recordId,
+                status = newStatusStr,
+                assignee = esppOrderSettings.AccountName,
+                resolution = resultMsg
+            };
+
+            var result = await esppHttpService.SendAsync<EsppResponse>(GenerateRequest(EsppOperationsEnum.SaveTask, request));
 
             if (result.Data != null && result.Data.ErrorCode != "0")
                 return new EsppResultBase<EsppResponse>(null, false, new Exception(result.Data.Message));
@@ -46,13 +62,21 @@ namespace PARR.EsppApi
             return result;
         }
 
+
         public async Task<EsppResultBase<EsppOrder>> FindOrderByRecordIdAsync(string recordId)
         {
-            var result = await esppHttpService.SendAsync<EsppOrder>($"<ROOT operation=\"GetTask\" returnFormat=\"json\">\r\n{{\"recordid\":\"{recordId}\"}}\r\n</ROOT>");//TODO упростить можно без RecordIdQuery
+            //TODO упростить можно без RecordIdQuery
+            //var query = $"<ROOT operation=\"GetTask\" returnFormat=\"json\">\r\n{{\"recordid\":\"{recordId}\"}}\r\n</ROOT>";
+
+            //var result = await esppHttpService.SendAsync<EsppOrder>(QuerySanitize(query));
+
+            var request = new GetTaskRequest { recordid = recordId };
+            var result = await esppHttpService.SendAsync<EsppOrder>(GenerateRequest(EsppOperationsEnum.GetTask, request));
 
             return result;
         }
 
+
         public async Task<EsppResultBase<IEnumerable<EsppOrder>>> FindOrdersAsync(FindOrdersQuery query)
         {
             DateTime? generateDateStartWOTimeZone = query.GenerateDateStart.HasValue ? query.GenerateDateStart.Value.AddHours(esppOrderSettings.EsppUserTimeZone) : null;
@@ -79,23 +103,79 @@ namespace PARR.EsppApi
                 return new EsppResultBase<IEnumerable<EsppOrder>>(null, false);
             }
 
-            var result = await esppHttpService.SendAsync<IEnumerable<EsppOrder>>($"<ROOT operation=\"GetTaskList\" returnFormat=\"json\">{{\"VIEW_QUERY\":\"{string.Join(" and ", conditions)}\"}}</ROOT>");
+            //var request = $"<ROOT operation=\"GetTaskList\" returnFormat=\"json\">{{\"VIEW_QUERY\":\"{string.Join(" and ", conditions)}\"}}</ROOT>";
+            //var result = await esppHttpService.SendAsync<IEnumerable<EsppOrder>>(QuerySanitize(request));
+
+            var request = new GetTaskListRequest { VIEW_QUERY = string.Join(" and ", conditions) };
+            var result = await esppHttpService.SendAsync<IEnumerable<EsppOrder>>(GenerateRequest(EsppOperationsEnum.GetTaskList, request));
 
             return result;
 
         }
 
+
         public async Task<EsppResultBase<EsppResponse>> AddMTnkAsync(AddMtnkQuery mtnk)
         {
-            var result = await esppHttpService.SendAsync<EsppResponse>(
+            //var query = $"<ROOT operation=\"AddMTNK\" returnFormat=\"json\">{{\"recordid\":\"{mtnk.RecordId}\"," +
-                $"<ROOT operation=\"AddMTNK\" returnFormat=\"json\">{{\"recordid\":\"{mtnk.RecordId}\"," +
+            //    $"\"joboperation\":\"{mtnk.JobOperation}\",\"time\":\"{mtnk.Time}\",\"workscope\":\"{mtnk.Workspace}\"" +
-                $"\"joboperation\":\"{mtnk.JobOperation}\",\"time\":\"{mtnk.Time}\",\"workscope\":\"{mtnk.Workspace}\"" +
+            //    $"}}</ROOT>";
-                $"}}</ROOT>");
+
+            //var result = await esppHttpService.SendAsync<EsppResponse>(QuerySanitize(query));
+
+            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")
                 return new EsppResultBase<EsppResponse>(null, false, new Exception(result.Data.Message));
 
             return result;
         }
+
+
+        /// <summary>
+        /// Убирает из запроса запрещенные символы
+        /// </summary>
+        /// <returns></returns>
+        private string QuerySanitize(string str)
+        {
+            //str = str.Replace("\r\n", "<br/>");
+
+            return str;
+        }
+
+
+        /// <summary>
+        /// Формирует запрос в ЕСПП из строки
+        /// </summary>
+        /// <param name="operation"></param>
+        /// <param name="query"></param>
+        /// <returns></returns>
+        private string GenerateRequest(EsppOperationsEnum operation, string query)
+        {
+            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)
+        {
+            var strQuery = JsonSerializer.Serialize(jsonQuery);
+
+            return GenerateRequest(operation, strQuery);
+        }
     }
 }

PARR.EsppApi/Requests/AddMTNKRequest.cs

@@ -0,0 +1,17 @@
+namespace PARR.EsppApi.Requests
+{
+    /// <summary>
+    /// Списать трудозатраты
+    /// </summary>
+    internal class AddMTNKRequest
+    {
+        public required string recordid { get; set; }
+
+        public required string joboperation { get; set; }
+
+        public required string time { get; set; }
+
+        public required string workscope { get; set; }
+
+    }
+}

PARR.EsppApi/Requests/GetTaskListRequest.cs

@@ -0,0 +1,10 @@
+namespace PARR.EsppApi.Requests
+{
+    /// <summary>
+    /// Получить список нарядов
+    /// </summary>
+    internal class GetTaskListRequest
+    {
+        public required string VIEW_QUERY { get; set; }
+    }
+}

PARR.EsppApi/Requests/GetTaskRequest.cs

@@ -0,0 +1,10 @@
+namespace PARR.EsppApi.Requests
+{
+    /// <summary>
+    /// Получить наряд по номеру
+    /// </summary>
+    internal class GetTaskRequest
+    {
+        public required string recordid { get; set; }
+    }
+}

PARR.EsppApi/Requests/SetStatusRequest.cs

@@ -0,0 +1,16 @@
+namespace PARR.EsppApi.Requests
+{
+    /// <summary>
+    /// Изменить статус наряда
+    /// </summary>
+    internal class SetStatusRequest
+    {
+        public required string recordid { get; set; }
+
+        public required string status { get; set; }
+
+        public required string assignee { get; set; }
+
+        public required string resolution { get; set; }
+    }
+}

PARR.EsppApi/Services/EsppHttpService.cs

@@ -30,15 +30,12 @@ namespace PARR.EsppApi
 
                 var responseString = await response.Content.ReadAsStringAsync();
 
-                if (responseString.Contains("ErrorCode") && responseString.Contains("Message"))
-                {
-                    logger.LogError(new Exception(responseString), $"Ошибка при выполнении запроса в ЕСПП. Тело запроса: {query}");
-
-                    return new EsppResultBase<T>(null, false, new Exception($"Espp error: {responseString}"));
-                }
-
                 logger.LogDebug($"Получил данные, строка:  {responseString}");
 
+                var errors = CheckErrors<T>(responseString, query);
+                if (errors != null)
+                    return errors;
+
                 var obj = JsonSerializer.Deserialize<T>(responseString);
 
 
@@ -51,5 +48,40 @@ namespace PARR.EsppApi
                 return new EsppResultBase<T>(null, false, ex);
             }
         }
+
+
+        /// <summary>
+        /// Проверка респонса на ошибки. В ЕСПП полный вест кост кастом
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <returns></returns>
+        private EsppResultBase<T>? CheckErrors<T>(string response, string query) where T : class
+        {
+            //Если вернет "ErrorCode":"0" - то все успешно прошло, если вернет другой ErrorCode, то не успешно
+            //Не всегда возвращается ErrorCode, если получали например наряд, он вернет тело наряда
+            if (response.Contains("ErrorCode") && response.Contains("Message"))
+            {
+                if (!response.Contains("\"ErrorCode\":\"0\""))
+                {
+                    logger.LogError(new Exception(response), $"Ошибка при выполнении запроса в ЕСПП. Тело запроса: {query}");
+
+                    return new EsppResultBase<T>(null, false, new Exception($"Espp error: {response}"));
+                }
+
+                // ахахах! Может быть "ErrorCode":"0", и "Message":"Успешно", но в "MessageESPP":"err - Операция 'Прочее(работы)' не найденаЗапись \"Трудозатраты и Время в пути\" добавлена."
+                // "Message":"Успешно","ErrorCode":"0","MessageESPP":"err - Операция 'Прочее(работы)' не найденаЗапись \"Трудозатраты и Время в пути\" добавлена."
+                // т е это ошибка. рука лицо и привет разрабам ЕСПП
+                // делаем тупо, может стоит переделать
+                if (response.Contains("\"MessageESPP\":\"err"))
+                {
+                    logger.LogError(new Exception(response), $"Ошибка при выполнении запроса в ЕСПП. Тело запроса: {query}");
+
+                    return new EsppResultBase<T>(null, false, new Exception($"Espp error: {response}"));
+                }
+            }
+
+            return null;
+        }
+
     }
 }

PARR.EsppOrderManager/EsppOrderManager.cs

@@ -47,7 +47,7 @@ namespace PARR.EsppOrderManager
             //    throw new Exception("Ошибка при подключении к RabbitMq");
 
             //test, and remove async in method name
-            await ManageOrderAsync("{\"OrderId\":\"77eeccfb-4ca0-443e-8cc7-f6aa9dc774b7\"}");
+            await ManageOrderAsync("{\"OrderId\":\"dd04a997-e7b5-4326-b6e1-505719cc46fb\"}");
         }
 
         public void Stop()
@@ -149,11 +149,11 @@ namespace PARR.EsppOrderManager
                                         .OrderBy(t => t.DateCreated)
                                         .Select(t => $"{t.DateCreated} :: {t.AgentHistoryLevel?.Name} :: {t.Message}");
 
-            var baseMsg = order.Template!.ApplicationsInWork!.Solution + "\r\n";
+            var baseMsg = order.Template!.ApplicationsInWork!.Solution + "\n";
 
-            var msgAgent = "Работы выполнены средствами автоматизации. \r\n" +
+            var msgAgent = "Работы выполнены средствами автоматизации. \n" +
-                "Журнал работы: \r\n" +
+                "Журнал работы: \n" +
-                $"{string.Join("\r\n", agentHistory)}";
+                $"{string.Join("\n", agentHistory)}";
 
             var msgAgentEmpty = "Работы должны были выполняться средствами автоматизации. " +
                 "От средств автоматизации не поступило сообщений. " +

PARR.EsppOrderManager/ParrEsppOrderManagerInstaller.cs

@@ -20,6 +20,10 @@ namespace PARR.EsppOrderManager
             configuration.GetSection(nameof(MqSettings)).Bind(mqSettings);
             services.AddSingleton(mqSettings);
 
+            var esppPoligonSettings = new EsppPoligonSettings();
+            configuration.GetSection(nameof(EsppPoligonSettings)).Bind(esppPoligonSettings);
+            services.AddSingleton(esppPoligonSettings);
+
             services.AddTransient<IEsppOrderManager, EsppOrderManager>();
             services.AddTransient<IEsppOrderService, EsppOrderService>();
         }

PARR.EsppOrderManager/Services/EsppOrderService.cs

@@ -3,6 +3,7 @@ using PARR.Constants;
 using PARR.DAL.Models;
 using PARR.EsppApi;
 using PARR.EsppApi.Models.Query;
+using PARR.EsppOrderManager.Settings;
 
 namespace PARR.EsppOrderManager.Services
 {
@@ -10,14 +11,17 @@ namespace PARR.EsppOrderManager.Services
     {
         private readonly ILogger<EsppOrderService> logger;
         private readonly IEsppApiService esppApiService;
+        private readonly EsppPoligonSettings esppPoligonSettings;
 
         public EsppOrderService(
             ILogger<EsppOrderService> logger,
-            IEsppApiService esppApiService
+            IEsppApiService esppApiService,
+            EsppPoligonSettings esppPoligonSettings
             )
         {
             this.logger = logger;
             this.esppApiService = esppApiService;
+            this.esppPoligonSettings = esppPoligonSettings;
         }
 
 
@@ -68,9 +72,15 @@ namespace PARR.EsppOrderManager.Services
                     {
                         JobOperation = order!.Template!.ApplicationsInWork!.Work!.Name,
                         RecordId = order.Number,
-                        Time = duration.ToString("HH:mm")
+                        Time = duration.ToString("hh\\:mm")
                     };
 
+                    if (esppPoligonSettings.IsEnabled)
+                    {
+                        //для теста, подемеяем значения из БД
+                        tnk.JobOperation = esppPoligonSettings.TnkValue;
+                    }
+
                     return await SetCompleteStatusAsync(order.Number, resultMsg, tnk);
                 }
                 else
@@ -104,6 +114,8 @@ namespace PARR.EsppOrderManager.Services
 
                 return false;
             }
+            else
+                logger.LogDebug($"В ЕСПП, для наряда {orderNumber} списаны трудозатраты. Операция: {tnk.JobOperation}, время: {tnk.Time}");
 
             // выполняем наряд
             var result = await esppApiService.SetStatusIsDoneAsync(orderNumber, resultMsg);

PARR.EsppOrderManager/Settings/EsppPoligonSettings.cs

@@ -0,0 +1,19 @@
+namespace PARR.EsppOrderManager.Settings
+{
+    /// <summary>
+    /// Настройки смежных полигнов (продуктив/дев ЕСПП). Значения на полигонах могут отличаться.
+    /// Чтобы тестировать, подменяем значения из БД, берем из этих настроек.
+    /// </summary>
+    internal class EsppPoligonSettings
+    {
+        /// <summary>
+        /// Применить все настройки
+        /// </summary>
+        public bool IsEnabled { get; set; }
+
+        /// <summary>
+        /// Значение ТНК, заменяет значение из БД.
+        /// </summary>
+        public string TnkValue { get; set; } = string.Empty;
+    }
+}

PARR.EsppOrderManagerWorker/appsettings.json

@@ -38,5 +38,9 @@
     "AccountName": "АВТО ТЕХНОЛОГ ПТК-ДВС (AUTO-PTK-DVS)",
     "Password": "123456789",
     "EsppUserTimeZone": 10
+  },
+  "EsppPoligonSettings": {
+    "IsEnabled": true,
+    "TnkValue": "Не учтена в перечне ТНК"
   }
 }

PARR.Test/Worker.cs

@@ -24,7 +24,7 @@ namespace PARR.Test
         private async Task TestEsppApi()
         {
             //var result = await esppApiService.FindOrdersAsync(new FindOrdersQuery { DescriptionContains = "Полное", GenerateDateStart = new DateTime(2023, 10, 10) , GenerateDateEnd = new DateTime(2023, 10, 24) });
-            var recordId = "НАР23-00049787";
+            var recordId = "НАР23-00046650";
 
             var result = await esppApiService.FindOrderByRecordIdAsync(recordId);
 
@@ -32,7 +32,7 @@ namespace PARR.Test
             {
                 //var orders = result.Data;
 
-                var inWorkResult = await esppApiService.SetStatusInWorkAsync(recordId, "Решение...");
+                var inWorkResult = await esppApiService.SetStatusInWorkAsync(recordId, "Решение...\nС новой строки");
                 if (!inWorkResult.IsSuccess)
                 {
                     _logger.LogError(inWorkResult.Exception, $"Не удалось взять в работу наряда{recordId}");