@meltwater/conversations-api-services 1.0.0

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

@@ -0,0 +1,35 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+
+export class FeatureToggleClient {
+    constructor() {
+        this.featureToggleUrl = configuration.get('FEATURE_TOGGLE_URL');
+
+        this.featureToggleNames = [
+            'CONNECTIONS-SOCIAL-GOVERNANCE',
+            'conversations-googlebusiness-display',
+            'CONVERSATIONS_FACEBOOK_MENTIONS',
+        ];
+    }
+
+    async get(companyId, jwt) {
+        try {
+            const result = await superagent
+                .post(`${this.featureToggleUrl}/treatments/${companyId}`)
+                .set('Authorization', jwt)
+                .send({
+                    features: this.featureToggleNames,
+                    attributes: {},
+                })
+                .timeout(5000);
+
+            return result.body.treatments;
+        } catch (error) {
+            logger.error(
+                `Failed requesting Feature Toggle service for feature toggle get `,
+                { error, companyId }
+            );
+        }
+    }
+}

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

@@ -0,0 +1,117 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+
+export class IdentityServicesClient {
+    constructor({ companyId, services }) {
+        this.companyId = companyId;
+        this.identityServicesUrl = configuration.get('IDENTITY_SERVICES_URL');
+
+        this.authService = services.auth;
+    }
+
+    async getById(userId, jwt, retries = 0) {
+        let user;
+        try {
+            let resignedToken = await this.authService.getResignedToken(jwt);
+            user = await superagent
+                .get(`${this.identityServicesUrl}/users/${userId}`)
+                .set('Authorization', resignedToken)
+                .set('x-client-name', configuration.get('CLIENT_NAME_HEADER'))
+                .then((result) => result.body.user);
+        } catch (error) {
+            if (retries <= 3) {
+                logger.error(
+                    `getById Failed requesting Identity Services for userId ${userId} retry ${retries}`,
+                    error
+                );
+                return this.getById(userId, jwt, ++retries);
+            } else {
+                logger.error(
+                    `getById Failed requesting Identity Services app settings for userId ${userId} complete failure`,
+                    error
+                );
+            }
+            return;
+        }
+
+        return user;
+    }
+
+    async getAllUsers(jwt, retries = 0) {
+        let users;
+        try {
+            let resignedToken = await this.authService.getResignedToken(jwt);
+            users = await superagent
+                .get(
+                    `${this.identityServicesUrl}/companies/${this.companyId}/users`
+                )
+                .set('Authorization', resignedToken)
+                .set('x-client-name', configuration.get('CLIENT_NAME_HEADER'))
+                .then((result) => result.body.map((record) => record.user));
+        } catch (error) {
+            if (retries <= 3) {
+                logger.error(
+                    `getAllUsers Failed requesting Identity Services for  ${this.companyId} retrying ${retries}`,
+                    error
+                );
+                return await this.getAllUsers(jwt, ++retries);
+            } else {
+                logger.error(
+                    `getAllUsers Failed requesting Identity Services app settings for companyId ${companyId} complete failure`,
+                    error
+                );
+            }
+            return;
+        }
+
+        return users;
+    }
+
+    async getUsersAppSettings({ userIds, settingNames, jwt }, retries = 0) {
+        if (!settingNames) {
+            return {};
+        } else {
+            let appSettings;
+            try {
+                let resignedToken = await this.authService.getResignedToken(
+                    jwt
+                );
+                appSettings = await superagent
+                    .post(
+                        `${this.identityServicesUrl}/users/app_settings/batch_get`
+                    )
+                    .set('Authorization', resignedToken)
+                    .set(
+                        'x-client-name',
+                        configuration.get('CLIENT_NAME_HEADER')
+                    )
+                    .send({
+                        userIds,
+                        settingNames: settingNames,
+                    })
+                    .then((result) => result.body);
+            } catch (error) {
+                if (retries <= 3) {
+                    logger.error(
+                        `getUsersAppSettings Failed requesting Identity Services app settings for userIds ${userIds} retrying ${retries}`,
+                        error
+                    );
+                    return await this.getUsersAppSettings(
+                        { userIds, settingNames, jwt },
+                        ++retries
+                    );
+                } else {
+                    logger.error(
+                        `getUsersAppSettings Failed requesting Identity Services app settings for userIds ${userIds} complete failure`,
+                        error
+                    );
+                }
+
+                return;
+            }
+
+            return appSettings;
+        }
+    }
+}

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

