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

Use cacheTable for roles and permissions

Browse Source
This commit is contained in:
Фролов 2021-12-03 15:03:33 +05:00
parent 00dd39b587
commit 539905e8e0
14 changed files with 250 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
AsbCloudApp/Services/ICrudService.cs
View File

@ -8,13 +8,12 @@ namespace AsbCloudApp.Services
where Tdto : Data.IId
{
List<string> Incledes { get; }
Task<int> DeleteAsync(int id, CancellationToken token = default);
Task<int> DeleteAsync(IEnumerable<int> ids, CancellationToken token = default);
Task<IEnumerable<Tdto>> GetAllAsync(CancellationToken token = default);
Task<Tdto> GetAsync(int id, CancellationToken token = default);
Task<Data.PaginationContainer<Tdto>> GetPageAsync(int skip = 0, int take = 32, CancellationToken token = default);
Task<int> InsertAsync(Tdto newItem, CancellationToken token = default);
Task<int> InsertRangeAsync(IEnumerable<Tdto> newItems, CancellationToken token = default);
Task<IEnumerable<Tdto>> GetAllAsync(CancellationToken token = default);
Task<Tdto> GetAsync(int id, CancellationToken token = default);
Task<int> UpdateAsync(int id, Tdto item, CancellationToken token = default);
Task<int> DeleteAsync(int id, CancellationToken token = default);
Task<int> DeleteAsync(IEnumerable<int> ids, CancellationToken token = default);
}
}

10
AsbCloudApp/Services/IPaginationService.cs Normal file
View File

@ -0,0 +1,10 @@
using System.Threading;
using System.Threading.Tasks;
namespace AsbCloudApp.Services
{
public interface IPaginationService<Tdto>
{
Task<Data.PaginationContainer<Tdto>> GetPageAsync(int skip = 0, int take = 32, CancellationToken token = default);
}
}

2
AsbCloudApp/Services/IPermissionService.cs
View File

@ -11,6 +11,6 @@ namespace AsbCloudApp.Services
Task<int> InsertRangeAsync(IEnumerable<PermissionDto> dtos, CancellationToken token);
Task<int> UpdateAsync(PermissionDto dto, CancellationToken token);
Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token);
Task<int> DeleteAllByRoleAsync(int idUserRole, CancellationToken token);
}
}

8
AsbCloudApp/Services/IUserRoleService.cs Normal file
View File

@ -0,0 +1,8 @@
using AsbCloudApp.Data;
namespace AsbCloudApp.Services
{
public interface IUserRoleService: ICrudService<UserRoleDto>
{
}
}

3
AsbCloudApp/Services/IWellCompositeService.cs
View File

@ -1,8 +1,5 @@
using AsbCloudApp.Data;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

30
AsbCloudInfrastructure/DependencyInjection.cs
View File

