private void PayOrder(InvoicePaymentProvider invoicePaymentProvider) { InvoiceWebhook invoiceWebhook = _invoiceWebhookDomainService.CreateInvoiceWebhook(invoicePaymentProvider, DateTime.Now); try { Invoice invoice = _invoiceRepository.GetAllIncluding(x => x.Order).Single(x => x.Id == invoicePaymentProvider.InvoceId); if (invoice.Order.Status.Status == OrderStatus.OrderStatusValue.PaymentPending) { _orderDomainService.PayOrder(invoice.Order); switch (invoice.Order.Type.Type) { case OrderType.OrderTypeValue.Subscription: _eventBus.Trigger(new OrderSubscriptionPayedEventData(invoice.Order)); break; case OrderType.OrderTypeValue.RenewSubscription: _eventBus.Trigger(new OrderRenewSubscriptionPayedEventData(invoice.Order)); break; } } } catch (Exception ex) { Logger.Error("Ocurrio un error al Pagar una Orden.", ex); _invoiceWebhookDomainService.ChangeToError(invoiceWebhook); } finally { _invoiceWebhookRepository.Insert(invoiceWebhook); } }
public void WebhookMobbex([FromQuery] Guid invoiceId, [FromQuery] int status, [FromQuery] string transactionId) { if (status == 200) { InvoicePaymentProvider invoicePaymentProvider = _invoicePaymentProviderRepository.Single(x => x.InvoceId == invoiceId && x.PaymentProvider.Provider == PaymentProvider.PaymentProviderValue.Mobbex); PayOrder(invoicePaymentProvider); } }
public async Task WebhookPaypal([FromQuery] string token) { Guid invoiceId = await _paypalService.ConfirmOrder(token); InvoicePaymentProvider invoicePaymentProvider = _invoicePaymentProviderRepository.Single(x => x.InvoceId == invoiceId && x.Transaction == token); PayOrder(invoicePaymentProvider); }
public InvoiceWebhook CreateInvoiceWebhook(InvoicePaymentProvider invoicePaymentProvider, DateTime datenow) { return(new InvoiceWebhook { CreationTime = datenow, InvocePaymentProviderId = invoicePaymentProvider.Id, Status = new InvoiceWebhookStatus(InvoiceWebhookStatus.InvoiceWebhookStatusValue.Done) }); }
public async Task <InvoicePaymentProvider> UpdateAmountInvoice(InvoicePaymentProvider invoicePaymentProvider, Domain.Entities.Orders.Order order) { PayPalEnvironment environment = CreateEnvironment(); var client = new PayPalHttpClient(environment); var getOrderRequest = new OrdersGetRequest(invoicePaymentProvider.Transaction); try { var getOrderResponse = await client.Execute(getOrderRequest); var getOrderResult = getOrderResponse.Result <PaypalOrder>(); var payment = new OrderRequest() { CheckoutPaymentIntent = "CAPTURE", PurchaseUnits = new List <PurchaseUnitRequest>() { new PurchaseUnitRequest() { CustomId = getOrderResult.PurchaseUnits[0].CustomId, Description = getOrderResult.PurchaseUnits[0].Description, AmountWithBreakdown = new AmountWithBreakdown() { CurrencyCode = Currency.CurrencyValue.USD.ToString(), Value = Convert.ToInt32(order.TotalAmount).ToString() } } }, ApplicationContext = CreateApplicationContext() }; var request = new OrdersCreateRequest(); request.Prefer("return=representation"); request.RequestBody(payment); var response = await client.Execute(request); var result = response.Result <PaypalOrder>(); var uri = new Uri(result.Links.Single(l => l.Rel == "approve").Href); await CancelInvoice(invoicePaymentProvider); invoicePaymentProvider.Link = uri; invoicePaymentProvider.Transaction = result.Id; return(invoicePaymentProvider); } catch (HttpException httpException) { var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault(); throw httpException; } }
public async Task CancelInvoice(InvoicePaymentProvider invoice) { PayPalEnvironment environment = CreateEnvironment(); var client = new PayPalHttpClient(environment); var request = new OrderDeleteRequest(invoice.Transaction); try { await client.Execute(request); } catch (HttpException httpException) { var debugId = httpException.Headers.GetValues("PayPal-Debug-Id").FirstOrDefault(); } }
public async Task <OrderDto> CreateOrder(CreateOrderInput input) { Order order = _mapper.Map <Order>(input); _repository.Insert(order); Invoice invoice = _invoiceDomainService.CreateInvoice(order, DateTime.Now); _invoiceDomainService.ActiveInvoice(invoice); _invoiceRepository.Insert(invoice); InvoicePaymentProvider invoicePaymentProvider = order.Currency.Code switch { Domain.ValueObjects.Currency.CurrencyValue.USD => await _paypalService.CreateUriForPayment(invoice, order, input.Description), Domain.ValueObjects.Currency.CurrencyValue.ARS => await _mobbexService.CreateUriForPayment(invoice, order, input.Description), _ => throw new NotImplementedException() }; invoicePaymentProvider = _invoicePaymentProviderRepository.Insert(invoicePaymentProvider); return(_mapper.Map <OrderDto>(order)); }
public async Task <SubscriptionOrderDto> CreateSubscription(CreateSubscriptionInput input) { PlanPrice planPrice = _planPriceRepository.Get(input.PlanPriceId); if (planPrice.IsNull()) { throw new UserFriendlyException("No existe un PlanPrice con ese Id"); } Plan plan = _planRepository.Get(planPrice.PlanId); Subscription actualSubscriptions = _subscriptionRepository.GetSubscriptionPlanActive(input.UserId, plan.ProductId); if (actualSubscriptions.IsNotNull()) { throw new UserFriendlyException("El usuario ya esta suscripto a un Plan del mismo producto."); } Subscription subscription = _subscriptionDomainService.CreateSubscription(plan); subscription = _subscriptionRepository.Insert(subscription); SubscriptionCycle subscriptionCycle = _subscriptionCycleDomainService.CreateSubscriptionCycle(subscription, DateTime.Now); _subscriptionCycleDomainService.PaymentPendingSubscriptionCycle(subscriptionCycle); subscriptionCycle = _subscriptionCycleRepository.Insert(subscriptionCycle); Order order = _orderDomainService.CreateOrderForSubscription(planPrice, input.UserId, DateTime.Now); _orderDomainService.PaymentPendingOrder(order); order = _orderRepository.Insert(order); SubscriptionCycleOrder subscriptionCycleOrder = _subscriptionCycleOrderDomainService.CreateSubscriptionCycleOrder(subscriptionCycle, order); _subscriptionCycleOrderRepository.Insert(subscriptionCycleOrder); Invoice invoice = _invoiceDomainService.CreateInvoice(order, DateTime.Now); _invoiceDomainService.ActiveInvoice(invoice); _invoiceRepository.Insert(invoice); InvoicePaymentProvider invoicePaymentProvider = planPrice.Currency.Code switch { Domain.ValueObjects.Currency.CurrencyValue.USD => await _paypalService.CreateUriForPayment(invoice, order, plan), Domain.ValueObjects.Currency.CurrencyValue.ARS => await _mobbexService.CreateUriForPayment(invoice, order, plan), _ => throw new NotImplementedException() }; invoicePaymentProvider = _invoicePaymentProviderRepository.Insert(invoicePaymentProvider); return(new SubscriptionOrderDto { Subscription = _mapper.Map <SubscriptionDto>(subscription), SubscriptionCycle = _mapper.Map <SubscriptionCycleDto>(subscriptionCycle), SubscriptionCycleOrder = _mapper.Map <SubscriptionCycleOrderDto>(subscriptionCycleOrder), Order = _mapper.Map <OrderDto>(order), InvoicePaymentProvider = _mapper.Map <InvoicePaymentProviderDto>(invoicePaymentProvider), }); } }
public async Task HandleEventAsync(OrderSubscriptionPayedEventData eventData) { PlanPrice planPrice = _planPriceRepository.GetByOrder(eventData.Entity); IEnumerable <Order> paymentPendingOrders = _orderRepository.GetPendingPayments(planPrice.Plan, eventData.Entity.UserId); foreach (Order order in paymentPendingOrders) { Order orderToUpdate = null; SubscriptionCycleOrder subscriptionCycleOrder = null; SubscriptionCycle subscriptionCycle = null; Subscription subscription = null; if (order.Id == eventData.Entity.Id) { orderToUpdate = _orderRepository.Get(eventData.Entity.Id); subscriptionCycleOrder = _subscriptionCycleOrderRepository.GetAll().Single(x => x.OrderId == orderToUpdate.Id); subscriptionCycle = _subscriptionCycleRepository.Get(subscriptionCycleOrder.SubscriptionCycleId); subscription = _subscriptionRepository.Get(subscriptionCycle.SubscriptionId); _orderDomainService.PayOrder(orderToUpdate); _subscriptionDomainService.ActiveSubscription(subscription); _subscriptionCycleDomainService.ActiveSubscriptionCycle(subscriptionCycle, DateTime.Now, planPrice.Plan.Duration); Invoice invoice = _invoiceRepository.Single(x => x.OrderId == order.Id); _invoiceDomainService.PayInvoice(invoice); _invoiceRepository.Update(invoice); Notification notification = _notificationDomainService.CreateNotification(orderToUpdate); _notificationDomainService.SetOrderPayed(notification); _noticationRepository.Insert(notification); NotificationDto notificationDto = _mapper.Map <NotificationDto>(notification); HttpResponseMessage httpResponse = await _httpClient.PostAsJsonAsync(_clientOptions.NotificactionUrl, notificationDto); if (httpResponse.IsSuccessStatusCode) { _noticationRepository.Delete(notification); } else { _notificationDomainService.AddAttempt(notification); _noticationRepository.Update(notification); } } else { orderToUpdate = _orderRepository.Get(order.Id); subscriptionCycleOrder = _subscriptionCycleOrderRepository.GetAll().Single(x => x.OrderId == orderToUpdate.Id); subscriptionCycle = _subscriptionCycleRepository.Get(subscriptionCycleOrder.SubscriptionCycleId); subscription = _subscriptionRepository.Get(subscriptionCycle.SubscriptionId); _subscriptionDomainService.CancelSubscription(subscription); _subscriptionCycleDomainService.CancelSubscriptionCycle(subscriptionCycle); _orderDomainService.CancelOrder(orderToUpdate); Invoice invoice = _invoiceRepository.GetAllIncluding(x => x.InvocePaymentProviders).Single(x => x.OrderId == order.Id); _invoiceDomainService.CancelInvoice(invoice); _invoiceRepository.Update(invoice); PaymentProvider.PaymentProviderValue paymentProviderValue = order.Currency.Code == Currency.CurrencyValue.USD ? PaymentProvider.PaymentProviderValue.Paypal : PaymentProvider.PaymentProviderValue.Mobbex; InvoicePaymentProvider invoicePaymentProvider = invoice.InvocePaymentProviders.Single(x => x.PaymentProvider.Provider == paymentProviderValue); switch (order.Currency.Code) { case Currency.CurrencyValue.ARS: await _mobbexService.CancelInvoice(invoicePaymentProvider); break; case Currency.CurrencyValue.USD: await _paypalService.CancelInvoice(invoicePaymentProvider); break; default: throw new NotImplementedException(); } } _subscriptionRepository.Update(subscription); _subscriptionCycleRepository.Update(subscriptionCycle); _orderRepository.Update(orderToUpdate); } }
public InvoicePaymentProviderDto GetInvoicePaymentProviderByOrder(Guid orderId) { InvoicePaymentProvider invoicePaymentProveider = _invoicePaymentProviderRepository.GetByOrder(orderId); return(_mapper.Map <InvoicePaymentProviderDto>(invoicePaymentProveider)); }
public Task <InvoicePaymentProvider> UpdateAmountInvoice(InvoicePaymentProvider invoicePaymentProvider, Order order) { throw new System.NotImplementedException(); }
public async Task CancelInvoice(InvoicePaymentProvider invoice) { await _apiGateway.DeleteAsync <object>(Path.Combine(ENDPOINT, invoice.Transaction)); }
public async Task CreateNewSubscriptionCycles() { var subscriptionCycles = _subscriptionCycleRepository.GetSoonExpires(DateTime.Now, _clientOptions.OrderDaysToExpire); foreach (var cycle in subscriptionCycles) { using var unitOfWork = UnitOfWorkManager.Begin(); SubscriptionCycle newCycle = _subscriptionCycleDomainService.CreateSubscriptionCycle(cycle.Subscription, DateTime.Now); _subscriptionCycleDomainService.PaymentPendingSubscriptionCycle(newCycle); _subscriptionCycleRepository.Insert(newCycle); Order oldOrder = _orderRepository.GetBySubscriptionCycle(cycle); PlanPrice planPrice = cycle.Subscription.Plan.PlanPrices.Single(x => x.Currency.Code == oldOrder.Currency.Code); Order order = _orderDomainService.CreateOrderForRenewSubscription(planPrice, oldOrder.UserId, DateTime.Now); _orderDomainService.PaymentPendingOrder(order); order = _orderRepository.Insert(order); SubscriptionCycleOrder subscriptionCycleOrder = _subscriptionCycleOrderDomainService.CreateSubscriptionCycleOrder(newCycle, order); _subscriptionCycleOrderRepository.Insert(subscriptionCycleOrder); Invoice invoice = _invoiceDomainService.CreateInvoice(order, DateTime.Now); _invoiceDomainService.ActiveInvoice(invoice); _invoiceRepository.Insert(invoice); InvoicePaymentProvider invoicePaymentProvider = planPrice.Currency.Code switch { Domain.ValueObjects.Currency.CurrencyValue.USD => await _paypalService.CreateUriForPayment(invoice, order, cycle.Subscription.Plan), Domain.ValueObjects.Currency.CurrencyValue.ARS => await _mobbexService.CreateUriForPayment(invoice, order, cycle.Subscription.Plan), _ => throw new NotImplementedException() }; _invoicePaymentProviderRepository.Insert(invoicePaymentProvider); Notification notification = _notificationDomainService.CreateNotification(order); _notificationDomainService.SetNewSubscribeCycle(notification); _noticationRepository.Insert(notification); NotificationDto notificationDto = _mapper.Map <NotificationDto>(notification); HttpResponseMessage httpResponse = await _httpClient.PostAsJsonAsync(_clientOptions.NotificactionUrl, notificationDto); if (httpResponse.IsSuccessStatusCode) { _noticationRepository.Delete(notification); } else { _notificationDomainService.AddAttempt(notification); _noticationRepository.Update(notification); } unitOfWork.Complete(); } }