@zohoim/client-sdk 0.0.5 → 1.0.0-attachmentsList

package/es/application/services/cannedMessages/CannedMessageService.js

@@ -0,0 +1,51 @@
+import { ICannedMessageRepository } from '../../../domain/interfaces/repositories';
+export default class CannedMessageService extends ICannedMessageRepository {
+  constructor(_ref) {
+    let {
+      cannedMessageRepository
+    } = _ref;
+    super();
+    this.cannedMessageRepository = cannedMessageRepository;
+  }
+
+  async getCannedMessages(request) {
+    return this.cannedMessageRepository.getCannedMessages(request);
+  }
+
+  async getCannedMessage(request) {
+    return this.cannedMessageRepository.getCannedMessage(request);
+  }
+
+  async createCannedMessage(request) {
+    return this.cannedMessageRepository.createCannedMessage(request);
+  }
+
+  async deleteCannedMessage(request) {
+    return this.cannedMessageRepository.deleteCannedMessage(request);
+  }
+
+  async updateCannedMessage(request) {
+    return this.cannedMessageRepository.updateCannedMessage(request);
+  }
+
+  async enableCannedMessage(request) {
+    return this.cannedMessageRepository.enableCannedMessage(request);
+  }
+
+  async disableCannedMessage(request) {
+    return this.cannedMessageRepository.disableCannedMessage(request);
+  }
+
+  toJSON() {
+    return {
+      getCannedMessages: this.getCannedMessages.bind(this),
+      getCannedMessage: this.getCannedMessage.bind(this),
+      createCannedMessage: this.createCannedMessage.bind(this),
+      deleteCannedMessage: this.deleteCannedMessage.bind(this),
+      updateCannedMessage: this.updateCannedMessage.bind(this),
+      enableCannedMessage: this.enableCannedMessage.bind(this),
+      disableCannedMessage: this.disableCannedMessage.bind(this)
+    };
+  }
+
+}

package/es/application/services/cannedMessages/index.js

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

package/es/application/services/index.js

@@ -3,4 +3,6 @@ export * from './sessions';
 export * from './bots';
 export * from './messages';
 export * from './agents';
-export * from './contacts';
+export * from './contacts';
+export * from './cannedMessages';
+export * from './templateMessages';

package/es/application/services/templateMessages/TemplateMessageService.js

@@ -0,0 +1,26 @@
+import { ITemplateMessageRepository } from '../../../domain/interfaces/repositories';
+export default class TemplateMessageService extends ITemplateMessageRepository {
+  constructor(_ref) {
+    let {
+      templateMessageRepository
+    } = _ref;
+    super();
+    this.templateMessageRepository = templateMessageRepository;
+  }
+
+  async getTemplateLanguages(request) {
+    return this.templateMessageRepository.getTemplateLanguages(request);
+  }
+
+  async getWhatsAppTemplateCreditExhaustStatus(request) {
+    return this.templateMessageRepository.getWhatsAppTemplateCreditExhaustStatus(request);
+  }
+
+  toJSON() {
+    return {
+      getTemplateLanguages: this.getTemplateLanguages.bind(this),
+      getWhatsAppTemplateCreditExhaustStatus: this.getWhatsAppTemplateCreditExhaustStatus.bind(this)
+    };
+  }
+
+}

package/es/application/services/templateMessages/index.js

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

package/es/core/constants/ModuleNames.js

@@ -4,6 +4,9 @@ const ModuleNames = {
   BOTS: 'bots',
   MESSAGES: 'messages',
   CONTACTS: 'contacts',
-  AGENTS: 'agents'
+  AGENTS: 'agents',
+  CANNED_MESSAGES: 'cannedMessages',
+  TEMPLATE_MESSAGES: 'templateMessages',
+  CUSTOM_REPLY_EXTENSIONS: 'articles'
 };
 export default ModuleNames;

package/es/core/utils/validateSchema.js

