@yrpri/api 9.0.101 → 9.0.103

package/dist/active-citizen/models/ac_watching.cjs

@@ -0,0 +1,31 @@
+"use strict";
+module.exports = (sequelize, DataTypes) => {
+    const AcWatching = sequelize.define("AcWatching", {
+        priority: { type: DataTypes.INTEGER, allowNull: false },
+        type: { type: DataTypes.INTEGER, allowNull: false },
+        deleted: { type: DataTypes.BOOLEAN, allowNull: false, defaultValue: false }
+    }, {
+        defaultScope: {
+            where: {
+                deleted: false
+            }
+        },
+        timestamps: true,
+        createdAt: 'created_at',
+        updatedAt: 'updated_at',
+        underscored: true,
+        tableName: 'ac_watching'
+    });
+    AcWatching.associate = (models) => {
+        AcWatching.belongsTo(models.Domain, { foreignKey: 'domain_id' });
+        AcWatching.belongsTo(models.Community, { foreignKey: 'community_id' });
+        AcWatching.belongsTo(models.Group, { foreignKey: 'group_id' });
+        AcWatching.belongsTo(models.Post, { foreignKey: 'post_id' });
+        AcWatching.belongsTo(models.Point, { foreignKey: 'point_id' });
+        AcWatching.belongsTo(models.User, { foreignKey: 'user_id' });
+        AcWatching.belongsTo(models.User, { as: 'WatchingUser' });
+    };
+    AcWatching.watchCommunity = function (community, user) {
+    };
+    return AcWatching;
+};

package/dist/active-citizen/scripts/analytics/setup_all_plausible_goals.cjs

@@ -0,0 +1,13 @@
+"use strict";
+const { addAllPlausibleGoals } = require("../../engine/analytics/plausible/manager");
+(async function () {
+    try {
+        await addAllPlausibleGoals();
+        console.log("All done");
+        process.exit();
+    }
+    catch (error) {
+        console.error(error);
+        process.exit();
+    }
+})();

package/dist/active-citizen/scripts/fix_old_delayed_notifications.js

@@ -0,0 +1,63 @@
+var models = require('../../models/index.cjs');
+var async = require('async');
+var log = require('../utils/logger.cjs');
+var _ = require('lodash');
+var moment = require('moment');
+var i18n = require('../utils/i18n.cjs');
+var Backend = require('i18next-fs-backend');
+var latestNotification;
+models.User.findAll({
+    attributes: ['id']
+}).then(function (users) {
+    async.eachSeries(users, function (user, userSeriesCallback) {
+        models.AcDelayedNotification.findAll({
+            where: {
+                user_id: user.id
+            },
+            include: [
+                {
+                    model: models.AcNotification, as: 'AcNotifications',
+                    required: true
+                }
+            ]
+        }).then(function (delayedNotifications) {
+            if (delayedNotifications && delayedNotifications.length > 0) {
+                models.AcDelayedNotification.create({
+                    user_id: user.id,
+                    frequency: 2,
+                    method: 2,
+                    created_at: moment().subtract('days', 2),
+                    type: 'fromScript'
+                }).then(function (newDelayedNotification) {
+                    async.eachSeries(delayedNotifications, function (delayedNotification, delayedNotificationSeriesCallback) {
+                        async.eachSeries(delayedNotification.AcNotifications, function (notification, notificationSeriesCallback) {
+                            console.error("NOTID:" + notification.id);
+                            latestNotification = notification;
+                            newDelayedNotification.addAcNotification(notification).then(function () {
+                                notificationSeriesCallback();
+                            }).catch(function (error) {
+                                console.error("COULD NOT SAVE NOTIFICATION - COULD NOT SAVE NOTIFICATION - COULD NOT SAVE NOTIFICATION - COULD NOT SAVE NOTIFICATION - COULD NOT SAVE NOTIFICATION");
+                                notificationSeriesCallback();
+                            });
+                        }, function (error) {
+                            delayedNotification.deleted = true;
+                            delayedNotification.save().then(function () {
+                                delayedNotificationSeriesCallback();
+                            });
+                        });
+                    }, function (error) {
+                        userSeriesCallback();
+                    });
+                }).catch(function (error) {
+                    userSeriesCallback(error);
+                });
+            }
+            else {
+                userSeriesCallback();
+            }
+        }).catch(function (error) {
+            userSeriesCallback(error);
+        });
+    });
+});
+export {};

