@yrpri/api 9.0.101 → 9.0.103

package/dist/controllers/videos.cjs

@@ -0,0 +1,226 @@
+"use strict";
+var express = require("express");
+var router = express.Router();
+var models = require("../models/index.cjs");
+var multer = require("multer");
+var multerMultipartResolver = multer({ dest: "uploads/" }).single("file");
+var auth = require("../authorization.cjs");
+var log = require("../utils/logger.cjs");
+var toJson = require("../utils/to_json.cjs");
+var queue = require("../active-citizen/workers/queue.cjs");
+const _ = require("lodash");
+router.get("/hasVideoUploadSupport", (req, res) => {
+    res.send({
+        hasTranscriptSupport: process.env.GOOGLE_TRANSCODING_FLAC_BUCKET != null &&
+            process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON != null,
+        hasVideoUploadSupport: process.env.S3_VIDEO_UPLOAD_BUCKET != null &&
+            process.env.S3_VIDEO_PUBLIC_BUCKET != null &&
+            process.env.S3_VIDEO_THUMBNAIL_BUCKET != null,
+    });
+});
+router.put("/videoView", (req, res) => {
+    models.Video.findOne({
+        where: {
+            id: req.body.videoId,
+        },
+    })
+        .then((video) => {
+        if (video) {
+            if (req.body.longPlaytime) {
+                video.increment("long_views");
+            }
+            else {
+                video.increment("views");
+            }
+        }
+        else {
+            log.error("Did not find video for view increment");
+        }
+        res.sendStatus(200);
+    })
+        .catch((error) => {
+        log.error("Error setting video increment", { error });
+        res.sendStatus(200);
+    });
+});
+router.put("/:postId/completeAndAddToPost", auth.can("edit post"), (req, res) => {
+    models.Video.completeUploadAndAddToCollection(req, res, {
+        postId: req.params.postId,
+        videoId: req.body.videoId,
+        browserLanguage: req.headers["accept-language"]
+            ? req.headers["accept-language"].split(",")[0]
+            : "en-US",
+        appLanguage: req.body.appLanguage,
+    });
+});
+router.put("/:groupId/completeAndAddToGroup", auth.can("edit group"), (req, res) => {
+    models.Video.completeUploadAndAddToCollection(req, res, {
+        groupId: req.params.groupId,
+        videoId: req.body.videoId,
+    });
+});
+router.put("/:communityId/completeAndAddToCommunity", auth.can("edit community"), (req, res) => {
+    models.Video.completeUploadAndAddToCollection(req, res, {
+        communityId: req.params.communityId,
+        videoId: req.body.videoId,
+    });
+});
+router.put("/:domainId/completeAndAddToDomain", auth.can("edit domain"), (req, res) => {
+    models.Video.completeUploadAndAddToCollection(req, res, {
+        domainId: req.params.domainId,
+        videoId: req.body.videoId,
+    });
+});
+router.delete("/:domainId/:videoId/deleteVideoFromDomain", auth.can("edit domain"), (req, res) => {
+    models.Video.removeVideoFromCollection(req, res, {
+        domainId: req.params.domainId,
+        videoId: req.params.videoId,
+    });
+});
+router.delete("/:communityId/:videoId/deleteVideoFromCommunity", auth.can("edit community"), (req, res) => {
+    models.Video.removeVideoFromCollection(req, res, {
+        communityId: req.params.communityId,
+        videoId: req.params.videoId,
+    });
+});
+router.delete("/:groupId/:videoId/deleteVideoFromGroup", auth.can("edit group"), (req, res) => {
+    models.Video.removeVideoFromCollection(req, res, {
+        groupId: req.params.groupId,
+        videoId: req.params.videoId,
+    });
+});
+router.post("/:groupId/createAndGetPreSignedUploadUrl", auth.can("create media"), (req, res) => {
+    models.Video.createAndGetSignedUploadUrl(req, res);
+});
+router.post("/createAndGetPreSignedUploadUrlLoggedIn", auth.isLoggedInNoAnonymousCheck, (req, res) => {
+    models.Video.createAndGetSignedUploadUrl(req, res);
+});
+const startTranscoding = (req, res) => {
+    const options = {
+        videoPostUploadLimitSec: req.body.videoPostUploadLimitSec,
+        videoPointUploadLimitSec: req.body.videoPointUploadLimitSec,
+        aspect: req.body.aspect,
+    };
+    models.Video.findOne({
+        where: {
+            id: req.params.videoId,
+        },
+    })
+        .then((video) => {
+        if (video && video.user_id === req.user.id) {
+            models.Video.startTranscoding(video, options, req, res);
+        }
+        else {
+            log.error("Can't find video or not same user", {
+                videoUserId: video ? video.user_id : -1,
+                userId: req.user.id,
+            });
+            res.sendStatus(404);
+        }
+    })
+        .catch((error) => {
+        log.error("Error getting video", { error });
+        res.sendStatus(500);
+    });
+};
+router.post("/:groupId/:videoId/startTranscoding", auth.can("create media"), (req, res) => {
+    startTranscoding(req, res);
+});
+router.post("/:videoId/startTranscodingLoggedIn", auth.isLoggedInNoAnonymousCheck, (req, res) => {
+    startTranscoding(req, res);
+});
+router.get("/:videoId/formatsAndImages", (req, res) => {
+    models.Video.findOne({
+        where: {
+            id: req.params.videoId,
+        },
+        order: [[{ model: models.Image, as: "VideoImages" }, "updated_at", "asc"]],
+        include: [
+            {
+                model: models.Image,
+                as: "VideoImages",
+            },
+        ],
+    })
+        .then((video) => {
+        if (video && video.user_id === req.user.id) {
+            video.createFormats(video);
+            const previewVideoUrl = video.formats[0];
+            let videoImages = [];
+            _.forEach(video.VideoImages, (image) => {
+                const formats = JSON.parse(image.formats);
+                videoImages.push(formats[0]);
+            });
+            res.send({ previewVideoUrl, videoImages });
+        }
+        else {
+            log.error("Can't find video or not same user", {
+                videoUserId: video ? video.user_id : -1,
+                userId: req.user.id,
+            });
+            res.sendStatus(404);
+        }
+    })
+        .catch((error) => {
+        log.error("Error getting video formatsAndImages", { error });
+        res.sendStatus(500);
+    });
+});
+router.put("/:videoId/setVideoCover", (req, res) => {
+    models.Video.findOne({
+        where: {
+            id: req.params.videoId,
+        },
+    })
+        .then((video) => {
+        if (video && video.user_id === req.user.id) {
+            if (!video.public_meta)
+                video.set("public_meta", {});
+            video.set("public_meta.selectedVideoFrameIndex", req.body.frameIndex);
+            video
+                .save()
+                .then(() => {
+                res.sendStatus(200);
+            })
+                .catch((error) => {
+                log.error("Error getting video formatsAndImages", { error });
+                res.sendStatus(500);
+            });
+        }
+        else {
+            log.error("Can't find video or not same user", {
+                videoUserId: video ? video.user_id : -1,
+                userId: req.user.id,
+            });
+            res.sendStatus(404);
+        }
+    })
+        .catch((error) => {
+        log.error("Error getting video formatsAndImages", { error });
+        res.sendStatus(500);
+    });
+});
+router.put("/:videoId/getTranscodingJobStatus", (req, res) => {
+    models.Video.findOne({
+        where: {
+            id: req.params.videoId,
+        },
+    })
+        .then((video) => {
+        if (video && video.user_id === req.user.id) {
+            models.Video.getTranscodingJobStatus(video, req, res);
+        }
+        else {
+            log.error("Can't find video or not same user", {
+                videoUserId: video ? video.user_id : -1,
+                userId: req.user.id,
+            });
+            res.sendStatus(404);
+        }
+    })
+        .catch((error) => {
+        log.error("Error getting video", { error });
+        res.sendStatus(500);
+    });
+});
+module.exports = router;

