public async Task <IActionResult> Search([FromQuery] PaginationParams param, FilterPackingListParam filterParam)
        {
            var lists = await _service.Search(param, filterParam);

            Response.AddPagination(lists.CurrentPage, lists.PageSize, lists.TotalCount, lists.TotalPages);
            return(Ok(lists));
        }
        public async Task <List <WMSB_Packing_List> > SearchNotPagination(FilterPackingListParam filterParam)
        {
            var packingSearch = _repoPackingList.GetAll();

            if (filterParam.From_Date != null && filterParam.To_Date != null)
            {
                packingSearch = packingSearch.
                                Where(x => x.Receive_Date >= DateTime.Parse(filterParam.From_Date + " 00:00:00.000") &&
                                      x.Generated_QRCode.Trim() == "N" &&
                                      x.Receive_Date <= DateTime.Parse(filterParam.To_Date + " 23:59:59.000")
                                      );
            }
            if (filterParam.MO_No != null && filterParam.MO_No != string.Empty)
            {
                packingSearch = packingSearch.Where(x => x.MO_No.Trim() == filterParam.MO_No.Trim());
            }
            return(await packingSearch.ToListAsync());
        }
Exemple #3
0
        public async Task<PagedList<IntegrationInputModel>> SearchIntegrationInput(PaginationParams param, FilterPackingListParam filterparam)
        {
            var pred_Packing_Lists = PredicateBuilder.New<WMSB_Packing_List>(true);
            pred_Packing_Lists.And(x => x.Generated_QRCode.Trim() == "Y");
            if (!String.IsNullOrEmpty(filterparam.MO_No)) {
                pred_Packing_Lists.And(x => x.MO_No.Trim() == filterparam.MO_No.Trim());
            }
            if (filterparam.Supplier_ID != null && filterparam.Supplier_ID != "All") {
                pred_Packing_Lists.And(x => x.Supplier_ID.Trim() == filterparam.Supplier_ID.Trim());
            }
            if (filterparam.From_Date != null && filterparam.To_Date != null) {
                pred_Packing_Lists.And(x => x.Receive_Date >= Convert.ToDateTime(filterparam.From_Date + " 00:00:00.000") &&
                    x.Receive_Date <= Convert.ToDateTime(filterparam.To_Date + " 23:59:59.997"));
            }
            var packingLists = await _repoPackingList.FindAll(pred_Packing_Lists).ToListAsync();
            var conn = await _database.CreateConnectionAsync();
            var qrCodeMains = conn.Query<WMSB_QRCode_Main>("Select * from WMSB_QRCode_Main where Is_Scanned = 'N'").ToList();
            var qrCodeMainDetail = conn.Query<WMSB_QRCode_Detail>("Select * from WMSB_QRCode_Detail").ToList();
            var data = (from a in packingLists
                        join b in qrCodeMains
                        on a.Receive_No.Trim() equals b.Receive_No.Trim()
                        join c in qrCodeMainDetail on b.QRCode_ID.Trim() equals c.QRCode_ID.Trim()
                        select new IntegrationInputModel()
                        {
                            Receive_No = a.Receive_No,
                            QRCode_Version = b.QRCode_Version,
                            QRCode_ID = b.QRCode_ID,
                            MO_No = a.MO_No,
                            Purchase_No = a.Purchase_No,
                            MO_Seq = a.MO_Seq,
                            Material_ID = a.Material_ID,
                            Material_Name = a.Material_Name,
                            Supplier_ID = a.Supplier_ID,
                            Supplier_Name = a.Supplier_Name,
                            Receive_Qty = c.Qty
                        }).GroupBy(x => x.QRCode_ID).Select(z => new IntegrationInputModel()
                        {
                            Receive_No = z.FirstOrDefault().Receive_No,
                            QRCode_Version = z.FirstOrDefault().QRCode_Version,
                            Purchase_No = z.FirstOrDefault().Purchase_No,
                            QRCode_ID = z.FirstOrDefault().QRCode_ID,
                            MO_No = z.FirstOrDefault().MO_No,
                            MO_Seq = z.FirstOrDefault().MO_Seq,
                            Material_ID = z.FirstOrDefault().Material_ID,
                            Material_Name = z.FirstOrDefault().Material_Name,
                            Supplier_ID = z.FirstOrDefault().Supplier_ID,
                            Supplier_Name = z.FirstOrDefault().Supplier_Name,
                            Receive_Qty = z.Sum(k => k.Receive_Qty)
                        }).ToList();

            var receiveNos = data.Select(x => x.Receive_No.Trim()).ToList();
            var packingListDetails = conn
                                .Query<WMSB_PackingList_Detail>("Select * from WMSB_PackingList_Detail where Receive_No IN @receiveNos", new {receiveNos = receiveNos})
                                .ToList();
            foreach (var item in data)
            {
                item.PackingListDetailItem = packingListDetails.Where(x => x.Receive_No.Trim() == item.Receive_No.Trim()).ToList();
            }

            return PagedList<IntegrationInputModel>.Create(data, param.PageNumber, param.PageSize,false);
        }
        public async Task <PagedList <WMSB_Packing_List> > Search(PaginationParams param, FilterPackingListParam filterParam)
        {
            var pred_Packing_List = PredicateBuilder.New <WMSB_Packing_List>(true);

            pred_Packing_List.And(x => x.Generated_QRCode.Trim() == "N");
            if (filterParam.From_Date != null && filterParam.To_Date != null)
            {
                pred_Packing_List.And(x => x.Receive_Date >= DateTime.Parse(filterParam.From_Date + " 00:00:00.000") &&
                                      x.Receive_Date <= DateTime.Parse(filterParam.To_Date + " 23:59:59.000"));
            }
            if (!String.IsNullOrEmpty(filterParam.MO_No))
            {
                pred_Packing_List.And(x => x.MO_No.Trim() == filterParam.MO_No.Trim());
            }
            if (filterParam.Supplier_ID != "All" && !String.IsNullOrEmpty(filterParam.Supplier_ID))
            {
                pred_Packing_List.And(x => x.Supplier_ID.Trim() == filterParam.Supplier_ID.Trim());
            }
            var data = _repoPackingList.FindAll(pred_Packing_List);

            return(await PagedList <WMSB_Packing_List> .CreateAsync(data, param.PageNumber, param.PageSize, false));
        }
        public async Task <IActionResult> SearchIntegrationInput([FromQuery] PaginationParams param, FilterPackingListParam filterparam)
        {
            var result = await _service.SearchIntegrationInput(param, filterparam);

            Response.AddPagination(result.CurrentPage, result.PageSize, result.TotalCount, result.TotalPages);
            return(Ok(result));
        }
        public async Task <IActionResult> SearchNotPagination(FilterPackingListParam filterParam)
        {
            var lists = await _service.SearchNotPagination(filterParam);

            return(Ok(lists));
        }
        public async Task <PagedList <WMSB_Packing_List> > SearchViewModel(PaginationParams param, FilterPackingListParam filterParam)
        {
            var packingSearch = _repoPackingList.GetAll();

            if (filterParam.From_Date != null && filterParam.To_Date != null)
            {
                packingSearch = packingSearch.
                                Where(x => x.Receive_Date >= DateTime.Parse(filterParam.From_Date + " 00:00:00.000") &&
                                      x.Generated_QRCode.Trim() == "N" &&
                                      x.Receive_Date <= DateTime.Parse(filterParam.To_Date + " 23:59:59.000")
                                      );
            }
            if (filterParam.MO_No != null && filterParam.MO_No != string.Empty)
            {
                packingSearch = packingSearch.Where(x => x.MO_No.Trim() == filterParam.MO_No.Trim());
            }
            return(await PagedList <WMSB_Packing_List> .CreateAsync(packingSearch, param.PageNumber, param.PageSize));
        }