@zohoim/client-sdk 1.0.0-rightPanelContact1 → 1.0.0-rightPanelSessionInfo-2

package/es/domain/entities/CannedMessage/CannedMessage.js

@@ -0,0 +1,86 @@
+import { validateSchema } from '../../../core/utils';
+import { CannedMessageStatus, CannedMessageType } from '../../enum';
+import { CannedMessageSchema } from '../../schema';
+import { Actor } from '../Actor';
+import Translation from './Translation';
+export default class CannedMessage {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: CannedMessageSchema,
+      data,
+      entityName: `CannedMessage${data?.id ? `_${data.id}` : ''}`
+    });
+    let {
+      createdBy,
+      translations
+    } = validatedData;
+
+    if (createdBy && typeof createdBy === 'object' && !Array.isArray(createdBy)) {
+      createdBy = new Actor(createdBy).toJSON();
+    }
+
+    if (Array.isArray(translations)) {
+      translations = translations.map(item => new Translation(item).toJSON());
+    }
+
+    this.data = {
+      id: validatedData.id,
+      title: validatedData.title,
+      message: validatedData.message,
+      tags: validatedData.tags,
+      status: validatedData.status,
+      uuid: validatedData.uuid,
+      createdBy,
+      displayMessage: validatedData.displayMessage,
+      type: validatedData.type,
+      isActive: validatedData.isActive,
+      meta: validatedData.meta,
+      isPrivate: validatedData.isPrivate,
+      rejectionReason: validatedData.rejectionReason,
+      modifiedTime: validatedData.modifiedTime,
+      translations,
+      parameters: validatedData.parameters,
+      primaryLanguage: validatedData.primaryLanguage,
+      wabaId: validatedData.wabaId
+    };
+  }
+
+  static isApproved(status) {
+    return status === CannedMessageStatus.APPROVED;
+  }
+
+  static isRejected(status) {
+    return status === CannedMessageStatus.REJECTED;
+  }
+
+  static isPending(status) {
+    return status === CannedMessageStatus.PENDING;
+  }
+
+  static isUnknown(status) {
+    return status === CannedMessageStatus.UNKNOWN;
+  }
+
+  static isPartiallyApproved(status) {
+    return status === CannedMessageStatus.PARTIALLY_APPROVED;
+  }
+
+  static isDeletionInProgress(status) {
+    return status === CannedMessageStatus.DELETION_IN_PROGRESS;
+  }
+
+  static isDeletionFailed(status) {
+    return status === CannedMessageStatus.DELETION_FAILED;
+  }
+
+  static isTemplate(type) {
+    return type === CannedMessageType.TEMPLATE;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/CannedMessage/Translation.js

@@ -0,0 +1,48 @@
+import { validateSchema } from '../../../core/utils';
+import { TranslationsSchema } from '../../schema';
+import { TemplateItemButton, TemplateItemHeader, TemplateItemFooter } from '../TemplateMessage';
+export default class Translation {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: TranslationsSchema,
+      data,
+      entityName: `Translation${data?.id ? `_${data.id}` : ''}`
+    });
+    const {
+      templateItems
+    } = validatedData;
+    let adaptedTemplateItems = null;
+
+    if (templateItems) {
+      const {
+        header,
+        footer,
+        buttons
+      } = templateItems;
+      adaptedTemplateItems = {
+        header: header ? new TemplateItemHeader(header).toJSON() : null,
+        footer: footer ? new TemplateItemFooter(footer).toJSON() : null,
+        buttons: Array.isArray(buttons) ? buttons.map(btn => new TemplateItemButton(btn).toJSON()) : null
+      };
+    }
+
+    this.data = {
+      id: validatedData.id,
+      language: validatedData.language,
+      message: validatedData.message,
+      displayMessage: validatedData.displayMessage,
+      uuid: validatedData.uuid,
+      status: validatedData.status,
+      modifiedTime: validatedData.modifiedTime,
+      failedReason: validatedData.failedReason,
+      templateItems: adaptedTemplateItems
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/CannedMessage/index.js

@@ -0,0 +1,3 @@
+import CannedMessage from './CannedMessage';
+import Translation from './Translation';
+export { CannedMessage, Translation };

package/es/domain/entities/Channel/Channel.js

@@ -0,0 +1,60 @@
+import { validateSchema } from '../../../core/utils';
+import { ChannelSchema } from '../../schema';
+export default class Channel {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: ChannelSchema,
+      data,
+      entityName: 'Channel'
+    }); // Set required properties from schema
+
+    this.id = validatedData.id;
+    this.name = validatedData.name;
+    this.isActive = validatedData.isActive;
+    this.isDeleted = validatedData.isDeleted;
+    this.isSandBox = validatedData.isSandBox;
+    this.createdTime = validatedData.createdTime;
+    this.universalLink = validatedData.universalLink; // Set optional properties from schema
+
+    this.integrationServiceType = validatedData.integrationServiceType || '';
+    this.integrationServiceId = validatedData.integrationServiceId || '';
+    this.defaultBotId = validatedData.defaultBotId || null;
+    this.accountName = validatedData.accountName || null;
+    this.isSubscribed = validatedData.isSubscribed || false;
+    this.createdBy = validatedData.createdBy || null;
+    this.isOwner = validatedData.isOwner || false;
+    this.photoURL = validatedData.photoURL || null;
+    this.configParams = validatedData.configParams || null;
+    this.authorizationPending = validatedData.authorizationPending || false;
+    this.meta = validatedData.meta || [];
+    this.logoURL = validatedData.logoURL || null;
+    this.workspaceId = validatedData.workspaceId || '';
+  }
+
+  toJSON() {
+    return {
+      id: this.id,
+      integrationServiceType: this.integrationServiceType,
+      integrationServiceId: this.integrationServiceId,
+      name: this.name,
+      defaultBotId: this.defaultBotId,
+      isActive: this.isActive,
+      isDeleted: this.isDeleted,
+      isSandBox: this.isSandBox,
+      createdTime: this.createdTime,
+      accountName: this.accountName,
+      universalLink: this.universalLink,
+      isSubscribed: this.isSubscribed,
+      createdBy: this.createdBy,
+      isOwner: this.isOwner,
+      photoURL: this.photoURL,
+      configParams: this.configParams,
+      authorizationPending: this.authorizationPending,
+      meta: this.meta,
+      logoURL: this.logoURL,
+      workspaceId: this.workspaceId
+    };
+  }
+
+}

