@meltwater/conversations-api-services 1.0.19 → 1.0.21

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

@@ -0,0 +1,146 @@
+import superagent from 'superagent';
+import { loggerError } from '../../lib/logger.helpers.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+const TIKTOK_API_URL = "https://business-api.tiktok.com/open_api/v1.3/business/";
+export async function comment(token, business_id, video_id, text, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/create/', {
+    business_id: business_id,
+    video_id: video_id.startsWith('tt_') ? video_id.split('_')[2] : video_id,
+    text
+  }, logger)) || {};
+  return publishedMessage;
+}
+export async function reply(token, videoId, sourceId, inReplyToId, text, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/reply/create/', {
+    business_id: sourceId,
+    comment_id: inReplyToId,
+    video_id: removePrefix(videoId),
+    text
+  }, logger)) || {};
+  return publishedMessage;
+}
+export async function like(token, externalId, sourceId, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/like/', {
+    business_id: removePrefix(sourceId),
+    comment_id: removePrefix(externalId),
+    action: 'LIKE'
+  }, logger)) || {};
+  return publishedMessage;
+}
+
+// Conversations says this is only allowed on Native...
+export async function unlike(token, inReplyToId, sourceId, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/like/', {
+    business_id: removePrefix(sourceId),
+    comment_id: removePrefix(inReplyToId),
+    action: 'unlike'
+  }, logger)) || {};
+  return publishedMessage;
+}
+
+// Conversations says this is only allowed on Native...
+export async function hide(token, externalId, sourceId, video_id, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/hide/', {
+    business_id: removePrefix(sourceId),
+    comment_id: removePrefix(externalId),
+    video_id: removePrefix(video_id),
+    action: 'HIDE'
+  }, logger)) || {};
+  return publishedMessage;
+}
+export async function unhide(token, externalId, sourceId, video_id, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/hide/', {
+    business_id: removePrefix(sourceId),
+    comment_id: removePrefix(externalId),
+    video_id: removePrefix(video_id),
+    action: 'UNHIDE'
+  }, logger)) || {};
+  return publishedMessage;
+}
+export async function deleteComment(token, inReplyToId, profileId, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/delete/', {
+    business_id: profileId,
+    comment_id: inReplyToId
+  }, logger)) || {};
+  return publishedMessage;
+}
+export async function getProfile(token, business_id) {
+  let fields = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '["username", "display_name", "profile_image"]';
+  let logger = arguments.length > 3 ? arguments[3] : undefined;
+  const profile = (await sendRequest(token, `get/?business_id=${business_id}&fields=${fields}`, logger)) || {};
+  return profile;
+}
+export async function getStats(token, business_id, externalIds) {
+  let paramString = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'video/list/';
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  const profile = (await sendRequest(token, `${paramString}?business_id=${business_id}&fields=["item_id","create_time","thumbnail_url","share_url","embed_url","caption","video_views","likes","comments","shares"]&filters=${JSON.stringify({
+    video_ids: externalIds
+  })}`, logger)) || {};
+  return profile;
+}
+
+// This doesn't appear to be used in Conversations either
+export async function getPostData(token, business_id, video_id) {
+  let fields = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '["item_id", "thumbnail_url", "create_time", "username", "display_name", "profile_image"]';
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  const video_ids = `["${video_id}"]`;
+  const profile = (await sendRequest(token, `video/list?business_id=${business_id}&fields=${fields}&filters={"video_ids":${video_ids}}`, logger)) || {};
+  return profile;
+}
+
+// assumes batch calls are using the same credential
+async function sendRequest(token) {
+  let paramString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let logger = arguments.length > 2 ? arguments[2] : undefined;
+  let response = {};
+  try {
+    response = await superagent.get(TIKTOK_API_URL + paramString).set('Accept', 'application/json').set('Content-Type', 'application/json').set('Access-Token', token).send();
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call tiktok api for paramString ${paramString}`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    loggerError(logger, `Failed to call tiktok api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call tiktok api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response.body;
+}
+async function sendPost(token) {
+  let paramString = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
+  let postData = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  let logger = arguments.length > 3 ? arguments[3] : undefined;
+  let response = {};
+  try {
+    response = await superagent.post(TIKTOK_API_URL + paramString).set('Accept', 'application/json').set('Content-Type', 'application/json').set('Access-Token', token).send(postData);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      loggerError(logger, `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`);
+    } else {
+      loggerError(logger, `Failed to call tiktok api for paramString ${paramString}`, err);
+    }
+    throw err;
+  }
+  return response;
+}

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

