payment-kit 1.13.136 → 1.13.138

package/api/src/crons/base.ts

@@ -4,26 +4,17 @@ import pAll from 'p-all';
 
 import { notificationCronConcurrency } from '../libs/env';
 import logger from '../libs/logger';
-import type { SubscriptionTrialWillEndEmailTemplateOptions } from '../libs/notification/template/subscription-trial-will-end';
-import { NotificationQueueJob, notificationQueue } from '../queues/notification';
+import { NotificationQueueJobType, notificationQueue } from '../queues/notification';
 import type { Subscription } from '../store/models';
-import type { Diff } from './interface/diff';
+import type { Diff, Task } from './interface/base';
 
 export interface BaseSubscriptionScheduleNotificationSubscription extends Subscription {
   diffs: Diff[];
 }
 
-export type BaseSubscriptionScheduleNotificationEventType =
-  | 'customer.subscription.trial_will_end'
-  | 'customer.subscription.will_renew';
+export type BaseSubscriptionScheduleNotificationEventType = NotificationQueueJobType;
 
-type Task<Options> = {
-  id: string;
-  job: { type: NotificationQueueJob['type']; options: Options };
-  delay: number;
-};
-
-export abstract class BaseSubscriptionScheduleNotification {
+export abstract class BaseSubscriptionScheduleNotification<Options extends any> {
   readonly start: number;
   readonly end: number;
   abstract eventType: BaseSubscriptionScheduleNotificationEventType;
@@ -154,30 +145,13 @@ export abstract class BaseSubscriptionScheduleNotification {
     });
   }
 