package/dist/deleteUnwantedDeclerations.cjs

@@ -0,0 +1,55 @@
+"use strict";
+const fs = require('fs');
+const path = require('path');
+const tsOutDir = './ts-out';
+const keepDeclarations = new Set([
+    "app.d.ts",
+    "server.d.ts",
+    path.join("active-citizen", "llms", "baseChatBot.d.ts"),
+    path.join("active-citizen", "llms", "llmTranslation.d.ts"),
+    path.join("active-citizen", "engine", "allOurIdeas", "aiHelper.d.ts"),
+    path.join("active-citizen", "engine", "allOurIdeas", "iconGenerator.d.ts"),
+    path.join("active-citizen", "engine", "allOurIdeas", "explainAnswerAssistant.d.ts"),
+    path.join("utils", "loggerTs.d.ts"),
+    path.join("utils", "ypLanguages.d.ts"),
+    path.join("active-citizen", "utils", "updateAllLocalesFromEn.d.ts"),
+    path.join("active-citizen", "utils", "updateLocaleFolders.d.ts"),
+]);
+// Function to delete files recursively in a directory
+function deleteDtsFiles(dir) {
+    const files = fs.readdirSync(dir);
+    files.forEach(file => {
+        const filePath = path.join(dir, file);
+        if (fs.statSync(filePath).isDirectory()) {
+            // Recurse into a subdirectory
+            deleteDtsFiles(filePath);
+        }
+        else {
+            // Construct a relative path for the current file
+            const relativePath = path.relative(tsOutDir, filePath);
+            // Delete the file if it ends with .d.ts and not in the keep list
+            if (file.endsWith('.d.ts') && !keepDeclarations.has(relativePath)) {
+                fs.unlinkSync(filePath);
+                console.log(`Deleted: ${filePath}`);
+            }
+            if (file.endsWith('.d.cts') && !keepDeclarations.has(relativePath)) {
+                fs.unlinkSync(filePath);
+                console.log(`Deleted: ${filePath}`);
+            }
+            if (file.endsWith('.js.map') && !keepDeclarations.has(relativePath)) {
+                fs.unlinkSync(filePath);
+                console.log(`Deleted: ${filePath}`);
+            }
+            if (file.endsWith('.cjs.map') && !keepDeclarations.has(relativePath)) {
+                fs.unlinkSync(filePath);
+                console.log(`Deleted: ${filePath}`);
+            }
+            if (file.endsWith('.cts.map') && !keepDeclarations.has(relativePath)) {
+                fs.unlinkSync(filePath);
+                console.log(`Deleted: ${filePath}`);
+            }
+        }
+    });
+}
+// Start the deletion process
+deleteDtsFiles(tsOutDir);

