@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/controllers/notifications.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var express = require('express');
+var router = express.Router();
+var models = require("../../models/index.cjs");
+var auth = require('../../authorization.cjs');
+var log = require('../utils/logger.cjs');
+var _ = require('lodash');
+var async = require('async');
+var getCommonWhereDateOptions = require('../engine/news_feeds/news_feeds_utils.cjs').getCommonWhereDateOptions;
+var getNotifications = function (req, options, callback) {
+    options = _.merge(options, {
+        dateColumn: 'updated_at'
+    });
+    if (req.query.afterDate) {
+        options = _.merge(options, {
+            afterDate: new Date(req.query.afterDate)
+        });
+    }
+    if (req.query.beforeDate) {
+        options = _.merge(options, {
+            beforeDate: new Date(req.query.beforeDate)
+        });
+    }
+    var where = _.merge({
+        user_id: req.user.id
+    }, getCommonWhereDateOptions(options));
+    var activityWhereOptions;
+    //TODO: Enabled this when limit bug is fixed in Sequelize or de normalize domain_id to notifications
+    /*
+    if (process.env.NODE_ENV == 'production') {
+      activityWhereOptions = { domain_id: req.ypDomain.id }
+    }
+    */
+    var notifications, unViewedCount;
+    async.series([
+        function (seriesCallback) {
+            models.AcNotification.findAll({
+                where: where,
+                attributes: ['id'],
+                order: [
+                    ["updated_at", "desc"]
+                ],
+                limit: 20
+            }).then(function (inNotifications) {
+                if (inNotifications) {
+                    notifications = inNotifications;
+                    seriesCallback();
+                }
+                else {
+                    seriesCallback("Notifications return null");
+                }
+            }).catch(function (error) {
+                seriesCallback(error);
+            });
+        },
+        function (seriesCallback) {
+            models.AcNotification.findAll({
+                where: {
+                    id: {
+                        $in: _.map(notifications, (item) => { return item.id; })
+                    }
+                },
+                attributes: ['id', 'type', 'created_at', 'updated_at', 'viewed'],
+                order: [
+                    ["updated_at", "desc"],
+                    [{ model: models.AcActivity, as: 'AcActivities' }, 'created_at', 'desc'],
+                    [{ model: models.AcActivity, as: 'AcActivities' }, models.User, { model: models.Image, as: 'UserProfileImages' }, 'created_at', 'asc'],
+                ],
+                include: [
+                    {
+                        model: models.AcActivity,
+                        as: 'AcActivities',
+                        attributes: ['id', 'type'],
+                        where: activityWhereOptions,
+                        required: true,
+                        include: [
+                            {
+                                model: models.Post,
+                                required: false,
+                                attributes: ['id', 'name', 'user_id']
+                            },
+                            { model: models.User,
+                                attributes: ["id", "name", "facebook_id", "twitter_id", "google_id", "github_id"],
+                                required: false,
+                                include: [
+                                    {
+                                        model: models.Image, as: 'UserProfileImages',
+                                        attributes: ['id', 'formats'],
+                                        required: false
+                                    }
+                                ]
+                            },
+                            {
+                                model: models.Community,
+                                required: false,
+                                attributes: ['id', 'name']
+                            },
+                            {
+                                model: models.Group,
+                                required: false,
+                                attributes: ['id', 'name']
+                            },
+                            {
+                                model: models.Point,
+                                required: false,
+                                attributes: ['id', 'value', 'content']
+                            }
+                        ]
+                    }
+                ]
+            }).then(function (inNotifications) {
+                notifications = inNotifications;
+                seriesCallback();
+            }).catch(function (error) {
+                seriesCallback(error);
+            });
+        },
+        function (seriesCallback) {
+            models.AcNotification.count({
+                where: {
+                    viewed: false,
+                    user_id: req.user.id
+                }
+            }).then(function (count) {
+                unViewedCount = count;
+                seriesCallback();
+            }).catch(function (error) {
+                seriesCallback(error);
+            });
+        }
+    ], function (error) {
+        if (error) {
+            callback(error);
+        }
+        else if (!notifications) {
+            callback("No notifications found");
+        }
+        else {
+            try {
+                const allActivities = [];
+                for (let n = 0; n < notifications.length; n++) {
+                    if (notifications[n].AcActivities) {
+                        for (let a = 0; a < notifications[n].AcActivities.length; a++) {
+                            allActivities.push(notifications[n].AcActivities[a]);
+                        }
+                    }
+                }
+                models.AcActivity.setOrganizationUsersForActivities(allActivities, (error) => {
+                    if (error) {
+                        callback(error);
+                    }
+                    else {
+                        callback(null, {
+                            notifications: notifications,
+                            unViewedCount: unViewedCount,
+                            oldestProcessedNotificationAt: notifications.length > 0 ? _.last(notifications).created_at : null
+                        });
+                    }
+                });
+            }
+            catch (error) {
+                callback(error);
+            }
+        }
+    });
+};
+router.get('/', auth.isLoggedInNoAnonymousCheck, function (req, res) {
+    var options = {};
+    getNotifications(req, options, function (error, notifications) {
+        if (error) {
+            log.error("Notifications Error", { userId: req.user ? req.user.id : null, errorStatus: 500, err: error });
+            res.sendStatus(500);
+        }
+        else {
+            res.send(notifications);
+        }
+    });
+});
+router.put('/markAllViewed', auth.isLoggedInNoAnonymousCheck, function (req, res) {
+    models.AcNotification.update({
+        viewed: true
+    }, {
+        where: { user_id: req.user.id },
+        silent: true
+    }).then(results => {
+        const [affectedCount, affectedRows] = results;
+        log.info("Notifications Have Marked All As Viewed", { affectedCount: affectedCount, affectedRows: affectedRows, userId: req.user ? req.user.id : null });
+        res.sendStatus(200);
+    }).catch(function (error) {
+        log.error("Notifications Have Marked All As Viewed Error", { userId: req.user ? req.user.id : null, err: error, errorStatus: 500 });
+        res.sendStatus(500);
+    });
+});
+router.put('/setIdsViewed', auth.isLoggedInNoAnonymousCheck, function (req, res) {
+    var viewedIds = req.body.viewedIds;
+    var unViewedCount;
+    async.series([
+        function (seriesCallback) {
+            models.AcNotification.update({
+                viewed: true
+            }, {
+                where: {
+                    user_id: req.user.id,
+                    id: {
+                        $in: viewedIds
+                    }
+                },
+                silent: true
+            }).then(results => {
+                const [affectedCount, affectedRows] = results;
+                log.info("Notifications Have Marked Ids As Viewed", { affectedCount: affectedCount, affectedRows: affectedRows, userId: req.user ? req.user.id : null });
+                seriesCallback();
+            }).catch(function (error) {
+                seriesCallback(error);
+            });
+        },
+        function (seriesCallback) {
+            models.AcNotification.count({
+                where: {
+                    viewed: false,
+                    user_id: req.user.id
+                }
+            }).then(function (count) {
+                unViewedCount = count;
+                seriesCallback();
+            }).catch(function (error) {
+                seriesCallback(error);
+            });
+        }
+    ], function (error) {
+        if (error) {
+            log.error("Notifications Have Marked Ids As Viewed Error", { userId: req.user ? req.user.id : null, err: error, errorStatus: 500 });
+            res.sendStatus(500);
+        }
+        else {
+            res.send({
+                viewedIds: viewedIds,
+                unViewedCount: unViewedCount
+            });
+        }
+    });
+});
+module.exports = router;

