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

package/es/infrastructure/adapters/integrationServices/IntegrationServiceAdapter.js

@@ -0,0 +1,25 @@
+import { AdapterError } from '../../../core/errors';
+import { IntegrationService } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class IntegrationServiceAdapter extends IAdapter {
+  adapt(integrationServiceData) {
+    if (!integrationServiceData) {
+      throw new AdapterError('IntegrationService data is required');
+    }
+
+    try {
+      return new IntegrationService({
+        id: integrationServiceData.id,
+        label: integrationServiceData.label,
+        provider: integrationServiceData.provider,
+        domain: integrationServiceData.domain,
+        channelAlias: integrationServiceData.channelAlias,
+        logoURL: integrationServiceData.logoURL,
+        isParentAccountNeeded: integrationServiceData.isParentAccountNeeded
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt integrationService: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/messages/MessageAdapter.js

@@ -0,0 +1,45 @@
+import { AdapterError } from '../../../core/errors';
+import { Message } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class MessageAdapter extends IAdapter {
+  adapt(messageData) {
+    if (!messageData) {
+      throw new AdapterError('Message data is required');
+    }
+
+    try {
+      const {
+        template
+      } = messageData;
+      const normalizedTemplate = template && Object.keys(template).length > 0 ? template : null;
+      return new Message({
+        id: messageData.id,
+        sessionId: messageData.sessionId,
+        displayMessage: messageData.displayMessage,
+        statusUpdatedTime: messageData.statusUpdatedTime,
+        actor: messageData.actor,
+        direction: messageData.direction,
+        createdTime: messageData.createdTime,
+        index: messageData.index,
+        replyToMessage: messageData.replyToMessage,
+        status: messageData.status,
+        info: messageData.info,
+        location: messageData.location,
+        externalInfo: messageData.externalInfo,
+        layout: messageData.layout,
+        action: messageData.action,
+        meta: messageData.meta,
+        contentType: messageData.contentType,
+        fullContentURL: messageData.fullContentURL,
+        attachment: messageData.attachment,
+        template: normalizedTemplate,
+        type: messageData.type,
+        isRead: messageData.isRead,
+        article: messageData.article
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt message: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/messages/MessageWithSessionAdapter.js

@@ -0,0 +1,23 @@
+import { AdapterError } from '../../../core/errors';
+import { MessageWithSession } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+import { MessageAdapter, SessionAdapter } from '../index';
+export default class MessageWithSessionAdapter extends IAdapter {
+  adapt(messageData) {
+    if (!messageData) {
+      throw new AdapterError('Message With Session data is required');
+    }
+
+    const message = new MessageAdapter().adapt(messageData);
+    const session = new SessionAdapter().adapt(messageData.session);
+
+    try {
+      return new MessageWithSession({ ...message,
+        session
+      }).toJSON();
+    } catch (error) {
+      throw new Error(`Failed to adapt message with session: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/placeholders/PlaceholderAdapter.js

@@ -0,0 +1,22 @@
+import { AdapterError } from '../../../core/errors';
+import { Placeholder } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class PlaceholderAdapter extends IAdapter {
+  adapt(placeholderData) {
+    if (!placeholderData) {
+      throw new AdapterError('Placeholder data is required');
+    }
+
+    try {
+      return new Placeholder({
+        apiName: placeholderData.apiName,
+        i18nFieldLabel: placeholderData.i18nFieldLabel,
+        fieldLabel: placeholderData.fieldLabel,
+        placeHolder: placeholderData.placeHolder
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt placeholder: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/sessions/SessionAdapter.js

@@ -0,0 +1,36 @@
+import { AdapterError } from '../../../core/errors';
+import { Session } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class SessionAdapter extends IAdapter {
+  adapt(sessionData) {
+    if (!sessionData) {
+      throw new AdapterError('Session data is required');
+    }
+
+    try {
+      return new Session({
+        id: sessionData.id,
+        channelId: sessionData.channelId,
+        status: sessionData.status,
+        createdTime: sessionData.createdTime,
+        agentId: sessionData.agentId,
+        botId: sessionData.botId,
+        actor: sessionData.actor,
+        subject: sessionData.subject,
+        messagesCount: sessionData.messagesCount,
+        agentLastActiveTime: sessionData.agentLastActiveTime,
+        contactLastActiveTime: sessionData.contactLastActiveTime,
+        lastActiveTime: sessionData.lastActiveTime,
+        unreadMessagesCount: sessionData.unreadMessagesCount,
+        integrationServiceId: sessionData.integrationServiceId,
+        replyStatus: sessionData.replyStatus,
+        contactId: sessionData.contactId,
+        meta: sessionData.meta,
+        assignee: sessionData.assignee
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt session: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/sessions/SessionMetricsAdapter.js

@@ -0,0 +1,19 @@
+import { AdapterError } from '../../../core/errors';
+import { SessionMetrics } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class SessionMetricsAdapter extends IAdapter {
+  adapt(sessionMetricsData) {
+    if (!sessionMetricsData) {
+      throw new AdapterError('Session metrics data is required');
+    }
+
+    try {
+      return new SessionMetrics({
+        assignee: sessionMetricsData.assignee
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt session Metrics Data: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/subscription/AddOnAdapter.js

@@ -0,0 +1,24 @@
+import { AdapterError } from '../../../core/errors';
+import { AddOn } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class AddOnAdapter extends IAdapter {
+  adapt(data) {
+    if (!data) {
+      throw new AdapterError('AddOn data is required'); // No I18N
+    }
+
+    try {
+      return new AddOn({
+        name: data.name,
+        type: data.type,
+        module: data.module,
+        cost: data.cost,
+        subscriptionInfo: data.subscriptionInfo
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt addOn: ${error.message}` // No I18N
+      );
+    }
+  }
+
+}

package/es/infrastructure/adapters/subscription/LicenseDetailsAdapter.js

@@ -0,0 +1,20 @@
+import { AdapterError } from '../../../core/errors';
+import { LicenseDetails } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class LicenseDetailsAdapter extends IAdapter {
+  adapt(data) {
+    if (!data) {
+      throw new AdapterError('LicenseDetails data is required'); // No I18N
+    }
+
+    try {
+      return new LicenseDetails({
+        paymentSource: data.paymentSource
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt licenseDetails: ${error.message}` // No I18N
+      );
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/templateMessages/TemplateCreditExhaustStatusAdapter.js

@@ -0,0 +1,20 @@
+import { AdapterError } from '../../../core/errors';
+import { TemplateCreditExhaustStatus } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class TemplateCreditExhaustStatusAdapter extends IAdapter {
+  adapt(templateCreditExhaustStatusData) {
+    if (!templateCreditExhaustStatusData) {
+      throw new AdapterError('Template Credit Exhaust Status data is required');
+    }
+
+    try {
+      return new TemplateCreditExhaustStatus({
+        code: templateCreditExhaustStatusData.code,
+        message: templateCreditExhaustStatusData.message
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt Template Credit Exhaust Status: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/templateMessages/TemplateLanguageAdapter.js

@@ -0,0 +1,20 @@
+import { AdapterError } from '../../../core/errors';
+import { TemplateLanguage } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class TemplateLanguageAdapter extends IAdapter {
+  adapt(templateLanguageData) {
+    if (!templateLanguageData) {
+      throw new AdapterError('templateLanguage data is required');
+    }
+
+    try {
+      return new TemplateLanguage({
+        code: templateLanguageData.code,
+        language: templateLanguageData.language
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt TemplateLanguage: ${error.message}`);
+    }
+  }
+
+}

package/es/infrastructure/adapters/templateMessages/TemplateTagsAdapter.js

@@ -0,0 +1,21 @@
+import { AdapterError } from '../../../core/errors';
+import { TemplateTags } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class TemplateTagsAdapter extends IAdapter {
+  adapt(templateTagsData) {
+    const tags = templateTagsData?.data?.tags;
+
+    if (!tags) {
+      throw new AdapterError('templateTags data is required');
+    }
+
+    try {
+      return new TemplateTags({
+        tags: tags
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt TemplateTags: ${error.message}`);
+    }
+  }
+
+}

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

@@ -0,0 +1,4 @@
+import TemplateLanguageAdapter from './TemplateLanguageAdapter';
+import TemplateCreditExhaustStatusAdapter from './TemplateCreditExhaustStatusAdapter';
+import TemplateTagsAdapter from './TemplateTagsAdapter';
+export { TemplateLanguageAdapter, TemplateCreditExhaustStatusAdapter, TemplateTagsAdapter };

package/es/infrastructure/adapters/userPreferences/UserPreferenceAdapter.js

@@ -0,0 +1,19 @@
+import { AdapterError } from '../../../core/errors';
+import { UserPreference } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class UserPreferencesAdapter extends IAdapter {
+  adapt(preferenceData) {
+    if (!preferenceData) {
+      throw new AdapterError('UserPreference data is required');
+    }
+
+    try {
+      return new UserPreference({
+        collapseSidePanel: preferenceData.collapseSidePanel
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt user preference: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/whatsAppPricing/WhatsAppPricingAdapter.js

@@ -0,0 +1,22 @@
+import { AdapterError } from '../../../core/errors';
+import { WhatsAppPricing } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class WhatsAppPricingAdapter extends IAdapter {
+  adapt(whatsAppPricingData) {
+    if (!whatsAppPricingData) {
+      throw new AdapterError('whatsAppPricing data is required');
+    }
+
+    try {
+      return new WhatsAppPricing({
+        total: whatsAppPricingData.total,
+        creditsCount: whatsAppPricingData.creditsCount,
+        actutalCreditsAmount: whatsAppPricingData.actutalCreditsAmount,
+        category: whatsAppPricingData.category
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt WhatsAppPricing: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/api/BaseAPI.js

@@ -0,0 +1,105 @@
+import { ModuleTypes, ResponseTypes } from '../../core/constants';
+import { ResponseUtils } from '../../core/utils';
+import configRegistry from '../config/configRegistry';
+import { getRegistryConfig } from './registry';
+import UrlBuilder from './UrlBuilder';
+export default class BaseAPI {
+  constructor() {
+    let {
+      module,
+      moduleType = ModuleTypes.AUTHENTICATED,
+      configProvider = configRegistry,
+      registryProvider = {
+        getRegistryConfig
+      },
+      urlBuilder
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    this.configProvider = configProvider;
+    this.registryProvider = registryProvider;
+    this.httpClient = moduleType === ModuleTypes.PUBLIC ? this.configProvider.getPublicHttpClient() : this.configProvider.getHttpClient();
+    this.baseURL = this.configProvider.getBaseURL();
+    this.module = module;
+    this.urlBuilder = urlBuilder || new UrlBuilder(this.baseURL);
+  }
+
+  async request(_ref) {
+    let {
+      request,
+      operation,
+      header
+    } = _ref;
+    const config = this.registryProvider.getRegistryConfig(this.module, operation);
+
+    if (!config) {
+      throw new Error(`Operation "${operation}" not found in registry for module "${this.module}"`);
+    }
+
+    const url = this.urlBuilder.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;
+  }
+
+  createAPIProxy(customAPI, defaultAPI) {
+    // If no custom API provided, just use default
+    if (!customAPI) {
+      return defaultAPI;
+    } // Create a proxy for method delegation
+
+
+    return new Proxy({}, {
+      get: (target, prop) => {
+        // For methods, check if custom implementation exists
+        if (typeof prop === 'string' && typeof customAPI[prop] === 'function' && this.isMethodOverridden(customAPI, prop)) {
+          // Use custom implementation if available
+          return customAPI[prop].bind(customAPI);
+        } // Fall back to default implementation
+
+
+        return defaultAPI[prop].bind(defaultAPI);
+      }
+    });
+  }
+
+  isMethodOverridden(customAPI, methodName) {
+    if (!customAPI) {
+      return false;
+    }
+
+    const customPrototype = Object.getPrototypeOf(customAPI);
+    return typeof customAPI[methodName] === 'function' && // Method is defined directly on custom prototype
+    Object.prototype.hasOwnProperty.call(customPrototype, methodName);
+  }
+
+  async executeAPICall(_ref2) {
+    let {
+      operation,
+      request,
+      apiProxy,
+      customAPI,
+      adapter,
+      responseType = ResponseTypes.SINGLE
+    } = _ref2;
+    const response = await apiProxy[operation](request);
+    const isOverridden = this.isMethodOverridden(customAPI, operation);
+
+    if (isOverridden) {
+      return response;
+    }
+
+    if (responseType === ResponseTypes.NONE || !adapter) {
+      return response;
+    }
+
+    return responseType === ResponseTypes.LIST ? ResponseUtils.adaptListResponse(response, adapter.adapt) : ResponseUtils.adaptSingleResponse(response, adapter.adapt);
+  }
+
+}

package/es/infrastructure/api/UrlBuilder.js

@@ -0,0 +1,53 @@
+export default class UrlBuilder {
+  constructor(baseURL) {
+    this.baseURL = baseURL;
+  }
+
+  replacePathParams(url, params) {
+    let processedUrl = url;
+    Object.entries(params).forEach(_ref => {
+      let [key, value] = _ref;
+      processedUrl = processedUrl.replace(`:${key}`, value);
+    });
+    return processedUrl;
+  }
+
+  buildUrl(_ref2) {
+    let {
+      url,
+      params,
+      query
+    } = _ref2;
+    const paramsObj = params || {};
+    const queryObj = query || {};
+    let processedUrl = this.replacePathParams(url, paramsObj);
+
+    if (this.baseURL) {
+      processedUrl = `${this.baseURL}${processedUrl}`;
+    }
+
+    const queryString = this.buildQuery(queryObj);
+
+    if (queryString) {
+      return `${processedUrl}?${queryString}`;
+    }
+
+    return processedUrl;
+  }
+
+  buildQuery(query) {
+    const filteredQuery = Object.entries(query).filter(_ref3 => {
+      let [, value] = _ref3;
+      return value !== undefined && value !== null && value !== '';
+    }).reduce((acc, _ref4) => {
+      let [key, value] = _ref4;
+      acc[key] = value;
+      return acc;
+    }, {});
+    return Object.entries(filteredQuery).map(_ref5 => {
+      let [key, value] = _ref5;
+      return `${key}=${value}`;
+    }).join('&');
+  }
+
+}

package/es/infrastructure/api/agents/AgentAPI.js

@@ -0,0 +1,14 @@
+import { getAgentsRequest } from '../../../domain/dto';
+import { IAgentRepository } from '../../../domain/interfaces/repositories';
+export default class AgentAPI extends IAgentRepository {
+  async getAgents() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getAgentsRequest();
+    const operation = 'getAgents';
+    const httpRequest = await this.request({
+      request,
+      operation
+    });
+    return httpRequest;
+  }
+
+}

package/es/infrastructure/api/agents/index.js

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

package/es/infrastructure/api/bots/BotAPI.js

@@ -0,0 +1,24 @@
+import { getBotsRequest, getBotRequest } from '../../../domain/dto';
+import { IBotRepository } from '../../../domain/interfaces/repositories';
+export default class BotAPI extends IBotRepository {
+  async getBots() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getBotsRequest();
+    const operation = 'getBots';
+    const httpRequest = await this.request({
+      request,
+      operation
+    });
+    return httpRequest;
+  }
+
+  async getBot() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getBotRequest();
+    const operation = 'getBot';
+    const httpRequest = await this.request({
+      request,
+      operation
+    });
+    return httpRequest;
+  }
+
+}

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

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

package/es/infrastructure/api/calls/CallAPI.js

@@ -0,0 +1,44 @@
+import { getCallsRequest, getCallRequest, updateCallStatusRequest, initiateCallRequest } from '../../../domain/dto';
+import { ICallRepository } from '../../../domain/interfaces/repositories';
+export default class CallAPI extends ICallRepository {
+  async getCalls() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getCallsRequest();
+    const operation = 'getCalls';
+    const httpRequest = await this.request({
+      operation,
+      request
+    });
+    return httpRequest;
+  }
+
+  async getCall() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getCallRequest();
+    const operation = 'getCall';
+    const httpRequest = await this.request({
+      operation,
+      request
+    });
+    return httpRequest;
+  }
+
+  async updateCallStatus() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : updateCallStatusRequest();
+    const operation = 'updateCallStatus';
+    const httpRequest = await this.request({
+      operation,
+      request
+    });
+    return httpRequest;
+  }
+
+  async initiateCall() {
+    let request = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initiateCallRequest();
+    const operation = 'initiateCall';
+    const httpRequest = await this.request({
+      operation,
+      request
+    });
+    return httpRequest;
+  }
+
+}

package/es/infrastructure/api/calls/index.js

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