package/dist/active-citizen/scripts/kue_status.js

@@ -0,0 +1,31 @@
+var kue = require('kue'), url = require('url');
+var log = require('../utils/logger.cjs');
+var toJson = require('../utils/to_json.cjs');
+var airbrake = null;
+if (process.env.AIRBRAKE_PROJECT_ID) {
+    airbrake = require('../utils/airbrake.cjs');
+}
+// make sure we use the Heroku Redis To Go URL
+// (put REDISTOGO_URL=redis://localhost:6379 in .env for local testing)
+var redisUrl = process.env.REDIS_URL ? process.env.REDIS_URL : "redis://localhost:6379";
+log.info("Starting app access to Kue Queue", { redis_url: redisUrl });
+var queue = kue.createQueue({
+    redis: redisUrl,
+    "socket_keepalive": true
+});
+queue.watchStuckJobs(1000);
+console.log("active");
+queue.activeCount(console.log);
+console.log("inactiveCount");
+queue.inactiveCount(console.log);
+console.log("failedCount");
+queue.failedCount(console.log);
+console.log("delayedCount");
+queue.delayedCount(console.log);
+console.log("completeCount");
+queue.completeCount(console.log);
+setTimeout(function () {
+    process.exit();
+}, 5000);
+module.exports = queue;
+export {};

package/dist/active-citizen/scripts/kue_watch_stuck_jobs.js

@@ -0,0 +1,24 @@
+var kue = require('kue'), url = require('url');
+var log = require('../utils/logger.cjs');
+var email = require('./email');
+var activity = require('./activity');
+var toJson = require('../utils/to_json.cjs');
+var airbrake = null;
+if (process.env.AIRBRAKE_PROJECT_ID) {
+    airbrake = require('../utils/airbrake.cjs');
+}
+// make sure we use the Heroku Redis To Go URL
+// (put REDISTOGO_URL=redis://localhost:6379 in .env for local testing)
+var redisUrl = process.env.REDIS_URL ? process.env.REDIS_URL : "redis://localhost:6379";
+log.info("Starting app access to Kue Queue", { redis_url: redisUrl });
+var queue = kue.createQueue({
+    redis: redisUrl,
+    "socket_keepalive": true
+});
+queue.activeCount(console.log);
+queue.inactiveCount(console.log);
+queue.failedCount(console.log);
+queue.delayedCount(console.log);
+queue.completeCount(console.log);
+module.exports = queue;
+export {};

package/dist/active-citizen/scripts/translation_clear_language.js

