NonInventPurchasingSystem/CPRNIMS.WebApps/Controllers/PO/POMgmtController.cs

using CPRNIMS.Domain.UIContracts.Account;
using CPRNIMS.Domain.UIContracts.PO;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.PO;
using CPRNIMS.WebApps.Controllers.Base;
using Microsoft.AspNetCore.Mvc;
using static Microsoft.EntityFrameworkCore.DbLoggerCategory;

namespace CPRNIMS.WebApps.Controllers.PO
{
    public class POMgmtController : BaseMethod
    {
        #region Constructor
        List<POVM>? response;
        POVM postPutItem;

        private readonly IPurchaseOrder _purchaseOrder;
        private readonly ICustomPOService _customPOService;
        public POMgmtController( 
            ErrorLogHelper errorMessageService, IWebHostEnvironment webHostEnvironment
         , IPurchaseOrder purchaseOrder, TokenHelper tokenHelper,IAccount account, ICustomPOService customPOService
            ) : base(errorMessageService, webHostEnvironment, tokenHelper, account)
        {
            _purchaseOrder = purchaseOrder;
            _customPOService = customPOService;
        }
        #endregion
        #region POST PUT 
        [HttpPost]
        public async Task<IActionResult> DeleteIncShip(POVM viewModel)
        {
            var postPutItem = await _purchaseOrder.DeleteIncShip(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutIncoterms(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostPutIncoterms(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }
            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutOtherCharges(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostPutOtherCharges(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutDocRequired(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostPutDocRequired(GetUser(), viewModel);

            if (postPutItem.messCode !=0)
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPOToSupplier(POVM viewModel)
        {
             postPutItem = await _purchaseOrder.PostPOToSupplier(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostPutPO(POVM viewModel, List<DocRequirementList> DocRequiredList)
        {
            viewModel.DocRequiredList = MapToDocReqList(DocRequiredList);
            postPutItem = await _purchaseOrder.PostPutPO(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }
            return Json(new { success = false, Response = postPutItem.Message });         
        }
        public async Task<IActionResult> PostPutCustomPO(POVM viewModel, 
            List<DocRequirementList> DocRequiredList,
             List<POChargesList> OtherChargesList,
             List<PRItemList> PRItemList
            )
        {
            viewModel.DocRequiredList = MapToDocReqList(DocRequiredList);
            viewModel.OtherChargesList = MapToPOChargesList(OtherChargesList);
            viewModel.PRItemList = MapToPRItemList(PRItemList);
 
            postPutItem = await _purchaseOrder.PostPutCustomPO(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message, data = postPutItem.Data });
            }
            return Json(new { success = false, Response = postPutItem.Message });       
        }
        public async Task<IActionResult> PutPOCancel(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutPOCancel(GetUser(), viewModel);
            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true, Response = postPutItem.Message, 
                    data = postPutItem.Data });
            }
            return Json(new { success = false, Response = postPutItem.Message , data = postPutItem.Data });
        }
        public async Task<IActionResult> ApprovedSelectedPO(POVM viewModel,
        List<POList> POList)
        {
            try
            {
                viewModel.POList = MapToPONoList(POList);

                postPutItem = await _purchaseOrder.ApprovedSelectedPO(GetUser(), viewModel);

                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true });
                }
                return Json(new { success = false, Response = postPutItem.Message });
            }
            catch (Exception ex)
            {
                var message = ex.InnerException?.ToString() ?? ex.Message.ToString();
                return Json(new { success = false, Response = postPutItem.Message });
                throw;
            }
        }
        public async Task<IActionResult> PostApprovedSuggested(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostApprovedSuggested(GetUser(), viewModel);

            if (postPutItem.StatusResponse != "Error")
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostApprovedPO(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostApprovedPO(GetUser(), viewModel);

            if (postPutItem.StatusResponse != "Error")
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PostApprovedSupplier(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PostApprovedSupplier(GetUser(), viewModel);

            if (postPutItem.StatusResponse != "Error")
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutPRItemDetails(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutPRItemDetails(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutPOItemDetail(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutPOItemDetail(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        public async Task<IActionResult> PutMyPONo(POVM viewModel)
        {
            postPutItem = await _purchaseOrder.PutMyPONo(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }

            return Json(new { success = false, Response = postPutItem.Message });
        }
        #endregion
        #region Mapper
        private POList MapToPONoList(IEnumerable<POList> poList)
        {
            if (poList == null || !poList.Any())
            {
                return new POList
                {
                    PONo = new List<string>()
                };
            }

            return new POList
            {
                PONo = poList.SelectMany(ic => ic.PONo).ToList(),
            };
        }
        private DocRequirementList MapToDocReqList(IEnumerable<DocRequirementList> docReqList)
        {
            if (docReqList == null || !docReqList.Any())
            {
                return new DocRequirementList
                {
                    DocRequirementId = new List<byte>()
                };
            }

            return new DocRequirementList
            {
                DocRequirementId = docReqList.SelectMany(ic => ic.DocRequirementId).ToList(),
            };
        }
        private POChargesList MapToPOChargesList(IEnumerable<POChargesList> chargesList)
        {
            if (chargesList == null || !chargesList.Any())
            {
                return new POChargesList
                {
                    OtherChargesId = new List<int>(),
                    Amount = new List<decimal>(),
                };
            }

            return new POChargesList
            {
                OtherChargesId = chargesList.SelectMany(ic => ic.OtherChargesId).ToList(),
                Amount = chargesList.SelectMany(ic => ic.Amount).ToList()
            };
        }
        private PRItemList MapToPRItemList(IEnumerable<PRItemList> itemList)
        {
            return new PRItemList
            {
                PRDetailsId = itemList.SelectMany(ic => ic.PRDetailsId).ToList(),
                Quantity = itemList.SelectMany(ic => ic.Quantity).ToList(),
                UnitPrice = itemList.SelectMany(ic => ic.UnitPrice).ToList(),
                PRNo = itemList.SelectMany(ic => ic.PRNo).ToList(),
                Amount = itemList.SelectMany(ic => ic.Amount).ToList(),
                Specification = itemList.SelectMany(ic => ic.Specification).ToList()
            };
        }
        #endregion

        #region Get
        [HttpGet]
        public async Task<IActionResult> GetPOFormData(long? poId = null)
        {
            var data = await _customPOService.GetPOFormDataAsync(poId);
            return Ok(data);
        }
        public async Task<IActionResult> GetIncomingShipment(POVM viewModels)
        {
            response = await _purchaseOrder.GetIncomingShipment(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBid()
        {
            var viewModels = new POVM();
            response = await _purchaseOrder.GetSupplierBid(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBidById(POVM viewModel)
        {
            response = await _purchaseOrder.GetSupplierBidById(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBidByItem(POVM viewModel)
        {
            response = await _purchaseOrder.GetSupplierBidByItem(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForPOApprovalByPRNo(POVM viewModel)
        {
            response = await _purchaseOrder.GetForPOApprovalByPRNo(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForBiddingApproval()
        {
            var viewModels = new POVM();
            response = await _purchaseOrder.GetForBiddingApproval(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForPO()
        {
            var viewModels = new POVM();
            response = await _purchaseOrder.GetForPO(GetUser(), viewModels);
            return GetResponse(response);
        } 
        public async Task<IActionResult> GetForPOPerSuppEmail(POVM viewModels)
        {
            response = await _purchaseOrder.GetForPOPerSuppEmail(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetApprovedPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetApprovedPO(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCreatedPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetCreatedPO(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetMyCreatedPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetMyCreatedPO(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetApprovedPOPerEmail(POVM viewModels)
        {
            response = await _purchaseOrder.GetApprovedPOPerEmail(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCreatedPOPerSupId(POVM viewModels)
        {
            response = await _purchaseOrder.GetCreatedPOPerSupId(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPortOfDischarge(string query)
        {
            var viewModels = new POVM();
            viewModels.PortOfDischarge = query;
            response = await _purchaseOrder.GetPortOfDischarge(GetUser(), viewModels);
            if (response == null)
            {
                response = new List<POVM>();
            }
            var formattedData = response.Select(item => new
            {
                label = item.PortOfDischarge,
                value = item.PodId
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetPOListByTerm(string query)
        {
            var viewModels = new POVM();
            viewModels.PONo = query;
            response = await _purchaseOrder.GetPOListByTerm(GetUser(), viewModels);
            if (response == null)
            {
                response = new List<POVM>();
            }
            var formattedData = response.Select(item => new
            {
                label = item.PONo,
                value = item.POId, 
                value2 = item.POTypeId
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetPaymentTerms(string query)
        {
            var viewModels = new POVM();
            viewModels.PaymentTerms = query;
            response = await _purchaseOrder.GetPaymentTerms(GetUser(), viewModels);
            if (response == null)
            {
                response = new List<POVM>();
            }
            var formattedData = response.Select(item => new
            {
                label = item.PaymentTerms,
                value = item.PaymentTermsId
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetLatestPO(POVM viewModels)
        {
            response = await _purchaseOrder.GetLatestPO(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetLatestPO2(POVM viewModels)
        {
            response = await _purchaseOrder.GetLatestPO2(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetDocRequired(POVM viewModels)
        {
            response = await _purchaseOrder.GetDocRequired(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetOtherCharges(POVM viewModels)
        {
            response = await _purchaseOrder.GetOtherCharges(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSuppliers(string query)
        {
            var viewModels = new POVM();
            viewModels.SupplierName = query;
            var responseQuery = await _purchaseOrder.GetSuppliers(GetUser(), viewModels);

            if (responseQuery == null)
            {
                responseQuery = new List<POVM>();
            }
            var formattedData = responseQuery.Select(item => new
            {
                label = item.SupplierName,
                value = item.SupplierId,
                value2 = item.Currency,
                value3 = item.PaymentTerms,
                value4 = item.PaymentTermsId,
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetPRWOCanvass(POVM viewModels)
        {
            response = await _purchaseOrder.GetPRWOCanvass(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPOItemDetail(POVM viewModels)
        {
             response = await _purchaseOrder.GetPOItemDetail(GetUser(), viewModels);
             return GetResponse(response);
        }
        public async Task<IActionResult> GetIncotermsByName(string query)
        {
            var viewModels = new POVM();
            viewModels.IncotermsName = query;
            response = await _purchaseOrder.GetIncotermsByName(GetUser(), viewModels);
            if (response == null)
            {
                response = new List<POVM>();
            }
            var formattedData = response.Select(item => new
            {
                label = item.IncotermsName,
                value = item.IncotermsId
            });

            return Json(new { success = true, data = formattedData });
        }
        public async Task<IActionResult> GetIncoterms(POVM viewModels)
        {
            response = await _purchaseOrder.GetIncoterms(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRPOSummaryReport(POVM viewModels)
        {
            response = await _purchaseOrder.GetPRPOSummaryReport(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRPOSummaryItem(POVM viewModels)
        {
            response = await _purchaseOrder.GetPRPOSummaryItem(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetIndexCard(POVM viewModel)
        {
            response = await _purchaseOrder.
                   GetIndexCard(GetUser(), viewModel);
            return GetResponse(response);
        }
        #endregion
        #region Views
        public IActionResult GetShippingInstructions(int id)
        {
            return ViewComponent("ShippingInstructions", new { shippingInstructionId = id });
        }
        public IActionResult GetPOTable(int id)
        {
            return ViewComponent("POTable", new { tableId = id });
        }
        public IActionResult GetPOReference(int id)
        {
            return ViewComponent("POReference", new { referenceId = id });
        }
        public IActionResult GetCustomFormPOElem(int id)
        {
            return ViewComponent("CustomFormPOElemVC", new { poTypeId = id });
        }
        public IActionResult GetPOReportTable(int id)
        {
            return ViewComponent("POReportTableVC", new { tableId = id });
        }
        public IActionResult GetIndexCardTable()
        {
            return ViewComponent("IndexCardTableVC");
        }
        //IndexCardTableVC
        public async Task<IActionResult> Index()
        {        
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CustomPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> Bidding()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> POPrepApproval()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> ApprovedPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> POArchived()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CentralPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CreatedPO()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> PutPONo()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> PRPOSummaryReport()
        {
            return await IsAuthenTicated();
        }
        #endregion
    }
}