package/dist/migrations/agentAuditLogs.cjs

@@ -0,0 +1,46 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agent_audit_logs', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            agent_id: {
+                type: DataTypes.INTEGER,
+                allowNull: true,
+            },
+            connector_id: {
+                type: DataTypes.INTEGER,
+                allowNull: true,
+            },
+            action: {
+                type: DataTypes.STRING,
+                allowNull: false,
+            },
+            details: {
+                type: DataTypes.JSONB,
+                allowNull: true,
+            }
+        });
+        await queryInterface.addIndex('ps_agent_audit_logs', ['user_id']);
+        await queryInterface.addIndex('ps_agent_audit_logs', ['agent_id']);
+        await queryInterface.addIndex('ps_agent_audit_logs', ['connector_id']);
+    }
+};

package/dist/migrations/agentClasses.cjs

@@ -0,0 +1,60 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agent_classes', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            uuid: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            class_base_id: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false,
+            },
+            version: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            configuration: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+            },
+            available: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+            },
+        });
+        await queryInterface.addIndex('ps_agent_classes', ['uuid'], {
+            unique: true,
+        });
+        await queryInterface.addIndex('ps_agent_classes', ['class_base_id']);
+        await queryInterface.addIndex('ps_agent_classes', ['class_base_id', 'version']);
+        await queryInterface.addIndex('ps_agent_classes', ['user_id']);
+        await queryInterface.addIndex('ps_agent_classes', ['version']);
+    }
+};

package/dist/migrations/agentConnectorClasses.cjs

@@ -0,0 +1,61 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agent_connector_classes', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            uuid: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            class_base_id: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false,
+            },
+            version: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            available: {
+                type: DataTypes.BOOLEAN,
+                allowNull: false,
+            },
+            configuration: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+            },
+        });
+        await queryInterface.addIndex('ps_agent_connector_classes', ['uuid'], {
+            unique: true,
+        });
+        await queryInterface.addIndex('ps_agent_connector_classes', ['class_base_id']);
+        await queryInterface.addIndex('ps_agent_connector_classes', ['class_base_id', 'version']);
+        await queryInterface.addIndex('ps_agent_connector_classes', ['user_id']);
+        await queryInterface.addIndex('ps_agent_connector_classes', ['name']);
+        await queryInterface.addIndex('ps_agent_connector_classes', ['version']);
+    }
+};

