@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/models/ac_activity.cjs

@@ -0,0 +1,216 @@
+"use strict";
+const log = require('../utils/logger.cjs');
+const queue = require('../workers/queue.cjs');
+const toJson = require('../utils/to_json.cjs');
+const commonIndexForActivitiesAndNewsFeeds = require('../engine/news_feeds/activity_and_item_index_definitions.cjs').commonIndexForActivitiesAndNewsFeeds;
+const _ = require('lodash');
+module.exports = (sequelize, DataTypes) => {
+    const AcActivity = sequelize.define("AcActivity", {
+        access: { type: DataTypes.INTEGER, allowNull: false },
+        type: { type: DataTypes.STRING, allowNull: false },
+        sub_type: { type: DataTypes.STRING, allowNull: true },
+        status: { type: DataTypes.STRING, allowNull: false },
+        object: DataTypes.JSONB,
+        actor: DataTypes.JSONB,
+        target: DataTypes.JSONB,
+        context: DataTypes.JSONB,
+        user_interaction_profile: DataTypes.JSONB,
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false,
+                status: 'active'
+            }
+        },
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        indexes: _.concat(commonIndexForActivitiesAndNewsFeeds('created_at'), [
+            {
+                name: 'activity_active_by_type',
+                fields: ['type'],
+                where: {
+                    status: 'active',
+                    deleted: false
+                }
+            },
+            {
+                name: 'activity_active_by_community_id',
+                fields: ['community_id'],
+                where: {
+                    status: 'active',
+                    deleted: false
+                }
+            },
+            {
+                name: 'ac_activities_idx_post_id_user_id_type_delete_status',
+                fields: ['post_id', 'user_id', 'type', 'deleted']
+            },
+            {
+                name: 'activity_active_by_group_id',
+                fields: ['group_id'],
+                where: {
+                    status: 'active',
+                    deleted: false
+                }
+            },
+            {
+                name: 'userid_groupid_deleted',
+                fields: ['user_id', 'group_id', 'deleted']
+            },
+            {
+                name: 'activity_active_by_post_id',
+                fields: ['post_id'],
+                where: {
+                    status: 'active',
+                    deleted: false
+                }
+            },
+            {
+                name: 'activity_all_by_type',
+                fields: ['type']
+            }
+        ]),
+        underscored: true,
+        tableName: 'ac_activities'
+    });
+    AcActivity.associate = (models) => {
+        AcActivity.belongsTo(models.Domain, { foreignKey: 'domain_id' });
+        AcActivity.belongsTo(models.Community, { foreignKey: 'community_id' });
+        AcActivity.belongsTo(models.Group, { foreignKey: 'group_id' });
+        AcActivity.belongsTo(models.Post, { foreignKey: 'post_id' });
+        AcActivity.belongsTo(models.Point, { foreignKey: 'point_id' });
+        AcActivity.belongsTo(models.Invite, { foreignKey: 'invite_id' });
+        AcActivity.belongsTo(models.User, { foreignKey: 'user_id' });
+        AcActivity.belongsTo(models.Image, { foreignKey: 'image_id' });
+        AcActivity.belongsTo(models.PostStatusChange, { foreignKey: 'post_status_change_id' });
+        AcActivity.belongsToMany(models.User, { through: 'other_users' });
+        AcActivity.belongsToMany(models.AcNotification, { as: 'AcActivities', through: 'notification_activities' });
+    };
+    AcActivity.ACCESS_PUBLIC = 0;
+    AcActivity.ACCESS_COMMUNITY = 1;
+    AcActivity.ACCESS_GROUP = 2;
+    AcActivity.ACCESS_PRIVATE = 3;
+    //TODO Refactor duplicate code with Post and point
+    AcActivity.setOrganizationUsersForActivities = (activities, done) => {
+        const filteredActivities = activities.filter(p => p.User);
+        if (filteredActivities && filteredActivities.length > 0) {
+            const userIds = filteredActivities.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 < filteredActivities.length; p++) {
+                            if (filteredActivities[p].User.id === users[u].id) {
+                                filteredActivities[p].User.OrganizationUsers = users[u].OrganizationUsers;
+                                filteredActivities[p].User.setDataValue('OrganizationUsers', users[u].OrganizationUsers);
+                            }
+                        }
+                    }
+                    done();
+                }
+                else {
+                    done();
+                }
+            }).catch(error => {
+                done(error);
+            });
+        }
+        else {
+            done();
+        }
+    };
+    AcActivity.createActivity = (options, callback) => {
+        queue.add('delayed-job', { type: 'create-priority-activity', workData: options }, 'high');
+        callback();
+    };
+    AcActivity.createPasswordRecovery = (user, domain, community, token, done) => {
+        sequelize.models.AcActivity.build({
+            type: "activity.password.recovery",
+            status: 'active',
+            actor: { user: user },
+            object: {
+                domainId: domain.id,
+                communityId: community ? community.id : null,
+                token: token
+            },
+            domain_id: domain.id,
+            community_id: community ? community.id : null,
+            user_id: user.id,
+            access: sequelize.models.AcActivity.ACCESS_PRIVATE
+        }).save().then((activity) => {
+            if (activity) {
+                queue.add('process-activity', activity, 'critical');
+                log.info('Activity Created', { activityId: activity.id, userId: user ? user.id : -1 });
+                done(null);
+            }
+            else {
+                done('Activity Not Found');
+            }
+        }).catch((error) => {
+            log.error('Activity Created Error', { err: error });
+            done(error);
+        });
+    };
+    AcActivity.inviteCreated = (options, done) => {
+        sequelize.models.AcActivity.build({
+            type: "activity.user.invite",
+            status: 'active',
+            actor: { user_id: options.user_id, sender_user_id: options.sender_user_id },
+            object: {
+                email: options.email,
+                token: options.token,
+                invite_id: options.invite_id,
+                sender_name: options.sender_name,
+                invite_type: options.invite_type,
+                invite_link: options.invite_link,
+            },
+            community_id: options.community_id,
+            group_id: options.group_id,
+            domain_id: options.domain_id,
+            user_id: options.user_id,
+            access: sequelize.models.AcActivity.ACCESS_PRIVATE
+        }).save().then((activity) => {
+            if (activity) {
+                queue.add('process-activity', activity, 'critical');
+                log.info('Activity Created', { activityId: activity.id, userId: options.user_id, email: options.email });
+                done(null);
+            }
+            else {
+                done('Activity Not Found');
+            }
+        }).catch((error) => {
+            log.error('Activity Created Error', { err: error });
+            done(error);
+        });
+    };
+    return AcActivity;
+};