@@ -0,0 +1,496 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import assert from 'assert';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+
+const INSTAGRAM_URL = 'https://graph.facebook.com';
+export class InstagramApiClient {
+    constructor() {
+        this.credentialsAPI = new CredentialsApiClient();
+    }
+
+    async validate(accessToken, payload) {
+        const { inReplyToId, text } = payload;
+        assert(accessToken, 'AccessToken is required.');
+        assert(inReplyToId, 'inReplyToId is required.');
+        assert(text, 'text is required.');
+    }
+
+    async requestApi(
+        apiUrl,
+        accessToken,
+        text,
+        documentId,
+        data,
+        discussionType = 're',
+        adCampaign = 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
+                .post(apiUrl)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .query(queryStringArgs)
+                .send(data);
+        } catch (err) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText =
+                    'Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}';
+                logger.error(errorText);
+            } else {
+                errorText =
+                    'Failed to call instagram api for documentId ${documentId}';
+                logger.error(errorText, err);
+            }
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call instagram api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call instagram api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+        logger.debug('Instagram Response status', response.status);
+        logger.debug('Instagram Response body', response.body);
+        logger.debug('Instagram Response body.id', response.body.id);
+        return response;
+    }
+
+    async getLikes(accessToken, payload) {
+        let response;
+        const { externalId, documentId } = payload;
+
+        logger.debug(
+            `Starting to call instagram getPost api for documentId ${documentId}`,
+            { payload }
+        );
+        try {
+            response = await this.getPost(
+                `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+                accessToken,
+                'like_count',
+                documentId
+            );
+
+            logger.info(
+                `Native Instagram API getPost Response for documentId ${documentId}`,
+                { status: response.status, ok: response.ok }
+            );
+            return response.body;
+        } catch (err) {
+            logger.error('Error getLikes Instagram', { payload });
+            return 0;
+        }
+    }
+
+    async mentionRequestApi(
+        apiUrl,
+        accessToken,
+        replayObject,
+        text,
+        documentId
+    ) {
+        let response = {};
+        try {
+            response = await superagent
+                .post(apiUrl)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .query({ access_token: accessToken })
+                .query(replayObject)
+                .query({ message: text })
+                .send();
+        } catch (err) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call instagram api for documentId ${documentId}`;
+                logger.error(errorText, err);
+            }
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call instagram api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call instagram api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+        logger.debug('Instagram Response status', response.status);
+        logger.debug('Instagram Response body', response.body);
+        logger.debug('Instagram Response body.id', response.body.id);
+        return response;
+    }
+
+    async hideApi(apiUrl, accessToken, hideStatus, documentId) {
+        let response = {};
+        try {
+            response = await superagent
+                .post(apiUrl)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .query({ access_token: accessToken })
+                .query({ hide: hideStatus })
+                .send();
+        } catch (err) {
+            let errorText = '';
+            if (err && err.response && err.response.body) {
+                errorText = `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText, err.response.body.error);
+            } else {
+                errorText = `Failed to call instagram api for documentId ${documentId}`;
+                logger.error(errorText, err);
+            }
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call instagram api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call instagram api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+        logger.debug('Instagram Response status', response.status);
+        logger.debug('Instagram Response body', response.body);
+        logger.debug('Instagram Response body.id', response.body.id);
+        return response;
+    }
+
+    async getPost(apiUrl, accessToken, fields, documentId) {
+        let response = {};
+        try {
+            response = await superagent
+                .get(apiUrl)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .query({ access_token: accessToken })
+                .query({ fields: fields })
+                .send();
+        } catch (err) {
+            let errorText = '';
+            if (err && err.response && err.response.body) {
+                errorText = `Failed to call instagram api for documentId ${documentId}: ${err.response.body.error.message}`;
+                logger.error(errorText, err.response.body.error);
+            } else {
+                errorText = `Failed to call instagram api for documentId ${documentId}`;
+                logger.error(errorText, err);
+            }
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            logger.error(
+                `Failed to call instagram api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call instagram api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+        logger.debug('Instagram Response status', response.status);
+        logger.debug('Instagram Response body', response.body);
+        logger.debug('Instagram Response body.id', response.body.id);
+        return response;
+    }
+
+    async comment(accessToken, payload) {
+        let response;
+        const { inReplyToId, text, documentId, isMention, sourceId } = payload;
+
+        logger.debug(
+            `Starting to call instagram comment api for documentId ${documentId}`,
+            payload
+        );
+
+        this.validate(accessToken, payload);
+
+        if (isMention) {
+            response = await this.mentionRequestApi(
+                `${INSTAGRAM_URL}/${sourceId}/mentions`,
+                accessToken,
+                { media_id: removePrefix(inReplyToId) },
+                text,
+                documentId
+            );
+        } else {
+            response = await this.requestApi(
+                `${INSTAGRAM_URL}/${removePrefix(inReplyToId)}/comments`,
+                accessToken,
+                text,
+                documentId,
+                undefined,
+                'qt'
+            );
+        }
+
+        logger.info(
+            `Native Intagram API Publish Comment Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async reply(accessToken, payload) {
+        let response;
+        const {
+            inReplyToId,
+            text,
+            documentId,
+            isMention,
+            sourceId,
+            threadId,
+            adCampaign,
+        } = payload;
+
+        logger.debug(
+            `Starting to call instagram comment api for documentId ${documentId}`,
+            payload
+        );
+
+        this.validate(accessToken, payload);
+
+        if (isMention) {
+            response = await this.mentionRequestApi(
+                `${INSTAGRAM_URL}/${sourceId}/mentions`,
+                accessToken,
+                {
+                    media_id: removePrefix(threadId),
+                    comment_id: removePrefix(inReplyToId),
+                },
+                text,
+                documentId
+            );
+        } else {
+            response = await this.requestApi(
+                `${INSTAGRAM_URL}/${removePrefix(inReplyToId)}/replies`,
+                accessToken,
+                text,
+                documentId,
+                undefined,
+                're',
+                adCampaign
+            );
+        }
+
+        logger.info(
+            `Native Instagram API Publish Reply Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async publish(document) {
+        const {
+            documentId,
+            body: {
+                content: { text },
+            },
+            appData: { isMention },
+            metaData: {
+                discussionType,
+                source: { id: sourceId },
+                inReplyTo: { id: inReplyToId, profileId, threadId },
+                adCampaign,
+            },
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = document;
+
+        let payload = {
+            documentId,
+            credentialId,
+            text,
+            companyId,
+            inReplyToId,
+            profileId,
+            isMention,
+            sourceId,
+            threadId,
+            adCampaign,
+        };
+
+        let updatedDocument;
+        let apiResponse;
+        try {
+            const token = await this.credentialsAPI.getToken(
+                payload.credentialId,
+                payload.companyId
+            );
+            logger.debug(
+                `finished fetching token for instagram for ${documentId} on company ${companyId} `,
+                payload
+            );
+
+            switch (discussionType) {
+                case 'qt':
+                    apiResponse = await this.comment(token.token, payload);
+                    break;
+                case 're':
+                    apiResponse = await this.reply(token.token, payload);
+                    break;
+                case 'dm':
+                    // get parent account
+                    const parentCredentialId =
+                        await this.credentialsAPI.getCredentialIdByAccountId(
+                            token.parentAccountId,
+                            'facebook'
+                        );
+
+                    if (!parentCredentialId) {
+                        throw 'Parent account id not found';
+                    }
+
+                    // get parent
+                    const parentCredential = await this.credentialsAPI.getToken(
+                        parentCredentialId,
+                        payload.companyId
+                    );
+
+                    if (!parentCredential) {
+                        throw 'Parent account not found';
+                    }
+
+                    apiResponse = await this.privateMessage(
+                        parentCredential.token,
+                        payload
+                    );
+                    break;
+                default:
+                    throw new Error('Unsupported discussion type');
+            }
+        } catch (err) {
+            logger.error(documentId + ' - exception details ' + err, err);
+        }
+
+        return apiResponse;
+    }
+
+    async hide(accessToken, payload) {
+        let response;
+        const { externalId, documentId } = payload;
+
+        logger.debug(
+            `Starting to call instagram hide api for documentId ${documentId}`,
+            { payload }
+        );
+
+        response = await this.hideApi(
+            `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+            accessToken,
+            true,
+            documentId
+        );
+
+        logger.info(
+            `Native Instagram API Hide Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async unhide(accessToken, payload) {
+        let response;
+        const { externalId, documentId } = payload;
+
+        logger.debug(
+            `Starting to call instagram unhide api for documentId ${documentId}`,
+            payload
+        );
+
+        response = await this.hideApi(
+            `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+            accessToken,
+            false,
+            documentId
+        );
+
+        logger.info(
+            `Native Instagram API Unhide Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+
+    async privateMessage(accessToken, payload) {
+        let response;
+        const { profileId, text, documentId, isMention, sourceId, threadId } =
+            payload;
+
+        logger.debug(
+            `Starting to call instagram private message api for documentId ${documentId}`,
+            payload
+        );
+
+        this.validate(accessToken, payload);
+
+        response = await this.requestApi(
+            `${INSTAGRAM_URL}/v10.0/me/messages`,
+            accessToken,
+            // this sends in query string leaving out :shrug:
+            undefined,
+            documentId,
+            {
+                recipient: {
+                    // not :100: this is right
+                    id: removePrefix(profileId),
+                },
+                message: {
+                    text,
+                },
+                // this apparently allows up to 7 days after message 🤔
+                tag: 'HUMAN_AGENT',
+            },
+            'dm'
+        );
+
+        logger.info(
+            `Native Instagram API Publish Private Message Response for documentId ${documentId}`,
+            { status: response.status, ok: response.ok }
+        );
+        return response.body;
+    }
+}