@ -42,41 +42,35 @@ namespace AsbCloudInfrastructure
services.AddTransient<IAuthService, AuthService>();
services.AddTransient<IClusterService, ClusterService>();
services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
services.AddTransient<IDrillParamsService, DrillParamsService>();
services.AddTransient<IDrillingProgramService, DrillingProgramService>();
services.AddTransient<IDrillParamsService, DrillParamsService>();
services.AddTransient<IEventService, EventService>();
services.AddTransient<IFileService, FileService>();
services.AddTransient<IMeasureService, MeasureService>();
services.AddTransient<IMessageService, MessageService>();
services.AddTransient<IOperationsStatService, OperationsStatService>();
services.AddTransient<IPermissionService, PermissionService>();
services.AddTransient<IReportService, ReportService>();
services.AddTransient<ISetpointsService, SetpointsService>();
services.AddTransient<ITelemetryAnalyticsService, TelemetryAnalyticsService>();
services.AddTransient<ITelemetryService, TelemetryService>();
services.AddTransient<ITelemetryUserService, TelemetryUserService>();
services.AddTransient<ITimeZoneService, TimeZoneService>();
services.AddTransient<IUserRoleService, UserRoleService>();
services.AddTransient<IWellService, WellService>();
services.AddTransient<IWellCompositeService, WellCompositeService>();
services.AddTransient<IWellOperationImportService, WellOperationImportService>();
services.AddTransient<IWellOperationService, WellOperationService>();
services.AddTransient<IOperationsStatService, OperationsStatService>();
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<ISetpointsService, SetpointsService>();
// admin crud services:
services.AddTransient<ICrudService<ClusterDto>, CrudServiceBase<ClusterDto, Cluster>>();
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<WellDto>, CrudServiceBase<WellDto, Well>>();
services.AddTransient<ICrudService<UserDto>, CrudServiceBase<UserDto, User>>();
services.AddTransient<ICrudService<TelemetryDto>, CrudServiceBase<TelemetryDto, Telemetry>>();
services.AddTransient<ICrudService<PermissionInfoDto>, CrudServiceBase<PermissionInfoDto, PermissionInfo>>();
services.AddTransient<ICrudService<DrillParamsDto>, DrillParamsService>();
services.AddTransient<ICrudService<DepositDto>, CrudServiceBase<DepositDto, Deposit>>();
services.AddTransient<ICrudService<CompanyDto>, CrudServiceBase<CompanyDto, Company>>();
services.AddTransient<ICrudService<ClusterDto>, CrudServiceBase<ClusterDto, Cluster>>();
// TelemetryData services
services.AddTransient<ITelemetryDataService<TelemetryDataSaubDto>, TelemetryDataSaubService>();

206
AsbCloudInfrastructure/Services/Cache/CacheTable.cs
View File

