nit refacroring before merge

AsbCloudApp/Services/IPermissionService.cs

@@ -7,10 +7,10 @@ namespace AsbCloudApp.Services
 {
     public interface IPermissionService
     {
-        Task<IEnumerable<PermissionDto>> GetallAsync(int idRole, CancellationToken token);
+        Task<IEnumerable<PermissionDto>> GetByIdRoleAsync(int idRole, CancellationToken token);
         Task<int> InsertRangeAsync(IEnumerable<PermissionDto> dtos, CancellationToken token);
-        Task<int> UpdateAsync(int id, PermissionDto dto, CancellationToken token);
+        Task<int> UpdateAsync(PermissionDto dto, CancellationToken token);
-        Task<int> DeleteAsync(int idRole, int idPermission, CancellationToken token);
+        Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token);
         
     }
 }

AsbCloudInfrastructure/DependencyInjection.cs

@@ -30,36 +30,36 @@ namespace AsbCloudInfrastructure
             services.AddSingleton<IRequerstTrackerService, RequerstTrackerService>();
 
             services.AddTransient<IAuthService, AuthService>();
-            services.AddTransient<IWellService, WellService>();
             services.AddTransient<IClusterService, ClusterService>();
-            services.AddTransient<ITelemetryService, TelemetryService>();
+            services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
-            services.AddTransient<IMessageService, MessageService>();
+            services.AddTransient<IDrillParamsService, DrillParamsService>();
+            services.AddTransient<IDrillingProgramService, DrillingProgramService>();
             services.AddTransient<IEventService, EventService>();
-            services.AddTransient<ITelemetryUserService, TelemetryUserService>();
+            services.AddTransient<IFileService, FileService>();
+            services.AddTransient<IMeasureService, MeasureService>();
+            services.AddTransient<IMessageService, MessageService>();
+            services.AddTransient<IPermissionService, PermissionService>();
             services.AddTransient<IReportService, ReportService>();
             services.AddTransient<ITelemetryAnalyticsService, TelemetryAnalyticsService>();
-            services.AddTransient<IFileService, FileService>();
+            services.AddTransient<ITelemetryService, TelemetryService>();
+            services.AddTransient<ITelemetryUserService, TelemetryUserService>();
+            services.AddTransient<ITimeZoneService, TimeZoneService>();
+            services.AddTransient<IWellCompositeService, WellCompositeService>();
+            services.AddTransient<IWellOperationImportService, WellOperationImportService>();
             services.AddTransient<IWellOperationService, WellOperationService>();
             services.AddTransient<IWellOperationsStatService, WellOperationsStatService>();
-            services.AddTransient<IWellOperationImportService, WellOperationImportService>();
+            services.AddTransient<IWellService, WellService>();
-            services.AddTransient<IWellCompositeService, WellCompositeService>();
-            services.AddTransient<IMeasureService, MeasureService>();
-            services.AddTransient<IDrillingProgramService, DrillingProgramService>();
-            services.AddTransient<IDrillParamsService, DrillParamsService>();
-            services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
-            services.AddTransient<ITimeZoneService, TimeZoneService>();
 
             // admin crud services:
-            services.AddTransient<ICrudService<DepositDto>, CrudServiceBase<DepositDto, Deposit>>();
             services.AddTransient<ICrudService<ClusterDto>, CrudServiceBase<ClusterDto, Cluster>>();
-            services.AddTransient<ICrudService<WellDto>, CrudServiceBase<WellDto, Well>>();
             services.AddTransient<ICrudService<CompanyDto>, CrudServiceBase<CompanyDto, Company>>();
+            services.AddTransient<ICrudService<DepositDto>, CrudServiceBase<DepositDto, Deposit>>();
+            services.AddTransient<ICrudService<DrillParamsDto>, DrillParamsService>();
+            services.AddTransient<ICrudService<PermissionInfoDto>, CrudServiceBase<PermissionInfoDto, PermissionInfo>>();
+            services.AddTransient<ICrudService<TelemetryDto>, CrudServiceBase<TelemetryDto, Telemetry>>();
             services.AddTransient<ICrudService<UserDto>, CrudServiceBase<UserDto, User>>();
             services.AddTransient<ICrudService<UserRoleDto>, UserRoleService>();
