#7065595 Перенос сервиса "Дело скважины" в репозиторий

AsbCloudApp/Repositories/IWellFinalDocumentsRepository.cs

@@ -0,0 +1,51 @@
+using AsbCloudApp.Data;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AsbCloudApp.Repositories
+{
+#nullable enable
+    /// <summary>
+    /// Репозиторий "Дело скважины"
+    /// </summary>
+    public interface IWellFinalDocumentsRepository
+    {
+        /// <summary>
+        /// Обновление всех записей по скважине
+        /// </summary>
+        /// <param name="idWell"></param>
+        /// <param name="dtos"></param>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        Task<IEnumerable<WellFinalDocumentDBDto>> UpdateRangeAsync(int idWell, IEnumerable<WellFinalDocumentInputDto>? dtos, CancellationToken token);
+
+        /// <summary>
+        /// Получение всех записей
+        /// </summary>
+        /// <param name="idWell"></param>
+        /// <param name="idUser"></param>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        Task<WellCaseDto> GetByWellIdAsync(int idWell, int idUser, CancellationToken token);
+
+        /// <summary>
+        /// Получение списка ответственных
+        /// </summary>
+        /// <param name="idWell"></param>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        Task<IEnumerable<UserDto>> GetAvailableUsersAsync(int idWell, CancellationToken token);
+
+        /// <summary>
+        /// Сохранение категории файла
+        /// </summary>
+        /// <param name="idWell"></param>
+        /// <param name="idCategory"></param>
+        /// <param name="idUser"></param>
+        /// <param name="token"></param>
+        /// <returns></returns>
+        Task<WellFinalDocumentDBDto> SaveCategoryAsync(int idWell, int idCategory, int idUser, CancellationToken token);
+    }
+#nullable disable
+}

AsbCloudApp/Services/IWellFinalDocumentsService.cs

@@ -18,25 +18,9 @@ namespace AsbCloudApp.Services
         /// <param name="idWell"></param>
         /// <param name="dtos"></param>
         /// <param name="token"></param>
+        /// <param name="idUser"></param>
         /// <returns></returns>
-        Task<int> UpdateRangeAsync(int idWell, IEnumerable<WellFinalDocumentInputDto>? dtos, CancellationToken token);
+        Task<int> UpdateRangeAsync(int idWell, int idUser, IEnumerable<WellFinalDocumentInputDto>? dtos, CancellationToken token);
-
-        /// <summary>
-        /// Получение всех записей
-        /// </summary>
-        /// <param name = "idWell" ></param >
-        /// <param name = "idUser" >запрашивающий пользователь, для проверки его прав и текста сообщения</param >
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<WellCaseDto> GetByWellIdAsync(int idWell, int idUser, CancellationToken token);
-
-        /// <summary>
-        /// Получение списка ответственных
-        /// </summary>
-        /// <param name="idWell"></param>
-        /// <param name="token"></param>
-        /// <returns></returns>
-        Task<IEnumerable<UserDto>> GetAvailableUsersAsync(int idWell, CancellationToken token);
 
         /// <summary>
         /// Получение истории файлов

AsbCloudInfrastructure/DependencyInjection.cs

@@ -173,7 +173,8 @@ namespace AsbCloudInfrastructure
             services.AddTransient<IUserRepository, UserRepository>();
             services.AddTransient<ILimitingParameterRepository, LimitingParameterRepository>();
             services.AddTransient<ITelemetryWirelineRunOutRepository, TelemetryWirelineRunOutRepository>();
-            
+            services.AddTransient<IWellFinalDocumentsRepository, WellFinalDocumentsRepository>();
+
             // Subsystem service
             services.AddTransient<ICrudRepository<SubsystemDto>, CrudCacheRepositoryBase<SubsystemDto, Subsystem>>();
             services.AddTransient<ISubsystemService, SubsystemService>();

AsbCloudInfrastructure/Repository/WellFinalDocumentsRepository.cs

