@meltwater/conversations-api-services 1.0.19 → 1.0.21

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

@@ -0,0 +1,344 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ban = ban;
+exports.comment = comment;
+exports.getAttachment = getAttachment;
+exports.getProfile = getProfile;
+exports.hide = hide;
+exports.isUserBanned = isUserBanned;
+exports.like = like;
+exports.privateMessage = privateMessage;
+exports.reactions = reactions;
+exports.shareCount = shareCount;
+exports.unban = unban;
+exports.unhide = unhide;
+exports.unlike = unlike;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _externalIdHelpers = require("../../lib/externalId.helpers.js");
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+var _httpError = require("../../errors/http-error.js");
+var _engageError = require("../../errors/engage-error.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const FACEBOOK_URL = 'https://graph.facebook.com';
+async function shareCount(token, externalId, logger) {
+  try {
+    const response = await getApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}/?fields=shares`, token);
+    return response.body.shares && response.body.shares.count;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Facebook shareCount error recieved - ${error.code}`, error);
+  }
+}
+async function reactions(token, externalIds, logger) {
+  try {
+    const response = await getApi(`${FACEBOOK_URL}?ids=${externalIds.map(externalId => (0, _externalIdHelpers.removePrefix)(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);
+    return response.body;
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, `Facebook reactions error recieved - ${error.code}`, error);
+    return undefined;
+  }
+}
+async function comment(token, _ref) {
+  let {
+    inReplyToExternalId,
+    text,
+    attachment = undefined
+  } = _ref;
+  let logger = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;
+  let response;
+  const isGif = attachment && attachment.mimeType === 'image/gif';
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook comment api inReplyToExternalId ${inReplyToExternalId}`, {
+    text,
+    attachment
+  });
+  response = await postApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(inReplyToExternalId)}/comments`, token, {
+    ...(text && text.length && {
+      message: text
+    }),
+    ...(attachment && !isGif && {
+      attachment_url: attachment.link
+    }),
+    ...(attachment && isGif && {
+      attachment_share_url: attachment.link
+    })
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Publish Comment Response to externalId ${inReplyToExternalId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function privateMessage(token, _ref2, logger) {
+  let {
+    recipientId,
+    text,
+    attachment = undefined
+  } = _ref2;
+  let response;
+  const isGif = attachment && attachment.mimeType === 'image/gif';
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook PM api to recipientId ${recipientId}`, {
+    payload: JSON.stringify({
+      text,
+      attachment
+    })
+  });
+  response = await postApi(`${FACEBOOK_URL}/me/messages`, token, {
+    recipient: {
+      id: (0, _externalIdHelpers.removePrefix)(recipientId)
+    },
+    message: {
+      text: text,
+      ...(attachment && {
+        attachment: {
+          type: isGif ? 'video' : attachment.mimeType.split('/')[0],
+          payload: {
+            url: attachment.link,
+            is_reusable: true
+          }
+        }
+      })
+    },
+    tag: 'HUMAN_AGENT'
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Publish Private Message Response for documentId ${documentId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function hide(token, externalId, logger) {
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook hide api`);
+  const response = await postApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, token, {
+    is_hidden: true
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger`Native Facebook API Hide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function unhide(token, externalId, logger) {
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook unhide api`);
+  const response = await postApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, token, {
+    is_hidden: false
+  }, logger);
+  loggerChild.info(`Native Facebook API Unhide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function like(token, externalId, logger) {
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook like api`);
+  const response = await postApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}/likes`, token, undefined, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Like Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function unlike(token, externalId, logger) {
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook unlike api`);
+  const response = await deleteApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}/likes`, token, undefined, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Unlike Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function isUserBanned(token, authorId, pageId, logger) {
+  if (!pageId) {
+    // if no pageId to check this call will fail
+    // should only happen with temp edge docs
+    return false;
+  }
+  const response = await getApi(`${FACEBOOK_URL}/${pageId}/blocked`, token, undefined,
+  // payload
+  {
+    user: (0, _externalIdHelpers.removePrefix)(authorId)
+  }, logger);
+  if (response && response.body && response.body.data) {
+    const userNoPrefix = (0, _externalIdHelpers.removePrefix)(authorId);
+    const user = response.body.data.find(user => {
+      if (user.id == userNoPrefix) {
+        return user;
+      }
+    });
+    if (user) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API is User Banned Response was invalid`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return false;
+}
+async function getProfile(token, authorId, logger) {
+  if (!authorId) {
+    return false;
+  }
+  let response = {};
+  const userNoPrefix = (0, _externalIdHelpers.removePrefix)(authorId);
+  try {
+    response = await _superagent.default.get(`${FACEBOOK_URL}/${userNoPrefix}`).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: token
+    }).send();
+  } catch (err) {
+    if (err?.response?.body?.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api for userId ${userNoPrefix}: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api for userId ${userNoPrefix}`, err);
+    }
+    return null;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api for userId ${userNoPrefix}`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api for userId ${userNoPrefix}`);
+    error.code = response.status;
+    return null;
+  }
+  return response;
+}
+async function ban(token, sourceId, authorId, logger) {
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook ban api for externalAuthorId ${authorId} ${sourceId}`);
+  const response = await postApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(sourceId)}/blocked`, token, {
+    psid: [(0, _externalIdHelpers.removePrefix)(authorId)]
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Hide Response for externalAuthorId ${authorId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function unban(token, sourceId, authorId, logger) {
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call facebook unban api for externalAuthorId ${authorId} ${sourceId}`);
+  const response = await deleteApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(sourceId)}/blocked`, token, {
+    psid: [(0, _externalIdHelpers.removePrefix)(authorId)]
+  }, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Facebook API Unban Response for externalAuthorId ${authorId}`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function getAttachment(token, externalId, discussionType, logger) {
+  let result;
+  try {
+    switch (discussionType) {
+      case 're':
+      case 'qt':
+        result = await getApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}?fields=attachment`, token, undefined, undefined, logger);
+        return {
+          images: [{
+            source: result?.body?.attachment?.media?.source || result?.body?.attachment?.media?.image?.src
+          }]
+        };
+      case 'dm':
+        result = await getApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}?fields=attachments`, token, undefined, undefined, logger);
+        return {
+          images: result?.body?.attachments?.data.map(item => {
+            return {
+              source: item.image_data?.url
+            };
+          })
+        };
+      default:
+        // og
+        result = await getApi(`${FACEBOOK_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}/attachments?fields=media,subattachments,file_url`, token, undefined, undefined, logger);
+
+        // if subattachments exist, use them
+        const res = result?.body?.data[0];
+        if (res?.subattachments) {
+          return {
+            images: res?.subattachments.data.map(item => {
+              return {
+                source: item?.media?.source || item?.media?.image?.src
+              };
+            })
+          };
+        }
+        return {
+          images: [{
+            source: res?.media?.source || res?.media?.image?.src
+          }]
+        };
+    }
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting facebook attachment`, error);
+    throw error;
+  }
+}
+async function getApi(apiUrl, accessToken, payload) {
+  let queryParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  let response = {};
+  try {
+    response = await _superagent.default.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken,
+      ...queryParams
+    }).send(payload);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook getApi ${apiUrl}: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook getApi ${apiUrl}`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api ${apiUrl}`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api ${apiUrl}`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function postApi(apiUrl, accessToken, payload, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).send(payload);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api`, err);
+    }
+    if (response.status) {
+      throw new _httpError.EngageHttpError(response.status, response.statusText, response.body, response.headers);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    logger.error(logger, `Failed to call facebook api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    throw new _engageError.EngageError(response.status, `Failed to call facebook api ${response.body}`);
+  }
+  return response;
+}
+async function deleteApi(apiUrl, accessToken, payload, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.delete(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).send(payload);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api delete: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api delete`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call facebook api delete`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call facebook api delete`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}