@coopenomics/notifications 2025.11.8

package/src/utils/slugify/slugify.ts

@@ -0,0 +1,284 @@
+/* cspell:disable */
+/*
+ * 15/11/2024
+ *
+ * Slugify a string.
+ *
+ * Original code: https://github.com/simov/slugify
+ * Enhanced code with custom replacements: https://gist.github.com/glorat/5070ebd2fa275e2012a51300329a7a55
+ */
+
+import { transliterate } from './transliterate';
+
+const builtinOverridableReplacements = [
+  ['&', ' and '],
+  ['🦄', ' unicorn '],
+  ['♥', ' love '],
+];
+
+const matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+function escapeStringRegexp(str: string) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  return str.replace(matchOperatorsRe, '\\$&');
+}
+
+interface Options {
+  /**
+   *@default '-'
+   *@example
+   *```
+   *import slugify from '@novu/shared';
+   *slugify('BAR and baz');
+   * //=> 'bar-and-baz'
+   *slugify('BAR and baz', {separator: '_'});
+   * //=> 'bar_and_baz'
+   *slugify('BAR and baz', {separator: ''});
+   * //=> 'barandbaz'
+   *```
+   */
+  readonly separator?: string;
+
+  /**
+   *Make the slug lowercase.
+   *@default true
+   *@example
+   *```
+   *import slugify from '@novu/shared';
+   *slugify('Déjà Vu!');
+   * //=> 'deja-vu'
+   *slugify('Déjà Vu!', {lowercase: false});
+   * //=> 'Deja-Vu'
+   *```
+   */
+  readonly lowercase?: boolean;
+
+  /**
+   *Convert camelcase to separate words. Internally it does `fooBar` → `foo bar`.
+   *@default true
+   *@example
+   *```
+   *import slugify from '@novu/shared';
+   *slugify('fooBar');
+   * //=> 'foo-bar'
+   *slugify('fooBar', {decamelize: false});
+   * //=> 'foobar'
+   *```
+   */
+  readonly decamelize?: boolean;
+
+  /**
+   *Add your own custom replacements.
+   *The replacements are run on the original string before any other transformations.
+   *This only overrides a default replacement if you set an item with the same key, like `&`.
+   *Add a leading and trailing space to the replacement to have it separated by dashes.
+   *@default [ ['&', ' and '], ['🦄', ' unicorn '], ['♥', ' love '] ]
+   *@example
+   *```
+   *import slugify from '@novu/shared';
+   *slugify('Foo@unicorn', {
+   *customReplacements: [
+   *['@', 'at']
+   *]
+   *});
+   * //=> 'fooatunicorn'
+   *slugify('foo@unicorn', {
+   *customReplacements: [
+   *['@', ' at ']
+   *]
+   *});
+   * //=> 'foo-at-unicorn'
+   *slugify('I love 🐶', {
+   *customReplacements: [
+   *['🐶', 'dogs']
+   *]
+   *});
+   * //=> 'i-love-dogs'
+   *```
+   */
+  readonly customReplacements?: ReadonlyArray<[string, string]>;
+
+  /**
+   *If your string starts with an underscore, it will be preserved in the slugified string.
+   *Sometimes leading underscores are intentional, for example, filenames representing hidden paths on a website.
+   *@default false
+   *@example
+   *```
+   *import slugify from '@novu/shared';
+   *slugify('_foo_bar');
+   * //=> 'foo-bar'
+   *slugify('_foo_bar', {preserveLeadingUnderscore: true});
+   * //=> '_foo-bar'
+   *```
+   */
+  readonly preserveLeadingUnderscore?: boolean;
+
+  /**
+   *If your string ends with a dash, it will be preserved in the slugified string.
+   *For example, using slugify on an input field would allow for validation while not preventing the user from writing a slug.
+   *@default false
+   *@example
+   *```
+   *import slugify from '@novu/shared';
+   *slugify('foo-bar-');
+   * //=> 'foo-bar'
+   *slugify('foo-bar-', {preserveTrailingDash: true});
+   * //=> 'foo-bar-'
+   *```
+   */
+  readonly preserveTrailingDash?: boolean;
+}
+
+const decamelize = (string: string) => {
+  return (
+    string
+      // Separate capitalized words.
+      .replace(/([A-Z]{2,})(\d+)/g, '$1 $2')
+      .replace(/([a-z\d]+)([A-Z]{2,})/g, '$1 $2')
+
+      .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+      /*
+       * `[a-rt-z]` matches all lowercase characters except `s`.
+       * This avoids matching plural acronyms like `APIs`.
+       */
+      .replace(/([A-Z]+)([A-Z][a-rt-z\d]+)/g, '$1 $2')
+  );
+};
+
+const removeMootSeparators = (string: string, separator: string) => {
+  const escapedSeparator = escapeStringRegexp(separator);
+
+  return string
+    .replace(new RegExp(`${escapedSeparator}{2,}`, 'g'), separator)
+    .replace(new RegExp(`^${escapedSeparator}|${escapedSeparator}$`, 'g'), '');
+};
+
+/**
+ * Slugify a string.
+ *
+ * Default behavior:
+ * - decamelize
+ * - lowercase
+ * - remove duplicates of the separator character
+ * - remove trailing spaces
+ * - remove special characters
+ * - multilanguage support
+ * - emojis support
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('Hello World');
+ * //=> 'hello-world'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('Hello World', { separator: '_' });
+ * //=> 'hello_world'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('αβγ');
+ * //=> 'avg'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('💯-1️⃣-2️⃣-3️⃣');
+ * //=> '100-1-2-3'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('camelCase', { decamelize: true });
+ * //=> 'camel-case'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('Hello World', { lowercase: false });
+ * //=> 'Hello-World'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('foo@unicorn', { preserveLeadingUnderscore: true });
+ * //=> '_foo-at-unicorn'
+ * ```
+ *
+ * @example
+ * ```
+ * import { slugify } from '@novu/shared';
+ * slugify('foo-bar-', { preserveTrailingDash: true });
+ * //=> 'foo-bar-'
+ * ```
+ */
+export const slugify = (string: string, options?: Options) => {
+  if (typeof string !== 'string') {
+    throw new TypeError(`Expected a string, got \`${typeof string}\``);
+  }
+
+  options = {
+    separator: '-',
+    lowercase: true,
+    decamelize: true,
+    customReplacements: [],
+    preserveLeadingUnderscore: false,
+    preserveTrailingDash: false,
+    ...options,
+  };
+
+  const shouldPrependUnderscore = options.preserveLeadingUnderscore && string.startsWith('_');
+  const shouldAppendDash = options.preserveTrailingDash && string.endsWith('-');
+
+  const customReplacements = new Map([
+    ...(builtinOverridableReplacements as [string, string][]),
+    ...(options.customReplacements as [string, string][]),
+  ]);
+
+  string = transliterate(string, { customReplacements: Array.from(customReplacements) });
+
+  if (options.decamelize) {
+    string = decamelize(string);
+  }
+
+  let patternSlug = /[^a-zA-Z\d]+/g;
+
+  if (options.lowercase) {
+    string = string.toLowerCase();
+    patternSlug = /[^a-z\d]+/g;
+  }
+
+  string = string.replace(patternSlug, options.separator ?? '-');
+  string = string.replace(/\\/g, '');
+
+  /*
+   * Detect contractions/possessives by looking for any word followed by a `-t`
+   * or `-s` in isolation and then remove it.
+   */
+  string = string.replace(/([a-zA-Z\d]+)-([ts])(-|$)/g, '$1$2$3');
+
+  if (options.separator) {
+    string = removeMootSeparators(string, options.separator);
+  }
+
+  if (shouldPrependUnderscore) {
+    string = `_${string}`;
+  }
+
+  if (shouldAppendDash) {
+    string = `${string}-`;
+  }
+
+  return string;
+};

