@meltwater/conversations-api-services 1.0.19 → 1.0.21

package/dist/esm/data-access/http/linkedInApi.client.js

@@ -0,0 +1,481 @@
+import superagent from 'superagent';
+import configuration from '../../lib/configuration.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+import logger from '../../lib/logger.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class LinkedInApiClient {
+  constructor() {
+    this.credentialsAPI = new CredentialsApiClient();
+  }
+  async likeMessage(document) {
+    const {
+      documentId,
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          }
+        }
+      },
+      metaData: {
+        externalId,
+        source: {
+          id: socialAccountId
+        }
+      },
+      enrichments: {
+        socialScores: {
+          li_liked_by_user: likedByUser
+        }
+      }
+    } = document;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId,
+      [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId
+    });
+    let response;
+    let payload = {
+      actor: socialAccountId,
+      object: externalId
+    };
+    let query = likedByUser ? `${configuration.get('LINKEDIN_API')}/socialActions/${fixedEncodeURIComponent(externalId)}/likes` : `${configuration.get('LINKEDIN_API')}/socialActions/${fixedEncodeURIComponent(externalId)}/likes/${fixedEncodeURIComponent(payload.actor)}?actor=${fixedEncodeURIComponent(payload.actor)}`;
+    try {
+      let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+      if (!likedByUser) {
+        loggerChild.debug(`${documentId} - trying Delete `, {
+          query,
+          payload: JSON.stringify(payload)
+        });
+        response = await superagent.delete(query).timeout(5000).set({
+          Authorization: `Bearer ${credential.token}`,
+          'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+          'LinkedIn-Version': '202311'
+        });
+      } else {
+        loggerChild.debug(`${documentId} - sending to linkedin `, {
+          query,
+          payload: JSON.stringify(payload)
+        });
+        response = await superagent.post(query).timeout(5000) // 5 seconds
+        .set({
+          Authorization: `Bearer ${credential.token}`,
+          'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+          'LinkedIn-Version': '202311'
+        }).send(payload);
+      }
+      loggerChild.info(`Native Linkedin API Like Comment Response for documentId ${documentId}`, {
+        ok: response.ok,
+        status: response.status,
+        message: JSON.parse(response.text),
+        likedByUser
+      });
+    } catch (err) {
+      loggerChild.error(`${documentId} - exception details`, err);
+      throw err;
+    }
+    return response.connection || response;
+  }
+  async deleteMessage(document) {
+    const {
+      documentId,
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          }
+        }
+      },
+      metaData: {
+        externalId,
+        source: {
+          id: actorURN
+        },
+        inReplyTo: {
+          id: inReplyToId
+        }
+      }
+    } = document;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId,
+      [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId
+    });
+    const [, comment] = externalId.split(',');
+    const commentId = comment.split(')')[0];
+    let response;
+    let query = `${configuration.get('LINKEDIN_API')}/socialActions/${fixedEncodeURIComponent(inReplyToId)}/comments/${commentId}?actor=${fixedEncodeURIComponent(actorURN)}`;
+    try {
+      let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+      loggerChild.debug(`${documentId} - trying Delete `, {
+        query
+      });
+      response = await superagent.delete(query).timeout(5000).set({
+        Authorization: `Bearer ${credential.token}`,
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      });
+      loggerChild.info(`Native Linkedin API Delete Comment Response for documentId ${documentId}`, {
+        status: response.status,
+        ok: response.ok
+      });
+    } catch (err) {
+      let errorText = '';
+      if (err && err.response && err.response.text) {
+        errorText = `Call to linkedin api with documentId ${documentId} failed`;
+        loggerChild.error(errorText, {
+          message: JSON.parse(err.response.text)
+        });
+      } else {
+        errorText = `Call to linkedin api with documentId ${documentId} failed`;
+        loggerChild.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    return response;
+  }
+  async publishComment(document, mediaId) {
+    // command
+    const {
+      documentId,
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          }
+        }
+      },
+      body: {
+        content: {
+          text: messageText
+        }
+      },
+      metaData: {
+        discussionType,
+        inReplyTo: {
+          id: parentUrn
+        },
+        source: {
+          id: socialAccountId
+        }
+      }
+    } = document;
+    let messageType = discussionType === 're' ? 'reply' : 'comment';
+
+    // 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 (messageType === 'reply') {
+      body.parentComment = parentUrn;
+    }
+    if (mediaId) {
+      body.content = [{
+        entity: {
+          digitalmediaAsset: mediaId
+        },
+        type: 'IMAGE'
+      }];
+    }
+    let query = `${configuration.get('LINKEDIN_API')}/socialActions/${fixedEncodeURIComponent(parentUrn)}/comments`;
+
+    // data-listener -> linkedin_api.client sendComment
+    let response, updatedDocument;
+    try {
+      let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+      let response = await superagent.post(query).timeout(5000).set({
+        Authorization: `Bearer ${credential.token}`,
+        'Content-Type': 'application/json',
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      }).send(body);
+      response = {
+        status: 200,
+        message: JSON.parse(response.text)
+      };
+    } catch (err) {
+      logger.error(`${documentId} - exception linkedin publish`, err, {
+        [MeltwaterAttributes.DOCUMENTID]: documentId,
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+    }
+    return response;
+  }
+  async getMediaUploadURL(companyId, credentialId, socialAccountId, documentId) {
+    let query = `${configuration.get('LINKEDIN_API')}/images?action=initializeUpload`;
+    let body = {
+      initializeUploadRequest: {
+        owner: socialAccountId
+      }
+    };
+    let response;
+    try {
+      let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+      response = await superagent.post(query).timeout(5000).set({
+        Authorization: `Bearer ${credential.token}`,
+        'Content-type': 'application/json',
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      }).send(body);
+      response = {
+        status: 200,
+        message: JSON.parse(response.text)
+      };
+      return response;
+    } catch (err) {
+      logger.error(`${documentId} - exception linkedin media register`, err, {
+        [MeltwaterAttributes.DOCUMENTID]: documentId,
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+    }
+  }
+  async getAllStats(externalId, token) {
+    let response = {};
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId
+    });
+    try {
+      response = await superagent.get(configuration.get('LINKEDIN_API') + '/socialMetadata/' + fixedEncodeURIComponent(externalId)).timeout(5000) // 5 seconds
+      .set({
+        Authorization: `Bearer ${token}`,
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      });
+    } catch (error) {
+      loggerChild.error('Error in getAllStats', error);
+    }
+    let {
+      commentSummary,
+      reactionSummaries
+    } = response.body || {};
+    if (commentSummary && reactionSummaries) {
+      return {
+        commentSummary,
+        reactionSummaries
+      };
+    } else {
+      loggerChild.error(`Invalid response getting all Linkedin Stats for externalId = ${externalId}`, {
+        response: JSON.stringify(response)
+      });
+      return {};
+    }
+  }
+  async getSocialStats(externalId, token) {
+    try {
+      // get all stats (likes are not to be trusted) seems to only work
+      // for og posts.
+      const {
+        commentSummary,
+        reactionSummaries
+      } = await this.getAllStats(externalId, token);
+      return {
+        commentSummary,
+        reactionSummaries
+      };
+    } catch (error) {
+      logger.error('Error in getSocialStats', error, {
+        [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId
+      });
+    }
+  }
+  async getImageMedia(mediaId, credentialId, companyId) {
+    let response = {};
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+    if (mediaId && mediaId.includes('digitalmediaAsset')) {
+      mediaId = mediaId.replace('urn:li:digitalmediaAsset:', 'urn:li:image:');
+    }
+    try {
+      response = await superagent.get(configuration.get('LINKEDIN_API') + '/images/' + fixedEncodeURIComponent(mediaId)).timeout(5000) // 5 seconds
+      .set({
+        Authorization: `Bearer ${credential.token}`,
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      });
+    } catch (error) {
+      loggerChild.error('Error in getImageMedia', error);
+    }
+    let {
+      downloadUrl
+    } = response.body || {};
+    if (downloadUrl) {
+      return {
+        downloadUrl
+      };
+    } else {
+      loggerChild.error(`Invalid response getting Linkedin media for mediaId: ${mediaId}`, {
+        response: JSON.stringify(response)
+      });
+      return {};
+    }
+  }
+  async getVideoMedia(mediaId, credentialId, companyId) {
+    let response = {};
+    let tempValue;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+    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(configuration.get('LINKEDIN_API') + '/videos/' + fixedEncodeURIComponent(mediaId)).timeout(5000) // 5 seconds
+      .set({
+        Authorization: `Bearer ${credential.token}`,
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      });
+    } catch (error) {
+      loggerChild.error('Error in getVideoMedia', error);
+    }
+    let {
+      thumbnail,
+      downloadUrl
+    } = response.body || {};
+    if (downloadUrl) {
+      return {
+        thumbnail,
+        downloadUrl
+      };
+    } else {
+      loggerChild.error(`Invalid response getting Linkedin media for mediaId: ${mediaId}`, {
+        response: JSON.stringify(response)
+      });
+      return {};
+    }
+  }
+  async getMedia(mediaId, type, credentialId, companyId) {
+    // 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 this.getImageMedia(mediaId, credentialId, companyId);
+        return {
+          downloadUrl
+        };
+      } else if (type.includes('video')) {
+        const {
+          thumbnail,
+          downloadUrl
+        } = await this.getVideoMedia(mediaId, credentialId, companyId);
+        return {
+          thumbnail,
+          downloadUrl
+        };
+      }
+      return {};
+    } catch (error) {
+      logger.error('Error in getMedia', error, {
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+    }
+  }
+  async getLikedByUser(externalId, authorExternalId, credentialId, companyId) {
+    let result;
+    try {
+      let credential = await this.credentialsAPI.getToken(credentialId, companyId);
+      result = await superagent.get(`${configuration.get('LINKEDIN_API')}/reactions/(actor:${fixedEncodeURIComponent(authorExternalId)},entity:${fixedEncodeURIComponent(externalId)})`).set({
+        Authorization: `Bearer ${credential.token}`,
+        'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+        'LinkedIn-Version': '202311'
+      }).then(result => result.body);
+    } catch (error) {
+      logger.error('Error in getLikesByUser', error, {
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+      return false;
+    }
+    return true;
+  }
+  async uploadMedia(query) {
+    const {
+      socialAccountId,
+      url,
+      token,
+      data
+    } = query;
+    logger.info(`Starting to upload media to linkedin for ${socialAccountId}`, {
+      url: query.url
+    });
+    return await superagent.put(url).set({
+      Accept: '*/*',
+      'Content-Type': 'application/octet-stream',
+      Authorization: `Bearer ${token}`,
+      'X-RestLi-Protocol-Version': configuration.get('LINKEDIN_API_VERSION'),
+      'LinkedIn-Version': '202311'
+    }).send(data).catch(err => {
+      logger.error(err);
+      throw err;
+    });
+  }
+}
+export async function getProfile(urn, token) {
+  let [,,, id] = urn.split(':');
+  let profile;
+  try {
+    profile = await superagent.get(`${configuration.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': configuration.get('LINKEDIN_API_VERSION'),
+      'LinkedIn-Version': '202311'
+    }).then(result => result.body);
+  } catch (error) {
+    logger.error(`Failed requesting LinkedIn API for profileId ${urn}`, error);
+    return;
+  }
+  logger.info(`Finished requesting LinkedIn API for profileId ${urn}`);
+  return profile;
+}
+export async function getOrganization(urn, token) {
+  let [,,, id] = urn.split(':');
+  let organization;
+  try {
+    organization = await superagent.get(`${configuration.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': configuration.get('LINKEDIN_API_VERSION'),
+      'LinkedIn-Version': '202311'
+    }).then(result => result.body);
+  } catch (error) {
+    logger.error(`Failed requesting LinkedIn API for organizationId ${urn}`, error);
+  }
+  logger.info(`Finished requesting LinkedIn API for organizationId ${urn}`);
+  return organization;
+}
+function fixedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace('(', '%28').replace(')', '%29');
+}

package/dist/esm/data-access/http/masf.client.js

@@ -0,0 +1,93 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+export class MasfClient {
+  constructor() {
+    this.searchServicesUrlMasf = configuration.get('MASF_SEARCH_SERVICE_URL');
+    this.searchServicesVersionMasf = configuration.get('MASF_SEARCH_SERVICE_VERSION');
+    this.xClientName = configuration.get('CLIENT_NAME_HEADER');
+    this.authorListVersionMasf = 'v3';
+  }
+  async getSearches(_ref) {
+    let {
+      companyId,
+      token
+    } = _ref;
+    try {
+      let uri = `${this.searchServicesUrlMasf}/${this.searchServicesVersionMasf}/company/${companyId}/searches`;
+      return (await superagent.get(uri).set({
+        Authorization: `${token}`
+      })).body;
+    } catch (error) {
+      logger.error(`Failed requesting Search Services for search list `, error, {
+        [MeltwaterAttributes.COMPANYID]: companyId
+      });
+    }
+  }
+  async getAuthorsLists(_ref2) {
+    let {
+      companyId,
+      token
+    } = _ref2;
+    try {
+      let uri = `${this.searchServicesUrlMasf}/v3/companies/${companyId}/authorlists`;
+      return (await superagent.get(uri).set({
+        Authorization: `${token}`
+      }).set('x-client-name', this.xClientName)).body.sort((_ref3, _ref4) => {
+        let {
+          name: n1
+        } = _ref3;
+        let {
+          name: n2
+        } = _ref4;
+        if (n1.toUpperCase() < n2.toUpperCase()) {
+          return -1;
+        }
+        if (n1.toUpperCase() > n2.toUpperCase()) {
+          return 1;
+        }
+        return 0;
+      });
+    } catch (error) {
+      logger.error(`Failed requesting Search Services for author list `, error, {
+        [MeltwaterAttributes.COMPANYID]: companyId
+      });
+    }
+  }
+  async getAuthorsList(_ref5) {
+    let {
+      companyId,
+      authorListId,
+      token
+    } = _ref5;
+    try {
+      let uri = `${this.searchServicesUrlMasf}/${this.authorListVersionMasf}/companies/${companyId}/authorlists/${authorListId}`;
+      return (await superagent.get(uri).set({
+        Authorization: `${token}`
+      })).body;
+    } catch (error) {
+      logger.error(`Failed requesting Search Services for author list `, error, {
+        [MeltwaterAttributes.COMPANYID]: companyId
+      });
+    }
+  }
+  async getRune(_ref6) {
+    let {
+      searchId,
+      token
+    } = _ref6;
+    let rune;
+    try {
+      let uri = `${this.searchServicesUrlMasf}/${this.searchServicesVersionMasf}/search/getSavedSearchAsRunes/${searchId}`;
+      rune = await superagent.get(uri).set({
+        Authorization: `${token}`
+      });
+    } catch (error) {
+      logger.error(`Failed requesting Search Services for search list `, error);
+      return;
+    }
+    logger.info(`Finished requesting Search Services for rune ${this.searchServicesUrlMasf} searchId: ${searchId}`);
+    return rune.body;
+  }
+}