Merge pull request 'рефакторинг WellOperationRepository' (#265) from feature/wellOperationRepository-refactoring into dev

Reviewed-on: http://test.digitaldrilling.ru:8080/DDrilling/AsbCloudServer/pulls/265

AsbCloudApp/Repositories/IWellOperationRepository.cs

@@ -54,7 +54,7 @@ namespace AsbCloudApp.Repositories
         /// <summary>
         /// Обновить существующую операцию
         /// </summary>
-        /// <param name="dto"></param>
+        /// <param name="dtos"></param>
         /// <param name="token"></param>
         /// <returns></returns>
         Task<int> UpdateRangeAsync(IEnumerable<WellOperationDto> dtos, CancellationToken token);

AsbCloudApp/Requests/WellOperationRequest.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
 
 namespace AsbCloudApp.Requests;
 
@@ -46,6 +47,34 @@ public class WellOperationRequestBase : RequestBase
     /// Идентификаторы конструкций секции
     /// </summary>
     public IEnumerable<int>? SectionTypeIds { get; set; }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public WellOperationRequestBase()
+    {
+        
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    /// <param name="request"></param>
+    public WellOperationRequestBase(WellOperationRequestBase request)
+    {
+        GeDepth = request.GeDepth;
+        LeDepth = request.LeDepth;
+        GeDate = request.GeDate;
+        LeDate = request.LeDate;
+
+        OperationCategoryIds = request.OperationCategoryIds;
+        OperationType = request.OperationType;
+        SectionTypeIds = request.SectionTypeIds;
+
+        Skip = request.Skip;
+        Take = request.Take;
+        SortFields = request.SortFields;
+    }
 }
 
 /// <summary>
@@ -61,24 +90,15 @@ public class WellOperationRequest : WellOperationRequestBase
 
     /// <inheritdoc />
     public WellOperationRequest(WellOperationRequestBase request, IEnumerable<int> idsWell)
-		: this(idsWell)
+        : base(request)
     {
-		GeDepth = request.GeDepth;
+        IdsWell = idsWell;
-		LeDepth = request.LeDepth;
-		GeDate = request.GeDate;
-		LeDate = request.LeDate;
-
-		OperationCategoryIds = request.OperationCategoryIds;
-		OperationType = request.OperationType;
-		SectionTypeIds = request.SectionTypeIds;
-
-		Skip = request.Skip;
-		Take = request.Take;
-		SortFields = request.SortFields;
     }
 
     /// <summary>
     /// Идентификаторы скважин
     /// </summary>
-	public IEnumerable<int>? IdsWell { get; }
+    [Required]
+    [Length(1, 100)]
+    public IEnumerable<int> IdsWell { get; }
 }

AsbCloudInfrastructure/Repository/WellOperationRepository.cs

@@ -1,9 +1,4 @@
-using System;
+using AsbCloudApp.Data;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using AsbCloudApp.Data;
 using AsbCloudApp.Data.WellOperation;
 using AsbCloudApp.Exceptions;
 using AsbCloudApp.Repositories;
@@ -14,6 +9,11 @@ using AsbCloudDb.Model;
 using Mapster;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Caching.Memory;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace AsbCloudInfrastructure.Repository;
 
@@ -23,17 +23,21 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
     private readonly IMemoryCache memoryCache;
     private readonly IWellOperationCategoryRepository wellOperationCategoryRepository;
     private readonly IWellService wellService;
+    private Lazy<IDictionary<int, WellOperationCategoryDto>> LazyWellCategories { get; }
+    private Lazy<IDictionary<int, WellSectionTypeDto>> LazyWellSectionTypes { get; }
 
     public WellOperationRepository(IAsbCloudDbContext context,
         IMemoryCache memoryCache,
         IWellOperationCategoryRepository wellOperationCategoryRepository,
         IWellService wellService)
-		: base(context, dbSet => dbSet.Include(e => e.WellSectionType)
+        : base(context, dbSet => dbSet)
-			.Include(e => e.OperationCategory))
     {
         this.memoryCache = memoryCache;
         this.wellOperationCategoryRepository = wellOperationCategoryRepository;
         this.wellService = wellService;
+
+        LazyWellCategories = new(() => wellOperationCategoryRepository.Get(true, false).ToDictionary(c => c.Id));
+        LazyWellSectionTypes = new(() => GetSectionTypes().ToDictionary(c => c.Id));
     }
 
     public IEnumerable<WellSectionTypeDto> GetSectionTypes() =>