package/src/utils/slugify/transliterate.ts

@@ -0,0 +1,48 @@
+import { builtinReplacements } from './builtinReplacements';
+
+const matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
+function escapeStringRegexp(str: string) {
+  if (typeof str !== 'string') {
+    throw new TypeError('Expected a string');
+  }
+
+  return str.replace(matchOperatorsRe, '\\$&');
+}
+
+const doCustomReplacements = (string: string, replacements: Map<string, string>) => {
+  for (const [key, value] of replacements) {
+    // TODO: Use `String#replaceAll()` when targeting Node.js 16.
+    string = string.replace(new RegExp(escapeStringRegexp(key), 'g'), value);
+  }
+
+  return string;
+};
+
+type TransliterateOptions = {
+  customReplacements: [string, string][];
+};
+
+export const transliterate = (string: string, options: TransliterateOptions) => {
+  if (typeof string !== 'string') {
+    throw new TypeError(`Expected a string, got \`${typeof string}\``);
+  }
+
+  options = {
+    ...options,
+    customReplacements: options.customReplacements || [],
+  };
+
+  const customReplacements = new Map<string, string>([
+    ...(builtinReplacements as [string, string][]),
+    ...(options.customReplacements as [string, string][]),
+  ]);
+
+  string = string.normalize();
+  string = doCustomReplacements(string, customReplacements);
+  string = string
+    .normalize('NFD')
+    .replace(/\p{Diacritic}/gu, '')
+    .normalize();
+
+  return string;
+};

