+ Tips

+ Memberships
- DDD
- FutureCreator
- UserTransactions

src/Web/Features/Memberships/Handlers/CancelSubscription.cs

@@ -0,0 +1,48 @@
+using Hutopy.Web.Features.Memberships.Data;
+using Hutopy.Web.Features.Memberships.Services;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public class CancelSubscriptionRequest
+{
+    public Guid SubscriptionId { get; set; }
+}
+
+public class CancelSubscriptionHandler(
+    MembershipDbContext dbDbContext,
+    StripeService stripeService)
+    : Endpoint<CancelSubscriptionRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/membership/unsubscribe");
+        Options(o => o.WithTags("Memberships"));
+    }
+    
+    public override async Task HandleAsync(
+        CancelSubscriptionRequest req,
+        CancellationToken ct)
+    {
+        var subscription = await dbDbContext
+            .Subscriptions
+            .FindAsync(
+                [req.SubscriptionId],
+                cancellationToken: ct);
+
+        if (subscription is not { EndDate: null })
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Cancel Stripe subscription
+        await stripeService.CancelSubscription(subscription.Id);
+
+        // Update subscription in the system
+        subscription.EndDate = DateTime.UtcNow;
+        await dbDbContext.SaveChangesAsync(ct);
+
+        await SendOkAsync(subscription.Id, ct);
+    }
+}

src/Web/Features/Memberships/Handlers/CreateMembershipTier.cs

@@ -0,0 +1,36 @@
+using Hutopy.Web.Features.Memberships.Data;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public class CreateMembershipTierRequest
+{
+    public Guid CreatorId { get; set; }
+    public string Name { get; set; }
+    public decimal Price { get; set; }
+}
+
+[PublicAPI]
+public class CreateMembershipTierEndpoint(
+    MembershipDbContext dbDbContext)
+    : Endpoint<CreateMembershipTierRequest>
+{
+    public override void Configure()
+    {
+        Post("/api/membership/tiers");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CreateMembershipTierRequest req,
+        CancellationToken ct)
+    {
+        var tier = dbDbContext
+            .Tiers
+            .Add(new Tier { CreatorId = req.CreatorId, Price = req.Price, Name = req.Name });
+
+        await dbDbContext.SaveChangesAsync(ct);
+
+        await SendOkAsync(tier, ct);
+    }
+}

src/Web/Features/Memberships/Handlers/GetActiveSubscriptions.cs

@@ -0,0 +1,32 @@
+using Hutopy.Web.Common;
+using Hutopy.Web.Features.Memberships.Data;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public class GetActiveSubscriptionsRequest;
+
+[PublicAPI]
+public class GetActiveSubscriptionsHandler(
+    MembershipDbContext dbDbContext)
+    : Endpoint<GetActiveSubscriptionsRequest>
+{
+    public override void Configure()
+    {
+        Get("/api/membership/active");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        GetActiveSubscriptionsRequest req,
+        CancellationToken ct)
+    {
+        var subscriptions = await dbDbContext
+            .Subscriptions
+            .Where(subscription => subscription.UserId == User.GetUserId())
+            .Where(subscription => subscription.IsActive)
+            .ToListAsync(ct);
+
+        await SendOkAsync(subscriptions, ct);
+    }
+}

src/Web/Features/Memberships/Handlers/GetMembershipTier.cs

@@ -0,0 +1,47 @@
+using Hutopy.Web.Features.Memberships.Data;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public class GetMembershipTierRequest
+{
+    public Guid CreatorId { get; set; }
+}
+
+[PublicAPI]
+public record struct TierModel(
+    Guid Id,
+    DateTime CreatedAt,
+    string Name,
+    decimal Price,
+    string CurrencyCode);
+
+[PublicAPI]
+public class GetMembershipTierEndpoint(
+    MembershipDbContext dbDbContext)
+    : Endpoint<CreateMembershipTierRequest, List<TierModel>>
+{
+    public override void Configure()
+    {
+        Get("/api/membership/tiers");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CreateMembershipTierRequest req,
+        CancellationToken ct)
+    {
+        var tiers = await dbDbContext
+            .Tiers
+            .Where(tier => tier.CreatorId == req.CreatorId)
+            .Select(tier => new TierModel(
+                tier.Id,
+                tier.CreatedAt,
+                tier.Name,
+                tier.Price,
+                tier.CurrencyCode))
+            .ToListAsync(ct);
+        
+        await SendOkAsync(tiers, ct);
+    }
+}

