@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/fixGroupAccess.js

@@ -0,0 +1,16 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+console.log("Fix group");
+models.Group.findAll({ where: { access: 1 } }).then(function (groups) {
+    async.eachSeries(groups, function (group, seriesCallback) {
+        group.access = models.Group.ACCESS_OPEN_TO_COMMUNITY;
+        group.save().then(function () {
+            console.log("Changed to open to community " + group.name);
+            seriesCallback();
+        });
+    }, function (error) {
+        console.log("Finished");
+        process.exit();
+    });
+});
+export {};

package/dist/scripts/fixGroupIdeasAndPointsCount.js

@@ -0,0 +1,49 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var groupId = process.argv[2];
+var postsCount = 0;
+var pointsCount = 0;
+async.series([
+    function (seriesCallback) {
+        models.Post.findAll({
+            where: {
+                group_id: groupId
+            }
+        }).then(function (posts) {
+            postsCount = posts.length;
+            seriesCallback();
+        });
+    },
+    function (seriesCallback) {
+        models.Point.findAll({
+            include: [
+                {
+                    model: models.Post,
+                    where: {
+                        group_id: groupId
+                    }
+                }
+            ]
+        }).then(function (posts) {
+            pointsCount = posts.length;
+            seriesCallback();
+        });
+    }
+], function (error) {
+    if (error) {
+        console.error(error);
+        process.exit();
+    }
+    else {
+        models.Group.findOne({ where: { id: groupId } }).then(function (group) {
+            group.counter_posts = postsCount;
+            group.counter_points = pointsCount;
+            group.save().then(function () {
+                console.log("Have updated group");
+                process.exit();
+            });
+        });
+    }
+});
+export {};

package/dist/scripts/fixNotificationSettings.js

@@ -0,0 +1,39 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+console.log("Fixing Notifications Settings");
+var loopyloop = true;
+var numberOfRows = 25000;
+var offset = 0;
+async.whilst(function () { return loopyloop; }, function (whilstCallback) {
+    models.User.findAll({
+        limit: numberOfRows,
+        offset: offset
+    }).then(function (users) {
+        if (users && users.length > 0) {
+            offset += numberOfRows;
+            async.eachSeries(users, function (user, seriesCallback) {
+                //          console.log(user.email);
+                if (user.notifications_settings) {
+                    user.set('notifications_settings.all_group.method', 0);
+                    user.set('notifications_settings.all_community.method', 0);
+                }
+                else {
+                    user.notifications_settings = models.AcNotification.defaultNotificationSettings;
+                }
+                user.save().then(function () {
+                    seriesCallback();
+                });
+            }, function (error) {
+                console.log("Finished with rows continue");
+                whilstCallback();
+            });
+        }
+        else {
+            console.log("Finished with rows ENDING");
+            loopyloop = false;
+            whilstCallback();
+        }
+    });
+}, function (err, n) {
+});
+export {};

package/dist/scripts/fixSurveyRadioBakedInSubCodes.js

@@ -0,0 +1,64 @@
+var models = require("../models/index.cjs");
+var async = require("async");
+console.log("Fix group");
+const groupId = process.argv[2];
+const getSubCodeFromRadio = (radios, answer) => {
+    let subCode;
+    if (radios) {
+        for (let i = 0; i < radios.length; i++) {
+            //console.log(answer);
+            //console.log(`${radios[i].subCode.trim()} !`)
+            if (answer.startsWith(`${radios[i].subCode.trim()} `)) {
+                subCode = radios[i].subCode;
+                break;
+            }
+        }
+    }
+    return subCode;
+};
+const fixRadioDescriptionIfNeeded = (answers, questionsById, i) => {
+    let currentValue = answers[i].value;
+    console.log(currentValue);
+    const subCode = getSubCodeFromRadio(questionsById[answers[i].uniqueId].radioButtons, answers[i].value);
+    if (subCode) {
+        currentValue = currentValue.replace(`${subCode} `, '');
+        console.log(currentValue);
+    }
+    return currentValue;
+};
+const getAnswerType = (answers, questionsById, i) => {
+    return questionsById[answers[i].uniqueId].type;
+};
+const processPost = (group, post, done) => {
+    const questionsById = {};
+    const questionComponents = group.configuration.structuredQuestionsJson;
+    for (let i = 0; i < questionComponents.length; i++) {
+        questionsById[questionComponents[i].uniqueId] = questionComponents[i];
+    }
+    const answers = post.public_data.structuredAnswersJson;
+    for (let i = 0; i < answers.length; i += 1) {
+        if (answers[i] && answers[i].uniqueId && answers[i].value) {
+            const answerType = getAnswerType(answers, questionsById, i);
+            if (answers[i].value && answerType === "radios") {
+                answers[i].value = fixRadioDescriptionIfNeeded(answers, questionsById, i);
+            }
+        }
+    }
+    const clonedAnswers = [...answers];
+    post.set('public_data.structuredAnswersJson', clonedAnswers);
+    post.changed('public_data', true);
+    post.save().then(() => {
+        done();
+    });
+};
+models.Group.findOne({ where: { id: groupId } }).then((group) => {
+    models.Post.unscoped().findAll({ where: { group_id: groupId } }).then((posts) => {
+        async.eachSeries(posts, (post, seriesCallback) => {
+            processPost(group, post, seriesCallback);
+        }, function (error) {
+            console.log("Finished");
+            process.exit();
+        });
+    });
+});
+export {};

