@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/keys/addOidcToDomain.cjs

@@ -0,0 +1,61 @@
+"use strict";
+const models = require('../../models/index.cjs');
+const async = require('async');
+const domainId = process.argv[2];
+const clientId = process.argv[3];
+const clientSecret = process.argv[4];
+const issuer = process.argv[5];
+const authorizationURL = process.argv[6];
+const tokenURL = process.argv[7];
+const userInfoURL = process.argv[8];
+console.log(`Updating OIDC keys for domain ${domainId}`);
+async.series([
+    function (callback) {
+        models.Domain.findOne({
+            where: {
+                id: domainId
+            }
+        }).then(function (domain) {
+            if (domain) {
+                console.log(`Found domain: ${domain.name}`);
+                // Initialize secret_api_keys if it doesn't exist
+                if (!domain.secret_api_keys) {
+                    domain.secret_api_keys = {};
+                }
+                // Initialize or update oidc keys
+                domain.secret_api_keys.oidc = {
+                    client_id: clientId,
+                    client_secret: clientSecret,
+                    issuer: issuer,
+                    authorizationURL: authorizationURL,
+                    tokenURL: tokenURL,
+                    userInfoURL: userInfoURL
+                };
+                console.log("Updated secret_api_keys:", JSON.stringify(domain.secret_api_keys, null, 2));
+                domain.changed('secret_api_keys', true);
+                domain.save({ fields: ['secret_api_keys'] }).then(() => {
+                    console.log("OIDC keys updated successfully");
+                    callback();
+                }).catch((error) => {
+                    console.error("Error saving domain:", error);
+                    callback(error);
+                });
+            }
+            else {
+                console.log("Can't find domain");
+                callback("Can't find domain");
+            }
+        }).catch((error) => {
+            console.error("Error finding domain:", error);
+            callback(error);
+        });
+    }
+], function (error) {
+    if (error) {
+        console.error("An error occurred:", error);
+    }
+    else {
+        console.log("Finished successfully");
+    }
+    process.exit();
+});

package/dist/scripts/landUseGame/export3Ddata.js

