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

using Marco.Pms.DataAccess.Data;
using Marco.Pms.Model.Dtos.Activities;
using Marco.Pms.Model.Entitlements;
using Marco.Pms.Model.Forum;
using Marco.Pms.Model.Mapper;
using Marco.Pms.Model.Utilities;
using Marco.Pms.Model.ViewModels.Activities;
using Marco.Pms.Model.ViewModels.Forum;
using MarcoBMS.Services.Helpers;
using MarcoBMS.Services.Service;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Marco.Pms.Services.Controllers
{
    [Authorize]
    [Route("api/[controller]")]
    [ApiController]
    public class MasterController : ControllerBase
    {
        private readonly ApplicationDbContext _context;
        private readonly UserHelper _userHelper;
        private readonly ILoggingService _logger;
        public MasterController(ApplicationDbContext context, UserHelper userHelper, ILoggingService logger)
        {
            _context = context;
            _userHelper = userHelper;
            _logger = logger;
        }
        [HttpGet]
        [Route("activities")]
        public async Task<IActionResult> GetActivitiesMaster()
        {
            var tenantId = _userHelper.GetTenantId();
            var activities = await _context.ActivityMasters.Where(c => c.TenantId == tenantId && c.IsActive == true).ToListAsync();
            List<ActivityVM> activitiesVM = new List<ActivityVM>();
            foreach (var activity in activities)
            {
                var checkList = await _context.ActivityCheckLists.Where(c => c.TenantId == tenantId && c.ActivityId == activity.Id).ToListAsync();
                List<CheckListVM> checkListVM = new List<CheckListVM>();
                if (checkList != null)
                {
                    foreach (ActivityCheckList check in checkList)
                    {
                        var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
                        checkListVM.Add(checkVM);
                    }
                }

                ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
                activitiesVM.Add(activityVM);
            }
            _logger.LogInfo("{count} activity records fetched successfully from tenant {tenantId}", activitiesVM.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(activitiesVM, System.String.Format("{0} activity records fetched successfully", activitiesVM.Count), 200));
        }

        [HttpPost("activity")]
        public async Task<IActionResult> CreateActivity([FromBody] CreateActivityMasterDto createActivity)
        {
            var tenantId = _userHelper.GetTenantId();
            var employee = await _userHelper.GetCurrentEmployeeAsync();
            if (employee.TenantId != tenantId)
            {
                _logger.LogWarning("User from tenant {employeeTenantId} tries to access data from tenant {tenantId}", employee.TenantId, tenantId);
                return Unauthorized(ApiResponse<object>.ErrorResponse("Current tenant did not match with user's tenant", "Current tenant did not match with user's tenant", 401));
            }
            var activityMaster = createActivity.ToActivityMasterFromCreateActivityMasterDto(tenantId);
            _context.ActivityMasters.Add(activityMaster);
            await _context.SaveChangesAsync();
            List<CheckListVM> checkListVM = new List<CheckListVM>();

            if (createActivity.CheckList != null)
            {
                List<ActivityCheckList> activityCheckList = new List<ActivityCheckList>();
                foreach (var check in createActivity.CheckList)
                {
                    ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activityMaster.Id);
                    activityCheckList.Add(checkList);
                }
                _context.ActivityCheckLists.AddRange(activityCheckList);
                await _context.SaveChangesAsync();

                foreach (ActivityCheckList check in activityCheckList)
                {
                    var checkVM = check.ToCheckListVMFromActivityCheckList(activityMaster.Id, false);
                    checkListVM.Add(checkVM);
                }
            }
            ActivityVM activityVM = activityMaster.ToActivityVMFromActivityMaster(checkListVM);

            _logger.LogInfo("activity created successfully from tenant {tenantId}", tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity created successfully", 200));
        }

        [HttpPost("activity/edit/{id}")]
        public async Task<IActionResult> UpdateActivity(int id, [FromBody] CreateActivityMasterDto createActivity)
        {
            var tenantId = _userHelper.GetTenantId();
            var employee = await _userHelper.GetCurrentEmployeeAsync();
            ActivityMaster? activity = await _context.ActivityMasters.FirstOrDefaultAsync(x => x.Id == id && x.IsActive == true && x.TenantId == tenantId);
            if (activity != null && createActivity.UnitOfMeasurement != null && createActivity.ActivityName != null)
            {

                activity.ActivityName = createActivity.ActivityName;
                activity.UnitOfMeasurement = createActivity.UnitOfMeasurement;
                List<CheckListVM> checkListVM = new List<CheckListVM>();

                if (createActivity.CheckList != null)
                {
                    List<ActivityCheckList> activityCheckList = new List<ActivityCheckList>();
                    foreach (var check in createActivity.CheckList)
                    {
                        ActivityCheckList checkList = check.ToActivityCheckListFromCreateCheckListDto(tenantId, activity.Id);
                        activityCheckList.Add(checkList);
                    }
                    _context.ActivityCheckLists.UpdateRange(activityCheckList);
                    await _context.SaveChangesAsync();

                    foreach (ActivityCheckList check in activityCheckList)
                    {
                        var checkVM = check.ToCheckListVMFromActivityCheckList(activity.Id, false);
                        checkListVM.Add(checkVM);
                    }
                }
                ActivityVM activityVM = activity.ToActivityVMFromActivityMaster(checkListVM);
                _logger.LogInfo("activity updated successfully from tenant {tenantId}", tenantId);
                return Ok(ApiResponse<object>.SuccessResponse(activityVM, "activity updated successfully", 200));
            }
            _logger.LogError("Activity {ActivityId} not found", id);
            return NotFound(ApiResponse<object>.ErrorResponse("Activity not found", "Activity not found", 404));
        }

        [HttpDelete("activity/delete/{id}")]
        public async Task<IActionResult> DeleteActivity(int Id)
        {
            int tenantId = _userHelper.GetTenantId();
            var activity = await _context.ActivityMasters.FirstOrDefaultAsync(a => a.Id == Id && a.TenantId == tenantId);
            if (activity != null)
            {
                activity.IsActive = false;
            }
            await _context.SaveChangesAsync();
            _logger.LogInfo("Activity Deleted Successfully from tenant {tenantId}", tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(new { }, "Activity Deleted Successfully", 200));
        }
        [HttpGet]
        [Route("industries")]
        public async Task<IActionResult> GetIndustries()
        {
            var tenantId = _userHelper.GetTenantId();
            var industries = await _context.Industries.ToListAsync();

            _logger.LogInfo("{count} industry records fetched successfully from tenant {tenantId}", industries.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(industries, System.String.Format("{0} industry records fetched successfully", industries.Count), 200));
        }

        [HttpGet("ticket-status")]
        public async Task<IActionResult> GetTicketStatusMaster()
        {
            var tenantId = _userHelper.GetTenantId();
            List<TicketStatusVM> statusVMs = new List<TicketStatusVM>();
            List<TicketStatusMaster> statusMasters = await _context.TicketStatusMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var statusMaster in statusMasters)
            {
                statusVMs.Add(statusMaster.ToTicketStatusVMFromTicketStatusMaster());
            }

            _logger.LogInfo("{count} Ticket Status records fetched successfully from tenant {tenantId}", statusVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(statusVMs, System.String.Format("{0} Ticket Status records fetched successfully", statusVMs.Count), 200));
        }

        [HttpGet("ticket-types")]
        public async Task<IActionResult> GetTicketTypeMaster()
        {
            var tenantId = _userHelper.GetTenantId();
            List<TicketTypeVM> typeVMs = new List<TicketTypeVM>();
            List<TicketTypeMaster> typeMasters = await _context.TicketTypeMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var typeMaster in typeMasters)
            {
                typeVMs.Add(typeMaster.ToTicketTypeVMFromTicketTypeMaster());
            }

            _logger.LogInfo("{count} Ticket Type records fetched successfully from tenant {tenantId}", typeVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(typeVMs, System.String.Format("{0} Ticket Type records fetched successfully", typeVMs.Count), 200));
        }

        [HttpGet("ticket-priorities")]
        public async Task<IActionResult> GetTicketPriorityMaster()
        {
            var tenantId = _userHelper.GetTenantId();
            List<TicketPriorityVM> priorityVMs = new List<TicketPriorityVM>();
            List<TicketPriorityMaster> priorityMasters = await _context.TicketPriorityMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var priorityMaster in priorityMasters)
            {
                priorityVMs.Add(priorityMaster.ToTicketPriorityVMFromTicketPriorityMaster());
            }

            _logger.LogInfo("{count} Ticket Priority records fetched successfully from tenant {tenantId}", priorityVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(priorityVMs, System.String.Format("{0} Ticket Priority records fetched successfully", priorityVMs.Count), 200));
        }

        [HttpGet("ticket-tags")]
        public async Task<IActionResult> GetTicketTagMaster()
        {
            var tenantId = _userHelper.GetTenantId();
            List<TicketTagVM> tagVMs = new List<TicketTagVM>();
            List<TicketTagMaster> tagMasters = await _context.TicketTagMasters.Where(s => s.TenantId == tenantId).ToListAsync();
            foreach (var tagMaster in tagMasters)
            {
                tagVMs.Add(tagMaster.ToTicketTagVMFromTicketTagMaster());
            }

            _logger.LogInfo("{count} Ticket Tag records fetched successfully from tenant {tenantId}", tagVMs.Count, tenantId);
            return Ok(ApiResponse<object>.SuccessResponse(tagVMs, System.String.Format("{0} Ticket Tag records fetched successfully", tagVMs.Count), 200));
        }
    }
}