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

package/es/frameworks/sdk/IMSDK.js

@@ -1,4 +1,4 @@
-import { ModuleNames } from '../../core/constants';
+import { ModuleNames, ModuleTypes } from '../../core/constants';
 import configRegistry from '../../infrastructure/config/configRegistry';
 import { ModuleManager } from '../managers';
 export default class IMSDK {
@@ -6,11 +6,13 @@ export default class IMSDK {
     let {
       baseURL,
       apiConfig = {},
-      httpClient
+      httpClient,
+      publicHttpClient
     } = _ref;
     configRegistry.setConfig({
       baseURL,
-      httpClient
+      httpClient,
+      publicHttpClient
     });
     this._moduleManager = new ModuleManager();
 
@@ -20,35 +22,55 @@ export default class IMSDK {
   }
 
   get channels() {
-    return this._moduleManager.getModule(ModuleNames.CHANNELS);
+    return this._moduleManager.getModuleByType(ModuleNames.CHANNELS);
   }
 
   get sessions() {
-    return this._moduleManager.getModule(ModuleNames.SESSIONS);
+    return this._moduleManager.getModuleByType(ModuleNames.SESSIONS);
   }
 
   get bots() {
-    return this._moduleManager.getModule(ModuleNames.BOTS);
+    return this._moduleManager.getModuleByType(ModuleNames.BOTS);
   }
 
   get messages() {
-    return this._moduleManager.getModule(ModuleNames.MESSAGES);
+    return this._moduleManager.getModuleByType(ModuleNames.MESSAGES);
   }
 
   get agents() {
-    return this._moduleManager.getModule(ModuleNames.AGENTS);
+    return this._moduleManager.getModuleByType(ModuleNames.AGENTS);
   }
 
   get contacts() {
-    return this._moduleManager.getModule(ModuleNames.CONTACTS);
+    return this._moduleManager.getModuleByType(ModuleNames.CONTACTS);
   }
 
   get cannedMessages() {
-    return this._moduleManager.getModule(ModuleNames.CANNED_MESSAGES);
+    return this._moduleManager.getModuleByType(ModuleNames.CANNED_MESSAGES);
   }
 
   get templateMessages() {
-    return this._moduleManager.getModule(ModuleNames.TEMPLATE_MESSAGES);
+    return this._moduleManager.getModuleByType(ModuleNames.TEMPLATE_MESSAGES);
+  }
+
+  get public() {
+    return this._moduleManager.getModulesByType(ModuleTypes.PUBLIC);
+  }
+
+  get integrationServices() {
+    return this._moduleManager.getModuleByType(ModuleNames.INTEGRATION_SERVICES);
+  }
+
+  get userPreferences() {
+    return this._moduleManager.getModuleByType(ModuleNames.USER_PREFERENCES);
+  }
+
+  get calls() {
+    return this._moduleManager.getModuleByType(ModuleNames.CALLS);
+  }
+
+  get subscription() {
+    return this._moduleManager.getModuleByType(ModuleNames.SUBSCRIPTION);
   }
 
   hasModule(moduleName) {
@@ -65,6 +87,11 @@ export default class IMSDK {
       contacts: this.contacts,
       cannedMessages: this.cannedMessages,
       templateMessages: this.templateMessages,
+      integrationServices: this.integrationServices,
+      userPreferences: this.userPreferences,
+      subscription: this.subscription,
+      public: this.public,
+      calls: this.calls,
       hasModule: this.hasModule.bind(this)
     };
   }

package/es/frameworks/sdk/calls/CallSDK.js

@@ -0,0 +1,27 @@
+import { CallService } from '../../../application/services';
+import { CallRepository } from '../../../infrastructure/repositories';
+export default class CallSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      callAPI,
+      callAdapter
+    } = config;
+    const callRepository = new CallRepository({
+      callAPI,
+      callAdapter
+    }).toJSON();
+    const callService = new CallService({
+      callRepository
+    }).toJSON();
+    this.services = { ...callService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}

package/es/frameworks/sdk/calls/index.js

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

package/es/frameworks/sdk/integrationServices/IntegrationServiceSDK.js

@@ -0,0 +1,30 @@
+import { IntegrationService } from '../../../application/services';
+import { IntegrationServiceRepository } from '../../../infrastructure/repositories';
+
+class IntegrationServiceSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      integrationServiceAPI,
+      integrationServiceAdapter
+    } = config;
+    const integrationServiceRepository = new IntegrationServiceRepository({
+      integrationServiceAPI,
+      integrationServiceAdapter
+    }).toJSON();
+    const integrationService = new IntegrationService({
+      integrationServiceRepository
+    }).toJSON();
+    this.services = { ...integrationService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default IntegrationServiceSDK;

package/es/frameworks/sdk/integrationServices/index.js

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

package/es/frameworks/sdk/subscription/SubscriptionSDK.js

@@ -0,0 +1,32 @@
+import { SubscriptionService } from '../../../application/services';
+import { SubscriptionRepository } from '../../../infrastructure/repositories';
+
+class SubscriptionSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      subscriptionAPI,
+      addOnAdapter,
+      licenseDetailsAdapter
+    } = config;
+    const subscriptionRepository = new SubscriptionRepository({
+      subscriptionAPI,
+      addOnAdapter,
+      licenseDetailsAdapter
+    }).toJSON();
+    const subscriptionService = new SubscriptionService({
+      subscriptionRepository
+    }).toJSON();
+    this.services = { ...subscriptionService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default SubscriptionSDK;

package/es/frameworks/sdk/subscription/index.js

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

package/es/frameworks/sdk/userPreferences/UserPreferencesSDK.js

@@ -0,0 +1,30 @@
+import { UserPreferenceService } from '../../../application/services';
+import { UserPreferenceRepository } from '../../../infrastructure/repositories';
+
+class UserPreferencesSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      userPreferenceAPI,
+      userPreferenceAdapter
+    } = config;
+    const userPreferenceRepository = new UserPreferenceRepository({
+      userPreferenceAPI,
+      userPreferenceAdapter
+    }).toJSON();
+    const userPreferenceService = new UserPreferenceService({
+      userPreferenceRepository
+    }).toJSON();
+    this.services = { ...userPreferenceService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default UserPreferencesSDK;

package/es/frameworks/sdk/userPreferences/index.js

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

package/es/frameworks/sdk/whatsAppPricing/WhatsAppPricingSDK.js

@@ -0,0 +1,28 @@
+import { WhatsAppPricingService } from '../../../application/services';
+import { WhatsAppPricingRepository } from '../../../infrastructure/repositories';
+
+class WhatsAppPricingSDK {
+  constructor(_ref) {
+    let {
+      config
+    } = _ref;
+    const {
+      whatsAppPricingAPI
+    } = config;
+    const whatsAppPricingRepository = new WhatsAppPricingRepository({
+      whatsAppPricingAPI
+    }).toJSON();
+    const whatsAppPricingService = new WhatsAppPricingService({
+      whatsAppPricingRepository
+    }).toJSON();
+    this.services = { ...whatsAppPricingService
+    };
+  }
+
+  toJSON() {
+    return this.services;
+  }
+
+}
+
+export default WhatsAppPricingSDK;

package/es/frameworks/sdk/whatsAppPricing/index.js

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

package/es/infrastructure/adapters/calls/CallAdapter.js

@@ -0,0 +1,31 @@
+import { AdapterError } from '../../../core/errors';
+import { Call } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class CallAdapter extends IAdapter {
+  adapt(callData) {
+    if (!callData) {
+      throw new AdapterError('Call data is required');
+    }
+
+    try {
+      return new Call({
+        id: callData.id,
+        integrationServiceId: callData.integrationServiceId,
+        actor: callData.actor,
+        channelId: callData.channelId,
+        createdTime: callData.createdTime,
+        direction: callData.direction,
+        sessionId: callData.sessionId,
+        status: callData.status,
+        meta: callData.meta,
+        participants: callData.participants,
+        session: callData.session,
+        statuses: callData.statuses,
+        duration: callData.duration
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt message: ${error.message}`);
+    }
+  }
+
+}

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

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

package/es/infrastructure/adapters/cannedMessages/CannedMessageAdapter.js

@@ -20,11 +20,13 @@ export default class CannedMessageAdapter extends IAdapter {
         isActive: cannedMessageData.isActive,
         isPrivate: cannedMessageData.isPrivate,
         translations: cannedMessageData.translations,
+        primaryLanguage: cannedMessageData.primaryLanguage,
         uuid: cannedMessageData.uuid,
         meta: cannedMessageData.meta,
         rejectedReason: cannedMessageData.rejectedReason,
         modifiedTime: cannedMessageData.modifiedTime,
-        parameters: cannedMessageData.parameters || null
+        parameters: cannedMessageData.parameters || null,
+        wabaId: cannedMessageData.wabaId
       }).toJSON();
     } catch (error) {
       throw new AdapterError(`Failed to adapt canned message: ${error.message}`);

package/es/infrastructure/adapters/cannedMessages/TranslationAdapter.js

@@ -0,0 +1,27 @@
+import { AdapterError } from '../../../core/errors';
+import { Translation } from '../../../domain/entities';
+import { IAdapter } from '../../../domain/interfaces';
+export default class TranslationAdapter extends IAdapter {
+  adapt(translationData) {
+    if (!translationData) {
+      throw new AdapterError('Translation data is required');
+    }
+
+    try {
+      return new Translation({
+        id: translationData.id,
+        language: translationData.language,
+        message: translationData.message,
+        displayMessage: translationData.displayMessage,
+        uuid: translationData.uuid,
+        status: translationData.status,
+        modifiedTime: translationData.modifiedTime,
+        failedReason: translationData.failedReason,
+        templateItems: translationData.templateItems
+      }).toJSON();
+    } catch (error) {
+      throw new AdapterError(`Failed to adapt translation: ${error.message}`);
+    }
+  }
+
+}

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

@@ -1,2 +1,3 @@
 import CannedMessageAdapter from './CannedMessageAdapter';
-export { CannedMessageAdapter };
+import TranslationAdapter from './TranslationAdapter';
+export { CannedMessageAdapter, TranslationAdapter };

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

@@ -8,18 +8,32 @@ export default class ChannelAdapter extends IAdapter {
     }
 
     try {
+      const {
+        integrationServiceId = '',
+        integrationService = {}
+      } = rawChannel;
+      const updatedIntegrationServiceId = integrationServiceId || integrationService.id;
       return new Channel({
         id: rawChannel.id,
-        integrationService: rawChannel.integrationService,
+        integrationServiceType: updatedIntegrationServiceId,
+        integrationServiceId: updatedIntegrationServiceId,
         name: rawChannel.name,
         defaultBotId: rawChannel.defaultBotId,
         isActive: rawChannel.isActive,
+        isDeleted: rawChannel.isDeleted,
+        isSandBox: rawChannel.isSandBox,
         createdTime: rawChannel.createdTime,
         accountName: rawChannel.accountName,
+        universalLink: rawChannel.universalLink,
         isSubscribed: rawChannel.isSubscribed,
         createdBy: rawChannel.createdBy,
         isOwner: rawChannel.isOwner,
-        photoURL: rawChannel.logoURL
+        photoURL: rawChannel.photoURL,
+        configParams: rawChannel.configParams,
+        authorizationPending: rawChannel.authorizationPending,
+        meta: rawChannel.meta,
+        logoURL: rawChannel.logoURL,
+        workspaceId: rawChannel.workspaceId
       }).toJSON();
     } catch (error) {
       throw new AdapterError(`Failed to adapt channel: ${error.message}`);

package/es/infrastructure/adapters/contacts/ContactAdapter.js

@@ -14,7 +14,10 @@ export default class ContactAdapter extends IAdapter {
         photoURL: contactData.photoURL,
         email: contactData.email,
         mobile: contactData.mobile,
-        phone: contactData.phone
+        phone: contactData.phone,
+        customFields: contactData.customFields,
+        webUrl: contactData.webUrl,
+        layoutId: contactData.layoutId
       }).toJSON();
     } catch (error) {
       throw new AdapterError(`Failed to adapt Contact: ${error.message}`);

package/es/infrastructure/adapters/index.js

@@ -7,4 +7,10 @@ export * from './agents';
 export * from './contacts';
 export * from './cannedMessages';
 export * from './templateMessages';
-export * from './customReplyExtension';
+export * from './customReplyExtension';
+export * from './placeholders';
+export * from './integrationServices';
+export * from './userPreferences';
+export * from './whatsAppPricing';
+export * from './calls';
+export * from './subscription';

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/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/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

@@ -1,2 +1,3 @@
 import SessionAdapter from './SessionAdapter';
-export { 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/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

@@ -1,3 +1,4 @@
 import TemplateLanguageAdapter from './TemplateLanguageAdapter';
 import TemplateCreditExhaustStatusAdapter from './TemplateCreditExhaustStatusAdapter';
-export { TemplateLanguageAdapter, 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

@@ -1,4 +1,4 @@
-import { ResponseTypes } from '../../core/constants';
+import { ModuleTypes, ResponseTypes } from '../../core/constants';
 import { ResponseUtils } from '../../core/utils';
 import configRegistry from '../config/configRegistry';
 import { getRegistryConfig } from './registry';
@@ -7,18 +7,19 @@ export default class BaseAPI {
   constructor() {
     let {
       module,
+      moduleType = ModuleTypes.AUTHENTICATED,
       configProvider = configRegistry,
       registryProvider = {
         getRegistryConfig
       },
-      urlBuilder = new UrlBuilder()
+      urlBuilder
     } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     this.configProvider = configProvider;
     this.registryProvider = registryProvider;
-    this.httpClient = this.configProvider.getHttpClient();
+    this.httpClient = moduleType === ModuleTypes.PUBLIC ? this.configProvider.getPublicHttpClient() : this.configProvider.getHttpClient();
     this.baseURL = this.configProvider.getBaseURL();
     this.module = module;
-    this.urlBuilder = urlBuilder;
+    this.urlBuilder = urlBuilder || new UrlBuilder(this.baseURL);
   }
 
   async request(_ref) {