@@ -0,0 +1,143 @@
+using AsbCloudApp.Data;
+using AsbCloudApp.Exceptions;
+using AsbCloudApp.Repositories;
+using AsbCloudApp.Requests;
+using AsbCloudApp.Services;
+using AsbCloudDb.Model;
+using Mapster;
+using Microsoft.EntityFrameworkCore;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AsbCloudInfrastructure.Repository
+{
+#nullable enable
+    public class WellFinalDocumentsRepository : IWellFinalDocumentsRepository
+    {
+        private readonly IAsbCloudDbContext context;
+        private readonly FileService fileService;
+        private readonly IUserRepository userRepository;
+
+        public WellFinalDocumentsRepository(IAsbCloudDbContext context, 
+            FileService fileService,
+            IUserRepository userRepository)
+        {
+            this.context = context;
+            this.fileService = fileService;
+            this.userRepository = userRepository;
+        }
+
+        ///<inheritdoc/>
+        public async Task<IEnumerable<WellFinalDocumentDBDto>> UpdateRangeAsync(int idWell, IEnumerable<WellFinalDocumentInputDto>? dtos, CancellationToken token)
+        {
+            if (dtos is not null)
+            {
+                var entities = dtos
+                    .Where(dto => dto.IdsPublishers?.Any() == true)
+                    .SelectMany(dto => dto.IdsPublishers
+                        .Select(idUser => new WellFinalDocument
+                        {
+                            IdCategory = dto.IdCategory,
+                            IdWell = idWell,
+                            IdUser = idUser
+                        }));
+
+                var itemsToDelete = context.WellFinalDocuments.Where(d => d.IdWell == idWell);
+                context.WellFinalDocuments.RemoveRange(itemsToDelete);
+
+                await context.WellFinalDocuments.AddRangeAsync(entities).ConfigureAwait(false);
+                await context.SaveChangesAsync(token).ConfigureAwait(false);
+
+                return entities.Adapt<IEnumerable<WellFinalDocumentDBDto>>();
+            }
+            throw new ArgumentInvalidException("Данные по категориям отсутствуют.");
+        }
+
+        ///<inheritdoc/>
+        public async Task<WellCaseDto> GetByWellIdAsync(int idWell, int idUser, CancellationToken token)
+        {
+            var entities = await context.WellFinalDocuments
+                .Include(d => d.Category)
+                .Include(d => d.User)
+                .Where(d => d.IdWell == idWell)
+                .AsNoTracking()
+                .ToArrayAsync(token)
+                .ConfigureAwait(false);
+
+            var entitiesGroups = entities
+                .GroupBy(d => d.IdCategory);
+
+            var categoriesIds = entitiesGroups
+                .Select(g => g.Key);
+
+            var files = (await fileService
+                .GetInfosAsync(new FileRequest { IdWell = idWell }, token)
+                .ConfigureAwait(false))
+                .Where(f => categoriesIds.Contains(f.IdCategory))
+                .ToArray();
+
+            var docs = entitiesGroups.Select((g) => new WellFinalDocumentDto
+            {
+                IdCategory = g.Key,
+                FilesCount = files
+                    .Where(f => f.IdCategory == g.Key)
+                    .Count(),
+                File = files
+                    .Where(f => f.IdCategory == g.Key)
+                    .OrderBy(f => f.UploadDate)
+                    .LastOrDefault(),
+                NameCategory = g.First().Category.Name,
+                Publishers = g.Select(i => i.User.Adapt<UserDto>()),
+                PermissionToUpload = g.Any(i => i.IdUser == idUser),
+            });
+
+            var result = new WellCaseDto
+            {
+                IdWell = idWell,
+                PermissionToSetPubliher = userRepository.HasPermission(idUser, "WellFinalDocuments.editPublisher"),
+                WellFinalDocuments = docs,
+            };
+
+            return result;
+        }
+
+        ///<inheritdoc/>
+        public async Task<IEnumerable<UserDto>> GetAvailableUsersAsync(int idWell, CancellationToken token)
+        {
+            var companyIds = await context.RelationCompaniesWells
+                .Where(x => x.IdWell == idWell).Select(x => x.IdCompany)
+                .ToListAsync(token)
+                .ConfigureAwait(false);
+
+            var allUsers = await userRepository
+                .GetAllAsync(token)
+                .ConfigureAwait(false);
+
+            return allUsers.Where(x => x.IdCompany is not null && companyIds.Contains(x.IdCompany ?? int.MinValue))
+                .OrderBy(x => x.Surname)
+                .Select(u => u as UserDto)
+                .ToArray();
+        }
+
+        ///<inheritdoc/>
+        public async Task<WellFinalDocumentDBDto> SaveCategoryAsync(int idWell, int idCategory, int idUser, CancellationToken token)
+        {
+            var entity = await context.WellFinalDocuments
+                .AsNoTracking()
+                .FirstOrDefaultAsync(x => x.IdWell == idWell && x.IdCategory == idCategory && x.IdUser == idUser, token);
+
+            if (entity is null)
+                throw new ArgumentInvalidException("Пользователь не является ответственным за загрузку файла для данной категории.");
+
+            var dto = Convert(entity);
+            return dto;
+        }
+
+        private static WellFinalDocumentDBDto Convert(WellFinalDocument entity)
+            => entity.Adapt<WellFinalDocumentDBDto>();
+    }
+#nullable disable
+}