@@ -1,10 +1,15 @@
-import { ValidationError } from '../errors'; // function validateSchemaKeys(schema, data) {
-//   Object.keys(schema).forEach((key) => {
-//     if (!(key in data)) {
-//       throw new ValidationError(`Key '${key}' is missing in the data`);
-//     }
-//   });
-// }
+function validateSchemaKeys(_ref) {
+  let {
+    schema = {},
+    data = {},
+    entityName = ''
+  } = _ref;
+  Object.keys(schema).forEach(key => {
+    if (!(key in data)) {
+      console.warn(`${entityName} - Key '${key}' is missing in the data`);
+    }
+  });
+}
 
 function isEmpty(value) {
   if (value === null || value === undefined || value === '') {
@@ -14,44 +19,63 @@ function isEmpty(value) {
   return false;
 }
 
-function validateRequiredCheck(_ref) {
+function validateRequiredCheck(_ref2) {
   let {
     value,
     rules,
-    path
-  } = _ref;
+    path,
+    entityName
+  } = _ref2;
 
   if (rules.required && isEmpty(value)) {
-    throw new ValidationError(rules.message || `${path} is required`);
+    console.warn(`${entityName} - ${path} is required`);
   }
 }
 
-function validateEnumCheck(_ref2) {
+function validateEnumCheck(_ref3) {
   let {
     value,
     rules,
-    path
-  } = _ref2;
+    path,
+    entityName
+  } = _ref3;
 
   if (rules.enum && !rules.enum.includes(value)) {
-    throw new ValidationError(`${path} must be one of: ${rules.enum.join(', ')}`);
+    console.warn(`${entityName} - ${path} must be one of: ${rules.enum.join(', ')}. Received: ${value}`);
   }
 }
 
-export const validateSchema = (schema, data) => {
-  const validate = function (schemaObj, dataObj) {
-    let path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+export const validateSchema = _ref4 => {
+  let {
+    schema,
+    data,
+    entityName = ''
+  } = _ref4;
+
+  const validate = _ref5 => {
+    let {
+      schema: schemaObj,
+      data: dataObj,
+      path = '',
+      entityName
+    } = _ref5;
     // Check if all schema keys exist in data
-    // validateSchemaKeys(schemaObj, dataObj);
-    // Validate each field
-    Object.entries(schemaObj).forEach(_ref3 => {
-      let [field, rules] = _ref3;
+    validateSchemaKeys({
+      schema: schemaObj,
+      data: dataObj,
+      entityName,
+      path
+    }); // Validate each field
+
+    Object.entries(schemaObj).forEach(_ref6 => {
+      let [field, rules] = _ref6;
       const value = dataObj[field];
       const fieldPath = path ? `${path}.${field}` : field;
       validateRequiredCheck({
         value,
         rules,
-        path: fieldPath
+        path: fieldPath,
+        entityName
       });
 
       if (value !== null && value !== undefined) {
@@ -59,16 +83,26 @@ export const validateSchema = (schema, data) => {
         validateEnumCheck({
           value,
           rules,
-          path: fieldPath
+          path: fieldPath,
+          entityName
         }); // Nested object validation
 
         if (rules.type === 'object' && rules.schema) {
-          validate(rules.schema, value, fieldPath);
+          validate({
+            schema: rules.schema,
+            data: value,
+            path: fieldPath,
+            entityName
+          });
         }
       }
     });
     return dataObj;
   };
 
-  return validate(schema, data);
+  return validate({
+    schema,
+    data,
+    entityName
+  });
 };

package/es/domain/dto/cannedMessages/createCannedMessageRequest.js

@@ -0,0 +1,18 @@
+import RequestBuilder from '../RequestBuilder';
+
+function createCannedMessageRequest() {
+  let {
+    params = {},
+    body = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({ ...params
+  }).withBody({
+    title: null,
+    message: null,
+    tags: null,
+    type: null,
+    ...body
+  }).build();
+}
+
+export default createCannedMessageRequest;

package/es/domain/dto/cannedMessages/deleteCannedMessageRequest.js

@@ -0,0 +1,13 @@
+import RequestBuilder from '../RequestBuilder';
+
+function deleteCannedMessageRequest() {
+  let {
+    params = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({
+    cannedMessageId: null,
+    ...params
+  }).build();
+}
+
+export default deleteCannedMessageRequest;

package/es/domain/dto/cannedMessages/disableCannedMessageRequest.js

@@ -0,0 +1,13 @@
+import RequestBuilder from '../RequestBuilder';
+
+function disableCannedMessageRequest() {
+  let {
+    params = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({
+    cannedMessageId: null,
+    ...params
+  }).build();
+}
+
+export default disableCannedMessageRequest;

package/es/domain/dto/cannedMessages/enableCannedMessageRequest.js

@@ -0,0 +1,13 @@
+import RequestBuilder from '../RequestBuilder';
+
+function enableCannedMessageRequest() {
+  let {
+    params = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({
+    cannedMessageId: null,
+    ...params
+  }).build();
+}
+
+export default enableCannedMessageRequest;

package/es/domain/dto/cannedMessages/getCannedMessageRequest.js

@@ -0,0 +1,13 @@
+import RequestBuilder from '../RequestBuilder';
+
+function getCannedMessageRequest() {
+  let {
+    params = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({
+    cannedMessageId: null,
+    ...params
+  }).build();
+}
+
+export default getCannedMessageRequest;

package/es/domain/dto/cannedMessages/getCannedMessagesRequest.js

@@ -0,0 +1,18 @@
+import RequestBuilder from '../RequestBuilder';
+
+function getCannedMessagesRequest() {
+  let {
+    query = {},
+    params = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({ ...params
+  }).withQuery({
+    from: 0,
+    limit: 10,
+    modifiedAfter: null,
+    type: null,
+    ...query
+  }).build();
+}
+
+export default getCannedMessagesRequest;

package/es/domain/dto/cannedMessages/index.js

@@ -0,0 +1,7 @@
+export { default as getCannedMessagesRequest } from './getCannedMessagesRequest';
+export { default as getCannedMessageRequest } from './getCannedMessageRequest';
+export { default as deleteCannedMessageRequest } from './deleteCannedMessageRequest';
+export { default as createCannedMessageRequest } from './createCannedMessageRequest';
+export { default as enableCannedMessageRequest } from './enableCannedMessageRequest';
+export { default as disableCannedMessageRequest } from './disableCannedMessageRequest';
+export { default as updateCannedMessageRequest } from './updateCannedMessageRequest';

package/es/domain/dto/cannedMessages/updateCannedMessageRequest.js

@@ -0,0 +1,20 @@
+import RequestBuilder from '../RequestBuilder';
+
+function updateCannedMessageRequest() {
+  let {
+    params = {},
+    body = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({
+    cannedMessageId: null,
+    ...params
+  }).withBody({
+    title: null,
+    message: null,
+    tags: null,
+    type: null,
+    ...body
+  }).build();
+}
+
+export default updateCannedMessageRequest;

package/es/domain/dto/index.js

@@ -3,4 +3,6 @@ export * from './sessions';
 export * from './bots';
 export * from './messages';
 export * from './agents';
-export * from './contacts';
+export * from './contacts';
+export * from './cannedMessages';
+export * from './templateMessages';

package/es/domain/dto/messages/initiateSessionRequest.js

@@ -15,6 +15,8 @@ function initiateSessionRequest() {
     language: null,
     parameters: {},
     message: null,
+    headerMessage: null,
+    urlMessage: null,
     ...body
   }).build();
 }

package/es/domain/dto/sessions/getSessionAttachmentsRequest.js

@@ -6,6 +6,8 @@ function getSessionAttachmentsRequest() {
   } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   return new RequestBuilder().withParams({
     sessionId: null,
+    from: null,
+    limit: null,
     ...params
   }).build();
 }

package/es/domain/dto/sessions/getSessionsRequest.js

@@ -19,6 +19,7 @@ function getSessionsRequest() {
     assigneeFilter: null,
     workspaceId: null,
     botIds: null,
+    excludeSyncingChannels: false,
     ...query
   }).build();
 }

package/es/domain/dto/templateMessages/getTemplateCreditExhaustStatusRequest.js

@@ -0,0 +1,13 @@
+import RequestBuilder from '../RequestBuilder';
+
+function getTemplateCreditExhaustStatusRequest() {
+  let {
+    params = {}
+  } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return new RequestBuilder().withParams({ ...params,
+    channelId: null,
+    receiverId: null
+  }).build();
+}
+
+export default getTemplateCreditExhaustStatusRequest;

package/es/domain/dto/templateMessages/getTemplateLanguagesRequest.js

@@ -0,0 +1,7 @@
+import RequestBuilder from '../RequestBuilder';
+
+function getTemplateLanguagesRequest() {
+  return new RequestBuilder().build();
+}
+
+export default getTemplateLanguagesRequest;

package/es/domain/dto/templateMessages/index.js

@@ -0,0 +1,2 @@
+export { default as getTemplateLanguagesRequest } from './getTemplateLanguagesRequest';
+export { default as getTemplateCreditExhaustStatusRequest } from './getTemplateCreditExhaustStatusRequest';

package/es/domain/entities/Actor/Actor.js

@@ -4,7 +4,11 @@ import { ActorSchema } from '../../schema';
 export default class Actor {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(ActorSchema, data);
+    const validatedData = validateSchema({
+      schema: ActorSchema,
+      data,
+      entityName: 'Actor'
+    });
     this.data = {
       name: validatedData.name,
       type: validatedData.type,

package/es/domain/entities/Agent/Agent.js

@@ -3,7 +3,11 @@ import { AgentSchema } from '../../schema';
 export default class Agent {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(AgentSchema, data);
+    const validatedData = validateSchema({
+      schema: AgentSchema,
+      data,
+      entityName: 'Agent'
+    });
     this.data = {
       id: validatedData.id,
       firstName: validatedData.firstName,

package/es/domain/entities/Attachment/Attachment.js

@@ -3,7 +3,11 @@ import { AttachmentSchema } from '../../schema';
 export default class Attachment {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(AttachmentSchema, data);
+    const validatedData = validateSchema({
+      schema: AttachmentSchema,
+      data,
+      entityName: 'Attachment'
+    });
     this.data = {
       id: validatedData.id,
       name: validatedData.name,

package/es/domain/entities/Bot/Bot.js

@@ -3,7 +3,11 @@ import { BotSchema } from '../../schema';
 export default class Bot {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(BotSchema, data);
+    const validatedData = validateSchema({
+      schema: BotSchema,
+      data,
+      entityName: 'Bot'
+    });
     this.data = {
       id: validatedData.id,
       botServiceType: validatedData.botServiceType,

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

@@ -0,0 +1,58 @@
+import { validateSchema } from '../../../core/utils';
+import { CannedMessageStatus } from '../../enum';
+import { CannedMessageSchema } from '../../schema';
+import { Actor } from '../Actor';
+export default class CannedMessage {
+  constructor() {
+    let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    const validatedData = validateSchema({
+      schema: CannedMessageSchema,
+      data,
+      entityName: 'CannedMessage'
+    });
+    let {
+      createdBy
+    } = validatedData;
+
+    if (createdBy && typeof createdBy === 'object' && !Array.isArray(createdBy)) {
+      createdBy = new Actor(createdBy);
+    }
+
+    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: validatedData.translations,
+      parameters: validatedData.parameters
+    };
+  }
+
+  static isApproved(status) {
+    return status === CannedMessageStatus.APPROVED;
+  }
+
+  static isRejected(status) {
+    return status === CannedMessageStatus.REJECTED;
+  }
+
+  static isPending(status) {
+    return status === CannedMessageStatus.PENDING;
+  }
+
+  toJSON() {
+    return { ...this.data
+    };
+  }
+
+}

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

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

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

@@ -3,7 +3,11 @@ import { ChannelSchema } from '../../schema';
 export default class Channel {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(ChannelSchema, data); // Set required properties from schema
+    const validatedData = validateSchema({
+      schema: ChannelSchema,
+      data,
+      entityName: 'Channel'
+    }); // Set required properties from schema
 
     this.id = validatedData.id;
     this.integrationService = validatedData.integrationService;

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

@@ -3,7 +3,11 @@ import { ContactSchema } from '../../schema';
 export default class Contact {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(ContactSchema, data);
+    const validatedData = validateSchema({
+      schema: ContactSchema,
+      data,
+      entityName: 'Contact'
+    });
     this.data = {
       id: validatedData.id,
       name: validatedData.name,

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

@@ -4,7 +4,11 @@ import { IntegrationServiceSchema } from '../../schema';
 export default class IntegrationService {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(IntegrationServiceSchema, data);
+    const validatedData = validateSchema({
+      schema: IntegrationServiceSchema,
+      data,
+      entityName: 'IntegrationService'
+    });
     this.data = {
       label: validatedData.label || '',
       id: validatedData.id || '',

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

@@ -4,7 +4,11 @@ import { ActionSchema } from '../../schema';
 export default class Action {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(ActionSchema, data);
+    const validatedData = validateSchema({
+      schema: ActionSchema,
+      data,
+      entityName: 'Action'
+    });
     this.data = {
       type: validatedData.type,
       subType: validatedData.subType,

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

@@ -4,7 +4,11 @@ import { ExternalInfoSchema } from '../../schema';
 export default class ExternalInfo {
   constructor() {
     let data = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    const validatedData = validateSchema(ExternalInfoSchema, data);
+    const validatedData = validateSchema({
+      schema: ExternalInfoSchema,
+      data,
+      entityName: 'ExternalInfo'
+    });
     this.data = {
       action: validatedData.action
     };