@meltwater/conversations-api-services 1.0.19 → 1.0.21

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

@@ -0,0 +1,542 @@
+import superagent from 'superagent';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+import { EngageHttpError } from '../../errors/http-error.js';
+import { EngageError } from '../../errors/engage-error.js';
+
+const FACEBOOK_URL = 'https://graph.facebook.com';
+
+
+export async function shareCount(token, externalId, logger) {
+    try{
+        const response = await getApi(
+            `${FACEBOOK_URL}/${removePrefix(
+                externalId
+            )}/?fields=shares`,
+            token
+        );
+        return response.body.shares && response.body.shares.count;
+    }catch(err){
+        loggerError(logger,
+            `Facebook shareCount error recieved - ${error.code}`,
+            error,
+        );
+    }
+}
+
+export async function reactions(token, externalIds, logger) {
+
+    try {
+        const response = await getApi(
+            `${FACEBOOK_URL}?ids=${externalIds
+                .map((externalId) => 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) {
+        loggerError(logger,
+            `Facebook reactions error recieved - ${error.code}`,
+            error
+        );
+        return undefined;
+    }
+}
+
+export async function comment(token, {
+    inReplyToExternalId,
+    text,
+    attachment = undefined,
+}, logger = undefined) {
+    let response;
+    const isGif = attachment && attachment.mimeType === 'image/gif';
+
+    loggerDebug(logger,
+        `Starting to call facebook comment api inReplyToExternalId ${inReplyToExternalId}`,
+        { text, attachment }
+    );
+
+    response = await postApi(
+        `${FACEBOOK_URL}/${removePrefix(inReplyToExternalId)}/comments`,
+        token,
+        {
+            ...(text && text.length && { message: text }),
+            ...(attachment &&
+                !isGif && { attachment_url: attachment.link }),
+            ...(attachment &&
+                isGif && { attachment_share_url: attachment.link }),
+        },
+        logger
+    );
+    loggerInfo(logger,
+        `Native Facebook API Publish Comment Response to externalId ${inReplyToExternalId}`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function privateMessage(token, {
+    recipientId,
+    text,
+    attachment = undefined,
+}, logger){
+    let response;
+    const isGif = attachment && attachment.mimeType === 'image/gif';
+
+    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: 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
+    );
+    loggerInfo(logger,
+        `Native Facebook API Publish Private Message Response for documentId ${documentId}`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function hide(token, externalId, logger) {
+    loggerDebug(logger,
+        `Starting to call facebook hide api`
+    );
+
+    const response = await postApi(
+        `${FACEBOOK_URL}/${removePrefix(externalId)}`,
+        token,
+        { is_hidden: true },
+        logger
+    );
+
+    loggerInfo(logger
+        `Native Facebook API Hide Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function unhide(token, externalId, logger) {
+    loggerDebug(logger,
+        `Starting to call facebook unhide api`
+    );
+
+    const response = await postApi(
+        `${FACEBOOK_URL}/${removePrefix(externalId)}`,
+        token,
+        { is_hidden: false },
+        logger
+    );
+
+    loggerChild.info(
+        `Native Facebook API Unhide Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function like(token, externalId, logger) {
+
+    loggerDebug(logger,
+        `Starting to call facebook like api`
+    );
+
+    const response = await postApi(
+        `${FACEBOOK_URL}/${removePrefix(externalId)}/likes`,
+        token,
+        undefined,
+        logger
+    );
+
+    loggerInfo(logger,
+        `Native Facebook API Like Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function unlike(token, externalId, logger) {
+
+    loggerDebug(logger,
+        `Starting to call facebook unlike api`
+    );
+
+    const response = await deleteApi(
+        `${FACEBOOK_URL}/${removePrefix(externalId)}/likes`,
+        token,
+        undefined,
+        logger
+    );
+
+    loggerInfo( logger,
+        `Native Facebook API Unlike Response`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export 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: removePrefix(authorId),
+        },
+        logger
+    );
+
+    if (response && response.body && response.body.data) {
+        const userNoPrefix = removePrefix(authorId);
+        const user = response.body.data.find((user) => {
+            if (user.id == userNoPrefix) {
+                return user;
+            }
+        });
+        if (user) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    loggerInfo( logger,
+        `Native Facebook API is User Banned Response was invalid`,
+        {
+            responseBody: JSON.stringify(response.body),
+        }
+    );
+    return false;
+}
+
+export async function getProfile(token, authorId, logger) {
+    if (!authorId) {
+        return false;
+    }
+
+    let response = {};
+    const userNoPrefix = removePrefix(authorId);
+
+    try {
+        response = await superagent
+            .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
+        ) {
+            loggerError(logger,
+                `Failed to call facebook api for userId ${userNoPrefix}: ${err.response.body.error.message}`
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call facebook api for userId ${userNoPrefix}`,
+                err
+            );
+        }
+
+        return null;
+    }
+
+    if (response.status !== 200) {
+        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;
+}
+
+export async function ban(token, sourceId, authorId, logger) {
+    loggerDebug( logger,
+        `Starting to call facebook ban api for externalAuthorId ${authorId} ${sourceId}`
+    );
+
+    const response = await postApi(
+        `${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`,
+        token,
+        { psid: [removePrefix(authorId)] },
+        logger
+    );
+
+    loggerInfo(logger,
+        `Native Facebook API Hide Response for externalAuthorId ${authorId}`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function unban(token, sourceId, authorId, logger) {
+
+    loggerDebug( logger,
+        `Starting to call facebook unban api for externalAuthorId ${authorId} ${sourceId}`
+    );
+
+    const response = await deleteApi(
+        `${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`,
+        token,
+        { psid: [removePrefix(authorId)] },
+        logger
+    );
+
+    loggerInfo( logger,
+        `Native Facebook API Unban Response for externalAuthorId ${authorId}`,
+        { responseBody: JSON.stringify(response.body) }
+    );
+    return response.body;
+}
+
+export async function getAttachment(token, externalId, discussionType, logger) {
+    let result;
+    try {
+        switch(discussionType) {
+            case 're':
+            case 'qt':
+                result = await getApi(
+                    `${FACEBOOK_URL}/${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}/${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}/${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) {
+        loggerError(logger,`Error getting facebook attachment`, error);
+        throw error;
+    }
+}
+
+async function getApi(apiUrl, accessToken, payload, queryParams = {}, logger) {
+
+    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) {
+        if (
+            err &&
+            err.response &&
+            err.response.body &&
+            err.response.body.error
+        ) {
+            loggerError(logger,
+                `Failed to call facebook getApi ${apiUrl}: ${err.response.body.error.message}`
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call facebook getApi ${apiUrl}`,
+                err
+            );
+        }
+
+        throw err;
+    }
+
+    if (response.status !== 200) {
+        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
+            .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
+        ) {
+            loggerError(logger,
+                `Failed to call facebook api: ${err.response.body.error.message}`
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call facebook api`,
+                err
+            );
+        }
+        if(response.status){
+            throw new 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(
+            response.status,
+            `Failed to call facebook api ${response.body}`
+        );
+    }
+
+    return response;
+}
+
+async function deleteApi(apiUrl, accessToken, payload, logger) {
+
+    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) {
+        if (
+            err &&
+            err.response &&
+            err.response.body &&
+            err.response.body.error
+        ) {
+            loggerError(logger,
+                `Failed to call facebook api delete: ${err.response.body.error.message}`
+            );
+        } else {
+            loggerError(logger,
+                `Failed to call facebook api delete`,
+                err
+            );
+        }
+
+        throw err;
+    }
+
+    if (response.status !== 200) {
+        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;
+}