package/dist/active-citizen/models/ac_background_job.cjs

@@ -0,0 +1,109 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcBackgroundJob = sequelize.define("AcBackgroundJob", {
+        progress: { type: DataTypes.INTEGER, allowNull: true },
+        error: { type: DataTypes.TEXT, allowNull: true },
+        data: { type: DataTypes.JSONB, allowNull: true },
+        internal_data: { type: DataTypes.JSONB, allowNull: true }
+    }, {
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        underscored: true,
+        tableName: 'ac_background_jobs',
+    });
+    AcBackgroundJob.createJob = (data, internal_data, done) => {
+        sequelize.models.AcBackgroundJob.create({
+            progress: 5,
+            data: data,
+            internal_data: internal_data
+        }).then(job => {
+            done(null, job.id);
+        }).catch(error => {
+            done(error);
+        });
+    };
+    AcBackgroundJob.createJobAsync = async (data, internal_data) => {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                const job = sequelize.models.AcBackgroundJob.create({
+                    progress: 5,
+                    data: data,
+                    internal_data: internal_data
+                });
+                resolve(job);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
+    AcBackgroundJob.updateProgress = (jobId, progress, done) => {
+        sequelize.models.AcBackgroundJob.update({
+            progress: progress,
+        }, {
+            where: { id: jobId },
+        })
+            .then(() => {
+            done();
+        })
+            .catch((error) => {
+            done(error);
+        });
+    };
+    AcBackgroundJob.updateProgressAsync = async (jobId, progress) => {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                resolve(sequelize.models.AcBackgroundJob.update({
+                    progress: progress
+                }, {
+                    where: { id: jobId },
+                }));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
+    AcBackgroundJob.updateDataAsync = async (jobId, data) => {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                resolve(sequelize.models.AcBackgroundJob.update({
+                    data: data
+                }, {
+                    where: { id: jobId },
+                }));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
+    AcBackgroundJob.updateErrorAsync = async (jobId, error) => {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                resolve(sequelize.models.AcBackgroundJob.update({
+                    error: error
+                }, {
+                    where: { id: jobId },
+                }));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
+    AcBackgroundJob.destroyJobAsync = async (jobId) => {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                resolve(sequelize.models.AcBackgroundJob.destroy({
+                    where: { id: jobId },
+                }));
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    };
+    return AcBackgroundJob;
+};

package/dist/active-citizen/models/ac_campaign.cjs

@@ -0,0 +1,97 @@
+"use strict";
+const queue = require('../workers/queue.cjs');
+module.exports = (sequelize, DataTypes) => {
+    const AcCampaign = sequelize.define("AcCampaign", {
+        data: DataTypes.JSONB,
+        user_id: { type: DataTypes.INTEGER, allowNull: false },
+        ac_list_id: { type: DataTypes.INTEGER, allowNull: false }
+    }, {
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'ac_campaigns'
+    });
+    AcCampaign.associate = (models) => {
+        AcCampaign.belongsTo(models.AcList, { foreignKey: 'ac_list_id' });
+        AcCampaign.belongsTo(models.User, { foreignKey: 'user_id' });
+    };
+    AcCampaign.updateCampaignAndUser = (parameters, updateParameter, done) => {
+        const marketingTrackingUserId = parameters.yu;
+        const marketingTrackingCampaignId = parameters.yc;
+        async.parallel([
+            (seriesCallback) => {
+                sequelize.models.AcCampaign.findOne({
+                    where: {
+                        id: marketingTrackingCampaignId
+                    }
+                }).then(campaign => {
+                    if (campaign) {
+                        campaign.set('data.' + updateParameter, campaign.data[updateParameter] + 1);
+                        campaign.save().then(() => {
+                            seriesCallback();
+                        }).catch(error => {
+                            seriesCallback(error);
+                        });
+                    }
+                    else {
+                        seriesCallback("Tracking campaign not found");
+                    }
+                }).catch(error => {
+                    seriesCallback(error);
+                });
+            },
+            (seriesCallback) => {
+                sequelize.models.AcListUser.findOne({
+                    where: {
+                        id: marketingTrackingUserId
+                    }
+                }).then(listUser => {
+                    if (listUser) {
+                        listUser.set('data.' + updateParameter, listUser.data[updateParameter] + 1);
+                        listUser.save().then(() => {
+                            seriesCallback();
+                        }).catch(error => {
+                            seriesCallback(error);
+                        });
+                    }
+                    else {
+                        seriesCallback("Tracking list user not found");
+                    }
+                }).catch(error => {
+                    seriesCallback(error);
+                });
+            }
+        ], (error) => {
+            done(error);
+        });
+    };
+    AcCampaign.sendCampaign = (campaignId, done) => {
+        models.AcBackgroundJob.createJob({}, {}, (error, jobId) => {
+            if (error) {
+                done(error);
+            }
+            else {
+                queue.add('process-marketing', {
+                    type: 'send-campaign',
+                    jobId: jobId,
+                    campaignId: campaignId,
+                }, 'medium');
+                done();
+            }
+        });
+    };
+    AcCampaign.getSendStatus = (jobId, done) => {
+        sequelize.models.AcBackgroundJob.findOne({
+            where: {
+                id: jobId
+            },
+            attributes: ['id', 'progress', 'error', 'data']
+        }).then(job => {
+            done(null, job);
+        }).catch(error => {
+            done(error);
+        });
+    };
+    return AcCampaign;
+};

package/dist/active-citizen/models/ac_client_activity.cjs

@@ -0,0 +1,23 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcClientActivity = sequelize.define("AcClientActivity", {
+        type: { type: DataTypes.STRING, allowNull: false },
+        sub_type: { type: DataTypes.STRING, allowNull: true },
+        domain_id: { type: DataTypes.INTEGER, allowNull: true },
+        community_id: { type: DataTypes.INTEGER, allowNull: true },
+        group_id: { type: DataTypes.INTEGER, allowNull: true },
+        user_id: { type: DataTypes.INTEGER, allowNull: true },
+        post_id: { type: DataTypes.INTEGER, allowNull: true },
+        object: DataTypes.JSONB,
+        actor: DataTypes.JSONB,
+        target: DataTypes.JSONB,
+        context: DataTypes.JSONB
+    }, {
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        underscored: true,
+        tableName: 'ac_client_activities',
+    });
+    return AcClientActivity;
+};

package/dist/active-citizen/models/ac_delayed_notification.cjs

@@ -0,0 +1,43 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcDelayedNotification = sequelize.define("AcDelayedNotification", {
+        method: { type: DataTypes.INTEGER, allowNull: false },
+        frequency: { type: DataTypes.INTEGER, allowNull: false },
+        type: { type: DataTypes.STRING, allowNull: false },
+        delivered: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false },
+        delivered_at: { type: DataTypes.DATE, allowNull: true },
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false
+            }
+        },
+        indexes: [
+            {
+                name: 'delayed_not_delivered_by_method_user_id_frequency',
+                fields: ['method', 'user_id', 'frequency'],
+                where: {
+                    delivered: true
+                }
+            },
+            {
+                name: 'delayed_n_not_delivered_by_method_user_id_frequency_timestamps',
+                fields: ['method', 'user_id', 'frequency', 'updated_at', 'delivered_at'],
+                where: {
+                    delivered: true
+                }
+            }
+        ],
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'ac_delayed_notifications'
+    });
+    AcDelayedNotification.associate = (models) => {
+        AcDelayedNotification.belongsToMany(models.AcNotification, { as: 'AcNotifications', through: 'delayed_notifications' });
+        AcDelayedNotification.belongsTo(models.User, { foreignKey: 'user_id' });
+    };
+    return AcDelayedNotification;
+};

