@yrpri/api 9.0.101 → 9.0.103

package/dist/scripts/cleanups/deleteLinkGroupsWithDeletedCommunities.js

@@ -0,0 +1,62 @@
+const models = require('../../models/index.cjs');
+const moment = require('moment');
+const maxNumberFromPath = process.argv[2];
+const maxNumberOfGroupsToDelete = maxNumberFromPath ? maxNumberFromPath : 1000;
+let numberOfDeletedGroups = 0;
+let startTime = moment();
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+(async () => {
+    let haveGroupsToDelete = true;
+    let allDeletions = "";
+    try {
+        let haveGroupsLeftToProcess = true;
+        let groupsOffset = 0;
+        while (haveGroupsLeftToProcess && numberOfDeletedGroups < maxNumberOfGroupsToDelete) {
+            const groups = await models.Group.findAll({
+                limit: 100,
+                offset: groupsOffset,
+                order: ['id'],
+                attributes: ['id', 'configuration', 'name', 'deleted'],
+            });
+            console.log(`${groups.length} groups offset ${groupsOffset}`);
+            if (groups.length > 0) {
+                groupsOffset += 100;
+                for (let i = 0; i < groups.length; i++) {
+                    if (groups[i].configuration &&
+                        groups[i].configuration.actAsLinkToCommunityId) {
+                        const community = await models.Community.findOne({
+                            where: {
+                                id: groups[i].configuration.actAsLinkToCommunityId
+                            },
+                            attributes: ['id']
+                        });
+                        if (!community) {
+                            const deleteText = `Deleting groupLink id ${groups[i].id} - name ${groups[i].name} - community id ${groups[i].configuration.actAsLinkToCommunityId}`;
+                            console.log(deleteText);
+                            allDeletions += `${deleteText}\n`;
+                            groups[i].deleted = true;
+                            await groups[i].save();
+                        }
+                    }
+                }
+            }
+            else {
+                haveGroupsLeftToProcess = false;
+                console.log("No more groups left to process from user");
+            }
+            await sleep(100);
+        }
+    }
+    catch (error) {
+        console.error(error);
+        haveGroupsToDelete = false;
+    }
+    console.log(`${numberOfDeletedGroups} old anon groups deleted`);
+    console.log(`Duration ${moment(moment() - startTime).format("HH:mm:ss.SSS")}`);
+    console.log("ALL DELETIONS");
+    console.log(allDeletions);
+    process.exit();
+})();
+export {};

package/dist/scripts/cleanups/deleteYearOldNotifications.cjs

@@ -0,0 +1,72 @@
+"use strict";
+const models = require('../../models/index.cjs');
+const moment = require('moment');
+const maxNumberFromPath = process.argv[2];
+// Default to 1,000,000 if no command line arg given, adjust as you see fit
+const maxNumberOfNotificationsToDelete = maxNumberFromPath ? parseInt(maxNumberFromPath) : 1000000;
+let numberOfDeletedNotifications = 0;
+const startTime = moment();
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function chunk(arr, size) {
+    return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) => arr.slice(i * size, i * size + size));
+}
+(async () => {
+    let haveNotificationsToDelete = true;
+    let offset = 0;
+    // Calculate the cutoff date for "older than 1 year"
+    const cutoffDate = moment().subtract(1, 'year').toISOString();
+    while (haveNotificationsToDelete && numberOfDeletedNotifications < maxNumberOfNotificationsToDelete) {
+        try {
+            // Fetch a batch of notifications older than 1 year
+            const notifications = await models.AcNotification.unscoped().findAll({
+                where: {
+                    created_at: {
+                        [models.Sequelize.Op.lte]: cutoffDate,
+                    },
+                },
+                limit: 1000,
+                offset: offset,
+                order: ['id'],
+                attributes: ['id'],
+            });
+            if (notifications.length > 0) {
+                console.log(`${notifications.length} notifications found at offset ${offset}`);
+                offset += 1000;
+                // Extract IDs and chunk them to avoid huge deletions in one query
+                const notificationIds = notifications.map(n => n.id);
+                const chunkedIds = chunk(notificationIds, 100);
+                // Delete chunk by chunk
+                for (const chunkIds of chunkedIds) {
+                    const destroyInfo = await models.AcNotification.unscoped().destroy({
+                        where: {
+                            id: {
+                                [models.Sequelize.Op.in]: chunkIds,
+                            },
+                        },
+                    });
+                    numberOfDeletedNotifications += destroyInfo;
+                    console.log(`Total deleted so far: ${numberOfDeletedNotifications}`);
+                    await sleep(10); // short pause
+                    // Stop if we’ve hit our daily (or run) limit
+                    if (numberOfDeletedNotifications >= maxNumberOfNotificationsToDelete) {
+                        break;
+                    }
+                }
+            }
+            else {
+                // No more notifications to delete
+                haveNotificationsToDelete = false;
+            }
+            await sleep(25); // short pause between big fetches
+        }
+        catch (error) {
+            console.error(error);
+            haveNotificationsToDelete = false;
+        }
+    }
+    console.log(`${numberOfDeletedNotifications} old notifications deleted`);
+    console.log(`Duration: ${moment(moment() - startTime).format('HH:mm:ss.SSS')}`);
+    process.exit();
+})();

