payment-kit 1.15.20 → 1.15.21

package/api/src/crons/base.ts

@@ -34,13 +34,19 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
     const subscriptions = await this.getSubscriptions();
     logger.info(`${name}.run.${subscriptions.length}`, subscriptions.length);
 
-    const subscriptionForWillRenew = this.getSubscriptionsForWillRenew(subscriptions);
+    const scheduleSubscriptions = this.getScheduleSubscriptions(subscriptions);
 
-    await this.addTaskToQueue(subscriptionForWillRenew);
+    await this.addTaskToQueue(scheduleSubscriptions);
 
     logger.info(`${name}.run end`);
   }
 
+  async reScheduleSubscriptionTasks(subscriptions: Subscription[]): Promise<void> {
+    await this.deleteScheduleSubscriptionJobs(subscriptions);
+    const scheduleSubscriptions = this.getScheduleSubscriptions(subscriptions);
+    await this.addTaskToQueue(scheduleSubscriptions);
+  }
+
   static readonly DIFFS: Diff[] = [
     {
       value: 1,
@@ -67,6 +73,8 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
       unit: 'm',
     },
   ];
+
+  abstract getEndTime(subscription: Subscription): number;
   /**
    * @see https://github.com/blocklet/payment-kit/issues/236#issuecomment-1824129965
    * @description
@@ -74,13 +82,13 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
    * @return {*}  {SubscriptionForWillRenew[]}
    * @memberof SubscriptionWillRenewSchedule
    */
-  getSubscriptionsForWillRenew(subscriptions: Subscription[]): BaseSubscriptionScheduleNotificationSubscription[] {
+  getScheduleSubscriptions(subscriptions: Subscription[]): BaseSubscriptionScheduleNotificationSubscription[] {
     return subscriptions.map((subscription: Subscription): BaseSubscriptionScheduleNotificationSubscription => {
       const s: BaseSubscriptionScheduleNotificationSubscription = clone(
         subscription
       ) as BaseSubscriptionScheduleNotificationSubscription;
       const currentPeriodStart: number = s.current_period_start * 1000;
-      const currentPeriodEnd: number = s.current_period_end * 1000;
+      const currentPeriodEnd: number = this.getEndTime(s);
 
       if (
         dayjs(currentPeriodEnd).diff(this.start, 'M') >= 1 &&
@@ -151,13 +159,26 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
 
   async addTaskToQueue(subscriptions: BaseSubscriptionScheduleNotificationSubscription[]): Promise<void> {
     const tasks: Task<Options>[] = [];
+    const deleteTasks = [];
     for (const subscription of subscriptions) {
       for (const diff of subscription.diffs) {
-        const task: Task<Options> = this.getTask({ subscription, diff });
-        tasks.push(task);
+        try {
+          const task: Task<Options> = this.getTask({ subscription, diff });
+          tasks.push(task);
+        } catch (error) {
+          logger.error('getTask error', { error, subscriptionId: subscription.id, diff });
+          deleteTasks.push(() => this.deleteScheduleSubscriptionJobs([subscription]));
+        }
       }
     }
 
+    await pAll(
+      deleteTasks.map((task) => () => task()),
+      {
+        concurrency: notificationCronConcurrency,
+        stopOnError: false,
+      }
+    );
     await pAll(
       tasks.map((x) => {
         return async () => {
@@ -170,7 +191,48 @@ export abstract class BaseSubscriptionScheduleNotification<Options extends any>
           notificationQueue.push(x);
         };
       }),
-      { concurrency: notificationCronConcurrency }
+      {
+        concurrency: notificationCronConcurrency,
+        stopOnError: false,
+      }
     );
   }
+
+  async deleteScheduleSubscriptionJobs(subscriptions: Subscription[]): Promise<void> {
+    const jobsToDelete = await Promise.all(
+      subscriptions.flatMap((subscription) =>
+        BaseSubscriptionScheduleNotification.DIFFS.map(async (diff) => {
+          const jobId = `${subscription.id}.${this.eventType}.${diff.value}.${diff.unit}`;
+          const job = await notificationQueue.get(jobId);
+          return job ? { jobId, subscriptionId: subscription.id } : null;
+        })
+      )
+    );
+
+    const existingJobs = jobsToDelete.filter((x): x is { jobId: string; subscriptionId: string } => x !== null);
+
+    const deletePromises = existingJobs.map(
+      ({ jobId, subscriptionId }: { jobId: string; subscriptionId: string }) =>
+        async () => {
+          try {
+            const deleted = await notificationQueue.delete(jobId);
+            if (deleted) {
+              logger.info('Deleted subscription job', { jobId, subscriptionId, eventType: this.eventType });
+            }
+          } catch (error) {
+            logger.error('Failed to delete subscription job', {
+              jobId,
+              subscriptionId,
+              eventType: this.eventType,
+              error: error instanceof Error ? error.message : String(error),
+            });
+          }
+        }
+    );
+
+    await pAll(deletePromises, {
+      concurrency: notificationCronConcurrency,
+      stopOnError: false,
+    });
+  }
 }

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

@@ -17,7 +17,7 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
         current_period_start: {
           [Op.lte]: this.start / 1000,
         },
-        current_period_end: {
+        trial_end: {
           [Op.lt]: this.end / 1000,
         },
         trial_start: {
@@ -25,7 +25,7 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
         },
         status: 'trialing',
       },
-      attributes: ['id', 'current_period_start', 'current_period_end'],
+      attributes: ['id', 'current_period_start', 'current_period_end', 'trial_end'],
       raw: true,
     });
 
@@ -40,6 +40,19 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
     diff: Diff;
   }): Task<SubscriptionTrialWillEndEmailTemplateOptions> {
     const type = this.eventType;
+    if (subscription.status !== 'trialing') {
+      throw new Error(`Subscription(${subscription.id}) is not trialing, no need to send notification`);
+    }
+
+    const trialEnd = this.getEndTime(subscription);
+    if (!subscription.trial_end) {
+      throw new Error(`Subscription(${subscription.id}) has no trial_end, no need to send notification`);
+    }
+
+    if (trialEnd <= this.start) {
+      throw new Error(`Subscription(${subscription.id}) is already expired, no need to send notification`);
+    }
+
     return {
       id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
       job: {
@@ -51,9 +64,11 @@ export class SubscriptionTrialWillEndSchedule extends BaseSubscriptionScheduleNo
           required: !!diff.required,
         },
       },
-      delay: dayjs(subscription.current_period_end * 1000)
-        .subtract(diff.value, diff.unit)
-        .diff(this.start, 's'),
+      delay: dayjs(trialEnd).subtract(diff.value, diff.unit).diff(this.start, 's'),
     };
   }
