webfast 0.1.51 → 0.1.54

package/app/content/js/webfast.js

@@ -127,8 +127,52 @@ web.fast.connectWebSocket = function(socketURL,maxRetries = 40, retries = 0) {
         };
 
         ws.onmessage = (event) => {
-            //console.log('Received:', event.data);
+            console.log('Received:', event.data);
             // Handle received data
+            // Check if type user then we will walk through the data to set the data for the user
+            const json = JSON.parse(event.data);
+            if (json.type == `user`) {
+                // We have user data
+                console.log(`Set User Data`);
+                // Now go Through to set all data
+                // Get all webfast client
+                jQuery(`[webfast-client]`).each(function(){
+                    // Get type
+                    const clientType = jQuery(this).attr(`webfast-client`);
+                    console.log(`Client Type`);
+                    // Check split
+                    const split = clientType.replace(/ /g,``).split(`||`);
+
+                    // set check
+                    let setted = false;
+                    for (let s in split) {
+                        // Get value
+                        let getValue = split[s];
+                        // Get value from json.data
+                        if (json.data[getValue] != undefined && setted == false) {
+                            const toSetValue = json.data[getValue];
+                            console.log(`Set Value`,toSetValue);
+                            jQuery(this).html(toSetValue)
+                            setted = true;
+                        }
+                    }
+                })
+
+                if (json.data.images != undefined) {
+                    console.log(`Set Images`,json.data.images);
+                    const oneImage = json.data.images[json.data.images.length-1];
+                    console.log(oneImage);
+                    jQuery(`[webfast-client="image"]`).each(function(){
+                        console.log(`Setted`);
+                        jQuery(this).css({
+                            'background-image': `url(${oneImage})`,
+                            'background-size': 'cover',
+                            'background-position': 'center'
+                        });
+                    });
+                }
+            }
+
             web.fast.que.state = Date.now();
             web.fast.receive(`socket`,event.data); // Placeholder for processing response
         };

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

