@erxes/api-shared 0.0.0-stage → 3.2.19-2

package/src/utils/constants.ts

@@ -0,0 +1,99 @@
+export const STATUSES = [
+  { label: 'Active', value: 'Active' },
+  { label: 'Deleted', value: 'Deleted' },
+];
+
+export const DEFAULT_SOCIAL_LINKS = [
+  { label: 'Facebook', value: 'facebook' },
+  { label: 'whatsapp', value: 'whatsapp' },
+  { label: 'Twitter', value: 'twitter' },
+  { label: 'Youtube', value: 'youtube' },
+  { label: 'Website', value: 'website' },
+];
+
+export const SOCIAL_LINKS = [
+  ...DEFAULT_SOCIAL_LINKS,
+  { label: 'Academia.edu', value: 'academia.edu' },
+  { label: 'Chess.com', value: 'chess.com' },
+  { label: 'Crunchyroll', value: 'crunchyroll' },
+  { label: 'DeviantArt', value: 'deviantArt' },
+  { label: 'Discord', value: 'discord' },
+  { label: 'Douban', value: 'douban' },
+  { label: 'eToro', value: 'eToro' },
+  { label: 'Flickr', value: 'flickr' },
+  { label: 'Gapo', value: 'gapo' },
+  { label: 'Goodreads', value: 'goodreads' },
+  { label: 'GitHub', value: 'gitHub' },
+  { label: 'Instagram', value: 'instagram' },
+  { label: 'KakaoStory', value: 'kakaoStory' },
+  { label: 'KizlarSoruyor', value: 'kizlarSoruyor' },
+  { label: 'Last.fm', value: 'last.fm' },
+  { label: 'LinkedIn', value: 'linkedIn' },
+  { label: 'LiveJournal', value: 'liveJournal' },
+  { label: 'Pinterest', value: 'pinterest' },
+  { label: 'Pixnet', value: 'pixnet' },
+  { label: 'Plurk', value: 'plurk' },
+  { label: 'Quora', value: 'quora' },
+  { label: 'Reddit', value: 'reddit' },
+  { label: 'Renren', value: 'renren' },
+  { label: 'Sina Weibo', value: 'sinaWeibo' },
+  { label: 'SoundCloud', value: 'soundCloud' },
+  { label: 'Spotify', value: 'spotify' },
+  { label: 'Steam', value: 'steam' },
+  { label: 'Tagged', value: 'tagged' },
+  { label: 'Taringa', value: 'taringa' },
+  { label: 'Tumblr', value: 'tumblr' },
+  { label: 'VK', value: 'vk' },
+  { label: 'Voat', value: 'voat' },
+  { label: 'Wattpad', value: 'wattpad' },
+  { label: 'XING', value: 'xing' },
+  { label: 'Yammer', value: 'yammer' },
+  { label: 'Yelp', value: 'yelp' },
+];
+
+export const DEFAULT_SEX_CHOICES = [
+  { label: 'Not known', value: 0 },
+  { label: 'Male', value: 1 },
+  { label: 'Female', value: 2 },
+  { label: 'Not applicable', value: 9 },
+];
+
+export const SEX_OPTIONS = [
+  ...DEFAULT_SEX_CHOICES,
+  { label: 'co/co', value: 10 },
+  { label: 'en/en', value: 11 },
+  { label: 'ey/em', value: 12 },
+  { label: 'he/him', value: 13 },
+  { label: 'he/them', value: 14 },
+  { label: 'she/her', value: 15 },
+  { label: 'she/them', value: 16 },
+  { label: 'they/them', value: 17 },
+  { label: 'xie/hir', value: 18 },
+  { label: 'yo/yo', value: 19 },
+  { label: 'ze/zir', value: 20 },
+  { label: 've/vis', value: 21 },
+  { label: 'xe/xem', value: 22 },
+];
+
+export const USER_ROLES = {
+  SYSTEM: 'system',
+  USER: 'user',
+  ALL: ['system', 'user'],
+};
+
+export const LOG_STATUSES = {
+  FAILED: 'failed',
+  SUCCESS: 'success',
+};
+
+export const CONFORMITY_TYPE = {
+  customers: 'customer',
+  companies: 'company',
+};
+
+export const PERMISSION_ROLES = {
+  OWNER: 'owner',
+  ADMIN: 'admin',
+  MEMBER: 'member',
+  ALL: ['owner', 'admin', 'member'],
+};

package/src/utils/editor.ts

