AgileWebs/Core.Thalos.DAL.API
6
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

Use Blueprint.Mongo package in Role and Permission services

Browse Source
This commit is contained in:
Oscar Morales
2025-05-21 12:45:21 -06:00
parent c18c85959c
commit 1c38008e97
10 changed files with 403 additions and 666 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
Core.Thalos.Provider/Contracts/IPermissionService.cs → Core.Thalos.Provider/Contracts/IPermissionProvider.cs
View File

@@ -3,13 +3,13 @@
// AgileWebs
// </copyright>
// ***********************************************************************
using Core.Blueprint.Mongo;
using Core.Thalos.Adapters;
using Core.Thalos.Adapters.Common.Enums;
using Core.Thalos.Domain.Contexts.Onboarding.Request;
namespace Core.Thalos.Provider.Contracts
{
public interface IPermissionService
public interface IPermissionProvider
{
/// <summary>
/// Creates a new Permission.
@@ -17,7 +17,7 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="entity">The Permission to be created.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<PermissionAdapter> CreatePermissionService(PermissionRequest newPermission);
ValueTask<PermissionAdapter> CreatePermission(PermissionRequest newPermission, CancellationToken cancellationToken);
/// <summary>
/// Gets an Permission by identifier.
@@ -25,14 +25,14 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="id">The Permission identifier.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<PermissionAdapter> GetPermissionByIdService(string id);
ValueTask<PermissionAdapter> GetPermissionById(string _id, CancellationToken cancellationToken);
/// <summary>
/// Gets all the roles.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<IEnumerable<PermissionAdapter>> GetAllPermissionsService();
ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissions(CancellationToken cancellationToken);
/// <summary>
/// Gets all the permissions by permissions identifier list.
@@ -40,7 +40,7 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="permissions">The list of permissions identifiers.</param>
/// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<IEnumerable<PermissionAdapter>> GetAllPermissionsByListService(string[] permissions);
ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissionsByList(string[] permissions, CancellationToken cancellationToken);
/// <summary>
/// Changes the status of the permission.
@@ -50,7 +50,7 @@ namespace Core.Thalos.Provider.Contracts
/// <returns>The <see cref="PermissionAdapter"/> updated entity.</returns>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<PermissionAdapter> ChangePermissionStatusService(string id, StatusEnum newStatus);
ValueTask<PermissionAdapter> ChangePermissionStatus(string id, StatusEnum newStatus, CancellationToken cancellationToken);
/// <summary>
/// Updates a Permission by id.
@@ -59,6 +59,6 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="id">The Permission identifier.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<PermissionAdapter> UpdatePermissionService(PermissionAdapter entity, string id);
ValueTask<PermissionAdapter> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken);
}
}

16
Core.Thalos.Provider/Contracts/IRoleService.cs → Core.Thalos.Provider/Contracts/IRoleProvider.cs
View File

@@ -9,7 +9,7 @@ using Core.Thalos.Domain.Contexts.Onboarding.Request;
namespace Core.Thalos.Provider.Contracts
{
public interface IRoleService
public interface IRoleProvider
{
/// <summary>
/// Creates a new Role.
@@ -17,7 +17,7 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="entity">The Role to be created.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<RoleAdapter> CreateRoleService(RoleRequest newRole);
ValueTask<RoleAdapter> CreateRole(RoleRequest newRole, CancellationToken cancellationToken);
/// <summary>
/// Gets an Role by identifier.
@@ -25,14 +25,14 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<RoleAdapter> GetRoleByIdService(string id);
ValueTask<RoleAdapter> GetRoleById(string _id, CancellationToken cancellationToken);
/// <summary>
/// Gets all the roles.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<IEnumerable<RoleAdapter>> GetAllRolesService();
ValueTask<IEnumerable<RoleAdapter>> GetAllRoles(CancellationToken cancellationToken);
/// <summary>
/// Changes the status of the role.
@@ -42,7 +42,7 @@ namespace Core.Thalos.Provider.Contracts
/// <returns>The <see cref="RoleAdapter"/> updated entity.</returns>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<RoleAdapter> ChangeRoleStatusService(string id, StatusEnum newStatus);
ValueTask<RoleAdapter> ChangeRoleStatus(string id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken);
/// <summary>
/// Updates a Role by id.
@@ -51,7 +51,7 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<RoleAdapter> UpdateRoleService(RoleAdapter entity, string id);
ValueTask<RoleAdapter> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken);
/// <summary>
/// Adds an application to the role's list of applications.
@@ -59,7 +59,7 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="roleId">The identifier of the role to which the application will be added.</param>
/// <param name="application">The application enum value to add.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
Task<RoleAdapter> AddApplicationToRoleService(string roleId, ApplicationsEnum application);
ValueTask<RoleAdapter> AddApplicationToRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken);
/// <summary>
/// Removes an application from the role's list of applications.
@@ -67,6 +67,6 @@ namespace Core.Thalos.Provider.Contracts
/// <param name="roleId">The identifier of the role from which the application will be removed.</param>
/// <param name="application">The application enum value to remove.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
Task<RoleAdapter> RemoveApplicationFromRoleService(string roleId, ApplicationsEnum application);
ValueTask<RoleAdapter> RemoveApplicationFromRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken);
}
}