-            services.AddTransient<ICrudService<TelemetryDto>, CrudServiceBase<TelemetryDto, Telemetry>>();
+            services.AddTransient<ICrudService<WellDto>, CrudServiceBase<WellDto, Well>>();
-            services.AddTransient<ICrudService<DrillParamsDto>, DrillParamsService>();
-            services.AddTransient<IPermissionService, PermissionService>();
-            services.AddTransient<ICrudService<PermissionInfoDto>, CrudServiceBase<PermissionInfoDto, PermissionInfo>>();
 
             // TelemetryData services
             services.AddTransient<ITelemetryDataService<TelemetryDataSaubDto>, TelemetryDataSaubService>();

AsbCloudInfrastructure/Services/PermissionService.cs

@@ -10,7 +10,7 @@ using System.Threading.Tasks;
 
 namespace AsbCloudInfrastructure.Services
 {
-    public class PermissionService : IPermissionService
+    public class PermissionService : IPermissionService, IConverter<PermissionDto, Permission>
     {
         private readonly IAsbCloudDbContext db;
         
@@ -18,42 +18,52 @@ namespace AsbCloudInfrastructure.Services
         {
             this.db = db;
         }
-        
 
-        public async Task<IEnumerable<PermissionDto>> GetallAsync(int idRole, CancellationToken token)
+        public async Task<IEnumerable<PermissionDto>> GetByIdRoleAsync(int idRole, CancellationToken token)
         {
-            var entities = await (from p in db.Permissions
+            var entities = await db.Permissions
-                    where p.IdUserRole == idRole
+                .Where(p => p.IdUserRole == idRole)
-                        select p)
+                .ToListAsync(token)
-                .ToListAsync(token).ConfigureAwait(false);
+                .ConfigureAwait(false);
-            var dto = entities.Adapt<PermissionDto>();
+            var dto = entities.Select(Convert);
             return dto;
         }
 
         public Task<int> InsertRangeAsync(IEnumerable<PermissionDto> dtos, CancellationToken token)
         {
-            var entities = dtos.Adapt<Permission>();
+            var entities = dtos.Select(Convert);
-
             db.Permissions.AddRange(entities);
             return db.SaveChangesAsync(token);
         }
 
-        public Task<int> UpdateAsync(int id, PermissionDto dto, CancellationToken token)
+        public Task<int> UpdateAsync(PermissionDto dto, CancellationToken token)
         {
-            var entity = dto.Adapt<Permission>();
+            var entity = Convert(dto);
             db.Permissions.Update(entity);
             return db.SaveChangesAsync(token);
         }
 
-        public Task<int> DeleteAsync(int idRole, int idPermission, CancellationToken token)
+        public Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token)
         {
             var entities = db.Permissions.AsNoTracking()
-                .Where(e => e.IdUserRole == idRole && e.IdPermission == idPermission)
+                .Where(e => e.IdUserRole == idUserRole && e.IdPermission == idPermission)
                 .ToList();
             if (!entities.Any())
                 return Task.FromResult(0);
             db.Permissions.RemoveRange(entities);
             return db.SaveChangesAsync(token);
         }
+
+        public Permission Convert(PermissionDto src)
+        {
+            var entity = src.Adapt<Permission>();
+            return entity;
+        }
+
+        public PermissionDto Convert(Permission src)
+        {
+            var dto = src.Adapt<PermissionDto>();
+            return dto;
+        }
     }
 }

AsbCloudInfrastructure/Services/UserRoleService.cs

@@ -7,31 +7,25 @@ using AsbCloudApp.Data;
 using AsbCloudDb.Model;
 using AsbCloudInfrastructure.Services.Cache;
 using Mapster;
