@yrpri/api 9.0.103 → 9.0.104

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

@@ -1,1911 +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 getAnonymousUser = require('../utils/get_anonymous_system_user.cjs');
-let airbrake = null;
-if (process.env.AIRBRAKE_PROJECT_ID) {
-    airbrake = require('../utils/airbrake.cjs');
-}
-let DeletionWorker = function () { };
-const getGroupAndUser = (groupId, userId, userEmail, callback) => {
-    var user, group;
-    async.series([
-        (seriesCallback) => {
-            models.Group.findOne({
-                where: {
-                    id: groupId
-                }
-            }).then((groupIn) => {
-                if (groupIn) {
-                    group = groupIn;
-                }
-                seriesCallback();
-            }).catch((error) => {
-                seriesCallback(error);
-            });
-        },
-        (seriesCallback) => {
-            if (userId) {
-                models.User.findOne({
-                    where: {
-                        id: userId
-                    },
-                    attributes: ['id', 'email', 'name', 'created_at']
-                }).then((userIn) => {
-                    if (userIn) {
-                        user = userIn;
-                    }
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback();
-            }
-        },
-        (seriesCallback) => {
-            if (userEmail) {
-                models.User.findOne({
-                    where: {
-                        email: userEmail
-                    },
-                    attributes: ['id', 'email', 'name', 'created_at']
-                }).then((userIn) => {
-                    if (userIn) {
-                        user = userIn;
-                    }
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback();
-            }
-        }
-    ], (error) => {
-        if (error) {
-            callback(error);
-        }
-        else {
-            callback(null, group, user);
-        }
-    });
-};
-var getCommunityAndUser = function (communityId, userId, userEmail, callback) {
-    var user, community;
-    async.series([
-        function (seriesCallback) {
-            models.Community.findOne({
-                where: {
-                    id: communityId
-                }
-            }).then(function (communityIn) {
-                if (communityIn) {
-                    community = communityIn;
-                }
-                seriesCallback();
-            }).catch(function (error) {
-                seriesCallback(error);
-            });
-        },
-        function (seriesCallback) {
-            if (userId) {
-                models.User.findOne({
-                    where: {
-                        id: userId
-                    },
-                    attributes: ['id', 'email', 'name', 'created_at']
-                }).then(function (userIn) {
-                    if (userIn) {
-                        user = userIn;
-                    }
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback();
-            }
-        },
-        function (seriesCallback) {
-            if (userEmail) {
-                models.User.findOne({
-                    where: {
-                        email: userEmail
-                    },
-                    attributes: ['id', 'email', 'name', 'created_at']
-                }).then(function (userIn) {
-                    if (userIn) {
-                        user = userIn;
-                    }
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback();
-            }
-        }
-    ], function (error) {
-        if (error) {
-            callback(error);
-        }
-        else {
-            callback(null, community, user);
-        }
-    });
-};
-var getDomainAndUser = function (domainId, userId, userEmail, callback) {
-    var user, domain;
-    async.series([
-        function (seriesCallback) {
-            models.Domain.findOne({
-                where: {
-                    id: domainId
-                }
-            }).then(function (domainIn) {
-                if (domainIn) {
-                    domain = domainIn;
-                }
-                seriesCallback();
-            }).catch(function (error) {
-                seriesCallback(error);
-            });
-        },
-        function (seriesCallback) {
-            if (userId) {
-                models.User.findOne({
-                    where: {
-                        id: userId
-                    },
-                    attributes: ['id', 'email', 'name', 'created_at']
-                }).then(function (userIn) {
-                    if (userIn) {
-                        user = userIn;
-                    }
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback();
-            }
-        },
-        function (seriesCallback) {
-            if (userEmail) {
-                models.User.findOne({
-                    where: {
-                        email: userEmail
-                    },
-                    attributes: ['id', 'email', 'name', 'created_at']
-                }).then(function (userIn) {
-                    if (userIn) {
-                        user = userIn;
-                    }
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-            else {
-                seriesCallback();
-            }
-        }
-    ], function (error) {
-        if (error) {
-            callback(error);
-        }
-        else {
-            callback(null, domain, user);
-        }
-    });
-};
-const recountPost = (postId, callback) => {
-    let endorsementsUpCount = 0, endorsementsDownCount = 0, pointsCount = 0;
-    async.series([
-        (seriesCallback) => {
-            models.Endorsement.findAll({
-                where: {
-                    post_id: postId
-                },
-                attributes: ['value']
-            }).then((endorsements) => {
-                _.forEach(endorsements, (endorsement) => {
-                    if (endorsement.value > 0) {
-                        endorsementsUpCount += 1;
-                    }
-                    else {
-                        endorsementsDownCount += 1;
-                    }
-                });
-                seriesCallback();
-            }).catch((error) => {
-                seriesCallback(error);
-            });
-        },
-        (seriesCallback) => {
-            models.Point.findAll({
-                where: {
-                    post_id: postId
-                },
-                attributes: ['id']
-            }).then((points) => {
-                pointsCount = points.length;
-                seriesCallback();
-            }).catch((error) => {
-                seriesCallback(error);
-            });
-        },
-        (seriesCallback) => {
-            models.Post.findOne({
-                where: {
-                    id: postId
-                },
-                attributes: ['id', 'counter_points', 'counter_endorsements_up', 'counter_endorsements_down']
-            }).then((post) => {
-                if (post) {
-                    post.counter_points = pointsCount;
-                    post.counter_endorsements_up = endorsementsUpCount;
-                    post.counter_endorsements_down = endorsementsDownCount;
-                    post.save().then(() => {
-                        seriesCallback();
-                    }).catch((error) => { seriesCallback(error); });
-                }
-                else {
-                    log.warn("No post for recountPost", { postId: postId });
-                    seriesCallback();
-                }
-            }).catch((error) => { seriesCallback(error); });
-        }
-    ], (error) => {
-        log.info("Post recounted", { error: error });
-        callback();
-    });
-};
-const recountGroup = (workPackage, callback) => {
-    const groupId = workPackage.groupId;
-    let postsCount = 0, pointsCount = 0;
-    async.series([
-        (seriesCallback) => {
-            models.Post.findAll({
-                where: {
-                    group_id: groupId
-                }
-            }).then(function (posts) {
-                postsCount = posts.length;
-                async.forEachLimit(posts, 100, (post, forEachCallback) => {
-                    recountPost(post.id, forEachCallback);
-                }, (error) => {
-                    seriesCallback(error);
-                });
-            }).catch((error) => {
-                seriesCallback(error);
-            });
-        },
-        (seriesCallback) => {
-            models.Point.findAll({
-                include: [
-                    {
-                        model: models.Post,
-                        where: {
-                            group_id: groupId
-                        }
-                    }
-                ]
-            }).then(function (points) {
-                pointsCount = points.length;
-                seriesCallback();
-            }).catch((error) => {
-                seriesCallback(error);
-            });
-        }
-    ], (error) => {
-        if (error) {
-            callback(error);
-        }
-        else {
-            models.Group.findOne({
-                where: { id: groupId },
-                attributes: ['id', 'community_id', 'counter_posts', 'counter_points', 'counter_users'],
-                include: [
-                    {
-                        model: models.User,
-                        as: 'GroupUsers',
-                        attributes: ['id'],
-                        required: false
-                    }
-                ]
-            }).then((group) => {
-                if (group) {
-                    group.counter_posts = postsCount;
-                    group.counter_points = pointsCount;
-                    group.counter_users = group.GroupUsers ? group.GroupUsers.length : 0;
-                    group.save().then(() => {
-                        log.info("Group recounted", { error: error, context: 'ac-delete', groupId: groupId });
-                        callback();
-                    }).catch((error) => {
-                        callback(error);
-                    });
-                }
-                else {
-                    log.warn("No group for update counters, recountGroup", { groupId: groupId });
-                    callback();
-                }
-            }).catch((error) => {
-                callback(error);
-            });
-        }
-    });
-};
-const recountCommunity = (workPackage, callback) => {
-    models.Community.findOne({
-        attributes: ['id', 'counter_posts', 'counter_points', 'counter_users'],
-        where: {
-            id: workPackage.communityId
-        },
-        include: [
-            {
-                model: models.Group,
-                attributes: ['id', 'counter_posts', 'counter_points', 'counter_users'],
-                where: {
-                    is_group_folder: false
-                },
-            },
-            {
-                model: models.User,
-                as: 'CommunityUsers',
-                attributes: ['id'],
-                required: false
-            }
-        ]
-    }).then((community) => {
-        if (community) {
-            const groupIds = _.map(community.Groups, (group) => {
-                return group.id;
-            });
-            async.series([
-                (innerCallback) => {
-                    if (workPackage.doDeepGroupCounting) {
-                        async.forEachLimit(groupIds, 100, (groupId, forEachCallback) => {
-                            recountGroup({ groupId: groupId }, forEachCallback);
-                        }, (error) => {
-                            log.info("Community groups deep recounted", { error: error, context: 'ac-delete', communityId: workPackage.communityId });
-                            innerCallback(error);
-                        });
-                    }
-                    else {
-                        innerCallback();
-                    }
-                },
-                (innerCallback) => {
-                    let postCount = 0, pointCount = 0, userCount = 0;
-                    community.reload().then((community) => {
-                        _.forEach(community.Groups, (group) => {
-                            postCount += group.counter_posts;
-                            pointCount += group.counter_points;
-                        });
-                        community.counter_posts = postCount;
-                        community.counter_points = pointCount;
-                        community.counter_users = community.CommunityUsers ? community.CommunityUsers.length : 0;
-                        community.save().then(() => {
-                            log.info("Community recounted", { context: 'ac-delete', communityId: workPackage.communityId });
-                            innerCallback();
-                        }).catch((error) => {
-                            innerCallback(error);
-                        });
-                    }).catch((error) => {
-                        innerCallback();
-                    });
-                }
-            ], (error) => {
-                callback(error);
-            });
-        }
-        else {
-            callback("No community in recount community");
-        }
-    }).catch((error) => {
-        callback(error);
-    });
-};
-const recountDomain = (workPackage, callback) => {
-    log.info("recountDomain started");
-    models.Domain.findOne({
-        attributes: ['id', 'counter_posts', 'counter_points', 'counter_users'],
-        where: {
-            id: workPackage.domainId
-        },
-        include: [
-            {
-                model: models.Community,
-                attributes: ['id', 'counter_posts', 'counter_points', 'counter_users']
-            }
-        ]
-    }).then((domain) => {
-        if (domain) {
-            log.info("recountDomain found domain");
-            async.series([
-                (innerCallback) => {
-                    let postCount = 0, pointCount = 0, userCount = 0;
-                    _.forEach(domain.Communities, (community) => {
-                        postCount += community.counter_posts;
-                        pointCount += community.counter_points;
-                    });
-                    domain.counter_posts = postCount;
-                    domain.counter_points = pointCount;
-                    domain.save().then(() => {
-                        log.info("recountDomain done", { workPackage: workPackage });
-                        innerCallback();
-                    }).catch((error) => {
-                        innerCallback(error);
-                    });
-                }
-            ], (error) => {
-                callback(error);
-            });
-        }
-        else {
-            callback("No domain");
-        }
-    }).catch((error) => {
-        callback(error);
-    });
-};
-const recountGroupFromPostId = (postId, callback) => {
-    let postsCount = 0;
-    let pointsCount = 0;
-    models.Post.unscoped().findOne({
-        where: { id: postId },
-        attributes: ['id', 'group_id']
-    }).then((post) => {
-        if (post) {
-            let groupId = post.group_id;
-            async.series([
-                (seriesCallback) => {
-                    models.Post.findAll({
-                        where: {
-                            group_id: groupId
-                        }
-                    }).then(function (posts) {
-                        postsCount = posts.length;
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                },
-                (seriesCallback) => {
-                    models.Point.findAll({
-                        include: [
-                            {
-                                model: models.Post,
-                                where: {
-                                    group_id: groupId
-                                }
-                            }
-                        ]
-                    }).then(function (posts) {
-                        pointsCount = posts.length;
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-            ], (error) => {
-                if (error) {
-                    callback(error);
-                }
-                else {
-                    models.Group.findOne({
-                        where: { id: groupId },
-                        attributes: ['id', 'community_id', 'counter_posts', 'counter_points']
-                    }).then((group) => {
-                        if (group) {
-                            group.counter_posts = postsCount;
-                            group.counter_points = pointsCount;
-                            group.save().then(() => {
-                                callback();
-                            }).catch((error) => {
-                                callback(error);
-                            });
-                        }
-                        else {
-                            log.warn("No group for update counters, recountGroupFromPostId", { groupId: groupId });
-                            callback();
-                        }
-                    }).catch((error) => {
-                        callback(error);
-                    });
-                }
-            });
-        }
-        else {
-            log.warn("No post for update counters");
-            callback();
-        }
-    }).catch((error) => {
-        log.info("recountGroupFromPostId done", { error: error });
-        callback(error);
-    });
-};
-const resetCountForCommunityForGroup = (groupId, callback) => {
-    let totalPosts = 0, totalPoints = 0;
-    models.Group.unscoped().findOne({
-        where: { id: groupId },
-        attributes: ['id', 'community_id']
-    }).then((group) => {
-        if (group) {
-            let communityId = group.community_id;
-            async.series([
-                (seriesCallback) => {
-                    models.Group.findAll({
-                        where: { community_id: communityId },
-                        attributes: ['id', 'community_id', 'counter_points', 'counter_posts']
-                    }).then((groups) => {
-                        groups.forEach((group) => {
-                            if (group.counter_posts) {
-                                totalPosts += group.counter_posts;
-                            }
-                            if (group.counter_points) {
-                                totalPoints += group.counter_points;
-                            }
-                        });
-                        models.Community.update({ counter_posts: totalPosts, counter_points: totalPoints }, { where: { id: communityId } }).then(() => {
-                            seriesCallback();
-                        }).catch((error) => {
-                            seriesCallback(error);
-                        });
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-            ], (error) => {
-                callback(error);
-            });
-        }
-        else {
-            callback();
-        }
-    }).catch((error) => {
-        log.info("resetCountForCommunityForGroup done", { error: error });
-        callback(error);
-    });
-};
-const deletePointContent = (workPackage, callback) => {
-    const pointId = workPackage.pointId;
-    log.info('Starting Point Activities Delete', { pointId: pointId, context: 'ac-delete', userId: workPackage.userId });
-    if (pointId) {
-        async.series([
-            (seriesCallback) => {
-                if (!workPackage.skipActivities) {
-                    models.AcActivity.update({ deleted: true }, { where: { point_id: pointId } }).then(function (spread) {
-                        log.info('Point Activities Deleted', { pointId: pointId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                        seriesCallback();
-                    }).catch(function (error) {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            },
-            (seriesCallback) => {
-                models.PointQuality.update({ deleted: true }, { where: { point_id: pointId } }).then(function (spread) {
-                    log.info('Point Quality Deleted', { pointId: pointId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-        ], (error) => {
-            log.info("deletePointContent done", { error: error, workPackage: workPackage });
-            callback(error);
-        });
-    }
-    else {
-        callback("No pointId for deletePointContent");
-    }
-};
-const deletePointActivities = (workPackage, callback) => {
-    const pointId = workPackage.pointId;
-    const userId = workPackage.userId;
-    log.info('Starting Point Activities Delete', { pointId: pointId, context: 'ac-delete', userId: workPackage.userId });
-    if (pointId) {
-        async.series([
-            (seriesCallback) => {
-                models.AcActivity.update({ deleted: true }, { where: { point_id: pointId } }).then(function (spread) {
-                    log.info('Point Activities Deleted', { pointId: pointId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.PointRevision.update({ deleted: true }, { where: { point_id: pointId } }).then(function (spread) {
-                    log.info('Point Revision Deleted', { pointId: pointId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.PointQuality.update({ deleted: true }, { where: { point_id: pointId } }).then(function (spread) {
-                    log.info('Point Quality Deleted', { pointId: pointId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-        ], (error) => {
-            log.info("deletePointActivities done", { error: error, workPackage: workPackage });
-            callback(error);
-        });
-    }
-    else {
-        log.error("No pointId, userId for deletePointActivities", { workPackage: workPackage });
-        callback("No pointId, userId for deletePointActivities");
-    }
-};
-const deletePostActivities = (workPackage, callback) => {
-    const postId = workPackage.postId;
-    const userId = workPackage.userId;
-    log.info('Starting Post Activities Delete', { postId: postId, context: 'ac-delete', userId: workPackage.userId });
-    if (postId) {
-        async.series([
-            (seriesCallback) => {
-                models.AcActivity.update({ deleted: true }, { where: { post_id: postId } }).then(function (spread) {
-                    log.info('Post User Activities Deleted', { postId: postId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Endorsement.update({ deleted: true }, { where: { post_id: postId } }).then(function (spread) {
-                    log.info('Post User Endorsement Deleted', { postId: postId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            }
-        ], (error) => {
-            log.info("deletePostActivities done", { error: error, workPackage: workPackage });
-            callback(error);
-        });
-    }
-    else {
-        callback("No pointId, userId for deletePostActivities");
-    }
-};
-const deletePostContent = (workPackage, callback) => {
-    const postId = workPackage.postId;
-    log.info('Starting Post Activities Delete', { postId: postId, context: 'ac-delete', userId: workPackage.userId });
-    if (postId) {
-        async.series([
-            (seriesCallback) => {
-                if (!workPackage.skipActivities) {
-                    models.AcActivity.update({ deleted: true }, { where: { post_id: postId } }).then((spread) => {
-                        log.info('Post Activities Deleted', { postId: postId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            },
-            (seriesCallback) => {
-                models.Point.findAll({
-                    attributes: ['id', 'post_id'],
-                    where: {
-                        post_id: postId
-                    }
-                }).then((points) => {
-                    async.forEachLimit(points, 100, (point, innerCallback) => {
-                        deletePointContent(_.merge({ pointId: point.id, skipActivities: true }, workPackage), innerCallback);
-                        queue.add('process-similarities', { type: 'update-collection', pointId: point.id }, 'low', { delay: 10000 });
-                    }, (error) => {
-                        seriesCallback(error);
-                    });
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Point.update({ deleted: true }, { where: { post_id: postId } }).then((spread) => {
-                    log.info('Post Activities Points Deleted', { postId: postId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Endorsement.update({ deleted: true }, { where: { post_id: postId } }).then((spread) => {
-                    log.info('Post Endorsement Deleted', { postId: postId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                if (workPackage.resetCounters) {
-                    models.Post.update({ counter_endorsements_up: 0, counter_endorsements_down: 0, counter_points: 0, counter_users: 0 }, { where: { id: postId } }).then(function () {
-                        log.info("Post reset counters for post");
-                        recountGroupFromPostId(postId, (error) => {
-                            seriesCallback(error);
-                        });
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            }
-        ], (error) => {
-            if (workPackage.useNotification) {
-                models.Post.findOne({
-                    where: { id: postId },
-                    attributes: ['id', 'group_id'],
-                    include: [
-                        {
-                            model: models.Group,
-                            attributes: ['id', 'community_id'],
-                            include: [
-                                {
-                                    model: models.Community,
-                                    attributes: ['id', 'domain_id']
-                                }
-                            ]
-                        }
-                    ]
-                }).then((post) => {
-                    if (post) {
-                        const notificationType = error ? 'deletePostContentError' : 'deletePostContentDone';
-                        models.AcActivity.createActivity({
-                            type: 'activity.system.generalUserNotification',
-                            object: { type: notificationType, name: workPackage.postName, forwardToUser: true, offerReload: true },
-                            userId: workPackage.userId, postId: postId, groupId: post.Group.id, communityId: post.Group.Community.id,
-                            domainId: post.Group.Community.domain_id
-                        }, (subError) => {
-                            callback(error || subError);
-                        });
-                    }
-                    else {
-                        callback("Could not find post for notification in deletions");
-                    }
-                }).catch((error) => {
-                    callback(error);
-                });
-            }
-            else {
-                callback(error);
-            }
-        });
-    }
-    else {
-        callback("No postId for deletePostContent");
-    }
-};
-const deleteGroupContent = (workPackage, callback) => {
-    const groupId = workPackage.groupId;
-    let allPosts = null;
-    log.info('Starting Group Activities Delete', { groupId: groupId, context: 'ac-delete', userId: workPackage.userId });
-    if (groupId) {
-        async.series([
-            (seriesCallback) => {
-                models.AcActivity.update({ deleted: true }, { where: { group_id: groupId } }).then((spread) => {
-                    log.info('Group Activities Deleted', { groupId: groupId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Post.findAll({
-                    attributes: ['id'],
-                    where: { group_id: groupId }
-                }).then(function (posts) {
-                    async.forEachLimit(posts, 100, function (post, innerCallback) {
-                        deletePostContent(_.merge({ postId: post.id, skipActivities: true, useNotification: false, resetCounters: false }, workPackage), innerCallback);
-                        queue.add('process-similarities', { type: 'update-collection', postId: post.id }, 'low', { delay: 10000 });
-                    }, (error) => {
-                        seriesCallback(error);
-                    });
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Post.update({ deleted: true }, { where: { group_id: groupId } }).then((spread) => {
-                    log.info('Group Activities Post Deleted', { groupId: groupId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                if (workPackage.resetCounters) {
-                    models.Group.update({ counter_posts: 0, counter_points: 0, counter_users: 0 }, { where: { id: groupId } }).then(function () {
-                        log.info("Group reset counters for group");
-                        resetCountForCommunityForGroup(groupId, seriesCallback);
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            }
-        ], (error) => {
-            if (workPackage.useNotification) {
-                models.Group.findOne({
-                    where: { id: groupId },
-                    attributes: ['id', 'community_id'],
-                    include: [
-                        {
-                            model: models.Community,
-                            attributes: ['id', 'domain_id']
-                        }
-                    ]
-                }).then((group) => {
-                    if (group) {
-                        const notificationType = error ? 'deleteGroupContentError' : 'deleteGroupContentDone';
-                        models.AcActivity.createActivity({
-                            type: 'activity.system.generalUserNotification',
-                            object: { type: notificationType, name: workPackage.groupName, forwardToUser: true, offerReload: true },
-                            userId: workPackage.userId, groupId: group.id, communityId: group.Community.id, domainId: group.Community.domain_id
-                        }, (subError) => {
-                            callback(error || subError);
-                        });
-                    }
-                    else {
-                        callback("Could not find group for notification in deletions");
-                    }
-                }).catch((error) => {
-                    callback(error);
-                });
-            }
-            else {
-                callback(error);
-            }
-        });
-    }
-    else {
-        callback("No groupId for deleteGroupContent");
-    }
-};
-const deleteCommunityContent = (workPackage, callback) => {
-    const communityId = workPackage.communityId;
-    log.info('Starting Community Activities Delete', { communityId: communityId, context: 'ac-delete', userId: workPackage.userId });
-    if (communityId) {
-        async.series([
-            (seriesCallback) => {
-                models.AcActivity.update({ deleted: true }, { where: { community_id: communityId } }).then(function (spread) {
-                    log.info('Community Activities Deleted', { communityId: communityId, numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch(function (error) {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Group.findAll({
-                    attributes: ['id'],
-                    where: { community_id: communityId }
-                }).then(function (groups) {
-                    groups.forEach(function (group) {
-                        queue.add('process-deletion', { type: 'delete-group-content', userId: workPackage.userId, groupId: group.id }, 'high');
-                        queue.add('process-similarities', { type: 'update-collection', groupId: group.id }, 'low', { delay: 10000 });
-                    });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                if (workPackage.resetCounters) {
-                    models.Community.update({ counter_posts: 0, counter_points: 0, counter_groups: 0, counter_users: 0 }, { where: { id: communityId } }).then(function () {
-                        log.info("Community reset counters for community");
-                        seriesCallback();
-                    }).catch((error) => {
-                        seriesCallback(error);
-                    });
-                }
-                else {
-                    seriesCallback();
-                }
-            },
-            (seriesCallback) => {
-                models.Group.update({ deleted: true }, { where: { community_id: communityId } }).then(function () {
-                    log.info("Community groups deleted");
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            }
-        ], (error) => {
-            if (workPackage.useNotification) {
-                models.Community.findOne({
-                    where: { id: communityId },
-                    attributes: ['id', 'domain_id']
-                }).then((community) => {
-                    if (community) {
-                        const notificationType = error ? 'deleteCommunityContentError' : 'deleteCommunityContentDone';
-                        models.AcActivity.createActivity({
-                            type: 'activity.system.generalUserNotification',
-                            object: { type: notificationType, name: workPackage.communityName, forwardToUser: true, offerReload: true },
-                            userId: workPackage.userId, communityId: community.id, domainId: community.domain_id
-                        }, (subError) => {
-                            callback(error || subError);
-                        });
-                    }
-                    else {
-                        callback("Could not find community for notifications in deletions");
-                    }
-                }).catch((error) => {
-                    callback(error);
-                });
-            }
-            else {
-                callback(error);
-            }
-        });
-    }
-    else {
-        callback("No communityId for deleteCommunityContent");
-    }
-};
-const deleteUserEndorsements = (workPackage, callback) => {
-    models.Endorsement.findAll({
-        attributes: ['id', 'post_id', 'deleted', 'value'],
-        where: {
-            user_id: workPackage.userId
-        },
-        include: [
-            {
-                model: models.Post,
-                attributes: ['id', 'counter_endorsements_up', 'counter_endorsements_down']
-            }
-        ]
-    }).then((endorsements) => {
-        async.forEachLimit(endorsements, 100, (endorsement, forEachCallback) => {
-            if (endorsement.value === 1) {
-                endorsement.Post.decrement('counter_endorsements_up');
-            }
-            else {
-                endorsement.Post.decrement('counter_endorsements_down');
-            }
-            endorsement.deleted = true;
-            endorsement.save().then(() => {
-                forEachCallback();
-            }).catch((error) => {
-                forEachCallback(error);
-            });
-        }, (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                log.info('User Endorsements Deleted', { context: 'ac-delete', userId: workPackage.userId });
-                callback();
-            }
-        });
-    }).catch((error) => {
-        callback(error);
-    });
-};
-const deleteUserGroupEndorsements = (workPackage, callback) => {
-    models.Endorsement.findAll({
-        attributes: ['id', 'post_id', 'deleted', 'value'],
-        where: {
-            user_id: workPackage.userId
-        },
-        include: [
-            {
-                model: models.Post,
-                attributes: ['id', 'counter_endorsements_up', 'counter_endorsements_down'],
-                where: {
-                    group_id: workPackage.groupId
-                }
-            }
-        ]
-    }).then((endorsements) => {
-        async.forEachLimit(endorsements, 100, (endorsement, forEachCallback) => {
-            if (endorsement.value === 1) {
-                endorsement.Post.decrement('counter_endorsements_up');
-            }
-            else {
-                endorsement.Post.decrement('counter_endorsements_down');
-            }
-            endorsement.deleted = true;
-            endorsement.save().then(() => {
-                forEachCallback();
-            }).catch((error) => {
-                forEachCallback(error);
-            });
-        }, (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                log.info('User Group Endorsements Deleted', { context: 'ac-delete', userId: workPackage.userId });
-                callback();
-            }
-        });
-    }).catch((error) => {
-        callback(error);
-    });
-};
-const moveUserEndorsements = (workPackage, callback) => {
-    models.Endorsement.update({ user_id: workPackage.toUserId }, { where: { user_id: workPackage.fromUserId } }).then((spread) => {
-        log.info('Endorsement Moved', { numberDeleted: spread[0], context: 'ac-move', fromUserId: workPackage.fromUserId, toUserId: workPackage.toUserId });
-        callback();
-    }).catch((error) => {
-        callback(error);
-    });
-};
-const deleteUserContent = (workPackage, callback) => {
-    if (workPackage.userId && workPackage.anonymousUserId) {
-        async.series([
-            (seriesCallback) => {
-                deleteUserEndorsements(workPackage, seriesCallback);
-            },
-            (seriesCallback) => {
-                models.PointQuality.findAll({
-                    attributes: ['id', 'point_id', 'deleted', 'value'],
-                    where: {
-                        user_id: workPackage.userId
-                    },
-                    include: [
-                        {
-                            model: models.Point,
-                            attributes: ['id', 'counter_quality_up', 'counter_quality_down']
-                        }
-                    ]
-                }).then(function (pointQualities) {
-                    async.forEachLimit(pointQualities, 100, function (pointQuality, forEachCallback) {
-                        if (pointQuality.value === 1) {
-                            pointQuality.Point.decrement('counter_quality_up');
-                        }
-                        else {
-                            pointQuality.Point.decrement('counter_quality_down');
-                        }
-                        pointQuality.deleted = true;
-                        pointQuality.save().then(function () {
-                            forEachCallback();
-                        }).catch((error) => {
-                            forEachCallback(error);
-                        });
-                    }, function (error) {
-                        if (error) {
-                            seriesCallback(error);
-                        }
-                        else {
-                            log.info('User PointQuality Deleted', { context: 'ac-delete', userId: workPackage.userId });
-                            seriesCallback();
-                        }
-                    });
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Point.update({ deleted: true }, { where: { user_id: workPackage.userId } }).then((spread) => {
-                    log.info('User Points Deleted', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.AcActivity.update({ deleted: true }, { where: { user_id: workPackage.userId } }).then((spread) => {
-                    log.info('User AcActitivies Deleted', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Post.update({ deleted: true }, { where: { user_id: workPackage.userId } }).then((spread) => {
-                    log.info('User Post Deleted', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Group.update({ user_id: workPackage.anonymousUserId }, { where: { user_id: workPackage.userId } }).then((spread) => {
-                    log.info('User Groups Anonymized', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Community.update({ user_id: workPackage.anonymousUserId, ip_address: '127.0.0.1' }, { where: { user_id: workPackage.userId } }).then((spread) => {
-                    log.info('User Communities Anonymized', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            }
-        ], (error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userId or workPackage.anonymousUserId");
-    }
-};
-const recountAllFromGroup = (workPackage, callback) => {
-    let domainId, communityId;
-    async.series([
-        (seriesCallback) => {
-            log.info("RecountAllFromGroup start");
-            models.Group.findOne({
-                where: {
-                    id: workPackage.groupId
-                },
-                attributes: ['id'],
-                include: [
-                    {
-                        model: models.Community,
-                        attributes: ['id'],
-                        include: [
-                            {
-                                model: models.Domain,
-                                attributes: ['id']
-                            }
-                        ]
-                    }
-                ]
-            }).then((group) => {
-                communityId = group.Community.id;
-                domainId = group.Community.Domain.id;
-                seriesCallback();
-            }).catch((error) => { seriesCallback(); });
-        },
-        (seriesCallback) => {
-            log.info("RecountAllFromGroup group count");
-            recountGroup({ groupId: workPackage.groupId }, seriesCallback);
-        },
-        (seriesCallback) => {
-            log.info("RecountAllFromGroup community count");
-            recountCommunity({ communityId: communityId }, seriesCallback);
-        },
-        (seriesCallback) => {
-            log.info("RecountAllFromGroup domain count");
-            recountDomain({ domainId: domainId }, seriesCallback);
-        }
-    ], (error) => {
-        log.info("RecountAllFromGroup finished");
-        callback();
-    });
-};
-const recountAllFromCommunity = (workPackage, callback) => {
-    let domainId;
-    async.series([
-        (seriesCallback) => {
-            models.Community.findOne({
-                where: {
-                    id: workPackage.communityId
-                },
-                attributes: ['id'],
-                include: [
-                    {
-                        model: models.Domain,
-                        attributes: ['id']
-                    }
-                ]
-            }).then((community) => {
-                domainId = community.Domain.id;
-                seriesCallback();
-            }).catch((error) => { seriesCallback(); });
-        },
-        (seriesCallback) => {
-            recountCommunity({ communityId: workPackage.communityId, doDeepGroupCounting: true }, seriesCallback);
-        },
-        (seriesCallback) => {
-            recountDomain({ domainId: domainId }, seriesCallback);
-        }
-    ], (error) => {
-        log.info("RecountAllFromCommunity finished");
-        callback(error);
-    });
-};
-const recountAllFromDomain = (workPackage, callback) => {
-    async.series([
-        (seriesCallback) => {
-            models.Domain.findOne({
-                where: {
-                    id: workPackage.domainId
-                },
-                attributes: ['id'],
-                include: [
-                    {
-                        model: models.Community,
-                        attributes: ['id']
-                    }
-                ]
-            }).then((domain) => {
-                async.forEachLimit(domain.Communities, 100, (community, forEachCallback) => {
-                    recountCommunity({ communityId: community.id, doDeepGroupCounting: true }, forEachCallback);
-                }, (error) => { seriesCallback(error); });
-            }).catch((error) => { seriesCallback(); });
-        },
-        (seriesCallback) => {
-            recountDomain({ domainId: workPackage.domainId }, seriesCallback);
-        }
-    ], (error) => {
-        log.info("RecountAllFromDomain finished");
-        callback(error);
-    });
-};
-const deleteUserGroupContent = (workPackage, callback) => {
-    if (workPackage.userId && workPackage.anonymousUserId && workPackage.groupId) {
-        async.series([
-            (seriesCallback) => {
-                deleteUserGroupEndorsements(workPackage, seriesCallback);
-            },
-            (seriesCallback) => {
-                models.PointQuality.findAll({
-                    attributes: ['id', 'point_id', 'deleted', 'value'],
-                    where: {
-                        user_id: workPackage.userId
-                    },
-                    include: [
-                        {
-                            model: models.Point,
-                            attributes: ['id', 'counter_quality_up', 'counter_quality_down'],
-                            required: true,
-                            where: {
-                                group_id: workPackage.groupId
-                            }
-                        }
-                    ]
-                }).then(function (pointQualities) {
-                    async.forEachLimit(pointQualities, 100, function (pointQuality, forEachCallback) {
-                        if (pointQuality.value === 1) {
-                            pointQuality.Point.decrement('counter_quality_up');
-                        }
-                        else {
-                            pointQuality.Point.decrement('counter_quality_down');
-                        }
-                        pointQuality.deleted = true;
-                        pointQuality.save().then(function () {
-                            forEachCallback();
-                        }).catch((error) => {
-                            forEachCallback(error);
-                        });
-                    }, function (error) {
-                        if (error) {
-                            seriesCallback(error);
-                        }
-                        else {
-                            log.info('User PointQuality Deleted', { context: 'ac-delete', userId: workPackage.userId });
-                            seriesCallback();
-                        }
-                    });
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Point.update({ deleted: true }, { where: { user_id: workPackage.userId, group_id: workPackage.groupId } }).then((spread) => {
-                    log.info('User Group Points Deleted', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.AcActivity.update({ deleted: true }, { where: { user_id: workPackage.userId, group_id: workPackage.groupId } }).then((spread) => {
-                    log.info('User Group AcActitivies Deleted', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Post.update({ deleted: true }, { where: { user_id: workPackage.userId, group_id: workPackage.groupId } }).then((spread) => {
-                    log.info('User Post Deleted', { numberDeleted: spread[0], context: 'ac-delete', userId: workPackage.userId });
-                    seriesCallback();
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                if (workPackage.skipRecount) {
-                    log.info("Skip recount in deleteGroup content");
-                    seriesCallback();
-                }
-                else {
-                    recountAllFromGroup(workPackage, seriesCallback);
-                }
-            }
-        ], (error) => {
-            log.info("deleteUserGroupContent done", { error: error });
-            callback(error);
-        });
-    }
-    else {
-        callback("No userId or anonymousUserId or groupId");
-    }
-};
-const deleteUserCommunityContent = (workPackage, callback) => {
-    if (workPackage.userId && workPackage.anonymousUserId && workPackage.communityId) {
-        models.Community.findOne({
-            attributes: ['id'],
-            where: {
-                id: workPackage.communityId
-            },
-            include: [
-                {
-                    model: models.Group,
-                    attributes: ['id']
-                }
-            ]
-        }).then((community) => {
-            const groupIds = _.map(community.Groups, (group) => {
-                return group.id;
-            });
-            async.forEachLimit(groupIds, 100, (groupId, forEachCallback) => {
-                deleteUserGroupContent({
-                    userId: workPackage.userId,
-                    skipRecount: true,
-                    anonymousUserId: workPackage.anonymousUserId,
-                    groupId: groupId
-                }, forEachCallback);
-            }, (error) => {
-                log.info("User Community Content Deleted", { error: error, context: 'ac-delete', userId: workPackage.userId });
-                callback(error);
-            });
-        }).catch((error) => {
-            if (workPackage.skipRecount) {
-                log.info("Skiping recount for deleteUserCommunityContent");
-                callback(error);
-            }
-            else {
-                recountAllFromGroup(workPackage, callback);
-            }
-        });
-    }
-    else {
-        callback("No userId or anonymousUserId or communityId");
-    }
-};
-const deleteUserDomainContent = (workPackage, callback) => {
-    if (workPackage.userId && workPackage.anonymousUserId && workPackage.domainId) {
-        models.Domain.findOne({
-            attributes: ['id'],
-            where: {
-                id: workPackage.domainId
-            },
-            include: [
-                {
-                    model: models.Community,
-                    attributes: ['id']
-                }
-            ]
-        }).then((domain) => {
-            const communityIds = _.map(domain.Communities, (community) => {
-                return community.id;
-            });
-            async.forEachLimit(communityIds, 100, (communityId, forEachCallback) => {
-                deleteUserCommunityContent({
-                    userId: workPackage.userId,
-                    skipRecount: true,
-                    anonymousUserId: workPackage.anonymousUserId,
-                    communityId: communityId
-                }, forEachCallback);
-            }, (error) => {
-                log.info("User Domain Content Deleted", { error: error, context: 'ac-delete', userId: workPackage.userId });
-                if (workPackage.skipRecount) {
-                    log.info("Skiping recount for deleteUserDomainContent");
-                    callback(error);
-                }
-                else {
-                    recountAllFromDomain(workPackage, callback);
-                }
-            });
-        }).catch((error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userId or anonymousUserId or domainId");
-    }
-};
-const removeManyGroupAdmins = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.groupId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getGroupAndUser(workPackage.groupId, userId, null, (error, group, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && group) {
-                    group.removeGroupAdmins(user).then((results) => {
-                        log.info('Admin removed', { context: 'remove_admin', groupId: workPackage.groupId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or group not found for removeManyGroupAdmins");
-                }
-            });
-        }, (error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userIds for removeManyGroupAdmins");
-    }
-};
-const removeManyGroupPromoters = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.groupId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getGroupAndUser(workPackage.groupId, userId, null, (error, group, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && group) {
-                    group.removeGroupPromoters(user).then((results) => {
-                        log.info('Promoter removed', { context: 'remove_promoter', groupId: workPackage.groupId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or group not found for removeManyGroupPromoters");
-                }
-            });
-        }, (error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userIds for removeManyGroupPromoters");
-    }
-};
-const removeManyCommunityAdmins = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.communityId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getCommunityAndUser(workPackage.communityId, userId, null, (error, community, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && community) {
-                    community.removeCommunityAdmins(user).then((results) => {
-                        log.info('Admin removed', { context: 'remove_admin', communityId: workPackage.communityId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or community not found for removeManyCommunityAdmins");
-                }
-            });
-        }, (error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userIds for removeManyCommunityAdmins");
-    }
-};
-const removeManyCommunityPromoters = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.communityId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getCommunityAndUser(workPackage.communityId, userId, null, (error, community, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && community) {
-                    community.removeCommunityPromoters(user).then((results) => {
-                        log.info('Promoter removed', { context: 'remove_promoter', communityId: workPackage.communityId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or community not found for removeManyCommunityPromoters");
-                }
-            });
-        }, (error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userIds for removeManyCommunityPromoters");
-    }
-};
-const removeManyDomainAdmins = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.domainId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getDomainAndUser(workPackage.domainId, userId, null, (error, domain, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && domain) {
-                    domain.removeDomainAdmins(user).then((results) => {
-                        log.info('Admin removed', { context: 'remove_admin', domainId: workPackage.domainId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or domain not found for removeManyDomainAdmins");
-                }
-            });
-        }, (error) => {
-            callback(error);
-        });
-    }
-    else {
-        callback("No userIds for removeManyDomainAdmins");
-    }
-};
-const removeManyGroupUsers = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.groupId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getGroupAndUser(workPackage.groupId, userId, null, (error, group, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && group) {
-                    group.removeGroupUsers(user).then((results) => {
-                        log.info('User removed', { context: 'remove_user', results: results, groupId: workPackage.groupId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or group not found for removeManyGroupUsers");
-                }
-            });
-        }, (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                if (workPackage.skipRecount) {
-                    log.info("Skipping recount for group", { workPackage: workPackage });
-                    callback();
-                }
-                else {
-                    recountAllFromGroup(workPackage, callback);
-                }
-            }
-        });
-    }
-    else {
-        callback("No userIds for removeManyGroupUsers");
-    }
-};
-const removeManyCommunityUsers = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.communityId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getCommunityAndUser(workPackage.communityId, userId, null, (error, community, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && community) {
-                    community.removeCommunityUsers(user).then((results) => {
-                        log.info('User removed', { context: 'remove_user', communityId: workPackage.communityId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or community not found for removeManyCommunityUsers");
-                }
-            });
-        }, (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                if (workPackage.skipRecount) {
-                    log.info("Skipping recount for community", { workPackage: workPackage });
-                    callback();
-                }
-                else {
-                    recountAllFromCommunity(workPackage, callback);
-                }
-            }
-        });
-    }
-    else {
-        callback("No userIds for removeManyCommunityUsers");
-    }
-};
-const removeManyDomainUsers = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.domainId) {
-        async.forEachLimit(workPackage.userIds, 100, (userId, seriesCallback) => {
-            getDomainAndUser(workPackage.domainId, userId, null, (error, domain, user) => {
-                if (error) {
-                    seriesCallback(error);
-                }
-                else if (user && domain) {
-                    domain.removeDomainUsers(user).then((results) => {
-                        log.info('User removed', { context: 'remove_user', domainId: workPackage.domainId, userRemovedId: userId });
-                        seriesCallback();
-                    });
-                }
-                else {
-                    seriesCallback("User or domain not found for removeManyDomainUsers");
-                }
-            });
-        }, (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                if (workPackage.skipRecount) {
-                    callback();
-                }
-                else {
-                    recountAllFromDomain(workPackage, callback);
-                }
-            }
-        });
-    }
-    else {
-        callback("No userIds for removeManyDomainUsers");
-    }
-};
-const removeManyGroupUsersAndDeleteContent = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.groupId) {
-        async.parallel([
-            (parallelCallback) => {
-                removeManyGroupUsers(_.merge(workPackage, { skipRecount: true }), parallelCallback);
-            },
-            (parallelCallback) => {
-                async.forEachLimit(workPackage.userIds, 100, (userId, forEachCallback) => {
-                    deleteUserGroupContent({
-                        userId: userId,
-                        skipRecount: true,
-                        groupId: workPackage.groupId,
-                        anonymousUserId: workPackage.anonymousUserId
-                    }, forEachCallback);
-                }, (error) => {
-                    parallelCallback(error);
-                });
-            }
-        ], (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                recountAllFromGroup(workPackage, callback);
-            }
-        });
-    }
-    else {
-        callback("No userIds for removeManyGroupUsersAndDeleteContent");
-    }
-};
-const removeManyCommunityUsersAndDeleteContent = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.communityId) {
-        async.series([
-            (seriesCallback) => {
-                async.forEachLimit(workPackage.userIds, 100, (userId, forEachCallback) => {
-                    deleteUserCommunityContent({
-                        userId: userId,
-                        skipRecount: true,
-                        communityId: workPackage.communityId,
-                        anonymousUserId: workPackage.anonymousUserId
-                    }, forEachCallback);
-                }, (error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                removeManyCommunityUsers(_.merge(workPackage, { skipRecount: true }), seriesCallback);
-            },
-            (seriesCallback) => {
-                models.Community.findOne({
-                    where: {
-                        id: workPackage.communityId
-                    },
-                    attributes: ['id'],
-                    include: [
-                        {
-                            model: models.Group,
-                            attributes: ['id']
-                        }
-                    ]
-                }).then((community) => {
-                    async.forEachLimit(community.Groups, 100, (group, forEachCallback) => {
-                        removeManyGroupUsers(_.merge(workPackage, { groupId: group.id, skipRecount: true }), forEachCallback);
-                    }, (error) => {
-                        log.info("Have removed group users for community deletion", { error: error, communityId: workPackage.communityId });
-                        seriesCallback(error);
-                    });
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            }
-        ], (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                recountAllFromCommunity(workPackage, callback);
-            }
-        });
-    }
-    else {
-        callback("No userIds for removeManyCommunityUsersAndDeleteContent");
-    }
-};
-const removeManyDomainUsersAndDeleteContent = (workPackage, callback) => {
-    if (workPackage.userIds && workPackage.userIds.length > 0 && workPackage.domainId) {
-        async.series([
-            (seriesCallback) => {
-                async.forEachLimit(workPackage.userIds, 100, (userId, forEachCallback) => {
-                    deleteUserDomainContent({
-                        userId: userId,
-                        skipRecount: true,
-                        domainId: workPackage.domainId,
-                        anonymousUserId: workPackage.anonymousUserId
-                    }, forEachCallback);
-                }, (error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                models.Domain.findOne({
-                    where: {
-                        id: workPackage.domainId
-                    },
-                    attributes: ['id'],
-                    include: [
-                        {
-                            model: models.Community,
-                            attributes: ['id']
-                        }
-                    ]
-                }).then((domain) => {
-                    async.forEachLimit(domain.Communities, 100, (community, forEachCallback) => {
-                        async.series([
-                            (innerSeriesCallback) => {
-                                removeManyCommunityUsers(_.merge(workPackage, { communityId: community.id, skipRecount: true }), innerSeriesCallback);
-                            },
-                            (innerSeriesCallback) => {
-                                models.Community.findOne({
-                                    where: {
-                                        id: community.id
-                                    },
-                                    attributes: ['id'],
-                                    include: [
-                                        {
-                                            model: models.Group,
-                                            attributes: ['id']
-                                        }
-                                    ]
-                                }).then((community) => {
-                                    async.forEachLimit(community.Groups, 100, (group, innerForEachCallback) => {
-                                        removeManyGroupUsers(_.merge(workPackage, { groupId: group.id, skipRecount: true }), innerForEachCallback);
-                                    }, (error) => {
-                                        log.info("Have removed group users for domain deletion", { error: error, domainId: workPackage.domainId });
-                                        innerSeriesCallback(error);
-                                    });
-                                }).catch((error) => {
-                                    innerSeriesCallback(error);
-                                });
-                            },
-                        ], (error) => {
-                            forEachCallback(error);
-                        });
-                    }, (error) => {
-                        seriesCallback(error);
-                    });
-                }).catch((error) => {
-                    seriesCallback(error);
-                });
-            },
-            (seriesCallback) => {
-                removeManyDomainUsers(_.merge(workPackage, { skipRecount: true }), seriesCallback);
-            }
-        ], (error) => {
-            if (error) {
-                callback(error);
-            }
-            else {
-                recountAllFromDomain(workPackage, callback);
-            }
-        });
-    }
-    else {
-        callback("No userIds for removeManyDomainUsersAndDeleteContent");
-    }
-};
-DeletionWorker.prototype.process = (workPackage, callback) => {
-    getAnonymousUser((error, anonymousUser) => {
-        if (error) {
-            callback(error);
-        }
-        else {
-            workPackage = _.merge({ anonymousUserId: anonymousUser.id }, workPackage);
-            switch (workPackage.type) {
-                case 'delete-point-content':
-                    deletePointContent(workPackage, callback);
-                    break;
-                case 'delete-point-activities':
-                    deletePointActivities(workPackage, callback);
-                    break;
-                case 'delete-post-content':
-                    deletePostContent(workPackage, callback);
-                    break;
-                case 'delete-post-activities':
-                    deletePostActivities(workPackage, callback);
-                    break;
-                case 'delete-group-content':
-                    deleteGroupContent(workPackage, callback);
-                    break;
-                case 'delete-community-content':
-                    deleteCommunityContent(workPackage, callback);
-                    break;
-                case 'delete-user-content':
-                    deleteUserContent(workPackage, callback);
-                    break;
-                case 'delete-group-user-content':
-                    deleteUserGroupContent(workPackage, callback);
-                    break;
-                case 'delete-community-user-content':
-                    deleteUserCommunityContent(workPackage, callback);
-                    break;
-                case 'delete-domain-user-content':
-                    deleteUserDomainContent(workPackage, callback);
-                    break;
-                case 'delete-user-endorsements':
-                    deleteUserEndorsements(workPackage, callback);
-                    break;
-                case 'move-user-endorsements':
-                    moveUserEndorsements(workPackage, callback);
-                    break;
-                case 'remove-many-group-admins':
-                    removeManyGroupAdmins(workPackage, callback);
-                    break;
-                case 'remove-many-group-promoters':
-                    removeManyGroupPromoters(workPackage, callback);
-                    break;
-                case 'remove-many-group-users':
-                    removeManyGroupUsers(workPackage, callback);
-                    break;
-                case 'remove-many-group-users-and-delete-content':
-                    removeManyGroupUsersAndDeleteContent(workPackage, callback);
-                    break;
-                case 'remove-many-community-admins':
-                    removeManyCommunityAdmins(workPackage, callback);
-                    break;
-                case 'remove-many-community-promoters':
-                    removeManyCommunityPromoters(workPackage, callback);
-                    break;
-                case 'remove-many-community-users':
-                    removeManyCommunityUsers(workPackage, callback);
-                    break;
-                case 'remove-many-community-users-and-delete-content':
-                    removeManyCommunityUsersAndDeleteContent(workPackage, callback);
-                    break;
-                case 'remove-many-domain-admins':
-                    removeManyDomainAdmins(workPackage, callback);
-                    break;
-                case 'remove-many-domain-users':
-                    removeManyDomainUsers(workPackage, callback);
-                    break;
-                case 'remove-many-domain-users-and-delete-content':
-                    removeManyDomainUsersAndDeleteContent(workPackage, callback);
-                    break;
-                default:
-                    callback("Unknown type for workPackage: " + workPackage.type);
-            }
-        }
-    });
-};
-module.exports = new DeletionWorker();