@@ -0,0 +1,433 @@
+import superagent from 'superagent';
+import configuration from '../../lib/configuration.js';
+import logger from '../../lib/logger.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class TikTokApiClient {
+  constructor() {
+    this.tiktokURL = configuration.get('TIKTOK_API_URL');
+    this.credentialsAPI = new CredentialsApiClient();
+  }
+  async getAuthorization(document) {
+    const {
+      documentId,
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {}
+    } = document;
+    try {
+      const credential = await this.credentialsAPI.getToken(credentialId, companyId);
+      return `${credential.token}`;
+    } catch (error) {
+      logger.error(`${documentId} - error getting tiktok token - ${error.code}`, error, {
+        [MeltwaterAttributes.DOCUMENTID]: documentId,
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+    }
+  }
+  async sendPost(_ref) {
+    let {
+      paramString = '',
+      headers = {},
+      document,
+      postData = undefined
+    } = _ref;
+    let response = {};
+    try {
+      response = await superagent.post(this.tiktokURL + paramString).set('Accept', 'application/json').set('Content-Type', 'application/json').set('Access-Token', await this.getAuthorization(document)).send(postData);
+    } catch (err) {
+      let errorText = '';
+      if (err && err.response && err.response.body && err.response.body.error) {
+        errorText = `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`;
+        logger.error(errorText);
+      } else {
+        errorText = `Failed to call tiktok api for paramString ${paramString}`;
+        logger.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    return response;
+  }
+
+  // assumes batch calls are using the same credential
+  async sendRequest(_ref2) {
+    let {
+      paramString = '',
+      headers = {},
+      document
+    } = _ref2;
+    let response = {};
+    try {
+      response = await superagent.get(this.tiktokURL + paramString).set('Accept', 'application/json').set('Content-Type', 'application/json').set('Access-Token', await this.getAuthorization(document)).send();
+    } catch (err) {
+      let errorText = '';
+      if (err && err.response && err.response.body && err.response.body.error) {
+        errorText = `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`;
+        logger.error(errorText);
+      } else {
+        errorText = `Failed to call tiktok api for paramString ${paramString}`;
+        logger.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    if (response.status !== 200) {
+      logger.error(`Failed to call tiktok api for documentId ${document.documentId}`, response.body, {
+        [MeltwaterAttributes.DOCUMENTID]: document.documentId
+      });
+      let error = new Error(`Failed to call tiktok api for documentId ${document.documentId}`);
+      error.code = response.status;
+      throw error;
+    }
+    return response.body;
+  }
+  async getChannelInfoForDocuments(documents) {
+    const channelInfo = await this.getStatsForDocuments(documents, 'metaData.authors.0.authorInfo.externalId', {
+      og: ['video/list/']
+    });
+    return channelInfo;
+  }
+  async getStatsForDocuments(documents) {
+    let externalIdFrom = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'metaData.externalId';
+    let paramsByType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+      og: ['video/list/']
+    };
+    // for batching separate og and comment/reply requests per credential
+    const documentsByTypeAndCredentials = documents.reduce((retObj, document, index) => {
+      const paramArray = paramsByType[document.metaData.discussionType];
+      if (paramArray) {
+        paramArray.forEach(paramString => {
+          let discussionTypeBucket = retObj[`${paramString}${document.systemData.connectionsCredential}`];
+          if (!discussionTypeBucket) {
+            discussionTypeBucket = {
+              paramString,
+              document,
+              externalIds: [],
+              externalIdToDocumentIndex: {}
+            };
+            retObj[`${paramString}${document.systemData.connectionsCredential}`] = discussionTypeBucket;
+          }
+          const externalIdTrimmed = removePrefix(
+          // javascript weirdness to get around '.' notation
+          externalIdFrom.split('.').reduce((a, b) => a[b], document));
+          discussionTypeBucket.externalIds.push(externalIdTrimmed);
+          discussionTypeBucket.externalIdToDocumentIndex[externalIdTrimmed] = index;
+        });
+      }
+      return retObj;
+    }, {});
+    const sortedResults = Array(documents.length).fill();
+    await Promise.all(Object.values(documentsByTypeAndCredentials).map(async documentsByTypeAndCredential => {
+      if (documentsByTypeAndCredential.externalIds.length) {
+        const {
+          metaData: {
+            inReplyTo: {
+              profileId: business_id
+            }
+          }
+        } = documentsByTypeAndCredential.document;
+        const trimmedBusinessId = removePrefix(business_id);
+        const requestResult = await this.sendRequest({
+          paramString: `${documentsByTypeAndCredential.paramString}?business_id=${trimmedBusinessId}&fields=["item_id","create_time","thumbnail_url","share_url","embed_url","caption","video_views","likes","comments","shares"]&filters=${JSON.stringify({
+            video_ids: documentsByTypeAndCredential.externalIds
+          })}`,
+          document: documentsByTypeAndCredential.document
+        });
+        requestResult.data.videos.forEach(_ref3 => {
+          let {
+            item_id,
+            create_time,
+            thumbnail_url,
+            share_url,
+            embed_url,
+            caption,
+            video_views,
+            likes,
+            comments,
+            shares,
+            ...args
+          } = _ref3;
+          const documentIndex = documentsByTypeAndCredential.externalIdToDocumentIndex[item_id];
+          sortedResults[documentIndex] = {
+            ...sortedResults[documentIndex],
+            item_id,
+            create_time,
+            thumbnail_url,
+            externalId: documents[documentIndex].metaData.externalId,
+            share_url,
+            embed_url,
+            caption,
+            video_views,
+            likes,
+            comments,
+            shares
+          };
+        });
+      }
+    }));
+    return sortedResults;
+  }
+  async publish(message, videoId, markMessageAsCompleteDocumentId) {
+    const {
+      metaData: {
+        discussionType
+      }
+    } = message;
+    let publishedMessage;
+    switch (discussionType) {
+      case 'qt':
+        publishedMessage = await this.insertComment(message);
+        break;
+      case 're':
+        publishedMessage = await this.insertReply(videoId, message, markMessageAsCompleteDocumentId);
+        break;
+    }
+    return publishedMessage;
+  }
+  async insertComment(document) {
+    const {
+      body: {
+        content: {
+          text: text
+        }
+      },
+      metaData: {
+        source: {
+          id: business_id
+        },
+        inReplyTo: {
+          id: video_id
+        }
+      }
+    } = document;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/create/',
+      postData: {
+        business_id,
+        video_id,
+        text
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async insertReply(videoId, document, markMessageAsCompleteDocumentId) {
+    const {
+      body: {
+        content: {
+          text: text
+        }
+      },
+      metaData: {
+        inReplyTo: {
+          id: comment_id,
+          profileId: business_id
+        }
+      }
+    } = document;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/reply/create/',
+      postData: {
+        business_id: document.metaData.source.id,
+        comment_id: markMessageAsCompleteDocumentId || comment_id,
+        video_id: removePrefix(videoId),
+        text
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async toggleLike(document) {
+    const {
+      enrichments: {
+        socialScores: {
+          tt_liked_by_user: likedByUser
+        }
+      }
+    } = document;
+    try {
+      let likeResponse = await (!likedByUser ? this.like(document) : this.unlike(document));
+      return likeResponse;
+    } catch (error) {
+      logger.error(`${document} - error recieved - ${error.code}`, error);
+      throw error;
+    }
+  }
+  async toggleHide(document) {
+    let parentDoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+    const {
+      documentId,
+      appData: {
+        hidden: hiddenOnNative
+      }
+    } = document;
+    let response;
+    try {
+      if (hiddenOnNative) {
+        response = await this.hide(document, parentDoc);
+      } else {
+        response = await this.unhide(document, parentDoc);
+      }
+      logger.info(`Native Tiktok API Hide Response for documentId ${documentId}`, {
+        status: response.status,
+        ok: response.ok,
+        [MeltwaterAttributes.DOCUMENTID]: documentId
+      });
+      if (response.message === 'OK') {
+        return response;
+      }
+    } catch (error) {
+      logger.error(`${documentId} - error recieved - ${error.code}`, error, {
+        [MeltwaterAttributes.DOCUMENTID]: documentId
+      });
+    }
+  }
+  async like(document) {
+    const {
+      metaData: {
+        externalId: comment_id,
+        source: {
+          id: sourceId
+        }
+      }
+    } = document;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/like/',
+      postData: {
+        business_id: removePrefix(sourceId),
+        comment_id: removePrefix(comment_id),
+        action: 'LIKE'
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async unlike(document) {
+    const {
+      metaData: {
+        inReplyTo: {
+          id: comment_id
+        },
+        source: {
+          id: sourceId
+        }
+      }
+    } = document;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/like/',
+      postData: {
+        business_id: removePrefix(sourceId),
+        comment_id: removePrefix(comment_id),
+        action: 'unlike'
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async hide(document) {
+    let parentDoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+    const {
+      metaData: {
+        externalId: comment_id,
+        source: {
+          id: sourceId
+        },
+        discussionType
+      }
+    } = document;
+
+    //very small chance we get externalid instead of id
+    const video_id = discussionType === 're' ? parentDoc?.metaData?.inReplyTo?.id || parentDoc?.metaData?.inReplyTo?.externalId : document?.metaData?.inReplyTo?.id || document?.metaData?.inReplyTo?.externalId;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/hide/',
+      postData: {
+        business_id: removePrefix(sourceId),
+        comment_id: removePrefix(comment_id),
+        video_id: removePrefix(video_id),
+        action: 'HIDE'
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async unhide(document) {
+    let parentDoc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
+    const {
+      metaData: {
+        externalId: comment_id,
+        source: {
+          id: sourceId
+        },
+        discussionType
+      }
+    } = document;
+    const video_id = discussionType === 're' ? parentDoc?.metaData?.inReplyTo?.id : document?.metaData?.inReplyTo?.id;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/hide/',
+      postData: {
+        business_id: removePrefix(sourceId),
+        comment_id: removePrefix(comment_id),
+        video_id: removePrefix(video_id),
+        action: 'UNHIDE'
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async deleteComment(document) {
+    const {
+      metaData: {
+        inReplyTo: {
+          id: comment_id,
+          profileId: business_id
+        }
+      }
+    } = document;
+    const {
+      body: publishedMessage
+    } = (await this.sendPost({
+      paramString: 'comment/delete/',
+      postData: {
+        business_id,
+        comment_id
+      },
+      document
+    })) || {};
+    return publishedMessage;
+  }
+  async getProfile(business_id, document) {
+    const fields = '["username", "display_name", "profile_image"]';
+    const profile = (await this.sendRequest({
+      paramString: `get/?business_id=${business_id}&fields=${fields}`,
+      document
+    })) || {};
+    return profile;
+  }
+  async getPostData(business_id, video_id, document) {
+    const fields = '["item_id", "thumbnail_url", "create_time", "username", "display_name", "profile_image"]';
+    const video_ids = `["${video_id}"]`;
+    const profile = (await this.sendRequest({
+      paramString: `video/list?business_id=${business_id}&fields=${fields}&filters={"video_ids":${video_ids}}`,
+      document
+    })) || {};
+    return profile;
+  }
+}

package/dist/esm/data-access/index.js

@@ -0,0 +1,30 @@
+import { awsS3Client } from './http/amazonS3.js';
+import { assetManagerTvmRepository } from './http/asset-manager-tvm.client.js';
+import { CompanyApiClient } from './http/companiesApi.client.js';
+import { CredentialsApiClient } from './http/credentialsApi.client.js';
+import { EntitlementsApiClient } from './http/entitlementsApi.client.js';
+import { FacebookApiClient } from './http/facebookApi.client.js';
+import { FeatureToggleClient } from './http/featureToggleApi.client.js';
+import { IdentityServicesClient } from './http/identityServices.client.js';
+import { InstagramApiClient } from './http/instagramApi.client.js';
+import { InstagramVideoClient } from './http/InstagramVideoClient.js';
+import { IRClient } from './http/ir.client.js';
+import { LinkedInApiClient, getOrganization, getProfile } from './http/linkedInApi.client.js';
+import { TikTokApiClient } from './http/tiktokApi.client.js';
+import { MasfClient } from './http/masf.client.js';
+import { WarpZoneApiClient } from './http/WarpZoneApi.client.js';
+import * as messageHelpers from '../lib/message.helpers.js';
+import * as applicationTagFunctions from '../lib/applicationTags.helpers.js';
+import * as hiddenHelpers from '../lib/hidden.helpers.js';
+import * as FacebookNative from './http/facebook.native.js';
+import * as TiktokNative from './http/tiktok.native.js';
+const DocumentHelperFunctions = {
+  ...messageHelpers,
+  ...applicationTagFunctions,
+  ...hiddenHelpers
+};
+const LinkedInHelpers = {
+  getOrganization,
+  getProfile
+};
+export { FacebookNative, TiktokNative, awsS3Client, assetManagerTvmRepository, CompanyApiClient, CredentialsApiClient, EntitlementsApiClient, FacebookApiClient, FeatureToggleClient, IdentityServicesClient, InstagramApiClient, InstagramVideoClient, IRClient, LinkedInApiClient, TikTokApiClient, MasfClient, WarpZoneApiClient, DocumentHelperFunctions, LinkedInHelpers };

package/dist/esm/errors/engage-error.js

@@ -0,0 +1,9 @@
+export class EngageError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
+    this.code = code;
+  }
+}

package/dist/esm/errors/http-error.js

@@ -0,0 +1,16 @@
+import { EngageError } from "./engage-error";
+export class EngageHttpError extends EngageError {
+  status;
+  statusText;
+  response;
+  headers;
+  constructor(status, statusText, response, headers) {
+    super(`HTTP ${status}: ${statusText}`, statusText);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.name = this.constructor.name;
+    this.status = status;
+    this.statusText = statusText;
+    this.response = response;
+    this.headers = headers;
+  }
+}

package/dist/esm/lib/applicationTags.helpers.js

@@ -0,0 +1,22 @@
+export function parseApplicationTags(tags) {
+  const parsedTags = {};
+  if (!tags) {
+    return parsedTags;
+  }
+  tags.map(tag => {
+    const [key, value] = tag.split('=');
+    parsedTags[key] = value;
+  });
+  return parsedTags;
+}
+export function checkApplicationTagsForUserLikes(applicationTags) {
+  const appTags = parseApplicationTags(applicationTags);
+  if (appTags.userLikes === 'true') {
+    return true;
+  } else {
+    return false;
+  }
+}
+export function getCredentialIdFromApplicationTags(applicationTags) {
+  return applicationTags.find(appTag => appTag.startsWith('connectionsCredential=') || appTag.startsWith('connectionscredential='))?.substring(22);
+}

package/dist/esm/lib/configuration.js

@@ -0,0 +1,8 @@
+export default {
+  get: varName => {
+    const value = process.env[varName];
+    if (value === 'true') return true;
+    if (value === 'false') return false;
+    return value;
+  }
+};

package/dist/esm/lib/document-action-events.js

@@ -0,0 +1,6 @@
+export default {
+  MARK_AS_TODO: 'MARK_AS_TODO',
+  MARK_AS_COMPLETE: 'MARK_AS_COMPLETE',
+  USER_STARTED_RESPONDING: 'USER_STARTED_RESPONDING',
+  USER_STOPPED_RESPONDING: 'USER_STOPPED_RESPONDING'
+};

package/dist/esm/lib/externalId.helpers.js

@@ -0,0 +1,12 @@
+export function removePrefix(document) {
+  return document && document.replace(/id\:[a-zA-Z]+\.com:/g, '');
+}
+export function twitterPrefixCheck(socialOriginType, value) {
+  let result = value;
+  if (socialOriginType === 'twitter') {
+    if (!value.includes('id:twitter.com:')) {
+      result = 'id:twitter.com:' + value;
+    }
+  }
+  return result;
+}