@yrpri/api 9.0.101 → 9.0.103

package/dist/utils/parse_domain.cjs

@@ -0,0 +1,16 @@
+"use strict";
+const parseDomain = (urlPath) => {
+    const results = {};
+    const splitPath = urlPath.split(".");
+    results.domain = splitPath[splitPath.length - 2];
+    results.tld = splitPath[splitPath.length - 1];
+    const subDomainSplit = urlPath.split('.' + results.domain + '.' + results.tld);
+    if (subDomainSplit && subDomainSplit.length > 1) {
+        results.subdomain = subDomainSplit[0];
+    }
+    else {
+        results.subdomain = "";
+    }
+    return results;
+};
+module.exports = parseDomain;

package/dist/utils/recount_utils.cjs

@@ -0,0 +1,415 @@
+"use strict";
+const async = require('async');
+const models = require('../models/index.cjs');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+const recountPosts = (postIds, done) => {
+    async.forEachSeries(postIds, (postId, forEachPostCallback) => {
+        recountPost(postId, forEachPostCallback);
+    }, error => {
+        done(error);
+    });
+};
+const recountPoints = (pointIds, done) => {
+    async.forEachSeries(pointIds, (pointId, forEachPostCallback) => {
+        recountPoint(pointId, forEachPostCallback);
+    }, error => {
+        done(error);
+    });
+};
+const recountPost = (postId, done) => {
+    var endorsementsCount;
+    var oppositionCount;
+    var pointCount;
+    async.parallel([
+        (parallelCallback) => {
+            models.Endorsement.count({
+                where: {
+                    value: 1,
+                    post_id: postId
+                }
+            }).then((count) => {
+                endorsementsCount = count;
+                parallelCallback();
+            }).catch((error) => {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.Endorsement.count({
+                where: {
+                    value: -1,
+                    post_id: postId
+                }
+            }).then((count) => {
+                oppositionCount = count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.Point.count({
+                where: {
+                    $or: [
+                        { value: -1 },
+                        { value: 1 }
+                    ],
+                    post_id: postId
+                }
+            }).then((count) => {
+                pointCount = count;
+                parallelCallback();
+            }).catch((error) => {
+                parallelCallback(error);
+            });
+        }
+    ], (error) => {
+        if (error) {
+            done(error);
+        }
+        else {
+            models.Post.findOne({
+                where: {
+                    id: postId
+                },
+                attributes: ['id', 'counter_endorsements_up', 'counter_endorsements_down', 'counter_points']
+            }).then((post) => {
+                post.counter_points = pointCount;
+                post.counter_endorsements_up = endorsementsCount;
+                post.counter_endorsements_down = oppositionCount;
+                post.save().then((results) => {
+                    console.log(`Recount for post ${post.id} done`);
+                    done();
+                });
+            }).catch((error) => {
+                done(error);
+            });
+        }
+    });
+};
+const recountPoint = (pointId, done) => {
+    var counter_quality_up;
+    var counter_quality_down;
+    var pointCount;
+    async.parallel([
+        (parallelCallback) => {
+            models.PointQuality.count({
+                where: {
+                    value: 1,
+                    point_id: pointId
+                }
+            }).then((count) => {
+                counter_quality_up = count;
+                parallelCallback();
+            }).catch((error) => {
+                parallelCallback(error);
+            });
+        },
+        (parallelCallback) => {
+            models.PointQuality.count({
+                where: {
+                    value: -1,
+                    point_id: pointId
+                }
+            }).then((count) => {
+                counter_quality_down = count;
+                parallelCallback();
+            }).catch(function (error) {
+                parallelCallback(error);
+            });
+        }
+    ], (error) => {
+        if (error) {
+            done(error);
+        }
+        else {
+            models.Point.findOne({
+                where: {
+                    id: pointId
+                },
+                attributes: ['id', 'counter_quality_up', 'counter_quality_down']
+            }).then((point) => {
+                point.counter_quality_up = counter_quality_up;
+                point.counter_quality_down = counter_quality_down;
+                point.save().then((results) => {
+                    console.log(`Recount for point ${point.id} done`);
+                    done();
+                });
+            }).catch((error) => {
+                done(error);
+            });
+        }
+    });
+};
+const countPostInGroup = (groupId, done) => {
+    models.Post.count({
+        where: {
+            group_id: groupId
+        }
+    }).then(count => {
+        done(null, count);
+    }).catch(error => {
+        done(error);
+    });
+};
+const countPointsInGroup = (groupId, done) => {
+    models.Point.count({
+        where: {
+            group_id: groupId
+        }
+    }).then(count => {
+        done(null, count);
+    }).catch(error => {
+        done(error);
+    });
+};
+const countUsersInGroup = (groupId, done) => {
+    const userIds = [];
+    async.series([
+        (seriesCallback) => {
+            models.Endorsement.findAll({
+                attributes: ['user_id'],
+                include: [
+                    {
+                        model: models.Post,
+                        attributes: ['id'],
+                        where: {
+                            group_id: groupId
+                        }
+                    }
+                ]
+            }).then(endorsements => {
+                for (let i = 0; i < endorsements.length; i++) {
+                    userIds.push(endorsements[i].user_id);
+                }
+                seriesCallback();
+            }).catch(seriesCallback);
+        },
+        (seriesCallback) => {
+            models.Rating.findAll({
+                attributes: ['user_id'],
+                include: [
+                    {
+                        model: models.Post,
+                        attributes: ['id'],
+                        where: {
+                            group_id: groupId
+                        }
+                    }
+                ]
+            }).then(ratings => {
+                for (let i = 0; i < ratings.length; i++) {
+                    userIds.push(ratings[i].user_id);
+                }
+                seriesCallback();
+            }).catch(seriesCallback);
+        },
+        (seriesCallback) => {
+            models.PointQuality.findAll({
+                attributes: ['user_id'],
+                include: [
+                    {
+                        model: models.Point,
+                        attributes: ['id'],
+                        include: [
+                            {
+                                model: models.Post,
+                                attributes: ['id'],
+                                where: {
+                                    group_id: groupId
+                                }
+                            }
+                        ]
+                    }
+                ]
+            }).then(qualities => {
+                for (let i = 0; i < qualities.length; i++) {
+                    userIds.push(qualities[i].user_id);
+                }
+                seriesCallback();
+            }).catch(seriesCallback);
+        },
+        (seriesCallback) => {
+            models.Point.findAll({
+                attributes: ['user_id'],
+                include: [
+                    {
+                        model: models.Post,
+                        attributes: ['id'],
+                        where: {
+                            group_id: groupId
+                        }
+                    }
+                ]
+            }).then(points => {
+                for (let i = 0; i < points.length; i++) {
+                    userIds.push(points[i].user_id);
+                }
+                seriesCallback();
+            }).catch(seriesCallback);
+        },
+        (seriesCallback) => {
+            models.Post.findAll({
+                attributes: ['id'],
+                where: {
+                    group_id: groupId
+                }
+            }).then(posts => {
+                for (let i = 0; i < posts.length; i++) {
+                    userIds.push(posts[i].user_id);
+                }
+                seriesCallback();
+            }).catch(seriesCallback);
+        }
+    ], error => {
+        done(error, _.uniq(userIds).length, userIds);
+    });
+};
+const countAllInGroup = (groupId, done) => {
+    let postCount = 0;
+    let pointCount = 0;
+    let userCount = 0;
+    let allUsers;
+    async.parallel([
+        (seriesCallback) => {
+            countPostInGroup(groupId, (error, count) => {
+                if (error) {
+                    seriesCallback(error);
+                }
+                else {
+                    postCount = count;
+                    seriesCallback();
+                }
+            });
+        },
+        (seriesCallback) => {
+            countPointsInGroup(groupId, (error, count) => {
+                if (error) {
+                    seriesCallback(error);
+                }
+                else {
+                    pointCount = count;
+                    seriesCallback();
+                }
+            });
+        },
+        (seriesCallback) => {
+            countUsersInGroup(groupId, (error, count, allUsersIn) => {
+                if (error) {
+                    seriesCallback(error);
+                }
+                else {
+                    userCount = count;
+                    allUsers = allUsersIn;
+                    seriesCallback();
+                }
+            });
+        }
+    ], error => {
+        if (error) {
+            done(error);
+        }
+        else {
+            done(null, postCount, pointCount, userCount, allUsers);
+        }
+    });
+};
+const recountGroup = (groupId, callback) => {
+    models.Group.findOne({
+        where: {
+            id: groupId
+        }
+    }).then(group => {
+        if (group) {
+            countAllInGroup(group.id, (error, postCount, pointCount, userCount, allUsers) => {
+                if (error) {
+                    callback(error);
+                }
+                else {
+                    group.set('counter_points', pointCount);
+                    group.set('counter_users', Math.max(userCount, 1));
+                    group.set('counter_posts', postCount);
+                    group.save().then(() => {
+                        console.log(`Recount Group ${group.id} users: ${Math.max(userCount, 1)} posts: ${postCount} points: ${pointCount}`);
+                        callback(null, { postCount, pointCount, userCount, allUsers });
+                    }).catch(error => {
+                        callback(error);
+                    });
+                }
+            });
+        }
+        else {
+            callback("Group not found");
+        }
+    }).catch(error => {
+        callback(error);
+    });
+};
+const recountCommunity = (communityId, callback) => {
+    models.Community.findOne({
+        where: {
+            id: communityId
+        },
+        attributes: ['id', 'counter_points', 'counter_users', 'counter_posts'],
+        include: [
+            {
+                model: models.Group,
+                attributes: ['id', 'counter_points', 'counter_users', 'counter_posts'],
+                where: {
+                    is_group_folder: false
+                }
+            }
+        ]
+    }).then(community => {
+        if (community) {
+            let postCount = 0;
+            let pointCount = 0;
+            let allUsers = [];
+            async.forEachSeries(community.Groups, (group, forEachCallback) => {
+                recountGroup(group.id, (error, counts) => {
+                    if (error) {
+                        forEachCallback(error);
+                    }
+                    else {
+                        postCount += counts.postCount;
+                        pointCount += counts.pointCount;
+                        allUsers = allUsers.concat(counts.allUsers);
+                        forEachCallback();
+                    }
+                });
+            }, error => {
+                if (error) {
+                    callback(error);
+                }
+                else {
+                    community.set('counter_points', pointCount);
+                    community.set('counter_users', Math.max(_.uniq(allUsers).length, 1));
+                    community.set('counter_posts', postCount);
+                    community.save().then(() => {
+                        console.log(`Recount Community ${community.id} users: ${Math.max(_.uniq(allUsers).length, 1)} posts: ${postCount} points: ${pointCount}`);
+                        callback();
+                    }).catch(error => {
+                        callback(error);
+                    });
+                }
+            });
+        }
+        else {
+            console.error(`Community ${communityId} found`);
+            callback();
+        }
+    }).catch(error => {
+        callback(error);
+    });
+};
+module.exports = {
+    recountCommunity,
+    recountGroup,
+    recountPost,
+    recountPosts,
+    recountPoint,
+    recountPoints,
+    countUsersInGroup
+};

package/dist/utils/sharing_parameters.cjs

@@ -0,0 +1,111 @@
+"use strict";
+const models = require("../models/index.cjs");
+const url = require("url");
+const updateParametersFromCampaign = async (utmContent, collectionType, collectionId, parameters) => {
+    return await new Promise(async (resolve, reject) => {
+        let where = {
+            id: utmContent
+        };
+        switch (collectionType) {
+            case "domain":
+                where = { ...where, ...{ domain_id: collectionId } };
+                break;
+            case "community":
+                where = { ...where, ...{ community_id: collectionId } };
+                break;
+            case "group":
+                where = { ...where, ...{ group_id: collectionId } };
+                break;
+            case "post":
+                where = { ...where, ...{ post_id: collectionId } };
+                break;
+            case "user":
+                where = { ...where, ...{ user_id: collectionId } };
+                break;
+            default:
+                reject("Can't find a valid collection type for campaign");
+        }
+        try {
+            const campaign = await models.Campaign.findOne({
+                where: where,
+                attributes: ["id", "configuration"],
+            });
+            if (campaign && campaign.configuration.shareImageUrl) {
+                parameters.imageUrl = campaign.configuration.shareImageUrl;
+            }
+            if (campaign && campaign.configuration.shareDescriptionText) {
+                parameters.description = campaign.configuration.shareDescriptionText;
+            }
+            resolve(parameters);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
+const getSharingParameters = async (req, collection, url, imageUrl) => {
+    return await new Promise(async (resolve, reject) => {
+        try {
+            let description = collection.description || collection.objectives || "";
+            if (description) {
+                description = description.replace(/"/g, "'");
+            }
+            let name = collection.name;
+            const collectionType = collection.constructor.name.toLowerCase();
+            if (collectionType === "domain" && url.indexOf("betrireykjavik.is") > -1) {
+                name = `Betri Reykjavík - ${name}`;
+            }
+            let parameters = {
+                title: name,
+                description: description,
+                url: url || "",
+                imageUrl: imageUrl || "",
+                locale: collection.language || "",
+            };
+            if (req.query.utm_content && !isNaN(req.query.utm_content)) {
+                parameters = await updateParametersFromCampaign(req.query.utm_content, collectionType, collection.id, parameters);
+            }
+            resolve(parameters);
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
+const getFullUrl = (req) => {
+    var replacedUrl = req.originalUrl;
+    if (replacedUrl.startsWith("/?_escaped_fragment_=")) {
+        replacedUrl = req.originalUrl.replace(/[?]_escaped_fragment_=/g, "");
+        replacedUrl = replacedUrl.replace("//", "/");
+    }
+    var formattedUrl = url.format({
+        protocol: req.protocol,
+        host: req.get("host"),
+        pathname: replacedUrl,
+    });
+    return formattedUrl;
+};
+const getSplitUrl = (req) => {
+    let url = req.url;
+    let splitPath = 1;
+    if (url.startsWith("/?_escaped_fragment_=")) {
+        url = req.url.replace(/%2F/g, "/");
+        splitPath = 2;
+    }
+    let splitUrl = url.split("/");
+    let id = splitUrl[splitPath + 1];
+    if (id) {
+        id = id.split("?")[0];
+    }
+    return {
+        splitUrl,
+        splitPath,
+        id,
+        url,
+    };
+};
+module.exports = {
+    getSharingParameters,
+    getFullUrl,
+    getSplitUrl,
+};