@@ -0,0 +1,162 @@
+const { post } = require("request");
+const queue = require("../../active-citizen/workers/queue.cjs");
+const models = require("../../models/index.cjs");
+const fs = require("fs");
+const axios = require("axios");
+async function axiosWrapper(url, options = {}) {
+    // Set default headers if not provided
+    const headers = options.headers || {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+    };
+    // Perform the HTTP request using axios and return the response directly
+    try {
+        const response = await axios({
+            method: options.method || "get", // Default to 'get' if method is not specified
+            url: url,
+            headers: headers,
+            data: options.body, // In axios, 'data' is used instead of 'body'
+            ...options, // Spread the remaining options in case there are other axios-specific options provided
+        });
+        // Returning the data property of the response which is the actual body of the HTTP response
+        return response.data;
+    }
+    catch (error) {
+        // For simplicity, the error is logged and then rethrown
+        console.error("Error", error.message);
+        throw error;
+    }
+}
+async function getPoints(groupId, parentPointId) {
+    const url = `https://betraisland.is/api/groups/${groupId}/${parentPointId}/get_parent_point`;
+    console.log(`Fetching point ${parentPointId} ${url}`);
+    try {
+        const outPoints = [];
+        const point = await axiosWrapper(url);
+        console.log(`Fetched point ${parentPointId}`);
+        if (point && point.PointRevisions && point.PointRevisions.length > 0) {
+            point.latestContent =
+                point.PointRevisions[point.PointRevisions.length - 1].content;
+            point.content = point.latestContent;
+            outPoints.push(point);
+            const commentsUrl = `https://betraisland.is/api/points/${parentPointId}/comments`;
+            console.log(`Fetching comments ${commentsUrl}`);
+            const comments = await axiosWrapper(commentsUrl);
+            console.error(`Fetched comments ${JSON.stringify(comments, null, 2)}`);
+            for (const comment of comments) {
+                comment.latestContent =
+                    comment.PointRevisions[comment.PointRevisions.length - 1].content;
+                comment.content = comment.latestContent;
+                outPoints.push(comment);
+            }
+            return outPoints;
+        }
+        else {
+            throw new Error(`No point revisions for point ${parentPointId}`);
+        }
+    }
+    catch (error) {
+        // Handle errors specific to getPoints if necessary
+        console.error(`Failed to get points for post ${parentPointId}:`, error);
+        // Re-throw the error or handle it as per your application's error handling policy
+        throw error;
+    }
+}
+function convertToCsv(dataArray) {
+    let csvString = "rectangle,groupId,postId,userId,landUseType,comment\n"; // Headers
+    dataArray.forEach((tile) => {
+        const row = `${tile.rectangle},${tile.groupId},${tile.postId},${tile.userId},${tile.landUseType},"${tile.comment}"\n`;
+        csvString += row;
+    });
+    return csvString;
+}
+let newTilesData = [];
+let tilesData = [];
+(async () => {
+    console.log("Start export");
+    let offset = 0;
+    let count = 0;
+    let continueFetching = true;
+    const chunkSize = 5000;
+    const communityId = process.argv[2];
+    const postsProcessed = {};
+    let outCsvText = "rectangle,groupId,userId,landUseType,comment";
+    console.log(`Fetching posts ${offset} to ${offset + chunkSize - 1}...`);
+    const posts = await models.Post.findAll({
+        attributes: ["id", "name", "user_id", "group_id", "data"],
+        include: [
+            {
+                model: models.Group,
+                attributes: ["id"],
+                where: {
+                    id: process.argv[2],
+                },
+            },
+        ],
+        limit: chunkSize,
+        offset: offset,
+    });
+    console.log(`Post length ${posts.length}`);
+    // Process the posts
+    for (let p = 0; p < posts.length; p++) {
+        const post = posts[p];
+        console.log(`${post.id} ${post.name}`);
+        if (post.data &&
+            post.data.publicPrivateData &&
+            post.data.publicPrivateData.length) {
+            // Loop through each item in the publicPrivateData array
+            post.data.publicPrivateData.forEach((item) => {
+                // Extract the landUseType, rectangleIndex, and pointId
+                const { landUseType, rectangleIndex, pointId } = item;
+                // Construct a tile data object
+                const tileData = { landUseType, rectangleIndex, pointId, post };
+                // Add the tile data object to an array or however you choose to store it
+                // For example, pushing it into an array:
+                tilesData.push(tileData);
+            });
+        }
+        else {
+            console.warn(`Post ${post.id} has no publicPrivateData`);
+        }
+    }
+    for (const tile of tilesData) {
+        if (tile.pointId) {
+            try {
+                const pointsWithComments = await getPoints(tile.post.group_id, tile.pointId);
+                console.log(`Fetched ${pointsWithComments.length} points for post ${tile.pointId} ${JSON.stringify(pointsWithComments, null, 2)}`);
+                for (const point of pointsWithComments) {
+                    let newTileData = {
+                        rectangle: tile.rectangleIndex,
+                        groupId: tile.post.group_id,
+                        userId: tile.post.user_id,
+                        landUseType: tile.landUseType,
+                        postId: tile.post.id,
+                        comment: point.content,
+                    };
+                    console.log(`New tile data ${JSON.stringify(newTileData, null, 2)}`);
+                    newTilesData.push(newTileData);
+                }
+                count += pointsWithComments.length;
+            }
+            catch (error) {
+                console.error(`Error fetching points for post ${tile.pointId}:`, error);
+                process.exit(1);
+            }
+        }
+        else {
+            newTilesData.push({
+                rectangle: tile.rectangleIndex,
+                groupId: tile.post.group_id,
+                userId: tile.post.user_id,
+                postId: tile.post.id,
+                landUseType: tile.landUseType,
+                comment: "",
+            });
+        }
+    }
+    const csvData = convertToCsv(newTilesData);
+    fs.writeFileSync(`/tmp/landUseGameGroup${process.argv[2]}.csv`, csvData);
+    console.log(`Done. Processed ${count} posts.`);
+    process.exit(0);
+})();
+export {};

package/dist/scripts/listLanguagesForGroup.js

@@ -0,0 +1,54 @@
+const models = require('../models/index.cjs');
+const async = require('async');
+const groupId = 2102; //process.argv[2];
+let points;
+let posts;
+async.series([
+    (seriesCallback) => {
+        models.Post.findAll({
+            where: {
+                group_id: groupId
+            },
+            attributes: ['id', 'language']
+        }).then((postsIn) => {
+            posts = postsIn;
+            seriesCallback();
+        }).catch((error) => {
+            seriesCallback(error);
+        });
+    },
+    (seriesCallback) => {
+        models.Point.findAll({
+            where: {
+                group_id: groupId
+            },
+            attributes: ['id', 'language']
+        }).then((pointsIn) => {
+            points = pointsIn;
+            seriesCallback();
+        }).catch((error) => {
+            seriesCallback(error);
+        });
+    },
+], (error) => {
+    if (error) {
+        console.error(error);
+    }
+    else {
+        if (posts) {
+            console.log("Posts");
+            posts.forEach((post) => {
+                console.log(post.id + " - " + post.language);
+            });
+        }
+        if (points) {
+            console.log("Points");
+            points.forEach((point) => {
+                console.log(point.id + " - " + point.language);
+            });
+        }
+    }
+    console.log("Done");
+    process.exit();
+});
+export {};