+using AsbCloudApp.Services;
 
 namespace AsbCloudInfrastructure.Services
 {
     public class UserRoleService : CrudServiceBase<UserRoleDto, UserRole>
     {
         private readonly CacheTable<UserRole> cacheUserRoles;
-        private readonly CacheTable<PermissionInfo> cachePermissionsInfo;
+        private readonly IPermissionService permissionService;
-        private readonly CacheTable<Permission> cachePermissions;
-        private int counter = 0;
 
-        public UserRoleService(IAsbCloudDbContext context, CacheDb cacheDb) : base(context)
+        public UserRoleService(IAsbCloudDbContext context, CacheDb cacheDb, IPermissionService permissionService) : base(context)
         {
             cacheUserRoles = cacheDb.GetCachedTable<UserRole>((AsbCloudDbContext)context);
-            cachePermissionsInfo = cacheDb.GetCachedTable<PermissionInfo>((AsbCloudDbContext)context);
+            this.permissionService = permissionService;
-            cachePermissions = 
-                cacheDb.GetCachedTable<Permission>((AsbCloudDbContext)context);
         }
 
         public override async Task<PaginationContainer<UserRoleDto>> GetPageAsync(int skip = 0, 
             int take = 32, CancellationToken token = default)
         {
-            var rolesDtos = await base.GetPageAsync(skip, take,token);
+            var rolesDtos = await base.GetPageAsync(skip, take, token);
-
-            rolesDtos.Items = rolesDtos.Items.Select(FillUserRoleWithPermissions).ToList();
-
             return rolesDtos;
         }
 
@@ -39,19 +33,19 @@ namespace AsbCloudInfrastructure.Services
         {
             var roleDto = await base.GetAsync(id,token);
 
-            return roleDto is null 
+            return roleDto;
-                ? null 
-                : FillUserRoleWithPermissions(roleDto);
         }
 
         public override async Task<int> InsertAsync(UserRoleDto dto, CancellationToken token = default)
         {
-            var newRoleId = await base.InsertAsync(dto, token);
+            var id = await base.InsertAsync(dto, token).ConfigureAwait(false);
-
+            if (dto.Permissions is not null && dto.Permissions.Any())
-            var newRolePermissions = GetAncestorsPermissions(newRoleId, 
+            {
-                dto.Permissions.Adapt<Permission>(), dto.IdParent, ref counter);
+                foreach (var permission in dto.Permissions)
-
+                    permission.IdUserRole = id;
-            return await cachePermissions.InsertAsync(newRolePermissions, token);
+                await permissionService.InsertRangeAsync(dto.Permissions, token).ConfigureAwait(false);
+            }
+            return id;
         }
 
         public override async Task<int> UpdateAsync(int id, UserRoleDto item, CancellationToken token = default)
@@ -61,45 +55,48 @@ namespace AsbCloudInfrastructure.Services
             
             var result = await base.UpdateAsync(id, item, token);
 
-            await cachePermissions.RemoveAsync(r => r.IdUserRole == item.Id, token)
-                .ConfigureAwait(false);
-
-            var newPermissions = item.Permissions.Adapt<Permission>();
-            
-            await cachePermissions.InsertAsync(newPermissions, token);
-        
             return result;
         }
 
-        private UserRoleDto FillUserRoleWithPermissions(UserRoleDto roleDto)
+        private IEnumerable<Permission> GetNestedPermissions(UserRole role, int counter = 10)
         {
-            roleDto.Permissions = cachePermissions.Where(c =>
+            List<Permission> permissions = role.Permissions.ToList();
-                c.IdUserRole == roleDto.Id).Adapt<PermissionDto>();
+            if (role.IdParent is not null)
+            {
+                if(counter == 0)
+                {
+                    Trace.WriteLine($"User role with id: {role.Id} has more than 10 nested childs");
+                    return permissions;
+                }
+                var parentRole = cacheUserRoles.FirstOrDefault(r => r.Id == role.IdParent);
+                
+                if(parentRole is null)
+                    return permissions;
 
-            return roleDto;
+                var parentPermissions = GetNestedPermissions(parentRole, counter--);
+                Merge(ref permissions, parentPermissions);
+            }
+            return permissions;
         }
 
-        private IEnumerable<Permission> GetAncestorsPermissions(int idRole, IEnumerable<Permission> currentPermissions, 
+        private static void Merge(ref List<Permission> permissions, IEnumerable<Permission> newPermissions)
-            int? idParent, ref int counter)
         {
-            if (idParent == null) 
+            foreach (var newPermission in newPermissions)
-                return currentPermissions;
-        
-            if (counter > 10)
             {
-                Trace.WriteLine($"User role with id: {idRole} has more than 10 nested parents");
+                var permissionIndex = permissions.FindIndex(p => p.IdPermission == newPermission.IdPermission);
-                return currentPermissions;
+                if (permissionIndex == -1)
+                    permissions.Add(newPermission);
+                else
+                {
+                    var permission = permissions[permissionIndex];
+                    permissions[permissionIndex] = new Permission
+                    {
+                        IdPermission = permission.IdPermission,
+                        IdUserRole = permission.IdUserRole,
+                        PermissionValue = permission.PermissionValue | newPermission.PermissionValue,
+                    };
+                }
             }
-        
-            var parentRole = cacheUserRoles.FirstOrDefault(r => r.Id == idParent);
-            var parentRolePermissions = cachePermissions.Where(p =>
-                p.IdUserRole == parentRole.Id);
-            var resultPermissions = currentPermissions.Union(parentRolePermissions);
-        
-            counter++;
-        
-            return GetAncestorsPermissions(parentRole.Id, resultPermissions, 
-                parentRole.IdParent, ref counter);
         }
     }
 }

