@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/countCommunityUsers.js

@@ -0,0 +1,152 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var communityId = process.argv[2];
+var allUserIds = [];
+var addToUsers = function (items) {
+    _.forEach(items, function (item) {
+        allUserIds.push(item.user_id);
+    });
+};
+async.parallel([
+    function (parallelCallback) {
+        models.Rating.findAll({
+            attributes: ['user_id'],
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            include: [
+                                {
+                                    model: models.Community,
+                                    where: {
+                                        id: communityId
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (withUserIds) {
+            addToUsers(withUserIds);
+        });
+    },
+    function (parallelCallback) {
+        models.Endorsement.findAll({
+            attributes: ['user_id'],
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            include: [
+                                {
+                                    model: models.Community,
+                                    where: {
+                                        id: communityId
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (withUserIds) {
+            addToUsers(withUserIds);
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.PointQuality.findAll({
+            attributes: ['user_id'],
+            include: [
+                {
+                    model: models.Point,
+                    include: [
+                        {
+                            model: models.Post,
+                            include: [
+                                {
+                                    model: models.Group,
+                                    include: [
+                                        {
+                                            model: models.Community,
+                                            where: {
+                                                id: communityId
+                                            }
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (withUserIds) {
+            addToUsers(withUserIds);
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Point.findAll({
+            attributes: ['user_id'],
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            include: [
+                                {
+                                    model: models.Community,
+                                    where: {
+                                        id: communityId
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (withUserIds) {
+            addToUsers(withUserIds);
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Post.findAll({
+            attributes: ['user_id'],
+            include: [
+                {
+                    model: models.Group,
+                    include: [
+                        {
+                            model: models.Community,
+                            where: {
+                                id: communityId
+                            }
+                        }
+                    ]
+                }
+            ]
+        }).then(function (withUserIds) {
+            addToUsers(withUserIds);
+            parallelCallback();
+        });
+    }
+], function (error) {
+    if (error) {
+        console.error(error);
+    }
+    else {
+        console.log("User action count: " + allUserIds.length);
+        console.log(allUserIds);
+        console.log("Community user count: " + _.uniq(allUserIds).length);
+    }
+    process.exit();
+});
+export {};

package/dist/scripts/countDelayedNotifications.js

@@ -0,0 +1,18 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+models.AcDelayedNotification.findAll({
+    include: [
+        {
+            model: models.AcActivity,
+            as: 'AcDelayedNotifications'
+        }
+    ]
+}).then(function (notifications) {
+    async.eachSeries(notifications, function (notification, seriesCallback) {
+        console.log("Notification: " + notification.id);
+        console.log("User id: " + notification.user_id);
+        console.log("Number of delayed notifications:" + notification.AcActivity.length);
+        seriesCallback();
+    });
+});
+export {};

package/dist/scripts/countGroup.js

@@ -0,0 +1,246 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var groupId = process.argv[2];
+var totalEndorsements;
+var endorsementsCount;
+var oppositionCount;
+var totalPointQualities;
+var pointsHelpful;
+var pointsUnhelpful;
+var totalPoints;
+var pointsAgainst;
+var pointsFor;
+async.parallel([
+    function (parallelCallback) {
+        models.Endorsement.count({
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            where: {
+                                id: groupId
+                            },
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            totalEndorsements = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Point.count({
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            where: {
+                                id: groupId
+                            },
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            totalPoints = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Point.count({
+            where: {
+                value: -1
+            },
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            where: {
+                                id: groupId
+                            },
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            pointsAgainst = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Point.count({
+            where: {
+                value: 1
+            },
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            where: {
+                                id: groupId
+                            },
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            pointsFor = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Endorsement.count({
+            where: {
+                value: 1
+            },
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            where: {
+                                id: groupId
+                            },
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            endorsementsCount = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.Endorsement.count({
+            where: {
+                value: -1
+            },
+            include: [
+                {
+                    model: models.Post,
+                    include: [
+                        {
+                            model: models.Group,
+                            where: {
+                                id: groupId
+                            },
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            oppositionCount = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.PointQuality.count({
+            include: [
+                {
+                    model: models.Point,
+                    include: [
+                        {
+                            model: models.Post,
+                            include: [
+                                {
+                                    model: models.Group,
+                                    where: {
+                                        id: groupId
+                                    },
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            totalPointQualities = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.PointQuality.count({
+            where: {
+                value: 1
+            },
+            include: [
+                {
+                    model: models.Point,
+                    include: [
+                        {
+                            model: models.Post,
+                            include: [
+                                {
+                                    model: models.Group,
+                                    where: {
+                                        id: groupId
+                                    },
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            pointsHelpful = count;
+            parallelCallback();
+        });
+    },
+    function (parallelCallback) {
+        models.PointQuality.count({
+            where: {
+                value: -1
+            },
+            include: [
+                {
+                    model: models.Point,
+                    include: [
+                        {
+                            model: models.Post,
+                            include: [
+                                {
+                                    model: models.Group,
+                                    where: {
+                                        id: groupId
+                                    },
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }).then(function (count) {
+            pointsUnhelpful = count;
+            parallelCallback();
+        });
+    }
+], function (error) {
+    if (error) {
+        console.error(error);
+    }
+    else {
+        console.log("Group id: " + groupId);
+        console.log("Total endorsements: " + totalEndorsements);
+        console.log("Endorsements: " + endorsementsCount);
+        console.log("Oppositions: " + oppositionCount);
+        console.log("Total point qualities: " + totalPointQualities);
+        console.log("Points helpful: " + pointsHelpful);
+        console.log("Points not helpful: " + pointsUnhelpful);
+        console.log("Points count: " + totalPoints);
+        console.log("Points for: " + pointsFor);
+        console.log("Points against: " + pointsAgainst);
+    }
+    process.exit();
+});
+export {};

package/dist/scripts/countStuff.js

@@ -0,0 +1,67 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var moment = require('moment');
+var allUsers = {};
+var size = function (obj) {
+    var size = 0, key;
+    for (key in obj) {
+        if (obj.hasOwnProperty(key))
+            size++;
+    }
+    return size;
+};
+models.Domain.findOne({ where: { id: 1 } }).then(function (domain) {
+    domain.getDomainUsers().then(function (users) {
+        console.log(users.length);
+        users.map(function (user) {
+            allUsers[user.email] = 1;
+        });
+        console.log(size(allUsers));
+    });
+});
+var grouped = {};
+models.Group.findAll({
+    where: {
+        community_id: 471 //process.argv[2]
+    }
+}).then(function (groups) {
+    async.eachSeries(groups, function (group, seriesCallback) {
+        models.Post.unscoped().findAll({
+            where: {
+                group_id: group.id //process.argv[2]
+            }
+        }).then(function (posts) {
+            var postsJson = _.map(posts, function (post) {
+                return post.toJSON();
+            });
+            var newGroupedBy = _.groupBy(postsJson, function (post) {
+                return moment(post.created_at).format("DD/MM/YY");
+            });
+            _.each(newGroupedBy, function (posts, key) {
+                if (grouped[key]) {
+                    grouped[key] += posts.length;
+                }
+                else {
+                    grouped[key] = posts.length;
+                }
+            });
+            seriesCallback();
+        });
+    }, function (error) {
+        var keys = [], k, i, len;
+        for (k in grouped) {
+            if (grouped.hasOwnProperty(k)) {
+                keys.push(k);
+            }
+        }
+        keys.sort();
+        len = keys.length;
+        for (i = 0; i < len; i++) {
+            k = keys[i];
+            console.log(k + ',' + grouped[k]);
+        }
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/countUniqueVotersInAGroup.js

@@ -0,0 +1,48 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var moment = require('moment');
+var groupId = process.argv[2];
+const allUsers = {};
+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"],
+    where: {
+        value: {
+            $or: [
+                -1, 1
+            ]
+        }
+    },
+    include: [
+        {
+            model: models.Post,
+            attributes: ["id"],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ["id"],
+                    where: {
+                        id: groupId
+                    }
+                }
+            ]
+        }
+    ]
+}).then((endorsements) => {
+    console.log(`Votes: ${endorsements.length}`);
+    endorsements.forEach(e => {
+        allUsers[e.user_id] = 1;
+    });
+    console.log(`Voters: ${size(allUsers)}`);
+    console.log(`Average votes per user: ${parseInt(endorsements.length / size(allUsers))}`);
+    process.exit();
+});
+export {};

package/dist/scripts/createInvitesAndShow.js

@@ -0,0 +1,75 @@
+const models = require('../models/index.cjs');
+const _ = require('lodash');
+const toJson = require('../utils/to_json.cjs');
+var crypto = require("crypto");
+const communityId = process.argv[2];
+const senderUserId = process.argv[3];
+const numberOfInvites = process.argv[4];
+const masterCampaignName = process.argv[5];
+const createOneInvite = async (campaignName, inviteEmail) => {
+    let community, invite, registeredUser, senderUser, token, inviteUrl;
+    try {
+        token = (await crypto.randomBytes(20)).toString('hex');
+        community = await models.Community.findOne({
+            where: { id: communityId },
+            attributes: ['id', 'domain_id', 'hostname'],
+            include: [{ model: models.Domain, attributes: ['id', 'domain_name'] }]
+        });
+        senderUser = await models.User.findOne({
+            where: { id: senderUserId },
+            attributes: ['id', 'email', 'name']
+        });
+        if (inviteEmail) {
+            registeredUser = await models.User.findOne({
+                where: { email: inviteEmail },
+                attributes: ['id', 'email']
+            });
+        }
+        invite = await models.Invite.create({
+            token: token,
+            expires_at: Date.now() + (3600000 * 24 * 30),
+            type: models.Invite.INVITE_TO_COMMUNITY,
+            community_id: communityId,
+            user_id: registeredUser ? registeredUser.id : null,
+            from_user_id: senderUser.id,
+            metadata: { toEmail: inviteEmail, campaignName: campaignName }
+        });
+        if (inviteEmail && community) {
+            await models.AcActivity.inviteCreated({
+                email: inviteEmail,
+                user_id: registeredUser ? registeredUser.id : null,
+                sender_user_id: senderUser.id,
+                community_id: communityId,
+                sender_name: senderUser.name,
+                domain_id: community.domain_id,
+                invite_id: invite.id,
+                token: token
+            });
+        }
+        inviteUrl = 'https://' + community.hostname + '.' + community.Domain.domain_name + '/user/accept/invite/' + token;
+        return inviteUrl;
+    }
+    catch (error) {
+        throw error;
+    }
+};
+const generateInvites = async () => {
+    let urls = [];
+    for (let i = 0; i < numberOfInvites; i++) {
+        try {
+            const inviteUrl = await createOneInvite(masterCampaignName, null);
+            if (inviteUrl) {
+                urls.push(inviteUrl);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    urls.forEach((url) => {
+        console.log(url);
+    });
+    process.exit();
+};
+generateInvites();
+export {};

package/dist/scripts/database/sync_database.js

@@ -0,0 +1,14 @@
+const models = require('../../models/index.cjs');
+models.sequelize.sync({}).then(() => {
+    setTimeout(() => {
+        models.Post.addFullTextIndex();
+        setTimeout(() => {
+            console.log("Time has passed");
+            process.exit();
+        }, 15000);
+    }, 1000);
+}).catch(error => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/scripts/database/sync_dev_database.js

@@ -0,0 +1,17 @@
+const models = require('../../models/index.cjs');
+models.sequelize.query('CREATE DATABASE yrpri_dev', (err, res) => {
+    console.log(err, res);
+    models.sequelize.sync({}).then(() => {
+        setTimeout(() => {
+            models.Post.addFullTextIndex();
+            setTimeout(() => {
+                console.log("Time has passed");
+                process.exit();
+            }, 15000);
+        }, 1000);
+    }).catch(error => {
+        console.error(error);
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/debugNotifications.js

@@ -0,0 +1,58 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var moment = require('moment');
+var allUsers = {};
+var size = function (obj) {
+    var size = 0, key;
+    for (key in obj) {
+        if (obj.hasOwnProperty(key))
+            size++;
+    }
+    return size;
+};
+/*models.AcNotification.findAll({
+  attributes: ['id','type'],
+  include: [
+  {
+    model: models.AcActivity, as: 'AcActivities',
+    attributes: ['id','point_id','type','post_id','user_id'],
+    required: true,
+    where: {
+      post_id: 7212
+    }
+  }
+]}).then(function(notifications) {
+  console.log("Hello: "+notifications.length);
+  _.forEach(notifications, function (notification) {
+    if (true || notification.AcActivities.length>1 && notification.type=="notification.post.endorsement") {
+      console.log("================================================");
+      _.forEach(notification.AcActivities, function (activity) {
+        console.log("Activity: "+notification.type+" id: "+notification.id+" activity: "+activity.type+" userId: "+activity.user_id+" postId: "+activity.post_id+" pointId: "+activity.point_id);
+      });
+    }
+  });
+});
+*/
+models.AcNotification.findOne({
+    attributes: ['id', 'type'],
+    include: [
+        {
+            model: models.AcActivity, as: 'AcActivities',
+            attributes: ['id', 'point_id', 'type', 'post_id', 'user_id'],
+            required: true,
+            where: {
+                post_id: 8528
+            }
+        }
+    ]
+}).then(function (notification) {
+    debugger;
+    if (true || notification.AcActivities.length > 1 && notification.type == "notification.post.endorsement") {
+        console.log(notification.type + " ================================================ " + notification.AcActivities.length);
+        _.forEach(notification.AcActivities, function (activity) {
+            console.log("Activity: " + notification.type + " id: " + notification.id + " activity: " + activity.type + " userId: " + activity.user_id + " postId: " + activity.post_id + " pointId: " + activity.point_id);
+        });
+    }
+});
+export {};