| | | 1 | | using Microsoft.EntityFrameworkCore; |
| | | 2 | | using OzonDomains.Models; |
| | | 3 | | using OzonRepositories.Context; |
| | | 4 | | |
| | | 5 | | namespace OzonRepositories.Data; |
| | | 6 | | |
| | | 7 | | public class OrderReturnRepository : MainRepository, IRepository<OrderReturn> |
| | | 8 | | { |
| | 15 | 9 | | public OrderReturnRepository(ApplicationDbContext context) : base(context) |
| | | 10 | | { |
| | 15 | 11 | | } |
| | | 12 | | |
| | | 13 | | public async Task<int> Add(OrderReturn value) |
| | | 14 | | { |
| | 0 | 15 | | value.UpdatedAt = DateTime.UtcNow; |
| | 0 | 16 | | await _context.OrderReturns.AddAsync(value); |
| | 0 | 17 | | return await _context.SaveChangesAsync(); |
| | 0 | 18 | | } |
| | | 19 | | |
| | | 20 | | public async Task<int> Delete(OrderReturn value) |
| | | 21 | | { |
| | 0 | 22 | | _context.OrderReturns.Remove(value); |
| | 0 | 23 | | return await _context.SaveChangesAsync(); |
| | 0 | 24 | | } |
| | | 25 | | |
| | | 26 | | public async Task<List<OrderReturn>> Get() |
| | | 27 | | { |
| | 0 | 28 | | return await _context.OrderReturns |
| | 0 | 29 | | .Include(x => x.Order) |
| | 0 | 30 | | .Include(x => x.OzonClient) |
| | 0 | 31 | | .OrderByDescending(x => x.UpdatedAt) |
| | 0 | 32 | | .ToListAsync(); |
| | 0 | 33 | | } |
| | | 34 | | |
| | | 35 | | public async Task<OrderReturn?> GetAsync(int id) |
| | | 36 | | { |
| | 0 | 37 | | var entity = await GetByIdAsync(id); |
| | 0 | 38 | | return entity ?? throw new InvalidOperationException($"OrderReturn с Id={id} не найден."); |
| | 0 | 39 | | } |
| | | 40 | | |
| | | 41 | | public async Task<OrderReturn?> GetAsync(OrderReturn value) |
| | | 42 | | { |
| | 0 | 43 | | var entity = await _context.OrderReturns |
| | 0 | 44 | | .Include(x => x.Order) |
| | 0 | 45 | | .Include(x => x.OzonClient) |
| | 0 | 46 | | .FirstOrDefaultAsync(x => x.OzonReturnId == value.OzonReturnId); |
| | 0 | 47 | | return entity ?? throw new InvalidOperationException($"OrderReturn с OzonReturnId={value.OzonReturnId} не найден |
| | 0 | 48 | | } |
| | | 49 | | |
| | | 50 | | public async Task<int> Update(OrderReturn value) |
| | | 51 | | { |
| | 0 | 52 | | value.UpdatedAt = DateTime.UtcNow; |
| | 0 | 53 | | _context.OrderReturns.Update(value); |
| | 0 | 54 | | return await _context.SaveChangesAsync(); |
| | 0 | 55 | | } |
| | | 56 | | |
| | | 57 | | /// <summary>Получить возврат по внутреннему Id.</summary> |
| | | 58 | | public async Task<OrderReturn?> GetByIdAsync(long id) |
| | | 59 | | { |
| | 0 | 60 | | return await _context.OrderReturns |
| | 0 | 61 | | .Include(x => x.Order) |
| | 0 | 62 | | .ThenInclude(o => o!.ProductInfo) |
| | 0 | 63 | | .Include(x => x.OzonClient) |
| | 0 | 64 | | .FirstOrDefaultAsync(x => x.Id == id); |
| | 0 | 65 | | } |
| | | 66 | | |
| | | 67 | | /// <summary>Получить возврат по OzonReturnId (без OzonClient — используйте OzonClientId при необходимости).</summar |
| | | 68 | | public async Task<OrderReturn?> GetByOzonReturnIdAsync(long ozonReturnId) |
| | | 69 | | { |
| | 0 | 70 | | return await _context.OrderReturns |
| | 0 | 71 | | .Include(x => x.Order) |
| | 0 | 72 | | .FirstOrDefaultAsync(x => x.OzonReturnId == ozonReturnId); |
| | 0 | 73 | | } |
| | | 74 | | |
| | | 75 | | /// <summary>Получить возврат по OzonReturnId для Upsert — без Include (облегчённый запрос).</summary> |
| | | 76 | | public async Task<OrderReturn?> GetByOzonReturnIdForUpsertAsync(long ozonReturnId) |
| | | 77 | | { |
| | 0 | 78 | | return await _context.OrderReturns |
| | 0 | 79 | | .FirstOrDefaultAsync(x => x.OzonReturnId == ozonReturnId); |
| | 0 | 80 | | } |
| | | 81 | | |
| | | 82 | | /// <summary>Получить все возвраты для заказа.</summary> |
| | | 83 | | public async Task<List<OrderReturn>> GetByOrderIdAsync(int orderId) |
| | | 84 | | { |
| | 0 | 85 | | return await _context.OrderReturns |
| | 0 | 86 | | .Include(x => x.Order) |
| | 0 | 87 | | .Include(x => x.OzonClient) |
| | 0 | 88 | | .Where(x => x.OrderId == orderId) |
| | 0 | 89 | | .OrderByDescending(x => x.UpdatedAt) |
| | 0 | 90 | | .ToListAsync(); |
| | 0 | 91 | | } |
| | | 92 | | |
| | | 93 | | /// <summary>Получить возвраты по списку заказов.</summary> |
| | | 94 | | public async Task<List<OrderReturn>> GetByOrderIdsAsync(IEnumerable<int> orderIds) |
| | | 95 | | { |
| | 0 | 96 | | if (orderIds == null || !orderIds.Any()) |
| | 0 | 97 | | return new List<OrderReturn>(); |
| | | 98 | | |
| | 0 | 99 | | return await _context.OrderReturns |
| | 0 | 100 | | .AsNoTracking() |
| | 0 | 101 | | .Include(x => x.Order) |
| | 0 | 102 | | .Include(x => x.OzonClient) |
| | 0 | 103 | | .Where(x => x.OrderId.HasValue && orderIds.Contains(x.OrderId.Value)) |
| | 0 | 104 | | .OrderByDescending(x => x.UpdatedAt) |
| | 0 | 105 | | .ToListAsync(); |
| | 0 | 106 | | } |
| | | 107 | | |
| | | 108 | | /// <summary>Получить возвраты по номеру отправления.</summary> |
| | | 109 | | public async Task<List<OrderReturn>> GetByPostingNumberAsync(string postingNumber) |
| | | 110 | | { |
| | 0 | 111 | | return await _context.OrderReturns |
| | 0 | 112 | | .Include(x => x.Order) |
| | 0 | 113 | | .Include(x => x.OzonClient) |
| | 0 | 114 | | .Where(x => x.PostingNumber == postingNumber) |
| | 0 | 115 | | .OrderByDescending(x => x.UpdatedAt) |
| | 0 | 116 | | .ToListAsync(); |
| | 0 | 117 | | } |
| | | 118 | | |
| | | 119 | | /// <summary>Найти возврат по PostingNumber и OrderNumber для обновления (уникальность).</summary> |
| | | 120 | | public async Task<OrderReturn?> GetByPostingAndOrderNumberAsync(string? postingNumber, string? orderNumber, int ozon |
| | | 121 | | { |
| | 0 | 122 | | if (string.IsNullOrEmpty(postingNumber) && string.IsNullOrEmpty(orderNumber)) |
| | 0 | 123 | | return null; |
| | | 124 | | |
| | 0 | 125 | | var query = _context.OrderReturns |
| | 0 | 126 | | .Include(x => x.Order) |
| | 0 | 127 | | .Include(x => x.OzonClient) |
| | 0 | 128 | | .Where(x => x.OzonClientId == ozonClientId); |
| | | 129 | | |
| | 0 | 130 | | if (!string.IsNullOrEmpty(postingNumber) && !string.IsNullOrEmpty(orderNumber)) |
| | 0 | 131 | | query = query.Where(x => x.PostingNumber == postingNumber && x.OrderNumber == orderNumber); |
| | 0 | 132 | | else if (!string.IsNullOrEmpty(postingNumber)) |
| | 0 | 133 | | query = query.Where(x => x.PostingNumber == postingNumber); |
| | | 134 | | else |
| | 0 | 135 | | query = query.Where(x => x.OrderNumber == orderNumber); |
| | | 136 | | |
| | 0 | 137 | | return await query.OrderByDescending(x => x.UpdatedAt).FirstOrDefaultAsync(); |
| | 0 | 138 | | } |
| | | 139 | | |
| | | 140 | | /// <summary> |
| | | 141 | | /// Найти возврат для Upsert — без Include (облегчённый запрос). |
| | | 142 | | /// Приоритет: PostingNumber (если задан), иначе OrderNumber. |
| | | 143 | | /// </summary> |
| | | 144 | | public async Task<OrderReturn?> GetByPostingAndOrderNumberForUpsertAsync(string? postingNumber, string? orderNumber, |
| | | 145 | | { |
| | 0 | 146 | | if (string.IsNullOrEmpty(postingNumber) && string.IsNullOrEmpty(orderNumber)) |
| | 0 | 147 | | return null; |
| | | 148 | | |
| | 0 | 149 | | var query = _context.OrderReturns |
| | 0 | 150 | | .Where(x => x.OzonClientId == ozonClientId && x.OzonReturnId == 0); |
| | | 151 | | |
| | 0 | 152 | | if (!string.IsNullOrEmpty(postingNumber)) |
| | 0 | 153 | | query = query.Where(x => x.PostingNumber == postingNumber); |
| | | 154 | | else |
| | 0 | 155 | | query = query.Where(x => x.OrderNumber == orderNumber); |
| | | 156 | | |
| | 0 | 157 | | return await query.OrderByDescending(x => x.UpdatedAt).FirstOrDefaultAsync(); |
| | 0 | 158 | | } |
| | | 159 | | |
| | | 160 | | /// <summary>Получить возвраты по клиенту Ozon с пагинацией.</summary> |
| | | 161 | | /// <param name="ozonClientId">ID клиента или 0 для всех Ozon-клиентов.</param> |
| | | 162 | | public async Task<(List<OrderReturn> Items, int Total)> GetByOzonClientIdAsync( |
| | | 163 | | int ozonClientId, |
| | | 164 | | int skip = 0, |
| | | 165 | | int take = 50, |
| | | 166 | | string? statusSysName = null, |
| | | 167 | | string? postingNumber = null, |
| | | 168 | | string? orderNumber = null, |
| | | 169 | | string? returnReasonName = null, |
| | | 170 | | int? orderId = null, |
| | | 171 | | DateTime? fromDate = null, |
| | | 172 | | DateTime? toDate = null, |
| | | 173 | | IEnumerable<int>? ozonClientIdsFilter = null) |
| | | 174 | | { |
| | 0 | 175 | | var query = _context.OrderReturns |
| | 0 | 176 | | .AsNoTracking() |
| | 0 | 177 | | .Include(x => x.Order) |
| | 0 | 178 | | .Include(x => x.OzonClient) |
| | 0 | 179 | | .AsQueryable(); |
| | | 180 | | |
| | 0 | 181 | | if (orderId.HasValue) |
| | 0 | 182 | | query = query.Where(x => x.OrderId == orderId.Value); |
| | 0 | 183 | | else if (ozonClientIdsFilter != null && ozonClientIdsFilter.Any()) |
| | 0 | 184 | | query = query.Where(x => ozonClientIdsFilter.Contains(x.OzonClientId)); |
| | 0 | 185 | | else if (ozonClientId > 0) |
| | 0 | 186 | | query = query.Where(x => x.OzonClientId == ozonClientId); |
| | | 187 | | |
| | 0 | 188 | | if (!string.IsNullOrEmpty(statusSysName)) |
| | 0 | 189 | | query = query.Where(x => x.VisualStatusSysName == statusSysName); |
| | | 190 | | |
| | 0 | 191 | | if (!string.IsNullOrEmpty(postingNumber)) |
| | 0 | 192 | | query = query.Where(x => x.PostingNumber != null && x.PostingNumber.Contains(postingNumber)); |
| | | 193 | | |
| | 0 | 194 | | if (!string.IsNullOrEmpty(orderNumber)) |
| | 0 | 195 | | query = query.Where(x => x.OrderNumber != null && x.OrderNumber.Contains(orderNumber)); |
| | | 196 | | |
| | 0 | 197 | | if (!string.IsNullOrEmpty(returnReasonName)) |
| | 0 | 198 | | query = query.Where(x => x.ReturnReasonName != null && x.ReturnReasonName.Contains(returnReasonName)); |
| | | 199 | | |
| | 0 | 200 | | if (fromDate.HasValue) |
| | 0 | 201 | | query = query.Where(x => x.CreatedAt >= fromDate.Value); |
| | | 202 | | |
| | 0 | 203 | | if (toDate.HasValue) |
| | 0 | 204 | | query = query.Where(x => x.CreatedAt <= toDate.Value); |
| | | 205 | | |
| | 0 | 206 | | var total = await query.CountAsync(); |
| | 0 | 207 | | var items = await query |
| | 0 | 208 | | .OrderByDescending(x => x.UpdatedAt) |
| | 0 | 209 | | .Skip(skip) |
| | 0 | 210 | | .Take(take) |
| | 0 | 211 | | .ToListAsync(); |
| | | 212 | | |
| | 0 | 213 | | return (items, total); |
| | 0 | 214 | | } |
| | | 215 | | |
| | | 216 | | /// <summary>Создать или обновить возврат по данным из API. Уникальность по OzonReturnId, затем по PostingNumber+Ord |
| | | 217 | | public async Task<OrderReturn> UpsertFromOzonReturnAsync(OrderReturn entity) |
| | | 218 | | { |
| | 0 | 219 | | var existing = await GetByOzonReturnIdForUpsertAsync(entity.OzonReturnId); |
| | 0 | 220 | | if (existing != null) |
| | | 221 | | { |
| | 0 | 222 | | UpdateFromEntity(existing, entity); |
| | 0 | 223 | | await Update(existing); |
| | 0 | 224 | | return existing; |
| | | 225 | | } |
| | | 226 | | |
| | 0 | 227 | | existing = await GetByPostingAndOrderNumberForUpsertAsync(entity.PostingNumber, entity.OrderNumber, entity.OzonC |
| | 0 | 228 | | if (existing != null) |
| | | 229 | | { |
| | 0 | 230 | | UpdateFromEntity(existing, entity); |
| | 0 | 231 | | await Update(existing); |
| | 0 | 232 | | return existing; |
| | | 233 | | } |
| | | 234 | | |
| | 0 | 235 | | await Add(entity); |
| | 0 | 236 | | return entity; |
| | 0 | 237 | | } |
| | | 238 | | |
| | | 239 | | /// <summary> |
| | | 240 | | /// Сбросить ChangeTracker после обработанного батча. Джоб загрузки живёт в одном DI-скоупе, |
| | | 241 | | /// поэтому за прогон в трекере копятся десятки тысяч сущностей и каждый следующий SaveChanges |
| | | 242 | | /// становится медленнее — DetectChanges линеен по числу отслеживаемых записей. |
| | | 243 | | /// </summary> |
| | 1 | 244 | | public void ClearChangeTracker() => _context.ChangeTracker.Clear(); |
| | | 245 | | |
| | | 246 | | /// <summary> |
| | | 247 | | /// Максимальный VisualStatusChangeMoment среди уже сохранённых возвратов клиента — watermark |
| | | 248 | | /// для инкрементальной загрузки. Считается по фактически записанным данным, поэтому оборванный |
| | | 249 | | /// прогон не сдвигает границу вперёд и недогруженный период будет перечитан на следующем запуске. |
| | | 250 | | /// </summary> |
| | | 251 | | public async Task<DateTime?> GetMaxVisualStatusChangeMomentAsync(int ozonClientId) |
| | | 252 | | { |
| | 2 | 253 | | if (ozonClientId <= 0) |
| | 0 | 254 | | return null; |
| | | 255 | | |
| | 2 | 256 | | return await _context.OrderReturns |
| | 2 | 257 | | .AsNoTracking() |
| | 2 | 258 | | .Where(x => x.OzonClientId == ozonClientId && x.VisualStatusChangeMoment != null) |
| | 2 | 259 | | .MaxAsync(x => x.VisualStatusChangeMoment); |
| | 2 | 260 | | } |
| | | 261 | | |
| | | 262 | | /// <summary> |
| | | 263 | | /// Батч-создание/обновление возвратов из API. Один запрос на проверку существования + один SaveChanges. |
| | | 264 | | /// Возвращает общее количество обработанных записей и те из них, у которых реально изменился |
| | | 265 | | /// статус возврата или компенсации — только для них имеет смысл переспрашивать статус заказа в Ozon. |
| | | 266 | | /// </summary> |
| | | 267 | | public async Task<OrderReturnUpsertResult> UpsertBatchFromOzonReturnsAsync(IEnumerable<OrderReturn> entities) |
| | | 268 | | { |
| | 13 | 269 | | var entityList = entities.ToList(); |
| | 13 | 270 | | if (entityList.Count == 0) |
| | 0 | 271 | | return OrderReturnUpsertResult.Empty; |
| | | 272 | | |
| | | 273 | | // Отфильтровываем записи с некорректным ID и дедуплицируем батч по OzonReturnId, |
| | | 274 | | // оставляя последнее состояние на случай повторов в ответе API Ozon. |
| | 13 | 275 | | var dedupedList = entityList |
| | 19 | 276 | | .Where(e => e.OzonReturnId > 0) |
| | 18 | 277 | | .GroupBy(e => e.OzonReturnId) |
| | 17 | 278 | | .Select(g => g.Last()) |
| | 13 | 279 | | .ToList(); |
| | | 280 | | |
| | 13 | 281 | | if (dedupedList.Count == 0) |
| | 0 | 282 | | return OrderReturnUpsertResult.Empty; |
| | | 283 | | |
| | 13 | 284 | | var changed = new List<OrderReturn>(); |
| | | 285 | | |
| | 30 | 286 | | var ozonReturnIds = dedupedList.Select(e => e.OzonReturnId).Distinct().ToList(); |
| | 13 | 287 | | var existingByOzonId = await _context.OrderReturns |
| | 13 | 288 | | .Where(x => ozonReturnIds.Contains(x.OzonReturnId)) |
| | 22 | 289 | | .ToDictionaryAsync(x => x.OzonReturnId); |
| | | 290 | | |
| | 30 | 291 | | var notFoundByOzonId = dedupedList.Where(e => !existingByOzonId.ContainsKey(e.OzonReturnId)).ToList(); |
| | | 292 | | |
| | 13 | 293 | | var postingKeys = notFoundByOzonId |
| | 8 | 294 | | .Where(e => e.OzonClientId > 0 && !string.IsNullOrEmpty(e.PostingNumber)) |
| | 8 | 295 | | .Select(e => new { e.OzonClientId, PostingNumber = e.PostingNumber! }) |
| | 13 | 296 | | .Distinct() |
| | 13 | 297 | | .ToList(); |
| | | 298 | | |
| | 13 | 299 | | var orderKeysWithoutPosting = notFoundByOzonId |
| | 8 | 300 | | .Where(e => e.OzonClientId > 0 && string.IsNullOrEmpty(e.PostingNumber) && !string.IsNullOrEmpty(e.OrderNumb |
| | 0 | 301 | | .Select(e => new { e.OzonClientId, OrderNumber = e.OrderNumber! }) |
| | 13 | 302 | | .Distinct() |
| | 13 | 303 | | .ToList(); |
| | | 304 | | |
| | 13 | 305 | | Dictionary<string, OrderReturn>? existingByPosting = null; |
| | 13 | 306 | | if (postingKeys.Count > 0) |
| | | 307 | | { |
| | 13 | 308 | | var postingClientIds = postingKeys.Select(k => k.OzonClientId).Distinct().ToList(); |
| | 13 | 309 | | var postingNumbers = postingKeys.Select(k => k.PostingNumber).Distinct().ToList(); |
| | 6 | 310 | | var existingPostingList = await _context.OrderReturns |
| | 6 | 311 | | .Where(x => |
| | 6 | 312 | | postingClientIds.Contains(x.OzonClientId) && |
| | 6 | 313 | | x.OzonReturnId == 0 && |
| | 6 | 314 | | x.PostingNumber != null && |
| | 6 | 315 | | postingNumbers.Contains(x.PostingNumber)) |
| | 6 | 316 | | .ToListAsync(); |
| | | 317 | | |
| | 6 | 318 | | var postingSet = postingKeys |
| | 7 | 319 | | .Select(k => $"{k.OzonClientId}|{k.PostingNumber}") |
| | 6 | 320 | | .ToHashSet(); |
| | | 321 | | |
| | 6 | 322 | | existingByPosting = existingPostingList |
| | 0 | 323 | | .Where(x => x.PostingNumber != null && postingSet.Contains($"{x.OzonClientId}|{x.PostingNumber}")) |
| | 0 | 324 | | .GroupBy(x => $"{x.OzonClientId}|{x.PostingNumber}") |
| | 6 | 325 | | .ToDictionary(g => g.Key, g => g.OrderByDescending(x => x.UpdatedAt).First()); |
| | 6 | 326 | | } |
| | | 327 | | |
| | 13 | 328 | | Dictionary<string, OrderReturn>? existingByOrderWithoutPosting = null; |
| | 13 | 329 | | if (orderKeysWithoutPosting.Count > 0) |
| | | 330 | | { |
| | 0 | 331 | | var orderClientIds = orderKeysWithoutPosting.Select(k => k.OzonClientId).Distinct().ToList(); |
| | 0 | 332 | | var orderNumbers = orderKeysWithoutPosting.Select(k => k.OrderNumber).Distinct().ToList(); |
| | 0 | 333 | | var existingOrderList = await _context.OrderReturns |
| | 0 | 334 | | .Where(x => |
| | 0 | 335 | | orderClientIds.Contains(x.OzonClientId) && |
| | 0 | 336 | | x.OzonReturnId == 0 && |
| | 0 | 337 | | x.OrderNumber != null && |
| | 0 | 338 | | orderNumbers.Contains(x.OrderNumber)) |
| | 0 | 339 | | .ToListAsync(); |
| | | 340 | | |
| | 0 | 341 | | var orderSet = orderKeysWithoutPosting |
| | 0 | 342 | | .Select(k => $"{k.OzonClientId}|{k.OrderNumber}") |
| | 0 | 343 | | .ToHashSet(); |
| | | 344 | | |
| | 0 | 345 | | existingByOrderWithoutPosting = existingOrderList |
| | 0 | 346 | | .Where(x => x.OrderNumber != null && orderSet.Contains($"{x.OzonClientId}|{x.OrderNumber}")) |
| | 0 | 347 | | .GroupBy(x => $"{x.OzonClientId}|{x.OrderNumber}") |
| | 0 | 348 | | .ToDictionary(g => g.Key, g => g.OrderByDescending(x => x.UpdatedAt).First()); |
| | 0 | 349 | | } |
| | | 350 | | |
| | 13 | 351 | | var count = 0; |
| | 13 | 352 | | var inserted = 0; |
| | 60 | 353 | | foreach (var entity in dedupedList) |
| | | 354 | | { |
| | 17 | 355 | | entity.UpdatedAt = DateTime.UtcNow; |
| | | 356 | | |
| | 17 | 357 | | if (existingByOzonId.TryGetValue(entity.OzonReturnId, out var existing)) |
| | | 358 | | { |
| | 9 | 359 | | var statusChanged = HasStatusChanged(existing, entity); |
| | 9 | 360 | | UpdateFromEntity(existing, entity); |
| | 9 | 361 | | if (statusChanged) |
| | 4 | 362 | | changed.Add(existing); |
| | 9 | 363 | | count++; |
| | 9 | 364 | | continue; |
| | | 365 | | } |
| | | 366 | | |
| | 8 | 367 | | if (!string.IsNullOrEmpty(entity.PostingNumber)) |
| | | 368 | | { |
| | 8 | 369 | | var postingKey = $"{entity.OzonClientId}|{entity.PostingNumber}"; |
| | 8 | 370 | | if (existingByPosting != null && existingByPosting.TryGetValue(postingKey, out var existingByPostingNumb |
| | | 371 | | { |
| | 0 | 372 | | var statusChanged = HasStatusChanged(existingByPostingNumber, entity); |
| | 0 | 373 | | UpdateFromEntity(existingByPostingNumber, entity); |
| | 0 | 374 | | existingByOzonId[entity.OzonReturnId] = existingByPostingNumber; |
| | 0 | 375 | | existingByPosting.Remove(postingKey); |
| | 0 | 376 | | if (statusChanged) |
| | 0 | 377 | | changed.Add(existingByPostingNumber); |
| | 0 | 378 | | count++; |
| | 0 | 379 | | continue; |
| | | 380 | | } |
| | | 381 | | } |
| | 0 | 382 | | else if (!string.IsNullOrEmpty(entity.OrderNumber)) |
| | | 383 | | { |
| | 0 | 384 | | var orderKey = $"{entity.OzonClientId}|{entity.OrderNumber}"; |
| | 0 | 385 | | if (existingByOrderWithoutPosting != null && existingByOrderWithoutPosting.TryGetValue(orderKey, out var |
| | | 386 | | { |
| | 0 | 387 | | var statusChanged = HasStatusChanged(existingByOrderNumber, entity); |
| | 0 | 388 | | UpdateFromEntity(existingByOrderNumber, entity); |
| | 0 | 389 | | existingByOzonId[entity.OzonReturnId] = existingByOrderNumber; |
| | 0 | 390 | | existingByOrderWithoutPosting.Remove(orderKey); |
| | 0 | 391 | | if (statusChanged) |
| | 0 | 392 | | changed.Add(existingByOrderNumber); |
| | 0 | 393 | | count++; |
| | 0 | 394 | | continue; |
| | | 395 | | } |
| | | 396 | | } |
| | | 397 | | |
| | 8 | 398 | | await _context.OrderReturns.AddAsync(entity); |
| | 8 | 399 | | existingByOzonId[entity.OzonReturnId] = entity; |
| | | 400 | | |
| | | 401 | | // Новый возврат — статус для нас всегда новый. |
| | 8 | 402 | | changed.Add(entity); |
| | 8 | 403 | | inserted++; |
| | 8 | 404 | | count++; |
| | 8 | 405 | | } |
| | | 406 | | |
| | | 407 | | try |
| | | 408 | | { |
| | 13 | 409 | | await _context.SaveChangesAsync(); |
| | 13 | 410 | | return new OrderReturnUpsertResult(count, inserted, changed); |
| | | 411 | | } |
| | 0 | 412 | | catch |
| | | 413 | | { |
| | 0 | 414 | | _context.ChangeTracker.Clear(); |
| | 0 | 415 | | throw; |
| | | 416 | | } |
| | 13 | 417 | | } |
| | | 418 | | |
| | | 419 | | /// <summary> |
| | | 420 | | /// Изменился ли статус возврата или компенсации. Остальные поля (стоимость хранения, дни, |
| | | 421 | | /// прогноз утилизации) меняются у Ozon постоянно и поводом перезапрашивать статус заказа не являются. |
| | | 422 | | /// </summary> |
| | | 423 | | private static bool HasStatusChanged(OrderReturn existing, OrderReturn incoming) => |
| | 9 | 424 | | !string.Equals(existing.VisualStatusSysName, incoming.VisualStatusSysName, StringComparison.Ordinal) || |
| | 9 | 425 | | existing.VisualStatusChangeMoment != incoming.VisualStatusChangeMoment || |
| | 9 | 426 | | !string.Equals(existing.CompensationStatusSysName, incoming.CompensationStatusSysName, StringComparison.Ordinal) |
| | 9 | 427 | | existing.CompensationStatusChangeMoment != incoming.CompensationStatusChangeMoment; |
| | | 428 | | |
| | | 429 | | private static void UpdateFromEntity(OrderReturn target, OrderReturn source) |
| | | 430 | | { |
| | 9 | 431 | | target.OzonReturnId = source.OzonReturnId; |
| | | 432 | | // Связь с заказом не затираем: поиск заказа идёт только по неархивным |
| | | 433 | | // (OrderRepository.GetOrderIdsByShipmentNumbersAsync фильтрует OrderArchive == null), |
| | | 434 | | // поэтому после архивации заказа source.OrderId придёт null и уже найденная связь |
| | | 435 | | // была бы потеряна вместе с возвратом на странице заказа и в фильтрах. |
| | 9 | 436 | | target.OrderId = source.OrderId ?? target.OrderId; |
| | 9 | 437 | | target.PostingNumber = source.PostingNumber; |
| | 9 | 438 | | target.OrderNumber = source.OrderNumber; |
| | 9 | 439 | | target.ReturnReasonName = source.ReturnReasonName; |
| | 9 | 440 | | target.ReturnType = source.ReturnType; |
| | 9 | 441 | | target.Schema = source.Schema; |
| | 9 | 442 | | target.PlaceId = source.PlaceId; |
| | 9 | 443 | | target.PlaceName = source.PlaceName; |
| | 9 | 444 | | target.PlaceAddress = source.PlaceAddress; |
| | 9 | 445 | | target.TargetPlaceId = source.TargetPlaceId; |
| | 9 | 446 | | target.TargetPlaceName = source.TargetPlaceName; |
| | 9 | 447 | | target.TargetPlaceAddress = source.TargetPlaceAddress; |
| | 9 | 448 | | target.StorageSumPrice = source.StorageSumPrice; |
| | 9 | 449 | | target.StorageSumCurrency = source.StorageSumCurrency; |
| | 9 | 450 | | target.StorageDays = source.StorageDays; |
| | 9 | 451 | | target.StorageTarificationFirstDate = source.StorageTarificationFirstDate; |
| | 9 | 452 | | target.StorageTarificationStartDate = source.StorageTarificationStartDate; |
| | 9 | 453 | | target.StorageArrivedMoment = source.StorageArrivedMoment; |
| | 9 | 454 | | target.UtilizationSumPrice = source.UtilizationSumPrice; |
| | 9 | 455 | | target.UtilizationSumCurrency = source.UtilizationSumCurrency; |
| | 9 | 456 | | target.UtilizationForecastDate = source.UtilizationForecastDate; |
| | 9 | 457 | | target.ProductSku = source.ProductSku; |
| | 9 | 458 | | target.ProductOfferId = source.ProductOfferId; |
| | 9 | 459 | | target.ProductName = source.ProductName; |
| | 9 | 460 | | target.ProductPrice = source.ProductPrice; |
| | 9 | 461 | | target.ProductPriceCurrency = source.ProductPriceCurrency; |
| | 9 | 462 | | target.ProductCommissionPercent = source.ProductCommissionPercent; |
| | 9 | 463 | | target.ProductCommission = source.ProductCommission; |
| | 9 | 464 | | target.ProductQuantity = source.ProductQuantity; |
| | 9 | 465 | | target.TechnicalReturnMoment = source.TechnicalReturnMoment; |
| | 9 | 466 | | target.FinalMoment = source.FinalMoment; |
| | 9 | 467 | | target.CancelledWithCompensationMoment = source.CancelledWithCompensationMoment; |
| | 9 | 468 | | target.ReturnDate = source.ReturnDate; |
| | 9 | 469 | | target.LogisticBarcode = source.LogisticBarcode; |
| | 9 | 470 | | target.VisualStatusId = source.VisualStatusId; |
| | 9 | 471 | | target.VisualStatusDisplayName = source.VisualStatusDisplayName; |
| | 9 | 472 | | target.VisualStatusSysName = source.VisualStatusSysName; |
| | 9 | 473 | | target.VisualStatusChangeMoment = source.VisualStatusChangeMoment; |
| | 9 | 474 | | target.CompensationStatusId = source.CompensationStatusId; |
| | 9 | 475 | | target.CompensationStatusDisplayName = source.CompensationStatusDisplayName; |
| | 9 | 476 | | target.CompensationStatusSysName = source.CompensationStatusSysName; |
| | 9 | 477 | | target.CompensationStatusChangeMoment = source.CompensationStatusChangeMoment; |
| | 9 | 478 | | target.IsOpened = source.IsOpened; |
| | 9 | 479 | | target.IsSuperEconom = source.IsSuperEconom; |
| | 9 | 480 | | target.RawDataJson = source.RawDataJson; |
| | 9 | 481 | | } |
| | | 482 | | } |
| | | 483 | | |
| | | 484 | | /// <summary> |
| | | 485 | | /// Результат батч-upsert возвратов. |
| | | 486 | | /// </summary> |
| | | 487 | | /// <param name="Processed">Сколько записей пришло из API и было обработано.</param> |
| | | 488 | | /// <param name="Inserted">Из них создано впервые.</param> |
| | | 489 | | /// <param name="Changed">Записи, у которых изменился статус возврата или компенсации, включая новые.</param> |
| | | 490 | | public sealed record OrderReturnUpsertResult(int Processed, int Inserted, IReadOnlyList<OrderReturn> Changed) |
| | | 491 | | { |
| | | 492 | | public static readonly OrderReturnUpsertResult Empty = new(0, 0, Array.Empty<OrderReturn>()); |
| | | 493 | | |
| | | 494 | | /// <summary>Записи, которые пришли из API без единого изменения — их большинство на устоявшемся прогоне.</summary> |
| | | 495 | | public int Unchanged => Processed - Changed.Count; |
| | | 496 | | } |