Skip to content
  • Home
  • Aktuell
  • Tags
  • 0 Ungelesen 0
  • Kategorien
  • Unreplied
  • Beliebt
  • GitHub
  • Docu
  • Hilfe
Skins
  • Light
  • Brite
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Standard: (Kein Skin)
  • Kein Skin
Einklappen
ioBroker Logo

Community Forum

donate donate
  1. ioBroker Community Home
  2. Deutsch
  3. Skripten / Logik
  4. JavaScript
  5. [Skript] Wiederherstellen und Auflisten von Skripten

NEWS

  • Neuer Blogbeitrag: Monatsrückblick - Dezember 2025 🎄
    BluefoxB
    Bluefox
    11
    1
    324

  • Weihnachtsangebot 2025! 🎄
    BluefoxB
    Bluefox
    24
    1
    1.5k

  • UPDATE 31.10.: Amazon Alexa - ioBroker Skill läuft aus ?
    apollon77A
    apollon77
    48
    3
    9.5k

[Skript] Wiederherstellen und Auflisten von Skripten

Geplant Angeheftet Gesperrt Verschoben JavaScript
18 Beiträge 6 Kommentatoren 2.1k Aufrufe 10 Watching
  • Älteste zuerst
  • Neuste zuerst
  • Meiste Stimmen
Antworten
  • In einem neuen Thema antworten
