예제 #1
0
        public SmsPaymentStatus?GetOrderPaymentStatus(IUnitOfWork uow, int orderId)
        {
            SmsPayment smsPaymentAlias = null;

            var orders = uow.Session.QueryOver(() => smsPaymentAlias)
                         .Where(() => smsPaymentAlias.Order.Id == orderId)
                         .List();

            if (orders.Any(x => x.SmsPaymentStatus == SmsPaymentStatus.Paid))
            {
                return(SmsPaymentStatus.Paid);
            }

            if (orders.Any(x => x.SmsPaymentStatus == SmsPaymentStatus.WaitingForPayment))
            {
                return(SmsPaymentStatus.WaitingForPayment);
            }

            if (orders.Any(x => x.SmsPaymentStatus == SmsPaymentStatus.Cancelled))
            {
                return(SmsPaymentStatus.Cancelled);
            }

            return(null);
        }
예제 #2
0
        public SmsPaymentDTO CreateSmsPaymentDTO(SmsPayment smsPayment, Order order)
        {
            var newSmsPaymentDTO = new SmsPaymentDTO {
                Recepient           = smsPayment.Recepient.Name,
                RecepientId         = smsPayment.Recepient.Id,
                PhoneNumber         = smsPayment.PhoneNumber,
                PaymentStatus       = SmsPaymentStatus.WaitingForPayment,
                OrderId             = smsPayment.Order.Id,
                PaymentCreationDate = smsPayment.CreationDate,
                Amount        = smsPayment.Amount,
                RecepientType = smsPayment.Recepient.PersonType,
                Items         = new List <SmsPaymentItemDTO>()
            };

            foreach (var orderItem in order.OrderItems)
            {
                newSmsPaymentDTO.Items.Add(new SmsPaymentItemDTO {
                    Name     = orderItem.Nomenclature.OfficialName,
                    Quantity = orderItem.CurrentCount,
                    Price    = orderItem.Sum / orderItem.Count
                });
            }

            return(newSmsPaymentDTO);
        }
        public SmsPaymentDTO CreateSmsPaymentDTO(IUnitOfWork uow, SmsPayment smsPayment, Order order, PaymentFrom paymentFrom)
        {
            var newSmsPaymentDTO = new SmsPaymentDTO
            {
                Recepient           = smsPayment.Recepient.Name,
                RecepientId         = smsPayment.Recepient.Id,
                PhoneNumber         = smsPayment.PhoneNumber,
                PaymentStatus       = SmsPaymentStatus.WaitingForPayment,
                OrderId             = smsPayment.Order.Id,
                PaymentCreationDate = smsPayment.CreationDate,
                Amount         = smsPayment.Amount,
                RecepientType  = smsPayment.Recepient.PersonType,
                Items          = GetCalculatedSmsPaymentItemDTOs(order.OrderItems),
                OrganizationId = _organizationProvider.GetOrganization(uow, order, paymentFrom, PaymentType.ByCard).Id
            };

            return(newSmsPaymentDTO);
        }
