@meltwater/conversations-api-services 1.0.19 → 1.0.21

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

@@ -0,0 +1,162 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.comment = comment;
+exports.deleteComment = deleteComment;
+exports.getPostData = getPostData;
+exports.getProfile = getProfile;
+exports.getStats = getStats;
+exports.hide = hide;
+exports.like = like;
+exports.reply = reply;
+exports.unhide = unhide;
+exports.unlike = unlike;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+var _externalIdHelpers = require("../../lib/externalId.helpers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const TIKTOK_API_URL = "https://business-api.tiktok.com/open_api/v1.3/business/";
+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;
+}
+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: (0, _externalIdHelpers.removePrefix)(videoId),
+    text
+  }, logger)) || {};
+  return publishedMessage;
+}
+async function like(token, externalId, sourceId, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/like/', {
+    business_id: (0, _externalIdHelpers.removePrefix)(sourceId),
+    comment_id: (0, _externalIdHelpers.removePrefix)(externalId),
+    action: 'LIKE'
+  }, logger)) || {};
+  return publishedMessage;
+}
+
+// Conversations says this is only allowed on Native...
+async function unlike(token, inReplyToId, sourceId, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/like/', {
+    business_id: (0, _externalIdHelpers.removePrefix)(sourceId),
+    comment_id: (0, _externalIdHelpers.removePrefix)(inReplyToId),
+    action: 'unlike'
+  }, logger)) || {};
+  return publishedMessage;
+}
+
+// Conversations says this is only allowed on Native...
+async function hide(token, externalId, sourceId, video_id, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/hide/', {
+    business_id: (0, _externalIdHelpers.removePrefix)(sourceId),
+    comment_id: (0, _externalIdHelpers.removePrefix)(externalId),
+    video_id: (0, _externalIdHelpers.removePrefix)(video_id),
+    action: 'HIDE'
+  }, logger)) || {};
+  return publishedMessage;
+}
+async function unhide(token, externalId, sourceId, video_id, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/hide/', {
+    business_id: (0, _externalIdHelpers.removePrefix)(sourceId),
+    comment_id: (0, _externalIdHelpers.removePrefix)(externalId),
+    video_id: (0, _externalIdHelpers.removePrefix)(video_id),
+    action: 'UNHIDE'
+  }, logger)) || {};
+  return publishedMessage;
+}
+async function deleteComment(token, inReplyToId, profileId, logger) {
+  const {
+    body: publishedMessage
+  } = (await sendPost(token, 'comment/delete/', {
+    business_id: profileId,
+    comment_id: inReplyToId
+  }, logger)) || {};
+  return publishedMessage;
+}
+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;
+}
+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
+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.default.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) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call tiktok api for paramString ${paramString}`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.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.default.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) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call tiktok api for paramString ${paramString}`, err);
+    }
+    throw err;
+  }
+  return response;
+}

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

@@ -0,0 +1,441 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TikTokApiClient = void 0;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _configuration = _interopRequireDefault(require("../../lib/configuration.js"));
+var _logger = _interopRequireDefault(require("../../lib/logger.js"));
+var _externalIdHelpers = require("../../lib/externalId.helpers.js");
+var _credentialsApiClient = require("../http/credentialsApi.client.js");
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class TikTokApiClient {
+  constructor() {
+    this.tiktokURL = _configuration.default.get('TIKTOK_API_URL');
+    this.credentialsAPI = new _credentialsApiClient.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.default.error(`${documentId} - error getting tiktok token - ${error.code}`, error, {
+        [_loggerHelpers.MeltwaterAttributes.DOCUMENTID]: documentId,
+        [_loggerHelpers.MeltwaterAttributes.COMPANYID]: companyId,
+        [_loggerHelpers.MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+    }
+  }
+  async sendPost(_ref) {
+    let {
+      paramString = '',
+      headers = {},
+      document,
+      postData = undefined
+    } = _ref;
+    let response = {};
+    try {
+      response = await _superagent.default.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.default.error(errorText);
+      } else {
+        errorText = `Failed to call tiktok api for paramString ${paramString}`;
+        _logger.default.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.default.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.default.error(errorText);
+      } else {
+        errorText = `Failed to call tiktok api for paramString ${paramString}`;
+        _logger.default.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    if (response.status !== 200) {
+      _logger.default.error(`Failed to call tiktok api for documentId ${document.documentId}`, response.body, {
+        [_loggerHelpers.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 = (0, _externalIdHelpers.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 = (0, _externalIdHelpers.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: (0, _externalIdHelpers.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.default.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.default.info(`Native Tiktok API Hide Response for documentId ${documentId}`, {
+        status: response.status,
+        ok: response.ok,
+        [_loggerHelpers.MeltwaterAttributes.DOCUMENTID]: documentId
+      });
+      if (response.message === 'OK') {
+        return response;
+      }
+    } catch (error) {
+      _logger.default.error(`${documentId} - error recieved - ${error.code}`, error, {
+        [_loggerHelpers.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: (0, _externalIdHelpers.removePrefix)(sourceId),
+        comment_id: (0, _externalIdHelpers.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: (0, _externalIdHelpers.removePrefix)(sourceId),
+        comment_id: (0, _externalIdHelpers.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: (0, _externalIdHelpers.removePrefix)(sourceId),
+        comment_id: (0, _externalIdHelpers.removePrefix)(comment_id),
+        video_id: (0, _externalIdHelpers.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: (0, _externalIdHelpers.removePrefix)(sourceId),
+        comment_id: (0, _externalIdHelpers.removePrefix)(comment_id),
+        video_id: (0, _externalIdHelpers.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;
+  }
+}
+exports.TikTokApiClient = TikTokApiClient;