webfast 0.1.14 → 0.1.18

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

@@ -0,0 +1,107 @@
+// Here we can collect something by when user enter collect state in telegram
+module.exports = {
+    line : {},
+    set : function(id,data) {
+        // To set que
+        console.log(`Que Set Telegram`);
+        this.line[id] = data;
+        return this.line[id];
+    },
+    get : function(id) {
+        console.log(`Que Get Telegram`);
+        // Check if in que line
+        let indexPart = Object.keys(this.line).indexOf(id);
+        if (indexPart == -1) {
+            return false;
+        } else {
+            let lineData = this.line[indexPart];
+            return lineData;
+        }
+    },
+    timer : function() {
+        // Run timer
+        console.log(`Timer Run To See if we need to send a message or not`);
+    },
+    run : async function(program,command,chatID,middleValue,data) {
+        // Run timer
+        console.log(`run que data to give back response`);
+
+        // Check if que
+        try {
+
+            let scriptStart = `start`;
+            // It's new
+            if (program.modules.telegram.script.int[command] == undefined) {
+                // Send message we don't know
+                
+                return false;
+            } 
+
+            // Create the que line command
+            const script = program.modules.telegram.script.int[command];
+
+            let current;
+
+            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];
+            } else {
+                // Create que line
+                let setData = {
+                    ts : Date.now(),
+                    action : command,
+                    process : scriptStart,
+                    script : script,
+                    anwsers : {}
+                }
+                program.modules.telegram.functions.que.line[chatID] = setData;
+                current = setData;
+            }
+
+            // Get item
+            const theScript = script[scriptStart];
+
+            // Create replacelist
+            let replace = {
+                "{{URL}}"   :   process.env.url,
+                "{{TEST}}"  :   "TEST REPLACED"
+            }
+
+            // Check if text
+            let toSend = {}
+            if (theScript.object.text != undefined) {
+                toSend.text = theScript.object.text;
+            }
+
+            // Get object
+            if (theScript.object.image != undefined) {
+                console.log(`Send Image`);
+                toSend.image = theScript.object.image;
+            }
+
+            // Iterate through keys in toSend
+            for (let key in toSend) {
+                if (typeof toSend[key] === 'string') {
+                    // Replace placeholders in the string globally
+                    for (let placeholder in replace) {
+                        toSend[key] = toSend[key].replace(new RegExp(placeholder, 'g'), replace[placeholder]);
+                    }
+                }
+            }
+
+            // Check if text
+            await program.modules.telegram.functions.send(program,toSend,middleValue.chat.id);
+
+            program.modules.telegram.functions.que.line[chatID] = current;
+            console.log(`We have script data`);
+        } catch (err) {
+            console.error(err);
+            console.error(`Error with que something`);
+        }
+
+        // Do all the things that we need to do in the run
+        
+    }
+}

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

@@ -0,0 +1,31 @@
+module.exports = {
+    check : async function (program,command,chatID,middleValue,received) {
+        // Checkif there is que
+        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,[
+                    [
+                        { text: 'EventGO!',  web_app : { url : 'https://cloud.eventgo.today/events/list'}},
+                        { text: 'Create Event', callback_data: 'create_event' },
+                    ]
+                ]);
+            } else {
+                // We have some script so check if we have in que
+                const queData = await program.modules.telegram.functions.que.run(program,command,chatID,middleValue,received);
+
+                // 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 
+
+                console.log(`Went through que get`);
+            }
+            console.log(`Setted`);
+
+            return true;
+        } catch(err) {
+            console.error(err);
+            console.error(`Error Scripting`);
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+{
+    "input"     :       "test input",
+    "start"     :       {
+        "object"  :   {
+            "text" : "Testing 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"            
+                        }]
+                    ]
+                },
+                "next"      :   "nextFunc"
+            },{
+                "response"  :   "other",
+                "function"  :   "program.modules.bots.scripts.function",
+                "next"      :   "nextFunc"
+            }]
+        },
+        "fail"  :   {
+            "response"  :   "start",
+            "function"  :   "program.modules.bots.scripts.function",
+            "next"      :   "failResponse"
+        }
+    }
+}

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

