@meltwater/conversations-api-services 1.0.24 → 1.0.26

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

@@ -0,0 +1,286 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.comment = comment;
+exports.commentOnMention = commentOnMention;
+exports.getAttachment = getAttachment;
+exports.getLikes = getLikes;
+exports.hide = hide;
+exports.privateMessage = privateMessage;
+exports.reply = reply;
+exports.replyOnMention = replyOnMention;
+exports.unhide = unhide;
+var _superagent = _interopRequireDefault(require("superagent"));
+var _externalIdHelpers = require("../../lib/externalId.helpers.js");
+var _loggerHelpers = require("../../lib/logger.helpers.js");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const INSTAGRAM_URL = 'https://graph.facebook.com';
+async function requestApi(apiUrl, accessToken, text, data) {
+  let discussionType = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 're';
+  let adCampaign = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : undefined;
+  let logger = arguments.length > 6 ? arguments[6] : undefined;
+  let response = {};
+  try {
+    let queryStringArgs = {
+      access_token: accessToken
+    };
+    if (adCampaign) {
+      queryStringArgs.ad_id = adCampaign.adAccountId;
+    }
+    if (text) {
+      queryStringArgs[discussionType === 'dm' ? 'text' : 'message'] = text;
+    }
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query(queryStringArgs).send(data);
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  (0, _loggerHelpers.loggerDebug)(logger, 'Instagram Response status', response.status);
+  return response;
+}
+async function getPost(apiUrl, accessToken, fields, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.get(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query({
+      fields: fields
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err.response.body.error);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function getMessageData(accessToken, sourceId, inReplyToId, logger) {
+  let response;
+  try {
+    response = await getPost(`${INSTAGRAM_URL}/${sourceId}`, accessToken, `mentioned_comment.comment_id(${inReplyToId}){id, text, timestamp, media{id,media_url}}`, logger);
+    return response.body;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    return null;
+  }
+}
+async function mentionRequestApi(apiUrl, accessToken, replayObject, text, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query(replayObject).query({
+      message: text
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body && err.response.body.error) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api: ${err.response.body.error.message}`);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function hideApi(apiUrl, accessToken, hideStatus, logger) {
+  let response = {};
+  try {
+    response = await _superagent.default.post(apiUrl).set('Accept', 'application/json').set('Content-Type', 'application/json').query({
+      access_token: accessToken
+    }).query({
+      hide: hideStatus
+    }).send();
+  } catch (err) {
+    if (err && err.response && err.response.body) {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err.response.body.error);
+    } else {
+      (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, err);
+    }
+    throw err;
+  }
+  if (response.status !== 200) {
+    (0, _loggerHelpers.loggerError)(logger, `Failed to call instagram api`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    let error = new Error(`Failed to call instagram api`);
+    error.code = response.status;
+    throw error;
+  }
+  return response;
+}
+async function getLikes(accessToken, externalId, logger) {
+  let response;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram getPost api for externalId ${externalId}`);
+  try {
+    response = await getPost(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, accessToken, 'like_count', logger);
+    (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API getPost Response`, {
+      responseBody: JSON.stringify(response.body)
+    });
+    return response.body;
+  } catch (err) {
+    (0, _loggerHelpers.loggerError)(logger, 'Error getLikes Instagram ' + externalId, err);
+    return 0;
+  }
+}
+async function commentOnMention(accessToken, sourceId, inReplyToId, text, logger) {
+  return commentHelper(accessToken, inReplyToId, text, true, sourceId, logger);
+}
+async function comment(accessToken, sourceId, inReplyToId, text, logger) {
+  return commentHelper(accessToken, inReplyToId, text, false, sourceId, logger);
+}
+async function commentHelper(accessToken, inReplyToId, text, isMention, sourceId, logger) {
+  let response;
+  if (isMention) {
+    response = await mentionRequestApi(`${INSTAGRAM_URL}/${sourceId}/mentions`, accessToken, {
+      media_id: (0, _externalIdHelpers.removePrefix)(inReplyToId)
+    }, text, logger);
+  } else {
+    response = await requestApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(inReplyToId)}/comments`, accessToken, text, undefined, 'qt', logger);
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Intagram API Publish Comment Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function replyOnMention(accessToken, inReplyToId, text, sourceId, threadId, logger) {
+  return replyHelper(accessToken, {
+    inReplyToId,
+    text,
+    sourceId,
+    threadId,
+    isMention: true
+  }, logger);
+}
+async function reply(accessToken, inReplyToId, text) {
+  let adCampaign = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : undefined;
+  let logger = arguments.length > 4 ? arguments[4] : undefined;
+  return replyHelper(accessToken, {
+    inReplyToId,
+    text,
+    isMention: false,
+    adCampaign
+  }, logger);
+}
+async function replyHelper(accessToken, payload, logger) {
+  let response;
+  const {
+    inReplyToId,
+    text,
+    isMention,
+    sourceId,
+    threadId,
+    adCampaign
+  } = payload;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram comment api`, {
+    payload: JSON.stringify(payload)
+  });
+  if (isMention) {
+    let messageData = await getMessageData(accessToken, sourceId, inReplyToId, logger);
+    let media_id = null;
+    if (messageData) {
+      media_id = messageData.mentioned_comment.media.id;
+    }
+    response = await mentionRequestApi(`${INSTAGRAM_URL}/${sourceId}/mentions`, accessToken, {
+      media_id: media_id ? media_id : (0, _externalIdHelpers.removePrefix)(threadId),
+      comment_id: (0, _externalIdHelpers.removePrefix)(inReplyToId)
+    }, text, logger);
+  } else {
+    response = await requestApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(inReplyToId)}/replies`, accessToken, text, undefined, 're', adCampaign, logger);
+  }
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Publish Reply Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function privateMessage(accessToken, profileId, text, logger) {
+  const response = await requestApi(`${INSTAGRAM_URL}/v10.0/me/messages`, accessToken,
+  // this sends in query string leaving out :shrug:
+  undefined, {
+    recipient: {
+      // not :100: this is right
+      id: (0, _externalIdHelpers.removePrefix)(profileId)
+    },
+    message: {
+      text
+    },
+    // this apparently allows up to 7 days after message 🤔
+    tag: 'HUMAN_AGENT'
+  }, 'dm', logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Publish Private Message Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function hide(accessToken, externalId, logger) {
+  let response;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram hide api`);
+  response = await hideApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, accessToken, true, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Hide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function unhide(accessToken, externalId, logger) {
+  let response;
+  (0, _loggerHelpers.loggerDebug)(logger, `Starting to call instagram unhide api`);
+  response = await hideApi(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, accessToken, false, logger);
+  (0, _loggerHelpers.loggerInfo)(logger, `Native Instagram API Unhide Response`, {
+    responseBody: JSON.stringify(response.body)
+  });
+  return response.body;
+}
+async function getAttachment(token, externalId, logger) {
+  try {
+    const result = await getPost(`${INSTAGRAM_URL}/${(0, _externalIdHelpers.removePrefix)(externalId)}`, token, 'media_url,children{media_url}', logger);
+    const res = result.body;
+    if (res?.children?.data?.length) {
+      return {
+        images: res.children.data.map(item => {
+          return {
+            source: item?.media_url
+          };
+        })
+      };
+    }
+    return {
+      images: [{
+        source: res?.media_url
+      }]
+    };
+  } catch (error) {
+    (0, _loggerHelpers.loggerError)(logger, `Error getting instagram attachment`, error);
+    throw error;
+  }
+}