src/Web/Features/Memberships/Handlers/GetReceivedTips.cs

@@ -0,0 +1,45 @@
+using Hutopy.Web.Common;
+using Hutopy.Web.Features.Memberships.Data;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public record struct TipReceivedModel(
+    Guid Id,
+    DateTimeOffset CreatedAt,
+    Guid TipperId,
+    string TipperName,
+    decimal Amount,
+    string Currency,
+    string Message);
+
+[PublicAPI]
+public class GetReceivedTipsHandler(
+    MembershipDbContext dbDbContext)
+    : EndpointWithoutRequest<List<TipReceivedModel>>
+{
+    public override void Configure()
+    {
+        Get("/api/tips/received");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken ct)
+    {
+        var tipsReceived = await dbDbContext
+            .Tips
+            .Where(tip => tip.CreatorId == User.GetUserId())
+            .Select(tip => new TipReceivedModel(
+                tip.Id,
+                tip.CreatedAt,
+                tip.TipperId,
+                tip.TipperName,
+                tip.Amount,
+                tip.Currency,
+                tip.Message))
+            .ToListAsync(ct);
+
+        await SendOkAsync(tipsReceived, ct);
+    }
+}

src/Web/Features/Memberships/Handlers/GetSentTips.cs

@@ -0,0 +1,45 @@
+using Hutopy.Web.Common;
+using Hutopy.Web.Features.Memberships.Data;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public record struct TipSentModel(
+    Guid Id,
+    DateTimeOffset CreatedAt,
+    Guid CreatorId,
+    string CreatorName,
+    decimal Amount,
+    string Currency,
+    string Message);
+
+[PublicAPI]
+public class GetSentTipsHandler(
+    MembershipDbContext dbContext)
+    : EndpointWithoutRequest<List<TipSentModel>>
+{
+    public override void Configure()
+    {
+        Get("/api/tips/sent");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        CancellationToken ct)
+    {
+        var tips = await dbContext
+            .Tips
+            .Where(t => t.TipperId == User.GetUserId())
+            .Select(tip => new TipSentModel(
+                tip.Id,
+                tip.CreatedAt,
+                tip.CreatorId,
+                tip.CreatorName,
+                tip.Amount,
+                tip.Currency,
+                tip.Message))
+            .ToListAsync(ct);
+
+        await SendOkAsync(tips, ct);
+    }
+}

src/Web/Features/Memberships/Handlers/HandleStripe.cs