package/dist/scripts/fixWrongUserIdForStatusUpdates.js

@@ -0,0 +1,49 @@
+const models = require('../models/index.cjs');
+const async = require('async');
+const moment = require('moment');
+const domainId = process.argv[2];
+const oldUserId = process.argv[3];
+const newUserId = process.argv[4];
+const beforeDate = process.argv[5];
+console.log("Fix wrong user id on status updated");
+if (!domainId || !oldUserId || !newUserId || !beforeDate) {
+    console.error("Missing parameters");
+    process.exit();
+}
+else {
+    let beforeDateObject = moment(beforeDate);
+    models.User.findOne({
+        where: {
+            id: newUserId
+        }
+    }).then(function (newUser) {
+        if (newUser) {
+            models.AcActivity.findAll({
+                where: {
+                    domain_id: domainId,
+                    type: 'activity.post.status.change',
+                    user_id: oldUserId,
+                    created_at: {
+                        $lt: beforeDateObject
+                    }
+                }
+            }).then(function (activities) {
+                async.eachSeries(activities, function (activity, innerCallback) {
+                    activity.user_id = newUser.id;
+                    activity.save().then(function (results) {
+                        console.log('Adding admin user to missing status updates for activities ' + newUser.email);
+                        innerCallback();
+                    });
+                }, function (error) {
+                    console.info("Completed");
+                    process.exit();
+                });
+            });
+        }
+        else {
+            console.error("Missing user");
+            process.exit();
+        }
+    });
+}
+export {};

package/dist/scripts/gallery/exportGalleryData.js

