@yrpri/api 9.0.101 → 9.0.103

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

@@ -0,0 +1,109 @@
+"use strict";
+const _ = require("lodash");
+const FraudGetBase = require('./FraudGetBase.cjs');
+const models = require("../../../../models/index.cjs");
+class FraudGetPoints extends FraudGetBase {
+    async getAllItems() {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                const items = await models.Post.findAll({
+                    attributes: ["id", "created_at", "group_id", "name", "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);
+            }
+        });
+    }
+    getTopItems(items, type) {
+        let topItems = this.setupTopItems(items);
+        const postIds = this.getPostIdsFromItems(topItems);
+        const postCount = _.uniq(postIds).length;
+        const pointMultiplier = 10;
+        if (type === "byIpFingerprint") {
+            let out = [];
+            _.each(topItems, function (item) {
+                if ((item.count / postCount) > pointMultiplier) {
+                    if ((item.count / postCount) > 5 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 70);
+                    }
+                    else if ((item.count / postCount) > 4 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 60);
+                    }
+                    else if ((item.count / postCount) > 3 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 40);
+                    }
+                    else if ((item.count / postCount) > 2 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 20);
+                    }
+                    else {
+                        this.setWeightedConfidenceScore(item.items, 10);
+                    }
+                    out.push(item);
+                }
+            }.bind(this));
+            return out;
+        }
+        else if (type === "byMissingFingerprint") {
+            return topItems;
+        }
+        else if (type === "byIpAddress") {
+            let out = [];
+            _.each(topItems, function (item) {
+                if ((item.count / postCount) > pointMultiplier) {
+                    if ((item.count / postCount) > 100 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 70);
+                    }
+                    else if ((item.count / postCount) > 50 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 65);
+                    }
+                    else if ((item.count / postCount) > 25 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 40);
+                    }
+                    else if ((item.count / postCount) > 10 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 35);
+                    }
+                    else if ((item.count / postCount) > 5 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 20);
+                    }
+                    else if ((item.count / postCount) > 2 * pointMultiplier) {
+                        this.setWeightedConfidenceScore(item.items, 15);
+                    }
+                    else {
+                        this.setWeightedConfidenceScore(item.items, 10);
+                    }
+                    out.push(item);
+                }
+            }.bind(this));
+            return out;
+        }
+        else {
+            console.warn("Wrong type for e fraud check");
+            return [];
+        }
+    }
+}
+module.exports = FraudGetPoints;

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

