webfast 0.1.87 → 0.1.88

package/app/content/js/webfast.js

@@ -5,14 +5,64 @@ 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) {
+    getCookieValue : function(cookieName) {
+        let allCookies = document.cookie;
+        let cookies = document.cookie.split("; ");
+        for (let i = 0; i < cookies.length; i++) {
+            let cookie = cookies[i].split("=");
+            if (cookie[0] === cookieName) {
+            return decodeURIComponent(cookie[1]);
+            }
+        }
+        return null; // Cookie not found
+    },
+    redirect :async function(data) {
+        console.log(`Received Redirect`,data.event);
+        const state = data.event.type;
+        if (state == true && web.fast.redirected == undefined) {
             // Redirect
-            window.location.replace(event.url);
+            console.log(`Replace to : `, data.event.url);
+            web.fast.redirected = Date.now();
+            
+            let replacedURL = data.event.url.replace(`https://`,``);
+            if (data.event.full == true) {
+                replacedURL = data.event.url;
+
+            }
+            // check if new hash
+            const sendData = telegram.initData.replace(`__order`,``)
+            
+            const id = data.event.requestID;
+            if (web.fast.user != undefined && jQuery(`[wbfst-frame="${id}"]`).length == 0 && data.event.full != true) {
+                //const myUrl = new URL(data.event.url);
+                //history.pushState({}, null, myUrl); // Update the URL without reloading the page
+                //window.location.hash = window.location.hash.replace(`__order`,``);
+                window.Telegram.WebView.onEvent(`back_button_pressed`, function(event){
+                    console.log(`Back Button Event Pressed`,event);
+                    const frame = jQuery(`[wbfst-frame="${id}"]`);
+                    jQuery(frame).animate({ opacity:0 }, 600,function(){
+                        jQuery(this).remove();
+                    });
+                    window.Telegram.WebApp.BackButton.hide();
+                })
+                await web.fast.telegram(`frame`).set(id,replacedURL,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();
+                    });
+                    
+                });
+            }else if (data.event.full == true && web.fast.user != undefined) {
+                // typeof order.state
+                window.Telegram.WebApp.disableClosingConfirmation(false);
+                window.Telegram.WebApp.close();
+            } else {
+                window.location.replace(data.event.url);
+            }
         } else {
-            console.error(`Something wrong redirect`,event);
+            //console.error(`Something wrong redirect`,data.event);
         }
     },
     functions : {
@@ -182,11 +232,18 @@ if (webfastSocket == undefined) {
 }
 
 let setData;
+// Split hash
+const locSplit = window.location.hash.split(`__`);
+
+//alert(locSplit);
 if (telegram.initData == ``) {
     setData = `hybrid.institute.anonymous`
+} else if (locSplit.length > 1 && locSplit[1] == `redirected`) {
+    setData = telegram.initData.replace(`__order&`,`&`);
 } else {
     setData = telegram.initData;
 }
+//alert(setData);
 
 const socketURL = `wss://${webfastSocket.replace(`https://`,``)}socket.io/?qbt=${setData}`;
 

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

@@ -1,4 +1,4 @@
-module.exports = async function(program,message,id,buttons) {
+module.exports = async function(program,message,id,buttons,messageID) {
     console.log(`Telegram Send`);
     // Create Request for send
     let telegramURL = `https://api.telegram.org/bot${process.env.telegram}`;
@@ -20,7 +20,7 @@ module.exports = async function(program,message,id,buttons) {
     }
 
 
-    const body = {
+    let body = {
         text: message,
         disable_web_page_preview: false,
         disable_notification: false,
@@ -30,7 +30,7 @@ module.exports = async function(program,message,id,buttons) {
     }
 
     // Check if object
-    if (typeof message == `object`) {
+    if (typeof message == `object` && messageID == undefined) {
         if (message.text != undefined && message.image == undefined) {
             body.text = message.text;
             telegramURL = `${telegramURL}/sendMessage`;
@@ -44,6 +44,14 @@ module.exports = async function(program,message,id,buttons) {
             delete body.reply_to_message_id;
             telegramURL = `${telegramURL}/sendPhoto`;
         }
+    } else if (messageID != undefined) {
+        body = {
+            chat_id : id,
+            message_id : messageID,
+            text : message,
+            parse_mode : `HTML`
+        }
+        telegramURL = `${telegramURL}/editMessageText`;
     } else {
         telegramURL = `${telegramURL}/sendMessage`;
     }

package/modules/express/init.js

@@ -365,15 +365,20 @@ wss.on('connection', async (ws, req) => {
     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) {
-            // Error for params
-            console.error(`Error for program params start_param`);
+        if (startSplit.length <= 1) {
+            console.log(`Start split is one`);
+        } else {
+            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) {
+                // Error for params
+                console.error(`Error for program params start_param`);
+            }
         }
     }
 
@@ -409,7 +414,7 @@ wss.on('connection', async (ws, req) => {
             // 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);
+                    let resp = await program.express.process[split[0]][split[1]][split[2]](program,ws,json,data,path,clientId,ws,parsedQuery);
                     if (resp != false) {
                         ws.send(JSON.stringify(resp));
                     }

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

@@ -0,0 +1,132 @@
+module.exports = async function(program,json) {
+    console.log(`Init Create with json data`);
+    return async function(program,order,payment,price,currency) {
+        console.log(`Create Payment`);
+        //const price = Number(order.price).toFixed(2);
+        // Get order info data
+        let pipeline = [
+            {
+              $match: {
+                uuid: order.package
+              }
+            }
+        ];
+        let package = await program.modules.data.aggregate(program,process.env.dbName, 'pricing', pipeline);
+        if (package.length == 0) {
+            throw new Error(`No Package found for payment`);
+        } else {
+            package = package[0];
+        }
+
+        // create redirect url
+        let webhookURL = program.modules.payment.mollie.webhookURL;
+        // create new payment uuid
+        const paymentUUID = program.uuid.v4();
+        
+        const redirectURL = webhookURL.replace(`:orderId`,paymentUUID).replace(`:action`,`redirect`);
+        const cancelURL = webhookURL.replace(`:orderId`,paymentUUID).replace(`:action`,`cancel`);
+        const pageRedirect = webhookURL.replace(`:orderId`,paymentUUID).replace(`:action`,`page-redirect`);
+        webhookURL =  webhookURL.replace(`:orderId`,paymentUUID).replace(`:action`,`update`);
+
+        const paramsArray = {
+            amount : {
+                currency : String(currency).toUpperCase(),
+                value : String(Number(price/100).toFixed(2))
+            },
+            description  :  `eSimCo. ${package.name.toUpperCase()}`,
+            redirectUrl : redirectURL,
+            cancelUrl : cancelURL,
+            webhookUrl : webhookURL,
+            locale : 'en_US',
+            method : payment.provider
+        }
+
+        // We have now method etc. let's build up the call
+        const getURL = `${json.url}/v2/payments`
+        const request = await program.modules.payment.mollie.post(program,getURL,paramsArray,{
+            'Authorization': `Bearer ${json.key}`,
+            'content-type': 'application/json'
+        })
+
+        // WE made request
+        request.uuid = paymentUUID;
+        request.package = order.package;
+        request.user = order.user;
+        request.order = order.uuid;
+
+        // Now save to request DB
+        const create = await program.modules.data.insert(process.env.dbName,`payment`,request);
+
+        // Now upate
+        let newState = order.state;
+        newState[`waiting`] = Date.now();
+
+        console.log(`Updated`);
+
+        console.log(`Made Request`,request);
+        
+        // Now send response
+        let redirect = {
+            type : true,
+            url : request._links.checkout.href,
+            requestID : program.uuid.v4(),
+            full : true
+        }
+
+        // Check url
+        redirect.url = pageRedirect;
+
+        // Send Payment info per bot and link for order
+        console.log(`Send Payment info link per bot`);
+        // create payment url 
+        const orderURL = `${process.env.webURL.slice(0,-1)}/concepts/esimco/order#${request.order}__redirect`;
+        // create order url redirect url
+        const paymentRedirect = `${process.env.url.slice(0,-1)}/webhooks/orders/${request.uuid}/bot-redirect`;
+
+        // Create message
+        let payIcon = `!`;
+        if (request.amount.currency.toUpperCase() == `USD`) {
+            payIcon = `$`;
+        }
+        if (request.amount.currency.toUpperCase() == `EUR`) {
+            payIcon = `€`;
+        }
+        const textMessage = `<b>⚠️ Your order is created but unpaid!</b>\n<span class="tg-spoiler">Order ID: <b>${request.order}</b></span>\n\nTo receive your order we would like to ask you to fullfill the payment for the remaining amount of <span class="tg-spoiler"><b>${payIcon} ${request.amount.value}</b></span>.\n\nClick on <u>Pay Now</u> to fullfill your payment or click <u>view order</u> to view your order.`
+        try {
+            let telegramSend = await program.modules.telegram.functions.send(program,textMessage,request.user,[
+                [
+                    //{ text: 'View Order',  web_app : { url : orderURL}},
+                    { text: 'Pay Order',  web_app : { url : paymentRedirect}}
+                ]
+            ]);
+
+            // Now we have message id set that to the order
+
+            // Add update to message order thingy
+
+            const updated =await program.modules.data.update(process.env.dbName,`order`,{
+                uuid : order.uuid
+            },{
+                $set: {
+                    state : newState,
+                    payment : paymentUUID,
+                    messages : [telegramSend.result.uuid]
+                }
+            });
+            console.log(`Telegram Send`);
+        } catch (err) {
+            console.error(err);
+            console.error(`Error with sending to client`);
+        }
+
+
+        const sendArray =  {
+            func : `redirect`,
+            data : {
+                event : redirect
+            },
+            js : `delete web.fast.tmp.sending;`
+        };
+        return sendArray;
+    }
+}

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

@@ -13,6 +13,7 @@ module.exports = async function(program,json) {
     const functionPath = program.path.join(json.path,`functions`);
     console.log(`Function Path`);
     let restArray = {
+        create : await require(program.path.join(__dirname,`create.js`))(program,json),
         get : async function(url,params) {
             console.log(`GET`);
 
@@ -35,9 +36,11 @@ module.exports = async function(program,json) {
 
             return data;
         },
-        post : async function(url,params) {
+        post : async function(program,url,body,headers) {
             console.log(`POST`);
-
+            
+            const requestPOST = await program.modules.request.post(program,url,body,headers);
+            return requestPOST;
         }
     }
 
@@ -64,13 +67,15 @@ module.exports = async function(program,json) {
     const requestUSD = await restArray.get(getURL,{
         locale : "en_US",
         'amount[value]'  :  "100.00",
-        'amount[currency]'  :  "USD"
+        'amount[currency]'  :  "USD",
+        "include"       :   "pricing"
     })
 
     const requestEU = await restArray.get(getURL,{
         locale : "en_US",
         'amount[value]'  :  "100.00",
-        'amount[currency]'  :  "EUR"
+        'amount[currency]'  :  "EUR",
+        "include"       :   "pricing"
     })
 
     // Process both
@@ -106,10 +111,78 @@ module.exports = async function(program,json) {
                     status : itemData.status,
                     res : itemData.resource,
                     images : itemData.image,
-                    currency : {}
+                    currency : {},
+                    pricing : {
+                        items : itemData.pricing
+                    }
                 }
             }
 
+            // Now loop through pricing to see max and min
+            let allPricing = [];
+
+            let maxPers = 0;
+            let minPers = 0;
+            let maxFix = 0;
+            let minFix = 0;
+            let pricingCurrency = [];
+            for (let prI in itemData.pricing) {
+                // get item
+                const pricing = itemData.pricing[prI];
+
+                let setPricing = {};
+
+                for (let key in pricing) {
+                    switch (key) {
+                        case `variable`:
+                            const thePerc = Number(pricing[key]);
+                            if (thePerc > maxPers) {
+                                maxPers = thePerc;
+                            }
+                            if (thePerc < minPers || minPers == 0) {
+                                minPers = thePerc;
+                            }
+                            setPricing.percentage = thePerc;
+                        break;
+                        case `fixed`:
+                            const fixPrice = Number(pricing[key].value);
+                            // Set fix price
+                            if (fixPrice > maxFix) {
+                                maxFix = fixPrice;
+                            }
+                            if (fixPrice < minFix || minFix == 0) {
+                                minFix = fixPrice;
+                            }
+                            pricing[key].value = Number(pricing[key].value);
+                            setPricing[key] = pricing[key];
+
+                            // check if in array
+                            if (pricingCurrency.indexOf(pricing[key].currency) == -1) {
+                                pricingCurrency.push(pricing[key].currency)
+                            }
+                        break;
+                        default:
+                            console.log(`Set Just: ${key}`);
+                            setPricing[key] = pricing[key];
+                    }
+                }
+                allPricing.push(setPricing);
+            }
+            console.log(`We have all pricing per item now`);
+            itemData.pricing = {
+                all : allPricing,
+                perc : {
+                    min : minPers,
+                    max : maxPers
+                },
+                fix : {
+                    min : minFix,
+                    max : maxFix
+                },
+                currencies : pricingCurrency
+            }
+            payar[itemData.id].pricing = itemData.pricing;
+
             // Now grab currency
             const currency = {
                 max : itemData.maximumAmount.value,
@@ -126,5 +199,162 @@ module.exports = async function(program,json) {
 
     restArray.methods = payar;
 
+    // Create dynamic app get for receiving data
+    const fullPath = `${process.env.url.slice(0,-1)}/webhooks/orders/:orderId/:action`;
+    // setup dynamic routing
+    restArray.webhookURL = fullPath;
+    async function functionRequest(req,res,type) {
+        const orderId = req.params.orderId;
+        const action = req.params.action;
+        console.log(`Received data for payment`,type);
+
+        // Get body Data
+        const body = req.body;
+
+        // First grab order
+        let pipeline = [
+            {
+                $match: {
+                uuid: orderId
+                }
+            }
+        ];
+
+        let payment = await program.modules.data.aggregate(program,process.env.dbName, 'payment', pipeline);
+        if (payment.length == 0) {
+            res.status(500);
+            res.send(`FALSE`);
+        } else {
+            payment = payment[0];
+        }
+
+        console.log(`We have payment data`);
+
+        // Check if cancel
+        let order = await program.modules.data.aggregate(program,process.env.dbName, 'order', [
+            {
+                $match: {
+                uuid: payment.order
+                }
+            }
+        ]);
+        order = order[0];
+
+        // We have order add action to state
+        const typeOf = typeof order.state;
+        if (typeOf != `object`) {
+            order.state = [];
+        }
+        order.state[action] = Date.now();
+
+
+        // Get id
+        if (type == `post`) {
+            const paymentID = body.id;
+
+            // Now check payment
+            const getURL = `${json.url}/v2/payments/${paymentID}`
+            const validate = await restArray.get(getURL);
+
+            // Okay we have new data
+            const status = validate.status;
+
+            order.state[status] = Date.now();
+
+            console.log(`To Validate Payment`);
+
+            // Add completed to state if finished
+            if (status == `paid`) {
+                const paidDate = new Date(validate.paidAt);
+                const unixTimestamp = Math.floor(paidDate.getTime() / 1000);
+                order.state[`completed`] = unixTimestamp;
+
+                // Update 
+                const updatedFinal =await program.modules.data.update(process.env.dbName,`order`,{
+                    uuid : orderId
+                },{
+                    $set: {
+                        payed : unixTimestamp,
+                        paymentDetails : validate.details,
+                        countryCode : validate.countryCode,
+                        mode : validate.mode,
+                        state : true,
+                        paid : Date.now()
+                    }
+                });
+                console.log(`Final Update`,updatedFinal);
+
+                // Check also for message now
+                // Grab message
+                try {
+                    const lastMessageId = order.messages[0];
+                    let messageData = await program.modules.data.aggregate(program,process.env.dbName, 'send', [{$match: {uuid: lastMessageId}}]);
+                    if (messageData.length == 0) {
+                        // No message send
+                        console.error(`No Message Send`);
+                    } else {
+                        messageData = messageData[0];
+                    }
+
+                    const packageID = order.package;
+                    
+                    let packageLine = [{$match: {uuid:packageID}},{$project: {name: 1,description: 1, price:1}}];
+                    let packageData = await program.modules.data.aggregate(program,process.env.dbName, 'pricing', packageLine);
+            
+                    // Okay we have message data
+                    const orderURL = `${process.env.webURL.slice(0,-1)}/concepts/esimco/order#${payment.uuid}__redirect`;
+                    const howToURL = `${process.env.webURL.slice(0,-1)}/concepts/esimco/order#${payment.uuid}__how-to`;
+                    const referralURL = `${process.env.webURL.slice(0,-1)}/concepts/esimco/order#${payment.uuid}__referral`;
+        
+                    const textMessage = `<b>✅ Your payment is received!</b>\n<span class="tg-spoiler">Order ID: <b>${order.uuid}</b></span>\n\nWe are now matching your order and payment. You will receive your ordered prodcut in a few minutes: <b>${String(packageData[0].description).toUpperCase()}</b>`
+                    try {
+                        let telegramSend = await program.modules.telegram.functions.send(program,textMessage,order.user,[
+                            [
+                                { text: 'View Order',  web_app : { url : orderURL}},
+                                { text: 'How to?',  web_app : { url : howToURL}},
+                                { text: 'Referral',  web_app : { url : referralURL}}
+                            ]
+                        ],messageData.message_id);
+
+                        console.log(`Sending telegram`);
+                    } catch(err) {
+                        console.error(err);
+                        console.error(`Error updating message`);
+                    }
+
+                } catch (err) {
+                    console.error(err);
+                    console.error(`Something with message`);
+                }
+            }
+        }
+
+
+        const updated =await program.modules.data.update(process.env.dbName,`order`,{
+            uuid : order.uuid
+        },{
+            $set: {
+                state : order.state
+            }
+        });
+
+        // Updated state in order
+        // Now redirect doesn't matter in what
+        const fullPath = `${process.env.webURL.slice(0,-1)}/concepts/esimco/order#${order.uuid}__redirect`;
+        if (type == `post`) {
+            res.send(`OK`);
+            res.status(200);
+        } else if (action == `page-redirect` || action == `bot-redirect`) {
+            res.redirect(payment._links.checkout.href)
+        } else {
+            res.redirect(fullPath);   
+        }
+    }
+    program.express.app.get(`/webhooks/orders/:orderId/:action`, async function(req,res){
+        return await functionRequest(req,res,`get`);
+    })
+    program.express.app.post(`/webhooks/orders/:orderId/:action`, async function(req,res){
+        return await functionRequest(req,res,`post`);
+    })
     return restArray;
 }

package/modules/request/functions/post.js

@@ -24,7 +24,17 @@ module.exports = async function(program, url, body,headers) {
         const respHeaders = response.headers;
 
       if (!response.ok) {
+        if (respBody.parameters != undefined) {
+          // Probably some wait 
+          if (respBody.parameters.retry_after != undefined) {
+            const timeOUtAmount = respBody.parameters.retry_after * 1000*60; // for 1 minute if retry_ is 1 minute
+            await setTimeout(async function(){
+              return await program.modules.request.post(program,url,body,headers);
+            },timeOUtAmount);
+          }
+        } else {
           throw new Error(`HTTP error! Status: ${response.status}`);
+        }
       }
 
       const responseData = respBody;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "webfast",
-  "version": "0.1.87",
+  "version": "0.1.88",
   "description": "WebFast! Bot Application, including TON mini-apps for makign it easy and fast to build ini-apps",
   "main": "index.js",
   "repository": {
@@ -41,7 +41,9 @@
     "ideal",
     "creditcard",
     "applepay",
-    "googlepay"
+    "googlepay",
+    "mollie pay",
+    "payments"
   ],
   "author": "Kai Gartner",
   "license": "ISC",