package/dist/active-citizen/models/ac_following.cjs

@@ -0,0 +1,43 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcFollowing = sequelize.define("AcFollowing", {
+        value: { type: DataTypes.INTEGER },
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false
+            }
+        },
+        indexes: [
+            {
+                fields: ['user_id'],
+                where: {
+                    deleted: false
+                }
+            },
+            {
+                fields: ['other_user_id'],
+                where: {
+                    deleted: false
+                }
+            },
+            {
+                fields: ['user_id', 'other_user_id'],
+                where: {
+                    deleted: false
+                }
+            }
+        ],
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'ac_followings'
+    });
+    AcFollowing.associate = (models) => {
+        AcFollowing.belongsTo(models.User, { foreignKey: 'user_id' });
+        AcFollowing.belongsTo(models.User, { as: 'OtherUser' });
+    };
+    return AcFollowing;
+};

package/dist/active-citizen/models/ac_list.cjs

@@ -0,0 +1,68 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcList = sequelize.define("AcList", {
+        data: DataTypes.JSONB,
+        user_id: { type: DataTypes.INTEGER, allowNull: false },
+        group_id: { type: DataTypes.INTEGER, allowNull: true },
+        community_id: { type: DataTypes.INTEGER, allowNull: true },
+        post_id: { type: DataTypes.INTEGER, allowNull: true }
+    }, {
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'ac_lists'
+    });
+    AcList.associate = (models) => {
+        AcList.belongsTo(models.Post, { foreignKey: 'post_id' });
+        AcList.belongsTo(models.Community, { foreignKey: 'community_id' });
+        AcList.belongsTo(models.Group, { foreignKey: 'group_id' });
+        AcList.belongsTo(models.User, { foreignKey: 'user_id' });
+    };
+    AcList.getList = (groupId, done) => {
+        models.AcList.findOrCreate({
+            where: {
+                group_id: groupId
+            },
+            defaults: {
+                group_id: groupId
+            }
+        }).then(list => {
+            done(null, list);
+        }).catch(error => {
+            done(error);
+        });
+    };
+    AcList.addListUsers = async (listId, body, done) => {
+        const t = await sequelize.transaction();
+        try {
+            async.eachSeries(body.listUsersEntries, (listUserEntry, seriesCallback) => {
+                models.AcListUser.findOrCreate({
+                    where: {
+                        sms: listUserEntry.sms
+                    },
+                    defaults: {
+                        ac_list_id: listId,
+                        data: {
+                            openCount: 0,
+                            sentCount: 0,
+                            completeCount: 0
+                        }
+                    },
+                    transaction: t
+                }).then(() => {
+                    seriesCallback();
+                }).catch(error => {
+                    seriesCallback(error);
+                });
+            }, (error) => {
+                done(error);
+            });
+        }
+        catch (error) {
+            await t.rollback();
+            done(error);
+        }
+    };
+    return AcList;
+};

