@zohoim/client-sdk 1.0.0-poc4 → 1.0.0-poc40

package/es/domain/interfaces/BaseAPI.js

@@ -0,0 +1,86 @@
+import { getRegistryConfig } from "../../config/registry";
+import { configRegistry } from "../../infrastructure/sdk/config";
+export default class BaseAPI {
+  constructor(_ref) {
+    let {
+      module
+    } = _ref;
+    this.httpClient = configRegistry.getHttpClient();
+    this.baseURL = configRegistry.getBaseURL();
+    this.module = module;
+  }
+
+  replacePathParams(url, params) {
+    let _url = url;
+    Object.entries(params).forEach(_ref2 => {
+      let [key, value] = _ref2;
+      _url = url.replace(`:${key}`, value);
+    });
+    return _url;
+  }
+
+  buildUrl(_ref3) {
+    let {
+      url,
+      params,
+      query
+    } = _ref3;
+
+    const _params = params || {};
+
+    const _query = query || {};
+
+    let _url = this.replacePathParams(url, _params);
+
+    if (this.baseURL) {
+      _url = `${this.baseURL}${_url}`;
+    }
+
+    const queryString = this.buildQuery(_query);
+
+    if (queryString) {
+      return `${_url}?${queryString}`;
+    }
+
+    return _url;
+  }
+
+  buildQuery(query) {
+    const filteredQuery = Object.entries(query).filter(_ref4 => {
+      let [, value] = _ref4;
+      return value !== undefined && value !== null && value !== '';
+    }).reduce((acc, _ref5) => {
+      let [key, value] = _ref5;
+      acc[key] = value;
+      return acc;
+    }, {});
+    return new URLSearchParams(filteredQuery).toString();
+  }
+
+  async request(_ref6) {
+    let {
+      request,
+      operation,
+      header
+    } = _ref6;
+    const config = getRegistryConfig(this.module, operation);
+
+    if (!config) {
+      throw new Error(`Operation "${operation}" not found in registry for module "${this.module}"`);
+    }
+
+    const url = this.buildUrl({
+      url: config.endpoint,
+      params: request.params || {},
+      query: request.query || {}
+    });
+    const httpRequest = await this.httpClient.request({
+      url,
+      method: config.method,
+      header,
+      payload: request.body || {}
+    });
+    return httpRequest;
+  }
+
+}

package/es/domain/interfaces/IAdapter.js

@@ -0,0 +1,6 @@
+export default class IAdapter {
+  adapt() {
+    throw new Error('Method "adapt" must be implemented');
+  }
+
+}

package/es/domain/interfaces/bots/IBot.js

@@ -0,0 +1,10 @@
+import { getBotsRequest } from "../../../infrastructure/interfaces/api";
+import BaseAPI from "../BaseAPI";
+export default class IBot extends BaseAPI {
+  // eslint-disable-next-line no-unused-vars
+  async getBots() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getBotsRequest();
+    throw new Error('Method not implemented');
+  }
+
+}

package/es/domain/interfaces/bots/index.js

@@ -0,0 +1,2 @@
+import IBot from "./IBot";
+export { IBot };

package/es/domain/interfaces/channels/IChannel.js

@@ -0,0 +1,10 @@
+import { getChannelsRequest } from "../../../infrastructure/interfaces/api";
+import BaseAPI from "../BaseAPI";
+export default class IChannel extends BaseAPI {
+  // eslint-disable-next-line no-unused-vars
+  getChannels() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getChannelsRequest();
+    throw new Error('Method not implemented.');
+  }
+
+}

package/es/domain/interfaces/channels/IChannelAgent.js