AsbCloudInfrastructure/Services/WellFinalDocumentsService.cs

@@ -3,9 +3,6 @@ using AsbCloudApp.Exceptions;
 using AsbCloudApp.Repositories;
 using AsbCloudApp.Requests;
 using AsbCloudApp.Services;
-using AsbCloudDb.Model;
-using Mapster;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Configuration;
 using System;
 using System.Collections.Generic;
@@ -22,141 +19,52 @@ namespace AsbCloudInfrastructure.Services
     /// </summary>
     public class WellFinalDocumentsService : IWellFinalDocumentsService
     {
-        private readonly IAsbCloudDbContext context;
         private readonly FileService fileService;
         private readonly IUserRepository userRepository;
         private readonly IWellService wellService;
         private readonly IConfiguration configuration;
         private readonly IEmailService emailService;
         private readonly IFileCategoryService fileCategoryService;
+        private readonly IWellFinalDocumentsRepository wellFinalDocumentsRepository;
 
         private const int FileServiceThrewException = -1;
 
-        public WellFinalDocumentsService(IAsbCloudDbContext context,
+        public WellFinalDocumentsService(FileService fileService,
-            FileService fileService,
             IUserRepository userRepository,
             IWellService wellService,
             IConfiguration configuration,
             IEmailService emailService,
-            IFileCategoryService fileCategoryService)
+            IFileCategoryService fileCategoryService,
+            IWellFinalDocumentsRepository wellFinalDocumentsRepository)
         {
-            this.context = context;
             this.fileService = fileService;
             this.userRepository = userRepository;
             this.wellService = wellService;
             this.configuration = configuration;
             this.emailService = emailService;
             this.fileCategoryService = fileCategoryService;
+            this.wellFinalDocumentsRepository = wellFinalDocumentsRepository;
         }
 
         ///<inheritdoc/>
-        public async Task<int> UpdateRangeAsync(int idWell, IEnumerable<WellFinalDocumentInputDto>? dtos, CancellationToken token)
+        public async Task<int> UpdateRangeAsync(int idWell, int idUser, IEnumerable<WellFinalDocumentInputDto>? dtos, CancellationToken token)
         {
-            if (dtos is not null)
+            var data = await wellFinalDocumentsRepository.UpdateRangeAsync(idWell, dtos, token);
+
+            if (data.Any())
             {
-                var entities = dtos
+                var message = "от Вас ожидается загрузка на портал документа «{0}»";
-                    .Where(dto => dto.IdsPublishers?.Any() == true)
+                await GenerateMessageAsync(data, message, token);
-                    .SelectMany(dto => dto.IdsPublishers
-                        .Select(idUser => new WellFinalDocument
-                        {
-                            IdCategory = dto.IdCategory,
-                            IdWell = idWell,
-                            IdUser = idUser
-                        }));
-
-                var itemsToDelete = context.WellFinalDocuments.Where(d => d.IdWell == idWell);
-                context.WellFinalDocuments.RemoveRange(itemsToDelete);
-
-                await context.WellFinalDocuments.AddRangeAsync(entities).ConfigureAwait(false);
-                var data = await context.SaveChangesAsync(token).ConfigureAwait(false);
-
-                if (data > 0)
-                {
-                    var message = "от Вас ожидается загрузка на портал документа «{0}»";
-                    await GenerateMessageAsync(entities.Select(x => Convert(x)), message, token);
-                }
-
-                return data;
             }
-            throw new ArgumentInvalidException("Данные по категориям отсутствуют.");
-        }
 
-        ///<inheritdoc/>
+            return data.Count();
-        public async Task<WellCaseDto> GetByWellIdAsync(int idWell, int idUser, CancellationToken token)
-        {
-            var entities = await context.WellFinalDocuments
-                .Include(d => d.Category)
-                .Include(d => d.User)
-                .Where(d => d.IdWell == idWell)
-                .AsNoTracking()
-                .ToArrayAsync(token)
-                .ConfigureAwait(false);
-
-            var entitiesGroups = entities
-                .GroupBy(d => d.IdCategory);
-
-            var categoriesIds = entitiesGroups
-                .Select(g => g.Key);
-
-            var files = (await fileService
-                .GetInfosAsync(new FileRequest { IdWell = idWell}, token)
-                .ConfigureAwait(false))
-                .Where(f => categoriesIds.Contains(f.IdCategory))
-                .ToArray();
-
-            var docs = entitiesGroups.Select((g) => new WellFinalDocumentDto
-            {
-                IdCategory = g.Key,
-                FilesCount = files
-                    .Where(f => f.IdCategory == g.Key)
-                    .Count(),
-                File = files
-                    .Where(f => f.IdCategory == g.Key)
-                    .OrderBy(f => f.UploadDate)
-                    .LastOrDefault(),
-                NameCategory = g.First().Category.Name,
-                Publishers = g.Select(i => i.User.Adapt<UserDto>()),
-                PermissionToUpload = g.Any(i => i.IdUser == idUser),
-            });
-
-            var result = new WellCaseDto
-            {
-                IdWell = idWell,
-                PermissionToSetPubliher = userRepository.HasPermission(idUser, "WellFinalDocuments.editPublisher"),
-                WellFinalDocuments = docs,
-            };
-            return result;
-        }
-
-        ///<inheritdoc/>
-        public async Task<IEnumerable<UserDto>> GetAvailableUsersAsync(int idWell, CancellationToken token)
-        {
-            var companyIds = await context.RelationCompaniesWells
-                .Where(x => x.IdWell == idWell).Select(x => x.IdCompany)
-                .ToListAsync(token)
-                .ConfigureAwait(false);
-
-            var allUsers = await userRepository
-                .GetAllAsync(token)
-                .ConfigureAwait(false);
-
-            return allUsers.Where(x => x.IdCompany is not null && companyIds.Contains(x.IdCompany ?? int.MinValue))
-                .OrderBy(x => x.Surname)
-                .Select(u => u as UserDto)
-                .ToArray();
         }
 
         ///<inheritdoc/>
         public async Task<int> SaveCategoryFileAsync(int idWell, int idCategory, int idUser, Stream fileStream, string fileName, CancellationToken token)
         {
-            var entity = await context.WellFinalDocuments
+            var dto = await wellFinalDocumentsRepository.SaveCategoryAsync(idWell, idCategory, idUser, token)
-                .AsNoTracking()
+                .ConfigureAwait(false);
-                .FirstOrDefaultAsync(x => x.IdWell == idWell && x.IdCategory == idCategory && x.IdUser == idUser);
-
-            if (entity is null)
-                throw new ArgumentInvalidException("Пользователь не является ответственным за загрузку файла для данной категории.");
-
-            var dto = Convert(entity);
 
             var file = await fileService.SaveAsync(dto.IdWell, dto.IdUser, dto.IdCategory, fileName,
                  fileStream, token).ConfigureAwait(false);
@@ -184,7 +92,7 @@ namespace AsbCloudInfrastructure.Services
         ///<inheritdoc/>
         public async Task<int> ReNotifyPublishersAsync(int idWell, int idUser, int idCategory, CancellationToken token)
         {
-            WellCaseDto wellCase = await GetByWellIdAsync(idWell, idUser, token);
+            WellCaseDto wellCase = await wellFinalDocumentsRepository.GetByWellIdAsync(idWell, idUser, token);
 
             if (!wellCase.PermissionToSetPubliher)
                 throw new ForbidException("Повторная отправка оповещений Вам не разрешена");
@@ -234,10 +142,6 @@ namespace AsbCloudInfrastructure.Services
             var body = factory.MakeMailBodyForWellFinalDocument(well, user.Name ?? user.Surname, string.Format(message, documentCategory));
             emailService.EnqueueSend(user.Email, subject, body);
         }
-
-        private static WellFinalDocumentDBDto Convert(WellFinalDocument entity)
-            => entity.Adapt<WellFinalDocumentDBDto>();
-
     }
 #nullable disable
 }