package/es/domain/entities/Channel/index.js

@@ -0,0 +1,2 @@
+import Channel from './Channel';
+export { Channel };

package/es/domain/entities/Contact/Contact.js

@@ -0,0 +1,29 @@
+import { validateSchema } from '../../../core/utils';
+import { ContactSchema } from '../../schema';
+export default class Contact {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: ContactSchema,
+      data,
+      entityName: 'Contact'
+    });
+    this.data = {
+      id: validatedData.id,
+      name: validatedData.name,
+      email: validatedData.email,
+      photoURL: validatedData.photoURL || null,
+      mobile: validatedData.mobile,
+      phone: validatedData.phone,
+      customFields: validatedData.customFields || {},
+      webUrl: validatedData.webUrl || '',
+      layoutId: validatedData.layoutId || ''
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Contact/index.js

@@ -0,0 +1,2 @@
+import Contact from './Contact';
+export { Contact };

package/es/domain/entities/CustomReplyExtension/CustomReplyExtension.js

@@ -0,0 +1,26 @@
+import { validateSchema } from '../../../core/utils';
+import { CustomReplyExtensionSchema } from '../../schema';
+export default class CustomReplyExtension {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: CustomReplyExtensionSchema,
+      data,
+      entityName: 'CustomReplyExtension'
+    });
+    this.data = {
+      id: validatedData.id,
+      title: validatedData.title,
+      message: validatedData.message,
+      displayMessage: validatedData.displayMessage,
+      webUrl: validatedData.webUrl || null,
+      categoryName: validatedData.categoryName
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/CustomReplyExtension/index.js

@@ -0,0 +1,2 @@
+import CustomReplyExtension from './CustomReplyExtension';
+export { CustomReplyExtension };

package/es/domain/entities/IntegrationService/IntegrationService.js

@@ -0,0 +1,44 @@
+import { validateSchema } from '../../../core/utils';
+import { IntegrationServices } from '../../enum';
+import { IntegrationServiceSchema } from '../../schema';
+export default class IntegrationService {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: IntegrationServiceSchema,
+      data,
+      entityName: 'IntegrationService'
+    });
+    this.data = {
+      label: validatedData.label || '',
+      id: validatedData.id || '',
+      provider: validatedData.provider || {},
+      logoURL: validatedData.logoURL || null,
+      domain: validatedData.domain || '',
+      channelAlias: validatedData.channelAlias,
+      isParentAccountNeeded: validatedData.isParentAccountNeeded
+    };
+  }
+
+  static isWhatsApp(integrationServiceId) {
+    return integrationServiceId === IntegrationServices.WHATSAPP;
+  }
+
+  static isTwilio(integrationServiceId) {
+    return integrationServiceId === IntegrationServices.TWILIO;
+  }
+
+  static isBusinessMessaging(integrationServiceId) {
+    return integrationServiceId === IntegrationServices.IM_TALK;
+  }
+
+  static isWecom(integrationServiceId) {
+    return integrationServiceId === IntegrationServices.WECOM;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/IntegrationService/index.js

@@ -0,0 +1,2 @@
+import IntegrationService from './IntegrationService';
+export { IntegrationService };

package/es/domain/entities/Message/Action.js

@@ -0,0 +1,29 @@
+import { validateSchema } from '../../../core/utils';
+import { ActionType } from '../../enum';
+import { ActionSchema } from '../../schema';
+export default class Action {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: ActionSchema,
+      data,
+      entityName: 'Action'
+    });
+    this.data = {
+      type: validatedData.type,
+      subType: validatedData.subType,
+      value: validatedData.value
+    };
+  }
+
+  static isTransferAction() {
+    let action = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return action && action.type === ActionType.TRANSFER;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/ExternalInfo.js

@@ -0,0 +1,30 @@
+import { validateSchema } from '../../../core/utils';
+import { ExternalInfoAction } from '../../enum';
+import { ExternalInfoSchema } from '../../schema';
+export default class ExternalInfo {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: ExternalInfoSchema,
+      data,
+      entityName: 'ExternalInfo'
+    });
+    this.data = {
+      action: validatedData.action
+    };
+  }
+
+  static isGCConversationEnded(action) {
+    return action === ExternalInfoAction.GC_CONVERSATION_ENDED;
+  }
+
+  static isZIAConversationEnded(action) {
+    return action === ExternalInfoAction.ZIA_CONVERSATION_ENDED;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/Info.js

@@ -0,0 +1,48 @@
+import { validateSchema } from '../../../core/utils';
+import { Actor } from '../Actor';
+import { InfoSchema } from '../../schema/message';
+import { InfoAction } from '../../enum';
+import InfoTarget from './InfoTarget';
+
+function adaptTargets() {
+  let targets = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return targets.map(target => new InfoTarget(target).toJSON());
+}
+
+export default class Info {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: InfoSchema,
+      data,
+      entityName: 'Info'
+    });
+    this.data = {
+      actor: new Actor(validatedData.actor).toJSON(),
+      action: validatedData.action,
+      sessionStatus: validatedData.sessionStatus,
+      targets: adaptTargets(validatedData.targets)
+    };
+  }
+
+  static isEndSessionMessage() {
+    let info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return info && info.action === InfoAction.END_SESSION;
+  }
+
+  static isAutoAssignMessage() {
+    let info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return info && info.action === InfoAction.CHAT_AUTO_ASSIGN;
+  }
+
+  static isTransferMessage() {
+    let info = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    return info && info.action === InfoAction.CHAT_TRANSFER;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/InfoTarget.js

@@ -0,0 +1,26 @@
+import { validateSchema } from '../../../core/utils';
+import { InfoTargetSchema } from '../../schema/message';
+export default class InfoTarget {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: InfoTargetSchema,
+      data,
+      entityName: 'InfoTarget'
+    });
+    this.data = {
+      id: validatedData.id,
+      name: validatedData.name || null,
+      photoURL: validatedData.photoURL || null,
+      email: validatedData.email || null,
+      isReplyAllowed: validatedData.isReplyAllowed,
+      type: validatedData.type
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/Location.js

@@ -0,0 +1,22 @@
+import { validateSchema } from '../../../core/utils';
+import { LocationSchema } from '../../schema';
+export default class Location {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: LocationSchema,
+      data,
+      entityName: 'Location'
+    });
+    this.data = {
+      latitude: validatedData.latitude,
+      longitude: validatedData.longitude
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/Message.js

@@ -0,0 +1,160 @@
+import { validateSchema } from '../../../core/utils';
+import { MessageDirection, MessageStatus, MessageTypes, MessageMeta, MetaSystemMessageType, MetaMessageSourceType } from '../../enum';
+import { MessageSchema } from '../../schema';
+import { Actor } from '../Actor';
+import { Attachment } from '../Attachment';
+import Action from './Action';
+import ExternalInfo from './ExternalInfo';
+import Info from './Info';
+import Location from './Location';
+export default class Message {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: MessageSchema,
+      data,
+      entityName: 'Message'
+    });
+    this.data = {
+      id: validatedData.id,
+      sessionId: validatedData.sessionId,
+      displayMessage: validatedData.displayMessage,
+      statusUpdatedTime: validatedData.statusUpdatedTime,
+      actor: new Actor(validatedData.actor).toJSON(),
+      direction: validatedData.direction,
+      createdTime: validatedData.createdTime,
+      index: validatedData.index,
+      replyToMessage: validatedData.replyToMessage ? new Message(validatedData.replyToMessage).toJSON() : null,
+      status: validatedData.status,
+      info: validatedData.info ? new Info(validatedData.info).toJSON() : null,
+      location: validatedData.location ? new Location(validatedData.location).toJSON() : null,
+      externalInfo: validatedData.externalInfo ? new ExternalInfo(validatedData.externalInfo).toJSON() : null,
+      layout: validatedData.layout,
+      action: validatedData.action ? new Action(validatedData.action).toJSON() : null,
+      meta: validatedData.meta,
+      contentType: validatedData.contentType,
+      fullContentURL: validatedData.fullContentURL,
+      attachment: validatedData.attachment ? new Attachment(validatedData.attachment).toJSON() : null,
+      template: validatedData.template,
+      type: validatedData.type,
+      isRead: validatedData.isRead,
+      article: validatedData.article,
+      webUrl: validatedData.webUrl
+    };
+  }
+
+  static isLocation(type) {
+    return type === MessageTypes.LOCATION;
+  }
+
+  static isDeleted(status) {
+    return status === MessageStatus.DELETED;
+  }
+
+  static isOutgoing(direction) {
+    return direction === MessageDirection.OUT;
+  }
+
+  static isIncoming(direction) {
+    return direction === MessageDirection.IN;
+  }
+
+  static isInfo(type) {
+    return type === MessageTypes.INFO;
+  }
+
+  static isExternalInfo(type) {
+    return type === MessageTypes.EXTERNAL_INFO;
+  }
+
+  static isAttachment(type) {
+    return type === MessageTypes.ATTACHMENT;
+  }
+
+  static isTemplate(type) {
+    return type === MessageTypes.TEMPLATE;
+  }
+
+  static isActionMessage(type) {
+    return type === MessageTypes.ACTION;
+  }
+
+  static getMetaValue() {
+    let meta = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    let key = arguments.length > 1 ? arguments[1] : undefined;
+
+    if (Array.isArray(meta) && meta.length > 0) {
+      const item = meta.find(item => item.name === key);
+      return item ? item.value : '';
+    }
+
+    return '';
+  }
+
+  static getSystemMessageValue(meta) {
+    return Message.getMetaValue(meta, MessageMeta.SYSTEM_MESSAGE_TYPE);
+  }
+
+  static isSystemMessage(meta) {
+    const systemMessageType = Message.getSystemMessageValue(meta);
+    return !!systemMessageType;
+  }
+
+  static isHapinessRating(meta) {
+    const messageType = Message.getSystemMessageValue(meta);
+    return messageType === MetaSystemMessageType.CX_HAPPINESS_SURVEY;
+  }
+
+  static isWelcomeMessage(meta) {
+    const messageType = Message.getSystemMessageValue(meta);
+    return messageType === MetaSystemMessageType.WELCOMEMSG;
+  }
+
+  static isWorkflowMessage(meta) {
+    const messageType = Message.getSystemMessageValue(meta);
+    return messageType === MetaSystemMessageType.WORKFLOW_MESSAGE;
+  }
+
+  static isWorkflowNotification(meta) {
+    const messageType = Message.getSystemMessageValue(meta);
+    return messageType === MetaSystemMessageType.WORKFLOW_NOTIFICATION;
+  }
+
+  static isUnsupportedFile(meta) {
+    const messageType = Message.getSystemMessageValue(meta);
+    return messageType === MetaSystemMessageType.UN_SUPPORTED_FILE;
+  }
+
+  static getMessageSourceValue(meta) {
+    return Message.getMetaValue(meta, MessageMeta.MESSAGE_SOURCE);
+  }
+
+  static isHistoryMessage(meta) {
+    const messageType = Message.getMessageSourceValue(meta);
+    return messageType === MetaMessageSourceType.HISTORY_MESSAGE;
+  }
+
+  static isHistoryMessageViaMobileWBApp(meta) {
+    const messageType = Message.getMessageSourceValue(meta);
+    return messageType === MetaMessageSourceType.HISTORY_MESSAGE_VIA_MOBILE_WHATSAPP_BUSINESS_APP;
+  }
+
+  static isMessageViaMobileWBApp(meta) {
+    const messageType = Message.getMessageSourceValue(meta);
+    return messageType === MetaMessageSourceType.VIA_MOBILE_WHATSAPP_BUSINESS_APP;
+  }
+
+  static isFailed(status) {
+    return status === MessageStatus.FAILED;
+  }
+
+  static isAutoSent(systemMsgType) {
+    return !!systemMsgType;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/MessageWithSession.js

@@ -0,0 +1,25 @@
+import { validateSchema } from '../../../core/utils';
+import { MessageWithSessionSchema } from '../../schema';
+import { Session } from '../Session';
+import Message from './Message';
+export default class MessageWithSession {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: MessageWithSessionSchema,
+      data,
+      entityName: 'MessageWithSession'
+    });
+    const messageData = new Message(validatedData).toJSON();
+    const sessionData = new Session(validatedData.session).toJSON();
+    this.data = { ...messageData,
+      session: sessionData
+    };
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

package/es/domain/entities/Message/index.js

@@ -0,0 +1,7 @@
+export { default as Message } from './Message';
+export { default as Info } from './Info';
+export { default as Action } from './Action';
+export { default as ExternalInfo } from './ExternalInfo';
+export { default as Location } from './Location';
+export { default as MessageWithSession } from './MessageWithSession';
+export { default as InfoTarget } from './InfoTarget';