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

using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Projects;
using Marco.Pms.Services.Helpers;
using Marco.Pms.Services.Service;
using Microsoft.EntityFrameworkCore;

namespace MarcoBMS.Services.Helpers
{
    public class ProjectsHelper
    {
        private readonly ApplicationDbContext _context;
        private readonly RolesHelper _rolesHelper;
        private readonly CacheUpdateHelper _cache;
        private readonly PermissionServices _permission;

        public ProjectsHelper(ApplicationDbContext context, RolesHelper rolesHelper, CacheUpdateHelper cache, PermissionServices permission)
        {
            _context = context;
            _rolesHelper = rolesHelper;
            _cache = cache;
            _permission = permission;
        }

        public async Task<List<Project>> GetAllProjectByTanentID(Guid tanentID)
        {
            List<Project> alloc = await _context.Projects.Where(c => c.TenantId == tanentID).ToListAsync();
            return alloc;
        }

        public async Task<List<ProjectAllocation>> GetProjectByEmployeeID(Guid employeeID)
        {
            List<ProjectAllocation> alloc = await _context.ProjectAllocations.Where(c => c.EmployeeId == employeeID && c.IsActive == true).Include(c => c.Project).ToListAsync();
            return alloc;
        }

        public async Task<List<ProjectAllocation>> GetTeamByProject(Guid TenantId, Guid ProjectId, bool IncludeInactive)
        {
            if (IncludeInactive)
            {

                var employees = await _context.ProjectAllocations.Where(c => c.TenantId == TenantId && c.ProjectId == ProjectId).Include(e => e.Employee).ToListAsync();

                return employees;
            }
            else
            {
                var employees = await _context.ProjectAllocations.Where(c => c.TenantId == TenantId && c.ProjectId == ProjectId && c.IsActive == true).Include(e => e.Employee).ToListAsync();

                return employees;
            }
        }

        public async Task<List<Guid>> GetMyProjects(Guid tenantId, Employee LoggedInEmployee)
        {
            var projectIds = await _cache.GetProjects(LoggedInEmployee.Id);

            if (projectIds == null)
            {
                var hasPermission = await _permission.HasPermission(PermissionsMaster.ManageProject, LoggedInEmployee.Id);
                if (hasPermission)
                {
                    var projects = await _context.Projects.Where(c => c.TenantId == tenantId).ToListAsync();
                    projectIds = projects.Select(p => p.Id).ToList();
                }
                else
                {
                    var allocation = await GetProjectByEmployeeID(LoggedInEmployee.Id);
                    if (allocation.Any())
                    {
                        projectIds = allocation.Select(c => c.ProjectId).Distinct().ToList();
                    }
                    return new List<Guid>();
                }
                await _cache.AddProjects(LoggedInEmployee.Id, projectIds);
            }

            return projectIds;
        }

    }
}