@meltwater/conversations-api-services 1.0.0

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

@@ -0,0 +1,624 @@
+import superagent from 'superagent';
+import configuration from '../../lib/configuration.js';
+import { CredentialsApiClient } from '../http/credentialsApi.client.js';
+import logger from '../../lib/logger.js';
+
+export class LinkedInApiClient {
+    constructor() {
+        this.credentialsAPI = new CredentialsApiClient();
+    }
+
+    async likeMessage(document) {
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: {
+                    storage: { privateTo: companyId },
+                },
+            },
+            metaData: {
+                externalId,
+                source: { id: socialAccountId },
+            },
+            enrichments: {
+                socialScores: { li_liked_by_user: likedByUser },
+            },
+        } = document;
+
+        let response;
+        let payload = { actor: socialAccountId, object: externalId };
+        let query = likedByUser
+            ? `${configuration.get(
+                  'LINKEDIN_API'
+              )}/socialActions/${fixedEncodeURIComponent(externalId)}/likes`
+            : `${configuration.get(
+                  'LINKEDIN_API'
+              )}/socialActions/${fixedEncodeURIComponent(
+                  externalId
+              )}/likes/${fixedEncodeURIComponent(
+                  payload.actor
+              )}?actor=${fixedEncodeURIComponent(payload.actor)}`;
+
+        try {
+            let credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+            if (!likedByUser) {
+                logger.debug(`${documentId} - trying Delete `, {
+                    query,
+                    payload,
+                });
+                response = await superagent
+                    .delete(query)
+                    .timeout(5000)
+                    .set({
+                        Authorization: `Bearer ${credential.token}`,
+                        'X-RestLi-Protocol-Version': configuration.get(
+                            'LINKEDIN_API_VERSION'
+                        ),
+                        'LinkedIn-Version': '202305',
+                    });
+            } else {
+                logger.debug(`${documentId} - sending to linkedin `, {
+                    query,
+                    payload,
+                });
+                response = await superagent
+                    .post(query)
+                    .timeout(5000) // 5 seconds
+                    .set({
+                        Authorization: `Bearer ${credential.token}`,
+                        'X-RestLi-Protocol-Version': configuration.get(
+                            'LINKEDIN_API_VERSION'
+                        ),
+                        'LinkedIn-Version': '202305',
+                    })
+                    .send(payload);
+            }
+
+            logger.info(
+                `Native Linkedin API Like Comment Response for documentId ${documentId}`,
+                {
+                    ok: response.ok,
+                    status: response.status,
+                    message: JSON.parse(response.text),
+                    likedByUser,
+                }
+            );
+        } catch (err) {
+            logger.error(documentId + ' - exception details', {
+                err,
+            });
+            throw err;
+        }
+        return response.connection || response;
+    }
+
+    async deleteMessage(document) {
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: {
+                    storage: { privateTo: companyId },
+                },
+            },
+            metaData: {
+                externalId,
+                source: { id: actorURN },
+                inReplyTo: { id: inReplyToId },
+            },
+        } = document;
+
+        const [, comment] = externalId.split(',');
+        const commentId = comment.split(')')[0];
+
+        let response;
+        let query = `${configuration.get(
+            'LINKEDIN_API'
+        )}/socialActions/${fixedEncodeURIComponent(
+            inReplyToId
+        )}/comments/${commentId}?actor=${fixedEncodeURIComponent(actorURN)}`;
+
+        try {
+            let credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            logger.debug(`${documentId} - trying Delete `, {
+                query,
+            });
+            response = await superagent
+                .delete(query)
+                .timeout(5000)
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                });
+
+            logger.info(
+                `Native Linkedin API Delete Comment Response for documentId ${documentId}`,
+                { status: response.status, ok: response.ok }
+            );
+        } catch (err) {
+            let errorText = '';
+            if (err && err.response && err.response.text) {
+                errorText = `Call to linkedin api with documentId ${documentId} failed`;
+                logger.error(errorText, {
+                    message: JSON.parse(err.response.text),
+                });
+            } else {
+                errorText = `Call to linkedin api with documentId ${documentId} failed`;
+                logger.error(errorText, err);
+            }
+            throw new Error(errorText);
+        }
+        return response;
+    }
+
+    async publishComment(document, mediaId) {
+        // command
+        const {
+            documentId,
+            systemData: {
+                connectionsCredential: credentialId,
+                policies: {
+                    storage: { privateTo: companyId },
+                },
+            },
+            body: {
+                content: { text: messageText },
+            },
+            metaData: {
+                discussionType,
+                inReplyTo: { id: parentUrn },
+                source: { id: socialAccountId },
+            },
+        } = document;
+        let messageType = discussionType === 're' ? 'reply' : 'comment';
+
+        // for now this is needed to make the urns from the images api work until the docs are updated to reflect how to use these new ids.
+        if (mediaId) {
+            mediaId = mediaId.replace(
+                'urn:li:image:',
+                'urn:li:digitalmediaAsset:'
+            );
+        }
+
+        let body = {
+            actor: socialAccountId,
+            message: {
+                attributes: [],
+                text: messageText,
+            },
+        };
+        if (messageType === 'reply') {
+            body.parentComment = parentUrn;
+        }
+        if (mediaId) {
+            body.content = [
+                {
+                    entity: {
+                        digitalmediaAsset: mediaId,
+                    },
+                    type: 'IMAGE',
+                },
+            ];
+        }
+
+        let query = `${configuration.get(
+            'LINKEDIN_API'
+        )}/socialActions/${fixedEncodeURIComponent(parentUrn)}/comments`;
+
+        // data-listener -> linkedin_api.client sendComment
+        let response, updatedDocument;
+        try {
+            let credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            let response = await superagent
+                .post(query)
+                .timeout(5000)
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'Content-Type': 'application/json',
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                })
+                .send(body);
+
+            response = {
+                status: 200,
+                message: JSON.parse(response.text),
+            };
+        } catch (err) {
+            logger.error(
+                documentId + ' - exception linkedin publish ' + err,
+                err
+            );
+        }
+
+        return response;
+    }
+
+    async getMediaUploadURL(
+        companyId,
+        credentialId,
+        socialAccountId,
+        documentId
+    ) {
+        let query = `${configuration.get(
+            'LINKEDIN_API'
+        )}/images?action=initializeUpload`;
+        let body = {
+            initializeUploadRequest: {
+                owner: socialAccountId,
+            },
+        };
+
+        let response;
+        try {
+            let credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            response = await superagent
+                .post(query)
+                .timeout(5000)
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'Content-type': 'application/json',
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                })
+                .send(body);
+
+            response = {
+                status: 200,
+                message: JSON.parse(response.text),
+            };
+            return response;
+        } catch (err) {
+            logger.error(
+                documentId + ' - exception linkedin media register ' + err,
+                err
+            );
+        }
+    }
+
+    async getProfile(urn, token) {
+        let [, , , id] = urn.split(':');
+
+        let profile;
+        try {
+            profile = await superagent
+                .get(`${configuration.get('LINKEDIN_API')}/people/(id:${id})`)
+                .query({
+                    projection:
+                        '(id,localizedFirstName,localizedLastName,vanityName,profilePicture(displayImage~:playableStreams))',
+                })
+                .timeout(5000)
+                .set({
+                    Authorization: `Bearer ${token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                })
+                .then((result) => result.body);
+        } catch (error) {
+            logger.error(
+                `Failed requesting LinkedIn API for profileId ${urn}`,
+                error
+            );
+            return;
+        }
+
+        logger.info(`Finished requesting LinkedIn API for profileId ${urn}`);
+
+        return profile;
+    }
+
+    async getOrganization(urn, token) {
+        let [, , , id] = urn.split(':');
+
+        let organization;
+        try {
+            organization = await superagent
+                .get(`${configuration.get('LINKEDIN_API')}/organizations/${id}`)
+                .query({
+                    projection:
+                        '(id,localizedName,vanityName,logoV2(original~:playableStreams))',
+                })
+                .timeout(5000) // 5 seconds
+                .set({
+                    Authorization: `Bearer ${token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                })
+                .then((result) => result.body);
+        } catch (error) {
+            logger.error(
+                `Failed requesting LinkedIn API for organizationId ${urn}`,
+                error
+            );
+        }
+
+        logger.info(
+            `Finished requesting LinkedIn API for organizationId ${urn}`
+        );
+
+        return organization;
+    }
+
+    async getAllStats(externalId, token) {
+        let response = {};
+
+        try {
+            response = await superagent
+                .get(
+                    configuration.get('LINKEDIN_API') +
+                        '/socialMetadata/' +
+                        fixedEncodeURIComponent(externalId)
+                )
+                .timeout(5000) // 5 seconds
+                .set({
+                    Authorization: `Bearer ${token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                });
+        } catch (error) {
+            logger.error('Error in getAllStats ' + error, error);
+        }
+
+        let { commentSummary, reactionSummaries } = response.body || {};
+        if (commentSummary && reactionSummaries) {
+            return { commentSummary, reactionSummaries };
+        } else {
+            logger.error(
+                `Invalid response getting all Linkedin Stats for externalId = ${externalId} ` +
+                    response,
+                response
+            );
+            return {};
+        }
+    }
+
+    async getSocialStats(externalId, token) {
+        try {
+            // get all stats (likes are not to be trusted) seems to only work
+            // for og posts.
+            const { commentSummary, reactionSummaries } =
+                await this.getAllStats(externalId, token);
+
+            return {
+                commentSummary,
+                reactionSummaries,
+            };
+        } catch (error) {
+            logger.error('Error in getSocialStats: ' + error, error);
+        }
+    }
+
+    async getImageMedia(mediaId, credentialId, companyId) {
+        let response = {};
+
+        let credential = await this.credentialsAPI.getToken(
+            credentialId,
+            companyId
+        );
+
+        if (mediaId && mediaId.includes('digitalmediaAsset')) {
+            mediaId = mediaId.replace(
+                'urn:li:digitalmediaAsset:',
+                'urn:li:image:'
+            );
+        }
+
+        try {
+            response = await superagent
+                .get(
+                    configuration.get('LINKEDIN_API') +
+                        '/images/' +
+                        fixedEncodeURIComponent(mediaId)
+                )
+                .timeout(5000) // 5 seconds
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                });
+        } catch (error) {
+            logger.error('Error in getImageMedia ' + error, error);
+        }
+
+        let { downloadUrl } = response.body || {};
+        if (downloadUrl) {
+            return { downloadUrl };
+        } else {
+            logger.error(
+                `Invalid response getting Linkedin media for mediaId = ${mediaId} ` +
+                    response,
+                response
+            );
+            return {};
+        }
+    }
+
+    async getVideoMedia(mediaId, credentialId, companyId) {
+        let response = {};
+        let tempValue;
+
+        let credential = await this.credentialsAPI.getToken(
+            credentialId,
+            companyId
+        );
+
+        if (mediaId && mediaId.includes('digitalmediaMediaArtifact')) {
+            tempValue = mediaId.split('digitalmediaMediaArtifact:(')[1];
+            tempValue = tempValue.split(
+                ',urn:li:digitalmediaMediaArtifactClass'
+            )[0];
+            mediaId = tempValue;
+        }
+
+        if (mediaId && mediaId.includes('digitalmediaAsset')) {
+            mediaId = mediaId.replace(
+                'urn:li:digitalmediaAsset:',
+                'urn:li:video:'
+            );
+        }
+
+        try {
+            response = await superagent
+                .get(
+                    configuration.get('LINKEDIN_API') +
+                        '/videos/' +
+                        fixedEncodeURIComponent(mediaId)
+                )
+                .timeout(5000) // 5 seconds
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                });
+        } catch (error) {
+            logger.error('Error in getVideoMedia ' + error, error);
+        }
+
+        let { thumbnail, downloadUrl } = response.body || {};
+        if (downloadUrl) {
+            return { thumbnail, downloadUrl };
+        } else {
+            logger.error(
+                `Invalid response getting Linkedin media for mediaId = ${mediaId} ` +
+                    response,
+                response
+            );
+            return {};
+        }
+    }
+
+    async getMedia(mediaId, type, credentialId, companyId) {
+        // needed due to issue with polled data
+        if (type.includes('video') && mediaId.includes('image')) {
+            type = 'image/jpeg';
+        }
+
+        try {
+            if (type.includes('image')) {
+                const { downloadUrl } = await this.getImageMedia(
+                    mediaId,
+                    credentialId,
+                    companyId
+                );
+
+                return {
+                    downloadUrl,
+                };
+            } else if (type.includes('video')) {
+                const { thumbnail, downloadUrl } = await this.getVideoMedia(
+                    mediaId,
+                    credentialId,
+                    companyId
+                );
+
+                return {
+                    thumbnail,
+                    downloadUrl,
+                };
+            }
+
+            return {};
+        } catch (error) {
+            logger.error('Error in getMedia: ' + error, error);
+        }
+    }
+
+    async getLikedByUser(
+        externalId,
+        authorExternalId,
+        credentialId,
+        companyId
+    ) {
+        let result;
+        try {
+            let credential = await this.credentialsAPI.getToken(
+                credentialId,
+                companyId
+            );
+
+            result = await superagent
+                .get(
+                    `${configuration.get(
+                        'LINKEDIN_API'
+                    )}/reactions/(actor:${fixedEncodeURIComponent(
+                        authorExternalId
+                    )},entity:${fixedEncodeURIComponent(externalId)})`
+                )
+                .set({
+                    Authorization: `Bearer ${credential.token}`,
+                    'X-RestLi-Protocol-Version': configuration.get(
+                        'LINKEDIN_API_VERSION'
+                    ),
+                    'LinkedIn-Version': '202305',
+                })
+                .then((result) => result.body);
+        } catch (error) {
+            logger.error('Error in getLikesByUser: ' + error, error);
+            return false;
+        }
+        return true;
+    }
+
+    async uploadMedia(query) {
+        const { socialAccountId, url, token, data } = query;
+
+        logger.info(
+            `Starting to upload media to linkedin for ${socialAccountId}`,
+            { url: query.url }
+        );
+
+        return await superagent
+            .put(url)
+            .set({
+                Accept: '*/*',
+                'Content-Type': 'application/octet-stream',
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': configuration.get(
+                    'LINKEDIN_API_VERSION'
+                ),
+                'LinkedIn-Version': '202305',
+            })
+            .send(data)
+            .catch((err) => {
+                logger.error(err);
+                throw err;
+            });
+    }
+}
+
+function fixedEncodeURIComponent(str) {
+    return encodeURIComponent(str).replace('(', '%28').replace(')', '%29');
+}

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

@@ -0,0 +1,93 @@
+import superagent from 'superagent';
+import logger from '../../lib/logger.js';
+import configuration from '../../lib/configuration.js';
+
+export class MasfClient {
+    constructor() {
+        this.searchServicesUrlMasf = configuration.get(
+            'MASF_SEARCH_SERVICE_URL'
+        );
+        this.searchServicesVersionMasf = configuration.get(
+            'MASF_SEARCH_SERVICE_VERSION'
+        );
+        this.authorListVersionMasf = 'v3';
+    }
+
+    async getSearches({ companyId, token }) {
+        try {
+            let uri = `${this.searchServicesUrlMasf}/${this.searchServicesVersionMasf}/company/${companyId}/searches`;
+            return (
+                await superagent.get(uri).set({
+                    Authorization: `${token}`,
+                })
+            ).body;
+        } catch (error) {
+            logger.error(
+                `Failed requesting Search Services for search list `,
+                error
+            );
+        }
+    }
+
+    async getAuthorsLists({ companyId, token }) {
+        try {
+            let uri = `${this.searchServicesUrlMasf}/v3/companies/${companyId}/authorlists`;
+            return (
+                await superagent.get(uri).set({
+                    Authorization: `${token}`,
+                })
+            ).body.sort(({ name: n1 }, { name: n2 }) => {
+                if (n1.toUpperCase() < n2.toUpperCase()) {
+                    return -1;
+                }
+                if (n1.toUpperCase() > n2.toUpperCase()) {
+                    return 1;
+                }
+                return 0;
+            });
+        } catch (error) {
+            logger.error(
+                `Failed requesting Search Services for author list `,
+                error
+            );
+        }
+    }
+
+    async getAuthorsList({ companyId, authorListId, token }) {
+        try {
+            let uri = `${this.searchServicesUrlMasf}/${this.authorListVersionMasf}/companies/${companyId}/authorlists/${authorListId}`;
+            return (
+                await superagent.get(uri).set({
+                    Authorization: `${token}`,
+                })
+            ).body;
+        } catch (error) {
+            logger.error(
+                `Failed requesting Search Services for author list `,
+                error
+            );
+        }
+    }
+
+    async getRune({ searchId, token }) {
+        let rune;
+        try {
+            let uri = `${this.searchServicesUrlMasf}/${this.searchServicesVersionMasf}/search/getSavedSearchAsRunes/${searchId}`;
+            rune = await superagent.get(uri).set({
+                Authorization: `${token}`,
+            });
+        } catch (error) {
+            logger.error(
+                `Failed requesting Search Services for search list `,
+                error
+            );
+            return;
+        }
+
+        logger.info(
+            `Finished requesting Search Services for rune ${this.searchServicesUrlMasf} searchId: ${searchId}`
+        );
+
+        return rune.body;
+    }
+}