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();
}
}
