payment-kit 1.13.162 → 1.13.164

package/api/src/index.ts

@@ -27,6 +27,7 @@ import routes from './routes';
 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 payHandlers from './routes/connect/pay';
 import setupHandlers from './routes/connect/setup';
 import subscribeHandlers from './routes/connect/subscribe';
@@ -54,6 +55,7 @@ app.use(ensureI18n());
 
 const router = express.Router();
 handlers.attach(Object.assign({ app: router }, collectHandlers));
+handlers.attach(Object.assign({ app: router }, collectBatchHandlers));
 handlers.attach(Object.assign({ app: router }, payHandlers));
 handlers.attach(Object.assign({ app: router }, setupHandlers));
 handlers.attach(Object.assign({ app: router }, subscribeHandlers));

package/api/src/locales/zh.ts

@@ -11,7 +11,7 @@ export default flat({
       validityPeriod: '服务周期',
       trialPeriod: '试用期',
       viewSubscription: '查看订阅',
-      viewInvoice: '查看发票',
+      viewInvoice: '查看账单',
       viewTxHash: '查看交易',
       trialDuration: '试用期时长',
       duration: '时长',

package/api/src/queues/payment.ts

@@ -77,7 +77,7 @@ export const handlePaymentSucceed = async (paymentIntent: PaymentIntent) => {
         logger.info(`Subscription ${subscription.id} updated on payment done ${invoice.id}`);
       } else if (subscription.status === 'past_due' && subscription.cancelation_details?.reason === 'payment_failed') {
         // ensure no uncollectible amount before recovering from payment failed
-        const result = await Invoice.getUncollectibleAmountBySubscription(subscription.id);
+        const [result] = await Invoice.getUncollectibleAmount({ subscriptionId: subscription.id });
         if (isEmpty(result)) {
           // reset billing cycle anchor and cancel_* if we are recovering from payment failed
           if (subscription.cancel_at && subscription.cancel_at !== subscription.current_period_end) {

package/api/src/routes/connect/collect-batch.ts

@@ -0,0 +1,125 @@
+/* eslint-disable no-await-in-loop */
+import type { Transaction } from '@ocap/client';
+import { fromAddress } from '@ocap/wallet';
+
+import type { CallbackArgs } from '../../libs/auth';
+import { wallet } from '../../libs/auth';
+import { getGasPayerExtra } from '../../libs/payment';
+import { getTxMetadata } from '../../libs/util';
+import { invoiceQueue } from '../../queues/invoice';
+import { handlePaymentSucceed, paymentQueue } from '../../queues/payment';
+import { PaymentIntent } from '../../store/models';
+import { ensureSubscriptionForCollectBatch, getAuthPrincipalClaim } from './shared';
+
+// Used to collect uncollectible invoices for a subscription and currency
+export default {
+  action: 'collect-batch',
+  authPrincipal: false,
+  claims: {
+    authPrincipal: async ({ extraParams }: CallbackArgs) => {
+      const { paymentMethod } = await ensureSubscriptionForCollectBatch(
+        extraParams.subscriptionId,
+        extraParams.currencyId
+      );
+      return getAuthPrincipalClaim(paymentMethod, 'pay');
+    },
+  },
+  onConnect: async ({ userDid, userPk, extraParams }: CallbackArgs) => {
+    const { subscriptionId, currencyId } = extraParams;
+    const { amount, invoices, paymentCurrency, paymentMethod } = await ensureSubscriptionForCollectBatch(
+      subscriptionId,
+      currencyId
+    );
+
+    if (paymentMethod.type === 'arcblock') {
+      const tokens = [{ address: paymentCurrency.contract as string, value: amount }];
+      // @ts-ignore
+      const itx: TransferV3Tx = {
+        outputs: [{ owner: wallet.address, tokens, assets: [] }],
+        data: getTxMetadata({
+          subscriptionId,
+          currencyId,
+          invoices,
+        }),
+      };
+
+      const claims: { [key: string]: object } = {
+        prepareTx: {
+          type: 'TransferV3Tx',
+          description: `Pay all past due invoices for ${subscriptionId}`,
+          partialTx: { from: userDid, pk: userPk, itx },
+          requirement: { tokens },
+          chainInfo: {
+            host: paymentMethod.settings?.arcblock?.api_host as string,
+            id: paymentMethod.settings?.arcblock?.chain_id as string,
+          },
+        },
+      };
+
+      return claims;
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+  onAuth: async ({ userDid, claims, extraParams }: CallbackArgs) => {
+    const { subscriptionId, currencyId } = extraParams;
+    const { invoices, paymentMethod } = await ensureSubscriptionForCollectBatch(subscriptionId, currencyId);
+
+    if (paymentMethod.type === 'arcblock') {
+      const client = paymentMethod.getOcapClient();
+      const claim = claims.find((x) => x.type === 'prepareTx');
+
+      const tx: Partial<Transaction> = client.decodeTx(claim.finalTx);
+      if (claim.delegator && claim.from) {
+        tx.delegator = claim.delegator;
+        tx.from = claim.from;
+      }
+
+      // @ts-ignore
+      const { buffer } = await client.encodeTransferV3Tx({ tx });
+      const txHash = await client.sendTransferV3Tx(
+        // @ts-ignore
+        { tx, wallet: fromAddress(userDid) },
+        getGasPayerExtra(buffer)
+      );
+
+      const paymentIntents = await PaymentIntent.findAll({
+        where: {
+          invoice_id: invoices,
+        },
+      });
+      for (const paymentIntent of paymentIntents) {
+        await paymentIntent.update({
+          status: 'succeeded',
+          amount_received: paymentIntent.amount,
+          capture_method: 'manual',
+          last_payment_error: null,
+          payment_details: {
+            arcblock: {
+              tx_hash: txHash,
+              payer: userDid,
+            },
+          },
+        });
+
+        await handlePaymentSucceed(paymentIntent);
+
+        // cleanup the queue
+        let exist = await paymentQueue.get(paymentIntent.id);
+        if (exist) {
+          await paymentQueue.delete(paymentIntent.id);
+        }
+        if (paymentIntent.invoice_id) {
+          exist = await invoiceQueue.get(paymentIntent.invoice_id);
+          if (exist) {
+            await invoiceQueue.delete(paymentIntent.invoice_id);
+          }
+        }
+      }
+
+      return { hash: txHash };
+    }
+
+    throw new Error(`Payment method ${paymentMethod.type} not supported`);
+  },
+};

package/api/src/routes/connect/shared.ts

@@ -4,6 +4,7 @@ import { toTypeInfo } from '@arcblock/did';
 import { toDelegateAddress } from '@arcblock/did-util';
 import { BN } from '@ocap/util';
 import { fromPublicKey } from '@ocap/wallet';
+import isEmpty from 'lodash/isEmpty';
 
 import { estimateMaxGasForTx, hasStakedForGas } from '../../integrations/blockchain/stake';
 import { blocklet, wallet } from '../../libs/auth';
@@ -768,3 +769,34 @@ export async function ensureChangePaymentContext(subscriptionId: string) {
     paymentCurrency,
   };
 }
+
+export async function ensureSubscriptionForCollectBatch(subscriptionId: string, currencyId: string) {
+  const subscription = await Subscription.findByPk(subscriptionId);
+  if (!subscription) {
+    throw new Error(`Subscription ${subscriptionId} not found when prepare batch collect`);
+  }
+
+  const paymentCurrency = await PaymentCurrency.findByPk(currencyId);
+  if (!paymentCurrency) {
+    throw new Error(`PaymentCurrency ${currencyId} not found when prepare batch collect`);
+  }
+
+  const [summary, detail] = await Invoice.getUncollectibleAmount({
+    subscriptionId: subscription.id,
+    customerId: subscription.customer_id,
+    currencyId,
+  });
+  if (isEmpty(summary) || !summary[currencyId] || summary[currencyId] === '0') {
+    throw new Error(`No uncollectible invoice found for subscription ${subscriptionId} to batch collect`);
+  }
+
+  const paymentMethod = await PaymentMethod.findByPk(paymentCurrency.payment_method_id);
+
+  return {
+    subscription,
+    paymentCurrency: paymentCurrency as PaymentCurrency,
+    paymentMethod: paymentMethod as PaymentMethod,
+    amount: summary[currencyId],
+    invoices: detail[currencyId],
+  };
+}

package/api/src/routes/products.ts

@@ -2,7 +2,6 @@ import { fromTokenToUnit } from '@ocap/util';
 import { Router } from 'express';
 import Joi from 'joi';
 import pick from 'lodash/pick';
-import type { WhereOptions } from 'sequelize';
 
 import { getWhereFromKvQuery, getWhereFromQuery } from '../libs/api';
 import logger from '../libs/logger';
@@ -112,22 +111,33 @@ const paginationSchema = Joi.object<{
   pageSize: number;
   livemode?: boolean;
   active?: boolean;
+  status?: string;
   name?: string;
   description?: string;
+  q?: string;
+  o?: string;
 }>({
   page: Joi.number().integer().min(1).default(1),
   pageSize: Joi.number().integer().min(1).max(100).default(20),
   livemode: Joi.boolean().empty(''),
   active: Joi.boolean().empty(''),
+  status: Joi.string().empty(''),
   name: Joi.string().empty(''),
   description: Joi.string().empty(''),
+  q: Joi.string().empty(''), // query
+  o: Joi.string().empty(''), // order
 });
 router.get('/', auth, async (req, res) => {
   const { page, pageSize, active, livemode, name, description, ...query } = await paginationSchema.validateAsync(
     req.query,
     { stripUnknown: false, allowUnknown: true }
   );
-  const where: WhereOptions<Product> = {};
+  const where = getWhereFromKvQuery(query.q);
+
+  if (query.status) {
+    // 兼容处理，支持 status
+    where.active = query.status === 'active';
+  }
 
   if (typeof active === 'boolean') {
     where.active = active;
@@ -151,7 +161,7 @@ router.get('/', auth, async (req, res) => {
 
   const { rows: list, count } = await Product.findAndCountAll({
     where,
-    order: [['created_at', 'DESC']],
+    order: [['created_at', query.o === 'asc' ? 'ASC' : 'DESC']],
     offset: (page - 1) * pageSize,
     limit: pageSize,
     include: [{ model: Price, as: 'prices' }],

package/api/src/routes/subscriptions.ts

@@ -1375,4 +1375,24 @@ router.get('/:id/usage-records', authPortal, (req, res) => {
   createUsageRecordQueryFn(req.doc)(req, res);
 });
 
+// Get invoice summary
+router.get('/:id/summary', authPortal, async (req, res) => {
+  try {
+    const subscription = await Subscription.findByPk(req.params.id);
+    if (!subscription) {
+      return res.status(404).json({ error: 'Subscription not found' });
+    }
+
+    const [summary] = await Invoice.getUncollectibleAmount({
+      subscriptionId: subscription.id,
+      currencyId: subscription.currency_id,
+      customerId: subscription.customer_id,
+    });
+    return res.json(summary);
+  } catch (err) {
+    console.error(err);
+    return res.status(400).json({ error: err.message });
+  }
+});
+
 export default router;

package/api/src/store/models/customer.ts

@@ -161,11 +161,11 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
 
   public async getSummary() {
     const { PaymentIntent, Refund, Invoice } = this.sequelize.models;
-    const [paid, due, refunded] = await Promise.all([
+    const [paid, [due], refunded] = await Promise.all([
       // @ts-ignore
       PaymentIntent!.getPaidAmountByCustomer(this.id),
       // @ts-ignore
-      Invoice!.getUncollectibleAmountByCustomer(this.id),
+      Invoice!.getUncollectibleAmount({ customerId: this.id }),
       // @ts-ignore
       Refund!.getRefundAmountByCustomer(this.id),
     ]);
@@ -176,8 +176,8 @@ export class Customer extends Model<InferAttributes<Customer>, InferCreationAttr
   public async canMakeNewPurchase(excludedInvoiceId: string = '') {
     const { Invoice } = this.sequelize.models;
     // @ts-ignore
-    const result = await Invoice!.getUncollectibleAmountByCustomer(this.id, excludedInvoiceId);
-    return Object.entries(result).every(([, amount]) => new BN(amount).lte(new BN(0)));
+    const [summary] = await Invoice!.getUncollectibleAmount({ customerId: this.id, excludedInvoiceId });
+    return Object.entries(summary).every(([, amount]) => new BN(amount).lte(new BN(0)));
   }
 
   public getBalanceToApply(currencyId: string, amount: string) {

package/api/src/store/models/invoice.ts

@@ -19,6 +19,7 @@ import type {
   CustomerShipping,
   DiscountAmount,
   GroupedBN,
+  GroupedStrList,
   PaymentError,
   PaymentSettings,
   SimpleCustomField,
@@ -523,44 +524,59 @@ export class Invoice extends Model<InferAttributes<Invoice>, InferCreationAttrib
     return ['paid', 'void'].includes(this.status);
   }
 
-  public static async getUncollectibleAmount(where: WhereOptions<Invoice>): Promise<GroupedBN> {
+  private static async _getUncollectibleAmount(where: WhereOptions<Invoice>): Promise<[GroupedBN, GroupedStrList]> {
     const invoices = await Invoice.findAll({ where });
-    return invoices.reduce((acc: GroupedBN, invoice) => {
+    const summary: GroupedBN = {};
+    const detail: GroupedStrList = {};
+
+    invoices.forEach((invoice) => {
       const key = invoice.currency_id;
-      if (!acc[key]) {
-        acc[key] = '0';
+      if (!summary[key]) {
+        summary[key] = '0';
+      }
+      if (!detail[key]) {
+        detail[key] = [];
       }
 
-      acc[key] = new BN(acc[key]).add(new BN(invoice.amount_remaining)).toString();
+      summary[key] = new BN(summary[key]).add(new BN(invoice.amount_remaining)).toString();
+      detail[key]!.push(invoice.id);
+    });
 
-      return acc;
-    }, {});
+    return [summary, detail];
   }
 
-  public static getUncollectibleAmountByCustomer(customerId: string, excludedInvoiceId?: string) {
-    const where: WhereOptions<Invoice> = {
-      status: ['uncollectible'],
-      customer_id: customerId,
-      amount_remaining: { [Op.gt]: '0' },
-    };
-    if (excludedInvoiceId) {
-      where.id = { [Op.not]: excludedInvoiceId };
+  public static getUncollectibleAmount({
+    customerId,
+    subscriptionId,
+    currencyId,
+    excludedInvoiceId,
+  }: {
+    customerId?: string;
+    subscriptionId?: string;
+    currencyId?: string;
+    excludedInvoiceId?: string;
+  }) {
+    if (!customerId && !subscriptionId) {
+      throw new Error('customerId or subscriptionId is required for getUncollectibleAmount');
     }
-
-    return Invoice.getUncollectibleAmount(where);
-  }
-
-  public static getUncollectibleAmountBySubscription(subscriptionId: string, excludedInvoiceId?: string) {
     const where: WhereOptions<Invoice> = {
       status: ['uncollectible'],
-      subscription_id: subscriptionId,
       amount_remaining: { [Op.gt]: '0' },
     };
+    if (currencyId) {
+      where.currency_id = currencyId;
+    }
+    if (customerId) {
+      where.customer_id = customerId;
+    }
+    if (subscriptionId) {
+      where.subscription_id = subscriptionId;
+    }
     if (excludedInvoiceId) {
       where.id = { [Op.not]: excludedInvoiceId };
     }
 
-    return Invoice.getUncollectibleAmount(where);
+    return this._getUncollectibleAmount(where);
   }
 }
 

package/api/src/store/models/subscription.ts

@@ -322,7 +322,7 @@ export class Subscription extends Model<InferAttributes<Subscription>, InferCrea
                   },
                 });
                 if (count === 2) {
-                  // 当且仅当 有试用期的订阅更新了 && 恰好有 2 次发票,此时订阅的试用期刚好结束
+                  // 当且仅当 有试用期的订阅更新了 && 恰好有 2 次账单,此时订阅的试用期刚好结束
                   createEvent('Subscription', 'customer.subscription.trial_end', model, options).catch(console.error);
                 }
               }

package/api/src/store/models/types.ts

@@ -2,6 +2,7 @@
 import type { LiteralUnion } from 'type-fest';
 
 export type GroupedBN = { [currencyId: string]: string };
+export type GroupedStrList = { [currencyId: string]: string[] };
 
 export type Pagination<T = any> = T & {
   // offset based

package/api/tests/libs/util.spec.ts

@@ -1,17 +1,16 @@
 import { Op } from 'sequelize';
+
+import { getWhereFromKvQuery } from '../../src/libs/api';
 import dayjs from '../../src/libs/dayjs';
 import {
   createCodeGenerator,
   createIdGenerator,
   formatMetadata,
   getDataObjectFromQuery,
-
   getNextRetry,
   tryWithTimeout,
 } from '../../src/libs/util';
 
-import { getWhereFromKvQuery } from '../../src/libs/api'
-
 describe('createIdGenerator', () => {
   it('should return a function that generates an ID with the specified prefix and size', () => {
     const generateId = createIdGenerator('test', 10);
@@ -199,11 +198,7 @@ describe('getWhereFromKvQuery', () => {
     const q = 'like-status:succ like-number:1533';
     const result = getWhereFromKvQuery(q);
     expect(result).toEqual({
-      [Op.or]: [
-        { status: { [Op.like]: `%succ%` } },
-        { number: { [Op.like]: `%1533%` } }
-      ],
+      [Op.or]: [{ status: { [Op.like]: '%succ%' } }, { number: { [Op.like]: '%1533%' } }],
     });
   });
-
-});
+});

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.13.162
+version: 1.13.164
 logo: logo.png
 files:
   - dist
@@ -93,7 +93,7 @@ navigation:
   - id: billing
     title:
       en: Billing
-      zh: 订阅管理
+      zh: 我的账单
     icon: ion:receipt-outline
     link: /customer
     section:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.13.162",
+  "version": "1.13.164",
   "scripts": {
     "dev": "cross-env COMPONENT_STORE_URL=https://test.store.blocklet.dev blocklet dev --open",
     "eject": "vite eject",
@@ -50,7 +50,7 @@
     "@arcblock/jwt": "^1.18.110",
     "@arcblock/ux": "^2.9.39",
     "@blocklet/logger": "1.16.23",
-    "@blocklet/payment-react": "1.13.162",
+    "@blocklet/payment-react": "1.13.164",
     "@blocklet/sdk": "1.16.23",
     "@blocklet/ui-react": "^2.9.39",
     "@blocklet/uploader": "^0.0.74",
@@ -110,7 +110,7 @@
   "devDependencies": {
     "@abtnode/types": "1.16.23",
     "@arcblock/eslint-config-ts": "^0.2.4",
-    "@blocklet/payment-types": "1.13.162",
+    "@blocklet/payment-types": "1.13.164",
     "@types/cookie-parser": "^1.4.6",
     "@types/cors": "^2.8.17",
     "@types/dotenv-flow": "^3.3.3",
@@ -149,5 +149,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "e11cae8972d35cde567d4784511aacd33a29c1bc"
+  "gitHead": "3172c382ed27451d90ea78ebd99087658fe7362c"
 }