@@ -62,7 +62,7 @@ module.exports = {
     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' });
+            const { stdout, stderr } = await program.exec(`${program.set.wget} -O - "${photoURL}"`, { encoding: 'buffer' });
     
             // Check if the download was successful
             const errBuf = Buffer.from(stderr);

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

@@ -14,7 +14,7 @@ module.exports = {
         try {
             await client.connect();
             const db = client.db('eventgo');
-            const collection = db.collection(collectionName);
+            const collection = await db.collection(collectionName);
     
             // Check if the field is an array in the existing document
             const existingDocument = await collection.findOne(search);
@@ -22,17 +22,16 @@ module.exports = {
     
             if (isFieldArray) {
                 // Field is an array, push the data
-                await collection.updateOne({}, { $addToSet: { [fieldName]: { $each: data } } });
+                await collection.updateOne(search, { $addToSet: { [fieldName]: { $each: data } } });
             } else {
                 // Field is not an array, save the array
-                await collection.updateOne({}, { $set: { [fieldName]: data } }, { upsert: true });
+                await collection.updateOne(search, { $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/data/mongo/file.js

@@ -32,29 +32,51 @@ module.exports = {
     },
 
     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 });
+        try {
+            await client.connect();
+            const db = client.db(dbName);
+    
+            // Find all files with the given filename
+            const filesCollection = db.collection('fs.files');
+            const files = await filesCollection.find({ filename: filename }).toArray();
+    
+            // If no files found, return null
+            if (files.length === 0) {
+                return null;
+            }
+    
+            // Initialize an array to store download promises
+            const downloadPromises = [];
+    
+            // Loop through each file and download it
+            files.forEach(file => {
+                const bucket = new GridFSBucket(db);
+                const downloadStream = bucket.openDownloadStreamByName(filename);
+                downloadPromises.push(new Promise((resolve, reject) => {
+                    const chunks = [];
+                    downloadStream.on('data', (chunk) => {
+                        chunks.push(chunk);
+                    });
+                    downloadStream.on('end', () => {
+                        const buffer = Buffer.concat(chunks);
+                        const metadata = downloadStream.s.file.metadata;
+                        resolve({ buffer, metadata });
+                    });
+                    downloadStream.on('error', reject);
+                }));
             });
-
-            downloadStream.on('error', reject);
-        });
+    
+            // Wait for all download promises to resolve
+            const results = await Promise.all(downloadPromises);
+    
+            return results;
+        } catch (error) {
+            console.error('Error downloading file:', error);
+            throw error;
+        } finally {
+            // Close the MongoDB connection
+            await client.close();
+        }
     }
+    
 };

package/modules/data/mongo/find.js

@@ -1,11 +1,25 @@
 const { MongoClient } = require('mongodb');
-module.exports = function(db,collection) {
+module.exports = async function(db,collection,query,one = false,array) {
     // Ensure the MongoDB connection string is provided
+    const program = array.program;
+    let callback;
+    if (array.function != undefined) {
+        callback = array.function;
+    }
     if (!process.env.mongo) {
         console.error('MongoDB connection string not provided. Set process.env.mongo.');
         process.exit(1);
     }
 
+    function routeExists(path) {
+        return program.express.app._router.stack.some(layer => {
+            if (layer.route) {
+                return layer.route.path === path;
+            }
+            return false;
+        });
+    }
+
     // Define the MongoDB URI
     const uri = process.env.mongo;
 
@@ -14,11 +28,10 @@ module.exports = function(db,collection) {
     const collectionName = collection;
 
     // Define the query you want to perform
-    const query = { /* Your query goes here */ };
 
     async function main() {
     // Create a new MongoClient
-    const client = new MongoClient(uri);
+    const client = await new MongoClient(uri);
 
     try {
         // Connect to the MongoDB server
@@ -26,17 +39,88 @@ module.exports = function(db,collection) {
         console.log('Connected to the MongoDB server');
 
         // Select the database
-        const database = client.db(dbName);
+        const database = await client.db(dbName);
 
         // Select the collection
-        const collection = database.collection(collectionName);
+        const collection = await database.collection(collectionName);
 
         // Perform the find query
-        const result = await collection.find(query).toArray();
+        result = await collection.find(query).toArray();
 
+        if (one == true) {
+            result = result[0];
+        }
         // Process the result
         console.log('Query result:', result);
-        return result;
+
+        // Check if profile image to get it from db
+        if (result.profileImage != undefined && array.image == true) {
+            const profileImage = await program.modules.data.file.downloadBuffer(result.profileImage,`eventgo`);
+
+            // Set in dynamic routing for serving
+            let sizeMeta = {};
+            let other = {}
+            for (let pi in profileImage) {
+                // Profile image
+                const theImage = profileImage[pi];
+
+                // Get the meta
+                const imageMeta = theImage.metadata;
+
+                // Sizes
+                const size = imageMeta.size;
+
+                const sizeKey = `${size.width}x${size.height}`;
+                const setUUID = program.uuid.v4();
+                sizeMeta[setUUID] = {
+                    buffer : theImage.buffer,
+                    meta : imageMeta
+                }
+                console.log(`The Size Meta`);
+            }
+
+            // Now we have sizes thingy so create a route for this specific uuid
+            const dynamicLink = `/dynamic/${result.profileImage}/list`;
+            result.imageList = `${process.env.url}${dynamicLink.slice(1)}`;
+            result.images = sizeMeta;
+
+            const routeCheck = await routeExists(dynamicLink);
+            if (!routeCheck) {
+                program.express.app.get(dynamicLink, async (req, res) => {
+                    // Requesting image
+                    console.log(`Requesting dynamic link`);
+                    // Send buffer image as image
+                    // Set content type header to indicate that you're sending an image
+                    res.setHeader('Content-Type', 'application/json');
+
+                    // Send the image buffer as the response body
+                    for (let sizeKey in sizeMeta) {
+                        const item = sizeMeta[sizeKey];
+                        other[sizeKey] = item.meta;
+
+                        // Create dynamic url for this on
+                        const imageDynamicPath = `/dynamic/${sizeKey}.${item.meta.type}`;
+                        const imageLinkURL = `https://${process.env.url}${imageDynamicPath.slice(1)}`
+                        //other[sizeKey].link = imageLinkURL;
+
+                        // generate dynamic url
+                        
+                    }
+                    
+                    res.send(JSON.stringify(other, null, 2));
+                });
+            }
+            console.log(`Profile Image`);
+
+            // generate paths
+        }
+
+        if (callback != undefined) {
+            
+            callback(program,result);
+        } else {
+            return result;
+        }
     } finally {
         // Close the MongoClient
         await client.close();
@@ -45,6 +129,6 @@ module.exports = function(db,collection) {
     }
 
     // Execute the main function
-    main().catch(console.error);
+    await main().catch(console.error);
 
 }

package/modules/express/init.js

@@ -224,7 +224,7 @@ module.exports = async function (program) {
   const wss = new WebSocket.Server({ port: PORT });
 
  
-  wss.on('connection', (ws, req) => {
+  wss.on('connection', async (ws, req) => {
     console.log(`Socket Connected`);
 
     // Generate a unique ID for the WebSocket connection
@@ -283,13 +283,75 @@ module.exports = async function (program) {
         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 }));
+    let getUser;
+    if (parsedQuery.user != undefined) {
+        // Get user
+        const userJSON = JSON.parse(JSON.parse(parsedQuery.user));
+        getUser = await program.modules.data.find(`eventgo`,`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;
+            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(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.1.51",
+  "version": "0.1.54",
   "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {