@meltwater/conversations-api-services 1.0.21 → 1.0.23

package/src/data-access/http/linkedin.native.js

@@ -0,0 +1,530 @@
+
+import superagent from 'superagent';
+import { loggerDebug, loggerError, loggerInfo } from '../../lib/logger.helpers.js';
+
+
+const LINKEDIN_API = "https://api.linkedin.com/v2";
+const LINKEDIN_API_VERSION = "2.0.0";
+
+export async function like(token, externalId, socialAccountId, logger) {
+    let response;
+    let payload = { actor: socialAccountId, object: externalId };
+    let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(externalId)}/likes`
+
+    try {
+        loggerDebug(logger,`Linkedin trying to Like `, {
+            query,
+            payload: JSON.stringify(payload),
+        });
+        response = await superagent
+            .post(query)
+            .timeout(5000) // 5 seconds
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .send(payload);
+        
+
+        loggerInfo(logger,
+            `Native Linkedin API Like Mutation Response`,
+            { response: JSON.stringify(response) }
+        );
+    } catch (err) {
+        loggerError(logger,`Linkedin Like or Unlike Exception`, err);
+        throw err;
+    }
+    return response.connection || response;
+}
+
+export async function unlike(token, externalId, socialAccountId, logger) {
+    let response;
+    let payload = { actor: socialAccountId, object: externalId };
+    let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(
+              externalId
+          )}/likes/${fixedEncodeURIComponent(
+              payload.actor
+          )}?actor=${fixedEncodeURIComponent(payload.actor)}`;
+
+    try {
+        loggerDebug(logger,`Linkedin trying Delete Previous Like `, {
+            query,
+            payload: JSON.stringify(payload),
+        });
+        response = await superagent
+            .delete(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+
+        loggerInfo(logger,
+            `Native Linkedin API UNLike Mutation Response`,
+            { response: JSON.stringify(response) }
+        );
+    } catch (err) {
+        loggerError(logger,`Linkedin Like or Unlike Exception`, err);
+        throw err;
+    }
+    return response.connection || response;
+}
+
+export async function deleteMessage(token, externalId, sourceId, inReplyToId, logger) {
+    const [, comment] = externalId.split(',');
+    const commentId = comment.split(')')[0];
+
+    let response;
+    const query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(
+        inReplyToId
+    )}/comments/${commentId}?actor=${fixedEncodeURIComponent(sourceId)}`;
+
+    try {
+
+        loggerDebug(logger,`Linkedin trying Delete `, {
+            query,
+        });
+        response = await superagent
+            .delete(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+
+        loggerInfo(logger,
+            `Native Linkedin API Delete Comment Response`,
+            { response: JSON.stringify(response) }
+        );
+    } catch (err) {
+        loggerError(logger,`Linkedin Delete exception details`, {
+            err,
+        });
+        throw err;
+    }
+    return response;
+}
+
+export async function comment(token, mediaId,inReplyToId,socialAccountId, messageText, logger){
+    return publish(token,'qt', mediaId,inReplyToId,socialAccountId, messageText, logger)
+}
+export async function reply(token, mediaId,inReplyToId,socialAccountId, messageText, logger){
+    return publish(token,'re', mediaId,inReplyToId,socialAccountId, messageText, logger)
+}
+
+async function publish(token,discussionType, mediaId,inReplyToId,socialAccountId, messageText, logger) {
+    // 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 (discussionType === 're') {
+        body.parentComment = inReplyToId;
+    }
+    if (mediaId) {
+        body.content = [
+            {
+                entity: {
+                    digitalmediaAsset: mediaId,
+                },
+                type: 'IMAGE',
+            },
+        ];
+    }
+
+    let query = `${LINKEDIN_API}/socialActions/${fixedEncodeURIComponent(inReplyToId)}/comments`;
+
+    // data-listener -> linkedin_api.client sendComment
+    let response;
+    let downloadUrl = '';
+    try {
+        response = await superagent
+            .post(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .send(body);
+
+        loggerInfo(logger,
+            `Native Linkedin API Publish Comment Response`,
+            { response: JSON.stringify(response) }
+        );
+        response = {
+            status: 200,
+            message: JSON.parse(response.text),
+        };
+
+
+        if (mediaId) {
+            loggerInfo(logger,
+                `mediaId`,
+                { mediaId }
+            );
+            downloadUrl = await getImageMedia(
+                mediaId,
+                token,
+                logger
+            );
+            loggerInfo(logger,
+                `downloadUrl`,
+                { downloadUrl }
+            );
+        }
+        
+    } catch (err) {
+        loggerError(logger
+            `Exception in linkedin publish `,
+            err
+        );
+        throw err;
+    }
+
+    return {response, downloadUrl};
+}
+
+async function getImageMedia(mediaId, token, logger) {
+    let response = {};
+    if (mediaId && mediaId.includes('digitalmediaAsset')) {
+        mediaId = mediaId.replace(
+            'urn:li:digitalmediaAsset:',
+            'urn:li:image:'
+        );
+    }
+
+    try {
+        response = await superagent
+            .get(
+                    LINKEDIN_API +
+                    '/images/' +
+                    fixedEncodeURIComponent(mediaId)
+            )
+            .timeout(5000) // 5 seconds
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+    } catch (error) {
+        loggerError(logger,'Error in getImageMedia', error);
+    }
+
+    let { downloadUrl } = response.body || {};
+    if (downloadUrl) {
+        return { downloadUrl };
+    } else {
+        loggerError(logger,
+            `Invalid response getting Linkedin media for mediaId: ${mediaId} `,
+            { response: JSON.stringify(response) }
+        );
+        return {};
+    }
+}
+
+export async function getVideoMedia(mediaId, token, logger) {
+
+    let response = {};
+    let tempValue;
+
+    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(
+                    LINKEDIN_API +
+                    '/videos/' +
+                    fixedEncodeURIComponent(mediaId)
+            )
+            .timeout(5000) // 5 seconds
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+    } catch (error) {
+        loggerError(logger, 'Error in getVideoMedia', error);
+    }
+
+    let { thumbnail, downloadUrl } = response.body || {};
+    if (downloadUrl) {
+        return { thumbnail, downloadUrl };
+    } else {
+        loggerError(logger,
+            `Invalid response getting Linkedin media for mediaId: ${mediaId} `,
+            { response: JSON.stringify(response) }
+        );
+        return {};
+    }
+}
+
+export async function getMedia(token, mediaId, type, logger) {
+    // 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 getImageMedia(
+                mediaId,
+                token,
+                logger
+            );
+
+            return {
+                downloadUrl,
+            };
+        } else if (type.includes('video')) {
+            const { thumbnail, downloadUrl } = await getVideoMedia(
+                mediaId,
+                token,
+                logger
+            );
+
+            return {
+                thumbnail,
+                downloadUrl,
+            };
+        }
+
+        return {};
+    } catch (error) {
+        loggerError(logger,'Error in getMedia', error);
+    }
+}
+
+export async function mediaUploadURL(
+    token,
+    socialAccountId,
+    logger
+) {
+    let query = `${LINKEDIN_API}/images?action=initializeUpload`;
+    let body = {
+        initializeUploadRequest: {
+            owner: socialAccountId,
+        },
+    };
+
+    let response;
+    try {
+        response = await superagent
+            .post(query)
+            .timeout(5000)
+            .set({
+                Authorization: `Bearer ${token}`,
+                'Content-type': 'application/json',
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .send(body);
+
+        response = {
+            status: 200,
+            message: JSON.parse(response.text),
+        };
+        return response;
+    } catch (err) {
+        loggerError(logger,
+            `Exception linkedin media register `,
+            err
+        );
+    }
+}
+
+export async function getProfile(urn, token, logger) {
+    let [, , , id] = urn.split(':');
+
+    let profile;
+    try {
+        profile = await superagent
+            .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': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .then((result) => result.body);
+    } catch (error) {
+        loggerError(logger,
+            `Failed requesting LinkedIn API for profileId ${urn}`,
+            error
+        );
+        return;
+    }
+
+    loggerInfo( logger,
+        `Finished requesting LinkedIn API for profileId ${urn}`
+    );
+
+    return profile;
+}
+
+export async function getOrganization(urn, token, logger) {
+    let [, , , id] = urn.split(':');
+
+    let organization;
+    try {
+        organization = await superagent
+            .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': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .then((result) => result.body);
+    } catch (error) {
+        if (error.response.body.message.includes('ADMIN_ONLY')) {
+            return { id: 'private' };
+        }
+
+        loggerError(logger,
+            `Failed requesting LinkedIn API for organizationId ${urn}`,
+            error
+        );
+    }
+
+    loggerInfo(logger,
+        `Finished requesting LinkedIn API for organizationId ${urn}`
+    );
+
+    return organization;
+}
+
+async function getAllStats(externalId, token, logger) {
+    let response = {};
+    try {
+        response = await superagent
+            .get(
+                    LINKEDIN_API +
+                    '/socialMetadata/' +
+                    fixedEncodeURIComponent(externalId)
+            )
+            .timeout(5000) // 5 seconds
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            });
+    } catch (error) {
+        loggerError(logger,'Error in getAllStats', error);
+    }
+
+    let { commentSummary, reactionSummaries } = response.body || {};
+    if (commentSummary && reactionSummaries) {
+        return { commentSummary, reactionSummaries };
+    } else {
+        loggerError( logger,
+            `Invalid response getting all Linkedin Stats for externalId: ${externalId}`,
+            { response: JSON.stringify(response) }
+        );
+        return {};
+    }
+}
+
+export async function getSocialStats(externalId, token, logger) {
+    try {
+        // get all stats (likes are not to be trusted) seems to only work
+        // for og posts.
+        const {
+            commentSummary,
+            reactionSummaries,
+        } = await getAllStats(externalId, token, logger);
+
+        return {
+            commentSummary,
+            reactionSummaries,
+        };
+    } catch (error) {
+        loggerError(logger,'Error in getSocialStats', error);
+    }
+}
+
+export async function likedByUser(
+    token,
+    externalId,
+    authorExternalId,
+    logger
+) {
+    let result;
+    try {
+        result = await superagent
+            .get(
+                `${LINKEDIN_API}/reactions/(actor:${fixedEncodeURIComponent(
+                    authorExternalId
+                )},entity:${fixedEncodeURIComponent(externalId)})`
+            )
+            .set({
+                Authorization: `Bearer ${token}`,
+                'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+                'LinkedIn-Version': '202311',
+            })
+            .then((result) => result.body);
+    } catch (error) {
+        loggerError(logger,'Error in getLikesByUser', error);
+        return false;
+    }
+    return true;
+}
+
+// query object is from AssetManager
+export async function uploadMedia(query, logger) {
+    const { url, token, data } = query;
+    return await superagent
+        .put(url)
+        .set({
+            Accept: '*/*',
+            'Content-Type': 'application/octet-stream',
+            Authorization: `Bearer ${token}`,
+            'X-RestLi-Protocol-Version': LINKEDIN_API_VERSION,
+            'LinkedIn-Version': '202311',
+        })
+        .send(data)
+        .catch((err) => {
+            loggerError(logger,"Linkedin Error uploading Media",err);
+            throw err;
+        });
+}
+
+
+function fixedEncodeURIComponent(str) {
+    return encodeURIComponent(str).replace(/\(/g, '%28').replace(/\)/g, '%29');
+}

package/src/data-access/index.js

@@ -18,6 +18,7 @@ import * as applicationTagFunctions  from '../lib/applicationTags.helpers.js';
 import * as hiddenHelpers from '../lib/hidden.helpers.js';
 import * as FacebookNative from './http/facebook.native.js';
 import * as TiktokNative from './http/tiktok.native.js';
+import * as LinkedinNative from './http/linkedin.native.js';
 
 const DocumentHelperFunctions = {
     ...messageHelpers,
@@ -32,6 +33,7 @@ const LinkedInHelpers = {
 export {
     FacebookNative,
     TiktokNative,
+    LinkedinNative,
     awsS3Client,
     assetManagerTvmRepository,
     CompanyApiClient,