@opengis/pay 1.3.3 → 2.0.0

package/server/plugins/payment/paymentInfo.js

@@ -0,0 +1,26 @@
+import config from '../../../config.js';
+import pgClients from '../pg/pgClients.js';
+
+const { table = 'pay.transactions' } = config.integrations?.pay || {};
+
+export default async function paymentInfo(id, pg = pgClients.client) {
+    if (!id) throw new Error('not enough params: id');
+
+    const {
+        amount,
+        status,
+        service,
+        referer_url: referer,
+        user_id: userId,
+    } = id && pg.pk?.[table] ? await pg.query(`select ${pg.pk?.[table]} as id, * from ${table} where ${pg.pk?.[table]}=$1`, [id])
+        .then(el => el.rows?.[0] || {}) : {};
+
+    return {
+        id, // id for existing transtaction
+        price: amount, // price for new transtaction as is, else - preCreated
+        status, // payment status
+        service, // service name
+        referer, // redirect user after finish of transaction
+        uid: userId,
+    };
+}

package/server/plugins/payment/portmone.checkStatus.js

@@ -0,0 +1,51 @@
+import request from 'request-promise';
+
+import config from '../../../config.js';
+import pgClients from '../pg/pgClients.js';
+
+const { table = 'pay.transactions' } = config.integrations?.pay || {};
+
+const {
+  host = 'https://www.portmone.com.ua',
+  login,
+  password,
+  payeeId,
+} = config.integrations?.portmone || {};
+
+export default async function portmoneCheckStatus(id, origin, pg = pgClients.client) {
+  if (!payeeId) throw new Error('empty integration params: payeeId');
+  if (!id) throw new Error('not enough params: id');
+
+  const data = pg.pk?.[table] && id ? await pg.query(`select ${pg.pk?.[table]} as id, * from ${table} where ${pg.pk?.[table]}=$1`, [id]).then(el => el.rows?.[0] || {}) : undefined;
+  if (!data?.id) throw new Error('transaction not found');
+
+  const formData = {
+    method: 'result',
+    login,
+    password,
+    payeeId,
+    shopOrderNumber: data.id,
+    // shopbillId,
+    id: data.id,
+  };
+
+  const isValidOrigin = origin && origin === host;
+
+  if (!(login && password) && !isValidOrigin) {
+    throw new Error('empty integration params: portmone 2');
+  }
+
+  // ? likely cause timeout, skip be origin check or check credentials i.e.: login, password
+  const response = isValidOrigin ? { billAmount: data.amount, status: 'success' } : await request({
+    url: `${host}/gateway/`,
+    method: 'POST',
+    formData,
+    followAllRedirects: false,
+    jar: true,
+    timeout: 6000,
+    simple: false, // prevent not 2xx code trigger catch
+    resolveWithFullResponse: true,
+  });
+
+  return { ...response, status: response.status, amount: +response.billAmount };
+}

package/server/plugins/payment/portmone.createTransaction.js

@@ -0,0 +1,94 @@
+import request from 'request-promise';
+
+import config from '../../../config.js';
+import pgClients from '../pg/pgClients.js';
+
+import createPayment from './createPayment.js';
+
+const { prefix = '/api' } = config;
+
+const { table = 'pay.transactions' } = config.integrations?.pay || {};
+const { host = 'https://www.portmone.com.ua', payeeId } = config.integrations?.portmone || {};
+
+export default async function portmoneCreateTransaction({
+    id, price, rootUrl, referer, uid, debug,
+}, pg = pgClients.client) {
+    if (!host) {
+        throw new Error('empty integration host');
+    }
+
+    if (!payeeId) {
+        throw new Error('empty integration payeeId');
+    }
+
+    if (!id && !price) {
+        throw new Error('not enough params: id or price required');
+    }
+
+    if (!rootUrl) {
+        throw new Error('not enough params: rootUrl required');
+    }
+
+    if (!uid) {
+        throw new Error('not enough params: uid required');
+    }
+
+    const paymentId = !id ? await pg.query('select next_id()').then(el => el.rows?.[0]?.next_id) : id;
+
+    const paymentData = id && pg.pk?.[table]
+        ? await pg.query(`select ${pg.pk?.[table]} as id, * from ${table} where ${pg.pk?.[table]}=$1`, [id]).then(el => el.rows?.[0])
+        : await createPayment({
+            paymentId,
+            price,
+            referer,
+            uid,
+            service: 'portmone',
+        });
+
+    if (!paymentData?.id) {
+        throw new Error('payment not found / creation failed');
+    }
+
+    const paymentAmount = id ? paymentData.amount : price;
+
+    if (!paymentAmount) {
+        throw new Error('invalid payment amount');
+    }
+
+    const formData = {
+        payee_id: payeeId,
+        description: `Послуга - поповнення рахунку на суму ${paymentAmount} грн`,
+        shop_order_number: paymentData.id,
+        bill_amount: paymentAmount,
+        success_url: `${rootUrl}${prefix}/portmone/${paymentData.id}/success`,
+        failure_url: `${rootUrl}${prefix}/portmone/${paymentData.id}/error`,
+        lang: 'ua',
+    };
+
+    // portmone always returns error without simple: false options
+    const response = await request({
+        url: `${host}/gateway/`,
+        method: 'POST',
+        formData,
+        followAllRedirects: false,
+        jar: true,
+        timeout: 6000,
+        simple: false, // prevent not 2xx code trigger catch
+        resolveWithFullResponse: true,
+    });
+
+    if (process.env.NODE_ENV !== 'test' && debug) {
+        return response;
+    }
+
+    // handle exceptions
+    if (response.statusCode !== 302 || !response.headers?.location) {
+        throw new Error(response);
+    }
+
+    if (process.env.NODE_ENV === 'test' && debug) {
+        return { id: paymentData?.id, url: response.headers.location };
+    }
+
+    return response.headers.location;
+}

