on.nemtina/DD.WellWorkover.Cloud
1
0
Fork 0
forked from ddrilling/AsbCloudServer
Code Pull Requests Activity

nit refacroring before merge

Browse Source
This commit is contained in:
Фролов 2021-12-03 09:44:10 +05:00
parent aff16dc84b
commit 4aaac31c43
8 changed files with 142 additions and 178 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
AsbCloudApp/Services/IPermissionService.cs
View File

@ -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> DeleteAsync(int idRole, int idPermission, CancellationToken token);
Task<int> UpdateAsync(PermissionDto dto, CancellationToken token);
Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token);
}
}

36
AsbCloudInfrastructure/DependencyInjection.cs
View File

@ -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<IMessageService, MessageService>();
services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
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<IWellCompositeService, WellCompositeService>();
services.AddTransient<IMeasureService, MeasureService>();
services.AddTransient<IDrillingProgramService, DrillingProgramService>();
services.AddTransient<IDrillParamsService, DrillParamsService>();
services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
services.AddTransient<ITimeZoneService, TimeZoneService>();
services.AddTransient<IWellService, WellService>();
// 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<DrillParamsDto>, DrillParamsService>();
services.AddTransient<IPermissionService, PermissionService>();
services.AddTransient<ICrudService<PermissionInfoDto>, CrudServiceBase<PermissionInfoDto, PermissionInfo>>();
services.AddTransient<ICrudService<WellDto>, CrudServiceBase<WellDto, Well>>();
// TelemetryData services
services.AddTransient<ITelemetryDataService<TelemetryDataSaubDto>, TelemetryDataSaubService>();

38
AsbCloudInfrastructure/Services/PermissionService.cs
View File

@ -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
where p.IdUserRole == idRole
select p)
.ToListAsync(token).ConfigureAwait(false);
var dto = entities.Adapt<PermissionDto>();
var entities = await db.Permissions
.Where(p => p.IdUserRole == idRole)
.ToListAsync(token)
.ConfigureAwait(false);
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;
}
}
}

95
AsbCloudInfrastructure/Services/UserRoleService.cs
View File

@ -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 CacheTable<Permission> cachePermissions;
private int counter = 0;
private readonly IPermissionService permissionService;
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);
cachePermissions =
cacheDb.GetCachedTable<Permission>((AsbCloudDbContext)context);
this.permissionService = permissionService;
}
public override async Task<PaginationContainer<UserRoleDto>> GetPageAsync(int skip = 0,
int take = 32, CancellationToken token = default)
{
var rolesDtos = await base.GetPageAsync(skip, take,token);
rolesDtos.Items = rolesDtos.Items.Select(FillUserRoleWithPermissions).ToList();
var rolesDtos = await base.GetPageAsync(skip, take, token);
return rolesDtos;
}
@ -39,19 +33,19 @@ namespace AsbCloudInfrastructure.Services
{
var roleDto = await base.GetAsync(id,token);
return roleDto is null
? null
: FillUserRoleWithPermissions(roleDto);
return roleDto;
}
public override async Task<int> InsertAsync(UserRoleDto dto, CancellationToken token = default)
{
var newRoleId = await base.InsertAsync(dto, token);
var newRolePermissions = GetAncestorsPermissions(newRoleId,
dto.Permissions.Adapt<Permission>(), dto.IdParent, ref counter);
return await cachePermissions.InsertAsync(newRolePermissions, token);
var id = await base.InsertAsync(dto, token).ConfigureAwait(false);
if (dto.Permissions is not null && dto.Permissions.Any())
{
foreach (var permission in dto.Permissions)
permission.IdUserRole = id;
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 =>
c.IdUserRole == roleDto.Id).Adapt<PermissionDto>();
List<Permission> permissions = role.Permissions.ToList();
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,
int? idParent, ref int counter)
private static void Merge(ref List<Permission> permissions, IEnumerable<Permission> newPermissions)
{
if (idParent == null)
return currentPermissions;
if (counter > 10)
foreach (var newPermission in newPermissions)
{
Trace.WriteLine($"User role with id: {idRole} has more than 10 nested parents");
return currentPermissions;
var permissionIndex = permissions.FindIndex(p => p.IdPermission == newPermission.IdPermission);
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);
}
}
}

108
AsbCloudWebApi/Controllers/AdminPermissionController.cs
View File

@ -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,
ICrudService<PermissionInfoDto> permissionInfoService)
public AdminPermissionController(IPermissionService permissionService)
{
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);
}
}

18
AsbCloudWebApi/Controllers/AdminPermissionInfoController.cs Normal file
View File

@ -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)
{}
}
}

2
AsbCloudWebApi/Controllers/AdminUserRoleController.cs
View File

@ -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>>

17
AsbCloudWebApi/Controllers/CrudController.cs
View File

@ -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)