@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/setNewUserForContentOfCommunity.js

@@ -0,0 +1,189 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+const communityId = process.argv[2];
+const newUserId = process.argv[3];
+let postsCount = 0;
+let postRevisionCount = 0;
+let pointsCount = 0;
+let pointRevisionCount = 0;
+if (newUserId && newUserId.length > 1) {
+    models.User.findOne({
+        where: {
+            id: newUserId
+        }
+    }).then(user => {
+        if (user) {
+            async.series([
+                (seriesCallback) => {
+                    models.Post.findAll({
+                        attributes: ['id', 'user_id'],
+                        include: [
+                            {
+                                model: models.Group,
+                                attributes: ['id'],
+                                required: true,
+                                include: [
+                                    {
+                                        model: models.Community,
+                                        attributes: ['id'],
+                                        where: {
+                                            id: communityId
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }).then(function (posts) {
+                        async.eachSeries(posts, function (post, callback) {
+                            postsCount++;
+                            post.set('user_id', newUserId);
+                            post.save().then(function (results) {
+                                callback();
+                            });
+                        }, function (error) {
+                            seriesCallback(error);
+                        });
+                    });
+                },
+                (seriesCallback) => {
+                    models.PostRevision.findAll({
+                        attributes: ['id', 'user_id'],
+                        include: [
+                            {
+                                model: models.Post,
+                                attributes: ['id'],
+                                include: [
+                                    {
+                                        model: models.Group,
+                                        attributes: ['id'],
+                                        required: true,
+                                        include: [
+                                            {
+                                                model: models.Community,
+                                                attributes: ['id'],
+                                                where: {
+                                                    id: communityId
+                                                }
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }).then(function (postRevisions) {
+                        async.eachSeries(postRevisions, function (postRevision, callback) {
+                            postRevisionCount++;
+                            postRevision.set('user_id', newUserId);
+                            postRevision.save().then(function (results) {
+                                callback();
+                            });
+                        }, function (error) {
+                            seriesCallback(error);
+                        });
+                    });
+                },
+                (seriesCallback) => {
+                    models.Point.findAll({
+                        attributes: ['id', 'user_id'],
+                        include: [
+                            {
+                                model: models.Post,
+                                attributes: ['id'],
+                                include: [
+                                    {
+                                        model: models.Group,
+                                        attributes: ['id'],
+                                        required: true,
+                                        include: [
+                                            {
+                                                model: models.Community,
+                                                attributes: ['id'],
+                                                where: {
+                                                    id: communityId
+                                                }
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }).then(function (points) {
+                        async.eachSeries(points, function (point, callback) {
+                            pointsCount++;
+                            point.set('user_id', newUserId);
+                            point.save().then(function (results) {
+                                callback();
+                            });
+                        }, function (error) {
+                            seriesCallback(error);
+                        });
+                    });
+                },
+                (seriesCallback) => {
+                    models.PointRevision.findAll({
+                        attributes: ['id', 'user_id'],
+                        include: [
+                            {
+                                model: models.Point,
+                                attributes: ['id'],
+                                include: [
+                                    {
+                                        model: models.Post,
+                                        attributes: ['id'],
+                                        include: [
+                                            {
+                                                model: models.Group,
+                                                attributes: ['id'],
+                                                required: true,
+                                                include: [
+                                                    {
+                                                        model: models.Community,
+                                                        attributes: ['id'],
+                                                        where: {
+                                                            id: communityId
+                                                        }
+                                                    }
+                                                ]
+                                            }
+                                        ]
+                                    }
+                                ]
+                            }
+                        ]
+                    }).then(function (pointRevisions) {
+                        async.eachSeries(pointRevisions, function (pointRevision, callback) {
+                            pointRevisionCount++;
+                            pointRevision.set('user_id', newUserId);
+                            pointRevision.save().then(function (results) {
+                                callback();
+                            });
+                        }, function (error) {
+                            seriesCallback(error);
+                        });
+                    });
+                }
+            ], (error) => {
+                if (error)
+                    console.error(error);
+                console.log("Done updating owners");
+                console.log("Posts: " + postsCount);
+                console.log("PostRevisions: " + postRevisionCount);
+                console.log("Points: " + pointsCount);
+                console.log("PointRevisions: " + pointRevisionCount);
+                process.exit();
+            });
+        }
+        else {
+            console.error("User not found");
+            process.exit();
+        }
+    }).catch(error => {
+        console.error(error);
+        process.exit();
+    });
+}
+else {
+    console.error("No new user id provided");
+    process.exit();
+}
+export {};

package/dist/scripts/setOfficialStatusOnAllPostsForCommunity.js

@@ -0,0 +1,35 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+const communityId = process.argv[2];
+const newOfficialStatus = parseInt(process.argv[3]);
+var postsCount = 0;
+models.Post.findAll({
+    attributes: ['id', 'official_status'],
+    include: [
+        {
+            model: models.Group,
+            attributes: ['id'],
+            required: true,
+            include: [
+                {
+                    model: models.Community,
+                    where: {
+                        id: communityId
+                    }
+                }
+            ]
+        }
+    ]
+}).then(function (posts) {
+    async.eachSeries(posts, function (post, callback) {
+        postsCount++;
+        post.set('official_status', newOfficialStatus);
+        post.save().then(function (results) {
+            callback();
+        });
+    }, function (error) {
+        console.log("Done updating official status for posts: " + postsCount);
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/setUserOnAll.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 + " 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 users user for: " + model.name);
+                        model.addDomainUsers(user).then(seriesCallback);
+                    }
+                    else {
+                        console.log("Already users 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 users user for: " + model.name);
+                        model.addOrganizationUsers(user).then(seriesCallback);
+                    }
+                    else {
+                        console.log("Already users 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 users user for community: " + model.name);
+                        model.addCommunityUsers(user).then(function () {
+                            console.log("Im back");
+                            seriesCallback();
+                        });
+                    }
+                    else {
+                        console.log("Already users 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 users user for group: " + model.name);
+                        model.addGroupUsers(user).then(function () {
+                            console.log("Im back");
+                            seriesCallback();
+                        });
+                    }
+                    else {
+                        console.log("Already users for for: " + model.name);
+                        seriesCallback();
+                    }
+                });
+            }, function () {
+                callback();
+            });
+        });
+    }
+], function (error) {
+    console.log("Finished");
+    process.exit();
+});
+export {};

package/dist/scripts/showCategoryForGroup.js

@@ -0,0 +1,18 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var groupId = process.argv[2];
+var _ = require('lodash');
+models.Category.findAll({
+    where: {
+        group_id: groupId
+    }
+}).then(function (categories) {
+    var json = "{ ";
+    _.forEach(categories, function (category) {
+        json += '"' + category.name + '":' + category.id + ', \n';
+    });
+    json += "}";
+    console.log(json.toLowerCase());
+    process.exit();
+});
+export {};

package/dist/scripts/showOldActivityTypes.js

@@ -0,0 +1,14 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var allActivities = {};
+models.AcActivity.findAll({ attributes: [[models.Sequelize.literal("DISTINCT 'type'"), 'type'], 'type'] }).then(function (activityTypes) {
+    console.log(activityTypes.length);
+    async.eachSeries(activityTypes, function (activityType, callback) {
+        console.log(activityType.type);
+        allActivities[activityType.type] = activityType.type;
+        callback();
+    }, function done() {
+        console.log(allActivities);
+    });
+});
+export {};

package/dist/scripts/showPostsMissingCategoryForGroup.js

@@ -0,0 +1,17 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var groupId = process.argv[2];
+models.Post.findAll({
+    where: {
+        group_id: groupId,
+        category_id: null
+    }
+}).then(function (posts) {
+    console.log("Found " + posts.length + " post without category");
+    _.each(posts, function (post) {
+        console.log(post.id);
+    });
+    process.exit();
+});
+export {};

package/dist/scripts/showStatuses.js

@@ -0,0 +1,17 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+models.Post.findAll().then(function (posts) {
+    async.eachSeries(posts, function (post, callback) {
+        if (post.official_status != 0) {
+            console.log(post.official_status);
+            console.log(post.group_id);
+        }
+        if (post.status != 'published') {
+            console.log(post.status);
+        }
+        callback();
+    }, function done() {
+        console.log("DONE");
+    });
+});
+export {};

package/dist/scripts/showUniqueVotersInCommunity.js

@@ -0,0 +1,61 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var moment = require('moment');
+var communityId = process.argv[2];
+const allUsers = {};
+const uniqueSsns = [];
+var size = function (obj) {
+    var size = 0, key;
+    for (key in obj) {
+        if (obj.hasOwnProperty(key))
+            size++;
+    }
+    return size;
+};
+models.Endorsement.findAll({
+    attributes: ["id", "user_id", "value"],
+    where: {
+        value: {
+            [models.Sequelize.Op.not]: 0
+        }
+    },
+    include: [
+        {
+            model: models.User,
+            attributes: ['id', 'ssn', 'name']
+        },
+        {
+            model: models.Post,
+            attributes: ["id", "name"],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ["id"],
+                    include: [
+                        {
+                            model: models.Community,
+                            attributes: ["id"],
+                            where: {
+                                id: communityId
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}).then((endorsements) => {
+    console.log(`Votes: ${endorsements.length}`);
+    endorsements.forEach(e => {
+        if (!allUsers[e.User.ssn]) {
+            allUsers[e.User.ssn] = 1;
+            uniqueSsns.push(e.User.ssn);
+            console.log(`${e.User.ssn} - ${e.User.name}`);
+        }
+    });
+    console.log(`Voters: ${size(allUsers)}`);
+    console.log(`Average votes per user: ${parseInt(endorsements.length / size(allUsers))}`);
+    process.exit();
+});
+export {};

package/dist/scripts/showUserAgentsAndIpsForEmails.js

@@ -0,0 +1,66 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+emails = [];
+async.eachSeries(emails, (email, eachOfCallback) => {
+    models.User.findOne({
+        where: {
+            email: email
+        }
+    }).then((user) => {
+        if (user) {
+            console.log("\n\n\nemail: " + user.email) + "\n";
+            let userAgent = null;
+            let ipAddress = null;
+            async.series([
+                (seriesCallback) => {
+                    models.Endorsement.findOne({
+                        where: {
+                            user_id: user.id
+                        }
+                    }).then((endorsement) => {
+                        if (endorsement) {
+                            ipAddress = endorsement.ip_address;
+                            userAgent = endorsement.user_agent;
+                        }
+                        seriesCallback();
+                    });
+                },
+                (seriesCallback) => {
+                    models.Point.findOne({
+                        where: {
+                            user_id: user.id
+                        }
+                    }).then((point) => {
+                        if (point) {
+                            ipAddress = point.ip_address;
+                            userAgent = point.user_agent;
+                        }
+                        seriesCallback();
+                    });
+                },
+                (seriesCallback) => {
+                    models.Post.findOne({
+                        where: {
+                            user_id: user.id
+                        }
+                    }).then((post) => {
+                        if (post) {
+                            ipAddress = post.ip_address;
+                            userAgent = post.user_agent;
+                        }
+                        seriesCallback();
+                    });
+                },
+            ], (error) => {
+                console.log(ipAddress);
+                console.log(userAgent);
+                eachOfCallback();
+            });
+        }
+        else {
+            console.error("NOT FOUND: " + email);
+            eachOfCallback();
+        }
+    });
+});
+export {};

package/dist/scripts/simpleExportForGroupsForCommunity.js

@@ -0,0 +1,46 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var fs = require('fs');
+var communityId = process.argv[2];
+var outFile = process.argv[3];
+var clean = function (text) {
+    //console.log("Before: "+ text);
+    var newText = text.replace('"', "'").replace('\n', '').replace('\r', '').replace(/(\r\n|\n|\r)/gm, "").replace(/"/gm, "'").replace(',', ';').trim();
+    //console.log("After:" + newText);
+    return newText.replace(/´/g, '');
+};
+models.Group.findAll({
+    order: [
+        ['created_at', 'asc']
+    ],
+    include: [
+        {
+            model: models.Community,
+            where: {
+                id: communityId
+            }
+        }
+    ]
+}).then(function (groups) {
+    var outFileContent = "";
+    console.log(groups.length);
+    outFileContent += "group id, author id, title, text\n";
+    groupCounter = 0;
+    async.eachSeries(groups, function (group, seriesCallback) {
+        groupCounter += 1;
+        if (!group.deleted) {
+            outFileContent += group.id + ',"' + group.user_id + '","' + clean(group.name) + '","' + clean(group.objectives) + '"\n';
+        }
+        seriesCallback();
+    }, function (error) {
+        fs.writeFile(outFile, outFileContent, function (err) {
+            if (err) {
+                console.log(err);
+            }
+            console.log("The file was saved!");
+            process.exit();
+        });
+    });
+});
+export {};

package/dist/scripts/simpleExportForPointsForCommunity.js

@@ -0,0 +1,82 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var fs = require('fs');
+var communityId = process.argv[2];
+var outFile = process.argv[3];
+var clean = function (text) {
+    //console.log("Before: "+ text);
+    if (text) {
+        var newText = text.replace('"', "'").replace('\n', '').replace('\r', '').replace(/(\r\n|\n|\r)/gm, "").replace(/"/gm, "'").replace(',', ';').trim();
+        //console.log("After:" + newText);
+        return newText.replace(/´/g, '');
+    }
+    else {
+        return "empty";
+    }
+};
+var getPointType = function (value) {
+    if (value > 0) {
+        return "for";
+    }
+    else if (value < 0) {
+        return "against";
+    }
+    else {
+        return "comment/news";
+    }
+};
+models.Point.findAll({
+    order: [
+        ['created_at', 'asc']
+    ],
+    include: [
+        models.User,
+        {
+            model: models.Post,
+            include: [
+                {
+                    model: models.Group,
+                    include: [
+                        {
+                            model: models.Community,
+                            where: {
+                                id: communityId
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}).then(function (points) {
+    var outFileContent = "";
+    console.log(points.length);
+    outFileContent += "group id,post id,point id,point type,author id,text,helpful votes,unhelpful votes,external user id,state\n";
+    pointCounter = 0;
+    async.eachSeries(points, function (point, seriesCallback) {
+        pointCounter += 1;
+        if (!point.deleted) {
+            var externalUserId = '', state = '';
+            if (point.User.profile_data) {
+                if (point.User.profile_data.trackingParameters && point.User.profile_data.trackingParameters.externalUserId) {
+                    externalUserId = point.User.profile_data.trackingParameters.externalUserId;
+                }
+                if (point.User.profile_data.trackingParameters && point.User.profile_data.trackingParameters.state) {
+                    state = point.User.profile_data.trackingParameters.state;
+                }
+            }
+            outFileContent += point.Post.group_id + ',' + point.Post.id + ',"' + point.id + '","' + getPointType(point.value) + '","' + point.user_id + '","' + clean(point.content) + '",' + point.counter_quality_up + ',' + point.counter_quality_down + ',' + externalUserId + ',' + state + '\n';
+        }
+        seriesCallback();
+    }, function (error) {
+        fs.writeFile(outFile, outFileContent, function (err) {
+            if (err) {
+                console.log(err);
+            }
+            console.log("The file was saved!");
+            process.exit();
+        });
+    });
+});
+export {};