@meltwater/conversations-api-services 1.0.0

package/src/data-access/http/facebookApi.client.js

@@ -0,0 +1,701 @@
+import superagent from 'superagent'; // @todo remove superagent
+import logger from '../../lib/logger.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+
+const FACEBOOK_URL = 'https://graph.facebook.com';
+export class FacebookApiClient {
+    constructor() {
+        this.credentialsAPI = new CredentialsApiClient();
+    }
+
+    // assumes all documents are from same credential
+    async shareCount(documents) {
+        const {
+            documentId,
+            metaData: { discussionType = 'og' } = {},
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = documents;
+        if (discussionType !== 'og') {
+            return;
+        }
+        try {
+            const token = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+            const response = await this.getApi(
+                `${FACEBOOK_URL}/${removePrefix(
+                    documents.metaData.externalId
+                )}/?fields=shares`,
+                token.token,
+                documentId
+            );
+            return response.body.shares && response.body.shares.count;
+        } catch (error) {
+            logger.error(
+                `${documentId} - error recieved - ${error.code}`,
+                error
+            );
+            return undefined;
+        }
+    }
+
+    async reactions(documents) {
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = documents[0];
+
+        try {
+            const token = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            const response = await this.getApi(
+                `${FACEBOOK_URL}?ids=${documents
+                    .map((doc) => removePrefix(doc.metaData.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.token,
+                documentId
+            );
+            return response.body;
+        } catch (error) {
+            logger.error(
+                `${documentId} - error recieved - ${error.code}`,
+                error
+            );
+            return undefined;
+        }
+    }
+
+    async comment(accessToken, payload) {
+        let response;
+        const { inReplyToId, text, documentId, attachment } = payload;
+        const isGif = attachment && attachment.mimeType === 'image/gif';
+
+        logger.debug(
+            `Starting to call facebook comment api for documentId ${documentId}`,
+            payload
+        );
+
+        response = await this.postApi(
+            `${FACEBOOK_URL}/${removePrefix(inReplyToId)}/comments`,
+            accessToken.token,
+            documentId,
+            {
+                ...(text && text.length && { message: text }),
+                ...(attachment &&
+                    !isGif && { attachment_url: attachment.link }),
+                ...(attachment &&
+                    isGif && { attachment_share_url: attachment.link }),
+            }
+        );
+        logger.info(
+            `Native Facebook API Publish Comment Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async privateMessage(accessToken, payload) {
+        let response;
+        const { profileId, recipientId, text, documentId, attachment } =
+            payload;
+        const isGif = attachment && attachment.mimeType === 'image/gif';
+        logger.debug(
+            `Starting to call facebook messages api for documentId ${documentId}`,
+            payload
+        );
+
+        response = await this.postApi(
+            `${FACEBOOK_URL}/me/messages`,
+            accessToken.token,
+            documentId,
+            {
+                recipient: { id: removePrefix(profileId || recipientId) },
+                message: {
+                    text: text,
+                    ...(attachment && {
+                        attachment: {
+                            type: isGif
+                                ? 'video'
+                                : attachment.mimeType.split('/')[0],
+                            payload: {
+                                url: attachment.link,
+                                is_reusable: true,
+                            },
+                        },
+                    }),
+                },
+                tag: 'HUMAN_AGENT',
+            }
+        );
+        logger.info(
+            `Native Facebook API Publish Private Message Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async getApi(apiUrl, accessToken, documentId, payload, queryParams = {}) {
+        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) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call facebook api for documentId ${documentId}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call facebook api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call facebook api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+
+        return response;
+    }
+
+    async postApi(apiUrl, accessToken, documentId, payload) {
+        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) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call facebook api for documentId ${documentId}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call facebook api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call facebook api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+
+        return response;
+    }
+
+    async deleteApi(apiUrl, accessToken, documentId, payload) {
+        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) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call facebook api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call facebook api for documentId ${documentId}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call facebook api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call facebook api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+
+        return response;
+    }
+
+    async publish(document) {
+        const {
+            documentId,
+            body: {
+                content: { text },
+            },
+            attachments: [attachment] = [],
+            metaData: {
+                discussionType,
+                inReplyTo: { id: inReplyToId, recipientId, profileId },
+            },
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = document;
+
+        let updatedDocument;
+        let apiResponse;
+        try {
+            const token = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+            logger.debug(
+                `finished fetching token for Facebook for ${documentId} on company ${companyId} `
+            );
+            let payload;
+            switch (discussionType) {
+                case 'qt':
+                case 're':
+                    payload = {
+                        documentId,
+                        companyId,
+                        credentialId,
+                        text,
+                        inReplyToId,
+                        attachment,
+                    };
+                    apiResponse = await this.comment(token, payload);
+                    break;
+                case 'dm':
+                    payload = {
+                        documentId,
+                        companyId,
+                        credentialId,
+                        text,
+                        recipientId,
+                        profileId,
+                        attachment,
+                    };
+                    apiResponse = await this.privateMessage(token, payload);
+                    break;
+                default:
+                    throw new Error('Unsupported discussion type');
+            }
+
+            if (apiResponse) {
+                let findQuery = { documentId };
+                findQuery['systemData.policies.storage.privateTo'] = companyId;
+                let updateObj = {};
+                updateObj['systemData.status'] = DOCUMENT_STATUS.SUCCESS;
+                updateObj['metaData.externalId'] =
+                    apiResponse.id || apiResponse.message_id;
+                updateObj.documentId = Buffer.from(
+                    `${updateObj['metaData.externalId']}`
+                ).toString('base64');
+                updatedDocument = await messagesRepository.updateOne(
+                    findQuery,
+                    updateObj
+                );
+            } else {
+                throw new Error(
+                    'Invalid response from Facebook publish endpoints'
+                );
+            }
+        } catch (exception) {
+            logger.error(
+                documentId + ' - exception details ' + exception,
+                exception
+            );
+            let findQuery = { documentId };
+            findQuery['systemData.policies.storage.privateTo'] = companyId;
+
+            let updateQuery = {};
+            updateQuery['systemData.status'] = DOCUMENT_STATUS.FAILED;
+            updateQuery['systemData.error'] =
+                exception && exception.response && exception.response.error
+                    ? exception.response.error
+                    : exception;
+            updatedDocument = await messagesRepository.updateOne(
+                findQuery,
+                updateQuery
+            );
+        }
+
+        return apiResponse;
+    }
+
+    async toggleHide(document) {
+        const {
+            documentId,
+            appData: { hidden: hiddenOnNative },
+            metaData: { externalId },
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+            version,
+        } = document;
+        let hideResponse;
+
+        try {
+            logger.debug(
+                `processing Facebook Version ${version} for documentID ${documentId} on company ${companyId}`
+            );
+
+            const token = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            logger.debug(
+                `finished fetching token for facebook for ${documentId} on company ${companyId} `
+            );
+
+            if (hiddenOnNative) {
+                hideResponse = await this.hide(token, {
+                    externalId,
+                    documentId,
+                });
+            } else {
+                hideResponse = await this.unhide(token, {
+                    externalId,
+                    documentId,
+                });
+            }
+
+            logger.debug(
+                `finished hiding in facebook for ${documentId} on company ${companyId} `,
+                { hideResponse }
+            );
+
+            return hideResponse;
+        } catch (error) {
+            logger.error(
+                `${documentId} - error recieved - ${error.code}`,
+                error
+            );
+        }
+    }
+
+    async toggleBan(document, banStatus) {
+        let {
+            documentId,
+            metaData: {
+                source: { id: sourceId },
+                authors: authors,
+            },
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+            version,
+        } = document;
+
+        let banResponse;
+        let authorId = authors[0].authorInfo.externalId;
+
+        try {
+            logger.debug(
+                `processing Facebook Version ${version} for profileId ${authorId} on company ${companyId}`
+            );
+
+            const token = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            logger.debug(
+                `finished fetching token for facebook for ${authorId} on company ${companyId} `
+            );
+
+            if (!banStatus) {
+                banResponse = await this.unban(token, {
+                    sourceId,
+                    authorId,
+                });
+            } else if (banStatus) {
+                banResponse = await this.ban(token, {
+                    sourceId,
+                    authorId,
+                });
+            }
+
+            logger.debug(
+                `finished banning in facebook for ${authorId} on company ${companyId} `,
+                { banResponse }
+            );
+        } catch (error) {
+            logger.error(`${authorId} - error recieved - ${error.code}`, error);
+        }
+    }
+
+    async toggleLike(document) {
+        const {
+            documentId,
+            enrichments: {
+                socialScores: { fb_liked_by_user: likedByUser },
+            },
+            metaData: { externalId },
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+            version,
+        } = document;
+
+        try {
+            logger.debug(
+                `processing Facebook Version ${version} for documentID ${documentId}`
+            );
+
+            logger.debug(
+                `starting to fetch tokens for facebook for ${documentId} on company ${companyId} `
+            );
+            const token = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            logger.debug(
+                `finished fetching token for facebook for ${documentId} on company ${companyId} `
+            );
+
+            let likeResponse = await (likedByUser
+                ? this.like(token, { externalId, documentId })
+                : this.unlike(token, { externalId, documentId }));
+
+            logger.debug(
+                `finished liking in facebook for ${documentId} on company ${companyId} `,
+                { likeResponse }
+            );
+        } catch (error) {
+            logger.error(`${document} - error recieved - ${error.code}`, error);
+            throw error;
+        }
+    }
+
+    async like(accessToken, command) {
+        let response;
+        const { externalId, documentId } = command;
+
+        logger.debug(
+            `Starting to call facebook like api for documentId ${documentId}`,
+            { command }
+        );
+
+        response = await this.postApi(
+            `${FACEBOOK_URL}/${removePrefix(externalId)}/likes`,
+            accessToken.token,
+            documentId
+        );
+
+        logger.info(
+            `Native Facebook API Like Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async unlike(accessToken, command) {
+        let response;
+        const { externalId, documentId } = command;
+
+        logger.debug(
+            `Starting to call facebook unlike api for documentId ${documentId}`,
+            command
+        );
+
+        response = await this.deleteApi(
+            `${FACEBOOK_URL}/${removePrefix(externalId)}/likes`,
+            accessToken.token,
+            documentId
+        );
+
+        logger.info(
+            `Native Facebook API Unlike Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async hide(accessToken, command) {
+        let response;
+        const { externalId, documentId } = command;
+
+        logger.debug(
+            `Starting to call facebook hide api for documentId ${documentId}`,
+            { command }
+        );
+
+        response = await this.postApi(
+            `${FACEBOOK_URL}/${removePrefix(externalId)}`,
+            accessToken.token,
+            documentId,
+            { is_hidden: true }
+        );
+
+        logger.info(
+            `Native Facebook API Hide Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async unhide(accessToken, command) {
+        let response;
+        const { externalId, documentId } = command;
+
+        logger.debug(
+            `Starting to call facebook unhide api for documentId ${documentId}`,
+            command
+        );
+
+        response = await this.postApi(
+            `${FACEBOOK_URL}/${removePrefix(externalId)}`,
+            accessToken.token,
+            documentId,
+            { is_hidden: false }
+        );
+
+        logger.info(
+            `Native Facebook API Unhide Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async isUserBanned({ credentialId, companyId, userId, pageId }) {
+        const token = await this.credentialsAPI.getToken(
+            credentialId,
+            companyId
+        );
+
+        const response = await this.getApi(
+            `${FACEBOOK_URL}/${pageId}/blocked`,
+            token.token,
+            `${companyId}-${credentialId}-${userId}-${pageId}`,
+            undefined, // payload
+            {
+                user: removePrefix(userId),
+            }
+        );
+
+        if (response && response.body && response.body.data) {
+            const userNoPrefix = removePrefix(userId);
+            const user = response.body.data.find((user) => {
+                if (user.id == userNoPrefix) {
+                    return user;
+                }
+            });
+            if (user) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+        logger.info(
+            `Native Facebook API is User Banned Response was invalid for userId ${userId} ${credentialId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return false;
+    }
+
+    async ban(accessToken, command) {
+        let response;
+        const { sourceId, authorId } = command;
+
+        logger.debug(
+            `Starting to call facebook ban api for externalAuthorId ${authorId}`,
+            { command }
+        );
+
+        response = await this.postApi(
+            `${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`,
+            accessToken.token,
+            removePrefix(authorId),
+            { psid: [removePrefix(authorId)] }
+        );
+
+        logger.info(
+            `Native Facebook API Hide Response for externalAuthorId ${authorId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async unban(accessToken, command) {
+        let response;
+        const { sourceId, authorId } = command;
+
+        logger.debug(
+            `Starting to call facebook unban api for externalAuthorId ${authorId}`,
+            command
+        );
+
+        response = await this.deleteApi(
+            `${FACEBOOK_URL}/${removePrefix(sourceId)}/blocked`,
+            accessToken.token,
+            removePrefix(authorId),
+            { psid: [removePrefix(authorId)] }
+        );
+
+        logger.info(
+            `Native Facebook API Unban Response for externalAuthorId ${authorId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+}