webfast 0.1.85 → 0.1.87

package/README.md

@@ -130,6 +130,19 @@ program.modules.dependOn({REQUIRE},program,`{UNIQUE_NAME}-sync`,function(){
             console.log(`Depend On CallBack`);
 });
 ```
+## NEW BETA FEATURE
+Feature where youo can add a special frame for multiple views through telegram without reloading
+````
+await web.fast.telegram(`frame`).set(id,`https://${window.location.hostname}/concepts/esimco/package#${id}`,async function(id){
+    console.log(`Clicked Close`,id);
+    const frame = jQuery(`[wbfst-frame="${id}"]`);
+    console.log(`The Frame`,frame);
+    jQuery(frame).animate({ opacity:0 }, 600,function(){
+        jQuery(this).remove();
+    });
+    
+});
+````
 
 ## License
 

package/app/content/js/webfast.js

@@ -5,6 +5,16 @@ web.fast = {
     action : function(data,ell) {
         console.log(`Action Function`,data,ell);
     },
+    redirect :function(event) {
+        console.log(`Received Redirect`,event);
+        const state = event.type;
+        if (state == true) {
+            // Redirect
+            window.location.replace(event.url);
+        } else {
+            console.error(`Something wrong redirect`,event);
+        }
+    },
     functions : {
         isURL : function(str) {
             // Regular expression to check if a string is a URL
@@ -99,15 +109,68 @@ web.fast = {
         }
     },
     telegram : function(action){
-        try {
-            const telegram = window.Telegram;
-            const actionFunction = telegram[action];
-            console.log(`TELEGRAM`,action);
-            return actionFunction;
-        } catch (err) {
-            //console.error(Err);
-            console.error(`NO TELEGRAM`,action);
-            return false;
+        // check if action is to set frame
+        if (action == `frame`) {
+            return {
+                get : async function(id) {
+                    console.log(`Get Frame for ID`,id);
+                },
+                close : async function(id) {
+                    console.log(`Close Frame`);
+                },
+                set : async function(id,url,closeAction,zIndex = 9990) {
+                    if (web.fast.user != undefined) {
+                        //console.error(`NO USER`);
+                        //return window.location.href = url;
+                        window.Telegram.WebApp.HapticFeedback.impactOccurred('medium');
+                    }
+                    console.log(`Telegram Frame Set`,id,url,closeAction);
+                    let iframe = document.createElement('iframe');
+                    iframe.src = url; // Replace with your desired URL
+
+                    const settedID = ``+id;
+                    // Set additional attributes (optional)
+                    iframe.style.border = 'none'; // Remove the border
+                    iframe.style.width = '100vw'; // Set width to 100vw
+                    iframe.style.height = '100vh'; // Set height to 100vh
+                    iframe.style.top = '0'; // Set height to 100vh
+                    iframe.style.left = '0'; // Set height to 100vh
+                    iframe.style[`z-index`] = zIndex; // Set height to 100vh
+                    iframe.id = settedID;
+
+                    iframe.style.position = 'fixed';
+
+                    // Append the iframe to the body
+                    document.body.appendChild(iframe);
+                    jQuery(iframe).attr(`id`,settedID);
+                    jQuery(iframe).attr(`wbfst-frame`,settedID);
+
+                    try {
+                        //window.Telegram.WebApp.web_app_open_link(url);
+                        if (web.fast.user != undefined) {
+                            window.closeIframe = function() {
+                                console.log(`Close Iframe`,id);
+                                //jQuery(`#${id}`).hide();
+                                closeAction(id);
+                            } 
+                        } else {
+                            // Set on click event
+                            if (closeAction != undefined) {
+                                console.log(`Set Close Action`);
+                                window.closeIframe = function() {
+                                    console.log(`Close Iframe`,id);
+                                    //jQuery(`#${id}`).hide();
+                                    closeAction(id);
+                                } 
+                            }
+                        }
+
+                    } catch (err) {
+                        console.error(err);
+                        console.error(`Error opening link`,url);
+                    }
+                }
+            }
         }
     }
 }

package/index.js

@@ -112,7 +112,7 @@ module.exports = async function (array) {
 
                 // Now include this thing then
                 try {
-                    program.modules[reqFunc.name] = await reqFunc.run(program,reqFunc.name,reqFunc.functions);
+                    program.modules[reqFunc.name.replace(`-sync`,``)] = await reqFunc.run(program,reqFunc.name,reqFunc.functions);
                     if (callback != undefined) {
                         return callback(program,name)
                     } else {

package/modules/data/mongo/insert.js

@@ -0,0 +1,42 @@
+const { MongoClient } = require('mongodb');
+
+module.exports = async function(db, collection, dataToInsert) {
+    // Ensure the MongoDB connection string is provided
+    if (!process.env.mongo) {
+        console.error('MongoDB connection string not provided. Set process.env.mongo.');
+        process.exit(1);
+    }
+
+    // Define the MongoDB URI
+    const uri = process.env.mongo;
+
+    // Define the database and collection name
+    const dbName = db;
+    const collectionName = collection;
+
+    // Function to insert data
+    async function insertData() {
+        const client = new MongoClient(uri);
+    
+        try {
+            await client.connect();
+            console.log('Connected to MongoDB server');
+        
+            const database = client.db(dbName);
+            const collection = database.collection(collectionName);
+        
+            // Insert the data
+            const result = await collection.insertOne(dataToInsert);
+            console.log(`Document inserted with _id: ${result.insertedId}`);
+            return result;
+        } catch (error) {
+            console.error('Error inserting document:', error);
+        } finally {
+            // Close the connection
+            await client.close();
+        }
+    }
+
+    // Execute the main function
+    return insertData().catch(console.error);
+};

package/modules/express/init.js

@@ -1,428 +1,444 @@
 module.exports = async function (program) {
-    console.log(`Starting UP Express`);
-    program.express = {
-        ts: Date.now(),
-        process : program.set.process
-    };
-  
-    const express = require('express');
-    const cors = require('cors');
-    const bodyParser = require('body-parser');
-    const WebSocket = require('ws');
-    const crypto = require(`crypto`)
-    const port = process.env.port;
-    const basePath = `/api`;
-  
-    const app = express();
-  
-    const corsOptions = {
-        origin: '*',
-        methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
-        credentials: true,
-        optionsSuccessStatus: 204,
-    };
-  
-    app.use(cors(corsOptions));
-    app.use(bodyParser.json());
-    app.use(bodyParser.urlencoded({ extended: true }));
-    app.set('view engine', 'ejs');
-  
-    let routesPath = program.path.join(__dirname, `routes`);
-    // Check if custom routes path
-    if (program.set.path != undefined) {
-        routesPath = program.path.join(program.set.path, `routes`);
-    }
-  
-    let exprs = {};
-  
-    try {
-        let routesData = await program.modules.walkDirectory(routesPath);
-  
-        for (let routeData of routesData) {
-            let routePath = `${basePath}/${routeData.name}`;
-  
-            const split = routeData.name.split('.');
-            routeData.type = split.length > 1 ? split[split.length - 1] : 'get';
-            routeData.name = split.length > 1 ? split[0] : routeData.name;
-  
-            const routeID = program.uuid.v4();
-            routeData.tempID = routeID;
-  
-            try {
-                const stats = await program.fs.statSync(routeData.path);
-                const isDirectory = stats.isDirectory();
-  
-                if (isDirectory) {
-                    for (let subData of routeData.sub) {
-                        if (subData !== undefined) {
-                            const routeName = subData.name.replace('.get', '').replace('.post', '');
-                            const subDataSplit = subData.path.split('.');
-                            const type = subDataSplit[subDataSplit.length - 2];
-  
-                            subData.name = routeName;
-                            delete subData.sub;
-                            subData.type = type;
-  
-                            subData.func = require(subData.path);
-                            exprs[routePath + '/' + routeName] = subData;
-                        }
+console.log(`Starting UP Express`);
+program.express = {
+    ts: Date.now(),
+    process : program.set.process
+};
+
+const express = require('express');
+const cors = require('cors');
+const bodyParser = require('body-parser');
+const WebSocket = require('ws');
+const crypto = require(`crypto`)
+const port = process.env.port;
+const basePath = `/api`;
+
+const app = express();
+
+const corsOptions = {
+    origin: '*',
+    methods: 'GET,HEAD,PUT,PATCH,POST,DELETE',
+    credentials: true,
+    optionsSuccessStatus: 204,
+};
+
+app.use(cors(corsOptions));
+app.use(bodyParser.json());
+app.use(bodyParser.urlencoded({ extended: true }));
+app.set('view engine', 'ejs');
+
+let routesPath = program.path.join(__dirname, `routes`);
+// Check if custom routes path
+if (program.set.path != undefined) {
+    routesPath = program.path.join(program.set.path, `routes`);
+}
+
+let exprs = {};
+
+try {
+    let routesData = await program.modules.walkDirectory(routesPath);
+
+    for (let routeData of routesData) {
+        let routePath = `${basePath}/${routeData.name}`;
+
+        const split = routeData.name.split('.');
+        routeData.type = split.length > 1 ? split[split.length - 1] : 'get';
+        routeData.name = split.length > 1 ? split[0] : routeData.name;
+
+        const routeID = program.uuid.v4();
+        routeData.tempID = routeID;
+
+        try {
+            const stats = await program.fs.statSync(routeData.path);
+            const isDirectory = stats.isDirectory();
+
+            if (isDirectory) {
+                for (let subData of routeData.sub) {
+                    if (subData !== undefined) {
+                        const routeName = subData.name.replace('.get', '').replace('.post', '');
+                        const subDataSplit = subData.path.split('.');
+                        const type = subDataSplit[subDataSplit.length - 2];
+
+                        subData.name = routeName;
+                        delete subData.sub;
+                        subData.type = type;
+
+                        subData.func = require(subData.path);
+                        exprs[routePath + '/' + routeName] = subData;
                     }
-                } else {
-                    routeData.func = require(routeData.path);
-                    exprs[routePath] = routeData;
                 }
-            } catch (err) {
-                console.error(`Error Route Func`, routePath);
-                console.error(err);
+            } else {
+                routeData.func = require(routeData.path);
+                exprs[routePath] = routeData;
             }
-  
-            routeData.webwalk = 0;
+        } catch (err) {
+            console.error(`Error Route Func`, routePath);
+            console.error(err);
         }
-  
-        program.express.routes = exprs;
-  
-        for (let route in exprs) {
-            let routeData = exprs[route];
-            let state = false;
-  
-            try {
-                app[routeData.type](route, async (req, res) => {
-                    try {
-                        exprs[route].webwalk++;
-  
-                        // Get body
-                        const requestBody = req.body;
-                        const reqParams = req.params;
-  
-                        await routeData.func(program, req, res, route, requestBody, reqParams);
-                    } catch (err) {
-                        console.error(`Error With Route:`, route);
-                        console.error(err);
-                    }
-                });
-                state = true;
-            } catch (err) {
-                console.error(err);
-                console.error(`Error Setting Up Route`);
-            }
-  
-            exprs[route].state = state;
+
+        routeData.webwalk = 0;
+    }
+
+    program.express.routes = exprs;
+
+    for (let route in exprs) {
+        let routeData = exprs[route];
+        let state = false;
+
+        try {
+            app[routeData.type](route, async (req, res) => {
+                try {
+                    exprs[route].webwalk++;
+
+                    // Get body
+                    const requestBody = req.body;
+                    const reqParams = req.params;
+
+                    await routeData.func(program, req, res, route, requestBody, reqParams);
+                } catch (err) {
+                    console.error(`Error With Route:`, route);
+                    console.error(err);
+                }
+            });
+            state = true;
+        } catch (err) {
+            console.error(err);
+            console.error(`Error Setting Up Route`);
+        }
+
+        exprs[route].state = state;
+    }
+
+    console.log(`Routes are set up successfully`);
+} catch (err) {
+    console.error(err);
+    console.error(`Error Setting Up Routes`);
+}
+
+program.express.app = app;
+
+// Let app listen for content
+app.get(`/app/content/ton/manifest.json`, async (req, res) => {
+    // Let's create a json
+    const manifest = {
+        url: process.env.url,
+        name: process.env.name,
+        iconUrl: process.env.image
+    };
+
+    res.setHeader('Content-Type', 'application/json');
+    res.json(manifest);
+});
+
+app.get(`/app/content/:type/:file`, async (req, res) => {
+    console.log(`Content Get`);
+    // Try To get file from content folder
+    try {
+        const filePath = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, req.params.file);
+        let contentFolder = filePath;
+
+        // Check if minify at the end
+        const fileName = req.params.file;
+        const isExtend = /-extend\.js$/.test(fileName);
+
+        // Check if extending
+        if (isExtend) {
+            console.log(`${fileName} ends with -extend.js`);
+            // IS extended file include loading in
+
+            const toRequestFile = req.params.file.replace(`-extend.js`, `.js`);
+            contentFolder = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, toRequestFile);
+            // check if file exists in process, if not make it before giving out
+            // Check i
+            console.log(`Content Folder`);
+        } else {
+            console.log(`${fileName} does not end with -min.js`);
         }
-  
-        console.log(`Routes are set up successfully`);
+
+        res.sendFile(contentFolder);
     } catch (err) {
         console.error(err);
-        console.error(`Error Setting Up Routes`);
+        console.error(`Error Getting : ${req.params.type}`, req.params.file);
     }
-  
-    program.express.app = app;
-  
-    // Let app listen for content
-    app.get(`/app/content/ton/manifest.json`, async (req, res) => {
-        // Let's create a json
-        const manifest = {
-            url: process.env.url,
-            name: process.env.name,
-            iconUrl: process.env.image
-        };
-  
-        res.setHeader('Content-Type', 'application/json');
-        res.json(manifest);
-    });
-  
-    app.get(`/app/content/:type/:file`, async (req, res) => {
-        console.log(`Content Get`);
-        // Try To get file from content folder
+})
+
+// Walkt through for paths to be open 
+if (program.set.contentPath != undefined) {
+    // Loop Through
+    const readDir = program.fs.readdirSync(program.set.contentPath);
+    
+    // Create request app path for it
+    //loop through
+    for (let rdi in readDir) {
+        // Loop
+        const dirItem = readDir[rdi];
+        if (dirItem == `.DS_store`) {
+            continue;
+        }
+        const dirPath = program.path.join(program.set.contentPath,dirItem);
+        // Now read the dir
+        // Create app.get
         try {
-            const filePath = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, req.params.file);
-            let contentFolder = filePath;
-  
-            // Check if minify at the end
-            const fileName = req.params.file;
-            const isExtend = /-extend\.js$/.test(fileName);
-  
-            // Check if extending
-            if (isExtend) {
-                console.log(`${fileName} ends with -extend.js`);
-                // IS extended file include loading in
-  
-                const toRequestFile = req.params.file.replace(`-extend.js`, `.js`);
-                contentFolder = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, toRequestFile);
-                // check if file exists in process, if not make it before giving out
-                // Check i
-                console.log(`Content Folder`);
-            } else {
-                console.log(`${fileName} does not end with -min.js`);
+            const theRoute = `/inc/${dirItem}/*`;
+            app.get(theRoute, async (req, res) => {
+                const params = req.params;
+
+                try {
+                    const fullPath = program.path.join(dirPath,req.params[0]);
+                    res.sendFile(fullPath);
+                } catch (err) {
+                    console.error(`Error Responding with route`);
+                    console.error(err);
+                    res.status(500);
+                }
+                console.log(`The Route is there`, theRoute);
+            });
+
+        } catch (err) {
+            console.error(`Errro for path read dir including something`, diritem);
+        }
+    }
+    console.log(`We have directory`);
+}
+
+app.listen(port, () => {
+    console.log(`Server Listening`, port, basePath);
+});
+
+program.express.url = {
+    adaptive: {
+        get: [],
+        post: [],
+    },
+    set: function (requestPath, actionType, callback) {
+        program.express.url.adaptive[actionType] = app[actionType](requestPath, async (req, res) => {
+            let run = await callback(req, res, req.body, req.params);
+            return run;
+        });
+        return true;
+    },
+};
+
+program.express.setted = true;
+
+let clients = new Map();
+// Start socket thingy
+const PORT = process.env.socket || 3000;
+const wss = new WebSocket.Server({ port: PORT });
+
+
+wss.on('connection', async (ws, req) => {
+    console.log(`Socket Connected`);
+
+    // Generate a unique ID for the WebSocket connection
+    const clientId = program.uuid.v4();
+    const reqURL = req.url;
+    console.log(`We have some data`, reqURL);
+    const queryStringWithoutQBT = reqURL.replace('/socket.io/?qbt=', '');
+    const queryParamsArray = queryStringWithoutQBT.split('&');
+
+    const parsedQuery = queryParamsArray.reduce((acc, param) => {
+        const [key, value] = param.split('=');
+        acc[key] = decodeURIComponent(value);
+        return acc;
+    }, {});
+
+    // Extract data from the parsed query
+    const { auth_date, query_id, user, hash } = parsedQuery;
+
+    // Stringify the 'user' field if it contains JSON data
+    if (user != undefined) {
+        try {
+            parsedQuery.user = JSON.stringify(parsedQuery.user);
+        } catch (error) {
+            console.error('Error parsing JSON in user field:', error);
+        }
+    }
+
+    // Construct the data check string
+    const sortedKeys = Object.keys(parsedQuery).sort();
+    const data_check_string = sortedKeys.map(key => `${key}=${String(parsedQuery[key])}`).join('\n');
+
+    function HMAC_SHA256(data, key) {
+        const hmac = crypto.createHmac('sha256', key);
+        hmac.update(data);
+        return hmac.digest('hex');
+    }
+
+    const bot_token = process.env.telegram; // replace with your actual bot token
+    const secret_key = HMAC_SHA256(bot_token, 'WebAppData');
+    const calculated_hash = HMAC_SHA256(data_check_string, secret_key);
+
+    const received_hash = hash; // replace with the actual received hash
+
+    if (calculated_hash === received_hash) {
+        // Data is from Telegram and has not been tampered with
+        // Additional check for auth_date if needed
+        const currentUnixTimestamp = Math.floor(new Date().getTime() / 1000);
+        if (parseInt(auth_date, 10) <= currentUnixTimestamp) {
+            // Data is not outdated
+            // Use the validated data as needed
+            console.log('Data from Telegram is valid');
+        } else {
+            console.error('Received data is outdated');
+        }
+    } else {
+        console.error('Received data has been tampered with');
+    }
+
+    // Store the WebSocket connection with its ID in the map
+    clients.set(clientId, ws);
+
+    // Send the client ID to the connected client
+    let getUser;
+    if (parsedQuery.user != undefined) {
+        // Get user
+        const userJSON = JSON.parse(JSON.parse(parsedQuery.user));
+        getUser = await program.modules.data.find(process.env.dbName,`telegram`,{
+            id : userJSON.id
+        },true,{image:true,program,async function(program,json){
+            // Get firs timage
+            console.log(`User JSON`);
+            let image;
+            let allImages = [];
+            if (json.images != undefined) {
+                image = json.images[Object.keys(json.images)[0]];
+                
+                // Create path if not exists
+                async function routeExists(path) {
+                    return program.express.app._router.stack.some(layer => {
+                        if (layer.route) {
+                            return layer.route.path === path;
+                        }
+                        return false;
+                    });
+                }
+
+                for (const image in json.images) {
+                    console.log(`Set image url's`);
+
+                    const imagePath = `/user/dynamic/image/${image}.${json.images[image].meta.type}`;
+                    const routeCheck = await routeExists(imagePath);
+                    const fullPath = `${process.env.url}${imagePath.slice(1)}`;
+                    allImages.push(fullPath);
+                    if (!routeCheck) {
+                        // Create route
+                        const fullImageData = json.images[image];
+                        program.express.app.get(imagePath, async (req,res) => {
+                            console.log(`Request for`,imagePath);
+                            // set headers
+                            res.set('Content-Type', `image/${fullImageData.meta.type}`);
+                            res.send(fullImageData.buffer);
+                        })
+                    }
+                }
+            }
+            // Now we have the image data
+            console.log(`Image Data`);
+            // Further more we want to send some data 
+            const sendKeys = [`id`,`first_name`,`username`,`uuid`];
+
+            // Crerate little loop for the data to be send in json format to be processed 
+            let sendData = {};
+            for (let sd  in sendKeys) {
+                let key = sendKeys[sd];
+                // Get object
+                if (json[key] != undefined) {
+                    sendData[key] = json[key];
+                }
             }
-  
-            res.sendFile(contentFolder);
+            console.log(`Preparing for sending`);
+            sendData.images = allImages;
+
+            // TODO ADD OTHER DATA
+            //program.express.process.socket.api.
+            // TODO location
+            ws.send(JSON.stringify({ type: 'user', clientId: clientId, data : sendData }));
+        }});
+    }
+    //ws.send(JSON.stringify({ type: 'clientId', id: clientId, params: parsedQuery }));
+
+
+    // Check if data has order
+    // Check if action in this params and also if action order if user order 
+    // otherwise who error
+    if (parsedQuery.start_param != undefined) {
+        const startSplit = parsedQuery.start_param.split(`__`);
+        const uuid = startSplit[0];
+        const action = startSplit[1];
+
+        // Check action and if we have this action in custom routes thingy
+        try {
+            const userJSON = JSON.parse(JSON.parse(parsedQuery.user));
+            await program.express.process.params(program,ws,action,uuid,parsedQuery,clientId,userJSON);
         } catch (err) {
-            console.error(err);
-            console.error(`Error Getting : ${req.params.type}`, req.params.file);
+            // Error for params
+            console.error(`Error for program params start_param`);
         }
-    })
-  
-    // Walkt through for paths to be open 
-    if (program.set.contentPath != undefined) {
-      // Loop Through
-      const readDir = program.fs.readdirSync(program.set.contentPath);
-      
-      // Create request app path for it
-      //loop through
-      for (let rdi in readDir) {
-          // Loop
-          const dirItem = readDir[rdi];
-          if (dirItem == `.DS_store`) {
-              continue;
-          }
-          const dirPath = program.path.join(program.set.contentPath,dirItem);
-          // Now read the dir
-          // Create app.get
-          try {
-              const theRoute = `/inc/${dirItem}/*`;
-              app.get(theRoute, async (req, res) => {
-                  const params = req.params;
-  
-                  try {
-                      const fullPath = program.path.join(dirPath,req.params[0]);
-                      res.sendFile(fullPath);
-                  } catch (err) {
-                      console.error(`Error Responding with route`);
-                      console.error(err);
-                      res.status(500);
-                  }
-                  console.log(`The Route is there`, theRoute);
-              });
-  
-          } catch (err) {
-              console.error(`Errro for path read dir including something`, diritem);
-          }
-      }
-      console.log(`We have directory`);
     }
-  
-    app.listen(port, () => {
-        console.log(`Server Listening`, port, basePath);
+
+    // Set up a ping interval to keep the connection alive
+    const pingInterval = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.ping();
+        } else {
+            // If the connection is closed, remove it from the map
+            clearInterval(pingInterval);
+            clients.delete(clientId);
+            console.log(`Removed disconnected socket with ID: ${clientId}`);
+        }
+    }, 5000); // Adjust the interval as needed
+
+    ws.on('close', () => {
+        console.log(`Socket Disconnected`);
+        clearInterval(pingInterval);
+        clients.delete(clientId);
     });
-  
-    program.express.url = {
-        adaptive: {
-            get: [],
-            post: [],
-        },
-        set: function (requestPath, actionType, callback) {
-            program.express.url.adaptive[actionType] = app[actionType](requestPath, async (req, res) => {
-                let run = await callback(req, res, req.body, req.params);
-                return run;
+
+    // WebSocket on message event
+    ws.on('message', async (message) => {
+        //console.log(`Received message from ${clientId}: ${message}`);
+
+        try {
+            // Check for function
+            const json = JSON.parse(message.toString(`utf-8`));
+            const data = json.message;
+            const path = json.path;
+            const split = path.split(".")
+            
+            // Check if function is running in program modules that you can add in the init scirpt when using remote
+            if (program.express.process != undefined) {
+                try {
+                    let resp = await program.express.process[split[0]][split[1]][split[2]](program,ws,json,data,path,clientId,ws);
+                    if (resp != false) {
+                        ws.send(JSON.stringify(resp));
+                    }
+                } catch (err) {
+                    console.error(`Error Running program.express.process for `,split[0],split[1],split[2]);
+                    ws.send(JSON.stringify({
+                        ts : Date.now(),
+                        error : true,
+                        message : `Error Event Program receive`
+                    }));
+                }
+            }
+
+            // Add your custom on message logic here
+            // For example, you can broadcast the message to all connected clients
+            clients.forEach((client, id) => {
+                if (client.readyState === WebSocket.OPEN && id !== clientId) {
+                    //ws.send(`Broadcast from ${clientId}: ${message}`);
+                }
             });
-            return true;
-        },
-    };
-  
-    program.express.setted = true;
-  
-    let clients = new Map();
-    // Start socket thingy
-    const PORT = process.env.socket || 3000;
-    const wss = new WebSocket.Server({ port: PORT });
-  
-   
-    wss.on('connection', async (ws, req) => {
-      console.log(`Socket Connected`);
-  
-      // Generate a unique ID for the WebSocket connection
-      const clientId = program.uuid.v4();
-      const reqURL = req.url;
-      console.log(`We have some data`, reqURL);
-      const queryStringWithoutQBT = reqURL.replace('/socket.io/?qbt=', '');
-      const queryParamsArray = queryStringWithoutQBT.split('&');
-  
-      const parsedQuery = queryParamsArray.reduce((acc, param) => {
-          const [key, value] = param.split('=');
-          acc[key] = decodeURIComponent(value);
-          return acc;
-      }, {});
-  
-      // Extract data from the parsed query
-      const { auth_date, query_id, user, hash } = parsedQuery;
-  
-      // Stringify the 'user' field if it contains JSON data
-      if (user != undefined) {
-          try {
-              parsedQuery.user = JSON.stringify(parsedQuery.user);
-          } catch (error) {
-              console.error('Error parsing JSON in user field:', error);
-          }
-      }
-  
-      // Construct the data check string
-      const sortedKeys = Object.keys(parsedQuery).sort();
-      const data_check_string = sortedKeys.map(key => `${key}=${String(parsedQuery[key])}`).join('\n');
-  
-      function HMAC_SHA256(data, key) {
-          const hmac = crypto.createHmac('sha256', key);
-          hmac.update(data);
-          return hmac.digest('hex');
-      }
-  
-      const bot_token = process.env.telegram; // replace with your actual bot token
-      const secret_key = HMAC_SHA256(bot_token, 'WebAppData');
-      const calculated_hash = HMAC_SHA256(data_check_string, secret_key);
-  
-      const received_hash = hash; // replace with the actual received hash
-  
-      if (calculated_hash === received_hash) {
-          // Data is from Telegram and has not been tampered with
-          // Additional check for auth_date if needed
-          const currentUnixTimestamp = Math.floor(new Date().getTime() / 1000);
-          if (parseInt(auth_date, 10) <= currentUnixTimestamp) {
-              // Data is not outdated
-              // Use the validated data as needed
-              console.log('Data from Telegram is valid');
-          } else {
-              console.error('Received data is outdated');
-          }
-      } else {
-          console.error('Received data has been tampered with');
-      }
-  
-  
-      // Store the WebSocket connection with its ID in the map
-      clients.set(clientId, ws);
-  
-      // Send the client ID to the connected client
-      let getUser;
-      if (parsedQuery.user != undefined) {
-          // Get user
-          const userJSON = JSON.parse(JSON.parse(parsedQuery.user));
-          getUser = await program.modules.data.find(process.env.dbName,`telegram`,{
-              id : userJSON.id
-          },true,{image:true,program,async function(program,json){
-              // Get firs timage
-              console.log(`User JSON`);
-              let image;
-              let allImages = [];
-              if (json.images != undefined) {
-                  image = json.images[Object.keys(json.images)[0]];
-                  
-                  // Create path if not exists
-                  async function routeExists(path) {
-                      return program.express.app._router.stack.some(layer => {
-                          if (layer.route) {
-                              return layer.route.path === path;
-                          }
-                          return false;
-                      });
-                  }
-  
-                  for (const image in json.images) {
-                      console.log(`Set image url's`);
-  
-                      const imagePath = `/user/dynamic/image/${image}.${json.images[image].meta.type}`;
-                      const routeCheck = await routeExists(imagePath);
-                      const fullPath = `${process.env.url}${imagePath.slice(1)}`;
-                      allImages.push(fullPath);
-                      if (!routeCheck) {
-                          // Create route
-                          const fullImageData = json.images[image];
-                          program.express.app.get(imagePath, async (req,res) => {
-                              console.log(`Request for`,imagePath);
-                              // set headers
-                              res.set('Content-Type', `image/${fullImageData.meta.type}`);
-                              res.send(fullImageData.buffer);
-                          })
-                      }
-                  }
-              }
-              // Now we have the image data
-              console.log(`Image Data`);
-              // Further more we want to send some data 
-              const sendKeys = [`id`,`first_name`,`username`,`uuid`];
-  
-              // Crerate little loop for the data to be send in json format to be processed 
-              let sendData = {};
-              for (let sd  in sendKeys) {
-                  let key = sendKeys[sd];
-                  // Get object
-                  if (json[key] != undefined) {
-                      sendData[key] = json[key];
-                  }
-              }
-              console.log(`Preparing for sending`);
-              sendData.images = allImages;
-  
-              // TODO ADD OTHER DATA
-              //program.express.process.socket.api.
-              // TODO location
-              ws.send(JSON.stringify({ type: 'user', clientId: clientId, data : sendData }));
-              
-          }});
-      }
-      //ws.send(JSON.stringify({ type: 'clientId', id: clientId, params: parsedQuery }));
-  
-      // Set up a ping interval to keep the connection alive
-      const pingInterval = setInterval(() => {
-          if (ws.readyState === WebSocket.OPEN) {
-              ws.ping();
-          } else {
-              // If the connection is closed, remove it from the map
-              clearInterval(pingInterval);
-              clients.delete(clientId);
-              console.log(`Removed disconnected socket with ID: ${clientId}`);
-          }
-      }, 5000); // Adjust the interval as needed
-  
-      ws.on('close', () => {
-          console.log(`Socket Disconnected`);
-          clearInterval(pingInterval);
-          clients.delete(clientId);
-      });
-  
-      // WebSocket on message event
-      ws.on('message', async (message) => {
-          //console.log(`Received message from ${clientId}: ${message}`);
-  
-          try {
-              // Check for function
-              const json = JSON.parse(message.toString(`utf-8`));
-              const data = json.message;
-              const path = json.path;
-              const split = path.split(".")
-              
-              // Check if function is running in program modules that you can add in the init scirpt when using remote
-              if (program.express.process != undefined) {
-                  try {
-                      let resp = await program.express.process[split[0]][split[1]][split[2]](program,ws,json,data,path,clientId,ws);
-                      if (resp != false) {
-                          ws.send(JSON.stringify(resp));
-                      }
-                  } catch (err) {
-                      console.error(`Error Running program.express.process for `,split[0],split[1],split[2]);
-                      ws.send(JSON.stringify({
-                          ts : Date.now(),
-                          error : true,
-                          message : `Error Event Program receive`
-                      }));
-                  }
-              }
-  
-              // Add your custom on message logic here
-              // For example, you can broadcast the message to all connected clients
-              clients.forEach((client, id) => {
-                  if (client.readyState === WebSocket.OPEN && id !== clientId) {
-                      //ws.send(`Broadcast from ${clientId}: ${message}`);
-                  }
-              });
-  
-              // Check if 
-          } catch(err) {
-              console.error(`Error Something`);
-  
-          }
-      });
-  });
-  
-  
-    return program;
-  };
-  
+
+            // Check if 
+        } catch(err) {
+            console.error(`Error Something`);
+
+        }
+    });
+});
+
+
+return program;
+};

package/modules/payment/init.js

@@ -0,0 +1,52 @@
+module.exports = {
+    dependOn : [`modules.request.get`],
+    name : 'payment-sync',
+    run : async function(program,name) {
+        console.log(`Running ${name}`);
+
+        // Lets make a mockup for providers
+        const routesPath = program.path.join(__dirname,`providers`);
+        let moduleData = await program.modules.walkDirectory(routesPath);
+        
+        // Set Module
+        let setModule = {
+            ts : Date.now()
+        }
+
+        // loop Throuh module data 
+        for (let moduleIndex in moduleData) {
+            // Get the module
+            let module = moduleData[moduleIndex];
+            // Create module in setModule
+            try {
+                // We have set module
+                // read startup file
+                const mainModulePath = program.path.join(routesPath,`${module.name}`);
+                const startupPath = program.path.join(mainModulePath,`startup.js`);
+
+                // Check if program set path
+                if (program.set.path == undefined) {
+                    continue;
+                }
+                const configRead = JSON.parse(program.fs.readFileSync(program.path.join(program.set.path,`payment.config.json`),`UTF-8`));
+                // Read
+                const json = configRead[module.name];
+                if (json == undefined) {
+                    throw new Error(`NO JSON data found payment config ${module.name}`);
+                }
+                json.path = mainModulePath;
+                json.name = module.name;
+                setModule[module.name] = await require(startupPath)(program,json);
+            } catch (err) {
+                console.error(`Error Setting Module Data`,module.name);
+                console.error(err);
+            }
+        }
+        
+        // Put in program modules
+        //program.modules.request = setModule;
+        
+        // Here we can do whatever like grab modules for generator and represent them here
+        return setModule;
+    }
+}

package/modules/payment/providers/mollie/startup.js

@@ -0,0 +1,130 @@
+module.exports = async function(program,json) {
+    console.log(`Pocess Startup`);
+    // Process startup for mollie
+    if (!json.active) {
+        return false;
+    }
+
+    if (json.url[json.url.length-1] == `/`) {
+        json.url = json.url.slice(0, -1)
+    }
+
+    // When active startup process by indexing functions
+    const functionPath = program.path.join(json.path,`functions`);
+    console.log(`Function Path`);
+    let restArray = {
+        get : async function(url,params) {
+            console.log(`GET`);
+
+            // Process params for url
+            let count = 0;
+            for (let param in params) {
+                console.log(`Param ${param}`);
+                if (count == 0) {
+                    url += `?`;
+                } else {
+                    url += `&`
+                }
+                url += `${param}=${params[param]}`;
+                count++;
+            }
+
+            const data = await program.modules.request.get(program, url, undefined, {
+                'Authorization': `Bearer ${json.key}`
+            })
+
+            return data;
+        },
+        post : async function(url,params) {
+            console.log(`POST`);
+
+        }
+    }
+
+    // Start sync
+    //https://api.frankfurter.app/latest?to=EUR%2CUSD
+    restArray.currencySync = async function() {
+        const data = await program.modules.request.get(program, `https://api.frankfurter.app/latest`);
+        // process
+        console.log(`Process Data`);
+        data.ts = Date.now();
+        program.tmp.currency = data;
+    }
+    restArray.int = setInterval(function(){
+        console.log(`Set INterval`);
+        restArray.currencySync();
+        console.log(Date.now(),program.tmp.currency);
+    },14 * 60 * 1000)
+    
+    // Sync Onces
+    await restArray.currencySync();
+
+    // In init we want to do the get request
+    const getURL = `${json.url}/v2/methods/all`
+    const requestUSD = await restArray.get(getURL,{
+        locale : "en_US",
+        'amount[value]'  :  "100.00",
+        'amount[currency]'  :  "USD"
+    })
+
+    const requestEU = await restArray.get(getURL,{
+        locale : "en_US",
+        'amount[value]'  :  "100.00",
+        'amount[currency]'  :  "EUR"
+    })
+
+    // Process both
+    // Check who bigger then other
+    let mainLoop;
+    let subLoop;
+    if (requestEU.count > requestUSD.count) {
+        mainLoop = requestEU._embedded.methods;
+        subLoop = requestUSD._embedded.methods;
+    } else {
+        mainLoop = requestUSD._embedded.methods;
+        subLoop = requestEU._embedded.methods;
+    }
+
+    // Make paymentArray 
+    let payar = {}
+
+    // Set to arrays
+    // Loop Through main
+    const loopthrough = [mainLoop,subLoop];
+    for (let l in loopthrough) {
+        let currentLoop = loopthrough[l];
+        for (let nm in currentLoop) {
+            const itemData = currentLoop[nm];
+
+            // Set data
+            if (itemData.status == undefined) {
+                continue;
+            }
+            if (payar[itemData.id] == undefined) {
+                payar[itemData.id] = {
+                    desc : itemData.description,
+                    status : itemData.status,
+                    res : itemData.resource,
+                    images : itemData.image,
+                    currency : {}
+                }
+            }
+
+            // Now grab currency
+            const currency = {
+                max : itemData.maximumAmount.value,
+                min : itemData.minimumAmount.value
+            };
+
+            if (payar[itemData.id].currency[itemData.minimumAmount.currency] == undefined) {
+                payar[itemData.id].currency[itemData.minimumAmount.currency] = currency;
+            } else {
+                console.error(`Currency already set`);
+            }
+        }
+    }
+
+    restArray.methods = payar;
+
+    return restArray;
+}

package/modules/request/functions/get.js

@@ -15,6 +15,10 @@ module.exports = async function(program, url, body,headers) {
           body: JSON.stringify(body),
       };
 
+      if (body == undefined) {
+        delete theOptions.body;
+      }
+
       // Using standard fetch function
       const response = await fetch(url, theOptions);
         // Get response body
@@ -24,7 +28,7 @@ module.exports = async function(program, url, body,headers) {
         const respHeaders = response.headers;
 
       if (!response.ok) {
-          throw new Error(`HTTP error! Status: ${response.status}`);
+          throw new Error(respBody);
       }
 
       const responseData = respBody;
@@ -33,7 +37,7 @@ module.exports = async function(program, url, body,headers) {
       // Return response data or true to indicate success
       return responseData || true;
   } catch (err) {
-      console.error('Error in post:', err.message);
+      console.error('Error in get:', err.message);
       return false;
   }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.1.85",
+  "version": "0.1.87",
   "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {
@@ -35,7 +35,13 @@
     "model",
     "mini app",
     "webflow",
-    "lowcode"
+    "lowcode",
+    "mollie",
+    "payment",
+    "ideal",
+    "creditcard",
+    "applepay",
+    "googlepay"
   ],
   "author": "Kai Gartner",
   "license": "ISC",