@meltwater/conversations-api-services 1.3.2 → 1.4.0

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

@@ -2,52 +2,41 @@ import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
 import {
     loggerDebug,
-    loggerError,
     loggerInfo,
+    MeltwaterAttributes,
 } from '../../lib/logger.helpers.js';
 
 const FACEBOOK_URL = 'https://graph.facebook.com';
 
 export async function shareCount(token, externalId, logger) {
-    try {
-        const response = await getApi(
-            `${FACEBOOK_URL}/${removePrefix(externalId)}/?fields=shares`,
-            token
-        );
-        return response.body.shares && response.body.shares.count;
-    } catch (error) {
-        loggerError(
-            logger,
-            `Facebook shareCount error recieved - ${error.code}`,
-            error
-        );
-    }
+    const response = await getApi(
+        `${FACEBOOK_URL}/${removePrefix(externalId)}/?fields=shares`,
+        token,
+        undefined,
+        {},
+        logger
+    );
+    return response.body.shares && response.body.shares.count;
 }
 
 export async function reactions(token, externalIds, logger) {
-    try {
-        const response = await getApi(
-            `${FACEBOOK_URL}?ids=${externalIds
-                .map((externalId) => removePrefix(externalId))
-                .join(',')}&fields=` +
-                `reactions.limit(0).summary(viewer_reaction).as(fb_post_reaction_of_user),` +
-                `reactions.type(LOVE).limit(0).summary(total_count).as(fb_post_reactions_love),` +
-                `reactions.type(WOW).limit(0).summary(total_count).as(fb_post_reactions_wow),` +
-                `reactions.type(SAD).limit(0).summary(total_count).as(fb_post_reactions_sad),` +
-                `reactions.type(LIKE).limit(0).summary(total_count).as(fb_post_reactions_like),` +
-                `reactions.type(ANGRY).limit(0).summary(total_count).as(fb_post_reactions_angry),` +
-                `reactions.type(HAHA).limit(0).summary(total_count).as(fb_post_reactions_haha)`,
-            token
-        );
-        return response.body;
-    } catch (error) {
-        loggerError(
-            logger,
-            `Facebook reactions error recieved - ${error.code}`,
-            error
-        );
-        return undefined;
-    }
+    const response = await getApi(
+        `${FACEBOOK_URL}?ids=${externalIds
+            .map((externalId) => removePrefix(externalId))
+            .join(',')}&fields=` +
+            `reactions.limit(0).summary(viewer_reaction).as(fb_post_reaction_of_user),` +
+            `reactions.type(LOVE).limit(0).summary(total_count).as(fb_post_reactions_love),` +
+            `reactions.type(WOW).limit(0).summary(total_count).as(fb_post_reactions_wow),` +
+            `reactions.type(SAD).limit(0).summary(total_count).as(fb_post_reactions_sad),` +
+            `reactions.type(LIKE).limit(0).summary(total_count).as(fb_post_reactions_like),` +
+            `reactions.type(ANGRY).limit(0).summary(total_count).as(fb_post_reactions_angry),` +
+            `reactions.type(HAHA).limit(0).summary(total_count).as(fb_post_reactions_haha)`,
+        token,
+        undefined,
+        {},
+        logger
+    );
+    return response.body;
 }
 
 export async function comment(
@@ -106,8 +95,12 @@ export async function privateMessage(
             .responseType('arrayBuffer');
 
         if (imageResponse.status !== 200) {
-            loggerError(logger, 'Failed to fetch image from CDN', {
-                responseBody: JSON.stringify(imageResponse.body),
+            loggerInfo(logger, 'Failed to fetch image from CDN', {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    recipientId,
+                    status: imageResponse.status,
+                    responseBody: imageResponse.body,
+                }),
             });
             throw new Error('Failed to fetch image from CDN');
         }
@@ -242,51 +235,46 @@ export async function unlike(token, externalId, logger) {
 }
 
 export async function isUserBanned(token, authorId, pageId, logger) {
-    try {
-        if (!pageId) {
-            // if no pageId to check this call will fail
-            // should only happen with temp edge docs
-            return false;
-        }
-        const response = await getApi(
-            `${FACEBOOK_URL}/${pageId}/blocked`,
-            token,
-            undefined, // payload
-            {
-                user: removePrefix(authorId),
-            },
-            logger
-        );
+    if (!pageId) {
+        // if no pageId to check this call will fail
+        // should only happen with temp edge docs
+        return false;
+    }
+    const response = await getApi(
+        `${FACEBOOK_URL}/${pageId}/blocked`,
+        token,
+        undefined, // payload
+        {
+            user: removePrefix(authorId),
+        },
+        logger
+    );
 
-        if (response && response.body && response.body.data) {
-            const userNoPrefix = removePrefix(authorId);
-            const user = response.body.data.find((user) => {
-                if (user.id == userNoPrefix) {
-                    return user;
-                }
-            });
-            if (user) {
-                return true;
-            } else {
-                return false;
+    if (response && response.body && response.body.data) {
+        const userNoPrefix = removePrefix(authorId);
+        const user = response.body.data.find((user) => {
+            if (user.id == userNoPrefix) {
+                return user;
             }
+        });
+        if (user) {
+            return true;
+        } else {
+            return false;
         }
-
-        loggerInfo(
-            logger,
-            `Native Facebook API is User Banned Response was invalid`,
-            {
-                responseBody: JSON.stringify(response.body),
-            }
-        );
-    } catch (err) {
-        loggerError(
-            logger,
-            `Failed to call facebook api isUserBanned for userId ${authorId} ${pageId}`,
-            err
-        );
     }
-    return false;
+
+    loggerInfo(
+        logger,
+        `Native Facebook API is User Banned Response was invalid`,
+        {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                authorId,
+                pageId,
+                responseBody: response.body,
+            }),
+        }
+    );
 }
 
 export async function getProfile(token, authorId, fields, logger) {
@@ -310,28 +298,23 @@ export async function getProfile(token, authorId, fields, logger) {
             .query(queryParams)
             .send();
     } catch (err) {
-        if (err?.response?.body?.error) {
-            loggerError(
-                logger,
-                `Failed to call facebook api for userId ${userNoPrefix}: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(
-                logger,
-                `Failed to call facebook api for userId ${userNoPrefix}`,
-                err
-            );
-        }
-
+        loggerInfo(logger, `Failed to call facebook api for userId`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                userNoPrefix,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         return null;
     }
 
     if (response.status !== 200) {
-        loggerError(
-            logger,
-            `Failed to call facebook api for userId ${userNoPrefix}`,
-            { responseBody: JSON.stringify(response.body) }
-        );
+        loggerInfo(logger, `Failed to call facebook api for userId`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                userNoPrefix,
+                status: response.status,
+                responseBody: response.body,
+            }),
+        });
         let error = new Error(
             `Failed to call facebook api for userId ${userNoPrefix}`
         );
@@ -386,8 +369,7 @@ export async function unban(token, sourceId, authorId, logger) {
 
 export async function getAttachment(token, externalId, discussionType, logger) {
     let result;
-    try {
-        switch (discussionType) {
+    switch (discussionType) {
             case 're':
             case 'qt':
                 result = await getApi(
@@ -460,10 +442,6 @@ export async function getAttachment(token, externalId, discussionType, logger) {
                         },
                     ],
                 };
-        }
-    } catch (error) {
-        loggerError(logger, `Error getting facebook attachment`, error);
-        throw error;
     }
 }
 
@@ -477,30 +455,22 @@ async function getApi(apiUrl, accessToken, payload, queryParams = {}, logger) {
             .query({ access_token: accessToken, ...queryParams })
             .send(payload);
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(
-                logger,
-                `Failed to call facebook getApi ${apiUrl}: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(
-                logger,
-                `Failed to call facebook getApi ${apiUrl}`,
-                err
-            );
-        }
-
+        loggerInfo(logger, `Failed to call facebook getApi`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger, `Failed to call facebook api ${apiUrl}`, {
-            responseBody: JSON.stringify(response.body),
+        loggerInfo(logger, `Failed to call facebook api`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                status: response.status,
+                responseBody: response.body,
+            }),
         });
         let error = new Error(`Failed to call facebook api ${apiUrl}`);
         error.code = response.status;
@@ -551,7 +521,10 @@ async function postApi(
             err?.response?.body?.error?.error_user_title === "Duplicate Mark Spam Request"
         ) {
             loggerInfo(logger, `Content already marked as spam - treating as successful hide operation`, {
-                responseBody: JSON.stringify(err.response.body),
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    apiUrl,
+                    responseBody: err.response.body,
+                }),
             });
             return {
                 status: 200,
@@ -559,13 +532,22 @@ async function postApi(
             };
         }
         
-        loggerDebug(logger, `Failed to call facebook api`, err);
+        loggerDebug(logger, `Failed to call facebook api`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                error: err?.message,
+            }),
+        });
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger, `Failed to call facebook api`, {
-            responseBody: JSON.stringify(response.body),
+        loggerInfo(logger, `Failed to call facebook api`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                status: response.status,
+                responseBody: response.body,
+            }),
         });
         throw new Error(`Failed to call facebook api ${response.body}`);
     }