package/src/workflows/approval-request/index.ts

@@ -0,0 +1,52 @@
+
+import { WorkflowDefinition } from '../../types';
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { z } from 'zod';
+import { BaseWorkflowPayload } from '../../types';
+import { createEmailStep, createInAppStep, createPushStep } from '../../base/defaults';
+import { slugify } from '../../utils';
+
+// Схема для approval-request воркфлоу
+export const approvalRequestPayloadSchema = z.object({
+  chairmanName: z.string(),
+  requestTitle: z.string(),
+  requestDescription: z.string(),
+  authorName: z.string(),
+  coopname: z.string(),
+  approval_hash: z.string(),
+  approvalUrl: z.string().optional(),
+});
+
+export type IPayload = z.infer<typeof approvalRequestPayloadSchema>;
+
+export interface IWorkflow extends BaseWorkflowPayload, IPayload {}
+
+export const name = 'Запрос на одобрение председателя'
+export const id = slugify(name);
+
+export const workflow: WorkflowDefinition<IWorkflow> = WorkflowBuilder
+  .create<IWorkflow>()
+  .name(name)
+  .workflowId(id)
+  .description('Уведомление председателю совета о новом запросе на одобрение')
+  .payloadSchema(approvalRequestPayloadSchema)
+  .tags(['chairman']) // Только для председателя
+  .addSteps([
+    createEmailStep(
+      'approval-request-email',
+      'Новый запрос на одобрение действия: {{payload.requestTitle}}',
+      'Уважаемый {{payload.chairmanName}}!<br><br>Поступил новый запрос на одобрение:<br><br><strong>{{payload.requestTitle}}</strong><br><br>{{payload.requestDescription}}<br><br>Автор запроса: {{payload.authorName}}<br><br>Ссылка для одобрения или отклонения запроса: {{payload.approvalUrl}}'
+    ),
+    createInAppStep(
+      'approval-request-notification',
+      'Новый запрос на одобрение действия',
+      'Запрос: {{payload.requestTitle}}<br>Автор: {{payload.authorName}}'
+    ),
+    createPushStep(
+      'approval-request-push',
+      'Новый запрос на одобрение действия',
+      'Запрос: {{payload.requestTitle}} от {{payload.authorName}}'
+    ),
+  ])
+  .build();
+

package/src/workflows/approval-response/index.ts

