webfast 0.1.18 → 0.1.21

package/index.js

@@ -1,244 +1,246 @@
-const { readdirSync } = require("fs");
-
-console.log(`WebFast!! Program`);
-let program = {
-    ts  :   Date.now(),
-    modules : {},
-    tmp : {}
-}
-
-// Setup The Requirements
-async function set(program) {
-    program.path = await require(`path`);
-    program.fs = await require(`fs`);
-    program.uuid = require(`uuid`);
-    program.fetch = require(`fetch`);
-    return program;
-}
-
-// Program Fetch
-program.modules.dependOn = async function(reqFunc,program,name,callback) {
-    console.log(`Depend On Check`);
-   
-    // Loop Through dependOn if its not true then check
-    for (let dependIndex in reqFunc.dependOn) {
-        const dependOn = reqFunc.dependOn[dependIndex];
-        // So we dependOn 
-        // Check index
-        // If .
-        let split = dependOn.split(`.`);
-        // Now we should loop through array
-        let objectData = program;
-        let fullObjectPath = `program`;
-        let dependOnItem = ``;
-        for (let spl in split) {
-            // Grab object
-            let toCheck = split[spl];
-            if (objectData[toCheck] == undefined) {
-                if (program.modules[name] != undefined) {
-                    return;
-                } else {
-                    program.modules[name] = {
-                        ts : Date.now()
+module.exports = function () {
+    const { readdirSync } = require("fs");
+
+    console.log(`WebFast!! Program`);
+    let program = {
+        ts  :   Date.now(),
+        modules : {},
+        tmp : {}
+    }
+
+    // Setup The Requirements
+    async function set(program) {
+        program.path = await require(`path`);
+        program.fs = await require(`fs`);
+        program.uuid = require(`uuid`);
+        program.fetch = require(`fetch`);
+        return program;
+    }
+
+    // Program Fetch
+    program.modules.dependOn = async function(reqFunc,program,name,callback) {
+        console.log(`Depend On Check`);
+    
+        // Loop Through dependOn if its not true then check
+        for (let dependIndex in reqFunc.dependOn) {
+            const dependOn = reqFunc.dependOn[dependIndex];
+            // So we dependOn 
+            // Check index
+            // If .
+            let split = dependOn.split(`.`);
+            // Now we should loop through array
+            let objectData = program;
+            let fullObjectPath = `program`;
+            let dependOnItem = ``;
+            for (let spl in split) {
+                // Grab object
+                let toCheck = split[spl];
+                if (objectData[toCheck] == undefined) {
+                    if (program.modules[name] != undefined) {
+                        return;
+                    } else {
+                        program.modules[name] = {
+                            ts : Date.now()
+                        }
+                        await setTimeout(async function(){
+                            await program.modules.dependOn(reqFunc,program,name,callback);
+                        },200);
                     }
-                    await setTimeout(async function(){
-                        await program.modules.dependOn(reqFunc,program,name,callback);
-                    },200);
-                }
-            } else {
-                // New object thing and og next
-                if (split.length-1 != spl) {
-                    fullObjectPath = fullObjectPath + `.${toCheck}`
                 } else {
-                    // Depend on
-                    dependOnItem = toCheck;
+                    // New object thing and og next
+                    if (split.length-1 != spl) {
+                        fullObjectPath = fullObjectPath + `.${toCheck}`
+                    } else {
+                        // Depend on
+                        dependOnItem = toCheck;
+                    }
+                    objectData = objectData[toCheck];
                 }
-                objectData = objectData[toCheck];
             }
-        }
 
-        let progData = await eval(fullObjectPath);
-        const IndexCheck = Object.keys(progData).indexOf(dependOnItem);
-        if (IndexCheck == -1) {
-            // We need to wait and try again untill we can return
-            console.log(`DependOn Fail: ${dependOn}`);
-            await setTimeout(async function(){
-                await program.modules.dependOn(reqFunc,program);
-            },200);
-        } else if (program.modules[reqFunc.name] == undefined) {
-            console.log(`DependOn Succes: ${dependOn}`);
-
-            // Loop Through to find where data to set
-            const splitLoop = String(`${fullObjectPath}.${dependOnItem}`).split(`.`);
-            let object;
-            for (let s in splitLoop) {
-                let key = splitLoop[s];
+            let progData = await eval(fullObjectPath);
+            const IndexCheck = Object.keys(progData).indexOf(dependOnItem);
+            if (IndexCheck == -1) {
+                // We need to wait and try again untill we can return
+                console.log(`DependOn Fail: ${dependOn}`);
+                await setTimeout(async function(){
+                    await program.modules.dependOn(reqFunc,program);
+                },200);
+            } else if (program.modules[reqFunc.name] == undefined) {
+                console.log(`DependOn Succes: ${dependOn}`);
+
+                // Loop Through to find where data to set
+                const splitLoop = String(`${fullObjectPath}.${dependOnItem}`).split(`.`);
+                let object;
+                for (let s in splitLoop) {
+                    let key = splitLoop[s];
+                    try {
+                        if (object == undefined) {
+                            object = eval(key);
+                        } else {
+                            object = object[key];
+                        }
+                        if (s == splitLoop-1) {
+                            // It's end
+                            object = {
+                                depend : dependOn,
+                                state : true,
+                                ts : Date.now()
+                            }
+                        }
+                    } catch (err) {
+                        console.error(err);
+                        console.error(`errror boject eval set`);
+                        return setTimeout(async function(){
+                            await program.modules.dependOn(reqFunc,program,name,callback);
+                        },200);
+                    }
+                }
+                /*
+                progData[dependOnItem] = {
+                    depend : dependOn,
+                    state : true,
+                    ts : Date.now()
+                } */
+
+                // Now include this thing then
                 try {
-                    if (object == undefined) {
-                        object = eval(key);
+                    program.modules[reqFunc.name] = await reqFunc.run(program,reqFunc.name);
+                    if (callback != undefined) {
+                        return callback(program,name)
                     } else {
-                        object = object[key];
+                        return program;
                     }
-                    if (s == splitLoop-1) {
-                        // It's end
-                        object = {
-                            depend : dependOn,
-                            state : true,
-                            ts : Date.now()
-                        }
-                    }
-                } catch (err) {
+                } catch(err) {
+                    // When erro
+                    console.error(`Error Program add depend on require`);
                     console.error(err);
-                    console.error(`errror boject eval set`);
-                    return setTimeout(async function(){
-                        await program.modules.dependOn(reqFunc,program,name,callback);
-                    },200);
                 }
             }
-            /*
-            progData[dependOnItem] = {
-                depend : dependOn,
-                state : true,
-                ts : Date.now()
-            } */
-
-            // Now include this thing then
-            try {
-                program.modules[reqFunc.name] = await reqFunc.run(program,reqFunc.name);
-                if (callback != undefined) {
-                    return callback(program,name)
+        }
+    }
+
+    program.modules.fetch = async function(folder,program) {
+        // TO Fetch folder modules
+        program = await set(program);
+        try {
+            // Loop through folder and run module if js
+            const readPath = program.path.join(__dirname,folder);
+            const readDir = program.fs.readdirSync(readPath);
+            // Check if folder or not
+            await readDir.forEach(async (item) => {
+                const itemPath = program.path.join(readPath, item);
+                // Get the filename with extension
+                const fileNameWithExtension = program.path.basename(itemPath);
+
+                // Get the filename without extension
+                const fileNameWithoutExtension = program.path.parse(fileNameWithExtension).name;
+
+                console.log('Filename without extension:', fileNameWithoutExtension);
+
+                const isDirectory = program.fs.statSync(itemPath).isDirectory();
+
+                if (!isDirectory) {
+                    // So it's file
+                    // Run the file to know what to do but change program with the return
+                    //program = (require(itemPath)(program));
+                    //console.log(`Set`,itemPath);
                 } else {
-                    return program;
+                    // It's directory so read the init file
+                    const initPath = program.path.join(itemPath,`init.js`);
+
+                    // Require first
+                    const reqFunc = require(initPath);
+                    const theType = typeof reqFunc;
+                    switch (theType) {
+                        case `object`:
+                            // It's a object so check for dependend things etc.
+                            console.log(`Depending object`);
+                            return await program.modules.dependOn(reqFunc,program,fileNameWithoutExtension,function(program,name){
+                                console.log(`Setup `,name)
+                            });
+                        break;
+                        case `function`:
+                            program = await (require(initPath)(program,fileNameWithExtension));
+                        break;
+                        default:
+                            console.error(`Error Missing typeOf item`);
+                    }
                 }
-            } catch(err) {
-                // When erro
-                console.error(`Error Program add depend on require`);
-                console.error(err);
-            }
+            });
+
+        } catch(err) {
+            console.error(`Error Program Modules Fetch`);
+            console.error(err);
         }
     }
-}
-
-program.modules.fetch = async function(folder,program) {
-    // TO Fetch folder modules
-    program = await set(program);
-    try {
-        // Loop through folder and run module if js
-        const readPath = program.path.join(__dirname,folder);
-        const readDir = program.fs.readdirSync(readPath);
-        // Check if folder or not
-        await readDir.forEach(async (item) => {
-            const itemPath = program.path.join(readPath, item);
-            // Get the filename with extension
-            const fileNameWithExtension = program.path.basename(itemPath);
-
-            // Get the filename without extension
-            const fileNameWithoutExtension = program.path.parse(fileNameWithExtension).name;
-
-            console.log('Filename without extension:', fileNameWithoutExtension);
-
-            const isDirectory = program.fs.statSync(itemPath).isDirectory();
-
-            if (!isDirectory) {
-                // So it's file
-                // Run the file to know what to do but change program with the return
-                //program = (require(itemPath)(program));
-                //console.log(`Set`,itemPath);
+
+    // Create tmp file path
+    program.modules.walkDirectory = async function (directoryPath, callback, forward, parentFileData) {
+        let allFiles = [];
+        try {
+        // Read the contents of the current directory
+        const files = await program.fs.readdirSync(directoryPath);
+    
+        // Iterate through the files in the directory
+        for (const file of files) {
+            // Construct the full path of the current file or directory
+            const fullPath = program.path.join(directoryPath, file);
+    
+            // Check if the current item is a directory
+            const pathSync = await program.fs.statSync(fullPath);
+            const isDirectoryPath = await pathSync.isDirectory();
+            const fileExtension = program.path.extname(fullPath);
+    
+            // Get the filename without the extension
+            const fileName = program.path.basename(fullPath, fileExtension);
+    
+            // Create a new fileData object for each file or directory
+            const currentFileData = {
+            extension: fileExtension,
+            name: fileName,
+            path: fullPath,
+            sub: [],
+            };
+    
+            if (isDirectoryPath) {
+            // If it's a directory, recursively walk through it
+            let pushData = await program.modules.walkDirectory(fullPath, callback, fileName, currentFileData);
+            if (pushData.length !== 0) {
+                // Concatenate arrays instead of pushing an array
+                allFiles.push(currentFileData);
+                allFiles = allFiles.concat(pushData);
             } else {
-                // It's directory so read the init file
-                const initPath = program.path.join(itemPath,`init.js`);
-
-                // Require first
-                const reqFunc = require(initPath);
-                const theType = typeof reqFunc;
-                switch (theType) {
-                    case `object`:
-                        // It's a object so check for dependend things etc.
-                        console.log(`Depending object`);
-                        return await program.modules.dependOn(reqFunc,program,fileNameWithoutExtension,function(program,name){
-                            console.log(`Setup `,name)
-                        });
-                    break;
-                    case `function`:
-                        program = await (require(initPath)(program,fileNameWithExtension));
-                    break;
-                    default:
-                        console.error(`Error Missing typeOf item`);
-                }
+                allFiles.push(currentFileData);
+            }
+            } else {
+            // If it's a file, print the path
+            console.log('File Extension:', fileExtension);
+            console.log('File Name:', fileName);
+    
+            if (forward !== undefined) {
+                // Push it to sub
+                parentFileData.sub.push(currentFileData);
+            } else {
+                allFiles.push(currentFileData);
+            }
             }
-        });
-
-    } catch(err) {
-        console.error(`Error Program Modules Fetch`);
-        console.error(err);
-    }
-}
-
-// Create tmp file path
-program.modules.walkDirectory = async function (directoryPath, callback, forward, parentFileData) {
-    let allFiles = [];
-    try {
-      // Read the contents of the current directory
-      const files = await program.fs.readdirSync(directoryPath);
-  
-      // Iterate through the files in the directory
-      for (const file of files) {
-        // Construct the full path of the current file or directory
-        const fullPath = program.path.join(directoryPath, file);
-  
-        // Check if the current item is a directory
-        const pathSync = await program.fs.statSync(fullPath);
-        const isDirectoryPath = await pathSync.isDirectory();
-        const fileExtension = program.path.extname(fullPath);
-  
-        // Get the filename without the extension
-        const fileName = program.path.basename(fullPath, fileExtension);
-  
-        // Create a new fileData object for each file or directory
-        const currentFileData = {
-          extension: fileExtension,
-          name: fileName,
-          path: fullPath,
-          sub: [],
-        };
-  
-        if (isDirectoryPath) {
-          // If it's a directory, recursively walk through it
-          let pushData = await program.modules.walkDirectory(fullPath, callback, fileName, currentFileData);
-          if (pushData.length !== 0) {
-            // Concatenate arrays instead of pushing an array
-            allFiles.push(currentFileData);
-            allFiles = allFiles.concat(pushData);
-          } else {
-            allFiles.push(currentFileData);
-          }
-        } else {
-          // If it's a file, print the path
-          console.log('File Extension:', fileExtension);
-          console.log('File Name:', fileName);
-  
-          if (forward !== undefined) {
-            // Push it to sub
-            parentFileData.sub.push(currentFileData);
-          } else {
-            allFiles.push(currentFileData);
-          }
         }
-      }
-  
-      if (callback && forward === undefined) {
-        await callback(allFiles);
-      }
-  
-      return allFiles;
-    } catch (error) {
-      console.error('Error:', error.message);
-    }
-  };
-  
+    
+        if (callback && forward === undefined) {
+            await callback(allFiles);
+        }
+    
+        return allFiles;
+        } catch (error) {
+        console.error('Error:', error.message);
+        }
+    };
+    
 
-  
-  
+    
+    
 
-// Run program fetch
-program.modules.fetch(`modules`,program);
+    // Run program fetch
+    program.modules.fetch(`modules`,program);
+}

package/modules/bots/applications/telegram/que.js

@@ -7,14 +7,13 @@ module.exports = {
         this.line[id] = data;
         return this.line[id];
     },
-    get : function(id) {
+    get : function(id,program) {
         console.log(`Que Get Telegram`);
         // Check if in que line
-        let indexPart = Object.keys(this.line).indexOf(id);
-        if (indexPart == -1) {
+        if (program.modules.telegram.functions.que.line[id] == undefined) {
             return false;
         } else {
-            let lineData = this.line[indexPart];
+            let lineData = program.modules.telegram.functions.que.line[id];
             return lineData;
         }
     },
@@ -31,22 +30,87 @@ module.exports = {
 
             let scriptStart = `start`;
             // It's new
-            if (program.modules.telegram.script.int[command] == undefined) {
+            if (program.modules.telegram.script.int[command] == undefined && program.modules.telegram.functions.que.line[chatID] == undefined) {
                 // Send message we don't know
                 
                 return false;
             } 
 
             // Create the que line command
-            const script = program.modules.telegram.script.int[command];
+            let script = program.modules.telegram.script.int[command];
 
             let current;
 
+            let theUUID = program.uuid.v4();
             if (program.modules.telegram.functions.que.line[chatID] != undefined) {
                 // It's original que
                 // Process response
                 console.log(`It's a process`)
                 current = program.modules.telegram.functions.que.line[chatID];
+                theUUID = current.uuid;
+
+                // Check what to do next first of all save anwser
+                const question = current.script[current.process];
+                // Grab function to process
+                const anwser = middleValue;
+
+                // Check if text then we need to match if not we probably need to run only function and go to next one
+                let matched = false;
+                let anwserData;
+                if (middleValue.text != undefined) {
+                    console.log(`Match Text`);
+                    // Loop through match
+                    anwserData = middleValue.text;
+                    for (let q in question.match.data) {
+                        const qMatch = question.match.data[q];
+
+                        // Check typeof
+                        if (typeof qMatch.anwser == `object`) {
+                            // Match in index
+                            const matchedIndex = qMatch.anwser.indexOf(middleValue.text);
+                            if (matchedIndex != -1) {
+                                matched = qMatch;
+                            }
+                        } else if (qMatch.anwser == middleValue.text) {
+                            matched = qMatch;
+                        }
+                    }
+                } else {
+                    console.error(`Need to set anwser data`);
+                }
+
+                // End of match process fo matched checking
+                if (matched == false && current.q == true) {
+                    // We have different data
+                    console.error(`Not matched`);
+                    // Send command when wrong // or buttons like reset button
+                    // check what to do
+                    return false;
+                } else {
+                    console.log(`Matched`);
+                    current.anwsers[current.process] = {
+                        anwser : anwserData,
+                        message : anwser,
+                        ts : Date.now()
+                    };
+
+                    // Set next steps and get next steps data
+                    try {
+                        const nextData = current.script[matched.next];
+                        if (nextData == undefined) {
+                            throw new Error(`Problems getting nextData for`,current);
+                        }
+                        console.log(`Next Data`);
+                        scriptStart = matched.next;
+                        current.process = matched.next;
+                        script = current.script; 
+                    } catch (err) {
+                        console.error(err);
+                        console.error(`Error getting data for next: ${matched.next}`);
+                    }
+                }
+                
+                console.log(`We have question anwser`);
             } else {
                 // Create que line
                 let setData = {
@@ -54,7 +118,9 @@ module.exports = {
                     action : command,
                     process : scriptStart,
                     script : script,
-                    anwsers : {}
+                    anwsers : {},
+                    uuid : theUUID,
+                    q : true
                 }
                 program.modules.telegram.functions.que.line[chatID] = setData;
                 current = setData;
@@ -69,6 +135,22 @@ module.exports = {
                 "{{TEST}}"  :   "TEST REPLACED"
             }
 
+            // Check if anwsers
+            if (Object.keys(current.anwsers).length > 0) {
+                // Check the anwsers
+                for (let anwserTXT in current.anwsers) {
+                    const typedOf = typeof current.anwsers[anwserTXT].anwser;
+                    
+                    if (typedOf == `string`) {
+                        replace[`{{${String(anwserTXT).toUpperCase()}}}`] = current.anwsers[anwserTXT].anwser;
+                    }
+                }
+                console.log(`Check loop through anwsers`);
+            }
+
+            // Add items to replace
+            console.log(`Add Items to replace`);
+
             // Check if text
             let toSend = {}
             if (theScript.object.text != undefined) {
@@ -92,13 +174,29 @@ module.exports = {
             }
 
             // Check if text
-            await program.modules.telegram.functions.send(program,toSend,middleValue.chat.id);
+            let buttons;
+            // check for buttons
+            if (theScript.object.buttons != undefined) {
+                buttons = JSON.stringify(theScript.object.buttons);
+                // Loop through replace
+                for (let repKey in replace) {
+                    const newRegx = new RegExp(repKey, 'g');
+                    buttons = buttons.replace(newRegx,replace[repKey]);
+                }
+                buttons = JSON.parse(buttons);
+            }
+            await program.modules.telegram.functions.send(program,toSend,middleValue.chat.id,buttons);
 
+            // set que uuid
             program.modules.telegram.functions.que.line[chatID] = current;
+            
             console.log(`We have script data`);
+
+            return current;
         } catch (err) {
             console.error(err);
             console.error(`Error with que something`);
+            return false;
         }
 
         // Do all the things that we need to do in the run

package/modules/bots/applications/telegram/scripts/function.js

@@ -4,8 +4,8 @@ module.exports = {
         console.log(`Check if there is script`);
         try {
             const scriptData = program.modules.telegram.script.int[command];
-            if (scriptData.length == 0) {
-                await program.modules.telegram.functions.send(program,`${command}`,chatID,[
+            if (scriptData == undefined && program.modules.telegram.functions.que.get(chatID,program) == false) {
+                await program.modules.telegram.functions.send(program,`Sorry we don't understand: ${command}`,chatID,[
                     [
                         { text: 'EventGO!',  web_app : { url : 'https://cloud.eventgo.today/events/list'}},
                         { text: 'Create Event', callback_data: 'create_event' },
@@ -17,8 +17,16 @@ module.exports = {
 
                 // Check if queData is empty otherwise we will run the script from "start", if que data is not empty we run it further
                 //  unt o process script 
-
+                // now it's just wait
                 console.log(`Went through que get`);
+                // Send message
+                if (queData == false) {
+                    await program.modules.telegram.functions.send(program,`Sorry we don't know what to do with: ${command}`,chatID);
+                } else if (queData.process != `start`) {
+                    // Process the que event
+                    console.log(`Process the que event`);
+                    
+                }
             }
             console.log(`Setted`);
 
@@ -27,5 +35,8 @@ module.exports = {
             console.error(err);
             console.error(`Error Scripting`);
         }
+    },
+    response : async function() {
+        console.log(`Function Response`);
     }
 }

package/modules/bots/applications/telegram/scripts/test/script.json

@@ -2,36 +2,56 @@
     "input"     :       "test input",
     "start"     :       {
         "object"  :   {
-            "text" : "Testing Title : {{TEST}}",
+            "text" : "Test First Title : {{TEST}}",
             "image" :   "{{URL}}app/content/images/block.png"
         },
         "match"    :   {
             "data"  :   [{
-                "response"  :   "anwser text",
-                "function"      :   "program.modules.bots.scripts.function",
-                "reply_markup"      :  {
-                    "inline_keyboard": [[
-                        {
-                            "text": "A",
-                            "callback_data": "A1"            
-                        }, 
-                        {
-                            "text": "B",
-                            "callback_data": "C1"            
-                        }]
-                    ]
-                },
+                "anwser"  :   ["anwser text","anwser"],
+                "function"  :   "program.modules.bots.scripts.function.response",
                 "next"      :   "nextFunc"
             },{
-                "response"  :   "other",
-                "function"  :   "program.modules.bots.scripts.function",
+                "anwser"  :   "other",
+                "function"  :   "program.modules.bots.scripts.function.response",
                 "next"      :   "nextFunc"
+            },{
+                "anwser"  :   "hi",
+                "function"  :   "program.modules.bots.scripts.function.response",
+                "next"      :   "nextFunc"
+            }]
+        },
+        "fail"  :   {
+            "response"  :   "start",
+            "function"  :   "program.modules.bots.scripts.function.response",
+            "next"      :   "failResponse"
+        }
+    },
+    "nextFunc"     :       {
+        "object"  :   {
+            "text" : "Testing Title : {{START}}",
+            "buttons" : [
+                [
+                    { "text": "EventGO!",  "web_app" : { "url" : "{{URL}}events/list"}},
+                    { "text": "Create Event", "callback_data": "create_event" }
+                ]
+            ]
+        },
+        "match"    :   {
+            "data"  :   [{
+                "anwser"  :   ["create_event"],
+                "function"  :   "program.modules.bots.scripts.function.response",
+                "next"      :   "finish"
             }]
         },
         "fail"  :   {
             "response"  :   "start",
-            "function"  :   "program.modules.bots.scripts.function",
+            "function"  :   "program.modules.bots.scripts.function.response",
             "next"      :   "failResponse"
         }
+    },
+    "failResponse" : {
+        "object"  :   {
+            "text" : "Sorry Something Wnt wrong : {{START}}"
+        }
     }
 }

package/modules/bots/applications/telegram/send.js

@@ -44,6 +44,8 @@ module.exports = async function(program,message,id,buttons) {
             delete body.reply_to_message_id;
             telegramURL = `${telegramURL}/sendPhoto`;
         }
+    } else {
+        telegramURL = `${telegramURL}/sendMessage`;
     }
 
     // If options is there add as
@@ -52,6 +54,13 @@ module.exports = async function(program,message,id,buttons) {
     }
 
     const madeRequest = await program.modules.request.post(program,telegramURL,body)
+
+    // Save to send so we can have the id and do things
+    madeRequest.result.uuid = program.uuid.v4();
+    let saveSend = await program.modules.data.findOrCreate(`eventgo`,`send`,{
+        message_id : madeRequest.result.message_id
+    },madeRequest.result);
+
     console.log(`Send Message`);
     return madeRequest;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.1.18",
+  "version": "0.1.21",
   "description": "WebFast! Bot Application, including TON mini-apps",
   "main": "index.js",
   "repository": {