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

Add project files.

Browse Source
This commit is contained in:
Sergio Matias Urquin
2025-04-29 18:55:44 -06:00
commit c34987797a
46 changed files with 3697 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

63
.gitattributes vendored Normal file
View File

@@ -0,0 +1,63 @@
###############################################################################
# Set default behavior to automatically normalize line endings.
###############################################################################
* text=auto
###############################################################################
# Set default behavior for command prompt diff.
#
# This is need for earlier builds of msysgit that does not have it on by
# default for csharp files.
# Note: This is only used by command line
###############################################################################
#*.cs diff=csharp
###############################################################################
# Set the merge driver for project and solution files
#
# Merging from the command prompt will add diff markers to the files if there
# are conflicts (Merging from VS is not affected by the settings below, in VS
# the diff markers are never inserted). Diff markers may cause the following
# file extensions to fail to load in VS. An alternative would be to treat
# these files as binary and thus will always conflict and require user
# intervention with every merge. To do so, just uncomment the entries below
###############################################################################
#*.sln merge=binary
#*.csproj merge=binary
#*.vbproj merge=binary
#*.vcxproj merge=binary
#*.vcproj merge=binary
#*.dbproj merge=binary
#*.fsproj merge=binary
#*.lsproj merge=binary
#*.wixproj merge=binary
#*.modelproj merge=binary
#*.sqlproj merge=binary
#*.wwaproj merge=binary
###############################################################################
# behavior for image files
#
# image files are treated as binary by default.
###############################################################################
#*.jpg binary
#*.png binary
#*.gif binary
###############################################################################
# diff behavior for common document formats
#
# Convert binary document formats to text before diffing them. This feature
# is only available from the command line. Turn it on by uncommenting the
# entries below.
###############################################################################
#*.doc diff=astextplain
#*.DOC diff=astextplain
#*.docx diff=astextplain
#*.DOCX diff=astextplain
#*.dot diff=astextplain
#*.DOT diff=astextplain
#*.pdf diff=astextplain
#*.PDF diff=astextplain
#*.rtf diff=astextplain
#*.RTF diff=astextplain

59
.pipelines/GitVersion.yml Normal file
View File

@@ -0,0 +1,59 @@
mode: mainline
assembly-versioning-scheme: MajorMinorPatch
tag-prefix: '[vV]'
major-version-bump-message: '\+semver:\s?(breaking|major)'
minor-version-bump-message: '\+semver:\s?(feature|minor)'
patch-version-bump-message: '\+semver:\s?(fix|patch)'
no-bump-message: '\+semver:\s?(none|skip)'
legacy-semver-padding: 4
build-metadata-padding: 4
commits-since-version-source-padding: 4
commit-message-incrementing: Enabled
branches:
main:
regex: ^master$|^main$
tag: ''
increment: Patch
prevent-increment-of-merged-branch-version: true
track-merge-target: false
source-branches: [ 'develop', 'release' ]
tracks-release-branches: false
is-release-branch: false
is-mainline: true
pre-release-weight: 55000
feature:
regex: ^features?[/-]
tag: useBranchName
increment: Inherit
prevent-increment-of-merged-branch-version: false
track-merge-target: false
source-branches: [ 'develop', 'main', 'release', 'feature', 'support', 'hotfix' ]
tracks-release-branches: false
is-release-branch: false
is-mainline: false
pre-release-weight: 30000
release:
regex: ^releases?[/-]
tag: beta
increment: None
is-mainline: true
regex: ^releases?[/-]
prevent-increment-of-merged-branch-version: true
track-merge-target: false
source-branches: [ 'develop', 'main', 'support', 'release' ]
tracks-release-branches: false
is-release-branch: true
is-mainline: false
pre-release-weight: 30000
hotfix:
regex: ^hotfix(es)?[/-]
increment: Patch
prevent-increment-of-merged-branch-version: false
track-merge-target: false
source-branches: [ 'develop', 'main', 'support' ]
tracks-release-branches: false
is-release-branch: false
is-mainline: false
pre-release-weight: 30000
ignore:
sha: []

57
.pipelines/templated-pipeline.yml Normal file
View File

