npm - webfast - Versions diffs - 0.1.31 → 0.1.35 - Mend

webfast 0.1.31 → 0.1.35

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/app/content/js/webfast.js +39 -1
package/ejs/collect/event.ejs +2 -2
package/ejs/view/list.ejs +6 -1
package/example.js +5 -0
package/index.js +31 -13
package/modules/bots/applications/telegram/get.js +124 -0
package/modules/bots/applications/telegram/middleware/message/photo.js +59 -0
package/modules/bots/applications/telegram/que.js +22 -1
package/modules/bots/applications/telegram/scripts/test/script.json +4 -2
package/modules/bots/applications/telegram/set.js +38 -0
package/modules/bots/applications/telegram.js +9 -4
package/modules/data/mongo/file.js +60 -0
package/modules/data/mongo/find.js +2 -2
package/modules/data/mongo/updateOrCreate.js +57 -0
package/modules/express/init.js +249 -142
package/modules/express/routes/view/list.get.js +3 -2
package/package.json +6 -3

package/app/content/js/webfast.js CHANGED Viewed

@@ -1,4 +1,42 @@
 console.log(`WebFast!`);
 window.WebFast = {
     ts : Date.now()
-}
+}
+// Connect to the Socket.IO server
+const telegram = window.Telegram.WebApp;
+// Step 1: Parse the query string
+if (webfastSocket == undefined) {
+    webfastSocket = window.location.host;
+}
+let setData;
+if (telegram.initData == ``) {
+    setData = `hybrid.institute.anonymous`
+} else {
+    setData = telegram.initData;
+}
+const socketURL = `wss://${webfastSocket.replace(`https://`,``)}socket.io/?qbt=${setData}`;
+try {
+    new WebSocket(socketURL,`test`,{
+        timeout : 0
+    });
+    // Start the other things
+    //alert(telegram.initData);
+} catch (err) {
+    alert(`Err`);
+    console.error(err);
+}
+// On Ready desable all forms with jquery
+jQuery(document).ready(function() {
+    jQuery('form').submit(function(e) {
+        e.preventDefault(); // Prevent the default form submission
+        // Check what to do like socketpath
+        alert(`Form Submit`);
+        return false;
+    });
+});

package/ejs/collect/event.ejs CHANGED Viewed

@@ -4,10 +4,10 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title><%= title %></title>
-    <script src="<%= url %>/app/content/js/jquery-3.7.1.min.js"></script>
+    <script src="<%= url %>app/content/js/jquery-3.7.1.min.js"></script>
     <script src="https://telegram.org/js/telegram-web-app.js"></script>
     <script src="https://unpkg.com/@tonconnect/ui@latest/dist/tonconnect-ui.min.js"></script>
-    <script src="<%= url %>/app/content/js/webfast.js"></script>
+    <script src="<%= url %>app/content/js/webfast.js"></script>
 </head>
 <body>

package/ejs/view/list.ejs CHANGED Viewed

@@ -3,7 +3,12 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title><%= title %></title>
+    <title><%= title %></title><!-- Include Socket.IO from CDN -->
+    <script src="https://cdn.socket.io/4.0.0/socket.io.min.js"></script>
+    <script src="<%= url %>app/content/js/jquery-3.7.1.min.js"></script>
+    <script src="https://telegram.org/js/telegram-web-app.js"></script>
+    <script src="https://unpkg.com/@tonconnect/ui@latest/dist/tonconnect-ui.min.js"></script>
+    <script src="<%= url %>app/content/js/webfast.js"></script>
 </head>
 <body>

package/example.js ADDED Viewed

@@ -0,0 +1,5 @@
+const path = require(`path`);
+let program = require(path.join(__dirname,`index.js`))({
+    wget : '/usr/local/bin/wget'
+});
+console.log(`Required`);

package/index.js CHANGED Viewed

