marco.pms.api/Marco.Pms.Services/Helpers/CacheUpdateHelper.cs

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
{
    public class CacheUpdateHelper
    {
        private readonly ProjectCache _projectCache;
        private readonly EmployeeCache _employeeCache;
        private readonly ILoggingService _logger;

        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)
        {
            try
            {
                await _projectCache.AddProjectDetailsToCache(project);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while adding project {ProjectId} to Cache : {Error}", project.Id, ex.Message);
            }
        }
        public async Task<bool> UpdateProjectDetailsOnly(Project project)
        {
            try
            {
                bool response = await _projectCache.UpdateProjectDetailsOnlyToCache(project);
                return response;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while updating project {ProjectId} to Cache: {Error}", project.Id, ex.Message);
                return false;
            }
        }
        public async Task<ProjectMongoDB?> GetProjectDetails(Guid projectId)
        {
            try
            {
                var response = await _projectCache.GetProjectDetailsFromCache(projectId);
                return response;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while getting project {ProjectId} to Cache: {Error}", ex.Message);
                return null;
            }
        }
        public async Task<List<ProjectMongoDB>?> GetProjectDetailsList(List<Guid> projectIds)
        {
            try
            {
                var response = await _projectCache.GetProjectDetailsListFromCache(projectIds);
                return response;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while getting list od project details from to Cache: {Error}", ex.Message);
                return null;
            }
        }
        public async Task AddBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
        {
            try
            {
                await _projectCache.AddBuildngInfraToCache(projectId, building, floor, workArea, buildingId);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while adding project infra for project {ProjectId} to Cache: {Error}", projectId, ex.Message);
            }
        }
        public async Task UpdateBuildngInfra(Guid projectId, Building? building = null, Floor? floor = null, WorkArea? workArea = null, Guid? buildingId = null)
        {
            try
            {
                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 for project {ProjectId} to Cache: {Error}", projectId, ex.Message);
            }
        }
        public async Task<List<BuildingMongoDB>?> GetBuildingInfra(Guid projectId)
        {
            try
            {
                var response = await _projectCache.GetBuildingInfraFromCache(projectId);
                return response;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while getting project infra for project {ProjectId} form Cache: {Error}", projectId, ex.Message);
                return null;
            }
        }
        public async Task UpdatePlannedAndCompleteWorksInBuilding(Guid workAreaId, double plannedWork = 0, double completedWork = 0)
        {
            try
            {
                await _projectCache.UpdatePlannedAndCompleteWorksInBuildingFromCache(workAreaId, plannedWork, completedWork);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while updating planned work and completed work in building infra form Cache: {Error}", ex.Message);
            }
        }
        public async Task<WorkAreaInfoMongoDB?> GetBuildingAndFloorByWorkAreaId(Guid workAreaId)
        {
            try
            {
                var response = await _projectCache.GetBuildingAndFloorByWorkAreaIdFromCache(workAreaId);
                return response;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while fetching workArea Details using its ID form Cache: {Error}", ex.Message);
                return null;
            }
        }
        public async Task<List<WorkItemMongoDB>?> GetWorkItemsByWorkAreaIds(List<Guid> workAreaIds)
        {
            try
            {
                var response = await _projectCache.GetWorkItemsByWorkAreaIdsFromCache(workAreaIds);
                if (response.Count > 0)
                {
                    return response;
                }
                return null;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while fetching workItems list using workArea IDs list form Cache: {Error}", ex.Message);
                return null;
            }
        }

        // ------------------------------------------------------- WorkItem -------------------------------------------------------

        public async Task ManageWorkItemDetails(List<WorkItem> workItems)
        {
            try
            {
                await _projectCache.ManageWorkItemDetailsToCache(workItems);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while saving workItems form Cache: {Error}", ex.Message);
            }
        }
        public async Task<List<WorkItemMongoDB>?> GetWorkItemDetailsByWorkArea(Guid workAreaId)
        {
            try
            {
                var workItems = await _projectCache.GetWorkItemDetailsByWorkAreaFromCache(workAreaId);
                if (workItems.Count > 0)
                {
                    return workItems;
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while fetching list of workItems form Cache: {Error}", ex.Message);
                return null;
            }
        }
        public async Task<WorkItemMongoDB?> GetWorkItemDetailsById(Guid id)
        {
            try
            {
                var workItem = await _projectCache.GetWorkItemDetailsByIdFromCache(id);
                if (workItem.Id != "")
                {
                    return workItem;
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while fetching list of workItems form Cache: {Error}", ex.Message);
                return null;
            }
        }
        public async Task UpdatePlannedAndCompleteWorksInWorkItem(Guid id, double plannedWork = 0, double completedWork = 0, double todaysAssigned = 0)
        {
            try
            {
                var response = await _projectCache.UpdatePlannedAndCompleteWorksInWorkItemToCache(id, plannedWork, completedWork, todaysAssigned);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while updating planned work, completed work, and today's assigned work in workItems in Cache: {Error}", ex.Message);
            }
        }


        // ------------------------------------ Employee Profile Cache ---------------------------------------
        public async Task AddApplicationRole(Guid employeeId, List<Guid> 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)
        {
            try
            {
                var response = await _employeeCache.AddProjectsToCache(employeeId, projectIds);
                return response;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while adding projectIds for employee {EmployeeId} to Cache: {Error}", employeeId, ex.Message);
                return false;
            }
        }
        public async Task<List<Guid>?> GetProjects(Guid employeeId)
        {
            try
            {
                var response = await _employeeCache.GetProjectsFromCache(employeeId);
                if (response.Count > 0)
                {
                    return response;
                }
                return null;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while getting projectIds for employee {EmployeeId} from Cache: {Error}", employeeId, ex.Message);
                return null;
            }
        }
        public async Task<List<Guid>?> GetPermissions(Guid employeeId)
        {
            try
            {
                var response = await _employeeCache.GetPermissionsFromCache(employeeId);
                if (response.Count > 0)
                {
                    return response;
                }
                return null;
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while getting permissionIds for employee {EmployeeId} from Cache: {Error}", employeeId, ex.Message);
                return null;
            }
        }
        public async Task ClearAllProjectIds(Guid 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)
        {
            try
            {
                await _employeeCache.ClearAllProjectIdsByRoleIdFromCache(roleId);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while deleting projectIds from Cache for Application Role {RoleId}: {Error}", roleId, ex.Message);
            }
        }
        public async Task ClearAllPermissionIdsByEmployeeID(Guid employeeId)
        {
            try
            {
                var response = await _employeeCache.ClearAllPermissionIdsByEmployeeIDFromCache(employeeId);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while deleting permissionIds from Cache for employee {EmployeeId}: {Error}", employeeId, ex.Message);
            }
        }
        public async Task ClearAllPermissionIdsByRoleId(Guid roleId)
        {
            try
            {
                var response = await _employeeCache.ClearAllPermissionIdsByRoleIdFromCache(roleId);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while deleting permissionIds from Cache for Application role {RoleId}: {Error}", roleId, ex.Message);
            }
        }
        public async Task RemoveRoleId(Guid employeeId, Guid roleId)
        {
            try
            {
                var response = await _employeeCache.RemoveRoleIdFromCache(employeeId, roleId);
            }
            catch (Exception ex)
            {
                _logger.LogWarning("Error occured while deleting Application role {RoleId} from Cache for employee {EmployeeId}: {Error}", roleId, employeeId, ex.Message);
            }
        }
    }
}