package/dist/active-citizen/models/ac_list_users.cjs

@@ -0,0 +1,19 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcListUser = sequelize.define("AcListUser", {
+        data: DataTypes.JSONB,
+        user_id: { type: DataTypes.INTEGER, allowNull: true },
+        ac_list_id: { type: DataTypes.INTEGER, allowNull: false }
+    }, {
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'ac_list_users'
+    });
+    AcListUser.associate = (models) => {
+        AcListUser.belongsTo(models.AcList, { foreignKey: 'ac_list_id' });
+        AcListUser.belongsTo(models.User, { foreignKey: 'user_id' });
+    };
+    return AcListUser;
+};

package/dist/active-citizen/models/ac_mute.cjs

@@ -0,0 +1,27 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcMute = sequelize.define("AcMute", {
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false
+            }
+        },
+        underscored: true,
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        tableName: 'ac_mutes'
+    });
+    AcMute.associate = (models) => {
+        AcMute.belongsTo(models.Domain, { foreignKey: 'domain_id' });
+        AcMute.belongsTo(models.Community, { foreignKey: 'community_id' });
+        AcMute.belongsTo(models.Group, { foreignKey: 'group_id' });
+        AcMute.belongsTo(models.Post, { foreignKey: 'post_id' });
+        AcMute.belongsTo(models.Point, { foreignKey: 'point_id' });
+        AcMute.belongsTo(models.User, { foreignKey: 'user_id' });
+        AcMute.belongsTo(models.User, { as: 'OtherUser' });
+    };
+    return AcMute;
+};