@yrpri/api 9.0.103 → 9.0.104

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

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

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

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

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

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

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

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

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

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