+
+  override getEndTime(subscription: Subscription): number {
+    return subscription.trial_end! * 1000;
+  }
 }

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

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 import dayjs from 'dayjs';
 
+import { Op } from 'sequelize';
 import type { SubscriptionWillCanceledEmailTemplateOptions } from '../libs/notification/template/subscription-will-canceled';
 import { Subscription } from '../store/models';
 import { BaseSubscriptionScheduleNotification, BaseSubscriptionScheduleNotificationEventType } from './base';
@@ -12,14 +13,20 @@ export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNo
   async getSubscriptions(): Promise<Subscription[]> {
     const subscriptions = await Subscription.findAll({
       where: {
-        status: 'past_due',
+        status: ['active', 'past_due'],
+        [Op.or]: [
+          { cancel_at: { [Op.gt]: this.start } },
+          { cancel_at_period_end: true, current_period_end: { [Op.gt]: this.start } },
+        ],
       },
-      attributes: ['id', 'current_period_start', 'current_period_end'],
+      attributes: ['id', 'current_period_start', 'current_period_end', 'cancel_at', 'status'],
       raw: true,
     });
 
     subscriptions.forEach((subscription) => {
-      subscription.current_period_end = subscription.cancel_at!;
+      if (subscription.cancel_at) {
+        subscription.current_period_end = subscription.cancel_at;
+      }
     });
 
     return subscriptions;
@@ -33,6 +40,13 @@ export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNo
     diff: Diff;
   }): Task<SubscriptionWillCanceledEmailTemplateOptions> {
     const type = this.eventType;
+    const cancelAt = this.getEndTime(subscription);
+    if (!cancelAt) {
+      throw new Error(`Subscription(${subscription.id}) has no cancel_at, no need to send notification`);
+    }
+    if (cancelAt <= this.start) {
+      throw new Error(`Subscription(${subscription.id}) is already canceled, no need to send notification`);
+    }
     return {
       id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
       job: {
@@ -44,9 +58,11 @@ export class SubscriptionWillCanceledSchedule extends BaseSubscriptionScheduleNo
           required: true,
         },
       },
-      delay: dayjs(subscription.current_period_end * 1000)
-        .subtract(diff.value, diff.unit)
-        .diff(this.start, 's'),
+      delay: dayjs(cancelAt).subtract(diff.value, diff.unit).diff(this.start, 's'),
     };
   }
