forked from xiongyuxing/tiku-backend.net
1002 lines
37 KiB
C#
1002 lines
37 KiB
C#
using System.Globalization;
|
|
using System.Security.Cryptography;
|
|
using System.Text.Json;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Tiku.Application.Commerce;
|
|
using Tiku.Domain.Commerce;
|
|
using Tiku.Domain.Common;
|
|
using Tiku.Domain.Tenancy;
|
|
using Tiku.Infrastructure.Persistence;
|
|
|
|
namespace Tiku.Infrastructure.Commerce;
|
|
|
|
public sealed class CommerceService(
|
|
TikuDbContext dbContext,
|
|
IPaymentProviderGateway paymentGateway) : ICommerceService
|
|
{
|
|
private sealed record CouponApplication(Coupon Coupon, CouponRedemption Redemption, int DiscountCents);
|
|
|
|
public async Task<CommerceOrderItem> CreateOrderAsync(
|
|
CommerceActor actor,
|
|
CreateCommerceOrderCommand command,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
if (command.Quantity is < 1 or > 99)
|
|
{
|
|
throw new CommerceException("Quantity must be between 1 and 99.", "invalid_quantity");
|
|
}
|
|
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var plan = await dbContext.SvipPlans
|
|
.AsNoTracking()
|
|
.SingleOrDefaultAsync(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.Id == command.PlanId &&
|
|
item.IsActive,
|
|
cancellationToken)
|
|
?? throw new CommerceException("SVIP plan was not found.", "svip_plan_not_found");
|
|
|
|
if (plan.CouponOnly &&
|
|
string.IsNullOrWhiteSpace(command.CouponCode) &&
|
|
!command.CouponRedemptionId.HasValue)
|
|
{
|
|
throw new CommerceException("This SVIP plan requires a coupon.", "coupon_required");
|
|
}
|
|
|
|
if (command.RegionId.HasValue)
|
|
{
|
|
var regionExists = await dbContext.Regions
|
|
.AnyAsync(item => item.TenantId == actor.TenantId && item.Id == command.RegionId.Value, cancellationToken);
|
|
if (!regionExists)
|
|
{
|
|
throw new CommerceException("Region was not found.", "region_not_found");
|
|
}
|
|
}
|
|
|
|
await using var transaction = dbContext.Database.IsRelational()
|
|
? await dbContext.Database.BeginTransactionAsync(cancellationToken)
|
|
: null;
|
|
var originalAmountCents = checked(plan.PriceCents * command.Quantity);
|
|
var coupon = await ApplyCouponForOrderAsync(
|
|
actor,
|
|
command,
|
|
plan,
|
|
originalAmountCents,
|
|
cancellationToken);
|
|
if (plan.CouponOnly && coupon is null)
|
|
{
|
|
throw new CommerceException("This SVIP plan requires a coupon.", "coupon_required");
|
|
}
|
|
|
|
var amountCents = Math.Max(0, originalAmountCents - (coupon?.DiscountCents ?? 0));
|
|
var order = new Order
|
|
{
|
|
TenantId = actor.TenantId,
|
|
UserId = actor.UserId,
|
|
PlanId = plan.Id,
|
|
RegionId = command.RegionId ?? plan.RegionId,
|
|
OrderNo = GenerateOrderNo(),
|
|
Status = OrderStatus.Pending,
|
|
ProductType = "svip",
|
|
ProductName = plan.Name,
|
|
AmountCents = amountCents,
|
|
PayMethod = NormalizeMethod(command.PayMethod),
|
|
PayProvider = NormalizeProvider(command.PayProvider),
|
|
Days = checked(plan.Days * command.Quantity),
|
|
RawPayload = JsonSerializer.SerializeToElement(new
|
|
{
|
|
source = "student_checkout",
|
|
command.Quantity,
|
|
requestedCouponCode = command.CouponCode,
|
|
requestedCouponRedemptionId = command.CouponRedemptionId,
|
|
plan.PriceCents,
|
|
plan.OriginalPriceCents,
|
|
originalAmountCents,
|
|
discountCents = coupon?.DiscountCents ?? 0,
|
|
couponId = coupon?.Coupon.Id,
|
|
couponCode = coupon?.Coupon.Code,
|
|
couponRedemptionId = coupon?.Redemption.Id
|
|
})
|
|
};
|
|
dbContext.Orders.Add(order);
|
|
dbContext.OrderItems.Add(new OrderItem
|
|
{
|
|
TenantId = actor.TenantId,
|
|
OrderId = order.Id,
|
|
ItemType = "svip_plan",
|
|
ItemId = plan.Id,
|
|
Name = plan.Name,
|
|
Quantity = command.Quantity,
|
|
UnitAmountCents = plan.PriceCents,
|
|
TotalAmountCents = originalAmountCents,
|
|
Metadata = JsonSerializer.SerializeToElement(new
|
|
{
|
|
plan.Days,
|
|
plan.RegionId,
|
|
plan.VpProductId
|
|
})
|
|
});
|
|
|
|
if (coupon is not null)
|
|
{
|
|
coupon.Redemption.Status = CouponRedemptionStatus.Used;
|
|
coupon.Redemption.OrderId = order.Id;
|
|
coupon.Redemption.DiscountAppliedCents = coupon.DiscountCents;
|
|
coupon.Redemption.UsedAt = DateTimeOffset.UtcNow;
|
|
}
|
|
|
|
if (amountCents == 0)
|
|
{
|
|
var payment = new Payment
|
|
{
|
|
TenantId = actor.TenantId,
|
|
OrderId = order.Id,
|
|
Provider = "manual",
|
|
Method = "zero_amount",
|
|
Status = PaymentStatus.Pending,
|
|
AmountCents = 0
|
|
};
|
|
dbContext.Payments.Add(payment);
|
|
await MarkPaidAsync(
|
|
actor,
|
|
order,
|
|
payment,
|
|
$"zero-{order.OrderNo}",
|
|
order.RawPayload,
|
|
"zero_amount_paid",
|
|
$"zero-{order.OrderNo}",
|
|
true,
|
|
DateTimeOffset.UtcNow,
|
|
cancellationToken);
|
|
}
|
|
|
|
await dbContext.SaveChangesAsync(cancellationToken);
|
|
if (transaction is not null)
|
|
{
|
|
await transaction.CommitAsync(cancellationToken);
|
|
}
|
|
|
|
return ToOrderItem(order);
|
|
}
|
|
|
|
public async Task<CommerceOrderList> GetOrdersAsync(
|
|
CommerceActor actor,
|
|
CommerceOrderQuery query,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var orders = dbContext.Orders.AsNoTracking()
|
|
.Where(item => item.TenantId == actor.TenantId && item.UserId == actor.UserId);
|
|
if (!string.IsNullOrWhiteSpace(query.Status))
|
|
{
|
|
orders = orders.Where(item => item.Status == ParseOrderStatus(query.Status));
|
|
}
|
|
|
|
var items = await orders
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.Take(Math.Clamp(query.Limit ?? 20, 1, 100))
|
|
.ToArrayAsync(cancellationToken);
|
|
|
|
return new CommerceOrderList(items.Select(ToOrderItem).ToArray());
|
|
}
|
|
|
|
public async Task<CommerceOrderItem> GetOrderAsync(
|
|
CommerceActor actor,
|
|
string orderNo,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var order = await FindActorOrderAsync(actor, orderNo, cancellationToken);
|
|
return ToOrderItem(order);
|
|
}
|
|
|
|
public async Task<CommercePaymentItem> CreatePaymentAsync(
|
|
CommerceActor actor,
|
|
CreateCommercePaymentCommand command,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var order = await FindActorOrderAsync(actor, command.OrderNo, cancellationToken);
|
|
if (order.Status != OrderStatus.Pending)
|
|
{
|
|
throw new CommerceException("Only pending orders can create payments.", "order_status_invalid");
|
|
}
|
|
|
|
var provider = NormalizeProvider(command.Provider);
|
|
var method = NormalizeMethod(command.Method);
|
|
var payment = await dbContext.Payments
|
|
.Where(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.OrderId == order.Id &&
|
|
item.Provider == provider &&
|
|
item.Status == PaymentStatus.Pending)
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
|
|
if (payment is null)
|
|
{
|
|
payment = new Payment
|
|
{
|
|
TenantId = actor.TenantId,
|
|
OrderId = order.Id,
|
|
Provider = provider,
|
|
Method = method,
|
|
Status = PaymentStatus.Pending,
|
|
AmountCents = order.AmountCents
|
|
};
|
|
dbContext.Payments.Add(payment);
|
|
}
|
|
|
|
var result = await paymentGateway.CreatePaymentAsync(
|
|
provider,
|
|
new CreatePaymentProviderRequest(
|
|
actor.TenantId,
|
|
order.OrderNo,
|
|
order.ProductName ?? order.OrderNo,
|
|
order.AmountCents,
|
|
method,
|
|
command.OpenId,
|
|
command.ReturnUrl,
|
|
command.QuitUrl,
|
|
$"/api/commerce/payments/notify/{provider.Replace("_", "-", StringComparison.Ordinal)}?tenantId={actor.TenantId}",
|
|
JsonSerializer.SerializeToElement(new { order.Id, actor.UserId })),
|
|
cancellationToken);
|
|
|
|
payment.Method = result.Method;
|
|
payment.RawPayload = result.RawPayload;
|
|
if (!string.IsNullOrWhiteSpace(result.ProviderTradeNo))
|
|
{
|
|
payment.ProviderTradeNo = result.ProviderTradeNo;
|
|
}
|
|
|
|
if (IsPaid(result.Status))
|
|
{
|
|
await MarkPaidAsync(
|
|
actor,
|
|
order,
|
|
payment,
|
|
result.ProviderTradeNo,
|
|
result.RawPayload,
|
|
"payment_paid",
|
|
result.ProviderTradeNo,
|
|
true,
|
|
null,
|
|
cancellationToken);
|
|
}
|
|
else
|
|
{
|
|
dbContext.PaymentEvents.Add(new PaymentEvent
|
|
{
|
|
TenantId = actor.TenantId,
|
|
PaymentId = payment.Id,
|
|
Provider = provider,
|
|
EventType = "payment_created",
|
|
Payload = result.RawPayload
|
|
});
|
|
}
|
|
|
|
await dbContext.SaveChangesAsync(cancellationToken);
|
|
return ToPaymentItem(payment, order.OrderNo, result.ClientPayload);
|
|
}
|
|
|
|
public async Task<CurrentEntitlementItem> GetCurrentEntitlementAsync(
|
|
CommerceActor actor,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var now = DateTimeOffset.UtcNow;
|
|
var entitlement = await dbContext.Entitlements
|
|
.AsNoTracking()
|
|
.Where(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.EntitlementType == "svip" &&
|
|
item.Status == EntitlementStatus.Active &&
|
|
(item.ExpiresAt == null || item.ExpiresAt > now))
|
|
.OrderByDescending(item => item.ExpiresAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
|
|
if (entitlement is null)
|
|
{
|
|
return new CurrentEntitlementItem(false, "svip", null, null, "inactive", null);
|
|
}
|
|
|
|
return new CurrentEntitlementItem(
|
|
true,
|
|
entitlement.EntitlementType,
|
|
entitlement.StartsAt,
|
|
entitlement.ExpiresAt,
|
|
entitlement.Status.ToString(),
|
|
entitlement.ExpiresAt.HasValue
|
|
? Math.Max(0, (int)Math.Ceiling((entitlement.ExpiresAt.Value - now).TotalDays))
|
|
: null);
|
|
}
|
|
|
|
public async Task<CommerceCouponItem> ClaimCouponAsync(
|
|
CommerceActor actor,
|
|
ClaimCommerceCouponCommand command,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var coupon = await FindCouponByCodeAsync(actor.TenantId, command.CouponCode, cancellationToken);
|
|
ValidateCouponClaimable(coupon, null);
|
|
|
|
var existing = await dbContext.CouponRedemptions
|
|
.AsNoTracking()
|
|
.Where(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.CouponId == coupon.Id)
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (existing is not null)
|
|
{
|
|
return ToCouponItem(coupon, existing, null);
|
|
}
|
|
|
|
if (coupon.MaxUses.HasValue && coupon.UsedCount >= coupon.MaxUses.Value)
|
|
{
|
|
throw new CommerceException("Coupon usage limit has been reached.", "coupon_usage_limit_reached");
|
|
}
|
|
|
|
var redemption = new CouponRedemption
|
|
{
|
|
TenantId = actor.TenantId,
|
|
CouponId = coupon.Id,
|
|
UserId = actor.UserId,
|
|
PlanId = coupon.PlanId,
|
|
CouponCode = coupon.Code,
|
|
Status = CouponRedemptionStatus.Claimed,
|
|
Source = "student_claim",
|
|
ClaimedAt = DateTimeOffset.UtcNow
|
|
};
|
|
coupon.UsedCount += 1;
|
|
dbContext.CouponRedemptions.Add(redemption);
|
|
await dbContext.SaveChangesAsync(cancellationToken);
|
|
return ToCouponItem(coupon, redemption, null);
|
|
}
|
|
|
|
public async Task<CommerceCouponList> GetCouponsAsync(
|
|
CommerceActor actor,
|
|
CommerceCouponQuery query,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
var redemptions = dbContext.CouponRedemptions
|
|
.AsNoTracking()
|
|
.Where(item => item.TenantId == actor.TenantId && item.UserId == actor.UserId);
|
|
if (!string.IsNullOrWhiteSpace(query.Status))
|
|
{
|
|
redemptions = redemptions.Where(item => item.Status == ParseCouponRedemptionStatus(query.Status));
|
|
}
|
|
|
|
var items = await redemptions
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.Take(Math.Clamp(query.Limit ?? 50, 1, 100))
|
|
.ToArrayAsync(cancellationToken);
|
|
var couponIds = items
|
|
.Where(item => item.CouponId.HasValue)
|
|
.Select(item => item.CouponId!.Value)
|
|
.Distinct()
|
|
.ToArray();
|
|
var coupons = await dbContext.Coupons
|
|
.AsNoTracking()
|
|
.Where(item => item.TenantId == actor.TenantId && couponIds.Contains(item.Id))
|
|
.ToDictionaryAsync(item => item.Id, cancellationToken);
|
|
|
|
return new CommerceCouponList(
|
|
items.Select(item =>
|
|
{
|
|
coupons.TryGetValue(item.CouponId ?? Guid.Empty, out var coupon);
|
|
return ToCouponItem(coupon, item, item.DiscountAppliedCents);
|
|
}).ToArray());
|
|
}
|
|
|
|
public async Task<CommerceCouponCheckResult> CheckCouponAsync(
|
|
CommerceActor actor,
|
|
CheckCommerceCouponCommand command,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
await AssertActiveMemberAsync(actor, cancellationToken);
|
|
if (command.Quantity is < 1 or > 99)
|
|
{
|
|
throw new CommerceException("Quantity must be between 1 and 99.", "invalid_quantity");
|
|
}
|
|
|
|
var plan = await dbContext.SvipPlans
|
|
.AsNoTracking()
|
|
.SingleOrDefaultAsync(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.Id == command.PlanId &&
|
|
item.IsActive,
|
|
cancellationToken)
|
|
?? throw new CommerceException("SVIP plan was not found.", "svip_plan_not_found");
|
|
var originalAmountCents = checked(plan.PriceCents * command.Quantity);
|
|
try
|
|
{
|
|
var coupon = await ResolveCouponForCheckAsync(actor, command, plan, originalAmountCents, cancellationToken);
|
|
return new CommerceCouponCheckResult(
|
|
true,
|
|
null,
|
|
coupon.Coupon.Id,
|
|
coupon.Redemption.Id,
|
|
coupon.Coupon.Code,
|
|
originalAmountCents,
|
|
coupon.DiscountCents,
|
|
Math.Max(0, originalAmountCents - coupon.DiscountCents),
|
|
FormatCny(Math.Max(0, originalAmountCents - coupon.DiscountCents)));
|
|
}
|
|
catch (CommerceException exception) when (exception.Code.StartsWith("coupon_", StringComparison.Ordinal))
|
|
{
|
|
return new CommerceCouponCheckResult(
|
|
false,
|
|
exception.Code,
|
|
null,
|
|
command.CouponRedemptionId,
|
|
command.CouponCode,
|
|
originalAmountCents,
|
|
0,
|
|
originalAmountCents,
|
|
FormatCny(originalAmountCents));
|
|
}
|
|
}
|
|
|
|
public async Task<PaymentNotificationProcessResult> ProcessPaymentNotificationAsync(
|
|
Guid tenantId,
|
|
string provider,
|
|
IReadOnlyDictionary<string, string> headers,
|
|
string rawBody,
|
|
JsonElement body,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
var normalizedProvider = NormalizeProvider(provider);
|
|
var notification = await paymentGateway.ParsePaymentNotificationAsync(
|
|
normalizedProvider,
|
|
new PaymentNotificationRequest(
|
|
tenantId,
|
|
normalizedProvider,
|
|
headers,
|
|
rawBody,
|
|
body),
|
|
cancellationToken);
|
|
|
|
if (!notification.SignatureValid)
|
|
{
|
|
throw new CommerceException("Payment notification signature is invalid.", "payment_signature_invalid");
|
|
}
|
|
|
|
var alreadyProcessed = await dbContext.PaymentEvents.AnyAsync(
|
|
item =>
|
|
item.Provider == normalizedProvider &&
|
|
item.EventId == notification.EventId &&
|
|
item.ProcessedAt != null,
|
|
cancellationToken);
|
|
if (alreadyProcessed)
|
|
{
|
|
return new PaymentNotificationProcessResult(
|
|
normalizedProvider,
|
|
notification.EventId,
|
|
notification.OrderNo,
|
|
"processed",
|
|
true);
|
|
}
|
|
|
|
var order = await dbContext.Orders
|
|
.SingleOrDefaultAsync(item =>
|
|
item.TenantId == tenantId &&
|
|
item.OrderNo == notification.OrderNo,
|
|
cancellationToken)
|
|
?? throw new CommerceException("Order was not found.", "order_not_found");
|
|
|
|
if (order.UserId is null)
|
|
{
|
|
throw new CommerceException("Order does not belong to a user.", "order_user_missing");
|
|
}
|
|
|
|
if (order.AmountCents != notification.AmountCents)
|
|
{
|
|
dbContext.PaymentEvents.Add(new PaymentEvent
|
|
{
|
|
TenantId = tenantId,
|
|
Provider = normalizedProvider,
|
|
EventType = notification.EventType,
|
|
EventId = notification.EventId,
|
|
SignatureValid = true,
|
|
Payload = notification.RawPayload,
|
|
Error = "payment_amount_mismatch"
|
|
});
|
|
await dbContext.SaveChangesAsync(cancellationToken);
|
|
throw new CommerceException("Payment amount does not match order amount.", "payment_amount_mismatch");
|
|
}
|
|
|
|
var payment = await dbContext.Payments
|
|
.Where(item =>
|
|
item.TenantId == tenantId &&
|
|
item.OrderId == order.Id &&
|
|
item.Provider == normalizedProvider)
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (payment is null)
|
|
{
|
|
payment = new Payment
|
|
{
|
|
TenantId = tenantId,
|
|
OrderId = order.Id,
|
|
Provider = normalizedProvider,
|
|
Method = order.PayMethod,
|
|
Status = PaymentStatus.Pending,
|
|
AmountCents = order.AmountCents
|
|
};
|
|
dbContext.Payments.Add(payment);
|
|
}
|
|
|
|
if (notification.Paid && order.Status == OrderStatus.Pending)
|
|
{
|
|
await MarkPaidAsync(
|
|
new CommerceActor(tenantId, order.UserId.Value),
|
|
order,
|
|
payment,
|
|
notification.ProviderTradeNo,
|
|
notification.RawPayload,
|
|
notification.EventType,
|
|
notification.EventId,
|
|
notification.SignatureValid,
|
|
notification.PaidAt,
|
|
cancellationToken);
|
|
}
|
|
else
|
|
{
|
|
dbContext.PaymentEvents.Add(new PaymentEvent
|
|
{
|
|
TenantId = tenantId,
|
|
PaymentId = payment.Id,
|
|
Provider = normalizedProvider,
|
|
EventType = notification.EventType,
|
|
EventId = notification.EventId,
|
|
SignatureValid = notification.SignatureValid,
|
|
Payload = notification.RawPayload,
|
|
ProcessedAt = DateTimeOffset.UtcNow
|
|
});
|
|
}
|
|
|
|
await dbContext.SaveChangesAsync(cancellationToken);
|
|
return new PaymentNotificationProcessResult(
|
|
normalizedProvider,
|
|
notification.EventId,
|
|
notification.OrderNo,
|
|
"processed",
|
|
false);
|
|
}
|
|
|
|
private async Task MarkPaidAsync(
|
|
CommerceActor actor,
|
|
Order order,
|
|
Payment payment,
|
|
string? providerTradeNo,
|
|
JsonElement rawPayload,
|
|
string eventType,
|
|
string? eventId,
|
|
bool signatureValid,
|
|
DateTimeOffset? paidAtOverride,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var paidAt = paidAtOverride ?? DateTimeOffset.UtcNow;
|
|
payment.Status = PaymentStatus.Paid;
|
|
payment.ProviderTradeNo = providerTradeNo ?? payment.ProviderTradeNo;
|
|
payment.PaidAt = paidAt;
|
|
order.Status = OrderStatus.Paid;
|
|
order.TradeNo = payment.ProviderTradeNo;
|
|
order.PaidAt = paidAt;
|
|
|
|
var days = Math.Max(order.Days ?? 0, 0);
|
|
var current = await dbContext.Entitlements
|
|
.Where(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.EntitlementType == "svip" &&
|
|
item.Status == EntitlementStatus.Active)
|
|
.OrderByDescending(item => item.ExpiresAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (current is null)
|
|
{
|
|
dbContext.Entitlements.Add(new Entitlement
|
|
{
|
|
TenantId = actor.TenantId,
|
|
UserId = actor.UserId,
|
|
EntitlementType = "svip",
|
|
ScopeType = EntitlementScopeType.Tenant,
|
|
SourceType = "order",
|
|
SourceId = order.Id,
|
|
StartsAt = paidAt,
|
|
ExpiresAt = days > 0 ? paidAt.AddDays(days) : null,
|
|
Status = EntitlementStatus.Active,
|
|
Metadata = rawPayload
|
|
});
|
|
}
|
|
else if (days > 0)
|
|
{
|
|
var baseAt = current.ExpiresAt.HasValue && current.ExpiresAt > paidAt
|
|
? current.ExpiresAt.Value
|
|
: paidAt;
|
|
current.ExpiresAt = baseAt.AddDays(days);
|
|
current.Metadata = rawPayload;
|
|
}
|
|
|
|
dbContext.PaymentEvents.Add(new PaymentEvent
|
|
{
|
|
TenantId = actor.TenantId,
|
|
PaymentId = payment.Id,
|
|
Provider = payment.Provider,
|
|
EventType = eventType,
|
|
EventId = eventId,
|
|
SignatureValid = signatureValid,
|
|
Payload = rawPayload,
|
|
ProcessedAt = paidAt
|
|
});
|
|
}
|
|
|
|
private async Task<CouponApplication?> ApplyCouponForOrderAsync(
|
|
CommerceActor actor,
|
|
CreateCommerceOrderCommand command,
|
|
SvipPlan plan,
|
|
int originalAmountCents,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (command.CouponRedemptionId is null && string.IsNullOrWhiteSpace(command.CouponCode))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var coupon = command.CouponRedemptionId.HasValue
|
|
? await ResolveCouponByRedemptionAsync(actor, command.CouponRedemptionId.Value, cancellationToken)
|
|
: await ResolveOrClaimCouponByCodeAsync(actor, command.CouponCode, cancellationToken);
|
|
ValidateCouponUsable(coupon.Coupon, coupon.Redemption, plan, command.RegionId);
|
|
return coupon with { DiscountCents = CalculateDiscountCents(coupon.Coupon, originalAmountCents) };
|
|
}
|
|
|
|
private async Task<CouponApplication> ResolveCouponForCheckAsync(
|
|
CommerceActor actor,
|
|
CheckCommerceCouponCommand command,
|
|
SvipPlan plan,
|
|
int originalAmountCents,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (command.CouponRedemptionId is null && string.IsNullOrWhiteSpace(command.CouponCode))
|
|
{
|
|
throw new CommerceException("Coupon code or redemption id is required.", "coupon_required");
|
|
}
|
|
|
|
var coupon = command.CouponRedemptionId.HasValue
|
|
? await ResolveCouponByRedemptionAsync(actor, command.CouponRedemptionId.Value, cancellationToken)
|
|
: await ResolveCouponByCodeForCheckAsync(actor, command.CouponCode, cancellationToken);
|
|
ValidateCouponUsable(coupon.Coupon, coupon.Redemption, plan, command.RegionId);
|
|
return coupon with { DiscountCents = CalculateDiscountCents(coupon.Coupon, originalAmountCents) };
|
|
}
|
|
|
|
private async Task<CouponApplication> ResolveOrClaimCouponByCodeAsync(
|
|
CommerceActor actor,
|
|
string? couponCode,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var coupon = await FindCouponByCodeAsync(actor.TenantId, couponCode, cancellationToken);
|
|
ValidateCouponClaimable(coupon, null);
|
|
var existing = await dbContext.CouponRedemptions
|
|
.Where(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.CouponId == coupon.Id)
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (existing is not null)
|
|
{
|
|
return new CouponApplication(coupon, existing, 0);
|
|
}
|
|
|
|
if (coupon.MaxUses.HasValue && coupon.UsedCount >= coupon.MaxUses.Value)
|
|
{
|
|
throw new CommerceException("Coupon usage limit has been reached.", "coupon_usage_limit_reached");
|
|
}
|
|
|
|
var redemption = new CouponRedemption
|
|
{
|
|
TenantId = actor.TenantId,
|
|
CouponId = coupon.Id,
|
|
UserId = actor.UserId,
|
|
PlanId = coupon.PlanId,
|
|
CouponCode = coupon.Code,
|
|
Status = CouponRedemptionStatus.Claimed,
|
|
Source = "checkout_claim",
|
|
ClaimedAt = DateTimeOffset.UtcNow
|
|
};
|
|
coupon.UsedCount += 1;
|
|
dbContext.CouponRedemptions.Add(redemption);
|
|
return new CouponApplication(coupon, redemption, 0);
|
|
}
|
|
|
|
private async Task<CouponApplication> ResolveCouponByCodeForCheckAsync(
|
|
CommerceActor actor,
|
|
string? couponCode,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var coupon = await FindCouponByCodeAsync(actor.TenantId, couponCode, cancellationToken);
|
|
var redemption = await dbContext.CouponRedemptions
|
|
.AsNoTracking()
|
|
.Where(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.CouponId == coupon.Id)
|
|
.OrderByDescending(item => item.CreatedAt)
|
|
.FirstOrDefaultAsync(cancellationToken);
|
|
if (redemption is not null)
|
|
{
|
|
return new CouponApplication(coupon, redemption, 0);
|
|
}
|
|
|
|
ValidateCouponClaimable(coupon, null);
|
|
return new CouponApplication(
|
|
coupon,
|
|
new CouponRedemption
|
|
{
|
|
Id = Guid.Empty,
|
|
TenantId = actor.TenantId,
|
|
CouponId = coupon.Id,
|
|
UserId = actor.UserId,
|
|
PlanId = coupon.PlanId,
|
|
CouponCode = coupon.Code,
|
|
Status = CouponRedemptionStatus.Claimed
|
|
},
|
|
0);
|
|
}
|
|
|
|
private async Task<CouponApplication> ResolveCouponByRedemptionAsync(
|
|
CommerceActor actor,
|
|
Guid couponRedemptionId,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var redemption = await dbContext.CouponRedemptions
|
|
.SingleOrDefaultAsync(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.Id == couponRedemptionId,
|
|
cancellationToken)
|
|
?? throw new CommerceException("Coupon redemption was not found.", "coupon_redemption_not_found");
|
|
if (redemption.CouponId is null)
|
|
{
|
|
throw new CommerceException("Coupon redemption is not linked to a coupon.", "coupon_redemption_invalid");
|
|
}
|
|
|
|
var coupon = await dbContext.Coupons
|
|
.SingleOrDefaultAsync(item => item.TenantId == actor.TenantId && item.Id == redemption.CouponId.Value, cancellationToken)
|
|
?? throw new CommerceException("Coupon was not found.", "coupon_not_found");
|
|
return new CouponApplication(coupon, redemption, 0);
|
|
}
|
|
|
|
private async Task<Coupon> FindCouponByCodeAsync(
|
|
Guid tenantId,
|
|
string? couponCode,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var code = NormalizeRequired(couponCode, "coupon_code_required");
|
|
return await dbContext.Coupons
|
|
.SingleOrDefaultAsync(item => item.TenantId == tenantId && item.Code == code, cancellationToken)
|
|
?? throw new CommerceException("Coupon was not found.", "coupon_not_found");
|
|
}
|
|
|
|
private static void ValidateCouponClaimable(Coupon coupon, CouponRedemption? redemption)
|
|
{
|
|
var now = DateTimeOffset.UtcNow;
|
|
if (coupon.ValidFrom is not null && coupon.ValidFrom > now ||
|
|
coupon.ValidTo is not null && coupon.ValidTo <= now)
|
|
{
|
|
throw new CommerceException("Coupon is expired or not started.", "coupon_inactive");
|
|
}
|
|
|
|
if (redemption is null && coupon.MaxUses.HasValue && coupon.UsedCount >= coupon.MaxUses.Value)
|
|
{
|
|
throw new CommerceException("Coupon usage limit has been reached.", "coupon_usage_limit_reached");
|
|
}
|
|
}
|
|
|
|
private static void ValidateCouponUsable(
|
|
Coupon coupon,
|
|
CouponRedemption redemption,
|
|
SvipPlan plan,
|
|
Guid? regionId)
|
|
{
|
|
ValidateCouponClaimable(coupon, redemption);
|
|
if (redemption.Status != CouponRedemptionStatus.Claimed)
|
|
{
|
|
throw new CommerceException("Coupon redemption is not claimable.", "coupon_redemption_status_invalid");
|
|
}
|
|
|
|
if (coupon.PlanId.HasValue && coupon.PlanId != plan.Id ||
|
|
redemption.PlanId.HasValue && redemption.PlanId != plan.Id)
|
|
{
|
|
throw new CommerceException("Coupon is not applicable to this plan.", "coupon_plan_not_applicable");
|
|
}
|
|
|
|
if (redemption.RegionId.HasValue &&
|
|
regionId.HasValue &&
|
|
redemption.RegionId != regionId)
|
|
{
|
|
throw new CommerceException("Coupon is not applicable to this region.", "coupon_region_not_applicable");
|
|
}
|
|
}
|
|
|
|
private static int CalculateDiscountCents(Coupon coupon, int originalAmountCents)
|
|
{
|
|
var discount = coupon.DiscountType switch
|
|
{
|
|
DiscountType.Fixed => (int)Math.Round((coupon.DiscountValue ?? 0) * 100, MidpointRounding.AwayFromZero),
|
|
DiscountType.Percent => (int)Math.Round(
|
|
originalAmountCents * PercentFactor(coupon.DiscountValue ?? 0),
|
|
MidpointRounding.AwayFromZero),
|
|
_ => 0
|
|
};
|
|
return Math.Clamp(discount, 0, originalAmountCents);
|
|
}
|
|
|
|
private static decimal PercentFactor(decimal value)
|
|
{
|
|
if (value <= 0)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
return value <= 1 ? value : value / 100;
|
|
}
|
|
|
|
private async Task AssertActiveMemberAsync(CommerceActor actor, CancellationToken cancellationToken)
|
|
{
|
|
var exists = await dbContext.TenantMemberships.AnyAsync(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.Status == MembershipStatus.Active,
|
|
cancellationToken);
|
|
if (!exists)
|
|
{
|
|
throw new CommerceException("Current user is not a member of the tenant.", "tenant_access_denied");
|
|
}
|
|
}
|
|
|
|
private async Task<Order> FindActorOrderAsync(
|
|
CommerceActor actor,
|
|
string orderNo,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var trimmed = orderNo.Trim();
|
|
return await dbContext.Orders
|
|
.SingleOrDefaultAsync(item =>
|
|
item.TenantId == actor.TenantId &&
|
|
item.UserId == actor.UserId &&
|
|
item.OrderNo == trimmed,
|
|
cancellationToken)
|
|
?? throw new CommerceException("Order was not found.", "order_not_found");
|
|
}
|
|
|
|
private static CommerceOrderItem ToOrderItem(Order order)
|
|
{
|
|
return new CommerceOrderItem(
|
|
order.Id,
|
|
order.OrderNo,
|
|
order.Status.ToString(),
|
|
order.PlanId,
|
|
order.RegionId,
|
|
order.ProductType,
|
|
order.ProductName,
|
|
order.AmountCents,
|
|
FormatCny(order.AmountCents),
|
|
order.PayMethod,
|
|
order.PayProvider,
|
|
order.TradeNo,
|
|
order.Days,
|
|
order.PaidAt,
|
|
order.CreatedAt,
|
|
order.RawPayload);
|
|
}
|
|
|
|
private static CommercePaymentItem ToPaymentItem(Payment payment, string orderNo, JsonElement clientPayload)
|
|
{
|
|
return new CommercePaymentItem(
|
|
payment.Id,
|
|
payment.OrderId,
|
|
orderNo,
|
|
payment.Provider,
|
|
payment.Method,
|
|
payment.Status.ToString(),
|
|
payment.AmountCents,
|
|
FormatCny(payment.AmountCents),
|
|
payment.ProviderTradeNo,
|
|
payment.PaidAt,
|
|
clientPayload,
|
|
payment.RawPayload);
|
|
}
|
|
|
|
private static CommerceCouponItem ToCouponItem(
|
|
Coupon? coupon,
|
|
CouponRedemption redemption,
|
|
int? discountPreviewCents)
|
|
{
|
|
return new CommerceCouponItem(
|
|
redemption.Id,
|
|
redemption.CouponId,
|
|
redemption.CouponCode ?? coupon?.Code ?? string.Empty,
|
|
redemption.Status.ToString(),
|
|
redemption.PlanId ?? coupon?.PlanId,
|
|
redemption.RegionId,
|
|
coupon?.DiscountType?.ToString(),
|
|
coupon?.DiscountValue,
|
|
discountPreviewCents,
|
|
discountPreviewCents.HasValue ? FormatCny(discountPreviewCents.Value) : null,
|
|
coupon?.ValidFrom,
|
|
coupon?.ValidTo,
|
|
redemption.ClaimedAt,
|
|
redemption.UsedAt);
|
|
}
|
|
|
|
private static OrderStatus ParseOrderStatus(string? status)
|
|
{
|
|
return Enum.TryParse<OrderStatus>(NormalizeEnum(status), true, out var parsed)
|
|
? parsed
|
|
: throw new CommerceException("Order status is invalid.", "invalid_order_status");
|
|
}
|
|
|
|
private static CouponRedemptionStatus ParseCouponRedemptionStatus(string? status)
|
|
{
|
|
return Enum.TryParse<CouponRedemptionStatus>(NormalizeEnum(status), true, out var parsed)
|
|
? parsed
|
|
: throw new CommerceException("Coupon status is invalid.", "invalid_coupon_status");
|
|
}
|
|
|
|
private static string NormalizeEnum(string? value) =>
|
|
string.Concat((value ?? string.Empty).Split(
|
|
['_', '-', ' '],
|
|
StringSplitOptions.RemoveEmptyEntries));
|
|
|
|
private static string NormalizeRequired(string? value, string code)
|
|
{
|
|
var trimmed = value?.Trim();
|
|
return !string.IsNullOrWhiteSpace(trimmed)
|
|
? trimmed
|
|
: throw new CommerceException("Required commerce value is missing.", code);
|
|
}
|
|
|
|
private static string NormalizeProvider(string? provider)
|
|
{
|
|
var normalized = (provider ?? PaymentProviders.Manual)
|
|
.Trim()
|
|
.ToLowerInvariant()
|
|
.Replace("-", "_", StringComparison.Ordinal);
|
|
|
|
return normalized switch
|
|
{
|
|
"" => PaymentProviders.Manual,
|
|
"wechat" or "wechatpay" or "wxpay" or "wx_pay" => PaymentProviders.WechatPay,
|
|
"ali_pay" => PaymentProviders.Alipay,
|
|
PaymentProviders.WechatPay or PaymentProviders.Alipay or PaymentProviders.Manual => normalized,
|
|
_ => throw new CommerceException("Payment provider is invalid.", "invalid_payment_provider")
|
|
};
|
|
}
|
|
|
|
private static string NormalizeMethod(string? method)
|
|
{
|
|
var normalized = (method ?? "manual").Trim().ToLowerInvariant();
|
|
return string.IsNullOrWhiteSpace(normalized) ? "manual" : normalized;
|
|
}
|
|
|
|
private static bool IsPaid(string status) =>
|
|
string.Equals(status, "paid", StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(status, "success", StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(status, "succeeded", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static string GenerateOrderNo()
|
|
{
|
|
Span<byte> bytes = stackalloc byte[4];
|
|
RandomNumberGenerator.Fill(bytes);
|
|
return $"TK{DateTimeOffset.UtcNow:yyyyMMddHHmmss}{Convert.ToHexString(bytes)}";
|
|
}
|
|
|
|
private static string FormatCny(int cents) =>
|
|
(cents / 100m).ToString("0.00", CultureInfo.InvariantCulture);
|
|
}
|