package/server/plugins/payment/processTransaction.js

@@ -0,0 +1,73 @@
+import config from '../../../config.js';
+import pgClients from '../pg/pgClients.js';
+import dataUpdate from '../crud/dataUpdate.js';
+
+import liqpayCheckStatus from './liqpay.checkStatus.js';
+import monopayCheckStatus from './monopay.checkStatus.js';
+import portmoneCheckStatus from './portmone.checkStatus.js';
+
+const controller = {
+    liqpay: liqpayCheckStatus,
+    monopay: monopayCheckStatus,
+    portmone: portmoneCheckStatus,
+};
+
+const newDate = () => {
+    const date = new Date();
+    const tzOffset = date.getTimezoneOffset();
+    const currentTimeWithTimezome = date - tzOffset * 60 * 1000;
+    return new Date(currentTimeWithTimezome).toISOString();
+};
+
+const { table = 'pay.transactions' } = config.integrations?.liqpay || {};
+
+export default async function processTransaction(id, origin, pg = pgClients.client) {
+    if (!id) throw new Error('not enough params: id');
+
+    const {
+        id: paymentId, user_id: userId, status: trxStatus, service,
+    } = pg.pk?.[table] ? await pg.query(`select ${pg.pk?.[table]} as id, * from ${table} where ${pg.pk?.[table]}=$1`, [id]).then(el => el.rows?.[0] || {}) : {};
+
+    if (!paymentId) {
+        throw new Error('payment not found');
+    }
+
+    if (!service) throw new Error('invalid payment: service required');
+    if (!controller[service]) { throw new Error('invalid params: service'); }
+
+    if (trxStatus === 'success') {
+        throw new Error('Transaction was already processed');
+    }
+
+    const result = await controller[service](id, origin);
+
+    const { status = 'error', err_description: err } = result || {};
+
+    if (status !== 'success') {
+        throw new Error(err || 'Помилка перевірки статусу платежу');
+    }
+
+    const balance = await pg.query(`select balance from ${table} 
+        where user_id=$1
+        and status in ('success', 'error')
+        and balance is not null
+        order by created_at desc limit 1`, [userId]).then(el => el.rows?.[0]?.balance || 0);
+
+    const row = await dataUpdate({
+        table,
+        data: {
+            data: result,
+            status,
+            balance: +result.amount + +balance,
+            success_date: newDate(),
+        },
+        id,
+        uid: userId,
+    });
+
+    if (process.env.NODE_ENV === 'test') {
+        console.info(`id:${id}, status: ${result.status}, before: ${balance || 0}, sum: ${+result.amount}, after: ${+result.amount + +balance}`);
+    }
+
+    return { ...row, balance: +result.amount + +balance };
+}

package/server/routes/{portmone → core}/controllers/payment.info.js

@@ -1,7 +1,10 @@
+import config from '../../../../config.js';
 import pgClients from '../../../plugins/pg/pgClients.js';
 import dataUpdate from '../../../plugins/crud/dataUpdate.js';
 