@@ -0,0 +1,412 @@
+import { keyBy } from 'lodash';
+import { IBrand, ICustomer, IProduct, IUser } from '../core-types';
+import { isValidURL } from './string';
+import { sendTRPCMessage } from './trpc';
+
+export interface IReplacer {
+  key: string;
+  value: string;
+}
+
+export interface IArgs {
+  content: string;
+  customer?: any;
+  user?: IUser;
+  customerFields?: string[];
+  item?: any;
+  brand?: IBrand;
+}
+
+export interface ICustomerField {
+  _id: number;
+  name: string;
+  group?: string;
+  label?: string;
+  type?: string;
+  validation?: string;
+  options?: string[];
+  selectOptions?: Array<{ label: string; value: string }>;
+}
+
+export const getCustomerName = (customer: ICustomer) => {
+  if (customer.firstName || customer.lastName) {
+    return (customer.firstName || '') + ' ' + (customer.lastName || '');
+  }
+
+  if (customer.primaryEmail || customer.primaryPhone) {
+    return customer.primaryEmail || customer.primaryPhone;
+  }
+
+  const { visitorContactInfo } = customer;
+
+  if (visitorContactInfo) {
+    return visitorContactInfo.phone || visitorContactInfo.email;
+  }
+
+  return 'Unknown';
+};
+
+export function runReplacersOn(
+  content: string,
+  replacers: IReplacer[] = [],
+): string {
+  let replacedContent = content;
+
+  for (const replacer of replacers) {
+    const regex = new RegExp(replacer.key, 'gi');
+
+    replacedContent = replacedContent.replace(regex, replacer.value);
+  }
+
+  return replacedContent;
+}
+
+export class EditorAttributeUtil {
+  private _possibleCustomerFields?: ICustomerField[];
+  private API_DOMAIN: string;
+  private availableServices: Set<string>;
+  private subdomain: string;
+
+  constructor(
+    API_DOMAIN: string,
+    availableServices: string[],
+    subdomain: string,
+  ) {
+    this.API_DOMAIN = API_DOMAIN;
+    this.availableServices = new Set(availableServices);
+    this.subdomain = subdomain || 'os';
+  }
+
+  async fileToFileLink(url?: string, name?: string): Promise<string> {
+    if (!url) {
+      return '';
+    }
+
+    let href: string;
+    if (isValidURL(url) || url.includes('/')) {
+      href = url;
+    } else {
+      const key = url;
+      const uriName = name ? encodeURIComponent(name) : url;
+      href = `${this.API_DOMAIN}/read-file?key=${key}&name=${uriName}`;
+    }
+
+    return `<a target="_blank" download href="${href}">${name || url}</a>`;
+  }
+
+  async customFieldsDataItemToFileLink(
+    customFieldDataItem: any,
+  ): Promise<string> {
+    const value = customFieldDataItem.value;
+
+    if (Array.isArray(value)) {
+      const links = await Promise.all(
+        value.map((v) => this.fileToFileLink(v.url, v.name)),
+      );
+      return links.join(' | ');
+    }
+
+    return this.fileToFileLink(value.url, value.name);
+  }
+
+  async getPossibleCustomerFields(): Promise<ICustomerField[]> {
+    this._possibleCustomerFields ??= await sendTRPCMessage({
+      subdomain: this.subdomain,
+
+      pluginName: 'core',
+      method: 'query',
+      module: 'fields',
+      action: 'fieldsCombinedByContentType',
+      input: {
+        contentType: 'core:customer',
+      },
+    });
+
+    if (!this._possibleCustomerFields) {
+      throw new Error('Cannot acquire possibleCustomerFields');
+    }
+
+    return this._possibleCustomerFields || [];
+  }
+
+  async getCustomerFields(content: string): Promise<string[]> {
+    const customerFields = ['firstName', 'lastName', 'middleName'];
+    const possibleCustomerFields = await this.getPossibleCustomerFields();
+
+    for (const field of possibleCustomerFields) {
+      if (!content.includes(`{{ customer.${field.name} }}`)) {
+        continue;
+      }
+
+      if (field.name.includes('trackedData')) {
+        customerFields.push('trackedData');
+        continue;
+      }
+
+      if (field.name.includes('customFieldsData')) {
+        customerFields.push('customFieldsData');
+        continue;
+      }
+
+      customerFields.push(field.name);
+    }
+
+    return customerFields;
+  }
+
+  async fillMissingCustomFieldsDataItemOfCustomer(
+    content: string,
+    customer: any,
+  ): Promise<void> {
+    if (!customer.customFieldsData) {
+      customer.customFieldsData = [];
+    }
+
+    const existingItemsByFieldId = keyBy(customer.customFieldsData, 'field');
+
+    const possibleCustomerFields = await this.getPossibleCustomerFields();
+
+    for (const field of possibleCustomerFields) {
+      if (!content.includes(`{{ customer.${field.name} }}`)) {
+        continue;
+      }
+
+      if (field.name.includes('customFieldsData')) {
+        const fieldId = field.name.split('.').pop();
+
+        // if content has attribute that doesn't have fieldId, fill with dummy item
+        // if content has field attribute that doesn't exist on the customer.customFieldsData, fill with dummy item
+        if (!fieldId || !existingItemsByFieldId[fieldId]) {
+          customer.customFieldsData.push({
+            field: fieldId || '',
+            stringValue: '',
+            value: '',
+          });
+        }
+      }
+    }
+  }
+
+  async generateAmounts(productsData: IProduct[]) {
+    if (!this.availableServices.has('sales')) {
+      throw new Error('Sales service is not running.');
+    }
+    return sendTRPCMessage({
+      subdomain: this.subdomain,
+      pluginName: 'sales',
+      method: 'query',
+      module: 'deal',
+      action: 'generateAmounts',
+      input: productsData,
+    });
+  }
+
+  async generateProducts(productsData: IProduct[]): Promise<any> {
+    if (!this.availableServices.has('sales')) {
+      throw new Error('Sales service is not running.');
+    }
+
+    return sendTRPCMessage({
+      subdomain: this.subdomain,
+      pluginName: 'sales',
+      method: 'query',
+      module: 'deal',
+      action: 'generateProducts',
+      input: productsData,
+    });
+  }
+
+  async generateReplacers(args: IArgs): Promise<IReplacer[]> {
+    const { content, user, brand, item } = args;
+    const replacers: IReplacer[] = [];
+
+    // replace customer fields
+    if (args.customer) {
+      const customer = args.customer;
+      let customerFields = args.customerFields;
+
+      if (!customerFields || customerFields.length === 0) {
+        customerFields = await this.getCustomerFields(content);
+      }
+
+      await this.fillMissingCustomFieldsDataItemOfCustomer(content, customer);
+
+      replacers.push({
+        key: '{{ customer.name }}',
+        value: getCustomerName(customer) || 'Unknown',
+      });
+
+      const fields = await sendTRPCMessage({
+        subdomain: this.subdomain,
+
+        pluginName: 'core',
+        method: 'query',
+        module: 'fields',
+        action: 'find',
+        input: {
+          query: {
+            type: 'file',
+            contentType: 'core:customer',
+          },
+        },
+      });
+
+      const customerFileFieldsById = keyBy(fields, '_id');
+
+      for (const field of customerFields) {
+        if (
+          field.includes('trackedData') ||
+          field.includes('customFieldsData')
+        ) {
+          const dbFieldName = field.includes('trackedData')
+            ? 'trackedData'
+            : 'customFieldsData';
+
+          for (const customFieldsDataItem of customer[dbFieldName] || []) {
+            const replaceValue = customerFileFieldsById[
+              customFieldsDataItem.field
+            ]
+              ? await this.customFieldsDataItemToFileLink(customFieldsDataItem)
+              : customFieldsDataItem.stringValue ||
+                customFieldsDataItem.value ||
+                '';
+
+            replacers.push({
+              key: `{{ customer.${dbFieldName}.${customFieldsDataItem.field} }}`,
+              value: replaceValue,
+            });
+          }
+
+          continue;
+        }
+
+        replacers.push({
+          key: `{{ customer.${field} }}`,
+          value: customer[field] || '',
+        });
+      }
+    }
+
+    // replace user fields
+    if (user) {
+      replacers.push({ key: '{{ user.email }}', value: user.email || '' });
+
+      if (user.details) {
+        replacers.push(
+          {
+            key: '{{ user.fullName }}',
+            value: user.details.fullName || '',
+          },
+          {
+            key: '{{ user.position }}',
+            value: user.details.position || '',
+          },
+        );
+      }
+    }
+
+    // replace brand fields
+    if (brand) {
+      replacers.push({ key: '{{ brandName }}', value: brand.name || '' });
+    }
+
+    // deal, ticket, task mapping
+    if (item) {
+      replacers.push(
+        { key: '{{ itemName }}', value: item.name || '' },
+        {
+          key: '{{ itemDescription }}',
+          value: item.description || '',
+        },
+        {
+          key: '{{ itemCloseDate }}',
+          value: item.closeDate
+            ? new Date(item.closeDate).toLocaleDateString()
+            : '',
+        },
+        {
+          key: '{{ itemCreatedAt }}',
+          value: item.createdAt
+            ? new Date(item.createdAt).toLocaleDateString()
+            : '',
+        },
+        {
+          key: '{{ itemModifiedAt }}',
+          value: item.modifiedAt
+            ? new Date(item.modifiedAt).toLocaleDateString()
+            : '',
+        },
+      );
+
+      const products = await this.generateProducts(item.productsData);
+      const amounts = await this.generateAmounts(item.productsData);
+
+      replacers.push(
+        {
+          key: '{{ dealProducts }}',
+          value: products.map((p: any) => p.product.name).join(','),
+        },
+        {
+          key: '{{ dealAmounts }}',
+          value: Object.keys(amounts)
+            .map((key) => `${amounts[key]}${key}`)
+            .join(','),
+        },
+      );
+
+      const fieldMetaDatas: any = await sendTRPCMessage({
+        subdomain: this.subdomain,
+
+        pluginName: 'core',
+        method: 'query',
+        module: 'fields',
+        action: 'find',
+        input: {
+          query: {
+            contentType: item.contentType,
+            isDefinedByErxes: false,
+          },
+        },
+      });
+
+      for (const fieldMetaData of fieldMetaDatas) {
+        const customFieldsData: any[] = item.customFieldsData || [];
+        const customFieldsDataItem = customFieldsData.find(
+          (c) => c.field === fieldMetaData._id,
+        );
+
+        const key = `{{ itemCustomField.${fieldMetaData._id} }}`;
+
+        if (!customFieldsDataItem) {
+          if (content.includes(key)) {
+            replacers.push({
+              key,
+              value: '',
+            });
+          }
+          continue;
+        }
+
+        const replaceValue =
+          fieldMetaData.type === 'file'
+            ? await this.customFieldsDataItemToFileLink(customFieldsDataItem)
+            : customFieldsDataItem.stringValue ||
+              customFieldsDataItem.value ||
+              '';
+
+        replacers.push({
+          key,
+          value: replaceValue,
+        });
+      }
+    }
+
+    return replacers;
+  }
+
+  async replaceAttributes(args: IArgs): Promise<string> {
+    const replacers: IReplacer[] = await this.generateReplacers(args);
+    const replacedContent = runReplacersOn(args.content, replacers);
+    return replacedContent;
+  }
+}

