webfast 0.1.16 → 0.1.20

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

@@ -1,15 +1,205 @@
 // Here we can collect something by when user enter collect state in telegram
 module.exports = {
     line : {},
-    set : function(id) {
+    set : function(id,data) {
         // To set que
-        console.log(`Que Set Telegram`)
+        console.log(`Que Set Telegram`);
+        this.line[id] = data;
+        return this.line[id];
     },
-    get : function(id) {
-        console.log(`Que Get Telegram`)
+    get : function(id,program) {
+        console.log(`Que Get Telegram`);
+        // Check if in que line
+        if (program.modules.telegram.functions.que.line[id] == undefined) {
+            return false;
+        } else {
+            let lineData = program.modules.telegram.functions.que.line[id];
+            return lineData;
+        }
     },
     timer : function() {
         // Run timer
-        console.log(`Timer Run`);
+        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 && program.modules.telegram.functions.que.line[chatID] == undefined) {
+                // Send message we don't know
+                
+                return false;
+            } 
+
+            // Create the que line 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 = {
+                    ts : Date.now(),
+                    action : command,
+                    process : scriptStart,
+                    script : script,
+                    anwsers : {},
+                    uuid : theUUID,
+                    q : true
+                }
+                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 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) {
+                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
+            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

@@ -0,0 +1,42 @@
+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 == 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' },
+                    ]
+                ]);
+            } 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 
+                // 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`);
+
+            return true;
+        } catch(err) {
+            console.error(err);
+            console.error(`Error Scripting`);
+        }
+    },
+    response : async function() {
+        console.log(`Function Response`);
+    }
+}

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

@@ -0,0 +1,57 @@
+{
+    "input"     :       "test input",
+    "start"     :       {
+        "object"  :   {
+            "text" : "Test First Title : {{TEST}}",
+            "image" :   "{{URL}}app/content/images/block.png"
+        },
+        "match"    :   {
+            "data"  :   [{
+                "anwser"  :   ["anwser text","anwser"],
+                "function"  :   "program.modules.bots.scripts.function.response",
+                "next"      :   "nextFunc"
+            },{
+                "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.response",
+            "next"      :   "failResponse"
+        }
+    },
+    "failResponse" : {
+        "object"  :   {
+            "text" : "Sorry Something Wnt wrong : {{START}}"
+        }
+    }
+}

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,12 +29,38 @@ 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`;
+        }
+    } else {
+        telegramURL = `${telegramURL}/sendMessage`;
+    }
+
     // If options is there add as
     if (options != undefined) {
         body.reply_markup = options.reply_markup;
     }
 
     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/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.16",
+  "version": "0.1.20",
   "description": "WebFast! Bot Application, including TON mini-apps",
   "main": "index.js",
   "repository": {