package/dist/active-citizen/controllers/recommendations.cjs

@@ -0,0 +1,280 @@
+"use strict";
+var express = require('express');
+var router = express.Router();
+var models = require("../../models/index.cjs");
+var auth = require('../../authorization.cjs');
+var log = require('../utils/logger.cjs');
+var _ = require('lodash');
+var moment = require('moment');
+var getRecommendationFor = require('../engine/recommendations/events_manager.cjs').getRecommendationFor;
+var airbrake = null;
+if (process.env.AIRBRAKE_PROJECT_ID) {
+    airbrake = require('../utils/airbrake.cjs');
+}
+var OVERALL_LIMIT = 7;
+var DATE_OPTIONS = { name: "date", after: moment().add(-1000, 'months').toISOString() };
+//var DATE_OPTIONS_YEAR = { name:"date", after: moment().add(-300, 'months').toISOString() };
+var setupOptions = function (req) {
+    var options = {
+        user_id: req.user ? req.user.id : -1
+    };
+    return options;
+};
+var processRecommendations = function (levelType, req, res, recommendedItemIds, error) {
+    if (error) {
+        log.error("Recommendation Error " + levelType, { err: error, id: req.params.id, userId: req.user ? req.user.id : -1, errorStatus: 500 });
+        if (airbrake) {
+            airbrake.notify(error).then((airbrakeErr) => {
+                if (airbrakeErr.error) {
+                    log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
+                }
+            });
+        }
+        res.send([]);
+    }
+    else {
+        if (recommendedItemIds.length > OVERALL_LIMIT) {
+            recommendedItemIds = _.dropRight(recommendedItemIds, recommendedItemIds.length - OVERALL_LIMIT);
+        }
+        log.info("Recommendations domains status", { recommendedItemIds: recommendedItemIds });
+        models.Post.findAll({
+            where: {
+                id: {
+                    $in: recommendedItemIds
+                }
+            },
+            order: [
+                [{ model: models.Image, as: 'PostHeaderImages' }, 'updated_at', 'asc'],
+                [{ model: models.Video, as: "PostVideos" }, { model: models.Image, as: 'VideoImages' }, 'updated_at', 'asc']
+            ],
+            attributes: ['id', 'name', 'description', 'public_data', 'status', 'content_type', 'official_status', 'counter_endorsements_up', 'cover_media_type',
+                'counter_endorsements_down', 'group_id', 'language', 'counter_points', 'counter_flags', 'location', 'created_at'],
+            include: [
+                {
+                    // Category
+                    model: models.Category,
+                    required: false,
+                    include: [
+                        {
+                            model: models.Image,
+                            required: false,
+                            as: 'CategoryIconImages'
+                        }
+                    ]
+                },
+                // Group
+                {
+                    model: models.Group,
+                    required: true,
+                    attributes: models.Group.defaultAttributesPublic,
+                    where: {
+                        status: {
+                            $in: ['active', 'featured']
+                        }
+                    },
+                    include: [
+                        {
+                            model: models.Category,
+                            required: false
+                        },
+                        {
+                            model: models.Community,
+                            attributes: ['id', 'name', 'theme_id'],
+                            required: false
+                        }
+                    ]
+                },
+                {
+                    model: models.Video,
+                    required: false,
+                    attributes: ['id', 'formats', 'updated_at', 'viewable', 'public_meta'],
+                    as: 'PostVideos',
+                    include: [
+                        {
+                            model: models.Image,
+                            as: 'VideoImages',
+                            attributes: ["formats", 'updated_at'],
+                            required: false
+                        },
+                    ]
+                },
+                // User
+                {
+                    model: models.User,
+                    required: false,
+                    attributes: models.User.defaultAttributesWithSocialMediaPublic
+                },
+                // Image
+                {
+                    model: models.Image,
+                    required: false,
+                    as: 'PostHeaderImages'
+                },
+                // PointRevision
+                {
+                    model: models.PostRevision,
+                    required: false
+                }
+            ]
+        }).then(function (posts) {
+            res.send(posts);
+        }).catch(function (error) {
+            log.error("Recommendation Error " + levelType, { err: error, id: req.params.id, userId: req.user ? req.user.id : -1, errorStatus: 500 });
+            if (airbrake) {
+                airbrake.notify(error).then((airbrakeErr) => {
+                    if (airbrakeErr.error) {
+                        log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
+                    }
+                    res.send([]);
+                });
+            }
+            else {
+                res.send([]);
+            }
+        });
+    }
+};
+var processRecommendationsLight = function (groupId, req, res, recommendedItemIds, error, redisCacheKey) {
+    if (error) {
+        log.error("processRecommendationsLight Error", { err: error, userId: req.user ? req.user.id : -1, errorStatus: 500 });
+        if (airbrake) {
+            airbrake.notify(error).then((airbrakeErr) => {
+                if (airbrakeErr.error) {
+                    log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
+                }
+                res.send({ recommendations: [], groupId: groupId });
+            });
+        }
+        else {
+            res.send({ recommendations: [], groupId: groupId });
+        }
+    }
+    else if (!recommendedItemIds) {
+        log.error("processRecommendationsLight no recommendedItemIds", { userId: req.user ? req.user.id : -1, errorStatus: 500 });
+        res.send({ recommendations: [], groupId: groupId });
+    }
+    else {
+        log.info("processRecommendationsLight for group status");
+        models.Post.findAll({
+            where: {
+                id: {
+                    $in: recommendedItemIds
+                }
+            },
+            attributes: ['id', 'name', 'description'],
+            include: [
+                {
+                    model: models.Group,
+                    required: true,
+                    attributes: models.Group.defaultAttributesPublic,
+                    where: {
+                        id: groupId
+                    }
+                }
+            ]
+        }).then(function (posts) {
+            posts.sort(function (a, b) {
+                return recommendedItemIds.indexOf(a.id) - recommendedItemIds.indexOf(b.id);
+            });
+            const recommendationsInfo = { recommendations: posts, groupId: groupId };
+            if (redisCacheKey) {
+                req.redisClient.setEx(redisCacheKey, process.env.RECOMMENDATIONS_CACHE_TTL ? parseInt(process.env.RECOMMENDATIONS_CACHE_TTL) : 5, JSON.stringify(recommendationsInfo));
+            }
+            res.send(recommendationsInfo);
+        }).catch(function (error) {
+            log.error("processRecommendationsLight Error ", { err: error, userId: req.user ? req.user.id : -1, errorStatus: 500 });
+            if (airbrake) {
+                airbrake.notify(error).then((airbrakeErr) => {
+                    if (airbrakeErr.error) {
+                        log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
+                    }
+                    res.send({ recommendations: [], groupId: groupId });
+                });
+            }
+            else {
+                res.send({ recommendations: [], groupId: groupId });
+            }
+        });
+    }
+};
+router.get('/domains/:id', auth.can('view domain'), function (req, res) {
+    var options = setupOptions(req);
+    options = _.merge(options, {
+        domain_id: req.params.id,
+        limit: OVERALL_LIMIT * 2
+    });
+    getRecommendationFor(req, options.user_id, DATE_OPTIONS, options, function (error, recommendedItemIds) {
+        processRecommendations("domain", req, res, recommendedItemIds, error);
+    }, req.user ? req.user.default_locale : null);
+});
+router.get('/communities/:id', auth.can('view community'), function (req, res) {
+    var options = setupOptions(req);
+    options = _.merge(options, {
+        community_id: req.params.id,
+        limit: OVERALL_LIMIT * 2
+    }, req.user ? req.user.default_locale : null);
+    getRecommendationFor(req, options.user_id, DATE_OPTIONS, options, function (error, recommendedItemIds) {
+        processRecommendations("community", req, res, recommendedItemIds, error);
+    }, req.user ? req.user.default_locale : null);
+});
+router.get('/groups/:id', auth.can('view group'), function (req, res) {
+    var options = setupOptions(req);
+    options = _.merge(options, {
+        group_id: req.params.id,
+        limit: OVERALL_LIMIT * 2
+    });
+    getRecommendationFor(req, options.user_id, DATE_OPTIONS, options, function (error, recommendedItemIds) {
+        processRecommendations("group", req, res, recommendedItemIds, error);
+    }, req.user ? req.user.default_locale : null);
+});
+router.put('/groups/:id/getPostRecommendations', auth.can('view group'), function (req, res) {
+    const redisCacheKey = "cache:getPostRecommendations:" + req.params.id + ":userId:" + (req.user ? req.user.id : "notLoggedIn");
+    req.redisClient.get(redisCacheKey).then(recommendations => {
+        if (recommendations) {
+            res.send(JSON.parse(recommendations));
+        }
+        else {
+            var options = setupOptions(req);
+            options = _.merge(options, {
+                group_id: req.params.id,
+                limit: 100
+            });
+            models.Group.findOne({
+                where: {
+                    id: req.params.id
+                },
+                attributes: [
+                    'id', 'configuration'
+                ]
+            }).then(group => {
+                if (group) {
+                    var dateOptions = null; //DATE_OPTIONS_YEAR;
+                    if (group.configuration && group.configuration.maxDaysBackForRecommendations && group.configuration.maxDaysBackForRecommendations) {
+                        var maxDays = parseInt(group.configuration.maxDaysBackForRecommendations);
+                        dateOptions = { name: "date", after: moment().add(-Math.abs(maxDays), 'days').toISOString() };
+                    }
+                    getRecommendationFor(req, options.user_id, dateOptions, options, function (error, recommendedItemIds) {
+                        if (!error) {
+                            processRecommendationsLight(req.params.id, req, res, recommendedItemIds, error, redisCacheKey);
+                        }
+                        else {
+                            log.error("Error from getRecommendationFor", { error });
+                            res.send({ recommendations: [], groupId: req.params.id });
+                        }
+                    }, req.user ? req.user.default_locale : null);
+                }
+                else {
+                    log.error("Group not found");
+                    res.send({ recommendations: [], groupId: req.params.id });
+                }
+            }).catch(error => {
+                log.error(error);
+                res.send({ recommendations: [], groupId: req.params.id });
+            });
+        }
+    }).catch(error => {
+        log.error(error);
+        res.send({ recommendations: [], groupId: req.params.id });
+    });
+});
+module.exports = router;