@@ -0,0 +1,71 @@
+using Hutopy.Web.Features.Memberships.Data;
+using Hutopy.Web.Features.Memberships.Services;
+using Microsoft.Extensions.Options;
+using Stripe;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+public static class StripeEvents
+{
+    public const string SubscriptionCreated = "subscription_created";
+    public const string CustomerSubscriptionDeleted = "customer.subscription_deleted";
+    public const string InvoicePaymentSucceeded = "invoice.payment_succeeded";
+    public const string InvoicePaymentFailed = "invoice.payment_failed";
+    public const string CheckoutSessionCompleted = "checkout.session.completed";
+}
+
+public class StripeWebhookEndpoint(
+    MembershipDbContext dbContext,
+    StripeService stripeService,
+    IOptions<StripeOptions> options)
+    : EndpointWithoutRequest
+{
+    public override void Configure()
+    {
+        Post("/api/stripe");
+        AllowAnonymous();
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(CancellationToken ct)
+    {
+        using var streamReader = new StreamReader(HttpContext.Request.Body);
+        var json = await streamReader.ReadToEndAsync(ct);
+        
+        var signatureHeader = HttpContext.Request.Headers["Stripe-Signature"];
+        var stripeEvent = EventUtility.ConstructEvent(json, signatureHeader, options.Value.WebhookSecret);
+
+        switch (stripeEvent.Type)
+        {
+            case StripeEvents.InvoicePaymentSucceeded:
+                await stripeService.HandlePaymentSucceeded(stripeEvent, ct);
+                break;
+            case StripeEvents.InvoicePaymentFailed:
+                await stripeService.HandlePaymentFailed(stripeEvent, ct);
+                break;
+            case StripeEvents.CheckoutSessionCompleted:
+                await stripeService.HandleCheckoutSessionCompleted(stripeEvent, ct);
+                break;
+            case StripeEvents.CustomerSubscriptionDeleted:
+                {
+                    var subscription = stripeEvent.Data.Object as Stripe.Subscription;
+                    var existingSubscription = await dbContext
+                        .Subscriptions
+                        .FirstOrDefaultAsync(x => x.StripeSubscriptionId == subscription!.Id, ct);
+
+                    if (existingSubscription != null)
+                    {
+                        var today = DateTime.Today;
+                        int lastDay = DateTime.DaysInMonth(today.Year, today.Month);
+                        var lastDayOfMonth = new DateTime(today.Year, today.Month, lastDay);
+                        existingSubscription.EndDate = new DateTimeOffset(lastDayOfMonth);
+                        await dbContext.SaveChangesAsync(ct);
+                    }
+
+                    break;
+                }
+        }
+
+        await SendOkAsync(ct);
+    }
+}

src/Web/Features/Memberships/Handlers/SendTip.cs

@@ -0,0 +1,117 @@
+using Hutopy.Web.Common;
+using Hutopy.Web.Features.Memberships.Data;
+using Hutopy.Web.Features.Memberships.Services;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public record SendTipRequest
+{
+    public Guid CreatorId { get; set; }
+    public required decimal Amount { get; init; }
+    public required string Currency { get; init; }
+    public required string Message { get; init; }
+    public required string CheckoutSuccessUrl { get; init; }
+    public required string CheckoutCancelledUrl { get; init; }
+}
+
+[PublicAPI]
+public class SendTipResponse
+{
+    public required string Status { get; init; }
+    public required string StripeCheckoutUrl { get; init; }
+}
+
+[PublicAPI]
+public class SendTipRequestValidator : Validator<SendTipRequest>
+{
+    public SendTipRequestValidator()
+    {
+        RuleFor(x => x.Amount)
+            .GreaterThan(0)
+            .WithMessage("Tip amount must be greater than 0");
+
+        RuleFor(x => x.CreatorId)
+            .NotEmpty()
+            .WithMessage("Creator ID is required");
+        
+        RuleFor(x => x.CheckoutSuccessUrl)
+            .NotEmpty()
+            .WithMessage("CheckoutSuccessUrl is required");
+        
+        RuleFor(x => x.CheckoutCancelledUrl)
+            .NotEmpty()
+            .WithMessage("CheckoutCancelledUrl is required");
+    }
+}
+
+[PublicAPI]
+public class SendTipHandler(
+    MembershipDbContext dbDbContext,
+    StripeService stripeService)
+    : Endpoint<SendTipRequest, SendTipResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/tips/{CreatorId}");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        SendTipRequest req,
+        CancellationToken ct)
+    {
+        var userId = User.GetUserId();
+        var userName = User.GetName();
+
+        var creator = await dbDbContext.Creators.FindAsync(
+            [req.CreatorId],
+            cancellationToken: ct);
+        if (creator == null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        var checkoutSession = await stripeService.CreateTipCheckoutSession(
+            userId,
+            req.Amount,
+            req.Currency,
+            creator.Id,
+            creator.Name,
+            creator.StripeAccountId,
+            req.CheckoutSuccessUrl,
+            req.CheckoutCancelledUrl);
+
+        dbDbContext.Tips.Add(
+            new Tip
+            {
+                Id = Guid.NewGuid(),
+                CreatedAt = DateTimeOffset.UtcNow,
+                TipperId = userId,
+                TipperName = userName,
+                CreatorId = creator.Id,
+                CreatorName = creator.Name,
+                Amount = req.Amount,
+                Currency = req.Currency,
+                Message = req.Message,
+                StripeSessionId = checkoutSession.Id
+            });
+
+        dbDbContext.Transactions.Add(
+            new Transaction
+            {
+                Id = Guid.NewGuid(),
+                StripeCheckoutSessionId = checkoutSession.Id,
+                Amount = req.Amount,
+                Type = "Tip",
+                Timestamp = DateTime.UtcNow
+            });
+
+        await dbDbContext.SaveChangesAsync(ct);
+
+        await SendAsync(
+            new SendTipResponse { Status = "Pending", StripeCheckoutUrl = checkoutSession.Url },
+            cancellation: ct);
+    }
+}

