public async Task Should_Success_Get_Report_Include_Previous_Month()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            data.Mutation     = unitData.DPP + unitData.PPN;
            data.Date         = data.Date.AddMonths(1);
            var memoData = _dataUtil(service).GetMemoPostedViewModel();

            memoData.SupplierCode = unitData.SupplierCode;
            memoData.SupplierName = unitData.SupplierName;
            memoData.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var nextMonthUnitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            nextMonthUnitData.Date = nextMonthUnitData.Date.AddMonths(1);
            await service.CreateFromUnitReceiptNoteAsync(nextMonthUnitData);

            await service.CreateFromMemoAsync(memoData);

            var reportResponse = service.GetReport(1, 25, data.SupplierName, nextMonthUnitData.Date.Month, nextMonthUnitData.Date.Year, 7);

            Assert.NotEmpty(reportResponse.Item1.Data);
        }
        public async Task Should_Success_Put_UnitPaymentOrder()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = "UPOputTest";
            data.Code         = "UPOcodePutTest";
            data.InvoiceNo    = null;
            var Response = await service.CreateFromUnitReceiptNoteAsync(data);

            var newData = await service.GetByUnitReceiptNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.Null(newData.InvoiceNo);
            CreditorAccountUnitPaymentOrderPostedViewModel postedData = new CreditorAccountUnitPaymentOrderPostedViewModel()
            {
                InvoiceNo        = "InvoiceNo",
                CreditorAccounts = new List <CreditorAccountPostedViewModel>()
                {
                    newData
                }
            };
            var updateResponse = await service.UpdateFromUnitPaymentOrderAsync(postedData);

            var updateData = await service.GetByUnitReceiptNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.NotNull(updateData);
        }
        public async Task Should_Success_Get_Report_Correction()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);


            var reportResponse = service.GetReport(1, 25, data.SupplierName, data.Date.Month, data.Date.Year, 7);

            var test = reportResponse.Item1.Data.FirstOrDefault();
            await service.CreateFromUnitPaymentCorrection(new CreditorAccountUnitPaymentCorrectionPostedViewModel()
            {
                UnitReceiptNoteNo = test.UnitReceiptNoteNo, UnitPaymentCorrectionNo = "test"
            });

            service.GetReport(1, 25, data.SupplierName, data.Date.Month, data.Date.Year, 7);
            Assert.NotEmpty(reportResponse.Item1.Data);
        }
        public async Task Should_Success_Post_UnitReceiptNote()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();
            var Response = await service.CreateFromUnitReceiptNoteAsync(data);

            var newData = await service.GetByUnitReceiptNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.NotNull(newData);
        }
        public async Task Should_Return_1_IfNotFound()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = "";
            data.SupplierName = "";
            data.InvoiceNo    = "";
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var newData = await service.GetByBankExpenditureNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.Null(newData);
        }
        public async Task Should_Success_Get_Report_NoRate()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            unitData.CurrencyRate = 0;
            data.SupplierCode     = unitData.SupplierCode;
            data.SupplierName     = unitData.SupplierName;
            data.InvoiceNo        = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var reportResponse = service.GetReport(1, 25, data.SupplierName, data.Date.Month, data.Date.Year, 7);

            Assert.NotEmpty(reportResponse.Item1.Data);
        }
        public async Task Should_Success_Get_Excel_Impor()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            CreditBalanceService   creditBalanceService = new CreditBalanceService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetUnitReceiptNotePostedViewModel();

            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var reportResponse = creditBalanceService.GenerateExcel(true, data.SupplierName, data.Date.Month, data.Date.Year, 7);

            Assert.NotNull(reportResponse);
        }
        public async Task Should_Success_Get_Report_January()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            CreditBalanceService   creditBalanceService = new CreditBalanceService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetUnitReceiptNotePostedViewModel();

            unitData.Date     = new DateTimeOffset(unitData.Date.Year, 1, unitData.Date.Day, unitData.Date.Hour, unitData.Date.Minute, unitData.Date.Second, unitData.Date.Offset);
            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var reportResponse = creditBalanceService.GetReport(true, 1, 25, unitData.SupplierName, unitData.Date.Month, unitData.Date.Year, 7);

            Assert.NotEmpty(reportResponse.Data);
        }
        public async Task Should_Success_Get_Report_ForeignCurrency()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            CreditBalanceService   creditBalanceService = new CreditBalanceService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetUnitReceiptNotePostedViewModel();

            unitData.Currency = "USD";
            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var reportResponse = creditBalanceService.GetReport(false, 1, 25, data.SupplierName, data.Date.Month, data.Date.Year, 7, true);

            Assert.NotEmpty(reportResponse.Data);
        }
        public async Task Should_Success_GetFinalBalance()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            data.Mutation     = unitData.DPP + unitData.PPN;

            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);


            var reportResponse = service.GetFinalBalance(data.SupplierName, data.Date.Month, data.Date.Year, 7);

            Assert.True(0 == reportResponse);
        }
Exemple #11
0
        public async Task Should_Success_Get_Report()
        {
            //Arrange
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            CreditBalanceService   creditBalanceService = new CreditBalanceService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            //Act
            var reportResponse = creditBalanceService.GetReport(false, 1, 25, "", data.Date.Month, data.Date.Year, 7, false, 11);

            //Assert
            Assert.NotNull(reportResponse.Data);
        }
        public async Task Should_Success_Put_BankExpenditureNote()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetNewData_UnitReceiptNotePostedViewModel();

            data.SupplierCode = unitData.SupplierCode;
            data.SupplierName = unitData.SupplierName;
            data.InvoiceNo    = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var newData = await service.GetByBankExpenditureNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.NotNull(newData);
            newData.Mutation = 10000;
            var updateResponse = await service.UpdateFromBankExpenditureNoteAsync(newData);

            var updateData = await service.GetByBankExpenditureNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.NotNull(updateData);
        }
Exemple #13
0
        public async Task Should_Success_Delete_BankExpenditureNoteList()
        {
            CreditorAccountService service = new CreditorAccountService(GetServiceProvider().Object, _dbContext(GetCurrentMethod()));
            var data     = _dataUtil(service).GetBankExpenditureNotePostedViewModel();
            var unitData = _dataUtil(service).GetUnitReceiptNotePostedViewModel();

            unitData.SupplierCode += "deleted";
            unitData.SupplierName += "deleted";
            unitData.InvoiceNo    += "deletd";
            data.SupplierCode      = unitData.SupplierCode;
            data.SupplierName      = unitData.SupplierName;
            data.InvoiceNo         = unitData.InvoiceNo;
            var tempResponse = await service.CreateFromUnitReceiptNoteAsync(unitData);

            var Response = await service.CreateFromBankExpenditureNoteAsync(data);

            var newData = await service.GetByBankExpenditureNote(data.SupplierCode, data.Code, data.InvoiceNo);

            var deleteResponse = await service.DeleteFromBankExpenditureNoteListAsync(newData.Code);

            var deleteData = await service.GetByBankExpenditureNote(data.SupplierCode, data.Code, data.InvoiceNo);

            Assert.Null(deleteData);
        }