-  async addTaskToQueue<Options extends SubscriptionTrialWillEndEmailTemplateOptions>(
-    subscriptions: BaseSubscriptionScheduleNotificationSubscription[]
-  ): Promise<void> {
-    const type = this.eventType;
+  abstract getTask({ subscription, diff }: { subscription: Subscription; diff: Diff }): Task<Options>;
 
+  async addTaskToQueue(subscriptions: BaseSubscriptionScheduleNotificationSubscription[]): Promise<void> {
     const tasks: Task<Options>[] = [];
     for (const subscription of subscriptions) {
       for (const diff of subscription.diffs) {
-        const task: Task<Options> = {
-          id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
-          job: {
-            type,
-            options: {
-              subscriptionId: subscription.id,
-              willRenewValue: diff.value,
-              willRenewUnit: diff.unit,
-              required: !!diff.required,
-            } as Options,
-          },
-          delay: dayjs(subscription.current_period_end * 1000)
-            .subtract(diff.value, diff.unit)
-            .diff(this.start, 's'),
-        };
-
+        const task: Task<Options> = this.getTask({ subscription, diff });
         tasks.push(task);
       }
     }

package/api/src/crons/index.ts

@@ -5,6 +5,7 @@ import logger from '../libs/logger';
 import { startSubscriptionQueue } from '../queues/subscription';
 import { CheckoutSession } from '../store/models';
 import { SubscriptionTrailWillEndSchedule } from './subscription-trail-will-end';
+import { SubscriptionWillCanceledSchedule } from './subscription-will-canceled';
 import { SubscriptionWillRenewSchedule } from './subscription-will-renew';
 
 function init() {
@@ -23,6 +24,12 @@ function init() {
         fn: () => new SubscriptionTrailWillEndSchedule().run(),
         options: { runOnInit: true },
       },
+      {
+        name: 'customer.subscription.will_canceled',
+        time: notificationCronTime,
+        fn: () => new SubscriptionWillCanceledSchedule().run(),
+        options: { runOnInit: true },
+      },
       {
         name: 'subscription.schedule.retry',
         time: subscriptionCronTime,

package/api/src/crons/interface/base.ts

@@ -0,0 +1,17 @@
+import type { ManipulateType } from 'dayjs';
+
+import type { NotificationQueueJob } from '../../queues/notification';
+
+export interface Diff {
+  value: number;
+  unit: ManipulateType;
+
+  // 这个 job 必须跑吗?
+  required?: false | true;
+}
+
+export type Task<Options> = {
+  id: string;
+  job: { type: NotificationQueueJob['type']; options: Options };
+  delay: number;
+};

package/api/src/crons/subscription-trail-will-end.ts

@@ -1,10 +1,13 @@
+import dayjs from 'dayjs';
 /* eslint-disable no-console */
 import { Op } from 'sequelize';
 
+import type { SubscriptionTrialWillEndEmailTemplateOptions } from '../libs/notification/template/subscription-trial-will-end';
 import { Subscription } from '../store/models';
 import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
+import type { Diff, Task } from './interface/base';
 
-export class SubscriptionTrailWillEndSchedule extends BaseSubscriptionScheduleNotification {
+export class SubscriptionTrailWillEndSchedule extends BaseSubscriptionScheduleNotification<SubscriptionTrialWillEndEmailTemplateOptions> {
   override eventType: BaseSubscriptionScheduleNotificationEventType = 'customer.subscription.trial_will_end';
 
   async getSubscriptions(): Promise<Subscription[]> {
@@ -28,4 +31,29 @@ export class SubscriptionTrailWillEndSchedule extends BaseSubscriptionScheduleNo
 
     return subscriptions;
   }
+
+  override getTask({
+    subscription,
+    diff,
+  }: {
+    subscription: Subscription;
+    diff: Diff;
+  }): Task<SubscriptionTrialWillEndEmailTemplateOptions> {
+    const type = this.eventType;
+    return {
+      id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
+      job: {
+        type,
+        options: {
+          subscriptionId: subscription.id,
+          willRenewValue: diff.value,
+          willRenewUnit: diff.unit,
+          required: !!diff.required,
+        },
+      },
+      delay: dayjs(subscription.current_period_end * 1000)
+        .subtract(diff.value, diff.unit)
+        .diff(this.start, 's'),
+    };
+  }
 }

package/api/src/crons/subscription-will-canceled.ts

@@ -0,0 +1,48 @@
+/* eslint-disable no-console */
+import dayjs from 'dayjs';
+
+import type { SubscriptionWillCanceledEmailTemplateOptions } from '../libs/notification/template/subscription-will-canceled';
+import { Subscription } from '../store/models';
+import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
+import type { Diff, Task } from './interface/base';
+
+export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNotification<SubscriptionWillCanceledEmailTemplateOptions> {
+  override eventType: BaseSubscriptionScheduleNotificationEventType = 'customer.subscription.will_canceled';
+
+  async getSubscriptions(): Promise<Subscription[]> {
+    const subscriptions = await Subscription.findAll({
+      where: {
+        status: 'past_due',
+      },
+      attributes: ['id', 'current_period_start', 'current_period_end'],
+      raw: true,
+    });
+
+    return subscriptions;
+  }
+
+  override getTask({
+    subscription,
+    diff,
+  }: {
+    subscription: Subscription;
+    diff: Diff;
+  }): Task<SubscriptionWillCanceledEmailTemplateOptions> {
+    const type = this.eventType;
+    return {
+      id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
+      job: {
+        type,
+        options: {
+          subscriptionId: subscription.id,
+          willCancelValue: diff.value,
+          willCancelUnit: diff.unit,
+          required: !!diff.required,
+        },
+      },
+      delay: dayjs(subscription.current_period_end * 1000)
+        .subtract(diff.value, diff.unit)
+        .diff(this.start, 's'),
+    };
+  }
+}

package/api/src/crons/subscription-will-renew.ts

@@ -1,10 +1,12 @@
-/* eslint-disable no-console */
+import dayjs from 'dayjs';
 import { Op } from 'sequelize';
 
+import type { SubscriptionWillRenewEmailTemplateOptions } from '../libs/notification/template/subscription-will-renew';
 import { Subscription } from '../store/models';
 import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
+import type { Diff, Task } from './interface/base';
 
-export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotification {
+export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotification<SubscriptionWillRenewEmailTemplateOptions> {
   override eventType: BaseSubscriptionScheduleNotificationEventType = 'customer.subscription.will_renew';
 
   async getSubscriptions(): Promise<Subscription[]> {
@@ -26,4 +28,29 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
 
     return subscriptions;
   }
+
+  override getTask({
+    subscription,
+    diff,
+  }: {
+    subscription: Subscription;
+    diff: Diff;
+  }): Task<SubscriptionWillRenewEmailTemplateOptions> {
+    const type = this.eventType;
+    return {
+      id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
+      job: {
+        type,
+        options: {
+          subscriptionId: subscription.id,
+          willRenewValue: diff.value,
+          willRenewUnit: diff.unit,
+          required: !!diff.required,
+        },
+      },
+      delay: dayjs(subscription.current_period_end * 1000)
+        .subtract(diff.value, diff.unit)
+        .diff(this.start, 's'),
+    };
+  }
 }

package/api/src/libs/invoice.ts

@@ -1,10 +1,24 @@
+import querystring from 'querystring';
+
 import { component } from '@blocklet/sdk';
 import type { LiteralUnion } from 'type-fest';
 
-export function getCustomerInvoicePageUrl(
-  invoiceId: string,
-  locale: string = 'en',
-  action: LiteralUnion<'pay', string> = ''
-) {
-  return component.getUrl(`customer/invoice/${invoiceId}?locale=${locale}&action=${action}`);
+import { getConnectQueryParam } from './util';
+
+export function getCustomerInvoicePageUrl({
+  invoiceId,
+  userDid,
+  locale = 'en',
+  action = '',
+}: {
+  userDid: string;
+  invoiceId: string;
+  locale: LiteralUnion<'en' | 'zh', string>;
+  action?: LiteralUnion<'pay', string>;
+}) {
+  return component.getUrl(
+    `customer/invoice/${invoiceId}?locale=${locale}&action=${action}&${querystring.stringify(
+      getConnectQueryParam({ userDid })
+    )}`
+  );
 }

package/api/src/libs/notification/template/one-time-payment-succeeded.ts

@@ -0,0 +1,245 @@
+/* eslint-disable @typescript-eslint/brace-style */
+/* eslint-disable @typescript-eslint/indent */
+import { fromUnitToToken } from '@ocap/util';
+import pWaitFor from 'p-wait-for';
+
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import { CheckoutSession, Customer, NftMintItem, PaymentIntent, PaymentMethod } from '../../../store/models';
+import { PaymentCurrency } from '../../../store/models/payment-currency';
+import { getMainProductNameByCheckoutSession } from '../../product';
+import { formatTime } from '../../time';
+import { getExplorerLink } from '../../util';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+
+export interface OneTimePaymentSucceededEmailTemplateOptions {
+  checkoutSessionId: string;
+}
+
+interface OneTimePaymentSucceededEmailTemplateContext {
+  locale: string;
+  productName: string;
+  at: string;
+
+  nftMintItem: NftMintItem | undefined;
+  chainHost: string | undefined;
+  userDid: string;
+  paymentInfo: string;
+
+  viewSubscriptionLink: string;
+  viewInvoiceLink: string;
+  viewTxHashLink: string | undefined;
+}
+
+/**
+ * @see https://github.com/blocklet/payment-kit/issues/236#issue-2007698930
+ * @description
+ * @export
+ * @class OneTimePaymentSucceededEmailTemplate
+ * @implements {BaseEmailTemplate<OneTimePaymentSucceededEmailTemplateContext>}
+ */
+export class OneTimePaymentSucceededEmailTemplate
+  implements BaseEmailTemplate<OneTimePaymentSucceededEmailTemplateContext>
+{
+  options: OneTimePaymentSucceededEmailTemplateOptions;
+
+  constructor(options: OneTimePaymentSucceededEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  async getContext(): Promise<OneTimePaymentSucceededEmailTemplateContext> {
+    const cs: CheckoutSession | null = await CheckoutSession.findByPk(this.options.checkoutSessionId);
+    if (!cs) {
+      throw new Error(`CheckoutSession(${this.options.checkoutSessionId}) not found`);
+    }
+    if (cs.mode !== 'payment') {
+      throw new Error(`CheckoutSession(${this.options.checkoutSessionId}) mode must be payment`);
+    }
+
+    const customer = await Customer.findByPk(cs.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${cs.customer_id}`);
+    }
+
+    await pWaitFor(
+      async () => {
+        const checkoutSession = await CheckoutSession.findOne({
+          where: {
+            id: cs.id,
+          },
+        });
+
+        return Boolean(['disabled', 'minted', 'sent', 'error'].includes(checkoutSession?.nft_mint_status as string));
+      },
+      { timeout: 1000 * 10, interval: 1000 }
+    );
+
+    const checkoutSession = (await CheckoutSession.findByPk(cs.id)) as CheckoutSession;
+    const paymentCurrency = (await PaymentCurrency.findOne({
+      where: {
+        id: checkoutSession.currency_id,
+      },
+    })) as PaymentCurrency;
+
+    const userDid: string = customer.did;
+    const locale = await getUserLocale(userDid);
+    const productName = await getMainProductNameByCheckoutSession(checkoutSession);
+    const at: string = formatTime(checkoutSession.created_at);
+
+    const paymentInfo: string = `${fromUnitToToken(checkoutSession?.amount_total, paymentCurrency.decimal)} ${
+      paymentCurrency.symbol
+    }`;
+    const hasNft: boolean = checkoutSession?.nft_mint_status === 'minted';
+    const nftMintItem: NftMintItem | undefined = hasNft
+      ? // @ts-expect-error
+        checkoutSession?.nft_mint_details?.[paymentMethod.type]
+      : undefined;
+
+    const paymentIntent = await PaymentIntent.findByPk(checkoutSession!.payment_intent_id);
+    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(paymentIntent!.payment_method_id);
+    // @ts-expect-error
+    const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
+    const viewSubscriptionLink = '';
+    const viewInvoiceLink = '';
+
+    // @ts-expect-error
+    const txHash: string | undefined = paymentIntent?.payment_details?.[paymentMethod.type]?.tx_hash;
+    const viewTxHashLink: string | undefined = txHash && getExplorerLink(chainHost, txHash as string, 'tx');
+
+    return {
+      locale,
+      productName,
+      at,
+
+      userDid,
+      nftMintItem,
+      chainHost,
+      paymentInfo,
+
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      viewTxHashLink,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      productName,
+      at,
+      nftMintItem,
+      chainHost,
+      userDid,
+      paymentInfo,
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      viewTxHashLink,
+    } = await this.getContext();
+
+    const template: BaseEmailTemplateType = {
+      title: `${translate('notification.oneTimePaymentSucceeded.title', locale, {
+        productName: `(${productName})`,
+      })}`,
+      body: `${translate('notification.oneTimePaymentSucceeded.body', locale, {
+        at,
+        productName: `(${productName})`,
+      })}`,
+      // @ts-expect-error
+      attachments: [
+        nftMintItem &&
+          chainHost && {
+            type: 'asset',
+            data: {
+              chainHost,
+              did: nftMintItem.address,
+            },
+          },
+        {
+          type: 'section',
+          fields: [
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.account', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: userDid,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.product', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: productName,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.paymentInfo', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: paymentInfo,
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.validityPeriod', locale),
+              },
+            },
+            {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: translate('notification.common.permanent', locale),
+              },
+            },
+          ].filter(Boolean),
+        },
+      ].filter(Boolean),
+      // @ts-ignore
+      actions: [
+        viewSubscriptionLink && {
+          name: 'viewSubscription',
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+        viewInvoiceLink && {
+          name: 'viewSubscription',
+          title: translate('notification.common.viewInvoice', locale),
+          link: viewInvoiceLink,
+        },
+        viewTxHashLink && {
+          name: 'viewTxHash',
+          title: translate('notification.common.viewTxHash', locale),
+          link: viewTxHashLink as string,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}