package/dist/scripts/loadTestCreateDummyContentForGroup.js

@@ -0,0 +1,27 @@
+const models = require('../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const randomWords = require('random-words');
+const groupId = process.argv[2];
+let addedPosts = 0;
+async.doUntil((innerCallback) => {
+    models.Post.create({
+        name: randomWords({ min: 5, max: 11 }).join(" "),
+        description: randomWords({ min: 10, max: 110 }).join(" "),
+        status: 'published',
+        official_status: 0,
+        language: 'en',
+        group_id: groupId,
+        content_type: models.Post.CONTENT_IDEA,
+        user_agent: "script",
+        ip_address: ip.address()
+    }).then((post) => {
+        addedPosts += 1;
+        console.log("Added post id: " + post.id);
+        innerCallback();
+    });
+}, () => addedPosts > 5000, (error) => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/scripts/makeRecursiveMapData.js

@@ -0,0 +1,103 @@
+const models = require('../models/index.cjs');
+const util = require('util');
+const communityId = 1264; //process.argv[2];
+async function getTranslationForMap(textType, model, targetLanguage) {
+    return await new Promise((resolve, reject) => {
+        models.AcTranslationCache.getTranslation({ query: { textType, targetLanguage } }, model, async (error, translation) => {
+            if (!error && translation) {
+                resolve(translation.content);
+            }
+            else {
+                resolve();
+                console.log("No translation");
+            }
+        });
+    });
+}
+const truncate = (input, length, killwords, end) => {
+    length = length || 255;
+    if (input.length <= length)
+        return input;
+    if (killwords) {
+        input = input.substring(0, length);
+    }
+    else {
+        let idx = input.lastIndexOf(' ', length);
+        if (idx === -1) {
+            idx = length;
+        }
+        input = input.substring(0, idx);
+    }
+    input += (end !== undefined && end !== null) ? end : '...';
+    return input;
+};
+const getCommunityMap = async (communityId, map) => {
+    return await new Promise((resolve, reject) => {
+        models.Community.findOne({
+            where: {
+                id: communityId
+            },
+            attributes: ['id', 'name'],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ['id', 'name', 'configuration'],
+                    required: false
+                }
+            ]
+        }).then(async (community) => {
+            if (community) {
+                let communityName = await getTranslationForMap("communityName", community, "en");
+                if (!communityName) {
+                    communityName = community.name;
+                }
+                const newCommunity = {
+                    name: truncate(communityName, 25) + `(C-${community.id})`,
+                    type: "Community", children: []
+                };
+                for (const group of community.Groups) {
+                    let groupName = await getTranslationForMap("groupName", group, "en");
+                    if (!groupName) {
+                        groupName = group.name;
+                    }
+                    if (group.configuration.actAsLinkToCommunityId) {
+                        groupName = "(L)";
+                    }
+                    else {
+                        groupName = truncate(groupName, 25) + `(G-${group.id}`;
+                    }
+                    const newEntry = {
+                        name: groupName,
+                        children: []
+                    };
+                    newCommunity.children.push(newEntry);
+                    if (group.configuration.actAsLinkToCommunityId) {
+                        await getCommunityMap(group.configuration.actAsLinkToCommunityId, newEntry);
+                    }
+                }
+                map.children.push(newCommunity);
+                resolve();
+            }
+            else {
+                console.error("Cant find community " + communityId);
+                map.children.push({ name: "Not found community id " + communityId, children: [] });
+                resolve();
+            }
+        }).catch(error => {
+            reject(error);
+        });
+    });
+};
+const run = async () => {
+    let map = { name: "Aris", children: [] };
+    try {
+        await getCommunityMap(communityId, map);
+    }
+    catch (error) {
+        console.error(error);
+    }
+    console.log(util.inspect(map, { showHidden: false, depth: null }));
+    process.exit();
+};
+run();
+export {};

package/dist/scripts/mapping/community_map_csv.js

