@meltwater/conversations-api-services 1.0.22 → 1.0.23

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/linkedin.native.js

@@ -0,0 +1,387 @@
+import superagent from 'superagent';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+const LINKEDIN_API = "https://api.linkedin.com/v2";
+const LINKEDIN_API_VERSION = "2.0.0";
+export async function like(token, externalId, socialAccountId, logger) {
+  let response;
+  let payload = {
+    actor: socialAccountId,
+    object: externalId
+  };
+  let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(externalId)}/likes`;
+  try {
+    loggerDebug(logger, `Linkedin trying to Like `, {
+      query,
+      payload: JSON.stringify(payload)
+    });
+    response = await superagent.post(query).timeout(5000) // 5 seconds
+    .set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).send(payload);
+    loggerInfo(logger, `Native Linkedin API Like Mutation Response`, {
+      response: JSON.stringify(response)
+    });
+  } catch (err) {
+    loggerError(logger, `Linkedin Like or Unlike Exception`, err);
+    throw err;
+  }
+  return response.connection || response;
+}
+export 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 {
+    loggerDebug(logger, `Linkedin trying Delete Previous Like `, {
+      query,
+      payload: JSON.stringify(payload)
+    });
+    response = await superagent.delete(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+    loggerInfo(logger, `Native Linkedin API UNLike Mutation Response`, {
+      response: JSON.stringify(response)
+    });
+  } catch (err) {
+    loggerError(logger, `Linkedin Like or Unlike Exception`, err);
+    throw err;
+  }
+  return response.connection || response;
+}
+export 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 {
+    loggerDebug(logger, `Linkedin trying Delete `, {
+      query
+    });
+    response = await superagent.delete(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    });
+    loggerInfo(logger, `Native Linkedin API Delete Comment Response`, {
+      response: JSON.stringify(response)
+    });
+  } catch (err) {
+    loggerError(logger, `Linkedin Delete exception details`, {
+      err
+    });
+    throw err;
+  }
+  return response;
+}
+export async function comment(token, mediaId, inReplyToId, socialAccountId, messageText, logger) {
+  return publish(token, 'qt', mediaId, inReplyToId, socialAccountId, messageText, logger);
+}
+export 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.post(query).timeout(5000).set({
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+      'LinkedIn-Version': '202311'
+    }).send(body);
+    loggerInfo(logger, `Native Linkedin API Publish Comment Response`, {
+      response: JSON.stringify(response)
+    });
+    response = {
+      status: 200,
+      message: JSON.parse(response.text)
+    };
+    if (mediaId) {
+      loggerInfo(logger, `mediaId`, {
+        mediaId
+      });
+      downloadUrl = await getImageMedia(mediaId, token, logger);
+      loggerInfo(logger, `downloadUrl`, {
+        downloadUrl
+      });
+    }
+  } catch (err) {
+    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.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) {
+    loggerError(logger, 'Error in getImageMedia', error);
+  }
+  let {
+    downloadUrl
+  } = response.body || {};
+  if (downloadUrl) {
+    return {
+      downloadUrl
+    };
+  } else {
+    loggerError(logger, `Invalid response getting Linkedin media for mediaId: ${mediaId} `, {
+      response: JSON.stringify(response)
+    });
+    return {};
+  }
+}
+export 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.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) {
+    loggerError(logger, 'Error in getVideoMedia', error);
+  }
+  let {
+    thumbnail,
+    downloadUrl
+  } = response.body || {};
+  if (downloadUrl) {
+    return {
+      thumbnail,
+      downloadUrl
+    };
+  } else {
+    loggerError(logger, `Invalid response getting Linkedin media for mediaId: ${mediaId} `, {
+      response: JSON.stringify(response)
+    });
+    return {};
+  }
+}
+export 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) {
+    loggerError(logger, 'Error in getMedia', error);
+  }
+}
+export async function mediaUploadURL(token, socialAccountId, logger) {
+  let query = `${LINKEDIN_API}/images?action=initializeUpload`;
+  let body = {
+    initializeUploadRequest: {
+      owner: socialAccountId
+    }
+  };
+  let response;
+  try {
+    response = await superagent.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) {
+    loggerError(logger, `Exception linkedin media register `, err);
+  }
+}
+export async function getProfile(urn, token, logger) {
+  let [,,, id] = urn.split(':');
+  let profile;
+  try {
+    profile = await superagent.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) {
+    loggerError(logger, `Failed requesting LinkedIn API for profileId ${urn}`, error);
+    return;
+  }
+  loggerInfo(logger, `Finished requesting LinkedIn API for profileId ${urn}`);
+  return profile;
+}
+export async function getOrganization(urn, token, logger) {
+  let [,,, id] = urn.split(':');
+  let organization;
+  try {
+    organization = await superagent.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'
+      };
+    }
+    loggerError(logger, `Failed requesting LinkedIn API for organizationId ${urn}`, error);
+  }
+  loggerInfo(logger, `Finished requesting LinkedIn API for organizationId ${urn}`);
+  return organization;
+}
+async function getAllStats(externalId, token, logger) {
+  let response = {};
+  try {
+    response = await superagent.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) {
+    loggerError(logger, 'Error in getAllStats', error);
+  }
+  let {
+    commentSummary,
+    reactionSummaries
+  } = response.body || {};
+  if (commentSummary && reactionSummaries) {
+    return {
+      commentSummary,
+      reactionSummaries
+    };
+  } else {
+    loggerError(logger, `Invalid response getting all Linkedin Stats for externalId: ${externalId}`, {
+      response: JSON.stringify(response)
+    });
+    return {};
+  }
+}
+export 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) {
+    loggerError(logger, 'Error in getSocialStats', error);
+  }
+}
+export async function likedByUser(token, externalId, authorExternalId, logger) {
+  let result;
+  try {
+    result = await superagent.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) {
+    loggerError(logger, 'Error in getLikesByUser', error);
+    return false;
+  }
+  return true;
+}
+
+// query object is from AssetManager
+export async function uploadMedia(query, logger) {
+  const {
+    url,
+    token,
+    data
+  } = query;
+  return await superagent.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 => {
+    loggerError(logger, "Linkedin Error uploading Media", err);
+    throw err;
+  });
+}
+function fixedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/\(/g, '%28').replace(/\)/g, '%29');
+}

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

@@ -18,6 +18,7 @@ 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';
+import * as LinkedinNative from './http/linkedin.native.js';
 const DocumentHelperFunctions = {
   ...messageHelpers,
   ...applicationTagFunctions,
@@ -27,4 +28,4 @@ const LinkedInHelpers = {
   getOrganization,
   getProfile
 };
-export { FacebookNative, TiktokNative, awsS3Client, assetManagerTvmRepository, CompanyApiClient, CredentialsApiClient, EntitlementsApiClient, FacebookApiClient, FeatureToggleClient, IdentityServicesClient, InstagramApiClient, InstagramVideoClient, IRClient, LinkedInApiClient, TikTokApiClient, MasfClient, WarpZoneApiClient, DocumentHelperFunctions, LinkedInHelpers };
+export { FacebookNative, TiktokNative, LinkedinNative, awsS3Client, assetManagerTvmRepository, CompanyApiClient, CredentialsApiClient, EntitlementsApiClient, FacebookApiClient, FeatureToggleClient, IdentityServicesClient, InstagramApiClient, InstagramVideoClient, IRClient, LinkedInApiClient, TikTokApiClient, MasfClient, WarpZoneApiClient, DocumentHelperFunctions, LinkedInHelpers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltwater/conversations-api-services",
-  "version": "1.0.22",
+  "version": "1.0.23",
   "description": "Repository to contain all conversations api services shared across our services",
   "main": "dist/cjs/data-access/index.js",
   "module": "dist/esm/data-access/index.js",

package/src/data-access/http/linkedin.native.js

@@ -0,0 +1,530 @@
+
+import superagent from 'superagent';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+
+
+const LINKEDIN_API = "https://api.linkedin.com/v2";
+const LINKEDIN_API_VERSION = "2.0.0";
+
+export async function like(token, externalId, socialAccountId, logger) {
+    let response;
+    let payload = { actor: socialAccountId, object: externalId };
+    let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(externalId)}/likes`
+
+    try {
+        loggerDebug(logger,`Linkedin trying to Like `, {
+            query,
+            payload: JSON.stringify(payload),
+        });
+        response = await superagent
+            .post(query)
+            .timeout(5000) // 5 seconds
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .send(payload);
+        
+
+        loggerInfo(logger,
+            `Native Linkedin API Like Mutation Response`,
+            { response: JSON.stringify(response) }
+        );
+    } catch (err) {
+        loggerError(logger,`Linkedin Like or Unlike Exception`, err);
+        throw err;
+    }
+    return response.connection || response;
+}
+
+export 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 {
+        loggerDebug(logger,`Linkedin trying Delete Previous Like `, {
+            query,
+            payload: JSON.stringify(payload),
+        });
+        response = await superagent
+            .delete(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+
+        loggerInfo(logger,
+            `Native Linkedin API UNLike Mutation Response`,
+            { response: JSON.stringify(response) }
+        );
+    } catch (err) {
+        loggerError(logger,`Linkedin Like or Unlike Exception`, err);
+        throw err;
+    }
+    return response.connection || response;
+}
+
+export 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 {
+
+        loggerDebug(logger,`Linkedin trying Delete `, {
+            query,
+        });
+        response = await superagent
+            .delete(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+
+        loggerInfo(logger,
+            `Native Linkedin API Delete Comment Response`,
+            { response: JSON.stringify(response) }
+        );
+    } catch (err) {
+        loggerError(logger,`Linkedin Delete exception details`, {
+            err,
+        });
+        throw err;
+    }
+    return response;
+}
+
+export async function comment(token, mediaId,inReplyToId,socialAccountId, messageText, logger){
+    return publish(token,'qt', mediaId,inReplyToId,socialAccountId, messageText, logger)
+}
+export 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
+            .post(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .send(body);
+
+        loggerInfo(logger,
+            `Native Linkedin API Publish Comment Response`,
+            { response: JSON.stringify(response) }
+        );
+        response = {
+            status: 200,
+            message: JSON.parse(response.text),
+        };
+
+
+        if (mediaId) {
+            loggerInfo(logger,
+                `mediaId`,
+                { mediaId }
+            );
+            downloadUrl = await getImageMedia(
+                mediaId,
+                token,
+                logger
+            );
+            loggerInfo(logger,
+                `downloadUrl`,
+                { downloadUrl }
+            );
+        }
+        
+    } catch (err) {
+        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
+            .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) {
+        loggerError(logger,'Error in getImageMedia', error);
+    }
+
+    let { downloadUrl } = response.body || {};
+    if (downloadUrl) {
+        return { downloadUrl };
+    } else {
+        loggerError(logger,
+            `Invalid response getting Linkedin media for mediaId: ${mediaId} `,
+            { response: JSON.stringify(response) }
+        );
+        return {};
+    }
+}
+
+export 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
+            .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) {
+        loggerError(logger, 'Error in getVideoMedia', error);
+    }
+
+    let { thumbnail, downloadUrl } = response.body || {};
+    if (downloadUrl) {
+        return { thumbnail, downloadUrl };
+    } else {
+        loggerError(logger,
+            `Invalid response getting Linkedin media for mediaId: ${mediaId} `,
+            { response: JSON.stringify(response) }
+        );
+        return {};
+    }
+}
+
+export 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) {
+        loggerError(logger,'Error in getMedia', error);
+    }
+}
+
+export async function mediaUploadURL(
+    token,
+    socialAccountId,
+    logger
+) {
+    let query = `${LINKEDIN_API}/images?action=initializeUpload`;
+    let body = {
+        initializeUploadRequest: {
+            owner: socialAccountId,
+        },
+    };
+
+    let response;
+    try {
+        response = await superagent
+            .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) {
+        loggerError(logger,
+            `Exception linkedin media register `,
+            err
+        );
+    }
+}
+
+export async function getProfile(urn, token, logger) {
+    let [, , , id] = urn.split(':');
+
+    let profile;
+    try {
+        profile = await superagent
+            .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) {
+        loggerError(logger,
+            `Failed requesting LinkedIn API for profileId ${urn}`,
+            error
+        );
+        return;
+    }
+
+    loggerInfo( logger,
+        `Finished requesting LinkedIn API for profileId ${urn}`
+    );
+
+    return profile;
+}
+
+export async function getOrganization(urn, token, logger) {
+    let [, , , id] = urn.split(':');
+
+    let organization;
+    try {
+        organization = await superagent
+            .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' };
+        }
+
+        loggerError(logger,
+            `Failed requesting LinkedIn API for organizationId ${urn}`,
+            error
+        );
+    }
+
+    loggerInfo(logger,
+        `Finished requesting LinkedIn API for organizationId ${urn}`
+    );
+
+    return organization;
+}
+
+async function getAllStats(externalId, token, logger) {
+    let response = {};
+    try {
+        response = await superagent
+            .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) {
+        loggerError(logger,'Error in getAllStats', error);
+    }
+
+    let { commentSummary, reactionSummaries } = response.body || {};
+    if (commentSummary && reactionSummaries) {
+        return { commentSummary, reactionSummaries };
+    } else {
+        loggerError( logger,
+            `Invalid response getting all Linkedin Stats for externalId: ${externalId}`,
+            { response: JSON.stringify(response) }
+        );
+        return {};
+    }
+}
+
+export 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) {
+        loggerError(logger,'Error in getSocialStats', error);
+    }
+}
+
+export async function likedByUser(
+    token,
+    externalId,
+    authorExternalId,
+    logger
+) {
+    let result;
+    try {
+        result = await superagent
+            .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) {
+        loggerError(logger,'Error in getLikesByUser', error);
+        return false;
+    }
+    return true;
+}
+
+// query object is from AssetManager
+export async function uploadMedia(query, logger) {
+    const { url, token, data } = query;
+    return await superagent
+        .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) => {
+            loggerError(logger,"Linkedin Error uploading Media",err);
+            throw err;
+        });
+}
+
+
+function fixedEncodeURIComponent(str) {
+    return encodeURIComponent(str).replace(/\(/g, '%28').replace(/\)/g, '%29');
+}

package/src/data-access/index.js

@@ -18,6 +18,7 @@ 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';
+import * as LinkedinNative from './http/linkedin.native.js';
 
 const DocumentHelperFunctions = {
     ...messageHelpers,
@@ -32,6 +33,7 @@ const LinkedInHelpers = {
 export {
     FacebookNative,
     TiktokNative,
+    LinkedinNative,
     awsS3Client,
     assetManagerTvmRepository,
     CompanyApiClient,