@yrpri/api 9.0.103 → 9.0.104

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

@@ -1,233 +0,0 @@
-"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

@@ -1,118 +0,0 @@
-"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

@@ -1,41 +0,0 @@
-"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

@@ -1,148 +0,0 @@
-"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

@@ -1,54 +0,0 @@
-"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

@@ -1,31 +0,0 @@
-"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");
-    }
-};