@meltwater/conversations-api-services 1.0.19 → 1.0.21

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

@@ -0,0 +1,621 @@
+import superagent from 'superagent'; // @todo remove superagent
+import logger from '../../lib/logger.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+import { MeltwaterAttributes } from '../../lib/logger.helpers.js';
+const FACEBOOK_URL = 'https://graph.facebook.com';
+export class FacebookApiClient {
+  constructor() {
+    this.credentialsAPI = new CredentialsApiClient();
+  }
+
+  // assumes all documents are from same credential
+  async shareCount(documents) {
+    const {
+      documentId,
+      metaData: {
+        discussionType = 'og'
+      } = {},
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {}
+    } = documents;
+    if (discussionType !== 'og') {
+      return;
+    }
+    try {
+      const token = await this.credentialsAPI.getToken(credentialId, companyId);
+      const response = await this.getApi(`${FACEBOOK_URL}/${removePrefix(documents.metaData.externalId)}/?fields=shares`, token.token, documentId);
+      return response.body.shares && response.body.shares.count;
+    } catch (error) {
+      logger.error(`${documentId} - error recieved - ${error.code}`, error, {
+        [MeltwaterAttributes.DOCUMENTID]: documentId,
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+      return undefined;
+    }
+  }
+  async reactions(documents) {
+    const {
+      documentId,
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {}
+    } = documents[0];
+    try {
+      const token = await this.credentialsAPI.getToken(credentialId, companyId);
+      const response = await this.getApi(`${FACEBOOK_URL}?ids=${documents.map(doc => removePrefix(doc.metaData.externalId)).join(',')}&fields=` + `reactions.limit(0).summary(viewer_reaction).as(fb_post_reaction_of_user),` + `reactions.type(LOVE).limit(0).summary(total_count).as(fb_post_reactions_love),` + `reactions.type(WOW).limit(0).summary(total_count).as(fb_post_reactions_wow),` + `reactions.type(SAD).limit(0).summary(total_count).as(fb_post_reactions_sad),` + `reactions.type(LIKE).limit(0).summary(total_count).as(fb_post_reactions_like),` + `reactions.type(ANGRY).limit(0).summary(total_count).as(fb_post_reactions_angry),` + `reactions.type(HAHA).limit(0).summary(total_count).as(fb_post_reactions_haha)`, token.token, documentId);
+      return response.body;
+    } catch (error) {
+      logger.error(`${documentId} - error recieved - ${error.code}`, error, {
+        [MeltwaterAttributes.DOCUMENTID]: documentId,
+        [MeltwaterAttributes.COMPANYID]: companyId,
+        [MeltwaterAttributes.CREDENTIALID]: credentialId
+      });
+      return undefined;
+    }
+  }
+  async comment(accessToken, payload) {
+    let response;
+    const {
+      inReplyToId,
+      text,
+      documentId,
+      attachment
+    } = payload;
+    const isGif = attachment && attachment.mimeType === 'image/gif';
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    loggerChild.debug(`Starting to call facebook comment api for documentId ${documentId}`, {
+      payload: JSON.stringify(payload)
+    });
+    response = await this.postApi(`${FACEBOOK_URL}/${removePrefix(inReplyToId)}/comments`, accessToken.token, documentId, {
+      ...(text && text.length && {
+        message: text
+      }),
+      ...(attachment && !isGif && {
+        attachment_url: attachment.link
+      }),
+      ...(attachment && isGif && {
+        attachment_share_url: attachment.link
+      })
+    });
+    loggerChild.info(`Native Facebook API Publish Comment Response for documentId ${documentId}`, {
+      ok: response.ok,
+      status: response.status,
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    return response.body;
+  }
+  async privateMessage(accessToken, payload) {
+    let response;
+    const {
+      profileId,
+      recipientId,
+      text,
+      documentId,
+      attachment
+    } = payload;
+    const isGif = attachment && attachment.mimeType === 'image/gif';
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    loggerChild.debug(`Starting to call facebook messages api for documentId ${documentId}`, {
+      payload: JSON.stringify(payload)
+    });
+    response = await this.postApi(`${FACEBOOK_URL}/me/messages`, accessToken.token, documentId, {
+      recipient: {
+        id: removePrefix(profileId || recipientId)
+      },
+      message: {
+        text: text,
+        ...(attachment && {
+          attachment: {
+            type: isGif ? 'video' : attachment.mimeType.split('/')[0],
+            payload: {
+              url: attachment.link,
+              is_reusable: true
+            }
+          }
+        })
+      },
+      tag: 'HUMAN_AGENT'
+    });
+    loggerChild.info(`Native Facebook API Publish Private Message Response for documentId ${documentId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+  async getApi(apiUrl, accessToken, documentId, payload) {
+    let queryParams = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    let response = {};
+    try {
+      response = await superagent.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+        access_token: accessToken,
+        ...queryParams
+      }).send(payload);
+    } catch (err) {
+      let errorText = '';
+      if (err && err.response && err.response.body && err.response.body.error) {
+        errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+        loggerChild.error(errorText);
+      } else {
+        errorText = `Failed to call facebook api for documentId ${documentId}`;
+        loggerChild.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    if (response.status !== 200) {
+      loggerChild.error(`Failed to call facebook api for documentId ${documentId}`, {
+        response: JSON.stringify(response.body)
+      });
+      let error = new Error(`Failed to call facebook api for documentId ${documentId}`);
+      error.code = response.status;
+      throw error;
+    }
+    return response;
+  }
+  async postApi(apiUrl, accessToken, documentId, payload) {
+    let response = {};
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    try {
+      response = await superagent.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+        access_token: accessToken
+      }).send(payload);
+    } catch (err) {
+      let errorText = '';
+      if (err && err.response && err.response.body && err.response.body.error) {
+        errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+        loggerChild.error(errorText);
+      } else {
+        errorText = `Failed to call facebook api for documentId ${documentId}`;
+        loggerChild.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    if (response.status !== 200) {
+      loggerChild.error(`Failed to call facebook api for documentId ${documentId}`, {
+        response: JSON.stringify(response.body)
+      });
+      let error = new Error(`Failed to call facebook api for documentId ${documentId}`);
+      error.code = response.status;
+      throw error;
+    }
+    return response;
+  }
+  async deleteApi(apiUrl, accessToken, documentId, payload) {
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    let response = {};
+    try {
+      response = await superagent.delete(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+        access_token: accessToken
+      }).send(payload);
+    } catch (err) {
+      let errorText = '';
+      if (err && err.response && err.response.body && err.response.body.error) {
+        errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+        loggerChild.error(errorText);
+      } else {
+        errorText = `Failed to call facebook api for documentId ${documentId}`;
+        loggerChild.error(errorText, err);
+      }
+      throw new Error(errorText);
+    }
+    if (response.status !== 200) {
+      loggerChild.error(`Failed to call facebook api for documentId ${documentId}`, {
+        response: JSON.stringify(response.body)
+      });
+      let error = new Error(`Failed to call facebook api for documentId ${documentId}`);
+      error.code = response.status;
+      throw error;
+    }
+    return response;
+  }
+  async publish(document) {
+    const {
+      documentId,
+      body: {
+        content: {
+          text
+        }
+      },
+      attachments: [attachment] = [],
+      metaData: {
+        discussionType,
+        inReplyTo: {
+          id: inReplyToId,
+          recipientId,
+          profileId
+        }
+      },
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {}
+    } = document;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let updatedDocument;
+    let apiResponse;
+    try {
+      const token = await this.credentialsAPI.getToken(credentialId, companyId);
+      loggerChild.debug(`finished fetching token for Facebook for ${documentId} on company ${companyId}`);
+      let payload;
+      switch (discussionType) {
+        case 'qt':
+        case 're':
+          payload = {
+            documentId,
+            companyId,
+            credentialId,
+            text,
+            inReplyToId,
+            attachment
+          };
+          apiResponse = await this.comment(token, payload);
+          break;
+        case 'dm':
+          payload = {
+            documentId,
+            companyId,
+            credentialId,
+            text,
+            recipientId,
+            profileId,
+            attachment
+          };
+          apiResponse = await this.privateMessage(token, payload);
+          break;
+        default:
+          throw new Error('Unsupported discussion type');
+      }
+      if (apiResponse) {
+        let findQuery = {
+          documentId
+        };
+        findQuery['systemData.policies.storage.privateTo'] = companyId;
+        let updateObj = {};
+        updateObj['systemData.status'] = DOCUMENT_STATUS.SUCCESS;
+        updateObj['metaData.externalId'] = apiResponse.id || apiResponse.message_id;
+        updateObj.documentId = Buffer.from(`${updateObj['metaData.externalId']}`).toString('base64');
+        updatedDocument = await messagesRepository.updateOne(findQuery, updateObj);
+      } else {
+        throw new Error('Invalid response from Facebook publish endpoints');
+      }
+    } catch (exception) {
+      loggerChild.error(`${documentId} - exception details`, exception);
+      let findQuery = {
+        documentId
+      };
+      findQuery['systemData.policies.storage.privateTo'] = companyId;
+      let updateQuery = {};
+      updateQuery['systemData.status'] = DOCUMENT_STATUS.FAILED;
+      updateQuery['systemData.error'] = exception && exception.response && exception.response.error ? exception.response.error : exception;
+      updatedDocument = await messagesRepository.updateOne(findQuery, updateQuery);
+    }
+    return apiResponse;
+  }
+  async toggleHide(document) {
+    const {
+      documentId,
+      appData: {
+        hidden: hiddenOnNative
+      },
+      metaData: {
+        externalId
+      },
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {},
+      version
+    } = document;
+    let hideResponse;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    try {
+      loggerChild.debug(`processing Facebook Version ${version} for documentID ${documentId} on company ${companyId}`);
+      const token = await this.credentialsAPI.getToken(credentialId, companyId);
+      loggerChild.debug(`finished fetching token for facebook for ${documentId} on company ${companyId} `);
+      if (hiddenOnNative) {
+        hideResponse = await this.hide(token, {
+          externalId,
+          documentId
+        });
+      } else {
+        hideResponse = await this.unhide(token, {
+          externalId,
+          documentId
+        });
+      }
+      loggerChild.debug(`finished hiding in facebook for ${documentId} on company ${companyId} `, {
+        hideResponse: JSON.stringify(hideResponse)
+      });
+      return hideResponse;
+    } catch (error) {
+      loggerChild.error(`${documentId} - error recieved - ${error.code}`, error);
+    }
+  }
+  async toggleBan(document, banStatus) {
+    let {
+      documentId,
+      metaData: {
+        source: {
+          id: sourceId
+        },
+        authors: authors
+      },
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {},
+      version
+    } = document;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    let banResponse;
+    let authorId = authors[0].authorInfo.externalId;
+    try {
+      loggerChild.debug(`processing Facebook Version ${version} for profileId ${authorId} on company ${companyId}`);
+      const token = await this.credentialsAPI.getToken(credentialId, companyId);
+      loggerChild.debug(`finished fetching token for facebook for ${authorId} on company ${companyId} `);
+      if (!banStatus) {
+        banResponse = await this.unban(token, {
+          sourceId,
+          authorId
+        });
+      } else if (banStatus) {
+        banResponse = await this.ban(token, {
+          sourceId,
+          authorId
+        });
+      }
+      loggerChild.debug(`finished banning in facebook for ${authorId} on company ${companyId} `, {
+        banResponse: JSON.stringify(banResponse)
+      });
+    } catch (error) {
+      loggerChild.error(`${authorId} - error recieved - ${error.code}`, error);
+    }
+  }
+  async toggleLike(document) {
+    const {
+      documentId,
+      enrichments: {
+        socialScores: {
+          fb_liked_by_user: likedByUser
+        }
+      },
+      metaData: {
+        externalId
+      },
+      systemData: {
+        connectionsCredential: credentialId,
+        policies: {
+          storage: {
+            privateTo: companyId
+          } = {}
+        } = {}
+      } = {},
+      version
+    } = document;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId
+    });
+    try {
+      loggerChild.debug(`processing Facebook Version ${version} for documentID ${documentId}`);
+      loggerChild.debug(`starting to fetch tokens for facebook for ${documentId} on company ${companyId} `);
+      const token = await this.credentialsAPI.getToken(credentialId, companyId);
+      loggerChild.debug(`finished fetching token for facebook for ${documentId} on company ${companyId} `);
+      let likeResponse = await (likedByUser ? this.like(token, {
+        externalId,
+        documentId
+      }) : this.unlike(token, {
+        externalId,
+        documentId
+      }));
+      loggerChild.debug(`finished liking in facebook for ${documentId} on company ${companyId} `, {
+        likeResponse: JSON.stringify(likeResponse)
+      });
+    } catch (error) {
+      loggerChild.error(`${document} - error recieved - ${error.code}`, error);
+      throw error;
+    }
+  }
+  async like(accessToken, command) {
+    let response;
+    const {
+      externalId,
+      documentId
+    } = command;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    loggerChild.debug(`Starting to call facebook like api for documentId ${documentId}`, {
+      command: JSON.stringify(command)
+    });
+    response = await this.postApi(`${FACEBOOK_URL}/${removePrefix(externalId)}/likes`, accessToken.token, documentId);
+    loggerChild.info(`Native Facebook API Like Response for documentId ${documentId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+  async unlike(accessToken, command) {
+    let response;
+    const {
+      externalId,
+      documentId
+    } = command;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId
+    });
+    loggerChild.debug(`Starting to call facebook unlike api for documentId ${documentId}`, {
+      command: JSON.stringify(command)
+    });
+    response = await this.deleteApi(`${FACEBOOK_URL}/${removePrefix(externalId)}/likes`, accessToken.token, documentId);
+    loggerChild.info(`Native Facebook API Unlike Response for documentId ${documentId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+  async hide(accessToken, command) {
+    let response;
+    const {
+      externalId,
+      documentId
+    } = command;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId
+    });
+    loggerChild.debug(`Starting to call facebook hide api for documentId ${documentId}`, {
+      command: JSON.stringify(command)
+    });
+    response = await this.postApi(`${FACEBOOK_URL}/${removePrefix(externalId)}`, accessToken.token, documentId, {
+      is_hidden: true
+    });
+    loggerChild.info(`Native Facebook API Hide Response for documentId ${documentId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+  async unhide(accessToken, command) {
+    let response;
+    const {
+      externalId,
+      documentId
+    } = command;
+    const loggerChild = logger.child({
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.DOCUMENTEXTERNALID]: externalId
+    });
+    loggerChild.debug(`Starting to call facebook unhide api for documentId ${documentId}`, {
+      command: JSON.stringify(command)
+    });
+    response = await this.postApi(`${FACEBOOK_URL}/${removePrefix(externalId)}`, accessToken.token, documentId, {
+      is_hidden: false
+    });
+    loggerChild.info(`Native Facebook API Unhide Response for documentId ${documentId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+  async isUserBanned(_ref) {
+    let {
+      credentialId,
+      companyId,
+      userId,
+      pageId
+    } = _ref;
+    const token = await this.credentialsAPI.getToken(credentialId, companyId);
+    const response = await this.getApi(`${FACEBOOK_URL}/${pageId}/blocked`, token.token, `${companyId}-${credentialId}-${userId}-${pageId}`, undefined,
+    // payload
+    {
+      user: removePrefix(userId)
+    });
+    if (response && response.body && response.body.data) {
+      const userNoPrefix = removePrefix(userId);
+      const user = response.body.data.find(user => {
+        if (user.id == userNoPrefix) {
+          return user;
+        }
+      });
+      if (user) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    logger.info(`Native Facebook API is User Banned Response was invalid for userId ${userId} ${credentialId}`, {
+      ok: response.ok,
+      status: response.status,
+      [MeltwaterAttributes.DOCUMENTID]: documentId,
+      [MeltwaterAttributes.CREDENTIALID]: credentialId,
+      [MeltwaterAttributes.COMPANYID]: companyId,
+      [MeltwaterAttributes.USERID]: userId
+    });
+    return false;
+  }
+  async ban(accessToken, command) {
+    let response;
+    const {
+      sourceId,
+      authorId
+    } = command;
+    logger.debug(`Starting to call facebook ban api for externalAuthorId ${authorId}`, {
+      command: JSON.stringify(command)
+    });
+    response = await this.postApi(`${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`, accessToken.token, removePrefix(authorId), {
+      psid: [removePrefix(authorId)]
+    });
+    logger.info(`Native Facebook API Hide Response for externalAuthorId ${authorId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+  async unban(accessToken, command) {
+    let response;
+    const {
+      sourceId,
+      authorId
+    } = command;
+    logger.debug(`Starting to call facebook unban api for externalAuthorId ${authorId}`, {
+      command: JSON.stringify(command)
+    });
+    response = await this.deleteApi(`${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`, accessToken.token, removePrefix(authorId), {
+      psid: [removePrefix(authorId)]
+    });
+    logger.info(`Native Facebook API Unban Response for externalAuthorId ${authorId}`, {
+      status: response.status,
+      ok: response.ok
+    });
+    return response.body;
+  }
+}

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

@@ -0,0 +1,23 @@
+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 FeatureToggleClient {
+  constructor() {
+    this.featureToggleUrl = configuration.get('FEATURE_TOGGLE_URL');
+    this.featureToggleNames = ['CONNECTIONS-SOCIAL-GOVERNANCE', 'conversations-googlebusiness-display', 'CONVERSATIONS_FACEBOOK_MENTIONS'];
+  }
+  async get(companyId, jwt) {
+    try {
+      const result = await superagent.post(`${this.featureToggleUrl}/treatments/${companyId}`).set('Authorization', jwt).send({
+        features: this.featureToggleNames,
+        attributes: {}
+      }).timeout(5000);
+      return result.body.treatments;
+    } catch (error) {
+      logger.error(`Failed requesting Feature Toggle service for feature toggle get `, error, {
+        [MeltwaterAttributes.COMPANYID]: companyId
+      });
+    }
+  }
+}