payment-kit 1.15.2 → 1.15.4

package/api/src/crons/payment-stat.ts

@@ -66,6 +66,7 @@ export async function getPaymentStat(
       await Refund.findAll({
         where: {
           updated_at: { [Op.gte]: start.toDate(), [Op.lt]: end.toDate() },
+          type: 'refund',
           status: 'succeeded',
         },
         attributes: ['amount', 'currency_id'],

package/api/src/index.ts

@@ -10,7 +10,7 @@ import express, { ErrorRequestHandler, Request, Response } from 'express';
 import morgan from 'morgan';
 
 // eslint-disable-next-line import/no-extraneous-dependencies
-import { xss } from 'express-xss-sanitizer';
+import { xss } from '@blocklet/xss';
 
 import crons from './crons/index';
 import { ensureStakedForGas } from './integrations/arcblock/stake';
@@ -55,7 +55,7 @@ app.use((req, res, next) => {
 });
 app.use(express.urlencoded({ extended: true, limit: '1 mb' }));
 app.use(cors());
-app.use(xss());
+app.use(xss({ allowedKeys: [] }));
 app.use(ensureI18n());
 
 const router = express.Router();

package/api/src/integrations/arcblock/stake.ts

@@ -5,7 +5,7 @@ import assert from 'assert';
 import { isEthereumDid } from '@arcblock/did';
 import { toStakeAddress } from '@arcblock/did-util';
 import env from '@blocklet/sdk/lib/env';
-import { fromUnitToToken, toBN } from '@ocap/util';
+import { BN, fromUnitToToken, toBN } from '@ocap/util';
 
 import { wallet } from '../../libs/auth';
 import { events } from '../../libs/event';
@@ -189,20 +189,27 @@ export async function getStakeSummaryByDid(did: string, livemode: boolean = true
     return {};
   }
 
-  // FIXME: should use listStakes to find all stakes and summarize here
-  const address = toStakeAddress(did, wallet.address);
   const results: GroupedBN = {};
   await Promise.all(
     methods.map(async (method: PaymentMethod) => {
       const client = method.getOcapClient();
-      const { state } = await client.getStakeState({ address });
-      (state?.tokens || []).forEach((t: any) => {
-        // @ts-ignore
-        const currency = method.payment_currencies.find((c: PaymentCurrency) => t.address === c.contract);
-        if (currency) {
-          results[currency.id] = t.value;
-        }
+      const { stakes } = await client.listStakes({
+        addressFilter: {
+          receiver: wallet.address,
+        },
       });
+      (stakes || [])
+        .filter((x: any) => x.sender === did)
+        .forEach((x: any) => {
+          const { tokens } = x;
+          (tokens || []).forEach((t: any) => {
+            // @ts-ignore
+            const currency = method.payment_currencies?.find((c: PaymentCurrency) => t.address === c.contract);
+            if (currency) {
+              results[currency.id] = new BN(results[currency.id] || '0').add(new BN(t.balance || '0')).toString();
+            }
+          });
+        });
     })
   );
 

package/api/src/libs/notification/template/customer-reward-succeeded.ts

@@ -23,6 +23,7 @@ import logger from '../../logger';
 import { formatTime } from '../../time';
 import { getExplorerLink } from '../../util';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
+import { blocklet } from '../../auth';
 
 export interface CustomerRewardSucceededEmailTemplateOptions {
   checkoutSessionId: string;
@@ -109,16 +110,14 @@ export class CustomerRewardSucceededEmailTemplate
     const locale = await getUserLocale(userDid);
     const at: string = formatTime(checkoutSession.created_at);
 
-    const paymentInfo: string = `${fromUnitToToken(checkoutSession?.amount_total, paymentCurrency.decimal)} ${
-      paymentCurrency.symbol
-    }`;
+    const paymentInfo: string = `${fromUnitToToken(checkoutSession?.amount_total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
     const paymentIntent = await PaymentIntent.findByPk(checkoutSession!.payment_intent_id);
     if (!paymentIntent) {
       throw new Error(
         `Payment intent cannot be found for checkoutSession.payment_intent_id${checkoutSession!.payment_intent_id}`
       );
     }
-    const rewardDetail: string = this.getRewardDetail({
+    const rewardDetail: string = await this.getRewardDetail({
       paymentIntent,
       paymentCurrency,
       locale,
@@ -166,7 +165,7 @@ export class CustomerRewardSucceededEmailTemplate
       viewTxHashLink,
     };
   }
-  getRewardDetail({
+  async getRewardDetail({
     paymentIntent,
     paymentCurrency,
     locale,
@@ -174,16 +173,24 @@ export class CustomerRewardSucceededEmailTemplate
     paymentIntent: PaymentIntent;
     paymentCurrency: PaymentCurrency;
     locale: LiteralUnion<'zh' | 'en', string>;
-  }): string {
+  }): Promise<string> {
     if (isEmpty(paymentIntent.beneficiaries)) {
       logger.warn('Payment intent not available', { paymentIntentId: paymentIntent.id });
       return '';
     }
 
+    const promises = paymentIntent.beneficiaries!.map((x: PaymentBeneficiary) => {
+      return blocklet.getUser(x.address);
+    });
+    const users = await Promise.all(promises);
+    if (!users.length) {
+      logger.warn('No users found for payment intent', { paymentIntentId: paymentIntent.id });
+      return '';
+    }
     const rewardDetail: string = paymentIntent
-      .beneficiaries!.map((x: PaymentBeneficiary) => {
+      .beneficiaries!.map((x: PaymentBeneficiary, index: number) => {
         return translate('notification.customerRewardSucceeded.received', locale, {
-          address: `${x.address}`,
+          address: `${users[index]?.user?.fullName || ''} ( ${x.address} )`,
           amount: `${fromUnitToToken(x.share, paymentCurrency.decimal)} ${paymentCurrency.symbol}`,
         });
       })

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

@@ -5,14 +5,7 @@ import pWaitFor from 'p-wait-for';
 
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
-import {
-  CheckoutSession,
-  Customer,
-  NftMintItem,
-  PaymentIntent,
-  PaymentLink,
-  PaymentMethod,
-} from '../../../store/models';
+import { CheckoutSession, Customer, NftMintItem, PaymentIntent, PaymentMethod } from '../../../store/models';
 import { PaymentCurrency } from '../../../store/models/payment-currency';
 import { getMainProductNameByCheckoutSession } from '../../product';
 import { formatTime } from '../../time';
@@ -82,13 +75,6 @@ export class OneTimePaymentSucceededEmailTemplate
     );
 
     const checkoutSession = (await CheckoutSession.findByPk(cs.id)) as CheckoutSession;
-    const paymentLink = await PaymentLink.findByPk(checkoutSession.payment_link_id);
-    if (!paymentLink) {
-      throw new Error(`Payment link cannot be found for payment_link_id(${checkoutSession.payment_link_id})`);
-    }
-    if (paymentLink.submit_type !== 'auto') {
-      throw new Error(`Payment link submit_type(${paymentLink.submit_type}) must be auto`);
-    }
 
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
@@ -223,21 +209,6 @@ export class OneTimePaymentSucceededEmailTemplate
                 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),

package/api/src/libs/notification/template/subscription-canceled.ts

@@ -8,9 +8,8 @@ import { translate } from '../../../locales';
 import { Customer, PaymentMethod, Refund, Subscription } from '../../../store/models';
 import { Invoice } from '../../../store/models/invoice';
 import { PaymentCurrency } from '../../../store/models/payment-currency';
-import logger from '../../logger';
 import { getMainProductName } from '../../product';
-import { getCustomerSubscriptionPageUrl } from '../../subscription';
+import { getCustomerSubscriptionPageUrl, getSubscriptionStakeCancellation } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 
@@ -49,18 +48,6 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
     if (subscription.status !== 'canceled') {
       throw new Error(`Subscription(${this.options.subscriptionId}) status(${subscription.status}) must be canceled`);
     }
-    if (['payment_failed', 'payment_disputed'].includes(subscription.cancelation_details?.reason as string) === false) {
-      // 只有没钱导致订阅被取消了，或者管理员取消了，才会发送通知
-      logger.error(
-        `Subscription(${this.options.subscriptionId}) cancelation reason must be payment_disputed or payment_failed`,
-        {
-          cancelation_details: subscription.cancelation_details,
-        }
-      );
-      throw new Error(
-        `Subscription(${this.options.subscriptionId}) cancelation reason must be payment_disputed or payment_failed`
-      );
-    }
 
     const customer = await Customer.findByPk(subscription.customer_id);
     if (!customer) {
@@ -88,16 +75,51 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
         locale: getPrettyMsI18nLocale(locale),
       }
     );
-    const refund = await Refund.findOne({
-      where: {
-        subscription_id: subscription.id,
-      },
-    });
-    const cancellationReason = refund
-      ? translate('notification.subscriptionCanceled.adminCanceledAndRefunded', locale)
-      : translate('notification.subscriptionCanceled.adminCanceled', locale);
-
     const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(invoice.default_payment_method_id);
+
+    const customerCancelRequest = subscription.cancelation_details?.reason === 'cancellation_requested';
+    let cancellationReason = '';
+    const { stakeEnough, stakeReturn, stakeSlash, hasStake } = await getSubscriptionStakeCancellation(
+      subscription,
+      paymentMethod!,
+      paymentCurrency
+    );
+    if (customerCancelRequest) {
+      // cancel request from customer
+      cancellationReason = translate('notification.subscriptionCanceled.customerCanceled', locale);
+      if (stakeReturn && hasStake && stakeEnough) {
+        cancellationReason = translate('notification.subscriptionCanceled.customerCanceledAndStakeReturned', locale);
+      }
+    } else {
+      // default admin cancel
+      const refund = await Refund.findOne({
+        where: {
+          subscription_id: subscription.id,
+          type: 'refund',
+        },
+      });
+      const conditions = [
+        {
+          condition: refund && stakeSlash,
+          key: 'notification.subscriptionCanceled.adminCanceledAndRefundedAndStakeSlashed',
+        },
+        {
+          condition: refund && stakeReturn,
+          key: 'notification.subscriptionCanceled.adminCanceledAndRefundedAndStakeReturned',
+        },
+        { condition: refund, key: 'notification.subscriptionCanceled.adminCanceledAndRefunded' },
+        { condition: stakeReturn, key: 'notification.subscriptionCanceled.adminCanceledAndStakeReturned' },
+      ];
+      const matchedCondition = conditions.find((item) => item.condition);
+      if (matchedCondition) {
+        cancellationReason = translate(matchedCondition.key, locale);
+      }
+    }
+
+    if (subscription.cancelation_details?.reason === 'payment_failed') {
+      cancellationReason = translate('notification.subscriptionCanceled.paymentFailed', locale);
+    }
+
     // @ts-expect-error
     const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
     const viewSubscriptionLink = getCustomerSubscriptionPageUrl({

package/api/src/libs/notification/template/subscription-refund-succeeded.ts

@@ -8,7 +8,6 @@ import { translate } from '../../../locales';
 import { Customer, PaymentIntent, PaymentMethod, Refund } from '../../../store/models';
 import { Invoice } from '../../../store/models/invoice';
 import { PaymentCurrency } from '../../../store/models/payment-currency';
-import { getCustomerInvoicePageUrl } from '../../invoice';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
 import { formatTime, getPrettyMsI18nLocale } from '../../time';
@@ -28,16 +27,16 @@ interface SubscriptionRefundSucceededEmailTemplateContext {
   userDid: string;
   paymentInfo: string;
   refundInfo: string;
-  currentPeriodStart: string;
-  currentPeriodEnd: string;
+  currentPeriodStart?: string;
+  currentPeriodEnd?: string;
   duration: string;
-  unusedPeriodStart: string;
-  unusedPeriodEnd: string;
+  unusedPeriodStart?: string;
+  unusedPeriodEnd?: string;
   unusedDuration: string;
 
   viewSubscriptionLink: string;
-  viewInvoiceLink: string;
   viewTxHashLink: string | undefined;
+  refund: Refund;
 }
 
 export class SubscriptionRefundSucceededEmailTemplate
@@ -63,7 +62,6 @@ export class SubscriptionRefundSucceededEmailTemplate
       throw new Error(`Customer not found: ${refund.customer_id}`);
     }
 
-    const invoice = (await Invoice.findByPk(refund.invoice_id)) as Invoice;
     const paymentIntent = await PaymentIntent.findByPk(refund.payment_intent_id);
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
@@ -76,42 +74,43 @@ export class SubscriptionRefundSucceededEmailTemplate
     const productName = await getMainProductName(refund.subscription_id!);
     const at: string = formatTime(refund.created_at);
 
-    const paymentInfo: string = `${fromUnitToToken(paymentIntent?.amount_received || '0', paymentCurrency.decimal)} ${
-      paymentCurrency.symbol
-    }`;
+    const paymentInfo: string = `${fromUnitToToken(paymentIntent?.amount_received || '0', paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
     const refundInfo: string = `${fromUnitToToken(refund.amount, 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(),
-      {
+    let invoice = null;
+    let currentPeriodStart;
+    let currentPeriodEnd;
+    let duration;
+    let unusedPeriodStart;
+    let unusedPeriodEnd;
+    let unusedDuration;
+    if (refund.type === 'refund') {
+      invoice = (await Invoice.findByPk(refund.invoice_id)) as Invoice;
+      currentPeriodStart = formatTime(invoice.period_start * 1000);
+      currentPeriodEnd = formatTime(invoice.period_end * 1000);
+      duration = prettyMsI18n(new Date(currentPeriodEnd).getTime() - new Date(currentPeriodStart).getTime(), {
         locale: getPrettyMsI18nLocale(locale),
-      }
-    );
+      });
 
-    const unusedPeriodStart: string = formatTime(refund!.metadata!.unused_period_start! * 1000);
-    const unusedPeriodEnd: string = formatTime(refund!.metadata!.unused_period_end! * 1000);
-    const unusedDuration: string = prettyMsI18n(
-      new Date(unusedPeriodEnd).getTime() - new Date(unusedPeriodStart).getTime(),
-      {
-        locale: getPrettyMsI18nLocale(locale),
+      if (refund?.metadata?.unused_period_start && refund?.metadata?.unused_period_end) {
+        unusedPeriodStart = formatTime(refund!.metadata!.unused_period_start! * 1000);
+        unusedPeriodEnd = formatTime(refund!.metadata!.unused_period_end! * 1000);
+        unusedDuration = prettyMsI18n(new Date(unusedPeriodEnd).getTime() - new Date(unusedPeriodStart).getTime(), {
+          locale: getPrettyMsI18nLocale(locale),
+        });
       }
-    );
+    }
 
-    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(invoice.default_payment_method_id);
+    const paymentMethod: PaymentMethod | null = await PaymentMethod.findByPk(
+      refund.payment_method_id || invoice?.default_payment_method_id
+    );
     // @ts-expect-error
     const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
     const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
-      subscriptionId: refund.id,
+      subscriptionId: refund.subscription_id!,
       locale,
       userDid,
     });
-    const viewInvoiceLink = getCustomerInvoicePageUrl({
-      invoiceId: invoice.id,
-      userDid,
-      locale,
-    });
 
     // @ts-expect-error
     const txHash: string | undefined = refund?.payment_details?.[paymentMethod.type]?.tx_hash;
@@ -140,8 +139,8 @@ export class SubscriptionRefundSucceededEmailTemplate
       unusedDuration,
 
       viewSubscriptionLink,
-      viewInvoiceLink,
       viewTxHashLink,
+      refund,
     };
   }
 
@@ -163,8 +162,87 @@ export class SubscriptionRefundSucceededEmailTemplate
 
       viewSubscriptionLink,
       viewTxHashLink,
+      refund,
     } = await this.getContext();
 
+    if (refund.type === 'stake_return') {
+      return {
+        title: `${translate('notification.subscriptionStakeReturnSucceeded.title', locale, {
+          productName,
+        })}`,
+        body: `${translate('notification.subscriptionStakeReturnSucceeded.body', locale, {
+          at,
+          productName,
+          refundInfo,
+        })}`,
+        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.returnAmount', locale),
+                },
+              },
+              {
+                type: 'text',
+                data: {
+                  type: 'plain',
+                  text: refundInfo,
+                },
+              },
+            ],
+          },
+        ],
+        // @ts-ignore
+        actions: [
+          {
+            name: translate('notification.common.viewSubscription', locale),
+            title: translate('notification.common.viewSubscription', locale),
+            link: viewSubscriptionLink,
+          },
+          viewTxHashLink && {
+            name: translate('notification.common.viewTxHash', locale),
+            title: translate('notification.common.viewTxHash', locale),
+            link: viewTxHashLink as string,
+          },
+        ].filter(Boolean),
+      };
+    }
+
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionRefundSucceeded.title', locale, {
         productName,
@@ -254,21 +332,26 @@ export class SubscriptionRefundSucceededEmailTemplate
                 text: `${currentPeriodStart} ~ ${currentPeriodEnd}(${duration})`,
               },
             },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                color: '#9397A1',
-                text: translate('notification.common.refundPeriod', locale),
-              },
-            },
-            {
-              type: 'text',
-              data: {
-                type: 'plain',
-                text: `${unusedPeriodStart} ~ ${unusedPeriodEnd}(${unusedDuration})`,
-              },
-            },
+
+            ...(unusedPeriodStart && unusedPeriodEnd && unusedDuration
+              ? [
+                  {
+                    type: 'text',
+                    data: {
+                      type: 'plain',
+                      color: '#9397A1',
+                      text: translate('notification.common.refundPeriod', locale),
+                    },
+                  },
+                  {
+                    type: 'text',
+                    data: {
+                      type: 'plain',
+                      text: `${unusedPeriodStart} ~ ${unusedPeriodEnd}(${unusedDuration})`,
+                    },
+                  },
+                ]
+              : []),
           ].filter(Boolean),
         },
       ].filter(Boolean),

package/api/src/libs/notification/template/subscription-renewed.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/indent */
 import { fromUnitToToken, toDid } from '@ocap/util';
 import prettyMsI18n from 'pretty-ms-i18n';
-
+import logger from '@api/libs/logger';
 import { getUserLocale } from '../../../integrations/blocklet/notification';
 import { translate } from '../../../locales';
 import {
@@ -48,6 +48,7 @@ interface SubscriptionRenewedEmailTemplateContext {
   viewSubscriptionLink: string;
   viewInvoiceLink: string;
   viewTxHashLink: string | undefined;
+  invoice: Invoice;
 }
 
 export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<SubscriptionRenewedEmailTemplateContext> {
@@ -76,6 +77,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
         ? await Invoice.findByPk(this.options.invoiceId)
         : await Invoice.findByPk(subscription.latest_invoice_id)
     ) as Invoice;
+
     const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
     const paymentCurrency = (await PaymentCurrency.findOne({
       where: {
@@ -148,10 +150,11 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
       viewSubscriptionLink,
       viewInvoiceLink,
       viewTxHashLink,
+      invoice,
     };
   }
 
-  async getTemplate(): Promise<BaseEmailTemplateType> {
+  async getTemplate(): Promise<BaseEmailTemplateType | null> {
     const {
       locale,
       productName,
@@ -166,8 +169,13 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
       viewSubscriptionLink,
       viewInvoiceLink,
       viewTxHashLink,
+      invoice,
     } = await this.getContext();
 
+    if (invoice.total === '0') {
+      logger.info('Invoice amount is 0, skipping renewed notification');
+      return null;
+    }
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionRenewed.title', locale, {
         productName,