@meltwater/conversations-api-services 1.0.21 → 1.0.23

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

@@ -101,7 +101,7 @@ async function privateMessage(token, _ref2, logger) {
     },
     tag: 'HUMAN_AGENT'
   }, logger);
-  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Publish Private Message Response for documentId ${documentId}`, {
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Publish Private Message Response`, {
     responseBody: JSON.stringify(response.body)
   });
   return response.body;

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

@@ -0,0 +1,406 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.comment = comment;
+exports.deleteMessage = deleteMessage;
+exports.getMedia = getMedia;
+exports.getOrganization = getOrganization;
+exports.getProfile = getProfile;
+exports.getSocialStats = getSocialStats;
+exports.getVideoMedia = getVideoMedia;
+exports.like = like;
+exports.likedByUser = likedByUser;
+exports.mediaUploadURL = mediaUploadURL;
+exports.reply = reply;
+exports.unlike = unlike;
+exports.uploadMedia = uploadMedia;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const LINKEDIN_API = "https://api.linkedin.com/v2";
+const LINKEDIN_API_VERSION = "2.0.0";
+async function like(token, externalId, socialAccountId, logger) {
+  let response;
+  let payload = {
+    actor: socialAccountId,
+    object: externalId
+  };
+  let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(externalId)}/likes`;
+  try {
+    (0, _loggerHelpers.loggerDebug)(logger, `Linkedin trying to Like `, {
+      query,
+      payload: JSON.stringify(payload)
+    });
+    response = await _superagent.default.post(query).timeout(5000) // 5 seconds
+    .set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).send(payload);
+    (0, _loggerHelpers.loggerInfo)(logger, `Native Linkedin API Like Mutation Response`, {
+      response: JSON.stringify(response)
+    });
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Linkedin Like or Unlike Exception`, err);
+    throw err;
+  }
+  return response.connection || response;
+}
+async function unlike(token, externalId, socialAccountId, logger) {
+  let response;
+  let payload = {
+    actor: socialAccountId,
+    object: externalId
+  };
+  let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(externalId)}/likes/${fixedEncodeURIComponent(payload.actor)}?actor=${fixedEncodeURIComponent(payload.actor)}`;
+  try {
+    (0, _loggerHelpers.loggerDebug)(logger, `Linkedin trying Delete Previous Like `, {
+      query,
+      payload: JSON.stringify(payload)
+    });
+    response = await _superagent.default.delete(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+    (0, _loggerHelpers.loggerInfo)(logger, `Native Linkedin API UNLike Mutation Response`, {
+      response: JSON.stringify(response)
+    });
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Linkedin Like or Unlike Exception`, err);
+    throw err;
+  }
+  return response.connection || response;
+}
+async function deleteMessage(token, externalId, sourceId, inReplyToId, logger) {
+  const [, comment] = externalId.split(',');
+  const commentId = comment.split(')')[0];
+  let response;
+  const query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(inReplyToId)}/comments/${commentId}?actor=${fixedEncodeURIComponent(sourceId)}`;
+  try {
+    (0, _loggerHelpers.loggerDebug)(logger, `Linkedin trying Delete `, {
+      query
+    });
+    response = await _superagent.default.delete(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+    (0, _loggerHelpers.loggerInfo)(logger, `Native Linkedin API Delete Comment Response`, {
+      response: JSON.stringify(response)
+    });
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Linkedin Delete exception details`, {
+      err
+    });
+    throw err;
+  }
+  return response;
+}
+async function comment(token, mediaId, inReplyToId, socialAccountId, messageText, logger) {
+  return publish(token, 'qt', mediaId, inReplyToId, socialAccountId, messageText, logger);
+}
+async function reply(token, mediaId, inReplyToId, socialAccountId, messageText, logger) {
+  return publish(token, 're', mediaId, inReplyToId, socialAccountId, messageText, logger);
+}
+async function publish(token, discussionType, mediaId, inReplyToId, socialAccountId, messageText, logger) {
+  // for now this is needed to make the urns from the images api work until the docs are updated to reflect how to use these new ids.
+  if (mediaId) {
+    mediaId = mediaId.replace('urn:li:image:', 'urn:li:digitalmediaAsset:');
+  }
+  let body = {
+    actor: socialAccountId,
+    message: {
+      attributes: [],
+      text: messageText
+    }
+  };
+  if (discussionType === 're') {
+    body.parentComment = inReplyToId;
+  }
+  if (mediaId) {
+    body.content = [{
+      entity: {
+        digitalmediaAsset: mediaId
+      },
+      type: 'IMAGE'
+    }];
+  }
+  let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(inReplyToId)}/comments`;
+
+  // data-listener -> linkedin_api.client sendComment
+  let response;
+  let downloadUrl = '';
+  try {
+    response = await _superagent.default.post(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).send(body);
+    (0, _loggerHelpers.loggerInfo)(logger, `Native Linkedin API Publish Comment Response`, {
+      response: JSON.stringify(response)
+    });
+    response = {
+      status: 200,
+      message: JSON.parse(response.text)
+    };
+    if (mediaId) {
+      (0, _loggerHelpers.loggerInfo)(logger, `mediaId`, {
+        mediaId
+      });
+      downloadUrl = await getImageMedia(mediaId, token, logger);
+      (0, _loggerHelpers.loggerInfo)(logger, `downloadUrl`, {
+        downloadUrl
+      });
+    }
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger`Exception in linkedin publish `, err);
+    throw err;
+  }
+  return {
+    response,
+    downloadUrl
+  };
+}
+async function getImageMedia(mediaId, token, logger) {
+  let response = {};
+  if (mediaId && mediaId.includes('digitalmediaAsset')) {
+    mediaId = mediaId.replace('urn:li:digitalmediaAsset:', 'urn:li:image:');
+  }
+  try {
+    response = await _superagent.default.get(LINKEDIN_API + '/images/' + fixedEncodeURIComponent(mediaId)).timeout(5000) // 5 seconds
+    .set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in getImageMedia', error);
+  }
+  let {
+    downloadUrl
+  } = response.body || {};
+  if (downloadUrl) {
+    return {
+      downloadUrl
+    };
+  } else {
+    (0, _loggerHelpers.loggerError)(logger, `Invalid response getting Linkedin media for mediaId: ${mediaId} `, {
+      response: JSON.stringify(response)
+    });
+    return {};
+  }
+}
+async function getVideoMedia(mediaId, token, logger) {
+  let response = {};
+  let tempValue;
+  if (mediaId && mediaId.includes('digitalmediaMediaArtifact')) {
+    tempValue = mediaId.split('digitalmediaMediaArtifact:(')[1];
+    tempValue = tempValue.split(',urn:li:digitalmediaMediaArtifactClass')[0];
+    mediaId = tempValue;
+  }
+  if (mediaId && mediaId.includes('digitalmediaAsset')) {
+    mediaId = mediaId.replace('urn:li:digitalmediaAsset:', 'urn:li:video:');
+  }
+  try {
+    response = await _superagent.default.get(LINKEDIN_API + '/videos/' + fixedEncodeURIComponent(mediaId)).timeout(5000) // 5 seconds
+    .set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in getVideoMedia', error);
+  }
+  let {
+    thumbnail,
+    downloadUrl
+  } = response.body || {};
+  if (downloadUrl) {
+    return {
+      thumbnail,
+      downloadUrl
+    };
+  } else {
+    (0, _loggerHelpers.loggerError)(logger, `Invalid response getting Linkedin media for mediaId: ${mediaId} `, {
+      response: JSON.stringify(response)
+    });
+    return {};
+  }
+}
+async function getMedia(token, mediaId, type, logger) {
+  // needed due to issue with polled data
+  if (type.includes('video') && mediaId.includes('image')) {
+    type = 'image/jpeg';
+  }
+  try {
+    if (type.includes('image')) {
+      const {
+        downloadUrl
+      } = await getImageMedia(mediaId, token, logger);
+      return {
+        downloadUrl
+      };
+    } else if (type.includes('video')) {
+      const {
+        thumbnail,
+        downloadUrl
+      } = await getVideoMedia(mediaId, token, logger);
+      return {
+        thumbnail,
+        downloadUrl
+      };
+    }
+    return {};
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in getMedia', error);
+  }
+}
+async function mediaUploadURL(token, socialAccountId, logger) {
+  let query = `${LINKEDIN_API}/images?action=initializeUpload`;
+  let body = {
+    initializeUploadRequest: {
+      owner: socialAccountId
+    }
+  };
+  let response;
+  try {
+    response = await _superagent.default.post(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'Content-type': 'application/json',
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).send(body);
+    response = {
+      status: 200,
+      message: JSON.parse(response.text)
+    };
+    return response;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Exception linkedin media register `, err);
+  }
+}
+async function getProfile(urn, token, logger) {
+  let [,,, id] = urn.split(':');
+  let profile;
+  try {
+    profile = await _superagent.default.get(`${LINKEDIN_API}/people/(id:${id})`).query({
+      projection: '(id,localizedFirstName,localizedLastName,vanityName,profilePicture(displayImage~:playableStreams))'
+    }).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).then(result => result.body);
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed requesting LinkedIn API for profileId ${urn}`, error);
+    return;
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Finished requesting LinkedIn API for profileId ${urn}`);
+  return profile;
+}
+async function getOrganization(urn, token, logger) {
+  let [,,, id] = urn.split(':');
+  let organization;
+  try {
+    organization = await _superagent.default.get(`${LINKEDIN_API}/organizations/${id}`).query({
+      projection: '(id,localizedName,vanityName,logoV2(original~:playableStreams))'
+    }).timeout(5000) // 5 seconds
+    .set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).then(result => result.body);
+  } catch (error) {
+    if (error.response.body.message.includes('ADMIN_ONLY')) {
+      return {
+        id: 'private'
+      };
+    }
+    (0, _loggerHelpers.loggerError)(logger, `Failed requesting LinkedIn API for organizationId ${urn}`, error);
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Finished requesting LinkedIn API for organizationId ${urn}`);
+  return organization;
+}
+async function getAllStats(externalId, token, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.get(LINKEDIN_API + '/socialMetadata/' + fixedEncodeURIComponent(externalId)).timeout(5000) // 5 seconds
+    .set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in getAllStats', error);
+  }
+  let {
+    commentSummary,
+    reactionSummaries
+  } = response.body || {};
+  if (commentSummary && reactionSummaries) {
+    return {
+      commentSummary,
+      reactionSummaries
+    };
+  } else {
+    (0, _loggerHelpers.loggerError)(logger, `Invalid response getting all Linkedin Stats for externalId: ${externalId}`, {
+      response: JSON.stringify(response)
+    });
+    return {};
+  }
+}
+async function getSocialStats(externalId, token, logger) {
+  try {
+    // get all stats (likes are not to be trusted) seems to only work
+    // for og posts.
+    const {
+      commentSummary,
+      reactionSummaries
+    } = await getAllStats(externalId, token, logger);
+    return {
+      commentSummary,
+      reactionSummaries
+    };
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in getSocialStats', error);
+  }
+}
+async function likedByUser(token, externalId, authorExternalId, logger) {
+  let result;
+  try {
+    result = await _superagent.default.get(`${LINKEDIN_API}/reactions/(actor:${fixedEncodeURIComponent(authorExternalId)},entity:${fixedEncodeURIComponent(externalId)})`).set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).then(result => result.body);
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error in getLikesByUser', error);
+    return false;
+  }
+  return true;
+}
+
+// query object is from AssetManager
+async function uploadMedia(query, logger) {
+  const {
+    url,
+    token,
+    data
+  } = query;
+  return await _superagent.default.put(url).set({
+    Accept: '*/*',
+    'Content-Type': 'application/octet-stream',
+    Authorization: `Bearer ${token}`,
+    'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+    'LinkedIn-Version': '202311'
+  }).send(data).catch(err => {
+    (0, _loggerHelpers.loggerError)(logger, "Linkedin Error uploading Media", err);
+    throw err;
+  });
+}
+function fixedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/\(/g, '%28').replace(/\)/g, '%29');
+}

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

@@ -65,7 +65,7 @@ Object.defineProperty(exports, "LinkedInApiClient", {
     return _linkedInApiClient.LinkedInApiClient;
   }
 });
-exports.LinkedInHelpers = void 0;
+exports.LinkedinNative = exports.LinkedInHelpers = void 0;
 Object.defineProperty(exports, "MasfClient", {
   enumerable: true,
   get: function () {
@@ -119,6 +119,8 @@ var FacebookNative = _interopRequireWildcard(require("./http/facebook.native.js"
 exports.FacebookNative = FacebookNative;
 var TiktokNative = _interopRequireWildcard(require("./http/tiktok.native.js"));
 exports.TiktokNative = TiktokNative;
+var LinkedinNative = _interopRequireWildcard(require("./http/linkedin.native.js"));
+exports.LinkedinNative = LinkedinNative;
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 const DocumentHelperFunctions = exports.DocumentHelperFunctions = {

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

@@ -82,7 +82,7 @@ export async function privateMessage(token, _ref2, logger) {
     },
     tag: 'HUMAN_AGENT'
   }, logger);
-  loggerInfo(logger, `Native Facebook API Publish Private Message Response for documentId ${documentId}`, {
+  loggerInfo(logger, `Native Facebook API Publish Private Message Response`, {
     responseBody: JSON.stringify(response.body)
   });
   return response.body;