@@ -0,0 +1,54 @@
+import { WorkflowDefinition } from '../../types';
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { z } from 'zod';
+import { BaseWorkflowPayload } from '../../types';
+import { createEmailStep, createInAppStep, createPushStep } from '../../base/defaults';
+import { slugify } from '../../utils';
+
+// Схема для approval-response воркфлоу
+export const approvalResponsePayloadSchema = z.object({
+  userName: z.string(),
+  approvalStatus: z.enum(['approved', 'declined']),
+  approvalStatusText: z.string(),
+  approvalId: z.string(),
+  coopname: z.string(),
+  coopShortName: z.string(),
+  approvalUrl: z.string().optional(),
+});
+
+export type IPayload = z.infer<typeof approvalResponsePayloadSchema>;
+
+export interface IWorkflow extends BaseWorkflowPayload, IPayload {}
+
+export const name = 'Ответ на запрос одобрения';
+export const id = slugify(name);
+
+export const workflow: WorkflowDefinition<IWorkflow> = WorkflowBuilder
+  .create<IWorkflow>()
+  .name(name)
+  .workflowId(id)
+  .description('Уведомление пользователю об одобрении или отклонении его запроса председателем')
+  .payloadSchema(approvalResponsePayloadSchema)
+  .tags(['user']) // Для всех пользователей
+  .addSteps([
+    createEmailStep(
+      'approval-response-email',
+      'Ваш запрос {{payload.approvalStatusText}} председателем совета',
+      `Уважаемый {{payload.userName}}!
+
+Ваш запрос {{payload.approvalId}} {{payload.approvalStatusText}} председателем совета {{payload.coopShortName}}.
+
+Подробнее по ссылке: {{payload.approvalUrl}}`
+    ),
+    createInAppStep(
+      'approval-response-notification',
+      'Ответ на запрос одобрения',
+      'Ваш запрос {{payload.approvalId}} {{payload.approvalStatusText}} председателем совета {{payload.coopShortName}}'
+    ),
+    createPushStep(
+      'approval-response-push',
+      'Ответ на запрос одобрения',
+      'Запрос {{payload.approvalId}} {{payload.approvalStatusText}}'
+    ),
+  ])
+  .build();

package/src/workflows/decision-approved/index.ts

@@ -0,0 +1,50 @@
+
+import { WorkflowDefinition } from '../../types';
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { z } from 'zod';
+import { BaseWorkflowPayload } from '../../types';
+import { createEmailStep, createInAppStep, createPushStep } from '../../base/defaults';
+import { slugify } from '../../utils';
+
+// Схема для decision-approved воркфлоу
+export const decisionApprovedPayloadSchema = z.object({
+  userName: z.string(),
+  decisionTitle: z.string(),
+  coopname: z.string(),
+  decision_id: z.string(),
+  decisionUrl: z.string().optional(),
+});
+
+export type IPayload = z.infer<typeof decisionApprovedPayloadSchema>;
+
+export interface IWorkflow extends BaseWorkflowPayload, IPayload {}
+
+export const name = 'Решение совета принято';
+export const id = slugify(name);
+
+export const workflow: WorkflowDefinition<IWorkflow> = WorkflowBuilder
+  .create<IWorkflow>()
+  .name(name)
+  .workflowId(id)
+  .description('Уведомление пользователю о принятии решения совета по его вопросу')
+  .payloadSchema(decisionApprovedPayloadSchema)
+  .tags(['user']) // Для всех пользователей
+  .addSteps([
+    createEmailStep(
+      'decision-approved-email',
+      'Решение совета принято по вашему вопросу',
+      'Уважаемый {{payload.userName}}!<br><br>Совет кооператива принял решение по вашему вопросу:<br><br><strong>{{payload.decisionTitle}}</strong><br><br>Ссылка для просмотра подробной информации: {{payload.decisionUrl}}'
+    ),
+    createInAppStep(
+      'decision-approved-notification',
+      'Решение совета принято',
+      'По вашему вопросу принято решение: {{payload.decisionTitle}}'
+    ),
+    createPushStep(
+      'decision-approved-push',
+      'Решение совета принято',
+      'Принято решение: {{payload.decisionTitle}}'
+    ),
+  ])
+  .build();
+

package/src/workflows/email-verification/index.ts