src/Web/Features/Memberships/Handlers/SubscribeToCreator.cs

@@ -0,0 +1,110 @@
+using Hutopy.Web.Common;
+using Hutopy.Web.Features.Memberships.Data;
+using Hutopy.Web.Features.Memberships.Services;
+
+namespace Hutopy.Web.Features.Memberships.Handlers;
+
+[PublicAPI]
+public class SubscribeRequest
+{
+    public Guid CreatorId { get; set; }
+    public Guid TierId { get; set; }
+}
+
+[PublicAPI]
+public record struct SubscriptionResponse(
+    Guid SubscriptionId,
+    Guid CreatorId,
+    Guid UserId,
+    bool IsActive,
+    string Tier,
+    DateTimeOffset StartDate,
+    DateTimeOffset? EndDate);
+
+[PublicAPI]
+public class SubscribeValidator : Validator<SubscribeRequest>
+{
+    public SubscribeValidator()
+    {
+        RuleFor(x => x.TierId).NotEmpty();
+    }
+}
+
+[PublicAPI]
+public class SubscribeHandler(
+    MembershipDbContext dbDbContext,
+    StripeService stripeService)
+    : Endpoint<SubscribeRequest, SubscriptionResponse>
+{
+    public override void Configure()
+    {
+        Post("/api/membership/subscribe");
+        Options(o => o.WithTags("Memberships"));
+    }
+
+    public override async Task HandleAsync(
+        SubscribeRequest req,
+        CancellationToken ct)
+    {
+        var tier = await dbDbContext
+            .Tiers
+            .Include(tier => tier.Creator) // Include the related table
+            .Where(tier => tier.Id == req.TierId)
+            .FirstOrDefaultAsync(ct);
+        
+        if (tier == null)
+        {
+            await SendNotFoundAsync(ct);
+            return;
+        }
+
+        // Process Stripe subscription
+        var stripeSubscription = await stripeService.CreateSubscriptionCheckoutSession(
+            User.GetUserId(),
+            tier.Price,
+            tier.CurrencyCode,
+            $"{tier.Name} from {tier.Creator.Name}",
+            tier.Creator.StripeAccountId,
+            "",
+            "");
+
+        // Record subscription and transaction
+        var subscription = new Subscription
+        {
+            Id = Guid.NewGuid(),
+            StripeSubscriptionId = stripeSubscription.Id,
+            CreatorId = tier.CreatorId,
+            UserId = User.GetUserId(),
+            Tier = tier,
+            StartDate = DateTimeOffset.Now,
+            EndDate = DateTimeOffset.Now.AddMonths(1)
+        };
+
+        dbDbContext.Subscriptions.Add(subscription);
+
+        dbDbContext.Transactions.Add(
+            new Transaction
+            {
+                Id = Guid.NewGuid(),
+                StripeCheckoutSessionId = stripeSubscription.Id,
+                Amount = tier.Price,
+                Type = "Subscription",
+                Timestamp = DateTime.UtcNow
+            });
+
+        await dbDbContext.SaveChangesAsync(ct);
+
+        await SendOkAsync(
+            new SubscriptionResponse
+            {
+                UserId = subscription.UserId,
+                CreatorId = subscription.CreatorId,
+                SubscriptionId = subscription.Id,
+                IsActive = subscription.IsActive,
+                StartDate = subscription.StartDate,
+                EndDate = subscription.EndDate,
+                Tier = tier.Name,
+            },
+            ct);
+    }
+}