@@ -1,5 +1,9 @@
-export default class IChannelAgent {
-  static getChannelAgents() {
+import { getChannelAgentsRequest } from "../../../infrastructure/interfaces/api";
+import BaseAPI from "../BaseAPI";
+export default class IChannelAgent extends BaseAPI {
+  // eslint-disable-next-line no-unused-vars
+  getAgents() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getChannelAgentsRequest();
     throw new Error('Method not implemented.');
   }
 

package/es/domain/interfaces/channels/index.js

@@ -1,2 +1,3 @@
-import IChannelAgent from './IChannelAgent';
-export { IChannelAgent };
+import IChannel from "./IChannel";
+import IChannelAgent from "./IChannelAgent";
+export { IChannel, IChannelAgent };

package/es/domain/interfaces/index.js

@@ -1 +1,5 @@
-export * from './channels';
+import IAdapter from "./IAdapter";
+export * from "./channels";
+export * from "./sessions";
+export * from "./bots";
+export { IAdapter };

package/es/domain/interfaces/sessions/ISession.js

@@ -0,0 +1,10 @@
+import { updateSessionAssigneeRequest } from "../../../infrastructure/interfaces/api";
+import BaseAPI from "../BaseAPI";
+export default class ISession extends BaseAPI {
+  // eslint-disable-next-line no-unused-vars
+  updateAssignee() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : updateSessionAssigneeRequest();
+    throw new Error('Method not implemented.');
+  }
+
+}

package/es/domain/interfaces/sessions/index.js

@@ -0,0 +1,2 @@
+import ISession from "./ISession";
+export { ISession };

package/es/domain/schema/actor/ActorSchema.js

@@ -0,0 +1,33 @@
+import { ActorType } from "../../enum";
+const ActorSchema = {
+  name: {
+    type: 'string',
+    required: true
+  },
+  type: {
+    type: 'string',
+    required: true,
+    enum: Object.values(ActorType)
+  },
+  photoURL: {
+    type: 'string',
+    required: false
+  },
+  extId: {
+    type: 'string',
+    required: false
+  },
+  id: {
+    type: 'string',
+    required: true
+  },
+  email: {
+    type: 'string',
+    required: false
+  },
+  botType: {
+    type: 'string',
+    required: false
+  }
+};
+export default ActorSchema;

package/es/domain/schema/actor/AgentSchema.js

@@ -0,0 +1,29 @@
+import { ActorType } from "../../enum";
+const AgentSchema = {
+  id: {
+    type: 'string',
+    required: true
+  },
+  name: {
+    type: 'string',
+    required: true
+  },
+  email: {
+    type: 'string',
+    required: true
+  },
+  photoURL: {
+    type: 'string',
+    required: false
+  },
+  zuid: {
+    type: 'string',
+    required: true
+  },
+  type: {
+    type: 'string',
+    required: true,
+    enum: [ActorType.AGENT]
+  }
+};
+export default AgentSchema;

package/es/domain/schema/actor/index.js

@@ -0,0 +1,3 @@
+import ActorSchema from "./ActorSchema";
+import AgentSchema from "./AgentSchema";
+export { ActorSchema, AgentSchema };

package/es/domain/schema/bot/BotSchema.js

@@ -0,0 +1,33 @@
+import { BotServiceType } from "../../enum";
+const BotSchema = {
+  id: {
+    type: 'string',
+    required: true
+  },
+  botServiceType: {
+    type: 'string',
+    required: true,
+    enum: [BotServiceType.DESK_GC_BOT, BotServiceType.DESK_ZIA_BOT, BotServiceType.ZOHO_GC_BOT, BotServiceType.ZOHO_ZIA_BOT]
+  },
+  name: {
+    type: 'string',
+    required: true
+  },
+  isActive: {
+    type: 'boolean',
+    required: true
+  },
+  createdTime: {
+    type: 'string',
+    required: true
+  },
+  photoURL: {
+    type: 'string',
+    required: false
+  },
+  createdBy: {
+    type: 'string',
+    required: true
+  }
+};
+export default BotSchema;

package/es/domain/schema/bot/index.js

@@ -0,0 +1,2 @@
+import BotSchema from "./BotSchema";
+export { BotSchema };

package/es/domain/schema/channel/ChannelSchema.js

@@ -0,0 +1,49 @@
+import { IntegrationServiceSchema } from "../integrationService";
+const ChannelSchema = {
+  id: {
+    type: 'string',
+    required: true
+  },
+  integrationService: {
+    type: 'object',
+    required: true,
+    schema: IntegrationServiceSchema
+  },
+  name: {
+    type: 'string',
+    required: true
+  },
+  defaultBotId: {
+    type: 'string',
+    required: false
+  },
+  isActive: {
+    type: 'boolean',
+    required: true
+  },
+  createdTime: {
+    type: 'string',
+    required: true
+  },
+  accountName: {
+    type: 'string',
+    required: false
+  },
+  isSubscribed: {
+    type: 'boolean',
+    required: false
+  },
+  createdBy: {
+    type: 'string',
+    required: false
+  },
+  isOwner: {
+    type: 'boolean',
+    required: false
+  },
+  photoURL: {
+    type: 'string',
+    required: false
+  }
+};
+export default ChannelSchema;

package/es/domain/schema/channel/index.js

@@ -0,0 +1,2 @@
+import ChannelSchema from "./ChannelSchema";
+export { ChannelSchema };

package/es/domain/schema/index.js

@@ -0,0 +1,5 @@
+export * from "./actor";
+export * from "./session";
+export * from "./bot";
+export * from "./channel";
+export * from "./integrationService";

package/es/domain/schema/integrationService/IntegrationServiceSchema.js

@@ -0,0 +1,31 @@
+import { IntegrationServices } from "../../enum";
+const IntegrationServiceSchema = {
+  label: {
+    type: 'string',
+    required: true
+  },
+  id: {
+    type: 'string',
+    required: true,
+    enum: Object.values(IntegrationServices)
+  },
+  provider: {
+    type: 'object',
+    required: true,
+    schema: {
+      name: {
+        type: 'string',
+        required: true
+      },
+      domain: {
+        type: 'string',
+        required: true
+      }
+    }
+  },
+  logoURL: {
+    type: 'string',
+    required: false
+  }
+};
+export default IntegrationServiceSchema;

package/es/domain/schema/integrationService/index.js

@@ -0,0 +1,2 @@
+import IntegrationServiceSchema from "./IntegrationServiceSchema";
+export { IntegrationServiceSchema };

package/es/domain/schema/session/SessionSchema.js

@@ -0,0 +1,82 @@
+import { IntegrationServices, SessionReplyStatus, SessionStatus } from "../../enum";
+import { ActorSchema } from "../actor";
+const SessionSchema = {
+  channelId: {
+    type: 'string',
+    required: true
+  },
+  status: {
+    type: 'string',
+    required: true,
+    enum: Object.values(SessionStatus)
+  },
+  createdTime: {
+    type: 'string',
+    required: true
+  },
+  agentId: {
+    type: 'string',
+    required: false
+  },
+  botId: {
+    type: 'string',
+    required: false
+  },
+  actor: {
+    type: 'object',
+    required: true,
+    schema: ActorSchema
+  },
+  subject: {
+    type: 'string',
+    required: true
+  },
+  messagesCount: {
+    type: 'string',
+    required: true
+  },
+  agentLastActiveTime: {
+    type: 'string',
+    required: true
+  },
+  contactLastActiveTime: {
+    type: 'string',
+    required: true
+  },
+  lastActiveTime: {
+    type: 'string',
+    required: true
+  },
+  unreadMessagesCount: {
+    type: 'string',
+    required: true
+  },
+  integrationServiceId: {
+    type: 'string',
+    required: true,
+    enum: Object.values(IntegrationServices)
+  },
+  replyStatus: {
+    type: 'string',
+    required: true,
+    enum: Object.values(SessionReplyStatus)
+  },
+  id: {
+    type: 'string',
+    required: true
+  },
+  contactId: {
+    type: 'string',
+    required: true
+  },
+  meta: {
+    type: 'array',
+    required: false
+  },
+  assignee: {
+    type: 'object',
+    required: false,
+    schema: ActorSchema
+  }
+};
+export default SessionSchema;

package/es/domain/schema/session/index.js

@@ -0,0 +1,2 @@
+import SessionSchema from "./SessionSchema";
+export { SessionSchema };

package/es/domain/services/bots/BotService.js

@@ -0,0 +1,27 @@
+import { ResponseUtils } from "../../../core/utils";
+import { BotAdapter } from "../../../infrastructure/adapters";
+import { BotAPI } from "../../../infrastructure/api";
+import { IBot } from "../../interfaces";
+export default class BotService extends IBot {
+  constructor(_ref) {
+    let {
+      botAPI,
+      botAdapter
+    } = _ref;
+    super();
+    this.botAPI = botAPI || new BotAPI();
+    this.botAdapter = botAdapter || new BotAdapter();
+  }
+
+  async getBots(request) {
+    const response = await this.botAPI.getBots(request);
+    return ResponseUtils.adaptListResponse(response, this.botAdapter.adapt);
+  }
+
+  toJSON() {
+    return {
+      getBots: this.getBots.bind(this)
+    };
+  }
+
+}

package/es/domain/services/bots/index.js

@@ -0,0 +1,2 @@
+import BotService from "./BotService";
+export { BotService };

package/es/domain/services/channels/ChannelAgentService.js

@@ -1,14 +1,27 @@
-import IChannelAgent from '../../interfaces/channels/IChannelAgent';
+import { ResponseUtils } from "../../../core/utils";
+import { ChannelAgentAdapter } from "../../../infrastructure/adapters";
+import { ChannelAgentAPI } from "../../../infrastructure/api";
+import { IChannelAgent } from "../../interfaces";
 export default class ChannelAgentService extends IChannelAgent {
-  constructor(channelAPI, channelAgentAdapter) {
+  constructor(_ref) {
+    let {
+      channelAgentAPI,
+      channelAgentAdapter
+    } = _ref;
     super();
-    this.channelAPI = channelAPI;
-    this.channelAgentAdapter = channelAgentAdapter;
+    this.channelAgentAPI = channelAgentAPI || new ChannelAgentAPI();
+    this.channelAgentAdapter = channelAgentAdapter || new ChannelAgentAdapter();
   }
 
-  async getChannelAgents() {
-    const channelAgents = await this.channelAPI.getChannelAgents();
-    return channelAgents.map(this.channelAgentAdapter.adapt);
+  async getAgents(request) {
+    const response = await this.channelAgentAPI.getAgents(request);
+    return ResponseUtils.adaptListResponse(response, this.channelAgentAdapter.adapt);
+  }
+
+  toJSON() {
+    return {
+      getAgents: this.getAgents.bind(this)
+    };
   }
 
 }

package/es/domain/services/channels/ChannelService.js

@@ -0,0 +1,27 @@
+import { ResponseUtils } from "../../../core/utils";
+import { ChannelAdapter } from "../../../infrastructure/adapters";
+import { ChannelAPI } from "../../../infrastructure/api";
+import { IChannel } from "../../interfaces";
+export default class ChannelService extends IChannel {
+  constructor() {
+    let {
+      channelAPI,
+      channelAdapter
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    super();
+    this.channelAPI = channelAPI || new ChannelAPI();
+    this.channelAdapter = channelAdapter || new ChannelAdapter();
+  }
+
+  async getChannels(request) {
+    const response = await this.channelAPI.getChannels(request);
+    return ResponseUtils.adaptListResponse(response, this.channelAdapter.adapt);
+  }
+
+  toJSON() {
+    return {
+      getChannels: this.getChannels.bind(this)
+    };
+  }
+
+}

package/es/domain/services/channels/index.js

@@ -1,2 +1,3 @@
-import ChannelAgentService from './ChannelAgentService';
-export { ChannelAgentService };
+import ChannelAgentService from "./ChannelAgentService";
+import ChannelService from "./ChannelService";
+export { ChannelAgentService, ChannelService };

package/es/domain/services/index.js

@@ -1 +1,3 @@
-export * from './channels';
+export * from "./channels";
+export * from "./sessions";
+export * from "./bots";

package/es/domain/services/sessions/SessionService.js

@@ -0,0 +1,27 @@
+import { ResponseUtils } from "../../../core/utils";
+import { SessionAdapter } from "../../../infrastructure/adapters";
+import { SessionAPI } from "../../../infrastructure/api";
+import { ISession } from "../../interfaces";
+export default class SessionService extends ISession {
+  constructor(_ref) {
+    let {
+      sessionAPI,
+      sessionAdapter
+    } = _ref;
+    super();
+    this.sessionAPI = sessionAPI || new SessionAPI();
+    this.sessionAdapter = sessionAdapter || new SessionAdapter();
+  }
+
+  async updateAssignee(request) {
+    const response = await this.sessionAPI.updateAssignee(request);
+    return ResponseUtils.adaptSingleResponse(response, this.sessionAdapter.adapt);
+  }
+
+  toJSON() {
+    return {
+      updateAssignee: this.updateAssignee.bind(this)
+    };
+  }
+
+}

package/es/domain/services/sessions/index.js

@@ -0,0 +1,2 @@
+import SessionService from "./SessionService";
+export { SessionService };

package/es/index.js

@@ -1 +1,10 @@
-// export * from './domain';
+export * from "./domain/entities";
+export * from "./domain/enum";
+export * from "./domain/interfaces";
+export * from "./domain/services";
+export * from "./infrastructure/sdk";
+export * from "./infrastructure/adapters";
+export * from "./infrastructure/api";
+export * from "./infrastructure/interfaces/api";
+export * from "./core/constants";
+export * from "./config/urls/base";

package/es/infrastructure/adapters/bots/BotAdapter.js

@@ -0,0 +1,25 @@
+import { AdapterError } from "../../../core/errors";
+import { Bot } from "../../../domain/entities";
+import IAdapter from "../../../domain/interfaces/IAdapter";
+export default class BotAdapter extends IAdapter {
+  adapt(botData) {
+    if (!botData) {
+      throw new AdapterError('Bot data is required');
+    }
+
+    try {
+      return new Bot({
+        id: botData.id,
+        botServiceType: botData.botService.id,
+        name: botData.name,
+        isActive: botData.isActive,
+        createdTime: botData.createdTime,
+        photoURL: botData.logoURL,
+        createdBy: botData.createdBy
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt bot: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/bots/index.js

@@ -0,0 +1,2 @@
+import BotAdapter from "./BotAdapter";
+export { BotAdapter };

package/es/infrastructure/adapters/channels/ChannelAdapter.js

@@ -0,0 +1,29 @@
+import { AdapterError } from "../../../core/errors";
+import { Channel } from "../../../domain/entities";
+import IAdapter from "../../../domain/interfaces/IAdapter";
+export default class ChannelAdapter extends IAdapter {
+  adapt(rawChannel) {
+    if (!rawChannel) {
+      throw new AdapterError('Channel data is required');
+    }
+
+    try {
+      return new Channel({
+        id: rawChannel.id,
+        integrationService: rawChannel.integrationService,
+        name: rawChannel.name,
+        defaultBotId: rawChannel.defaultBotId,
+        isActive: rawChannel.isActive,
+        createdTime: rawChannel.createdTime,
+        accountName: rawChannel.accountName,
+        isSubscribed: rawChannel.isSubscribed,
+        createdBy: rawChannel.createdBy,
+        isOwner: rawChannel.isOwner,
+        photoURL: rawChannel.logoURL
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt channel: ${error.message}`);
+    }
+  }
+
+}