@yrpri/api 9.0.103 → 9.0.104

package/dist/active-citizen/workers/bulk_status_update.cjs

@@ -1,458 +0,0 @@
-"use strict";
-// https://gist.github.com/mojodna/1251812
-var async = require("async");
-var models = require("../../models/index.cjs");
-var log = require('../utils/logger.cjs');
-var queue = require('./queue.cjs');
-var i18n = require('../utils/i18n.cjs');
-var toJson = require('../utils/to_json.cjs');
-var airbrake = null;
-if (process.env.AIRBRAKE_PROJECT_ID) {
-    airbrake = require('../utils/airbrake.cjs');
-}
-var _ = require('lodash');
-var BulkStatusUpdateWorker = function () { };
-var verifyMode = true;
-var verifiedMovedPostCount, verifiedStatusChangedPostsCount;
-var movePostToGroupId = function (postId, toGroupId, done) {
-    var group, post, communityId, domainId;
-    async.series([
-        function (callback) {
-            models.Group.findOne({
-                where: {
-                    id: toGroupId
-                },
-                include: [
-                    {
-                        model: models.Community,
-                        required: true,
-                        include: [
-                            {
-                                model: models.Domain,
-                                required: true
-                            }
-                        ]
-                    }
-                ]
-            }).then(function (groupIn) {
-                group = groupIn;
-                communityId = group.Community.id;
-                domainId = group.Community.Domain.id;
-                callback();
-            }).catch(function (error) {
-                callback(error);
-            });
-        },
-        function (callback) {
-            models.Post.findOne({
-                where: {
-                    id: postid
-                }
-            }).then(function (postIn) {
-                post = postIn;
-                post.set('group_id', group.id);
-                if (!verifyMode) {
-                    post.save().then(function (results) {
-                        log.info("Have changed group id");
-                        callback();
-                    });
-                }
-                else {
-                    log.info("Not moving post, only verifying");
-                    verifiedMovedPostCount += 1;
-                }
-            }).catch(function (error) {
-                callback(error);
-            });
-        },
-        function (callback) {
-            if (!verifyMode) {
-                models.AcActivity.findAll({
-                    where: {
-                        post_id: post.id
-                    }
-                }).then(function (activities) {
-                    async.eachSeries(activities, function (activity, innerSeriesCallback) {
-                        activity.set('group_id', group.id);
-                        activity.set('community_id', communityId);
-                        activity.set('domain_id', domainId);
-                        activity.save().then(function (results) {
-                            log.info("Have changed group and all: " + activity.id);
-                            innerSeriesCallback();
-                        });
-                    }, function (error) {
-                        callback();
-                    });
-                }).catch(function (error) {
-                    callback(error);
-                });
-            }
-            else {
-                callback();
-            }
-        }
-    ], function (error) {
-        if (error) {
-            done(error);
-        }
-        else {
-            log.info("Moved post to group", { postId: post.id, groupId: group.id });
-            done();
-        }
-    });
-};
-var createStatusUpdateForPostId = function (postId, official_status, content, userId, callback) {
-    models.Post.findOne({
-        where: {
-            id: postId
-        },
-        include: [
-            {
-                model: models.Group,
-                required: true,
-                attributes: ['id'],
-                include: [
-                    {
-                        model: models.Community,
-                        required: true,
-                        attributes: ['id'],
-                        include: [
-                            {
-                                model: models.Domain,
-                                required: true,
-                                attributes: ['id']
-                            }
-                        ]
-                    }
-                ]
-            }
-        ]
-    }).then(function (post) {
-        if (post) {
-            if (!verifyMode) {
-                var postStatusChange = models.PostStatusChange.build({
-                    post_id: post.id,
-                    status_changed_to: post.official_status != parseInt(official_status) ? official_status : null,
-                    content: content,
-                    user_id: userId,
-                    status: 'active',
-                    user_agent: "Bulk Status Update",
-                    ip_address: "127.0.0.1"
-                });
-                postStatusChange.save().then(function (post_status_change) {
-                    if (post_status_change) {
-                        models.AcActivity.createActivity({
-                            type: 'activity.post.status.change',
-                            userId: userId,
-                            postId: post.id,
-                            object: { bulkStatusUpdate: true },
-                            postStatusChangeId: post_status_change.id,
-                            groupId: post.Group.id,
-                            communityId: post.Group.Community.id,
-                            domainId: post.Group.Community.Domain.id
-                        }, function (error) {
-                            if (error) {
-                                log.error("Post Status Change Error", {
-                                    context: 'status_change',
-                                    post: toJson(post),
-                                    err: error
-                                });
-                                callback("Post Status Change Error");
-                            }
-                            else {
-                                if (post.official_status != parseInt(official_status)) {
-                                    post.official_status = official_status;
-                                    post.save().then(function (results) {
-                                        log.info('Post Status Change Created And New Status', {
-                                            post: toJson(post),
-                                            context: 'status_change'
-                                        });
-                                        callback();
-                                    });
-                                }
-                                else {
-                                    log.info('Post Status Change Created', {
-                                        post: toJson(post),
-                                        context: 'status_change'
-                                    });
-                                    callback();
-                                }
-                            }
-                        });
-                    }
-                    else {
-                        log.error("Post Status Change Error", {
-                            context: 'status_change',
-                            post: toJson(post),
-                            err: "Could not created status change"
-                        });
-                        callback("Post Status Change Error");
-                    }
-                }).catch(function (error) {
-                    log.error("Post Status Change Error", {
-                        context: 'status_change',
-                        post: toJson(post),
-                        err: error
-                    });
-                    callback("Post Status Change Error");
-                });
-            }
-            else {
-                console.log("Not changing status, only verifying");
-                verifiedStatusChangedPostsCount += 1;
-            }
-        }
-        else {
-            log.error("Post Status Change Post Not Found", {
-                context: 'status_change',
-                err: "Could not created status change"
-            });
-            callback("404");
-        }
-    }).catch(function (error) {
-        callback(error);
-    });
-};
-var getAllUsersWithEndorsements = function (config, callback) {
-    var allPostIds = [];
-    var allUsers = [];
-    _.each(config.groups, function (group) {
-        _.each(group.posts, function (post) {
-            allPostIds.push(post.id);
-        });
-    });
-    async.eachSeries(allPostIds, function (postId, seriesCallback) {
-        models.Endorsement.findAll({
-            where: {
-                post_id: postId
-            },
-            include: [
-                models.User
-            ]
-        }).then(function (endorsements) {
-            _.each(endorsements, function (endorsement) {
-                allUsers.push(endorsement.User);
-                seriesCallback();
-            });
-        }).catch(function (error) {
-            seriesCallback(error);
-        });
-    }, function (error) {
-        allUsers = _.uniqBy(allUsers, function (user) {
-            return user.id;
-        });
-        callback(error, allUsers);
-    });
-};
-var changeStatusOfAllPost = function (config, userId, callback) {
-    var allPosts = [];
-    _.each(config.groups, function (group) {
-        _.each(group.posts, function (post) {
-            allPosts.push(post);
-        });
-    });
-    async.eachSeries(allPosts, function (configPost, seriesCallback) {
-        models.Post.findOne({
-            where: {
-                id: configPost.id
-            },
-            include: [
-                models.User
-            ]
-        }).then(function (dbPost) {
-            if (configPost.templateName || configPost.customMessage) {
-                var statusMessage;
-                if (configPost.templateName) {
-                    statusMessage = config.templates[configPost.templateName].content;
-                }
-                else if (configPost.customMessage) {
-                    statusMessage = configPost.customMessage;
-                }
-                createStatusUpdateForPostId(configPost.id, configPost.changeStatusTo, statusMessage, userId, seriesCallback);
-            }
-            else {
-                seriesCallback();
-            }
-        }).catch(function (error) {
-            seriesCallback(error);
-        });
-    }, function (error) {
-        callback(error);
-    });
-};
-var moveNeededPosts = function (config, callback) {
-    async.eachSeries(config.groups, function (configGroup, groupSeriesCallback) {
-        async.eachSeries(configGroup, function (configPost, postSeriesCallback) {
-            models.Post.findOne({
-                where: {
-                    id: configPost.id
-                },
-                include: [
-                    models.User
-                ]
-            }).then(function (dbPost) {
-                if (configPost.moveToGroupId) {
-                    movePostToGroupId(dbPost.id, moveToGroupId, postSeriesCallback);
-                }
-                else {
-                    postSeriesCallback();
-                }
-            }).catch(function (error) {
-                postSeriesCallback(error);
-            });
-        }, function (error) {
-            groupSeriesCallback(error, allUsers);
-        });
-    }, function (error) {
-        callback(error);
-    });
-};
-const createBulkStatusUpdates = function (statusUpdateJson, users, callback) {
-    models.BulkStatusUpdate.findOne({
-        where: {
-            id: statusUpdateJson.id
-        },
-        include: [
-            {
-                model: models.Community,
-                required: true,
-                attributes: ['id'],
-                include: [
-                    {
-                        model: models.Domain,
-                        required: true,
-                        attributes: ['id']
-                    }
-                ]
-            }
-        ]
-    }).then(function (statusUpdate) {
-        if (statusUpdate) {
-            async.eachSeries(users, function (user, seriesCallback) {
-                models.AcActivity.createActivity({
-                    type: 'activity.bulk.status.update',
-                    userId: user.id,
-                    object: {
-                        bulkStatusUpdateId: statusUpdate.id
-                    },
-                    communityId: statusUpdate.Community.id,
-                    domainId: statusUpdate.Community.Domain.id
-                }, function (error) {
-                    if (error) {
-                        log.error("Bulk Status Change Error", {
-                            context: 'status_change',
-                            post: toJson(post),
-                            err: error
-                        });
-                        seriesCallback("Bulk Status Change Error");
-                    }
-                    else {
-                        if (post.official_status != parseInt(official_status)) {
-                            post.official_status = official_status;
-                            post.save().then(function (results) {
-                                log.info('Bulk Status Change Created And New Status', {
-                                    post: toJson(post),
-                                    context: 'status_change'
-                                });
-                                seriesCallback();
-                            });
-                        }
-                        else {
-                            log.info('Bulk Status Change Created', {
-                                post: toJson(post),
-                                context: 'status_change'
-                            });
-                            seriesCallback();
-                        }
-                    }
-                });
-            });
-        }
-        else {
-            callback("Can't find status upodate");
-        }
-    }).catch(function (error) {
-        callback(error);
-    });
-};
-BulkStatusUpdateWorker.prototype.process = function (bulkStatusUpdateInfo, callback) {
-    var statusUpdate;
-    var allUsersWithEndorsements;
-    var allSuccessful, allFailed, allInProgress, allOpen;
-    var allMoved;
-    if (bulkStatusUpdateInfo.verifyMode) {
-        verifyMode = true;
-        verifiedMovedPostCount = verifiedStatusChangedPostsCount = 0;
-    }
-    else {
-        verifyMode = false;
-    }
-    async.series([
-        // Get Bulk Status Update
-        function (seriesCallback) {
-            models.BulkStatusUpdate.findOne({
-                where: { id: bulkStatusUpdateInfo.bulkStatusUpdateId },
-                include: [
-                    {
-                        model: models.Community,
-                        required: true
-                    },
-                    {
-                        model: models.User,
-                        required: true
-                    }
-                ]
-            }).then(function (results) {
-                if (results) {
-                    log.info("BulkStatusUpdateWorker Debug 1", { results: results.dataValues });
-                    statusUpdate = results;
-                    seriesCallback();
-                }
-                else {
-                    seriesCallback('BulkStatusUpdateWorker Update not found');
-                }
-            }).catch(function (error) {
-                seriesCallback(error);
-            });
-        },
-        function (seriesCallback) {
-            changeStatusOfAllPost(statusUpdate.config, statusUpdate.user_id, seriesCallback);
-        },
-        function (seriesCallback) {
-            moveNeededPosts(statusUpdate.config, seriesCallback);
-        },
-        // Get All Users With Endorsements
-        function (seriesCallback) {
-            getAllUsersWithEndorsements(statusUpdate.config, function (error, users) {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else {
-                    createBulkStatusUpdates(statusUpdate, users, seriesCallback);
-                }
-            });
-        }
-    ], function (error) {
-        if (error) {
-            if (error.stack)
-                log.error("BulkStatusUpdateWorker Error", { err: error, stack: error.stack.split("\n") });
-            else
-                log.error("BulkStatusUpdateWorker Error", { err: error });
-            if (airbrake) {
-                airbrake.notify(error).then((airbrakeErr) => {
-                    if (airbrakeErr.error) {
-                        log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error });
-                    }
-                    callback(error);
-                });
-            }
-            else {
-                callback(error);
-            }
-        }
-        else {
-            log.info('Processing BulkStatusUpdateWorker Started', { type: notification.type, user: user ? user.simple() : null });
-        }
-    });
-};
-module.exports = new BulkStatusUpdateWorker();

