@yrpri/api 9.0.103 → 9.0.104

package/dist/utils/parse_domain.cjs

@@ -1,16 +0,0 @@
-"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

@@ -1,415 +0,0 @@
-"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

@@ -1,111 +0,0 @@
-"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,
-};