@@ -0,0 +1,35 @@
+import { WorkflowDefinition, type BaseWorkflowPayload } from '../../types';
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { createEmailStep } from '../../base/defaults';
+import { z } from 'zod';
+import { slugify } from '../../utils';
+
+// Схема для email-verification воркфлоу
+export const emailVerificationPayloadSchema = z.object({
+  verificationUrl: z.string(),
+});
+
+export type IPayload = z.infer<typeof emailVerificationPayloadSchema>;
+
+export interface IWorkflow extends BaseWorkflowPayload, IPayload {}
+
+export const name = 'Верификация Email';
+export const id = slugify(name);
+
+export const workflow: WorkflowDefinition<IWorkflow> = WorkflowBuilder
+  .create<IWorkflow>()
+  .name(name)
+  .workflowId(id)
+  .description('Верификация email адреса пользователя')
+  .payloadSchema(emailVerificationPayloadSchema)
+  .tags(['auth'])
+  .addSteps([
+    createEmailStep(
+      'email-verification-email',
+      'Email Verification',
+      'Dear user,<br><br>' +
+      'To verify your email, click on this link: <a href="{{payload.verificationUrl}}">{{payload.verificationUrl}}</a><br><br>' +
+      'If you did not create an account, then ignore this email.'
+    ),
+  ])
+  .build();

package/src/workflows/incoming-transfer/index.ts

@@ -0,0 +1,43 @@
+import { WorkflowDefinition, type BaseWorkflowPayload } from '../../types';
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { createEmailStep, createInAppStep, createPushStep } from '../../base/defaults';
+import { z } from 'zod';
+import { slugify } from '../../utils';
+
+// Схема для incoming-transfer воркфлоу
+export const incomingTransferPayloadSchema = z.object({
+  quantity: z.string(),
+});
+
+export type IPayload = z.infer<typeof incomingTransferPayloadSchema>;
+
+export interface IWorkflow extends BaseWorkflowPayload, IPayload {}
+
+export const name = 'Входящий перевод';
+export const id = slugify(name);
+
+export const workflow: WorkflowDefinition<IWorkflow> = WorkflowBuilder
+  .create<IWorkflow>()
+  .name(name)
+  .workflowId(id)
+  .description('Уведомление о получении входящего перевода')
+  .payloadSchema(incomingTransferPayloadSchema)
+  .tags(['user']) // Доступно для всех ролей
+  .addSteps([
+    createEmailStep(
+      'incoming-transfer-email',
+      'Получен входящий перевод на сумму {{payload.quantity}}',
+      'Уведомляем вас о получении входящего перевода.<br><br><strong>Сумма перевода: {{payload.quantity}}</strong><br><br>Перевод успешно зачислен на ваш счет.'
+    ),
+    createInAppStep(
+      'incoming-transfer-notification',
+      'Входящий перевод',
+      'Получен входящий перевод на сумму {{payload.quantity}}'
+    ),
+    createPushStep(
+      'incoming-transfer-push',
+      'Входящий перевод',
+      'Получен перевод на сумму {{payload.quantity}}'
+    ),
+  ])
+  .build(); 

package/src/workflows/index.ts