@@ -44,18 +48,8 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
 
     public async Task<IEnumerable<WellOperationDto>> GetAsync(WellOperationRequest request, CancellationToken token)
     {
-		var query = BuildQuery(request);
+        var (items, _) = await GetWithDaysAndNpvAsync(request, token);
-
+        return items;
-		if (request.Skip.HasValue)
-			query = query.Skip(request.Skip.Value);
-
-		if (request.Take.HasValue)
-			query = query.Take(request.Take.Value);
-
-		var entities = await query.AsNoTracking()
-			.ToArrayAsync(token);
-
-		return await ConvertWithDrillingDaysAndNpvHoursAsync(entities, token);
     }
 
     public async Task<PaginationContainer<WellOperationDto>> GetPageAsync(WellOperationRequest request, CancellationToken token)
@@ -63,19 +57,14 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
         var skip = request.Skip ?? 0;
         var take = request.Take ?? 32;
 
-		var query = BuildQuery(request);
+        var (items, count) = await GetWithDaysAndNpvAsync(request, token);
-
-		var entities = await query.Skip(skip)
-			.Take(take)
-			.AsNoTracking()
-			.ToArrayAsync(token);
 
         var paginationContainer = new PaginationContainer<WellOperationDto>
         {
             Skip = skip,
             Take = take,
-			Count = await query.CountAsync(token),
+            Count = count,
-			Items = await ConvertWithDrillingDaysAndNpvHoursAsync(entities, token)
+            Items = items
         };
 
         return paginationContainer;
@@ -178,42 +167,98 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
             throw new ArgumentInvalidException(nameof(dtos), "Все операции должны принадлежать одной скважине");
     }
 
-	private IQueryable<WellOperation> BuildQuery(WellOperationRequest request)
+    private async Task<IEnumerable<WellOperation>> GetByIdsWells(IEnumerable<int> idsWells, CancellationToken token)
     {
         var query = GetQuery()
-			.Where(e => request.IdsWell != null && request.IdsWell.Contains(e.IdWell))
+            .Where(e => idsWells.Contains(e.IdWell))
+            .OrderBy(e => e.DateStart);
+        var entities = await query.ToArrayAsync(token);
+        return entities;
+    }
+
+    private async Task<(IEnumerable<WellOperationDto> items, int count)> GetWithDaysAndNpvAsync(WellOperationRequest request, CancellationToken token)
+    {
+        var skip = request.Skip ?? 0;
+        var take = request.Take ?? 32;
+
+        var entities = await GetByIdsWells(request.IdsWell, token);
+        var groupedByWellAndType = entities
+            .GroupBy(e => new { e.IdWell, e.IdType });
+
+        var result = new List<WellOperationDto>();
+        var count = 0;
+        foreach (var wellOperationsWithType in groupedByWellAndType)
+        {
+            var firstWellOperation = wellOperationsWithType
                 .OrderBy(e => e.DateStart)
-			.AsQueryable();
+                .FirstOrDefault()!;
 
+            var operationsWithNpt = wellOperationsWithType
+                .Where(o => WellOperationCategory.NonProductiveTimeSubIds.Contains(o.IdCategory));
+
+            IEnumerable<WellOperation> filteredWellOperations = FilterByRequest(wellOperationsWithType.AsQueryable(), request);
+
+            var filteredWellOperationsPart = filteredWellOperations
+                .Skip(skip)
+                .Take(take);
+
+            var dtos = filteredWellOperationsPart
+                .Select(entity =>
+                {
+                    var dto = Convert(entity);
+                    dto.Day = (entity.DateStart - firstWellOperation.DateStart).TotalDays;
+                    dto.NptHours = operationsWithNpt
+                        .Where(o => o.DateStart <= entity.DateStart)
+                        .Sum(e => e.DurationHours);
+                    return dto;
+                });
+
+            result.AddRange(dtos);
+            count += filteredWellOperations.Count();
+        }
+
+        return (result, count);
+    }
+
+    private static IQueryable<WellOperation> FilterByRequest(IQueryable<WellOperation> entities, WellOperationRequest request)
+    {
         if (request.OperationType.HasValue)
-			query = query.Where(e => e.IdType == request.OperationType.Value);
+            entities = entities.Where(e => e.IdType == request.OperationType.Value);
-
         if (request.SectionTypeIds?.Any() is true)
-			query = query.Where(e => request.SectionTypeIds.Contains(e.IdWellSectionType));
+            entities = entities.Where(e => request.SectionTypeIds.Contains(e.IdWellSectionType));
-
         if (request.OperationCategoryIds?.Any() is true)
-			query = query.Where(e => request.OperationCategoryIds.Contains(e.IdCategory));
+            entities = entities.Where(e => request.OperationCategoryIds.Contains(e.IdCategory));
-
         if (request.GeDepth.HasValue)
-			query = query.Where(e => e.DepthEnd >= request.GeDepth.Value);
+            entities = entities.Where(e => e.DepthEnd >= request.GeDepth.Value);
-
         if (request.LeDepth.HasValue)
-			query = query.Where(e => e.DepthEnd <= request.LeDepth.Value);
+            entities = entities.Where(e => e.DepthEnd <= request.LeDepth.Value);
 
         if (request.GeDate.HasValue)
         {
             var geDateUtc = request.GeDate.Value.UtcDateTime;
-			query = query.Where(e => e.DateStart >= geDateUtc);
+            entities = entities.Where(e => e.DateStart >= geDateUtc);
         }
 
         if (request.LeDate.HasValue)
         {
             var leDateUtc = request.LeDate.Value.UtcDateTime;
-			query = query.Where(e => e.DateStart <= leDateUtc);
+            entities = entities.Where(e => e.DateStart <= leDateUtc);
+        }
+        if (request.SortFields?.Any() is true)
+            entities = entities.AsQueryable().SortBy(request.SortFields);
+        else
+            entities = entities.AsQueryable().OrderBy(e => e.DateStart);
+
+        return entities;
     }
 
