@meltwater/conversations-api-services 1.0.23 → 1.0.25

package/src/data-access/http/twitter.native.js

@@ -0,0 +1,663 @@
+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({
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+}) {
+    return doRequest({
+        requestMethod: 'post',
+        token,
+        convertPayloadToUri,
+        payload,
+        uri,
+        attachUrlPrefix,
+        logger
+    });
+}
+
+async function getRequest({
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+}) {
+    return doRequest({
+        requestMethod: 'get',
+        payload,
+        token,
+        uri,
+        attachUrlPrefix,
+        convertPayloadToUri,
+        logger
+    });
+}
+
+async function deleteRequest({
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = false,
+    convertPayloadToUri = false,
+    logger
+}) {
+    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({
+    requestMethod,
+    token,
+    uri,
+    payload,
+    attachUrlPrefix = true,
+    convertPayloadToUri = true,
+    logger
+}) {
+    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`
+        );
+    }
+};