package/dist/scripts/cleanups/removeAllUsersFromHiddenPublicGroup.js

@@ -0,0 +1,43 @@
+var models = require('../../models/index.cjs');
+var { forEach } = require('async');
+var _ = require('lodash');
+const async = require("async");
+models.Group.findOne({
+    where: {
+        name: 'hidden_public_group_for_domain_level_points'
+    },
+    attributes: ['id', 'name'],
+    include: [
+        {
+            model: models.User,
+            as: 'GroupUsers',
+            required: false
+        }
+    ]
+}).then(group => {
+    if (group && group.GroupUsers.length > 0) {
+        async.forEachSeries(group.GroupUsers, (user, forEachSeriesCallback) => {
+            group.removeGroupUser(user).then(() => {
+                console.log(`Removed ${user.email}`);
+                forEachSeriesCallback();
+            });
+        }, error => {
+            if (error) {
+                console.error(error);
+                process.exit();
+            }
+            else {
+                console.log("Finished");
+                process.exit();
+            }
+        });
+    }
+    else {
+        console.warn(`Group not found or empty`);
+        process.exit();
+    }
+}).catch(error => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/scripts/clearAllEndorsementInGroup.js

@@ -0,0 +1,50 @@
+var models = require('../models/index.cjs');
+var async = require('async');
+var _ = require('lodash');
+var groupId = process.argv[2];
+models.Post.unscoped().findAll({
+    where: {
+        group_id: groupId
+    },
+    attributes: ['id', 'counter_endorsements_up', "counter_endorsements_down"],
+    include: [
+        {
+            model: models.Endorsement,
+            attributes: ['id', 'deleted'],
+            required: false
+        }
+    ]
+}).then((posts) => {
+    async.eachSeries(posts, (post, callback) => {
+        post.counter_endorsements_up = 0;
+        post.counter_endorsements_down = 0;
+        post.save().then(() => {
+            async.eachSeries(post.Endorsements, (endorsement, innerCallback) => {
+                endorsement.deleted = true;
+                endorsement.save().then(() => {
+                    console.log(`Deleted endorsement for id ${endorsement.id}`);
+                    innerCallback();
+                }).catch(error => {
+                    innerCallback(error);
+                });
+            }, (error) => {
+                console.log(`Cleared endorsement for post id ${post.id}`);
+                callback(error);
+            });
+        }).catch(error => {
+            callback(error);
+        });
+    }, (error) => {
+        if (error) {
+            console.error(error);
+        }
+        else {
+            console.log("Done clearing");
+        }
+        process.exit();
+    });
+}).catch(error => {
+    console.error(error);
+    process.exit();
+});
+export {};

package/dist/scripts/cloning/clearUsersForCommunitiesFromUrl.js

@@ -0,0 +1,129 @@
+const models = require('../../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+const cloneTranslationForConfig = require('../../active-citizen/utils/translation_cloning').cloneTranslationForConfig;
+const userId = process.argv[2];
+const type = process.argv[3];
+const urlToConfig = process.argv[4];
+const urlToAddAddFront = process.argv[5];
+/*const userId = "89244" //process.argv[3];
+const type = "onlyThemeColors";
+const urlToConfig = "https://yrpri-eu-direct-assets.s3-eu-west-1.amazonaws.com/copyConfigCommunities7421.csv";
+const urlToAddAddFront = "https://kyrgyz-aris.yrpri.org/";*/
+// node server_api/scripts/cloneWBFromUrlScriptAndCreateLinks.js 3 84397 https://yrpri-eu-direct-assets.s3-eu-west-1.amazonaws.com/CF_clone_WB_140221.csv https://kyrgyz-aris.yrpri.org/
+let config;
+let finalOutput = '';
+let user;
+async.series([
+    seriesCallback => {
+        if (userId && type && urlToConfig && urlToAddAddFront) {
+            seriesCallback();
+        }
+        else {
+            seriesCallback("Not all values set");
+        }
+    },
+    (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 => {
+        models.User.findOne({
+            where: {
+                id: userId
+            }
+        }).then(userIn => {
+            if (userIn) {
+                user = userIn;
+                seriesCallback();
+            }
+            else {
+                seriesCallback("User not found");
+            }
+        }).catch(error => {
+            seriesCallback(error);
+        });
+    },
+    (seriesCallback) => {
+        let index = 0;
+        async.forEachSeries(config.split('\r\n'), (configLine, forEachCallback) => {
+            const splitLine = configLine.split(",");
+            process.stdout.write(".");
+            if (index == 0 || !configLine || configLine.length < 3 || !splitLine || splitLine.length !== 1) {
+                index += 1;
+                forEachCallback();
+            }
+            else {
+                const toCommunityId = splitLine[0];
+                let toCommunity;
+                async.series([
+                    innerSeriesCallback => {
+                        models.Community.findOne({
+                            where: {
+                                id: toCommunityId
+                            },
+                            attributes: ['id', 'name', 'configuration']
+                        }).then(communityIn => {
+                            if (communityIn) {
+                                toCommunity = communityIn;
+                                innerSeriesCallback();
+                            }
+                            else {
+                                innerSeriesCallback("to community not found");
+                            }
+                        }).catch(error => {
+                            innerSeriesCallback(error);
+                        });
+                    },
+                    innerSeriesCallback => {
+                        toCommunity.hasCommunityAdmins(user).then((results => {
+                            if (results) {
+                                innerSeriesCallback();
+                            }
+                            else {
+                                innerSeriesCallback("No access to toCommunity: " + toCommunity.id);
+                            }
+                        })).catch(error => {
+                            innerSeriesCallback(error);
+                        });
+                    },
+                    innerSeriesCallback => {
+                        toCommunity.set('counter_users', 1);
+                        toCommunity.save().then(() => {
+                            finalOutput += urlToAddAddFront + "community/" + toCommunity.id + "\n";
+                            innerSeriesCallback();
+                        }).catch(error => {
+                            innerSeriesCallback(error);
+                        });
+                    }
+                ], error => {
+                    forEachCallback(error);
+                });
+            }
+        }, error => {
+            seriesCallback(error);
+        });
+    },
+], error => {
+    if (error)
+        console.error(error);
+    console.log("All done copying config to communities");
+    console.log(finalOutput);
+    process.exit();
+});
+export {};

package/dist/scripts/cloning/cloneFromUrlScript.js

@@ -0,0 +1,65 @@
+const models = require('../../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+const copyCommunityWithEverything = require('../../utils/copy_utils').copyCommunityWithEverything;
+const communityId = process.argv[2];
+const domainId = process.argv[3];
+const urlToConfig = process.argv[4];
+let config;
+let finalOutput = '';
+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.forEachSeries(config.split('\r\n'), (configLine, forEachCallback) => {
+            if (!configLine || configLine.length < 3) {
+                forEachCallback();
+                u;
+            }
+            else {
+                copyCommunityWithEverything(communityId, domainId, {}, (error, community) => {
+                    if (error) {
+                        forEachCallback(error);
+                    }
+                    else {
+                        community.name = "DEMO: No Planet B - " + configLine;
+                        community.hostname = "demo-no-planet-b-" + configLine.toLowerCase().replace(/ /g, '-');
+                        community.save().then(() => {
+                            console.log(community.hostname);
+                            finalOutput += 'https://' + community.hostname + '.yrpri.org\n';
+                            forEachCallback();
+                        }).catch(error => {
+                            forEachCallback(error);
+                        });
+                    }
+                });
+            }
+        }, error => {
+            seriesCallback(error);
+        });
+    },
+], error => {
+    if (error)
+        console.error(error);
+    console.log("All done");
+    console.log(finalOutput);
+    process.exit();
+});
+export {};

package/dist/scripts/cloning/cloneWBFromUrlScriptAndCreateLinks.js

@@ -0,0 +1,140 @@
+const models = require('../../models/index.cjs');
+const async = require('async');
+const _ = require('lodash');
+const fs = require('fs');
+const request = require('request');
+const copyCommunityWithEverything = require('../../utils/copy_utils').copyCommunityWithEverything;
+const updateTranslation = require('../../active-citizen/utils/translation_helpers').updateTranslation;
+const domainId = process.argv[2];
+const userId = process.argv[3];
+const urlToConfig = process.argv[4];
+const urlToAddAddFront = process.argv[5];
+/*const domainId = "3"; //process.argv[2];
+const userId = "850" //process.argv[3];
+const urlToConfig = "https://yrpri-eu-direct-assets.s3-eu-west-1.amazonaws.com/ClonesARIS01.03-CFEdit.xlsx+-+OSH.csv";// process.argv[4];
+//const urlToAddAddFront = "https://kyrgyz-aris.yrpri.org/";
+const urlToAddAddFront = "http://localhost:4242/"; //process.argv[5];*/
+// node server_api/scripts/cloneWBFromUrlScriptAndCreateLinks.js 3 84397 https://yrpri-eu-direct-assets.s3-eu-west-1.amazonaws.com/CF_clone_WB_140221.csv https://kyrgyz-aris.yrpri.org/
+let config;
+let finalOutput = '';
+let finalTargetOutput = '';
+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) => {
+        let index = 0;
+        async.forEachSeries(config.split('\r\n'), (configLine, forEachCallback) => {
+            const splitLine = configLine.split(",");
+            if (index == 0 || !configLine || configLine.length < 3 || !splitLine || splitLine.length !== 5 || splitLine[0].length < 2) {
+                index += 1;
+                forEachCallback();
+            }
+            else {
+                const fromCommunityId = splitLine[0];
+                const linkToCommunityId = splitLine[1];
+                const englishName = splitLine[2].trim();
+                const russianName = splitLine[3].trim();
+                const kyrgyzName = splitLine[4].trim();
+                copyCommunityWithEverything(fromCommunityId, domainId, {}, (error, newCommunity) => {
+                    if (error) {
+                        forEachCallback(error);
+                    }
+                    else {
+                        models.Community.findOne({
+                            where: {
+                                id: linkToCommunityId
+                            },
+                            attributes: ['id', 'name']
+                        }).then(linkCommunity => {
+                            newCommunity.hostname = newCommunity.hostname + "-" + newCommunity.id;
+                            newCommunity.name = russianName;
+                            newCommunity.language = "ru";
+                            newCommunity.save().then(() => {
+                                newCommunity.set('configuration.customBackURL', linkToCommunityId);
+                                newCommunity.set('configuration.customBackName', linkCommunity.name);
+                                newCommunity.save().then(() => {
+                                    updateTranslation({
+                                        contentId: newCommunity.id,
+                                        textType: "communityName",
+                                        targetLocale: "en",
+                                        content: russianName,
+                                        translatedText: englishName
+                                    }, (error) => {
+                                        updateTranslation({
+                                            contentId: newCommunity.id,
+                                            textType: "communityName",
+                                            targetLocale: "ky",
+                                            content: russianName,
+                                            translatedText: kyrgyzName
+                                        }, (error) => {
+                                            console.log(newCommunity.id);
+                                            finalOutput += urlToAddAddFront + "community/" + newCommunity.id + "\n";
+                                            finalTargetOutput += urlToAddAddFront + "community/" + linkToCommunityId + "\n";
+                                            const linkModel = models.Group.build({
+                                                name: "Link for community - " + linkToCommunityId,
+                                                objectives: "Link for community - " + linkToCommunityId,
+                                                access: models.Group.ACCESS_PUBLIC,
+                                                user_id: userId,
+                                                configuration: { actAsLinkToCommunityId: newCommunity.id },
+                                                community_id: linkToCommunityId
+                                            });
+                                            linkModel.save().then((model) => {
+                                                models.User.findOne({
+                                                    where: {
+                                                        id: userId
+                                                    }
+                                                }).then(user => {
+                                                    linkModel.addGroupAdmin(user).then(function () {
+                                                        forEachCallback();
+                                                    }).catch((error) => {
+                                                        forEachCallback(error);
+                                                    });
+                                                }).catch(error => {
+                                                    forEachCallback(error);
+                                                });
+                                            }).catch(error => {
+                                                forEachCallback(error);
+                                            });
+                                        });
+                                    });
+                                }).catch(error => {
+                                    forEachCallback(error);
+                                });
+                            }).catch(error => {
+                                forEachCallback(error);
+                            });
+                        }).catch(error => {
+                            forEachCallback(error);
+                        });
+                    }
+                });
+            }
+        }, error => {
+            seriesCallback(error);
+        });
+    },
+], error => {
+    if (error)
+        console.error(error);
+    console.log("All done clones");
+    console.log(finalOutput);
+    console.log("All done targets");
+    console.log(finalTargetOutput);
+    process.exit();
+});
+export {};