webfast 0.1.86 → 0.1.88

package/modules/payment/init.js

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

package/modules/payment/providers/mollie/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

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

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

package/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.86",
+  "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": {
@@ -35,7 +35,15 @@
     "model",
     "mini app",
     "webflow",
-    "lowcode"
+    "lowcode",
+    "mollie",
+    "payment",
+    "ideal",
+    "creditcard",
+    "applepay",
+    "googlepay",
+    "mollie pay",
+    "payments"
   ],
   "author": "Kai Gartner",
   "license": "ISC",