@meltwater/conversations-api-services 1.0.24 → 1.0.26

package/dist/esm/data-access/http/twitter.native.js

@@ -0,0 +1,561 @@
+import superagent from 'superagent';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+import OAuth from 'oauth-1.0a';
+import crypto from 'crypto';
+import axios from 'axios';
+import fs from 'fs';
+import Twit from '@meltwater/social-twit';
+export function addOAuthToToken(token, TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET) {
+  if (!token.oauth) {
+    token.oauth = OAuth({
+      consumer: {
+        key: TWITTER_CONSUMER_KEY,
+        secret: TWITTER_CONSUMER_SECRET
+      },
+      signature_method: 'HMAC-SHA1',
+      hash_function(base_string, key) {
+        return crypto.createHmac('sha1', key).update(base_string).digest('base64');
+      }
+    });
+    token.consumer_key = TWITTER_CONSUMER_KEY;
+    token.consumer_secret = TWITTER_CONSUMER_SECRET;
+  }
+  return token;
+}
+export async function getUserInfoFromHandles(token, handles, logger) {
+  try {
+    let query = `users/lookup.json?screen_name=${handles.join(',')}`;
+    let result = await postRequest({
+      token,
+      uri: query,
+      logger
+    });
+    return result.data;
+  } catch (e) {
+    loggerError(logger, `Error getting UserInfo`, e);
+  }
+}
+export async function getUserInfoFromHandle(token, handleId, logger) {
+  try {
+    let query = `users/show.json?user_id=${removePrefix(handleId)}`;
+    let result = await getRequest({
+      token,
+      uri: query,
+      logger
+    });
+    return result.data;
+  } catch (e) {
+    loggerError(logger, `Error getting UserInfo`, e);
+  }
+}
+export async function getDirectMessageImage(token, imageUrl, logger) {
+  try {
+    let result = await getRequest({
+      token,
+      uri: imageUrl,
+      attachUrlPrefix: false,
+      logger
+    });
+    return {
+      image: result.data,
+      contentType: result.contentType
+    };
+  } catch (e) {
+    loggerError(logger, `Error getting image`, e);
+    throw e;
+  }
+}
+export async function getCurrentInfo(token, externalId, logger) {
+  try {
+    const uri = `https://api.twitter.com/2/tweets?ids=${removePrefix(externalId)}&tweet.fields=public_metrics&expansions=author_id`;
+    let result = await getRequest({
+      token,
+      uri,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
+      logger
+    });
+
+    // this makes it so 'retweeted' is only true on a retweet that isn't a comment
+    // sometimes 'retweeted' is true if user retweeted with comment, sometimes not :sadness:
+    result.data.retweeted = !!result.data.current_user_retweet;
+    return result.data.data[0].public_metrics;
+  } catch (error) {
+    loggerDebug(logger, 'Error in twitter getCurrentInfo', error);
+  }
+}
+export async function getMentionHandleInfo(token, externalId, logger) {
+  try {
+    const uri = `https://api.twitter.com/2/tweets/${removePrefix(externalId)}?tweet.fields=entities&expansions=entities.mentions.username,author_id&user.fields=id,name,username,profile_image_url`;
+    let result = await getRequest({
+      token,
+      uri,
+      attachUrlPrefix: false,
+      convertPayloadToUri: false
+    });
+    return result.data;
+  } catch (error) {
+    loggerDebug(logger, 'Error in twitter getMentionHandleInfo', error);
+  }
+}
+export async function retweet(token, sourceId, externalId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: `https://api.twitter.com/2/users/${removePrefix(sourceId)}/retweets`,
+      payload: {
+        tweet_id: removePrefix(externalId)
+      },
+      attachUrlPrefix: false,
+      convertPayloadToUri: false,
+      logger
+    });
+    if (response.data.data.retweeted !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    loggerDebug(logger, `Error in retweet user: ${sourceId}`, error);
+  }
+}
+export async function unRetweet(token, sourceId, externalId, logger) {
+  try {
+    let response = await deleteRequest({
+      token,
+      uri: `https://api.twitter.com/2/users/${sourceId}/retweets/${removePrefix(externalId)}`,
+      logger
+    });
+    if (response.data.data.retweeted !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    loggerDebug(logger, `Error in unretweet user: ${sourceId}`, error, {
+      [MeltwaterAttributes.SOCIALEXTERNALID]: externalId
+    });
+  }
+}
+export async function like(token, externalId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'favorites/create.json?id=' + removePrefix(externalId),
+      logger
+    });
+    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      loggerInfo(logger, 'Twitter Error in like user statusCode non 200 ', {
+        response: JSON.stringify(response)
+      });
+      return false;
+    }
+  } catch (error) {
+    loggerDebug(logger, `Twitter Error in like user: ${externalId}`, error);
+    throw error;
+  }
+}
+export async function unLike(token, externalId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'favorites/destroy.json?id=' + removePrefix(externalId),
+      logger
+    });
+    if (response.data.favorited !== undefined && response.resp.statusCode === 200) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    loggerDebug(logger, `Error in unlike user: ${externalId}`, error);
+    throw error;
+  }
+}
+export async function followUser(token, profileId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'friendships/create.json',
+      payload: {
+        user_id: removePrefix(profileId),
+        follow: true
+      },
+      logger
+    });
+    if (response.data.following !== undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    loggerDebug(logger, `Error in following user: ${profileId}`, error);
+  }
+}
+export async function unFollowUser(token, profileId, logger) {
+  try {
+    let response = await postRequest({
+      token,
+      uri: 'friendships/destroy.json',
+      payload: {
+        user_id: removePrefix(profileId)
+      },
+      logger
+    });
+    if (response.data.following !== undefined) {
+      return true;
+    } else {
+      return false;
+    }
+  } catch (error) {
+    loggerDebug(logger, `Error in unfollowing user: ${profileId}`, error);
+  }
+}
+export async function userFollowStatus(token, profileId, logger) {
+  try {
+    let response = await getRequest({
+      token,
+      uri: 'friendships/lookup.json',
+      payload: {
+        user_id: removePrefix(profileId)
+      },
+      logger
+    });
+    if (response.data.length > 0) {
+      if (response.data[0].connections.length > 0) {
+        for (var i = 0; i < response.data[0].connections.length; i++) {
+          if (response.data[0].connections[i] === 'following') {
+            return true;
+          }
+        }
+        return false;
+      } else {
+        return false;
+      }
+    }
+  } catch (error) {
+    loggerDebug(logger, `Error in getting user follow status: ${profileId}`, error);
+    if (error.message != 'Bad Request') {
+      // if we hit a minor rate limit here, we wait for 5 seconds before attempting again, usually long enough to continue
+      await new Promise(r => setTimeout(r, 5000));
+      return userFollowStatus(token, profileId, logger);
+    }
+  }
+}
+export async function getBrandUserRelationship(token, profileId, brandProfileId, logger) {
+  try {
+    let {
+      data: {
+        relationship
+      } = {}
+    } = await getRequest({
+      token,
+      uri: `friendships/show.json?source_id=${brandProfileId}&target_id=${removePrefix(profileId)}`,
+      logger
+    });
+    return relationship;
+  } catch (error) {
+    loggerDebug(logger, `Error in getting user brand friendship info: ${profileId} and ${brandProfileId}`, error);
+  }
+}
+export async function reply(token, text, attachment, inReplyToId, removeInReplyToId, logger) {
+  let mediaId;
+  if (attachment) {
+    // discussionType only matters if DM or Not
+    mediaId = await uploadMedia(attachment, token, 're', logger);
+  }
+  const payload = {
+    text,
+    ...(attachment && {
+      media: {
+        media_ids: [mediaId]
+      }
+    }),
+    reply: {
+      in_reply_to_tweet_id: removePrefix(inReplyToId)
+    }
+  };
+  if (removeInReplyToId.length) {
+    payload.reply.exclude_reply_user_ids = removeInReplyToId.map(removePrefix);
+  }
+  let query = 'https://api.twitter.com/2/tweets';
+  return publishTweet(token, payload, query, false, logger);
+}
+export async function privateMessage(token, text, attachment, profileId, logger) {
+  let query = 'direct_messages/events/new.json';
+  let mediaId;
+  if (attachment) {
+    // discussionType only matters if DM or Not
+    mediaId = await uploadMedia(attachment, token, 'dm', logger);
+  }
+  const payload = {
+    event: {
+      type: 'message_create',
+      message_create: {
+        target: {
+          recipient_id: removePrefix(profileId)
+        },
+        message_data: {
+          text: text || ' ',
+          ...(attachment && {
+            attachment: {
+              type: 'media',
+              media: {
+                id: mediaId
+              }
+            }
+          })
+        }
+      }
+    }
+  };
+  return publishTweet(token, payload, query, true, logger);
+}
+export async function retweetWithComment(token, text, attachment, logger) {
+  let mediaId;
+  if (attachment) {
+    // discussionType only matters if DM or Not
+    mediaId = await uploadMedia(attachment, token, 're', logger);
+  }
+  const payload = {
+    text,
+    ...(attachment && {
+      media: {
+        media_ids: [mediaId]
+      }
+    })
+  };
+  let query = 'https://api.twitter.com/2/tweets';
+  return publishTweet(token, payload, query, false, logger);
+}
+async function publishTweet(token, payload, query, isDirectMessage, logger) {
+  try {
+    let nativeResponse = await postRequest({
+      token,
+      uri: query,
+      payload,
+      convertPayloadToUri: false,
+      attachUrlPrefix: isDirectMessage
+    });
+    if (!isDirectMessage && nativeResponse.resp.statusCode === 201) {
+      const uri = `https://api.twitter.com/2/tweets?ids=${nativeResponse.data.data.id}&tweet.fields=public_metrics&expansions=author_id`;
+      nativeResponse = await getRequest({
+        token,
+        uri,
+        payload,
+        attachUrlPrefix: false,
+        convertPayloadToUri: false
+      });
+    }
+    loggerInfo(logger, `finished fetching twitterAPI nativeResponse `, {
+      data: JSON.stringify(nativeResponse.data)
+    });
+    const response = nativeResponse.resp ? {
+      statusCode: nativeResponse.resp.statusCode,
+      statusMessage: nativeResponse.resp.statusCode === 200 ? 'Success' : 'Unknown Failure',
+      data: isDirectMessage ? nativeResponse.data.event : nativeResponse.data.data[0]
+    } : {
+      statusCode: nativeResponse.statusCode,
+      statusMessage: nativeResponse.message
+    };
+    loggerDebug(logger, `Twitter the data response is`, {
+      response: JSON.stringify(response)
+    });
+    return response;
+  } catch (err) {
+    loggerError(`Twitter publish exception details`, err);
+    throw err;
+  }
+}
+async function postRequest(_ref) {
+  let {
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+  } = _ref;
+  return doRequest({
+    requestMethod: 'post',
+    token,
+    convertPayloadToUri,
+    payload,
+    uri,
+    attachUrlPrefix,
+    logger
+  });
+}
+async function getRequest(_ref2) {
+  let {
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+  } = _ref2;
+  return doRequest({
+    requestMethod: 'get',
+    payload,
+    token,
+    uri,
+    attachUrlPrefix,
+    convertPayloadToUri,
+    logger
+  });
+}
+async function deleteRequest(_ref3) {
+  let {
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = false,
+    convertPayloadToUri = false,
+    logger
+  } = _ref3;
+  return doRequest({
+    requestMethod: 'delete',
+    token,
+    convertPayloadToUri,
+    payload,
+    uri,
+    attachUrlPrefix,
+    logger
+  });
+}
+function fixedEncodeURIComponent(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
+    return '%' + c.charCodeAt(0).toString(16);
+  });
+}
+async function doRequest(_ref4) {
+  let {
+    requestMethod,
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+  } = _ref4;
+  if (payload && convertPayloadToUri) {
+    uri = uri + (uri.endsWith('?') ? '' : '?') + Object.keys(payload).map(key => {
+      return fixedEncodeURIComponent(key) + '=' + fixedEncodeURIComponent(payload[key]);
+    }).join('&');
+  }
+  let url = attachUrlPrefix ? `https://api.twitter.com/1.1/${uri}` : uri;
+  return new Promise(async (resolve, reject) => {
+    try {
+      const {
+        Authorization
+      } = token.oauth.toHeader(token.oauth.authorize({
+        url,
+        method: requestMethod,
+        data: {}
+      }, {
+        key: token.token,
+        secret: token.tokenSecret
+      }));
+      const result = await (requestMethod === 'get' ? superagent.get(url).set('Authorization', Authorization) : requestMethod === 'post' ? superagent.post(url).set('Authorization', Authorization).send(payload && !convertPayloadToUri ? payload : undefined) : superagent.del(url).set('Authorization', Authorization));
+      loggerDebug(logger, 'Twitter Native Response ', {
+        native: {
+          //data: result.body,
+          contentType: result.headers['content-type']
+        },
+        methodParams: {
+          uri,
+          payload: JSON.stringify(payload)
+        }
+      });
+      resolve({
+        data: result.body,
+        contentType: result.headers['content-type'],
+        resp: {
+          ...result
+        }
+      });
+    } catch (e) {
+      loggerError(logger, `Error in twitter doRequest`, e, {
+        url,
+        convertPayloadToUri,
+        payload: JSON.stringify(payload)
+      });
+      reject(e);
+    }
+  });
+}
+
+// local
+async function downloadImage(url, fileName) {
+  const writer = fs.createWriteStream(fileName);
+  const response = await axios({
+    url,
+    method: 'GET',
+    responseType: 'stream'
+  });
+  response.data = response.data;
+  response.data.pipe(writer);
+  return new Promise((resolve, reject) => {
+    writer.on('finish', resolve);
+    writer.on('error', reject);
+  });
+}
+
+// local
+function generateFilePath(mimeType) {
+  let dir = `${__dirname}/temporaryTwitterMedia`;
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir);
+  }
+  let randomFileName = Math.floor(Math.random() * 100);
+  let fileExtension = mimeType.split('/')[1];
+  if (mimeType === 'video/quicktime') {
+    fileExtension = 'mov';
+  }
+  return `${dir}/${randomFileName}.${fileExtension}`;
+}
+// local
+async function uploadMedia(attachment, token, discussionType, logger) {
+  return new Promise(async (resolve, reject) => {
+    let filePath = generateFilePath(attachment.mimeType);
+    await downloadImage(attachment.url, filePath);
+    const T = new Twit({
+      consumer_key: token.consumer_key,
+      consumer_secret: token.consumer_secret,
+      access_token: token.token,
+      access_token_secret: token.tokenSecret
+    });
+    let mediaCategory = discussionType === 'dm' ? 'dm' : 'tweet';
+    try {
+      T.postMediaChunked({
+        file_path: filePath
+      }, mediaCategory, function (err, data, response) {
+        if (err) {
+          reject(err);
+        }
+        resolve(data.media_id_string);
+        removeMedia(filePath, logger);
+      });
+    } catch (e) {
+      loggerError(logger, `Failed posting media`, e);
+      // this is just a safety precaution
+      removeMedia(filePath, logger);
+    }
+  });
+}
+function removeMedia(file, logger) {
+  try {
+    fs.unlink(file, function (err) {
+      if (err) {
+        loggerError(logger, `Failed removing ${file}`, err);
+      }
+    });
+  } catch (e) {
+    loggerError(logger, `failed trying to remove media ${file} it may have already been removed`);
+  }
+}
+;