@@ -0,0 +1,117 @@
+const models = require('../../models/index.cjs');
+const _ = require('lodash');
+const objectType = process.argv[2];
+const objectId = process.argv[3];
+if (objectType === "point") {
+    models.Point.findOne({
+        where: {
+            id: objectId
+        },
+        attributes: ['id', 'language']
+    }).then((result) => {
+        if (result) {
+            console.log(`Clearing current point language of ${result.language}`);
+            result.set('language', null);
+            result.save().then(function () {
+                console.log(`Cleared language for point ${result.id}`);
+                process.exit();
+            }).catch((error) => {
+                console.error(error);
+                process.exit();
+            });
+        }
+        else {
+            console.warn("Not found: " + indexKey);
+            process.exit();
+        }
+    }).catch((error) => {
+        console.error(error);
+        process.exit();
+    });
+}
+else if (objectType === "group") {
+    models.Group.findOne({
+        where: {
+            id: objectId
+        },
+        attributes: ['id', 'language']
+    }).then((result) => {
+        if (result) {
+            console.log(`Clearing current group language of ${result.language}`);
+            result.set('language', null);
+            result.save().then(function () {
+                console.log(`Cleared language for group ${result.id}`);
+                process.exit();
+            }).catch((error) => {
+                console.error(error);
+                process.exit();
+            });
+        }
+        else {
+            console.warn("Not found: " + indexKey);
+            process.exit();
+        }
+    }).catch((error) => {
+        console.error(error);
+        process.exit();
+    });
+}
+else if (objectType === "community") {
+    models.Community.findOne({
+        where: {
+            id: objectId
+        },
+        attributes: ['id', 'language']
+    }).then((result) => {
+        if (result) {
+            console.log(`Clearing current community language of ${result.language}`);
+            result.set('language', null);
+            result.save().then(function () {
+                console.log(`Cleared language for community ${result.id}`);
+                process.exit();
+            }).catch((error) => {
+                console.error(error);
+                process.exit();
+            });
+        }
+        else {
+            console.warn("Not found: " + indexKey);
+            process.exit();
+        }
+    }).catch((error) => {
+        console.error(error);
+        process.exit();
+    });
+}
+else if (objectType === "domain") {
+    models.Domain.findOne({
+        where: {
+            id: objectId
+        },
+        attributes: ['id', 'language']
+    }).then((result) => {
+        if (result) {
+            console.log(`Clearing current domain language of ${result.language}`);
+            result.set('language', null);
+            result.save().then(function () {
+                console.log(`Cleared language for domain ${result.id}`);
+                process.exit();
+            }).catch((error) => {
+                console.error(error);
+                process.exit();
+            });
+        }
+        else {
+            console.warn("Not found: " + indexKey);
+            process.exit();
+        }
+    }).catch((error) => {
+        console.error(error);
+        process.exit();
+    });
+}
+else {
+    console.log("No object type selected");
+    process.exit();
+}
+export {};

package/dist/active-citizen/scripts/translation_delete.js