package/src/utils/email/address.ts

@@ -0,0 +1,42 @@
+export const normalizeEmail = (email: string) => email.trim().toLowerCase();
+
+export const parseAddress = (value: string) => {
+  const match = /^\s*(.*?)\s*<([^>]+)>\s*$/.exec(value || '');
+
+  return match
+    ? { name: match[1].replace(/^"|"$/g, ''), address: match[2].trim() }
+    : { name: '', address: (value || '').trim() };
+};
+
+const SPECIALS = /[()<>@,;:\\".[\]]/;
+
+const quoteName = (name: string) => {
+  const clean = name.replace(/[\r\n]/g, ' ').trim();
+
+  if (!clean) {
+    return '';
+  }
+
+  return SPECIALS.test(clean)
+    ? `"${clean.replace(/(["\\])/g, '\\$1')}"`
+    : clean;
+};
+
+export const alignSender = (
+  requested: string,
+  replyTo?: string,
+  alignedFrom?: string | null,
+): { from: string; replyTo?: string } => {
+  const reply = replyTo?.trim() || undefined;
+
+  if (!alignedFrom) {
+    return { from: requested, replyTo: reply };
+  }
+
+  const { name, address } = parseAddress(requested);
+
+  return {
+    from: `${quoteName(name) || address} <${alignedFrom}>`,
+    replyTo: reply || (address === alignedFrom ? undefined : address),
+  };
+};

package/src/utils/email/attachments.ts

@@ -0,0 +1,74 @@
+import fetch from 'node-fetch';
+import { IEmailAttachment } from './types';
+
+const DOWNLOAD_TIMEOUT_MS = 15000;
+const MAX_ATTACHMENT_BYTES = 25 * 1024 * 1024;
+
+export const toBase64Attachment = async (
+  attachment: IEmailAttachment,
+): Promise<{ filename: string; content: string; type?: string }> => {
+  if (attachment.content) {
+    return {
+      filename: attachment.filename,
+      content: attachment.content,
+      type: attachment.contentType,
+    };
+  }
+
+  if (!attachment.path) {
+    throw new Error(
+      `Attachment "${attachment.filename}" has neither "content" nor "path"`,
+    );
+  }
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
+
+  let response;
+
+  try {
+    response = await fetch(attachment.path, { signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+
+  if (!response.ok) {
+    throw new Error(
+      `Failed to download attachment "${attachment.filename}" from ${attachment.path}: ${response.status}`,
+    );
+  }
+
+  const declaredSize = Number(response.headers.get('content-length'));
+
+  if (declaredSize && declaredSize > MAX_ATTACHMENT_BYTES) {
+    throw new Error(
+      `Attachment "${attachment.filename}" exceeds the ${
+        MAX_ATTACHMENT_BYTES / (1024 * 1024)
+      }MB limit`,
+    );
+  }
+
+  const buffer = await response.buffer();
+
+  if (buffer.byteLength > MAX_ATTACHMENT_BYTES) {
+    throw new Error(
+      `Attachment "${attachment.filename}" exceeds the ${
+        MAX_ATTACHMENT_BYTES / (1024 * 1024)
+      }MB limit`,
+    );
+  }
+
+  return {
+    filename: attachment.filename,
+    content: buffer.toString('base64'),
+    type:
+      attachment.contentType ||
+      response.headers.get('content-type') ||
+      undefined,
+  };
+};
+
+export const toBase64Attachments = async (
+  attachments: IEmailAttachment[] = [],
+): Promise<Array<{ filename: string; content: string; type?: string }>> =>
+  Promise.all(attachments.map(toBase64Attachment));

package/src/utils/email/config.ts

@@ -0,0 +1,46 @@
+import { EMAIL_PROVIDER_CONFIG_CODES } from './constants';
+import { IEmailProviderConfig } from './types';
+
+export type TConfigReader = (
+  code: string,
+  defaultValue?: string,
+) => Promise<string | undefined>;
+
+export const loadEmailProviderConfig = async (
+  read: TConfigReader,
+): Promise<IEmailProviderConfig> => {
+  const values = await Promise.all(
+    EMAIL_PROVIDER_CONFIG_CODES.map((code) => read(code, '')),
+  );
+
+  return EMAIL_PROVIDER_CONFIG_CODES.reduce<IEmailProviderConfig>(
+    (config, code, index) => {
+      const value = values[index];
+
+      if (value) {
+        config[code] = value;
+      }
+
+      return config;
+    },
+    {},
+  );
+};
+
+export const resolveDefaultSenderEmail = ({
+  isSaas,
+  companyEmailFrom,
+  fallbackEmail,
+}: {
+  isSaas: boolean;
+  companyEmailFrom?: string;
+  fallbackEmail?: string;
+}): string =>
+  (isSaas ? fallbackEmail : companyEmailFrom || fallbackEmail) || '';
+
+export const getEmailProviderConfigFingerprint = (
+  config: IEmailProviderConfig,
+): string =>
+  EMAIL_PROVIDER_CONFIG_CODES.map(
+    (code) => `${code}=${config[code] ?? ''}`,
+  ).join('|');

package/src/utils/email/constants.ts

@@ -0,0 +1,25 @@
+import { TEmailProviderName } from './types';
+
+export const EMAIL_PROVIDER_CONFIG_CODES = [
+  'DEFAULT_EMAIL_SERVICE',
+
+  'AWS_SES_ACCESS_KEY_ID',
+  'AWS_SES_SECRET_ACCESS_KEY',
+  'AWS_REGION',
+  'AWS_SES_CONFIG_SET',
+
+  'SENDGRID_API_KEY',
+  'SENDGRID_SUBUSER',
+
+  'MAIL_SERVICE',
+  'MAIL_HOST',
+  'MAIL_PORT',
+  'MAIL_USER',
+  'MAIL_PASS',
+] as const;
+
+export const DEFAULT_EMAIL_PROVIDER: TEmailProviderName = 'SES';
+
+export const SENDGRID_API_BASE_URL = 'https://api.sendgrid.com/v3';
+
+export const SES_DKIM_CNAME_SUFFIX = 'dkim.amazonses.com';

package/src/utils/email/index.ts

@@ -0,0 +1,11 @@
+export * from './address';
+export * from './attachments';
+export * from './config';
+export * from './constants';
+export * from './providers/sendgrid';
+export * from './providers/sendgridEvents';
+export * from './providers/ses';
+export * from './providers/smtp';
+export * from './resolveProvider';
+export * from './service';
+export * from './types';