/* The job simply looks for ALL subscriptions that need to be
 charged, and then tries to charge a fee. We don’t know how, when,
 and how often we will run the job yet. But we don’t need those
 parameters in order to look at how to implement the job itself.
 Also since we want to process the payments sequentially, but 
 don’t know how many will have to be processed, we can code it to 
 just charge until all the job is complete in an infinite loop. */

while (true)
{
    /* Every payment should perform within its own scope 
       (database context and shared memory) to avoid any potential
       mistake when one thread is affecting another. */
    using var scope = _serviceScopeFactory.CreateScope();
    var paymentsService = scope.ServiceProvider.GetRequiredService<IPaymentsService>();

    try
    {
        /* The business operation can be split into two parts:
        First we’re looking for the subscription, we skip
        implementation of this method, but suppose the query 
        inside is looking for a subscription that is still active, 
        the last successful charge happened more than a month ago, 
        and there are no payment attempts within today. */
        var subscriptionId = await paymentsService.GetOldestOverdueSubscriptionIdAsync(cancellationToken);

       // After performing the search, if no subscriptions were found it means that we are done, the job is complete.
       if (subscriptionId == default)
            break;

        /* If, after performing the search, a subscription is
        found, the next thing to do is to charge money. We look
        for payment details, check that no other payments are 
        being processed simultaneously for this subscription, then
        lock the row and create a “payment attempt” entity. This 
        command will then be sent to the payment provider. The 
        result of charging will be a callback, in which all
        necessary status updates are performed. But this is out of
        the scope of our example job. */ 
        await paymentsService.ChargeForNextPeriodAsync(subscriptionId, cancellationToken);
    }
    catch (Exception ex)
    {
        /* Next we want to ensure the program will catch all
        errors. If we rethrow an exception during this process, it 
        should cause the job to fail. In our case, the job
        completion happens only when we’ve processed all pending
        subscriptions. */
    }
}

public class PaymentAttempt
{
    public int PaymentAttemptId { get; set; }

    public decimal Amount { get; set; }

    public string CurrencyId { get; set; }

    /* Good practice is to save time zone information. If your
    company has more than one developer, or if you collaborate
    with other teams (or companies) in different time zones, 
    accounting for differences in time stamps is a critical 
    component of error-proof coding. Never assume that everyone
    knows about your conventions (using UTC, or adding a UTC 
    prefix to the name). This will save you from countless 
    mistakes and headaches. */
    public DateTimeOffset RequestedAt { get; set; }

    public DateTimeOffset? AcknowledgedAt { get; set; }

    public State StateId { get; set; }

    // Remember to add the row version (concurrency token) to make sure no data is overridden by mistake.
    [Timestamp]
    public byte[] RowVersion { get; set; }

    …
}

public class Subscription
{
    public int SubscriptionId { get; set; }

    public int CustomerId  { get; set; }

    …

    /* In this example we are updating those properties 
        when a fee has been successfully charged. */
    public DateTimeOffset PaidUntilDate { get; set; }

    public int PaymentsLeftCount { get; set; }

    [Timestamp]
    public byte[] RowVersion { get; set; }

    [ForeignKey(nameof(PaymentPlanID))]
    public PaymentPlan PaymentPlan { get; set; }

    public List<PaymentAttempts> PaymentAttempts { get; set; }
}