@yrpri/api 9.0.101 → 9.0.103

package/dist/models/point.cjs

@@ -0,0 +1,622 @@
+"use strict";
+const async = require('async');
+const queue = require('../active-citizen/workers/queue.cjs');
+const log = require('../utils/logger.cjs');
+const _ = require("lodash");
+const findCommunityAndDomainForPointFromGroup = (sequelize, options, callback) => {
+    sequelize.models.Group.findOne({
+        where: {
+            id: options.group_id
+        },
+        include: [
+            {
+                model: sequelize.models.Community,
+                attributes: ['id'],
+                required: true,
+                include: [
+                    {
+                        model: sequelize.models.Domain,
+                        attributes: ['id'],
+                        required: true
+                    }
+                ]
+            }
+        ]
+    }).then((group) => {
+        if (group) {
+            options.community_id = group.Community.id;
+            options.domain_id = group.Community.Domain.id;
+        }
+        callback(null, options);
+    }).catch((error) => {
+        callback(error);
+    });
+};
+const attachEmptyGroupIfNeeded = (sequelize, options, callback) => {
+    if (!options.group_id &&
+        (options.domain_id || (options.community_id && options.communityAccess == sequelize.models.Community.ACCESS_PUBLIC))) {
+        sequelize.models.Group.findOrCreate({ where: { name: 'hidden_public_group_for_domain_level_points' },
+            defaults: { access: sequelize.models.Group.ACCESS_PUBLIC } })
+            .then(results => {
+            const [group, created] = results;
+            if (group) {
+                options.group_id = group.id;
+                callback(null, options);
+            }
+            else {
+                callback("Can't create hidden public group for domain level points");
+            }
+        }).catch(error => {
+            callback(error);
+        });
+    }
+    else {
+        callback(null, options);
+    }
+};
+const findGroupAndCommunityAndDomainForPointFromPost = (sequelize, options, callback) => {
+    sequelize.models.Post.findOne({
+        where: {
+            id: options.post_id
+        },
+        include: [
+            {
+                model: sequelize.models.Group,
+                attributes: ['id'],
+                required: true,
+                include: [
+                    {
+                        model: sequelize.models.Community,
+                        attributes: ['id'],
+                        required: true,
+                        include: [
+                            {
+                                model: sequelize.models.Domain,
+                                attributes: ['id'],
+                                required: true
+                            }
+                        ]
+                    }
+                ]
+            }
+        ]
+    }).then((post) => {
+        options.group_id = post.Group.id;
+        options.community_id = post.Group.Community.id;
+        options.domain_id = post.Group.Community.Domain.id;
+        callback(null, options);
+    }).catch((error) => {
+        callback(error);
+    });
+};
+const findDomainFromCommunity = (sequelize, options, callback) => {
+    sequelize.models.Community.findOne({
+        where: {
+            id: options.community_id
+        },
+        attributes: ['id', 'access'],
+        include: [
+            {
+                model: sequelize.models.Domain,
+                attributes: ['id'],
+                required: true
+            }
+        ]
+    }).then((community) => {
+        options.domain_id = community.Domain.id;
+        options.communityAccess = community.access;
+        callback(null, options);
+    }).catch((error) => {
+        callback(error);
+    });
+};
+const setAllActivityGroupingIds = (sequelize, options, callback) => {
+    async.series([
+        (seriesCallback) => {
+            if (options.post_id) {
+                findGroupAndCommunityAndDomainForPointFromPost(sequelize, options, (error, optionsIn) => {
+                    if (optionsIn) {
+                        options = optionsIn;
+                    }
+                    seriesCallback(error);
+                });
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            if (options.group_id) {
+                findCommunityAndDomainForPointFromGroup(sequelize, options, (error, optionsIn) => {
+                    if (optionsIn) {
+                        options = optionsIn;
+                    }
+                    seriesCallback(error);
+                });
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        (seriesCallback) => {
+            if (options.community_id) {
+                findDomainFromCommunity(sequelize, options, (error, optionsIn) => {
+                    if (optionsIn) {
+                        options = optionsIn;
+                    }
+                    seriesCallback(error);
+                });
+            }
+            else {
+                seriesCallback();
+            }
+        },
+        // Attach an empty public group to domain and community levels to enable join on activities with group access control
+        (seriesCallback) => {
+            attachEmptyGroupIfNeeded(sequelize, options, (error, optionsIn) => {
+                if (optionsIn) {
+                    options = optionsIn;
+                }
+                seriesCallback(error);
+            });
+        }
+    ], (error) => {
+        callback(error);
+    });
+};
+module.exports = (sequelize, DataTypes) => {
+    const Point = sequelize.define("Point", {
+        name: { type: DataTypes.STRING, allowNull: true },
+        content_type: { type: DataTypes.INTEGER, allowNull: false, defaultValue: 0 },
+        content: { type: DataTypes.TEXT, allowNull: false },
+        status: { type: DataTypes.STRING, allowNull: false },
+        value: { type: DataTypes.INTEGER, allowNull: false },
+        website: DataTypes.STRING,
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+        deleted_at: { type: DataTypes.DATE, allowNull: true },
+        ip_address: { type: DataTypes.STRING, allowNull: false },
+        user_agent: { type: DataTypes.TEXT, allowNull: false },
+        counter_revisions: { type: DataTypes.INTEGER, defaultValue: 1 },
+        counter_quality_up: { type: DataTypes.INTEGER, defaultValue: 0 },
+        counter_quality_down: { type: DataTypes.INTEGER, defaultValue: 0 },
+        counter_flags: { type: DataTypes.INTEGER, defaultValue: 0 },
+        embed_data: DataTypes.JSONB,
+        data: DataTypes.JSONB,
+        public_data: DataTypes.JSONB,
+        language: { type: DataTypes.STRING, allowNull: true }
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false,
+                status: 'published'
+            }
+        },
+        indexes: [
+            {
+                fields: ['post_id'],
+                where: {
+                    deleted: false
+                }
+            },
+            {
+                fields: ['data'],
+                using: 'gin',
+                operator: 'jsonb_path_ops'
+            },
+            {
+                fields: ['public_data'],
+                using: 'gin',
+                operator: 'jsonb_path_ops'
+            },
+            {
+                fields: ['image_id'],
+                where: {
+                    deleted: false
+                }
+            },
+            {
+                fields: ['post_status_change_id'],
+                where: {
+                    deleted: false
+                }
+            },
+            {
+                fields: ['parent_point_id'],
+                where: {
+                    deleted: false
+                }
+            },
+            {
+                fields: ['user_id', 'group_id', 'deleted']
+            },
+            {
+                fields: ['user_id', 'group_id', 'deleted', 'status']
+            },
+            {
+                fields: ['id', 'deleted', 'status']
+            },
+            {
+                fields: ['post_id', 'deleted', 'status']
+            },
+            {
+                fields: ['post_id', 'deleted', 'status', 'created_at']
+            },
+            {
+                name: 'points_idx_deleted_status_id',
+                fields: ['deleted', 'status', 'id']
+            },
+            {
+                name: 'points_idx_deleted_status',
+                fields: ['deleted', 'status']
+            }
+        ],
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'points',
+    });
+    Point.defaultAttributesPublic = [
+        'id', 'name', 'content_type', 'content', 'status', 'value',
+        'website', 'deleted', 'counter_revisions', 'counter_quality_up',
+        'embed_data', 'counter_quality_down', 'public_data', 'language'
+    ];
+    Point.associate = (models) => {
+        Point.belongsTo(sequelize.models.PostStatusChange, { foreignKey: 'post_status_change_id' });
+        Point.belongsTo(sequelize.models.Post, { foreignKey: 'post_id' });
+        Point.belongsTo(sequelize.models.Community, { foreignKey: 'community_id' });
+        Point.belongsTo(sequelize.models.Domain, { foreignKey: 'domain_id' });
+        Point.belongsTo(sequelize.models.User, { foreignKey: 'user_id' });
+        Point.belongsTo(sequelize.models.Image, { foreignKey: 'image_id' });
+        Point.belongsTo(sequelize.models.Point, { as: 'ParentPoint', foreignKey: 'parent_point_id' });
+        Point.belongsTo(sequelize.models.Group, { foreignKey: 'group_id' });
+        Point.hasMany(sequelize.models.PointRevision);
+        Point.hasMany(sequelize.models.PointQuality);
+        Point.belongsToMany(models.Video, { as: 'PointVideos', through: 'PointVideo' });
+        Point.belongsToMany(models.Audio, { as: 'PointAudios', through: 'PointAudio' });
+    };
+    Point.CONTENT_DEBATE = 0;
+    Point.CONTENT_NEWS_STORY = 1;
+    Point.CONTENT_COMMENT = 2;
+    Point.createComment = (req, options, callback) => {
+        options.content = options.comment.content;
+        delete options.comment;
+        options.user_id = req.user.id;
+        options.content_type = sequelize.models.Point.CONTENT_COMMENT;
+        options.value = 0;
+        options.status = 'published';
+        options.user_agent = req.useragent.source;
+        options.ip_address = req.clientIp;
+        async.series([
+            (seriesCallback) => {
+                if (options.parent_point_id) {
+                    sequelize.models.Point.findOne({
+                        where: {
+                            id: options.parent_point_id
+                        },
+                        attributes: ['id', 'group_id', 'post_id', 'community_id', 'domain_id']
+                    }).then((parentPoint) => {
+                        if (parentPoint) {
+                            options.group_id = parentPoint.group_id;
+                            options.community_id = parentPoint.community_id;
+                            options.domain_id = parentPoint.domain_id;
+                            options.post_id = options.post_id ? options.post_id : parentPoint.post_id;
+                        }
+                        seriesCallback();
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            },
+            (seriesCallback) => {
+                if (options.image_id) {
+                    sequelize.models.Image.findOne({
+                        where: {
+                            id: options.image_id
+                        },
+                        attributes: ['id', 'user_id'],
+                        include: [
+                            {
+                                model: sequelize.models.Post,
+                                as: 'PostUserImages',
+                                attributes: ['id', 'group_id']
+                            }
+                        ]
+                    }).then((image) => {
+                        if (image && image.PostUserImages && image.PostUserImages.length > 0) {
+                            options.group_id = image.PostUserImages[0].group_id;
+                            options.post_id = image.PostUserImages[0].id;
+                        }
+                        seriesCallback();
+                    }).catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            },
+            (seriesCallback) => {
+                setAllActivityGroupingIds(sequelize, options, (error, optionsIn) => {
+                    if (optionsIn) {
+                        options = optionsIn;
+                    }
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                options.data = {
+                    browserId: req.body.pointBaseId,
+                    browserFingerprint: req.body.pointValCode,
+                    browserFingerprintConfidence: req.body.pointConf,
+                    originalQueryString: req.body.originalQueryString,
+                    userLocale: req.body.userLocale,
+                    userAutoTranslate: req.body.userAutoTranslate,
+                    referrer: req.body.referrer,
+                    url: req.body.url,
+                    screen_width: req.body.screen_width
+                };
+                sequelize.models.Point.build(options).save().then((point) => {
+                    options.point_id = point.id;
+                    const pointRevision = sequelize.models.PointRevision.build(options);
+                    pointRevision.save().then(() => {
+                        log.info("process-moderation point toxicity on comment");
+                        queue.add('process-moderation', { type: 'estimate-point-toxicity', pointId: point.id }, 'high');
+                        sequelize.models.AcActivity.createActivity({
+                            type: 'activity.point.comment.new',
+                            userId: options.user_id,
+                            pointId: options.point_id,
+                            imageId: options.image_id,
+                            domainId: options.domain_id,
+                            groupId: options.group_id ? options.group_id : 1,
+                            communityId: options.community_id,
+                            postId: options.post_id,
+                            access: sequelize.models.AcActivity.ACCESS_PUBLIC
+                        }, (error) => {
+                            seriesCallback(error);
+                        });
+                    });
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            }
+        ], (error) => {
+            callback(error);
+        });
+    };
+    //TODO Refactor duplicate code with Post
+    Point.setOrganizationUsersForPoints = (points, done) => {
+        const userIds = points.map(p => {
+            return p.user_id;
+        });
+        sequelize.models.User.findAll({
+            attributes: ['id', 'created_at'],
+            where: {
+                id: {
+                    $in: userIds
+                }
+            },
+            include: [
+                {
+                    model: sequelize.models.Organization,
+                    as: 'OrganizationUsers',
+                    required: true,
+                    attributes: ['id', 'name'],
+                    include: [
+                        {
+                            model: sequelize.models.Image,
+                            as: 'OrgLogoImgs',
+                            attributes: ['id', 'formats'],
+                            required: false
+                        }
+                    ]
+                }
+            ],
+            order: [
+                [{ model: sequelize.models.Organization, as: 'OrganizationUsers' }, { model: sequelize.models.Image, as: 'OrgLogoImgs' }, 'created_at', 'asc']
+            ]
+        }).then(users => {
+            if (users && users.length > 0) {
+                for (let u = 0; u < users.length; u++) {
+                    for (let p = 0; p < points.length; p++) {
+                        if (points[p].User.id === users[u].id) {
+                            points[p].User.OrganizationUsers = users[u].OrganizationUsers;
+                            points[p].User.setDataValue('OrganizationUsers', users[u].OrganizationUsers);
+                        }
+                    }
+                }
+                done();
+            }
+            else {
+                done();
+            }
+        }).catch(error => {
+            done(error);
+        });
+    };
+    Point.setVideosForPoints = (points, done) => {
+        Point.getVideosForPoints(points.map(p => p.id), (error, videos) => {
+            if (error) {
+                done(error);
+            }
+            else if (!videos || videos.length === 0) {
+                done();
+            }
+            else {
+                for (let v = 0; v < videos.length; v++) {
+                    for (let p = 0; p < points.length; p++) {
+                        if (videos[v].PointVideos &&
+                            videos[v].PointVideos.length > 0 &&
+                            points[p].id === videos[v].PointVideos[0].id) {
+                            if (!points[p].PointVideos) {
+                                points[p].PointVideos = [];
+                            }
+                            points[p].PointVideos.push(videos[v]);
+                            points[p].setDataValue('PointVideos', points[p].PointVideos);
+                        }
+                    }
+                }
+                done();
+            }
+        });
+    };
+    //TODO Refactor duplicate code with Post
+    Point.getVideosForPoints = (pointIds, done) => {
+        sequelize.models.Video.findAll({
+            attributes: ['id', 'formats', 'viewable', 'created_at', 'public_meta'],
+            include: [
+                {
+                    model: sequelize.models.Image,
+                    as: 'VideoImages',
+                    attributes: ["formats", 'created_at'],
+                    required: false
+                },
+                {
+                    model: sequelize.models.Point,
+                    where: {
+                        id: {
+                            $in: pointIds
+                        }
+                    },
+                    as: 'PointVideos',
+                    required: true,
+                    attributes: ['id'],
+                }
+            ],
+            order: [
+                [{ model: sequelize.models.Image, as: 'VideoImages' }, 'created_at', 'asc']
+            ]
+        }).then(videos => {
+            videos = _.orderBy(videos, ['created_at'], ['desc']);
+            done(null, videos);
+        }).catch(error => {
+            done(error);
+        });
+    };
+    Point.addVideosToAllActivityPoints = (activities, videos) => {
+        const pointsHash = {};
+        for (let i = 0; i < activities.length; i++) {
+            if (activities[i].Point) {
+                pointsHash[activities[i].Point.id] = activities[i].Point;
+            }
+        }
+        for (let i = 0; i < videos.length; i++) {
+            if (videos[i].PointVideos && videos[i].PointVideos.length > 0) {
+                const pointId = videos[i].PointVideos[0].id;
+                if (pointsHash[pointId]) {
+                    if (!pointsHash[pointId].dataValues.PointVideos) {
+                        pointsHash[pointId].dataValues.PointVideos = [];
+                    }
+                    pointsHash[pointId].dataValues.PointVideos.push(videos[i]);
+                }
+                else {
+                    log.error("Can't find point to add video to");
+                }
+            }
+            else {
+                log.error("Can't find PointVideos");
+            }
+        }
+    };
+    Point.createNewsStory = (req, options, callback) => {
+        options.content = options.point.content;
+        options.embed_data = options.point.embed_data;
+        delete options.point;
+        async.series([
+            (seriesCallback) => {
+                setAllActivityGroupingIds(sequelize, options, (error, optionsIn) => {
+                    if (optionsIn) {
+                        options = optionsIn;
+                    }
+                    seriesCallback(error);
+                });
+            }
+        ], (error) => {
+            options.user_id = req.user.id;
+            options.content_type = sequelize.models.Point.CONTENT_NEWS_STORY;
+            options.value = 0;
+            options.status = 'published';
+            options.user_agent = req.useragent.source;
+            options.ip_address = req.clientIp;
+            sequelize.models.Point.build(options).save().then((point) => {
+                options.point_id = point.id;
+                const pointRevision = sequelize.models.PointRevision.build(options);
+                pointRevision.save().then(() => {
+                    log.info("process-moderation point toxicity on news story");
+                    if (!options.subType || options.subType != "bulkOperation") {
+                        queue.add('process-moderation', { type: 'estimate-point-toxicity', pointId: point.id }, 'high');
+                    }
+                    sequelize.models.AcActivity.createActivity({
+                        type: 'activity.point.newsStory.new',
+                        userId: options.user_id,
+                        subType: options.subType ? options.subType : null,
+                        domainId: options.domain_id,
+                        groupId: options.group_id ? options.group_id : 1,
+                        pointId: options.point_id,
+                        context: options.context ? options.context : null,
+                        communityId: options.community_id,
+                        postId: options.post_id,
+                        access: sequelize.models.AcActivity.ACCESS_PUBLIC
+                    }, (error) => {
+                        callback(error, point);
+                    });
+                });
+            }).catch((error) => {
+                callback(error);
+            });
+        });
+    };
+    Point.prototype.setupModerationData = function () {
+        if (!this.data) {
+            this.set('data', {});
+        }
+        if (!this.data.moderation) {
+            this.set('data.moderation', {});
+        }
+    };
+    Point.prototype.report = function (req, source, post, callback) {
+        this.setupModerationData();
+        async.series([
+            (seriesCallback) => {
+                if (!this.data.moderation.lastReportedBy) {
+                    this.set('data.moderation.lastReportedBy', []);
+                    if ((source === 'user' || source === 'fromUser') && !this.data.moderation.toxicityScore) {
+                        log.info("process-moderation point toxicity on manual report");
+                        queue.add('process-moderation', { type: 'estimate-point-toxicity', pointId: this.id }, 'high');
+                    }
+                }
+                this.set('data.moderation.lastReportedBy', [{ date: new Date(), source: source, userId: (req && req.user) ? req.user.id : null, userEmail: (req && req.user) ? req.user.email : 'anonymous' }].concat(this.data.moderation.lastReportedBy));
+                this.save().then(() => {
+                    seriesCallback();
+                }).catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                if (req && req.disableNotification === true) {
+                    seriesCallback();
+                }
+                else {
+                    sequelize.models.AcActivity.createActivity({
+                        type: 'activity.report.content',
+                        userId: (req && req.user) ? req.user.id : null,
+                        postId: post ? post.id : this.post_id,
+                        groupId: (post && post.Group) ? post.Group.id : this.group_id,
+                        pointId: this.id,
+                        communityId: (post && post.Group && post.Group.Community) ? post.Group.Community.id : null,
+                        domainId: (post && post.Group && post.Group.Community && post.Group.Community.Domain) ? post.Group.Community.Domain.id : null
+                    }, (error) => {
+                        seriesCallback();
+                    });
+                }
+            }
+        ], (error) => {
+            this.increment('counter_flags');
+            callback(error);
+        });
+    };
+    return Point;
+};

package/dist/models/point_quality.cjs

@@ -0,0 +1,39 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const PointQuality = sequelize.define("PointQuality", {
+        value: { type: DataTypes.INTEGER, allowNull: false },
+        status: { type: DataTypes.STRING, allowNull: false },
+        ip_address: { type: DataTypes.STRING, allowNull: false },
+        user_agent: { type: DataTypes.TEXT, allowNull: false },
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+        data: { type: DataTypes.JSONB, allowNull: true },
+    }, {
+        underscored: true,
+        tableName: 'point_qualities',
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        defaultScope: {
+            where: {
+                deleted: false
+            }
+        },
+        indexes: [
+            {
+                fields: ['user_id', 'deleted']
+            },
+            {
+                fields: ['id', 'deleted']
+            },
+            {
+                name: 'point_qualities_idx_deleted',
+                fields: ['deleted']
+            }
+        ]
+    });
+    PointQuality.associate = (models) => {
+        PointQuality.belongsTo(models.Point, { foreignKey: 'point_id' });
+        PointQuality.belongsTo(models.User, { foreignKey: 'user_id' });
+    };
+    return PointQuality;
+};