marco.pms.api/Marco.Pms.CacheHelper/EmployeeCache.cs

using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.MongoDBModels;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using MongoDB.Driver;

namespace Marco.Pms.CacheHelper
{
    public class EmployeeCache
    {
        private readonly ApplicationDbContext _context;
        //private readonly IMongoDatabase _mongoDB;
        private readonly IMongoCollection<EmployeePermissionMongoDB> _collection;
        public EmployeeCache(ApplicationDbContext context, IConfiguration configuration)
        {
            var connectionString = configuration["MongoDB:ConnectionString"];
            _context = context;
            var mongoUrl = new MongoUrl(connectionString);
            var client = new MongoClient(mongoUrl); // Your MongoDB connection string
            var mongoDB = client.GetDatabase(mongoUrl.DatabaseName);  // Your MongoDB Database name
            _collection = mongoDB.GetCollection<EmployeePermissionMongoDB>("EmployeeProfile");
        }
        public async Task<bool> AddApplicationRoleToCache(Guid employeeId, List<Guid> roleIds)
        {
            // 1. Guard Clause: Avoid unnecessary database work if there are no roles to add.
            if (roleIds == null || !roleIds.Any())
            {
                return false; // Nothing to add, so the operation did not result in a change.
            }

            // 2. Perform database queries concurrently for better performance.
            var employeeIdString = employeeId.ToString();

            Task<List<string>> getPermissionIdsTask = _context.RolePermissionMappings
                .Where(rp => roleIds.Contains(rp.ApplicationRoleId))
                .Select(p => p.FeaturePermissionId.ToString())
                .Distinct()
                .ToListAsync();

            // 3. Prepare role IDs in parallel with the database query.
            var newRoleIds = roleIds.Select(r => r.ToString()).ToList();

            // 4. Await the database query result.
            var newPermissionIds = await getPermissionIdsTask;

            // 5. Build a single, efficient update operation.
            var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeIdString);

            var update = Builders<EmployeePermissionMongoDB>.Update
                .AddToSetEach(e => e.ApplicationRoleIds, newRoleIds)
                .AddToSetEach(e => e.PermissionIds, newPermissionIds);

            var options = new UpdateOptions { IsUpsert = true };

            var result = await _collection.UpdateOneAsync(filter, update, options);

            // 6. Return a more accurate result indicating success for both updates and upserts.
            // The operation is successful if an existing document was modified OR a new one was created.
            return result.IsAcknowledged && (result.ModifiedCount > 0 || result.UpsertedId != null);
        }
        public async Task<bool> AddProjectsToCache(Guid employeeId, List<Guid> projectIds)
        {
            var newprojectIds = projectIds.Select(p => p.ToString()).ToList();

            var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .AddToSetEach(e => e.ProjectIds, newprojectIds);

            var result = await _collection.UpdateOneAsync(filter, update, new UpdateOptions { IsUpsert = true });
            if (result.MatchedCount == 0)
            {
                return false;
            }
            return true;
        }
        public async Task<List<Guid>> GetProjectsFromCache(Guid employeeId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeId.ToString());


            var result = await _collection
                .Find(filter)
                .FirstOrDefaultAsync();

            var projectIds = new List<Guid>();
            if (result != null)
            {
                projectIds = result.ProjectIds.Select(Guid.Parse).ToList();
            }

            return projectIds;
        }
        public async Task<List<Guid>> GetPermissionsFromCache(Guid employeeId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter.Eq(e => e.Id, employeeId.ToString());


            var result = await _collection
                .Find(filter)
                .FirstOrDefaultAsync();

            var permissionIds = new List<Guid>();
            if (result != null)
            {
                permissionIds = result.PermissionIds.Select(Guid.Parse).ToList();
            }

            return permissionIds;
        }
        public async Task<bool> ClearAllProjectIdsFromCache(Guid employeeId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter
                .Eq(e => e.Id, employeeId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .Set(e => e.ProjectIds, new List<string>());

            var result = await _collection.UpdateOneAsync(filter, update);

            if (result.MatchedCount == 0)
                return false;

            return true;
        }
        public async Task<bool> ClearAllProjectIdsByRoleIdFromCache(Guid roleId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter.AnyEq(e => e.ApplicationRoleIds, roleId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .Set(e => e.ProjectIds, new List<string>());

            var result = await _collection.UpdateOneAsync(filter, update);

            if (result.MatchedCount == 0)
                return false;

            return true;
        }
        public async Task<bool> ClearAllProjectIdsByPermissionIdFromCache(Guid permissionId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter.AnyEq(e => e.PermissionIds, permissionId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .Set(e => e.ProjectIds, new List<string>());

            var result = await _collection.UpdateOneAsync(filter, update);

            if (result.MatchedCount == 0)
                return false;

            return true;
        }
        public async Task<bool> RemoveRoleIdFromCache(Guid employeeId, Guid roleId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter
                .Eq(e => e.Id, employeeId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .Pull(e => e.ApplicationRoleIds, roleId.ToString());

            var result = await _collection.UpdateOneAsync(filter, update);

            if (result.MatchedCount == 0)
                return false;

            if (result.ModifiedCount == 0)
                return false;

            return true;
        }
        public async Task<bool> ClearAllPermissionIdsByEmployeeIDFromCache(Guid employeeId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter
                .Eq(e => e.Id, employeeId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .Set(e => e.PermissionIds, new List<string>());

            var result = await _collection.UpdateOneAsync(filter, update);

            if (result.MatchedCount == 0)
                return false;

            return true;
        }
        public async Task<bool> ClearAllPermissionIdsByRoleIdFromCache(Guid roleId)
        {
            var filter = Builders<EmployeePermissionMongoDB>.Filter.AnyEq(e => e.ApplicationRoleIds, roleId.ToString());

            var update = Builders<EmployeePermissionMongoDB>.Update
                .Set(e => e.PermissionIds, new List<string>());

            var result = await _collection.UpdateOneAsync(filter, update);

            if (result.MatchedCount == 0)
                return false;

            return true;
        }
    }
}