@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/engine/notifications/generate_point_notifications.cjs

@@ -0,0 +1,233 @@
+"use strict";
+const models = require("../../../models/index.cjs");
+const log = require('../../utils/logger.cjs');
+const async = require('async');
+const getModelAndUsersByType = require('./notifications_utils.cjs').getModelAndUsersByType;
+const addNotificationsForUsers = require('./notifications_utils.cjs').addNotificationsForUsers;
+const addOrPossiblyGroupNotification = require('./notifications_utils.cjs').addOrPossiblyGroupNotification;
+const _ = require('lodash');
+const generateNotificationsForNewPoint = (activity, callback) => {
+    // Make sure not to create duplicate notifications to the same user
+    const uniqueUserIds = { users: [] };
+    let notificationType;
+    if (activity.type === 'activity.point.newsStory.new') {
+        notificationType = 'notification.point.newsStory';
+    }
+    else if (activity.type === 'activity.point.comment.new') {
+        notificationType = 'notification.point.comment';
+    }
+    else {
+        notificationType = 'notification.point.new';
+    }
+    async.series([
+        (seriesCallback) => {
+            if (activity.sub_type === "bulkOperation" &&
+                activity.context &&
+                activity.context.silentMode === true) {
+                seriesCallback();
+            }
+            else {
+                // Notifications for my posts
+                const userWhere = {};
+                userWhere["notifications_settings.my_posts.method"] = {
+                    $gt: 0
+                };
+                if (activity.post_id) {
+                    models.Post.findOne({
+                        where: {
+                            id: activity.post_id
+                        },
+                        include: [
+                            {
+                                model: models.User,
+                                attributes: ['id', 'notifications_settings', 'email'],
+                                where: userWhere,
+                                required: true
+                            }
+                        ]
+                    }).then((post) => {
+                        if (post) {
+                            addNotificationsForUsers(activity, [post.User], notificationType, 'my_posts', uniqueUserIds, seriesCallback);
+                        }
+                        else {
+                            seriesCallback();
+                        }
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    // No post associated with this point
+                    seriesCallback();
+                }
+            }
+        },
+        (seriesCallback) => {
+            if (activity.sub_type === "bulkOperation") {
+                seriesCallback();
+            }
+            else {
+                // Notifications for my points
+                const userWhere = {};
+                userWhere["notifications_settings.my_points.method"] = {
+                    $gt: 0
+                };
+                if (activity.post_id) {
+                    models.Point.findAll({
+                        where: {
+                            post_id: activity.post_id,
+                            status: 'published'
+                        },
+                        attributes: ['id'],
+                        order: [
+                            models.sequelize.literal('(counter_quality_up-counter_quality_down) desc')
+                        ],
+                        //TODO: Review this limit on notifications for large points discussions
+                        limit: process.env.POINT_NOTIFICATIONS_USERS_LIMIT ? process.env.POINT_NOTIFICATIONS_USERS_LIMIT : 250
+                    }).then((pointsIn) => {
+                        models.Point.findAll({
+                            where: {
+                                id: {
+                                    $in: _.map(pointsIn, (pointIn) => { return pointIn.id; })
+                                }
+                            },
+                            attributes: ['id'],
+                            include: [
+                                {
+                                    model: models.User,
+                                    attributes: ['id', 'notifications_settings', 'email'],
+                                    where: userWhere,
+                                    required: true
+                                }
+                            ],
+                            order: [
+                                models.sequelize.literal('(counter_quality_up-counter_quality_down) desc')
+                            ],
+                        }).then((points) => {
+                            if (points) {
+                                const users = [];
+                                const userIds = [];
+                                async.eachSeries(points, (point, innerSeriesCallback) => {
+                                    if (!_.includes(userIds, point.User.id)) {
+                                        users.push(point.User);
+                                        userIds.push(point.User.id);
+                                    }
+                                    innerSeriesCallback();
+                                }, (error) => {
+                                    addNotificationsForUsers(activity, users, notificationType, 'my_points', uniqueUserIds, seriesCallback);
+                                });
+                            }
+                            else {
+                                seriesCallback();
+                            }
+                        }).catch((error) => {
+                            seriesCallback(error);
+                        });
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    // No post associated with this point
+                    seriesCallback();
+                }
+            }
+        },
+        (seriesCallback) => {
+            if (activity.sub_type === "bulkOperation") {
+                seriesCallback();
+            }
+            else {
+                if (activity.Community) {
+                    // Notifications for all new points in community
+                    getModelAndUsersByType(models.Community, 'CommunityUsers', activity.Community.id, "all_community", (error, community) => {
+                        if (error) {
+                            seriesCallback(error);
+                        }
+                        else if (community) {
+                            addNotificationsForUsers(activity, community.CommunityUsers, notificationType, 'all_community', uniqueUserIds, seriesCallback);
+                        }
+                        else {
+                            log.warn("Generate Point Notification Not found or muted", { userId: activity.user_id, type: activity.type });
+                            seriesCallback();
+                        }
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            }
+        },
+        (seriesCallback) => {
+            if (activity.sub_type === "bulkOperation") {
+                seriesCallback();
+            }
+            else {
+                if (activity.Group) {
+                    // Notifications for all new points in group
+                    getModelAndUsersByType(models.Group, 'GroupUsers', activity.Group.id, "all_group", (error, group) => {
+                        if (error) {
+                            seriesCallback(error);
+                        }
+                        else if (group) {
+                            addNotificationsForUsers(activity, group.GroupUsers, notificationType, "all_group", uniqueUserIds, seriesCallback);
+                        }
+                        else {
+                            log.warn("Generate Point Notification Not found or muted", { userId: activity.user_id, type: activity.type });
+                            seriesCallback();
+                        }
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            }
+        }
+    ], (error) => {
+        callback(error);
+    });
+    // TODO: Add AcWatching community and group users
+};
+const generateNotificationsForHelpfulness = (activity, callback) => {
+    // Notifications for quality on posts I've created
+    models.Point.findOne({
+        where: { id: activity.point_id },
+        include: [
+            {
+                model: models.User,
+                required: true,
+                attributes: ['id', 'notifications_settings', 'email', 'name'],
+                where: {
+                    "notifications_settings.my_points_endorsements.method": {
+                        $gt: 0
+                    }
+                }
+            }
+        ]
+    }).then((point) => {
+        //TODO: do notifications for stories as well that are without a post_id
+        if (point && point.post_id) {
+            addOrPossiblyGroupNotification(point, 'notification.point.quality', 'my_points_endorsements', activity, point.User, 50, callback);
+        }
+        else {
+            log.warn("Generate Point Notification Not found or muted", { userId: activity.user_id, type: activity.type });
+            callback();
+        }
+    }).catch((error) => {
+        callback(error);
+    });
+    // TODO: Add AcWatching users
+};
+module.exports = (activity, user, callback) => {
+    if (activity.type === 'activity.point.new' ||
+        activity.type === 'activity.point.newsStory.new' ||
+        activity.type === 'activity.point.comment.new') {
+        generateNotificationsForNewPoint(activity, callback);
+    }
+    else if (activity.type === 'activity.point.helpful.new' || activity.type === 'activity.point.unhelpful.new') {
+        generateNotificationsForHelpfulness(activity, callback);
+    }
+    else {
+        callback("Unexpected type for generatePointNotification");
+    }
+};

package/dist/active-citizen/engine/notifications/generate_post_notifications.cjs

@@ -0,0 +1,118 @@
+"use strict";
+const models = require("../../../models/index.cjs");
+const log = require("../../utils/logger.cjs");
+const async = require("async");
+const getModelAndUsersByType = require("./notifications_utils.cjs").getModelAndUsersByType;
+const addNotificationsForUsers = require("./notifications_utils.cjs").addNotificationsForUsers;
+const addOrPossiblyGroupNotification = require("./notifications_utils.cjs").addOrPossiblyGroupNotification;
+const generateNotificationsForNewPost = (activity, callback) => {
+    // Make sure not to create duplicate notifications to the same user
+    const uniqueUserIds = { users: [] };
+    if (!activity) {
+        return callback("Activity is null or undefined");
+    }
+    async.series([
+        (seriesCallback) => {
+            if (activity.Community) {
+                // Notifications for all new posts in community
+                getModelAndUsersByType(models.Community, "CommunityUsers", activity.Community.id, "all_community", (error, community) => {
+                    if (error) {
+                        seriesCallback(error);
+                    }
+                    else if (community) {
+                        addNotificationsForUsers(activity, community.CommunityUsers, "notification.post.new", "all_community", uniqueUserIds, seriesCallback);
+                    }
+                    else {
+                        log.warn("Generate Post Notification Not found or muted", {
+                            userId: activity.user_id,
+                            type: activity.type,
+                        });
+                        seriesCallback();
+                    }
+                });
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            if (activity.Group) {
+                // Notifications for all new posts in group
+                getModelAndUsersByType(models.Group, "GroupUsers", activity.Group.id, "all_group", (error, group) => {
+                    if (error) {
+                        seriesCallback(error);
+                    }
+                    else if (group) {
+                        addNotificationsForUsers(activity, group.GroupUsers, "notification.post.new", "all_group", uniqueUserIds, seriesCallback);
+                    }
+                    else {
+                        log.warn("Generate Post Notification Not found or muted", {
+                            userId: activity.user_id,
+                            type: activity.type,
+                        });
+                        seriesCallback();
+                    }
+                });
+            }
+            else {
+                seriesCallback();
+            }
+        },
+    ], (error) => {
+        callback(error);
+    });
+    // TODO: Add AcWatching community and group users
+    // TODO: Add AcFollowing
+};
+const generateNotificationsForEndorsements = (activity, callback) => {
+    // Notifications for endorsement on posts I've created
+    let mutePost = false;
+    if (!activity) {
+        return callback("Activity is null or undefined");
+    }
+    if (activity.Community &&
+        activity.Community.configuration &&
+        activity.Community.configuration.muteNotificationsForEndorsements) {
+        mutePost = true;
+    }
+    models.Post.findOne({
+        where: { id: activity.post_id },
+        include: [
+            {
+                model: models.User,
+                attributes: ["id", "notifications_settings", "email", "name"],
+                required: true,
+                where: {
+                    "notifications_settings.my_posts_endorsements.method": {
+                        $gt: 0,
+                    },
+                },
+            },
+        ],
+    })
+        .then((post) => {
+        if (post && !mutePost) {
+            addOrPossiblyGroupNotification(post, "notification.post.endorsement", "my_posts_endorsements", activity, post.User, 50, callback);
+        }
+        else {
+            log.warn("Generate Post Notification Not found or muted", {
+                userId: activity.user_id,
+                type: activity.type,
+            });
+            callback();
+        }
+    })
+        .catch((error) => {
+        callback(error);
+    });
+    // TODO: Add AcWatching users
+};
+module.exports = (activity, user, callback) => {
+    if (activity.type == "activity.post.new") {
+        generateNotificationsForNewPost(activity, callback);
+    }
+    else if (activity.type == "activity.post.endorsement.new" ||
+        activity.type == "activity.post.opposition.new") {
+        generateNotificationsForEndorsements(activity, callback);
+    }
+};

package/dist/active-citizen/engine/notifications/generate_post_status_change_notifications.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var models = require("../../../models/index.cjs");
+var async = require('async');
+var addNotificationsForUsers = require('./notifications_utils.cjs').addNotificationsForUsers;
+var _ = require('lodash');
+var generateNotificationsForPostStatusChange = function (activity, uniqueUserIds, callback) {
+    async.series([
+        function (seriesCallback) {
+            if (activity.post_id) {
+                models.Endorsement.findAll({
+                    where: {
+                        post_id: activity.post_id
+                    },
+                    attributes: ['id', 'user_id'],
+                    include: [
+                        {
+                            model: models.User,
+                            required: true,
+                            attributes: ['id', 'name', 'email']
+                        }
+                    ]
+                }).then(function (endorsements) {
+                    var users = _.map(endorsements, function (item) { return item.User; });
+                    addNotificationsForUsers(activity, users, "notification.post.status.change", "priority", uniqueUserIds, seriesCallback);
+                }).catch(function (error) {
+                    seriesCallback(error);
+                });
+            }
+            else {
+                seriesCallback();
+            }
+        }
+    ], function (error) {
+        callback(error);
+    });
+};
+module.exports = function (activity, user, callback) {
+    // Make sure not to create duplicate notifications to the same user
+    var uniqueUserIds = { users: [] };
+    generateNotificationsForPostStatusChange(activity, uniqueUserIds, callback);
+};

package/dist/active-citizen/engine/notifications/notifications_utils.cjs

@@ -0,0 +1,148 @@
+"use strict";
+const models = require("../../../models/index.cjs");
+const async = require('async');
+const _ = require('lodash');
+const getModelAndUsersByType = (model, userType, id, notification_setting_type, callback) => {
+    const userWhere = {};
+    userWhere["notifications_settings." + notification_setting_type + ".method"] = {
+        $gt: 0
+    };
+    //log.info("getModelAndUsersByType", { type: notification_setting_type, userWhere: userWhere });
+    // TODO: Use streams when ready https://github.com/sequelize/sequelize/issues/2454
+    model.findOne({
+        where: { id: id },
+        include: [
+            {
+                model: models.User,
+                attributes: ['id', 'notifications_settings', 'email'],
+                as: userType,
+                where: userWhere
+            }
+        ]
+    }).then((results) => {
+        //log.info("Notification Processing found users", { numberOfUsers: results ? results.length : null, userWhere: userWhere });
+        if (results) {
+            callback(null, results);
+        }
+        else {
+            callback();
+        }
+    }).catch((error) => {
+        callback(error);
+    });
+};
+const addNotificationsForUsers = (activity, users, notification_type, notification_setting_type, uniqueUserIds, callback) => {
+    async.eachSeries(users, (user, seriesCallback) => {
+        if (_.includes(uniqueUserIds.users, user.id)) {
+            seriesCallback();
+        }
+        else {
+            models.AcNotification.createNotificationFromActivity(user, activity, notification_type, notification_setting_type, 50, (error) => {
+                uniqueUserIds.users.push(user.id);
+                seriesCallback(error);
+            });
+        }
+    }, (error) => {
+        callback(error);
+    });
+};
+// type: 'notification.post.endorsement';
+const addOrPossiblyGroupNotification = (model, notification_type, notification_setting_type, activity, user, priority, callback) => {
+    let modelWhereOptions;
+    if (model.constructor.options.tableName == 'posts') {
+        modelWhereOptions = {
+            post_id: model.id
+        };
+    }
+    else {
+        modelWhereOptions = {
+            point_id: model.id
+        };
+    }
+    // Look for already generated notification for this content in the group ttl time
+    models.AcNotification.findAll({
+        where: {
+            user_id: user.id,
+            type: notification_type,
+            created_at: {
+                $lt: new Date(),
+                $gt: new Date(new Date() - models.AcNotification.ENDORSEMENT_GROUPING_TTL)
+            }
+        },
+        attributes: ['id', 'type', 'user_id', 'created_at'],
+        order: [
+            ["created_at", "desc"]
+        ],
+        include: [
+            {
+                model: models.AcActivity,
+                as: 'AcActivities',
+                attributes: ['id', 'post_id', 'point_id', 'type'],
+                required: true,
+                where: modelWhereOptions
+            }
+        ]
+    }).then((notifications) => {
+        const notification = notifications[0];
+        if (notification) {
+            // We check for repeated activity by the same user on the same content and  then don't create or update the notification
+            models.AcNotification.findAll({
+                where: {
+                    user_id: user.id,
+                    type: notification_type,
+                    created_at: {
+                        $lt: new Date(),
+                        $gt: new Date(new Date() - models.AcNotification.ENDORSEMENT_GROUPING_TTL)
+                    }
+                },
+                order: [
+                    ["created_at", "desc"]
+                ],
+                include: [
+                    {
+                        model: models.AcActivity,
+                        as: 'AcActivities',
+                        required: true,
+                        where: _.merge(modelWhereOptions, {
+                            user_id: activity.user_id,
+                            type: activity.type
+                        })
+                    }
+                ]
+            }).then((specificNotifications) => {
+                const specificNotification = specificNotifications[0];
+                if (specificNotification) {
+                    specificNotification.changed('viewed', false);
+                    specificNotification.changed('updated_at', true);
+                    specificNotification.save().then(() => {
+                        callback();
+                    }).catch((error) => {
+                        callback(error);
+                    });
+                }
+                else {
+                    notification.addAcActivities(activity).then((results) => {
+                        if (results) {
+                            // Create events for the worker queue
+                            models.AcNotification.processNotification(notification, user, activity, callback);
+                        }
+                        else {
+                            callback("Notification Error Can't add activity");
+                        }
+                    });
+                }
+            });
+        }
+        else {
+            // If not already found and grouped we
+            models.AcNotification.createNotificationFromActivity(user, activity, notification_type, notification_setting_type, priority, (error) => {
+                callback(error);
+            });
+        }
+    });
+};
+module.exports = {
+    getModelAndUsersByType: getModelAndUsersByType,
+    addNotificationsForUsers: addNotificationsForUsers,
+    addOrPossiblyGroupNotification: addOrPossiblyGroupNotification
+};

package/dist/active-citizen/engine/notifications/point_delivery.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var filterNotificationForDelivery = require("./emails_utils.cjs").filterNotificationForDelivery;
+module.exports = function (notification, user, callback) {
+    if (notification &&
+        user &&
+        notification.AcActivities &&
+        notification.AcActivities.length > 0) {
+        var contentName = "";
+        if (notification.AcActivities[0].Post) {
+            contentName = notification.AcActivities[0].Post.name;
+        }
+        else if (notification.AcActivities[0].Point.Group &&
+            notification.AcActivities[0].Point.Group.name !=
+                "hidden_public_group_for_domain_level_points") {
+            contentName = notification.AcActivities[0].Point.Group.name;
+        }
+        else if (notification.AcActivities[0].Point.Community) {
+            contentName = notification.AcActivities[0].Point.Community.name;
+        }
+        else if (notification.AcActivities[0].Point.Domain) {
+            contentName = notification.AcActivities[0].Point.Group.Domain.name;
+        }
+        if (notification.type == "notification.point.new") {
+            filterNotificationForDelivery(notification, user, "point_activity", {
+                translateToken: "notification.email.newPointOnMyPoint",
+                contentName: contentName,
+            }, callback);
+        }
+        else if (notification.type == "notification.point.newsStory") {
+            filterNotificationForDelivery(notification, user, "point_news_story", {
+                translateToken: "notification.email.newsStory",
+                contentName: contentName,
+            }, callback);
+        }
+        else if (notification.type == "notification.point.comment") {
+            filterNotificationForDelivery(notification, user, "point_comment", {
+                translateToken: "notification.email.comment",
+                contentName: contentName,
+            }, callback);
+        }
+        else if (notification.type == "notification.point.quality") {
+            var subjectTranslateToken = notification.AcActivities[0].type.indexOf("activity.point.helpful") > -1
+                ? "notification.email.pointHelpful"
+                : "notification.email.pointUnhelpful";
+            filterNotificationForDelivery(notification, user, "point_activity", { translateToken: subjectTranslateToken, contentName: contentName }, callback);
+        }
+        else {
+            callback("Unknown state for notification filtering: " + notification.type);
+        }
+    }
+    else {
+        callback("Missing data for notification delivery");
+    }
+};

package/dist/active-citizen/engine/notifications/post_delivery.cjs

@@ -0,0 +1,31 @@
+"use strict";
+var filterNotificationForDelivery = require("./emails_utils.cjs").filterNotificationForDelivery;
+module.exports = function (notification, user, callback) {
+    if (notification &&
+        user &&
+        notification.AcActivities &&
+        notification.AcActivities.length > 0 &&
+        notification.AcActivities[0].type) {
+        var post = notification.AcActivities[0].Post;
+        var postName = post ? post.name : "?";
+        if (!post) {
+            callback("No public post found for notification delivery");
+        }
+        else if (notification.type == "notification.post.new") {
+            filterNotificationForDelivery(notification, user, "post_activity", { translateToken: "notification.email.postNew", contentName: postName }, callback);
+        }
+        else if (notification.type == "notification.post.endorsement") {
+            var subjectTranslateToken = notification.AcActivities[0].type.indexOf("activity.post.endorsement") >
+                -1
+                ? "notification.email.postEndorsement"
+                : "notification.email.postOpposition";
+            filterNotificationForDelivery(notification, user, "post_activity", { translateToken: subjectTranslateToken, contentName: postName }, callback);
+        }
+        else {
+            callback();
+        }
+    }
+    else {
+        callback("Missing data for notification delivery");
+    }
+};