@meltwater/conversations-api-services 1.0.19 → 1.0.20

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,29 @@
+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';
+const DocumentHelperFunctions = {
+  ...messageHelpers,
+  ...applicationTagFunctions,
+  ...hiddenHelpers
+};
+const LinkedInHelpers = {
+  getOrganization,
+  getProfile
+};
+export { FacebookNative, 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;
+}

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

@@ -0,0 +1,6 @@
+export function socialTypesThatCanBeHidden() {
+  return ['instagram', 'facebook', 'tiktok'];
+}
+export function isThisHiddenEligible(document) {
+  return socialTypesThatCanBeHidden().includes(document.metaData.source.socialOriginType);
+}

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

@@ -0,0 +1,112 @@
+import logger from '../lib/logger.js';
+import { IRClient } from '../data-access/http/ir.clien.jst';
+import XRunes from '@meltwater/xrunes';
+import xRunesCore from '@meltwater/xrunes-core';
+import { MeltwaterAttributes } from '../lib/logger.helpers.js';
+class HiddenCommentHelper {
+  constructor(_ref) {
+    let {
+      company,
+      user,
+      traceId
+    } = _ref;
+    this.irClient = new IRClient({
+      company,
+      user,
+      traceId
+    });
+    this.xRunes = new XRunes();
+    this.xRunes.registerLibrary(xRunesCore);
+  }
+  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.debug(`export api query: ${JSON.stringify(runes.query)}`, {
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let results = await this.irClient.export(runes);
+    logger.debug(`export api result: ${JSON.stringify(results)}`, {
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    return results;
+  }
+}
+export default HiddenCommentHelper;