@meltwater/conversations-api-services 1.0.18 → 1.0.20

package/dist/cjs/lib/hidden.helpers.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isThisHiddenEligible = isThisHiddenEligible;
+exports.socialTypesThatCanBeHidden = socialTypesThatCanBeHidden;
+function socialTypesThatCanBeHidden() {
+  return ['instagram', 'facebook', 'tiktok'];
+}
+function isThisHiddenEligible(document) {
+  return socialTypesThatCanBeHidden().includes(document.metaData.source.socialOriginType);
+}

package/dist/cjs/lib/hiddenComment.helper.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _logger = _interopRequireDefault(require("../lib/logger.js"));
+var _irClien = require("../data-access/http/ir.clien.jst");
+var _xrunes = _interopRequireDefault(require("@meltwater/xrunes"));
+var _xrunesCore = _interopRequireDefault(require("@meltwater/xrunes-core"));
+var _loggerHelpers = require("../lib/logger.helpers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class HiddenCommentHelper {
+  constructor(_ref) {
+    let {
+      company,
+      user,
+      traceId
+    } = _ref;
+    this.irClient = new _irClien.IRClient({
+      company,
+      user,
+      traceId
+    });
+    this.xRunes = new _xrunes.default();
+    this.xRunes.registerLibrary(_xrunesCore.default);
+  }
+  shouldHandle(message) {
+    return message.metaData.discussionType === 'qt';
+  }
+  async hideChildren(message, markHidden) {
+    let {
+      body: {
+        publishDate: {
+          date: publishDate
+        } = {}
+      } = {},
+      metaData: {
+        externalId,
+        source: {
+          socialOriginType
+        } = {}
+      } = {},
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {}
+    } = message;
+    let operation;
+    let query = {
+      type: 'x:match',
+      matchQuery: {
+        type: 'all',
+        allQueries: [{
+          type: 'x:dateRange',
+          field: 'body.publishDate.date',
+          from: publishDate
+        }, {
+          type: 'term',
+          field: 'metaData.inReplyTo.externalId',
+          value: externalId
+        }]
+      }
+    };
+    if (markHidden) {
+      operation = 'addToSet';
+      query.notMatchQuery = {
+        type: 'term',
+        field: 'metaData.applicationTags',
+        value: 'parentHidden'
+      };
+    } else {
+      operation = 'removeFromSet';
+      query.matchQuery.allQueries.push({
+        type: 'term',
+        field: 'metaData.applicationTags',
+        value: 'parentHidden'
+      });
+    }
+    let runes = {
+      query,
+      transformers: [{
+        type: 'idml',
+        script: `action = "update" target = "revision" revisionGroup = "${companyId}" documentId = id operations = [{"operation": "${operation}", "value": ["parentHidden"], "fieldPath": "metaData.applicationTags"}]`
+      }],
+      overlayGroups: [companyId],
+      fields: ['id'],
+      outputConfiguration: {
+        type: 's3',
+        region: 'eu-west-1',
+        roleArn: process.env.EXPORT_API_ROLE_ARN,
+        externalId: process.env.EXPORT_API_EXTERNAL_ID,
+        s3BucketName: process.env.EXPORT_API_S3_BUCKET,
+        s3KeyPrefix: process.env.EXPORT_API_S3_PREFIX,
+        // the property is optional, the trailing / isn't
+        batchSize: 1000 // the property is optional, must be >= 100 and <= 20000. Default is 20000
+      },
+      metaData: {
+        companyId
+      }
+    };
+    runes.query = await this.xRunes.render(runes.query);
+    _logger.default.debug(`export api query: ${JSON.stringify(runes.query)}`, {
+      [_loggerHelpers.MeltwaterAttributes.COMPANYID]: companyId,
+      [_loggerHelpers.MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let results = await this.irClient.export(runes);
+    _logger.default.debug(`export api result: ${JSON.stringify(results)}`, {
+      [_loggerHelpers.MeltwaterAttributes.COMPANYID]: companyId,
+      [_loggerHelpers.MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    return results;
+  }
+}
+var _default = exports.default = HiddenCommentHelper;

package/dist/cjs/lib/logger.helpers.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MeltwaterAttributes = void 0;
+exports.loggerDebug = loggerDebug;
+exports.loggerError = loggerError;
+exports.loggerInfo = loggerInfo;
+const MeltwaterAttributes = exports.MeltwaterAttributes = {
+  COMPANYID: 'meltwater.company.id',
+  // Unique identifier of a company as it applies to meltwater search
+  DOCUMENTID: 'meltwater.document.id',
+  // Unique identifier of a document indexed into search
+  DOCUMENTLANG: 'meltwater.document.lang',
+  // Two-letter country code (lower-case) of the original document
+  DOCUMENTEXTERNALID: 'meltwater.document.external_id',
+  // The external ID of the document
+  REQUESTFORMAT: 'meltwater.document.request_format',
+  // The document format requested (“gyda”/”quiddity”)
+  DOCUMENTIDS: 'meltwater.document_ids',
+  // A list of document Ids
+  SEARCHIDS: 'meltwater.search_ids',
+  // List of IDs of saved searches.
+  AUTHORLISTIDS: 'meltwater.authorlist_ids',
+  // List of IDs of author lists.
+  TAGNAMES: 'meltwater.tag_names',
+  // List of tag names
+  SEARCHID: 'meltwater.search.id',
+  // ID for a saved search
+  CREDENTIALID: 'meltwater.social.credential_id',
+  // Identifier for Owned and Paid Social Connections.
+  CREDENTIALIDS: 'meltwater.social.credential_ids',
+  // List of Credential IDs
+  SOCIALEXTERNALID: 'meltwater.social.external_id',
+  // External ID for Owned and Paid Social Connections.
+  ASSETID: 'meltwater.asset.id',
+  // Asset ID in the asset library
+  ASSETIDS: 'meltwater.asset.ids',
+  // List of Asset IDs
+  WORKSPACEID: 'meltwater.workspace.id',
+  // Workspace ID
+  PRODUCTTYPE: 'meltwater.product_type',
+  // The name of the product for the search request
+  CLIENTNAME: 'meltwater.client_name',
+  // The “client_name” identifier used for API calls
+  ORIGINALCLIENTNAME: 'meltwater.original_client_name',
+  // The originating “client_name” identifier used for API calls
+  AUTHKEYID: 'meltwater.auth.kid',
+  // The JWT Key ID for the request.
+  AUTHEXP: 'meltwater.auth.exp',
+  // The expiration of the auth credentials.
+  AUTHPERMISSIONS: 'meltwater.auth.permissions',
+  // List of auth permermissions.
+  USERID: 'user.id' // ID of the user
+};
+function loggerDebug(logger, message) {
+  let meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (logger) logger.debug(message, meta);
+}
+function loggerInfo(logger, message) {
+  let meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (logger) logger.info(message, meta);
+}
+function loggerError(logger, message) {
+  let meta = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (logger) logger.error(message, meta);
+}

package/dist/cjs/lib/logger.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _winston = _interopRequireDefault(require("winston"));
+var _ecsWinstonFormat = require("@elastic/ecs-winston-format");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const format = (0, _ecsWinstonFormat.ecsFormat)({
+  serviceName: process.env.NODE_ENV ? `conversations-api-services-${process.env.NODE_ENV}` : 'conversations-api-services',
+  serviceVersion: process.env.npm_package_version,
+  serviceEnvironment: process.env.NODE_ENV
+});
+const logger = _winston.default.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format,
+  defaultMeta: {},
+  transports: [new _winston.default.transports.Console({
+    format
+  })]
+});
+var _default = exports.default = logger;

package/dist/cjs/lib/message.helpers.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMention = isMention;
+function isMention(_ref, credential) {
+  let {
+    appData: {
+      isMention = false
+    } = {},
+    body: {
+      mentions = []
+    } = {},
+    metaData: {
+      authors: [{
+        authorInfo: {
+          externalId: authorExternalId,
+          handle: authorHandle
+        } = {}
+      } = {}] = [{}],
+      inReplyTo: {
+        author: {
+          externalId: inReplyToExternalId,
+          handle: inReplyToHandle
+        } = {}
+      } = {},
+      discussionType = '',
+      source: {
+        socialOriginType
+      } = {}
+    } = {},
+    providerSpecific
+  } = _ref;
+  if (socialOriginType == 'twitter' && discussionType != 'og') {
+    return false;
+  }
+  // if inReplyToExternalId is the same as the credential's social_account_id, then it's not a mention
+  if (inReplyToExternalId && credential.social_account_id && inReplyToExternalId === credential.social_account_id || inReplyToHandle === credential.username) {
+    return false;
+  }
+  if (authorExternalId && credential.social_account_id && authorExternalId === credential.social_account_id || authorHandle?.length && (authorHandle.toLowerCase() === credential.username?.toLowerCase || authorHandle.toLowerCase() === credential.handle?.toLowerCase())) {
+    return false;
+  }
+  let retIsMention = (['og', 're', 'qt'].includes(discussionType) || discussionType === 'dm' && socialOriginType === 'instagram') && (mentions?.length && mentions.some(mention => mention.toLowerCase() === credential.pageName?.toLowerCase() || mention.toLowerCase() === credential.target_page_name?.toLowerCase() || mention.toLowerCase() === credential.userName?.toLowerCase() || mention.toLowerCase() === credential.username?.toLowerCase()) || isMention && socialOriginType === 'facebook');
+  if (providerSpecific) {
+    let hasMention = providerSpecific.some(_ref2 => {
+      let {
+        facebookPostType
+      } = _ref2;
+      return facebookPostType === 'mention';
+    });
+    if (hasMention) {
+      retIsMention = true;
+    }
+  }
+  return retIsMention;
+}

package/dist/cjs/lib/metrics.helper.js

@@ -0,0 +1,97 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.metricN = exports.Metrics = void 0;
+var _promClient = _interopRequireDefault(require("prom-client"));
+var _logger = _interopRequireDefault(require("./logger.js"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const podMetricsByName = new Map();
+const metricNames = ['irGetByDocumentId', 'irRatelimited', 'irSearch'];
+
+// todo: make this a dynamic process
+const irGetByDocumentIdHistogram = new _promClient.default.Histogram({
+  name: 'irGetByDocumentId_Avg_Reponse_Time',
+  help: 'metric_help',
+  buckets: _promClient.default.linearBuckets(0, 200, 40)
+});
+const irGetByDocumentIdCountHistogram = new _promClient.default.Histogram({
+  name: 'irGetByDocumentId_Count',
+  help: 'metric_help',
+  buckets: _promClient.default.linearBuckets(0, 1, 40)
+});
+metricNames.forEach(metricName => {
+  podMetricsByName.set(metricName, new _promClient.default.Counter({
+    name: metricName,
+    help: `${metricName}_help`
+  }));
+});
+class Metrics {
+  constructor() {
+    this.requestMetricsByName = new Map();
+    metricNames.forEach(metricName => {
+      this.requestMetricsByName.set(metricName, []);
+    });
+    this.getMetrics = metricName => {
+      return {
+        podMetrics: podMetricsByName.get(metricName),
+        requestMetrics: this.requestMetricsByName.get(metricName)
+      };
+    };
+  }
+  count(metricName) {
+    const {
+      podMetrics,
+      requestMetrics
+    } = this.getMetrics(metricName);
+    if (podMetrics) {
+      podMetrics.inc();
+    } else {
+      _logger.default.error(`No pod level metric exists for ${metricName}`);
+    }
+    const metricObject = {
+      type: 'count',
+      timestamp: Date.now()
+    };
+    if (requestMetrics) {
+      requestMetrics.push(metricObject);
+    }
+    return metricObject;
+  }
+  finishOperation(metricName, metricObject) {
+    const {
+      requestMetrics
+    } = this.getMetrics(metricName);
+    if (requestMetrics) {
+      const matchingMetric = requestMetrics.find(requestMetricExiting => requestMetricExiting.timestamp === metricObject.timestamp);
+      matchingMetric.duration = Date.now() - matchingMetric.timestamp;
+    }
+  }
+  async somethingCompleted() {
+    let name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'IR.getByDocumentId';
+    let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  } // duration math
+  async finishRequest() {
+    const {
+      requestMetrics
+    } = this.getMetrics('irGetByDocumentId');
+    let arrHasDuration = requestMetrics.filter(metric => metric.duration);
+    if (arrHasDuration.length) {
+      let avgDuration = arrHasDuration.reduce((avg, metric) => avg + metric.duration, 0) / arrHasDuration.length;
+      irGetByDocumentIdHistogram.observe(avgDuration);
+    }
+    if (requestMetrics.length > 0) {
+      irGetByDocumentIdCountHistogram.observe(requestMetrics.length);
+    }
+  }
+}
+exports.Metrics = Metrics;
+function createEnum(values) {
+  const enumObject = {};
+  for (const val of values) {
+    enumObject[val] = val;
+  }
+  return Object.freeze(enumObject);
+}
+const metricN = exports.metricN = createEnum(metricNames);

package/dist/esm/data-access/http/InstagramVideoClient.js

@@ -0,0 +1,34 @@
+import superagent from 'superagent';
+import configuration from '../../lib/configuration.js';
+import logger from '../../lib/logger.js';
+export class InstagramVideoClient {
+  /**
+   * @private
+   * @param {string} url
+   * @returns {Promise<object>}
+   */
+  _getDownloadLink = async url => {
+    const apiUrl = configuration.get('UGC_MEDIA_API_URL');
+    const apiToken = configuration.get('UGC_MEDIA_API_TOKEN');
+    try {
+      const response = await superagent.get(`${apiUrl}/instagram/video/`).set('x-api-token', apiToken).query({
+        url
+      });
+      return response.body?.data;
+    } catch (error) {
+      logger.error(`Could not retrieve video link from ${url}`, {
+        error
+      });
+      throw new Error('Could not retrieve video link');
+    }
+  };
+
+  /**
+   *
+   * @param {string} url
+   * @returns {Promise<object>}
+   */
+  getVideoLink = async url => {
+    return await this._getDownloadLink(url);
+  };
+}

package/dist/esm/data-access/http/WarpZoneApi.client.js

@@ -0,0 +1,24 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+export class WarpZoneApiClient {
+  constructor() {
+    this.warpzoneURL = configuration.get('WARPZONE_API_URL');
+    this.warpzoneAPI = configuration.get('WARPZONE_API_KEY');
+  }
+  async sendPost() {
+    let postData = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
+    let response = {};
+    try {
+      response = await superagent.post(this.warpzoneURL + 'event').set('Accept', 'application/json').set('Content-Type', 'application/json').set('X-API-Key', this.warpzoneAPI).send(postData);
+    } catch (err) {
+      if (err && err.response && err.response.body && err.response.body.error) {
+        logger.error(`Failed to call warp zone api: ${err.response.body.error.message}`);
+      } else {
+        logger.error(`Failed to call warp zone api`, err);
+      }
+      throw err;
+    }
+    return response;
+  }
+}

package/dist/esm/data-access/http/amazonS3.js

@@ -0,0 +1,37 @@
+import AWS from 'aws-sdk';
+import assert from 'assert';
+class AWS_S3 {
+  constructor() {}
+  async getClient() {
+    const {
+      Credentials: {
+        AccessKeyId,
+        SecretAccessKey,
+        SessionToken
+      } = {}
+    } = await assetManagerTvmRepository.get(companyId);
+    if (!AccessKeyId || !SecretAccessKey || !SessionToken) {
+      // probably a bit extreme, what would you prefer to do
+      throw 'No Credentials available';
+    }
+    return new AWS.S3({
+      accessKeyId: AccessKeyId,
+      secretAccessKey: SecretAccessKey,
+      sessionToken: SessionToken,
+      useAccelerateEndpoint: true
+    });
+  }
+  GetS3ObjectQuery(bucket, filename) {
+    assert(bucket, 'S3 bucket is required');
+    assert(filename, 'filePath is required');
+    assert(typeof filename === 'string', 'filePath should be a string.');
+    return {
+      config: {
+        Bucket: bucket,
+        Key: filename.replace(`/${bucket}/`, ''),
+        GrantRead: 'uri=http://acs.amazonaws.com/groups/global/AllUsers'
+      }
+    };
+  }
+}
+export const awsS3Client = new AWS_S3();

package/dist/esm/data-access/http/asset-manager-tvm.client.js

@@ -0,0 +1,28 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+const {
+  ASSET_MANAGER_TVM_API_KEY,
+  ASSET_MANAGER_TVM_URL
+} = process.env;
+class AssetManagerTVMRepository {
+  apiKey;
+  constructor() {}
+  async get(companyId) {
+    let response;
+    try {
+      response = await superagent.get(`https://${ASSET_MANAGER_TVM_URL}/tvm`).query({
+        companyId
+      }).timeout(5000).set({
+        'x-api-key': ASSET_MANAGER_TVM_API_KEY
+      }).then(result => result.body);
+    } catch (error) {
+      logger.error("Failed requesting Asset Manager TVM API", error, {
+        [MeltwaterAttributes.COMPANYID]: companyId
+      });
+      throw error;
+    }
+    return response;
+  }
+}
+export const assetManagerTvmRepository = new AssetManagerTVMRepository();

package/dist/esm/data-access/http/companiesApi.client.js

@@ -0,0 +1,30 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class CompanyApiClient {
+  constructor(_ref) {
+    let {
+      services
+    } = _ref;
+    this.companiesApiUrl = configuration.get('COMPANIES_API_URL');
+    this.authService = services.auth;
+  }
+  async getById(companyId, jwt) {
+    let retries = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let company;
+    try {
+      let resignedToken = await this.authService.getResignedToken(jwt);
+      company = await superagent.get(`${this.companiesApiUrl}/${companyId}`).set('Authorization', resignedToken).set('x-client-name', configuration.get('CLIENT_NAME_HEADER')).then(result => result.body);
+    } catch (error) {
+      logger.error(`Failed requesting Companies Api for companyId ${companyId} retry ${retries}`, error, {
+        [MeltwaterAttributes.COMPANYID]: companyId
+      });
+      if (retries <= 3) {
+        return this.getById(companyId, jwt, ++retries);
+      }
+      return;
+    }
+    return company;
+  }
+}

package/dist/esm/data-access/http/credentialsApi.client.js

@@ -0,0 +1,92 @@
+import superagent from 'superagent'; // @todo remove superagent
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class CredentialsApiClient {
+  constructor() {
+    this.credentialsApiUrl = configuration.get('CREDENTIALS_API_URL');
+    this.credentialsApiApplicationId = configuration.get('CREDENTIALS_API_APPLICATION_ID');
+  }
+  async getCredential(_ref, userPermissionsEnabled) {
+    let {
+      companyId,
+      userId,
+      accountId,
+      productArea
+    } = _ref;
+    const credentials = await this.getCredentialsByCompany({
+      companyId,
+      userId,
+      productArea
+    }, userPermissionsEnabled);
+    if (!credentials) {
+      throw 'No credentials returned';
+    }
+    const credential = credentials.find(credential => credential.social_account_id == accountId);
+    if (!credential) {
+      throw `${sourceId} credential was not found.`;
+    }
+    return credential;
+  }
+  async getCredentialsByCompany(_ref2, userPermissionsEnabled) {
+    let {
+      companyId,
+      userId,
+      productArea
+    } = _ref2;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.USERID]: userId
+    });
+    let credentials;
+    try {
+      if (productArea) {
+        loggerChild.info(`Get Credentials for company: ${companyId} and user: ${userId}`);
+        credentials = await superagent.get(`${this.credentialsApiUrl}/api/v4.0/CompanyCredentials/${this.credentialsApiApplicationId}/${companyId}/${userId}`).query({
+          productArea
+        }).then(result => result.body.data);
+      } else if (userPermissionsEnabled) {
+        credentials = await superagent.get(`${this.credentialsApiUrl}/api/v4.0/CompanyCredentials/${this.credentialsApiApplicationId}/${companyId}/${userId}`).then(result => result.body.data);
+      } else {
+        credentials = await superagent.get(`${this.credentialsApiUrl}/api/v3.0/CompanyCredentials/${this.credentialsApiApplicationId}/${companyId}/${userId}`).then(result => result.body.data);
+      }
+    } catch (error) {
+      loggerChild.error(`Failed requesting Credentials API for companyId ${companyId} ${userId}`, error);
+      return [];
+    }
+    loggerChild.info(`Finished requesting Credentials API for companyId ${companyId}`);
+    return credentials;
+  }
+
+  // todo: will this need to ever use productArea?
+  async getToken(credentialId, companyId) {
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let token;
+    try {
+      token = await superagent.get(`${this.credentialsApiUrl}/api/Token/${credentialId}/${companyId}`).then(result => {
+        return result.body;
+      });
+    } catch (error) {
+      loggerChild.error(`Failed requesting Credentials API for credentialId ${credentialId} and companyId ${companyId}`, error);
+      return;
+    }
+    loggerChild.info(`Finished requesting Credentials API for credentialId ${credentialId} and companyId ${companyId}`);
+    return token;
+  }
+  async getCredentialIdByAccountId(accountId, channel) {
+    let credentialId;
+    try {
+      credentialId = await superagent.get(`${this.credentialsApiUrl}/api/CompanyCredentials/GetCredential/${channel}/${accountId}`).then(result => {
+        return result.body && result.body.data && result.body.data.credentialId;
+      });
+    } catch (error) {
+      logger.error(`Failed requesting Credentials API for credentialId ${accountId} and channel ${channel}`, error);
+      return;
+    }
+    logger.info(`Finished requesting Credentials API for credentialId ${accountId} and channel ${channel}`);
+    return credentialId;
+  }
+}

package/dist/esm/data-access/http/entitlementsApi.client.js

@@ -0,0 +1,32 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class EntitlementsApiClient {
+  constructor(_ref) {
+    let {
+      services
+    } = _ref;
+    this.entitlementsApiUrl = configuration.get('ENTITLEMENTS_API_URL');
+    this.authService = services.auth;
+  }
+  async getById(entitlementId, companyId, jwt) {
+    let retries = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: companyId
+    });
+    let entitlement;
+    try {
+      let resignedToken = await this.authService.getResignedToken(jwt);
+      entitlement = await superagent.get(`${this.entitlementsApiUrl}/company/${companyId}/${entitlementId}`).set('Authorization', resignedToken).set('x-client-name', configuration.get('CLIENT_NAME_HEADER')).then(result => result.body);
+    } catch (error) {
+      loggerChild.error(`Failed requesting entitlement ${entitlementId} for companyId ${companyId} retry ${retries}`, error);
+      if (retries <= 3) {
+        return this.getById(entitlementId, companyId, jwt, ++retries);
+      }
+      return;
+    }
+    loggerChild.info(`Finished requesting entitlement ${entitlementId} for companyId ${companyId}`);
+    return entitlement;
+  }
+}