153
Core.Thalos.Provider/Providers/Onboarding/PermissionProvider.cs Normal file
View File

@@ -0,0 +1,153 @@
// ***********************************************************************
// <copyright file="PermissionService.cs">
// AgileWebs
// </copyright>
// ***********************************************************************
using Core.Thalos.Adapters;
using Core.Blueprint.Mongo;
using Core.Blueprint.Redis;
using Core.Blueprint.Redis.Helpers;
using Mapster;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using Core.Thalos.Provider.Contracts;
using Core.Thalos.Domain.Contexts.Onboarding.Request;
namespace Core.Thalos.Provider.Providers.Onboarding
{
/// <summary>
/// Handles all services and business rules related to <see cref="PermissionAdapter"/>.
/// </summary>
public class PermissionProvider : IPermissionProvider
{
private readonly CollectionRepository<PermissionAdapter> repository;
private readonly CacheSettings cacheSettings;
private readonly IRedisCacheProvider cacheProvider;
public PermissionProvider(CollectionRepository<PermissionAdapter> repository,
IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
{
this.repository = repository;
this.repository.CollectionInitialization();
this.cacheSettings = cacheSettings.Value;
this.cacheProvider = cacheProvider;
}
/// <summary>
/// Creates a new Permission.
/// </summary>
/// <param name="entity">The Permission to be created.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<PermissionAdapter> CreatePermission(PermissionRequest newPermission, CancellationToken cancellationToken)
{
var permissionCollection = newPermission.Adapt<PermissionAdapter>();
await repository.InsertOneAsync(permissionCollection);
return permissionCollection;
}
/// <summary>
/// Gets an Permission by identifier.
/// </summary>
/// <param name="id">The Permission identifier.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>0
public async ValueTask<PermissionAdapter> GetPermissionById(string _id, CancellationToken cancellationToken)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetPermissionById", _id);
var cachedData = await cacheProvider.GetAsync<PermissionAdapter>(cacheKey);
if (cachedData is not null) { return cachedData; }
var permission = await repository.FindByIdAsync(_id);
await cacheProvider.SetAsync(cacheKey, permission);
return permission;
}
/// <summary>
/// Gets all the permissions.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissions(CancellationToken cancellationToken)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissions");
var cachedData = await cacheProvider.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey) ?? [];
if (cachedData.Any()) return cachedData;
var permissions = await repository.AsQueryable();
await cacheProvider.SetAsync(cacheKey, permissions);
return permissions;
}
/// <summary>
/// Gets all the permissions by permissions identifier list.
/// </summary>
/// <param name="permissions">The list of permissions identifiers.</param>
/// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<IEnumerable<PermissionAdapter>> GetAllPermissionsByList(string[] permissions, CancellationToken cancellationToken)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissionsByList", permissions);
var cachedData = await cacheProvider.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey) ?? [];
if (cachedData.Any()) return cachedData;
var builder = Builders<PermissionAdapter>.Filter;
var filters = new List<FilterDefinition<PermissionAdapter>>();
if (permissions == null || !permissions.Any())
{
filters.Add(builder.In(x => x.Id, permissions));
}
var finalFilter = filters.Any() ? builder.And(filters) : builder.Empty;
var permissionsList = await repository.FilterByMongoFilterAsync(finalFilter);
await cacheProvider.SetAsync(cacheKey, permissionsList);
return permissionsList;
}
/// <summary>
/// Changes the status of the permission.
/// </summary>
/// <param name="id">The permission identifier.</param>
/// <param name="newStatus">The new status of the permission.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<PermissionAdapter> ChangePermissionStatus(string id, StatusEnum newStatus, CancellationToken cancellationToken)
{
var entity = await repository.FindByIdAsync(id);
entity.Status = newStatus;
await repository.ReplaceOneAsync(entity);
return entity;
}
/// <summary>
/// Updates a Permission by id.
/// </summary>
/// <param name="entity">The Permission to be updated.</param>
/// <param name="id">The Permission identifier.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<PermissionAdapter> UpdatePermission(PermissionAdapter entity, CancellationToken cancellationToken)
{
await repository.ReplaceOneAsync(entity);
return entity;
}
}
}

