@fto-consult/expo-ui 3.6.1 → 4.0.1

package/appConfig.txt

@@ -8,7 +8,10 @@
 
     /*** le nombre maximal de courbes qu'on peut afficher sur le même graphe***/
     maxSupportedChartSeries {number}
-
+    
+    ///fonction de rappel appelée avant d'exit l'application, doit retourner une promesse que lorsque résolue, exit l'application
+    beforeExit : ()=><Promise>
+    
     /***les fonctions d'aggregations du datagrid**/
     datagridAggregatorFunctions : {objectOf({code:{string},label:{string},eval:{function}})|| arrayOf({code:{string},label:{string},eval:{function}})}
     /**l'ensemble des selectors à appliquer au champs de type hashtag, permettant de faire des liens vers d'autres tables**/

package/babel.config.alias.js

@@ -1,5 +1,6 @@
 const path = require("path");
 const fs = require("fs");
+const writeFile = require("./electron/writeFile");
 module.exports = (opts)=>{
     const dir = path.resolve(__dirname);
     const base = opts.base || process.cwd();
@@ -115,13 +116,18 @@ module.exports = (opts)=>{
         outputPath
     });
     const $assets = r.$assets;
+    const $electron = path.resolve(dir,"electron");
     const electronPaths = {
         ...r,
         sourceCode : r.$src,
         assets : $assets,
         images : r.$images,
         projectRoot : base,//la racine au projet
+        electron : $electron,//le chemin racine electron
     };
+    //le chemin ver le repertoire electron
+    r.$eelectron = r["$e-electron"] = $electron;
+    r.$electron = r.$electron || r.$eelectron;
     const electronAssetsPath = path.resolve(dir,"electron","assets");
     if($assets){
         const l1 = path.resolve($assets,"logo.png"), l2 = path.resolve($assets,"logo.png");
@@ -132,7 +138,11 @@ module.exports = (opts)=>{
             electronPaths.logo = logoPath;
         }
     }
+    const jsonPath = path.resolve(base,'package.json');
+    if(fs.existsSync(jsonPath)){
+        require("./electron/copy")(jsonPath,path.resolve(dir,"electron","package.app.json"));
+    }
     ///on sauvegarde les chemins des fichiers utiles, qui seront utilisées par la variable electron plus tard
-    require("./electron/writeFile")(path.resolve(dir,"electron","paths.json"),JSON.stringify(electronPaths));
+    writeFile(path.resolve(dir,"electron","paths.json"),JSON.stringify(electronPaths));
     return r;
 }

package/bin/index.js

@@ -13,11 +13,10 @@ const fs = require("fs");
 const dir = path.resolve(__dirname);
 const electronDir = path.resolve(dir, "..","electron");
 const exec = require("../electron/exec");
-const args = process.argv.slice(2);
 let projectRoot = process.cwd();
 const createDir = require("../electron/createDir");
