webfast 0.1.31 → 0.1.32

package/example.js

@@ -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

@@ -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

@@ -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/set.js

@@ -0,0 +1,38 @@
+const { MongoClient } = require('mongodb');
+const uri = process.env.mongo;
+const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });
+
+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

@@ -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;
@@ -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

@@ -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, { useNewUrlParser: true, useUnifiedTopology: true });
+
+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

@@ -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

@@ -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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "webfast",
-  "version": "0.1.31",
-  "description": "WebFast! Bot Application, including TON mini-apps",
+  "version": "0.1.32",
+  "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {
     "type": "git",
@@ -44,6 +44,7 @@
     "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",