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

Add tenant services

Browse Source
This commit is contained in:
Sergio Matías
2025-08-03 15:19:16 -06:00
parent 7c92a7e791
commit 0eadd6e217
18 changed files with 1134 additions and 514 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
Core.Thalos.Provider/Providers/Onboarding/RoleProvider.cs
View File

@@ -3,6 +3,7 @@
// AgileWebs
// </copyright>
// ***********************************************************************
using Core.Blueprint.Mongo;
using Core.Blueprint.Redis;
using Core.Blueprint.Redis.Helpers;
@@ -10,7 +11,6 @@ using Core.Thalos.BuildingBlocks;
using Core.Thalos.Domain.Contexts.Onboarding.Request;
using Core.Thalos.Provider.Contracts;
using Mapster;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
namespace Core.Thalos.Provider.Providers.Onboarding
@@ -21,146 +21,166 @@ namespace Core.Thalos.Provider.Providers.Onboarding
public class RoleProvider : IRoleProvider
{
private readonly CollectionRepository<RoleAdapter> repository;
private readonly CacheSettings cacheSettings;
private readonly ICacheSettings cacheSettings;
private readonly IRedisCacheProvider cacheProvider;
public RoleProvider(CollectionRepository<RoleAdapter> repository,
public RoleProvider(
CollectionRepository<RoleAdapter> repository,
IRedisCacheProvider cacheProvider,
IOptions<CacheSettings> cacheSettings
)
ICacheSettings cacheSettings)
{
this.repository = repository;
this.repository.CollectionInitialization();
this.cacheSettings = cacheSettings.Value;
this.cacheProvider = cacheProvider;
this.cacheSettings = cacheSettings;
}
/// <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>
/// <param name="newRole">The Role to be created.</param>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{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.
/// Gets a Role by its identifier.
/// </summary>
/// <param name="id">The Role identifier.</param>
/// <returns>A <see cref="{Task{RoleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
/// <param name="_id">The Role Mongo identifier.</param>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{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; }
if (cachedData is not null) return cachedData;
var role = await repository.FindByIdAsync(_id);
await cacheProvider.SetAsync(cacheKey, role);
await cacheProvider.SetAsync(cacheKey, role, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
return role;
}
/// <summary>
/// Gets all the roles.
/// Gets all Roles.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{RoleAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{IEnumerable{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;
//if (cachedData.Any()) return cachedData;
var roles = await repository.AsQueryable();
await cacheProvider.SetAsync(cacheKey, roles);
await cacheProvider.SetAsync(cacheKey, roles, TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes));
return roles;
}
/// <summary>
/// Changes the status of the role.
/// Changes the status of a 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)
/// <param name="_id">The Role Mongo identifier.</param>
/// <param name="newStatus">The new status of the Role.</param>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous execution of the service.
/// </returns>
public async ValueTask<RoleAdapter> ChangeRoleStatus(string _id, Blueprint.Mongo.StatusEnum newStatus, CancellationToken cancellationToken)
{
var entity = await repository.FindByIdAsync(id);
var entity = await repository.FindByIdAsync(_id);
entity.Status = newStatus;
await repository.ReplaceOneAsync(entity);
return entity;
}
/// <summary>
/// Updates a Role by id.
/// Updates a Role.
/// </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>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{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.
/// 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="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>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{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);
u => u._Id == roleId && u.Status == Blueprint.Mongo.StatusEnum.Active);
var updatedApplications = role.Applications.Append(application).Distinct().ToArray();
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>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{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 == Blueprint.Mongo.StatusEnum.Active);
var updatedApplications = role.Applications?
.Where(c => c != application)
.ToArray();
role.Applications = updatedApplications;
await repository.ReplaceOneAsync(role);
return role;
}
/// <summary>
/// Removes an application from the role's list of applications.
/// Deletes a Role by identifier.
/// </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)
/// <param name="_id">The Role Mongo identifier.</param>
/// <param name="cancellationToken">A token to cancel the asynchronous operation.</param>
/// <returns>
/// A <see cref="ValueTask{RoleAdapter}"/> representing the asynchronous deletion result.
/// The deleted Role entity if found; otherwise, null.
/// </returns>
public async ValueTask<RoleAdapter?> DeleteRole(string _id, 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;
var entity = await repository.DeleteOneAsync(doc => doc._Id == _id);
return entity;
}
}
}