AsbCloudWebApi/Controllers/AdminPermissionController.cs

@@ -8,91 +8,16 @@ using Microsoft.AspNetCore.Mvc;
 
 namespace AsbCloudWebApi.Controllers
 {
-    [Route("api/admin/user")]
+    [Route("api/admin/permission")]
     [ApiController]
     [Authorize]
     public class AdminPermissionController : ControllerBase
     {
         private readonly IPermissionService permissionService;
-        private readonly ICrudService<PermissionInfoDto> permissionInfoService;
         
-        public AdminPermissionController(IPermissionService permissionService,
+        public AdminPermissionController(IPermissionService permissionService)
-            ICrudService<PermissionInfoDto> permissionInfoService)
         {
             this.permissionService = permissionService;
-            this.permissionInfoService = permissionInfoService;
-        }
-        
-        /// <summary>
-        /// Получает список доступных в справочнике разрешений
-        /// </summary>
-        /// <param name="token"> Токен отмены задачи </param>
-        /// <returns></returns>
-        [HttpGet("permissionInfo")]
-        [ProducesResponseType(typeof(IEnumerable<PermissionInfoDto>), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> GetAllAsync(CancellationToken token = default)
-        {
-            var result = await permissionInfoService.GetAllAsync(token);
-            return Ok(result);
-        }
-        
-        /// <summary>
-        /// Получает запрашиваемое из справочника разрешение
-        /// </summary>
-        /// <param name="id"> id запрашиваемого разрешения из справочника </param>
-        /// <param name="token"> Токен отмены задачи </param>
-        /// <returns></returns>
-        [HttpGet("permissionInfo/{id}")]
-        [ProducesResponseType(typeof(PermissionInfoDto), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> GetAsync(int id, CancellationToken token = default)
-        {
-            var result = await permissionInfoService.GetAsync(id, token);
-            return Ok(result);
-        }
-
-        /// <summary>
-        /// Добавляет разрешения для роли
-        /// </summary>
-        /// <param name="dtos"> Объекты новых разрешений для справочника </param>
-        /// <param name="token"> Токен отмены задачи </param>
-        /// <returns></returns>
-        [HttpPost("permissionInfo")]
-        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> InsertRangeAsync(IEnumerable<PermissionInfoDto> dtos, 
-            CancellationToken token = default)
-        {
-            var result = await permissionInfoService.InsertRangeAsync(dtos, token);
-            return Ok(result);
-        }
-        
-        /// <summary>
-        /// Обновляет разрешение для роли
-        /// </summary>
-        /// <param name="id"> id объекта разрешения</param>
-        /// <param name="dto"> Объект разрешения </param>
-        /// <param name="token"> Токен отмены задачи </param>
-        /// <returns></returns>
-        [HttpPut("permissionInfo")]
-        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> UpdateAsync(int id, PermissionInfoDto dto, 
-            CancellationToken token = default)
-        {
-            var result = await permissionInfoService.UpdateAsync(id, dto, token);
-            return Ok(result);
-        }
-        
-        /// <summary>
-        /// Удаляет разрешение для роли
-        /// </summary>
-        /// <param name="id"> id объекта разрешения из справочника </param>
-        /// <param name="token"> Токен отмены задачи </param>
-        /// <returns></returns>
-        [HttpDelete("permissionInfo")]
-        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> DeleteAsync(int id, CancellationToken token = default)
-        {
-            var result = await permissionInfoService.DeleteAsync(id, token);
-            return Ok(result);
         }
         
         /// <summary>
@@ -101,11 +26,11 @@ namespace AsbCloudWebApi.Controllers
         /// <param name="idRole"> id роли </param>
         /// <param name="token"> Токен отмены задачи </param>
         /// <returns></returns>
-        [HttpGet("permission")]
+        [HttpGet]
         [ProducesResponseType(typeof(IEnumerable<PermissionDto>), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> GetAllAsync(int idRole, CancellationToken token = default)
+        public async Task<IActionResult> GetByIdRoleAsync(int idRole, CancellationToken token = default)
         {
-            var result = await permissionService.GetallAsync(idRole, token);
+            var result = await permissionService.GetByIdRoleAsync(idRole, token);
             return Ok(result);
         }
 
@@ -115,7 +40,7 @@ namespace AsbCloudWebApi.Controllers
         /// <param name="dtos"> Объекты новых разрешений для справочника </param>
         /// <param name="token"> Токен отмены задачи </param>
         /// <returns></returns>
-        [HttpPost("permission")]
+        [HttpPost]
         [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
         public async Task<IActionResult> InsertRangeAsync(IEnumerable<PermissionDto> dtos, 
             CancellationToken token = default)
@@ -123,36 +48,35 @@ namespace AsbCloudWebApi.Controllers
             var result = await permissionService.InsertRangeAsync(dtos, token);
             return Ok(result);
         }
-        
+
         /// <summary>
-        /// Обновляет разрешение в правочник
+        /// Обновляет разрешение для роли
         /// </summary>
-        /// <param name="id"> id объекта разрешения для справочника </param>
         /// <param name="dto"> Объект разрешения для справочника </param>
         /// <param name="token"> Токен отмены задачи </param>
         /// <returns></returns>
-        [HttpPut("permission")]
+        [HttpPut]
         [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> UpdateAsync(int id, PermissionDto dto, 
+        public async Task<IActionResult> UpdateAsync(PermissionDto dto, 
             CancellationToken token = default)
         {
-            var result = await permissionService.UpdateAsync(id, dto, token);
+            var result = await permissionService.UpdateAsync(dto, token);
             return Ok(result);
         }
-        
+
         /// <summary>
         /// Удаляет разрешение для роли
         /// </summary>
-        /// <param name="idRole"> id роли для удаления разрешения </param>
         /// <param name="idPermission"> id разрешения </param>
+        /// <param name="idUserRole"> id роли для удаления разрешения </param>
         /// <param name="token"> Токен отмены задачи </param>
         /// <returns></returns>
-        [HttpDelete("permission")]
+        [HttpDelete("{idPermission}/{idRole}")]
         [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
-        public async Task<IActionResult> DeleteAsync(int idRole, int idPermission, 
+        public async Task<IActionResult> DeleteAsync(int idUserRole, int idPermission, 
             CancellationToken token = default)
         {
-            var result = await permissionService.DeleteAsync(idRole, idPermission, token);
+            var result = await permissionService.DeleteAsync(idUserRole, idPermission, token);
             return Ok(result);
         }
     }

AsbCloudWebApi/Controllers/AdminPermissionInfoController.cs

@@ -0,0 +1,18 @@
+using AsbCloudApp.Data;
+using AsbCloudApp.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AsbCloudWebApi.Controllers
+{
+    [Route("api/admin/permissionInfo")]
+    [ApiController]
+    [Authorize]
+    public class AdminPermissionInfoController : CrudController<PermissionInfoDto, ICrudService<PermissionInfoDto>>
+    {        
+        public AdminPermissionInfoController(ICrudService<PermissionInfoDto> permissionInfoService)
+            :base(permissionInfoService)
+        {}
+        
+    }
+}

AsbCloudWebApi/Controllers/AdminUserRoleController.cs

@@ -5,7 +5,7 @@ using Microsoft.AspNetCore.Mvc;
 
 namespace AsbCloudWebApi.Controllers
 {
-    [Route("api/admin/user/role")]
+    [Route("api/admin/role")]
     [ApiController]
     [Authorize]
     public class AdminUserRoleController : CrudController<UserRoleDto, ICrudService<UserRoleDto>>

AsbCloudWebApi/Controllers/CrudController.cs

@@ -48,6 +48,21 @@ namespace AsbCloudWebApi.Controllers
             return Ok(result);
         }
 
+        /// <summary>
+        /// Получить все записи
+        /// </summary>
+        /// <param name="token">CancellationToken</param>
+        /// <returns>все записи</returns>
+        [HttpGet("all")]
+        public virtual async Task<ActionResult<IEnumerable<T>>> GetAll(CancellationToken token = default)
+        {
+            if (!Roles.Any(role => User.IsInRole(role)))
+                return Forbid();
+
+            var result = await service.GetAllAsync(token).ConfigureAwait(false);
+            return Ok(result);
+        }
+
         /// <summary>
         /// Получить одну запись по Id
         /// </summary>
@@ -69,7 +84,7 @@ namespace AsbCloudWebApi.Controllers
         /// </summary>
         /// <param name="value">запись</param>
         /// <param name="token"></param>
-        /// <returns>1 - добавлено, 0 - нет</returns>
+        /// <returns>id</returns>
         [HttpPost]
         [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
         public virtual async Task<IActionResult> Insert([FromBody] T value, CancellationToken token = default)