+
+  override getEndTime(subscription: Subscription): number {
+    return (subscription.cancel_at || subscription.current_period_end) * 1000;
+  }
 }

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

@@ -21,7 +21,7 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
         },
         status: 'active',
       },
-      attributes: ['id', 'current_period_start', 'current_period_end'],
+      attributes: ['id', 'current_period_start', 'current_period_end', 'status'],
       raw: true,
     });
 
@@ -36,6 +36,13 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
     diff: Diff;
   }): Task<SubscriptionWillRenewEmailTemplateOptions> {
     const type = this.eventType;
+    const periodEnd = this.getEndTime(subscription);
+    if (periodEnd <= this.start) {
+      throw new Error(`Subscription(${subscription.id}) is already expired, no need to send notification`);
+    }
+    if (subscription.status !== 'active') {
+      throw new Error(`Subscription(${subscription.id}) is not active, no need to send notification`);
+    }
     return {
       id: `${subscription.id}.${type}.${diff.value}.${diff.unit}`,
       job: {
@@ -47,9 +54,11 @@ export class SubscriptionWillRenewSchedule extends BaseSubscriptionScheduleNotif
           required: !!diff.required,
         },
       },
-      delay: dayjs(subscription.current_period_end * 1000)
-        .subtract(diff.value, diff.unit)
-        .diff(this.start, 's'),
+      delay: dayjs(periodEnd).subtract(diff.value, diff.unit).diff(this.start, 's'),
     };
   }
+
+  override getEndTime(subscription: Subscription): number {
+    return subscription.current_period_end * 1000;
+  }
 }

package/api/src/index.ts

@@ -33,6 +33,7 @@ import changePaymentHandlers from './routes/connect/change-payment';
 import changePlanHandlers from './routes/connect/change-plan';
 import collectHandlers from './routes/connect/collect';
 import collectBatchHandlers from './routes/connect/collect-batch';
+import rechargeHandlers from './routes/connect/recharge';
 import payHandlers from './routes/connect/pay';
 import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
@@ -69,6 +70,7 @@ handlers.attach(Object.assign({ app: router }, setupHandlers));
 handlers.attach(Object.assign({ app: router }, subscribeHandlers));
 handlers.attach(Object.assign({ app: router }, changePaymentHandlers));
 handlers.attach(Object.assign({ app: router }, changePlanHandlers));
+handlers.attach(Object.assign({ app: router }, rechargeHandlers));
 
 router.use('/api', routes);
 

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

@@ -261,3 +261,30 @@ export async function getTokenSummaryByDid(
 
   return results;
 }
+
+export async function getTokenByAddress(
+  address: string,
+  paymentMethod: PaymentMethod,
+  paymentCurrency: PaymentCurrency
+): Promise<string | undefined> {
+  if (paymentMethod.type === 'arcblock') {
+    const client = paymentMethod.getOcapClient();
+    const { tokens } = await client.getAccountTokens({ address });
+    return tokens.find((t: any) => t.address === paymentCurrency.contract)?.balance;
+  }
+  if (paymentMethod.type === 'ethereum') {
+    const client = paymentMethod.getEvmClient();
+    if (paymentCurrency.contract) {
+      const token = await fetchErc20Balance(client, paymentCurrency.contract, address);
+      return token;
+    }
+    const token = await fetchEtherBalance(client, address);
+    return token;
+  }
+  logger.info(`unsupported payment method type: ${paymentMethod.type}`, {
+    paymentCurrencyId: paymentCurrency.id,
+    paymentMethodId: paymentMethod.id,
+    address,
+  });
+  return '0';
+}

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