234
Core.Thalos.Provider/Providers/Onboarding/PermissionService.cs
View File

@@ -1,234 +0,0 @@
// ***********************************************************************
// <copyright file="PermissionService.cs">
// AgileWebs
// </copyright>
// ***********************************************************************
using Core.Thalos.Adapters;
using Core.Thalos.Adapters.Common.Constants;
using Core.Thalos.Adapters.Common.Enums;
using Core.Thalos.Domain.Contexts.Onboarding.Mappers;
using Core.Thalos.Domain.Contexts.Onboarding.Request;
using Core.Thalos.Infraestructure.Caching.Configs;
using Core.Thalos.Infraestructure.Caching.Contracts;
using Core.Thalos.Provider.Contracts;
using LSA.Core.Dapper.Service.Caching;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Core.Thalos.Provider.Providers.Onboarding
{
/// <summary>
/// Handles all services and business rules related to <see cref="PermissionAdapter"/>.
/// </summary>
public class PermissionService(ILogger<PermissionService> logger, IHttpContextAccessor httpContextAccessor, ICacheService cacheService,
IOptions<CacheSettings> cacheSettings, IMongoDatabase database) : IPermissionService
{
private readonly CacheSettings _cacheSettings = cacheSettings.Value;
/// <summary>
/// Creates a new Permission.
/// </summary>
/// <param name="entity">The Permission to be created.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<PermissionAdapter> CreatePermissionService(PermissionRequest newPermission)
{
try
{
var entity = newPermission.ToAdapter(httpContextAccessor);
await database.GetCollection<PermissionAdapter>(CollectionNames.Permission).InsertOneAsync(entity);
entity.Id = (entity as dynamic ?? "").Id.ToString();
return entity;
}
catch (Exception ex)
{
logger.LogError(ex, $"CreatePermissionService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets an Permission by identifier.
/// </summary>
/// <param name="id">The Permission identifier.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>0
public async Task<PermissionAdapter> GetPermissionByIdService(string id)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetPermissionByIdService", id);
var cachedData = await cacheService.GetAsync<PermissionAdapter>(cacheKey);
if (cachedData is not null) { return cachedData; }
try
{
var filter = Builders<PermissionAdapter>.Filter.And(
Builders<PermissionAdapter>.Filter.Eq("_id", ObjectId.Parse(id)),
Builders<PermissionAdapter>.Filter.Eq("status", StatusEnum.Active.ToString())
);
var permission = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
.Find(filter)
.FirstOrDefaultAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, permission, cacheDuration);
return permission;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetPermissionByIdService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets all the permissions.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{PermissionAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<IEnumerable<PermissionAdapter>> GetAllPermissionsService()
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissionsService");
var cachedData = await cacheService.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey) ?? [];
if (cachedData.Any()) return cachedData;
try
{
var filter = Builders<PermissionAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
var roles = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
.Find(filter)
.ToListAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, roles, cacheDuration);
return roles;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetAllPermissionsService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets all the permissions by permissions identifier list.
/// </summary>
/// <param name="permissions">The list of permissions identifiers.</param>
/// <returns>A <see cref="Task{IEnumerable{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<IEnumerable<PermissionAdapter>> GetAllPermissionsByListService(string[] permissions)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllPermissionsByListService", permissions);
var cachedData = await cacheService.GetAsync<IEnumerable<PermissionAdapter>>(cacheKey);
if (cachedData != null && cachedData.Any()) return cachedData;
try
{
var objectIds = permissions.Select(id => ObjectId.Parse(id)).ToArray();
var filter = Builders<PermissionAdapter>.Filter.In("_id", objectIds)
& Builders<PermissionAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
var roles = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
.Find(filter)
.ToListAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, roles, cacheDuration);
return roles;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetAllPermissionsByListService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Changes the status of the permission.
/// </summary>
/// <param name="id">The permission identifier.</param>
/// <param name="newStatus">The new status of the permission.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<PermissionAdapter> ChangePermissionStatusService(string id, StatusEnum newStatus)
{
try
{
var filter = Builders<PermissionAdapter>.Filter
.Eq("_id", ObjectId.Parse(id));
var update = Builders<PermissionAdapter>.Update
//.Set(v => v.Status, newStatus)
.Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
.Set(v => v.UpdatedAt, DateTime.UtcNow);
await database.GetCollection<PermissionAdapter>(CollectionNames.Permission).UpdateOneAsync(filter, update);
var updatedPermission = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
.Find(filter)
.FirstOrDefaultAsync();
return updatedPermission;
}
catch (Exception ex)
{
logger.LogError(ex, $"ChangePermissionStatusService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Updates a Permission by id.
/// </summary>
/// <param name="entity">The Permission to be updated.</param>
/// <param name="id">The Permission identifier.</param>
/// <returns>A <see cref="{Task{PermissionAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<PermissionAdapter> UpdatePermissionService(PermissionAdapter entity, string id)
{
try
{
var filter = Builders<PermissionAdapter>.Filter
.Eq("_id", ObjectId.Parse(id));
var update = Builders<PermissionAdapter>.Update
.Set(v => v.Name, entity.Name)
.Set(v => v.Description, entity.Description)
.Set(v => v.AccessLevel, entity.AccessLevel)
.Set(v => v.Status, entity.Status)
.Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
.Set(v => v.UpdatedAt, DateTime.UtcNow);
await database.GetCollection<PermissionAdapter>(CollectionNames.Permission).UpdateOneAsync(filter, update);
var updatedPermission = await database.GetCollection<PermissionAdapter>(CollectionNames.Permission)
.Find(filter)
.FirstOrDefaultAsync();
return updatedPermission;
}
catch (Exception ex)
{
logger.LogError(ex, $"UpdatePermissionService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
}
}

170
Core.Thalos.Provider/Providers/Onboarding/RoleProvider.cs Normal file
View File

@@ -0,0 +1,170 @@
// ***********************************************************************
// <copyright file="RoleService.cs">
// AgileWebs
// </copyright>
// ***********************************************************************
using Core.Thalos.Adapters;
using Core.Thalos.Adapters.Common.Enums;
using Core.Blueprint.Mongo;
using Core.Blueprint.Redis;
using Core.Blueprint.Redis.Helpers;
using Mapster;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
using Core.Thalos.Provider.Contracts;
using MongoDB.Bson;
using System.Text.RegularExpressions;
using MongoDB.Bson.Serialization;
using Core.Thalos.Domain.Contexts.Onboarding.Request;
using Microsoft.Graph;
using System.ComponentModel.Design;
namespace Core.Thalos.Provider.Providers.Onboarding
{
/// <summary>
/// Handles all services and business rules related to <see cref="RoleAdapter"/>.
/// </summary>
public class RoleProvider : IRoleProvider
{
private readonly CollectionRepository<RoleAdapter> repository;
private readonly CacheSettings cacheSettings;
private readonly IRedisCacheProvider cacheProvider;
public RoleProvider(CollectionRepository<RoleAdapter> repository,
IRedisCacheProvider cacheProvider, IOptions<CacheSettings> cacheSettings)
{
this.repository = repository;
this.repository.CollectionInitialization();
this.cacheSettings = cacheSettings.Value;
this.cacheProvider = cacheProvider;
}
/// <summary>
/// Creates a new Role.
/// </summary>
/// <param name="entity">The Role to be created.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<RoleAdapter> CreateRole(RoleRequest newRole, CancellationToken cancellationToken)
{
var roleCollection = newRole.Adapt<RoleAdapter>();
await repository.InsertOneAsync(roleCollection);
return roleCollection;
}
/// <summary>
/// Gets an Role by identifier.
/// </summary>
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<RoleAdapter> GetRoleById(string _id, CancellationToken cancellationToken)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetRoleById", _id);
var cachedData = await cacheProvider.GetAsync<RoleAdapter>(cacheKey);
if (cachedData is not null) { return cachedData; }
var role = await repository.FindByIdAsync(_id);
await cacheProvider.SetAsync(cacheKey, role);
return role;
}
/// <summary>
/// Gets all the roles.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<IEnumerable<RoleAdapter>> GetAllRoles(CancellationToken cancellationToken)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllRoles");
var cachedData = await cacheProvider.GetAsync<IEnumerable<RoleAdapter>>(cacheKey) ?? [];
if (cachedData.Any()) return cachedData;
var roles = await repository.AsQueryable();
await cacheProvider.SetAsync(cacheKey, roles);
return roles;
}
/// <summary>
/// Changes the status of the role.
/// </summary>
/// <param name="id">The role identifier.</param>
/// <param name="newStatus">The new status of the role.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<RoleAdapter> ChangeRoleStatus(string id, Core.Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
{
var entity = await repository.FindByIdAsync(id);
entity.Status = newStatus;
await repository.ReplaceOneAsync(entity);
return entity;
}
/// <summary>
/// Updates a Role by id.
/// </summary>
/// <param name="entity">The Role to be updated.</param>
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async ValueTask<RoleAdapter> UpdateRole(RoleAdapter entity, CancellationToken cancellationToken)
{
await repository.ReplaceOneAsync(entity);
return entity;
}
/// <summary>
/// Adds an application to the role's list of applications.
/// </summary>
/// <param name="roleId">The identifier of the role to which the application will be added.</param>
/// <param name="application">The application enum value to add.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
public async ValueTask<RoleAdapter> AddApplicationToRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken)
{
var role = await repository.FindOneAsync(
u => u.Id == roleId &&
u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
var updatedApplications = role.Applications.Append(application).Distinct().ToArray();
role.Applications = updatedApplications;
await repository.ReplaceOneAsync(role);
return role;
}
/// <summary>
/// Removes an application from the role's list of applications.
/// </summary>
/// <param name="roleId">The identifier of the role from which the application will be removed.</param>
/// <param name="application">The application enum value to remove.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
public async ValueTask<RoleAdapter> RemoveApplicationFromRole(string roleId, ApplicationsEnum application, CancellationToken cancellationToken)
{
var role = await repository.FindOneAsync(
u => u.Id == roleId &&
u.Status == Core.Blueprint.Mongo.StatusEnum.Active);
var updatedApplications = role.Applications
?.Where(c => c != application)
.ToArray();
role.Applications = updatedApplications;
await repository.ReplaceOneAsync(role);
return role;
}
}
}

251
Core.Thalos.Provider/Providers/Onboarding/RoleService.cs
View File

@@ -1,251 +0,0 @@
// ***********************************************************************
// <copyright file="RoleService.cs">
// AgileWebs
// </copyright>
// ***********************************************************************
using Core.Thalos.Adapters;
using Core.Thalos.Adapters.Common.Constants;
using Core.Thalos.Adapters.Common.Enums;
using Core.Thalos.Domain.Contexts.Onboarding.Mappers;
using Core.Thalos.Domain.Contexts.Onboarding.Request;
using Core.Thalos.Infraestructure.Caching.Configs;
using Core.Thalos.Infraestructure.Caching.Contracts;
using Core.Thalos.Provider.Contracts;
using LSA.Core.Dapper.Service.Caching;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MongoDB.Bson;
using MongoDB.Driver;
namespace Core.Thalos.Provider.Providers.Onboarding
{
/// <summary>
/// Handles all services and business rules related to <see cref="RoleAdapter"/>.
/// </summary>
public class RoleService(ILogger<RoleService> logger, IHttpContextAccessor httpContextAccessor, ICacheService cacheService,
IOptions<CacheSettings> cacheSettings, IMongoDatabase database) : IRoleService
{
private readonly CacheSettings _cacheSettings = cacheSettings.Value;
/// <summary>
/// Creates a new Role.
/// </summary>
/// <param name="entity">The Role to be created.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<RoleAdapter> CreateRoleService(RoleRequest newRole)
{
try
{
var entity = newRole.ToAdapter(httpContextAccessor);
await database.GetCollection<RoleAdapter>(CollectionNames.Role).InsertOneAsync(entity);
entity.Id = (entity as dynamic ?? "").Id.ToString();
return entity;
}
catch (Exception ex)
{
logger.LogError(ex, $"CreateRoleService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets an Role by identifier.
/// </summary>
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<RoleAdapter> GetRoleByIdService(string id)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetRoleByIdService", id);
var cachedData = await cacheService.GetAsync<RoleAdapter>(cacheKey);
if (cachedData is not null) { return cachedData; }
try
{
var filter = Builders<RoleAdapter>.Filter.And(
Builders<RoleAdapter>.Filter.Eq("_id", ObjectId.Parse(id)),
Builders<RoleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString())
);
var role = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
.Find(filter)
.FirstOrDefaultAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, role, cacheDuration);
return role;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetRoleByIdService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets all the roles.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<IEnumerable<RoleAdapter>> GetAllRolesService()
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllRolesService");
var cachedData = await cacheService.GetAsync<IEnumerable<RoleAdapter>>(cacheKey) ?? [];
if (cachedData.Any()) return cachedData;
try
{
var filter = Builders<RoleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
var roles = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
.Find(filter)
.ToListAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, roles, cacheDuration);
return roles;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetAllRolesService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Changes the status of the role.
/// </summary>
/// <param name="id">The role identifier.</param>
/// <param name="newStatus">The new status of the role.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<RoleAdapter> ChangeRoleStatusService(string id, StatusEnum newStatus)
{
try
{
var filter = Builders<RoleAdapter>.Filter
.Eq("_id", ObjectId.Parse(id));
var update = Builders<RoleAdapter>.Update
//.Set(v => v.Status, newStatus)
.Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
.Set(v => v.UpdatedAt, DateTime.UtcNow);
await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
.Find(filter)
.FirstOrDefaultAsync();
return updatedRole;
}
catch (Exception ex)
{
logger.LogError(ex, $"ChangeRoleStatusService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Updates a Role by id.
/// </summary>
/// <param name="entity">The Role to be updated.</param>
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<RoleAdapter> UpdateRoleService(RoleAdapter entity, string id)
{
try
{
var filter = Builders<RoleAdapter>.Filter
.Eq("_id", ObjectId.Parse(id));
var update = Builders<RoleAdapter>.Update
.Set(v => v.Name, entity.Name)
.Set(v => v.Description, entity.Description)
.Set(v => v.Applications, entity.Applications)
.Set(v => v.Modules, entity.Modules)
.Set(v => v.Permissions, entity.Permissions)
.Set(v => v.Status, entity.Status)
.Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
.Set(v => v.UpdatedAt, DateTime.UtcNow);
await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
.Find(filter)
.FirstOrDefaultAsync();
return updatedRole;
}
catch (Exception ex)
{
logger.LogError(ex, $"UpdateRoleService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Adds an application to the role's list of applications.
/// </summary>
/// <param name="roleId">The identifier of the role to which the application will be added.</param>
/// <param name="application">The application enum value to add.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
public async Task<RoleAdapter> AddApplicationToRoleService(string roleId, ApplicationsEnum application)
{
try
{
var filter = Builders<RoleAdapter>.Filter.Eq("_id", ObjectId.Parse(roleId));
var update = Builders<RoleAdapter>.Update.AddToSet(r => r.Applications, application);
await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
.Find(filter)
.FirstOrDefaultAsync();
return updatedRole;
}
catch (Exception ex)
{
logger.LogError(ex, $"AddApplicationToRoleService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Removes an application from the role's list of applications.
/// </summary>
/// <param name="roleId">The identifier of the role from which the application will be removed.</param>
/// <param name="application">The application enum value to remove.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing the asynchronous operation, with the updated role object.</returns>
public async Task<RoleAdapter> RemoveApplicationFromRoleService(string roleId, ApplicationsEnum application)
{
try
{
var filter = Builders<RoleAdapter>.Filter.Eq("_id", ObjectId.Parse(roleId));
var update = Builders<RoleAdapter>.Update.Pull(r => r.Applications, application);
await database.GetCollection<RoleAdapter>(CollectionNames.Role).UpdateOneAsync(filter, update);
var updatedRole = await database.GetCollection<RoleAdapter>(CollectionNames.Role)
.Find(filter)
.FirstOrDefaultAsync();
return updatedRole;
}
catch (Exception ex)
{
logger.LogError(ex, $"RemoveApplicationFromRoleService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
}
}

6
Core.Thalos.Provider/ServiceCollectionExtensions.cs
View File

@@ -64,9 +64,9 @@ namespace Core.Thalos.Provider
services.AddHttpContextAccessor();
services.AddScoped<IUserProvider, UserProvider>();
services.AddScoped<IRoleService, RoleService>();
services.AddScoped<IPermissionService, PermissionService>();
services.AddScoped<IPermissionService, PermissionService>();
services.AddScoped<IRoleProvider, RoleProvider>();
services.AddScoped<IPermissionProvider, PermissionProvider>();
services.AddScoped<IPermissionProvider, PermissionProvider>();
services.AddScoped<IModuleProvider, ModuleProvider>();
return services;
}