@@ -583,26 +565,22 @@ async function deleteApi(apiUrl, accessToken, payload, logger) {
             .query({ access_token: accessToken })
             .send(payload);
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(
-                logger,
-                `Failed to call facebook api delete: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(logger, `Failed to call facebook api delete`, err);
-        }
-
+        loggerInfo(logger, `Failed to call facebook api delete`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger, `Failed to call facebook api delete`, {
-            responseBody: JSON.stringify(response.body),
+        loggerInfo(logger, `Failed to call facebook api delete`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                status: response.status,
+                responseBody: response.body,
+            }),
         });
         let error = new Error(`Failed to call facebook api delete`);
         error.code = response.status;

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

@@ -1,6 +1,6 @@
 import superagent from 'superagent';
 import { removePrefix } from '../../lib/externalId.helpers.js';
-import { loggerDebug, loggerError, loggerInfo, loggerWarn } from '../../lib/logger.helpers.js';
+import { loggerDebug, loggerInfo, loggerWarn, MeltwaterAttributes } from '../../lib/logger.helpers.js';
 
 
 const INSTAGRAM_URL = 'https://graph.facebook.com';
@@ -16,7 +16,6 @@ async function requestApi(
     logger
 ) {
     let response = {};
-
     try {
         let queryStringArgs =accessToken? { access_token: accessToken } : undefined;
         if (adCampaign?.adAccountId) {
@@ -42,28 +41,30 @@ async function requestApi(
                 .send(data);
         }
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(logger,
-                `Failed to call instagram api: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(logger,
-                `Failed to call instagram api`,
-                err
-            );
-        }
+        loggerInfo(logger, `Failed to call instagram api - requestApi`, {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                apiUrl,
+                discussionType,
+                adCampaign: adCampaign || undefined,
+                text: text || undefined,
+                error: err?.response?.body?.error?.message ?? err?.message,
+            }),
+        });
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger,
-            `Failed to call instagram api`,
-            { responseBody: JSON.stringify(response.body) }
+        loggerInfo(logger,
+            `Failed to call instagram api - requestApi bad status`,
+            {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    apiUrl,
+                    discussionType,
+                    adCampaign: adCampaign || undefined,
+                    status: response.status,
+                    responseBody: response.body,
+                }),
+            }
         );
         let error = new Error(
             `Failed to call instagram api`
@@ -87,24 +88,29 @@ async function getPost(apiUrl, accessToken, fields, logger) {
             .query({ fields: fields })
             .send();
     } catch (err) {
-        if (err && err.response && err.response.body) {
-            loggerError(logger,
-                `Failed to call instagram api`,
-                err.response.body.error
-            );
-        } else {
-            loggerError(logger,
-                `Failed to call instagram api`,
-                err
-            );
-        }
+        const errObject = {
+            apiUrl,
+            fields,
+            error: err?.response?.body?.error ?? err?.message,
+        };
+        loggerInfo(logger,
+            `Failed to call instagram api - getPost`,
+            { [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify(errObject) }
+        );
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger,
-            `Failed to call instagram api`,
-            { responseBody: JSON.stringify(response.body) }
+        loggerInfo(logger,
+            `Failed to call instagram api - getPost bad status`,
+            {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    apiUrl,
+                    fields,
+                    status: response.status,
+                    responseBody: response.body,
+                }),
+            }
         );
         let error = new Error(
             `Failed to call instagram api`
@@ -128,11 +134,16 @@ async function getMessageData(accessToken, sourceId, inReplyToId, logger) {
 
         return response.body;
     } catch (err) {
-        loggerError(logger,
-            `Failed to call instagram api`,
-            err
+        loggerInfo(logger,
+            `Failed to call instagram api - getMessageData`,
+            {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    sourceId,
+                    inReplyToId,
+                    error: err?.message,
+                }),
+            }
         );
-
         return null;
     }
 }