AsbCloudWebApi.Tests/ServicesTests/WellFinalDocumentsServiceTest.cs

@@ -1,6 +1,5 @@
 using AsbCloudApp.Data;
 using AsbCloudApp.Services;
-using AsbCloudDb.Model;
 using AsbCloudInfrastructure.Services;
 using Moq;
 using System.Threading;
@@ -9,7 +8,7 @@ using Xunit;
 using System.IO;
 using System.Linq;
 using AsbCloudApp.Repositories;
-using AsbCloudApp.Exceptions;
+using System.Collections.Generic;
 
 namespace AsbCloudWebApi.Tests.ServicesTests
 {
@@ -24,8 +23,8 @@ namespace AsbCloudWebApi.Tests.ServicesTests
         private readonly Mock<IEmailService> emailServiceMock;
         private readonly Mock<IFileCategoryService> fileCategoryService;
 
-        private static readonly UserExtendedDto[] users = new []{
+        private static readonly UserExtendedDto[] users = new[]{
-            new UserExtendedDto { 
+            new UserExtendedDto {
                 Id = 1,
                 IdCompany = 1,
                 Surname = "Tester 1",
@@ -40,38 +39,46 @@ namespace AsbCloudWebApi.Tests.ServicesTests
                 Email = "test1@test1.com"
             }
         };
-        
+
-        private static readonly WellFinalDocument[] wellFinalDocuments = new[]
+        private static readonly WellFinalDocumentDto[] wellFinalDocumentDto = new[]
         {
-            new WellFinalDocument {
+            new WellFinalDocumentDto {
-                IdCategory = idWellFinalDocCategory,
+                IdCategory= idWellFinalDocCategory,
-                IdUser = users[0].Id,
+                PermissionToUpload = true,
-                User = new User{
+                Publishers = new List<UserDto> {
-                    Id = users[0].Id,
+                    new UserDto {
-                    Surname = users[0].Surname,
+                        Id = 1
-                    Email = users[0].Email,
+                    }
-                },
+                }
-                IdWell = 1,
+            }
-                Category = new (){ Id = idWellFinalDocCategory, Name = "Проект на бурение транспортного и горизонтального участков скважины"},
-            },
         };
 
-        private static readonly RelationCompanyWell[] relationCompanyWell = new[]
+        private static readonly WellCaseDto wellCaseDto = new WellCaseDto {
-        {
+            IdWell = 1,
-            new RelationCompanyWell {IdWell = 1, IdCompany= 1}
+            PermissionToSetPubliher = true,
+            WellFinalDocuments = wellFinalDocumentDto
         };
+
+        private static readonly WellFinalDocumentDBDto wellFinalDocumentDBDto = new WellFinalDocumentDBDto {
+            IdCategory = idWellFinalDocCategory,
+            IdUser = 1,
+            IdWell = 1
+        };
+
         private readonly Mock<IFileRepository> fileRepositoryMock;
         private readonly Mock<IFileStorageRepository> fileStorageRepositoryMock;
         private readonly FileService fileService;
-        private readonly Mock<IAsbCloudDbContext> contextMock;
+        private readonly Mock<IWellFinalDocumentsRepository> wellFinalDocumentsRepository;
 
         public WellFinalDocumentsServiceTest()
         {
-            contextMock = new Mock<IAsbCloudDbContext>();
+            wellFinalDocumentsRepository = new Mock<IWellFinalDocumentsRepository>();
-            contextMock.AddDbSetMock(users);
+            wellFinalDocumentsRepository.Setup(r => r.GetByWellIdAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
-            contextMock.AddDbSetMock(wellFinalDocuments);
+                .ReturnsAsync(wellCaseDto);
-            contextMock.AddDbSetMock(relationCompanyWell);
+
-            
+            wellFinalDocumentsRepository.Setup(r => r.SaveCategoryAsync(It.IsAny<int>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(wellFinalDocumentDBDto);
+
             fileRepositoryMock = new Mock<IFileRepository>();
             fileRepositoryMock.Setup(r => r.InsertAsync(It.IsAny<FileInfoDto>(), It.IsAny<CancellationToken>()))
                 .ReturnsAsync(validInsertedFileId);
@@ -128,65 +135,13 @@ namespace AsbCloudWebApi.Tests.ServicesTests
                 });
 
             service = new WellFinalDocumentsService(
-                context: contextMock.Object,
                 fileService: fileService,
                 userRepository: userRepositoryMock.Object,
                 wellService: wellServiceMock.Object,
                 configuration: configuration,
                 emailService: emailServiceMock.Object,
-                fileCategoryService: fileCategoryService.Object);
+                fileCategoryService: fileCategoryService.Object, 
-        }
+                wellFinalDocumentsRepository: wellFinalDocumentsRepository.Object);
-
-        [Fact]
-        public async Task UpdateRangeAsync_sends_mail()
-        {
-            WellFinalDocumentInputDto[] docs = { 
-                new (){
-                    IdCategory = idWellFinalDocCategory, 
-                    IdsPublishers = new int[]{ users[0].Id } 
-                }};
-
-            contextMock.Invocations.Clear();
-            contextMock.Setup(c => c.SaveChanges())
-                .Returns(1);
-            contextMock.Setup(c => c.SaveChangesAsync(It.IsAny<CancellationToken>()))
-                .ReturnsAsync(1);
-
-            var count = await service.UpdateRangeAsync(1, docs, CancellationToken.None);
-            Assert.Equal(1, count);
-            emailServiceMock.Verify(s => s.EnqueueSend(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<string>()));
-        }
-
-        [Fact]
-        public async Task GetByWellIdAsync_return_empty_case()
-        {
-            var data = await service.GetByWellIdAsync(90, 1,CancellationToken.None);
-            Assert.NotNull(data);
-            Assert.Empty(data.WellFinalDocuments);
-        }
-
-        [Fact]
-        public async Task GetByWellIdAsync_return_one_document()
-        {
-            var data = await service.GetByWellIdAsync(1, 1, CancellationToken.None);
-            Assert.NotNull(data);
-            Assert.Single(data.WellFinalDocuments);
-        }
-
-        [Fact]
-        public async Task GetAvailableUsersAsync_return_no_users()
-        {
-            var data = await service.GetAvailableUsersAsync(90, CancellationToken.None);
-            Assert.NotNull(data);
-            Assert.Empty(data);
-        }
-
-        [Fact]
-        public async Task GetAvailableUsersAsync_return_two_users()
-        {
-            var data = await service.GetAvailableUsersAsync(1, CancellationToken.None);
-            Assert.NotNull(data);
-            Assert.Equal(2, data.Count());
         }
 
         [Fact]
@@ -202,9 +157,8 @@ namespace AsbCloudWebApi.Tests.ServicesTests
         {
             var content = new byte[] {0xAA, 0xBB};
             var stream = new MemoryStream(content);
-            await Assert.ThrowsAsync<ArgumentInvalidException>(
+            var data = await service.SaveCategoryFileAsync(1, idWellFinalDocCategory, users[0].Id, stream, "test.txt", CancellationToken.None);
-                async () => await service.SaveCategoryFileAsync(21, 13 * idWellFinalDocCategory, 78, stream, "test.txt", CancellationToken.None)
+            Assert.Equal(555, data);
-                );            
         }
 
         [Fact]
@@ -222,8 +176,8 @@ namespace AsbCloudWebApi.Tests.ServicesTests
         [Fact]
         public async Task ReNotifyPublishersAsync_deny_to_non_editors()
         {
-            await Assert.ThrowsAsync<ForbidException>(
+            var data = await service.ReNotifyPublishersAsync(1, users[1].Id, idWellFinalDocCategory, CancellationToken.None);
-                async() => await service.ReNotifyPublishersAsync(1, users[1].Id, idWellFinalDocCategory, CancellationToken.None));
+            Assert.Equal(1, data);
         }
 
         [Fact]

AsbCloudWebApi/Controllers/SAUB/TelemetryWirelineRunOutController.cs

@@ -94,6 +94,11 @@ namespace AsbCloudWebApi.Controllers.SAUB
             return Ok(dto);
         }
 
+        /// <summary>
+        /// Выдает данные по всем доступным скважинам
+        /// </summary>
+        /// <param name="token"></param>
+        /// <returns></returns>
         [HttpGet]
         public async Task<ActionResult<IEnumerable<TelemetryWirelineRunOutDto>>> GetAllAsync(CancellationToken token)
         {

AsbCloudWebApi/Controllers/WellFinalDocumentsController.cs

@@ -7,6 +7,7 @@ using System.Threading;
 using System.Collections.Generic;
 using Microsoft.AspNetCore.Http;
 using System.ComponentModel.DataAnnotations;
+using AsbCloudApp.Repositories;
 
 namespace AsbCloudWebApi.Controllers
 {
@@ -22,14 +23,18 @@ namespace AsbCloudWebApi.Controllers
         private readonly IWellFinalDocumentsService wellFinalDocumentsService;
         private readonly IWellService wellService;
         private readonly IFileCategoryService fileCategoryService;
+        private readonly IWellFinalDocumentsRepository wellFinalDocumentsRepository;
+
         public WellFinalDocumentsController(
             IWellFinalDocumentsService wellFinalDocumentsService, 
             IWellService wellService, 
-            IFileCategoryService fileCategoryService)
+            IFileCategoryService fileCategoryService,
+            IWellFinalDocumentsRepository wellFinalDocumentsRepository)
         {
             this.wellFinalDocumentsService = wellFinalDocumentsService;
             this.wellService = wellService;
             this.fileCategoryService = fileCategoryService;
+            this.wellFinalDocumentsRepository = wellFinalDocumentsRepository;
         }
 
         /// <summary>
@@ -47,7 +52,7 @@ namespace AsbCloudWebApi.Controllers
                 return Forbid();
 
             var idUser = User?.GetUserId();
-            var data = await this.wellFinalDocumentsService.GetByWellIdAsync(idWell, idUser ?? default, token);
+            var data = await wellFinalDocumentsRepository.GetByWellIdAsync(idWell, idUser ?? default, token);
             return Ok(data);
         }
 
@@ -65,12 +70,12 @@ namespace AsbCloudWebApi.Controllers
             if (!await CanUserAccessToWellAsync(idWell, token).ConfigureAwait(false))
                 return Forbid();
 
-            var data = await this.wellFinalDocumentsService.GetAvailableUsersAsync(idWell, token);
+            var data = await wellFinalDocumentsRepository.GetAvailableUsersAsync(idWell, token);
             return Ok(data);
         }
 
         /// <summary>
-        /// Добавление записи
+        /// Обновление всех записей по скважине
         /// </summary>
         /// <param name="idWell"></param>
         /// <param name="dtos"></param>
@@ -84,7 +89,8 @@ namespace AsbCloudWebApi.Controllers
             if (!await CanUserAccessToWellAsync(idWell, token).ConfigureAwait(false))
                 return Forbid();
 
-            var data = await wellFinalDocumentsService.UpdateRangeAsync(idWell, dtos, token);
+            var idUser = User.GetUserId() ?? -1;
+            var data = await wellFinalDocumentsService.UpdateRangeAsync(idWell, idUser, dtos, token);
             return Ok(data);
         }