-		if (request.SortFields?.Any() is true)
+    private IQueryable<WellOperation> BuildQuery(WellOperationRequest request)
-			query = query.SortBy(request.SortFields);
+    {
+        var query = GetQuery()
+            .Where(e => request.IdsWell.Contains(e.IdWell))
+            .OrderBy(e => e.DateStart)
+            .AsQueryable();
+        query = FilterByRequest(query, request);
 
         return query;
     }
@@ -284,7 +329,7 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
             return sections;
         });
 
-		return cache;
+        return cache!;
     }
 
     public async Task<DatesRangeDto?> GetDatesRangeAsync(int idWell, int idType, CancellationToken cancellationToken)
@@ -306,43 +351,6 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
         };
     }
 
-	private async Task<IEnumerable<WellOperationDto>> ConvertWithDrillingDaysAndNpvHoursAsync(IEnumerable<WellOperation> entities,
-		CancellationToken token)
-	{
-		var idsWell = entities.Select(e => e.IdWell).Distinct();
-
-		var currentWellOperations = GetQuery()
-			.Where(entity => idsWell.Contains(entity.IdWell));
-
-		var dateFirstDrillingOperationByIdWell = await currentWellOperations
-			.Where(entity => entity.IdType == WellOperation.IdOperationTypeFact)
-			.GroupBy(entity => entity.IdWell)
-			.ToDictionaryAsync(g => g.Key, g => g.Min(o => o.DateStart), token);
-
-		var operationsWithNptByIdWell = await currentWellOperations.Where(entity =>
-				entity.IdType == WellOperation.IdOperationTypeFact &&
-				WellOperationCategory.NonProductiveTimeSubIds.Contains(entity.IdCategory))
-			.GroupBy(entity => entity.IdWell)
-			.ToDictionaryAsync(g => g.Key, g => g.Select(o => o), token);
-
-		var dtos = entities.Select(entity =>
-		{
-			var dto = Convert(entity);
-
-			if (dateFirstDrillingOperationByIdWell.TryGetValue(entity.IdWell, out var dateFirstDrillingOperation))
-				dto.Day = (entity.DateStart - dateFirstDrillingOperation).TotalDays;
-
-			if (operationsWithNptByIdWell.TryGetValue(entity.IdWell, out var wellOperationsWithNtp))
-				dto.NptHours = wellOperationsWithNtp
-					.Where(o => o.DateStart <= entity.DateStart)
-					.Sum(e => e.DurationHours);
-
-			return dto;
-		});
-
-		return dtos;
-	}
-
     protected override WellOperation Convert(WellOperationDto src)
     {
         var entity = src.Adapt<WellOperation>();
@@ -355,9 +363,13 @@ public class WellOperationRepository : CrudRepositoryBase<WellOperationDto, Well
         //TODO: пока такое получение TimeZone скважины, нужно исправить на Lazy
         //Хоть мы и тянем данные из кэша, но от получения TimeZone в этом методе нужно избавиться, пока так
         var timeZoneOffset = wellService.GetTimezone(src.IdWell).Offset;
+
         var dto = src.Adapt<WellOperationDto>();
         dto.DateStart = src.DateStart.ToOffset(timeZoneOffset);
         dto.LastUpdateDate = src.LastUpdateDate.ToOffset(timeZoneOffset);
+
+        dto.OperationCategoryName = LazyWellCategories.Value.TryGetValue(src.IdCategory, out WellOperationCategoryDto? category) ? category.Name : string.Empty;
+        dto.WellSectionTypeCaption = LazyWellSectionTypes.Value.TryGetValue(src.IdWellSectionType, out WellSectionTypeDto? sectionType) ? sectionType.Caption : string.Empty;
         return dto;
     }
 }

AsbCloudWebApi.IntegrationTests/Controllers/WellOperations/WellOperationControllerTest.cs

