public async Task Should_Success_Delete_Approval_Non_PO()
        {
            CashierApprovalService service = new CashierApprovalService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            VbRequestModel         model   = await _dataUtil(service).GetTestData();

            CashierApprovalViewModel data = new CashierApprovalViewModel()
            {
                VBRequestCategory = "NONPO",
                CashierApproval   = new List <CashierApprovalItemViewModel>()
                {
                    new CashierApprovalItemViewModel()
                    {
                        VBNo = model.VBNo,
                        Id   = model.Id
                    }
                }
            };
            var acceptedResponse = await service.CashierAproval(data);

            var newModel = await service.ReadByIdAsync(model.Id);

            var deleteResponse = await service.DeleteCashierAproval(newModel.Id);

            Assert.NotEqual(0, deleteResponse);
        }
        public async Task <ActionResult> Post([FromBody] CashierApprovalViewModel viewModel)
        {
            try
            {
                VerifyUser();
                ValidateService.Validate(viewModel);

                await Service.CashierAproval(viewModel);

                return(NoContent());
            }
            catch (ServiceValidationException e)
            {
                Dictionary <string, object> Result =
                    new ResultFormatter(ApiVersion, General.BAD_REQUEST_STATUS_CODE, General.BAD_REQUEST_MESSAGE)
                    .Fail(e);
                return(BadRequest(Result));
            }
            catch (AggregateException ex)
            {
                string message = string.Join(',', ex.InnerExceptions.Select(x => x.Message));
                Dictionary <string, object> Result =
                    new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, message)
                    .Fail();
                return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
            }
            catch (Exception e)
            {
                Dictionary <string, object> Result =
                    new ResultFormatter(ApiVersion, General.INTERNAL_ERROR_STATUS_CODE, e.Message)
                    .Fail();
                return(StatusCode(General.INTERNAL_ERROR_STATUS_CODE, Result));
            }
        }
        public Task <int> CreateAsync(VbRequestModel model, CashierApprovalViewModel viewmodel)
        {
            EntityExtension.FlagForCreate(model, IdentityService.Username, UserAgent);

            DbContext.VbRequests.Add(model);

            return(DbContext.SaveChangesAsync());
        }
        public async Task <int> CashierAproval(CashierApprovalViewModel data)
        {
            int updated = 0;

            using (var transaction = DbContext.Database.BeginTransaction())
            {
                try
                {
                    List <string> approvals = new List <string>();

                    if (data.VBRequestCategory.Equals("PO"))
                    {
                        foreach (var item in data.CashierApproval)
                        {
                            approvals.Add(item.VBNo);
                            VbRequestModel model = DbContext.VbRequests.Single(x => x.Id == item.Id);
                            model.Apporve_Status  = true;
                            model.Complete_Status = false;
                            model.ApproveDate     = DateTimeOffset.UtcNow;
                            model.Amount          = item.Amount;

                            EntityExtension.FlagForUpdate(model, IdentityService.Username, UserAgent);
                        }

                        updated = await DbContext.SaveChangesAsync();
                    }
                    else if (data.VBRequestCategory.Equals("NONPO"))
                    {
                        foreach (var item in data.CashierApproval)
                        {
                            approvals.Add(item.VBNo);
                            VbRequestModel model = DbContext.VbRequests.Single(x => x.Id == item.Id);
                            model.Apporve_Status  = true;
                            model.Complete_Status = false;
                            model.ApproveDate     = DateTimeOffset.UtcNow;

                            EntityExtension.FlagForUpdate(model, IdentityService.Username, UserAgent);
                        }

                        updated = await DbContext.SaveChangesAsync();
                    }
                    transaction.Commit();
                }
                catch (Exception e)
                {
                    transaction.Rollback();
                    throw e;
                }
            }

            return(updated);
        }
        public CashierApprovalViewModel GetDataToValidate()
        {
            CashierApprovalViewModel TestData = new CashierApprovalViewModel()
            {
                VBRequestCategory = "NONPO",
                CashierApproval   = new List <CashierApprovalItemViewModel> {
                    new CashierApprovalItemViewModel {
                        Id   = 10,
                        VBNo = "VBNo"
                    }
                }
            };

            return(TestData);
        }
        public async Task Should_Fail_Post_Approval_Non_PO()
        {
            CashierApprovalService service = new CashierApprovalService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            VbRequestModel         model   = await _dataUtil(service).GetTestData();

            CashierApprovalViewModel data = new CashierApprovalViewModel()
            {
                VBRequestCategory = "NONPO",
                CashierApproval   = new List <CashierApprovalItemViewModel>()
                {
                    new CashierApprovalItemViewModel()
                    {
                        VBNo = model.VBNo,
                        Id   = model.Id
                    }
                }
            };

            await Assert.ThrowsAnyAsync <Exception>(() => service.CashierAproval(null));
        }
        public async Task Should_Success_Post_Approval_With_PO()
        {
            CashierApprovalService service = new CashierApprovalService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            VbRequestModel         model   = await _dataUtil(service).GetTestData();

            CashierApprovalViewModel data = new CashierApprovalViewModel()
            {
                VBRequestCategory = "PO",
                CashierApproval   = new List <CashierApprovalItemViewModel>()
                {
                    new CashierApprovalItemViewModel()
                    {
                        VBNo   = model.VBNo,
                        Id     = model.Id,
                        Amount = model.Amount,
                    }
                }
            };

            var response = await service.CashierAproval(data);

            Assert.NotEqual(0, response);
        }