@ -14,7 +14,7 @@ namespace AsbCloudInfrastructure.Services.Cache
{
private const int semaphoreTimeout = 5_000;
private static readonly SemaphoreSlim semaphore = new(1);
private static readonly TimeSpan minPeriodRefresh = TimeSpan.FromSeconds(5);
private static readonly TimeSpan minPeriodRefresh = TimeSpan.FromSeconds(5);
private static readonly string nameOfTEntity = typeof(TEntity).Name;
private readonly CacheTableDataStore data;
@ -37,7 +37,7 @@ namespace AsbCloudInfrastructure.Services.Cache
result = result.Include(include);
return result;
};
cached = (List<TEntity>)data.Entities;
if ((cached.Count == 0) || data.IsObsolete)
@ -47,7 +47,7 @@ namespace AsbCloudInfrastructure.Services.Cache
internal CacheTable(DbContext context, CacheTableDataStore data, Func<DbSet<TEntity>, IQueryable<TEntity>> configureDbSet = null)
{
this.context = context;
this.data = data;
this.data = data;
this.configureDbSet = configureDbSet;
dbSet = context.Set<TEntity>();
@ -65,15 +65,17 @@ namespace AsbCloudInfrastructure.Services.Cache
/// It may be needed to avoid multiple operations like Refresh().
/// </summary>
/// <param name="action">(wasFree) => {...}</param>
/// <returns>false - semaphore.Wait returned by timeout</returns>
private static bool Sync(Action<bool> action)
/// <returns>default if semaphoreTimeout. Or result of func(..)</returns>
private static T Sync<T>(Func<bool, T> func)
{
var wasFree = semaphore.CurrentCount > 0;
if (!semaphore.Wait(semaphoreTimeout))
return false;
T result = default;
if (func is null || !semaphore.Wait(semaphoreTimeout))
return result;
try
{
action?.Invoke(wasFree);
result = func.Invoke(wasFree);
}
catch (Exception ex)
{
@ -85,7 +87,7 @@ namespace AsbCloudInfrastructure.Services.Cache
{
semaphore.Release();
}
return true;
return result;
}
/// <summary>
@ -94,15 +96,18 @@ namespace AsbCloudInfrastructure.Services.Cache
/// It may be needed to avoid multiple operations like Refresh().
/// </summary>
/// <param name="action">(wasFree) => {...}</param>
/// <returns>false - semaphore.Wait returned by timeout</returns>
private static async Task<bool> SyncAsync(Func<bool, CancellationToken, Task> task, CancellationToken token = default)
/// <returns>default if semaphoreTimeout. Or result of func(..)</returns>
private static async Task<T> SyncAsync<T>(Func<bool, CancellationToken, Task<T>> funcAsync, CancellationToken token = default)
{
var wasFree = semaphore.CurrentCount > 0;
if (!await semaphore.WaitAsync(semaphoreTimeout, token).ConfigureAwait(false))
return false;
T result = default;
if (funcAsync is null || !await semaphore.WaitAsync(semaphoreTimeout, token).ConfigureAwait(false))
return result;
try
{
await task?.Invoke(wasFree, token);
result = await funcAsync.Invoke(wasFree, token);
}
catch (Exception ex)
{
@ -114,10 +119,10 @@ namespace AsbCloudInfrastructure.Services.Cache
{
semaphore.Release();
}
return true;
return result;
}
private void InternalRefresh(bool force)
private int InternalRefresh(bool force)
{
if (force || data.LastResreshDate + minPeriodRefresh < DateTime.Now)
{
@ -126,11 +131,12 @@ namespace AsbCloudInfrastructure.Services.Cache
var entities = query.AsNoTracking().ToList();
//Trace.WriteLine($"CacheTable<{nameOfTEntity}> refresh");
cached.AddRange(entities);
data.LastResreshDate = DateTime.Now;
data.LastResreshDate = DateTime.Now;
}
return cached.Count;
}
private async Task InternalRefreshAsync(bool force, CancellationToken token = default)
private async Task<int> InternalRefreshAsync(bool force, CancellationToken token = default)
{
if (force || data.LastResreshDate + minPeriodRefresh < DateTime.Now)
{
@ -142,24 +148,18 @@ namespace AsbCloudInfrastructure.Services.Cache
cached.AddRange(entities);
data.LastResreshDate = DateTime.Now;
}
return cached.Count;
}
public int Refresh(bool force)
{
Sync((wasFree) => {
if (wasFree)
InternalRefresh(force);
});
return cached.Count;
}
=> Sync((wasFree) => wasFree ? InternalRefresh(force) : 0);
public async Task<int> RefreshAsync(bool force, CancellationToken token = default)
public Task<int> RefreshAsync(bool force, CancellationToken token = default)
{
await SyncAsync(async (wasFree, token) => {
if (wasFree)
await InternalRefreshAsync(force, token).ConfigureAwait(false);
}, token).ConfigureAwait(false);
return cached.Count;
return SyncAsync(async (wasFree, token) =>
{
return wasFree ? await InternalRefreshAsync(force, token).ConfigureAwait(false) : 0;
}, token);
}
public bool Contains(Func<TEntity, bool> predicate)
@ -169,25 +169,22 @@ namespace AsbCloudInfrastructure.Services.Cache
=> await FirstOrDefaultAsync(predicate, token) != default;
public TEntity GetOrCreate(Func<TEntity, bool> predicate, Func<TEntity> makeNew)
=> Sync(wasFree =>
{
TEntity result = default;
Sync(wasFree => {
result = cached.FirstOrDefault(predicate);
if (result != default)
return;
var result = cached.FirstOrDefault(predicate);
if (result != default)
return result;
InternalRefresh(true);
result = cached.FirstOrDefault(predicate);
if (result != default)
return;
InternalRefresh(true);
result = cached.FirstOrDefault(predicate);
if (result != default)
return result;
var entry = dbSet.Add(makeNew());
context.SaveChanges();
InternalRefresh(true);
result = entry.Entity;
});
return result;
}
var entry = dbSet.Add(makeNew());
context.SaveChanges();
InternalRefresh(true);
return entry.Entity;
});
public TEntity FirstOrDefault()
{
@ -206,7 +203,7 @@ namespace AsbCloudInfrastructure.Services.Cache
return result;
await RefreshAsync(false, token);
return cached.FirstOrDefault();
return cached.FirstOrDefault();
}
public TEntity FirstOrDefault(Func<TEntity, bool> predicate)
@ -263,11 +260,11 @@ namespace AsbCloudInfrastructure.Services.Cache
return result;
}
public void Upsert(TEntity entity)
public int Upsert(TEntity entity)
{
if (entity == default)
return;
Sync((wasFree) =>
return 0;
return Sync((wasFree) =>
{
if (dbSet.Contains(entity))
dbSet.Update(entity);
@ -276,46 +273,51 @@ namespace AsbCloudInfrastructure.Services.Cache
var affected = context.SaveChanges();
if (affected > 0)
InternalRefresh(true);
});
return affected;
});
}
public Task UpsertAsync(TEntity entity, CancellationToken token = default)
=> SyncAsync(async (wasFree, token) => {
if (dbSet.Contains(entity))
dbSet.Update(entity);
else
dbSet.Add(entity);
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if(affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
}, token);
public Task<int> UpsertAsync(TEntity entity, CancellationToken token = default)
=> SyncAsync(async (wasFree, token) =>
{
if (dbSet.Contains(entity))
dbSet.Update(entity);
else
dbSet.Add(entity);
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
return affected;
}, token);
public void Upsert(IEnumerable<TEntity> entities)
public int Upsert(IEnumerable<TEntity> entities)
{
if (!entities.Any())
return;
return 0;
Sync((wasFree) =>
return Sync((wasFree) =>
{
foreach (var entity in entities)
{
if (dbSet.Contains(entity)) // TODO: это очень ммедленно
dbSet.Update(entity);
else
dbSet.Add(entity);
dbSet.Add(entity);
}
var affected = context.SaveChanges();
if (affected > 0)
InternalRefresh(true);
return affected;
});
}
public async Task UpsertAsync(IEnumerable<TEntity> entities, CancellationToken token = default)
public Task<int> UpsertAsync(IEnumerable<TEntity> entities, CancellationToken token = default)
{
if (!entities.Any())
return;
return Task.FromResult(0);
await SyncAsync(async (wasFree, token) => {
return SyncAsync(async (wasFree, token) =>
{
var upsertedEntries = new List<TEntity>(entities.Count());
foreach (var entity in entities)
{
@ -327,76 +329,76 @@ namespace AsbCloudInfrastructure.Services.Cache
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
return affected;
}, token);
}
public void Remove(Func<TEntity, bool> predicate)
public int Remove(Func<TEntity, bool> predicate)
=> Sync(_ =>
{
dbSet.RemoveRange(dbSet.Where(predicate));
var affected = context.SaveChanges();
if (affected > 0)
InternalRefresh(true);
return affected;
});
public Task RemoveAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
=> SyncAsync(async (wasFree, token) => {
public Task<int> RemoveAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
=> SyncAsync(async (wasFree, token) =>
{
dbSet.RemoveRange(dbSet.Where(predicate));
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
return affected;
}, token);
public TEntity Insert(TEntity entity)
{
TEntity result = default;
Sync(_ =>
return Sync(_ =>
{
var entry = dbSet.Add(entity);
var affected = context.SaveChanges();
if (affected > 0)
InternalRefresh(true);
result = entry.Entity;
return entry.Entity;
});
return result;
}
public async Task<TEntity> InsertAsync(TEntity entity, CancellationToken token = default)
public Task<TEntity> InsertAsync(TEntity entity, CancellationToken token = default)
{
TEntity result = default;
await SyncAsync(async (wasFree, token) =>
{
var entry = dbSet.Add(entity);
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
result = entry.Entity;
}, token);
return result;
return SyncAsync(async (wasFree, token) =>
{
var entry = dbSet.Add(entity);
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
return entry.Entity;
}, token);
}
public int Insert(IEnumerable<TEntity> newEntities)
{
int result = 0;
Sync(_ => {
dbSet.AddRange(newEntities);
result = context.SaveChanges();
if (result > 0)
InternalRefresh(true);
});
return result;
return Sync(_ =>
{
dbSet.AddRange(newEntities);
var affected = context.SaveChanges();
if (affected > 0)
InternalRefresh(true);
return affected;
});
}
public async Task<int> InsertAsync(IEnumerable<TEntity> newEntities, CancellationToken token = default)
public Task<int> InsertAsync(IEnumerable<TEntity> newEntities, CancellationToken token = default)
{
int result = 0;
await SyncAsync(async (wasFree, token) => {
return SyncAsync(async (wasFree, token) =>
{
dbSet.AddRange(newEntities);
result = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (result > 0)
var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
if (affected > 0)
await InternalRefreshAsync(true, token).ConfigureAwait(false);
return affected;
}, token);
return result;
}
public IEnumerator<TEntity> GetEnumerator() => Where().GetEnumerator();

8
AsbCloudInfrastructure/Services/CrudServiceBase.cs
View File

@ -102,11 +102,15 @@ namespace AsbCloudInfrastructure.Services
return context.SaveChangesAsync(token);
}
public virtual Task<int> UpdateAsync(int id, TDto item, CancellationToken token = default)
public virtual async Task<int> UpdateAsync(int id, TDto item, CancellationToken token = default)
{
var existingEntity = await dbSet.AsNoTracking().FirstOrDefaultAsync(e => e.Id == id).ConfigureAwait(false);
if (existingEntity is null)
return 0;
var entity = Convert(item);
entity.Id = id;
dbSet.Update(entity);
return context.SaveChangesAsync(token);
return await context.SaveChangesAsync(token);
}
public virtual Task<int> DeleteAsync(int id, CancellationToken token = default)

52
AsbCloudInfrastructure/Services/PermissionService.cs
View File

@ -1,8 +1,9 @@
using AsbCloudApp.Data;
using AsbCloudApp.Services;
using AsbCloudDb.Model;
using AsbCloudInfrastructure.Services.Cache;
using Mapster;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
@ -12,18 +13,19 @@ namespace AsbCloudInfrastructure.Services
{
public class PermissionService : IPermissionService, IConverter<PermissionDto, Permission>
{
private readonly IAsbCloudDbContext db;
public PermissionService(IAsbCloudDbContext db)
private readonly CacheTable<Permission> cachePermission;
public PermissionService(IAsbCloudDbContext db, CacheDb cacheDb)
{
this.db = db;
cachePermission = cacheDb.GetCachedTable<Permission>(
(AsbCloudDbContext)db,
new string[] { nameof(Permission.PermissionInfo) });
}
public async Task<IEnumerable<PermissionDto>> GetByIdRoleAsync(int idRole, CancellationToken token)
{
var entities = await db.Permissions
.Where(p => p.IdUserRole == idRole)
.ToListAsync(token)
var entities = await cachePermission
.WhereAsync(p => p.IdUserRole == idRole, token)
.ConfigureAwait(false);
var dto = entities.Select(Convert);
return dto;
@ -32,26 +34,36 @@ namespace AsbCloudInfrastructure.Services
public Task<int> InsertRangeAsync(IEnumerable<PermissionDto> dtos, CancellationToken token)
{
var entities = dtos.Select(Convert);
db.Permissions.AddRange(entities);
return db.SaveChangesAsync(token);
return cachePermission.InsertAsync(entities, token);
}
public Task<int> UpdateAsync(PermissionDto dto, CancellationToken token)
public async Task<int> UpdateAsync(PermissionDto dto, CancellationToken token)
{
var entity = Convert(dto);
db.Permissions.Update(entity);
return db.SaveChangesAsync(token);
await cachePermission.UpsertAsync(entity, token)
.ConfigureAwait(false);
return 1;
}
public Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token)
{
var entities = db.Permissions.AsNoTracking()
.Where(e => e.IdUserRole == idUserRole && e.IdPermission == idPermission)
.ToList();
if (!entities.Any())
return Task.FromResult(0);
db.Permissions.RemoveRange(entities);
return db.SaveChangesAsync(token);
bool predicate(Permission p) => p.IdUserRole == idUserRole && p.IdPermission == idPermission;
return DeleteAsync(predicate, token);
}
public Task<int> DeleteAllByRoleAsync(int idUserRole, CancellationToken token)
{
bool predicate(Permission p) => p.IdUserRole == idUserRole;
return DeleteAsync(predicate, token);
}
private async Task<int> DeleteAsync(Func<Permission, bool> predicate, CancellationToken token)
{
var count = (await cachePermission.WhereAsync(predicate, token).ConfigureAwait(false)).Count();
if (count > 0)
await cachePermission.RemoveAsync(predicate, token)
.ConfigureAwait(false);
return count;
}
public Permission Convert(PermissionDto src)

87
AsbCloudInfrastructure/Services/UserRoleService.cs
View File

@ -11,51 +11,82 @@ using AsbCloudApp.Services;
namespace AsbCloudInfrastructure.Services
{
public class UserRoleService : CrudServiceBase<UserRoleDto, UserRole>
public class UserRoleService : IUserRoleService
{
private readonly CacheTable<UserRole> cacheUserRoles;
private readonly IPermissionService permissionService;
public UserRoleService(IAsbCloudDbContext context, CacheDb cacheDb, IPermissionService permissionService) : base(context)
public List<string> Incledes { get; } = new();
public UserRoleService(IAsbCloudDbContext context, CacheDb cacheDb, IPermissionService permissionService)
{
cacheUserRoles = cacheDb.GetCachedTable<UserRole>((AsbCloudDbContext)context);
cacheUserRoles = cacheDb.GetCachedTable<UserRole>((AsbCloudDbContext)context, new string[] { nameof(UserRole.Permissions) });
this.permissionService = permissionService;
}
public override async Task<PaginationContainer<UserRoleDto>> GetPageAsync(int skip = 0,
int take = 32, CancellationToken token = default)
public async Task<IEnumerable<UserRoleDto>> GetAllAsync(CancellationToken token = default)
{
var rolesDtos = await base.GetPageAsync(skip, take, token);
return rolesDtos;
var entities = await cacheUserRoles.WhereAsync(token)
.ConfigureAwait(false);
var dtos = entities.Adapt<UserRoleDto>();
return dtos;
}
public override async Task<UserRoleDto> GetAsync(int id, CancellationToken token = default)
public async Task<UserRoleDto> GetAsync(int id, CancellationToken token = default)
{
var roleDto = await base.GetAsync(id,token);
return roleDto;
var entity = await cacheUserRoles.FirstOrDefaultAsync(r=>r.Id == id, token)
.ConfigureAwait(false);
var dto = entity?.Adapt<UserRoleDto>();
return dto;
}
public override async Task<int> InsertAsync(UserRoleDto dto, CancellationToken token = default)
public async Task<int> InsertAsync(UserRoleDto dto, CancellationToken token = default)
{
var id = await base.InsertAsync(dto, token).ConfigureAwait(false);
if (dto.Permissions is not null && dto.Permissions.Any())
var entity = dto.Adapt<UserRole>();
var updatedEntity = await cacheUserRoles.InsertAsync(entity, token).ConfigureAwait(false);
if (dto.Permissions?.Any() == true)
{
foreach (var permission in dto.Permissions)
permission.IdUserRole = id;
permission.IdUserRole = updatedEntity.Id;
await permissionService.InsertRangeAsync(dto.Permissions, token).ConfigureAwait(false);
await cacheUserRoles.RefreshAsync(true, token)
.ConfigureAwait(false);
}
return id;
return updatedEntity?.Id ?? 0;
}
public override async Task<int> UpdateAsync(int id, UserRoleDto item, CancellationToken token = default)
public async Task<int> InsertRangeAsync(IEnumerable<UserRoleDto> dtos, CancellationToken token = default)
{
foreach (var p in item.Permissions)
p.IdUserRole = item.Id;
var result = await base.UpdateAsync(id, item, token);
var entities = dtos.Adapt<UserRole>();
return await cacheUserRoles.InsertAsync(entities, token).ConfigureAwait(false);
}
return result;
public async Task<int> UpdateAsync(int id, UserRoleDto dto, CancellationToken token = default)
{
var entity = dto.Adapt<UserRole>();
entity.Id = id;
await cacheUserRoles.UpsertAsync(entity, token)
.ConfigureAwait(false);
if(dto.Permissions is not null)
{
await permissionService.DeleteAllByRoleAsync(id, token)
.ConfigureAwait(false);
if (dto.Permissions.Any())
{
foreach (var permission in dto.Permissions)
permission.IdUserRole = id;
await permissionService.InsertRangeAsync(dto.Permissions, token)
.ConfigureAwait(false);
}
await cacheUserRoles.RefreshAsync(true, token)
.ConfigureAwait(false);
}
return id;
}
private IEnumerable<Permission> GetNestedPermissions(UserRole role, int counter = 10)
@ -63,14 +94,14 @@ namespace AsbCloudInfrastructure.Services
List<Permission> permissions = role.Permissions.ToList();
if (role.IdParent is not null)
{
if(counter == 0)
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)
if (parentRole is null)
return permissions;
var parentPermissions = GetNestedPermissions(parentRole, counter--);
@ -98,5 +129,11 @@ namespace AsbCloudInfrastructure.Services
}
}
}
public Task<int> DeleteAsync(int id, CancellationToken token = default)
=> cacheUserRoles.RemoveAsync(r => r.Id == id, token);
public Task<int> DeleteAsync(IEnumerable<int> ids, CancellationToken token = default)
=> cacheUserRoles.RemoveAsync(r => ids.Contains(r.Id), token);
}
}

2
AsbCloudWebApi/Controllers/AdminPermissionController.cs
View File

@ -71,7 +71,7 @@ namespace AsbCloudWebApi.Controllers
/// <param name="idUserRole"> id роли для удаления разрешения </param>
/// <param name="token"> Токен отмены задачи </param>
/// <returns></returns>
[HttpDelete("{idPermission}/{idRole}")]
[HttpDelete("{idPermission}/{idUserRole}")]
[ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
public async Task<IActionResult> DeleteAsync(int idUserRole, int idPermission,
CancellationToken token = default)

3
AsbCloudWebApi/Controllers/AdminPermissionInfoController.cs
View File

@ -12,7 +12,6 @@ namespace AsbCloudWebApi.Controllers
{
public AdminPermissionInfoController(ICrudService<PermissionInfoDto> permissionInfoService)
:base(permissionInfoService)
{}
{}
}
}

9
AsbCloudWebApi/Controllers/AdminUserRoleController.cs
View File

@ -8,10 +8,11 @@ namespace AsbCloudWebApi.Controllers
[Route("api/admin/role")]
[ApiController]
[Authorize]
public class AdminUserRoleController : CrudController<UserRoleDto, ICrudService<UserRoleDto>>
public class AdminUserRoleController : CrudController<UserRoleDto, ICrudService<UserRoleDto>>
{
public AdminUserRoleController(ICrudService<UserRoleDto> service)
: base(service)
{ }
public AdminUserRoleController(IUserRoleService service)
:base(service)
{
}
}
}

22
AsbCloudWebApi/Controllers/CrudController.cs
View File

@ -30,24 +30,6 @@ namespace AsbCloudWebApi.Controllers
this.service = service;
}
/// <summary>
/// Получить страницу с записями в PaginationContainer
/// </summary>
/// <param name="skip">пропустить skip записей</param>
/// <param name="take">получить take записей</param>
/// <param name="token">CancellationToken</param>
/// <returns>страница с записями в PaginationContainer</returns>
[HttpGet()]
public virtual async Task<ActionResult<PaginationContainer<T>>> GetPage(int skip = 0, int take = 32,
CancellationToken token = default)
{
if (!Roles.Any(role => User.IsInRole(role)))
return Forbid();
var result = await service.GetPageAsync(skip, take, token).ConfigureAwait(false);
return Ok(result);
}
/// <summary>
/// Получить все записи
/// </summary>
@ -111,6 +93,8 @@ namespace AsbCloudWebApi.Controllers
return Forbid();
var result = await service.UpdateAsync(id, value, token).ConfigureAwait(false);
if (result == 0)
return BadRequest($"id:{id} does not exist in the db");
return Ok(result);
}
@ -131,4 +115,6 @@ namespace AsbCloudWebApi.Controllers
return Ok(result);
}
}
}