@@ -0,0 +1,74 @@
+import { WorkflowDefinition } from '../types';
+// Импорты воркфлоу для регистрации
+import { workflow as welcomeWorkflow } from './welcome';
+import { workflow as newAgendaItemWorkflow } from './new-agenda-item';
+import { workflow as incomingTransferWorkflow } from './incoming-transfer';
+import { workflow as approvalRequestWorkflow } from './approval-request';
+import { workflow as decisionApprovedWorkflow } from './decision-approved';
+import { workflow as paymentPaidWorkflow } from './payment-paid';
+import { workflow as paymentCancelledWorkflow } from './payment-cancelled';
+import { workflow as meetInitialWorkflow } from './meet-initial';
+import { workflow as meetReminderStartWorkflow } from './meet-reminder-start';
+import { workflow as meetStartedWorkflow } from './meet-started';
+import { workflow as meetReminderEndWorkflow } from './meet-reminder-end';
+import { workflow as meetRestartWorkflow } from './meet-restart';
+import { workflow as meetEndedWorkflow } from './meet-ended';
+import { workflow as approvalResponseWorkflow } from './approval-response';
+import { workflow as newInitialPaymentRequestWorkflow } from './new-initial-payment-request';
+import { workflow as newDepositPaymentRequestWorkflow } from './new-deposit-payment-request';
+import { workflow as resetKeyWorkflow } from './reset-key';
+import { workflow as inviteWorkflow } from './invite';
+import { workflow as emailVerificationWorkflow } from './email-verification';
+import { workflow as serverProvisionedWorkflow } from './server-provisioned';
+
+// Импортируем все воркфлоу
+export * as Welcome from './welcome';
+export * as NewAgenda from './new-agenda-item';
+export * as NewTransfer from './incoming-transfer';
+export * as ApprovalRequest from './approval-request';
+export * as DecisionApproved from './decision-approved';
+export * as PaymentPaid from './payment-paid';
+export * as PaymentCancelled from './payment-cancelled';
+export * as MeetInitial from './meet-initial';
+export * as MeetReminderStart from './meet-reminder-start';
+export * as MeetStarted from './meet-started';
+export * as MeetReminderEnd from './meet-reminder-end';
+export * as MeetRestart from './meet-restart';
+export * as MeetEnded from './meet-ended';
+export * as ApprovalResponse from './approval-response';
+export * as NewInitialPaymentRequest from './new-initial-payment-request';
+export * as NewDepositPaymentRequest from './new-deposit-payment-request';
+export * as ResetKey from './reset-key';
+export * as Invite from './invite';
+export * as EmailVerification from './email-verification';
+export * as ServerProvisioned from './server-provisioned';
+
+// Массив всех воркфлоу для автоматической регистрации
+export const allWorkflows: WorkflowDefinition[] = [
+  welcomeWorkflow,
+  newAgendaItemWorkflow,
+  incomingTransferWorkflow,
+  approvalRequestWorkflow,
+  decisionApprovedWorkflow,
+  paymentPaidWorkflow,
+  paymentCancelledWorkflow,
+  meetInitialWorkflow,
+  meetReminderStartWorkflow,
+  meetStartedWorkflow,
+  meetReminderEndWorkflow,
+  meetRestartWorkflow,
+  meetEndedWorkflow,
+  approvalResponseWorkflow,
+  newInitialPaymentRequestWorkflow,
+  newDepositPaymentRequestWorkflow,
+  resetKeyWorkflow,
+  inviteWorkflow,
+  emailVerificationWorkflow,
+  serverProvisionedWorkflow,
+];
+
+// Экспортируем воркфлоу по ID для удобного доступа
+export const workflowsById = allWorkflows.reduce((acc, workflow) => {
+  acc[workflow.workflowId] = workflow;
+  return acc;
+}, {} as Record<string, WorkflowDefinition>);

package/src/workflows/invite/index.ts

@@ -0,0 +1,34 @@
+import { WorkflowDefinition, type BaseWorkflowPayload } from '../../types';
+import { WorkflowBuilder } from '../../base/workflow-builder';
+import { createEmailStep } from '../../base/defaults';
+import { z } from 'zod';
+import { slugify } from '../../utils';
+
+// Схема для invite воркфлоу
+export const invitePayloadSchema = z.object({
+  inviteUrl: z.string(),
+});
+
+export type IPayload = z.infer<typeof invitePayloadSchema>;
+
+export interface IWorkflow extends BaseWorkflowPayload, IPayload {}
+
+export const name = 'Приглашение в кооператив';
+export const id = slugify(name);
+
+export const workflow: WorkflowDefinition<IWorkflow> = WorkflowBuilder
+  .create<IWorkflow>()
+  .name(name)
+  .workflowId(id)
+  .description('Приглашение на подключение к цифровому кооперативу')
+  .payloadSchema(invitePayloadSchema)
+  .tags(['auth'])
+  .addSteps([
+    createEmailStep(
+      'invite-email',
+      'Приглашение в Цифровой Кооператив',
+      'Вам отправлено приглашение на подключение к Цифровому Кооперативу в качестве действующего пайщика.<br><br>' +
+      'Для того, чтобы воспользоваться приглашением и получить ключ доступа, пожалуйста, перейдите по ссылке: <a href="{{payload.inviteUrl}}">{{payload.inviteUrl}}</a>'
+    ),
+  ])
+  .build();