package/dist/active-citizen/workers/delayed_jobs.cjs

@@ -1,244 +0,0 @@
-"use strict";
-const async = require("async");
-const models = require("../../models/index.cjs");
-const log = require("../utils/logger.cjs");
-const queue = require("./queue.cjs");
-const i18n = require("../utils/i18n.cjs");
-const toJson = require("../utils/to_json.cjs");
-const _ = require("lodash");
-const { addPlausibleEvent, } = require("../engine/analytics/plausible/manager.cjs");
-const { recountGroupFolder } = require("./recount.cjs");
-let airbrake = null;
-if (process.env.AIRBRAKE_PROJECT_ID) {
-    airbrake = require("../utils/airbrake.cjs");
-}
-let DelayedJobWorker = function () { };
-const delayedCreatePriorityActivity = (workPackage, callback) => {
-    const options = workPackage.workData;
-    var context, actor, object;
-    if (options.object)
-        object = options.object;
-    else
-        object = {};
-    if (options.context)
-        context = options.context;
-    else
-        context = {};
-    if (options.actor)
-        actor = options.actor;
-    else
-        actor = {};
-    if (options.userId)
-        actor["userId"] = options.userId;
-    if (options.domainId)
-        object["domainId"] = options.domainId;
-    if (options.communityId)
-        object["communityId"] = options.communityId;
-    if (options.groupId)
-        object["groupId"] = options.groupId;
-    if (options.postId)
-        object["postId"] = options.postId;
-    if (options.pointId)
-        object["pointId"] = options.pointId;
-    if (options.endorsementId)
-        object["endorsementId"] = options.endorsementId;
-    if (options.pointQualityId)
-        object["pointQualityId"] = options.pointQualityId;
-    if (options.ratingId)
-        object["ratingId"] = options.ratingId;
-    async.series([
-        // Checking for missing values for community or group if its a post related event
-        function (seriesCallback) {
-            if (options.postId == null ||
-                (options.groupId && options.communityId)) {
-                seriesCallback();
-            }
-            else if (options.groupId) {
-                models.Group.findOne({
-                    where: { id: options.groupId },
-                    attributes: ["id", "community_id"],
-                })
-                    .then(function (group) {
-                    if (group) {
-                        log.info("Found group info for post acitivity from app");
-                        options.communityId = group.community_id;
-                        seriesCallback();
-                    }
-                    else {
-                        seriesCallback("Can't find group");
-                    }
-                })
-                    .catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-            else if (options.postId) {
-                log.info("Looking for post, group and community START");
-                models.Post.findOne({
-                    where: { id: options.postId },
-                    attributes: ["id", "group_id"],
-                    include: [
-                        {
-                            model: models.Group,
-                            attributes: ["id", "community_id"],
-                        },
-                    ],
-                })
-                    .then(function (post) {
-                    log.info("Looking for post, group and community END");
-                    if (post) {
-                        log.info("Found post info for post acitivity from app");
-                        options.groupId = post.Group.id;
-                        options.communityId = post.Group.community_id;
-                        seriesCallback();
-                    }
-                    else {
-                        seriesCallback("Can't find post");
-                    }
-                })
-                    .catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback("Strange state of create ac activity looking up community id");
-            }
-        },
-    ], function (error) {
-        if (error) {
-            callback(error);
-        }
-        else {
-            models.AcActivity.build({
-                type: options.type,
-                status: "active",
-                sub_type: options.subType,
-                actor: actor,
-                object: object,
-                context: context,
-                user_id: options.userId,
-                domain_id: options.domainId,
-                community_id: options.communityId,
-                group_id: options.groupId,
-                post_id: options.postId,
-                point_id: options.pointId,
-                post_status_change_id: options.postStatusChangeId,
-                access: !isNaN(options.access)
-                    ? options.access
-                    : models.AcActivity.ACCESS_PRIVATE,
-            })
-                .save()
-                .then(function (activity) {
-                if (activity) {
-                    if (activity.type != "activity.fromApp") {
-                        queue.add("process-activity", activity, "high");
-                    }
-                    log.info("Activity Created", {
-                        activityId: activity.id,
-                        userId: options.userId,
-                    });
-                    callback();
-                }
-                else {
-                    callback("Activity Not Found");
-                }
-            })
-                .catch(function (error) {
-                log.error("Activity Created Error", { err: error });
-                callback(error);
-            });
-        }
-    });
-};
-const delayedCreateActivityFromApp = (workPackage, callback) => {
-    const workData = workPackage.workData;
-    models.AcClientActivity.build({
-        type: "activity.fromApp",
-        sub_type: workData.body.type,
-        actor: { appActor: workData.body.actor },
-        object: {
-            name: workData.body.object,
-            target: workData.body.target,
-        },
-        context: {
-            pathName: workData.body.path_name,
-            name: workData.body.context,
-            eventTime: workData.body.event_time,
-            sessionId: workData.body.sessionId,
-            userAgent: workData.body.user_agent,
-            userLocale: workData.body.userLocale,
-            userAutoTranslate: workData.body.userAutoTranslate,
-            server_timestamp: workData.body.server_timestamp,
-            url: workData.body.url,
-            screenWidth: workData.body.screen_width,
-            referrer: workData.body.referrer,
-            ipAddress: workData.body.ipAddress,
-            object: workData.body.object,
-            type: workData.body.type,
-            useTypeNameUnchanged: workData.body.useTypeNameUnchanged,
-            originalQueryString: workData.body.originalQueryString,
-            props: workData.body.props,
-        },
-        user_id: workData.userId,
-        domain_id: workData.domainId,
-        point_id: workData.pointId,
-        group_id: workData.groupId ? parseInt(workData.groupId) : null,
-        community_id: workData.communityId,
-        post_id: workData.postId ? parseInt(workData.postId) : null,
-    })
-        .save()
-        .then(async (clientActivity) => {
-        if (!clientActivity) {
-            log.error("Client Activity not created", {
-                context: "createClientActivity",
-                errorStatus: 500,
-            });
-        }
-        if (process.env.PLAUSIBLE_API_KEY) {
-            let plausibleEvent;
-            if (workData.body.type === "pageview") {
-                plausibleEvent = `pageview`;
-            }
-            else if (!workData.body.useTypeNameUnchanged &&
-                workData.body.object) {
-                plausibleEvent = `${workData.body.object} - ${workData.body.type}`;
-            }
-            else {
-                plausibleEvent = workData.body.type;
-            }
-            try {
-                await addPlausibleEvent(plausibleEvent, workData);
-                callback();
-            }
-            catch (error) {
-                callback(error);
-            }
-        }
-        else {
-            callback();
-        }
-    })
-        .catch(function (error) {
-        log.error("Client Activity Created Error", {
-            context: "createClientActivity",
-            err: error,
-        });
-        callback(error);
-    });
-};
-DelayedJobWorker.prototype.process = (workPackage, callback) => {
-    switch (workPackage.type) {
-        case "create-activity-from-app":
-            delayedCreateActivityFromApp(workPackage, callback);
-            break;
-        case "create-priority-activity":
-            delayedCreatePriorityActivity(workPackage, callback);
-            break;
-        case "recount-group-folder":
-            recountGroupFolder(workPackage, callback);
-            break;
-        default:
-            callback("Unknown type for workPackage: " + workPackage.type);
-    }
-};
-module.exports = new DelayedJobWorker();