@yrpri/api 9.0.103 → 9.0.105

package/dist/scripts/keys/addOidcToDomain.cjs

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

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

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

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

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

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

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

@@ -1,23 +0,0 @@
-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 {};