@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/exportUserEndorsementsWithUserAnalysis.js

@@ -0,0 +1,123 @@
+const models = require('../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const groupId = process.argv[2];
+const outFile = process.argv[3];
+let registrationQuestions;
+const getAnswerFor = (text, answers) => {
+    for (let i = 0; i < answers.length; i++) {
+        if (Object.keys(answers[i])[0] == text)
+            return Object.values(answers[i])[0];
+    }
+    return '';
+};
+models.Group.findOne({
+    where: {
+        id: groupId
+    }
+}).then(group => {
+    if (group.configuration.registrationQuestionsJson) {
+        registrationQuestions = group.configuration.registrationQuestionsJson;
+    }
+    models.Endorsement.findAll({
+        order: [
+            ['created_at', 'asc']
+        ],
+        attributes: ['id', 'value', 'created_at', 'user_id', 'ip_address', 'user_agent'],
+        include: [
+            {
+                model: models.User,
+                attributes: ['id', 'email', 'private_profile_data']
+            },
+            {
+                model: models.Post,
+                attributes: ['id', 'name'],
+                include: [
+                    {
+                        model: models.Category,
+                        attributes: ['id', 'name'],
+                        required: false
+                    },
+                    {
+                        model: models.Group,
+                        attributes: ['id'],
+                        where: {
+                            id: groupId
+                        }
+                    }
+                ]
+            }
+        ]
+    }).then(function (endorsements) {
+        var outFileContent = "";
+        console.log(endorsements.length);
+        outFileContent += "Post endorsements for Group Id: " + groupId + "\n";
+        outFileContent += "Post Id,Post Name,Value,Category Id,Category Name,User Id";
+        if (registrationQuestions) {
+            for (let i = 0; i < registrationQuestions.length; i++) {
+                if (registrationQuestions[i].type !== "segment" && registrationQuestions[i].type !== "textDescription") {
+                    outFileContent += "," + registrationQuestions[i].text;
+                }
+            }
+        }
+        outFileContent += ",IP Address,User Agent";
+        outFileContent += "\n";
+        let notValidCounter = 0;
+        let notValidUserCounter = 0;
+        let nullValueCounter = 0;
+        const notValidUsers = {};
+        const validUsers = {};
+        let validUsersCount = 0;
+        async.eachSeries(endorsements, (endorsement, seriesCallback) => {
+            if (endorsement.User.private_profile_data && endorsement.User.private_profile_data.registration_answers) {
+                if (endorsement.value !== 0) {
+                    outFileContent += endorsement.Post.id;
+                    outFileContent += ',"' + endorsement.Post.name + '"';
+                    outFileContent += ',' + endorsement.value;
+                    outFileContent += ',' + (endorsement.Post.Category ? endorsement.Post.Category.id : '');
+                    outFileContent += ',"' + (endorsement.Post.Category ? endorsement.Post.Category.name : '') + '"';
+                    outFileContent += ',' + endorsement.user_id;
+                    const answers = endorsement.User.private_profile_data.registration_answers;
+                    for (let i = 0; i < registrationQuestions.length; i++) {
+                        if (registrationQuestions[i].type !== "segment" && registrationQuestions[i].type !== "textDescription") {
+                            outFileContent += "," + getAnswerFor(registrationQuestions[i].text, answers);
+                        }
+                    }
+                    outFileContent += ',' + endorsement.ip_address;
+                    outFileContent += ',"' + endorsement.user_agent + '"';
+                    outFileContent += '\n';
+                }
+                else {
+                    nullValueCounter += 1;
+                }
+                if (!validUsers[endorsement.user_id]) {
+                    validUsersCount += 1;
+                    validUsers[endorsement.user_id] = true;
+                }
+            }
+            else {
+                notValidCounter += 1;
+                if (!notValidUsers[endorsement.user_id]) {
+                    notValidUserCounter += 1;
+                    notValidUsers[endorsement.user_id] = true;
+                }
+            }
+            seriesCallback();
+        }, function (error) {
+            fs.writeFile(outFile, outFileContent, function (err) {
+                if (err) {
+                    console.log(err);
+                }
+                console.log("The file was saved!");
+                console.log(`${notValidCounter} not valid entries ${notValidUserCounter} not valid users ${nullValueCounter} 0 values`);
+                console.log(`${validUsersCount} valid users`);
+                process.exit();
+            });
+        });
+    });
+}).catch(error => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/scripts/exportUsersForCommunity.js

@@ -0,0 +1,24 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var communityId = process.argv[2];
+models.Community.findOne({
+    where: {
+        id: communityId
+    },
+    include: [
+        {
+            model: models.User,
+            as: 'CommunityUsers'
+        }
+    ]
+}).then(function (community) {
+    console.log(community.CommunityUsers.length);
+    console.log("email, Name");
+    async.eachSeries(community.CommunityUsers, function (user, seriesCallback) {
+        console.log('"' + user.email + '","' + user.name + '"');
+        seriesCallback();
+    }, function () {
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/exportUsersForDomain.js

@@ -0,0 +1,24 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var domainId = process.argv[2];
+models.Domain.findOne({
+    where: {
+        id: domainId
+    },
+    include: [
+        {
+            model: models.User,
+            as: 'DomainUsers'
+        }
+    ]
+}).then(function (domain) {
+    console.log(domain.DomainUsers.length);
+    console.log("email,name,kt");
+    async.eachSeries(domain.DomainUsers, function (user, seriesCallback) {
+        console.log('"' + user.email + '","' + user.name + '"' + (user.ssn ? ',' + user.ssn : ''));
+        seriesCallback();
+    }, function () {
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/exportUsersForGroup.js

@@ -0,0 +1,24 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var groupId = process.argv[2];
+models.Group.findOne({
+    where: {
+        id: groupId
+    },
+    include: [
+        {
+            model: models.User,
+            as: 'GroupUsers'
+        }
+    ]
+}).then(function (group) {
+    console.log(group.GroupUsers.length);
+    console.log("email, Name");
+    async.eachSeries(group.GroupUsers, function (user, seriesCallback) {
+        console.log('"' + user.email + '","' + user.name + '"');
+        seriesCallback();
+    }, function () {
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/exports/ratingDistribution.js

@@ -0,0 +1,71 @@
+var models = require('../../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var moment = require('moment');
+var communityId = process.argv[2];
+const ratingCount = {
+    0: 0,
+    1: 0,
+    2: 0,
+    3: 0,
+    4: 0
+};
+var size = function (obj) {
+    var size = 0, key;
+    for (key in obj) {
+        if (obj.hasOwnProperty(key))
+            size++;
+    }
+    return size;
+};
+const countRatings = (rateValueMin, notMoreThan, ratings) => {
+    let count = 0;
+    for (let i = 0; i < ratings.length; i++) {
+        if (ratings[i].value >= rateValueMin && ratings[i].value < notMoreThan) {
+            count += 1;
+        }
+    }
+    return count;
+};
+models.Rating.findAll({
+    attributes: ["id", "user_id", "type_index", "value"],
+    where: {
+        value: {
+            [models.Sequelize.Op.not]: 0
+        }
+    },
+    include: [
+        {
+            model: models.User,
+            attributes: ['id', 'ssn', 'name', 'email']
+        },
+        {
+            model: models.Post,
+            attributes: ["id", "name"],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ["id", 'name'],
+                    include: [
+                        {
+                            model: models.Community,
+                            attributes: ["id", "name"],
+                            where: {
+                                id: communityId
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}).then((ratings) => {
+    console.log(`"Vote distribution report for ${ratings[0].Post.Group.Community.name}"`);
+    console.log(`"Rating value","Vote count"`);
+    console.log(`"1+",${countRatings(1, 2, ratings)}`);
+    console.log(`"2+",${countRatings(2, 3, ratings)}`);
+    console.log(`"3+",${countRatings(3, 4, ratings)}`);
+    console.log(`"4+",${countRatings(4, 5, ratings)}`);
+    process.exit();
+});
+export {};

package/dist/scripts/exports/whoEndorsedWhatByCommunity.js

@@ -0,0 +1,56 @@
+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', 'email']
+        },
+        {
+            model: models.Post,
+            attributes: ["id", "name"],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ["id", 'name'],
+                    include: [
+                        {
+                            model: models.Community,
+                            attributes: ["id"],
+                            where: {
+                                id: communityId
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}).then((endorsements) => {
+    console.log(`"Up / Down","Email","Name","Post Id","Post name","Group name"\n`);
+    for (let i = 0; i < endorsements.length; i++) {
+        const e = endorsements[i];
+        console.log(`${e.value},"${e.User.email}","${e.User.name}","${e.Post.id}","${e.Post.name}","${e.Post.Group.name}"`);
+    }
+    process.exit();
+});
+export {};

package/dist/scripts/findUnusedClientImports.js

@@ -0,0 +1,56 @@
+var path = require('path');
+var fs = require('fs');
+var _ = require('lodash');
+const readline = require('readline');
+var walkSync = function (dir, filelist) {
+    var files = fs.readdirSync(dir);
+    filelist = filelist || [];
+    files.forEach(function (file) {
+        if (fs.statSync(path.join(dir, file)).isDirectory()) {
+            filelist = walkSync(path.join(dir, file), filelist);
+        }
+        else {
+            if (file.endsWith((".html"))) {
+                if (!(dir.indexOf("test") > -1) && !(dir.indexOf("demo") > -1) && !(file.indexOf('-container-') > -1)) {
+                    filelist.push(path.join(dir, file));
+                }
+                else {
+                    //console.error("SKIP: "+ dir);
+                }
+            }
+        }
+    });
+    return filelist;
+};
+var checkFile = function (filePath) {
+    var lines = fs.readFileSync(filePath, 'utf-8')
+        .split('\n')
+        .filter(Boolean);
+    var importLines = _.reject(lines, function (line) {
+        return !line.endsWith('.html">') || line.indexOf("iron-flex-layout") > -1 ||
+            line.indexOf("behavior") > -1 || line.indexOf("/polymer.html") > -1 ||
+            line.indexOf("yp-app-icons") > -1 || line.indexOf("app-helpers") > -1;
+    });
+    var importedElements = _.map(importLines, function (importLine) {
+        var last = importLine.split("/").pop();
+        last = last.replace('.html">', '');
+        last = last.replace('<link rel="import" href="', '');
+        return { import: importLine, element: "<" + last };
+    });
+    _.forEach(importedElements, function (elementObject) {
+        var found = false;
+        _.forEach(lines, function (line) {
+            if (line.indexOf(elementObject.element) > -1) {
+                found = true;
+            }
+        });
+        if (!found) {
+            console.error(filePath + ": " + elementObject.element + ">");
+        }
+    });
+};
+var dir = "/home/robert/Projects/production-your-priorities-app/client_app/src";
+_.forEach(walkSync(dir), function (filePath) {
+    checkFile(filePath);
+});
+export {};

package/dist/scripts/fixAllPostPointCounts.js

@@ -0,0 +1,22 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var postsCount = 0;
+models.Post.findAll({}).then(function (posts) {
+    async.eachSeries(posts, function (post, callback) {
+        postsCount += 1;
+        models.Point.count({
+            where: {
+                post_id: post.id
+            }
+        }).then(function (count) {
+            post.set('counter_points', count);
+            post.save().then(function (results) {
+                callback();
+            });
+        });
+    }, function (error) {
+        console.log("Done updating posts: " + postsCount);
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/fixAnonNotificationsSettings.js

@@ -0,0 +1,48 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+let groupChangeCount = 0;
+let communityChangeCount = 0;
+models.User.findAll({
+    where: {
+        profile_data: { isAnonymousUser: true }
+    },
+    attributes: ['id', 'email', 'notifications_settings']
+}).then(users => {
+    async.forEachSeries(users, (user, callback) => {
+        let changed = false;
+        if (user.notifications_settings &&
+            user.notifications_settings.all_group &&
+            user.notifications_settings.all_group.method != 0) {
+            user.set('notifications_settings.all_group.method', 0);
+            groupChangeCount++;
+            changed = true;
+        }
+        if (user.notifications_settings &&
+            user.notifications_settings.all_community &&
+            user.notifications_settings.all_community.method != 0) {
+            user.set('notifications_settings.all_community.method', 0);
+            changed = true;
+            communityChangeCount++;
+        }
+        if (changed) {
+            user.save().then(() => {
+                console.log(`Saved ${user.email}`);
+                callback();
+            }).catch((error) => {
+                callback(error);
+            });
+        }
+        else {
+            callback();
+        }
+    }, (error) => {
+        if (error)
+            console.error(error);
+        console.log(`groupChangeCount ${groupChangeCount}`);
+        console.log(`communityChangeCount ${communityChangeCount}`);
+        process.exit();
+    });
+}).catch(error => {
+    console.error(error);
+});
+export {};

package/dist/scripts/fixCountKopavogur.js

@@ -0,0 +1,9 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+models.Group.findOne({ where: { id: 752 } }).then(function (group) {
+    group.counter_points = 0;
+    group.save().then(function () {
+        console.log("log");
+    });
+});
+export {};

package/dist/scripts/fixEndorsementsAfterCopyPostToGroup.js

@@ -0,0 +1,190 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var csvParser = require('csv-parse');
+var fs = require('fs');
+var onePostId = process.argv[2];
+var toGroupId = process.argv[3];
+var csvFileName = process.argv[4];
+var userIdToPostNewsStory = process.argv[5];
+var getDataFromUrl = function (url, done) {
+    var https = require('https');
+    var results = "";
+    var req = https.request(url, function (res) {
+        res.on('data', function (data) {
+            results += data.toString();
+        });
+        res.on('end', function (d) {
+            done(results);
+        });
+    });
+    req.end();
+};
+var fixOnePost = function (groupId, postId, done) {
+    var group, post, domainId, communityId;
+    var domain;
+    var newPost;
+    var oldPost;
+    var skipPointActivitiesIdsForPostCopy = [];
+    async.series([
+        function (callback) {
+            models.Group.findOne({
+                where: {
+                    id: groupId
+                },
+                include: [
+                    {
+                        model: models.Community,
+                        required: true,
+                        include: [
+                            {
+                                model: models.Domain,
+                                required: true
+                            }
+                        ]
+                    }
+                ]
+            }).then(function (groupIn) {
+                group = groupIn;
+                communityId = group.Community.id;
+                domainId = group.Community.Domain.id;
+                domain = group.Community.Domain;
+                callback();
+            }).catch(function (error) {
+                callback(error);
+            });
+        },
+        function (callback) {
+            models.Post.findOne({
+                where: {
+                    id: postId
+                },
+                order: [
+                    [{ model: models.Image, as: 'PostHeaderImages' }, 'updated_at', 'desc']
+                ],
+                include: [
+                    {
+                        model: models.Image,
+                        as: 'PostHeaderImages',
+                        required: false
+                    },
+                    {
+                        model: models.Image,
+                        as: 'PostUserImages',
+                        required: false
+                    }
+                ]
+            }).then(function (postIn) {
+                oldPost = postIn;
+                if (!postIn) {
+                    console.error("No post in");
+                    callback("no post");
+                }
+                else {
+                    models.Post.findOne({
+                        where: {
+                            user_id: oldPost.user_id,
+                            name: oldPost.name,
+                            created_at: oldPost.created_at,
+                            id: {
+                                $ne: oldPost.id
+                            }
+                        }
+                    }).then(function (newPostIn) {
+                        newPost = newPostIn;
+                        if (newPost) {
+                            async.series([
+                                function (postSeriesCallback) {
+                                    models.Endorsement.findAll({
+                                        where: {
+                                            post_id: oldPost.id
+                                        }
+                                    }).then(function (endorsements) {
+                                        async.eachSeries(endorsements, function (endorsement, endorsementCallback) {
+                                            models.Endorsement.findOne({
+                                                where: {
+                                                    post_id: newPost.id,
+                                                    user_id: endorsement.user_id
+                                                }
+                                            }).then(function (alreadyUpdatedEndorsement) {
+                                                if (alreadyUpdatedEndorsement) {
+                                                    console.warn("Already updated endorsement");
+                                                    endorsementCallback();
+                                                }
+                                                else {
+                                                    var endorsementJson = JSON.parse(JSON.stringify(endorsement.toJSON()));
+                                                    delete endorsementJson.id;
+                                                    var endorsementModel = models.Endorsement.build(endorsementJson);
+                                                    endorsementModel.set('post_id', newPost.id);
+                                                    endorsementModel.save().then(function () {
+                                                        endorsementCallback();
+                                                    });
+                                                }
+                                            });
+                                        }, function (error) {
+                                            postSeriesCallback(error);
+                                        });
+                                    });
+                                }
+                            ], function (error) {
+                                console.log("Have fixed post to group id");
+                                callback(error);
+                            });
+                        }
+                        else {
+                            console.error("Did not find post");
+                            callback();
+                        }
+                    }).catch(function (error) {
+                        callback(error);
+                    });
+                }
+            });
+        }
+    ], function (error) {
+        console.log("Done");
+        if (error)
+            console.error(error);
+        done(error);
+    });
+};
+var parsePosts = function (allPosts, done) {
+    async.eachSeries(allPosts, function (post, seriesCallback) {
+        console.log("Post: " + post[0]);
+        fixOnePost(toGroupId, getPostIdFromUrl(post[6]), function (error) {
+            seriesCallback(error);
+        });
+    }, function (error) {
+        done(error);
+    });
+};
+var getPostIdFromUrl = function (url) {
+    var splitted = url.split('/');
+    return splitted[splitted.length - 1];
+};
+var copyManyFromCsv = function (csvUrl, done) {
+    getDataFromUrl(csvUrl, function (contents) {
+        csvParser(contents, {}, function (err, allPosts) {
+            parsePosts(allPosts, done);
+        });
+    });
+};
+if (onePostId != 'null') {
+    copyOnePost(toGroupId, onePostId, null, function (error) {
+        if (error)
+            console.error(error);
+        process.exit();
+    });
+}
+else if (csvFileName && userIdToPostNewsStory) {
+    copyManyFromCsv(csvFileName, function (error) {
+        if (error)
+            console.error(error);
+        process.exit();
+    });
+}
+else {
+    console.error("Invalid start state");
+    process.exit();
+}
+export {};

package/dist/scripts/fixExternalUserId.js

@@ -0,0 +1,24 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+models.User.findAll({
+    attributes: ['id', 'profile_data']
+}).then((users) => {
+    async.forEachSeries(users, (user, callback) => {
+        if (user.profile_data && user.profile_data.trackingParameters && user.profile_data.trackingParameters.externalUserID) {
+            user.set('profile_data.trackingParameters.externalUserId', user.profile_data.trackingParameters.externalUserID);
+            user.save().then(() => {
+                callback();
+            });
+        }
+        else {
+            callback();
+        }
+    }, (error) => {
+        console.log("Done");
+        if (error)
+            console.error(error);
+        process.exit();
+    });
+});
+export {};
+// profile_data.trackingParameters.externalUserId