package/dist/migrations/agentConnectors.cjs

@@ -0,0 +1,50 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agent_connectors', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            uuid: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            class_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            group_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            configuration: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+            },
+        });
+        await queryInterface.addIndex('ps_agent_connectors', ['uuid'], {
+            unique: true,
+        });
+        await queryInterface.addIndex('ps_agent_connectors', ['user_id']);
+        await queryInterface.addIndex('ps_agent_connectors', ['class_id']);
+        await queryInterface.addIndex('ps_agent_connectors', ['group_id']);
+    }
+};

package/dist/migrations/agentEvals.cjs

@@ -0,0 +1,45 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agent_evals', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            agent_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            overall_score: {
+                type: DataTypes.INTEGER,
+                allowNull: true
+            },
+            results: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+            },
+            notes: {
+                type: DataTypes.TEXT,
+                allowNull: true,
+            },
+        });
+        await queryInterface.addIndex('ps_agent_evals', ['user_id']);
+        await queryInterface.addIndex('ps_agent_evals', ['agent_id']);
+    }
+};

package/dist/migrations/agentRegistries.cjs

@@ -0,0 +1,40 @@
+'use strict';
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agent_registries', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            uuid: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            configuration: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+            },
+        });
+        await queryInterface.addIndex('ps_agent_registries', ['uuid'], {
+            unique: true,
+        });
+        await queryInterface.addIndex('ps_agent_registries', ['user_id']);
+    }
+};

package/dist/migrations/agents.cjs

@@ -0,0 +1,54 @@
+'use strict';
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_agents', {
+            id: {
+                type: Sequelize.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            uuid: {
+                type: Sequelize.UUID,
+                defaultValue: Sequelize.UUIDV4,
+                allowNull: false,
+            },
+            user_id: {
+                type: Sequelize.INTEGER,
+                allowNull: false,
+            },
+            created_at: {
+                type: Sequelize.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.NOW,
+            },
+            updated_at: {
+                type: Sequelize.DATE,
+                allowNull: false,
+                defaultValue: Sequelize.NOW,
+            },
+            class_id: {
+                type: Sequelize.INTEGER,
+                allowNull: false,
+            },
+            group_id: {
+                type: Sequelize.INTEGER,
+                allowNull: false,
+            },
+            configuration: {
+                type: Sequelize.JSONB,
+                allowNull: false,
+            },
+            parent_agent_id: {
+                type: Sequelize.INTEGER,
+                allowNull: true,
+            },
+        });
+        await queryInterface.addIndex('ps_agents', ['uuid'], {
+            unique: true,
+        });
+        await queryInterface.addIndex('ps_agents', ['user_id']);
+        await queryInterface.addIndex('ps_agents', ['class_id']);
+        await queryInterface.addIndex('ps_agents', ['group_id']);
+        // Add index to both id and version on agent_classes
+    }
+};

package/dist/migrations/aiModels.cjs

@@ -0,0 +1,49 @@
+"use strict";
+const { DataTypes } = require('sequelize');
+module.exports = {
+    up: async (queryInterface, Sequelize) => {
+        await queryInterface.createTable('ps_ai_models', {
+            id: {
+                type: DataTypes.INTEGER,
+                autoIncrement: true,
+                primaryKey: true,
+            },
+            uuid: {
+                type: DataTypes.UUID,
+                defaultValue: DataTypes.UUIDV4,
+                allowNull: false,
+            },
+            user_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            organization_id: {
+                type: DataTypes.INTEGER,
+                allowNull: false,
+            },
+            name: {
+                type: DataTypes.STRING,
+                allowNull: false,
+            },
+            configuration: {
+                type: DataTypes.JSONB,
+                allowNull: false,
+            },
+            created_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+            updated_at: {
+                type: DataTypes.DATE,
+                allowNull: false,
+                defaultValue: DataTypes.NOW,
+            },
+        });
+        await queryInterface.addIndex('ps_ai_models', ['uuid'], {
+            unique: true,
+        });
+        await queryInterface.addIndex('ps_ai_models', ['user_id']);
+        await queryInterface.addIndex('ps_ai_models', ['organization_id']);
+    }
+};