public async Task <DownPaymentModel> GetTestDataById()
        {
            DownPaymentModel model = GetNewData();
            await Service.CreateAsync(model);

            return(await Service.ReadByIdAsync(model.Id));
        }
Пример #2
0
        public async Task <IActionResult> GetDownPaymentPDF([FromRoute] int Id)
        {
            try
            {
                var indexAcceptPdf     = Request.Headers["Accept"].ToList().IndexOf("application/pdf");
                int timeoffsset        = Convert.ToInt32(Request.Headers["x-timezone-offset"]);
                DownPaymentModel model = await _service.ReadByIdAsync(Id);

                if (model == null)
                {
                    Dictionary <string, object> Result =
                        new ResultFormatter(ApiVersion, General.NOT_FOUND_STATUS_CODE, General.NOT_FOUND_MESSAGE)
                        .Fail();
                    return(NotFound(Result));
                }
                else
                {
                    DownPaymentViewModel viewModel = _mapper.Map <DownPaymentViewModel>(model);

                    DownPaymentPDFTemplate PdfTemplate = new DownPaymentPDFTemplate();
                    MemoryStream           stream      = PdfTemplate.GeneratePdfTemplate(viewModel, timeoffsset);
                    return(new FileStreamResult(stream, "application/pdf")
                    {
                        FileDownloadName = "Kuitansi - " + viewModel.Buyer.Name + ".pdf"
                    });
                }
            }
            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 void Should_Success_Map_DownPayment()
        {
            var mapper = new MapperConfiguration(configuration => configuration.AddProfile <DownPaymentProfile>()).CreateMapper();
            var model  = new DownPaymentModel();
            var vm     = mapper.Map <DownPaymentViewModel>(model);

            Assert.NotNull(vm);
        }
Пример #4
0
        public Task <int> UpdateAsync(int id, DownPaymentModel model)
        {
            EntityExtension.FlagForUpdate(model, _identityService.Username, UserAgent);

            _dbContext.DownPayments.Update(model);

            return(_dbContext.SaveChangesAsync());
        }
Пример #5
0
        public Task <int> CreateAsync(DownPaymentModel model)
        {
            model.DocumentNo = GetDownPaymentNo(model);

            EntityExtension.FlagForCreate(model, _identityService.Username, UserAgent);

            _dbContext.DownPayments.Add(model);

            return(_dbContext.SaveChangesAsync());
        }
Пример #6
0
        private string GetDownPaymentNo(DownPaymentModel model)
        {
            var now   = DateTime.Now;
            var year  = now.ToString("yy");
            var month = now.ToString("MM");

            var documentNo = $"{year}{month}MEM{model.BuyerCode}";

            var countSameDocumentNo = _dbContext.DownPayments.Count(entity => entity.DocumentNo.Contains(documentNo));

            if (countSameDocumentNo > 0)
            {
                documentNo += _alphabets[countSameDocumentNo];
            }

            return(documentNo);
        }
        public async Task CreateOrUpdateAsync(DownPaymentModel downPayment)
        {
            using (var context = _msSqlContextFactory.CreateDataContext())
            {
                var existingReferral =
                    await context.DownPayments.FirstOrDefaultAsync(e => e.ReferralLeadId == downPayment.ReferralLeadId);

                if (existingReferral != null)
                {
                    context.DownPayments.Update(_mapper.Map <DownPaymentEntity>(downPayment));
                    await context.SaveChangesAsync();

                    return;
                }

                await context.DownPayments.AddAsync(_mapper.Map <DownPaymentEntity>(downPayment));

                await context.SaveChangesAsync();
            }
        }
        public DownPaymentModel GetNewData()
        {
            DownPaymentModel TestData = new DownPaymentModel()
            {
                DocumentNo       = "DocumentNo",
                AccountName      = "AccountName",
                AccountNumber    = "AccountNumber",
                BankName         = "BankName",
                CodeBankCurrency = "CodeBankCurrency",
                BuyerId          = 1,
                BuyerName        = "BuyerName",
                BuyerCode        = "BuyerCode",
                CurrencyId       = 1,
                CurrencyCode     = "USD",
                CurrencyRate     = 14447,
                DatePayment      = DateTimeOffset.UtcNow,
                PaymentFor       = "PaymentFor",
                Remark           = "Remark",
                TotalPayment     = 14447,
            };

            return(TestData);
        }
Пример #9
0
        public async Task <(bool IsSuccessful, string Message)> ProcessDownPaymentAsync(DownPaymentModel downPayment)
        {
            var existingDownPayment = await _downPaymentRepository.GetByReferralLeadIdAsync(downPayment.ReferralLeadId);

            if (existingDownPayment != null)
            {
                return(false, $"Down-payment for referral '{downPayment.ReferralLeadId}' already exists.");
            }

            if (!string.IsNullOrEmpty(downPayment.ReferralLeadId))
            {
                var result = await _referralClient.ReferralLeadApi.AddRealEstatePurchase(new RealEstatePurchaseRequest
                {
                    ReferralId = downPayment.ReferralLeadId,
                    Timestamp  = downPayment.Timestamp
                });

                if (result.ErrorCode != RealEstatePurchaseErrorCode.None)
                {
                    var message = $"The Referral Real estate creation failed with error code '{result.ErrorCode}'";
                    _log.Error(message: message, context: downPayment);

                    return(false, message);
                }

                //// Commented to avoid double bonuses. Down-payment should not trigger bonus payment.
                //// Down-payment amount will be received in the first installment.
                //
                // await _referralDownPaymentEventPublisher.PublishAsync(new ReferralRealEstatePurchasePaymentEvent
                // {
                //     CustomerId = downPayment.ReferrerId,
                //     ReferralId = downPayment.ReferralLeadId,
                //     InstallmentAmount = downPayment.FirstInstallmentAmount,
                //     CurrencyCode = downPayment.CurrencyCode,
                //     NetPropertyAmount = downPayment.NetPropertyPrice,
                //     PurchaseCompletionAmount = downPayment.FirstInstallmentAmount,
                //     PurchaseCompletionPercentage = downPayment.DownPaymentPercentage,
                //     IsDownPayment = true,
                //     CampaignId = result.CampaignId,
                //     UnitLocationCode = downPayment.UnitLocationCode
                // });
            }

            await _downPaymentRepository.CreateOrUpdateAsync(downPayment);

            return(true, string.Empty);
        }