admin/marco.pms.api
1
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

ProjectDetails_Split_API #103

Merged
admin merged 47 commits from ProjectDetails_Split_API into main 2025-07-11 11:32:34 +00:00
Conversation 0 Commits 47 Files Changed 33 +143 -27
1 changed files with 143 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 8521a68c3e - Show all commits

170
Marco.Pms.Services/Helpers/CacheUpdateHelper.cs
View File

@ -1,6 +1,7 @@
using Marco.Pms.CacheHelper;
using Marco.Pms.Model.MongoDBModels;
using Marco.Pms.Model.Projects;
using MarcoBMS.Services.Service;
using Project = Marco.Pms.Model.Projects.Project;
namespace Marco.Pms.Services.Helpers
@ -9,90 +10,205 @@ namespace Marco.Pms.Services.Helpers
{
private readonly ProjectCache _projectCache;
private readonly EmployeeCache _employeeCache;
private readonly ILoggingService _logger;
public CacheUpdateHelper(ProjectCache projectCache, EmployeeCache employeeCache)
public CacheUpdateHelper(ProjectCache projectCache, EmployeeCache employeeCache, ILoggingService logger)
{
_projectCache = projectCache;
_employeeCache = employeeCache;
_logger = logger;
}
// ------------------------------------ Project Details and Infrastructure Cache ---------------------------------------
public async Task AddProjectDetails(Project project)
{
await _projectCache.AddProjectDetailsToCache(project);
try
{
await _projectCache.AddProjectDetailsToCache(project);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding project to Cache: {Error}", ex.Message);
}
}
public async Task<bool> UpdateProjectDetailsOnly(Project project)
{
bool response = await _projectCache.UpdateProjectDetailsOnlyToCache(project);
return response;
try
{
bool response = await _projectCache.UpdateProjectDetailsOnlyToCache(project);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while updating project to Cache: {Error}", ex.Message);
return false;
}
}
public async Task<ProjectMongoDB?> GetProjectDetails(Guid projectId)
{
var response = await _projectCache.GetProjectDetailsFromCache(projectId);
return response;
try
{
var response = await _projectCache.GetProjectDetailsFromCache(projectId);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting project to Cache: {Error}", ex.Message);
return null;
}
}
//public async Task<List<ProjectMongoDB>?> GetProjectDetailsList(List<Guid> projectIds)
//{
// var response = await _projectCache.GetProjectDetailsListFromCache(projectIds);
// return response;
//}
public async Task AddBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
try
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding project infra to Cache: {Error}", ex.Message);
}
}
public async Task UpdateBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
{
var response = await _projectCache.UpdateBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
if (!response)
try
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
var response = await _projectCache.UpdateBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
if (!response)
{
await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
}
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while updating project infra to Cache: {Error}", ex.Message);
}
}
public async Task<List<BuildingMongoDB>?> GetBuildingInfra(Guid projectId)
{
var response = await _projectCache.GetBuildingInfraFromCache(projectId);
return response;
try
{
var response = await _projectCache.GetBuildingInfraFromCache(projectId);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting project infra Cache: {Error}", ex.Message);
return null;
}
}
// ------------------------------------ Employee Profile Cache ---------------------------------------
public async Task AddApplicationRole(Guid employeeId, List<Guid> roleIds)
{
var response = await _employeeCache.AddApplicationRoleToCache(employeeId, roleIds);
try
{
var response = await _employeeCache.AddApplicationRoleToCache(employeeId, roleIds);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding Application roleIds to Cache to employee {Employee}: {Error}", employeeId, ex.Message);
}
}
public async Task<bool> AddProjects(Guid employeeId, List<Guid> projectIds)
{
var response = await _employeeCache.AddProjectsToCache(employeeId, projectIds);
return response;
try
{
var response = await _employeeCache.AddProjectsToCache(employeeId, projectIds);
return response;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while adding projectIds to Cache: {Error}", ex.Message);
return false;
}
}
public async Task<List<Guid>?> GetProjects(Guid employeeId)
{
var response = await _employeeCache.GetProjectsFromCache(employeeId);
if (response.Count > 0)
try
{
return response;
var response = await _employeeCache.GetProjectsFromCache(employeeId);
if (response.Count > 0)
{
return response;
}
return null;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting projectIDs to Cache: {Error}", ex.Message);
return null;
}
return null;
}
public async Task<List<Guid>?> GetPermissions(Guid employeeId)
{
var response = await _employeeCache.GetPermissionsFromCache(employeeId);
if (response.Count > 0)
try
{
return response;
var response = await _employeeCache.GetPermissionsFromCache(employeeId);
if (response.Count > 0)
{
return response;
}
return null;
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while getting permissionIds to Cache: {Error}", ex.Message);
return null;
}
return null;
}
public async Task ClearAllProjectIds(Guid employeeId)
{
var response = await _employeeCache.ClearAllProjectIdsFromCache(employeeId);
try
{
var response = await _employeeCache.ClearAllProjectIdsFromCache(employeeId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting projectIds from Cache for employee {EmployeeId}: {Error}", employeeId, ex.Message);
}
}
//public async Task ClearAllProjectIdsByRoleId(Guid roleId)
//{
// await _employeeCache.ClearAllProjectIdsByRoleIdFromCache(roleId);
//}
public async Task ClearAllPermissionIdsByEmployeeID(Guid employeeId)
{
var response = await _employeeCache.ClearAllPermissionIdsByEmployeeIDFromCache(employeeId);
try
{
var response = await _employeeCache.ClearAllPermissionIdsByEmployeeIDFromCache(employeeId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting permissionIds from to Cache: {Error}", ex.Message);
}
}
public async Task ClearAllPermissionIdsByRoleId(Guid roleId)
{
var response = await _employeeCache.ClearAllPermissionIdsByRoleIdFromCache(roleId);
try
{
var response = await _employeeCache.ClearAllPermissionIdsByRoleIdFromCache(roleId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting permissionIds from to Cache: {Error}", ex.Message);
}
}
public async Task RemoveRoleId(Guid employeeId, Guid roleId)
{
var response = await _employeeCache.RemoveRoleIdFromCache(employeeId, roleId);
try
{
var response = await _employeeCache.RemoveRoleIdFromCache(employeeId, roleId);
}
catch (Exception ex)
{
_logger.LogWarning("Error occured while deleting Application roleIds from to Cache: {Error}", ex.Message);
}
}
}
}