예제 #4
0
        public PaymentResult SendPayment(int orderId, string phoneNumber)
        {
            _logger.Info($"Поступил запрос на отправку платежа с данными orderId: {orderId}, phoneNumber: {phoneNumber}");
            if (orderId <= 0)
            {
                _logger.Error("Запрос на отправку платежа пришёл с неверным значением номера заказа");
                return(new PaymentResult("Неверное значение номера заказа"));
            }
            if (String.IsNullOrWhiteSpace(phoneNumber))
            {
                _logger.Error("Запрос на отправку платежа пришёл с неверным значение номера телефона");
                return(new PaymentResult("Неверное значение номера телефона"));
            }
            phoneNumber = phoneNumber.TrimStart('+').TrimStart('7').TrimStart('8');
            if (String.IsNullOrWhiteSpace(phoneNumber) ||
                phoneNumber.Length == 0 ||
                phoneNumber.First() != '9' ||
                phoneNumber.Length != 10)
            {
                _logger.Error("Запрос на отправку платежа пришёл с неверным форматом номера телефона");
                return(new PaymentResult("Неверный формат номера телефона"));
            }
            phoneNumber = $"+7{phoneNumber}";

            try
            {
                using (IUnitOfWork uow = UnitOfWorkFactory.CreateWithoutRoot()) {
                    var order = uow.GetById <Order>(orderId);
                    if (order == null)
                    {
                        _logger.Error($"Запрос на отправку платежа пришёл со значением номера заказа, не существующем в базе (Id: {orderId})");
                        return(new PaymentResult($"Заказ с номером {orderId} не существующет в базе"));
                    }
                    var newPayment = new SmsPayment {
                        Amount       = order.OrderSum,
                        Order        = order,
                        Recepient    = order.Client,
                        CreationDate = DateTime.Now,
                        PhoneNumber  = phoneNumber
                    };
                    if (!order.DeliveryDate.HasValue)
                    {
                        _logger.Error("Запрос на отправку платежа пришёл без даты доставки");
                        return(new PaymentResult("Нельзя отправить платеж на заказ, в котором не указана дата доставки"));
                    }
                    if (order.OrderDepositItems.Any())
                    {
                        _logger.Error("Запрос на отправку платежа пришёл с возвратами залогов");
                        return(new PaymentResult("Нельзя отправить платеж на заказ, в котором есть возврат залогов"));
                    }
                    if (!order.OrderItems.Any())
                    {
                        _logger.Error("Запрос на отправку платежа пришёл без товаров на продажу");
                        return(new PaymentResult("Нельзя отправить платеж на заказ, в котором нет товаров на продажу"));
                    }
                    if (order.OrderItems.Any(x => x.Price < 0))
                    {
                        _logger.Error("Запрос на отправку платежа пришёл с товаром с ценой меньше 0");
                        return(new PaymentResult("Нельзя отправить платеж на заказ, в котором есть товары с ценой меньше 0"));
                    }
                    if (newPayment.Amount < 1)
                    {
                        _logger.Error("Запрос на отправку платежа пришёл с суммой заказа меньше 1 рубля");
                        return(new PaymentResult("Нельзя отправить платеж на заказ, сумма которого меньше 1 рубля"));
                    }

                    newPayment.SetReadyToSend();
                    var paymentDto = _smsPaymentDTOFactory.CreateSmsPaymentDTO(uow, newPayment, order,
                                                                               uow.GetById <PaymentFrom>(_orderParametersProvider.PaymentByCardFromSmsId));

                    if (!_smsPaymentValidator.Validate(paymentDto, out var errorMessages))
                    {
                        _logger.Error($"Оплата для заказа №{paymentDto.OrderId} не прошла валидацию:\n\t{string.Join("\n\t", errorMessages)}");
                        return(new PaymentResult(string.Join("\n", errorMessages)));
                    }

                    uow.Save(newPayment);
                    uow.Commit();

                    var sendResponse = _paymentController.SendPayment(paymentDto);

                    if (sendResponse.HttpStatusCode == HttpStatusCode.OK && sendResponse.ExternalId.HasValue)
                    {
                        newPayment.SetWaitingForPayment();
                        newPayment.ExternalId = sendResponse.ExternalId.Value;

                        try {
                            uow.Save(newPayment);
                            uow.Commit();
                            _logger.Info($"Создан новый платеж с данными: ExternalId: {newPayment.ExternalId}, orderId: {newPayment.Order.Id}, phoneNumber: {newPayment.PhoneNumber}");
                        }
                        catch (Exception e) {
                            _logger.Error(e, "Не получилось сохранить платёж с ExternalId, записываю данные во временный файл...");
                            _smsPaymentFileCache.WritePaymentCache(newPayment.Id, sendResponse.ExternalId.Value);
                        }
                    }
                    else
                    {
                        return(new PaymentResult("Сервис отправки платежей не смог отправить платеж."
                                                 + (sendResponse.HttpStatusCode.HasValue ? $" Http код: {sendResponse.HttpStatusCode}" : "")));
                    }
                }
            }
            catch (Exception ex) {
                _logger.Error(ex, $"Ошибка при отправке платежа (orderId: {orderId}, phoneNumber: {phoneNumber})");
                return(new PaymentResult($"Ошибка при отправке платежа. {ex}"));
            }
            return(new PaymentResult(SmsPaymentStatus.WaitingForPayment));
        }
예제 #5
0
        public void SynchronizePaymentStatuses()
        {
            try
            {
                _logger.Info("Запущен процесс синхронизации статусов платежей");

                using (var uow = UnitOfWorkFactory.CreateWithoutRoot())
                {
                    RouteListItem routeListItemAlias = null;
                    Order         orderAlias         = null;
                    SmsPayment    smsPaymentAlias    = null;
                    RouteList     routeListAlias     = null;

                    var payments = uow.Session.QueryOver <SmsPayment>(() => smsPaymentAlias)
                                   .Inner.JoinAlias(() => smsPaymentAlias.Order, () => orderAlias)
                                   .JoinEntityAlias(() => routeListItemAlias, () => routeListItemAlias.Order.Id == orderAlias.Id, JoinType.LeftOuterJoin)
                                   .Left.JoinAlias(() => routeListItemAlias.RouteList, () => routeListAlias)
                                   .Where(() => smsPaymentAlias.SmsPaymentStatus == SmsPaymentStatus.WaitingForPayment)
                                   .And(Restrictions.Disjunction()
                                        .Add(Restrictions.Eq(Projections.Property(() => routeListAlias.Id), null))
                                        .Add(() => routeListAlias.Status != RouteListStatus.Closed))
                                   .List <SmsPayment>();

                    int count = 0;
                    foreach (var payment in payments)
                    {
                        var actualStatus = _paymentController.GetPaymentStatus(payment.ExternalId);
                        if (actualStatus == null || actualStatus == payment.SmsPaymentStatus)
                        {
                            continue;
                        }

                        switch (actualStatus.Value)
                        {
                        case SmsPaymentStatus.WaitingForPayment:
                            payment.SetWaitingForPayment();
                            break;

                        case SmsPaymentStatus.Paid:
                            payment.SetPaid(uow, DateTime.Now, uow.GetById <PaymentFrom>(_orderParametersProvider.PaymentByCardFromSmsId));
                            break;

                        case SmsPaymentStatus.Cancelled:
                            payment.SetCancelled();
                            break;

                        default:
                            throw new ArgumentOutOfRangeException();
                        }

                        uow.Save(payment);
                        uow.Commit();
                        count++;
                    }

                    _logger.Info(payments.Count == 0
                                                ? $"Не найдено ни одного платежа для синхронизации"
                                                : $"Синхронизировано {count} статусов платежей");
                }
            }
            catch (Exception ex) {
                _logger.Error(ex, "При синхронизации произошла ошибка");
            }
        }