@@ -0,0 +1,57 @@
pool:
vmImage: 'windows-latest'
trigger:
branches:
include:
- release/*
- feature/*
- hotfix/*
- bugfix/*
- development
variables:
project: 'Core.Cerberos.DAL.API/Core.Cerberos.DAL.API.csproj'
solution: 'Core.Cerberos.DAL.API.sln'
buildConfiguration: 'Release'
artifactName: 'drop'
snykConnectionEndpoint: 'SnykConnection'
projectNameOnSonar: 'Core.Cerberos.DAL.API'
projectKeyOnSonar: 'heathpbu_Core.Cerberos.DAL.API'
feed: '1b3770f1-17db-4bf2-a43d-49f305aa7a22'
projectFileName: 'Core.Cerberos.DAL.API.csproj'
projectPath: 'Core.Cerberos.DAL.API/'
resources:
repositories:
- repository: templates
name: "Template.DevOps.Pipelines"
type: "git"
project: "SharedLibs"
jobs:
- job: CI
steps:
- template: templates/dotnet/v1/step1_setup.yml@templates
- template: templates/dotnet/v1/step2_versioning.yml@templates
parameters:
projectFileName: '$(projectFileName)'
path: '$(projectPath)'
- template: templates/dotnet/v1/step3_restore_and_build.yml@templates
parameters:
project: '$(project)'
solution: '$(solution)'
buildConfiguration: '$(buildConfiguration)'
projectNameOnSonar: '$(projectNameOnSonar)'
projectKeyOnSonar: '$(projectKeyOnSonar)'
feed: '$(feed)'
- template: templates/dotnet/v1/step5_snyk_analysis.yml@templates
parameters:
snykConnectionEndpoint: '$(snykConnectionEndpoint)'
solutionToScan: '$(solution)'
- template: templates/dotnet/v1/step6_release.yml@templates
parameters:
artifactName: '$(artifactName)'
project: '$(project)'

53
Core.Cerberos.DAL.API.sln Normal file
View File

@@ -0,0 +1,53 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.10.35027.167
MinimumVisualStudioVersion = 10.0.40219.1
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Cerberos.DAL.API", "Core.Cerberos.DAL.API\Core.Cerberos.DAL.API.csproj", "{F00B4683-03B3-487A-9608-4B30675AA278}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Application", "Application", "{2E7D918E-AB9F-44BF-A334-FD675C9B626E}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Cerberos.Domain", "Core.Cerberos.Domain\Core.Cerberos.Domain.csproj", "{BE8E05D6-05B2-4317-B619-21853B7D21DB}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Cerberos.Infrastructure", "Core.Cerberos.Infraestructure\Core.Cerberos.Infrastructure.csproj", "{43BD5F47-132F-4E78-83F1-A1FEED01A502}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Core.Cerberos.Provider", "Core.Cerberos.Provider\Core.Cerberos.Provider.csproj", "{8CAE8380-475F-46B8-AF90-C495AAC58606}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Presentation", "Presentation", "{36839283-6407-476A-BB33-F0EE90383E2B}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{F00B4683-03B3-487A-9608-4B30675AA278}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{F00B4683-03B3-487A-9608-4B30675AA278}.Debug|Any CPU.Build.0 = Debug|Any CPU
{F00B4683-03B3-487A-9608-4B30675AA278}.Release|Any CPU.ActiveCfg = Release|Any CPU
{F00B4683-03B3-487A-9608-4B30675AA278}.Release|Any CPU.Build.0 = Release|Any CPU
{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Debug|Any CPU.Build.0 = Debug|Any CPU
{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Release|Any CPU.ActiveCfg = Release|Any CPU
{BE8E05D6-05B2-4317-B619-21853B7D21DB}.Release|Any CPU.Build.0 = Release|Any CPU
{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Debug|Any CPU.Build.0 = Debug|Any CPU
{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Release|Any CPU.ActiveCfg = Release|Any CPU
{43BD5F47-132F-4E78-83F1-A1FEED01A502}.Release|Any CPU.Build.0 = Release|Any CPU
{8CAE8380-475F-46B8-AF90-C495AAC58606}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8CAE8380-475F-46B8-AF90-C495AAC58606}.Debug|Any CPU.Build.0 = Debug|Any CPU
{8CAE8380-475F-46B8-AF90-C495AAC58606}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8CAE8380-475F-46B8-AF90-C495AAC58606}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(NestedProjects) = preSolution
{F00B4683-03B3-487A-9608-4B30675AA278} = {36839283-6407-476A-BB33-F0EE90383E2B}
{BE8E05D6-05B2-4317-B619-21853B7D21DB} = {2E7D918E-AB9F-44BF-A334-FD675C9B626E}
{43BD5F47-132F-4E78-83F1-A1FEED01A502} = {2E7D918E-AB9F-44BF-A334-FD675C9B626E}
{8CAE8380-475F-46B8-AF90-C495AAC58606} = {2E7D918E-AB9F-44BF-A334-FD675C9B626E}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {6800B16F-366B-476B-9BD1-FA841D443A6B}
EndGlobalSection
EndGlobal

220
Core.Cerberos.DAL.API/Controllers/ModuleController.cs Normal file
View File

@@ -0,0 +1,220 @@
// ***********************************************************************
// <copyright file="ModuleController.cs">
// Heath
// </copyright>
// ***********************************************************************
using Asp.Versioning;
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Attributes;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Core.Cerberos.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace LSA.Core.Kerberos.API.Controllers
{
/// <summary>
/// Handles all requests for module authentication.
/// </summary>
[ApiVersion(MimeTypes.ApplicationVersion)]
[Route("api/v{api-version:apiVersion}/[controller]")]
[Produces(MimeTypes.ApplicationJson)]
[Consumes(MimeTypes.ApplicationJson)]
[ApiController]
public class ModuleController(IModuleService service, ILogger<ModuleController> logger) : ControllerBase
{
/// <summary>
/// Gets all the modules.
/// </summary>
/// <returns>The <see cref="IEnumerable{ModuleAdapter}"/> found entities.</returns>
/// <response code="200">The roles found.</response>
/// <response code="404">The roles not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("ModuleManagement.Read, RoleManagement.Read")]
public async Task<IActionResult> GetAllModulesAsync()
{
try
{
var result = await service.GetAllModulesService();
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetAllModulesAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets all the modules by module identifiers.
/// </summary>
/// <param name="modules">The list of module identifiers.</param>
/// <returns>The <see cref="IEnumerable{ModuleAdapter}"/> found entities.</returns>
/// <response code="200">The modules found.</response>
/// <response code="404">The modules not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpPost]
[Route(Routes.GetModuleList)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(IEnumerable<ModuleAdapter>), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("ModuleManagement.Read")]
public async Task<IActionResult> GetAllModulesByList([FromBody] string[] modules)
{
if (modules == null || !modules.Any())
{
return BadRequest("Module identifiers are required.");
}
try
{
var result = await service.GetAllModulesByListService(modules);
if (result == null || !result.Any())
{
return NotFound("No modules found for the given identifiers.");
}
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetAllModulesByList");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets the module by identifier.
/// </summary>
/// <param name="id">The module identifier.</param>
/// <returns>The <see cref="ModuleAdapter"/> found entity.</returns>
/// <response code="200">The module found.</response>
/// <response code="404">The module not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route(Routes.Id)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("ModuleManagement.Read")]
public async Task<IActionResult> GetModuleByIdAsync([FromRoute] string id)
{
try
{
var result = await service.GetModuleByIdService(id);
if (result is null) return NotFound($"module with id: '{id}' not found");
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetModuleByIdAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Creates a new module.
/// </summary>
/// <param name="newModule">The module to be added.</param>
/// <returns>The <see cref="ModuleAdapter"/> created entity.</returns>
/// <response code="201">The module created.</response>
/// <response code="422">The module could not be created.</response>
/// <response code="500">The service internal e|ror.</response>
[HttpPost]
[ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status201Created)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("ModuleManagement.Write")]
public async Task<IActionResult> CreateModuleAsync([FromBody] ModuleRequest newModule)
{
try
{
var result = await service.CreateModuleService(newModule).ConfigureAwait(false);
return Created("CreatedWithIdService", result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in CreateModuleAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Updates a full module by identifier.
/// </summary>
/// <param name="entity">The module to update.</param>
/// <param name="id">The module identifier.</param>
/// <returns>The <see cref="ModuleAdapter"/> updated entity.</returns>
/// <response code="200">The module updated.</response>
/// <response code="404">The module not found.</response>
/// <response code="422">The module could not be updated.</response>
/// <response code="500">The service internal error.</response>
[HttpPut]
[Route(Routes.Id)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("ModuleManagement.Write")]
public async Task<IActionResult> UpdateModuleAsync(ModuleAdapter entity, string id)
{
try
{
var result = await service.UpdateModuleService(entity, id);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in UpdateModuleAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Changes the status of the module.
/// </summary>
/// <param name="id">The module identifier.</param>
/// <param name="newStatus">The new status of the module.</param>
/// <returns>The <see cref="ModuleAdapter"/> updated entity.</returns>
/// <response code="200">The module updates.</response>
/// <response code="404">The module not found.</response>
/// <response code="422">The module could not be deleted.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch]
[Route(Routes.ChangeStatus)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(ModuleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("ModuleManagement.Write")]
public async Task<IActionResult> ChangeModuleStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus)
{
try
{
var result = await service.ChangeModuleStatusService(id, newStatus);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in ChangeModuleStatus");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
}
}

219
Core.Cerberos.DAL.API/Controllers/PermissionController.cs Normal file
View File

@@ -0,0 +1,219 @@
// ***********************************************************************
// <copyright file="PermissionController.cs">
// Heath
// </copyright>
// ***********************************************************************
using Asp.Versioning;
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Attributes;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Core.Cerberos.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace LSA.Core.Kerberos.API.Controllers
{
/// <summary>
/// Handles all requests for permission authentication.
/// </summary>
[ApiVersion(MimeTypes.ApplicationVersion)]
[Route("api/v{api-version:apiVersion}/[controller]")]
[Produces(MimeTypes.ApplicationJson)]
[Consumes(MimeTypes.ApplicationJson)]
[ApiController]
public class PermissionController(IPermissionService service, ILogger<PermissionController> logger) : ControllerBase
{
/// <summary>
/// Gets all the permissions.
/// </summary>
/// <returns>The <see cref="IEnumerable{PermissionAdapter}"/> found entities.</returns>
/// <response code="200">The roles found.</response>
/// <response code="404">The roles not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(IEnumerable<PermissionAdapter>), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("PermissionManagement.Read, RoleManagement.Read")]
public async Task<IActionResult> GetAllPermissionsAsync()
{
try
{
var result = await service.GetAllPermissionsService();
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetAllPermissionsAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets all the permissions by permission identifiers.
/// </summary>
/// <param name="permissions">The list of permission identifiers.</param>
/// <returns>The <see cref="IEnumerable{PermissionAdapter}"/> found entities.</returns>
/// <response code="200">The permissions found.</response>
/// <response code="404">The permissions not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpPost]
[Route(Routes.GetPermissionList)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(IEnumerable<PermissionAdapter>), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("PermissionManagement.Read")]
public async Task<IActionResult> GetAllPermissionsByList([FromBody] string[] permissions)
{
if (permissions == null || !permissions.Any())
{
return BadRequest("Permission identifiers are required.");
}
try
{
var result = await service.GetAllPermissionsByListService(permissions);
if (result == null || !result.Any())
{
return NotFound("No permissions found for the given identifiers.");
}
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetAllPermissionsByList");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets the permission by identifier.
/// </summary>
/// <param name="id">The permission identifier.</param>
/// <returns>The <see cref="PermissionAdapter"/> found entity.</returns>
/// <response code="200">The permission found.</response>
/// <response code="404">The permission not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route(Routes.Id)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("PermissionManagement.Read")]
public async Task<IActionResult> GetPermissionByIdAsync([FromRoute] string id)
{
try
{
var result = await service.GetPermissionByIdService(id);
if (result is null) return NotFound($"permission with id: '{id}' not found");
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetPermissionByIdAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Creates a new permission.
/// </summary>
/// <param name="newPermission">The permission to be added.</param>
/// <returns>The <see cref="PermissionAdapter"/> created entity.</returns>
/// <response code="201">The permission created.</response>
/// <response code="422">The permission could not be created.</response>
/// <response code="500">The service internal e|ror.</response>
[HttpPost]
[ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status201Created)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("PermissionManagement.Write")]
public async Task<IActionResult> CreatePermissionAsync([FromBody] PermissionRequest newPermission)
{
try
{
var result = await service.CreatePermissionService(newPermission).ConfigureAwait(false);
return Created("CreatedWithIdService", result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in CreatePermissionAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Updates a full permission by identifier.
/// </summary>
/// <param name="entity">The permission to update.</param>
/// <param name="id">The permission identifier.</param>
/// <returns>The <see cref="PermissionAdapter"/> updated entity.</returns>
/// <response code="200">The permission updated.</response>
/// <response code="404">The permission not found.</response>
/// <response code="422">The permission could not be updated.</response>
/// <response code="500">The service internal error.</response>
[HttpPut]
[Route(Routes.Id)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("PermissionManagement.Write")]
public async Task<IActionResult> UpdatePermissionAsync(PermissionAdapter entity, string id)
{
try
{
var result = await service.UpdatePermissionService(entity, id);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in UpdatePermissionAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <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>The <see cref="PermissionAdapter"/> updated entity.</returns>
/// <response code="200">The permission updates.</response>
/// <response code="404">The permission not found.</response>
/// <response code="422">The permission could not be deleted.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch]
[Route(Routes.ChangeStatus)]
[Consumes(MimeTypes.ApplicationJson)]
[Produces(MimeTypes.ApplicationJson)]
[ProducesResponseType(typeof(PermissionAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("PermissionManagement.Write")]
public async Task<IActionResult> ChangePermissionStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus)
{
try
{
var result = await service.ChangePermissionStatusService(id, newStatus);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in ChangePermissionStatus");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
}
}

231
Core.Cerberos.DAL.API/Controllers/RoleController.cs Normal file
View File

@@ -0,0 +1,231 @@
// ***********************************************************************
// <copyright file="RoleController.cs">
// Heath
// </copyright>
// ***********************************************************************
using Asp.Versioning;
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Attributes;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Core.Cerberos.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
namespace LSA.Core.Kerberos.API.Controllers
{
/// <summary>
/// Handles all requests for role authentication.
/// </summary>
[ApiVersion(MimeTypes.ApplicationVersion)]
[Route("api/v{api-version:apiVersion}/[controller]")]
[Produces(MimeTypes.ApplicationJson)]
[Consumes(MimeTypes.ApplicationJson)]
[ApiController]
public class RoleController(IRoleService service, ILogger<RoleController> logger) : ControllerBase
{
/// <summary>
/// Gets all the roles.
/// </summary>
/// <returns>The rol found entities.</returns>
/// <response code="200">The roles found.</response>
/// <response code="404">The roles not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<RoleAdapter>), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Read")]
public async Task<IActionResult> GetAllRolesAsync()
{
try
{
var result = await service.GetAllRolesService();
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetAllRolesAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets the role by identifier.
/// </summary>
/// <param name="id">The role identifier.</param>
/// <returns>The <see cref="RoleAdapter"/> found entity.</returns>
/// <response code="200">The role found.</response>
/// <response code="404">The role not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route(Routes.Id)]
[ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Read")]
public async Task<IActionResult> GetRoleByIdAsync([FromRoute] string id)
{
try
{
var result = await service.GetRoleByIdService(id);
if (result is null) return NotFound($"role with id: '{id}' not found");
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetRoleByIdAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Creates a new role.
/// </summary>
/// <param name="newRole">The role to be added.</param>
/// <returns>The <see cref="RoleAdapter"/> created entity.</returns>
/// <response code="201">The role created.</response>
/// <response code="422">The role could not be created.</response>
/// <response code="500">The service internal error.</response>
[HttpPost]
[ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status201Created)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Write")]
public async Task<IActionResult> CreateRoleAsync([FromBody] RoleRequest newRole)
{
try
{
var result = await service.CreateRoleService(newRole).ConfigureAwait(false);
return Created("CreatedWithIdService", result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in CreateRoleAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Updates a full role by identifier.
/// </summary>
/// <param name="entity">The role to update.</param>
/// <param name="id">The role identifier.</param>
/// <returns>The <see cref="RoleAdapter"/> updated entity.</returns>
/// <response code="200">The role updated.</response>
/// <response code="404">The role not found.</response>
/// <response code="422">The role could not be updated.</response>
/// <response code="500">The service internal error.</response>
[HttpPut]
[Route(Routes.Id)]
[ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Write")]
public async Task<IActionResult> UpdateRoleAsync([FromBody] RoleAdapter entity, [FromRoute] string id)
{
try
{
var result = await service.UpdateRoleService(entity, id);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in UpdateRoleAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <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>The <see cref="RoleAdapter"/> updated entity.</returns>
/// <response code="200">The role updates.</response>
/// <response code="404">The role not found.</response>
/// <response code="422">The role could not be deleted.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch]
[Route(Routes.ChangeStatus)]
[ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Write")]
public async Task<IActionResult> ChangeRoleStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus)
{
try
{
var result = await service.ChangeRoleStatusService(id, newStatus);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in ChangeRoleStatus");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <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>
/// <response code="200">The role updates.</response>
/// <response code="404">The role not found.</response>
/// <response code="422">The role could not be deleted.</response>
/// <response code="500">The service internal error.</response>
[HttpPost(Routes.AddApplication)]
[ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Write")]
public async Task<IActionResult> AddApplicationToRoleAsync([FromRoute] string roleId,
[FromRoute] ApplicationsEnum application)
{
try
{
var updatedRole = await service.AddApplicationToRoleService(roleId, application);
return Ok(updatedRole);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in AddApplicationToRoleAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <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>
/// <response code="200">The role updates.</response>
/// <response code="404">The role not found.</response>
/// <response code="422">The role could not be deleted.</response>
/// <response code="500">The service internal error.</response>
[HttpDelete(Routes.RemoveApplication)]
[ProducesResponseType(typeof(RoleAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("RoleManagement.Write")]
public async Task<IActionResult> RemoveApplicationFromRoleAsync([FromRoute] string roleId,
[FromRoute] ApplicationsEnum application)
{
try
{
var updatedRole = await service.RemoveApplicationFromRoleService(roleId, application);
return Ok(updatedRole);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in RemoveApplicationFromRoleAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
}
}

495
Core.Cerberos.DAL.API/Controllers/UserController.cs Normal file
View File

@@ -0,0 +1,495 @@
// ***********************************************************************
// <copyright file="UserController.cs">
// Heath
// </copyright>
// ***********************************************************************
using Asp.Versioning;
using Core.Blueprint.Storage.Adapters;
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Attributes;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Provider.Contracts;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Graph;
using UserRequest = Core.Cerberos.Domain.Contexts.Onboarding.Request.UserRequest;
namespace LSA.Core.Kerberos.API.Controllers
{
/// <summary>
/// Handles all requests for user authentication.
/// </summary>
[ApiVersion("1.0")]
[Route("api/v{api-version:apiVersion}/[controller]")]
[Produces(MimeTypes.ApplicationJson)]
[Consumes(MimeTypes.ApplicationJson)]
[ApiController]
public class UserController(IUserService service, ILogger<UserController> logger) : ControllerBase
{
/// <summary>
/// Gets all the users.
/// </summary>
/// <returns>The <see cref="IEnumerable{UserAdapter}"/> found entity.</returns>
/// <response code="200">The users found.</response>
/// <response code="404">The users not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[ProducesResponseType(typeof(IEnumerable<UserAdapter>), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Read")]
public async Task<IActionResult> GetAllUsersService()
{
try
{
var result = await service.GetAllUsersService();
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetAllUsersService");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets the user by identifier.
/// </summary>
/// <param name="id">The user identifier.</param>
/// <returns>The <see cref="UserAdapter"/> found entity.</returns>
/// <response code="200">The user found.</response>
/// <response code="404">The user not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route(Routes.Id)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Read")]
public async Task<IActionResult> GetUserByIdService([FromRoute] string id)
{
try
{
var result = await service.GetUserByIdService(id);
if (result is null) return NotFound($"user with id: '{id}' not found");
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetUserByIdService");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets the user by email.
/// </summary>
/// <param name="email">The user's email.</param>
/// <returns>The <see cref="UserAdapter"/> found entity.</returns>
/// <response code="200">The user found.</response>
/// <response code="404">The user not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route(Routes.Email)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
public async Task<IActionResult> GetUserByEmail([FromRoute] string email)
{
try
{
var result = await service.GetUserByEmailService(email);
if (result is null) return NotFound($"user with email: '{email}' not found");
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetUserByIdEmail");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Validates if a user exists on the database.
/// </summary>
/// <param name="email">The user's email.</param>
/// <returns>The <see cref="UserExistenceAdapter"/> found entity.</returns>
/// <response code="200">The user found.</response>
/// <response code="404">The user not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route("{email}/ValidateExistence")]
[ProducesResponseType(typeof(UserExistenceAdapter), StatusCodes.Status200OK)]
[AllowAnonymous]
public async Task<IActionResult> ValidateUserExistence([FromRoute] string email)
{
try
{
var result = await service.ValidateUserExistenceService(email);
var existence = new UserExistenceAdapter
{
Existence = (result is not null) ? true : false
};
return Ok(existence);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in ValidateUserExistance");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Creates a new user.
/// </summary>
/// <param name="newUser">The user to be added.</param>
/// <param name="sendInvitation">Sends an invitation in case of third party access.</param>
/// <returns>The <see cref="UserAdapter"/> created entity.</returns>
/// <response code="201">The user created.</response>
/// <response code="422">The user could not be created.</response>
/// <response code="500">The service internal error.</response>
[HttpPost(Routes.Register)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status201Created)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> CreateUserAsync([FromBody] UserRequest newUser, [FromRoute] bool sendInvitation)
{
try
{
var user = await service.GetUserByEmailService(newUser.Email).ConfigureAwait(false);
if (user is not null)
return UnprocessableEntity("There is a user with the same email registered in the database");
var result = await service.CreateUserService(newUser).ConfigureAwait(false);
return Created("CreatedWithIdService", result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in CreateUserAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Updates a full user by identifier.
/// </summary>
/// <param name="entity">The user to update.</param>
/// <param name="id">The user identifier.</param>
/// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
/// <response code="200">The user updated.</response>
/// <response code="404">The user not found.</response>
/// <response code="422">The user could not be updated.</response>
/// <response code="500">The service internal error.</response>
[HttpPut]
[Route(Routes.Id)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> UpdateUserAsync([FromBody] UserAdapter entity, [FromRoute] string id)
{
try
{
var result = await service.UpdateUserService(entity, id);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in UpdateUserAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Logs in the user.
/// </summary>
/// <param name="email">The User's email.</param>
/// <returns>A <see cref="UserAdapter"/> representing
/// the asynchronous execution of the service.</returns>
/// <response code="200">The User found.</response>
/// <response code="404">The User not found.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch(Routes.LogIn)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
public async Task<IActionResult> LoginUserAsync([FromRoute] string email)
{
try
{
var result = await service.LogInUserService(email).ConfigureAwait(false);
if (result is null)
return new NotFoundObjectResult($"The user with email: '{email}' was not found");
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in LogInUserService");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Logs out the user.
/// </summary>
/// <param name="email">The User's email.</param>
/// <returns>A <see cref="UserAdapter"/> representing
/// the asynchronous execution of the service.</returns>
/// <response code="200">The User updated.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch(Routes.LogOut)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
public async Task<IActionResult> LogOutUserSessionAsync([FromRoute] string email)
{
try
{
var result = await service.LogOutUserSessionService(email).ConfigureAwait(false);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in LogOutUserSessionService");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Changes the status of the user.
/// </summary>
/// <param name="id">The user identifier.</param>
/// <param name="newStatus">The new status of the user.</param>
/// <returns>The <see cref="UserAdapter"/> updated entity.</returns>
/// <response code="200">The user updates.</response>
/// <response code="404">The user not found.</response>
/// <response code="422">The user could not be deleted.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch]
[Route(Routes.ChangeStatus)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> ChangeUserStatus([FromRoute] string id, [FromRoute] StatusEnum newStatus)
{
try
{
var result = await service.ChangeUserStatusService(id, newStatus);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in ChangeUserStatus");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Adds a company to the user's list of companies.
/// </summary>
/// <param name="userId">The user identifier.</param>
/// <param name="companyId">The company identifier to add.</param>
/// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
/// <response code="200">The user with the updated companies.</response>
/// <response code="404">The user or company not found.</response>
/// <response code="500">The service internal error.</response>
[HttpPost]
[Route(Routes.AddCompany)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> AddCompanyToUserAsync([FromRoute] string userId, [FromRoute] string companyId)
{
try
{
var result = await service.AddCompanyToUserService(userId, companyId);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in AddCompanyToUserAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Removes a company from the user's list of companies.
/// </summary>
/// <param name="userId">The user identifier.</param>
/// <param name="companyId">The company identifier to remove.</param>
/// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
/// <response code="200">The user with the updated companies.</response>
/// <response code="404">The user or company not found.</response>
/// <response code="500">The service internal error.</response>
[HttpDelete]
[Route(Routes.RemoveCompany)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> RemoveCompanyFromUserAsync([FromRoute] string userId, [FromRoute] string companyId)
{
try
{
var result = await service.RemoveCompanyFromUserService(userId, companyId);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in RemoveCompanyFromUserAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Adds a project to the user's list of projects.
/// </summary>
/// <param name="userId">The user identifier.</param>
/// <param name="projectId">The project identifier to add.</param>
/// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
/// <response code="200">The user with the updated projects.</response>
/// <response code="404">The user or project not found.</response>
/// <response code="500">The service internal error.</response>
[HttpPost]
[Route(Routes.AddProject)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> AddProjectToUserAsync([FromRoute] string userId, [FromRoute] string projectId)
{
try
{
var result = await service.AddProjectToUserService(userId, projectId);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in AddProjectToUserAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Removes a project from the user's list of projects.
/// </summary>
/// <param name="userId">The user identifier.</param>
/// <param name="projectId">The project identifier to remove.</param>
/// <returns>The updated <see cref="UserAdapter"/> entity.</returns>
/// <response code="200">The user with the updated projects.</response>
/// <response code="404">The user or project not found.</response>
/// <response code="500">The service internal error.</response>
[HttpDelete]
[Route(Routes.RemoveProject)]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Write")]
public async Task<IActionResult> RemoveProjectFromUserAsync([FromRoute] string userId, [FromRoute] string projectId)
{
try
{
var result = await service.RemoveProjectFromUserService(userId, projectId);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in RemoveProjectFromUserAsync");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Gets a token for the user, including roles, permissions, and modules.
/// </summary>
/// <param name="email">The user's email.</param>
/// <returns>The token adapter with user details, role, permissions, and modules.</returns>
/// <response code="200">The token adapter with user details.</response>
/// <response code="404">The user not found.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route("{email}/GetTokenAdapter")]
[ProducesResponseType(typeof(TokenAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
public async Task<IActionResult> GetTokenAdapter([FromRoute] string email)
{
try
{
var tokenAdapter = await service.GetTokenAdapter(email);
if (tokenAdapter == null) return NotFound($"User with email: {email} not found");
return Ok(tokenAdapter);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetTokenAdapter");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Get Consent Form PDF.
/// </summary>
/// <returns>The <see cref="BlobDownloadUriAdapter"/> found pdf.</returns>
/// <response code="200">The pdf found.</response>
/// <response code="404">The pdf not found error.</response>
/// <response code="500">The service internal error.</response>
[HttpGet]
[Route("GetConsentFormPDF")]
[ProducesResponseType(typeof(BlobDownloadUriAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = Schemes.HeathScheme)]
[Permission("UserManagement.Read")]
public async Task<IActionResult> GetConsentFormPDFService()
{
try
{
var result = await service.GetConsentFormPDFService();
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in GetConsentFormPDFService");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
/// <summary>
/// Accept user consent form.
/// </summary>
/// <returns>A <see cref="UserAdapter"/> representing
/// the asynchronous execution of the service.</returns>
/// <response code="200">The User found.</response>
/// <response code="404">The User not found.</response>
/// <response code="500">The service internal error.</response>
[HttpPatch("AcceptUserConsentForm")]
[ProducesResponseType(typeof(UserAdapter), StatusCodes.Status200OK)]
[Authorize(AuthenticationSchemes = $"{Schemes.HeathScheme}, {Schemes.AzureScheme}")]
public async Task<IActionResult> AcceptUserConsentFormAsync()
{
try
{
var result = await service.AcceptUserConsentFormService().ConfigureAwait(false);
return Ok(result);
}
catch (Exception ex)
{
logger.LogError(ex, "Error in AcceptUserConsentFormService");
return StatusCode(500, $"Internal server error, ErrorMessage: {ex.Message}");
}
}
}
}

26
Core.Cerberos.DAL.API/Core.Cerberos.DAL.API.csproj Normal file
View File

@@ -0,0 +1,26 @@
<Project Sdk="Microsoft.NET.Sdk.Web">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<Nullable>enable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
<GenerateDocumentationFile>True</GenerateDocumentationFile>
</PropertyGroup>
<ItemGroup>
<Compile Remove="Constants\**" />
<Content Remove="Constants\**" />
<EmbeddedResource Remove="Constants\**" />
<None Remove="Constants\**" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Microsoft.Extensions.Configuration.AzureAppConfiguration" Version="8.0.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Core.Cerberos.Domain\Core.Cerberos.Domain.csproj" />
<ProjectReference Include="..\Core.Cerberos.Provider\Core.Cerberos.Provider.csproj" />
</ItemGroup>
</Project>

6
Core.Cerberos.DAL.API/Core.Cerberos.DAL.API.http Normal file
View File

@@ -0,0 +1,6 @@
@Core.Cerberos.DAL.API_HostAddress = http://localhost:5211
GET {{Core.Cerberos.DAL.API_HostAddress}}/weatherforecast/
Accept: application/json
###

86
Core.Cerberos.DAL.API/Program.cs Normal file
View File

@@ -0,0 +1,86 @@
using Core.Cerberos.Adapters.Extensions;
using Core.Cerberos.Adapters.Helpers;
using Core.Cerberos.Provider;
using Microsoft.AspNetCore.RateLimiting;
using Microsoft.AspNetCore.ResponseCompression;
using System.IO.Compression;
using System.Reflection;
using System.Threading.RateLimiting;
var builder = WebApplication.CreateBuilder(args);
var authSettings = AuthHelper.GetAuthSettings(builder, "cerberos_dal");
builder.Services.ConfigureAuthentication(builder.Configuration, authSettings);
builder.Configuration.AddUserSecrets(Assembly.GetExecutingAssembly()).AddEnvironmentVariables();
// Add services to the container.
builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddCors(options =>
{
options.AddPolicy("AllowAll", policyBuilder =>
policyBuilder.AllowAnyOrigin().AllowAnyHeader().AllowAnyMethod());
});
builder.Services.AddMvc().AddJsonOptions(options =>
{
options.JsonSerializerOptions.WriteIndented = true;
options.JsonSerializerOptions.MaxDepth = 20;
options.JsonSerializerOptions.NumberHandling = System.Text.Json.Serialization.JsonNumberHandling.AllowNamedFloatingPointLiterals;
});
builder.Services.Configure<BrotliCompressionProviderOptions>(options =>
{
options.Level = CompressionLevel.Fastest;
});
builder.Services.Configure<GzipCompressionProviderOptions>(options =>
{
options.Level = CompressionLevel.SmallestSize;
});
builder.Services.AddResponseCompression(options =>
{
options.EnableForHttps = true;
options.Providers.Add<BrotliCompressionProvider>();
options.Providers.Add<GzipCompressionProvider>();
});
builder.Services.AddRateLimiter(_ => _
.AddFixedWindowLimiter("fixed", options =>
{
options.PermitLimit = 5;
options.Window = TimeSpan.FromSeconds(10);
options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
options.QueueLimit = 2;
})
.AddSlidingWindowLimiter("sliding", options =>
{
options.PermitLimit = 5;
options.Window = TimeSpan.FromSeconds(10);
options.SegmentsPerWindow = 5;
options.QueueProcessingOrder = QueueProcessingOrder.OldestFirst;
options.QueueLimit = 2;
}));
builder.Services.AddResponseCaching();
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwagger(builder.Configuration, "Core.Cerberos.DAL.API.xml", authSettings);
builder.Services.AddVersioning(builder.Configuration);
builder.Services.AddLogging();
builder.Services.AddProblemDetails();
builder.Services.AddDALLayer(builder.Configuration);
var app = builder.Build();
app.UseSwaggerUI(builder.Configuration, authSettings);
app.ConfigureSwagger(builder.Configuration);
app.UseHttpsRedirection();
app.UseAuthorization();
app.MapControllers();
app.Run();

41
Core.Cerberos.DAL.API/Properties/launchSettings.json Normal file
View File

@@ -0,0 +1,41 @@
{
"$schema": "http://json.schemastore.org/launchsettings.json",
"iisSettings": {
"windowsAuthentication": false,
"anonymousAuthentication": true,
"iisExpress": {
"applicationUrl": "http://localhost:59551",
"sslPort": 44359
}
},
"profiles": {
"http": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"launchUrl": "swagger",
"applicationUrl": "http://localhost:5211",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Local"
}
},
"https": {
"commandName": "Project",
"dotnetRunMessages": true,
"launchBrowser": true,
"launchUrl": "swagger",
"applicationUrl": "https://localhost:7031;http://localhost:5211",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Local"
}
},
"IIS Express": {
"commandName": "IISExpress",
"launchBrowser": true,
"launchUrl": "swagger",
"environmentVariables": {
"ASPNETCORE_ENVIRONMENT": "Local"
}
}
}
}

8
Core.Cerberos.DAL.API/appsettings.Development.json Normal file
View File

@@ -0,0 +1,8 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
}

12
Core.Cerberos.DAL.API/appsettings.json Normal file
View File

@@ -0,0 +1,12 @@
{
"Logging": {
"LogLevel": {
"Default": "Information",
"Microsoft.AspNetCore": "Warning"
}
},
"AllowedHosts": "*",
"Endpoints": {
"AppConfigurationURI": "https://sandbox-hci-usc-appcg.azconfig.io"
}
}

35
Core.Cerberos.DAL.API/sample.settings.json Normal file
View File

@@ -0,0 +1,35 @@
{
"ConnectionStrings": {
"DefaultConnection": "", // Sandbox MongoDB connection string
"Redis": "", // New Redis connection string
"KeyVault": "" //KeyVault Uri
},
"MongoDb": {
"DatabaseName": "Cerberos"
},
"CacheSettings": {
"DefaultCacheDurationInMinutes": 3 // Default cache duration set to 3 minutes
},
"JwtIssuerOptions": {
"Audience": "", // Audience for token creation, specifies intended recipients
"Issuer": "" // Issuer for token creation, identifies the issuer of the token
},
"AzureAdB2C": {
"Instance": "", // Azure AD instance URL (STORED IN KEY VAULT)
"TenantId": "", // Azure AD tenant ID (STORED IN KEY VAULT)
"ClientId": "", // Azure AD application client ID (STORED IN KEY VAULT)
"ClientSecret": "", // Azure AD application client secret (STORED IN KEY VAULT)
"CallbackPath": "", // Path for redirect after authentication
"Scopes": "" // Access scopes for user permissions
},
"HeathCerberosApp": {
"AuthorizationUrl": "", // URL for authorization endpoint (STORED IN KEY VAULT)
"TokenUrl": "", // URL for token endpoint (STORED IN KEY VAULT)
"Scope": "", // Scope for application permissions (STORED IN KEY VAULT)
"ClientId": "" // Client ID for Kerberos application (STORED IN KEY VAULT)
},
"MicrosoftGraph": {
"Scopes": "", // Scopes for Microsoft Graph API access
"BaseUrl": "" // Base URL for Microsoft Graph API
}
}

42
Core.Cerberos.Domain/Contexts/Onboarding/Mappers/ModuleMapper.cs Normal file
View File

@@ -0,0 +1,42 @@
// ***********************************************************************
// <copyright file="ModuleMapper.cs">
// HEATH
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Microsoft.AspNetCore.Http;
using MongoDB.Bson;
using System.Security.Claims;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Mappers
{
/// <summary>
/// Handles mappings between
/// <see cref="ModuleRequest"/>,
/// and <see cref="ModuleAdapter"/>
/// </summary>
public static class ModuleMapper
{
/// <summary>
/// Maps the permissionRequest to ModuleAdapter.
/// </summary>
/// <param name="newModule">The Module to be mapped.</param>
/// <returns>A <see cref="ModuleAdapter"/> representing
/// the asynchronous execution of the service.</returns>
public static ModuleAdapter ToAdapter(this ModuleRequest newModule, IHttpContextAccessor httpContextAccessor)
{
return new ModuleAdapter
{
Id = ObjectId.GenerateNewId().ToString(),
Name = newModule.Name,
Description = newModule.Description,
Icon = newModule.Icon,
Route = newModule.Route,
Order = newModule.Order,
Application = newModule.Application,
CreatedAt = DateTime.UtcNow,
CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty,
};
}
}
}

39
Core.Cerberos.Domain/Contexts/Onboarding/Mappers/PermissionMapper.cs Normal file
View File

@@ -0,0 +1,39 @@
// ***********************************************************************
// <copyright file="PermissionMapper.cs">
// HEATH
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Microsoft.AspNetCore.Http;
using MongoDB.Bson;
using System.Security.Claims;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Mappers
{
/// <summary>
/// Handles mappings between
/// <see cref="PermissionRequest"/>,
/// and <see cref="PermissionAdapter"/>
/// </summary>
public static class PermissionMapper
{
/// <summary>
/// Maps the permissionRequest to PermissionAdapter.
/// </summary>
/// <param name="newPermission">The Permission to be mapped.</param>
/// <returns>A <see cref="PermissionAdapter"/> representing
/// the asynchronous execution of the service.</returns>
public static PermissionAdapter ToAdapter(this PermissionRequest newPermission, IHttpContextAccessor httpContextAccessor)
{
return new PermissionAdapter
{
Id = ObjectId.GenerateNewId().ToString(),
Name = newPermission.Name,
Description = newPermission.Description,
CreatedAt = DateTime.UtcNow,
CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty,
AccessLevel = newPermission.AccessLevel
};
}
}
}

42
Core.Cerberos.Domain/Contexts/Onboarding/Mappers/RoleMapper.cs Normal file
View File

@@ -0,0 +1,42 @@
// ***********************************************************************
// <copyright file="RoleMapper.cs">
// HEATH
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Microsoft.AspNetCore.Http;
using MongoDB.Bson;
using System.Security.Claims;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Mappers
{
/// <summary>
/// Handles mappings between
/// <see cref="RoleRequest"/>,
/// and <see cref="RoleAdapter"/>
/// </summary>
public static class RoleMapper
{
/// <summary>
/// Maps the RoleRequest to RoleAdapter.
/// </summary>
/// <param name="newRole">The Role to be mapped.</param>
/// <returns>A <see cref="RoleAdapter"/> representing
/// the asynchronous execution of the service.</returns>
public static RoleAdapter ToAdapter(this RoleRequest newRole, IHttpContextAccessor httpContextAccessor)
{
return new RoleAdapter
{
Id = ObjectId.GenerateNewId().ToString(),
Name = newRole.Name,
Description = newRole.Description,
Applications = newRole.Applications,
Modules = newRole.Modules,
Permissions = newRole.Permissions,
CreatedAt = DateTime.UtcNow,
CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty
};
}
}
}

46
Core.Cerberos.Domain/Contexts/Onboarding/Mappers/UserMapper.cs Normal file
View File

@@ -0,0 +1,46 @@
// ***********************************************************************
// <copyright file="UserMapper.cs">
// HEATH
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Microsoft.AspNetCore.Http;
using MongoDB.Bson;
using System.Security.Claims;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Mappers
{
/// <summary>
/// Handles mappings between
/// <see cref="UserRequest"/>,
/// and <see cref="UserAdapter"/>
/// </summary>
public static class UserMapper
{
/// <summary>
/// Maps the UserRequest to UserAdapter.
/// </summary>
/// <param name="newUser">The User to be mapped.</param>
/// <returns>A <see cref="UserAdapter"/> representing
/// the asynchronous execution of the service.</returns>
public static UserAdapter ToAdapter(this UserRequest newUser, IHttpContextAccessor httpContextAccessor)
{
return new UserAdapter
{
Id = ObjectId.GenerateNewId().ToString(),
Guid = Guid.NewGuid().ToString(),
Email = newUser.Email,
Name = newUser.Name,
MiddleName = newUser.MiddleName,
LastName = newUser.LastName,
DisplayName = $"{newUser.Name} {newUser.MiddleName} {newUser.LastName}",
RoleId = newUser.RoleId,
Companies = newUser.Companies,
Projects = newUser.Projects,
CreatedAt = DateTime.UtcNow,
CreatedBy = httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? string.Empty
};
}
}
}

68
Core.Cerberos.Domain/Contexts/Onboarding/Request/ModuleRequest.cs Normal file
View File

@@ -0,0 +1,68 @@
// ***********************************************************************
// <copyright file="ModuleRequest.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters.Common.Enums;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Request
{
/// <summary>
/// Data transfer object (DTO) for adding modules.
/// </summary>
public class ModuleRequest
{
/// <summary>
/// Gets or sets the name of the module.
/// </summary>
[BsonElement("name")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("name")]
public string Name { get; set; } = null!;
/// <summary>
/// Gets or sets the description of the module.
/// </summary>
[BsonElement("description")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("description")]
public string? Description { get; set; }
/// <summary>
/// Gets or sets the icon of the module.
/// </summary>
[BsonElement("icon")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("icon")]
public string? Icon { get; set; }
/// <summary>
/// Gets or sets the route of the module.
/// </summary>
[BsonElement("route")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("route")]
public string Route { get; set; } = null!;
/// <summary>
/// Gets or sets the order of the module.
/// </summary>
[BsonElement("order")]
[BsonRepresentation(BsonType.Int32)]
[JsonPropertyName("order")]
public int? Order { get; set; }
/// <summary>
/// Gets or sets the application of the module.
/// </summary>
[BsonElement("application")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("application")]
[JsonConverter(typeof(JsonStringEnumConverter))]
public ApplicationsEnum? Application { get; set; } = null!;
}
}

44
Core.Cerberos.Domain/Contexts/Onboarding/Request/PermissionRequest.cs Normal file
View File

@@ -0,0 +1,44 @@
// ***********************************************************************
// <copyright file="PermissionRequest.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters.Common.Constants;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Request
{
/// <summary>
/// Data transfer object (DTO) for adding permissions.
/// </summary>
public class PermissionRequest
{
/// <summary>
/// Gets or sets the name of the permission.
/// </summary>
[BsonElement("name")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("name")]
public string Name { get; set; } = null!;
/// <summary>
/// Gets or sets the description of the permission.
/// </summary>
[BsonElement("description")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("description")]
public string? Description { get; set; }
/// <summary>
/// Gets or sets the access level of the permission.
/// </summary>
[BsonElement("accessLevel")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("accessLevel")]
[JsonConverter(typeof(JsonStringEnumConverter))]
public AccessLevelEnum? AccessLevel { get; set; } = null!;
}
}

57
Core.Cerberos.Domain/Contexts/Onboarding/Request/RoleRequest.cs Normal file
View File

@@ -0,0 +1,57 @@
// ***********************************************************************
// <copyright file="RoleRequest.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters.Common.Enums;
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Request
{
/// <summary>
/// Data transfer object (DTO) for adding a role.
/// </summary>
public class RoleRequest
{
/// <summary>
/// Gets or sets the name of the role.
/// </summary>
[BsonElement("name")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("name")]
public string Name { get; set; } = null!;
/// <summary>
/// Gets or sets the description of the role.
/// </summary>
[BsonElement("description")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("description")]
public string? Description { get; set; }
/// <summary>
/// Gets or sets the status of the entity.
/// </summary>
[BsonElement("applications")]
[JsonPropertyName("applications")]
[JsonConverter(typeof(EnumArrayJsonConverter<ApplicationsEnum>))]
public ApplicationsEnum[]? Applications { get; set; }
/// <summary>
/// Gets or sets the modules of the role.
/// </summary>
[BsonElement("modules")]
[JsonPropertyName("modules")]
public string[] Modules { get; set; } = null!;
/// <summary>
/// Gets or sets the permissions of the role.
/// </summary>
[BsonElement("permissions")]
[JsonPropertyName("permissions")]
public string[] Permissions { get; set; } = null!;
}
}

72
Core.Cerberos.Domain/Contexts/Onboarding/Request/UserRequest.cs Normal file
View File

@@ -0,0 +1,72 @@
// ***********************************************************************
// <copyright file="UserAddDto.cs">
// Heath
// </copyright>
// ***********************************************************************
using MongoDB.Bson;
using MongoDB.Bson.Serialization.Attributes;
using System.Text.Json.Serialization;
namespace Core.Cerberos.Domain.Contexts.Onboarding.Request
{
/// <summary>
/// Data transfer object (DTO) for adding a user.
/// </summary>
public class UserRequest
{
/// <summary>
/// Gets or sets the email address of the user.
/// </summary>
[BsonElement("email")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("email")]
public string Email { get; set; } = null!;
/// <summary>
/// Gets or sets the name of the user.
/// </summary>
[BsonElement("name")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("name")]
public string Name { get; set; } = null!;
/// <summary>
/// Gets or sets the middlename of the user.
/// </summary>
[BsonElement("middleName")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("middleName")]
public string MiddleName { get; set; } = null!;
/// <summary>
/// Gets or sets the last name of the user.
/// </summary>
[BsonElement("lastName")]
[BsonRepresentation(BsonType.String)]
[JsonPropertyName("lastName")]
public string LastName { get; set; } = null!;
/// <summary>
/// Gets or sets the role ID of the user.
/// </summary>
[BsonElement("roleId")]
[BsonRepresentation(BsonType.ObjectId)]
[JsonPropertyName("roleId")]
public string RoleId { get; set; } = null!;
/// <summary>
/// Gets or sets the array of companies associated with the user.
/// </summary>
[BsonElement("companies")]
[JsonPropertyName("companies")]
public string[] Companies { get; set; } = null!;
/// <summary>
/// Gets or sets the array of projects associated with the user.
/// </summary>
[BsonElement("projects")]
[JsonPropertyName("projects")]
public string[]? Projects { get; set; }
}
}

13
Core.Cerberos.Domain/Core.Cerberos.Domain.csproj Normal file
View File

@@ -0,0 +1,13 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Core.Cerberos.Adapters" Version="0.3.0-alpha0042" />
</ItemGroup>
</Project>

30
Core.Cerberos.Infraestructure/Caching/CacheHelper.cs Normal file
View File

@@ -0,0 +1,30 @@
using Core.Cerberos.Infraestructure.Caching.Configs;
namespace LSA.Core.Dapper.Service.Caching
{
public static class CacheHelper
{
/// <summary>
/// Determines the cache duration based on specific duration, settings, or a default value.
/// </summary>
/// <param name="specificCacheDuration">Specific cache duration in minutes, if provided.</param>
/// <param name="cacheSettings">General cache settings containing default duration values.</param>
/// <returns>The cache duration as a TimeSpan.</returns>
public static TimeSpan GetCacheDuration(CacheSettings cacheSettings, int? specificCacheDuration = 0)
{
var defaultCacheDuration = TimeSpan.FromMinutes(.5);
if (specificCacheDuration.HasValue && specificCacheDuration.Value > 0)
{
return TimeSpan.FromMinutes(specificCacheDuration.Value);
}
if (cacheSettings.DefaultCacheDurationInMinutes > 0)
{
return TimeSpan.FromMinutes(cacheSettings.DefaultCacheDurationInMinutes);
}
return defaultCacheDuration;
}
}
}

47
Core.Cerberos.Infraestructure/Caching/CacheKeyHelper.cs Normal file
View File

@@ -0,0 +1,47 @@
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
namespace LSA.Core.Dapper.Service.Caching
{
public static class CacheKeyHelper
{
public static string GenerateCacheKey(object instance, string methodName, params object[] parameters)
{
var className = instance.GetType().Name;
var keyBuilder = new StringBuilder($"{className}.{methodName}");
foreach (var param in parameters)
{
string normalizedParam = NormalizeParameter(param);
keyBuilder.Append($".{normalizedParam}");
}
return keyBuilder.ToString();
}
private static string NormalizeParameter(object param)
{
if (param == null)
{
return "null";
}
string paramString;
if (param is DateTime dateTime)
{
paramString = dateTime.ToString("yyyyMMdd");
}
else
{
paramString = param.ToString();
}
// Replace special characters with an underscore
string normalizedParam = Regex.Replace(paramString, @"[^a-zA-Z0-9]", "_");
return normalizedParam;
}
}
}

133
Core.Cerberos.Infraestructure/Caching/CacheService.cs Normal file
View File

@@ -0,0 +1,133 @@
using Azure.Identity;
using Core.Cerberos.Infraestructure.Caching.Contracts;
using Microsoft.Extensions.Logging;
using StackExchange.Redis;
using System.Text.Json;
namespace LSA.Core.Dapper.Service.Caching
{
public class CacheService : ICacheService
{
private IDatabase _cacheDatabase = null!;
private readonly ILogger<CacheService> _logger;
public CacheService(string connectionString, ILogger<CacheService> logger)
{
_logger = logger;
Task.Run(async () =>
{
_cacheDatabase = await GetRedisDatabase(connectionString);
}).Wait();
}
private async Task<IDatabase> GetRedisDatabase(string connectionString)
{
try
{
var configurationOptions = await ConfigurationOptions.Parse($"{connectionString}")
.ConfigureForAzureWithTokenCredentialAsync(new DefaultAzureCredential());
configurationOptions.AbortOnConnectFail = false;
var connectionMultiplexer = await ConnectionMultiplexer.ConnectAsync(configurationOptions);
_logger.LogInformation("Successfully connected to Redis.");
return connectionMultiplexer.GetDatabase();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error establishing Redis connection.");
throw;
}
}
public async Task<T> GetAsync<T>(string key)
{
try
{
var value = await _cacheDatabase.StringGetAsync(key);
if (value.IsNullOrEmpty)
{
_logger.LogInformation($"Cache miss for key: {key}");
return default;
}
_logger.LogInformation($"Cache hit for key: {key}");
return JsonSerializer.Deserialize<T>(value);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error getting cache item with key {key}");
throw;
}
}
public async Task SetAsync<T>(string key, T value, TimeSpan? expiry = null)
{
try
{
var json = JsonSerializer.Serialize(value);
await _cacheDatabase.StringSetAsync(key, json, expiry);
_logger.LogInformation($"Cache item set with key: {key}");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error setting cache item with key {key}");
throw;
}
}
public async Task RemoveAsync(string key)
{
try
{
await _cacheDatabase.KeyDeleteAsync(key);
_logger.LogInformation($"Cache item removed with key: {key}");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error removing cache item with key {key}");
throw;
}
}
public async Task<bool> ExistsAsync(string key)
{
try
{
var exists = await _cacheDatabase.KeyExistsAsync(key);
_logger.LogInformation($"Cache item exists check for key: {key} - {exists}");
return exists;
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error checking existence of cache item with key {key}");
throw;
}
}
public async Task RefreshAsync(string key, TimeSpan? expiry = null)
{
try
{
var value = await _cacheDatabase.StringGetAsync(key);
if (!value.IsNullOrEmpty)
{
await _cacheDatabase.StringSetAsync(key, value, expiry);
_logger.LogInformation($"Cache item refreshed with key: {key}");
}
else
{
_logger.LogWarning($"Cache item with key: {key} does not exist, cannot refresh");
}
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error refreshing cache item with key {key}");
throw;
}
}
}
}

7
Core.Cerberos.Infraestructure/Caching/Configs/CacheSettings.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Core.Cerberos.Infraestructure.Caching.Configs
{
public class CacheSettings
{
public int DefaultCacheDurationInMinutes { get; set; }
}
}

11
Core.Cerberos.Infraestructure/Caching/Contracts/ICacheService.cs Normal file
View File

@@ -0,0 +1,11 @@
namespace Core.Cerberos.Infraestructure.Caching.Contracts
{
public interface ICacheService
{
Task<T> GetAsync<T>(string key);
Task SetAsync<T>(string key, T value, TimeSpan? expiry = null);
Task RemoveAsync(string key);
Task<bool> ExistsAsync(string key);
Task RefreshAsync(string key, TimeSpan? expiry = null);
}
}

33
Core.Cerberos.Infraestructure/Contexts/Mongo/ConnectionStringProvider.cs Normal file
View File

@@ -0,0 +1,33 @@
using Microsoft.Extensions.Configuration;
namespace Core.Cerberos.Infraestructure.Contexts.Mongo
{
public class ConnectionStringProvider(IConfiguration configuration) : IConnectionStringProvider
{
public string ConnectionString { get; set; } = string.Empty;
public string Databasename { get; set; } = string.Empty;
public string Audience { get; set; } = string.Empty;
public string GetConnectionString()
{
return configuration?.GetConnectionString("DefaultConnection")?.ToString() ?? string.Empty;
}
public string GetDatabasename()
{
return configuration.GetSection("MongoDb:DatabaseName").Value ?? string.Empty;
}
public string GetAudience()
{
return configuration.GetSection("MongoDb:Audience").Value ?? string.Empty;
}
}
public interface IConnectionStringProvider
{
string GetConnectionString();
string GetDatabasename();
string ConnectionString { get; set; }
string Databasename { get; set; }
string Audience { get; set; }
}
}

14
Core.Cerberos.Infraestructure/Contexts/Mongo/MongoConnSettings.cs Normal file
View File

@@ -0,0 +1,14 @@
namespace Core.Cerberos.Infraestructure.Contexts.Mongo;
public interface IMongoConnSettings
{
string ConnectionString { get; set; }
string Databasename { get; set; }
string Audience { get; set; }
}
public class MongoConnSettings : IMongoConnSettings
{
public string ConnectionString { get; set; }
public string Databasename { get; set; }
public string Audience { get; set; }
}

17
Core.Cerberos.Infraestructure/Core.Cerberos.Infrastructure.csproj Normal file
View File

@@ -0,0 +1,17 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Core.Cerberos.Adapters" Version="0.3.0-alpha0042" />
<PackageReference Include="Microsoft.Azure.StackExchangeRedis" Version="3.1.0" />
<PackageReference Include="Microsoft.Extensions.Caching.Abstractions" Version="8.0.0" />
<PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" Version="8.0.0" />
<PackageReference Include="StackExchange.Redis" Version="2.8.16" />
</ItemGroup>
</Project>

15
Core.Cerberos.Infraestructure/PerformanceCacheService/CacheAttribute.cs Normal file
View File

@@ -0,0 +1,15 @@
namespace Core.Cerberos.Infraestructure.PerformanceCacheService
{
[AttributeUsage(AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
public class CacheAttribute : Attribute
{
public int CacheDurationInMinutes { get; set; }
public bool EnableCaching { get; set; }
public CacheAttribute(int cacheDurationInMinutes, bool enableCaching = true)
{
CacheDurationInMinutes = cacheDurationInMinutes;
EnableCaching = enableCaching;
}
}
}

64
Core.Cerberos.Provider/Contracts/IModuleService.cs Normal file
View File

@@ -0,0 +1,64 @@
// ***********************************************************************
// <copyright file="IModuleService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
namespace Core.Cerberos.Provider.Contracts
{
public interface IModuleService
{
/// <summary>
/// Creates a new Module.
/// </summary>
/// <param name="entity">The Module to be created.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<ModuleAdapter> CreateModuleService(ModuleRequest newModule);
/// <summary>
/// Gets an Module by identifier.
/// </summary>
/// <param name="id">The Module identifier.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<ModuleAdapter> GetModuleByIdService(string id);
/// <summary>
/// Gets all the roles.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<IEnumerable<ModuleAdapter>> GetAllModulesService();
/// <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{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<IEnumerable<ModuleAdapter>> GetAllModulesByListService(string[] permissions);
/// <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>The <see cref="ModuleAdapter"/> updated entity.</returns>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<ModuleAdapter> ChangeModuleStatusService(string id, StatusEnum newStatus);
/// <summary>
/// Updates a Module by id.
/// </summary>
/// <param name="entity">The Module to be updated.</param>
/// <param name="id">The Module identifier.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<ModuleAdapter> UpdateModuleService(ModuleAdapter entity, string id);
}
}

64
Core.Cerberos.Provider/Contracts/IPermissionService.cs Normal file
View File

@@ -0,0 +1,64 @@
// ***********************************************************************
// <copyright file="IPermissionService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
namespace Core.Cerberos.Provider.Contracts
{
public interface IPermissionService
{
/// <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>
Task<PermissionAdapter> CreatePermissionService(PermissionRequest newPermission);
/// <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>
Task<PermissionAdapter> GetPermissionByIdService(string id);
/// <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();
/// <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>
Task<IEnumerable<PermissionAdapter>> GetAllPermissionsByListService(string[] permissions);
/// <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>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);
/// <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>
Task<PermissionAdapter> UpdatePermissionService(PermissionAdapter entity, string id);
}
}

72
Core.Cerberos.Provider/Contracts/IRoleService.cs Normal file
View File

@@ -0,0 +1,72 @@
// ***********************************************************************
// <copyright file="IRoleService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
namespace Core.Cerberos.Provider.Contracts
{
public interface IRoleService
{
/// <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>
Task<RoleAdapter> CreateRoleService(RoleRequest newRole);
/// <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>
Task<RoleAdapter> GetRoleByIdService(string id);
/// <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();
/// <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>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);
/// <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>
Task<RoleAdapter> UpdateRoleService(RoleAdapter entity, string id);
/// <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>
Task<RoleAdapter> AddApplicationToRoleService(string roleId, ApplicationsEnum application);
/// <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>
Task<RoleAdapter> RemoveApplicationFromRoleService(string roleId, ApplicationsEnum application);
}
}

143
Core.Cerberos.Provider/Contracts/IUserService.cs Normal file
View File

@@ -0,0 +1,143 @@
// ***********************************************************************
// <copyright file="IUserService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Blueprint.Storage.Adapters;
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
namespace Core.Cerberos.Provider.Contracts
{
public interface IUserService
{
/// <summary>
/// Creates a new User.
/// </summary>
/// <param name="entity">The User to be created.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> CreateUserService(UserRequest newUser);
/// <summary>
/// Gets an User by identifier.
/// </summary>
/// <param name="id">The User identifier.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> GetUserByIdService(string id);
/// <summary>
/// Gets all the users.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerable{UserAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<IEnumerable<UserAdapter>> GetAllUsersService();
/// <summary>
/// Gets an User by email.
/// </summary>
/// <param name="email">The User email.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> GetUserByEmailService(string? email);
/// <summary>
/// Validates if a users exists by email.
/// </summary>
/// <param name="eamil">The User email.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> ValidateUserExistenceService(string? email);
/// <summary>
/// Changes the status of the user.
/// </summary>
/// <param name="id">The user identifier.</param>
/// <param name="newStatus">The new status of the user.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> ChangeUserStatusService(string id, StatusEnum newStatus);
/// <summary>
/// Updates a User by id.
/// </summary>
/// <param name="entity">The User to be updated.</param>
/// <param name="id">The User identifier.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> UpdateUserService(UserAdapter entity, string id);
/// <summary>
/// Logs in the user.
/// </summary>
/// <param name="email">The User's email.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter?> LogInUserService(string email);
/// <summary>
/// Logs out the user's session.
/// </summary>
/// <param name="email">The User's email.</param>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter> LogOutUserSessionService(string email);
/// <summary>
/// Adds a company to the user's list of companies.
/// </summary>
/// <param name="userId">The identifier of the user to whom the company will be added.</param>
/// <param name="companyId">The identifier of the company to add.</param>
/// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
Task<UserAdapter> AddCompanyToUserService(string userId, string companyId);
/// <summary>
/// Removes a company from the user's list of companies.
/// </summary>
/// <param name="userId">The identifier of the user from whom the company will be removed.</param>
/// <param name="companyId">The identifier of the company to remove.</param>
/// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
Task<UserAdapter> RemoveCompanyFromUserService(string userId, string companyId);
/// <summary>
/// Adds a project to the user's list of projects.
/// </summary>
/// <param name="userId">The identifier of the user to whom the project will be added.</param>
/// <param name="projectId">The identifier of the project to add.</param>
/// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
Task<UserAdapter> AddProjectToUserService(string userId, string projectId);
/// <summary>
/// Removes a project from the user's list of projects.
/// </summary>
/// <param name="userId">The identifier of the user from whom the project will be removed.</param>
/// <param name="projectId">The identifier of the project to remove.</param>
/// <returns>A <see cref="Task{UserAdapter}"/> representing the asynchronous operation, with the updated user object.</returns>
Task<UserAdapter> RemoveProjectFromUserService(string userId, string projectId);
/// <summary>
/// Gets the token adapter for a user.
/// </summary>
/// <param name="email">The user's email.</param>
/// <returns>A <see cref="{Task{TokenAdapter}}"/> representing the asynchronous execution of the service.</returns>
Task<TokenAdapter?> GetTokenAdapter(string email);
/// <summary>
/// Get Consent Form PDF.
/// </summary>
/// <returns>A <see cref="{Task{BlobDownloadUriAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<BlobDownloadUriAdapter> GetConsentFormPDFService();
/// <summary>
/// Accept user consent form.
/// </summary>
/// <returns>A <see cref="{Task{UserAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
Task<UserAdapter?> AcceptUserConsentFormService();
}
}

25
Core.Cerberos.Provider/Core.Cerberos.Provider.csproj Normal file
View File

@@ -0,0 +1,25 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<Compile Remove="Providers\Onboarding\UserService - Copy.cs" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="Core.Blueprint.Storage" Version="0.3.0-alpha0049" />
<PackageReference Include="Core.Cerberos.Adapters" Version="0.3.0-alpha0042" />
<PackageReference Include="Microsoft.AspNetCore.Http.Abstractions" Version="2.2.0" />
<PackageReference Include="MongoDB.Driver" Version="3.0.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Core.Cerberos.Domain\Core.Cerberos.Domain.csproj" />
<ProjectReference Include="..\Core.Cerberos.Infraestructure\Core.Cerberos.Infrastructure.csproj" />
</ItemGroup>
</Project>

16
Core.Cerberos.Provider/Providers/BaseProvider.cs Normal file
View File

@@ -0,0 +1,16 @@
using MongoDB.Driver;
namespace Core.Cerberos.Provider.Providers
{
public class BaseProvider
{
private readonly IMongoDatabase _database;
public BaseProvider(IMongoDatabase database)
{
_database = database ?? throw new ArgumentNullException(nameof(database));
}
protected IMongoDatabase Database => _database;
}
}

99
Core.Cerberos.Provider/Providers/HeathOidcCallback.cs Normal file
View File

@@ -0,0 +1,99 @@
using Azure.Core;
using Azure.Identity;
using Core.Cerberos.Adapters.Common.Constants;
using MongoDB.Driver.Authentication.Oidc;
namespace Core.Cerberos.Provider.Providers
{
public class HeathOidcCallback : IOidcCallback
{
private readonly string _audience;
private readonly string _environment;
public HeathOidcCallback(string audience)
{
_audience = audience;
_environment = Environment.GetEnvironmentVariable(EnvironmentVariables.Stage) ?? string.Empty;
}
public OidcAccessToken GetOidcAccessToken(OidcCallbackParameters parameters, CancellationToken cancellationToken)
{
try
{
AccessToken token;
TokenRequestContext tokenRequestContext =
new TokenRequestContext(
new[] { _audience }
);
if (_environment == "Local")
{
token =
new ChainedTokenCredential(
new ManagedIdentityCredential(),
new VisualStudioCredential(),
new VisualStudioCodeCredential(),
new SharedTokenCacheCredential()
)
.GetToken(
tokenRequestContext
);
}
else
{
token =
new ManagedIdentityCredential()
.GetToken(
tokenRequestContext
);
}
return new(token.Token, expiresIn: null);
}
catch (Exception ex)
{
throw new Exception($"An error ocurred while trying to get the OIDC token to connect to the database, ERROR: {ex.Message}");
}
}
public async Task<OidcAccessToken> GetOidcAccessTokenAsync(OidcCallbackParameters parameters, CancellationToken cancellationToken)
{
try
{
TokenRequestContext tokenRequestContext =
new TokenRequestContext(
new[] { _audience }
);
AccessToken token;
if (_environment == "Local")
{
token = await new ChainedTokenCredential(
new ManagedIdentityCredential(),
new VisualStudioCredential(),
new VisualStudioCodeCredential(),
new SharedTokenCacheCredential()
)
.GetTokenAsync(
tokenRequestContext, cancellationToken
).ConfigureAwait(false);
}
else
{
token = await new ManagedIdentityCredential()
.GetTokenAsync(
tokenRequestContext, cancellationToken
).ConfigureAwait(false);
}
return new(token.Token, expiresIn: null);
}
catch (Exception ex)
{
throw new Exception($"An error ocurred while trying to get the OIDC token to connect to the database, ERROR: {ex.Message}");
}
}
}
}

27
Core.Cerberos.Provider/Providers/Helper.cs Normal file
View File

@@ -0,0 +1,27 @@
// ***********************************************************************
// <copyright file="Helper.cs">
// Heath
// </copyright>
// ***********************************************************************
using Microsoft.AspNetCore.Http;
using System.Security.Claims;
namespace Core.Cerberos.Provider.Providers
{
/// <summary>
/// Provides helper methods for common operations.
/// </summary>
public static class Helper
{
/// <summary>
/// Retrieves the email address of the authenticated user from the HTTP context.
/// </summary>
/// <param name="httpContextAccessor">The IHttpContextAccessor instance to access the current HTTP context.</param>
/// <returns>The email address of the authenticated user, or an empty string if not available.</returns>
public static string GetEmail(IHttpContextAccessor httpContextAccessor)
{
return httpContextAccessor.HttpContext?.User?.FindFirst(ClaimTypes.Email)?.Value ?? "";
}
}
}

256
Core.Cerberos.Provider/Providers/Onboarding/ModuleService.cs Normal file
View File

@@ -0,0 +1,256 @@
// ***********************************************************************
// <copyright file="ModuleService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Mappers;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Core.Cerberos.Infraestructure.Caching.Configs;
using Core.Cerberos.Infraestructure.Caching.Contracts;
using Core.Cerberos.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.Cerberos.Provider.Providers.Onboarding
{
/// <summary>
/// Handles all services and business rules related to <see cref="ModuleAdapter"/>.
/// </summary>
public class ModuleService(ILogger<ModuleService> logger, IHttpContextAccessor httpContextAccessor, ICacheService cacheService,
IOptions<CacheSettings> cacheSettings, IMongoDatabase database) : IModuleService
{
private readonly CacheSettings _cacheSettings = cacheSettings.Value;
/// <summary>
/// Creates a new Module.
/// </summary>
/// <param name="entity">The Module to be created.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<ModuleAdapter> CreateModuleService(ModuleRequest newModule)
{
try
{
var entity = newModule.ToAdapter(httpContextAccessor);
entity.Order = (entity.Order is not null) ? entity.Order : await GetLastOrderModule(newModule);
await database.GetCollection<ModuleAdapter>(CollectionNames.Module).InsertOneAsync(entity);
entity.Id = (entity as dynamic ?? "").Id.ToString();
return entity;
}
catch (Exception ex)
{
logger.LogError(ex, $"CreateModuleService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets an Module by identifier.
/// </summary>
/// <param name="id">The Module identifier.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>0
public async Task<ModuleAdapter> GetModuleByIdService(string id)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetModuleByIdService", id);
var cachedData = await cacheService.GetAsync<ModuleAdapter>(cacheKey);
if (cachedData is not null) { return cachedData; }
try
{
var filter = Builders<ModuleAdapter>.Filter.And(
Builders<ModuleAdapter>.Filter.Eq("_id", ObjectId.Parse(id)),
Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString())
);
var module = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
.Find(filter)
.FirstOrDefaultAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, module, cacheDuration);
return module;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetModuleByIdService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets all the modules.
/// </summary>
/// <returns>A <see cref="{Task{IEnumerbale{ModuleAdapter}}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<IEnumerable<ModuleAdapter>> GetAllModulesService()
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllModulesService");
var cachedData = await cacheService.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey) ?? [];
if (cachedData.Any()) return cachedData;
try
{
var filter = Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
var roles = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
.Find(filter)
.SortBy(m => m.Application)
.ThenBy(m => m.Order)
.ToListAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, roles, cacheDuration);
return roles;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetAllModulesService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Gets all the modules by modules identifier list.
/// </summary>
/// <param name="modules">The list of modules identifiers.</param>
/// <returns>A <see cref="Task{IEnumerable{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<IEnumerable<ModuleAdapter>> GetAllModulesByListService(string[] modules)
{
var cacheKey = CacheKeyHelper.GenerateCacheKey(this, "GetAllModulesByListService", modules);
var cachedData = await cacheService.GetAsync<IEnumerable<ModuleAdapter>>(cacheKey);
if (cachedData != null && cachedData.Any()) return cachedData;
try
{
var objectIds = modules.Select(id => ObjectId.Parse(id)).ToArray();
var filter = Builders<ModuleAdapter>.Filter.In("_id", objectIds)
& Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString());
var roles = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
.Find(filter)
.SortBy(m => m.Application)
.ThenBy(m => m.Order)
.ToListAsync();
var cacheDuration = CacheHelper.GetCacheDuration(_cacheSettings);
await cacheService.SetAsync(cacheKey, roles, cacheDuration);
return roles;
}
catch (Exception ex)
{
logger.LogError(ex, $"GetAllModulesByListService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Changes the status of the module.
/// </summary>
/// <param name="id">The module identifier.</param>
/// <param name="newStatus">The new status of the module.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<ModuleAdapter> ChangeModuleStatusService(string id, StatusEnum newStatus)
{
try
{
var filter = Builders<ModuleAdapter>.Filter
.Eq("_id", ObjectId.Parse(id));
var update = Builders<ModuleAdapter>.Update
.Set(v => v.Status, newStatus)
.Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
.Set(v => v.UpdatedAt, DateTime.UtcNow);
await database.GetCollection<ModuleAdapter>(CollectionNames.Module).UpdateOneAsync(filter, update);
var updatedModule = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
.Find(filter)
.FirstOrDefaultAsync();
return updatedModule;
}
catch (Exception ex)
{
logger.LogError(ex, $"ChangeModuleStatusService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
/// <summary>
/// Updates a Module by id.
/// </summary>
/// <param name="entity">The Module to be updated.</param>
/// <param name="id">The Module identifier.</param>
/// <returns>A <see cref="{Task{ModuleAdapter}}"/> representing
/// the asynchronous execution of the service.</returns>
public async Task<ModuleAdapter> UpdateModuleService(ModuleAdapter entity, string id)
{
try
{
var filter = Builders<ModuleAdapter>.Filter
.Eq("_id", ObjectId.Parse(id));
var update = Builders<ModuleAdapter>.Update
.Set(v => v.Name, entity.Name)
.Set(v => v.Description, entity.Description)
.Set(v => v.Icon, entity.Icon)
.Set(v => v.Route, entity.Route)
.Set(v => v.Order, entity.Order)
.Set(v => v.Application, entity.Application)
.Set(v => v.Status, entity.Status)
.Set(v => v.UpdatedBy, Helper.GetEmail(httpContextAccessor))
.Set(v => v.UpdatedAt, DateTime.UtcNow);
await database.GetCollection<ModuleAdapter>(CollectionNames.Module).UpdateOneAsync(filter, update);
var updatedModule = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
.Find(filter)
.FirstOrDefaultAsync();
return updatedModule;
}
catch (Exception ex)
{
logger.LogError(ex, $"UpdateModuleService: Error in getting data - {ex.Message}");
throw new Exception(ex.Message, ex);
}
}
private async Task<int?> GetLastOrderModule(ModuleRequest newModule)
{
var filter = Builders<ModuleAdapter>.Filter.And(
Builders<ModuleAdapter>.Filter.Eq("status", StatusEnum.Active.ToString()),
Builders<ModuleAdapter>.Filter.Eq("application", newModule.Application.ToString()));
var maxOrderModule = await database.GetCollection<ModuleAdapter>(CollectionNames.Module)
.Find(filter)
.SortByDescending(m => m.Order)
.FirstOrDefaultAsync();
return (maxOrderModule is not null && maxOrderModule.Order is not null) ? maxOrderModule.Order : 0;
}
}
}

234
Core.Cerberos.Provider/Providers/Onboarding/PermissionService.cs Normal file
View File

@@ -0,0 +1,234 @@
// ***********************************************************************
// <copyright file="PermissionService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Mappers;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Core.Cerberos.Infraestructure.Caching.Configs;
using Core.Cerberos.Infraestructure.Caching.Contracts;
using Core.Cerberos.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.Cerberos.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);
}
}
}
}

251
Core.Cerberos.Provider/Providers/Onboarding/RoleService.cs Normal file
View File

@@ -0,0 +1,251 @@
// ***********************************************************************
// <copyright file="RoleService.cs">
// Heath
// </copyright>
// ***********************************************************************
using Core.Cerberos.Adapters;
using Core.Cerberos.Adapters.Common.Constants;
using Core.Cerberos.Adapters.Common.Enums;
using Core.Cerberos.Domain.Contexts.Onboarding.Mappers;
using Core.Cerberos.Domain.Contexts.Onboarding.Request;
using Core.Cerberos.Infraestructure.Caching.Configs;
using Core.Cerberos.Infraestructure.Caching.Contracts;
using Core.Cerberos.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.Cerberos.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);
}
}
}
}

104
Core.Cerberos.Provider/ServiceCollectionExtensions.cs Normal file
View File

@@ -0,0 +1,104 @@
using Core.Blueprint.Storage.Configuration;
using Core.Cerberos.Infraestructure.Caching.Contracts;
using Core.Cerberos.Infraestructure.Contexts.Mongo;
using Core.Cerberos.Provider.Contracts;
using Core.Cerberos.Provider.Providers;
using Core.Cerberos.Provider.Providers.Onboarding;
using LSA.Core.Dapper.Service.Caching;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using MongoDB.Driver;
namespace Core.Cerberos.Provider
{
public static class ServiceCollectionExtensions
{
public static IServiceCollection AddDALLayer(this IServiceCollection services, IConfiguration configuration)
{
var environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT") ?? string.Empty;
var connectionString = configuration.GetSection("ConnectionStrings:MongoDB").Value ?? string.Empty;
var databaseName = configuration.GetSection("MongoDB:DatabaseName").Value ?? string.Empty;
var audience = (environment == "Local")
? configuration.GetSection("MongoDB:LocalAudience").Value
: configuration.GetSection("MongoDB:Audience").Value;
if (string.IsNullOrEmpty(connectionString) || string.IsNullOrEmpty(databaseName) || string.IsNullOrEmpty(audience))
{
throw new InvalidOperationException("Mongo connection is not configured correctly.");
}
services.Configure<MongoConnSettings>(options =>
{
options.ConnectionString = connectionString;
options.Databasename = databaseName;
options.Audience = audience ?? string.Empty;
});
services.AddSingleton<IMongoClient>(serviceProvider =>
{
var settings = serviceProvider.GetRequiredService<IOptions<MongoConnSettings>>().Value;
var mongoClientSettings = MongoClientSettings.FromConnectionString(settings.ConnectionString);
mongoClientSettings.Credential = MongoCredential.CreateOidcCredential(new HeathOidcCallback(settings.Audience));
return new MongoClient(mongoClientSettings);
});
services.AddSingleton<IMongoDatabase>(serviceProvider =>
{
var settings = serviceProvider.GetRequiredService<IOptions<MongoConnSettings>>().Value;
var client = serviceProvider.GetRequiredService<IMongoClient>();
return client.GetDatabase(settings.Databasename);
});
services.AddDALConfigurationLayer();
services.AddLogs();
services.AddRedisCacheService(configuration);
services.AddBlobStorage(configuration);
return services;
}
private static IServiceCollection AddDALConfigurationLayer(this IServiceCollection services)
{
services.AddHttpContextAccessor();
services.AddScoped<IUserService, UserService>();
services.AddScoped<IRoleService, RoleService>();
services.AddScoped<IPermissionService, PermissionService>();
services.AddScoped<IPermissionService, PermissionService>();
services.AddScoped<IModuleService, ModuleService>();
return services;
}
private static IServiceCollection AddLogs(this IServiceCollection services)
{
services.AddLogging();
var serviceProvider = services.BuildServiceProvider();
//var logger = serviceProvider.GetService<ILogger<DashboardDALService>>(); //Add for Markup class later TODO
//services.AddSingleton(typeof(ILogger), logger);
return services;
}
private static IServiceCollection AddRedisCacheService(this IServiceCollection services, IConfiguration configuration)
{
var source = configuration.GetSection("ConnectionStrings");
var redisConnectionString = source["Redis"]?.ToString();
if (string.IsNullOrEmpty(redisConnectionString))
{
throw new InvalidOperationException("Redis connection string is not configured.");
}
services.AddSingleton<ICacheService>(provider =>
new CacheService(redisConnectionString, provider.GetRequiredService<ILogger<CacheService>>()));
return services;
}
}
}

1
README.md Normal file
View File

@@ -0,0 +1 @@
SharedApplications