@meltwater/conversations-api-services 1.0.0

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

@@ -0,0 +1,477 @@
+import superagent from 'superagent';
+import configuration from '../../lib/configuration.js';
+import logger from '../../lib/logger.js';
+import { removePrefix } from '../../lib/externalId.helpers.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+
+export class TikTokApiClient {
+    constructor() {
+        this.tiktokURL = configuration.get('TIKTOK_API_URL');
+        this.credentialsAPI = new CredentialsApiClient();
+    }
+
+    async getAuthorization(document) {
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = document;
+
+        try {
+            const credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+            return `${credential.token}`;
+        } catch (error) {
+            logger.error(
+                `${documentId} - error getting tiktok token - ${error.code}`,
+                error
+            );
+        }
+    }
+
+    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) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call tiktok api for paramString ${paramString}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        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) {
+            let errorText = '';
+            if (
+                err &&
+                err.response &&
+                err.response.body &&
+                err.response.body.error
+            ) {
+                errorText = `Failed to call tiktok api for paramString ${paramString}: ${err.response.body.error.message}`;
+                logger.error(errorText);
+            } else {
+                errorText = `Failed to call tiktok api for paramString ${paramString}`;
+                logger.error(errorText, err);
+            }
+
+            throw new Error(errorText);
+        }
+
+        if (response.status !== 200) {
+            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) {
+            logger.error(`${document} - error recieved - ${error.code}`, error);
+            throw error;
+        }
+    }
+
+    async toggleHide(document) {
+        const {
+            documentId,
+            appData: { hidden: hiddenOnNative },
+        } = document;
+
+        let response;
+        try {
+            if (hiddenOnNative) {
+                response = await this.hide(document);
+            } else {
+                response = await this.unhide(document);
+            }
+            logger.info(
+                `Native Tiktok API Hide Response for documentId ${documentId}`,
+                { status: response.status, ok: response.ok }
+            );
+
+            if (response.message === 'OK') {
+                return response;
+            }
+        } catch (error) {
+            logger.error(
+                `${documentId} - error recieved - ${error.code}`,
+                error
+            );
+        }
+    }
+
+    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: {
+                externalId: comment_id,
+                source: { id: sourceId },
+                inReplyTo: { id: video_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/hide/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    video_id: removePrefix(video_id),
+                    action: 'HIDE',
+                },
+                document,
+            })) || {};
+        return publishedMessage;
+    }
+
+    async unhide(document) {
+        const {
+            metaData: {
+                externalId: comment_id,
+                source: { id: sourceId },
+                inReplyTo: { id: video_id },
+            },
+        } = document;
+        const { body: publishedMessage } =
+            (await this.sendPost({
+                paramString: 'comment/hide/',
+                postData: {
+                    business_id: removePrefix(sourceId),
+                    comment_id: removePrefix(comment_id),
+                    video_id: removePrefix(video_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

@@ -0,0 +1,33 @@
+import { awsS3Client } from './http/amazonS3.js';
+import { assetManagerTvmRepository } from './http/asset-manager-tvm.client.js';
+import { CompanyApiClient } from './http/companiesApi.client.js';
+import { CredentialsApiClient } from './http/credentialsApi.client.js';
+import { EntitlementsApiClient } from './http/entitlementsApi.client.js';
+import { FacebookApiClient } from './http/facebookApi.client.js';
+import { FeatureToggleClient } from './http/featureToggleApi.client.js';
+import { IdentityServicesClient } from './http/identityServices.client.js';
+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';
+
+export {
+    awsS3Client,
+    assetManagerTvmRepository,
+    CompanyApiClient,
+    CredentialsApiClient,
+    EntitlementsApiClient,
+    FacebookApiClient,
+    FeatureToggleClient,
+    IdentityServicesClient,
+    InstagramApiClient,
+    InstagramVideoClient,
+    IRClient,
+    LinkedInApiClient,
+    TikTokApiClient,
+    MasfClient,
+    WarpZoneApiClient,
+};

package/src/lib/applicationTags.helpers.js

@@ -0,0 +1,22 @@
+export function parseApplicationTags(tags) {
+    const parsedTags = {};
+    if (!tags) {
+        return parsedTags;
+    }
+
+    tags.map((tag) => {
+        const [key, value] = tag.split('=');
+        parsedTags[key] = value;
+    });
+
+    return parsedTags;
+}
+
+export function checkApplicationTagsForUserLikes(applicationTags) {
+    const appTags = parseApplicationTags(applicationTags);
+    if (appTags.userLikes === 'true') {
+        return true;
+    } else {
+        return false;
+    }
+}

package/src/lib/configuration.js

@@ -0,0 +1,10 @@
+export default {
+    get: (varName) => {
+        const value = process.env[varName];
+
+        if (value === 'true') return true;
+        if (value === 'false') return false;
+
+        return value;
+    },
+};

package/src/lib/document-action-events.js

@@ -0,0 +1,6 @@
+export default {
+    MARK_AS_TODO: 'MARK_AS_TODO',
+    MARK_AS_COMPLETE: 'MARK_AS_COMPLETE',
+    USER_STARTED_RESPONDING: 'USER_STARTED_RESPONDING',
+    USER_STOPPED_RESPONDING: 'USER_STOPPED_RESPONDING',
+};

package/src/lib/externalId.helpers.js

@@ -0,0 +1,15 @@
+export function removePrefix(document) {
+    return document && document.replace(/id\:[a-zA-Z]+\.com:/g, '');
+}
+
+export function twitterPrefixCheck(socialOriginType, value) {
+    let result = value;
+
+    if (socialOriginType === 'twitter') {
+        if (!value.includes('id:twitter.com:')) {
+            result = 'id:twitter.com:' + value;
+        }
+    }
+
+    return result;
+}

package/src/lib/hiddenComment.helper.js

@@ -0,0 +1,100 @@
+import logger from '../lib/logger.js';
+import { IRClient } from '../data-access/http/ir.clien.jst';
+import XRunes from '@meltwater/xrunes';
+import xRunesCore from '@meltwater/xrunes-core';
+
+class HiddenCommentHelper {
+    constructor({ company, user, traceId }) {
+        this.irClient = new IRClient({ company, user, traceId });
+
+        this.xRunes = new XRunes();
+        this.xRunes.registerLibrary(xRunesCore);
+    }
+
+    shouldHandle(message) {
+        return message.metaData.discussionType === 'qt';
+    }
+
+    async hideChildren(message, markHidden) {
+        let {
+            body: { publishDate: { date: publishDate } = {} } = {},
+            metaData: { externalId, source: { socialOriginType } = {} } = {},
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: { storage: { privateTo: companyId } = {} } = {},
+            } = {},
+        } = message;
+
+        let operation;
+        let query = {
+            type: 'x:match',
+            matchQuery: {
+                type: 'all',
+                allQueries: [
+                    {
+                        type: 'x:dateRange',
+                        field: 'body.publishDate.date',
+                        from: publishDate,
+                    },
+                    {
+                        type: 'term',
+                        field: 'metaData.inReplyTo.externalId',
+                        value: externalId,
+                    },
+                ],
+            },
+        };
+
+        if (markHidden) {
+            operation = 'addToSet';
+            query.notMatchQuery = {
+                type: 'term',
+                field: 'metaData.applicationTags',
+                value: 'parentHidden',
+            };
+        } else {
+            operation = 'removeFromSet';
+            query.matchQuery.allQueries.push({
+                type: 'term',
+                field: 'metaData.applicationTags',
+                value: 'parentHidden',
+            });
+        }
+
+        let runes = {
+            query,
+            transformers: [
+                {
+                    type: 'idml',
+                    script: `action = "update" target = "revision" revisionGroup = "${companyId}" documentId = id operations = [{"operation": "${operation}", "value": ["parentHidden"], "fieldPath": "metaData.applicationTags"}]`,
+                },
+            ],
+            overlayGroups: [companyId],
+            fields: ['id'],
+            outputConfiguration: {
+                type: 's3',
+                region: 'eu-west-1',
+                roleArn: process.env.EXPORT_API_ROLE_ARN,
+                externalId: process.env.EXPORT_API_EXTERNAL_ID,
+                s3BucketName: process.env.EXPORT_API_S3_BUCKET,
+                s3KeyPrefix: process.env.EXPORT_API_S3_PREFIX, // the property is optional, the trailing / isn't
+                batchSize: 1000, // the property is optional, must be >= 100 and <= 20000. Default is 20000
+            },
+            metaData: {
+                companyId,
+            },
+        };
+
+        runes.query = await this.xRunes.render(runes.query);
+
+        logger.debug(`export api query: ${JSON.stringify(runes.query)}`);
+
+        let results = await this.irClient.export(runes);
+
+        logger.debug(`export api result: ${JSON.stringify(results)}`);
+
+        return results;
+    }
+}
+
+export default HiddenCommentHelper;

package/src/lib/logger.js

@@ -0,0 +1,14 @@
+import winston from 'winston';
+
+const logger = winston.createLogger({
+    level: process.env.LOG_LEVEL || 'info',
+    format: winston.format.json(),
+    defaultMeta: {},
+    transports: [
+        new winston.transports.Console({
+            format: winston.format.json(),
+        }),
+    ],
+});
+
+export default logger;