@@ -1,7 +1,6 @@
 module.exports = function (array) {
     const { readdirSync } = require("fs");
-    // Need to walk through array for specific things
     console.log(`WebFast!! Program`);
     let program = {
         ts  :   Date.now(),
@@ -11,17 +10,18 @@ module.exports = function (array) {
     }
     for (let key in array) {
-        program.set[key] = array[key];
+        program.set[key]=array[key]
     }
     // Setup The Requirements
-    async function set(program) {
-        program.path = await require(`path`);
-        program.fs = await require(`fs`);
-        program.uuid = require(`uuid`);
-        program.fetch = require(`fetch`);
-        return program;
+    program.path = require(`path`);
+    program.fs = require(`fs`);
+    program.uuid = require(`uuid`);
+    program.fetch = require(`fetch`);
+    program.util = require(`util`);
+    program.exec = program.util.promisify(require('child_process').exec);
+    program.image = {
+        size : require('image-size')
     }
     // Program Fetch
@@ -127,11 +127,8 @@ module.exports = function (array) {
         }
     }
-    program.modules.fetch = async function(folder,program,fetch) {
+    program.modules.fetch = async function(folder,program) {
         // TO Fetch folder modules
-        if (fetch == undefined) {
-            program = await set(program);
-        }
         try {
             // Loop through folder and run module if js
             const readPath = program.path.join(__dirname,folder);
@@ -252,5 +249,26 @@ module.exports = function (array) {
     // Run program fetch
     program.modules.fetch(`modules`,program);
+    // Check if program.set.path is set
+    if (program.set.path != undefined) {
+        // We have the path for normal path so check for the folder app
+        try {
+            const appFolder = program.path.join(program.set.path,`app`,`init.js`);
+            // Now include this appFolder // set app
+            program.app = require(appFolder)(program);
+            console.log(`Include App`);
+        } catch (err) {
+            console.error(err);
+            console.error(`Error with program set folder`);
+        }
+    }
     return program;
+}
+// to cut the log
+if (process.env.log == undefined) {
+    console.log = function() {
+    }
 }

package/modules/bots/applications/telegram/get.js ADDED Viewed

@@ -0,0 +1,124 @@
+module.exports = {
+    UserProfilePhotos : async function(program,user,callback) {
+        console.log(`Get User Profile Photos`);
+        // Save user photo when first time
+        // Create call
+        const userPhotos = await program.modules.telegram.functions.get.request(`getUserProfilePhotos`,{
+            user_id : user.id
+        },program,callback);
+        console.log(`The User Photo`);
+        // convert base64 and save to database
+        const uuid = program.uuid.v4();
+        for (let userI in userPhotos.result.photos) {
+            // Make request for file
+            let profilePictures = userPhotos.result.photos[userI]
+            // Telegram will give back an array
+            for (let profileI in profilePictures) {
+                const profilePictureData = profilePictures[profileI];
+                const fileID = profilePictureData.file_id;
+                const fileUnique = profilePictureData.file_unique_id;
+                try {
+                    const userPhotoURL = await program.modules.telegram.functions.get.file(program,fileID);
+                    // create url
+                    const photoURL = `https://api.telegram.org/file/bot${process.env.telegram}/${userPhotoURL.result.file_path}`;;
+                    // Now do the fetch process thingy
+                    await program.modules.telegram.functions.get.downloadAndConvertToBase64(program,photoURL,async function(program,response){
+                        console.log(`We have now file data`);
+                        // Create id for file that is unique uuid
+                        const meta = {
+                            user : response.data.user.id,
+                            type : response.imageData.type,
+                            size : {
+                                width : response.imageData.width,
+                                height : response.imageData.height
+                            }
+                        }
+                        await program.modules.data.file.uploadBuffer(program,response.buffer,uuid,meta,async function(progam,upload,meta){
+                            console.log(`Uploaded Buffer`);
+                            // Save to membe
+                            await program.modules.telegram.functions.set.profilePhoto(progam,upload,meta);
+                        });
+                    },{
+                        user : user,
+                        data : profilePictureData
+                    });
+                } catch (err) {
+                    console.error(`Error For Downloading file`);
+                }
+            }
+        }
+    },
+    file : async function(program,fileID,callback) {
+        // TO get the file from telegram
+        const getFile = await program.modules.telegram.functions.get.request(`getFile`,{
+            file_id : fileID
+        },program,callback);
+        return getFile;
+    },
+    downloadAndConvertToBase64 : async (program, photoURL, callback,data) => {
+        try {
+            // Use wget to download the image
+            const { stdout, stderr } = await program.exec(`${program.set.wget} -O - ${photoURL}`, { encoding: 'buffer' });
+            // Check if the download was successful
+            const errBuf = Buffer.from(stderr);
+            const errorText = errBuf.toString('utf-8');
+            // Check if the errorText contains "200 OK"
+            if (errorText.includes('200 OK')) {
+                // The request was successful
+                console.log('Download successful');
+            } else {
+                // The request encountered an error
+                console.error('Download failed:', errorText);
+                throw new Error(`Failed to download image. Error: ${stderr}`);
+            }
+            // Convert the downloaded buffer to base64
+            const buffer = Buffer.from(stdout);
+            const base64 = buffer.toString('base64');
+            // Determine the MIME type and dimensions of the image
+            const dimensions = program.image.size(buffer);
+            const { width, height, type } = dimensions;
+            // Log the details
+            console.log('MIME Type:', type);
+            console.log('Dimensions:', `${width}x${height}`);
+            // Now you can use the base64 encoded string
+            //console.log('Base64:', base64);
+            // Call the callback with the result
+            callback(program,{
+                base: base64,
+                imageData: dimensions,
+                type: type,
+                data : data,
+                buffer : buffer
+            });
+            return true;
+        } catch (error) {
+            console.error('Error:', error.message);
+            return false;
+        }
+    },
+    request : async function(path, body,program,callback) {
+        // Make request with url
+        console.log(`Make Telegram Get Request`);
+        let respData = {}
+        const url = `https://api.telegram.org/bot${process.env.telegram}/${path}`;
+        // We have url make request
+        respData = await program.modules.request.post(program,url,body)
+        if (callback != undefined) {
+            return callback(madeRequest);
+        } else {
+            return respData;
+        }
+    }
+}

package/modules/bots/applications/telegram/middleware/message/photo.js ADDED Viewed

@@ -0,0 +1,59 @@
+module.exports = async function(program,req,res,body,params,command,middleValue) {
+    console.log(`Location Telegram Function`);
+    // We have the start function
+    let locSendMessage = false;
+    // Now get the photos and save them in db files
+    // loop through photos
+    const user = middleValue.from.id;
+    const uuid = program.uuid.v4();
+    for (let photoI in middleValue.photo) {
+        let photo = middleValue.photo[photoI];
+        // photo url user
+        const userPhotoURL = await program.modules.telegram.functions.get.file(program,photo.file_id);
+        console.log(userPhotoURL);
+         // create url
+         const photoURL = `https://api.telegram.org/file/bot${process.env.telegram}/${userPhotoURL.result.file_path}`;;
+         //res.status(200);
+         // Now do the fetch process thingy
+         await program.modules.telegram.functions.get.downloadAndConvertToBase64(program,photoURL,async function(program,response){
+             console.log(`We have now file data`);
+             // Create id for file that is unique uuid
+             const meta = {
+                 user : response.data.user,
+                 type : response.imageData.type,
+                 size : {
+                     width : response.imageData.width,
+                     height : response.imageData.height
+                 }
+             }
+             await program.modules.data.file.uploadBuffer(program,response.buffer,uuid,meta,async function(progam,upload,meta){
+                 console.log(`Uploaded Buffer`);
+                 // Save to membe
+                 // Now we have received so we can add marker to the receive message
+             });
+         },{
+             user : user,
+             data : middleValue
+         });
+    }
+    res.status(200);
+    locSendMessage = `Image succesfull received`;
+    const scripting = await program.modules.telegram.script.function.check(program,command,middleValue.chat.id,middleValue,body);
+    console.log(scripting);
+    // Send back
+    return {
+        message : locSendMessage,
+        response : {
+            message : locSendMessage,
+            uuid : uuid
+        }
+    }
+}

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

@@ -76,7 +76,27 @@ module.exports = {
                         }
                     }
                 } else {
-                    console.error(`Need to set anwser data`);
+                    // Check if something with type:
+                    for (let li in question.match.data) {
+                        let matchCheck = question.match.data[li];
+                        if (typeof matchCheck.anwser == `object`) {
+                            // Grab type if it's there
+                            switch (matchCheck.anwser.type) {
+                                case command:
+                                    console.log(`It's the dynamic thing`);
+                                    matched = matchCheck;
+                                    let variable = data.message[command]
+                                    anwserData = {
+                                        type : command,
+                                        data : variable
+                                    };
+                                break;
+                                default:
+                                    console.log(`No matching type found`);
+                            }
+                        }
+                    }
                 }
                 // End of match process fo matched checking
@@ -132,6 +152,7 @@ module.exports = {
             // Create replacelist
             let replace = {
                 "{{URL}}"   :   process.env.url,
+                "{{WEBURL}}"   :   process.env.webURL,
                 "{{TEST}}"  :   "TEST REPLACED"
             }

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

@@ -15,7 +15,9 @@
                 "function"  :   "program.modules.bots.scripts.function.response",
                 "next"      :   "nextFunc"
             },{
-                "anwser"  :   "hi",
+                "anwser"  :   {
+                    "type" : "photo"
+                },
                 "function"  :   "program.modules.bots.scripts.function.response",
                 "next"      :   "nextFunc"
             }]
@@ -31,7 +33,7 @@
             "text" : "Testing Title : {{START}}",
             "buttons" : [
                 [
-                    { "text": "EventGO!",  "web_app" : { "url" : "{{URL}}events/list"}},
+                    { "text": "EventGO!",  "web_app" : { "url" : "{{WEBURL}}concepts/eventgo/events-list"}},
                     { "text": "Create Event", "callback_data": "create_event" }
                 ]
             ]

package/modules/bots/applications/telegram/set.js ADDED Viewed

@@ -0,0 +1,38 @@
+const { MongoClient } = require('mongodb');
+const uri = process.env.mongo;
+const client = new MongoClient(uri);
+module.exports = {
+    profilePhoto : async function(program,content,meta) {
+        console.log(`Set User Profile Pic`);
+        const added = await program.modules.telegram.functions.set.addToCollection(program,`telegram`, `profileImage`, meta.name,{
+            id : meta.user
+        });
+        console.log(`Added`);
+    },
+    addToCollection : async function (program,collectionName, fieldName, data,search) {
+        try {
+            await client.connect();
+            const db = client.db('eventgo');
+            const collection = db.collection(collectionName);
+            // Check if the field is an array in the existing document
+            const existingDocument = await collection.findOne(search);
+            const isFieldArray = Array.isArray(existingDocument[fieldName]);
+            if (isFieldArray) {
+                // Field is an array, push the data
+                await collection.updateOne({}, { $addToSet: { [fieldName]: { $each: data } } });
+            } else {
+                // Field is not an array, save the array
+                await collection.updateOne({}, { $set: { [fieldName]: data } }, { upsert: true });
+            }
+            console.log('Data added to the collection successfully.');
+        } catch (error) {
+            console.error('Error:', error.message);
+        } finally {
+            await client.close();
+        }
+    }
+}

package/modules/bots/applications/telegram.js CHANGED Viewed

@@ -48,8 +48,13 @@ module.exports = async function(program,folder) {
                             id : middleValue.chat.id
                         },middleValue.chat);
                         let typeOFF = typeof user;
-                        if (middleValue.chat.uuid == user.uuid) {
+                        if (middleValue.chat.uuid == user.uuid || user.profileImage == undefined) {
                             user.new = true;
+                            // do the process for downloading the users profile image
+                            console.log(`Process Image`);
+                            //getUserProfilePhotos
+                            program.modules.telegram.functions.get.UserProfilePhotos(program,user);
                         }
                         middleValue.chat.uuid = user.uuid;
@@ -202,7 +207,7 @@ module.exports = async function(program,folder) {
                         } catch (message) {
                             // Process as other
                             console.log(`Process Different`);
-                            let checkArray = [`location`];
+                            let checkArray = [`location`,`photo`];
                             // Loop through checkArray
                             for (let c in checkArray) {
                                 const command = checkArray[c];
@@ -210,7 +215,7 @@ module.exports = async function(program,folder) {
                                 if (indexCheck != -1) {
                                     console.log(`Run this as middleware`);
                                     try {
-                                        const runFunc   =   await program.modules.telegram.middleware[key][command](req,res,body,params,command,middleValue);
+                                        const runFunc   =   await program.modules.telegram.middleware[key][command](program,req,res,body,params,command,middleValue);
                                         const respFunc = runFunc;
                                         // PRocess response for object
                                         if (respFunc == undefined) {
@@ -351,7 +356,7 @@ module.exports = async function(program,folder) {
         int : {}
     }
     for (let scriptIndex in scriptsData) {
-        let script =  [scriptIndex];
+        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

package/modules/data/mongo/file.js ADDED Viewed

@@ -0,0 +1,60 @@
+const { MongoClient, GridFSBucket } = require('mongodb');
+const fs = require('fs');
+// Define the MongoDB URI
+const uri = process.env.mongo;
+const client = new MongoClient(uri);
+module.exports = {
+    uploadBuffer: async function (progam,buffer, filename, metadata = {}, callback) {
+        const dbName = 'eventgo';
+        await client.connect();
+        const db = client.db(dbName);
+        const bucket = new GridFSBucket(db);
+        const uploadStream = bucket.openUploadStream(filename, { metadata });
+        uploadStream.end(buffer); // Write the buffer directly to the upload stream
+        new Promise((resolve, reject) => {
+            uploadStream.on('finish', () => {
+                // Access the ObjectId assigned to the stored file
+                const fileId = uploadStream.id;
+                let objectID = resolve(fileId);
+                console.log(`File ID hing`);
+                metadata.name = filename;
+                callback(progam,uploadStream,metadata);
+            });
+            uploadStream.on('error', reject);
+        });
+    },
+    downloadBuffer: async function (filename, dbName = 'media') {
+        await client.connect();
+        const db = client.db(dbName);
+        const bucket = new GridFSBucket(db);
+        const downloadStream = bucket.openDownloadStreamByName(filename);
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            // Accumulate chunks as they arrive
+            downloadStream.on('data', (chunk) => {
+                chunks.push(chunk);
+            });
+            // Resolve with the concatenated buffer and metadata when the download is complete
+            downloadStream.on('end', () => {
+                const buffer = Buffer.concat(chunks);
+                const metadata = downloadStream.s.file.metadata;
+                resolve({ buffer, metadata });
+            });
+            downloadStream.on('error', reject);
+        });
+    }
+};

package/modules/data/mongo/find.js CHANGED Viewed

@@ -18,7 +18,7 @@ module.exports = function(db,collection) {
     async function main() {
     // Create a new MongoClient
-    const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
+    const client = new MongoClient(uri);
     try {
         // Connect to the MongoDB server
@@ -36,7 +36,7 @@ module.exports = function(db,collection) {
         // Process the result
         console.log('Query result:', result);
+        return result;
     } finally {
         // Close the MongoClient
         await client.close();

package/modules/data/mongo/updateOrCreate.js ADDED Viewed

@@ -0,0 +1,57 @@
+const { MongoClient } = require('mongodb');
+module.exports = async function (db, collection, condition, dataToUpdate) {
+    // 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;
+    async function main() {
+        // Create a new MongoClient
+        const client = new MongoClient(uri);
+        try {
+            // Connect to the MongoDB server
+            await client.connect();
+            console.log('Connected to the MongoDB server');
+            // Select the database
+            const database = client.db(dbName);
+            // Select the collection
+            const collection = database.collection(collectionName);
+            // Perform the update or create operation
+            const result = await collection.updateOne(condition, { $set: dataToUpdate }, { upsert: true });
+            // If a document was upserted, retrieve the upserted document
+            const upsertedDocument = result.upsertedId
+                ? await collection.findOne({ _id: result.upsertedId })
+                : null;
+            // Process the result
+            if (upsertedDocument) {
+                console.log('Document upserted:', upsertedDocument);
+                return upsertedDocument;
+            } else {
+                console.log('Document updated.');
+                return dataToUpdate;
+            }
+        } finally {
+            // Close the MongoClient
+            await client.close();
+            console.log('Connection closed.');
+        }
+    }
+    // Execute the main function
+    return main().catch(console.error);
+};

package/modules/express/init.js CHANGED Viewed

@@ -1,178 +1,285 @@
 module.exports = async function (program) {
-    console.log(`Starting UP Express`);
-    program.express = {
+  console.log(`Starting UP Express`);
+  program.express = {
       ts: Date.now(),
-    };
-    const express = require('express');
-    const cors = require('cors');
-    const bodyParser = require('body-parser');
-    const port = 1221;
-    const basePath = `/api`;
-    const app = express();
-    const corsOptions = {
+  };
+  const express = require('express');
+  const cors = require('cors');
+  const bodyParser = require('body-parser');
+  const WebSocket = require('ws');
+  const crypto = require(`crypto`)
+  const port = 1221;
+  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 {
+  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;
+          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;
               }
-            }
-          } else {
-            routeData.func = require(routeData.path);
-            exprs[routePath] = routeData;
+          } catch (err) {
+              console.error(`Error Route Func`, routePath);
+              console.error(err);
           }
-        } catch (err) {
-          console.error(`Error Route Func`, routePath);
-          console.error(err);
-        }
-        routeData.webwalk = 0;
+          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++;
+          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;
+                      // 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);
+                      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);
-            }
-          });
-          state = true;
-        } catch (err) {
-          console.error(err);
-          console.error(`Error Setting Up Route`);
-        }
-        exprs[route].state = state;
+              console.error(`Error Setting Up Route`);
+          }
+          exprs[route].state = state;
       }
       console.log(`Routes are set up successfully`);
-    } catch (err) {
+  } 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) => {
+  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
+          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 isMinified = /-min\.js$/.test(fileName);
-            if (isMinified) {
-                console.log(`${fileName} ends with -min.js`);
-                const toRequestFile = req.params.file.replace(`-min.js`,`.js`);
-                contentFolder = program.path.join(__dirname,`..`,`..`,`app`,`content`,req.params.type,toRequestFile);
-            } else {
-                console.log(`${fileName} does not end with -min.js`);
-            }
+  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;
-            res.sendFile(contentFolder);
-        } catch (err) {
-            console.error(err);
-            console.error(`Error Getting : ${req.params.type}`,req.params.file);
-        }
-    })
+          // Check if minify at the end
+          const fileName = req.params.file;
+          const isMinified = /-min\.js$/.test(fileName);
-    app.listen(port, () => {
+          if (isMinified) {
+              console.log(`${fileName} ends with -min.js`);
+              const toRequestFile = req.params.file.replace(`-min.js`, `.js`);
+              contentFolder = program.path.join(__dirname, `..`, `..`, `app`, `content`, req.params.type, toRequestFile);
+          } else {
+              console.log(`${fileName} does not end with -min.js`);
+          }
+          res.sendFile(contentFolder);
+      } catch (err) {
+          console.error(err);
+          console.error(`Error Getting : ${req.params.type}`, req.params.file);
+      }
+  })
+  app.listen(port, () => {
       console.log(`Server Listening`, port, basePath);
-    });
-    program.express.url = {
+  });
+  program.express.url = {
       adaptive: {
-        get: [],
-        post: [],
+          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.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;
-    return program;
   };
+  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', (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');
+    }
+    console.log(parsedQuery);
+    // Store the WebSocket connection with its ID in the map
+    clients.set(clientId, ws);
+    // Send the client ID to the connected client
+    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', (message) => {
+        console.log(`Received message from ${clientId}: ${message}`);
+        // 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) {
+                client.send(`Broadcast from ${clientId}: ${message}`);
+            }
+        });
+    });
+});
+  return program;
+};

