NonInventPurchasingSystem/CPRNIMS.WebApps/Controllers/Canvass/CanvassMgmtController.cs

using CPRNIMS.Domain.UIContracts.Account;
using CPRNIMS.Domain.UIContracts.Canvass;
using CPRNIMS.Infrastructure.Dto.Canvass.Request;
using CPRNIMS.Infrastructure.Dto.Common;
using CPRNIMS.Infrastructure.Helper;
using CPRNIMS.Infrastructure.ViewModel.Canvass;
using CPRNIMS.WebApps.Controllers.Base;
using Microsoft.AspNetCore.Mvc;

namespace CPRNIMS.WebApps.Controllers.Canvass
{
    public class CanvassMgmtController : BaseMethod
    {
        List<CanvassVM>? response;
        private readonly ICanvass _canvass;
        public CanvassMgmtController(TokenHelper tokenHelper, ErrorLogHelper errorMessageService,
         IWebHostEnvironment webHostEnvironment
         , ICanvass canvass,IAccount account
            )
         : base(errorMessageService, webHostEnvironment, tokenHelper, account)
        {
            _canvass = canvass;       
        }
        #region POST PUT 
        public async Task<IActionResult> PostSupplierForCanvass(CanvassVM viewModel)
        {
            var response = await _canvass.PostSupplierForCanvass(GetUser(), viewModel);

            if (response.messCode != 0)
            {
                return Json(new { success = true });
            }
            return Json(new { success = false, response = response.errMessage });
        }
        public async Task<IActionResult> PostCanvass(CanvassVM viewModel, List<CanvassList> CanvassList)
        {
            if (CanvassList.Count > 0)
            {
                viewModel.CanvassList = new CanvassList
                {
                    PRDetailsId = CanvassList.SelectMany(ic => ic.PRDetailsId).ToList(),
                    ItemNo = CanvassList.SelectMany(ic => ic.ItemNo).ToList(),
                    PRNo = CanvassList.SelectMany(ic => ic.PRNo).ToList(),
                };
                var postPutItem = await _canvass.PostCanvass(GetUser(), viewModel);
                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true });
                }
            }
            else
            {
                return Json(new { success = false, response = "Array Empty" });
            }
            return Json(new { success = false });
        }     
        public async Task<IActionResult> PostPutSupplier(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.PostPutSupplier(GetUser(), viewModel);

            if (postPutItem.messCode != 0)
            {
                return Json(new { success = true });
            }
            return Json(new { success = false, response = postPutItem.errMessage });
        }
        public async Task<IActionResult> PostTaggingSupplier(CanvassVM viewModel, 
            List<SupplierList> SupplierList)
        {
            var postPutItem = new CanvassVM();
            if (SupplierList.Count > 0)
            {
                viewModel.SupplierList = new SupplierList
                {
                    SupplierId = SupplierList.SelectMany(ic => ic.SupplierId).ToList(),
                };
                postPutItem = await _canvass.PostTaggingSupplier(GetUser(), viewModel);
                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true });
                }
            }
            else
            {
                return Json(new { success = false, response = "Array Empty" });
            }
            return Json(new { success = false });
        }
        public async Task<IActionResult> PostPutItemTagging(CanvassVM viewModel, 
            List<ItemList> ItemList)
        {

            if (ItemList.Count > 0)
            {
                viewModel.ItemList = new ItemList
                {
                    ItemNo = ItemList.SelectMany(ic => ic.ItemNo).ToList(),
                };
                var  postPutItem = await _canvass.PostPutItemTagging(GetUser(), viewModel);
                if (postPutItem.messCode != 0)
                {
                    return Json(new { success = true });
                }
            }
            else
            {
                return Json(new { success = false, response = "Array Empty" });
            }
            return Json(new { success = false });
        }
        public async Task<IActionResult> PostApprovedSupp(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.PostApprovedSupp(GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.errMessage });
        }
        public async Task<IActionResult> PostSuggestedSupp(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.PostSuggestedSupp(GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.errMessage });
        }
        public async Task<IActionResult> PutSuppUnitPrice(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.PutSuppUnitPrice(GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.errMessage });
        }
        public async Task<IActionResult> PutSuppBidDetails(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.PutSuppBidDetails(GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.errMessage });
        }
        public async Task<IActionResult> PostPutMySupplier(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.PostPutMySupplier(GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.errMessage });
        }
        public async Task<IActionResult> UnlockFormLink(CanvassVM viewModel)
        {
            var postPutItem = await _canvass.UnlockFormLink(GetUser(), viewModel);

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

            return Json(new { success = false, Response = postPutItem.errMessage });
        }
        [HttpPost]
        public async Task<IActionResult> StartCanvass([FromBody] StartCanvassRequest request)
        {
            if (request?.Items == null || request.Items.Count == 0)
                return Json(new { success = false, response = "Array Empty" });

            var viewModel = new CanvassVM
            {
                ForSupplierSearchList = new ForSupplierSearchList
                {
                    PRDetailsId = request.Items.Select(i => i.PRDetailsId).ToList(),
                    PRNo = request.Items.Select(i => i.PRNo).ToList(),
                    ItemNo = request.Items.Select(i => i.ItemNo).ToList(),
                    ItemDescription = request.Items.Select(i => i.ItemDescription).ToList(),
                    ItemName = request.Items.Select(i => i.ItemName).ToList(),
                },
                IsInternational = request.IsInternational
            };

            var result = await _canvass.StartCanvass(GetUser(), viewModel);
            if (result.messCode != 0)
                return Json(new { success = true });

            return Json(new { success = false });
        }
        #endregion
        #region Get
        public async Task<IActionResult> GetItemSupplierWOEmail(long PRNo)
        {
            var viewModels = new CanvassVM();
            viewModels.PRNo = PRNo;
            response = await _canvass.GetItemSupplierWOEmail(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierById(CanvassVM viewModel)
        {
            response = await _canvass.GetSupplierById(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierItemWOEmail(long ItemNo)
        {
            var viewModels = new CanvassVM();
            viewModels.ItemNo = ItemNo;
            response = await _canvass.GetSupplierItemWOEmail(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCanvassPerSupplier(string searchPRNo = "", string searchItemNo = "",
           string searchSupplier = "", string searchItemName = "", int pageNumber = 1, int pageSize = 10)
        {
            var dto = new CanvassVM
            {
                SearchPRNo = searchPRNo,
                SearchItemName = searchItemName,
                SearchItemNo = searchItemNo,
                SearchSupplier = searchSupplier,
                PageNumber = pageNumber,
                PageSize = pageSize
            };

            var result = await _canvass.GetCanvassPerSupplier(GetUser(), dto);
            int draw = int.TryParse(Request.Query["draw"], out int d) ? d : 1;

            return Json(new
            {
                draw = draw,
                recordsTotal = result.TotalCount,
                recordsFiltered = result.TotalCount,
                data = result.Data,
                supplierList = result.SupplierList
            });
        }
        public async Task<IActionResult> GetItemsForTagging(string searchPRNo = "", string searchItemNo = "",
         string searchItemName = "",string searchDepartment="", int pageNumber = 1, int pageSize = 10)
        {
            var dto = new CanvassVM
            {
                SearchPRNo = searchPRNo,
                SearchItemName = searchItemName,
                SearchItemNo = searchItemNo,
                SearchDepartment = searchDepartment,
                PageNumber = pageNumber,
                PageSize = pageSize
            };

            var result = await _canvass.GetItemsForTagging(GetUser(), dto);
            int draw = int.TryParse(Request.Query["draw"], out int d) ? d : 1;

            return Json(new
            {
                draw = draw,
                recordsTotal = result.TotalCount,
                recordsFiltered = result.TotalCount,
                data = result.Data,
                departmentList = result.DepartmentList
            });
        }
        public async Task<IActionResult> GetCanvassPerSupplierEmail(CanvassVM viewModel)
        {
            response = await _canvass.GetCanvassPerSupplierEmail(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCanvassPerSupplierId(CanvassVM viewModel)
        {
            response = await _canvass.GetCanvassPerSupplierId(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBid(CanvassVM viewModels)
        {
            response = await _canvass.GetSupplierBid(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetAlternativeOfferByPRDetailId(CanvassVM viewModels)
        {
            response = await _canvass.GetAlternativeOfferByPRDetailId(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBidByItem(CanvassVM viewModel)
        {
            response = await _canvass.GetSupplierBidByItem(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetSupplierBidById(CanvassVM viewModel)
        {
            response = await _canvass.GetSupplierBidById(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCanvassByPRNo(long PRNo)
        {
            var viewModels = new CanvassVM();
            viewModels.PRNo = PRNo;
            response = await _canvass.GetCanvassByPRNo(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCanvassById()
        {
            var viewModels = new CanvassVM();
            response = await _canvass.GetCanvassById(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRItemList()
        {
            var viewModels = new CanvassVM();
            response = await _canvass.GetPRItemList(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRItem(long ItemNo)
        {
            var viewModels = new CanvassVM();
            viewModels.ItemNo = ItemNo;
            response = await _canvass.GetPRItem(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCanvassWOResponse()
        {
            var viewModels = new CanvassVM();
            response = await _canvass.GetCanvassWOResponse(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetWOResponseBySuppId(CanvassVM viewModels)
        {
            response = await _canvass.GetWOResponseBySuppId(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetForCanvassPerItem()
        {
            var viewModels = new CanvassVM();
            response = await _canvass.GetForCanvassPerItem(GetUser(), viewModels);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetPRListByPRNo(CanvassVM viewModel)
        {
            response = await _canvass.
                     GetPRListByPRNo(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetMySuppliers(CanvassVM viewModel)
        {
            response = await _canvass.
                   GetMySuppliers(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetMyPRWOCanvass(CanvassVM viewModel)
        {
            response = await _canvass.
                   GetMyPRWOCanvass(GetUser(), viewModel);
            return GetResponse(response);
        }
        public async Task<IActionResult> GetCanvassGroupByPRNo(CanvassVM viewModel)
        {
            response = await _canvass.
                   GetCanvassGroupByPRNo(GetUser(), viewModel);
            return GetResponse(response);
        }
        #endregion
        #region Views
        public IActionResult GetCanvassingTabPage(int id)
        {
            return ViewComponent("CanvassingTabPage", new { canvassingTabPageId = id });
        }
        public async Task<IActionResult> Suppliers()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> WOResponse()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> Canvass()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> SupplierBid()
        {
            return await IsAuthenTicated();
        }
        public async Task<IActionResult> CanvassReport()
        {           
            return await IsAuthenTicated();
        }
        #endregion
    }
}