@yrpri/api 9.0.103 → 9.0.105

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

@@ -1,21 +0,0 @@
-"use strict";
-module.exports = (input, length, killwords, end) => {
-    if (!input)
-        return '';
-    var orig = input;
-    length = length || 255;
-    if (input.length <= length)
-        return input;
-    if (killwords) {
-        input = input.substring(0, length);
-    }
-    else {
-        var idx = input.lastIndexOf(' ', length);
-        if (idx === -1) {
-            idx = length;
-        }
-        input = input.substring(0, idx);
-    }
-    input += (end !== undefined && end !== null) ? end : '...';
-    return input;
-};

package/dist/active-citizen/utils/updateAllLocalesFromEn.js

@@ -1,253 +0,0 @@
-import { jsonrepair } from "jsonrepair";
-import { OpenAI } from "openai";
-import * as fs from "fs";
-import * as path from "path";
-import { promisify } from "util";
-import { YpLanguages } from "../../utils/ypLanguages.js";
-const readFilePromise = promisify(fs.readFile);
-const writeFilePromise = promisify(fs.writeFile);
-export class YpLocaleTranslation {
-    constructor() {
-        this.modelName = "gpt-4o";
-        this.maxTokens = 4000;
-        this.temperature = 0.0;
-        this.excludeKeysFromTranslation = [
-            "facebook",
-            "twitter",
-            "linkedin",
-            "adwords",
-            "snapchat",
-            "instagram",
-            "youtube",
-            "tiktok",
-            "allOurIdeas"
-        ];
-        this.openaiClient = new OpenAI({
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    getValueByPath(obj, path) {
-        return path.split('.').reduce((acc, part) => acc && acc[part], obj) || "";
-    }
-    async loadAndCompareTranslations() {
-        const localesDir = "./locales";
-        const baseTranslationPath = path.join(localesDir, "en/translation.json");
-        const baseTranslation = await this.loadJsonFile(baseTranslationPath);
-        const localeDirs = fs
-            .readdirSync(localesDir)
-            .filter((file) => fs.statSync(path.join(localesDir, file)).isDirectory());
-        for (const localeDir of localeDirs) {
-            if (localeDir === "en")
-                continue; // Skip English since it's the base
-            console.log(`Processing locale: ${localeDir}`);
-            const translationFilePath = path.join(localesDir, localeDir, "translation.json");
-            let translation = await this.loadJsonFile(translationFilePath);
-            translation = this.updateWithMissingKeys(baseTranslation, translation);
-            console.log(`Updated translation for ${localeDir}:`);
-            const missingTranslations = this.extractMissingTranslations(baseTranslation, translation);
-            // Chunk the missing translations
-            const chunks = this.chunkArray(missingTranslations, 15);
-            console.log(`Missing translations for ${localeDir}:`, missingTranslations, chunks);
-            for (const chunk of chunks) {
-                //console.log(`Translating chunk: ${JSON.stringify(chunk)}`); // Log the chunk before translation
-                // Prepare the texts for translation
-                const textsToTranslate = chunk.map((key) => this.getValueByPath(translation, key));
-                // Call your translateUITexts method
-                const translations = await this.translateUITexts(localeDir, textsToTranslate);
-                // Update the translation with the new texts
-                chunk.forEach((key, index) => {
-                    if (translations && translations[index]) {
-                        this.setValueAtPath(translation, key, translations[index]);
-                    }
-                });
-                //console.log(`Chunk after translation: ${JSON.stringify(chunk)}`); // Log the chunk after translation
-                console.log(`Updated translation for ${localeDir}:`);
-                await writeFilePromise(translationFilePath, JSON.stringify(translation, null, 2));
-            }
-        }
-    }
-    setValueAtPath(obj, path, value) {
-        //console.log(`Setting value at path: ${path} to '${value}'`); // Debugging log
-        const keys = path.split(".");
-        let current = obj;
-        for (let i = 0; i < keys.length - 1; i++) {
-            const key = keys[i];
-            if (!(key in current) || typeof current[key] !== 'object' || current[key] === null) {
-                current[key] = {};
-            }
-            current = current[key];
-        }
-        current[keys[keys.length - 1]] = value;
-    }
-    async loadJsonFile(filePath) {
-        const fileContent = await readFilePromise(filePath, "utf8");
-        return JSON.parse(fileContent);
-    }
-    updateWithMissingKeys(baseTranslation, targetTranslation, path = []) {
-        const updatedTranslation = JSON.parse(JSON.stringify(targetTranslation)); // Deep copy to avoid mutating the original
-        const updateRecursively = (base, target, currentPath) => {
-            Object.keys(base).forEach((key) => {
-                const newPath = currentPath.concat(key); // Prepare the new path for potential recursive update
-                if (typeof base[key] === "object" && base[key] !== null) {
-                    // If the base key is an object, ensure the target has a corresponding object
-                    if (!target.hasOwnProperty(key) || typeof target[key] !== "object" || target[key] === null) {
-                        console.log(`Creating missing object at path: ${newPath.join(".")}`);
-                        target[key] = {}; // Initialize missing object
-                    }
-                    updateRecursively(base[key], target[key], newPath); // Recurse into objects
-                }
-                else if (!target.hasOwnProperty(key) || target[key] === "" || target[key] === null) {
-                    // If the key is missing or empty in the target, update it from the base
-                    console.log(`Updating missing or empty key at path: ${newPath.join(".")}`);
-                    target[key] = base[key];
-                }
-                // No action needed for non-empty, non-object fields; they're already present and not empty
-            });
-        };
-        updateRecursively(baseTranslation, updatedTranslation, []);
-        return updatedTranslation;
-    }
-    extractMissingTranslations(baseTranslation, targetTranslation) {
-        const missingTranslations = [];
-        const findMissing = (base, target, path = []) => {
-            Object.keys(base).forEach((key) => {
-                const newPath = path.concat(key);
-                if (typeof base[key] === "object" &&
-                    base[key] !== null &&
-                    typeof target[key] === "object" &&
-                    target[key] !== null) {
-                    // Recurse into nested objects
-                    findMissing(base[key], target[key], newPath);
-                }
-                else if (!target.hasOwnProperty(key) ||
-                    target[key] === base[key] ||
-                    target[key] === "") {
-                    // If the key is missing, the value is the same as the base, or the value is an empty string
-                    if (!this.excludeKeysFromTranslation.includes(key)) {
-                        missingTranslations.push(newPath.join("."));
-                    }
-                }
-            });
-        };
-        findMissing(baseTranslation, targetTranslation);
-        return missingTranslations;
-    }
-    chunkArray(array, size) {
-        return array.reduce((acc, val, i) => {
-            let idx = Math.floor(i / size);
-            let page = acc[idx] || (acc[idx] = []);
-            page.push(val);
-            return acc;
-        }, []);
-    }
-    renderSystemPrompt() {
-        return `You are a helpful website backend translation assistant that knows all the world languages.
-
-INPUTS:
-The user will tell us the Language to translate to.
-
-You will get JSON with an array of strings to translate:
-[
-  "string",
-  ...
-]
-
-OUTPUT:
-You will output JSON string array in the same order as the input array.
-[
-  "string",
-  ...
-]
-
-
-INSTRUCTIONS:
-Do not translate brand names including ours: All Our Ideas and Your Priorities.
-Always output only a JSON string array.`;
-    }
-    renderUserMessage(language, textsToTranslate) {
-        return `Language to translate to: ${language}
-
-Website backend texts to translate in JSON Input:
-${JSON.stringify(textsToTranslate, null, 2)}
-
-Your ${language} website backend texts JSON output:`;
-    }
-    async translateUITexts(languageIsoCode, textsToTranslate) {
-        try {
-            console.log(`translateTexts: ${JSON.stringify(textsToTranslate)} ${languageIsoCode}`);
-            const languageName = YpLanguages.getEnglishName(languageIsoCode) ||
-                languageIsoCode;
-            console.log("LANGUAGE NAME:", languageName);
-            return await this.callLlm(languageName, textsToTranslate);
-        }
-        catch (error) {
-            console.error("Error in getAnswerIdeas:", error);
-            return undefined;
-        }
-    }
-    async callLlm(languageName, inObject) {
-        const messages = [
-            {
-                role: "system",
-                content: this.renderSystemPrompt(),
-            },
-            {
-                role: "user",
-                content: this.renderUserMessage(languageName, inObject),
-            },
-        ];
-        const maxRetries = 3;
-        let retries = 0;
-        let running = true;
-        while (running) {
-            try {
-                console.log(`Messages ${retries}:`, messages);
-                const results = await this.openaiClient.chat.completions.create({
-                    model: this.modelName,
-                    messages,
-                    max_tokens: this.maxTokens,
-                    temperature: this.temperature,
-                });
-                console.log("Results:", results);
-                const textJson = results.choices[0].message.content;
-                console.log("Text JSON:", textJson);
-                if (textJson) {
-                    let cleanText = textJson;
-                    // Detect and remove markdown code block syntax if present
-                    if (cleanText.startsWith("```json") && cleanText.endsWith("```")) {
-                        cleanText = cleanText.substring(7, cleanText.length - 3).trim(); // Remove the surrounding markers
-                    }
-                    let translationData = [];
-                    try {
-                        translationData = JSON.parse(jsonrepair(cleanText));
-                        console.log("Parsed Translation Data:", translationData);
-                    }
-                    catch (error) {
-                        console.error("Error parsing cleaned text as JSON:", error);
-                    }
-                    if (translationData) {
-                        running = false;
-                        return translationData;
-                    }
-                }
-                else {
-                    throw new Error("No content in response");
-                }
-            }
-            catch (error) {
-                console.error("Error:", error);
-                retries++;
-                if (retries > maxRetries) {
-                    console.error("Max retries reached");
-                    running = false;
-                    return undefined;
-                }
-            }
-        }
-        return undefined;
-    }
-}
-(async () => {
-    const translator = new YpLocaleTranslation();
-    await translator.loadAndCompareTranslations();
-})();

package/dist/active-citizen/utils/updateLocaleFolders.js

@@ -1,34 +0,0 @@
-import { YpLanguages } from "../../utils/ypLanguages.js";
-import fs from "fs/promises";
-import path from "path";
-const ensureAllLocaleFoldersAreCreated = async () => {
-    const localesPath = path.join(process.cwd(), "locales");
-    try {
-        await fs.mkdir(localesPath, { recursive: true });
-        for (const language of YpLanguages.allLanguages) {
-            const localePath = path.join(localesPath, language.code.replace("-", "_"));
-            const pathExists = await fs
-                .access(localePath)
-                .then(() => true)
-                .catch(() => false);
-            if (!pathExists) {
-                console.log("Creating ---->:", localePath);
-                await fs.mkdir(localePath, { recursive: true });
-                await fs.writeFile(path.join(localePath, "translation.json"), "{}");
-            }
-            else {
-                console.log("Path exists:", localePath);
-            }
-        }
-        console.log("Locale folders and files have been created successfully.");
-    }
-    catch (error) {
-        console.error("Error creating locale folders:", error);
-    }
-};
-async function main() {
-    await ensureAllLocaleFoldersAreCreated();
-}
-main()
-    .then(() => console.log("I have updated the locale folders."))
-    .catch((error) => console.error("Error in main:", error));

package/dist/active-citizen/workers/activity.cjs

@@ -1,189 +0,0 @@
-"use strict";
-// https://gist.github.com/mojodna/1251812
-const models = require("../../models/index.cjs");
-const log = require('../utils/logger.cjs');
-const toJson = require('../utils/to_json.cjs');
-const async = require('async');
-let airbrake = null;
-if (process.env.AIRBRAKE_PROJECT_ID) {
-    airbrake = require('../utils/airbrake.cjs');
-}
-const generatePostNotification = require('../engine/notifications/generate_post_notifications.cjs');
-const generatePointNotification = require('../engine/notifications/generate_point_notifications.cjs');
-const generateRecommendationEvent = require('../engine/recommendations/events_manager.cjs').generateRecommendationEvent;
-const generatePostStatusChangeNotification = require('../engine/notifications/generate_post_status_change_notifications.cjs');
-const ActivityWorker = function () { };
-ActivityWorker.prototype.process = (activityJson, callback) => {
-    let activity;
-    log.info('Processing activity Started');
-    async.series([
-        (seriesCallback) => {
-            models.AcActivity.findOne({
-                where: { id: activityJson.id },
-                include: [
-                    {
-                        model: models.User,
-                        attributes: ['id', 'notifications_settings', 'email', 'name', 'created_at'],
-                        required: false
-                    },
-                    {
-                        model: models.Domain,
-                        required: false
-                    },
-                    {
-                        model: models.Community,
-                        required: false
-                    },
-                    {
-                        model: models.Group,
-                        required: false
-                    },
-                    {
-                        model: models.Post.unscoped(),
-                        required: false
-                    },
-                    {
-                        model: models.Point,
-                        required: false,
-                        include: [
-                            {
-                                model: models.Post,
-                                required: false
-                            }
-                        ]
-                    }
-                ]
-            }).then((results) => {
-                if (results) {
-                    activity = results;
-                    seriesCallback();
-                }
-                else {
-                    seriesCallback('Activity not found');
-                }
-            }).catch((error) => {
-                seriesCallback(error);
-            });
-        },
-        (seriesCallback) => {
-            log.info('Processing Activity Started', { type: activity.type });
-            try {
-                switch (activity.type) {
-                    case "activity.user.invite":
-                        models.AcNotification.createNotificationFromActivity(activity.actor.user_id, activity, "notification.user.invite", "priority", 70, (error) => {
-                            log.info('Processing activity.user.invite Completed', { type: activity.type, err: error });
-                            seriesCallback(error);
-                        });
-                        break;
-                    case "activity.password.recovery":
-                        models.AcNotification.createNotificationFromActivity(activity.actor.user, activity, "notification.password.recovery", "priority", 100, (error) => {
-                            log.info('Processing activity.password.recovery Completed', { type: activity.type, err: error });
-                            seriesCallback(error);
-                        });
-                        break;
-                    case "activity.password.changed":
-                        models.AcNotification.createNotificationFromActivity(activity.actor.user, activity, "notification.password.changed", "priority", 100, (error) => {
-                            log.info('Processing activity.password.changed Completed', { type: activity.type, err: error });
-                            seriesCallback(error);
-                        });
-                        break;
-                    case "activity.system.generalUserNotification":
-                        models.AcNotification.createNotificationFromActivity(activity.actor.userId, activity, "notification.generalUserNotification", "priority", 100, (error) => {
-                            log.info('Processing activity.system.generalUserNotification', { type: activity.type, err: error });
-                            seriesCallback(error);
-                        });
-                        break;
-                    case "activity.report.content":
-                        models.AcNotification.createReportNotifications(activity.actor.user, activity, (error) => {
-                            log.info('Processing activity.report.content Completed', { type: activity.type, err: error });
-                            seriesCallback(error);
-                        });
-                        break;
-                    case "activity.bulk.status.update":
-                        models.AcNotification.createNotificationFromActivity(activity.actor.user, activity, "notification.bulk.status.update", "priority", 100, (error) => {
-                            log.info('Processing activity.bulk.status.update Completed', { type: activity.type, err: error });
-                            seriesCallback(error);
-                        });
-                        break;
-                    case "activity.post.new":
-                    case "activity.post.opposition.new":
-                    case "activity.post.endorsement.new":
-                        generatePostNotification(activity, activity.User, (error) => {
-                            if (error) {
-                                log.error('Processing activity.post.* Error', { type: activity.type, err: error });
-                                seriesCallback(error);
-                            }
-                            else {
-                                log.info('Processing activity.post.* Completed', { type: activity.type });
-                                seriesCallback();
-                            }
-                        });
-                        break;
-                    case "activity.point.new":
-                    case "activity.point.helpful.new":
-                    case "activity.point.unhelpful.new":
-                    case "activity.point.newsStory.new":
-                    case "activity.point.comment.new":
-                        generatePointNotification(activity, activity.User, (error) => {
-                            if (error) {
-                                log.error('Processing activity.point.* Completed', { type: activity.type, err: error });
-                                seriesCallback(error);
-                            }
-                            else {
-                                log.info('Processing activity.point.* Completed', { type: activity.type });
-                                seriesCallback();
-                            }
-                        });
-                        break;
-                    case "activity.post.status.change":
-                        if (activity.object && activity.object.bulkStatusUpdate) {
-                            log.info('Processing activity.post.status.change not creating notifications', { type: activity.type });
-                            seriesCallback();
-                        }
-                        else {
-                            generatePostStatusChangeNotification(activity, activity.User, (error) => {
-                                if (error) {
-                                    log.error('Processing activity.post.status.change Completed', { type: activity.type, err: error });
-                                    seriesCallback(error);
-                                }
-                                else {
-                                    log.info('Processing activity.post.status.change Completed', { type: activity.type });
-                                    seriesCallback();
-                                }
-                            });
-                        }
-                        break;
-                    default:
-                        seriesCallback();
-                }
-            }
-            catch (error) {
-                log.error("Processing Activity Error", { err: error });
-                seriesCallback(error);
-            }
-        },
-        (seriesCallback) => {
-            generateRecommendationEvent(activity, seriesCallback);
-        }
-    ], (error) => {
-        if (error) {
-            log.error("Processing Activity Error", { err: error });
-            if (airbrake) {
-                airbrake.notify(error).then((airbrakeErr) => {
-                    if (airbrakeErr.error) {
-                        log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
-                    }
-                    callback(error);
-                });
-            }
-            else {
-                callback(error);
-            }
-        }
-        else {
-            log.info('Processing Activity and Recommendation Completed', { type: activity.type });
-            callback();
-        }
-    });
-};
-module.exports = new ActivityWorker();