payment-kit 1.13.65 → 1.13.67

package/api/src/index.ts

@@ -1,5 +1,7 @@
 import 'express-async-errors';
 
+import './schedule';
+
 import path from 'path';
 
 import fallback from '@blocklet/sdk/lib/middlewares/fallback';
@@ -14,6 +16,7 @@ import { ensureWebhookRegistered } from './integrations/stripe/setup';
 import { startCheckoutSessionQueue } from './jobs/checkout-session';
 import { startEventQueue } from './jobs/event';
 import { startInvoiceQueue } from './jobs/invoice';
+import { startNotificationQueue } from './jobs/notification';
 import { startPaymentQueue } from './jobs/payment';
 import { startSubscriptionQueue } from './jobs/subscription';
 import { handlers } from './libs/auth';
@@ -101,6 +104,7 @@ export const server = app.listen(port, (err?: any) => {
   startSubscriptionQueue().then(() => logger.info('subscription queue started'));
   startEventQueue().then(() => logger.info('event queue started'));
   startCheckoutSessionQueue().then(() => logger.info('checkoutSession queue started'));
+  startNotificationQueue().then(() => logger.info('notification queue started'));
 
   if (process.env.BLOCKLET_MODE === 'production') {
     ensureWebhookRegistered().catch(console.error);

package/api/src/integrations/blocklet/notification.ts

@@ -1,14 +1,16 @@
 import Notification from '@blocklet/sdk/service/notification';
 import { toDid } from '@ocap/util';
+import { get } from 'lodash';
+import type { LiteralUnion } from 'type-fest';
 
 import { blocklet } from '../../libs/auth';
 import logger from '../../libs/logger';
 import { translate } from '../../locales';
 
-export async function getUserLocale(userDid: string) {
+export const getUserLocale = async (userDid: string): Promise<LiteralUnion<'zh' | 'en', string>> => {
   const { user } = await blocklet.getUser(userDid);
-  return user?.locale || 'en';
-}
+  return get(user, 'locale', 'en');
+};
 
 export function createInfoRows(info: any = {}) {
   const fields = Object.keys(info).reduce((list, cur) => {

package/api/src/jobs/notification.ts

@@ -0,0 +1,142 @@
+import { events } from '../libs/event';
+import logger from '../libs/logger';
+import { Notification } from '../libs/notification';
+import type { BaseEmailTemplate } from '../libs/notification/template/base';
+import {
+  SubscriptionRenewFailedEmailTemplate,
+  SubscriptionRenewFailedEmailTemplateOptions,
+} from '../libs/notification/template/subscription-renew-failed';
+import {
+  SubscriptionRenewedEmailTemplate,
+  SubscriptionRenewedEmailTemplateOptions,
+} from '../libs/notification/template/subscription-renewed';
+import {
+  SubscriptionSucceededEmailTemplate,
+  SubscriptionSucceededEmailTemplateOptions,
+} from '../libs/notification/template/subscription-succeeded';
+import {
+  SubscriptionTrailStartEmailTemplate,
+  SubscriptionTrailStartEmailTemplateOptions,
+} from '../libs/notification/template/subscription-trial-start';
+import {
+  SubscriptionTrailWilEndEmailTemplate,
+  SubscriptionTrialWillEndEmailTemplateOptions,
+} from '../libs/notification/template/subscription-trial-will-end';
+import {
+  SubscriptionWillRenewEmailTemplate,
+  SubscriptionWillRenewEmailTemplateOptions,
+} from '../libs/notification/template/subscription-will-renew';
+import type { SufficientForPaymentResult } from '../libs/payment';
+import createQueue from '../libs/queue';
+import type { EventType, Invoice, Subscription } from '../store/models';
+
+export type NotificationQueueJobOptions = any;
+export type NotificationQueueJob = {
+  type: EventType | 'customer.subscription.will_renew' | 'customer.subscription.trial_will_end';
+  options: NotificationQueueJobOptions;
+};
+
+function getNotificationTemplate(job: NotificationQueueJob): BaseEmailTemplate {
+  if (job.type === 'customer.subscription.started') {
+    return new SubscriptionSucceededEmailTemplate(job.options as SubscriptionSucceededEmailTemplateOptions);
+  }
+  if (job.type === 'customer.subscription.renewed') {
+    return new SubscriptionRenewedEmailTemplate(job.options as SubscriptionRenewedEmailTemplateOptions);
+  }
+  if (job.type === 'customer.subscription.renew_failed') {
+    return new SubscriptionRenewFailedEmailTemplate(job.options as SubscriptionRenewFailedEmailTemplateOptions);
+  }
+  if (job.type === 'customer.subscription.trial_start') {
+    return new SubscriptionTrailStartEmailTemplate(job.options as SubscriptionTrailStartEmailTemplateOptions);
+  }
+  if (job.type === 'customer.subscription.will_renew') {
+    return new SubscriptionWillRenewEmailTemplate(job.options as SubscriptionWillRenewEmailTemplateOptions);
+  }
+  if (job.type === 'customer.subscription.trial_will_end') {
+    return new SubscriptionTrailWilEndEmailTemplate(job.options as SubscriptionTrialWillEndEmailTemplateOptions);
+  }
+
+  throw new Error(`Unknown job type: ${job.type}`);
+}
+
+async function handleNotificationJob(job: NotificationQueueJob): Promise<void> {
+  try {
+    const template = getNotificationTemplate(job);
+    await new Notification(template).send();
+  } catch (error) {
+    logger.error('handleNotificationJob.error.$job', job);
+    logger.error('handleNotificationJob.error', error);
+    throw error;
+  }
+}
+
+export const notificationQueue = createQueue<NotificationQueueJob>({
+  name: 'notification',
+  onJob: handleNotificationJob,
+  options: {
+    concurrency: 10,
+    maxRetries: 3,
+    enableScheduledJob: true,
+  },
+});
+
+/**
+ *
+ * @see https://team.arcblock.io/comment/discussions/0fba06ff-75b4-47d2-8c5c-f0379540ce03
+ * @description
+ * @export
+ */
+// eslint-disable-next-line require-await
+export async function startNotificationQueue() {
+  events.on('customer.subscription.trial_start', (subscription: Subscription) => {
+    notificationQueue.push({
+      job: {
+        type: 'customer.subscription.trial_start',
+        options: {
+          subscriptionId: subscription.id,
+        },
+      },
+    });
+  });
+
+  events.on('customer.subscription.started', (subscription: Subscription) => {
+    if (!subscription.trail_start) {
+      // 没有试用期的 subscription 通知
+      notificationQueue.push({
+        job: {
+          type: 'customer.subscription.started',
+          options: {
+            subscriptionId: subscription.id,
+          },
+        },
+      });
+    }
+  });
+
+  events.on('customer.subscription.renewed', (subscription: Subscription, invoice: Invoice) => {
+    notificationQueue.push({
+      job: {
+        type: 'customer.subscription.renewed',
+        options: {
+          subscriptionId: subscription.id,
+          invoiceId: invoice?.id,
+        } as SubscriptionRenewedEmailTemplateOptions,
+      },
+    });
+  });
+
+  events.on(
+    'customer.subscription.renew_failed',
+    ({ invoice, result }: { invoice: Invoice; result: SufficientForPaymentResult }) => {
+      notificationQueue.push({
+        job: {
+          type: 'customer.subscription.renew_failed',
+          options: {
+            invoice,
+            result,
+          },
+        },
+      });
+    }
+  );
+}

package/api/src/jobs/payment.ts

@@ -65,6 +65,16 @@ export const handlePaymentSucceed = async (paymentIntent: PaymentIntent) => {
         logger.info(`Subscription ${subscription.id} moved to active after payment done ${paymentIntent.id}`);
       }
     }
+
+    const count: number = await Invoice.count({
+      where: {
+        subscription_id: invoice.subscription_id,
+        status: 'paid',
+      },
+    });
+    if (count >= 2) {
+      events.emit('customer.subscription.renewed', subscription, invoice);
+    }
   }
 
   if (invoice.checkout_session_id) {
@@ -136,6 +146,10 @@ export const handlePayment = async (job: PaymentJob) => {
     });
     if (result.sufficient === false) {
       logger.error('PaymentIntent capture aborted on preCheck', { id: paymentIntent.id, result });
+      events.emit('customer.subscription.renew_failed', {
+        invoice,
+        result,
+      });
       // FIXME: send email to customer, pause subscription
       throw new CustomError(result.reason, 'payer balance or delegation not sufficient for this payment');
     }

package/api/src/jobs/subscription.ts

@@ -174,8 +174,8 @@ export const handleSubscription = async (job: SubscriptionJob) => {
     number: await customer.getInvoiceNumber(),
     description: 'Subscription cycle',
     statement_descriptor: getStatementDescriptor(expandedItems),
-    period_start: subscription.current_period_start,
-    period_end: subscription.current_period_end,
+    period_start: setup.period.start,
+    period_end: setup.period.end,
 
     auto_advance: true,
     paid: false,

package/api/src/libs/audit.ts

@@ -1,11 +1,13 @@
 import pick from 'lodash/pick';
+import type { LiteralUnion } from 'type-fest';
 
+import type { EventType } from '../store/models';
 import { Event } from '../store/models/event';
 import { events } from './event';
 
 const API_VERSION = '2023-09-05';
 
-export async function createEvent(scope: string, type: string, model: any, options: any) {
+export async function createEvent(scope: string, type: LiteralUnion<EventType, string>, model: any, options: any) {
   // console.log('createEvent', scope, type, model, options);
   const data: any = {
     object: model.dataValues,

package/api/src/libs/env.ts

@@ -1,5 +1,8 @@
 import env from '@blocklet/sdk/lib/env';
 
+export const notificationCronTime: string = process.env.NOTIFICATION_CRON_TIME || '0 5 */6 * * *'; // 默认每6个小时执行一次
+export const notificationCronConcurrency: number = Number(process.env.NOTIFICATION_CRON_CONCURRENCY) || 8; // 默认并发数为 8
+
 export default {
   ...env,
 };

package/api/src/libs/event.ts

@@ -1,3 +1,12 @@
 import EventEmitter from 'events';
 
-export const events = new EventEmitter();
+import type { LiteralUnion } from 'type-fest';
+
+import type { EventType } from '../store/models';
+
+interface MyEventType extends EventEmitter {
+  on(eventName: LiteralUnion<EventType, string | symbol>, listener: (...args: any[]) => void): this;
+  emit(eventName: LiteralUnion<EventType, string | symbol>, ...args: any[]): boolean;
+}
+
+export const events = new EventEmitter() as MyEventType;

package/api/src/libs/invoice.ts

@@ -0,0 +1,5 @@
+import { component } from '@blocklet/sdk';
+
+export function getCustomerInvoicePageUrl(invoiceId: string, locale: string = 'en') {
+  return component.getUrl(`customer/invoice/${invoiceId}?locale=${locale}`);
+}

package/api/src/libs/notification/index.ts

@@ -0,0 +1,23 @@
+import { Notification as BlockletNotification } from '@blocklet/sdk';
+
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './template/base';
+
+export class Notification {
+  template: BaseEmailTemplate;
+
+  constructor(template: BaseEmailTemplate) {
+    this.template = template;
+  }
+
+  async send() {
+    const template: BaseEmailTemplateType | null = await this.template.getTemplate();
+
+    if (!template) {
+      return;
+    }
+
+    const { userDid } = await this.template.getContext();
+
+    await BlockletNotification.sendToUser(userDid, template as any);
+  }
+}

package/api/src/libs/notification/template/base.ts

@@ -0,0 +1,12 @@
+import type { TNotification, TNotificationInput } from '@blocklet/sdk/lib/types/notification';
+
+export type BaseEmailTemplateType = TNotificationInput | TNotification;
+export type BaseEmailTemplateContext = {
+  userDid: string;
+};
+
+export interface BaseEmailTemplate<C = BaseEmailTemplateContext> {
+  getTemplate(): Promise<BaseEmailTemplateType | null>;
+
+  getContext(): Promise<C>;
+}

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

@@ -0,0 +1,286 @@
+/* eslint-disable @typescript-eslint/brace-style */
+/* eslint-disable @typescript-eslint/indent */
+import { fromUnitToToken, toDid } from '@ocap/util';
+import prettyMsI18n from 'pretty-ms-i18n';
+
+import { getUserLocale } from '../../../integrations/blocklet/notification';
+import { translate } from '../../../locales';
+import {
+  CheckoutSession,
+  Customer,
+  Invoice,
+  NftMintItem,
+  PaymentIntent,
+  PaymentMethod,
+  Subscription,
+} from '../../../store/models';
+import { PaymentCurrency } from '../../../store/models/payment-currency';
+import { getCustomerInvoicePageUrl } from '../../invoice';
+import { SufficientForPaymentResult, getPaymentDetail } from '../../payment';
+import { getMainProductName } from '../../product';
+import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { formatTime, getPrettyMsI18nLocale } from '../../time';
+import { getExplorerLink } from '../../util';
+import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+
+export interface SubscriptionRenewFailedEmailTemplateOptions {
+  invoice: Invoice;
+  result: SufficientForPaymentResult;
+}
+
+interface SubscriptionRenewFailedEmailTemplateContext {
+  locale: string;
+  productName: string;
+  at: string;
+  reason: string;
+
+  nftMintItem: NftMintItem | undefined;
+  userDid: string;
+  paymentInfo: string;
+  currentPeriodStart: string;
+  currentPeriodEnd: string;
+  duration: string;
+
+  viewSubscriptionLink: string;
+  viewInvoiceLink: string;
+  viewTxHashLink: string | undefined;
+}
+
+export class SubscriptionRenewFailedEmailTemplate
+  implements BaseEmailTemplate<SubscriptionRenewFailedEmailTemplateContext>
+{
+  options: SubscriptionRenewFailedEmailTemplateOptions;
+
+  constructor(options: SubscriptionRenewFailedEmailTemplateOptions) {
+    this.options = options;
+  }
+
+  private async getReason(userDid: string, invoice: Invoice, locale: string): Promise<string> {
+    if (this.options.result.sufficient) {
+      throw new Error(`SufficientForPaymentResult.sufficient should be false: ${JSON.stringify(this.options.result)}`);
+    }
+
+    // 类似 NO_DID_WALLET 字符串将转成 noDidWallet
+    const toCamelCase = (input: string): string => {
+      return input.toLowerCase().replace(/_([a-z])/g, (_match, group1) => {
+        return group1.toUpperCase();
+      });
+    };
+
+    const i18nText = `notification.subscriptionRenewFailed.reason.${toCamelCase(this.options.result.reason as string)}`;
+
+    const paymentDetail = await getPaymentDetail(userDid, invoice);
+    const reason = translate(i18nText, locale, {
+      balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
+      price: `${paymentDetail.price} ${paymentDetail.symbol}`,
+    });
+
+    return reason;
+  }
+
+  async getContext(): Promise<SubscriptionRenewFailedEmailTemplateContext> {
+    const subscription: Subscription | null = await Subscription.findByPk(this.options.invoice.subscription_id);
+    if (!subscription) {
+      throw new Error(`Subscription not found: ${this.options.invoice.subscription_id}`);
+    }
+
+    const customer = await Customer.findByPk(subscription.customer_id);
+    if (!customer) {
+      throw new Error(`Customer not found: ${subscription.customer_id}`);
+    }
+
+    const { invoice } = this.options;
+    const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
+    const paymentCurrency = (await PaymentCurrency.findOne({
+      where: {
+        id: subscription.currency_id,
+      },
+    })) as PaymentCurrency;
+
+    const checkoutSession = await CheckoutSession.findOne({
+      where: {
+        subscription_id: subscription.id,
+      },
+    });
+
+    const locale = await getUserLocale(customer.did);
+    const productName = await getMainProductName(subscription.id);
+    const at: string = formatTime(Date.now());
+    const reason: string = await this.getReason(customer.did, invoice, locale);
+
+    const hasNft: boolean = checkoutSession?.nft_mint_status === 'minted';
+    const nftMintItem: NftMintItem | undefined = hasNft
+      ? checkoutSession?.nft_mint_details?.[checkoutSession?.nft_mint_details?.type as 'arcblock' | 'ethereum']
+      : undefined;
+    const paymentInfo: string = `${fromUnitToToken(invoice.amount_remaining, paymentCurrency.decimal)} ${
+      paymentCurrency.symbol
+    }`;
+    const currentPeriodStart: string = formatTime(invoice.period_start * 1000);
+    const currentPeriodEnd: string = formatTime(invoice.period_end * 1000);
+    const duration: string = prettyMsI18n(
+      new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(),
+      {
+        locale: getPrettyMsI18nLocale(locale),
+      }
+    );
+
+    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(invoice.default_payment_method_id);
+    const chainHost: string | undefined =
+      paymentMethod?.settings?.[checkoutSession?.nft_mint_details?.type as 'arcblock' | 'ethereum']?.api_host;
+    const viewSubscriptionLink = getCustomerSubscriptionPageUrl(subscription.id, locale);
+    const viewInvoiceLink = getCustomerInvoicePageUrl(invoice.id, locale);
+    const txHash: string | undefined =
+      paymentIntent?.payment_details?.[checkoutSession?.nft_mint_details?.type as 'arcblock' | 'ethereum']?.tx_hash;
+    const viewTxHashLink: string | undefined = hasNft && txHash ? getExplorerLink(chainHost, txHash, 'tx') : undefined;
+
+    return {
+      locale,
+      productName,
+      at,
+      reason,
+
+      nftMintItem,
+      userDid: customer.did,
+      paymentInfo,
+      currentPeriodStart,
+      currentPeriodEnd,
+      duration,
+
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      viewTxHashLink,
+    };
+  }
+
+  async getTemplate(): Promise<BaseEmailTemplateType> {
+    const {
+      locale,
+      productName,
+      at,
+      nftMintItem,
+      userDid,
+      paymentInfo,
+      currentPeriodStart,
+      currentPeriodEnd,
+      duration,
+      reason,
+      viewSubscriptionLink,
+      viewInvoiceLink,
+      viewTxHashLink,
+    } = await this.getContext();
+
+    const template: BaseEmailTemplateType = {
+      title: `${translate('notification.subscriptionRenewFailed.title', locale, {
+        productName: `(${productName})`,
+      })}`,
+      body: `${translate('notification.subscriptionRenewFailed.body', locale, {
+        at,
+        productName: `(${productName})`,
+        reason: `${reason}`,
+      })}`,
+      // @ts-expect-error
+      attachments: [
+        {
+          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: `${currentPeriodStart} ~ ${currentPeriodEnd}(${duration})`,
+              },
+            },
+            nftMintItem && {
+              type: 'text',
+              data: {
+                type: 'plain',
+                color: '#9397A1',
+                text: translate('notification.common.nftAddress', locale),
+              },
+            },
+            nftMintItem && {
+              type: 'text',
+              data: {
+                type: 'plain',
+                text: toDid(nftMintItem.address),
+              },
+            },
+          ].filter(Boolean),
+        },
+      ].filter(Boolean),
+      // @ts-ignore
+      actions: [
+        {
+          name: 'viewSubscription',
+          title: translate('notification.common.viewSubscription', locale),
+          link: viewSubscriptionLink,
+        },
+        {
+          name: 'viewSubscription',
+          title: translate('notification.subscriptionRenewFailed.renewNow', locale),
+          link: viewInvoiceLink,
+        },
+        viewTxHashLink && {
+          name: 'viewTxHash',
+          title: translate('notification.common.viewTxHash', locale),
+          link: viewTxHashLink as string,
+        },
+      ].filter(Boolean),
+    };
+
+    return template;
+  }
+}