data-primals-engine 1.3.4 → 1.4.1

package/src/modules/data/data.js

@@ -43,7 +43,7 @@ import {
 } from "../mongodb.js";
 import {dbUrl, MongoClient, MongoDatabase} from "../../engine.js";
 import path from "node:path";
-import {getObjectHash, getRandom, isGUID, isPlainObject, randomDate} from "../../core.js";
+import {getObjectHash, getRandom, isGUID, isPlainObject, randomDate, sequential} from "../../core.js";
 import {Event} from "../../events.js";
 import fs from "node:fs";
 import schedule from "node-schedule";
@@ -52,7 +52,7 @@ import i18n from "../../i18n.js";
 import {
     executeSafeJavascript,
     runScheduledJobWithDbLock,
-    scheduleWorkflowTriggers,
+    scheduleWorkflowTriggers, substituteVariables,
     triggerWorkflows
 } from "../workflow.js";
 import NodeCache from "node-cache";
@@ -60,13 +60,14 @@ import AWS from 'aws-sdk';
 import checkDiskSpace from "check-disk-space";
 import {addFile, removeFile} from "../file.js";
 import {downloadFromS3, getUserS3Config, listS3Backups, uploadToS3} from "../bucket.js";
-import {calculateTotalUserStorageUsage, hasPermission, middlewareAuthenticator} from "../user.js";
+import {calculateTotalUserStorageUsage, getSmtpConfig, hasPermission, middlewareAuthenticator} from "../user.js";
 import {getAllPacks} from "../../packs.js";
 import {Config} from "../../config.js";
 import {profiles} from "../../../client/src/constants.js";
 import {registerRoutes, sendSseToUser} from "./data.routes.js";
 import {importJobs, modelsCache, mongoDBWhitelist, runCryptoWorkerTask, runImportExportWorker} from "./data.core.js";
 import readXlsxFile from "read-excel-file/node";
+import {sendEmail} from "../../email.js";
 
 let engine;
 let logger;
@@ -543,7 +544,7 @@ const validateField = (field) => {
         break;
     }
     case 'number':
-        allowedFieldTest(['min', 'max', 'step', 'unit']);
+        allowedFieldTest(['min', 'max', 'step', 'unit', 'delay', 'gauge', 'percent']);
         if (field.min !== undefined && typeof field.min !== 'number') {
             throw new Error(i18n.t('api.validate.fieldNumber', "L'attribut '{{0}}' doit être un nombre.", ["min"]));
         }
@@ -559,6 +560,15 @@ const validateField = (field) => {
         if (field.unit !== undefined && typeof field.unit !== 'string') {
             throw new Error(i18n.t('api.validate.fieldString', "Le champ '{{0}}' doit être une chaîne de caractères.", ["unit"]));
         }
+        if (field.delay !== undefined && typeof field.delay !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "Le champ '{{0}}' doit être un booléen.", ["unit"]));
+        }
+        if (field.gauge !== undefined && typeof field.gauge !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["gauge"]));
+        }
+        if (field.percent !== undefined && typeof field.percent !== 'boolean') {
+            throw new Error(i18n.t('api.validate.fieldBoolean', "L'attribut '{{0}}' doit être un booléen.", ["percent"]));
+        }
         break;
     case 'string':
     case 'string_t':
@@ -780,7 +790,7 @@ function convertDataTypes(dataArray, modelFields, sourceType = 'csv') {
     });
 }
 