@@ -0,0 +1,140 @@
+"use strict";
+const _ = require("lodash");
+const FraudGetEndorsements = require('./FraudGetEndorsements.cjs');
+const models = require("../../../../models/index.cjs");
+class FraudGetRatings extends FraudGetEndorsements {
+    constructor(workPackage) {
+        super(workPackage);
+        this.groupConfiguration = null;
+    }
+    async getAllItems() {
+        const itemsContainer = await this.getAllModelItems(models.Rating, true);
+        this.groupConfiguration = itemsContainer.groupConfiguration;
+        return itemsContainer.itemsToAnalyse;
+    }
+    getTopItems(items, type) {
+        let topItems = this.setupTopItems(items);
+        const postIds = this.getPostIdsFromItems(topItems);
+        const postCount = _.uniq(postIds).length;
+        let ratingsCount = 10000000;
+        if (this.groupConfiguration) {
+            ratingsCount = Object.keys(this.groupConfiguration.customRatings).length;
+        }
+        if (type === "byIpUserAgentPostId") {
+            let out = [];
+            _.each(topItems, function (item) {
+                if ((item.count / ratingsCount) > 1) {
+                    if ((item.count / ratingsCount) > 10) {
+                        this.setWeightedConfidenceScore(item.items, 95);
+                    }
+                    else if ((item.count / ratingsCount) > 5) {
+                        this.setWeightedConfidenceScore(item.items, 90);
+                    }
+                    else if ((item.count / ratingsCount) > 4) {
+                        this.setWeightedConfidenceScore(item.items, 85);
+                    }
+                    else if ((item.count / ratingsCount) > 3) {
+                        this.setWeightedConfidenceScore(item.items, 80);
+                    }
+                    else if ((item.count / ratingsCount) > 2) {
+                        this.setWeightedConfidenceScore(item.items, 75);
+                    }
+                    else {
+                        this.setWeightedConfidenceScore(item.items, 70);
+                    }
+                    out.push(item);
+                }
+            }.bind(this));
+            return out;
+        }
+        else if (type === "byIpFingerprint") {
+            let out = [];
+            _.each(topItems, function (item) {
+                if ((item.count / postCount / ratingsCount) > 1) {
+                    if ((item.count / postCount / ratingsCount) > 5) {
+                        this.setWeightedConfidenceScore(item.items, 99);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 4) {
+                        this.setWeightedConfidenceScore(item.items, 95);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 3) {
+                        this.setWeightedConfidenceScore(item.items, 90);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 2) {
+                        this.setWeightedConfidenceScore(item.items, 85);
+                    }
+                    else {
+                        this.setWeightedConfidenceScore(item.items, 80);
+                    }
+                    out.push(item);
+                }
+            }.bind(this));
+            return out;
+        }
+        else if (type === "byMissingFingerprint") {
+            return topItems;
+        }
+        else if (type === "byIpFingerprintPostId") {
+            let out = [];
+            _.each(topItems, function (item) {
+                if ((item.count / ratingsCount) > 1) {
+                    if ((item.count / ratingsCount) > 10) {
+                        this.setWeightedConfidenceScore(item.items, 100);
+                    }
+                    else if ((item.count / ratingsCount) > 5) {
+                        this.setWeightedConfidenceScore(item.items, 98);
+                    }
+                    else if ((item.count / ratingsCount) > 4) {
+                        this.setWeightedConfidenceScore(item.items, 95);
+                    }
+                    else if ((item.count / ratingsCount) > 3) {
+                        this.setWeightedConfidenceScore(item.items, 90);
+                    }
+                    else if ((item.count / ratingsCount) > 2) {
+                        this.setWeightedConfidenceScore(item.items, 85);
+                    }
+                    else {
+                        this.setWeightedConfidenceScore(item.items, 80);
+                    }
+                    out.push(item);
+                }
+            }.bind(this));
+            return out;
+        }
+        else if (type === "byIpAddress") {
+            let out = [];
+            _.each(topItems, function (item) {
+                if ((item.count / postCount / ratingsCount) > 1) {
+                    if ((item.count / postCount / ratingsCount) > 100) {
+                        this.setWeightedConfidenceScore(item.items, 90);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 50) {
+                        this.setWeightedConfidenceScore(item.items, 85);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 25) {
+                        this.setWeightedConfidenceScore(item.items, 80);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 10) {
+                        this.setWeightedConfidenceScore(item.items, 75);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 5) {
+                        this.setWeightedConfidenceScore(item.items, 70);
+                    }
+                    else if ((item.count / postCount / ratingsCount) > 2) {
+                        this.setWeightedConfidenceScore(item.items, 65);
+                    }
+                    else {
+                        this.setWeightedConfidenceScore(item.items, 50);
+                    }
+                    out.push(item);
+                }
+            }.bind(this));
+            return out;
+        }
+        else {
+            console.warn("Wrong type for e fraud check");
+            return [];
+        }
+    }
+}
+module.exports = FraudGetRatings;

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