package/modules/express/routes/view/list.get.js CHANGED Viewed

@@ -1,12 +1,13 @@
 module.exports = async function(program,req,res,route) {
     console.log(`Create`);
-    const fullPath = program.path.join(__dirname, `..`,`..`,`..`,`..`,`ejs`,`example`,`list.ejs`);
+    const fullPath = program.path.join(__dirname, `..`,`..`,`..`,`..`,`ejs`,`view`,`list.ejs`);
     // Render the EJS template
     res.render(fullPath, {
         title: 'EJS Example',
         name: 'John Doe',
         isAdmin: true,
-        fruits: ['Apple', 'Banana', 'Orange']
+        fruits: ['Apple', 'Banana', 'Orange'],
+        url : process.env.url
     });
 }

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "webfast",
-  "version": "0.1.31",
-  "description": "WebFast! Bot Application, including TON mini-apps",
+  "version": "0.1.35",
+  "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -39,15 +39,18 @@
   "dependencies": {
     "body-parser": "^1.20.2",
     "cors": "^2.8.5",
+    "crypto": "^1.0.1",
     "dotenv": "^16.0.3",
     "ejs": "^3.1.9",
     "express": "^4.18.2",
     "fetch": "^1.1.0",
     "fs": "^0.0.1-security",
+    "image-size": "^1.1.1",
     "js": "^0.1.0",
     "mongodb": "^6.3.0",
     "node-fetch": "^3.3.2",
     "path": "^0.12.7",
-    "uuid": "^9.0.1"
+    "uuid": "^9.0.1",
+    "ws": "^8.16.0"
   }
 }