@meltwater/conversations-api-services 1.0.21 → 1.0.23

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.21",
+  "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/facebook.native.js

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