-const copyDir = require("../electron/copyDir");
-const parsedArgs = require("./parseArgs")(args,supportedScript);
+const copyDir = require("../electron/copy");
+const parsedArgs = require("../electron/parseArgs")(null,supportedScript);
 if(!parsedArgs.script || !(parsedArgs.script in supportedScript)){
    console.error ("Erreur : script invalide, vous devez spécifier script figurant parmi les script : ["+Object.keys(supportedScript).join(", ")+"]");
    process.exit();
@@ -29,6 +28,7 @@ let cmd = null;
  *  cmde : [cmd] start electron config=[path-to-config-relative-to-project-dir] 
  *        splash=[path-to-splashcreen-relative-to-project-root] 
  *        output-dir|out = [path-to-output-dir-relative-to-root-project]
+ *        url = [url-to-start-electron-to]
  * */
 if(parsedArgs.electron){
   const pathsJSON = path.resolve(electronDir,"paths.json");
@@ -54,17 +54,32 @@ if(parsedArgs.electron){
   const buildOutDir = path.resolve(electronDir,"dist");
   const indexFile = path.resolve(buildOutDir,"index.html");
   const webBuildDir = path.resolve(projectRoot,"web-build");
+  const url = parsedArgs.url  && parsedArgs.url.trim() || "";
+  const start = x=>{
+     return new Promise((resolve,reject)=>{
+      cmd = "electron "+electronDir+" url="+url;
+        exec({
+          cmd, 
+          projectRoot : electronDir,
+        }).finally(()=>{
+          console.log("ant to exit");
+        })
+        typeof (resolve) =='function' && setTimeout(resolve,1000);
+    })
+  };
+  if(url){
+    return start().then(process.exit);
+  }
   const promise = new Promise((resolve,reject)=>{
-      const next = ()=>{
+    const next = ()=>{
         if(fs.existsSync(webBuildDir)){
             return copyDir(webBuildDir,buildOutDir).catch(reject).then(resolve);
         } else {
-          reject("fichier web-build exporté par electron innexistant!!");
+          reject("dossier web-build exporté par electron innexistant!!");
         }
       }
-      if(parsedArgs.compile || !fs.existsSync(path.resolve(webBuildDir,"index.html"))){
+      if(!url && (parsedArgs.compile || !fs.existsSync(path.resolve(webBuildDir,"index.html")))){
         cmd = "npx expo export:web";
-        console.log("******************** exporting app : "+cmd);
         return exec({cmd,projectRoot}).then(next).catch(reject);
       }
       next();
@@ -75,16 +90,7 @@ if(parsedArgs.electron){
     }
     switch(script){
         case "start":
-           cmd = "electron "+electronDir;
-           return new Promise((resolve,reject)=>{
-              exec({
-                cmd, 
-                projectRoot : electronDir,
-              }).finally(()=>{
-                console.log("ant to exit");
-              })
-              setTimeout(resolve,1000)
-           })
+           return start();
           break;
         case "build":
           break;

package/electron/app/desktopCapturer.js

@@ -0,0 +1,123 @@
+module.exports = (ELECTRON)=>{
+    let ProgressBar = require("./ProgressBar")
+    let progressBarCounter = 0;
+    function getUserMedia(constraints) {
+        let check = typeof constraints === "boolean"? true : false;
+        if(check){
+            constraints = {};
+        }
+        // if Promise-based API is available, use it
+        if (isObj(navigator.mediaDevices)) {
+            if(check === true) return true;
+            return navigator.mediaDevices.getUserMedia(constraints);
+        }
+          
+        // otherwise try falling back to old, possibly prefixed API...
+        var legacyApi = navigator.getUserMedia || navigator.webkitGetUserMedia ||
+          navigator.mozGetUserMedia || navigator.msGetUserMedia;
+        if(check === true){
+            return legacyApi ? true : false;
+        }
+        if (legacyApi) {
+          return new Promise(function (resolve, reject) {
+            legacyApi.bind(navigator)(constraints, resolve, reject);
+          });
+        }
+        return Promise.reject({status:false,msg:"user media not available"})
+    }
+    const { desktopCapturer,ipcRenderer } = require('electron')
+    let SECRET_KEY = require("../app.config").id;
+    ipcRenderer.on("click-on-system-tray-menu-item",(event,opts)=>{
+        opts = defaultObj(opts);
+        switch(opts.action){
+            case "pauseRecording":
+                return pauseRecording();
+            case "stopRecording":
+                return stopRecording();
+            case "resumeRecording" : 
+                return resumeRecording();
+        }
+    }),
+    updateSystemTray = ()=>{
+        let {isPaused,isRecording} = APP.desktopCapturer.getRecordingStatus();
+        /*ipcRenderer.send("update-system-tray",{
+            tooltip : isRecording? ("La capture vidéo est en cours d'enregistrement"):(isPaused? "La capture vidéo est en pause":"La capture vidéo est inactive"),
+            contextMenu : isRecording || isPaused? JSON.stringify([
+                { label: isRecording? 'Mettre en pause':'Relancer la capture vidéo',action:isRecording?'pauseRecording':'resumeRecording'},
+                { label: 'Arréter la capture vidéo',action:'stopRecording'}
+            ]): null
+        });*/
+        if(!APP.COMPANY.showPreloaderOnScreenCapture){
+            if(progressBarCounter !== 0){
+                progressBarCounter = 0;
+                ProgressBar.set(0);
+            }
+            return false;
+        }
+        if((isPaused || !isRecording)){
+            progressBarCounter = 0;
+        } else if(isRecording){
+            progressBarCounter+=2;
+        } else progressBarCounter = 0;
+        ProgressBar.set(progressBarCounter);
+    }
+    async function getUserMediaAsync(constraints) {
+        try {
+          const stream = await getUserMedia(constraints);
+          return stream;
+        } catch (e) {
+          console.error('navigator.getUserMedia error:', e);
+        }
+        return null;
+    }
+    function startRecording(opts) {
+        opts = defaultObj(opts)
+        var title = document.title;
+        document.title = SECRET_KEY;
+        opts.video = defaultObj(opts.video);
+        let audio = isBool(opts.audio) && !opts.audio ? false : defaultObj(opts.audio);
+        let handleStream = defaultFunc(opts.handleStream), handleUserMediaError = defaultFunc(opts.handleUserMediaError)
+        let video = {
+            ...opts.video,
+            mandatory: {
+                ...defaultObj(opts.video.mandatory),
+                chromeMediaSource: 'desktop',
+            }
+        }
+        return  desktopCapturer.getSources({ types: ['window', 'screen'] }).then(function(sources) {
+            for (let i = 0; i < sources.length; i++) {
+                let src = sources[i];
+                if (src.name === SECRET_KEY) {
+                    document.title = title;
+                    video.mandatory.chromeMediaSourceId = src.id;
+                    if(audio){
+                        (async() => {
+                            const audioStream = await getUserMediaAsync(APP.desktopCapturer.getAudioConstraint())
+                            const videoStream = await getUserMediaAsync({audio:false,video})
+                            if(audioStream && videoStream){
+                                const combinedStream = new MediaStream([...videoStream.getVideoTracks(), ...audioStream.getAudioTracks()])
+                                handleStream(combinedStream)
+                            }
+                        })();
+                    } else {
+                        getUserMedia({audio:false,video}).then(handleStream).catch(handleUserMediaError);
+                    }
+                    return {sources,currentSource:src,isRecording:true};
+                }
+            }
+            return {sources,isRecording:false};
+        });
+    }
+
+    if(!isObj(ELECTRON.desktopCapturer)){
+        Object.defineProperties(ELECTRON,{
+            desktopCapturer : {
+                value : {
+                    updateSystemTray, 
+                    startRecording,
+                }
+                ,override:false,writable:false
+            }
+        })
+    }
+}

package/electron/app/email.js

@@ -0,0 +1,55 @@
+const nodemailer = require("nodemailer");
+let Email = {}
+let getEmailSettings = x => defaultObj(APP.getRemoteInfos().get("smtp"));
+let isAvailable = ()=>{
+    if(!window.APP || typeof window.APP == "undefined") return false;
+    let infos = getEmailSettings();
+    let isR = infos.host && infos.port && infos.password && isNonNullString(infos.user)? true : false;
+    if(!isR){
+        APP.getRemoteInfos().check();
+    }
+    return isR;
+}
+let notAllowedMsg = 'Impossible d\'envoyer un mail car cette fonction n\'est pas disponible pour cette installation du logiciel';
+Object.defineProperties(Email,{
+    send : {
+        value : (opts)=>{
+            if(!isAvailable()) return Promise.reject({msg:notAllowedMsg})
+            let emailSettings =getEmailSettings();
+            opts = defaultObj(opts);
+            opts.auth = {
+                user: emailSettings.user, // generated ethereal user
+                pass: defaultStr(emailSettings.pass,emailSettings.password), // generated ethereal password
+            }
+            if(!opts.from || !isValidEmail(opts.from)){
+                opts.from = defaultStr(emailSettings.email,APP.getDevMail());
+            }
+            if(Array.isArray(opts.to)){
+                opts.to = opts.to.join(",");
+            }
+            let transporter = nodemailer.createTransport({
+                ...emailSettings,
+                auth: {
+                  user: emailSettings.user, // generated ethereal user
+                  pass: defaultStr(emailSettings.pass,emailSettings.password), // generated ethereal password
+                },
+            });
+            showPreloader(defaultStr(opts.preloader,"envoie de l'email en cours..."))
+            return new Promise((resolve,reject)=>{
+                    transporter.sendMail(opts, function(err, reply) {
+                        hidePreloader();
+                        if(err){
+                            console.log(err," error sending email")
+                            //APP.require("$notify").error(err);
+                            reject(err);
+                        } else resolve(reply);
+                
+                    })
+            })
+        }
+    },
+    nodemailer : {value : nodemailer},
+    isAvailable : {value : isAvailable},
+    notAllowedMsg : {value : notAllowedMsg}
+})
+module.exports = Email;