payment-kit 1.20.10 → 1.20.12

package/api/src/libs/discount/discount.ts

@@ -0,0 +1,349 @@
+import { BN } from '@ocap/util';
+import { Coupon, Discount, PaymentCurrency, PromotionCode } from '../../store/models';
+import type { TLineItemExpanded } from '../../store/models';
+import { getPriceUintAmountByCurrency } from '../price';
+import { validCoupon, checkPromotionCodeEligibility, calculateDiscountAmount } from './coupon';
+import logger from '../logger';
+
+const getItemsTotalAmount = (lineItems: TLineItemExpanded[], currencyId: string, options?: { trialing?: boolean }) => {
+  let totalUnitPrice = new BN(0);
+
+  lineItems.forEach((item) => {
+    const price = item.upsell_price || item.price;
+    const unitPrice = getPriceUintAmountByCurrency(price, currencyId);
+
+    if (price?.type === 'recurring') {
+      if (options?.trialing) {
+        return;
+      }
+      if (price?.recurring?.usage_type === 'metered') {
+        return;
+      }
+    }
+
+    totalUnitPrice = totalUnitPrice.add(new BN(unitPrice).mul(new BN(item.quantity)));
+  });
+  return totalUnitPrice.toString();
+};
+
+const getItemAmount = (item: TLineItemExpanded, currencyId: string) => {
+  const price = item.upsell_price || item.price;
+  const unitPrice = getPriceUintAmountByCurrency(price, currencyId);
+  return new BN(unitPrice).mul(new BN(item.quantity)).toString();
+};
+
+/**
+ * Apply discounts to line items and calculate discount summary
+ */
+export async function applyDiscountsToLineItems({
+  lineItems,
+  promotionCodeId,
+  couponId,
+  discountId,
+  customerId,
+  currency,
+  totalAmount,
+  billingContext,
+}: {
+  lineItems: TLineItemExpanded[];
+  promotionCodeId?: string;
+  discountId?: string;
+  couponId: string;
+  customerId: string;
+  currency: PaymentCurrency;
+  totalAmount?: string; // Optional, will calculate from lineItems if not provided
+  billingContext?: { trialing?: boolean };
+}): Promise<{
+  enhancedLineItems: (TLineItemExpanded & {
+    discountable: boolean;
+    discount_amounts: Array<{ amount: string; coupon: string }>;
+  })[];
+  discountSummary: {
+    appliedCoupon: string | null;
+    discountAmount: string;
+    totalDiscountAmount: string;
+    finalTotal: string;
+  };
+  notValidReason?: string;
+}> {
+  let discount = null;
+  if (discountId) {
+    discount = await Discount.findByPk(discountId);
+  }
+
+  // 1. Calculate total amount from lineItems if not provided, considering billing context
+  const baseTotal = totalAmount ?? getItemsTotalAmount(lineItems, currency.id, billingContext);
+
+  // 2. Get coupon (required)
+  const coupon = await Coupon.findByPk(discount?.coupon_id || couponId);
+  if (!coupon) {
+    // 3. If couponId doesn't exist, return original items
+    const enhancedLineItems = lineItems.map((item) => ({
+      ...item,
+      discountable: false,
+      discount_amounts: [],
+    }));
+    return {
+      enhancedLineItems,
+      discountSummary: {
+        appliedCoupon: null,
+        discountAmount: '0',
+        totalDiscountAmount: '0',
+        finalTotal: baseTotal,
+      },
+      notValidReason: 'Coupon not found',
+    };
+  }
+
+  let isValid = false;
+  let notValidReason = '';
+
+  // 4. Validate coupon eligibility
+  if (promotionCodeId || discount?.promotion_code_id) {
+    // Get promotion code and use comprehensive validation
+    const promotionCode = await PromotionCode.findByPk(promotionCodeId || discount?.promotion_code_id);
+    if (!promotionCode) {
+      isValid = false;
+    } else {
+      const eligibility = await checkPromotionCodeEligibility({
+        promotionCode,
+        couponId,
+        customerId,
+        amount: baseTotal,
+        currencyId: currency.id,
+        lineItems,
+      });
+      isValid = eligibility.eligible;
+      notValidReason = eligibility.reason || '';
+    }
+  } else {
+    // Direct coupon validation
+    const couponValidation = await validCoupon(coupon, lineItems);
+    isValid = couponValidation.valid;
+    notValidReason = couponValidation.reason || '';
+  }
+
+  if (!isValid) {
+    // Return original items if validation fails
+    const enhancedLineItems = lineItems.map((item) => ({
+      ...item,
+      discountable: false,
+      discount_amounts: [],
+    }));
+    return {
+      enhancedLineItems,
+      discountSummary: {
+        appliedCoupon: null,
+        discountAmount: '0',
+        totalDiscountAmount: '0',
+        finalTotal: baseTotal,
+      },
+      notValidReason,
+    };
+  }
+
+  // Use common calculation logic
+  const result = calculateDiscountForLineItems({
+    lineItems,
+    coupon,
+    discount,
+    currency,
+    totalAmount,
+    billingContext,
+  });
+
+  return {
+    ...result,
+    notValidReason: undefined, // No validation error if we reach here
+  };
+}
+
+/**
+ * Common discount calculation logic
+ */
+function calculateDiscountForLineItems({
+  lineItems,
+  coupon,
+  discount,
+  currency,
+  totalAmount,
+  billingContext,
+}: {
+  lineItems: TLineItemExpanded[];
+  coupon: Coupon;
+  discount?: Discount | null;
+  currency: PaymentCurrency;
+  totalAmount?: string;
+  billingContext?: { trialing?: boolean };
+}): {
+  enhancedLineItems: (TLineItemExpanded & {
+    discountable: boolean;
+    discount_amounts: Array<{ amount: string; coupon: string }>;
+  })[];
+  discountSummary: {
+    appliedCoupon: string | null;
+    discountAmount: string;
+    totalDiscountAmount: string;
+    finalTotal: string;
+  };
+} {
+  // 1. Calculate total amount from lineItems if not provided, considering billing context
+  const baseTotal = totalAmount ?? getItemsTotalAmount(lineItems, currency.id, billingContext);
+
+  // 2. Get all eligible items based on coupon product restrictions
+  const eligibleLineItems = lineItems.filter((item) => {
+    if (!coupon.applies_to?.products?.length) {
+      return true; // No product restriction, all items eligible
+    }
+    return coupon.applies_to.products.some((productId) => item.price?.product_id === productId);
+  });
+
+  if (eligibleLineItems.length === 0) {
+    // No eligible items, return original
+    const enhancedLineItems = lineItems.map((item) => ({
+      ...item,
+      discountable: false,
+      discount_amounts: [],
+    }));
+    return {
+      enhancedLineItems,
+      discountSummary: {
+        appliedCoupon: null,
+        discountAmount: '0',
+        totalDiscountAmount: '0',
+        finalTotal: baseTotal,
+      },
+    };
+  }
+
+  // 3. Calculate total eligible amount (only products that qualify for the discount)
+  const totalEligibleAmount = eligibleLineItems.reduce((sum, item) => {
+    const itemAmount = getItemAmount(item, currency.id);
+    return new BN(sum).add(new BN(itemAmount)).toString();
+  }, '0');
+
+  // 4. Calculate discount amount based ONLY on eligible products, not the entire cart
+  const totalDiscountAmount = calculateDiscountAmount(coupon, totalEligibleAmount, currency);
+
+  // Ensure discount doesn't exceed base total
+  const adjustedDiscountAmount = new BN(totalDiscountAmount).gt(new BN(baseTotal)) ? baseTotal : totalDiscountAmount;
+
+  const finalTotal = new BN(baseTotal).sub(new BN(adjustedDiscountAmount));
+  const adjustedFinalTotal = finalTotal.lt(new BN('0')) ? '0' : finalTotal.toString();
+
+  // 5. Apply discount to line items
+  const enhancedLineItems = lineItems.map((item) => {
+    const isEligible = eligibleLineItems.includes(item);
+
+    if (!isEligible) {
+      return {
+        ...item,
+        discountable: false,
+        discount_amounts: [],
+      };
+    }
+
+    const itemAmount = getItemAmount(item, currency.id);
+    let itemDiscountAmount = '0';
+
+    if (coupon.percent_off > 0) {
+      // For percentage discounts, apply directly to each eligible item
+      itemDiscountAmount = new BN(itemAmount).mul(new BN(coupon.percent_off)).div(new BN(100)).toString();
+    } else if (coupon.amount_off && totalEligibleAmount !== '0') {
+      // For fixed amount discounts, distribute proportionally among eligible items
+      itemDiscountAmount = new BN(itemAmount)
+        .mul(new BN(adjustedDiscountAmount))
+        .div(new BN(totalEligibleAmount))
+        .toString();
+    }
+
+    return {
+      ...item,
+      discountable: true,
+      discount_amounts:
+        itemDiscountAmount !== '0' ? [{ amount: itemDiscountAmount, coupon: coupon.id, discount: discount?.id }] : [],
+    };
+  });
+
+  return {
+    enhancedLineItems,
+    discountSummary: {
+      appliedCoupon: coupon.id,
+      discountAmount: adjustedDiscountAmount,
+      totalDiscountAmount: adjustedDiscountAmount,
+      finalTotal: adjustedFinalTotal,
+    },
+  };
+}
+
+/**
+ * Apply discount to subscription billing cycles (skips validation for stored discounts)
+ */
+export async function applySubscriptionDiscount({
+  lineItems,
+  discount,
+  currency,
+  totalAmount,
+  billingContext,
+}: {
+  lineItems: TLineItemExpanded[];
+  discount: Discount;
+  currency: PaymentCurrency;
+  totalAmount?: string;
+  billingContext?: { trialing?: boolean };
+}): Promise<{
+  enhancedLineItems: (TLineItemExpanded & {
+    discountable: boolean;
+    discount_amounts: Array<{ amount: string; coupon: string }>;
+  })[];
+  discountSummary: {
+    appliedCoupon: string | null;
+    discountAmount: string;
+    totalDiscountAmount: string;
+    finalTotal: string;
+  };
+}> {
+  // Get coupon from stored discount
+  const coupon = await Coupon.findByPk(discount.coupon_id);
+  if (!coupon) {
+    logger.error('Coupon not found for stored discount', {
+      discountId: discount.id,
+      couponId: discount.coupon_id,
+    });
+
+    // Return original items if coupon is missing
+    const enhancedLineItems = lineItems.map((item) => ({
+      ...item,
+      discountable: false,
+      discount_amounts: [],
+    }));
+    return {
+      enhancedLineItems,
+      discountSummary: {
+        appliedCoupon: null,
+        discountAmount: '0',
+        totalDiscountAmount: '0',
+        finalTotal: totalAmount ?? getItemsTotalAmount(lineItems, currency.id, billingContext),
+      },
+    };
+  }
+
+  // Use common calculation logic
+  const result = calculateDiscountForLineItems({
+    lineItems,
+    coupon,
+    discount,
+    currency,
+    totalAmount,
+    billingContext,
+  });
+
+  logger.info('Applied subscription discount', {
+    discountId: discount.id,
+    originalTotal: totalAmount,
+    discountAmount: result.discountSummary.discountAmount,
+    finalTotal: result.discountSummary.finalTotal,
+  });
+
+  return result;
+}

