@meltwater/conversations-api-services 1.0.19 → 1.0.21

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;
+  }
+}

package/dist/esm/data-access/http/facebook.native.js

@@ -0,0 +1,325 @@
+import superagent from 'superagent';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+import { EngageHttpError } from '../../errors/http-error.js';
+import { EngageError } from '../../errors/engage-error.js';
+const FACEBOOK_URL = 'https://graph.facebook.com';
+export async function shareCount(token, externalId, logger) {
+  try {
+    const response = await getApi(`${FACEBOOK_URL}/${removePrefix(externalId)}/?fields=shares`, token);
+    return response.body.shares && response.body.shares.count;
+  } catch (err) {
+    loggerError(logger, `Facebook shareCount error recieved - ${error.code}`, error);
+  }
+}
+export async function reactions(token, externalIds, logger) {
+  try {
+    const response = await getApi(`${FACEBOOK_URL}?ids=${externalIds.map(externalId => removePrefix(externalId)).join(',')}&fields=` + `reactions.limit(0).summary(viewer_reaction).as(fb_post_reaction_of_user),` + `reactions.type(LOVE).limit(0).summary(total_count).as(fb_post_reactions_love),` + `reactions.type(WOW).limit(0).summary(total_count).as(fb_post_reactions_wow),` + `reactions.type(SAD).limit(0).summary(total_count).as(fb_post_reactions_sad),` + `reactions.type(LIKE).limit(0).summary(total_count).as(fb_post_reactions_like),` + `reactions.type(ANGRY).limit(0).summary(total_count).as(fb_post_reactions_angry),` + `reactions.type(HAHA).limit(0).summary(total_count).as(fb_post_reactions_haha)`, token);
+    return response.body;
+  } catch (error) {
+    loggerError(logger, `Facebook reactions error recieved - ${error.code}`, error);
+    return undefined;
+  }
+}
+export async function comment(token, _ref) {
+  let {
+    inReplyToExternalId,
+    text,
+    attachment = undefined
+  } = _ref;
+  let logger = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  let response;
+  const isGif = attachment && attachment.mimeType === 'image/gif';
+  loggerDebug(logger, `Starting to call facebook comment api inReplyToExternalId ${inReplyToExternalId}`, {
+    text,
+    attachment
+  });
+  response = await postApi(`${FACEBOOK_URL}/${removePrefix(inReplyToExternalId)}/comments`, token, {
+    ...(text && text.length && {
+      message: text
+    }),
+    ...(attachment && !isGif && {
+      attachment_url: attachment.link
+    }),
+    ...(attachment && isGif && {
+      attachment_share_url: attachment.link
+    })
+  }, logger);
+  loggerInfo(logger, `Native Facebook API Publish Comment Response to externalId ${inReplyToExternalId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function privateMessage(token, _ref2, logger) {
+  let {
+    recipientId,
+    text,
+    attachment = undefined
+  } = _ref2;
+  let response;
+  const isGif = attachment && attachment.mimeType === 'image/gif';
+  loggerDebug(logger, `Starting to call facebook PM api to recipientId ${recipientId}`, {
+    payload: JSON.stringify({
+      text,
+      attachment
+    })
+  });
+  response = await postApi(`${FACEBOOK_URL}/me/messages`, token, {
+    recipient: {
+      id: removePrefix(recipientId)
+    },
+    message: {
+      text: text,
+      ...(attachment && {
+        attachment: {
+          type: isGif ? 'video' : attachment.mimeType.split('/')[0],
+          payload: {
+            url: attachment.link,
+            is_reusable: true
+          }
+        }
+      })
+    },
+    tag: 'HUMAN_AGENT'
+  }, logger);
+  loggerInfo(logger, `Native Facebook API Publish Private Message Response for documentId ${documentId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function hide(token, externalId, logger) {
+  loggerDebug(logger, `Starting to call facebook hide api`);
+  const response = await postApi(`${FACEBOOK_URL}/${removePrefix(externalId)}`, token, {
+    is_hidden: true
+  }, logger);
+  loggerInfo(logger`Native Facebook API Hide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function unhide(token, externalId, logger) {
+  loggerDebug(logger, `Starting to call facebook unhide api`);
+  const response = await postApi(`${FACEBOOK_URL}/${removePrefix(externalId)}`, token, {
+    is_hidden: false
+  }, logger);
+  loggerChild.info(`Native Facebook API Unhide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function like(token, externalId, logger) {
+  loggerDebug(logger, `Starting to call facebook like api`);
+  const response = await postApi(`${FACEBOOK_URL}/${removePrefix(externalId)}/likes`, token, undefined, logger);
+  loggerInfo(logger, `Native Facebook API Like Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function unlike(token, externalId, logger) {
+  loggerDebug(logger, `Starting to call facebook unlike api`);
+  const response = await deleteApi(`${FACEBOOK_URL}/${removePrefix(externalId)}/likes`, token, undefined, logger);
+  loggerInfo(logger, `Native Facebook API Unlike Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function isUserBanned(token, authorId, pageId, logger) {
+  if (!pageId) {
+    // if no pageId to check this call will fail
+    // should only happen with temp edge docs
+    return false;
+  }
+  const response = await getApi(`${FACEBOOK_URL}/${pageId}/blocked`, token, undefined,
+  // payload
+  {
+    user: removePrefix(authorId)
+  }, logger);
+  if (response && response.body && response.body.data) {
+    const userNoPrefix = removePrefix(authorId);
+    const user = response.body.data.find(user => {
+      if (user.id == userNoPrefix) {
+        return user;
+      }
+    });
+    if (user) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  loggerInfo(logger, `Native Facebook API is User Banned Response was invalid`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return false;
+}
+export async function getProfile(token, authorId, logger) {
+  if (!authorId) {
+    return false;
+  }
+  let response = {};
+  const userNoPrefix = removePrefix(authorId);
+  try {
+    response = await superagent.get(`${FACEBOOK_URL}/${userNoPrefix}`).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: token
+    }).send();
+  } catch (err) {
+    if (err?.response?.body?.error) {
+      loggerError(logger, `Failed to call facebook api for userId ${userNoPrefix}: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call facebook api for userId ${userNoPrefix}`, err);
+    }
+    return null;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call facebook api for userId ${userNoPrefix}`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api for userId ${userNoPrefix}`);
+    error.code = response.status;
+    return null;
+  }
+  return response;
+}
+export async function ban(token, sourceId, authorId, logger) {
+  loggerDebug(logger, `Starting to call facebook ban api for externalAuthorId ${authorId} ${sourceId}`);
+  const response = await postApi(`${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`, token, {
+    psid: [removePrefix(authorId)]
+  }, logger);
+  loggerInfo(logger, `Native Facebook API Hide Response for externalAuthorId ${authorId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function unban(token, sourceId, authorId, logger) {
+  loggerDebug(logger, `Starting to call facebook unban api for externalAuthorId ${authorId} ${sourceId}`);
+  const response = await deleteApi(`${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`, token, {
+    psid: [removePrefix(authorId)]
+  }, logger);
+  loggerInfo(logger, `Native Facebook API Unban Response for externalAuthorId ${authorId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+export async function getAttachment(token, externalId, discussionType, logger) {
+  let result;
+  try {
+    switch (discussionType) {
+      case 're':
+      case 'qt':
+        result = await getApi(`${FACEBOOK_URL}/${removePrefix(externalId)}?fields=attachment`, token, undefined, undefined, logger);
+        return {
+          images: [{
+            source: result?.body?.attachment?.media?.source || result?.body?.attachment?.media?.image?.src
+          }]
+        };
+      case 'dm':
+        result = await getApi(`${FACEBOOK_URL}/${removePrefix(externalId)}?fields=attachments`, token, undefined, undefined, logger);
+        return {
+          images: result?.body?.attachments?.data.map(item => {
+            return {
+              source: item.image_data?.url
+            };
+          })
+        };
+      default:
+        // og
+        result = await getApi(`${FACEBOOK_URL}/${removePrefix(externalId)}/attachments?fields=media,subattachments,file_url`, token, undefined, undefined, logger);
+
+        // if subattachments exist, use them
+        const res = result?.body?.data[0];
+        if (res?.subattachments) {
+          return {
+            images: res?.subattachments.data.map(item => {
+              return {
+                source: item?.media?.source || item?.media?.image?.src
+              };
+            })
+          };
+        }
+        return {
+          images: [{
+            source: res?.media?.source || res?.media?.image?.src
+          }]
+        };
+    }
+  } catch (error) {
+    loggerError(logger, `Error getting facebook attachment`, error);
+    throw error;
+  }
+}
+async function getApi(apiUrl, accessToken, payload) {
+  let queryParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  let response = {};
+  try {
+    response = await superagent.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken,
+      ...queryParams
+    }).send(payload);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call facebook getApi ${apiUrl}: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call facebook getApi ${apiUrl}`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call facebook api ${apiUrl}`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api ${apiUrl}`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function postApi(apiUrl, accessToken, payload, logger) {
+  let response = {};
+  try {
+    response = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).send(payload);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call facebook api: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call facebook api`, err);
+    }
+    if (response.status) {
+      throw new EngageHttpError(response.status, response.statusText, response.body, response.headers);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    logger.error(logger, `Failed to call facebook api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    throw new EngageError(response.status, `Failed to call facebook api ${response.body}`);
+  }
+  return response;
+}
+async function deleteApi(apiUrl, accessToken, payload, logger) {
+  let response = {};
+  try {
+    response = await superagent.delete(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).send(payload);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call facebook api delete: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call facebook api delete`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call facebook api delete`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api delete`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}