public RequestHandler(SubscriptionsContext dbContext, UserContext userContext, IStripeService stripeService, ILogger <RequestHandler> logger)
{
_dbContext = dbContext;
_userContext = userContext;
_stripeService = stripeService;
_logger = logger;
}
public void ShouldSubscribeForTopics()
{
//Arrange
const string user = "******";
const int expectedSubscriptions = 2;
const int expectedUsers = 1;
Guid resultToken;
//Act
using (var context = new SubscriptionsContext(options))
{
var service = new SubscriptionService(context);
resultToken = service.SubscribeAsync(user, new [] { 1, 3 }).Result;
}
//Assert
using (var context = new SubscriptionsContext(options))
{
Assert.AreEqual(expectedSubscriptions, context.Subscriptions.Count());
Assert.AreEqual(expectedUsers, context.Users.Count());
Assert.AreNotEqual(Guid.Empty, resultToken);
}
//TODO: Values of the records should be checked as well
}
public SubscriptionChangedEventHandler(SubscriptionsContext dbContext, IStripeService stripeService, IOptions <StripeSettings> settings, ILogger <SubscriptionChangedEventHandler> logger)
{
_dbContext = dbContext;
_stripeService = stripeService;
_stripeSettings = settings.Value;
_logger = logger;
}
public RequestHandler(SubscriptionsContext dbContext, UserContext userContext, IStripeService stripeService, IOptions <StripeSettings> settings, ILogger <RequestHandler> logger)
{
_dbContext = dbContext;
_userContext = userContext;
_stripeService = stripeService;
_logger = logger;
_settings = settings.Value;
}
public UserContext(SubscriptionsContext dbContext)
{
var user = dbContext.ApplicationUser.SingleOrDefault(e => e.Id == Guid.Parse("07b742cc-8c82-43b6-8615-de54635db929"));
if (user != null)
{
Id = user.Id;
EmailAddress = user.EmailAddress;
CustomerId = user.CustomerId;
}
}
public static async Task <bool> UserHasPlanAsync(SubscriptionsContext subscriptionsContext, string userId)
{
if (userId is null)
{
throw new System.ArgumentNullException(nameof(userId));
}
var hasActiveSubscription = await subscriptionsContext.Subscription
.AnyAsync(x => x.Customer.IdentityKey == userId && x.Status.Id == SubscriptionStatus.Active.Id);
return(hasActiveSubscription);
}
public void TestInitialize()
{
this.options = new DbContextOptionsBuilder <SubscriptionsContext>()
.UseInMemoryDatabase(databaseName: "SubscriptionsTest").Options;
using (var context = new SubscriptionsContext(options))
{
context.Topics.AddRange(new List <Topic>
{
new Topic {
TopicId = 1, DisplayName = "topic one"
},
new Topic {
TopicId = 2, DisplayName = "topic two"
},
new Topic {
TopicId = 3, DisplayName = "topic three"
}
});
context.SaveChanges();
}
}
public TopicsService(SubscriptionsContext dbContext)
{
this.dbContext = dbContext;
}
public RequestHandler(SubscriptionsContext dbContext, UserContext userContext, ILogger <RequestHandler> logger)
{
_dbContext = dbContext;
_userContext = userContext;
_logger = logger;
}
public TopicsController(SubscriptionsContext dbContext, ITopicsService topicsService)
{
this.topicsService = topicsService;
}
public RequestHandler(SubscriptionsContext dbContext, UserContext userContext)
{
_dbContext = dbContext;
_userContext = userContext;
}
public static async Task <Subscription> ExecAsync(SubscriptionsContext dbContext, IStripeService stripeService, string subscriptionId, StripeSettings settings, ILogger logger)
{
logger.LogInformation("Processing EnsureSubscriptionCommand for {StripeSubscriptionId}", subscriptionId);
var subscription = await dbContext.Subscription.FirstOrDefaultAsync(e => e.ExternalKey == subscriptionId);
var stripeSubscription = await stripeService.GetSubscriptionAsync(subscriptionId);
await semaphoreSlim.WaitAsync();
try
{
hasSubscription = subscription != null;
if (!hasSubscription)
{
subscription = await dbContext.Subscription.FirstOrDefaultAsync(e => e.ExternalKey == subscriptionId);
hasSubscription = subscription != null;
if (!hasSubscription)
{
logger.LogWarning("Creating subscription while processing EnsureSubscriptionCommand for {StripeSubscriptionId}", subscriptionId);
var customer = await dbContext.Customer.FirstOrDefaultAsync(e => e.ExternalKey == stripeSubscription.CustomerId);
var plan = await dbContext.Plan.FirstOrDefaultAsync(x => x.ExternalKey == settings.DefaultPlanKey);
subscription = new Subscription(subscriptionId, plan);
customer.AddSubscription(subscription);
dbContext.Subscription.Add(subscription);
hasSubscription = true;
}
}
var status = SubscriptionStatus.FindByName(stripeSubscription.Status);
dbContext.Entry(status).State = EntityState.Unchanged;
subscription.CurrentPeriodStart = stripeSubscription.CurrentPeriodStart;
subscription.CurrentPeriodEnd = stripeSubscription.CurrentPeriodEnd;
subscription.CancelAtPeriodEnd = stripeSubscription.CancelAtPeriodEnd;
subscription.Status = status;
subscription.LastModifiedDateTime = DateTime.Now;
await dbContext.SaveChangesAsync();
logger.LogInformation("Finished processing EnsureSubscriptionCommand for {StripeSubscriptionId} with {ApplicationSubscriptionId}", subscriptionId, subscription.Id);
}
catch (Exception ex)
{
logger.LogError(ex, "Error while processing EnsureSubscriptionCommand for {StripeSubscriptionId}", subscriptionId);
}
finally
{
semaphoreSlim.Release();
}
return(subscription);
}
public static async Task <Invoice> ExecAsync(SubscriptionsContext dbContext, IStripeService stripeService, string invoiceId, ILogger logger)
{
logger.LogInformation("Processing EnsureInvoiceCommand for {StripeInvoiceId}", invoiceId);
var invoice = await dbContext.Invoice.FirstOrDefaultAsync(e => e.ExternalKey == invoiceId);
var stripeInvoice = await stripeService.GetInvoiceAsync(invoiceId);
await semaphoreSlim.WaitAsync();
try
{
hasInvoice = invoice != null;
if (!hasInvoice)
{
logger.LogWarning("Creating invoice while processing EnsureInvoiceCommand for {StripeInvoiceId}", invoiceId);
invoice = await dbContext.Invoice.FirstOrDefaultAsync(e => e.ExternalKey == invoiceId);
hasInvoice = invoice != null;
if (!hasInvoice)
{
logger.LogInformation("Creating invoice for {StripeInvoiceId}", invoiceId);
var subscription = await dbContext.Subscription
.Include(x => x.Customer)
.FirstOrDefaultAsync(e => e.ExternalKey == stripeInvoice.SubscriptionId);
invoice = subscription.AddInvoice(invoiceId, subscription.Customer.Id, stripeInvoice.Number);
dbContext.Invoice.Add(invoice);
hasInvoice = true;
}
}
var status = InvoiceStatus.FindByName(stripeInvoice.Status);
dbContext.Entry(status).State = EntityState.Unchanged;
invoice.AmountRemainingInCents = (int)stripeInvoice.AmountRemaining;
invoice.AmountDueInCents = (int)stripeInvoice.AmountDue;
invoice.AmountPaidInCents = (int)stripeInvoice.AmountPaid;
invoice.CurrencyCode = stripeInvoice.Currency;
invoice.HostedInvoiceUrl = stripeInvoice.HostedInvoiceUrl;
invoice.InvoicePdfUrl = stripeInvoice.InvoicePdf;
invoice.IsPaid = stripeInvoice.Paid;
invoice.ReceiptNumber = stripeInvoice.ReceiptNumber;
invoice.PeriodStart = stripeInvoice.PeriodStart;
invoice.PeriodEnd = stripeInvoice.PeriodEnd;
invoice.Total = (int)stripeInvoice.Total;
invoice.Status = status;
invoice.LastModifiedDateTime = DateTime.Now;
await dbContext.SaveChangesAsync();
logger.LogInformation("Finished processing EnsureInvoiceCommand for {StripeInvoiceId} with {ApplicationInvoiceId} and {StripeSubscriptionId}", invoiceId, invoice.Id, stripeInvoice.SubscriptionId);
}
catch (Exception ex)
{
logger.LogError(ex, "Error while processing EnsureInvoiceCommand for {StripeInvoiceId}", invoiceId);
}
finally
{
semaphoreSlim.Release();
}
return(invoice);
}
public CheckoutSessionCompletedEventHandler(SubscriptionsContext dbContext, ILogger <CheckoutSessionCompletedEventHandler> logger)
{
_dbContext = dbContext;
_logger = logger;
}
public SubscriptionController(SubscriptionsContext context, ILogger <SubscriptionController> logger)
{
_context = context;
_logger = logger;
}
