payment-kit 1.18.56 → 1.19.1

package/api/src/libs/notification/template/subscription-will-renew.ts

@@ -1,33 +1,18 @@
 /* eslint-disable @typescript-eslint/brace-style */
 /* eslint-disable @typescript-eslint/indent */
 import type { ManipulateType } from 'dayjs';
-import prettyMsI18n from 'pretty-ms-i18n';
 import type { LiteralUnion } from 'type-fest';
 
 import { fromUnitToToken } from '@ocap/util';
 import dayjs from '../../dayjs';
 import { getTokenByAddress } from '../../../integrations/arcblock/stake';
-import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
-import {
-  Customer,
-  Invoice,
-  PaymentMethod,
-  Price,
-  Subscription,
-  SubscriptionItem,
-  PaymentCurrency,
-} from '../../../store/models';
+import { Invoice, Price, SubscriptionItem } from '../../../store/models';
 import type { PaymentDetail } from '../../payment';
-import { getMainProductName } from '../../product';
-import {
-  getCustomerSubscriptionPageUrl,
-  getSubscriptionPaymentAddress,
-  getPaymentAmountForCycleSubscription,
-} from '../../subscription';
-import { formatTime, getPrettyMsI18nLocale, getSimplifyDuration } from '../../time';
-import { formatCurrencyInfo, getCustomerRechargeLink, getSubscriptionNotificationCustomActions } from '../../util';
-import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import { getSubscriptionPaymentAddress, getPaymentAmountForCycleSubscription } from '../../subscription';
+import { formatTime, getSimplifyDuration } from '../../time';
+import { formatCurrencyInfo, getCustomerRechargeLink } from '../../util';
+import { BaseSubscriptionEmailTemplate, BaseEmailTemplateType } from './base';
 
 export interface SubscriptionWillRenewEmailTemplateOptions {
   subscriptionId: string;
@@ -43,110 +28,109 @@ interface SubscriptionWillRenewEmailTemplateContext {
   willRenewDuration: string;
   paymentDetail: PaymentDetail;
   paidType: string;
-
   userDid: string;
   paymentInfo: string;
   currentPeriodStart: string;
   currentPeriodEnd: string;
   duration: string;
-
   viewSubscriptionLink: string;
   addFundsLink: string;
-  paymentMethod: PaymentMethod | null;
   customActions: any[];
+  isCreditSubscription: boolean;
+  isStripe: boolean;
 }
 
-export class SubscriptionWillRenewEmailTemplate
-  implements BaseEmailTemplate<SubscriptionWillRenewEmailTemplateContext>
-{
+export class SubscriptionWillRenewEmailTemplate extends BaseSubscriptionEmailTemplate<SubscriptionWillRenewEmailTemplateContext> {
   options: SubscriptionWillRenewEmailTemplateOptions;
 
   constructor(options: SubscriptionWillRenewEmailTemplateOptions) {
+    super();
     this.options = options;
   }
 
   async getContext(): Promise<SubscriptionWillRenewEmailTemplateContext> {
-    const subscription: Subscription | null = await Subscription.findByPk(this.options.subscriptionId);
-    if (!subscription) {
-      throw new Error(`Subscription not found: ${this.options.subscriptionId}`);
-    }
+    // 获取基础订阅数据
+    const basicData = await this.getSubscriptionBasicData(this.options.subscriptionId);
+    const { subscription, userDid, locale, productName, paymentCurrency, isCreditSubscription } = basicData;
+
     if (subscription.isActive() === false) {
       throw new Error(`Subscription not active: ${this.options.subscriptionId}`);
     }
     if (subscription.isScheduledToCancel()) {
       throw new Error(`Subscription is scheduled to cancel: ${this.options.subscriptionId}`);
     }
-    if (await this.subscriptionIsRenewed(subscription)) {
+    if (this.subscriptionIsRenewed(subscription)) {
       throw new Error(`The subscription(${this.options.subscriptionId}) has been renewed`);
     }
 
-    const customer = await Customer.findByPk(subscription.customer_id);
-    if (!customer) {
-      throw new Error(`Customer not found: ${subscription.customer_id}`);
-    }
+    const invoice = await Invoice.findByPk(subscription.latest_invoice_id);
 
-    const invoice = (await Invoice.findByPk(subscription.latest_invoice_id)) as Invoice;
-    const paymentCurrency = (await PaymentCurrency.findOne({
-      where: {
-        id: subscription.currency_id,
-      },
-    })) as PaymentCurrency;
+    // 获取支付信息
+    const paymentInfoResult = await this.getPaymentInfo(
+      subscription,
+      paymentCurrency,
+      isCreditSubscription,
+      invoice?.id
+    );
 
-    const userDid = customer.did;
-    const locale = await getUserLocale(userDid);
-    const productName = await getMainProductName(subscription.id);
-    const at: string = formatTime(invoice.period_end * 1000);
-    const willRenewDuration = getSimplifyDuration((invoice.period_end - dayjs().unix()) * 1000, locale);
+    // 获取链接
+    const links = this.generateSubscriptionLinks(
+      subscription,
+      locale,
+      userDid,
+      'customer.subscription.will_renew',
+      invoice?.id,
+      isCreditSubscription
+    );
+
+    // 计算时间和支付详情 - 使用invoice的period_end，如果不存在则使用subscription的current_period_end
+    const periodEnd = invoice?.period_end || subscription.current_period_end;
+    const at = formatTime(periodEnd * 1000);
+    const willRenewDuration = getSimplifyDuration((periodEnd - dayjs().unix()) * 1000, locale);
 
     const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
     const paymentDetail = { price: paymentAmount, balance: 0, symbol: paymentCurrency.symbol, balanceFormatted: '0' };
 
-    const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
-    if (!paymentMethod) {
-      throw new Error(`Payment method not found: ${paymentCurrency.payment_method_id}`);
+    // 获取余额信息（非 Stripe 支付方式）
+    const isStripe = paymentInfoResult.paymentMethod?.type === 'stripe';
+    if (!isStripe && !isCreditSubscription) {
+      const paymentAddress = getSubscriptionPaymentAddress(subscription, paymentInfoResult.paymentMethod!.type);
+      const balance = await getTokenByAddress(paymentAddress, paymentInfoResult.paymentMethod!, paymentCurrency);
+      paymentDetail.balanceFormatted = fromUnitToToken(balance, paymentCurrency.decimal);
+      paymentDetail.balance = +paymentDetail.balanceFormatted;
     }
 
-    const paymentAddress = getSubscriptionPaymentAddress(subscription, paymentMethod.type);
-    const balance = await getTokenByAddress(paymentAddress, paymentMethod, paymentCurrency);
-    paymentDetail.balanceFormatted = fromUnitToToken(balance, paymentCurrency.decimal);
-    paymentDetail.balance = +paymentDetail.balanceFormatted;
-
-    const { isPrePaid, interval } = await this.getPaymentCategory({
-      subscriptionId: subscription.id,
-    });
-    const paidType: string = isPrePaid
+    // 获取支付类型和周期信息
+    const { isPrePaid, interval } = await this.getPaymentCategory(subscription.id);
+    const paidType = isPrePaid
       ? translate('notification.common.prepaid', locale)
       : translate('notification.common.postpaid', locale);
-    const paymentInfo: string = formatCurrencyInfo(paymentDetail?.price || '0', paymentCurrency, paymentMethod, true);
-    const currentPeriodStart: string = isPrePaid
-      ? formatTime(invoice.period_end * 1000)
-      : formatTime(invoice.period_start * 1000);
-    const currentPeriodEnd: string = isPrePaid
-      ? formatTime(dayjs(invoice.period_end * 1000).add(1, interval as ManipulateType))
-      : formatTime(invoice.period_end * 1000);
-    const duration: string = prettyMsI18n(
-      new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(),
-      {
-        locale: getPrettyMsI18nLocale(locale),
-      }
+
+    const paymentInfo = formatCurrencyInfo(
+      paymentDetail?.price || '0',
+      paymentCurrency,
+      paymentInfoResult.paymentMethod,
+      true
     );
 
-    const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
-      subscriptionId: subscription.id,
-      locale,
-      userDid,
-    });
-    const addFundsLink: string = getCustomerRechargeLink({
+    // 计算周期时间 - 使用安全的回退机制
+    const periodStart = invoice?.period_start || subscription.current_period_start;
+    const periodInfo = this.formatSubscriptionPeriod(
+      isPrePaid ? periodEnd : periodStart,
+      isPrePaid
+        ? dayjs(periodEnd * 1000)
+            .add(1, interval as ManipulateType)
+            .unix()
+        : periodEnd,
+      locale
+    );
+
+    const addFundsLink = getCustomerRechargeLink({
       locale,
       userDid,
       subscriptionId: subscription.id,
     });
 
-    const customActions = getSubscriptionNotificationCustomActions(
-      subscription,
-      'customer.subscription.will_renew',
-      locale
-    );
     return {
       locale,
       productName,
@@ -154,62 +138,49 @@ export class SubscriptionWillRenewEmailTemplate
       willRenewDuration,
       paymentDetail,
       paidType,
-
       userDid,
       paymentInfo,
-      currentPeriodStart,
-      currentPeriodEnd,
-      duration,
-
-      viewSubscriptionLink,
+      currentPeriodStart: periodInfo.currentPeriodStart,
+      currentPeriodEnd: periodInfo.currentPeriodEnd,
+      duration: periodInfo.duration,
+      viewSubscriptionLink: links.viewSubscriptionLink,
       addFundsLink,
-      paymentMethod,
-      customActions,
+      customActions: links.customActions,
+      isCreditSubscription,
+      isStripe,
     };
   }
-  async getPaymentCategory({ subscriptionId }: { subscriptionId: string }): Promise<{
+
+  private async getPaymentCategory(subscriptionId: string): Promise<{
     isPrePaid: boolean;
     interval: LiteralUnion<'hour' | 'day' | 'week' | 'month' | 'year', string> | undefined;
   }> {
     const subscriptionItems = await SubscriptionItem.findAll({
-      where: {
-        subscription_id: subscriptionId,
-      },
+      where: { subscription_id: subscriptionId },
     });
 
     const lineItemExpanded = await Price.expand(subscriptionItems);
     const metered = lineItemExpanded.find((lineItem) => lineItem.price.recurring?.usage_type === 'metered');
     const recurringItems = lineItemExpanded.filter((lineItem) => lineItem.price.type === 'recurring');
 
-    const isPrePaid = !metered;
-    const interval = recurringItems?.[0]?.price.recurring?.interval;
-
     return {
-      isPrePaid,
-      interval,
+      isPrePaid: !metered,
+      interval: recurringItems?.[0]?.price.recurring?.interval,
     };
   }
 
-  /**
-   * @see https://github.com/blocklet/payment-kit/issues/307
-   * @description 该订阅已经在指定期限内续费过了吗?
-   * @param {Subscription} subscription
-   * @return {*}  {Promise<void>}
-   * @memberof SubscriptionWillRenewEmailTemplate
-   */
-  // eslint-disable-next-line require-await
-  async subscriptionIsRenewed(subscription: Subscription): Promise<boolean> {
-    // @note: 为了最精确的验证，这里的期限 this.options.willRenewValue 还要 + 1,如果没有订阅没有续费,那么 expectedCurrentPeriodEnd 一定是大于 currentPeriodEnd
-    const expectedCurrentPeriodEnd: number = dayjs()
+  private subscriptionIsRenewed(subscription: any): boolean {
+    const expectedCurrentPeriodEnd = dayjs()
       .add(this.options.willRenewValue + 1, this.options.willRenewUnit)
       .toDate()
       .getTime();
-    const currentPeriodEnd: number = subscription.current_period_end * 1000;
+    const currentPeriodEnd = subscription.current_period_end * 1000;
 
     return currentPeriodEnd > expectedCurrentPeriodEnd;
   }
 
   async getTemplate(): Promise<BaseEmailTemplateType | null> {
+    const context = await this.getContext();
     const {
       locale,
       productName,
@@ -217,195 +188,199 @@ export class SubscriptionWillRenewEmailTemplate
       willRenewDuration,
       paymentDetail,
       paidType,
-
       userDid,
       paymentInfo,
       currentPeriodStart,
       currentPeriodEnd,
       duration,
-
       viewSubscriptionLink,
       addFundsLink,
-      paymentMethod,
       customActions,
-    } = await this.getContext();
+      isCreditSubscription,
+      isStripe,
+    } = context;
 
     // 如果当前时间大于预计扣费时间，那么不发送通知
     if (dayjs().utc().isAfter(dayjs.utc(at))) {
       return null;
     }
-    const canPay: boolean = paymentDetail.balance >= paymentDetail.price;
-    if (canPay) {
-      // 当余额足够支付并且本封邮件不是必须发送时,可以不发送邮件
+
+    const canPay = paymentDetail.balance >= paymentDetail.price;
+    if (canPay && !this.options.required) {
       return null;
     }
+
     if (!paymentDetail.price && paymentDetail.symbol !== 'USD') {
-      // 如果预估的价格是 0 并且货币不是 USD，那么直接不发送
       return null;
     }
-    const isStripe = paymentMethod?.type === 'stripe';
-    const template: BaseEmailTemplateType = {
-      title: `${translate('notification.subscriptionWillRenew.title', locale, {
-        productName,
-        willRenewDuration,
-      })}`,
-      body:
-        canPay || isStripe
-          ? `${translate('notification.subscriptionWillRenew.body', locale, {
-              at,
-              productName,
-              willRenewDuration,
-              balance: `${paymentDetail.balanceFormatted} ${paymentDetail.symbol}`,
-            })}`
-          : `${translate('notification.subscriptionWillRenew.unableToPayBody', locale, {
-              at,
-              productName,
-              willRenewDuration,
-            })}`,
-      // @ts-expect-error
-      attachments: [
-        {
-          type: 'section',
-          fields: [
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                color: '#9397A1',
-                text: translate('notification.common.account', locale),
-              },
+
+    // 构建字段
+    const commonFields = this.buildCommonFields(userDid, productName, locale);
+
+    // 续费金额字段
+    const renewAmountFields = isCreditSubscription
+      ? []
+      : [
+          {
+            type: 'text',
+            data: {
+              type: 'plain',
+              color: '#9397A1',
+              text: translate('notification.subscriptionWillRenew.renewAmount', locale),
             },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                text: userDid,
-              },
+          },
+          {
+            type: 'text',
+            data: {
+              type: 'plain',
+              text: paymentInfo,
             },
+          },
+        ];
+
+    // 当前余额字段（非 Stripe 时显示）
+    const balanceFields =
+      !isStripe && !isCreditSubscription
+        ? [
             {
               type: 'text',
               data: {
                 type: 'plain',
                 color: '#9397A1',
-                text: translate('notification.common.product', locale),
+                text: translate('notification.common.currentBalance', locale),
               },
             },
             {
               type: 'text',
               data: {
                 type: 'plain',
-                text: productName,
+                ...(!canPay && { color: '#FF0000' }),
+                text: `${paymentDetail.balanceFormatted} ${paymentDetail.symbol}`,
               },
             },
+          ]
+        : [];
+
+    // 余额不足提醒字段
+    const insufficientBalanceFields =
+      !canPay && !isStripe && !isCreditSubscription
+        ? [
             {
               type: 'text',
               data: {
                 type: 'plain',
                 color: '#9397A1',
-                text: translate('notification.subscriptionWillRenew.renewAmount', locale),
+                text: translate('notification.common.balanceReminder', locale),
               },
             },
             {
               type: 'text',
               data: {
                 type: 'plain',
-                text: paymentInfo,
+                color: '#FF0000',
+                text: translate('notification.subscriptionWillRenew.unableToPayReason', locale, {
+                  balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
+                  price: `${paymentDetail.price} ${paymentDetail.symbol}`,
+                }),
               },
             },
-            ...(!isStripe
-              ? [
-                  {
-                    type: 'text',
-                    data: {
-                      type: 'plain',
-                      color: '#9397A1',
-                      text: translate('notification.common.currentBalance', locale),
-                    },
-                  },
-                  {
-                    type: 'text',
-                    data: {
-                      type: 'plain',
-                      ...(!canPay && {
-                        color: '#FF0000',
-                      }),
-                      text: `${paymentDetail.balanceFormatted} ${paymentDetail.symbol}`,
-                    },
-                  },
-                ]
-              : []),
-            ...(!canPay && !isStripe
-              ? [
-                  {
-                    type: 'text',
-                    data: {
-                      type: 'plain',
-                      color: '#9397A1',
-                      text: translate('notification.common.balanceReminder', locale),
-                    },
-                  },
-                  {
-                    type: 'text',
-                    data: {
-                      type: 'plain',
-                      color: '#FF0000',
-                      text: translate('notification.subscriptionWillRenew.unableToPayReason', locale, {
-                        balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
-                        price: `${paymentDetail.price} ${paymentDetail.symbol}`,
-                      }),
-                    },
-                  },
-                ]
-              : []),
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                color: '#9397A1',
-                text: translate('notification.common.paidType', locale),
-              },
+          ]
+        : [];
+
+    // 支付类型字段
+    const paidTypeFields = isCreditSubscription
+      ? []
+      : [
+          {
+            type: 'text',
+            data: {
+              type: 'plain',
+              color: '#9397A1',
+              text: translate('notification.common.paidType', locale),
             },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                text: `${paidType}`,
-              },
+          },
+          {
+            type: 'text',
+            data: {
+              type: 'plain',
+              text: paidType,
             },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                color: '#9397A1',
-                text: translate('notification.common.paymentPeriod', locale),
-              },
+          },
+        ];
+
+    // 支付周期字段
+    const periodFields = isCreditSubscription
+      ? []
+      : [
+          {
+            type: 'text',
+            data: {
+              type: 'plain',
+              color: '#9397A1',
+              text: translate('notification.common.paymentPeriod', locale),
             },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                text: `${currentPeriodStart} ~ ${currentPeriodEnd}(${duration})`,
-              },
+          },
+          {
+            type: 'text',
+            data: {
+              type: 'plain',
+              text: `${currentPeriodStart} ~ ${currentPeriodEnd}(${duration})`,
             },
-          ].filter(Boolean),
-        },
-      ].filter(Boolean),
-      // @ts-ignore
-      actions: [
-        !canPay &&
-          !isStripe &&
-          addFundsLink && {
-            name: translate('notification.common.addFunds', locale),
-            title: translate('notification.common.addFunds', locale),
-            link: addFundsLink,
           },
+        ];
+
+    // 构建操作按钮
+    const actions = [
+      !canPay &&
+        !isStripe &&
+        !isCreditSubscription &&
+        addFundsLink && {
+          name: translate('notification.common.addFunds', locale),
+          title: translate('notification.common.addFunds', locale),
+          link: addFundsLink,
+        },
+      {
+        name: translate('notification.common.viewSubscription', locale),
+        title: translate('notification.common.viewSubscription', locale),
+        link: viewSubscriptionLink,
+      },
+      ...customActions,
+    ].filter(Boolean);
+
+    const template: BaseEmailTemplateType = {
+      title: translate('notification.subscriptionWillRenew.title', locale, {
+        productName,
+        willRenewDuration,
+      }),
+      body:
+        canPay || isStripe
+          ? translate('notification.subscriptionWillRenew.body', locale, {
+              at,
+              productName,
+              willRenewDuration,
+              balance: `${paymentDetail.balanceFormatted} ${paymentDetail.symbol}`,
+            })
+          : translate('notification.subscriptionWillRenew.unableToPayBody', locale, {
+              at,
+              productName,
+              willRenewDuration,
+            }),
+      // @ts-expect-error
+      attachments: [
         {
-          name: translate('notification.common.viewSubscription', locale),
-          title: translate('notification.common.viewSubscription', locale),
-          link: viewSubscriptionLink,
+          type: 'section',
+          fields: [
+            ...commonFields,
+            ...renewAmountFields,
+            ...balanceFields,
+            ...insufficientBalanceFields,
+            ...paidTypeFields,
+            ...periodFields,
+          ].filter(Boolean),
         },
-        ...customActions,
       ].filter(Boolean),
+      // @ts-ignore
+      actions,
     };
 
     return template;