| | | 1 | | using System.Text.Json; |
| | | 2 | | using Microsoft.EntityFrameworkCore; |
| | | 3 | | using OzonDomains.Models; |
| | | 4 | | using OzonDomains.Models.SupplierStatuses; |
| | | 5 | | using OzonRepositories.Context; |
| | | 6 | | using Services.ApiServices.BergApi; |
| | | 7 | | using Services.ApiSupplierSettingsServices; |
| | | 8 | | using Services.DataServices; |
| | | 9 | | using Services.SupplierStatusServices; |
| | | 10 | | |
| | | 11 | | namespace OzonOrdersWeb.TransactionServices; |
| | | 12 | | |
| | | 13 | | public sealed record BergCartQueueItem( |
| | | 14 | | int OrderId, |
| | | 15 | | long ResourceId, |
| | | 16 | | long WarehouseId, |
| | | 17 | | decimal Quantity, |
| | | 18 | | decimal? Price, |
| | | 19 | | string? Article, |
| | | 20 | | string? Brand, |
| | | 21 | | string? ProductName, |
| | | 22 | | string? ShipmentNumber, |
| | | 23 | | string? ClientName, |
| | | 24 | | int Multi = 1, |
| | | 25 | | int? DeliveryDaysMin = null, |
| | | 26 | | int? DeliveryDaysMax = null, |
| | | 27 | | string? Direction = null); |
| | | 28 | | |
| | | 29 | | public sealed record BergCartResult(bool IsSuccess, IReadOnlyList<string> Messages); |
| | | 30 | | |
| | | 31 | | /// <summary> |
| | | 32 | | /// Корзина Berg со страницы проведения. У Berg нет API корзины: <c>ordering/place_order.json</c> |
| | | 33 | | /// размещает заказ целиком одним вызовом, поэтому отобранные позиции копятся в локальной таблице |
| | | 34 | | /// <c>BergCartItems</c>, а прямое оформление отправляет их поставщику за один запрос. |
| | | 35 | | /// </summary> |
| | | 36 | | public sealed class BergCartService |
| | | 37 | | { |
| | | 38 | | private const string ProviderKey = ApiSupplierSettings.BergProviderKey; |
| | | 39 | | private const string SupplierDisplayName = "Берг"; |
| | | 40 | | private const string LogoUrl = "/images/berg-logo-2026.png"; |
| | | 41 | | private const string CurrencyCode = "RUB"; |
| | | 42 | | private const string SupplierCartUrl = "/SupplierCart?provider=berg&supplierTab=basket"; |
| | | 43 | | |
| | | 44 | | /// <summary>Заказы, поданные после этого часа, Berg отгружает во второй половине дня.</summary> |
| | | 45 | | private const int MiddayHour = 15; |
| | | 46 | | |
| | | 47 | | private readonly ApplicationDbContext _context; |
| | | 48 | | private readonly BergDataManager _berg; |
| | | 49 | | private readonly BergDeliveryAddressMappingService _addresses; |
| | | 50 | | private readonly IOrderHistoryDataService _orderHistoryService; |
| | | 51 | | private readonly IOrderSupplierStateService _supplierStateService; |
| | | 52 | | |
| | 8 | 53 | | public BergCartService(ApplicationDbContext context, BergDataManager berg, |
| | 8 | 54 | | BergDeliveryAddressMappingService addresses, IOrderHistoryDataService orderHistoryService, |
| | 8 | 55 | | IOrderSupplierStateService supplierStateService) |
| | | 56 | | { |
| | 8 | 57 | | _context = context; |
| | 8 | 58 | | _berg = berg; |
| | 8 | 59 | | _addresses = addresses; |
| | 8 | 60 | | _orderHistoryService = orderHistoryService; |
| | 8 | 61 | | _supplierStateService = supplierStateService; |
| | 8 | 62 | | } |
| | | 63 | | |
| | | 64 | | /// <summary>Позиции кладутся только в локальную корзину: заказ у Berg оформляется отдельно.</summary> |
| | | 65 | | public async Task<BergCartResult> PlaceQueuedItemsAsync(IReadOnlyCollection<BergCartQueueItem> items, |
| | | 66 | | string changedBy, CancellationToken ct = default) |
| | | 67 | | { |
| | 7 | 68 | | if (items.Count == 0) return new(true, []); |
| | 7 | 69 | | if (Invalid(items)) return new(false, ["Для корзины Berg требуется ровно одно корректное предложение на заказ."] |
| | | 70 | | |
| | 7 | 71 | | var messages = new List<string>(); |
| | 7 | 72 | | var added = new List<BergCartQueueItem>(); |
| | 28 | 73 | | foreach (var item in items) |
| | | 74 | | { |
| | 7 | 75 | | var existing = await _context.BergCartItems |
| | 7 | 76 | | .SingleOrDefaultAsync(x => x.ActiveStudioOrderId == item.OrderId, ct); |
| | 7 | 77 | | if (existing is not null) |
| | | 78 | | { |
| | 2 | 79 | | messages.Add($"{Label(item)}: уже в корзине Berg, повторно не добавляем."); |
| | 2 | 80 | | continue; |
| | | 81 | | } |
| | | 82 | | |
| | 5 | 83 | | _context.BergCartItems.Add(BuildCartItem(item, changedBy, BergCartItemStatus.Pending)); |
| | 5 | 84 | | added.Add(item); |
| | 5 | 85 | | } |
| | | 86 | | |
| | 7 | 87 | | if (added.Count == 0) |
| | 2 | 88 | | return new(false, messages); |
| | | 89 | | |
| | 5 | 90 | | await _context.SaveChangesAsync(ct); |
| | | 91 | | |
| | | 92 | | // Журнал и стадия — только по реально добавленным строкам: пропущенный дубль |
| | | 93 | | // не должен появляться в истории заказа. |
| | 20 | 94 | | foreach (var item in added) |
| | | 95 | | { |
| | 5 | 96 | | await TryTrackCartAsync(item, changedBy); |
| | 5 | 97 | | await TryRecordHistoryAsync(item, true, null, null, changedBy, ApiSupplierBasketCartStatus.Pending); |
| | 5 | 98 | | messages.Add($"{Label(item)}: добавлено в корзину Berg."); |
| | 5 | 99 | | } |
| | | 100 | | |
| | 5 | 101 | | return new(added.Count == items.Count, messages); |
| | 7 | 102 | | } |
| | | 103 | | |
| | | 104 | | /// <summary> |
| | | 105 | | /// Прямое оформление: позиции сохраняются в локальной корзине и сразу уходят в Berg одним |
| | | 106 | | /// заказом. Berg не умеет дозаказывать в существующий заказ, поэтому дробить вызов нельзя. |
| | | 107 | | /// </summary> |
| | | 108 | | public async Task<BergCartResult> CheckoutDirectAsync(IReadOnlyCollection<BergCartQueueItem> items, |
| | | 109 | | string changedBy, CancellationToken ct = default, bool isTest = false) |
| | | 110 | | { |
| | 4 | 111 | | if (items.Count == 0) return new(false, ["Не выбраны позиции Berg для оформления."]); |
| | 4 | 112 | | if (Invalid(items)) return new(false, ["Для прямого оформления Berg требуется ровно одно корректное предложение |
| | | 113 | | |
| | | 114 | | // Адрес отгрузки обязателен и определяется складом заказа. Заказы с разными адресами — |
| | | 115 | | // это разные заказы Berg, а одним вызовом place_order их не разделить. |
| | 4 | 116 | | var addresses = new Dictionary<int, BergDeliveryAddressSelection>(); |
| | 4 | 117 | | var missing = new List<string>(); |
| | 16 | 118 | | foreach (var item in items) |
| | | 119 | | { |
| | 4 | 120 | | var address = await _addresses.ResolveAsync(item.OrderId, cancellationToken: ct); |
| | 5 | 121 | | if (address is null) missing.Add(Label(item)); |
| | 3 | 122 | | else addresses[item.OrderId] = address; |
| | 4 | 123 | | } |
| | | 124 | | |
| | 4 | 125 | | if (missing.Count > 0) |
| | 1 | 126 | | return new(false, [$"Для складов этих позиций не задан адрес отгрузки Berg: {string.Join(", ", missing)}. " |
| | 1 | 127 | | "Свяжите склад с адресом в <a href=\"/Studio2/ApiSupplierSettings/Berg\" target=\"_blank\ |
| | 1 | 128 | | "(раздел Справочники → Настройки API-поставщиков → Berg)."]); |
| | | 129 | | |
| | | 130 | | var distinctAddresses = addresses.Values.Select(x => x.BergShipmentAddressId).Distinct().Count(); |
| | 3 | 131 | | if (distinctAddresses > 1) |
| | 0 | 132 | | return new(false, ["Позиции относятся к разным адресам отгрузки Berg. Проведите их отдельными документами."] |
| | | 133 | | |
| | 3 | 134 | | var selection = addresses.Values.First(); |
| | 3 | 135 | | var request = BuildOrderRequest(items, selection) with { IsTest = isTest }; |
| | | 136 | | |
| | 3 | 137 | | var cartItems = new List<BergCartItem>(); |
| | 12 | 138 | | foreach (var item in items) |
| | | 139 | | { |
| | 3 | 140 | | var existing = await _context.BergCartItems |
| | 3 | 141 | | .SingleOrDefaultAsync(x => x.ActiveStudioOrderId == item.OrderId, ct); |
| | 3 | 142 | | if (existing is null) |
| | | 143 | | { |
| | 2 | 144 | | existing = BuildCartItem(item, changedBy, BergCartItemStatus.Processing); |
| | 2 | 145 | | _context.BergCartItems.Add(existing); |
| | | 146 | | } |
| | | 147 | | else |
| | | 148 | | { |
| | 1 | 149 | | existing.Status = BergCartItemStatus.Processing; |
| | 1 | 150 | | existing.UpdatedAtUtc = DateTime.UtcNow; |
| | | 151 | | } |
| | | 152 | | |
| | 3 | 153 | | cartItems.Add(existing); |
| | 3 | 154 | | } |
| | | 155 | | |
| | 3 | 156 | | await _context.SaveChangesAsync(ct); |
| | | 157 | | |
| | | 158 | | BergPlaceOrderResult result; |
| | | 159 | | try |
| | | 160 | | { |
| | 3 | 161 | | result = await _berg.PlaceOrderAsync(request, ct); |
| | 3 | 162 | | } |
| | 0 | 163 | | catch (BergApiException ex) |
| | | 164 | | { |
| | 0 | 165 | | await MarkFailedAsync(cartItems, items, ex.Message, changedBy, ct); |
| | 0 | 166 | | return new(false, [$"Berg не оформил заказ: {ex.Message}. Позиции остались в корзине Berg."]); |
| | | 167 | | } |
| | | 168 | | |
| | 3 | 169 | | if (!result.IsSuccess) |
| | | 170 | | { |
| | 1 | 171 | | var error = result.Errors.Count > 0 |
| | | 172 | | ? string.Join("; ", result.Errors.Select(x => $"{x.Text} ({x.Code})")) |
| | 1 | 173 | | : "поставщик не вернул номер заказа"; |
| | 1 | 174 | | await MarkFailedAsync(cartItems, items, error, changedBy, ct); |
| | 1 | 175 | | return new(false, [$"Berg не оформил заказ: {error}. Позиции остались в корзине Berg."]); |
| | | 176 | | } |
| | | 177 | | |
| | 2 | 178 | | var order = await SaveOrderAsync(result.Order!, request, items, cartItems, changedBy, ct); |
| | | 179 | | |
| | 2 | 180 | | var messages = new List<string>(); |
| | 8 | 181 | | foreach (var item in items) |
| | | 182 | | { |
| | 2 | 183 | | var line = MatchLine(result.Order!, item); |
| | 2 | 184 | | await TryTrackOrderedAsync(item, order.ExternalOrderId, line?.Sequence, changedBy); |
| | 2 | 185 | | await TryRecordHistoryAsync(item, true, line?.Sequence.ToString(), order.ExternalOrderId.ToString(), |
| | 2 | 186 | | changedBy, ApiSupplierBasketCartStatus.Ordered); |
| | 2 | 187 | | } |
| | | 188 | | |
| | 2 | 189 | | messages.Add(request.IsTest |
| | 2 | 190 | | ? $"Berg принял тестовый заказ №{order.ExternalOrderId} (is_test — заказ не обрабатывается)." |
| | 2 | 191 | | : $"Создан заказ Berg №{order.ExternalOrderId}."); |
| | 4 | 192 | | foreach (var warning in result.Warnings) |
| | 0 | 193 | | messages.Add($"Berg: {warning.Text} ({warning.Code})."); |
| | | 194 | | |
| | 2 | 195 | | return new(true, messages); |
| | 4 | 196 | | } |
| | | 197 | | |
| | | 198 | | internal static BergOrderRequest BuildOrderRequest(IReadOnlyCollection<BergCartQueueItem> items, |
| | | 199 | | BergDeliveryAddressSelection address, DateTime? now = null) |
| | | 200 | | { |
| | 6 | 201 | | var moment = now ?? DateTime.Now; |
| | | 202 | | // Дату отгрузки задаёт самая долгая позиция: раньше неё заказ целиком не уедет. |
| | 14 | 203 | | var days = items.Max(x => x.DeliveryDaysMin ?? 0); |
| | 6 | 204 | | return new BergOrderRequest |
| | 6 | 205 | | { |
| | 8 | 206 | | Items = items.Select(x => new BergOrderItemRequest( |
| | 8 | 207 | | x.ResourceId, x.WarehouseId, x.Quantity, |
| | 8 | 208 | | MaxPrice: x.Price, |
| | 8 | 209 | | Comment: Comment(x))).ToList(), |
| | 6 | 210 | | DispatchType = address.DispatchType, |
| | 6 | 211 | | DispatchAt = moment.Date.AddDays(days), |
| | 6 | 212 | | DispatchTime = moment.Hour < MiddayHour ? BergDispatchTime.BeforeMidday : BergDispatchTime.AfterMidday, |
| | 6 | 213 | | ShipmentAddressId = address.BergShipmentAddressId, |
| | 6 | 214 | | Comment = $"Studio2: {string.Join(", ", items.Select(Label))}", |
| | 6 | 215 | | // Числовой ключ идемпотентности: Berg отклонит повторную отправку той же формы. |
| | 6 | 216 | | Reference = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() |
| | 6 | 217 | | }; |
| | | 218 | | } |
| | | 219 | | |
| | | 220 | | private async Task<BergOrder> SaveOrderAsync(BergOrderState state, BergOrderRequest request, |
| | | 221 | | IReadOnlyCollection<BergCartQueueItem> items, IReadOnlyList<BergCartItem> cartItems, string changedBy, |
| | | 222 | | CancellationToken ct) |
| | | 223 | | { |
| | 2 | 224 | | var order = new BergOrder |
| | 2 | 225 | | { |
| | 2 | 226 | | ExternalOrderId = state.Id, |
| | 2 | 227 | | Reference = request.Reference, |
| | 2 | 228 | | DispatchType = request.DispatchType, |
| | 2 | 229 | | DispatchAt = request.DispatchAt, |
| | 2 | 230 | | DispatchTime = request.DispatchTime, |
| | 2 | 231 | | ShipmentAddressId = request.ShipmentAddressId, |
| | 2 | 232 | | ShipmentAddress = state.ShipmentAddress, |
| | 2 | 233 | | PaymentType = state.PaymentType, |
| | 2 | 234 | | IsTest = state.IsTest || request.IsTest, |
| | 2 | 235 | | Status = request.IsTest ? BergOrderStatus.Test : BergOrderStatus.Placed, |
| | 2 | 236 | | RequestJson = BergDataManager.BuildOrderBody(request).ToString(Newtonsoft.Json.Formatting.None), |
| | 2 | 237 | | ResponseJson = JsonSerializer.Serialize(state, HistoryJsonOptions), |
| | 2 | 238 | | CreatedBy = changedBy, |
| | 2 | 239 | | CreatedAtUtc = DateTime.UtcNow |
| | 2 | 240 | | }; |
| | | 241 | | |
| | 8 | 242 | | foreach (var item in items) |
| | | 243 | | { |
| | 2 | 244 | | var line = MatchLine(state, item); |
| | 4 | 245 | | var cartItem = cartItems.FirstOrDefault(x => x.StudioOrderId == item.OrderId); |
| | 2 | 246 | | order.Items.Add(new BergOrderItem |
| | 2 | 247 | | { |
| | 2 | 248 | | BergCartItemId = cartItem?.Id, |
| | 2 | 249 | | StudioOrderId = item.OrderId, |
| | 2 | 250 | | Sequence = line?.Sequence ?? 0, |
| | 2 | 251 | | ResourceId = item.ResourceId, |
| | 2 | 252 | | WarehouseId = item.WarehouseId, |
| | 2 | 253 | | Article = Trim(item.Article, 60), |
| | 2 | 254 | | Brand = Trim(item.Brand, 100), |
| | 2 | 255 | | Quantity = item.Quantity, |
| | 2 | 256 | | Price = line?.Price ?? item.Price, |
| | 2 | 257 | | StateId = line?.StateId, |
| | 2 | 258 | | StateName = Trim(line?.StateName, 200) |
| | 2 | 259 | | }); |
| | | 260 | | |
| | 2 | 261 | | if (cartItem is null) continue; |
| | 2 | 262 | | cartItem.Status = BergCartItemStatus.Ordered; |
| | | 263 | | // Строка уходит из активной корзины, но остаётся в истории. |
| | 2 | 264 | | cartItem.ActiveStudioOrderId = null; |
| | 2 | 265 | | cartItem.LastError = null; |
| | 2 | 266 | | cartItem.UpdatedAtUtc = DateTime.UtcNow; |
| | | 267 | | } |
| | | 268 | | |
| | 2 | 269 | | _context.BergOrders.Add(order); |
| | 2 | 270 | | await _context.SaveChangesAsync(ct); |
| | 2 | 271 | | return order; |
| | 2 | 272 | | } |
| | | 273 | | |
| | | 274 | | private async Task MarkFailedAsync(IReadOnlyList<BergCartItem> cartItems, |
| | | 275 | | IReadOnlyCollection<BergCartQueueItem> items, string error, string changedBy, CancellationToken ct) |
| | | 276 | | { |
| | 4 | 277 | | foreach (var cartItem in cartItems) |
| | | 278 | | { |
| | 1 | 279 | | cartItem.Status = BergCartItemStatus.Failed; |
| | 1 | 280 | | cartItem.LastError = Trim(error, 1000); |
| | 1 | 281 | | cartItem.UpdatedAtUtc = DateTime.UtcNow; |
| | | 282 | | } |
| | | 283 | | |
| | 1 | 284 | | await _context.SaveChangesAsync(ct); |
| | | 285 | | |
| | 4 | 286 | | foreach (var item in items) |
| | | 287 | | { |
| | 1 | 288 | | await TryTrackCartAsync(item, changedBy, SupplierCartStatusCode.Failed); |
| | 1 | 289 | | await TryRecordHistoryAsync(item, false, null, null, changedBy, ApiSupplierBasketCartStatus.Failed, error); |
| | 1 | 290 | | } |
| | 1 | 291 | | } |
| | | 292 | | |
| | 7 | 293 | | private BergCartItem BuildCartItem(BergCartQueueItem item, string changedBy, string status) => new() |
| | 7 | 294 | | { |
| | 7 | 295 | | StudioOrderId = item.OrderId, |
| | 7 | 296 | | ActiveStudioOrderId = item.OrderId, |
| | 7 | 297 | | ResourceId = item.ResourceId, |
| | 7 | 298 | | WarehouseId = item.WarehouseId, |
| | 7 | 299 | | Article = Trim(item.Article, 60), |
| | 7 | 300 | | Brand = Trim(item.Brand, 100), |
| | 7 | 301 | | ProductName = Trim(item.ProductName, 200), |
| | 7 | 302 | | WarehouseName = Trim(item.Direction, 160), |
| | 7 | 303 | | Quantity = item.Quantity, |
| | 7 | 304 | | Multi = item.Multi > 0 ? item.Multi : 1, |
| | 7 | 305 | | SourcePrice = item.Price, |
| | 7 | 306 | | MaxPrice = item.Price, |
| | 7 | 307 | | CurrencyCode = CurrencyCode, |
| | 7 | 308 | | DeliveryAtUtc = item.DeliveryDaysMin.HasValue ? DateTime.UtcNow.Date.AddDays(item.DeliveryDaysMin.Value) : null, |
| | 7 | 309 | | Status = status, |
| | 7 | 310 | | CreatedBy = changedBy, |
| | 7 | 311 | | CreatedAtUtc = DateTime.UtcNow, |
| | 7 | 312 | | UpdatedAtUtc = DateTime.UtcNow |
| | 7 | 313 | | }; |
| | | 314 | | |
| | | 315 | | /// <summary>Berg нумерует строки заказа сам, поэтому сопоставляем по паре resource + склад.</summary> |
| | | 316 | | private static BergOrderItemState? MatchLine(BergOrderState state, BergCartQueueItem item) => |
| | 8 | 317 | | state.Items.FirstOrDefault(x => x.ResourceId == item.ResourceId && x.WarehouseId == item.WarehouseId); |
| | | 318 | | |
| | | 319 | | private static bool Invalid(IReadOnlyCollection<BergCartQueueItem> items) => |
| | 22 | 320 | | items.Any(x => x.OrderId <= 0 || x.ResourceId <= 0 || x.WarehouseId <= 0 || x.Quantity <= 0) || |
| | 33 | 321 | | items.GroupBy(x => x.OrderId).Any(x => x.Count() > 1); |
| | | 322 | | |
| | | 323 | | /// <summary>Подпись позиции в сообщениях: номер отгрузки Studio2 и артикул — по ним |
| | | 324 | | /// пользователь находит заказ, к которому относится строка.</summary> |
| | | 325 | | private static string Label(BergCartQueueItem item) |
| | | 326 | | { |
| | 16 | 327 | | var order = string.IsNullOrWhiteSpace(item.ShipmentNumber) ? $"ID {item.OrderId}" : item.ShipmentNumber!; |
| | 16 | 328 | | return string.IsNullOrWhiteSpace(item.Article) ? order : $"{order} ({item.Article})"; |
| | | 329 | | } |
| | | 330 | | |
| | | 331 | | private static string Comment(BergCartQueueItem item) => |
| | 8 | 332 | | $"Studio2 {(string.IsNullOrWhiteSpace(item.ShipmentNumber) ? $"ID {item.OrderId}" : item.ShipmentNumber)} (ID {i |
| | | 333 | | |
| | | 334 | | private static string Trim(string? value, int maxLength) |
| | | 335 | | { |
| | 35 | 336 | | var trimmed = (value ?? string.Empty).Trim(); |
| | 35 | 337 | | return trimmed.Length <= maxLength ? trimmed : trimmed[..maxLength]; |
| | | 338 | | } |
| | | 339 | | |
| | 1 | 340 | | private static readonly JsonSerializerOptions HistoryJsonOptions = new() |
| | 1 | 341 | | { |
| | 1 | 342 | | Encoder = System.Text.Encodings.Web.JavaScriptEncoder.Create(System.Text.Unicode.UnicodeRanges.All) |
| | 1 | 343 | | }; |
| | | 344 | | |
| | | 345 | | /// <summary>Стадия корзины — вспомогательный журнал: её сбой не должен ломать уже выполненное размещение.</summary> |
| | | 346 | | private async Task TryTrackCartAsync(BergCartQueueItem item, string changedBy, |
| | | 347 | | string statusCode = SupplierCartStatusCode.Pending) |
| | | 348 | | { |
| | | 349 | | try |
| | | 350 | | { |
| | 6 | 351 | | await _supplierStateService.MarkInCartAsync(item.OrderId, ProviderKey, statusCode, |
| | 6 | 352 | | cartItemId: null, externalBasketItemId: null, user: changedBy, |
| | 6 | 353 | | deliveryDaysMin: item.DeliveryDaysMin, deliveryDaysMax: item.DeliveryDaysMax, direction: item.Direction) |
| | 6 | 354 | | } |
| | 0 | 355 | | catch |
| | | 356 | | { |
| | | 357 | | // См. комментарий к методу. |
| | 0 | 358 | | } |
| | 6 | 359 | | } |
| | | 360 | | |
| | | 361 | | private async Task TryTrackOrderedAsync(BergCartQueueItem item, long externalOrderId, int? sequence, string changedB |
| | | 362 | | { |
| | | 363 | | try |
| | | 364 | | { |
| | 2 | 365 | | var orderId = externalOrderId.ToString(); |
| | 2 | 366 | | await _supplierStateService.MarkOrderedAsync(item.OrderId, ProviderKey, externalOrderNumber: orderId, |
| | 2 | 367 | | externalOrderId: orderId, externalLineId: sequence?.ToString(), user: changedBy, |
| | 2 | 368 | | deliveryDaysMin: item.DeliveryDaysMin, deliveryDaysMax: item.DeliveryDaysMax, direction: item.Direction) |
| | 2 | 369 | | } |
| | 0 | 370 | | catch |
| | | 371 | | { |
| | | 372 | | // См. TryTrackCartAsync. |
| | 0 | 373 | | } |
| | 2 | 374 | | } |
| | | 375 | | |
| | | 376 | | private async Task TryRecordHistoryAsync(BergCartQueueItem item, bool success, string? apiItemId, |
| | | 377 | | string? supplierOrderNumber, string changedBy, string cartStatus, string? errorMessage = null) |
| | | 378 | | { |
| | | 379 | | try |
| | | 380 | | { |
| | 8 | 381 | | var entry = new ApiSupplierBasketHistoryEntry(ProviderKey, SupplierDisplayName, LogoUrl, success, |
| | 8 | 382 | | errorMessage, apiItemId, item.Article, item.ProductName, item.Price, CurrencyCode, item.Quantity, |
| | 8 | 383 | | string.IsNullOrWhiteSpace(item.ShipmentNumber) ? $"ID {item.OrderId}" : item.ShipmentNumber, |
| | 8 | 384 | | ClientName: item.ClientName, WarehouseName: item.Direction, CartStatus: cartStatus, |
| | 8 | 385 | | SupplierOrderNumber: supplierOrderNumber, SupplierCartUrl: SupplierCartUrl); |
| | | 386 | | |
| | 8 | 387 | | await _orderHistoryService.AddOrderHistory(new OrderHistory |
| | 8 | 388 | | { |
| | 8 | 389 | | OrderId = item.OrderId, |
| | 8 | 390 | | ColumnName = ApiSupplierBasketHistoryEntry.HistoryColumnName, |
| | 8 | 391 | | ColumnDisplayName = $"Корзина {SupplierDisplayName}", |
| | 8 | 392 | | OldValue = null, |
| | 8 | 393 | | NewValue = JsonSerializer.Serialize(entry, ApiSupplierBasketHistoryEntry.JsonOptions), |
| | 8 | 394 | | ChangedAt = DateTime.Now, |
| | 8 | 395 | | ChangedBy = changedBy |
| | 8 | 396 | | }); |
| | 8 | 397 | | } |
| | 0 | 398 | | catch |
| | | 399 | | { |
| | | 400 | | // Не ломаем размещение в корзине из-за журнала истории. |
| | 0 | 401 | | } |
| | 8 | 402 | | } |
| | | 403 | | |
| | | 404 | | /// <summary> |
| | | 405 | | /// Оформление отобранных строк локальной корзины со страницы «Корзина поставщика». |
| | | 406 | | /// <paramref name="isTest"/> отправляет заказ с order[is_test]=1: Berg сохранит его в истории, |
| | | 407 | | /// но обрабатывать не станет — это штатная проверка перед боевым размещением. |
| | | 408 | | /// </summary> |
| | | 409 | | public async Task<BergCartResult> CheckoutAsync(IReadOnlyCollection<long> cartItemIds, string changedBy, |
| | | 410 | | bool isTest = false, CancellationToken ct = default) |
| | | 411 | | { |
| | 1 | 412 | | var rows = await _context.BergCartItems |
| | 1 | 413 | | .Where(x => cartItemIds.Contains(x.Id) && BergCartItemStatus.Active.Contains(x.Status)) |
| | 1 | 414 | | .ToListAsync(ct); |
| | 1 | 415 | | if (rows.Count == 0) return new(false, ["Не выбраны позиции корзины Berg."]); |
| | | 416 | | |
| | | 417 | | var queue = rows.Select(x => new BergCartQueueItem(x.StudioOrderId, x.ResourceId, x.WarehouseId, x.Quantity, |
| | | 418 | | x.MaxPrice ?? x.SourcePrice, x.Article, x.Brand, x.ProductName, null, null, |
| | | 419 | | x.Multi, null, null, x.WarehouseName)).ToList(); |
| | | 420 | | |
| | 1 | 421 | | var shipmentNumbers = await _context.Orders.AsNoTracking() |
| | 1 | 422 | | .Where(x => queue.Select(q => q.OrderId).Contains(x.Id)) |
| | | 423 | | .ToDictionaryAsync(x => x.Id, x => x.ShipmentNumber, ct); |
| | 2 | 424 | | queue = queue.Select(x => shipmentNumbers.TryGetValue(x.OrderId, out var number) && !string.IsNullOrWhiteSpace(n |
| | 2 | 425 | | ? x with { ShipmentNumber = number } |
| | 2 | 426 | | : x).ToList(); |
| | | 427 | | |
| | 1 | 428 | | return await CheckoutDirectAsync(queue, changedBy, ct, isTest); |
| | 1 | 429 | | } |
| | | 430 | | |
| | | 431 | | public Task<int> CountActiveAsync(CancellationToken ct = default) => |
| | 0 | 432 | | _context.BergCartItems.CountAsync(x => BergCartItemStatus.Active.Contains(x.Status), ct); |
| | | 433 | | |
| | | 434 | | public Task<List<BergCartItem>> GetActiveAsync(CancellationToken ct = default) => |
| | 0 | 435 | | _context.BergCartItems.AsNoTracking() |
| | 0 | 436 | | .Where(x => BergCartItemStatus.Active.Contains(x.Status)) |
| | 0 | 437 | | .OrderByDescending(x => x.CreatedAtUtc) |
| | 0 | 438 | | .ToListAsync(ct); |
| | | 439 | | |
| | | 440 | | /// <summary>Снимает строки с активной корзины, сохраняя их в истории.</summary> |
| | | 441 | | public async Task<int> RemoveAsync(IReadOnlyCollection<long> cartItemIds, CancellationToken ct = default) |
| | | 442 | | { |
| | 1 | 443 | | if (cartItemIds.Count == 0) return 0; |
| | | 444 | | |
| | 1 | 445 | | var rows = await _context.BergCartItems.Where(x => cartItemIds.Contains(x.Id)).ToListAsync(ct); |
| | 4 | 446 | | foreach (var row in rows) |
| | | 447 | | { |
| | 1 | 448 | | row.Status = BergCartItemStatus.Removed; |
| | 1 | 449 | | row.ActiveStudioOrderId = null; |
| | 1 | 450 | | row.UpdatedAtUtc = DateTime.UtcNow; |
| | | 451 | | } |
| | | 452 | | |
| | 1 | 453 | | await _context.SaveChangesAsync(ct); |
| | | 454 | | |
| | 4 | 455 | | foreach (var row in rows) |
| | | 456 | | { |
| | 2 | 457 | | try { await _supplierStateService.RemoveFromCartAsync(row.StudioOrderId, ProviderKey); } |
| | 0 | 458 | | catch { /* журнал стадии не должен ломать удаление */ } |
| | | 459 | | } |
| | | 460 | | |
| | 1 | 461 | | return rows.Count; |
| | 1 | 462 | | } |
| | | 463 | | } |