@yrpri/api 9.0.103 → 9.0.104

package/dist/active-citizen/engine/moderation/fraud/FraudDeleteBase.cjs

@@ -1,211 +0,0 @@
-"use strict";
-const _ = require("lodash");
-const moment = require("moment");
-const models = require("../../../../models/index.cjs");
-const FraudBase = require('./FraudBase.cjs');
-const recountCommunity = require('../../../../utils/recount_utils.cjs').recountCommunity;
-const recountPosts = require('../../../../utils/recount_utils.cjs').recountPosts;
-const recountPoints = require('../../../../utils/recount_utils.cjs').recountPoints;
-class FraudDeleteBase extends FraudBase {
-    constructor(workPackage) {
-        super(workPackage);
-        this.postsToRecount = [];
-        this.pointsToRecount = [];
-        this.job = null;
-    }
-    sliceIntoChunks(arr, chunkSize) {
-        const res = [];
-        for (let i = 0; i < arr.length; i += chunkSize) {
-            const chunk = arr.slice(i, i + chunkSize);
-            res.push(chunk);
-        }
-        return res;
-    }
-    async getItemsById() {
-        // this.job.internal_data.idsToDelete
-        console.error("Should be implemented in a sub class");
-        return null;
-    }
-    async destroyChunkItems(chunks) {
-        console.error("Should be implemented in a sub class");
-    }
-    getAllItemsExceptOne(items) {
-        if (items.length === 1 && this.getAllowedSingleDelete()) {
-            return items;
-        }
-        else {
-            const sortedItems = _.sortBy(items, function (item) {
-                return item.date;
-            });
-            const finalItems = [];
-            let foundEmail = false;
-            for (let i = 0; i < sortedItems.length; i++) {
-                if (!foundEmail && sortedItems[i].User.email && sortedItems[i].User.email.indexOf("_anonymous@citizens.i") === -1) {
-                    foundEmail = true;
-                }
-                else {
-                    finalItems.push(sortedItems[i]);
-                }
-            }
-            if (items.length === finalItems.length) {
-                finalItems.pop();
-            }
-            return finalItems;
-        }
-    }
-    async createAuditLog() {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const user = await models.User.findOne({
-                    where: {
-                        id: this.workPackage.userId,
-                    },
-                    attributes: ['name']
-                });
-                const fraudAuditLog = await models.GeneralDataStore.create({ data: {
-                        date: new Date(),
-                        userName: user.name,
-                        workPackage: this.workPackage,
-                        deleteData: this.job.internal_data
-                    } });
-                const community = await models.Community.findOne({
-                    where: {
-                        id: this.workPackage.communityId
-                    },
-                    attributes: ['data', 'id']
-                });
-                if (!community.data) {
-                    community.data = {};
-                }
-                if (!community.data.fraudDeletionsAuditLogs) {
-                    community.set('data.fraudDeletionsAuditLogs', []);
-                }
-                community.data.fraudDeletionsAuditLogs.push({
-                    logId: fraudAuditLog.id,
-                    date: fraudAuditLog.data.date,
-                    userName: user.name
-                });
-                community.changed('data', true);
-                await community.save();
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    getAllowedSingleDelete() {
-        return this.workPackage.type === "delete-one-item";
-    }
-    getMomentInYourPriorities() {
-        if (this.workPackage.collectionType === "endorsements") {
-            return moment("16/02/2022", "DD/MM/YYYY").valueOf();
-        }
-        else {
-            return moment("21/02/2022", "DD/MM/YYYY").valueOf();
-        }
-    }
-    getTopItems(items, type) {
-        return this.setupTopItems(items);
-    }
-    async destroyAllItems(chunks) {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const progressAdvanceForChunk = 75 / 10;
-                let progress = 25;
-                for (let c = 0; c < chunks.length; c++) {
-                    await this.destroyChunkItems(chunks[c]);
-                    progress = Math.round(Math.min(80, progress += progressAdvanceForChunk));
-                    await models.AcBackgroundJob.updateProgressAsync(this.workPackage.jobId, progress);
-                }
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async deleteData() {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const keys = Object.keys(this.dataToProcess);
-                let itemsToDelete = [];
-                for (let c = 0; c < keys.length; c++) {
-                    itemsToDelete = itemsToDelete.concat(this.getAllItemsExceptOne(this.dataToProcess[keys[c]].items));
-                }
-                await this.destroyAllItems(this.sliceIntoChunks(itemsToDelete, 100));
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async recountPosts() {
-        return await new Promise(async (resolve, reject) => {
-            recountPosts(this.postsToRecount, error => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    async recountPoints() {
-        return await new Promise(async (resolve, reject) => {
-            recountPoints(this.pointsToRecount, error => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    async recountCommunity() {
-        return await new Promise(async (resolve, reject) => {
-            recountCommunity(this.workPackage.communityId, error => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    async deleteItems() {
-        return await new Promise(async (resolve, reject) => {
-            console.log(`Delete data ${JSON.stringify(this.workPackage)}`);
-            try {
-                this.job = await models.AcBackgroundJob.findOne({
-                    where: {
-                        id: this.workPackage.jobId
-                    }
-                });
-                this.items = await this.getItemsById();
-                this.setupDataToProcess();
-                await this.deleteData();
-                await this.createAuditLog();
-                if (this.postsToRecount.length > 0) {
-                    await this.recountPosts();
-                }
-                if (this.pointsToRecount.length > 0) {
-                    await this.recountPoints();
-                }
-                await this.recountCommunity();
-                await models.AcBackgroundJob.updateProgressAsync(this.workPackage.jobId, 100);
-                resolve();
-            }
-            catch (error) {
-                await models.AcBackgroundJob.updateErrorAsync(this.workPackage.jobId, error.toString());
-                console.error(error);
-                reject(error);
-            }
-        });
-    }
-}
-module.exports = FraudDeleteBase;

package/dist/active-citizen/engine/moderation/fraud/FraudDeleteEndorsements.cjs

@@ -1,120 +0,0 @@
-"use strict";
-const _ = require("lodash");
-const FraudDeleteBase = require('./FraudDeleteBase.cjs');
-const models = require("../../../../models/index.cjs");
-class FraudDeleteEndorsements extends FraudDeleteBase {
-    async destroyChunkItemsByModel(model, items) {
-        return await new Promise(async (resolve, reject) => {
-            const idsToDestroy = items.map(i => i.id);
-            try {
-                const modelUpdate = await model.update({
-                    deleted: true
-                }, {
-                    where: {
-                        id: {
-                            $in: idsToDestroy
-                        }
-                    },
-                    include: [
-                        {
-                            model: models.Post,
-                            attributes: ['id'],
-                            include: [
-                                {
-                                    model: models.Group,
-                                    attributes: ['id'],
-                                    include: [
-                                        {
-                                            model: models.Community,
-                                            attributes: ['id'],
-                                            where: {
-                                                id: this.workPackage.communityId
-                                            },
-                                            required: true
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ],
-                    attributes: ['id']
-                });
-                for (let i = 0; i < items.length; i++) {
-                    if (this.postsToRecount.indexOf(items[i].post_id) === -1) {
-                        this.postsToRecount.push(items[i].post_id);
-                    }
-                }
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async destroyChunkItems(items) {
-        return this.destroyChunkItemsByModel(models.Endorsement, items);
-    }
-    async getModelItemsById(model, getGroup) {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const items = await model.findAll({
-                    where: {
-                        id: {
-                            $in: this.job.internal_data.idsToDelete
-                        }
-                    },
-                    attributes: ["id", "created_at", "value", "post_id", "user_id", "user_agent", "ip_address", "data"],
-                    include: [
-                        {
-                            model: models.User,
-                            attributes: ['id', 'email'],
-                        },
-                        {
-                            model: models.Post,
-                            attributes: ['id', 'name'],
-                            include: [
-                                {
-                                    model: models.Group,
-                                    attributes: ['id'],
-                                    include: [
-                                        {
-                                            model: models.Community,
-                                            attributes: [],
-                                            where: {
-                                                id: this.workPackage.communityId
-                                            }
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ]
-                });
-                const itemsToAnalyse = _.sortBy(items, function (item) {
-                    return [item.post_id, item.user_agent];
-                });
-                let groupConfiguration;
-                if (getGroup) {
-                    const group = await models.Group.findOne({
-                        where: {
-                            id: itemsToAnalyse[0].Post.Group.id
-                        },
-                        attributes: ['configuration']
-                    });
-                    if (group) {
-                        groupConfiguration = group.configuration;
-                    }
-                }
-                resolve({ itemsToAnalyse, groupConfiguration });
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async getItemsById() {
-        const itemsContainer = await this.getModelItemsById(models.Endorsement);
-        return itemsContainer.itemsToAnalyse;
-    }
-}
-module.exports = FraudDeleteEndorsements;

package/dist/active-citizen/engine/moderation/fraud/FraudDeletePointQualities.cjs

@@ -1,114 +0,0 @@
-"use strict";
-const _ = require("lodash");
-const FraudDeleteBase = require('./FraudDeleteBase.cjs');
-const models = require("../../../../models/index.cjs");
-//TODO: Change to native JS instead of lodash
-class FraudDeletePointQualities extends FraudDeleteBase {
-    async destroyChunkItems(items) {
-        return await new Promise(async (resolve, reject) => {
-            const idsToDestroy = items.map(i => i.id);
-            try {
-                const modelUpdate = await models.PointQuality.update({
-                    deleted: true
-                }, {
-                    where: {
-                        id: {
-                            $in: idsToDestroy
-                        }
-                    },
-                    include: [
-                        {
-                            model: models.Point,
-                            attributes: ['id'],
-                            include: [
-                                {
-                                    model: models.Post,
-                                    attributes: ['id'],
-                                    include: [
-                                        {
-                                            model: models.Group,
-                                            attributes: ['id'],
-                                            include: [
-                                                {
-                                                    model: models.Community,
-                                                    attributes: ['id'],
-                                                    where: {
-                                                        id: this.workPackage.communityId
-                                                    },
-                                                    required: true
-                                                }
-                                            ]
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                    ],
-                    attributes: ['id']
-                });
-                for (let i = 0; i < items.length; i++) {
-                    if (this.pointsToRecount.indexOf(items[i].Point.id) === -1) {
-                        this.pointsToRecount.push(items[i].Point.id);
-                    }
-                }
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async getItemsById() {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const items = await models.PointQuality.findAll({
-                    where: {
-                        id: {
-                            $in: this.job.internal_data.idsToDelete
-                        }
-                    },
-                    attributes: ["id", "created_at", "value", "point_id", "user_id", "user_agent", "ip_address", "data"],
-                    include: [
-                        {
-                            model: models.User,
-                            attributes: ['id', 'email'],
-                        },
-                        {
-                            model: models.Point,
-                            attributes: ['id'],
-                            include: [
-                                {
-                                    model: models.Post,
-                                    attributes: ['id', 'name'],
-                                    include: [
-                                        {
-                                            model: models.Group,
-                                            attributes: ['id'],
-                                            include: [
-                                                {
-                                                    model: models.Community,
-                                                    attributes: [],
-                                                    where: {
-                                                        id: this.workPackage.communityId
-                                                    }
-                                                }
-                                            ]
-                                        }
-                                    ]
-                                }
-                            ]
-                        },
-                    ]
-                });
-                const itemsToAnalyse = _.sortBy(items, function (item) {
-                    return [item.point_id, item.user_agent];
-                });
-                resolve(itemsToAnalyse);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-}
-module.exports = FraudDeletePointQualities;

package/dist/active-citizen/engine/moderation/fraud/FraudDeletePoints.cjs

@@ -1,101 +0,0 @@
-"use strict";
-const _ = require("lodash");
-const FraudDeleteBase = require('./FraudDeleteBase.cjs');
-const models = require("../../../../models/index.cjs");
-class FraudDeletePointQualities extends FraudDeleteBase {
-    async destroyChunkItems(items) {
-        return await new Promise(async (resolve, reject) => {
-            const idsToDestroy = items.map(i => i.id);
-            try {
-                const modelUpdate = await models.Point.update({
-                    deleted: true
-                }, {
-                    where: {
-                        id: {
-                            $in: idsToDestroy
-                        }
-                    },
-                    include: [
-                        {
-                            model: models.Post,
-                            attributes: ['id'],
-                            include: [
-                                {
-                                    model: models.Group,
-                                    attributes: ['id'],
-                                    include: [
-                                        {
-                                            model: models.Community,
-                                            attributes: ['id'],
-                                            where: {
-                                                id: this.workPackage.communityId
-                                            },
-                                            required: true
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ],
-                    attributes: ['id']
-                });
-                for (let i = 0; i < items.length; i++) {
-                    if (this.postsToRecount.indexOf(items[i].Post.id) === -1) {
-                        this.postsToRecount.push(items[i].Post.id);
-                    }
-                }
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async getItemsById() {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const items = await models.Point.findAll({
-                    where: {
-                        id: {
-                            $in: this.job.internal_data.idsToDelete
-                        }
-                    },
-                    attributes: ["id", "created_at", "value", "post_id", "user_id", "user_agent", "ip_address", "data"],
-                    include: [
-                        {
-                            model: models.User,
-                            attributes: ['id', 'email'],
-                        },
-                        {
-                            model: models.Post,
-                            attributes: ['id', 'name'],
-                            include: [
-                                {
-                                    model: models.Group,
-                                    attributes: ['id'],
-                                    include: [
-                                        {
-                                            model: models.Community,
-                                            attributes: [],
-                                            where: {
-                                                id: this.workPackage.communityId
-                                            }
-                                        }
-                                    ]
-                                }
-                            ]
-                        }
-                    ]
-                });
-                const itemsToAnalyse = _.sortBy(items, function (item) {
-                    return [item.point_id, item.user_agent];
-                });
-                resolve(itemsToAnalyse);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-}
-module.exports = FraudDeletePointQualities;

package/dist/active-citizen/engine/moderation/fraud/FraudDeletePosts.cjs

@@ -1,84 +0,0 @@
-"use strict";
-const _ = require("lodash");
-const FraudDeleteEndorsements = require('./FraudDeleteEndorsements.cjs');
-const models = require("../../../../models/index.cjs");
-class FraudDeletePosts extends FraudDeleteEndorsements {
-    async destroyChunkItems(items) {
-        return await new Promise(async (resolve, reject) => {
-            const idsToDestroy = items.map(i => i.id);
-            try {
-                const modelUpdate = await models.Post.update({
-                    deleted: true
-                }, {
-                    where: {
-                        id: {
-                            $in: idsToDestroy
-                        }
-                    },
-                    include: [
-                        {
-                            model: models.Group,
-                            attributes: ['id'],
-                            include: [
-                                {
-                                    model: models.Community,
-                                    attributes: ['id'],
-                                    where: {
-                                        id: this.workPackage.communityId
-                                    },
-                                    required: true
-                                }
-                            ]
-                        }
-                    ],
-                    attributes: ['id']
-                });
-                resolve();
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-    async getItemsById() {
-        return await new Promise(async (resolve, reject) => {
-            try {
-                const items = await models.Post.findAll({
-                    where: {
-                        id: {
-                            $in: this.job.internal_data.idsToDelete
-                        }
-                    },
-                    attributes: ["id", "created_at", "group_id", "user_id", "user_agent", "ip_address", "data"],
-                    include: [
-                        {
-                            model: models.User,
-                            attributes: ['id', 'email'],
-                        },
-                        {
-                            model: models.Group,
-                            attributes: ['id'],
-                            include: [
-                                {
-                                    model: models.Community,
-                                    attributes: [],
-                                    where: {
-                                        id: this.workPackage.communityId
-                                    }
-                                }
-                            ]
-                        }
-                    ]
-                });
-                const itemsToAnalyse = _.sortBy(items, function (item) {
-                    return [item.group_id, item.user_agent];
-                });
-                resolve(itemsToAnalyse);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-}
-module.exports = FraudDeletePosts;

package/dist/active-citizen/engine/moderation/fraud/FraudDeleteRatings.cjs

@@ -1,15 +0,0 @@
-"use strict";
-const _ = require("lodash");
-const FraudDeleteEndorsements = require('./FraudDeleteEndorsements.cjs');
-const models = require("../../../../models/index.cjs");
-//TODO: Change to native JS instead of lodash
-class FraudDeleteRatings extends FraudDeleteEndorsements {
-    async destroyChunkItems(items) {
-        return this.destroyChunkItemsByModel(models.Rating, items);
-    }
-    async getItemsById() {
-        const itemsContainer = await this.getModelItemsById(models.Rating);
-        return itemsContainer.itemsToAnalyse;
-    }
-}
-module.exports = FraudDeleteRatings;