@@ -0,0 +1,27 @@
+const models = require('../../models/index.cjs');
+const _ = require('lodash');
+const indexKey = process.argv[2];
+const textToReplace = process.argv[3];
+models.AcTranslationCache.findOne({
+    where: {
+        index_key: indexKey
+    }
+}).then((result) => {
+    if (result) {
+        result.destroy().then(function () {
+            console.log(`Deleted ${result.index_key} to ${result.content}`);
+            process.exit();
+        }).catch((error) => {
+            console.error(error);
+            process.exit();
+        });
+    }
+    else {
+        console.warn("Not found: " + indexKey);
+        process.exit();
+    }
+}).catch((error) => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/active-citizen/scripts/translation_replace_text_from_url.js

@@ -0,0 +1,180 @@
+const models = require('../../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+const farmhash = require('farmhash');
+//const communityId = "1264"; //process.argv[2];
+//const communityId = "1402"; //process.argv[2];
+//const communityId = "1321"; //process.argv[2];
+//const communityId = "1403"; //process.argv[2];
+const communityId = process.argv[2];
+const targetLocale = process.argv[3];
+const urlToConfig = process.argv[4];
+let config;
+let changeCount = 0;
+const searchAndReplaceTranslation = (textType, id, content, done) => {
+    if (!content)
+        done();
+    const indexKey = `${textType}-${id}-${targetLocale}-${farmhash.hash32(content).toString()}`;
+    models.AcTranslationCache.findOne({
+        where: {
+            index_key: indexKey
+        }
+    }).then((result) => {
+        if (result) {
+            let newContent = result.content;
+            config.split('\r\n').forEach(searchLine => {
+                if (searchLine && searchLine !== "") {
+                    const searchLineSplit = searchLine.split(",");
+                    if (newContent.indexOf(searchLineSplit[0]) > -1) {
+                        const regExp = new RegExp(searchLineSplit[0], 'g');
+                        newContent = newContent.replace(regExp, searchLineSplit[1]);
+                        changeCount += 1;
+                    }
+                }
+            });
+            if (newContent !== result.content) {
+                result.set('content', newContent);
+                result.save().then(() => {
+                    console.log(`Updated ${result.index_key} to ${result.content}`);
+                    done();
+                }).catch(error => {
+                    done(error);
+                });
+            }
+            else {
+                done();
+            }
+        }
+        else {
+            console.warn("Not found: " + indexKey);
+            done();
+        }
+    }).catch((error) => {
+        done(error);
+    });
+};
+const updateTranslationForPosts = (posts, done) => {
+    async.forEachSeries(posts, (post, forEachCallback) => {
+        searchAndReplaceTranslation('postName', post.id, post.name, (error) => {
+            if (error) {
+                forEachCallback(error);
+            }
+            else {
+                searchAndReplaceTranslation('postContent', post.id, post.description, (error) => {
+                    forEachCallback(error);
+                });
+            }
+        });
+    }, error => {
+        done(error);
+    });
+};
+const updateTranslationForGroups = (groups, done) => {
+    async.forEachSeries(groups, (group, forEachCallback) => {
+        searchAndReplaceTranslation('groupName', group.id, group.name, (error) => {
+            if (error) {
+                forEachCallback(error);
+            }
+            else {
+                searchAndReplaceTranslation('groupContent', group.id, group.objectives, (error) => {
+                    forEachCallback(error);
+                });
+            }
+        });
+    }, error => {
+        done(error);
+    });
+};
+const updateTranslationForCommunity = (community, done) => {
+    searchAndReplaceTranslation('communityName', community.id, community.name, (error) => {
+        if (error) {
+            done(error);
+        }
+        else {
+            searchAndReplaceTranslation('communityContent', community.id, community.description, (error) => {
+                done(error);
+            });
+        }
+    });
+};
+async.series([
+    (seriesCallback) => {
+        const options = {
+            url: urlToConfig,
+        };
+        request.get(options, (error, content) => {
+            if (content && content.statusCode !== 200) {
+                seriesCallback(content.statusCode);
+            }
+            else if (content) {
+                config = content.body;
+                seriesCallback();
+            }
+            else {
+                seriesCallback("No content");
+            }
+        });
+    },
+    (seriesCallback) => {
+        async.series([
+            (innerSeriesCallback) => {
+                models.Post.findAll({
+                    attributes: ['id', 'name', 'description'],
+                    include: [
+                        {
+                            model: models.Group,
+                            attributes: ['id'],
+                            include: [
+                                {
+                                    model: models.Community,
+                                    attributes: ['id'],
+                                    where: {
+                                        id: communityId
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }).then(posts => {
+                    updateTranslationForPosts(posts, innerSeriesCallback);
+                }).catch(error => {
+                    innerSeriesCallback(error);
+                });
+            },
+            (innerSeriesCallback) => {
+                models.Group.findAll({
+                    attributes: ['id', 'name', 'objectives'],
+                    where: {
+                        community_id: communityId
+                    }
+                }).then(groups => {
+                    updateTranslationForGroups(groups, innerSeriesCallback);
+                }).catch(error => {
+                    innerSeriesCallback(error);
+                });
+            },
+            (innerSeriesCallback) => {
+                models.Community.findOne({
+                    attributes: ['id', 'name', 'description'],
+                    where: {
+                        id: communityId
+                    }
+                }).then(community => {
+                    updateTranslationForCommunity(community, innerSeriesCallback);
+                }).catch(error => {
+                    innerSeriesCallback(error);
+                });
+            }
+        ], (error) => {
+            seriesCallback(error);
+        });
+    },
+], error => {
+    if (error)
+        console.error(error);
+    console.log(`All done with ${changeCount} changes`);
+    process.exit();
+});
+export {};

package/dist/active-citizen/scripts/translation_update.js

@@ -0,0 +1,28 @@
+const models = require('../../models/index.cjs');
+const _ = require('lodash');
+const indexKey = process.argv[2];
+const textToReplace = process.argv[3];
+models.AcTranslationCache.findOne({
+    where: {
+        index_key: indexKey
+    }
+}).then((result) => {
+    if (result) {
+        result.set('content', textToReplace);
+        result.save().then(function () {
+            console.log(`Updated ${result.index_key} to ${result.content}`);
+            process.exit();
+        }).catch((error) => {
+            console.error(error);
+            process.exit();
+        });
+    }
+    else {
+        console.warn("Not found: " + indexKey);
+        process.exit();
+    }
+}).catch((error) => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/active-citizen/scripts/translations_list.js

@@ -0,0 +1,27 @@
+const models = require('../../models/index.cjs');
+const _ = require('lodash');
+const textToSearch = process.argv[2];
+models.AcTranslationCache.findAll({
+    where: {
+        content: {
+            [models.Sequelize.Op.substring]: textToSearch
+        }
+    }
+}).then((results) => {
+    if (results && results.length > 0) {
+        results.forEach((item) => {
+            console.log(`${item.index_key} - ${item.content}`);
+            console.log(`--------------------------------------`);
+            console.log("");
+        });
+    }
+    else {
+        console.warn("No results found");
+        process.exit();
+    }
+    process.exit();
+}).catch((error) => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/{active-citizen/utils/airbrake.js → dist/active-citizen/utils/airbrake.cjs}

@@ -1,3 +1,4 @@
+"use strict";
 if (process.env.AIRBRAKE_PROJECT_ID) {
     const Airbrake = require('@airbrake/node');
     let airBrake = null;
@@ -14,4 +15,3 @@ if (process.env.AIRBRAKE_PROJECT_ID) {
     }
     module.exports = airBrake;
 }
-export {};

package/dist/active-citizen/utils/get_anonymous_system_user.cjs

@@ -0,0 +1,21 @@
+"use strict";
+const models = require("../../models/index.cjs");
+module.exports = (callback) => {
+    models.User.findOrCreate({
+        where: {
+            email: "system.anonymous.user72@citizens.is"
+        },
+        defaults: {
+            profile_data: { isAnonymousUser: true },
+            email: "system.anonymous.user72@citizens.is",
+            name: "Anonymous",
+            notifications_settings: models.AcNotification.anonymousNotificationSettings,
+            status: 'active'
+        }
+    }).then(results => {
+        const [user, created] = results;
+        callback(null, user);
+    }).catch(function (error) {
+        callback(error);
+    });
+};

package/dist/active-citizen/utils/i18n.cjs

@@ -0,0 +1,3 @@
+"use strict";
+var i18n = require('i18next');
+module.exports = i18n;

package/dist/active-citizen/utils/logger.cjs

@@ -0,0 +1,25 @@
+"use strict";
+var bunyan = require('bunyan');
+var PrettyStream = require('bunyan-prettystream');
+var logger;
+if (process.env.USE_BUNYAN_LOGGER && process.env.NODE_ENV != 'production') {
+    var prettyStdOut = new PrettyStream({ useColor: true });
+    prettyStdOut.pipe(process.stdout);
+    logger = bunyan.createLogger({
+        name: 'your-priorities',
+        streams: [{
+                level: 'debug',
+                type: 'raw',
+                stream: prettyStdOut
+            }]
+    });
+}
+else {
+    if (process.env.USE_BUNYAN_LOGGER) {
+        logger = bunyan.createLogger({ name: "your-priorities" });
+    }
+    else {
+        logger = console;
+    }
+}
+module.exports = logger;

package/dist/active-citizen/utils/redisConnection.cjs

@@ -0,0 +1,29 @@
+"use strict";
+const redis = require("redis");
+let redisClient;
+if (process.env.REDIS_URL) {
+    let redisUrl = process.env.REDIS_URL;
+    if (redisUrl.startsWith("redis://h:")) {
+        redisUrl = redisUrl.replace("redis://h:", "redis://:");
+    }
+    if (redisUrl.includes("rediss://")) {
+        redisClient = redis.createClient({
+            legacyMode: false,
+            url: redisUrl,
+            pingInterval: 10000,
+            socket: { tls: true, rejectUnauthorized: false },
+        });
+    }
+    else {
+        redisClient = redis.createClient({ legacyMode: true, url: redisUrl });
+    }
+}
+else {
+    redisClient = redis.createClient({ legacyMode: true });
+}
+redisClient.on("error", (err) => console.error("Backend Redis client error", err));
+redisClient.on("connect", () => console.log("Backend Redis client is connect"));
+redisClient.on("reconnecting", () => console.log("Backend  Redis client is reconnecting"));
+redisClient.on("ready", () => console.log("Backend Redis client is ready"));
+redisClient.connect().catch(console.error);
+module.exports = redisClient;

package/dist/active-citizen/utils/to_json.cjs

@@ -0,0 +1,9 @@
+"use strict";
+module.exports = function (item) {
+    if (item && typeof item.toJSON === 'function') {
+        return item.toJSON();
+    }
+    else {
+        return null;
+    }
+};