-import liqpayCheckStatus from '../../liqpay/utils/check.status.js';
+import liqpayCheckStatus from '../../../plugins/payment/liqpay.checkStatus.js';
+import monopayCheckStatus from '../../../plugins/payment/monopay.checkStatus.js';
+import portmoneCheckStatus from '../../../plugins/payment/portmone.checkStatus.js';
 
 const newDate = (dateNum) => {
   const date = dateNum ? new Date(dateNum) : new Date();
@@ -10,6 +13,8 @@ const newDate = (dateNum) => {
   return new Date(currentTimeWithTimezome).toISOString();
 };
 
+const { table = 'pay.transactions' } = config.integrations?.pay || {};
+
 /**
  * Апі для отримання інформації за ID
  *
@@ -33,58 +38,56 @@ export default async function paymentInfo({
     return reply.status(400).send('not enough query params: id');
   }
 
-  const { rows = [] } = await pg.query(`select 
-    payment_id,
-    account_id,
-    payment_amount,
-    payment_status,
-    total_balance,
-    payment_num,
-    payment_service,
-    payment_data,
-    subscription_id
-  from billing.payments
-  where payment_id = $1
-  and   account_id in (select account_id from billing.account_user where user_id = $2)`, [params.id, user.uid]);
+  const { rows = [] } = await pg.query(
+    `select ${pg.pk?.[table]} as id, * from ${table} where ${pg.pk?.[table]} = $1 and user_id = $2`,
+    [params.id, user.uid],
+  );
 
   if (!rows.length) {
     return reply.status(404).send('payment not found');
   }
 
   const {
-    account_id: accountId,
-    payment_service: service,
-    payment_status: status,
+    user_id: userId,
+    service,
+    status,
   } = rows[0];
 
   if (status !== 'success' && service === 'liqpay') {
-    const result = await liqpayCheckStatus(params.id);
+    const result = await liqpayCheckStatus({ id: params.id });
     const { amount = 0 } = result;
 
-    const { total_balance: totalBalance = 0 } = await pg.query(`select total_balance from billing.payments 
-      where account_id=$1
-      and payment_status in ('success', 'error')
-      and total_balance is not null
-      order by cdate desc limit 1`, [accountId]).then(el => el.rows?.[0] || {});
+    const balance = await pg.query(`select balance from ${table} 
+      where user_id=$1
+      and status = 'success'
+      and balance is not null
+      order by created_at desc limit 1`, [userId]).then(el => el.rows?.[0]?.balance || 0);
 
     const res = await dataUpdate({
       pg,
-      table: 'billing.payments',
+      table,
       id: params.id,
       data: {
-        payment_data: result,
-        payment_status: 'success',
-        total_balance: +amount + +totalBalance,
+        data: result,
+        status: 'success',
+        balance: +amount + +balance,
         success_date: newDate(result.end_date),
       },
       uid: user?.uid,
     });
 
-    // const res1 = await metaFormat({ rows: [res].filter(el => el), cls: { account_id: 'billing.account_id', payment_status: 'billing.payment_status', subscription_id: 'billing.subscription_id' } });
     return res;
   }
 
-  // await metaFormat({ rows, cls: { account_id: 'billing.account_id', payment_status: 'billing.payment_status', subscription_id: 'billing.subscription_id' } });
+  if (status !== 'success' && service === 'portmone' && false) {
+    const result = await portmoneCheckStatus({ id: params.id });
+    return; // !test
+  }
+
+  if (status !== 'success' && service === 'monopay' && false) {
+    const result = await monopayCheckStatus({ id: params.id });
+    return; // !test
+  }
 
   return rows[0];
 }

package/server/routes/core/index.mjs

@@ -0,0 +1,12 @@
+import paymentInfo from './controllers/payment.info.js';
+
+export default async function plugin(app, opts) {
+    app.route({
+        method: 'GET',
+        url: '/payment-info/:id',
+        config: {
+            policy: ['site'],
+        },
+        handler: paymentInfo,
+    });
+}

package/server/routes/liqpay/controllers/liqpay.redirect.js

@@ -1,137 +1,47 @@
-import request from 'request-promise';
-import LiqPay from 'liqpayjs-sdk';
-
 import config from '../../../../config.js';
 import pgClients from '../../../plugins/pg/pgClients.js';
-import dataInsert from '../../../plugins/crud/dataInsert.js';
-import dataUpdate from '../../../plugins/crud/dataUpdate.js';
-
-const { prefix = '/api' } = config;
-
-const { publicKey, privateKey, paymentRedirect } = config.integrations?.liqpay || {};
-const liqpay = new LiqPay(publicKey, privateKey);
 
-const host = 'https://www.liqpay.ua';
+import paymentInfo from '../../../plugins/payment/paymentInfo.js';
+import createTransaction from '../../../plugins/payment/liqpay.createTransaction.js';
 
 export default async function liqpayRedirect(req, reply) {
     const {
-        pg = pgClients.client, query = {}, user = {}, headers = {},
+        hostname, headers, pg = pgClients.client, query = {}, user = {}, protocol,
     } = req;
 
-    if (!publicKey || !privateKey) {
-        return reply.status(400).send('invalid liqpay integration settings');
+    if (!user?.uid) {
+        return reply.status(401).send('unauthorized');
     }
 
-    const domain = req.hostname.split(':').shift();
-
-    const paymentData = query.id ? await pg.query('select payment_id, account_id, payment_amount, payment_status from billing.payments where payment_id=$1', [query.id])
-        .then(el => el.rows?.[0] || {}) : {};
-
-    if (paymentData.payment_status && paymentData.payment_status === 'success') {
-        return { message: 'already processed', status: 400 };
-    }
+    const domain = hostname?.split?.(':')?.shift?.();
+    const rootUrl = `${protocol || 'https'}://${domain}`;
 
-    const paymentAmount = paymentData.payment_amount || query.price;
-
-    if (!paymentAmount) {
-        return { message: 'price is required', status: 400 };
-    }
+    const paymentData = query.id ? await paymentInfo(query.id) : {
+        price: query.price, // price for new transtaction as is, else - preCreated
+        service: 'portmone',
+        referer: headers?.referer, // redirect user after finish of transaction
+        uid: user.uid, // user id
+    };
 
-    const accountId = paymentData.account_id
-        || (user?.uid ? await pg.query('select account_id from billing.account_user where user_id=$1 limit 1', [user?.uid]).then(el => el.rows?.[0]?.account_id) : null);
+    // redirect back from payment service to API endpoint, provide protocol + domain
+    Object.assign(paymentData, { rootUrl });
 
-    if (!accountId) {
-        return { message: 'account_id is required', status: 400 };
+    if (query.id && paymentData.status === 'success') {
+        return reply.status(400).send('already processed');
     }
 
-    const { payment_id: paymentId } = !paymentData.payment_id
-        ? await dataInsert({
-            table: 'billing.payments',
-            data: {
-                payment_amount: paymentAmount,
-                account_id: accountId,
-                payment_service: 'liqpay',
-                payment_status: 'inprogress',
-            },
-            uid: user?.uid || '0',
-        }).then(el => el.rows?.[0] || {})
-        : { payment_id: paymentData.payment_id };
-
-    if (!paymentId) {
-        return { message: 'payment not found', status: 404 };
+    if (!paymentData?.price) {
+        return reply.status(400).send('price is required');
     }
 
-    await dataUpdate({
-        table: 'billing.payments',
-        id: paymentId,
-        data: {
-            referer_url: paymentRedirect ? paymentRedirect.replace(/{{id}}/g, paymentId) : headers?.referer,
-            payment_status: 'inprogress',
-        },
-        uid: user?.uid || '0',
-    });
-
-    const protocol = headers?.referer?.split?.('://')?.shift?.() || req.protocol || 'https';
-    const rootPageUrl = `${protocol || 'https'}://${domain}`;
-
-    // redirect to api to check payment status and redirect user to page afterwards
-    const serverUrl = `${rootPageUrl}${prefix}/liqpay/${paymentId}/success`;
-
-    const paymentOptions = {
-        action: 'pay',
-        amount: paymentAmount,
-        currency: 'UAH',
-        description: 'regular payment',
-        order_id: paymentId,
-        version: '3',
-        // server_url: serverUrl, // update payment info - api url, does not work on sdk package out of the box
-        result_url: serverUrl, // redirect user after payment - page url
-    };
-    const { data, signature } = liqpay.cnb_object(paymentOptions) || {};
-
-    const logObj = {
-        type: 'redirect',
-        paymentId,
-        accountId,
-        price: paymentAmount,
-        service: 'liqpay',
-        domain,
-        paymentRedirectUrl: serverUrl,
-        serverUrl,
-        uid: user?.uid || '0',
-    };
+    // create if not exists, then request to payment service
+    const result = await createTransaction({ ...paymentData, debug: config.debug && query.debug }, pg);
 
+    // html
     if (config.debug && query?.debug) {
-        const html = liqpay.cnb_form(paymentOptions);
-        return reply.status(302).headers({ 'Content-Type': 'text/html' }).send(html);
+        return reply.status(302).headers({ 'Content-Type': 'text/html' }).send(result);
     }
 
-    try {
-        const response = await request({
-            url: `${host}/api/3/checkout`,
-            method: 'POST',
-            form: { data, signature },
-            followAllRedirects: false,
-            jar: true,
-            timeout: 6000,
-            simple: false, // prevent not 2xx code trigger catch
-            resolveWithFullResponse: true,
-        });
-
-        if (response.statusCode !== 302 || !response.headers?.location) {
-            throw new Error(response);
-        }
-
-        if (response.headers?.location?.includes?.('throw_error')) {
-            throw new Error(response.headers?.location);
-        }
-
-        Object.assign(logObj, { paymentId, redirect: response.headers?.location, status: 302 });
-        console.log('payments/info', JSON.stringify(logObj));
-        return reply.redirect(response.headers.location);
-    }
-    catch (err) {
-        console.error('payments/error', JSON.stringify(logObj), err.toString(), err.stack);
-        return reply.status(500).send(err.toString());
-    }
+    // link to payment service
+    return reply.redirect(result);
 }