@@ -0,0 +1,40 @@
+const models = require("../../models/index.cjs");
+const _ = require("lodash");
+const fs = require("fs").promises;
+const groupId = process.argv[2];
+const outFile = process.argv[3];
+const clean = (text) => text
+    .replace(/["\n\r]/g, "")
+    .replace(/,/g, ";")
+    .replace(/´/g, "")
+    .trim();
+const getYear = (post) => post.public_data &&
+    post.public_data.galleryMetaData &&
+    post.public_data.galleryMetaData.Upphafsar
+    ? post.public_data.galleryMetaData.Upphafsar
+    : "";
+const main = async () => {
+    const group = await models.Group.findByPk(groupId, { attributes: ["name"] });
+    const posts = await models.Post.unscoped().findAll({
+        where: { group_id: groupId },
+        order: [["counter_endorsements_up", "desc"]],
+        include: [{ model: models.User, required: true }],
+    });
+    let outFileContent = `"${group.name}"\n"Atkvæðafjöldi","Nafn listmanns","Heiti verks ísl.","Heiti verks en.","Ártal verks"\n`;
+    for (const post of posts) {
+        if (!post.deleted) {
+            outFileContent +=
+                `${post.counter_endorsements_up},"${clean(post.description)}","${clean(post.name)}",` + `"","${getYear(post)}"\n`;
+        }
+    }
+    try {
+        await fs.writeFile(outFile, outFileContent);
+        console.log("The file was saved!");
+        process.exit();
+    }
+    catch (err) {
+        console.log(err);
+    }
+};
+main();
+export {};

package/dist/scripts/gallery/importGalleryForCommunity.js

@@ -0,0 +1,168 @@
+const models = require("../../models/index.cjs");
+const moment = require("moment");
+const fs = require("fs");
+const path = require("path");
+const http = require("https");
+const sizeOf = require("image-size");
+const jsonPath = process.argv[2]; // "/home/robert/Downloads/finalMyndThin.json";
+//TODO: Finna út úr að gera þetta frá URLI!
+const imageFolderPath = "/home/robert/Downloads/myndlistinOkkar/myndir/MyndlistinOkkar2023V2/"; //process.argv[3];
+//const groupId = 28478; //process.argv[4];
+const userId = 850; //process.argv[5];
+const groupIds = {
+    "Málverk - fyrir 1973": 28838,
+    "Málverk - eftir 1973": 28837,
+    "Málverk - án ártals": 28839,
+    "Þrívíð verk": 28840,
+    "Ljósmyndaverk": 28841,
+    "Önnur verk": 28843,
+    "Teikningar": 28844,
+    "Grafík": 28842,
+};
+LOCAL_TEST = false;
+const urlbase = "https://yrpri-eu-direct-assets.s3.eu-west-1.amazonaws.com/MyndlistinOkkar2023V2/";
+const createPost = async (groupId, groupName, name, description, imageFileName, imageFilePath, metaData) => {
+    return new Promise(async (resolve, reject) => {
+        try {
+            const imageUrl = urlbase + imageFileName;
+            let imageDimensions;
+            if (LOCAL_TEST) {
+                try {
+                    imageDimensions = sizeOf(imageFilePath);
+                    console.log(imageDimensions.width, imageDimensions.height);
+                }
+                catch (error) {
+                    resolve();
+                    return;
+                }
+            }
+            else {
+                imageDimensions = { width: 1000, height: 1000 };
+            }
+            console.error(imageUrl);
+            const formats = JSON.stringify([imageUrl, imageUrl, imageUrl]);
+            const image = models.Image.build({
+                user_id: userId,
+                s3_bucket_name: process.env.S3_BUCKET || "fromScript",
+                original_filename: imageFileName,
+                formats,
+                user_agent: "Script",
+                ip_address: "127.0.0.1",
+            });
+            await image.save();
+            const post = models.Post.build({
+                user_id: userId,
+                group_id: groupId,
+                name,
+                description,
+                content: description,
+                status: "published",
+                user_agent: "Script",
+                ip_address: "127.0.0.1",
+                content_type: models.Post.CONTENT_IDEA,
+            });
+            post.set("public_data", {
+                galleryMetaData: metaData,
+                galleryImageData: {
+                    width: imageDimensions.width,
+                    height: imageDimensions.height,
+                },
+            });
+            await post.save();
+            console.log(JSON.stringify(post));
+            await post.addPostHeaderImage(image);
+            resolve();
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
+};
+// Empty anonymous function to avoid async/await error
+(async () => {
+    if (LOCAL_TEST) {
+        fs.readFile(jsonPath, "utf8", async function (err, data) {
+            if (err)
+                throw err;
+            const obj = JSON.parse(data);
+            await downloadImages(obj);
+            process.exit();
+        });
+    }
+    else {
+        // Load the JSON file with http request and then call the downloadImages function
+        const obj = await new Promise((resolve, reject) => {
+            http.get(jsonPath, (resp) => {
+                let data = "";
+                // A chunk of data has been received.
+                resp.on("data", (chunk) => {
+                    data += chunk;
+                });
+                // The whole response has been received. Print out the result.
+                resp.on("end", () => {
+                    resolve(JSON.parse(data));
+                });
+            });
+        });
+        await downloadImages(obj);
+        process.exit();
+    }
+})();
+async function downloadImages(obj) {
+    // Loop through the array of objects
+    const theData = obj.response.data;
+    for (let i = 0; i < theData.length; i++) {
+        // Get the image url
+        const imageUrl = theData[i].fieldData.Mynd;
+        const postDescription = theData[i].fieldData.ListamadurHofundur;
+        const postName = theData[i].fieldData.Verkheiti;
+        const year = theData[i].fieldData["Upphafsar"];
+        let groupName = theData[i].fieldData["Ljósmynd af"];
+        if (groupName == "Málverk") {
+            if (isNaN(year)) {
+                groupName = "Málverk - án ártals";
+            }
+            else if (year < 1973) {
+                groupName = "Málverk - fyrir 1973";
+            }
+            else {
+                groupName = "Málverk - eftir 1973";
+            }
+        }
+        const groupId = groupIds[groupName];
+        if (!groupId) {
+            console.error("No group found for: " + JSON.stringify(theData[i].fieldData));
+        }
+        else {
+            const metaData = theData[i].fieldData;
+            //console.log(imageUrl);
+            if (imageUrl && imageUrl.startsWith("https://")) {
+                // Get the image name
+                //console.log(theData[i])
+                //console.log(imageUrl);
+                let imageName = imageUrl.split("/").pop().split("?")[0];
+                imageName = imageName.split("/").pop();
+                imageName = imageName.replace(/'/g, "");
+                //console.log(imageName);
+                // Download the image
+                //console.log(imageName, postName, postDescription, metaData)
+                //await download(imageUrl, imageName);
+                if (imageName.indexOf(".jpg") == -1) {
+                    console.log("--------------------------------------");
+                    console.log(postName);
+                    console.log(postDescription);
+                    console.error(imageName);
+                }
+                else {
+                    await createPost(groupId, groupName, postName, postDescription, imageName, `${imageFolderPath}${imageName}`, metaData);
+                }
+                // change imageName to a random string from randomImages
+                //imageName = randomImages[Math.floor(Math.random() * randomImages.length)];
+            }
+            else {
+                console.error("No valid image found for: " + JSON.stringify(theData[i].fieldData));
+            }
+        }
+    }
+}
+export {};

package/dist/scripts/gallery/readJsonAndDownloadImagesVersion2.js

@@ -0,0 +1,55 @@
+// Read path to json and image folder from the command line
+// Read json file and download images
+// Usage: node readJsonAndDownloadImages.js <path to json file> <path to image folder>
+const fs = require("fs");
+const path = require("path");
+const http = require("https");
+const jsonPath = process.argv[2];
+const imageFolderPath = process.argv[3];
+// Read and parse json file, use the callback function to download images
+fs.readFile(jsonPath, "utf8", function (err, data) {
+    if (err)
+        throw err;
+    const obj = JSON.parse(data);
+    downloadImages(obj);
+});
+async function downloadImages(obj) {
+    // Loop through the array of objects
+    const theData = obj.response.data;
+    for (let i = 0; i < theData.length; i++) {
+        // Get the image url
+        const imageUrl = theData[i].fieldData.Mynd;
+        if (imageUrl && imageUrl.startsWith("https://")) {
+            // Get the image name
+            //console.log(theData[i])
+            //console.log(imageUrl);
+            let imageName = imageUrl.split("/").pop().split("?")[0];
+            imageName = imageName.split("/").pop();
+            imageName = imageName.replace(/'/g, "");
+            //console.log(imageName);
+            // Download the image
+            await download(imageUrl, imageName);
+            console.log(`"${imageName}",`);
+        }
+        else {
+            console.error("No valid image found for: " + JSON.stringify(theData[i].fieldData));
+        }
+    }
+}
+// Download and save the image from url using the http module
+async function download(url, imageName) {
+    url = "https://www.citizens.is/wp-content/uploads/2020/01/cf-logo-small-final.jpg";
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(`${imageFolderPath}/${imageName}`);
+        const request = http.get(url, function (response) {
+            response.pipe(file);
+            // after download completed close filestream
+            file.on("finish", () => {
+                file.close();
+                //console.log(`${imageName} downloaded`);
+                resolve();
+            });
+        });
+    });
+}
+export {};

package/dist/scripts/gallery/refreshAcApiPostIdsForCommunity.js

@@ -0,0 +1,58 @@
+const queue = require('../../active-citizen/workers/queue.cjs');
+const models = require("../../models/index.cjs");
+(async () => {
+    console.log("Start");
+    let offset = 0;
+    let count = 0;
+    let continueFetching = true;
+    const chunkSize = 100;
+    const communityId = process.argv[2];
+    const postsProcessed = {};
+    while (continueFetching) {
+        console.log(`Fetching posts ${offset} to ${offset + chunkSize - 1}...`);
+        const posts = await models.Post.findAll({
+            attributes: [
+                "id", "name"
+            ],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ['id'],
+                    include: [
+                        {
+                            model: models.Community,
+                            attributes: ['id'],
+                            where: {
+                                id: process.argv[2]
+                            }
+                        }
+                    ]
+                }
+            ],
+            limit: chunkSize,
+            offset: offset
+        });
+        // Process the posts
+        for (let p = 0; p < posts.length; p++) {
+            console.log(`${posts[p].id} ${posts[p].name}`);
+            queue.add('process-similarities', { type: 'update-collection', postId: posts[p].id }, 'low');
+            await new Promise(resolve => setTimeout(resolve, 150));
+            count++;
+            if (postsProcessed[posts[p].id]) {
+                console.error(`Post ${posts[p].id} already processed!`);
+            }
+            else {
+                postsProcessed[posts[p].id] = true;
+            }
+        }
+        // Check if there are fewer posts than the chunk size, which indicates that it's the last chunk
+        if (posts.length < chunkSize) {
+            continueFetching = false;
+        }
+        else {
+            offset += chunkSize;
+        }
+    }
+    console.log(`Done. Processed ${count} posts.`);
+})();
+export {};

package/dist/scripts/genderAnalysis.js

@@ -0,0 +1,63 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var femalePostCount = 0;
+var malePostCount = 0;
+var unknownPostCount = 0;
+var femalePointCount = 0;
+var malePointCount = 0;
+var unknownPointCount = 0;
+var femaleEndorsementCount = 0;
+var maleEndorsementCount = 0;
+var unknownEndorsementCount = 0;
+models.Domain.findOne({ where: { id: 1 } }).then(function (domain) {
+    domain.getDomainUsers().then(function (users) {
+        async.eachSeries(users, function (user, callback) {
+            models.Post.findAll({ where: { user_id: user.id } }).then(function (posts) {
+                if ((user.name.indexOf('dottir') > -1) || (user.name.indexOf('dóttir') > -1)) {
+                    femalePostCount += posts.length;
+                }
+                else if ((user.name.indexOf('sson') > -1) || (user.name.indexOf('son') > -1)) {
+                    malePostCount += posts.length;
+                }
+                else {
+                    console.log(user.name);
+                    unknownPostCount += posts.length;
+                }
+                models.Point.findAll({ where: { user_id: user.id } }).then(function (points) {
+                    if ((user.name.indexOf('dottir') > -1) || (user.name.indexOf('dóttir') > -1)) {
+                        femalePointCount += points.length;
+                    }
+                    else if ((user.name.indexOf('sson') > -1) || (user.name.indexOf('son') > -1)) {
+                        malePointCount += points.length;
+                    }
+                    else {
+                        unknownPointCount += points.length;
+                    }
+                    models.Endorsement.findAll({ where: { user_id: user.id } }).then(function (endorsements) {
+                        if ((user.name.indexOf('dottir') > -1) || (user.name.indexOf('dóttir') > -1)) {
+                            femaleEndorsementCount += endorsements.length;
+                        }
+                        else if ((user.name.indexOf('sson') > -1) || (user.name.indexOf('son') > -1)) {
+                            maleEndorsementCount += endorsements.length;
+                        }
+                        else {
+                            unknownEndorsementCount += endorsements.length;
+                        }
+                        callback();
+                    });
+                });
+            });
+        }, function done() {
+            console.log("femalePostCount: " + femalePostCount);
+            console.log("malePostCount: " + malePostCount);
+            console.log("unknownPostCount: " + unknownPostCount);
+            console.log("femalePointCount: " + femalePointCount);
+            console.log("malePointCount: " + malePointCount);
+            console.log("unknownPointCount: " + unknownPointCount);
+            console.log("femaleEndorsementCount: " + femaleEndorsementCount);
+            console.log("maleEndorsementCount: " + maleEndorsementCount);
+            console.log("unknownEndorsementCount: " + unknownEndorsementCount);
+        });
+    });
+});
+export {};

package/dist/scripts/genderAnalysisByStatus.js

@@ -0,0 +1,62 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var femalePostCount = 0;
+var malePostCount = 0;
+var unknownPostCount = 0;
+var translateOfficialStatus = function (status) {
+    if (status == [0]) {
+        return "Open";
+    }
+    else if (status == [-2]) {
+        return "Failed";
+    }
+    else if (status == [-1, 1]) {
+        return "InProgress";
+    }
+    else if (status == [2]) {
+        return "Successful";
+    }
+};
+models.Domain.findOne({ where: { id: 1 } }).then(function (domain) {
+    domain.getDomainUsers().then(function (users) {
+        async.eachSeries([[0], [-2], [-1, 1], [2]], function (officialStatus, outerSeriesCallback) {
+            async.eachSeries(users, function (user, callback) {
+                async.series([
+                    function (innerCallback) {
+                        models.Post.findAll({
+                            where: {
+                                user_id: user.id,
+                                official_status: {
+                                    $in: officialStatus
+                                }
+                            }
+                        }).then(function (posts) {
+                            if ((user.name.indexOf('dottir') > -1) || (user.name.indexOf('dóttir') > -1)) {
+                                femalePostCount += posts.length;
+                            }
+                            else if ((user.name.indexOf('sson') > -1) || (user.name.indexOf('son') > -1)) {
+                                malePostCount += posts.length;
+                            }
+                            else {
+                                unknownPostCount += posts.length;
+                            }
+                            innerCallback();
+                        });
+                    }
+                ], function () {
+                    callback();
+                });
+            }, function () {
+                console.log("Ideas " + translateOfficialStatus(officialStatus));
+                console.log("femalePostCount: " + femalePostCount);
+                console.log("malePostCount: " + malePostCount);
+                console.log("unknownPostCount: " + unknownPostCount);
+                femalePostCount = 0;
+                malePostCount = 0;
+                unknownPostCount = 0;
+                outerSeriesCallback();
+            });
+        });
+    });
+});
+export {};