@@ -0,0 +1,145 @@
+const models = require('../../models/index.cjs');
+const _ = require('lodash');
+const communityId = process.argv[2];
+let groupsInCommunity = [];
+let communities = [];
+async function getTranslationForMap(textType, model, targetLanguage) {
+    return await new Promise((resolve, reject) => {
+        models.AcTranslationCache.getTranslation({ query: { textType, targetLanguage } }, model, async (error, translation) => {
+            if (!error && translation) {
+                resolve(translation.content);
+            }
+            else {
+                resolve();
+                console.log("No translation");
+            }
+        });
+    });
+}
+const truncate = (input, length, killwords, end) => {
+    length = length || 255;
+    if (input.length <= length)
+        return input;
+    if (killwords) {
+        input = input.substring(0, length);
+    }
+    else {
+        let idx = input.lastIndexOf(' ', length);
+        if (idx === -1) {
+            idx = length;
+        }
+        input = input.substring(0, idx);
+    }
+    input += (end !== undefined && end !== null) ? end : '...';
+    return input;
+};
+const getCommunityMap = async (communityId, map, options) => {
+    return await new Promise((resolve, reject) => {
+        models.Community.findOne({
+            where: {
+                id: communityId
+            },
+            attributes: ['id', 'name'],
+            include: [
+                {
+                    model: models.Group,
+                    attributes: ['id', 'name', 'configuration', 'community_id'],
+                    required: false
+                }
+            ]
+        }).then(async (community) => {
+            if (community) {
+                communities.push(community);
+                let communityName;
+                if (options.targetLocale) {
+                    communityName = await getTranslationForMap("communityName", community, "en");
+                }
+                else {
+                    communityName = community.name;
+                }
+                if (!communityName) {
+                    communityName = community.name;
+                }
+                const newCommunity = {
+                    name: truncate(communityName, 25) + ` (C-${community.id})`,
+                    link: "/community/" + community.id,
+                    type: "Community", children: []
+                };
+                for (const group of community.Groups) {
+                    let groupName;
+                    if (options.targetLocale) {
+                        groupName = await getTranslationForMap("groupName", group, "en");
+                    }
+                    else {
+                        groupName = group.name;
+                    }
+                    if (!groupName) {
+                        groupName = group.name;
+                    }
+                    groupName = truncate(groupName, 25) + ` (G-${group.id})`;
+                    if (group.configuration.actAsLinkToCommunityId) {
+                        await getCommunityMap(group.configuration.actAsLinkToCommunityId, newCommunity, options);
+                    }
+                    else {
+                        const newEntry = {
+                            name: groupName,
+                            link: "/group/" + group.id,
+                            id: group.id,
+                            realGroupName: group.name,
+                            communityId: group.community_id,
+                            children: []
+                        };
+                        groupsInCommunity.push(newEntry);
+                        newCommunity.children.push(newEntry);
+                    }
+                }
+                map.children.push(newCommunity);
+                resolve();
+            }
+            else {
+                console.error("Cant find community " + communityId);
+                map.children.push({ name: "Not found community id " + communityId, children: [] });
+                resolve();
+            }
+        }).catch(error => {
+            reject(error);
+        });
+    });
+};
+const getMapForCommunity = async (communityId, options) => {
+    return await new Promise((resolve, reject) => {
+        models.Community.findOne({
+            where: {
+                id: communityId
+            },
+            attributes: ['name', 'id']
+        }).then(async (community) => {
+            communities.push(community);
+            let map = { name: community.name, children: [] };
+            try {
+                await getCommunityMap(communityId, map, options);
+                resolve(map);
+            }
+            catch (error) {
+                reject(error);
+            }
+        }).catch(error => {
+            reject(error);
+        });
+    });
+};
+(async () => {
+    await getMapForCommunity(communityId, {});
+    console.log("Groups");
+    groupsInCommunity = _.orderBy(groupsInCommunity, group => {
+        return group.id;
+    });
+    groupsInCommunity.forEach(group => {
+        console.log(`${group.id},"${group.realGroupName}",${group.communityId}`);
+    });
+    communities.forEach(community => {
+        console.log(`${community.id},"${community.name}"`);
+    });
+    process.exit();
+})();
+export {};

package/dist/scripts/moveCommunityToDomain.js

@@ -0,0 +1,22 @@
+const models = require('../models/index.cjs');
+const communityId = process.argv[2];
+const domainId = process.argv[3];
+models.Community.findOne({
+    where: {
+        id: communityId
+    },
+    attributes: ['id', 'domain_id']
+}).then(community => {
+    community.domain_id = domainId;
+    community.save().then(() => {
+        console.log(`Done changing community ${community.id} to domain ${community.domain_id}`);
+        process.exit();
+    }).catch(error => {
+        console.error(error);
+        process.exit();
+    });
+}).catch(error => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/scripts/moveGroupToCommunity.js

@@ -0,0 +1,23 @@
+const models = require('../models/index.cjs');
+const async = require('async');
+const groupId = process.argv[2];
+const communityId = process.argv[3];
+models.Group.findOne({
+    where: {
+        id: groupId
+    },
+    attributes: ['id', 'community_id']
+}).then(group => {
+    group.community_id = communityId;
+    group.save().then(() => {
+        console.log(`Done changing group ${group.id} to community ${group.community_id}`);
+        process.exit();
+    }).catch(error => {
+        console.error(error);
+        process.exit();
+    });
+}).catch(error => {
+    console.error(error);
+    process.exit();
+});
+export {};