marco.pms.api/Marco.Pms.Services/Controllers/ProjectController.cs

using Marco.Pms.DataAccess.Data;
using Marco.Pms.DataAccess.Repository;
using Marco.Pms.DataAccess.Repository.IRepository;
using Marco.Pms.Model.Activities;
using Marco.Pms.Model.Dtos.Project;
using Marco.Pms.Model.Employees;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Projects;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace MarcoBMS.Services.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    [Authorize]
    public class ProjectController : ControllerBase
    {
        private readonly IUnitOfWork _unitOfWork;
        private readonly ApplicationDbContext _context;
        private ApplicationUser _applicationUser;
        private readonly IProjectRepository _projectrepo;
        private readonly UserManager<IdentityUser> _userManager;

        public ProjectController(UserManager<IdentityUser> userManager, IProjectRepository projectrepo, IUnitOfWork unitOfWork, ApplicationDbContext context)
        {
            _unitOfWork = unitOfWork;
            _context = context;
            _projectrepo = projectrepo;
            _userManager = userManager;

        }
        [HttpGet("list")]
        public async Task<IActionResult> GetAll()
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            List<Project> project = await _projectrepo.GetAllAsync();
            // var commentDto = comments.Select(x => x.ToCommentDto());

            return Ok(project);
        }

        [HttpGet("get/{id:int}")]
        public async Task<IActionResult> Get([FromRoute] int id)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var project = _projectrepo.Get(c => c.Id == id); //_context.Stock.FindAsync(id);

            //  List<Project> project = await _projectrepo.GetAsync(id);

            return Ok(project);
        }

        [HttpGet("details/{id:int}")]
        public async Task<IActionResult> Details([FromRoute] int id)
        {
            // ProjectDetailsVM vm = new ProjectDetailsVM();

            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var projects = await _projectrepo.GetAsync((c => c.Id == id), includeProperties: "ProjectStatus,Tenant"); //_context.Stock.FindAsync(id);

            if (projects == null)
            {
                //vm.project = new Project();
                //vm.buildings = new List<Building>();
                //vm.floors = new List<Floor>();
                //vm.workAreas = new List<WorkArea>();
            }
            else
            {
                var project = projects.Where(c => c.Id == id).SingleOrDefault();
                ProjectDetailsVM vm = GetProjectViewModel(id, project);

                ProjectVM projectVM = new ProjectVM();
                projectVM.Id = vm.project.Id;
                projectVM.Name = vm.project.Name;
                projectVM.ProjectAddress = vm.project.ProjectAddress;
                projectVM.ContactPerson = vm.project.ContactPerson;
                projectVM.StartDate = vm.project.StartDate;
                projectVM.EndDate = vm.project.EndDate;
                projectVM.ProjectStatusId = vm.project.ProjectStatusId;
                projectVM.Buildings = new List<BuildingVM>();
                foreach (Building build in vm.buildings)
                {
                    BuildingVM buildVM = new BuildingVM() { Id = build.Id, Description = build.Description, Name = build.Name };
                    buildVM.Floors = new List<FloorsVM>();
                    foreach (Floor floorDto in vm.floors.Where(c => c.BuildingId == build.Id).ToList())
                    {
                        FloorsVM floorVM = new FloorsVM() { FloorName = floorDto.FloorName, Id = floorDto.Id };
                        floorVM.WorkAreas = new List<WorkAreaVM>();

                        foreach (WorkArea workAreaDto in vm.workAreas.Where(c => c.FloorId == floorVM.Id).ToList())
                        {
                            WorkAreaVM workAreaVM = new WorkAreaVM() { Id = workAreaDto.Id, AreaName = workAreaDto.AreaName, WorkItems = new List<WorkItemVM>() };

                            foreach (WorkItem workItemDto in vm.workItems.Where(c => c.WorkAreaId == workAreaDto.Id).ToList())
                            {
                                WorkItemVM workItemVM = new WorkItemVM() { WorkItemId = workItemDto.Id, WorkItem = workItemDto };
                                workItemVM.WorkItem.WorkArea = null;
                                workItemVM.WorkItem.ActivityMaster.Tenant = null;
                                workItemVM.WorkItem.Tenant = null;



                                workAreaVM.WorkItems.Add(workItemVM);
                            }

                            floorVM.WorkAreas.Add(workAreaVM);
                        }

                        buildVM.Floors.Add(floorVM);
                    }
                    projectVM.Buildings.Add(buildVM);
                }

                return Ok(projectVM);
            }

            return Ok(new ProjectVM());
        }

        private ProjectDetailsVM GetProjectViewModel(int? id, Project project)
        {
            ProjectDetailsVM vm = new ProjectDetailsVM();

            // List<Building> buildings = _unitOfWork.Building.GetAll(c => c.ProjectId == id).ToList();
            List<Building> buildings = _context.Buildings.Where(c => c.ProjectId == id).ToList();
            List<int> idList = buildings.Select(o => o.Id).ToList();
            // List<Floor> floors = _unitOfWork.Floor.GetAll(c => idList.Contains(c.Id)).ToList();
            List<Floor> floors = _context.Floor.Where(c => idList.Contains(c.BuildingId)).ToList();
            idList = floors.Select(o => o.Id).ToList();
            //List<WorkArea> workAreas = _unitOfWork.WorkArea.GetAll(c => idList.Contains(c.Id), includeProperties: "WorkItems,WorkItems.ActivityMaster").ToList();

            List<WorkArea> workAreas = _context.WorkAreas.Where(c => idList.Contains(c.FloorId)).ToList();

            idList = floors.Select(o => o.Id).ToList();
            List<WorkItem> workItems = _unitOfWork.WorkItem.GetAll(c => idList.Contains(c.WorkAreaId), includeProperties: "ActivityMaster").ToList();

            vm.project = project;
            vm.buildings = buildings;
            vm.floors = floors;
            vm.workAreas = workAreas;
            vm.workItems = workItems;

            return vm;
        }

        private int GetTenantId()
        {
            var tenant = User.FindFirst("TenantId")?.Value;
            return (tenant != null ? Convert.ToInt32(tenant) : 1);
        }

        [HttpPost]
        public async Task<IActionResult> Create([FromBody] CreateProjectDto projectDto)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            int TenantId = GetTenantId();
            var projectModel = projectDto.ToProjectFromCreateProjectDto(TenantId);

            var result = await _projectrepo.CreateAsync(projectModel);

            return Ok(result);

        }

        [HttpGet("get-allocation/{projectId:int}")]
        public async Task<IActionResult> GetAllocation([FromRoute] int projectId)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            List<ProjectAllocation> allocations = await _unitOfWork.ProjectAllocation.GetAsync(c => c.ProjectId == projectId);
            allocations = allocations.Where(c => c.ProjectId == projectId).ToList();

            return Ok(allocations);
        }

        [HttpPut]
        [Route("update/{id:int}")]
        public async Task<IActionResult> Update([FromRoute] int id, [FromBody] UpdateProjectDto updateProjectDto)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            try
            {
                int TenantId = GetTenantId();
                updateProjectDto.TenantId = TenantId;
                var projectModel = await _projectrepo.UpdateAsync(id, updateProjectDto);

                if (projectModel == null)
                {
                    return NotFound("Project not found");
                }
                return Ok(projectModel.ToProjectDto());
            }
            catch (Exception ex)
            {
                return Ok(null);
            }
        }


        [HttpPost("assign-employee")]
        public async Task<IActionResult> AssignEmployee(int? allocationid, int employeeId, int projectId)
        {
            var employee = await _context.Employees.FindAsync(employeeId);
            var project = _projectrepo.Get(c => c.Id == projectId);
            if (employee == null || project == null)
            {
                return NotFound();
            }

            // Logic to add the product to a new table (e.g., selected products)

            if (allocationid == null)
            {
                // Add allocation
                ProjectAllocation allocation = new ProjectAllocation()
                {
                    EmployeeId = employeeId,
                    ProjectId = project.Id,
                    AllocationDate = DateTime.UtcNow,
                    //EmployeeRole = employee.Rol
                    TenantId = project.TenantId
                };

                _unitOfWork.ProjectAllocation.CreateAsync(allocation);
            }
            else
            {
                //remove allocation
                var allocation = await _context.ProjectAllocations.FindAsync(allocationid);
                if (allocation != null)
                {
                    allocation.ReAllocationDate = DateTime.UtcNow;

                    _unitOfWork.ProjectAllocation.UpdateAsync(allocation.Id, allocation);
                }
                else
                {
                    return NotFound();
                }
            }

            return Ok();
        }

        [HttpGet]
        [Route("allocation/{projectId:int}")]
        public async Task<IActionResult> GetProjectAllocation(int? projectId)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }
            int TenantId = GetTenantId();

            var employees = await _context.ProjectAllocations.Where(c => c.TenantId == TenantId && c.ProjectId == projectId ).Include(e => e.Employee).Select(e=> new
            {
                ID = e.Id,
                EmployeeId = e.EmployeeId,
                ProjectId = e.ProjectId,
                RoleID = e.EmployeeRoleId,
                AllocationDate = e.AllocationDate,
                ReAllocationDate = e.ReAllocationDate,
                FirstName = e.Employee.FirstName, 
                LastName = e.Employee.LastName, 
                MiddleName = e.Employee.MiddleName,
                IsActive = e.IsActive

            }).ToListAsync();

            return Ok(ApiResponse<object>.SuccessResponse(employees, "Success.", 200));
        }

            [HttpPost("allocation")]
        public async Task<IActionResult> ManageAllocation(List<ProjectAllocationDot> projectAllocationDot)
        {
            if (projectAllocationDot != null)
            {
                int TenentID = GetTenantId();

                foreach (var item in projectAllocationDot)
                {
                    try
                    {
                        ProjectAllocation projectAllocation = item.ToProjectAllocationFromProjectAllocationDto(TenentID);
                        ProjectAllocation projectAllocationFromDb =await _context.ProjectAllocations.Where(c => c.EmployeeId == projectAllocation.EmployeeId 
                        && c.ProjectId == projectAllocation.ProjectId 
                        && c.ReAllocationDate == null 
                        && c.TenantId == TenentID).SingleOrDefaultAsync();

                        if (projectAllocationFromDb != null)
                        {
                            _context.ProjectAllocations.Attach(projectAllocationFromDb);

                            if (item.Status)
                            {
                                projectAllocationFromDb.EmployeeRoleId = projectAllocation.EmployeeRoleId; ;
                                projectAllocationFromDb.IsActive = true;
                                _context.Entry(projectAllocationFromDb).Property(e => e.EmployeeRoleId).IsModified = true;
                                _context.Entry(projectAllocationFromDb).Property(e => e.IsActive).IsModified = true;

                            }
                            else
                            {
                                projectAllocationFromDb.ReAllocationDate = DateTime.Now;
                                projectAllocationFromDb.IsActive = false;
                                _context.Entry(projectAllocationFromDb).Property(e => e.ReAllocationDate).IsModified = true;
                                _context.Entry(projectAllocationFromDb).Property(e => e.IsActive).IsModified = true;

                            }
                            await _context.SaveChangesAsync();

                        }
                        else
                        {
                            projectAllocation.AllocationDate = DateTime.Now;
                            projectAllocation.IsActive = true;
                            _context.ProjectAllocations.Add(projectAllocation);
                            await _context.SaveChangesAsync();
                        }

                    }
                    catch (Exception ex) { }


                }
                return Ok(ApiResponse<object>.SuccessResponse(null, "Data saved successfully.", 200));

            }
            return BadRequest(ApiResponse<string>.ErrorResponse("Invalid details.", new { id = "Work Item Details are not valid." }, 400));

        }

        [HttpPost("task")]
        public async Task<IActionResult> CreateProjectTask(List<WorkItemDot> workItemDot)
        {
            if (workItemDot != null)
            {
                foreach (var item in workItemDot)
                {
                    item.TenantId = GetTenantId();
                    WorkItem workItem = item.ToWorkItemFromWorkItemDto();

                    if (item.Id > 0)
                    {
                        //update

                        _unitOfWork.WorkItem.Update(workItem);

                    }
                    else
                    {

                        //create
                        _unitOfWork.WorkItem.Add(workItem);

                    }

                    _unitOfWork.Save();

                }

                return Ok(ApiResponse<object>.SuccessResponse(null, "Data saved successfully.", 200));
            }

            return BadRequest(ApiResponse<string>.ErrorResponse("Invalid details.", new { id = "Work Item Details are not valid." }, 400));

        }
        [HttpPost("manage-infra")]
        public async Task<IActionResult> ManageProjectInfra(List<InfraDot> infraDots)

        {
            if (infraDots != null)
            {
                foreach (var item in infraDots)
                {
                    if (item.Building != null)
                    {

                        Building building = item.Building.ToBuildingFromBuildingDto();
                        building.TenantId = GetTenantId();

                        if (item.Building.Id == 0)
                        {
                            //create
                            _unitOfWork.Building.Add(building);
                        }
                        else
                        {
                            //update
                            _unitOfWork.Building.Update(building);
                        }

                        _unitOfWork.Save();
                    }
                    if (item.Floor != null)
                    {
                        Floor floor = item.Floor.ToFloorFromFloorDto();
                        floor.TenantId = GetTenantId();

                        if (item.Floor.Id == 0)
                        {
                            //create
                            _unitOfWork.Floor.Add(floor);
                        }
                        else
                        {
                            //update
                            _unitOfWork.Floor.Update(floor);
                        }

                        _unitOfWork.Save();

                    }
                    if (item.WorkArea != null)
                    {
                        WorkArea workArea = item.WorkArea.ToWorkAreaFromWorkAreaDto();
                        workArea.TenantId = GetTenantId();

                        if (item.WorkArea.Id == 0)
                        {
                            //create
                            _unitOfWork.WorkArea.Add(workArea);
                        }
                        else
                        {
                            //update
                            _unitOfWork.WorkArea.Update(workArea);
                        }

                        _unitOfWork.Save();
                    }
                }
            }
            return Ok();
        }


    }
}