Example #1
0
        public async Task <IActionResult> PaymentReturnAmount(int paymentId, [FromBody] PaymentReturnAmountRequestDto requestDto)
        {
            if (!ModelState.IsValid)
            {
                throw new ValidationException("Model is not valid.");
            }

            var responseDto = await _executor.GetCommand <PaymentReturnAmountCommand>()
                              .Process(q => q.ExecuteAsync(paymentId, requestDto));

            return(Ok(responseDto));
        }
Example #2
0
        public async Task <PaymentReturnAmountResponseDto> ExecuteAsync(int paymentId, PaymentReturnAmountRequestDto requestDto)
        {
            var responseDto = new PaymentReturnAmountResponseDto();

            var paymentRepository       = Uow.GetRepository <Payment>();
            var paymentUseRepository    = Uow.GetRepository <PaymentUse>();
            var paymentStatusRepository = Uow.GetRepository <DicPaymentStatus>();

            var user = _executor.GetQuery <GetUserByIdQuery>()
                       .Process(q => q.Execute(NiisAmbientContext.Current.User.Identity.UserId));

            var payment = await paymentRepository
                          .AsQueryable()
                          .Include(p => p.PaymentUses)
                          .FirstOrDefaultAsync(p => p.Id == paymentId);

            var paymentDto = _mapper.Map <Payment, PaymentDto>(payment);

            responseDto.PaymentUsesExist = paymentUseRepository
                                           .AsQueryable()
                                           .Any(pu => pu.PaymentId == paymentId && !pu.IsDeleted);

            var paymentReminderAmountRnd = decimal.Round(paymentDto.RemainderAmount, 2);
            var returnAmountRnd          = decimal.Round(requestDto.ReturnAmount, 2);

            if (requestDto.ReturnFullAmount)
            {
                if (!responseDto.PaymentUsesExist)
                {
                    payment.ReturnedAmount = payment.Amount;
                    payment.ReturnedDate   = DateTimeOffset.Now;
                    payment.EmployeeNameReturnedPayment = $"{user.NameRu} {user.Position?.NameRu}";
                    payment.ReturnedReason = requestDto.ReturnReason;
                    paymentRepository.Update(payment);
                    Uow.SaveChanges();

                    responseDto.Success = true;
                }
            }
            else
            {
                if (returnAmountRnd <= paymentReminderAmountRnd + payment.ReturnedAmount.GetValueOrDefault())
                {
                    payment.ReturnedAmount = returnAmountRnd;
                    payment.ReturnedDate   = DateTimeOffset.Now;
                    payment.EmployeeNameReturnedPayment = $"{user.NameRu} {user.Position?.NameRu}";
                    payment.ReturnedReason = requestDto.ReturnReason;
                    paymentRepository.Update(payment);
                    Uow.SaveChanges();

                    responseDto.Success = true;
                }
                else
                {
                    responseDto.ReturnAmountIsGreaterThanPaymentReminder = true;
                }
            }

            if (responseDto.Success)
            {
                _executor.GetCommand <UpdatePaymentStatusCommand>()
                .Process(c => c.Execute(payment.Id));
            }

            return(responseDto);
        }