package/api/src/libs/discount/nft.ts

@@ -0,0 +1,239 @@
+// NFT verification for promotion codes
+// TODO: This module needs implementation for NFT-based promotion code validation
+
+import logger from '../logger';
+import { PromotionCode, Coupon } from '../../store/models';
+import { validPromotionCode } from './coupon';
+
+/**
+ * NFT verification config interface
+ */
+export interface NFTConfig {
+  addresses?: string[];
+  tags?: string[];
+  trusted_issuers?: string[];
+  trusted_parents?: string[];
+  min_balance?: number;
+}
+
+/**
+ * NFT match result interface
+ */
+export interface NFTMatchResult {
+  valid: boolean;
+  matchedNFTs: Array<{
+    address: string;
+    tag?: string;
+    type: 'tag_match' | 'address_match';
+  }>;
+}
+
+/**
+ * NFT verification using separated NFT config structure
+ * TODO: Implement proper NFT client integration
+ */
+export function verifyNFTConfig(userDid: string, nftConfig: NFTConfig): Promise<NFTMatchResult> {
+  return Promise.resolve()
+    .then(() => {
+      // TODO: Implement proper NFT client integration
+      // This should connect to blockchain services to verify NFT ownership
+      logger.info('NFT verification called', { userDid, nftConfig });
+
+      // Placeholder implementation - always returns false for now
+      // In real implementation, this would:
+      // 1. Connect to blockchain client (ArcBlock, Ethereum, etc.)
+      // 2. Query user's NFT assets
+      // 3. Match against config requirements (addresses, tags, issuers, parents)
+      // 4. Check minimum balance requirements
+
+      return {
+        valid: false, // TODO: Implement actual verification
+        matchedNFTs: [],
+      };
+    })
+    .catch((error) => {
+      logger.error('Error verifying NFT config', {
+        userDid,
+        nftConfig,
+        error: error.message,
+      });
+
+      return {
+        valid: false,
+        matchedNFTs: [],
+      };
+    });
+}
+
+/**
+ * Validates NFT voucher and returns associated promotion code
+ * TODO: This function needs proper NFT ownership verification
+ */
+export function validateNFTVoucher(
+  nftAddress: string,
+  userDid: string,
+  paymentMethodId: string
+): { valid: boolean; error?: string; nftAddress?: string; promotionCode?: any; coupon?: any; discount?: any } {
+  try {
+    logger.info('NFT voucher validation called', { nftAddress, userDid, paymentMethodId });
+
+    // TODO: Implement NFT ownership verification
+    // This should:
+    // 1. Verify user owns the NFT at the given address
+    // 2. Find promotion code mapped to this NFT
+    // 3. Return validation result
+
+    return { valid: false, error: 'NFT_VERIFICATION_NOT_IMPLEMENTED' };
+  } catch (error) {
+    logger.error('Error validating NFT voucher', {
+      nftAddress,
+      userDid,
+      error: error.message,
+    });
+    return { valid: false, error: error.message };
+  }
+}
+
+/**
+ * 根据用户DID匹配可用的NFT促销
+ * TODO: This function needs to be integrated with actual NFT verification
+ */
+export function getNFTPromotions(
+  userDid: string,
+  currencyId: string,
+  amount?: string
+): Promise<
+  Array<{
+    promotion_code_id: string;
+    code: string;
+    coupon: any;
+    matched_nfts: Array<{
+      address: string;
+      tag?: string;
+      type: 'tag_match' | 'address_match';
+    }>;
+    discount_amount: string;
+    discount_type: 'amount_off' | 'percent_off';
+  }>
+> {
+  return Promise.resolve()
+    .then(() => {
+      logger.info('NFT promotions query called', { userDid, currencyId, amount });
+
+      // TODO: Implement NFT promotion matching
+      // This should:
+      // 1. Query promotion codes with NFT verification requirements
+      // 2. Check user's NFT ownership against each requirement
+      // 3. Return matching promotions with discount information
+
+      return []; // Placeholder - return empty array until implemented
+    })
+    .catch((error) => {
+      logger.error('Error getting NFT promotions', { userDid, currencyId, error: error.message });
+      return [];
+    });
+}
+
+/**
+ * 新的促销码验证函数，支持NFT验证模式
+ * TODO: This function needs integration with proper NFT verification systems
+ */
+export async function validatePromotionCodeWithNFT(
+  code: string,
+  customerId: string,
+  currencyId: string,
+  amount: string,
+  userDid?: string,
+  inputMethod: 'code' | 'nft' = 'code'
+) {
+  try {
+    logger.info('Promotion code validation with NFT support called', {
+      code,
+      customerId,
+      currencyId,
+      amount,
+      userDid,
+      inputMethod,
+    });
+
+    // Find promotion code
+    const promotionCode = await PromotionCode.findOne({
+      where: {
+        code: code.toLowerCase(),
+        active: true,
+      },
+      include: [
+        {
+          model: Coupon,
+          as: 'coupon',
+          required: true,
+        },
+      ],
+    });
+
+    if (!promotionCode) {
+      return { valid: false, error: 'PROMOTION_CODE_NOT_FOUND' };
+    }
+
+    // Basic validation using coupon.ts logic
+    const basicValidation = await validPromotionCode(promotionCode, {
+      customerId,
+      amount,
+      currencyId,
+    });
+
+    if (!basicValidation.valid) {
+      return {
+        valid: false,
+        error: basicValidation.reason || 'PROMOTION_CODE_INVALID',
+      };
+    }
+
+    // Check for NFT verification requirements
+    if (promotionCode.verification_type === 'nft' && promotionCode.nft_config) {
+      if (!userDid) {
+        return { valid: false, error: 'USER_AUTHENTICATION_REQUIRED' };
+      }
+
+      // TODO: Implement NFT verification
+      const nftVerification = await verifyNFTConfig(userDid, promotionCode.nft_config);
+
+      if (!nftVerification.valid) {
+        return { valid: false, error: 'NFT_VERIFICATION_FAILED' };
+      }
+    }
+
+    // Build success response
+    const { coupon } = promotionCode as any;
+    const discount: any = {
+      duration: coupon.duration,
+      duration_in_months: coupon.duration_in_months,
+    };
+
+    if (coupon.percent_off && coupon.percent_off > 0) {
+      discount.type = 'percent';
+      discount.value = coupon.percent_off;
+    } else if (coupon.amount_off && coupon.amount_off !== '0') {
+      discount.type = 'amount';
+      discount.value = coupon.amount_off;
+      discount.currency_id = currencyId;
+    }
+
+    return {
+      valid: true,
+      promotionCode,
+      coupon,
+      discount,
+    };
+  } catch (error) {
+    logger.error('Error validating promotion code with NFT', {
+      code,
+      customerId,
+      currencyId,
+      userDid,
+      inputMethod,
+      error: error.message,
+    });
+    return { valid: false, error: error.message };
+  }
+}