@@ -0,0 +1,279 @@
+"use strict";
+const _ = require("lodash");
+const models = require("../../../../models/index.cjs");
+const i18n = require('../../../utils/i18n.cjs');
+const deepEqual = require('deep-equal');
+const FraudGetEndorsements = require("./FraudGetEndorsements");
+const FraudGetPointQualities = require("./FraudGetPointQualities");
+const FraudGetRatings = require("./FraudGetRatings");
+const queue = require("../../../workers/queue.cjs");
+const Backend = require("i18next-fs-backend");
+const path = require("path");
+var localesPath = path.resolve(__dirname, '../../../locales');
+class FraudScannerNotifier {
+    constructor() {
+        this.currentCommunity = null;
+        this.uniqueCollectionItemsIds = {};
+        this.collectionsToScan = ['endorsements', 'ratings', 'pointQualities'];
+        this.scannerModels = [FraudGetEndorsements, FraudGetRatings, FraudGetPointQualities];
+    }
+    getCommunityURL() {
+        if (this.currentCommunity && this.currentCommunity.Domain && this.currentCommunity.Domain.domain_name) {
+            const domainName = this.currentCommunity.Domain.domain_name;
+            let hostname = this.currentCommunity.hostname;
+            const id = this.currentCommunity.id;
+            if (domainName === "parliament.scot") {
+                hostname = "engage";
+            }
+            else if (domainName === "multicitychallenge.org" && process.env.US_CLUSTER != null) {
+                hostname = "ideas";
+            }
+            else if (domainName === "engage-southampton.ac.uk") {
+                hostname = "scca-online";
+            }
+            else if (domainName === "multicitychallenge.org") {
+                hostname = "yp";
+            }
+            else if (domainName === "mycitychallenge.org") {
+                hostname = "ideas";
+            }
+            else if (domainName === "engagebritain.org") {
+                hostname = "socialcare";
+            }
+            else if (domainName === "boliden.com") {
+                hostname = "sidtjarn";
+            }
+            if (hostname) {
+                return `https://${hostname}.${domainName}/community/${id}`;
+            }
+            else {
+                return `https://${domainName}/community/${id}`;
+            }
+        }
+        else {
+            console.error("No domain name for community");
+            return "";
+        }
+    }
+    setupCounts(items, collectionType) {
+        if (!this.uniqueCollectionItemsIds[collectionType]) {
+            this.uniqueCollectionItemsIds[collectionType] = [];
+        }
+        if (items) {
+            for (let i = 0; i < items.length; i++) {
+                if (this.uniqueCollectionItemsIds[collectionType].indexOf(items[i].id) === -1) {
+                    const confidenceScore = parseInt(items[i].confidenceScore.replace("%", ""));
+                    if (confidenceScore > 75) {
+                        this.uniqueCollectionItemsIds[collectionType].push(items[i].id);
+                    }
+                }
+            }
+        }
+        else {
+            console.error(`No job data for ${collectionType}`);
+        }
+    }
+    capitalizeFirstLetter(string) {
+        return string.charAt(0).toUpperCase() + string.slice(1);
+    }
+    formatNumber(value) {
+        if (value) {
+            return value.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+        }
+        else {
+            return "0";
+        }
+    }
+    getNumberSign(number) {
+        if (number >= 0) {
+            return "+";
+        }
+        else {
+            return "";
+        }
+    }
+    async sendNotificationEmails(fraudAuditResults) {
+        if (this.currentCommunity && this.currentCommunity.CommunityAdmins && this.currentCommunity.CommunityAdmins.length > 0) {
+            const admins = this.currentCommunity.CommunityAdmins;
+            let textsHtml = "";
+            for (let t = 0; t < fraudAuditResults.length; t++) {
+                textsHtml += `${fraudAuditResults[t].collectionType}: ${this.formatNumber(fraudAuditResults[t].count)} items`;
+                if (fraudAuditResults[t].changeFromLastCount) {
+                    textsHtml += ` (${this.getNumberSign(fraudAuditResults[t].changeFromLastCount)}${this.formatNumber(fraudAuditResults[t].changeFromLastCount)})`;
+                }
+                textsHtml += `</br>`;
+            }
+            const content = `
+        <div>
+          <h1>${i18n.t('notification.email.possibleFraudHeader')}</h1>
+          <p>${i18n.t('notification.email.possibleFraudInformation')}</p>
+          <h2>${i18n.t('notification.email.possibleFraudSubHeader')}</h2>
+          <p>${textsHtml}</p>
+          <p>${i18n.t('notification.email.possibleFraudFooter')}</p>
+        </div>
+      `;
+            for (let u = 0; u < Math.min(admins.length, 5); u++) {
+                queue.add('send-one-email', {
+                    subject: { translateToken: 'notification.email.possibleFraudHeader', contentName: this.currentCommunity.name },
+                    template: 'general_user_notification',
+                    user: admins[u],
+                    domain: this.currentCommunity.Domain,
+                    community: this.currentCommunity,
+                    object: fraudAuditResults,
+                    header: "",
+                    content: content,
+                    link: this.getCommunityURL()
+                }, 'high');
+            }
+        }
+        else {
+            console.error("No community admins found");
+            return;
+        }
+    }
+    getContainerOldCount(collectionType) {
+        let foundCollection;
+        if (this.currentCommunity.data.lastFraudScanResults) {
+            for (let i = 0; i < this.currentCommunity.data.lastFraudScanResults.length; i++) {
+                if (this.currentCommunity.data.lastFraudScanResults[i].collectionType &&
+                    this.currentCommunity.data.lastFraudScanResults[i].collectionType === collectionType) {
+                    foundCollection = this.currentCommunity.data.lastFraudScanResults[i];
+                    break;
+                }
+            }
+        }
+        return foundCollection;
+    }
+    getWithDifference(results) {
+        const newResults = JSON.parse(JSON.stringify(results));
+        for (let i = 0; i < newResults.length; i++) {
+            const oldResults = this.getContainerOldCount(newResults[i].collectionType);
+            if (oldResults) {
+                newResults[i].changeFromLastCount = newResults[i].count - oldResults.count;
+            }
+        }
+        return newResults;
+    }
+    async notify() {
+        const fraudScanResults = [];
+        for (let c = 0; c < this.collectionsToScan.length; c++) {
+            const collectionLength = this.uniqueCollectionItemsIds[this.collectionsToScan[c]].length;
+            if (collectionLength > 0) {
+                fraudScanResults.push({ collectionType: this.capitalizeFirstLetter(this.collectionsToScan[c]), count: collectionLength });
+            }
+        }
+        if (fraudScanResults.length > 0) {
+            if (!this.currentCommunity.data ||
+                !this.currentCommunity.data.lastFraudScanResults ||
+                !deepEqual(this.currentCommunity.data.lastFraudScanResults, fraudScanResults)) {
+                await this.sendNotificationEmails(this.getWithDifference(fraudScanResults));
+                await this.currentCommunity.reload();
+                if (!this.currentCommunity.data) {
+                    this.currentCommunity.data = {};
+                }
+                this.currentCommunity.data.lastFraudScanResults = fraudScanResults;
+                this.currentCommunity.changed('data', true);
+                await this.currentCommunity.save();
+            }
+            else {
+                console.log("Not resending same numbers");
+            }
+        }
+    }
+    async scan() {
+        for (let c = 0; c < this.collectionsToScan.length; c++) {
+            let methodsToScan = ['byIpFingerprint', 'byMissingBrowserFingerprint', 'byIpAddress'];
+            if (this.collectionsToScan[c] === "pointQualities") {
+                methodsToScan = methodsToScan.concat(['byIpFingerprintPointId', 'byIpUserAgentPointId']);
+            }
+            else {
+                methodsToScan = methodsToScan.concat(['byIpFingerprintPostId', 'byIpUserAgentPostId']);
+            }
+            for (let m = 0; m < methodsToScan.length; m++) {
+                let job = await models.AcBackgroundJob.createJobAsync({}, {});
+                const workPackage = {
+                    userId: -1,
+                    communityId: this.currentCommunity.id,
+                    jobId: job.id,
+                    collectionType: this.collectionsToScan[c],
+                    selectedMethod: methodsToScan[m]
+                };
+                const scanner = new this.scannerModels[c](workPackage);
+                await scanner.processAndGetFraudItems();
+                job = await job.reload();
+                this.setupCounts(job.data.items, this.collectionsToScan[c]);
+                await job.destroy();
+            }
+        }
+    }
+    async scanAndNotify() {
+        return await new Promise(async (resolve, reject) => {
+            try {
+                const communities = await models.Community.findAll({
+                    where: {
+                        "configuration.enableFraudDetection": true
+                    },
+                    attributes: ['id', 'configuration', 'name', 'data', 'hostname'],
+                    include: [
+                        {
+                            model: models.Domain,
+                            attributes: ['id', 'name', 'domain_name']
+                        },
+                        {
+                            model: models.User,
+                            as: 'CommunityAdmins',
+                            attributes: ['id', 'email', 'name']
+                        }
+                    ]
+                });
+                for (let i = 0; i < communities.length; i++) {
+                    console.log("Processing community: " + communities[i].name);
+                    this.currentCommunity = communities[i];
+                    try {
+                        await this.scan();
+                        await this.notify();
+                    }
+                    catch (error) {
+                        console.error("Error processing community: " + communities[i].name);
+                        console.error(error);
+                        reject(error);
+                        return;
+                    }
+                }
+                resolve();
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+}
+i18n
+    .use(Backend)
+    .init({
+    preload: ['en', 'fr', 'sk', 'bg', 'cs', 'it', 'da', 'kl', 'es', 'sv', 'sq', 'uz', 'uk', 'ca', 'hr', 'ro', 'ru',
+        'ro_md', 'pt_br', 'hu', 'tr', 'is', 'nl', 'no', 'pl', 'zh_tw', 'ky'],
+    fallbackLng: 'en',
+    // this is the defaults
+    backend: {
+        // path where resources get loaded from
+        loadPath: localesPath + '/{{lng}}/translation.json',
+        // path to post missing resources
+        addPath: localesPath + '/{{lng}}/translation.missing.json',
+        // jsonIndent to use when storing json files
+        jsonIndent: 2
+    }
+}, function (err, t) {
+    (async () => {
+        try {
+            const scanner = new FraudScannerNotifier();
+            await scanner.scanAndNotify();
+            console.log("Fraud Scanning Complete");
+            process.exit();
+        }
+        catch (error) {
+            console.error(error);
+            process.exit();
+        }
+    })();
+});