package/dist/esm/data-access/index.js

@@ -20,6 +20,8 @@ import * as FacebookNative from './http/facebook.native.js';
 import * as TiktokNative from './http/tiktok.native.js';
 import * as YoutubeNative from './http/youtube.native.js';
 import * as LinkedinNative from './http/linkedin.native.js';
+import * as TwitterNative from './http/twitter.native.js';
+import * as InstagramNative from './http/instagram.native.js';
 const DocumentHelperFunctions = {
   ...messageHelpers,
   ...applicationTagFunctions,
@@ -29,4 +31,4 @@ const LinkedInHelpers = {
   getOrganization,
   getProfile
 };
-export { FacebookNative, TiktokNative, YoutubeNative, LinkedinNative, awsS3Client, assetManagerTvmRepository, CompanyApiClient, CredentialsApiClient, EntitlementsApiClient, FacebookApiClient, FeatureToggleClient, IdentityServicesClient, InstagramApiClient, InstagramVideoClient, IRClient, LinkedInApiClient, TikTokApiClient, MasfClient, WarpZoneApiClient, DocumentHelperFunctions, LinkedInHelpers };
+export { InstagramNative, FacebookNative, TiktokNative, YoutubeNative, LinkedinNative, TwitterNative, 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.24",
+  "version": "1.0.26",
   "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",
@@ -30,6 +30,9 @@
   },
   "homepage": "https://github.com/meltwater/conversations-api-services#readme",
   "dependencies": {
+    "axios": "^1.1.3",
+    "oauth-1.0a": "^2.2.6",
+    "@meltwater/social-twit": "^2.2.12",
     "@elastic/ecs-winston-format": "^1.5.3",
     "@hapi/joi": "^17.1.1",
     "@meltwater/date-range": "^3.6.0",