-export  const cancelAlerts = async (user) => {
+export const cancelAlerts = async (user) => {
 
     const datasCollection = getCollection('datas'); // Alerts are in the global collection
 
@@ -840,15 +850,56 @@ async function runStatefulAlertJob(alertId) {
         if (count > 0) {
             logger.info(`[Scheduled Job] Condition met for alert ${alertDoc.name} (ID: ${alertId}). Sending notification and updating state.`);
 
+            let emailSent = false;
+            try {
+                const user = await engine.userProvider.findUserByUsername(alertDoc._user);
+                if (user && user.email) {
+                    const smtpConfig = await getSmtpConfig(user);
+                    if (alertDoc.sendEmail && smtpConfig) {
+                        const userLang = user.lang || 'en';
+                        let emailContent, msg;
+                        if (alertDoc.message){
+                            if (alertDoc.message[userLang])
+                                msg= alertDoc.message[userLang];
+                            else
+                                msg = alertDoc.message[Object.keys(alertDoc.message)[0]];
+                            emailContent = await substituteVariables(msg, { count, alert: alertDoc });
+                        } else {
+                            // Sinon, utiliser le message par défaut
+                            emailContent = i18n.t('alert.email.content', `L'alerte '${alertDoc.name}' s'est déclenchée. ${count} élément(s) correspondent à votre condition.`, { name: alertDoc.name, count: count });
+                        }
+
+                        await sendEmail(
+                            user.email,
+                            {
+                                title: i18n.t('alert.email.title', `Alerte: ${alertDoc.name}`),
+                                content: emailContent
+                            },
+                            smtpConfig,
+                            userLang
+                        );
+                        emailSent = true;
+                        logger.info(`[Scheduled Job] Email notification sent for alert ${alertId} to ${user.email}.`);
+                    } else if (alertDoc.sendEmail) {
+                        logger.warn(`[Scheduled Job] Could not send email for alert ${alertId}. SMTP config is missing or incomplete for user ${user.username}.`);
+                    }
+                } else {
+                    logger.warn(`[Scheduled Job] Could not send email for alert ${alertId}. User ${alertDoc._user} not found or has no email address.`);
+                }
+            } catch (emailError) {
+                logger.error(`[Scheduled Job] Failed to send email for alert ${alertId}:`, emailError);
+            }
+
             // Send notification
             const alertPayload = {
                 type: 'cron_alert',
                 triggerId: alertDoc._id.toString(),
                 triggerName: alertDoc.name,
                 timestamp: new Date().toISOString(),
-                message: `Alerte '${alertDoc.name}': ${count} élément(s) correspondent à votre condition.`
+                message: `Alerte '${alertDoc.name}': ${count} élément(s) correspondent à votre condition.`,
+                emailSent
             };
-            await sendSseToUser(alertDoc._user, alertPayload);
+            sendSseToUser(alertDoc._user, alertPayload);
 
             // Update state in DB to prevent re-notification
             await datasCollection.updateOne(
@@ -4313,14 +4364,20 @@ async function manageBackupRotation(user, backupFrequency, s3Config = null) { //
  * @param {string} [lang='en'] - Language code for localized data
  * @returns {Promise<{success: boolean, summary: object, errors: Array, modifiedCount: number}>}
  */
-export async function installPack(packIdentifier, user = null, lang = 'en', isTemporary= false) {
+export async function installPack(packIdentifier, user = null, lang = 'en', options = {}) {
     let pack;
     const packsCollection = getCollection('packs');
 
     // Determine if we're working with an ID or direct pack object
     if (typeof packIdentifier === 'string') {
+        let p;
+        try {
+            p = new ObjectId(packIdentifier);
+        } catch (e) {
+            p = packIdentifier;
+        }
         // Existing behavior - fetch from database
-        pack = await packsCollection.findOne({ _id: new ObjectId(packIdentifier) });
+        pack = await packsCollection.findOne({ $and: [{ _user: {$exists: false} }, {private: false}, {$or:[{ _id: p}, { name: packIdentifier }]}]} );
         if (!pack) {
             throw new Error(`Pack with ID ${packIdentifier} not found.`);
         }
@@ -4359,6 +4416,8 @@ export async function installPack(packIdentifier, user = null, lang = 'en', isTe
             ? await modelsCollection.find({ _user: username }).toArray()
             : await modelsCollection.find({ _user: { $exists: false } }).toArray();
 
+        console.log("EXISTING", existingModels);
+
         const existingModelNames = existingModels.map(m => m.name);
 
         for (const modelOrName of pack.models) {
@@ -4406,7 +4465,7 @@ export async function installPack(packIdentifier, user = null, lang = 'en', isTe
     const dataToInstall = { ...pack.data?.all, ...pack.data?.[lang] };
     if (!dataToInstall || Object.keys(dataToInstall).length === 0) {
         logger.warn(`Pack '${pack.name}' has no data to install.`);
-        return { success: errors.length === 0, summary, errors, modifiedCount: 0 };
+        return { success: false, summary, errors, modifiedCount: 0 };
     }
 
     // Process link references (same as original)
@@ -4559,6 +4618,14 @@ export async function installPack(packIdentifier, user = null, lang = 'en', isTe
         }
     }
 
+    if( options.installForUser && user?.username ){
+        if( pack.name )
+            await packsCollection.deleteOne({ name: pack.name, _user: user.username });
+        logger.info(`--- Creating pack '${pack.name}' for user... ---`);
+        const packToCreate = {...pack, _id: undefined, private: true, _user: user.username };
+        await packsCollection.insertOne(packToCreate);
+    }
+
     // Trigger event only if pack came from database (original behavior)
     if (typeof packIdentifier === 'string') {
         await Event.Trigger("OnPackInstalled", "event", "system", pack);
@@ -4577,13 +4644,14 @@ export async function installPack(packIdentifier, user = null, lang = 'en', isTe
 export const installAllPacks = async () => {
     const packs = await getAllPacks();
     await packsCollection.deleteMany({ _user: { $exists : false }});
-    await packsCollection.insertMany(packs);
+    await packsCollection.insertMany(packs.map(p =>({...p, private: false })));
 }
 
 export async function handleDemoInitialization(req, res) {
     const user = req.me;
     const body = req.fields;
-    const models = (Object.keys(profiles).includes(body.profile) && profiles[body.profile]) || '';
+    const packs = body.packs;
+    const models = (Object.keys(profiles).includes(body.profile) && profiles[body.profile].models) || '';
     if (!isDemoUser(user)) {
         return res.status(403).json({ success: false, error: "This action is only for demo users." });
     }
@@ -4617,10 +4685,16 @@ export async function handleDemoInitialization(req, res) {
 
         logger.info(`[Demo Init] Installing dynamically generated pack with models: [${models.join(', ')}].`);
 
+        await sequential(packs.map(p => {
+            return () => installPack(p, user, req.query.lang || 'en');
+        }));
+
         // Create and install pack
         const result = await installPack(packToInstall, user, req.query.lang || 'en');
 
         if (result.success || result.modifiedCount > 0) {
+
+            await Event.Trigger('OnDemoUserAdded', "event", "system", req.me.username);
             logger.info(`[Demo Init] Pack installed successfully for user '${user.username}'.`);
             res.status(200).json({ success: true, message: "Demo environment initialized successfully.", summary: result.summary });
         } else {