@@ -1,7 +1,7 @@
 module.exports = async function(program,message,id,buttons) {
     console.log(`Telegram Send`);
     // Create Request for send
-    const telegramURL = `https://api.telegram.org/bot${process.env.telegram}/sendMessage`;
+    let telegramURL = `https://api.telegram.org/bot${process.env.telegram}`;
 
     // Check if buttons is send as []
     let options;
@@ -29,6 +29,23 @@ module.exports = async function(program,message,id,buttons) {
         parse_mode : 'HTML'
     }
 
+    // Check if object
+    if (typeof message == `object`) {
+        if (message.text != undefined && message.image == undefined) {
+            body.text = message.text;
+            telegramURL = `${telegramURL}/sendMessage`;
+        } 
+
+        // Check for image
+        if (message.image != undefined) {
+            body.photo = message.image;
+            body.caption = message.text;
+            delete body.text;
+            delete body.reply_to_message_id;
+            telegramURL = `${telegramURL}/sendPhoto`;
+        }
+    }
+
     // If options is there add as
     if (options != undefined) {
         body.reply_markup = options.reply_markup;

package/modules/bots/applications/telegram.js

@@ -53,6 +53,19 @@ module.exports = async function(program,folder) {
                         }
                         
                         middleValue.chat.uuid = user.uuid;
+
+                        // Find or create to add message to db
+                        body.uuid = program.uuid.v4();
+                        let received = await program.modules.data.findOrCreate(`eventgo`,`received`,{
+                            update_id : body.update_id
+                        },body);
+                        
+                        // Set body from receivd
+                        body.uuid = received.uuid;
+                        
+
+                        console.log(`We have received message`,received);
+
                         try {
                             if (middleValue.text.startsWith('/')) {
                                 // If it starts with a slash, it might be a command
@@ -69,18 +82,20 @@ module.exports = async function(program,folder) {
                                 // Let's split up
                                 let match = [];
 
-                                let splitVariables = variables.split(`-`);
+                                if (variables != undefined) {
+                                    let splitVariables = variables.split(`-`);
 
-                                if (splitVariables.length > 4) {
-                                    match[0] = splitVariables[0];
-                                    if (splitVariables.length >= 5) {
-                                        match[1] = splitVariables[splitVariables.length-1];
-                                        let uuid = variables.replace(`${match[0]}-`,``).replace(`-${match[1]}`,``);;
-                                        match[2] = uuid;
+                                    if (splitVariables.length > 4) {
+                                        match[0] = splitVariables[0];
+                                        if (splitVariables.length >= 5) {
+                                            match[1] = splitVariables[splitVariables.length-1];
+                                            let uuid = variables.replace(`${match[0]}-`,``).replace(`-${match[1]}`,``);;
+                                            match[2] = uuid;
+                                        }
                                     }
                                 }
                                 
-                                if (match) {
+                                if (match.length > 0) {
                                     // Extract the parts
                                     const action = match[0];
                                     const uuid = match[2];
@@ -93,10 +108,22 @@ module.exports = async function(program,folder) {
                                     // It's something to do check if we can find this in applications
                                     try {
                                         console.log(`Run Sub Function`);
-                                        await program.modules.telegram.functions[action](program,key,action,uuid,subFunction,middleValue);
+                                        let resp = await program.modules.telegram.functions[action](program,key,action,uuid,subFunction,middleValue,received);
+
+                                        // Switch resp;
+                                        console.log(`Check if we send message`);
+                                        switch (resp.response) {
+                                            case `message`:
+                                                console.log(`We have response, check for response message`);
+                                                const message = respFunc[action];
+                                                await program.modules.telegram.functions.send(program,message,middleValue.chat.id);
+                                            break;
+                                            default:
+                                                console.error(`Missing Response Action Telegram: ${action}`);
+                                        }
                                     } catch (err) {
                                         console.error(err);
-                                        console.error(`Error Sub Function`);
+                                        console.error(`Error Sub Function ${key}, ${action}`);
                                     }
 
                                 } else {
@@ -104,7 +131,7 @@ module.exports = async function(program,folder) {
                                     // So run the function
                                     try {
                                         // Run dynamic the type of middleware
-                                        const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue);
+                                        const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue,received);
                                         const respFunc = runFunc.response;
                                         // PRocess response for object
                                         const action = Object.keys(respFunc)[0];
@@ -156,12 +183,16 @@ module.exports = async function(program,folder) {
                                 } catch (err) {
                                     //console.error(err);
                                     //console.error(`Error For Telegram Function`);
+                                    console.log(`Checking for script`);
+                                    const scripting = await program.modules.telegram.script.function.check(program,command,middleValue.chat.id,middleValue,received);
+                                    /*
                                     await program.modules.telegram.functions.send(program,`${command}`,middleValue.chat.id,[
                                         [
                                             { text: 'EventGO!',  web_app : { url : 'https://cloud.eventgo.today/events/list'}},
                                             { text: 'Create Event', callback_data: 'create_event' },
                                         ]
-                                    ]);
+                                    ]);*/
+                                    console.log(scripting);
                                 }
 
                                 
@@ -170,8 +201,6 @@ module.exports = async function(program,folder) {
                             }
                         } catch (message) {
                             // Process as other
-                            res.send(`OK | ${command} | ${variables}`)
-                            res.status(200);
                             console.log(`Process Different`);
                             let checkArray = [`location`];
                             // Loop through checkArray
@@ -209,6 +238,11 @@ module.exports = async function(program,folder) {
                                     }
                                 }
                             }
+
+                            console.log(`We do something here`);
+
+                            res.send(`OK `)
+                            res.status(200);
                         }
                     } catch (err) {
                         console.error(err);
@@ -298,6 +332,84 @@ module.exports = async function(program,folder) {
     // Add middleware
     telegram.middleware = middleWarFuncs;
 
+    // Process scripts
+    const scriptsPath   =   program.path.join(__dirname,`telegram`,`scripts`);
+
+    // Loop Through scripts folder
+    let scriptsData = await program.modules.walkDirectory(scriptsPath);
+
+    // Let's loop througha and if no extension it's folder
+    let allScripts = {
+        int : {}
+    }
+    for (let scriptIndex in scriptsData) {
+        let script = scriptsData[scriptIndex];
+        // We now have the specific script check if folder
+        if (!script.extension) {
+            // It's folder create the function and read folder
+            console.log(`It's folder check for files as in .json or .js`);
+            const folderScriptScan = await program.modules.walkDirectory(script.path);
+
+            // Create now allScripts item interaction as we will check dynamic for the item
+            for (let fsi in folderScriptScan) {
+                // So now again we only do things when it's a file but check  extension
+                const scriptItem = folderScriptScan[fsi];
+                // We have folder data
+                if (!scriptItem.extension) {
+                    continue;
+                }
+
+                // We have script create 
+                console.log(`Folder Script Scan`,scriptItem);
+
+                // Switch extension
+                const extCheck = scriptItem.extension.slice(1);
+
+                // We have the extension so swich between those
+                switch (extCheck){
+                    case `json`:
+                        console.log(`Read File`);
+                        try {
+                            const readFile = JSON.parse(await program.fs.readFileSync(scriptItem.path,`utf-8`));
+
+                            // Create the command
+                            const interact = readFile.input;
+
+                            // For interaction
+                            delete readFile.input;
+                            allScripts.int[interact] = readFile;
+                            
+                            console.log(`We have readed the file`);
+                        } catch (err) {
+                            console.error(err);
+                            console.error(`Error Reading JSON file`);
+                        }
+                    break;
+                    default:
+                        // When it's not like json
+                        console.log(`it's something else`);
+                }
+            }
+
+            console.log(`Walk Through folder and check for script.json`);
+
+        } else {
+            // It's main script functions
+            console.log(`Main Script Function In Specific folder`);
+            try {
+                // Add script to allscript
+                allScripts[script.name] =   require(script.path);
+                console.log(`Script : ${script.name} - loaded`);
+            } catch (err) {
+                console.error(err);
+                console.error(`Error Loading script`,script);
+            }
+        }
+    }
+
+    // Set all script
+    telegram.script = allScripts;
+
     program.modules.telegram = telegram;
     return program;
 }

package/modules/data/mongo/findOrCreate.js

@@ -44,7 +44,7 @@ module.exports = async function(db, collection, condition, dataToCreate) {
                 if (result.acknowledged === true) {
                     console.log('New document created:', result.insertedId);
                     const existingDocument = await collection.findOne(condition);
-                    return existingDocument;
+                    return dataToCreate;
                 } else {
                     console.error('Failed to create a new document.');
                     return null;

package/modules/request/functions/post.js

@@ -15,12 +15,17 @@ module.exports = async function(program, url, body) {
 
       // Using standard fetch function
       const response = await fetch(url, theOptions);
+        // Get response body
+        const respBody = await response.json(); // Assuming the response is JSON
+
+        // Get response headers
+        const respHeaders = response.headers;
 
       if (!response.ok) {
           throw new Error(`HTTP error! Status: ${response.status}`);
       }
 
-      const responseData = await response.json();
+      const responseData = respBody;
       console.log('Response Data:', responseData);
 
       // Return response data or true to indicate success

package/package.json

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