@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/recountGroupNoUserChange.js

@@ -0,0 +1,219 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+const groupId = process.argv[2];
+let masterPostCount = 0;
+let masterPointCount = 0;
+let masterEndorsementCount = 0;
+let masterQualityCount = 0;
+const recountOnePoint = (pointId, done) => {
+    var endorsementsCount;
+    var oppositionCount;
+    let revisionsCount;
+    async.parallel([
+        (parallelCallback) => {
+            models.PointQuality.count({
+                where: {
+                    value: 1,
+                    point_id: pointId
+                }
+            }).then(function (count) {
+                endorsementsCount = count;
+                masterQualityCount += count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.PointQuality.count({
+                where: {
+                    value: -1,
+                    point_id: pointId
+                }
+            }).then(function (count) {
+                oppositionCount = count;
+                masterQualityCount += count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.PointRevision.count({
+                where: {
+                    point_id: pointId
+                }
+            }).then(function (count) {
+                pointCount = count;
+                revisionsCount = count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        }
+    ], function (error) {
+        if (error) {
+            done(error);
+        }
+        else {
+            models.Point.findOne({
+                where: {
+                    id: pointId
+                },
+                attributes: ['id', 'counter_revisions', 'counter_quality_up', 'counter_quality_down']
+            }).then(function (point) {
+                point.counter_revisions = revisionsCount;
+                point.counter_quality_up = endorsementsCount;
+                point.counter_quality_down = oppositionCount;
+                point.save().then(() => {
+                    done();
+                });
+            }).catch(error => {
+                done(error);
+            });
+        }
+    });
+};
+const recountOnePost = (postId, done) => {
+    var endorsementsCount;
+    var oppositionCount;
+    var pointCount;
+    async.parallel([
+        (parallelCallback) => {
+            models.Endorsement.count({
+                where: {
+                    value: 1,
+                    post_id: postId
+                }
+            }).then(function (count) {
+                endorsementsCount = count;
+                masterEndorsementCount += count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.Endorsement.count({
+                where: {
+                    value: -1,
+                    post_id: postId
+                }
+            }).then(function (count) {
+                oppositionCount = count;
+                masterEndorsementCount += count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.Point.count({
+                where: {
+                    $or: [
+                        { value: -1 },
+                        { value: 1 }
+                    ],
+                    post_id: postId
+                }
+            }).then(function (count) {
+                pointCount = count;
+                masterPointCount += count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        }
+    ], function (error) {
+        if (error) {
+            done(error);
+        }
+        else {
+            models.Post.findOne({
+                where: {
+                    id: postId
+                },
+                attributes: ['id', 'counter_endorsements_up', 'counter_endorsements_down', 'counter_points']
+            }).then(function (post) {
+                post.counter_points = pointCount;
+                post.counter_endorsements_up = endorsementsCount;
+                post.counter_endorsements_down = oppositionCount;
+                post.save().then(function (results) {
+                    console.log(`Recount for post ${post.id} done`);
+                    done();
+                });
+            }).catch(function (error) {
+                done(error);
+            });
+        }
+    });
+};
+const recountGroupPosts = (groupId, done) => {
+    models.Post.findAll({
+        where: {
+            group_id: groupId
+        },
+        attribute: ['id']
+    }).then(function (posts) {
+        masterPostCount = posts.length;
+        async.eachSeries(posts, (post, forEachCallback) => {
+            recountOnePost(post.id, (error) => {
+                forEachCallback();
+            });
+        }, error => {
+            done(error);
+        });
+    });
+};
+const recountPostPoints = (postId, done) => {
+    models.Point.findAll({
+        where: {
+            post_id: postId
+        },
+        attribute: ['id']
+    }).then(function (points) {
+        async.eachSeries(points, (point, forEachCallback) => {
+            recountOnePoint(point.id, forEachCallback);
+        }, error => {
+            done(error);
+        });
+    });
+};
+recountGroupPosts(groupId, error => {
+    if (error) {
+        console.error(error);
+        process.exit();
+    }
+    else {
+        models.Group.findOne({
+            where: {
+                id: groupId
+            },
+            include: [
+                {
+                    model: models.User,
+                    as: 'GroupUsers',
+                    attributes: ['id'],
+                    required: false
+                }
+            ],
+            attributes: ['id', 'counter_posts', 'counter_points', 'counter_users']
+        }).then(group => {
+            group.counter_posts = masterPostCount;
+            group.counter_points = masterPointCount;
+            //group.counter_users = group.GroupUsers.length;
+            group.save().then(() => {
+                console.log(`Done recounting group ${groupId}`);
+                process.exit();
+            }).catch(error => {
+                console.error(error);
+                process.exit();
+            });
+        }).catch(error => {
+            console.error(error);
+            process.exit();
+        });
+    }
+});
+export {};

package/dist/scripts/resetAllEndorsementsForGroup.js

@@ -0,0 +1,57 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var groupId = process.argv[2];
+const deletePostEndorsements = (postId, callback) => {
+    models.Endorsement.findAll({
+        attributes: ['id', 'post_id', 'deleted', 'value'],
+        where: {
+            post_id: postId
+        },
+        include: [
+            {
+                model: models.Post,
+                attributes: ['id', 'counter_endorsements_up', 'counter_endorsements_down']
+            }
+        ]
+    }).then(function (endorsements) {
+        async.forEach(endorsements, function (endorsement, forEachCallback) {
+            endorsement.deleted = true;
+            endorsement.save().then(function () {
+                forEachCallback();
+            }).catch((error) => {
+                forEachCallback(error);
+            });
+        }, function (error) {
+            if (error) {
+                callback(error);
+            }
+            else {
+                console.log('User Endorsements Deleted', { context: 'ac-delete', postId: postId });
+                callback();
+            }
+        });
+    }).catch((error) => {
+        callback(error);
+    });
+};
+models.Post.findAll({
+    where: {
+        group_id: groupId
+    }
+}).then(function (posts) {
+    async.forEach(posts, (post, forEachCallback) => {
+        post.counter_endorsements_up = 0;
+        post.counter_endorsements_down = 0;
+        post.save().then(() => {
+            deletePostEndorsements(post.id, forEachCallback);
+        });
+    }, (error) => {
+        if (error) {
+            console.error(error);
+        }
+        console.log("Completed reset of endorsements for group: " + groupId);
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/resetEnTranslationForGroup.js

@@ -0,0 +1,45 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var groupId = process.argv[2];
+models.Post.findAll({
+    where: {
+        group_id: groupId,
+        language: {
+            $in: ['en', 'sv']
+        }
+    }
+}).then(function (posts) {
+    async.forEachSeries(posts, (post, callback) => {
+        post.language = null;
+        post.save().then(() => {
+            console.log("Saving post id: " + post.id);
+            callback();
+        });
+    }, (error) => {
+        if (error) {
+            console.error(error);
+        }
+        else {
+            models.Point.findAll({
+                where: {
+                    group_id: groupId,
+                    language: 'en'
+                }
+            }).then(function (points) {
+                async.forEachSeries(points, (point, callback) => {
+                    point.language = null;
+                    point.save().then(() => {
+                        console.log("Saving point id: " + point.id);
+                        callback();
+                    });
+                }, (error) => {
+                    if (error)
+                        console.error(error);
+                    console.log("Done");
+                    process.exit();
+                });
+            });
+        }
+    });
+});
+export {};

package/dist/scripts/setAdminOnAll.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var models = require('../models/index.cjs');
+var async = require('async');
+var userEmail = process.argv[2];
+var user;
+console.log("Adding " + userEmail + " as admin to all public communities and groups + domains");
+async.series([
+    function (callback) {
+        models.User.findOne({ where: { email: userEmail } }).then(function (incomingUser) {
+            if (incomingUser) {
+                user = incomingUser;
+                console.log("Found user " + user.name);
+                callback();
+            }
+            else {
+                console.log("Can't find user");
+            }
+        });
+    },
+    function (callback) {
+        models.Domain.findAll({
+            attributes: ['id', 'name']
+        }).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasDomainAdmins(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for: " + model.name);
+                        model.addDomainAdmins(user).then(seriesCallback);
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Organization.findAll({}).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasOrganizationAdmins(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for: " + model.name);
+                        model.addOrganizationAdmins(user).then(seriesCallback);
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Community.findAll({
+            attributes: ['id', 'name']
+        }).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasCommunityAdmins(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for community: " + model.name);
+                        model.addCommunityAdmins(user).then(function () {
+                            console.log("Im back");
+                            seriesCallback();
+                        });
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Group.findAll({
+            attributes: ['id', 'name']
+        }).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasGroupAdmins(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for group: " + model.name);
+                        model.addGroupAdmins(user).then(function () {
+                            console.log("Im back");
+                            seriesCallback();
+                        });
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    }
+], function (error) {
+    console.log("Finished");
+    process.exit();
+});

package/{scripts/change → dist/scripts}/setDomainAdmin.cjs

@@ -1,8 +1,6 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 var models = require('../models/index.cjs');
 var async = require('async');
-var ip = require('ip');
 var userEmail = process.argv[2];
 var domainId = process.argv[3];
 var user;

package/dist/scripts/setDomainLocales.js

@@ -0,0 +1,33 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+console.log("Setting up locales");
+async.series([
+    function (callback) {
+        models.Domain.findOne({ where: { domain_name: 'betrireykjavik.is' } }).then(function (domain) {
+            domain.default_locale = 'is';
+            domain.save().then(function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Domain.findOne({ where: { domain_name: 'betraisland.is' } }).then(function (domain) {
+            domain.default_locale = 'is';
+            domain.save().then(function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Domain.findOne({ where: { domain_name: 'yrpri.org' } }).then(function (domain) {
+            domain.default_locale = 'en';
+            domain.save().then(function () {
+                callback();
+            });
+        });
+    }
+], function (error) {
+    console.log("Finished");
+    process.exit();
+});
+export {};

package/dist/scripts/setEarlQuestionIdOnGroup.cjs

@@ -0,0 +1,29 @@
+"use strict";
+var models = require("../models/index.cjs");
+var questionId = process.argv[2];
+var groupId = process.argv[3];
+console.log("Adding pariwise question id " + questionId + " to group " + groupId);
+models.Group.findOne({
+    where: {
+        id: groupId,
+    },
+})
+    .then((group) => {
+    if (group.configuration.allOurIdeas &&
+        group.configuration.allOurIdeas.earl) {
+        group.set("configuration.allOurIdeas.earl.question_id", questionId);
+        group.set("configuration.allOurIdeas.earl.question.id", questionId);
+        group.save().then(() => {
+            console.log("Finished");
+            process.exit();
+        });
+    }
+    else {
+        console.log("Group does not have allOurIdeas configuration");
+        process.exit();
+    }
+})
+    .catch((error) => {
+    console.log("Error: ", error);
+    process.exit();
+});

package/dist/scripts/setLanguageOnGroupCommunitesFromUrl.js

@@ -0,0 +1,86 @@
+const models = require('../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+/*
+const urlToConfig = "https://yrpri-eu-direct-assets.s3-eu-west-1.amazonaws.com/WB_ResetLanguageOnCommuntiesList_16_02_21.csv"//process.argv[1];
+const toLanguage = "ru"; // process.argv[2];
+const urlToAddAddFront = "https://kyrgyz-aris.yrpri.org/"; // process.argv[3];
+*/
+const urlToConfig = process.argv[2];
+const toLanguage = process.argv[3];
+const urlToAddAddFront = process.argv[4];
+let config;
+let finalTargetOutput = '';
+const setLanguageOnGroupCommunties = (communityId, done) => {
+    models.Community.findOne({
+        where: {
+            id: communityId
+        },
+        include: [
+            {
+                model: models.Group,
+            }
+        ]
+    }).then(community => {
+        async.forEach(community.Groups, (group, forEachCallback) => {
+            if (group.language !== toLanguage) {
+                group.set('language', toLanguage);
+                group.save().then(() => {
+                    finalTargetOutput += urlToAddAddFront + "group/" + group.id + "\n";
+                    forEachCallback();
+                }).catch(error => {
+                    forEachCallback(error);
+                });
+            }
+            else {
+                forEachCallback();
+            }
+        }, error => {
+            done(error);
+        });
+    }).catch(error => {
+        done(error);
+    });
+};
+async.series([
+    (seriesCallback) => {
+        const options = {
+            url: urlToConfig,
+        };
+        request.get(options, (error, content) => {
+            if (content && content.statusCode != 200) {
+                seriesCallback(content.statusCode);
+            }
+            else if (content) {
+                config = content.body;
+                seriesCallback();
+            }
+            else {
+                seriesCallback("No content");
+            }
+        });
+    },
+    (seriesCallback) => {
+        async.forEachSeries(config.split('\r\n'), (configLine, forEachCallback) => {
+            const splitLine = configLine.split(",");
+            if (!configLine || configLine.length < 3 || !splitLine || splitLine.length !== 1) {
+                forEachCallback();
+            }
+            else {
+                const communityId = splitLine[0];
+                setLanguageOnGroupCommunties(communityId, forEachCallback);
+            }
+        }, error => {
+            seriesCallback();
+        });
+    },
+], error => {
+    if (error)
+        console.error(error);
+    console.log("All done set to " + toLanguage);
+    console.log(finalTargetOutput);
+    process.exit();
+});
+export {};

package/dist/scripts/setMemberOfAll.js

@@ -0,0 +1,101 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var userEmail = process.argv[2];
+var user;
+console.log("Adding " + userEmail + " as admin to all public communities and groups + domains");
+async.series([
+    function (callback) {
+        models.User.findOne({ where: { email: userEmail } }).then(function (incomingUser) {
+            if (incomingUser) {
+                user = incomingUser;
+                console.log("Found user " + user.name);
+                callback();
+            }
+            else {
+                console.log("Can't find user");
+            }
+        });
+    },
+    function (callback) {
+        models.Domain.findAll({}).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasDomainUsers(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for: " + model.name);
+                        model.addDomainUsers(user).then(seriesCallback);
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Organization.findAll({}).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasOrganizationUsers(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for: " + model.name);
+                        model.addOrganizationUsers(user).then(seriesCallback);
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Community.findAll({}).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasCommunityUsers(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for community: " + model.name);
+                        model.addCommunityUsers(user).then(function () {
+                            console.log("Im back");
+                            seriesCallback();
+                        });
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    },
+    function (callback) {
+        models.Group.findAll({}).then(function (models) {
+            async.eachSeries(models, function (model, seriesCallback) {
+                model.hasGroupUsers(user).then(function (results) {
+                    if (!results) {
+                        console.log("Adding admin user for group: " + model.name);
+                        model.addGroupUsers(user).then(function () {
+                            console.log("Im back");
+                            seriesCallback();
+                        });
+                    }
+                    else {
+                        console.log("Already admin for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    }
+], function (error) {
+    console.log("Finished");
+    process.exit();
+});
+export {};