@@ -122,6 +122,10 @@ export class SubscriptionCanceledEmailTemplate implements BaseEmailTemplate<Subs
       cancellationReason = translate('notification.subscriptionCanceled.paymentFailed', locale);
     }
 
+    if (subscription.cancelation_details?.reason === 'stake_revoked') {
+      cancellationReason = translate('notification.subscriptionCanceled.stakeRevoked', locale);
+    }
+
     // @ts-expect-error
     const chainHost: string | undefined = paymentMethod?.settings?.[paymentMethod.type]?.api_host;
     const viewSubscriptionLink = getCustomerSubscriptionPageUrl({

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

@@ -11,7 +11,7 @@ import { Customer, PaymentMethod, Subscription, PaymentCurrency } from '../../..
 import { PaymentDetail, getPaymentAmountForCycleSubscription } from '../../payment';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
-import { formatTime, getPrettyMsI18nLocale } from '../../time';
+import { formatTime, getPrettyMsI18nLocale, getSimplifyDuration } from '../../time';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 import dayjs from '../../dayjs';
 import { getSubscriptionNotificationCustomActions } from '../../util';
@@ -27,7 +27,7 @@ interface SubscriptionTrialWilEndEmailTemplateContext {
   locale: string;
   productName: string;
   at: string;
-  willRenewDuration: string;
+  willEndDuration: string;
   paymentDetail: PaymentDetail;
 
   userDid: string;
@@ -79,10 +79,13 @@ export class SubscriptionTrialWilEndEmailTemplate
     const userDid = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
+    if (!subscription.trial_end) {
+      throw new Error(`Subscription has no trial end: ${subscription.id}`);
+    }
+
     const at: string = formatTime((subscription.trial_end as number) * 1000);
-    const willRenewDuration: string =
-      locale === 'en' ? this.getWillRenewDuration(locale) : this.getWillRenewDuration(locale).split(' ').join('');
 
+    const willEndDuration: string = getSimplifyDuration((subscription.trial_end! - dayjs().unix()) * 1000, locale);
     // const paymentDetail: PaymentDetail = await getPaymentDetail(userDid, invoice);
 
     const paymentAmount = await getPaymentAmountForCycleSubscription(subscription, paymentCurrency);
@@ -117,7 +120,7 @@ export class SubscriptionTrialWilEndEmailTemplate
       locale,
       productName,
       at,
-      willRenewDuration,
+      willEndDuration,
       paymentDetail,
 
       userDid,
@@ -132,37 +135,12 @@ export class SubscriptionTrialWilEndEmailTemplate
     };
   }
 
-  getWillRenewDuration(locale: string): string {
-    if (this.options.willRenewUnit === 'M') {
-      if (this.options.willRenewValue > 1) {
-        return `${this.options.willRenewValue} ${translate('notification.common.months', locale)}`;
-      }
-
-      return `${this.options.willRenewValue} ${translate('notification.common.month', locale)}`;
-    }
-    if (this.options.willRenewUnit === 'd') {
-      if (this.options.willRenewValue > 1) {
-        return `${this.options.willRenewValue} ${translate('notification.common.days', locale)}`;
-      }
-      return `${this.options.willRenewValue} ${translate('notification.common.day', locale)}`;
-    }
-
-    if (this.options.willRenewUnit === 'm') {
-      if (this.options.willRenewValue > 1) {
-        return `${this.options.willRenewValue} ${translate('notification.common.minutes', locale)}`;
-      }
-      return `${this.options.willRenewValue} ${translate('notification.common.minute', locale)}`;
-    }
-
-    return `${this.options.willRenewValue} ${this.options.willRenewUnit}`;
-  }
-
   async getTemplate(): Promise<BaseEmailTemplateType | null> {
     const {
       locale,
       productName,
       at,
-      willRenewDuration,
+      willEndDuration,
       paymentDetail,
 
       userDid,
@@ -191,19 +169,19 @@ export class SubscriptionTrialWilEndEmailTemplate
     const template: BaseEmailTemplateType = {
       title: `${translate('notification.subscriptionTrialWillEnd.title', locale, {
         productName,
-        willRenewDuration,
+        willEndDuration,
       })}`,
       body:
         canPay || isStripe
           ? `${translate('notification.subscriptionTrialWillEnd.body', locale, {
               at,
               productName,
-              willRenewDuration,
+              willEndDuration,
             })}`
           : `${translate('notification.subscriptionTrialWillEnd.unableToPayBody', locale, {
               at,
               productName,
-              willRenewDuration,
+              willEndDuration,
               balance: `${paymentDetail.balance} ${paymentDetail.symbol}`,
               price: `${paymentDetail.price} ${paymentDetail.symbol}`,
             })}`,

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

@@ -12,7 +12,7 @@ import { getCustomerInvoicePageUrl } from '../../invoice';
 import logger from '../../logger';
 import { getMainProductName } from '../../product';
 import { getCustomerSubscriptionPageUrl } from '../../subscription';
-import { formatTime } from '../../time';
+import { formatTime, getSimplifyDuration } from '../../time';
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './base';
 import { getSubscriptionNotificationCustomActions } from '../../util';
 
@@ -27,7 +27,8 @@ interface SubscriptionWillCanceledEmailTemplateContext {
   locale: string;
   productName: string;
   at: string;
-  willCancelDuration: string;
+  cancelReason: string;
+  body: string;
 
   userDid: string;
   paymentInfo: string;
@@ -35,6 +36,7 @@ interface SubscriptionWillCanceledEmailTemplateContext {
   viewSubscriptionLink: string;
   viewInvoiceLink: string;
   customActions: any[];
+  needRenew: boolean;
 }
 
 export class SubscriptionWillCanceledEmailTemplate
@@ -56,8 +58,19 @@ export class SubscriptionWillCanceledEmailTemplate
     if (!subscription) {
       throw new Error(`Subscription(${this.options.subscriptionId}) not found`);
     }
-    if (subscription.status !== 'past_due') {
-      throw new Error(`Subscription(${this.options.subscriptionId}) status(${subscription.status}) must be past_due`);
+    if (subscription.isImmutable()) {
+      throw new Error(`Subscription(${this.options.subscriptionId}) is immutable, no need to send notification`);
+    }
+
+    const now = dayjs().unix();
+    const cancelAt = subscription.cancel_at || subscription.current_period_end;
+    if (!subscription.cancel_at && !subscription.cancel_at_period_end) {
+      throw new Error(
+        `Subscription(${this.options.subscriptionId}) is not scheduled to cancel, no need to send notification`
+      );
+    }
+    if (cancelAt <= now) {
+      throw new Error(`Subscription(${this.options.subscriptionId}) is already canceled, no need to send notification`);
     }
 
     const customer = await Customer.findByPk(subscription.customer_id);
@@ -75,12 +88,39 @@ export class SubscriptionWillCanceledEmailTemplate
     const userDid = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);
-    const at: string = formatTime(invoice.period_end * 1000);
-    const willCancelDuration: string =
-      locale === 'en' ? this.getWillCancelDuration(locale) : this.getWillCancelDuration(locale).split(' ').join('');
-
+    const at: string = formatTime(cancelAt * 1000);
+    const willCancelDuration: string = getSimplifyDuration((cancelAt - now) * 1000, locale);
     const paymentInfo: string = `${fromUnitToToken(+invoice.total, paymentCurrency.decimal)} ${paymentCurrency.symbol}`;
 
+    let body: string = translate('notification.subscriptWillCanceled.body', locale, {
+      productName,
+      willCancelDuration,
+      at,
+    });
+
+    let needRenew = false;
+    const reasonMap = {
+      cancellation_requested: 'customerCanceled',
+      payment_failed: 'paymentFailed',
+      stake_revoked: 'stakeRevoked',
+    } as const;
+
+    const cancelReason = translate(
+      `notification.subscriptWillCanceled.${reasonMap[subscription.cancelation_details?.reason as keyof typeof reasonMap] || 'adminCanceled'}`,
+      locale,
+      {
+        canceled_at: formatTime(subscription.canceled_at ? subscription.canceled_at * 1000 : dayjs().unix()),
+      }
+    );
+    if (subscription.status === 'past_due' || subscription.cancelation_details?.reason === 'payment_failed') {
+      body = translate('notification.subscriptWillCanceled.pastDue', locale, {
+        productName,
+        willCancelDuration,
+        at,
+      });
+      needRenew = true;
+    }
+
     const viewSubscriptionLink = getCustomerSubscriptionPageUrl({
       subscriptionId: subscription.id,
       locale,
@@ -102,7 +142,8 @@ export class SubscriptionWillCanceledEmailTemplate
       locale,
       productName,
       at,
-      willCancelDuration,
+      body,
+      cancelReason,
 
       userDid,
       paymentInfo,
@@ -110,41 +151,18 @@ export class SubscriptionWillCanceledEmailTemplate
       viewSubscriptionLink,
       viewInvoiceLink,
       customActions,
+      needRenew,
     };
   }
 
-  getWillCancelDuration(locale: string): string {
-    if (this.options.willCancelUnit === 'M') {
-      if (this.options.willCancelValue > 1) {
-        return `${this.options.willCancelValue} ${translate('notification.common.months', locale)}`;
-      }
-
-      return `${this.options.willCancelValue} ${translate('notification.common.month', locale)}`;
-    }
-    if (this.options.willCancelUnit === 'd') {
-      if (this.options.willCancelValue > 1) {
-        return `${this.options.willCancelValue} ${translate('notification.common.days', locale)}`;
-      }
-      return `${this.options.willCancelValue} ${translate('notification.common.day', locale)}`;
-    }
-
-    if (this.options.willCancelUnit === 'm') {
-      if (this.options.willCancelValue > 1) {
-        return `${this.options.willCancelValue} ${translate('notification.common.minutes', locale)}`;
-      }
-      return `${this.options.willCancelValue} ${translate('notification.common.minute', locale)}`;
-    }
-
-    return `${this.options.willCancelValue} ${this.options.willCancelUnit}`;
-  }
-
   async getTemplate(): Promise<BaseEmailTemplateType | null> {
     const {
       locale,
       productName,
       at,
-      willCancelDuration,
-
+      body,
+      cancelReason,
+      needRenew,
       userDid,
       paymentInfo,
 
@@ -162,11 +180,7 @@ export class SubscriptionWillCanceledEmailTemplate
       title: `${translate('notification.subscriptWillCanceled.title', locale, {
         productName,
       })}`,
-      body: translate('notification.subscriptWillCanceled.body', locale, {
-        productName,
-        willCancelDuration,
-        at,
-      }),
+      body,
       // @ts-expect-error
       attachments: [
         {
@@ -202,19 +216,38 @@ export class SubscriptionWillCanceledEmailTemplate
                 text: productName,
               },
             },
+            ...(needRenew
+              ? [
+                  {
+                    type: 'text',
+                    data: {
+                      type: 'plain',
+                      color: '#9397A1',
+                      text: translate('notification.common.paymentAmount', locale),
+                    },
+                  },
+                  {
+                    type: 'text',
+                    data: {
+                      type: 'plain',
+                      text: paymentInfo,
+                    },
+                  },
+                ]
+              : []),
             {
               type: 'text',
               data: {
                 type: 'plain',
                 color: '#9397A1',
-                text: translate('notification.common.paymentAmount', locale),
+                text: translate('notification.subscriptWillCanceled.cancelReason', locale),
               },
             },
             {
               type: 'text',
               data: {
                 type: 'plain',
-                text: paymentInfo,
+                text: cancelReason,
               },
             },
           ].filter(Boolean),
@@ -227,11 +260,12 @@ export class SubscriptionWillCanceledEmailTemplate
           title: translate('notification.common.viewSubscription', locale),
           link: viewSubscriptionLink,
         },
-        viewInvoiceLink && {
-          name: translate('notification.common.renewNow', locale),
-          title: translate('notification.common.renewNow', locale),
-          link: viewInvoiceLink,
-        },
+        viewInvoiceLink &&
+          needRenew && {
+            name: translate('notification.common.renewNow', locale),
+            title: translate('notification.common.renewNow', locale),
+            link: viewInvoiceLink,
+          },
         ...customActions,
       ].filter(Boolean),
     };