@meltwater/conversations-api-services 1.0.3 → 1.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meltwater/conversations-api-services",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Repository to contain all conversations api services shared across our services",
   "type": "module",
   "main": "src/data-access/index.js",

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

@@ -394,7 +394,7 @@ export class FacebookApiClient {
         const {
             documentId,
             appData: { hidden: hiddenOnNative },
-            metaData: { externalId: externalId },
+            metaData: { externalId },
             systemData: {
                 connectionsCredential: credentialId,
                 policies: { storage: { privateTo: companyId } = {} } = {},

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

@@ -82,7 +82,12 @@ export class LinkedInApiClient {
 
             this.logger.info(
                 `Native Linkedin API Like Comment Response for documentId ${documentId}`,
-                { response, likedByUser }
+                {
+                    ok: response.ok,
+                    status: response.status,
+                    message: JSON.parse(response.text),
+                    likedByUser,
+                }
             );
         } catch (err) {
             this.logger.error(documentId + ' - exception details', {
@@ -141,12 +146,20 @@ export class LinkedInApiClient {
 
             this.logger.info(
                 `Native Linkedin API Delete Comment Response for documentId ${documentId}`,
-                { response }
+                { status: response.status, ok: response.ok }
             );
         } catch (err) {
-            this.logger.error(documentId + ' - exception details', {
-                err,
-            });
+            if (err && err.response && err.response.text) {
+                this.logger.error(
+                    `Call to linkedin api with documentId ${documentId} failed`,
+                    { message: JSON.parse(err.response.text) }
+                );
+            } else {
+                this.logger.error(
+                    `Call to linkedin api with documentId ${documentId} failed`,
+                    err
+                );
+            }
             throw err;
         }
         return response;

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

@@ -0,0 +1,489 @@
+import superagent from 'superagent';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import configuration from '../../lib/configuration.js';
+
+export class TikTokApiClient {
+    constructor({ services }) {
+        this.tiktokURL = configuration.get('TIKTOK_API_URL');
+        this.tokenService = services.token;
+        this.logger = services.logger;
+    }
+
+    async getAuthorization(document) {
+        const {
+            documentId,
+            systemData: { connectionsCredential: credentialId } = {},
+        } = document;
+        try {
+            const token = await this.tokenService.getByCredentialId(
+                credentialId
+            );
+            return `${token.token}`;
+        } catch (error) {
+            this.logger.error(
+                `${documentId} - error getting tiktok token - ${error.code}`,
+                error
+            );
+            return undefined;
+        }
+    }
+
+    async sendPost({
+        paramString = '',
+        headers = {},
+        document,
+        postData = undefined,
+    }) {
+        let response = {};
+        try {
+            response = await superagent
+                .post(this.tiktokURL + paramString)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .set('Access-Token', await this.getAuthorization(document))
+                .send(postData);
+        } catch (err) {
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                this.logger.error(
+                    `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`
+                );
+            } else {
+                this.logger.error(
+                    `Failed to call tiktok api for paramString ${paramString}`,
+                    err
+                );
+            }
+
+            throw err;
+        }
+
+        return response;
+    }
+
+    // assumes batch calls are using the same credential
+    async sendRequest({ paramString = '', headers = {}, document }) {
+        let response = {};
+        try {
+            response = await superagent
+                .get(this.tiktokURL + paramString)
+                .set('Accept', 'application/json')
+                .set('Content-Type', 'application/json')
+                .set('Access-Token', await this.getAuthorization(document))
+                .send();
+        } catch (err) {
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                this.logger.error(
+                    `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`
+                );
+            } else {
+                this.logger.error(
+                    `Failed to call tiktok api for paramString ${paramString}`,
+                    err
+                );
+            }
+
+            throw err;
+        }
+
+        if (response.status !== 200) {
+            this.logger.error(
+                `Failed to call tiktok api for documentId ${documentId}`,
+                response.body
+            );
+            let error = new Error(
+                `Failed to call tiktok api for documentId ${documentId}`
+            );
+            error.code = response.status;
+            throw error;
+        }
+
+        return response.body;
+    }
+
+    async getChannelInfoForDocuments(documents) {
+        const channelInfo = await this.getStatsForDocuments(
+            documents,
+            'metaData.authors.0.authorInfo.externalId',
+            {
+                og: ['video/list/'],
+            }
+        );
+        return channelInfo;
+    }
+
+    async getStatsForDocuments(
+        documents,
+        externalIdFrom = 'metaData.externalId',
+        paramsByType = {
+            og: ['video/list/'],
+        }
+    ) {
+        // for batching separate og and comment/reply requests per credential
+        const documentsByTypeAndCredentials = documents.reduce(
+            (retObj, document, index) => {
+                const paramArray =
+                    paramsByType[document.metaData.discussionType];
+                if (paramArray) {
+                    paramArray.forEach((paramString) => {
+                        let discussionTypeBucket =
+                            retObj[
+                                `${paramString}${document.systemData.connectionsCredential}`
+                            ];
+                        if (!discussionTypeBucket) {
+                            discussionTypeBucket = {
+                                paramString,
+                                document,
+                                externalIds: [],
+                                externalIdToDocumentIndex: {},
+                            };
+                            retObj[
+                                `${paramString}${document.systemData.connectionsCredential}`
+                            ] = discussionTypeBucket;
+                        }
+                        const externalIdTrimmed = removePrefix(
+                            // javascript weirdness to get around '.' notation
+                            externalIdFrom
+                                .split('.')
+                                .reduce((a, b) => a[b], document)
+                        );
+                        discussionTypeBucket.externalIds.push(
+                            externalIdTrimmed
+                        );
+                        discussionTypeBucket.externalIdToDocumentIndex[
+                            externalIdTrimmed
+                        ] = index;
+                    });
+                }
+                return retObj;
+            },
+            {}
+        );
+
+        const sortedResults = Array(documents.length).fill();
+        await Promise.all(
+            Object.values(documentsByTypeAndCredentials).map(
+                async (documentsByTypeAndCredential) => {
+                    if (documentsByTypeAndCredential.externalIds.length) {
+                        const {
+                            metaData: {
+                                inReplyTo: { profileId: business_id },
+                            },
+                        } = documentsByTypeAndCredential.document;
+                        const trimmedBusinessId = removePrefix(business_id);
+                        const requestResult = await this.sendRequest({
+                            paramString: `${
+                                documentsByTypeAndCredential.paramString
+                            }?business_id=${trimmedBusinessId}&fields=["item_id","create_time","thumbnail_url","share_url","embed_url","caption","video_views","likes","comments","shares"]&filters=${JSON.stringify(
+                                {
+                                    video_ids:
+                                        documentsByTypeAndCredential.externalIds,
+                                }
+                            )}`,
+                            document: documentsByTypeAndCredential.document,
+                        });
+                        requestResult.data.videos.forEach(
+                            ({
+                                item_id,
+                                create_time,
+                                thumbnail_url,
+                                share_url,
+                                embed_url,
+                                caption,
+                                video_views,
+                                likes,
+                                comments,
+                                shares,
+                                ...args
+                            }) => {
+                                const documentIndex =
+                                    documentsByTypeAndCredential
+                                        .externalIdToDocumentIndex[item_id];
+                                sortedResults[documentIndex] = {
+                                    ...sortedResults[documentIndex],
+                                    item_id,
+                                    create_time,
+                                    thumbnail_url,
+                                    externalId:
+                                        documents[documentIndex].metaData
+                                            .externalId,
+                                    share_url,
+                                    embed_url,
+                                    caption,
+                                    video_views,
+                                    likes,
+                                    comments,
+                                    shares,
+                                };
+                            }
+                        );
+                    }
+                }
+            )
+        );
+        return sortedResults;
+    }
+
+    async publish(message, videoId, markMessageAsCompleteDocumentId) {
+        const {
+            metaData: { discussionType },
+        } = message;
+        let publishedMessage;
+
+        switch (discussionType) {
+            case 'qt':
+                publishedMessage = await this.insertComment(message);
+                break;
+            case 're':
+                publishedMessage = await this.insertReply(
+                    videoId,
+                    message,
+                    markMessageAsCompleteDocumentId
+                );
+                break;
+        }
+
+        return publishedMessage;
+    }
+
+    async insertComment(document) {
+        const {
+            body: {
+                content: { text: text },
+            },
+            metaData: {
+                source: { id: business_id },
+                inReplyTo: { id: video_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/create/',
+                postData: {
+                    business_id,
+                    video_id,
+                    text,
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async insertReply(videoId, document, markMessageAsCompleteDocumentId) {
+        const {
+            body: {
+                content: { text: text },
+            },
+            metaData: {
+                inReplyTo: { id: comment_id, profileId: business_id },
+            },
+        } = document;
+
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/reply/create/',
+                postData: {
+                    business_id: document.metaData.source.id,
+                    comment_id: markMessageAsCompleteDocumentId || comment_id,
+                    video_id: removePrefix(videoId),
+                    text,
+                },
+                document,
+            })) || {};
+
+        return publishedMessage;
+    }
+
+    async toggleLike(document) {
+        const {
+            enrichments: {
+                socialScores: { tt_liked_by_user: likedByUser },
+            },
+        } = document;
+
+        try {
+            let likeResponse = await (!likedByUser
+                ? this.like(document)
+                : this.unlike(document));
+            return likeResponse;
+        } catch (error) {
+            this.logger.error(`${document} - error recieved - ${error.code}`, error);
+            throw error;
+        }
+    }
+
+    async toggleHide(document) {
+        const {
+            documentId,
+            appData: { hidden: hiddenOnNative },
+            systemData: {
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = document;
+        let hideResponse;
+        let notificationPayload = document;
+
+        try {
+            if (hiddenOnNative) {
+                hideResponse = await this.hide(document);
+            } else {
+                hideResponse = await this.unhide(document);
+            }
+
+            notificationPayload.appData.hideStatus = {
+                code: hideResponse.success === true ? 200 : 500,
+                message:
+                    hideResponse.success === true
+                        ? 'Success'
+                        : 'Failed to Hide',
+            };
+            this.logger.debug(
+                `Notification payload for ${documentId} on company ${companyId} `,
+                notificationPayload
+            );
+        } catch (error) {
+            this.logger.error(
+                `${documentId} - error recieved - ${error.code}`,
+                error
+            );
+            // message failed ot send, mark as such
+            notificationPayload.appData.hideStatus = {
+                code: 405,
+                message: 'Exception Occurred',
+            };
+        }
+        setTimeout(() => {
+            PushRepository.publish(
+                `${companyId}-${documentId}`,
+                notificationPayload
+            );
+        }, 5000);
+    }
+
+    async like(document) {
+        const {
+            metaData: {
+                externalId: comment_id,
+                source: { id: sourceId },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/like/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    action: 'LIKE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async unlike(document) {
+        const {
+            metaData: {
+                inReplyTo: { id: comment_id },
+                source: { id: sourceId },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/like/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    action: 'unlike',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async hide(document) {
+        const {
+            metaData: {
+                inReplyTo: { id: comment_id, profileId: business_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/hide/',
+                postData: {
+                    business_id,
+                    comment_id,
+                    action: 'HIDE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async unhide(document) {
+        const {
+            metaData: {
+                inReplyTo: { id: comment_id, profileId: business_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/hide/',
+                postData: {
+                    business_id,
+                    comment_id,
+                    action: 'UNHIDE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async deleteComment(document) {
+        const {
+            metaData: {
+                inReplyTo: { id: comment_id, profileId: business_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/delete/',
+                postData: {
+                    business_id,
+                    comment_id,
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async getProfile(business_id, document) {
+        const fields = '["username", "display_name", "profile_image"]';
+        const profile =
+            (await this.sendRequest({
+                paramString: `get/?business_id=${business_id}&fields=${fields}`,
+                document,
+            })) || {};
+        return profile;
+    }
+
+    async getPostData(business_id, video_id, document) {
+        const fields =
+            '["item_id", "thumbnail_url", "create_time", "username", "display_name", "profile_image"]';
+        const video_ids = `["${video_id}"]`;
+        const profile =
+            (await this.sendRequest({
+                paramString: `video/list?business_id=${business_id}&fields=${fields}&filters={"video_ids":${video_ids}}`,
+                document,
+            })) || {};
+        return profile;
+    }
+}

package/src/data-access/index.js

@@ -10,6 +10,7 @@ import { InstagramApiClient } from './http/instagramApi.client.js';
 import { InstagramVideoClient } from './http/InstagramVideoClient.js';
 import { IRClient } from './http/ir.client.js';
 import { LinkedInApiClient } from './http/linkedInApi.client.js';
+import { TikTokApiClient } from './http/tiktokApi.client.js';
 import { MasfClient } from './http/masf.client.js';
 import { WarpZoneApiClient } from './http/WarpZoneApi.client.js';
 
@@ -26,6 +27,7 @@ export {
     InstagramVideoClient,
     IRClient,
     LinkedInApiClient,
+    TikTokApiClient,
     MasfClient,
     WarpZoneApiClient,
 };