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