@@ -156,28 +167,30 @@ async function mentionRequestApi(
             .query({ message: text })
             .send();
     } catch (err) {
-        if (
-            err &&
-            err.response &&
-            err.response.body &&
-            err.response.body.error
-        ) {
-            loggerError(logger,
-                `Failed to call instagram api: ${err.response.body.error.message}`
-            );
-        } else {
-            loggerError(logger,
-                `Failed to call instagram api`,
-                err
-            );
-        }
+        const errObject = {
+            apiUrl,
+            replayObject,
+            text,
+            error: err?.response?.body?.error?.message ?? err?.message,
+        };
+        loggerInfo(logger,
+            `Failed to call instagram api - mentionRequestApi`,
+            { [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify(errObject) }
+        );
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger,
-            `Failed to call instagram api`,
-            { responseBody: JSON.stringify(response.body) }
+        loggerInfo(logger,
+            `Failed to call instagram api - mentionRequestApi bad status`,
+            {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    apiUrl,
+                    replayObject,
+                    status: response.status,
+                    responseBody: response.body,
+                }),
+            }
         );
         let error = new Error(
             `Failed to call instagram api`
@@ -199,24 +212,29 @@ async function hideApi(apiUrl, accessToken, hideStatus, logger) {
             .query({ hide: hideStatus })
             .send();
     } catch (err) {
-        if (err && err.response && err.response.body) {
-            loggerError(logger,
-                `Failed to call instagram api`,
-                err.response.body.error
-            );
-        } else {
-            loggerError(logger,
-                `Failed to call instagram api`,
-                err
-            );
-        }
+        const errObject = {
+            apiUrl,
+            hideStatus,
+            error: err?.response?.body?.error ?? err?.message,
+        };
+        loggerInfo(logger,
+            `Failed to call instagram api - hideApi`,
+            { [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify(errObject) }
+        );
         throw err;
     }
 
     if (response.status !== 200) {
-        loggerError(logger,
-            `Failed to call instagram api`,
-            { responseBody: JSON.stringify(response.body) }
+        loggerInfo(logger,
+            `Failed to call instagram api - hideApi bad status`,
+            {
+                [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                    apiUrl,
+                    hideStatus,
+                    status: response.status,
+                    responseBody: response.body,
+                }),
+            }
         );
         let error = new Error(
             `Failed to call instagram api`
@@ -246,10 +264,17 @@ export async function getLikes(accessToken, externalId, logger) {
         );
         return response.body;
     } catch (err) {
+        const errPayload = {
+            [MeltwaterAttributes.PAYLOADDATA]: JSON.stringify({
+                externalId,
+                status: err?.status,
+                error: err?.message,
+            }),
+        };
         if(err?.status === 400) {
-            loggerWarn(logger,'Warn getLikes Instagram Comment probably deleted on native', err);
-        }else{
-            loggerError(logger,'Error getLikes Instagram '+externalId,err);
+            loggerWarn(logger, 'Warn getLikes Instagram Comment probably deleted on native', errPayload);
+        } else {
+            loggerInfo(logger, 'Error getLikes Instagram', errPayload);
         }
         return 0;
     }
@@ -461,28 +486,23 @@ export async function unhide(accessToken, externalId, logger) {
 }
 
 export async function getAttachment(token, externalId, logger) {
-    try {
-        const result = await getPost(
-            `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
-            token,
-            'media_url,children{media_url}',
-            logger
-        );
-
-        const res = result.body;
-        if (res?.children?.data?.length) {
-            return {
-                images: res.children.data.map((item) => {
-                    return { source: item?.media_url };
-                }),
-            };
-        }
+    const result = await getPost(
+        `${INSTAGRAM_URL}/${removePrefix(externalId)}`,
+        token,
+        'media_url,children{media_url}',
+        logger
+    );
 
+    const res = result.body;
+    if (res?.children?.data?.length) {
         return {
-            images: [{ source: res?.media_url }],
+            images: res.children.data.map((item) => {
+                return { source: item?.media_url };
+            }),
         };
-    } catch (error) {
-        loggerError(logger,`Error getting instagram attachment`, error);
-        throw error;
     }
+
+    return {
+        images: [{ source: res?.media_url }],
+    };
 }