public async Task <WrapperMonthPayableListVM> MonthlyPayable(MonthlyReport vm)
        {
            vm.To   = vm.To.ToLocalTime();
            vm.From = vm.From.ToLocalTime();

            WrapperMonthPayableListVM returnData = new WrapperMonthPayableListVM();

            Task <List <Payable> > payableT = _repositoryWrapper
                                              .Payable
                                              .FindAll()
                                              .Where(x => x.FactoryId == vm.FactoryId)
                                              //.Where(x => x.Month == vm.Month)
                                              .Where(x => x.CreatedDateTime >= vm.From)
                                              .Where(x => x.CreatedDateTime <= vm.To)
                                              .Include(x => x.Supplier)
                                              .ToListAsync();
            await payableT;
            Task <List <Payable> > payableT_1 = _repositoryWrapper
                                                .Payable
                                                .FindAll()
                                                .Where(x => x.FactoryId == vm.FactoryId)
                                                //.Where(x => x.Month == vm.Month)
                                                .Where(x => x.CreatedDateTime >= vm.From)
                                                .Where(x => x.CreatedDateTime <= vm.To)
                                                .Include(x => x.Customer)
                                                .ToListAsync();
            await payableT_1;
            Task <List <Payable> > payableT_2 = _repositoryWrapper
                                                .Payable
                                                .FindAll()
                                                .Where(x => x.FactoryId == vm.FactoryId)
                                                .Where(x => x.CreatedDateTime >= vm.From)
                                                .Where(x => x.CreatedDateTime <= vm.To)
                                                //.Where(x => x.Month == vm.Month)
                                                .Include(x => x.Staff)
                                                .ToListAsync();
            await payableT_2;
            //await Task.WhenAll(payableT, payableT_1, payableT_2);
            List <Payable> lst = payableT.Result.ToList();

            lst = _utilService.ConcatList <Payable>(payableT.Result.ToList(), _utilService.ConcatList <Payable>(payableT_1.Result.ToList(), payableT_2.Result.ToList()));
            List <MonthlyPayable> monthlyPayable = new List <MonthlyPayable>();

            monthlyPayable = _utilService.Mapper.Map <List <Payable>, List <MonthlyPayable> >(lst);



            returnData.TotalRecords = monthlyPayable.ToList().Count();
            returnData.ListOfData   = monthlyPayable;
            MonthlyPayable lastRow = new MonthlyPayable();

            lastRow.Amount = returnData.ListOfData.Sum(x => (x.Amount));

            returnData.ListOfData = monthlyPayable
                                    .OrderByDescending(x => x.CreatedDateTime)
                                    .Skip((vm.PageNumber - 1) * (vm.PageSize))
                                    .Take(vm.PageSize)

                                    .ToList();

            returnData.Total_TillNow = lastRow.Amount;
            returnData.Total_Monthly = returnData.ListOfData.Sum(x => (x.Amount));

            returnData.ListOfData.Add(lastRow);



            return(returnData);
        }