@yrpri/api 9.0.101 → 9.0.103

package/dist/models/group.cjs

@@ -0,0 +1,728 @@
+"use strict";
+const async = require("async");
+const queue = require("../active-citizen/workers/queue.cjs");
+const _ = require("lodash");
+const log = require("../utils/logger.cjs");
+module.exports = (sequelize, DataTypes) => {
+    const Group = sequelize.define("Group", {
+        name: { type: DataTypes.STRING, allowNull: false },
+        access: { type: DataTypes.INTEGER, allowNull: false },
+        deleted: {
+            type: DataTypes.BOOLEAN,
+            allowNull: false,
+            defaultValue: false,
+        },
+        google_analytics_code: { type: DataTypes.STRING, allowNull: true },
+        objectives: DataTypes.TEXT,
+        message_for_new_idea: DataTypes.TEXT,
+        message_to_users: DataTypes.TEXT,
+        is_group_folder: { type: DataTypes.BOOLEAN, defaultValue: false },
+        in_group_folder_id: { type: DataTypes.INTEGER, defaultValue: null },
+        weight: { type: DataTypes.INTEGER, defaultValue: 0 },
+        status: {
+            type: DataTypes.STRING,
+            allowNull: false,
+            defaultValue: "active",
+        },
+        counter_posts: { type: DataTypes.INTEGER, defaultValue: 0 },
+        counter_points: { type: DataTypes.INTEGER, defaultValue: 0 },
+        counter_users: { type: DataTypes.INTEGER, defaultValue: 0 },
+        counter_flags: { type: DataTypes.INTEGER, defaultValue: 0 },
+        theme_id: { type: DataTypes.INTEGER, defaultValue: null },
+        configuration: DataTypes.JSONB,
+        private_access_configuration: {
+            type: DataTypes.JSONB,
+            allowNull: true,
+        },
+        language: { type: DataTypes.STRING, allowNull: true },
+        data: DataTypes.JSONB,
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false,
+            },
+        },
+        timestamps: true,
+        createdAt: "created_at",
+        updatedAt: "updated_at",
+        underscored: true,
+        tableName: "groups",
+        indexes: [
+            {
+                fields: ["name"],
+                where: {
+                    deleted: false,
+                },
+            },
+            {
+                fields: ["id", "deleted"],
+            },
+            {
+                fields: ['private_access_configuration'],
+                using: 'gin',
+                operator: 'jsonb_path_ops'
+            },
+            {
+                fields: ['configuration'],
+                using: 'gin',
+                operator: 'jsonb_path_ops'
+            },
+            {
+                name: "groups_idx_counter_users",
+                fields: ["counter_users"],
+            },
+            {
+                name: "groups_idx_counter_users_community_id_access_deleted",
+                fields: ["counter_users", "community_id", "access", "deleted"],
+            },
+            {
+                fields: ["community_id", "deleted", "in_group_folder_id"],
+            },
+            {
+                fields: ["community_id", "deleted", "in_group_folder_id", "status"],
+            },
+            {
+                fields: ["community_id", "deleted", "is_group_folder"],
+            },
+            {
+                fields: ["community_id", "deleted", "is_group_folder", "access"],
+            },
+            {
+                fields: ["deleted", "in_group_folder_id", "status", "access"],
+            },
+            {
+                fields: [
+                    "community_id",
+                    "deleted",
+                    "in_group_folder_id",
+                    "status",
+                    "access",
+                ],
+            },
+            {
+                name: "ComDelComAccCountStatInGroup",
+                fields: [
+                    "deleted",
+                    "community_id",
+                    "access",
+                    "counter_users",
+                    "status",
+                    "in_group_folder_id",
+                ],
+            },
+            {
+                fields: ["id", "deleted", "is_group_folder"],
+            },
+            {
+                fields: ["deleted", "is_group_folder"],
+            },
+            {
+                fields: ["id", "deleted", "in_group_folder_id"],
+            },
+            {
+                fields: ["deleted", "in_group_folder_id"],
+            },
+        ],
+    });
+    Group.associate = (models) => {
+        Group.hasMany(models.Post, { foreignKey: "group_id" });
+        Group.hasMany(models.Point, { foreignKey: "group_id" });
+        Group.hasMany(models.Endorsement, { foreignKey: "group_id" });
+        Group.hasMany(models.Category, { foreignKey: "group_id" });
+        Group.belongsTo(models.Community, { foreignKey: "community_id" });
+        Group.belongsTo(models.IsoCountry, { foreignKey: "iso_country_id" });
+        Group.belongsTo(models.User, { foreignKey: "user_id" });
+        Group.hasMany(models.Group, {
+            as: "GroupFolders",
+            foreignKey: "in_group_folder_id",
+        });
+        Group.belongsTo(models.Group, {
+            as: "GroupFolder",
+            foreignKey: "in_group_folder_id",
+        });
+        Group.belongsToMany(models.Image, { through: "GroupImage" });
+        Group.belongsToMany(models.Video, {
+            as: "GroupLogoVideos",
+            through: "GroupLogoVideo",
+        });
+        Group.belongsToMany(models.Image, {
+            as: "GroupLogoImages",
+            through: "GroupLogoImage",
+        });
+        Group.belongsToMany(models.Video, {
+            as: "GroupHtmlVideos",
+            through: "GroupHtmlVideo",
+        });
+        Group.belongsToMany(models.Image, {
+            as: "GroupHtmlImages",
+            through: "GroupHtmlImage",
+        });
+        Group.belongsToMany(models.Image, {
+            as: "GroupHeaderImages",
+            through: "GroupHeaderImage",
+        });
+        Group.belongsToMany(models.User, {
+            as: "GroupUsers",
+            through: "GroupUser",
+        });
+        Group.belongsToMany(models.User, {
+            as: "GroupAdmins",
+            through: "GroupAdmin",
+        });
+        Group.belongsToMany(models.User, {
+            as: "GroupPromoters",
+            through: "GroupPromoter",
+        });
+        Group.hasMany(models.Campaign);
+    };
+    Group.ACCESS_PUBLIC = 0;
+    Group.ACCESS_CLOSED = 1;
+    Group.ACCESS_SECRET = 2;
+    Group.ACCESS_OPEN_TO_COMMUNITY = 3;
+    Group.defaultAttributesPublic = [
+        "id",
+        "name",
+        "access",
+        "google_analytics_code",
+        "is_group_folder",
+        "in_group_folder_id",
+        "status",
+        "weight",
+        "theme_id",
+        "community_id",
+        "created_at",
+        "updated_at",
+        "configuration",
+        "language",
+        "objectives",
+        "counter_posts",
+        "counter_points",
+        "counter_users",
+        "user_id",
+    ];
+    Group.masterGroupIncludes = (models) => {
+        return [
+            {
+                model: models.Community,
+                required: false,
+                attributes: [
+                    "id",
+                    "theme_id",
+                    "name",
+                    "access",
+                    "google_analytics_code",
+                    "configuration",
+                    "only_admins_can_create_groups",
+                ],
+                include: [
+                    {
+                        model: models.Domain,
+                        attributes: ["id", "theme_id", "name"],
+                    },
+                ],
+            },
+            {
+                model: models.Group,
+                required: false,
+                as: "GroupFolder",
+                attributes: ["id", "name"],
+            },
+            {
+                model: models.Category,
+                required: false,
+                attributes: ["id", "name"],
+                include: [
+                    {
+                        model: models.Image,
+                        required: false,
+                        as: "CategoryIconImages",
+                        attributes: models.Image.defaultAttributesPublic,
+                        order: [
+                            [
+                                { model: models.Image, as: "CategoryIconImages" },
+                                "updated_at",
+                                "asc",
+                            ],
+                        ],
+                    },
+                ],
+            },
+            {
+                model: models.Image,
+                as: "GroupLogoImages",
+                attributes: models.Image.defaultAttributesPublic,
+                required: false,
+            },
+            {
+                model: models.Image,
+                as: "GroupHeaderImages",
+                attributes: models.Image.defaultAttributesPublic,
+                required: false,
+            },
+        ];
+    };
+    Group.addVideosAndCommunityLinksToGroups = (groups, done) => {
+        const linkedCommunityIds = [];
+        const linkedCommunityIdToGroupIndex = {};
+        const groupsHash = {};
+        const collectedGroupIds = [];
+        for (let g = 0; g < groups.length; g++) {
+            if (groups[g].configuration &&
+                groups[g].configuration.actAsLinkToCommunityId) {
+                linkedCommunityIds.push(groups[g].configuration.actAsLinkToCommunityId);
+                linkedCommunityIdToGroupIndex[groups[g].configuration.actAsLinkToCommunityId] = g;
+            }
+            groupsHash[groups[g].id] = groups[g];
+            collectedGroupIds.push(groups[g].id);
+        }
+        async.series([
+            (seriesCallback) => {
+                //TODO: Limit then number of VideoImages to 1 - there is one very 10 sec
+                sequelize.models.Video.findAll({
+                    attributes: [
+                        "id",
+                        "formats",
+                        "viewable",
+                        "public_meta",
+                        "created_at",
+                    ],
+                    include: [
+                        {
+                            model: sequelize.models.Image,
+                            as: "VideoImages",
+                            attributes: ["formats", "created_at"],
+                            required: false,
+                        },
+                        {
+                            model: sequelize.models.Group,
+                            where: {
+                                id: {
+                                    $in: collectedGroupIds,
+                                },
+                            },
+                            as: "GroupLogoVideos",
+                            required: true,
+                            attributes: ["id"],
+                        },
+                    ],
+                    order: [
+                        [
+                            { model: sequelize.models.Image, as: "VideoImages" },
+                            "created_at",
+                            "asc",
+                        ],
+                    ],
+                })
+                    .then((videos) => {
+                    if (videos) {
+                        videos = _.orderBy(videos, ["created_at"], ["asc"]);
+                        for (let v = 0; v < videos.length; v++) {
+                            const groupId = videos[v].GroupLogoVideos[0].id;
+                            if (groupId) {
+                                groupsHash[groupId].dataValues.GroupLogoVideos = [
+                                    videos[v],
+                                ];
+                                groupsHash[groupId].GroupLogoVideos = [videos[v]];
+                            }
+                            else {
+                                log.warn("Not finding group id in hash");
+                            }
+                        }
+                        seriesCallback();
+                    }
+                    else {
+                        seriesCallback();
+                    }
+                })
+                    .catch((error) => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                if (linkedCommunityIds.length > 0) {
+                    sequelize.models.Community.findAll({
+                        where: {
+                            id: { $in: linkedCommunityIds },
+                        },
+                        attributes: [
+                            "id",
+                            "name",
+                            "description",
+                            "counter_posts",
+                            "counter_points",
+                            "counter_users",
+                            "language",
+                        ],
+                        order: [
+                            [
+                                { model: sequelize.models.Image, as: "CommunityLogoImages" },
+                                "created_at",
+                                "asc",
+                            ],
+                        ],
+                        include: [
+                            {
+                                model: sequelize.models.Image,
+                                as: "CommunityLogoImages",
+                                attributes: sequelize.models.Image.defaultAttributesPublic,
+                                required: false,
+                            },
+                        ],
+                    })
+                        .then((communities) => {
+                        async.eachOfLimit(communities, 20, (community, eachIndex, forEachVideoCallback) => {
+                            const index = linkedCommunityIdToGroupIndex[community.id];
+                            if (groups[index].dataValues) {
+                                groups[index].dataValues.CommunityLink = community;
+                            }
+                            else {
+                                groups[index].CommunityLink = community;
+                            }
+                            sequelize.models.Community.addVideosToCommunity(community, forEachVideoCallback);
+                        }, (error) => {
+                            seriesCallback(error);
+                        });
+                    })
+                        .catch((error) => {
+                        seriesCallback(error);
+                    });
+                }
+                else {
+                    seriesCallback();
+                }
+            },
+        ], (error) => {
+            done(error);
+        });
+    };
+    Group.addUserToGroupIfNeeded = (groupId, req, done) => {
+        sequelize.models.Group.findOne({
+            where: { id: groupId },
+            attributes: [
+                "id",
+                "community_id",
+                "counter_users",
+                "name",
+                "in_group_folder_id",
+            ],
+        }).then((group) => {
+            if (group &&
+                group.name !== "hidden_public_group_for_domain_level_points") {
+                group.hasGroupUser(req.user).then((result) => {
+                    if (!result) {
+                        async.parallel([
+                            (callback) => {
+                                group.addGroupUser(req.user).then((result) => {
+                                    group.increment("counter_users");
+                                    callback();
+                                });
+                            },
+                            (callback) => {
+                                sequelize.models.Community.findOne({
+                                    where: { id: group.community_id },
+                                    attributes: ["id"],
+                                }).then((community) => {
+                                    if (community) {
+                                        community.hasCommunityUser(req.user).then((result) => {
+                                            if (result) {
+                                                callback();
+                                            }
+                                            else {
+                                                community
+                                                    .addCommunityUser(req.user)
+                                                    .then((result) => {
+                                                    community.increment("counter_users");
+                                                    callback();
+                                                });
+                                            }
+                                        });
+                                    }
+                                    else {
+                                        callback();
+                                    }
+                                });
+                            },
+                            (callback) => {
+                                req.ypDomain.hasDomainUser(req.user).then((result) => {
+                                    if (result) {
+                                        callback();
+                                    }
+                                    else {
+                                        req.ypDomain.addDomainUser(req.user).then((result) => {
+                                            req.ypDomain.increment("counter_users");
+                                            callback();
+                                        });
+                                    }
+                                });
+                            },
+                        ], (err) => {
+                            if (group && group.in_group_folder_id) {
+                                queue.add("delayed-job", {
+                                    type: "recount-group-folder",
+                                    groupId: groupId,
+                                }, "low");
+                            }
+                            done(err);
+                        });
+                    }
+                    else {
+                        done();
+                    }
+                });
+            }
+            else {
+                done();
+            }
+        });
+    };
+    Group.convertAccessFromRadioButtons = (body) => {
+        let access = 0;
+        if (body.public) {
+            access = 0;
+        }
+        else if (body.closed) {
+            access = 1;
+        }
+        else if (body.secret) {
+            access = 2;
+        }
+        else if (body.open_to_community) {
+            access = 3;
+        }
+        return access;
+    };
+    Group.prototype.simple = function () {
+        return { id: this.id, name: this.name };
+    };
+    Group.prototype.updateAllExternalCounters = function (req, direction, column, done) {
+        async.parallel([
+            (callback) => {
+                sequelize.models.Community.findOne({
+                    where: { id: this.community_id },
+                }).then((community) => {
+                    if (direction === "up")
+                        community.increment(column);
+                    else if (direction === "down")
+                        community.decrement(column);
+                    callback();
+                });
+            },
+            (callback) => {
+                if (req.ypDomain) {
+                    if (direction === "up")
+                        req.ypDomain.increment(column);
+                    else if (direction === "down")
+                        req.ypDomain.decrement(column);
+                    callback();
+                }
+                else {
+                    callback();
+                }
+            },
+            (callback) => {
+                if (this.in_group_folder_id) {
+                    queue.add("delayed-job", {
+                        type: "recount-group-folder",
+                        groupId: this.id,
+                    }, "low");
+                }
+                callback();
+            },
+        ], (err) => {
+            done(err);
+        });
+    };
+    Group.prototype.setupLogoImage = function (req, done) {
+        if (req.body.uploadedLogoImageId) {
+            sequelize.models.Image.findOne({
+                where: { id: req.body.uploadedLogoImageId, user_id: req.user.id },
+            }).then((image) => {
+                if (image)
+                    this.addGroupLogoImage(image);
+                else
+                    log.error("Image not found for group logo image");
+                done();
+            });
+        }
+        else
+            done();
+    };
+    Group.prototype.setupHeaderImage = function (req, done) {
+        if (req.body.uploadedHeaderImageId) {
+            sequelize.models.Image.findOne({
+                where: { id: req.body.uploadedHeaderImageId, user_id: req.user.id },
+            }).then((image) => {
+                if (image)
+                    this.addGroupHeaderImage(image);
+                else
+                    log.error("Image not found for group header image");
+                done();
+            });
+        }
+        else
+            done();
+    };
+    Group.prototype.setupHtmlMedia = async (req, groupId, done) => {
+        log.info("--------------------------> setupHtmlMedia");
+        const group = await sequelize.models.Group.findOne({
+            where: { id: groupId },
+            attributes: ["id"]
+        });
+        if (req.body.staticHtml) {
+            try {
+                const staticHtml = JSON.parse(req.body.staticHtml);
+                if (staticHtml.media && staticHtml.media.length > 0) {
+                    for (let i = 0; i < staticHtml.media.length; i++) {
+                        const media = staticHtml.media[i];
+                        log.info("--------------------------> group", group);
+                        log.info("--------------------------------------------------------> media", media);
+                        if (media.type === "image") {
+                            const image = await sequelize.models.Image.findOne({
+                                where: { id: media.id, user_id: req.user.id },
+                            });
+                            if (image) {
+                                if (!(await group.hasGroupHtmlImage(image))) {
+                                    await group.addGroupHtmlImage(image);
+                                }
+                                else {
+                                    log.info("Image already associated with group.");
+                                }
+                            }
+                            else {
+                                log.error("Image not found for group html image");
+                            }
+                        }
+                        else if (media.type === "video") {
+                            const video = await sequelize.models.Video.findOne({
+                                where: { id: media.id, user_id: req.user.id },
+                            });
+                            if (video) {
+                                if (!(await group.hasGroupHtmlVideo(video))) {
+                                    await group.addGroupHtmlVideo(video);
+                                }
+                                else {
+                                    log.info("Video already associated with group.");
+                                }
+                            }
+                            else {
+                                log.error("Video not found for group html video");
+                            }
+                        }
+                    }
+                }
+                else {
+                    log.info("--------------------------> No media in staticHtml");
+                }
+                done();
+            }
+            catch (error) {
+                log.error("--------------------------> Error parsing staticHtml", error);
+                done();
+            }
+        }
+        else {
+            log.info("--------------------------> No staticHtml");
+            done();
+        }
+    };
+    Group.prototype.getImageFormatUrl = function (formatId) {
+        if (this.GroupLogoImages && this.GroupLogoImages.length > 0) {
+            const formats = JSON.parse(this.GroupLogoImages[this.GroupLogoImages.length - 1].formats);
+            if (formats && formats.length > 0)
+                return formats[formatId];
+        }
+        else {
+            return "";
+        }
+    };
+    Group.prototype.setupImages = function (req, groupId, done) {
+        async.parallel([
+            (callback) => {
+                this.setupLogoImage(req, (err) => {
+                    if (err)
+                        return callback(err);
+                    callback();
+                });
+            },
+            (callback) => {
+                this.setupHeaderImage(req, (err) => {
+                    if (err)
+                        return callback(err);
+                    callback();
+                });
+            },
+            (callback) => {
+                this.setupHtmlMedia(req, groupId, (err) => {
+                    if (err)
+                        return callback(err);
+                    callback();
+                });
+            }
+        ], (err) => {
+            done(err);
+        });
+    };
+    Group.prototype.setupModerationData = function () {
+        if (!this.data) {
+            this.set("data", {});
+        }
+        if (!this.data.moderation) {
+            this.set("data.moderation", {});
+        }
+    };
+    Group.prototype.report = function (req, source, 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 post toxicity on manual report");
+                        queue.add("process-moderation", {
+                            type: "estimate-collection-toxicity",
+                            collectionId: this.id,
+                            collectionType: "group",
+                        }, "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);
+                });
+            },
+            /* TODO: Finish sending emails to domain admins if needed
+            (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: null,
+                     groupId: this.id,
+                     communityId:  this.Community ? this.Community.id : null,
+                     domainId:  this.Community ? this.Community.domain_id : null
+                   }, (error) => {
+                     seriesCallback(error);
+                   });
+                 }
+               }*/
+        ], (error) => {
+            this.increment("counter_flags");
+            callback(error);
+        });
+    };
+    return Group;
+};