Anmelden zum Antworten
Dieses Thema wurde gelöscht. Nur Nutzer mit entsprechenden Rechten können es sehen.
  • liv-in-skyL Offline
    liv-in-skyL Offline
    liv-in-sky
    schrieb am zuletzt editiert von
    #5

    @fastfoot sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

    Inhaltsfilter contentFilter

    ['0_userdata.myState', 'sendTo'] findet Skripte welche im Code Wetter oder sendTo enthalten

    super sache - kleiner fehler in der beschreibung ?

    nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

    F 1 Antwort Letzte Antwort
    0
    • sigi234S sigi234

      @fastfoot sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

      @sigi234 jein, die Archiv Entpackroutinen sind (noch!!??) auf Linux ausgelegt. Wenn Du aber die entsprechende Datei entpackst und nach inputPath kopierst sollte es problemlos funktionieren. Ich wollte vermeiden dass man noch zusätzliche Libs installieren muss, überlege aber das evtl. zu ändern

      Hm, eventuell ist ja eine eigene Windows Version sinnvoll?

      F Offline
      F Offline
      fastfoot
      schrieb am zuletzt editiert von
      #6

      @sigi234 sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

      Hm, eventuell ist ja eine eigene Windows Version sinnvoll?

      nee, zuviel Supportaufwand. Ich habe aber mittlerweile Libraries gefunden, welche man (hoffentlich!) nicht nachinstallieren muss. Damit sollte es auch unter Windows und Mac laufen. Ich update Post #1 wenn fertig

      iobroker läuft unter Docker auf QNAP TS-451+
      SkriptRecovery: https://forum.iobroker.net/post/930558

      1 Antwort Letzte Antwort
      1
      • liv-in-skyL liv-in-sky

        @fastfoot sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

        Inhaltsfilter contentFilter

        ['0_userdata.myState', 'sendTo'] findet Skripte welche im Code Wetter oder sendTo enthalten

        super sache - kleiner fehler in der beschreibung ?

        F Offline
        F Offline
        fastfoot
        schrieb am zuletzt editiert von
        #7

        @liv-in-sky sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

        kleiner fehler in der beschreibung ?

        Danke, hab's korrigiert. Du hast ja auch jede Menge Skripte, wie ist die Performance denn bei Dir? Hier benötigt das Skript für 500 Skripte nur wenige Sekunden (ohne Import ins System)

        iobroker läuft unter Docker auf QNAP TS-451+
        SkriptRecovery: https://forum.iobroker.net/post/930558

        liv-in-skyL 2 Antworten Letzte Antwort
        0
        • F fastfoot

          @liv-in-sky sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

          kleiner fehler in der beschreibung ?

          Danke, hab's korrigiert. Du hast ja auch jede Menge Skripte, wie ist die Performance denn bei Dir? Hier benötigt das Skript für 500 Skripte nur wenige Sekunden (ohne Import ins System)

          liv-in-skyL Offline
          liv-in-skyL Offline
          liv-in-sky
          schrieb am zuletzt editiert von
          #8

          @fastfoot

          superschnell - 2-3 sekunden für über 850 scripte (muss mal wieder aufräumen :-) )

          nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

          1 Antwort Letzte Antwort
          1
          • F fastfoot

            @liv-in-sky sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

            kleiner fehler in der beschreibung ?

            Danke, hab's korrigiert. Du hast ja auch jede Menge Skripte, wie ist die Performance denn bei Dir? Hier benötigt das Skript für 500 Skripte nur wenige Sekunden (ohne Import ins System)

            liv-in-skyL Offline
            liv-in-skyL Offline
            liv-in-sky
            schrieb am zuletzt editiert von
            #9

            @fastfoot

            könnte sowas auch gut für die vis gebrauchen :-)

            nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

            H 1 Antwort Letzte Antwort
            0
            • liv-in-skyL liv-in-sky

              @fastfoot

              könnte sowas auch gut für die vis gebrauchen :-)

              H Offline
              H Offline
              homecineplexx
              schrieb am zuletzt editiert von
              #10

              sagt, muss diese Datei

              /home/iobroker/scriptInput
              

              vorhanden sein?

              liv-in-skyL F 2 Antworten Letzte Antwort
              0
              • H homecineplexx

                sagt, muss diese Datei

                /home/iobroker/scriptInput
                

                vorhanden sein?

                liv-in-skyL Offline
                liv-in-skyL Offline
                liv-in-sky
                schrieb am zuletzt editiert von liv-in-sky
                #11

                @homecineplexx du musst den ordner benennen und anlegen - hier mal mein setting des testscript - vielleicht hilft das - ich nutze direkt den backup folder in meinem setting und habe den output folder angelegt

                const dbg = false;
                
                // hier wird die JSON Tabelle gespeichert, der DP wird erstellt wenn generateTable true ist
                const idBase = "0_userdata.0.scriptRecovery";
                const idJson = "jsonTable";
                
                // erzeugt eine JSON Tabelle der gefundenen Skripte für eine evtl. VIS
                const generateTable = true;
                
                // erzeugt ein Listing der gefundenen Skripte(__Listingxxx.json)
                const generateListing = true;
                
                // Dateien ins Filesystem schreiben, false = brauchbar wenn man nur ein Listing will
                const restoreToFilesystem = false;
                
                // Extension für importierte Skripte, zur Unterscheidung von existierenden Skripten.
                const scriptSuffix = "_rcvr";
                
                // Skripte werden sofort ins System geladen(Endung: wie in scriptSuffix) ACHTUNG: AUF EIGENE GEFAHR!!!!
                // existierende Skripte werden nicht überschrieben
                const restoreToSystemDB = false;
                
                // Array Skriptnamen-Filter, wenn vorhanden werden nur diese  Skripte behandelt z.B. ['script 1','script 2']
                // Nur Teil-Namens sind erlaubt und Groß- Kleinschreibung ist egal
                // const scriptFilter = ['^[abc]', '[xyz0-9]$', 'script'];// Skripte beginnen mit a,b oder c oder enden mit x,y,z oder einer Zahl oder haben <<script>> im Namen
                const scriptFilter = [''];
                
                // Array Inhaltsfilter z.B. ['0_userdata.0.example_state', 'Wetter'] zum Suchen nach bestimmten Begriffen
                // const contentFilter = ['0_user', 'sql', 'sendto'];
                const contentFilter = [''];
                
                // Array - Skripte in diesen Ordnern werden nicht berücksichtigt(für rootFolder 'root' oder '/')
                // const excludeFolders = ['/','global', 'löschen'];
                const excludeFolders = [''];
                
                // Array - Nur Skripte in diesen Ordnern und deren Unterordnern werden berücksichtigt(für NUR rootFolder 'root' oder '/')
                // const includeFolders = ['/','tools', 'forum'];
                const includeFolders = [''];
                
                // Array Typ Filter um nur bestimmte Typen zu berücksichtigen (Blockly, Javascript, Rules, Typescript)
                // const typeFilter = ['Blockly','javas'];// findet Blockly- oder Javascript Skripte
                const typeFilter = [''];
                
                // hier liegt die in inputFile definierte Datei, entweder Archiv(nur Linux) oder bereits extrahierte Datei
                let inputPath = "/opt/iobroker/backups";
                
                // hier landen die extrahierten Skripte und die Listing-Datei, wird bei Skriptstart geleert und angelegt wenn nicht vorhanden
                const outputPath = "/Daten/scriptOutput";
                
                // Datei mit den Skripten(autoObjects = letzte objects.json[l], autoBackup = letzte backupdatei, autoScripts = letztes Skript Backup)
                let inputFile = "javascripts_2023_01_18-16_16_18_daily_backupiobroker.tar.gz";
                
                //                                                       Beispiele für mögliche Dateien
                // letzte Dateien JS-Controller und BackitUp-Adapter
                //inputFile = "iobroker_2023_01_18-16_15_10_daily_backupiobroker.tar.gz";
                // inputFile = "autoBackup";
                // inputFile = "autoScripts";
                
                // Backup von JS-Controller
                // inputFile = '2023-01-17_19-16_objects.jsonl.gz';
                // inputFile = "objects.jsonl";
                // inputFile = "2022-12-19_12-18_objects.json.gz";
                // inputFile = "objects.json";
                
                // BackitUp-Adapter
                // inputFile = "iobroker_2023_01_17-17_38_03_backupiobroker.tar.gz";
                // inputFile = "backup.json";
                // inputFile = "javascripts_2023_01_17-17_38_18_backupiobroker.tar.gz";
                // inputFile = "script.json";
                
                // Konsole: 'iobroker backup'
                // inputFile = "2023_01_17-17_45_40_backupiobroker.tar.gz";
                
                // JS-Adapter Export
                //inputFile = "";
                  //2023-01-17-scripts.zip 
                // Einzelskript
                // inputFile = 'findObject.json';
                // inputFile = 'sqlBL.json';
                // inputFile = 'sqlBL.js';
                
                

                nach einem gelösten Thread wäre es sinnvoll dies in der Überschrift des ersten Posts einzutragen [gelöst]-... Bitte benutzt das Voting rechts unten im Beitrag wenn er euch geholfen hat. Forum-Tools: PicPick https://picpick.app/en/download/ und ScreenToGif https://www.screentogif.com/downloads.html

                1 Antwort Letzte Antwort
                0
                • H homecineplexx

                  sagt, muss diese Datei

                  /home/iobroker/scriptInput
                  

                  vorhanden sein?

                  F Offline
                  F Offline
                  fastfoot
                  schrieb am zuletzt editiert von
                  #12

                  @homecineplexx sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

                  sagt, muss diese Datei

                  /home/iobroker/scriptInput
                  

                  vorhanden sein?

                  irgendwo muss deine zu durchsuchende Datei ja liegen :-) Du kannst das ja frei wählen. Wenn Du aber zB autoObjects angibst dann ist damit schon klar wo die Datei liegt. Allerdings wird dann nur die neueste Datei durchsucht. Oder du machst es wie liv-in-sky

                  iobroker läuft unter Docker auf QNAP TS-451+
                  SkriptRecovery: https://forum.iobroker.net/post/930558

                  1 Antwort Letzte Antwort
                  0
                  • sigi234S sigi234

                    @fastfoot

                    Cool, auch unter Windows lauffähig?

                    F Offline
                    F Offline
                    fastfoot
                    schrieb am zuletzt editiert von
                    #13

                    @sigi234 sagte in [Skript] Wiederherstellen und Auflisten von Skripten:

                    @fastfoot

                    Cool, auch unter Windows lauffähig?

                    probier mal :-)

                    iobroker läuft unter Docker auf QNAP TS-451+
                    SkriptRecovery: https://forum.iobroker.net/post/930558

                    1 Antwort Letzte Antwort
                    0
                    • F Offline
                      F Offline
                      fastfoot
                      schrieb am zuletzt editiert von
                      #14

                      kleines Update, die Fehlerbehandlung wurde verbessert. Da das Skript auch unter Windows und Mac lauffähig ist wäre eine Rückmeldung von Benutzern dieser Systeme hilfreich. Vor allem unter Mac ist das Skript gar nicht getestet

                      iobroker läuft unter Docker auf QNAP TS-451+
                      SkriptRecovery: https://forum.iobroker.net/post/930558

                      H 1 Antwort Letzte Antwort
                      0
                      • F fastfoot

                        kleines Update, die Fehlerbehandlung wurde verbessert. Da das Skript auch unter Windows und Mac lauffähig ist wäre eine Rückmeldung von Benutzern dieser Systeme hilfreich. Vor allem unter Mac ist das Skript gar nicht getestet

                        H Offline
                        H Offline
                        homecineplexx
                        schrieb am zuletzt editiert von
                        #15

                        @fastfoot said in [Skript] Wiederherstellen und Auflisten von Skripten:

                        kleines Update, die Fehlerbehandlung wurde verbessert. Da das Skript auch unter Windows und Mac lauffähig ist wäre eine Rückmeldung von Benutzern dieser Systeme hilfreich. Vor allem unter Mac ist das Skript gar nicht getestet

                        Guten Morgen
                        danke für dein Script, aber eine Frage, warum legst du es nicht in GIT ab, dann hätte man auch eine Versionierung bzw wäre vielleicht einfacher

                        F 1 Antwort Letzte Antwort
                        0
                        • H homecineplexx

                          @fastfoot said in [Skript] Wiederherstellen und Auflisten von Skripten:

                          kleines Update, die Fehlerbehandlung wurde verbessert. Da das Skript auch unter Windows und Mac lauffähig ist wäre eine Rückmeldung von Benutzern dieser Systeme hilfreich. Vor allem unter Mac ist das Skript gar nicht getestet

                          Guten Morgen
                          danke für dein Script, aber eine Frage, warum legst du es nicht in GIT ab, dann hätte man auch eine Versionierung bzw wäre vielleicht einfacher

                          F Offline
                          F Offline
                          fastfoot
                          schrieb am zuletzt editiert von
                          #16

                          @homecineplexx eine Versionierung braucht es nicht, das Skript ist 'fertig' und tut alles wozu ich es geschrieben habe. Ausser evtl. kleinerer Fehlerbehebungen wird sich da also nicht mehr viel tun

                          iobroker läuft unter Docker auf QNAP TS-451+
                          SkriptRecovery: https://forum.iobroker.net/post/930558

                          1 Antwort Letzte Antwort
                          1
                          • F fastfoot

                            Das Skript kann aus diversen Backupdateien

                            • Skripte wiederherstellen
                              • als Importdatei im Dateisystem, restoreToFilesystem im Standard false
                              • direkt in die Objektdatenbank, restoreToSystemDB im Standard false
                                • zur 'Sicherheit' und zum Schutz vor Überschreiben kann an den Namen das Suffix scriptSuffix angegeben werden, im Standard ist es auf '_rcvr' gesetzt
                            • Skripte auflisten
                              • als Datei, generateListing im Standard true, wird in outputPath gespeichert
                              • als JSON Tabelle in einem Datenpunkt zur Verwendung in VIS, generateTable im Standard true
                                • der DP wird in idBase und idJson angegeben und wird vom Skript erstellt falls generateTable true ist.
                            • Backupdateien können sein
                              • Backup der Objektdatenbank in /opt/iobroker/iobroker-data/backup-objects
                              • Backupdateien des BackitUp Adapters in /opt/iobroker/backups
                              • Exportdatei des Javascript Adapters
                              • Einzelne Skriptdatei

                            hierzu dienen verschiedene Filter-Arrays mit denen man die Ergebnisse einschränken kann. Groß- Kleinschreibung ist dabei egal, Teilausdrücke sind erlaubt, es sind reguläre Ausdrücke möglich. Die Filter können kombiniert werden

                            • Namenfilter scriptFilter
                              • ['wetter', '^a'] findet Skripte mit wetter im Namen oder die mit a oder A beginnen
                            • Inhaltsfilter contentFilter
                              • ['0_userdata.myState', 'sendTo'] findet Skripte welche im Code 0_userdata.myState oder sendTo enthalten
                            • Typfilter typeFilter
                              • ['Blockly', '^R'] findet nur Blockly- und Rules Skripte
                            • Ordnerfilter includeFolders
                              • ['tools', 'Forum'] findet nur Skripte in den Ordnern Tools und Forum und deren Unterordnern
                            • Ordnerfilter excludeFolders
                              • ['/'] oder ['root'] Nur Skripte welche in Ordnern sind werden gefunden
                              • ['Forum', 'Tools'] Skripte in diesen Ordnern und ihren Unterordnern werden ignoriert

                            Es macht keinen Sinn die beiden Ordnerfilter zu kombinieren!

                            Anleitung:
                            Mit den Standardsettings(inputFile = autoObjects) kann das Skript ohne weitere Einstellungen sofort gestartet werden. In einem neu aufgesetzten System funktioniert das jedoch nicht da ja noch keine Backupdateien existieren und die wohl auch keine Skripte enthalten

                            • Ordner für die Backupdatei anlegen und in inputPath angeben. Standard ist /home/iobroker/scriptInput
                            • Die Datei in den Ordner inputPath kopieren und in inputFile angeben. Bei Verwendung eines der drei autoxxxxxxxx Namen kann die Erstellung des inputPath entfallen
                              • autoObjects - das zuletzt vom JS-Controller erstellte Backup wird verwendet
                              • autoBackup - die letzte Backupdatei des BackitUp Adapters wird verwendet
                              • autoScript - die letzte Backupdatei für Skripte des BackitUp Adapters wird verwendet
                            • Ausgabeordner in outputPath benennen, Standard ist /home/iobroker/scriptOutput. Der Ordner wird bei Skriptstart erstellt bzw. geleert.
                            • Skript starten, das Listing befindet sich in outputPath

                            /**
                            * Name:            scriptRecovery
                            * Zweck:           Wiederherstellen/Auflisten von Skripten aus verschiedenen Quellen
                            * Datum:           24.01.2023
                            * Autor:           @fastfoot
                            * Forum:           https://forum.iobroker.net/post/930558
                            * 
                            * Changelog:       24.01.2023 - verbessertes Error-Handling
                            *                  21.01.2023 - Windows/Mac kompatibel
                            */
                            
                            /*                                                        Einstellungen                                               */
                            
                            // zusätzliche Meldungen, dafür unbedingt auch in der JS-Instanz den Debug-Modus aktivieren!!!
                            const dbg = false;
                            
                            // hier wird die JSON Tabelle gespeichert, der DP wird erstellt wenn generateTable true ist
                            const idBase = "0_userdata.0.scriptRecovery";
                            const idJson = "jsonTable";
                            
                            // erzeugt eine JSON Tabelle der gefundenen Skripte für eine evtl. VIS
                            const generateTable = true;
                            
                            // erzeugt ein Listing der gefundenen Skripte(__Listingxxx.json)
                            const generateListing = true;
                            
                            // Dateien ins Filesystem schreiben, false = brauchbar wenn man nur ein Listing will
                            const restoreToFilesystem = false;
                            
                            // Extension für importierte Skripte, zur Unterscheidung von existierenden Skripten.
                            const scriptSuffix = "_rcvr";
                            
                            // Skripte werden sofort ins System geladen(Endung: wie in scriptSuffix) ACHTUNG: AUF EIGENE GEFAHR!!!!
                            // existierende Skripte werden nicht überschrieben
                            const restoreToSystemDB = false;
                            
                            // Array Skriptnamen-Filter, wenn vorhanden werden nur diese  Skripte behandelt z.B. ['script 1','script 2']
                            // Nur Teil-Namens sind erlaubt und Groß- Kleinschreibung ist egal
                            // const scriptFilter = ['^[abc]', '[xyz0-9]$', 'script'];// Skripte beginnen mit a,b oder c oder enden mit x,y,z oder einer Zahl oder haben <<script>> im Namen
                            const scriptFilter = [''];
                            
                            // Array Inhaltsfilter z.B. ['0_userdata.0.example_state', 'Wetter'] zum Suchen nach bestimmten Begriffen
                            // const contentFilter = ['0_user', 'sql', 'sendto'];
                            const contentFilter = [''];
                            
                            // Array - Skripte in diesen Ordnern werden nicht berücksichtigt(für rootFolder 'root' oder '/')
                            // const excludeFolders = ['/','global', 'löschen'];
                            const excludeFolders = [''];
                            
                            // Array - Nur Skripte in diesen Ordnern und deren Unterordnern werden berücksichtigt(für NUR rootFolder 'root' oder '/')
                            // const includeFolders = ['/','tools', 'forum'];
                            const includeFolders = [''];
                            
                            // Array Typ Filter um nur bestimmte Typen zu berücksichtigen (Blockly, Javascript, Rules, Typescript)
                            // const typeFilter = ['Blockly','javas'];// findet Blockly- oder Javascript Skripte
                            const typeFilter = [''];
                            
                            // hier liegt die in inputFile definierte Datei, entweder Archiv oder bereits extrahierte Datei
                            let inputPath = "../../scriptInput";
                            
                            // hier landen die extrahierten Skripte und die Listing-Datei, wird bei Skriptstart geleert und angelegt wenn nicht vorhanden
                            const outputPath = "../../scriptOutput";
                            
                            // Datei mit den Skripten(autoObjects = letzte objects.json[l], autoBackup = letzte backupdatei, autoScripts = letztes Skript Backup)
                            let inputFile = "";
                            
                            //                                                       Beispiele für mögliche Dateien
                            // letzte Dateien JS-Controller und BackitUp-Adapter
                            inputFile = "autoObjects";
                            // inputFile = "autoBackup";
                            // inputFile = "autoScripts";
                            
                            // Backup von JS-Controller
                            // inputFile = '2023-01-23_13-30_objects.jsonl.gz';
                            // inputFile = "objects.jsonl";
                            // inputFile = "2022-12-19_12-18_objects.json.gz";
                            // inputFile = "objects.json";
                            
                            // BackitUp-Adapter
                            // inputFile = "iobroker_2023_01_23-13_34_49_backupiobroker.tar.gz";
                            // inputFile = "backup.json";
                            // inputFile = "javascripts_2023_01_23-13_35_04_backupiobroker.tar.gz";
                            // inputFile = "script.json";
                            
                            // Konsole: 'iobroker backup'
                            // inputFile = "2023_01_23-13_36_02_backupiobroker.tar.gz";
                            
                            // JS-Adapter Export
                            // inputFile = "2023-01-24-scripts.zip";
                            // inputFile = "FullBackup-scripts_2023-01-11.zip";
                            
                            // Einzelskript
                            // inputFile = 'sqlBlockly.js';
                            
                            /* **************************************************************************************
                            * *******************                                                *******************
                            * *******************       Ab hier keine Änderungen vornehmen       *******************
                            * *******************                                                *******************
                            * **************************************************************************************
                            */
                            // @ts-ignore
                            const fse = require("fs-extra");
                            const Path = require("path");
                            // @ts-ignore
                            const tar = require('tar');
                            // @ts-ignore
                            const JSZip = require('jszip');
                            const zlib = require('node:zlib');
                            const { pipeline } = require('node:stream');
                            // const os = require("os");
                            
                            // hier werden die aus evtl. Archiven(tar.gz, gz, zip) extrahierten Skripte temporär abgelegt. Wird bei Skriptstart angelegt wenn nicht vorhanden
                            const tmpRoot = '../../scriptTmp';// os.tmpdir();
                            const tmpPath = Path.resolve(tmpRoot, scriptName.slice(10));
                            
                            // Ignoriert Fehler in der JSONL Datenbank
                            const ignoreJsonlErrors = true;
                            
                            // komprimiere JSONL Datenbank beim Einlesen
                            const compressJsonl = false;
                            
                            // wichtig damit der mirrorPath nicht überschrieben wird und somit alle Skripte gelöscht werden
                            const mirrorPath = getObject("system.adapter.javascript.0").native.mirrorPath;
                            
                            start();
                            
                            async function start() {
                               if (dbg) console.error('Debugmode aktiv, unbedingt auch in der JS-Instanz den Debug-Modus aktivieren!!!');
                               fse.ensureDirSync(tmpPath);
                               fse.emptyDirSync(tmpPath);
                               fse.ensureDirSync(outputPath);
                            
                               if (outputPath != mirrorPath) {
                                   fse.emptyDirSync(outputPath);
                               }
                               try { await main(); }
                               catch (e) { return console.error('Ein Fehler ist aufgetreten!') }
                            
                               stopScript(scriptName);
                            }
                            
                            async function main() {
                               let dataFile = '';
                               let allScripts = {};
                               switch (inputFile.toLocaleLowerCase()) {
                                   case 'autoobjects':
                                       inputPath = '../../iobroker-data/backup-objects';
                                       inputFile = await getNewestFile(inputPath, /objects\.jsonl\.gz/);//await getLatestObjects();
                                       break;
                                   case 'autobackup':
                                       inputPath = '../../backups';
                                       inputFile = await getNewestFile(inputPath, /^[2i.+\.tar\.gz]/);//await getLatestBackup();
                                       break;
                                   case 'autoscripts':
                                       inputPath = '../../backups';
                                       inputFile = await getNewestFile(inputPath, /^javascript.+\.tar\.gz/);//await getLatestScripts();
                                       break;
                                   default:
                               }
                            
                               if (inputFile === '' || inputFile === undefined) {
                                   return console.error(`[main()] - Keine Datei in ${inputPath} gefunden!`);
                               }
                            
                               if (!(await fse.pathExists(Path.resolve(inputPath, inputFile)))) {
                                   return console.error(`[main()] - Die Datei ${inputFile} in ${inputPath} wurde nicht gefunden!`);
                               }
                            
                               const fullArchiveName = Path.resolve(inputPath, inputFile);
                               if (inputFile.indexOf('.tar.gz') > 0) {
                                   dataFile = await tarExtract(fullArchiveName);
                            
                                   if (dataFile.endsWith('backup.json')) {
                                       allScripts = await handleBackup(dataFile);
                                   } else if (dataFile.endsWith('script.json')) {
                                       allScripts = await handleJson(dataFile);
                                   }
                               } else if (inputFile.endsWith('backup.json')) {
                                   allScripts = await handleBackup(fullArchiveName);
                               } else if (inputFile.endsWith('script.json')) {
                                   allScripts = await handleJson(fullArchiveName);
                               } else if (inputFile.indexOf('.jsonl.gz') > 0) {
                                   dataFile = await gzipExtract(fullArchiveName);
                                   allScripts = await handleJsonl(dataFile);
                               } else if (inputFile.endsWith('objects.jsonl')) {
                                   allScripts = await handleJsonl(fullArchiveName);
                               } else if (inputFile.indexOf('.json.gz') > 0) {
                                   dataFile = await gzipExtract(fullArchiveName);
                                   allScripts = await handleJson(dataFile);
                               } else if (inputFile.endsWith('objects.json')) {
                                   allScripts = await handleJson(fullArchiveName);
                               } else if (inputFile.indexOf('.zip') > 0) {
                                   dataFile = await zipExtract(fullArchiveName);
                                   if (dataFile)
                                       allScripts = await handleExport(dataFile);
                                   else
                                       return console.warn('Keine passenden Dateien gefunden, Filter prüfen!');
                               } else if (inputFile) {
                                   try {
                                       let b = fse.lstatSync(fullArchiveName).isDirectory()
                                   } catch (e) {
                                       return console.error('[main()] - Fehler: ' + e);
                                   }
                                   allScripts = await handleExport(inputFile, inputPath);
                               } else {
                                   return console.error('[main()] - Fehler: Variable inputFile falsch belegt')
                               }
                               if (dbg) {
                                   console.debug('[main()] - datafile = ' + (dataFile != '' ? dataFile : inputFile))
                               };
                               handleScripts(allScripts);
                            }
                            
                            async function handleScripts(allScripts) {
                               let res = {};
                               let tableData = [];
                            
                               for (let key in allScripts) {
                                   let fileExtension = "";
                                   let script = allScripts[key];
                                   const keyNew = key + scriptSuffix;
                                   const folder = key.replace('script.js.', '').replace(script.common.name, '').replace(/\.$/, '');
                            
                                   // exclude Filter
                                   if (isExcludedFolder(folder)) continue;
                                   // folder Filter
                                   if (!isIncludedFolder(folder)) continue;
                                   // script Filter
                                   if (!isName(script.common.name)) continue;
                                   // Typ Filter
                                   if (!isType(script.common.engineType)) continue;
                                   // Inhalts Filter
                                   if (!isContent(script.common.source)) continue;
                            
                                   script.common.enabled = false;
                                   script.common.debug = false;
                                   script.common.verbose = false;
                                   script.common.expert = false;
                            
                                   if (!existsObject(keyNew) && restoreToSystemDB) {
                                       if (dbg) console.debug('[handleSripts()] - Key: ' + key);
                                       const oldName = script.common.name;
                                       script.common.name += scriptSuffix;
                                       await createScriptFolder(keyNew.slice(0, keyNew.length - script.common.name.length - 1));
                                       await setObjectAsync(keyNew, { type: "script", common: script.common, native: {} });
                            
                                       script.common.name = oldName;
                                   }
                                   if (restoreToFilesystem) {
                                       let data = script.common.source;
                            
                                       switch (script.common.engineType.toLowerCase()) {
                                           case "blockly":
                                               fileExtension = ".xml";
                                               if (script.common.source.length)
                                                   data = handleBlockly(data);
                                               else console.warn("217 Leeres Skript: " + script.common.name);
                                               break;
                                           case "rules":
                                               fileExtension = ".js";
                                               break;
                                           case "javascript/js":
                                               fileExtension = ".js";
                                               break;
                                           case "typescript/ts":
                                               fileExtension = ".ts";
                                               break;
                                           default:
                                               fileExtension = ".js";
                                       }
                            
                                       if (data && data.length) {
                                           if (dbg) console.debug('[handleSripts()] - Key: ' + key);
                                           if (dbg) console.debug('[handleSripts()] - Pfad: ' + Path.resolve(outputPath, key.substring(10)));
                                           let scriptName = key.split('.').pop();
                                           let scriptPfad = key.slice(10, key.length - scriptName.length - 1).replace(/\./g, '/');
                                           scriptPfad = Path.resolve(outputPath, scriptPfad);
                                           fse.ensureDirSync(scriptPfad);
                                           fse.writeFile(
                                               Path.resolve(scriptPfad, scriptName) + fileExtension,
                                               data,
                                               (e) => {
                                                   if (e) console.error("[handleSripts()] - Fehler beim Schreiben der Datei:" + e.code);
                                               }
                                           );
                                       } else {
                                           if (dbg) console.debug('[handleSripts()] - No source data: ' + key);
                                       }
                                   }
                            
                                   if (generateTable) {
                                       tableData = generateJsonTable(script, tableData);
                                   }
                                   if (dbg) console.debug('[handleSripts()] - Key: ' + key)
                                   res[key.substring(10)] = script.common.engineType;
                               }
                            
                               if (generateTable) {
                                   if (!tableData.length) {
                                       tableData.push({ Warnung: 'Keine Daten vorhanden, Filter prüfen!' });
                                   } else {
                                       tableData.sort((a, b) => a.Name.localeCompare(b.Name));
                                       let no = 0;
                                       tableData.forEach(rec => rec.Nr = ++no);
                                   }
                                   if (await createDatapoints(idBase)) {
                                       setState(`${idBase}.${idJson}`, JSON.stringify(tableData));
                                   }
                               }
                            
                               if (generateListing) {
                                   let b = {};
                                   if (Object.keys(res).length) {
                                       // sortieren
                                       let a = Object.keys(res).sort();
                                       for (let i = 0; i < a.length; i++) {
                                           b[i + 1 + " " + a[i]] = res[a[i]];
                                       }
                                   } else {
                                       b.Warnung = 'Keine Daten vorhanden, Filter prüfen!';
                                   }
                                   const fullFileName = Path.resolve(outputPath, '__Listing_' + inputFile + ".json");
                                   fse.writeFile(fullFileName, JSON.stringify(b, null, 3), (e) => {
                                       if (e) console.error("[handleSripts()] - Schreibfehler bei Ergebnisdatei");
                                   });
                               }
                            }
                            
                            /* extrahiere Skripte aus iobroker Datenbank (neueste Version JSONL)*/
                            async function handleJsonl(dataFile) {
                               const allScripts = {};
                               // @ts-ignore
                               const DB = require("@alcalzone/jsonl-db").JsonlDB;
                               const dbOptions = {
                                   autoCompress: { onOpen: compressJsonl },
                                   ignoreReadErrors: ignoreJsonlErrors,
                               };
                               const db = new DB(dataFile, dbOptions);
                               try {
                                   await db.open();
                               } catch (e) {
                                   console.error(`[handleJsonl()] - Fehler beim Öffnen der Datenbank ${dataFile} in ${inputPath}` + e);
                               }
                               db.forEach((obj, key) => {
                                   if (obj.type === "script") {
                                       allScripts[key] = obj;
                                   }
                               });
                               await db.close();
                            
                               return allScripts;
                            }
                            
                            /* extrahiere Skripte aus iobroker Datenbank (ältere Version JSON)*/
                            async function handleJson(dataFile) {
                               let allData = '';
                               const allScripts = [];
                               let allObjects = new Object();
                               try {
                                   allData = fse.readFileSync(dataFile, "utf8");
                               } catch (e) {
                                   console.error(`[handleJson()] - Fehler beim Lesen von ${inputFile} in ${inputPath}: ` + e);
                               }
                               try {
                                   allObjects = JSON.parse(allData);
                               } catch (e) {
                                   console.error("[handleJson()] - Fehlerhafte Daten: ==> " + e);
                               }
                               for (let prop in allObjects) {
                                   const obj = allObjects[prop];
                                   if (obj.type === "script") {
                                       allScripts[prop] = obj;
                                   }
                               }
                               return allScripts;
                            }
                            
                            /* extrahiere Skripte aus backup.json des Backitup-Adapers */
                            async function handleBackup(dataFile) {
                               let allData = '';
                               const allScripts = {};
                               let allObjects = [];
                               try {
                                   allData = fse.readFileSync(dataFile, "utf8");
                               } catch (e) {
                                   console.error(`[handleBackup()] - Fehler beim Lesen von ${inputFile} in ${inputPath}: ` + e);
                               }
                               try {
                                   allObjects = JSON.parse(allData).objects;
                               } catch (e) {
                                   console.error('[handleBackup()] - Fehlerhafte Daten: ==> ' + e);
                               }
                            
                               for (let obj of allObjects) {
                                   if (obj.value.type === 'script') {
                                       allScripts[obj.id] = obj.value;
                                   }
                               }
                               return allScripts;
                            }
                            
                            /* bearbeite Skripte */
                            async function handleExport(scriptListx, dir = tmpPath) {
                               const allScripts = {};
                               const scriptList = scriptListx.trim().split(' ');
                               let fileObj = {};
                               let sourceData = '';
                            
                               scriptList.forEach((file) => {
                                   const scriptObj = {
                                       "_id": "script.js.",
                                       "common": {
                                           "name": "",
                                           "engineType": "JavaScript/js",
                                           "engine": "system.adapter.javascript.0",
                                           "source": "",
                                           "enabled": false,
                                           "debug": false,
                                           "verbose": false
                                       },
                                       "type": "script",
                                       "native": {},
                                       "ts": 0,
                                   }
                                   const scriptNam = getFileName(file);
                                   if (dbg) console.debug('[handleExport()] - File: ' + file);
                                   if (dbg) console.debug('[handleExport()] - Name: ' + scriptNam);
                                   let scriptData;
                                   scriptData = fse.readFileSync(Path.resolve(dir, file), 'utf8');
                                   const regExport = new RegExp(/\/\* -- do not edit/);
                                   if (regExport.test(scriptData)) {
                                       const regObj = new RegExp(/(\{.+\})(?:\n-- do not edit prev)/s);
                                       sourceData = scriptData.substring(scriptData.indexOf('END --*/') + 9);
                                       if (regObj.test(scriptData)) {
                                           try {
                                               fileObj = JSON.parse(regObj.exec(scriptData)[1]) || '{}';
                                           } catch (e) {
                                               console.error('[handleExport()] - Fehler');
                                           }
                                       }
                                   } else {
                                       sourceData = scriptData;
                                   }
                                   const engineType = getEngineType(sourceData);
                                   if (dbg) console.debug('[handleExport()] - ' + engineType);
                                   if (dbg) console.debug('[handleExport()] - Type: ' + engineType);
                                   if (dbg) console.debug('[handleExport()] - File: ' + file);
                                   if (dbg) console.debug('[handleExport()] - Id: ' + file.replace(/\//g, '.').replace(/.json$/, ''));
                                   scriptObj._id = `script.js.${file.replace(/\//g, '.').replace(/.json$|.js$/, '')}`;
                                   scriptObj.ts = fileObj.ts || Date.now();
                                   scriptObj.common.name = scriptNam;
                                   scriptObj.common.source = sourceData;
                                   scriptObj.common.engineType = fileObj.engineType || engineType;
                                   scriptObj.common.engine = fileObj.engine || 'system.adapter.javascript.0';
                                   scriptObj.common.enabled = fileObj.enabled || false;
                                   scriptObj.common.debug = fileObj.debug || false;
                                   scriptObj.common.verbose = fileObj.verbose || false;
                                   if (fileObj && fileObj.engineType && fileObj.engineType.toLowerCase() === 'typescript/ts') {
                                       scriptObj.common.sourceHash = fileObj.sourceHash;
                                       scriptObj.common.compiled = fileObj.compiled;
                                   }
                            
                                   allScripts[scriptObj._id] = scriptObj;
                            
                               })
                            
                               return allScripts;
                            }
                            
                            function generateJsonTable(scriptData, tableData) {
                               const data = scriptData.common.source;
                               const dt = scriptData.ts && new Date(scriptData.ts) || 0;
                            
                               let Zweck = '-',
                                   Autor = '-',
                                   Datum = dt && dt.getFullYear() + '-' + dt.getMonth() + 1 + '-' + dt.getDate() || '-',
                                   Instance = scriptData.common.engine.split('.').pop(),
                                   sName = scriptData.common.name
                            
                               if (/(Zweck|Purpose):\s+(.*)/.test(data)) {
                                   if (dbg) console.debug('[generateJsonTable()] - Zweck: ' + /(Zweck|Purpose):\s+(.*)/.exec(data))
                                   Zweck = /(Zweck|Purpose):\s+(.*)/.exec(data)[2];
                               }
                               if (/(Autor|Author):\s+(.*)/.test(data)) {
                                   Autor = /(Autor|Author):\s+(.*)/.exec(data)[2];
                               }
                               if (/(Datum|Date):\s+(.*)/.test(data)) {
                                   Datum = /(Datum|Date):\s+(.*)/.exec(data)[2].replace(/(\d+).(\d+).(\d+)/, "$3-$2-$1");
                               }
                               let p = scriptData._id.lastIndexOf('.');
                               let ps = '';
                               if (p === 9) ps = '/';
                               else ps = '/' + scriptData._id.slice(10, p);
                               tableData.push({
                                   Nr: 0,
                                   Name: sName,
                                   Pfad: ps,
                                   Zweck: Zweck,
                                   Autor: Autor,
                                   Datum: Datum,
                                   Instanz: Instance,
                                   Typ: scriptData.common.engineType.split('/')[0]
                               })
                            
                               return tableData;
                            }
                            
                            function isName(name) {
                               if (dbg) console.debug('[isName()] - Name: ' + name);
                               const regExp = new RegExp(scriptFilter.slice(0).join("|"), "i");
                               return regExp.test(name);
                            }
                            
                            function isExcludedFolder(folder) {
                               if (folder === '') folder = 'root/';
                               const filter = excludeFolders.slice(0).join("|") || '&&&';
                               if (dbg) console.debug('[isExcludedFolder()] -  Folder: ' + folder);
                               if (dbg) console.debug('[isExcludedFolder()] - Filter: ' + filter);
                               const regExp = new RegExp(filter, "i");
                               return regExp.test(folder);
                            }
                            
                            function isIncludedFolder(folder) {
                               if (folder === '') folder = 'root/';
                               const filter = includeFolders.slice(0).join("|");
                               if (dbg) console.debug('[isIncludedFolder()] - Folder: ' + folder);
                               if (dbg) console.debug('[isIncludedFolder()] - Filter: ' + filter);
                               const regExp = new RegExp(filter, "i");
                               return regExp.test(folder);
                            }
                            
                            function isType(typ) {
                               const regExp = new RegExp(typeFilter.slice(0).join("|"), "i");
                               return regExp.test(typ);
                            }
                            
                            function isContent(source) {
                               const regExp = new RegExp(contentFilter.slice(0).join("|"), "i");
                               return regExp.test(source);
                            }
                            
                            function handleBlockly(source) {
                               const pos = source.lastIndexOf("\n");
                               if (pos !== -1) {
                                   source = source.substring(pos + 3);
                                   if (source.indexOf("JTNDeG1sJTIweG1") > -1) {
                                       source = decodeURIComponent(
                                           Buffer.from(source, "base64").toString("utf8")
                                       );
                                       return prettifyXml(source);
                                   }
                               } else return prettifyXml(source);
                            
                               //from Stackoverflow
                               function prettifyXml(xml) {
                                   var reg = /(>)\s*(<)(\/*)/g;
                                   xml = xml.replace(/\r|\n/g, ''); //deleting already existing whitespaces
                                   xml = xml.replace(reg, "$1\r\n$2$3");
                                   return xml;
                               }
                            }
                            
                            const tarList = async file => {
                               const filenames = []
                               await tar.list({
                                   file,
                                   onentry: entry => {
                                       if (/script.json|backup.json/.test(entry.path)) {
                                           filenames.push(entry.path)
                                       }
                                   },
                               })
                               return filenames
                            }
                            
                            const tarExtract = async archive => {
                               const fileList = await tarList(archive);
                               const strip = fileList.includes('backup/backup.json') ? 1 : 0;
                               if (dbg) console.debug(strip + '   ' + fileList);
                               const opts = {
                                   file: archive,
                                   strip,
                                   cwd: tmpPath
                               }
                               await tar.extract(opts, fileList);
                               return Path.resolve(tmpPath, fileList[0].replace('backup/', ''));
                            }
                            
                            const zipExtract = async archive => {
                               return new Promise(async (resolve, reject) => {
                                   let fileList = [];
                                   const data = fse.readFileSync(archive)
                                   const zip = new JSZip();
                                   const zipObj = await zip.loadAsync(data);
                                   zipObj.filter((a, b) => false)
                                   zipObj.folder().forEach(async (fileName, entry) => {
                                       const fullPath = Path.resolve(tmpPath, fileName);
                                       const pos = fullPath.lastIndexOf(Path.sep) + 1;
                                       const realName = fullPath.substring(pos);
                                       const realPath = fullPath.substring(0, pos - 1);
                                       if (!entry.dir && isName(realName) && realName.indexOf('_dir.json') < 0) {
                                           if (dbg) console.debug(realPath + '  = ' + realName);
                                           fse.ensureDirSync(Path.resolve(tmpPath, realPath));
                                           fse.writeFileSync(fullPath, Buffer.from(entry._data.compressedContent));
                                           fileList.push(fileName);
                                       }
                                   })
                                   resolve(fileList.join(' '));
                               })
                            }
                            
                            const gzipExtract = async archive => {
                               return new Promise(async (resolve, reject) => {
                                   const objectsFile = archive.split(Path.sep).pop().replace('.gz', '').substring(17);
                                   const gunzip = zlib.createGunzip();
                                   const readStream = fse.createReadStream(archive);
                                   const writeStream = fse.createWriteStream(Path.resolve(tmpPath, objectsFile));
                                   readStream.on('error', e => {
                                       reject(console.error(e));
                                   })
                                   writeStream.on('error', e => {
                                       reject(console.error(e));
                                   })
                            
                                   pipeline(readStream, gunzip, writeStream, e => {
                                       if (e) reject(console.error(e));
                                       resolve(Path.resolve(tmpPath, objectsFile));
                                   })
                               })
                            }
                            
                            function getFileName(fullName) {
                               return fullName.substring(fullName.lastIndexOf('/') + 1, fullName.lastIndexOf('.'));
                            }
                            
                            function isBlockly(sourceData) {
                               const pos = sourceData.lastIndexOf('\n');
                               const testData = sourceData.substring(pos + 1);
                               return /^[\/][\/]JTNDeG1sJTIwe/.test(testData);
                            }
                            
                            function isRules(sourceData) {
                               const pos = sourceData.lastIndexOf('\n');
                               const testData = sourceData.substring(pos + 1);
                               return /[/][/]{"triggers":/.test(testData);
                            }
                            
                            function isTypescript(sourceData) {
                               return /(let|const|var)\s*[a-zA-Z0-9]+:*(string|object|number)/.test(sourceData);
                            }
                            
                            function getEngineType(sourceData) {
                               return isBlockly(sourceData) ? 'Blockly'
                                   : isRules(sourceData) ? 'Rules'
                                       : isTypescript(sourceData) ? 'Typescript/ts'
                                           : 'Javascript/js';
                            }
                            
                            async function getNewestFile(dir, filter) {
                               return new Promise((resolve, reject) => {
                                   return fse.readdir(dir, (e, f) => {
                                       if (e) reject(e);
                                       const s = f.map(f => {
                                           let t;
                                           const ff = Path.resolve(dir, f);
                                           try {
                                               t = fse.lstatSync(ff).mtime.getTime();
                                           } catch (e) {
                                               reject(e)
                                           }
                                           return { name: f, time: t }
                                       })
                                           .sort((a, b) => b.time - a.time)
                                           .map(v => v.name)
                                           .filter(v => filter.test(v));
                                       resolve(s[0]);
                                   })
                               })
                            }
                            
                            // create data points if not existing
                            async function createDatapoints(idBase) {
                               let dp,
                                   idKey,
                                   firstRun = false;
                            
                               if (!idBase.startsWith('0_userdata.0')) return firstRun;
                               firstRun = true;
                               const stateAttributes = {};
                               stateAttributes[idJson] = { "name": "Skripte Info", "type": "json", "role": "", "read": true, "write": true, "desc": "enthält Skript Tabelle", "def": "" }
                            
                               //createScriptFolder(idBase);
                               for (let key in stateAttributes) {
                            
                                   idKey = idBase + '.' + key;
                            
                                   if (!(await existsStateAsync(idKey))) {
                                       dp = stateAttributes[key];
                                       firstRun = true;
                                       let e = await createStateAsync(idKey, dp);
                                       if (e) console.error('[createDatapoints()] - createState: ' + e);
                                   }
                               }
                            
                               return firstRun;
                            
                            }
                            
                            async function createScriptFolder(id) {
                               const arr = id.split('.');
                               const preId = arr[0] + '.' + arr[1];
                               if (preId.length === id.length || (preId != 'script.js' /*&& preId != '0_userdata.0'*/)) return;
                               const idNew = id.replace(/[\s"]/g, '_');
                            
                               if (!(await existsObjectAsync(idNew))) {
                                   const obj = new Object({
                                       "type": "folder",
                                       "common": {
                                           name: arr[arr.length - 1]
                                       },
                                       "native": {},
                                   })
                            
                                   await setObjectAsync(idNew, obj);
                               }
                               arr.pop();
                               id = arr.join('.');
                               await createScriptFolder(id);
                            }
                            
                            onStop(() => {
                               fse.removeSync(tmpPath);
                               if (dbg) console.log('[onStop()] - Skript wurde nach Beendigung automatisch gestoppt!');
                            })
                            

                            S Offline
                            S Offline
                            sruhsam
                            schrieb am zuletzt editiert von
                            #17

                            @fastfoot
                            super Teil, war sehr lange auf der Suche ......

                            Hat super funktioniert, doch nun kommt aber ein Fehler, bestimmt kein großes ding .......

                            16:19:25.797	info	javascript.0 (22538) Stop script script.js.common.Restore
                            16:19:27.683	info	javascript.0 (22538) Start javascript script.js.common.Restore
                            16:19:27.684	error	javascript.0 (22538) script.js.common.Restore compile failed: at script.js.common.Restore:15
                            
                            javascript.0
                            2023-08-25 16:27:43.558	error	at processImmediate (node:internal/timers:473:21)
                            
                            javascript.0
                            2023-08-25 16:27:43.558	error	at Immediate._onImmediate (/opt/iobroker/node_modules/iobroker.javascript/main.js:1628:17)
                            
                            javascript.0
                            2023-08-25 16:27:43.558	error	at /opt/iobroker/node_modules/iobroker.javascript/main.js:2153:17
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	at prepareScript (/opt/iobroker/node_modules/iobroker.javascript/main.js:2055:37)
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	at createVM (/opt/iobroker/node_modules/iobroker.javascript/main.js:1802:21)
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	at new Script (node:vm:100:7)
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	SyntaxError: Identifier 'dbg' has already been declared
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	^
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	const dbg = false;
                            
                            javascript.0
                            2023-08-25 16:27:43.557	error	script.js.common.Restore compile failed: at script.js.common.Restore:15
                            
                            javascript.0
                            2023-08-25 16:27:43.556	info	Start javascript script.js.common.Restore
                            
                            javascript.0
                            2023-08-25 16:27:36.426	info	Stop script script.js.common.Restore
                            

                            Grüße Stephan

                            1 Antwort Letzte Antwort
                            0
                            • F fastfoot

                              Das Skript kann aus diversen Backupdateien

                              • Skripte wiederherstellen
                                • als Importdatei im Dateisystem, restoreToFilesystem im Standard false
                                • direkt in die Objektdatenbank, restoreToSystemDB im Standard false
                                  • zur 'Sicherheit' und zum Schutz vor Überschreiben kann an den Namen das Suffix scriptSuffix angegeben werden, im Standard ist es auf '_rcvr' gesetzt
                              • Skripte auflisten
                                • als Datei, generateListing im Standard true, wird in outputPath gespeichert
                                • als JSON Tabelle in einem Datenpunkt zur Verwendung in VIS, generateTable im Standard true
                                  • der DP wird in idBase und idJson angegeben und wird vom Skript erstellt falls generateTable true ist.
                              • Backupdateien können sein
                                • Backup der Objektdatenbank in /opt/iobroker/iobroker-data/backup-objects
                                • Backupdateien des BackitUp Adapters in /opt/iobroker/backups
                                • Exportdatei des Javascript Adapters
                                • Einzelne Skriptdatei

                              hierzu dienen verschiedene Filter-Arrays mit denen man die Ergebnisse einschränken kann. Groß- Kleinschreibung ist dabei egal, Teilausdrücke sind erlaubt, es sind reguläre Ausdrücke möglich. Die Filter können kombiniert werden

                              • Namenfilter scriptFilter
                                • ['wetter', '^a'] findet Skripte mit wetter im Namen oder die mit a oder A beginnen
                              • Inhaltsfilter contentFilter
                                • ['0_userdata.myState', 'sendTo'] findet Skripte welche im Code 0_userdata.myState oder sendTo enthalten
                              • Typfilter typeFilter
                                • ['Blockly', '^R'] findet nur Blockly- und Rules Skripte
                              • Ordnerfilter includeFolders
                                • ['tools', 'Forum'] findet nur Skripte in den Ordnern Tools und Forum und deren Unterordnern
                              • Ordnerfilter excludeFolders
                                • ['/'] oder ['root'] Nur Skripte welche in Ordnern sind werden gefunden
                                • ['Forum', 'Tools'] Skripte in diesen Ordnern und ihren Unterordnern werden ignoriert

                              Es macht keinen Sinn die beiden Ordnerfilter zu kombinieren!

                              Anleitung:
                              Mit den Standardsettings(inputFile = autoObjects) kann das Skript ohne weitere Einstellungen sofort gestartet werden. In einem neu aufgesetzten System funktioniert das jedoch nicht da ja noch keine Backupdateien existieren und die wohl auch keine Skripte enthalten

                              • Ordner für die Backupdatei anlegen und in inputPath angeben. Standard ist /home/iobroker/scriptInput
                              • Die Datei in den Ordner inputPath kopieren und in inputFile angeben. Bei Verwendung eines der drei autoxxxxxxxx Namen kann die Erstellung des inputPath entfallen
                                • autoObjects - das zuletzt vom JS-Controller erstellte Backup wird verwendet
                                • autoBackup - die letzte Backupdatei des BackitUp Adapters wird verwendet
                                • autoScript - die letzte Backupdatei für Skripte des BackitUp Adapters wird verwendet
                              • Ausgabeordner in outputPath benennen, Standard ist /home/iobroker/scriptOutput. Der Ordner wird bei Skriptstart erstellt bzw. geleert.
                              • Skript starten, das Listing befindet sich in outputPath

                              /**
                              * Name:            scriptRecovery
                              * Zweck:           Wiederherstellen/Auflisten von Skripten aus verschiedenen Quellen
                              * Datum:           24.01.2023
                              * Autor:           @fastfoot
                              * Forum:           https://forum.iobroker.net/post/930558
                              * 
                              * Changelog:       24.01.2023 - verbessertes Error-Handling
                              *                  21.01.2023 - Windows/Mac kompatibel
                              */
                              
                              /*                                                        Einstellungen                                               */
                              
                              // zusätzliche Meldungen, dafür unbedingt auch in der JS-Instanz den Debug-Modus aktivieren!!!
                              const dbg = false;
                              
                              // hier wird die JSON Tabelle gespeichert, der DP wird erstellt wenn generateTable true ist
                              const idBase = "0_userdata.0.scriptRecovery";
                              const idJson = "jsonTable";
                              
                              // erzeugt eine JSON Tabelle der gefundenen Skripte für eine evtl. VIS
                              const generateTable = true;
                              
                              // erzeugt ein Listing der gefundenen Skripte(__Listingxxx.json)
                              const generateListing = true;
                              
                              // Dateien ins Filesystem schreiben, false = brauchbar wenn man nur ein Listing will
                              const restoreToFilesystem = false;
                              
                              // Extension für importierte Skripte, zur Unterscheidung von existierenden Skripten.
                              const scriptSuffix = "_rcvr";
                              
                              // Skripte werden sofort ins System geladen(Endung: wie in scriptSuffix) ACHTUNG: AUF EIGENE GEFAHR!!!!
                              // existierende Skripte werden nicht überschrieben
                              const restoreToSystemDB = false;
                              
                              // Array Skriptnamen-Filter, wenn vorhanden werden nur diese  Skripte behandelt z.B. ['script 1','script 2']
                              // Nur Teil-Namens sind erlaubt und Groß- Kleinschreibung ist egal
                              // const scriptFilter = ['^[abc]', '[xyz0-9]$', 'script'];// Skripte beginnen mit a,b oder c oder enden mit x,y,z oder einer Zahl oder haben <<script>> im Namen
                              const scriptFilter = [''];
                              
                              // Array Inhaltsfilter z.B. ['0_userdata.0.example_state', 'Wetter'] zum Suchen nach bestimmten Begriffen
                              // const contentFilter = ['0_user', 'sql', 'sendto'];
                              const contentFilter = [''];
                              
                              // Array - Skripte in diesen Ordnern werden nicht berücksichtigt(für rootFolder 'root' oder '/')
                              // const excludeFolders = ['/','global', 'löschen'];
                              const excludeFolders = [''];
                              
                              // Array - Nur Skripte in diesen Ordnern und deren Unterordnern werden berücksichtigt(für NUR rootFolder 'root' oder '/')
                              // const includeFolders = ['/','tools', 'forum'];
                              const includeFolders = [''];
                              
                              // Array Typ Filter um nur bestimmte Typen zu berücksichtigen (Blockly, Javascript, Rules, Typescript)
                              // const typeFilter = ['Blockly','javas'];// findet Blockly- oder Javascript Skripte
                              const typeFilter = [''];
                              
                              // hier liegt die in inputFile definierte Datei, entweder Archiv oder bereits extrahierte Datei
                              let inputPath = "../../scriptInput";
                              
                              // hier landen die extrahierten Skripte und die Listing-Datei, wird bei Skriptstart geleert und angelegt wenn nicht vorhanden
                              const outputPath = "../../scriptOutput";
                              
                              // Datei mit den Skripten(autoObjects = letzte objects.json[l], autoBackup = letzte backupdatei, autoScripts = letztes Skript Backup)
                              let inputFile = "";
                              
                              //                                                       Beispiele für mögliche Dateien
                              // letzte Dateien JS-Controller und BackitUp-Adapter
                              inputFile = "autoObjects";
                              // inputFile = "autoBackup";
                              // inputFile = "autoScripts";
                              
                              // Backup von JS-Controller
                              // inputFile = '2023-01-23_13-30_objects.jsonl.gz';
                              // inputFile = "objects.jsonl";
                              // inputFile = "2022-12-19_12-18_objects.json.gz";
                              // inputFile = "objects.json";
                              
                              // BackitUp-Adapter
                              // inputFile = "iobroker_2023_01_23-13_34_49_backupiobroker.tar.gz";
                              // inputFile = "backup.json";
                              // inputFile = "javascripts_2023_01_23-13_35_04_backupiobroker.tar.gz";
                              // inputFile = "script.json";
                              
                              // Konsole: 'iobroker backup'
                              // inputFile = "2023_01_23-13_36_02_backupiobroker.tar.gz";
                              
                              // JS-Adapter Export
                              // inputFile = "2023-01-24-scripts.zip";
                              // inputFile = "FullBackup-scripts_2023-01-11.zip";
                              
                              // Einzelskript
                              // inputFile = 'sqlBlockly.js';
                              
                              /* **************************************************************************************
                              * *******************                                                *******************
                              * *******************       Ab hier keine Änderungen vornehmen       *******************
                              * *******************                                                *******************
                              * **************************************************************************************
                              */
                              // @ts-ignore
                              const fse = require("fs-extra");
                              const Path = require("path");
                              // @ts-ignore
                              const tar = require('tar');
                              // @ts-ignore
                              const JSZip = require('jszip');
                              const zlib = require('node:zlib');
                              const { pipeline } = require('node:stream');
                              // const os = require("os");
                              
                              // hier werden die aus evtl. Archiven(tar.gz, gz, zip) extrahierten Skripte temporär abgelegt. Wird bei Skriptstart angelegt wenn nicht vorhanden
                              const tmpRoot = '../../scriptTmp';// os.tmpdir();
                              const tmpPath = Path.resolve(tmpRoot, scriptName.slice(10));
                              
                              // Ignoriert Fehler in der JSONL Datenbank
                              const ignoreJsonlErrors = true;
                              
                              // komprimiere JSONL Datenbank beim Einlesen
                              const compressJsonl = false;
                              
                              // wichtig damit der mirrorPath nicht überschrieben wird und somit alle Skripte gelöscht werden
                              const mirrorPath = getObject("system.adapter.javascript.0").native.mirrorPath;
                              
                              start();
                              
                              async function start() {
                                 if (dbg) console.error('Debugmode aktiv, unbedingt auch in der JS-Instanz den Debug-Modus aktivieren!!!');
                                 fse.ensureDirSync(tmpPath);
                                 fse.emptyDirSync(tmpPath);
                                 fse.ensureDirSync(outputPath);
                              
                                 if (outputPath != mirrorPath) {
                                     fse.emptyDirSync(outputPath);
                                 }
                                 try { await main(); }
                                 catch (e) { return console.error('Ein Fehler ist aufgetreten!') }
                              
                                 stopScript(scriptName);
                              }
                              
                              async function main() {
                                 let dataFile = '';
                                 let allScripts = {};
                                 switch (inputFile.toLocaleLowerCase()) {
                                     case 'autoobjects':
                                         inputPath = '../../iobroker-data/backup-objects';
                                         inputFile = await getNewestFile(inputPath, /objects\.jsonl\.gz/);//await getLatestObjects();
                                         break;
                                     case 'autobackup':
                                         inputPath = '../../backups';
                                         inputFile = await getNewestFile(inputPath, /^[2i.+\.tar\.gz]/);//await getLatestBackup();
                                         break;
                                     case 'autoscripts':
                                         inputPath = '../../backups';
                                         inputFile = await getNewestFile(inputPath, /^javascript.+\.tar\.gz/);//await getLatestScripts();
                                         break;
                                     default:
                                 }
                              
                                 if (inputFile === '' || inputFile === undefined) {
                                     return console.error(`[main()] - Keine Datei in ${inputPath} gefunden!`);
                                 }
                              
                                 if (!(await fse.pathExists(Path.resolve(inputPath, inputFile)))) {
                                     return console.error(`[main()] - Die Datei ${inputFile} in ${inputPath} wurde nicht gefunden!`);
                                 }
                              
                                 const fullArchiveName = Path.resolve(inputPath, inputFile);
                                 if (inputFile.indexOf('.tar.gz') > 0) {
                                     dataFile = await tarExtract(fullArchiveName);
                              
                                     if (dataFile.endsWith('backup.json')) {
                                         allScripts = await handleBackup(dataFile);
                                     } else if (dataFile.endsWith('script.json')) {
                                         allScripts = await handleJson(dataFile);
                                     }
                                 } else if (inputFile.endsWith('backup.json')) {
                                     allScripts = await handleBackup(fullArchiveName);
                                 } else if (inputFile.endsWith('script.json')) {
                                     allScripts = await handleJson(fullArchiveName);
                                 } else if (inputFile.indexOf('.jsonl.gz') > 0) {
                                     dataFile = await gzipExtract(fullArchiveName);
                                     allScripts = await handleJsonl(dataFile);
                                 } else if (inputFile.endsWith('objects.jsonl')) {
                                     allScripts = await handleJsonl(fullArchiveName);
                                 } else if (inputFile.indexOf('.json.gz') > 0) {
                                     dataFile = await gzipExtract(fullArchiveName);
                                     allScripts = await handleJson(dataFile);
                                 } else if (inputFile.endsWith('objects.json')) {
                                     allScripts = await handleJson(fullArchiveName);
                                 } else if (inputFile.indexOf('.zip') > 0) {
                                     dataFile = await zipExtract(fullArchiveName);
                                     if (dataFile)
                                         allScripts = await handleExport(dataFile);
                                     else
                                         return console.warn('Keine passenden Dateien gefunden, Filter prüfen!');
                                 } else if (inputFile) {
                                     try {
                                         let b = fse.lstatSync(fullArchiveName).isDirectory()
                                     } catch (e) {
                                         return console.error('[main()] - Fehler: ' + e);
                                     }
                                     allScripts = await handleExport(inputFile, inputPath);
                                 } else {
                                     return console.error('[main()] - Fehler: Variable inputFile falsch belegt')
                                 }
                                 if (dbg) {
                                     console.debug('[main()] - datafile = ' + (dataFile != '' ? dataFile : inputFile))
                                 };
                                 handleScripts(allScripts);
                              }
                              
                              async function handleScripts(allScripts) {
                                 let res = {};
                                 let tableData = [];
                              
                                 for (let key in allScripts) {
                                     let fileExtension = "";
                                     let script = allScripts[key];
                                     const keyNew = key + scriptSuffix;
                                     const folder = key.replace('script.js.', '').replace(script.common.name, '').replace(/\.$/, '');
                              
                                     // exclude Filter
                                     if (isExcludedFolder(folder)) continue;
                                     // folder Filter
                                     if (!isIncludedFolder(folder)) continue;
                                     // script Filter
                                     if (!isName(script.common.name)) continue;
                                     // Typ Filter
                                     if (!isType(script.common.engineType)) continue;
                                     // Inhalts Filter
                                     if (!isContent(script.common.source)) continue;
                              
                                     script.common.enabled = false;
                                     script.common.debug = false;
                                     script.common.verbose = false;
                                     script.common.expert = false;
                              
                                     if (!existsObject(keyNew) && restoreToSystemDB) {
                                         if (dbg) console.debug('[handleSripts()] - Key: ' + key);
                                         const oldName = script.common.name;
                                         script.common.name += scriptSuffix;
                                         await createScriptFolder(keyNew.slice(0, keyNew.length - script.common.name.length - 1));
                                         await setObjectAsync(keyNew, { type: "script", common: script.common, native: {} });
                              
                                         script.common.name = oldName;
                                     }
                                     if (restoreToFilesystem) {
                                         let data = script.common.source;
                              
                                         switch (script.common.engineType.toLowerCase()) {
                                             case "blockly":
                                                 fileExtension = ".xml";
                                                 if (script.common.source.length)
                                                     data = handleBlockly(data);
                                                 else console.warn("217 Leeres Skript: " + script.common.name);
                                                 break;
                                             case "rules":
                                                 fileExtension = ".js";
                                                 break;
                                             case "javascript/js":
                                                 fileExtension = ".js";
                                                 break;
                                             case "typescript/ts":
                                                 fileExtension = ".ts";
                                                 break;
                                             default:
                                                 fileExtension = ".js";
                                         }
                              
                                         if (data && data.length) {
                                             if (dbg) console.debug('[handleSripts()] - Key: ' + key);
                                             if (dbg) console.debug('[handleSripts()] - Pfad: ' + Path.resolve(outputPath, key.substring(10)));
                                             let scriptName = key.split('.').pop();
                                             let scriptPfad = key.slice(10, key.length - scriptName.length - 1).replace(/\./g, '/');
                                             scriptPfad = Path.resolve(outputPath, scriptPfad);
                                             fse.ensureDirSync(scriptPfad);
                                             fse.writeFile(
                                                 Path.resolve(scriptPfad, scriptName) + fileExtension,
                                                 data,
                                                 (e) => {
                                                     if (e) console.error("[handleSripts()] - Fehler beim Schreiben der Datei:" + e.code);
                                                 }
                                             );
                                         } else {
                                             if (dbg) console.debug('[handleSripts()] - No source data: ' + key);
                                         }
                                     }
                              
                                     if (generateTable) {
                                         tableData = generateJsonTable(script, tableData);
                                     }
                                     if (dbg) console.debug('[handleSripts()] - Key: ' + key)
                                     res[key.substring(10)] = script.common.engineType;
                                 }
                              
                                 if (generateTable) {
                                     if (!tableData.length) {
                                         tableData.push({ Warnung: 'Keine Daten vorhanden, Filter prüfen!' });
                                     } else {
                                         tableData.sort((a, b) => a.Name.localeCompare(b.Name));
                                         let no = 0;
                                         tableData.forEach(rec => rec.Nr = ++no);
                                     }
                                     if (await createDatapoints(idBase)) {
                                         setState(`${idBase}.${idJson}`, JSON.stringify(tableData));
                                     }
                                 }
                              
                                 if (generateListing) {
                                     let b = {};
                                     if (Object.keys(res).length) {
                                         // sortieren
                                         let a = Object.keys(res).sort();
                                         for (let i = 0; i < a.length; i++) {
                                             b[i + 1 + " " + a[i]] = res[a[i]];
                                         }
                                     } else {
                                         b.Warnung = 'Keine Daten vorhanden, Filter prüfen!';
                                     }
                                     const fullFileName = Path.resolve(outputPath, '__Listing_' + inputFile + ".json");
                                     fse.writeFile(fullFileName, JSON.stringify(b, null, 3), (e) => {
                                         if (e) console.error("[handleSripts()] - Schreibfehler bei Ergebnisdatei");
                                     });
                                 }
                              }
                              
                              /* extrahiere Skripte aus iobroker Datenbank (neueste Version JSONL)*/
                              async function handleJsonl(dataFile) {
                                 const allScripts = {};
                                 // @ts-ignore
                                 const DB = require("@alcalzone/jsonl-db").JsonlDB;
                                 const dbOptions = {
                                     autoCompress: { onOpen: compressJsonl },
                                     ignoreReadErrors: ignoreJsonlErrors,
                                 };
                                 const db = new DB(dataFile, dbOptions);
                                 try {
                                     await db.open();
                                 } catch (e) {
                                     console.error(`[handleJsonl()] - Fehler beim Öffnen der Datenbank ${dataFile} in ${inputPath}` + e);
                                 }
                                 db.forEach((obj, key) => {
                                     if (obj.type === "script") {
                                         allScripts[key] = obj;
                                     }
                                 });
                                 await db.close();
                              
                                 return allScripts;
                              }
                              
                              /* extrahiere Skripte aus iobroker Datenbank (ältere Version JSON)*/
                              async function handleJson(dataFile) {
                                 let allData = '';
                                 const allScripts = [];
                                 let allObjects = new Object();
                                 try {
                                     allData = fse.readFileSync(dataFile, "utf8");
                                 } catch (e) {
                                     console.error(`[handleJson()] - Fehler beim Lesen von ${inputFile} in ${inputPath}: ` + e);
                                 }
                                 try {
                                     allObjects = JSON.parse(allData);
                                 } catch (e) {
                                     console.error("[handleJson()] - Fehlerhafte Daten: ==> " + e);
                                 }
                                 for (let prop in allObjects) {
                                     const obj = allObjects[prop];
                                     if (obj.type === "script") {
                                         allScripts[prop] = obj;
                                     }
                                 }
                                 return allScripts;
                              }
                              
                              /* extrahiere Skripte aus backup.json des Backitup-Adapers */
                              async function handleBackup(dataFile) {
                                 let allData = '';
                                 const allScripts = {};
                                 let allObjects = [];
                                 try {
                                     allData = fse.readFileSync(dataFile, "utf8");
                                 } catch (e) {
                                     console.error(`[handleBackup()] - Fehler beim Lesen von ${inputFile} in ${inputPath}: ` + e);
                                 }
                                 try {
                                     allObjects = JSON.parse(allData).objects;
                                 } catch (e) {
                                     console.error('[handleBackup()] - Fehlerhafte Daten: ==> ' + e);
                                 }
                              
                                 for (let obj of allObjects) {
                                     if (obj.value.type === 'script') {
                                         allScripts[obj.id] = obj.value;
                                     }
                                 }
                                 return allScripts;
                              }
                              
                              /* bearbeite Skripte */
                              async function handleExport(scriptListx, dir = tmpPath) {
                                 const allScripts = {};
                                 const scriptList = scriptListx.trim().split(' ');
                                 let fileObj = {};
                                 let sourceData = '';
                              
                                 scriptList.forEach((file) => {
                                     const scriptObj = {
                                         "_id": "script.js.",
                                         "common": {
                                             "name": "",
                                             "engineType": "JavaScript/js",
                                             "engine": "system.adapter.javascript.0",
                                             "source": "",
                                             "enabled": false,
                                             "debug": false,
                                             "verbose": false
                                         },
                                         "type": "script",
                                         "native": {},
                                         "ts": 0,
                                     }
                                     const scriptNam = getFileName(file);
                                     if (dbg) console.debug('[handleExport()] - File: ' + file);
                                     if (dbg) console.debug('[handleExport()] - Name: ' + scriptNam);
                                     let scriptData;
                                     scriptData = fse.readFileSync(Path.resolve(dir, file), 'utf8');
                                     const regExport = new RegExp(/\/\* -- do not edit/);
                                     if (regExport.test(scriptData)) {
                                         const regObj = new RegExp(/(\{.+\})(?:\n-- do not edit prev)/s);
                                         sourceData = scriptData.substring(scriptData.indexOf('END --*/') + 9);
                                         if (regObj.test(scriptData)) {
                                             try {
                                                 fileObj = JSON.parse(regObj.exec(scriptData)[1]) || '{}';
                                             } catch (e) {
                                                 console.error('[handleExport()] - Fehler');
                                             }
                                         }
                                     } else {
                                         sourceData = scriptData;
                                     }
                                     const engineType = getEngineType(sourceData);
                                     if (dbg) console.debug('[handleExport()] - ' + engineType);
                                     if (dbg) console.debug('[handleExport()] - Type: ' + engineType);
                                     if (dbg) console.debug('[handleExport()] - File: ' + file);
                                     if (dbg) console.debug('[handleExport()] - Id: ' + file.replace(/\//g, '.').replace(/.json$/, ''));
                                     scriptObj._id = `script.js.${file.replace(/\//g, '.').replace(/.json$|.js$/, '')}`;
                                     scriptObj.ts = fileObj.ts || Date.now();
                                     scriptObj.common.name = scriptNam;
                                     scriptObj.common.source = sourceData;
                                     scriptObj.common.engineType = fileObj.engineType || engineType;
                                     scriptObj.common.engine = fileObj.engine || 'system.adapter.javascript.0';
                                     scriptObj.common.enabled = fileObj.enabled || false;
                                     scriptObj.common.debug = fileObj.debug || false;
                                     scriptObj.common.verbose = fileObj.verbose || false;
                                     if (fileObj && fileObj.engineType && fileObj.engineType.toLowerCase() === 'typescript/ts') {
                                         scriptObj.common.sourceHash = fileObj.sourceHash;
                                         scriptObj.common.compiled = fileObj.compiled;
                                     }
                              
                                     allScripts[scriptObj._id] = scriptObj;
                              
                                 })
                              
                                 return allScripts;
                              }
                              
                              function generateJsonTable(scriptData, tableData) {
                                 const data = scriptData.common.source;
                                 const dt = scriptData.ts && new Date(scriptData.ts) || 0;
                              
                                 let Zweck = '-',
                                     Autor = '-',
                                     Datum = dt && dt.getFullYear() + '-' + dt.getMonth() + 1 + '-' + dt.getDate() || '-',
                                     Instance = scriptData.common.engine.split('.').pop(),
                                     sName = scriptData.common.name
                              
                                 if (/(Zweck|Purpose):\s+(.*)/.test(data)) {
                                     if (dbg) console.debug('[generateJsonTable()] - Zweck: ' + /(Zweck|Purpose):\s+(.*)/.exec(data))
                                     Zweck = /(Zweck|Purpose):\s+(.*)/.exec(data)[2];
                                 }
                                 if (/(Autor|Author):\s+(.*)/.test(data)) {
                                     Autor = /(Autor|Author):\s+(.*)/.exec(data)[2];
                                 }
                                 if (/(Datum|Date):\s+(.*)/.test(data)) {
                                     Datum = /(Datum|Date):\s+(.*)/.exec(data)[2].replace(/(\d+).(\d+).(\d+)/, "$3-$2-$1");
                                 }
                                 let p = scriptData._id.lastIndexOf('.');
                                 let ps = '';
                                 if (p === 9) ps = '/';
                                 else ps = '/' + scriptData._id.slice(10, p);
                                 tableData.push({
                                     Nr: 0,
                                     Name: sName,
                                     Pfad: ps,
                                     Zweck: Zweck,
                                     Autor: Autor,
                                     Datum: Datum,
                                     Instanz: Instance,
                                     Typ: scriptData.common.engineType.split('/')[0]
                                 })
                              
                                 return tableData;
                              }
                              
                              function isName(name) {
                                 if (dbg) console.debug('[isName()] - Name: ' + name);
                                 const regExp = new RegExp(scriptFilter.slice(0).join("|"), "i");
                                 return regExp.test(name);
                              }
                              
                              function isExcludedFolder(folder) {
                                 if (folder === '') folder = 'root/';
                                 const filter = excludeFolders.slice(0).join("|") || '&&&';
                                 if (dbg) console.debug('[isExcludedFolder()] -  Folder: ' + folder);
                                 if (dbg) console.debug('[isExcludedFolder()] - Filter: ' + filter);
                                 const regExp = new RegExp(filter, "i");
                                 return regExp.test(folder);
                              }
                              
                              function isIncludedFolder(folder) {
                                 if (folder === '') folder = 'root/';
                                 const filter = includeFolders.slice(0).join("|");
                                 if (dbg) console.debug('[isIncludedFolder()] - Folder: ' + folder);
                                 if (dbg) console.debug('[isIncludedFolder()] - Filter: ' + filter);
                                 const regExp = new RegExp(filter, "i");
                                 return regExp.test(folder);
                              }
                              
                              function isType(typ) {
                                 const regExp = new RegExp(typeFilter.slice(0).join("|"), "i");
                                 return regExp.test(typ);
                              }
                              
                              function isContent(source) {
                                 const regExp = new RegExp(contentFilter.slice(0).join("|"), "i");
                                 return regExp.test(source);
                              }
                              
                              function handleBlockly(source) {
                                 const pos = source.lastIndexOf("\n");
                                 if (pos !== -1) {
                                     source = source.substring(pos + 3);
                                     if (source.indexOf("JTNDeG1sJTIweG1") > -1) {
                                         source = decodeURIComponent(
                                             Buffer.from(source, "base64").toString("utf8")
                                         );
                                         return prettifyXml(source);
                                     }
                                 } else return prettifyXml(source);
                              
                                 //from Stackoverflow
                                 function prettifyXml(xml) {
                                     var reg = /(>)\s*(<)(\/*)/g;
                                     xml = xml.replace(/\r|\n/g, ''); //deleting already existing whitespaces
                                     xml = xml.replace(reg, "$1\r\n$2$3");
                                     return xml;
                                 }
                              }
                              
                              const tarList = async file => {
                                 const filenames = []
                                 await tar.list({
                                     file,
                                     onentry: entry => {
                                         if (/script.json|backup.json/.test(entry.path)) {
                                             filenames.push(entry.path)
                                         }
                                     },
                                 })
                                 return filenames
                              }
                              
                              const tarExtract = async archive => {
                                 const fileList = await tarList(archive);
                                 const strip = fileList.includes('backup/backup.json') ? 1 : 0;
                                 if (dbg) console.debug(strip + '   ' + fileList);
                                 const opts = {
                                     file: archive,
                                     strip,
                                     cwd: tmpPath
                                 }
                                 await tar.extract(opts, fileList);
                                 return Path.resolve(tmpPath, fileList[0].replace('backup/', ''));
                              }
                              
                              const zipExtract = async archive => {
                                 return new Promise(async (resolve, reject) => {
                                     let fileList = [];
                                     const data = fse.readFileSync(archive)
                                     const zip = new JSZip();
                                     const zipObj = await zip.loadAsync(data);
                                     zipObj.filter((a, b) => false)
                                     zipObj.folder().forEach(async (fileName, entry) => {
                                         const fullPath = Path.resolve(tmpPath, fileName);
                                         const pos = fullPath.lastIndexOf(Path.sep) + 1;
                                         const realName = fullPath.substring(pos);
                                         const realPath = fullPath.substring(0, pos - 1);
                                         if (!entry.dir && isName(realName) && realName.indexOf('_dir.json') < 0) {
                                             if (dbg) console.debug(realPath + '  = ' + realName);
                                             fse.ensureDirSync(Path.resolve(tmpPath, realPath));
                                             fse.writeFileSync(fullPath, Buffer.from(entry._data.compressedContent));
                                             fileList.push(fileName);
                                         }
                                     })
                                     resolve(fileList.join(' '));
                                 })
                              }
                              
                              const gzipExtract = async archive => {
                                 return new Promise(async (resolve, reject) => {
                                     const objectsFile = archive.split(Path.sep).pop().replace('.gz', '').substring(17);
                                     const gunzip = zlib.createGunzip();
                                     const readStream = fse.createReadStream(archive);
                                     const writeStream = fse.createWriteStream(Path.resolve(tmpPath, objectsFile));
                                     readStream.on('error', e => {
                                         reject(console.error(e));
                                     })
                                     writeStream.on('error', e => {
                                         reject(console.error(e));
                                     })
                              
                                     pipeline(readStream, gunzip, writeStream, e => {
                                         if (e) reject(console.error(e));
                                         resolve(Path.resolve(tmpPath, objectsFile));
                                     })
                                 })
                              }
                              
                              function getFileName(fullName) {
                                 return fullName.substring(fullName.lastIndexOf('/') + 1, fullName.lastIndexOf('.'));
                              }
                              
                              function isBlockly(sourceData) {
                                 const pos = sourceData.lastIndexOf('\n');
                                 const testData = sourceData.substring(pos + 1);
                                 return /^[\/][\/]JTNDeG1sJTIwe/.test(testData);
                              }
                              
                              function isRules(sourceData) {
                                 const pos = sourceData.lastIndexOf('\n');
                                 const testData = sourceData.substring(pos + 1);
                                 return /[/][/]{"triggers":/.test(testData);
                              }
                              
                              function isTypescript(sourceData) {
                                 return /(let|const|var)\s*[a-zA-Z0-9]+:*(string|object|number)/.test(sourceData);
                              }
                              
                              function getEngineType(sourceData) {
                                 return isBlockly(sourceData) ? 'Blockly'
                                     : isRules(sourceData) ? 'Rules'
                                         : isTypescript(sourceData) ? 'Typescript/ts'
                                             : 'Javascript/js';
                              }
                              
                              async function getNewestFile(dir, filter) {
                                 return new Promise((resolve, reject) => {
                                     return fse.readdir(dir, (e, f) => {
                                         if (e) reject(e);
                                         const s = f.map(f => {
                                             let t;
                                             const ff = Path.resolve(dir, f);
                                             try {
                                                 t = fse.lstatSync(ff).mtime.getTime();
                                             } catch (e) {
                                                 reject(e)
                                             }
                                             return { name: f, time: t }
                                         })
                                             .sort((a, b) => b.time - a.time)
                                             .map(v => v.name)
                                             .filter(v => filter.test(v));
                                         resolve(s[0]);
                                     })
                                 })
                              }
                              
                              // create data points if not existing
                              async function createDatapoints(idBase) {
                                 let dp,
                                     idKey,
                                     firstRun = false;
                              
                                 if (!idBase.startsWith('0_userdata.0')) return firstRun;
                                 firstRun = true;
                                 const stateAttributes = {};
                                 stateAttributes[idJson] = { "name": "Skripte Info", "type": "json", "role": "", "read": true, "write": true, "desc": "enthält Skript Tabelle", "def": "" }
                              
                                 //createScriptFolder(idBase);
                                 for (let key in stateAttributes) {
                              
                                     idKey = idBase + '.' + key;
                              
                                     if (!(await existsStateAsync(idKey))) {
                                         dp = stateAttributes[key];
                                         firstRun = true;
                                         let e = await createStateAsync(idKey, dp);
                                         if (e) console.error('[createDatapoints()] - createState: ' + e);
                                     }
                                 }
                              
                                 return firstRun;
                              
                              }
                              
                              async function createScriptFolder(id) {
                                 const arr = id.split('.');
                                 const preId = arr[0] + '.' + arr[1];
                                 if (preId.length === id.length || (preId != 'script.js' /*&& preId != '0_userdata.0'*/)) return;
                                 const idNew = id.replace(/[\s"]/g, '_');
                              
                                 if (!(await existsObjectAsync(idNew))) {
                                     const obj = new Object({
                                         "type": "folder",
                                         "common": {
                                             name: arr[arr.length - 1]
                                         },
                                         "native": {},
                                     })
                              
                                     await setObjectAsync(idNew, obj);
                                 }
                                 arr.pop();
                                 id = arr.join('.');
                                 await createScriptFolder(id);
                              }
                              
                              onStop(() => {
                                 fse.removeSync(tmpPath);
                                 if (dbg) console.log('[onStop()] - Skript wurde nach Beendigung automatisch gestoppt!');
                              })
                              

                              R Offline
                              R Offline
                              Ralf 6
                              schrieb am zuletzt editiert von
                              #18

                              @fastfoot
                              Ich habe es zum Laufen gebracht. Im Fall der Fälle habe ich jetzt ein prima Werkzeug.

                              Vielen Dank für Deine Mühe. :+1:

                              1 Antwort Letzte Antwort
                              0
                              Antworten
                              • In einem neuen Thema antworten
                              Anmelden zum Antworten
                              • Älteste zuerst
                              • Neuste zuerst
                              • Meiste Stimmen


                              Support us

                              ioBroker
                              Community Adapters
                              Donate

                              672

                              Online

                              32.5k

                              Benutzer

                              81.7k

                              Themen

                              1.3m

                              Beiträge
                              Community
                              Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen | Einwilligungseinstellungen
                              ioBroker Community 2014-2025
                              logo
                              • Anmelden

                              • Du hast noch kein Konto? Registrieren

                              • Anmelden oder registrieren, um zu suchen
                              • Erster Beitrag
                                Letzter Beitrag
                              0
                              • Home
                              • Aktuell
                              • Tags
                              • Ungelesen 0
                              • Kategorien
                              • Unreplied
                              • Beliebt
                              • GitHub
                              • Docu
                              • Hilfe