payment-kit 1.18.30 → 1.18.32

package/api/src/crons/metering-subscription-detection.ts

@@ -36,6 +36,12 @@ interface MeteringSubscriptionDetectionContext {
 
 export class MeteringSubscriptionDetectionTemplate implements BaseEmailTemplate<MeteringSubscriptionDetectionContext> {
   private timeRange: { start: number; end: number };
+  options: {
+    timeRange: {
+      start: number;
+      end: number;
+    };
+  };
 
   constructor() {
     const end = dayjs();
@@ -44,6 +50,9 @@ export class MeteringSubscriptionDetectionTemplate implements BaseEmailTemplate<
       start: start.unix(),
       end: end.unix(),
     };
+    this.options = {
+      timeRange: this.timeRange,
+    };
   }
 
   private async getAbnormalSubscriptions(meteringInvoiceIds: string[], meteringSubscriptionIds: string[]) {

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

@@ -108,6 +108,7 @@ export async function mintNftForCheckoutSession(id: string) {
       },
     });
 
+    // FIXME: checkoutSession has multiple subscriptions?
     if (checkoutSession.subscription_id) {
       const subscription = await Subscription.findByPk(checkoutSession.subscription_id);
       if (subscription && subscription.metadata?.nft_address) {

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

@@ -109,7 +109,7 @@ export async function ensurePassportRevoked(subscription: Subscription) {
     return;
   }
 
-  const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+  const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
   if (!checkoutSession) {
     logger.warn('checkoutSession for subscription not found', info);
     return;

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -99,7 +99,7 @@ export async function ensureStripeInvoice(stripeInvoice: any, subscription: Subs
   await lock.acquire();
 
   const customer = await Customer.findByPk(subscription.customer_id);
-  const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+  const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
   let invoice = await Invoice.findOne({ where: { 'metadata.stripe_id': stripeInvoice.id } });
   if (invoice) {
@@ -256,7 +256,7 @@ export async function handleStripeInvoiceCreated(event: TEventExpanded, client:
   });
 
   const customer = await Customer.findByPk(subscription.customer_id);
-  const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+  const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
   if (stripeInvoice.billing_reason === 'subscription_cycle') {
     // check if usage report is empty

package/api/src/integrations/stripe/handlers/setup-intent.ts

@@ -2,6 +2,7 @@ import type Stripe from 'stripe';
 
 import logger from '../../../libs/logger';
 import { CheckoutSession, Lock, SetupIntent, Subscription, TEventExpanded } from '../../../store/models';
+import { updateGroupSubscriptionsPaymentMethod } from '../resource';
 
 async function handleSubscriptionOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
   const subscription = await Subscription.findOne({
@@ -19,7 +20,7 @@ async function handleSubscriptionOnSetupSucceeded(event: TEventExpanded, stripeI
       logger.info('subscription become active on stripe intent succeeded', subscription.id);
     }
 
-    const checkoutSession = await CheckoutSession.findOne({ where: { subscription_id: subscription.id } });
+    const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
     if (checkoutSession && checkoutSession.status === 'open') {
       await checkoutSession.update({ status: 'complete', payment_status: 'no_payment_required' });
       logger.info('checkout session become complete on stripe intent succeeded', checkoutSession.id);
@@ -81,6 +82,32 @@ async function handleSetupIntentOnSetupSucceeded(event: TEventExpanded, stripeIn
   }
 }
 
+async function handleCheckoutSessionOnSetupSucceeded(event: TEventExpanded, stripeIntentId: string) {
+  const checkoutSession = await CheckoutSession.findOne({
+    where: { 'payment_details.stripe.setup_intent_id': stripeIntentId },
+  });
+  if (!checkoutSession) {
+    logger.warn('local checkout session not found for setup intent', {
+      id: event.id,
+      type: event.type,
+      stripeIntentId,
+    });
+    return;
+  }
+
+  logger.info('received setup intent event', { id: event.id, data: event.data, stripeIntentId, checkoutSession });
+
+  if (event.type === 'setup_intent.succeeded') {
+    const stripePaymentMethod = event.data.object.payment_method;
+    if (stripePaymentMethod && checkoutSession.subscription_groups) {
+      await updateGroupSubscriptionsPaymentMethod({
+        stripePaymentMethodId: stripePaymentMethod,
+        subscriptionIds: Object.values(checkoutSession.subscription_groups),
+      });
+    }
+  }
+}
+
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
   const stripeIntentId = event.data.object.id;
@@ -88,4 +115,5 @@ export async function handleSetupIntentEvent(event: TEventExpanded, _: Stripe) {
 
   await handleSubscriptionOnSetupSucceeded(event, stripeIntentId);
   await handleSetupIntentOnSetupSucceeded(event, stripeIntentId);
+  await handleCheckoutSessionOnSetupSucceeded(event, stripeIntentId);
 }

package/api/src/integrations/stripe/handlers/subscription.ts

@@ -4,6 +4,7 @@ import type Stripe from 'stripe';
 import logger from '../../../libs/logger';
 import { finalizeStripeSubscriptionUpdate } from '../../../libs/subscription';
 import { CheckoutSession, PaymentMethod, Subscription, TEventExpanded } from '../../../store/models';
+import { getCheckoutSessionSubscriptionIds } from '../../../libs/session';
 
 export async function handleStripeSubscriptionSucceed(subscription: Subscription, status: string) {
   if (!subscription.payment_details?.stripe?.subscription_id) {
@@ -16,14 +17,9 @@ export async function handleStripeSubscriptionSucceed(subscription: Subscription
   const result: any = await client.subscriptions.retrieve(subscription.payment_details.stripe.subscription_id, {
     expand: ['latest_invoice.payment_intent', 'pending_setup_intent'],
   });
-  if (result.pending_setup_intent && result.pending_setup_intent.status !== 'succeeded') {
-    logger.warn('subscription can not active because stripe setup not done', {
-      id: subscription.id,
-      status: result.pending_setup_intent.status,
-    });
-    return;
-  }
-  if (result.latest_invoice?.payment_intent && result.latest_invoice.payment_intent !== 'succeeded') {
+  const paymentIntent = result.latest_invoice?.payment_intent;
+  const paymentIntentStatus = typeof paymentIntent === 'string' ? paymentIntent : paymentIntent?.status;
+  if (result.latest_invoice?.payment_intent && paymentIntentStatus !== 'succeeded') {
     logger.warn('subscription can not active because stripe payment not done', {
       id: subscription.id,
       status: result.latest_invoice.payment_intent.status,
@@ -34,14 +30,22 @@ export async function handleStripeSubscriptionSucceed(subscription: Subscription
   await subscription.update({ status });
   logger.info('subscription become active on stripe event', { id: subscription.id, status: subscription.status });
 
-  const checkoutSession = await CheckoutSession.findOne({ where: { payment_intent_id: subscription.id } });
-  if (checkoutSession) {
-    await checkoutSession.update({
-      status: 'complete',
-      payment_status: 'paid',
-      payment_details: subscription.payment_details,
+  const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
+  if (checkoutSession && checkoutSession.status === 'open') {
+    await checkoutSession.increment('success_subscription_count', { by: 1 });
+    await checkoutSession.reload();
+    const subscriptionIds = getCheckoutSessionSubscriptionIds(checkoutSession);
+    if (checkoutSession.success_subscription_count === subscriptionIds.length) {
+      await checkoutSession.update({
+        status: 'complete',
+        payment_status: 'paid',
+        payment_details: paymentIntent?.payment_details || null,
+      });
+    }
+    logger.info('checkout session become complete on stripe event', {
+      id: checkoutSession.id,
+      subscriptionId: subscription.id,
     });
-    logger.info('checkout session become complete on stripe event', { id: checkoutSession.id });
   }
 }
 

package/api/src/integrations/stripe/resource.ts

@@ -11,6 +11,7 @@ import { getPriceUintAmountByCurrency } from '../../libs/session';
 import { getSubscriptionItemPrice } from '../../libs/subscription';
 import { sleep } from '../../libs/util';
 import {
+  CheckoutSession,
   Customer,
   Invoice,
   PaymentCurrency,
@@ -239,6 +240,31 @@ export async function ensureStripePaymentIntent(
   return stripeIntent;
 }
 
+export async function ensureStripeSetupIntentForCheckoutSession(
+  checkoutSession: CheckoutSession,
+  method: PaymentMethod,
+  metadata: Record<string, string>
+) {
+  const client = method.getStripeClient();
+  const customer = await ensureStripePaymentCustomer(checkoutSession, method);
+  const setupIntent = await client.setupIntents.create({
+    customer: customer.id,
+    payment_method_types: ['card'],
+    usage: 'off_session',
+    metadata,
+  });
+  await checkoutSession.update({
+    payment_details: {
+      ...(checkoutSession.payment_details || {}),
+      stripe: {
+        ...(checkoutSession.payment_details?.stripe || {}),
+        setup_intent_id: setupIntent.id,
+      },
+    },
+  });
+  return setupIntent;
+}
+
 export async function ensureStripeSubscription(
   internal: Subscription,
   method: PaymentMethod,
@@ -260,7 +286,7 @@ export async function ensureStripeSubscription(
     const prices = await Promise.all(
       items.map(async (x: any) => {
         const price = x.upsell_price || x.price;
-        x.stripePrice = await ensureStripePrice(price as any, method, currency);
+        x.stripePrice = await ensureStripePrice(price, method, currency);
         return x;
       })
     );
@@ -543,3 +569,57 @@ export async function batchHandleStripePayments() {
     await sleep(1000);
   }
 }
+
+export async function updateGroupSubscriptionsPaymentMethod(params: {
+  stripePaymentMethodId: string;
+  subscriptionIds: string[];
+}) {
+  const { stripePaymentMethodId, subscriptionIds } = params;
+  try {
+    const updates = subscriptionIds.map(async (subId) => {
+      const subscription = (await Subscription.findByPk(subId, {
+        include: [{ model: PaymentMethod, as: 'paymentMethod' }],
+      })) as Subscription & { paymentMethod: PaymentMethod };
+      if (!subscription || !subscription.paymentMethod || !subscription.payment_details?.stripe?.subscription_id) {
+        return null;
+      }
+      const client = subscription.paymentMethod.getStripeClient();
+      let stripeSub = await client.subscriptions.retrieve(subscription.payment_details.stripe.subscription_id, {
+        expand: ['latest_invoice', 'latest_invoice.payment_intent'],
+      });
+      if (stripeSub.status !== 'incomplete') {
+        return null;
+      }
+      const updatedSub = await client.subscriptions.update(stripeSub.id, {
+        default_payment_method: stripePaymentMethodId,
+        payment_behavior: 'default_incomplete',
+      });
+
+      stripeSub = await client.subscriptions.retrieve(updatedSub.id, {
+        expand: ['latest_invoice', 'latest_invoice.payment_intent'],
+      });
+      // if the latest invoice is not paid, pay it
+      // @ts-ignore
+      if (stripeSub.latest_invoice && stripeSub.latest_invoice?.status !== 'paid') {
+        // @ts-ignore
+        await client.invoices.pay(stripeSub.latest_invoice.id);
+      }
+      return updatedSub;
+    });
+
+    const updatedSubscriptions = await Promise.all(updates);
+    logger.info('Updated group subscriptions payment method', {
+      paymentMethod: stripePaymentMethodId,
+      subscriptions: subscriptionIds,
+    });
+
+    return updatedSubscriptions;
+  } catch (error) {
+    logger.error('Failed to update group subscriptions payment method', {
+      error,
+      paymentMethod: stripePaymentMethodId,
+      subscriptionIds,
+    });
+    throw error;
+  }
+}

package/api/src/libs/audit.ts

@@ -118,3 +118,45 @@ export async function createCustomEvent(
   events.emit('event.created', { id: event.id });
   events.emit(event.type, data.object);
 }
+
+/**
+ * 创建自定义事件，无需依赖模型对象
+ * @param type 完整的事件类型，格式为 prefix.suffix
+ * @param objectType 对象类型
+ * @param objectId 对象ID
+ * @param data 事件数据
+ * @param options 额外选项
+ */
+export async function createFlexibleEvent(
+  type: string,
+  objectType: string,
+  objectId: string,
+  data: Record<string, any>,
+  options: {
+    livemode?: boolean;
+    requestedBy?: string;
+    metadata?: Record<string, any>;
+  } = {}
+) {
+  const { livemode = false, requestedBy, metadata = {} } = options;
+
+  const event = await Event.create({
+    type,
+    api_version: API_VERSION,
+    livemode,
+    object_id: objectId,
+    object_type: objectType,
+    data,
+    request: {
+      id: '',
+      idempotency_key: '',
+      requested_by: requestedBy || context.getRequestedBy() || 'system',
+    },
+    metadata,
+    pending_webhooks: 99, // force all events goto the event queue
+  });
+
+  events.emit('event.created', { id: event.id });
+  events.emit(type, data);
+  return event;
+}

package/api/src/libs/invoice.ts

@@ -3,7 +3,7 @@ import type { LiteralUnion } from 'type-fest';
 import { withQuery } from 'ufo';
 
 import { BN, fromUnitToToken } from '@ocap/util';
-import { Op } from 'sequelize';
+import { Op, type WhereOptions } from 'sequelize';
 import { cloneDeep, pick } from 'lodash';
 import {
   Customer,
@@ -523,6 +523,7 @@ export async function ensureInvoiceAndItems({
   customer,
   currency,
   subscription,
+  subscriptions,
   props,
   lineItems,
   trialing,
@@ -532,6 +533,7 @@ export async function ensureInvoiceAndItems({
   customer: Customer;
   currency: PaymentCurrency;
   subscription?: Subscription;
+  subscriptions?: Subscription[];
   props: TInvoice;
   lineItems: TLineItemExpanded[];
   trialing: boolean; // do we have trialing
@@ -549,9 +551,16 @@ export async function ensureInvoiceAndItems({
   }
 
   // get subscription items
-  const subscriptionItems = subscription
-    ? await SubscriptionItem.findAll({ where: { subscription_id: subscription?.id } })
-    : [];
+  let subscriptionItems: SubscriptionItem[] = [];
+  if (subscriptions && subscriptions.length > 0) {
+    subscriptionItems = await SubscriptionItem.findAll({
+      where: { subscription_id: { [Op.in]: subscriptions.map((s) => s.id) } },
+    });
+  } else if (subscription) {
+    subscriptionItems = await SubscriptionItem.findAll({
+      where: { subscription_id: subscription?.id },
+    });
+  }
 
   function getLineSetup(x: TLineItemExpanded) {
     const price = getSubscriptionItemPrice(x);
@@ -794,13 +803,25 @@ export async function ensureStakeInvoice(
   },
   subscription: Subscription,
   paymentMethod: PaymentMethod,
-  customer: Customer
+  customer: Customer,
+  allSubscriptions?: Subscription[]
 ) {
   if (paymentMethod.type !== 'arcblock') {
     return;
   }
 
   try {
+    const isMultiSubscription = allSubscriptions && allSubscriptions.length > 1;
+    const metadata = {
+      ...(invoiceProps.metadata || {}),
+    };
+
+    if (isMultiSubscription) {
+      metadata.all_subscription_ids = allSubscriptions.map((s) => s.id);
+      metadata.is_shared_stake = true;
+      metadata.primary_subscription_id = subscription.id;
+    }
+
     const { invoice } = await createInvoiceWithItems({
       customer,
       subscription,
@@ -817,7 +838,7 @@ export async function ensureStakeInvoice(
       amount_remaining: '0',
       default_payment_method_id: paymentMethod.id,
       checkout_session_id: invoiceProps?.checkout_session_id || '',
-      metadata: invoiceProps.metadata || {},
+      metadata,
       auto_advance: false,
       paid: true,
       paid_out_of_band: false,
@@ -839,6 +860,32 @@ export async function ensureStakeInvoice(
   }
 }
 
+export async function getStakeInvoiceForSubscription(subscriptionId: string, currencyId: string) {
+  const where: WhereOptions = {
+    [Op.or]: [
+      { subscription_id: subscriptionId },
+      { 'metadata.all_subscription_ids': { [Op.contains]: [subscriptionId] } },
+    ],
+    billing_reason: 'stake',
+    status: 'paid',
+  };
+
+  if (currencyId) {
+    where.currency_id = currencyId;
+  }
+  try {
+    const invoice = await Invoice.findOne({ where });
+    return invoice;
+  } catch (error) {
+    logger.error('getStakeInvoiceForSubscription: find invoice failed', {
+      error,
+      subscriptionId,
+      currencyId,
+    });
+    return null;
+  }
+}
+
 // mark overdraft protection invoice as void after payment
 export async function handleOverdraftProtectionInvoiceAfterPayment(invoice: Invoice) {
   try {
@@ -960,7 +1007,7 @@ export async function retryUncollectibleInvoices(options: {
 
     const { customerId, subscriptionId, invoiceId, invoiceIds, currencyId } = options;
 
-    const where: any = {
+    const where: WhereOptions = {
       status: { [Op.in]: ['uncollectible'] },
       payment_intent_id: { [Op.ne]: null },
     };

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

@@ -1,12 +1,20 @@
 import { Notification as BlockletNotification } from '@blocklet/sdk';
 
 import type { BaseEmailTemplate, BaseEmailTemplateType } from './template/base';
+import { CheckoutSession, Invoice, Subscription } from '../../store/models';
+import { getNotificationSettings, shouldSendSystemNotification } from '../setting';
+import logger from '../logger';
+import { events } from '../event';
+import { createFlexibleEvent } from '../audit';
 
 export class Notification {
   template: BaseEmailTemplate;
-
-  constructor(template: BaseEmailTemplate) {
+  type?: string;
+  constructor(template: BaseEmailTemplate, type?: string) {
     this.template = template;
+    if (type) {
+      this.type = type;
+    }
   }
 
   async send() {
@@ -16,8 +24,68 @@ export class Notification {
       return;
     }
 
-    const { userDid } = await this.template.getContext();
-
+    const context = await this.template.getContext();
+    const { userDid } = context;
+    try {
+      const entity = await this.getEntityFromOptions(this.template.options);
+      if (entity) {
+        const settings = await getNotificationSettings(entity);
+        const shouldSend = shouldSendSystemNotification(this.type as string, settings);
+        if (!shouldSend) {
+          logger.info('Notification will not be sent', {
+            type: this.type,
+            entity,
+          });
+          try {
+            await createFlexibleEvent('manual.notification', 'notification', entity.id, {
+              type: this.type,
+              data: {
+                entity,
+                userDid,
+                context,
+              },
+            });
+          } catch (error) {
+            logger.error('Create flexible event error', error);
+            events.emit('manual.notification', {
+              type: this.type,
+              data: {
+                entity,
+                userDid,
+                context,
+              },
+            });
+          }
+          return;
+        }
+      }
+    } catch (error) {
+      logger.error('Check notification settings error', error);
+    }
     await BlockletNotification.sendToUser(userDid, template as any);
   }
+  private async getEntityFromOptions(options: Record<string, any>) {
+    if (options.subscriptionId) {
+      const subscription = await Subscription.findByPk(options.subscriptionId);
+      if (subscription) {
+        return { subscription, id: subscription.id };
+      }
+    }
+
+    if (options.invoiceId) {
+      const invoice = await Invoice.findByPk(options.invoiceId);
+      if (invoice) {
+        return { invoice, id: invoice.id };
+      }
+    }
+
+    if (options.checkoutSessionId) {
+      const checkoutSession = await CheckoutSession.findByPk(options.checkoutSessionId);
+      if (checkoutSession) {
+        return { checkoutSession, id: checkoutSession.id };
+      }
+    }
+
+    return null;
+  }
 }

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

@@ -9,4 +9,6 @@ export interface BaseEmailTemplate<C = BaseEmailTemplateContext> {
   getTemplate(): Promise<BaseEmailTemplateType | null>;
 
   getContext(): Promise<C>;
+
+  options: Record<string, any>;
 }

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

@@ -96,11 +96,7 @@ export class SubscriptionRenewFailedEmailTemplate
       },
     })) as PaymentCurrency;
 
-    const checkoutSession = await CheckoutSession.findOne({
-      where: {
-        subscription_id: subscription.id,
-      },
-    });
+    const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);

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

@@ -87,11 +87,7 @@ export class SubscriptionRenewedEmailTemplate implements BaseEmailTemplate<Subsc
       },
     })) as PaymentCurrency;
 
-    const checkoutSession = await CheckoutSession.findOne({
-      where: {
-        subscription_id: subscription.id,
-      },
-    });
+    const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);
     const productName = await getMainProductName(subscription.id);

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

@@ -77,19 +77,13 @@ export class SubscriptionSucceededEmailTemplate
 
     await pWaitFor(
       async () => {
-        const [checkoutSession, invoice] = await Promise.all([
-          CheckoutSession.findOne({
-            where: {
-              subscription_id: subscription.id,
-            },
-          }),
-          Invoice.findOne({
-            where: {
-              subscription_id: subscription.id,
-            },
-            order: [['created_at', 'ASC']],
-          }),
-        ]);
+        const invoice = await Invoice.findOne({
+          where: {
+            subscription_id: subscription.id,
+          },
+          order: [['created_at', 'ASC']],
+        });
+        const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
         return Boolean(
           ['disabled', 'minted', 'sent', 'error'].includes(checkoutSession?.nft_mint_status as string) &&
@@ -106,11 +100,7 @@ export class SubscriptionSucceededEmailTemplate
       },
     })) as PaymentCurrency;
 
-    const checkoutSession = await CheckoutSession.findOne({
-      where: {
-        subscription_id: subscription.id,
-      },
-    });
+    const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);

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

@@ -78,11 +78,7 @@ export class SubscriptionTrialStartEmailTemplate
 
     await pWaitFor(
       async () => {
-        const checkoutSession = await CheckoutSession.findOne({
-          where: {
-            subscription_id: subscription.id,
-          },
-        });
+        const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
         return ['minted', 'sent', 'error', 'disabled'].includes(checkoutSession?.nft_mint_status as string);
       },
       { timeout: 1000 * 10, interval: 1000 }
@@ -101,11 +97,7 @@ export class SubscriptionTrialStartEmailTemplate
 
     const oneTimeProductInfo = await getOneTimeProductInfo(subscription.latest_invoice_id as string, paymentCurrency);
 
-    const checkoutSession = await CheckoutSession.findOne({
-      where: {
-        subscription_id: subscription.id,
-      },
-    });
+    const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);

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

@@ -76,11 +76,7 @@ export class SubscriptionUpgradedEmailTemplate implements BaseEmailTemplate<Subs
       },
     })) as PaymentCurrency;
 
-    const checkoutSession = await CheckoutSession.findOne({
-      where: {
-        subscription_id: subscription.id,
-      },
-    });
+    const checkoutSession = await CheckoutSession.findBySubscriptionId(subscription.id);
 
     const userDid: string = customer.did;
     const locale = await getUserLocale(userDid);