@opengis/pay 1.2.2 → 1.3.0

package/server/routes/monopay/index.mjs

@@ -0,0 +1,32 @@
+import monopayRedirect from './controllers/monopay.redirect.js';
+import monopayStatus from './controllers/monopay.status.js';
+
+const schema = {
+    querystring: {
+        type: 'object',
+        properties: {
+            price: {
+                type: 'number',
+                exclusiveMinimum: 0,
+            },
+        },
+        // additionalProperties: false,
+    },
+};
+
+export default async function plugin(app, opts) {
+    app.route({
+        method: 'GET',
+        url: '/monopay-redirect',
+        config: { policy: ['site'] },
+        schema,
+        handler: monopayRedirect,
+    });
+    app.route({
+        method: 'GET',
+        url: '/monopay/:id/:status',
+        config: { policy: ['public'] },
+        schema,
+        handler: monopayStatus,
+    });
+}

package/server/routes/portmone/controllers/payment.info.js

@@ -1,4 +1,5 @@
-import { dataUpdate, metaFormat, pgClients } from '@opengis/fastify-table/utils.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import dataUpdate from '../../../plugins/crud/dataUpdate.js';
 
 import liqpayCheckStatus from '../../liqpay/utils/check.status.js';
 
@@ -23,13 +24,13 @@ const newDate = (dateNum) => {
 
 export default async function paymentInfo({
   pg = pgClients.client, user = {}, params = {},
-}) {
+}, reply) {
   if (!user?.uid) {
-    return { message: 'unauthorized', status: 401 };
+    return reply.status(401).send('unauthorized');
   }
 
   if (!params?.id) {
-    return { message: 'not enough query params: id', status: 400 };
+    return reply.status(400).send('not enough query params: id');
   }
 
   const { rows = [] } = await pg.query(`select 
@@ -47,14 +48,13 @@ export default async function paymentInfo({
   and   account_id in (select account_id from billing.account_user where user_id = $2)`, [params.id, user.uid]);
 
   if (!rows.length) {
-    return { message: 'payment not found', status: 404 };
+    return reply.status(404).send('payment not found');
   }
 
   const {
     account_id: accountId,
     payment_service: service,
     payment_status: status,
-
   } = rows[0];
 
   if (status !== 'success' && service === 'liqpay') {
@@ -80,11 +80,11 @@ export default async function paymentInfo({
       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 res1;
+    // 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' } });
+  // await metaFormat({ rows, cls: { account_id: 'billing.account_id', payment_status: 'billing.payment_status', subscription_id: 'billing.subscription_id' } });
 
   return rows[0];
 }

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

@@ -1,8 +1,9 @@
 import request from 'request-promise';
 
-import {
-  config, pgClients, logger, dataInsert, dataUpdate, handlebarsSync,
-} from '@opengis/fastify-table/utils.js';
+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 { host, payeeId, paymentRedirect = config.paymentRedirect } = config.integrations?.pay || {};
 
@@ -24,15 +25,15 @@ const { host, payeeId, paymentRedirect = config.paymentRedirect } = config.integ
 
 export default async function PortmoneRedirect(req, reply) {
   const {
-    pg = pgClients.client, user = {}, query = {}, headers = {},
+    pg = pgClients.client, user = {}, query = {}, headers = {}, unittest,
   } = req;
 
   if (!host) {
-    return { message: 'empty integration host', status: 400 };
+    return reply.status(400).send('empty integration host');
   }
 
   if (!payeeId) {
-    return { message: 'empty integration payeeId', status: 400 };
+    return reply.status(400).send('empty integration payeeId');
   }
 
   const domain = req.hostname.split(':').shift();
@@ -58,10 +59,17 @@ export default async function PortmoneRedirect(req, reply) {
   }
 
   if ((!headers?.referer || !headers.referer.includes(domain))) {
-    logger.file('payments/warn', {
-      message: 'invalid referer', service: 'portmone', domain, referer: headers?.referer, uid: user?.uid,
-    });
-    if (!config.auth?.disableRestricted) return { message: 'access restricted: referer', status: 403 };
+    console.warn(
+      'payments/warn',
+      'invalid referer',
+      'portmone',
+      domain,
+      headers?.referer,
+      user?.uid,
+    );
+    if (!config.auth?.disableRestricted && !unittest) {
+      return reply.status(403).send('access restricted: referer');
+    }
   }
 
   const { payment_id: paymentId } = !data.payment_id
@@ -78,14 +86,14 @@ export default async function PortmoneRedirect(req, reply) {
     : { payment_id: data.payment_id };
 
   if (!paymentId) {
-    return { message: 'payment not found', status: 404 };
+    return reply.status(404).send('payment not found');
   }
 
   await dataUpdate({
     table: 'billing.payments',
     id: paymentId,
     data: {
-      referer_url: paymentRedirect ? handlebarsSync.compile(paymentRedirect)({ id: paymentId }) : headers?.referer,
+      referer_url: paymentRedirect ? paymentRedirect.replace(/{{id}}/g, paymentId) : headers?.referer,
       payment_status: 'inprogress',
     },
     uid: user?.uid || '0',
@@ -111,7 +119,7 @@ export default async function PortmoneRedirect(req, reply) {
     accountId,
     price: paymentAmount,
     domain,
-    paymentRedirectUrl: paymentRedirect ? handlebarsSync.compile(paymentRedirect)({ id: paymentId }) : headers?.referer,
+    paymentRedirectUrl: paymentRedirect ? paymentRedirect.replace(/{{id}}/g, paymentId) : headers?.referer,
     uid: user?.uid || '0',
   };
 
@@ -133,13 +141,11 @@ export default async function PortmoneRedirect(req, reply) {
       throw new Error(response);
     }
 
-    Object.assign(logObj, { paymentId, redirect: response.headers?.location, status: 302 });
-    logger.file('payments', logObj);
+    console.log('payments/redirect', paymentId, response.headers?.location);
     return reply.redirect(response.headers.location);
   }
   catch (err) {
-    Object.assign(logObj, { error: err.toString() });
-    logger.file('payments/error', logObj);
+    console.error('payments/error', JSON.stringify(logObj), err.toString(), err.stack);
     return { error: err.toString(), status: 500 };
   }
 }

package/server/routes/portmone/controllers/portmone.status.js

@@ -1,8 +1,16 @@
-import {
-  config, logger, pgClients, dataUpdate, getTemplate,
-} from '@opengis/fastify-table/utils.js';
+import path from 'node:path';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'url';
 
-import { sendNotification } from '@opengis/admin/utils.js';
+const dirname = path.dirname(fileURLToPath(import.meta.url));
+
+import config from '../../../../config.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+import dataUpdate from '../../../plugins/crud/dataUpdate.js';
+
+import sendNotification from '../../../utils/sendNotification.js';
+
+const ptBody = readFileSync(path.join(dirname, '../../../../module/pay/pt/marketplace-service-payment-client-template.html'));
 
 const newDate = () => {
   const date = new Date();
@@ -56,14 +64,15 @@ export default async function portmoneStatus(req, reply) {
     } = data;
 
     if (trxStatus === 'success') {
-      logger.file('payments/skip', {
-        type: 'status',
-        service: 'portmone',
+      console.log(
+        'payments/skip',
+        'status',
+        'portmone',
         paymentId,
         origin,
-        uid: user?.uid || '0',
-        message: 'Transaction was already processed',
-      });
+        user?.uid || '0',
+        'Transaction was already processed',
+      );
       return { message: 'Transaction was already processed', status: 400 };
     }
 
@@ -75,28 +84,30 @@ export default async function portmoneStatus(req, reply) {
 
     // request portmone trx info to recheck request data is valid?
     if (!origin?.startsWith(host)) {
-      logger.file('payments/warn', {
-        type: 'status',
-        service: 'portmone',
+      console.warn(
+        'payments/warn',
+        'status',
+        'portmone',
         paymentId,
         origin,
-        uid: user?.uid || '0',
+        user?.uid || '0',
         refill,
-        message: 'invalid referer',
-      });
+        'invalid referer',
+      );
       if (!config.auth?.disableRestricted) return { message: 'access restricted: host', status: 403 };
     }
 
-    logger.file('payments', {
-      type: 'status',
-      service: 'portmone',
+    console.log(
+      'payments/info',
+      'status',
+      'portmone',
       paymentId,
       origin,
-      uid: user?.uid || '0',
+      user?.uid || '0',
       refill,
       body,
       params,
-    });
+    );
 
     // last trx contains total balance
     const { total_balance: totalBalance } = await pg.query(`select total_balance from billing.payments 
@@ -122,30 +133,31 @@ export default async function portmoneStatus(req, reply) {
     const { account_email: to } = await pg.query('select account_email from billing.accounts where account_id=$1', [accountId])
       .then(el => el.rows?.[0] || {});
 
-    logger.file('payments', {
-      type: 'status',
-      service: 'portmone',
+    console.log(
+      'payments/info2',
+      'status',
+      'portmone',
       paymentId,
       responseStatus,
       to,
       origin,
-      redirect: redirectUrl,
-      uid: user.uid || '0',
-    });
-
-    Object.assign(data, {
-      domain: req.hostname,
-      total_balance: +(refill || 0) + (+totalBalance || 0),
-    });
+      redirectUrl,
+      user.uid || '0',
+    );
 
     if (to) {
-      const pt = await getTemplate('pt', 'marketplace-service-payment-client-template');
+      const pt = ptBody
+        .replace(/{{domain}}/g, req.hostname)
+        .replace(/{{total_balance}}/g, +(refillSum || 0) + (+totalBalance || 0))
+        .replace(/{{username}}/g, to)
+        .replace(/{{created_at}}/g, (data?.cdate || data?.created_at || new Date()).toLocaleString('uk-UA'))
+        .replace(/{{payment_status}}/g, responseStatus)
+        .replace(/{{payment_amount}}/g, refillSum || 0);
       const options = {
         pg,
         to,
         title: `Поповнення рахунку на порталі ${req.hostname}`,
-        template: pt?.html || pt,
-        data,
+        pt,
         nocache: config?.local,
       };
       await sendNotification(options);
@@ -153,15 +165,14 @@ export default async function portmoneStatus(req, reply) {
     return reply.redirect(redirectUrl || '/');
   }
   catch (err) {
-    logger.file('payments/error', {
+    console.error('payments/error', JSON.stringify({
       type: 'status',
       service: 'portmone',
       paymentId,
       origin,
       responseStatus,
       uid: user?.uid || '0',
-      error: err.toString(),
-    });
+    }), err.toString(), err.stack);
     return reply.status(500).send(err.toString());
   }
 }

package/server/routes/portmone/utils/portmone.check.status.js

@@ -1,33 +1,34 @@
-import request from 'request-promise';
-
-import { config, pgClients } from '@opengis/fastify-table/utils.js';
-
-const { host, payeeId } = config.integrations?.pay || {};
-
-export default async function updateTrxStatus({
-  pg = pgClients.client, paymentId,
-}) {
-  const data = pg.pk?.['billing.payments'] && paymentId ? await pg.query('select * from billing.payments where payment_id=$1', [paymentId]).then(el => el.rows?.[0] || {}) : undefined;
-  if (!paymentId || !host || !payeeId || !data) throw new Error('not enough params');
-
-  const formData = {
-    method: 'result',
-    login: 'WDISHOP',
-    password: 'wdi451',
-    payeeId,
-    shopOrderNumber: paymentId,
-    // shopbillId,
-    id: paymentId,
-  };
-  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,
-  });
-  return response;
-}
+import request from 'request-promise';
+
+import config from '../../../../config.js';
+import pgClients from '../../../plugins/pg/pgClients.js';
+
+const { host, payeeId } = config.integrations?.pay || {};
+
+export default async function updateTrxStatus({
+  pg = pgClients.client, paymentId,
+}) {
+  const data = pg.pk?.['billing.payments'] && paymentId ? await pg.query('select * from billing.payments where payment_id=$1', [paymentId]).then(el => el.rows?.[0] || {}) : undefined;
+  if (!paymentId || !host || !payeeId || !data) throw new Error('not enough params');
+
+  const formData = {
+    method: 'result',
+    login: 'WDISHOP',
+    password: 'wdi451',
+    payeeId,
+    shopOrderNumber: paymentId,
+    // shopbillId,
+    id: paymentId,
+  };
+  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,
+  });
+  return response;
+}

package/server/utils/cron/addCron.js

@@ -0,0 +1,48 @@
+import config from '../../../config.js';
+import pgClients from '../pg/pgClients.js';
+
+import cronList from './cronList.js';
+import runCron from './runCron.js';
+import interval2ms from './interval2ms.js';
+
+/**
+ * interval:
+ * -   02:54 - every day
+ * -    2:03 - every day
+ * -   *1:43 - 2 times a day
+ * -  *12:03 - 2 times a day
+ * -   **:54 - every hour
+ * -   **:*3 - every 10 minutes
+ * -      60 - every minute
+ * - 10 * 60 - every 10 minutes
+ */
+
+export default async function addCron(func, interval, pg = pgClients.client) {
+  const { time = {}, disabled = [] } = config.cron || {};
+
+  const name = func.name || func.toString().split('/').at(-1).split('\'')[0];
+
+  if (disabled.includes(name)) {
+    console.warn('cron', name, 'cron disabled');
+    return;
+  }
+
+  cronList[name] = func;
+
+  const userInterval = time[name] || interval;
+  const [waitMs, intervalMs] = interval2ms[typeof interval](userInterval);
+
+  if (intervalMs < 1000) {
+    console.warn('cron', name, `interval ${interval} too small`);
+    return;
+  }
+
+  // setTimeout to w8 for the time to start
+  setTimeout(() => {
+    runCron({ pg, func, name });
+    // interval
+    setInterval(() => {
+      runCron({ pg, func, name });
+    }, intervalMs);
+  }, waitMs);
+}

package/server/utils/cron/cronList.js

@@ -0,0 +1 @@
+export default {};

package/server/utils/cron/interval2ms.js

@@ -0,0 +1,40 @@
+const intervalStringMs = {
+    everyMin: 1000 * 60,
+    tenMin: 1000 * 60 * 10,
+    everyHour: 1000 * 60 * 60,
+    isHalfday: 1000 * 60 * 60 * 12,
+    dailyHour: 1000 * 60 * 60 * 24,
+};
+
+const interval2ms = {
+    string: (interval) => {
+        const date = new Date();
+        const intervarSplit = interval.match(/^(\*{2}|(\*)?(\d{1,2})):(\*(\d)|(\d{2}))/);
+
+        if (!intervarSplit) {
+            throw new Error(`interval ${interval} not suported`);
+        }
+
+        const [, , isHalfday, dailyHour, , tenMin, HourlyMin] = intervarSplit;
+        const intervalMs = (isHalfday && intervalStringMs.isHalfday)
+            || (dailyHour && intervalStringMs.dailyHour)
+            || (tenMin && intervalStringMs.tenMin)
+            || intervalStringMs.everyHour;
+        const offsetDay = ((+dailyHour || 0) * 60 + (+tenMin || +HourlyMin)) * 60 * 1000;
+        const offsetCur = (date - date.getTimezoneOffset() * 1000 * 60) % intervalMs;
+        const waitMs = (offsetDay - offsetCur + intervalMs) % intervalMs;
+        return [waitMs, intervalMs];
+    },
+    number: (interval) => {
+        const date = new Date();
+        const intervalMs = interval * 1000;
+        const dateWithTZ = date - date.getTimezoneOffset() * 1000 * 60;
+        const offsetCur = dateWithTZ % intervalMs;
+        // start every cron within 1 hour
+        const sixtyMinutesStartMs = 3600000;
+        const waitMs = (intervalMs - offsetCur) % sixtyMinutesStartMs;
+        return [waitMs, intervalMs];
+    },
+};
+
+export default interval2ms;

package/server/utils/cron/runCron.js

@@ -0,0 +1,24 @@
+import logger from '../../logger/getLogger.js';
+import pgClients from '../../pg/pgClients.js';
+
+import verifyUnique from './verifyUnique.js';
+
+export default async function runCron({
+    pg = pgClients.client, func, name,
+}) {
+    const unique = await verifyUnique(name);
+    if (!unique) return;
+
+    const db = pg?.options?.database;
+    if (!db) return;
+
+    try {
+        const data = await func({ pg });
+        const subdir = data ? 'cron' : 'cron/null';
+        logger.file(subdir, { db, name, result: data });
+    }
+    catch (err) {
+        logger.file('cron', { db, name, error: err.toString() });
+        logger.error(err);
+    }
+}

package/server/utils/cron/verifyUnique.js

@@ -0,0 +1,23 @@
+import { createHash } from 'node:crypto';
+
+import config from '../../../config.js';
+
+import getRedis from '../../redis/funcs/getRedis.js';
+
+const md5 = (string) => createHash('md5').update(string).digest('hex');
+
+const rclient = getRedis();
+
+export default async function verifyUnique(name) {
+    if (!config.redis) return true; // skip if redis is disabled
+    const cronId = config.port || 3000 + md5(name);
+    // one per node check
+    const key = `cron:unique:${cronId}`;
+    const unique = await rclient.setnx(key, 1);
+    const ttl = await rclient.ttl(key);
+    if (!unique && ttl !== -1) {
+        return false;
+    }
+    await rclient.expire(key, 20);
+    return true;
+}

package/server/utils/getFolder.js

@@ -0,0 +1,11 @@
+import path from 'node:path';
+
+import config from '../../config.js';
+
+export default function getFolder(req, type = 'server') {
+  if (!['server', 'local'].includes(type)) throw new Error('params type is invalid');
+  const types = { local: req.root || config.root, server: req.mapServerRoot || config.mapServerRoot };
+  const dbname = req.pg?.options?.database || req.pg?.database || config.pg?.database; // request / config params / default config params
+  const filepath = path.posix.join(types[type] || `/data/local/${dbname || ''}`, req.folder || config.folder || '');
+  return filepath;
+}

package/server/utils/getInsertQuery.js

@@ -0,0 +1,44 @@
+import getMeta from '../plugins/pg/funcs/getMeta.js';
+
+export default async function getInsertQuery({
+    pg, table, data, id, uid,
+}) {
+    if (!pg?.pk || !data) {
+        return null;
+    }
+
+    const { columns } = await getMeta({ pg, table });
+
+    if (!columns) {
+        return null;
+    }
+
+    const names = columns.map((el) => el.name);
+
+    Object.assign(data, {
+        ...(id && pg.pk?.[table] ? { [pg.pk?.[table]]: id } : {}),
+        ...(table !== 'admin.users' ? { uid } : {}),
+        editor_id: uid,
+        created_by: uid,
+        updated_by: uid,
+        // editor_id: uid,
+    });
+
+    const systemColumns = ['cdate', 'editor_date', 'created_at', 'updated_at'].filter((el) => names.includes(el)).map((el) => [el, 'now()']);
+    const systemColumnNames = systemColumns.map(el => el[0]);
+
+    const filterData = Object.keys(data)
+        .filter((el) => !systemColumnNames.includes(el) && (typeof data[el] === 'boolean' ? true : data[el]) && names.includes(el)).map((el) => [el, data[el]]);
+
+    const insertQuery = `insert into ${table}
+
+    ( ${filterData?.map((key) => `"${key[0]}"`).concat(systemColumnNames).join(',')}) 
+
+    values  (${filterData?.map((key, i) => (key[0] === 'geom' ? `st_setsrid(st_geomfromgeojson($${i + 1}::json),4326)` : `$${i + 1}`)).concat(systemColumns.map((el) => el[1])).join(',')}) 
+    
+    returning *`;
+
+    const args = [...filterData.map((el) => (typeof el[1] === 'object' && (!Array.isArray(el[1]) || typeof el[1]?.[0] === 'object') ? JSON.stringify(el[1]) : el[1]))];
+
+    return { insertQuery, args };
+}

package/server/utils/migration/exec.migrations.js

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { readdirSync, existsSync } from 'node:fs';
+
+import config from '../../../config.js';
+import execSql from './exec.sql.js';
+import pgClients from '../../plugins/pg/pgClients.js';
+
+const time = Date.now();
+
+export default async function execMigrations(dirPath, pg = pgClients.client, iscore = false) {
+  if (
+    !dirPath
+    || (config.migrationsCore === false && iscore)
+    || config.migrations === false
+    || process.env.NODE_ENV === 'unit test'
+  ) {
+    console.log('migrations skip', 'core: ', !!iscore, 'dir: ', dirPath || 'not specified');
+    return;
+  }
+
+  console.log('migrations start', dirPath, Date.now() - time);
+
+  const exists = existsSync(dirPath);
+
+  if (exists) {
+    // get directory sql file list
+    const content = readdirSync(dirPath, { withFileTypes: true })
+      ?.filter((el) => el.isFile() && path.extname(el.name) === '.sql')
+      ?.map((el) => el.name) || [];
+
+    // execute sql files
+    if (content?.length) {
+      await content.reduce((promise, filename) => promise.then(() => execSql(path.join(dirPath, filename), pg)), Promise.resolve());
+    }
+  }
+
+  console.log('migrations finish', dirPath, exists, Date.now() - time);
+}