@@ -27,7 +27,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
     }
 
     /// <summary>
-    /// Успешное добавление операций (без предварительной очистки данных)
+    /// Óñïåøíîå äîáàâëåíèå îïåðàöèé (áåç ïðåäâàðèòåëüíîé î÷èñòêè äàííûõ)
     /// </summary>
     /// <returns></returns>
     [Fact]
@@ -46,7 +46,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
     }
 
     /// <summary>
-    /// Успешное добавление операций (с предварительной очисткой данных)
+    /// Óñïåøíîå äîáàâëåíèå îïåðàöèé (ñ ïðåäâàðèòåëüíîé î÷èñòêîé äàííûõ)
     /// </summary>
     /// <returns></returns>
     [Fact]
@@ -65,7 +65,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
     }
 
     /// <summary>
-    /// Успешное обновление операций
+    /// Óñïåøíîå îáíîâëåíèå îïåðàöèé
     /// </summary>
     /// <returns></returns>
     [Fact]
@@ -87,7 +87,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
     }
 
     /// <summary>
-    /// Получение плановых операций
+    /// Ïîëó÷åíèå ïëàíîâûõ îïåðàöèé
     /// </summary>
     /// <returns></returns>
     [Fact]
@@ -144,7 +144,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
             IdWellSectionType = 2,
             IdCategory = WellOperationCategory.IdSlide,
             IdPlan = null,
-            CategoryInfo = "Доп.инфо",
+            CategoryInfo = "Äîï.èíôî",
             IdType = idType,
             DepthStart = 10.0,
             DepthEnd = 20.0,
@@ -201,7 +201,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
         var stream = responseTemplate.Content;
 
         using var workbook = new XLWorkbook(stream);
-        var sheet = workbook.GetWorksheet("Справочники");
+        var sheet = workbook.GetWorksheet("Ñïðàâî÷íèêè");
 
         var count = sheet.RowsUsed().Count() - 1;
 
@@ -230,6 +230,60 @@ public class WellOperationControllerTest : BaseIntegrationTest
         Assert.True(notExistedInDb.Count() == 0);
     }
 
+    [Theory]
+    [InlineData(WellOperation.IdOperationTypePlan)]
+    [InlineData(WellOperation.IdOperationTypeFact)]
+    public async Task GetPageOperationsAsyncWithDaysAndNpv_returns_success(int idType)
+    {
+        //arrange
+        const int pageSize = 10;
+        const int pageIndex = 0;
+
+        var well = await dbContext.Wells.FirstAsync();
+        var entity1 = CreateWellOperation(well.Id);
+
+        var entity2 = entity1.Adapt<WellOperation>();
+		entity2.DateStart = entity2.DateStart.AddDays(1);
+		entity2.IdCategory = WellOperationCategory.IdEquipmentDrillingRepair;
+		entity2.DurationHours = 2;
+
+        var entity3 = entity2.Adapt<WellOperation>();
+        entity3.DateStart = entity3.DateStart.AddDays(1);
+        entity3.IdCategory = WellOperationCategory.IdEquipmentDrillingRepair;
+        entity3.DurationHours = 3;
+
+        dbContext.WellOperations.Add(entity1);
+        dbContext.WellOperations.Add(entity2);
+        dbContext.WellOperations.Add(entity3);
+
+        await dbContext.SaveChangesAsync();
+
+		var request = new WellOperationRequestBase
+		{
+			OperationType = WellOperation.IdOperationTypePlan,
+			Skip = pageIndex,
+			Take = pageSize,
+            SortFields = [nameof(WellOperation.DateStart)]
+        };
+
+		//act
+		var response = await client.GetPageOperationsAsync(well.Id, request);
+
+        //assert
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.NotNull(response.Content);
+
+		var items = response.Content.Items.ToArray();
+
+        Assert.Equal(0, items[0].Day);
+        Assert.Equal(1, items[1].Day);
+        Assert.Equal(2, items[2].Day);
+
+        Assert.Equal(0, items[0].NptHours);
+        Assert.Equal(2, items[1].NptHours);
+        Assert.Equal(5, items[2].NptHours);
+    }
+
     private static WellOperation CreateWellOperation(int idWell, int idType = WellOperation.IdOperationTypePlan) =>
 		new()
 		{
@@ -237,7 +291,7 @@ public class WellOperationControllerTest : BaseIntegrationTest
 			IdWellSectionType = 2,
 			IdCategory = WellOperationCategory.IdSlide,
 			IdPlan = null,
-            CategoryInfo = "Доп.инфо",
+			CategoryInfo = "Äîï.èíôî",
 			LastUpdateDate = new DateTimeOffset(new DateTime(2023, 1, 10)).ToUniversalTime(),
 			IdType = idType,
 			DepthStart = 10.0,