library.js

'use strict';

/*
 * nodebb-ucashpay
 * U.CASH Pay / tip button for NodeBB (crypto + cards, non-custodial).
 *
 * Two integration surfaces, both powered by the store Cloud Token (publishable):
 *
 *   1. CLIENT-SIDE hosted pay link (default): the post/profile button links
 *      directly to https://pay.u.cash/embed.php?<params>. The Cloud Token is
 *      publishable and safe to expose in the browser, so this needs no server
 *      secret and works straight from a static page.
 *
 *   2. SERVER-SIDE tracked checkout (optional): an admin toggle routes the
 *      button through a NodeBB route that calls the pay.u.cash
 *      create-transaction endpoint. This records a checkout (idempotent per
 *      external_reference) so you can reconcile paid orders back to NodeBB
 *      content. It uses the same publishable store Cloud Token.
 *
 * See README.md for setup (store Cloud Token at pay.u.cash).
 */

const url = require('url');
const http = require('http');
const https = require('https');

const EMBED_ENDPOINT = 'https://pay.u.cash/embed.php';
const AJAX_ENDPOINT = 'https://pay.u.cash/payment/ajax.php';

const plugin = {};

/* ------------------------------------------------------------------ */
/* NodeBB module accessors (lazily loaded)                             */
/* ------------------------------------------------------------------ */

function getMeta() {
    try { return require.main.require('./src/meta'); }
    catch (e) { return null; }
}

function getSettings() {
    const meta = getMeta();
    return (meta && meta.settings && meta.settings['nodebb-plugin-ucashpay']) || {};
}

function getSetting(key, fallback) {
    const settings = getSettings();
    const value = settings[key];
    if (value === undefined || value === null || value === '') return fallback;
    return value;
}

function toBool(value, fallback) {
    if (value === undefined || value === null || value === '') return fallback;
    return value === true || value === 'true' || value === '1' || value === 1;
}

/* ------------------------------------------------------------------ */
/* URL + HTTP helpers                                                  */
/* ------------------------------------------------------------------ */

function buildEmbedUrl(params) {
    const query = new URLSearchParams();
    if (params.cloud) query.set('cloud', params.cloud);
    if (params.amount) query.set('amount', String(params.amount));
    query.set('currency', params.currency || 'USD');
    if (params.title) query.set('title', params.title);
    if (params.external_reference) query.set('external_reference', params.external_reference);
    if (params.redirect) query.set('redirect', params.redirect);
    return EMBED_ENDPOINT + '?' + query.toString();
}

/* Minimal form-encoded POST with a callback. Node 16+ has global fetch, but
 * older NodeBB Node LTS versions may not; keep a portable http(s) impl. */
function postForm(targetUrl, fields, callback) {
    let body = '';
    Object.keys(fields).forEach((key) => {
        const val = fields[key] === undefined || fields[key] === null ? '' : String(fields[key]);
        if (body.length) body += '&';
        body += encodeURIComponent(key) + '=' + encodeURIComponent(val);
    });

    const parsed = url.parse(targetUrl);
    const transport = parsed.protocol === 'https:' ? https : http;

    const options = {
        hostname: parsed.hostname,
        port: parsed.port,
        path: parsed.path,
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Content-Length': Buffer.byteLength(body),
            'Accept': 'application/json',
            'User-Agent': 'nodebb-ucashpay/0.1.0'
        }
    };

    const req = transport.request(options, (res) => {
        let data = '';
        res.setEncoding('utf8');
        res.on('data', (chunk) => { data += chunk; });
        res.on('end', () => {
            if (res.statusCode < 200 || res.statusCode >= 300) {
                return callback(new Error('pay.u.cash returned HTTP ' + res.statusCode));
            }
            let json;
            try { json = JSON.parse(data); } catch (e) {
                return callback(new Error('pay.u.cash returned non-JSON response'));
            }
            callback(null, json);
        });
    });
    req.on('error', callback);
    req.write(body);
    req.end();
}

/* create-transaction response is { success, response: [paymentUrl, txnId, ...] }.
 * The payment URL is the array element starting with http(s)://. */
function extractPaymentUrl(responseBody) {
    const arr = (responseBody && responseBody.response) || [];
    if (Array.isArray(arr)) {
        for (let i = 0; i < arr.length; i++) {
            if (typeof arr[i] === 'string' && /^https?:\/\//i.test(arr[i])) {
                return arr[i];
            }
        }
    }
    return null;
}

/* Public helper: create a tracked checkout on pay.u.cash.
 * idempotent per external_reference. */
plugin.createTransaction = function (params, callback) {
    postForm(AJAX_ENDPOINT, {
        function: 'create-transaction',
        amount: params.amount || '',
        currency_code: params.currency || 'USD',
        cryptocurrency_code: '',
        external_reference: params.external_reference || '',
        title: params.title || '',
        redirect: params.redirect || '',
        cloud: params.cloud || '',
        idempotent: '1'
    }, callback);
};

/* ------------------------------------------------------------------ */
/* Hook: static:app.load  ->  register server route                    */
/* ------------------------------------------------------------------ */

plugin.onLoad = function (params, callback) {
    const { router, middleware } = params;
    const controllers = require('./lib/controllers');
    const admin = require('./lib/admin');

    // Public checkout route. Calls pay.u.cash create-transaction server-side
    // and redirects to the returned payment URL.
    router.get('/ucashpay/checkout', middleware.stripGlobalVariable, controllers.embedCheckout);

    // ACP settings page.
    router.get('/admin/plugins/ucashpay', middleware.admin.buildHeader, admin.render);
    router.get('/api/admin/plugins/ucashpay', admin.render);

    callback();
};

/* ------------------------------------------------------------------ */
/* Hook: filter:post.getPosts  ->  attach button data to each post     */
/* ------------------------------------------------------------------ */

plugin.posts = {};

plugin.posts.getPosts = function (payload, callback) {
    attachButtonData(payload, 'post', callback);
};

/* ------------------------------------------------------------------ */
/* Hook: filter:admin.header.build  ->  ACP menu entry                 */
/* ------------------------------------------------------------------ */

plugin.admin = {};

plugin.admin.menu = function (customHeader, callback) {
    customHeader.navigation.push({
        route: '/plugins/ucashpay',
        icon: 'fa-solid fa-coins',
        name: 'U.CASH Pay'
    });
    callback(null, customHeader);
};

/* ------------------------------------------------------------------ */
/* Hook: filter:meta.getMetaTags  ->  emit publishable client config   */
/* ------------------------------------------------------------------ */

plugin.meta = {};

plugin.meta.getMetaTags = function (data, callback) {
    const cloud = getSetting('cloudToken', '');
    if (!cloud) {
        return callback(null, data);
    }
    const cfg = {
        cloud: cloud,
        currency: getSetting('defaultCurrency', 'USD'),
        amount: getSetting('defaultAmount', ''),
        label: getSetting('buttonLabel', 'Tip'),
        serverTracked: toBool(getSetting('serverTracked', false), false),
        enablePosts: toBool(getSetting('enablePosts', true), true),
        enableProfiles: toBool(getSetting('enableProfiles', false), false)
    };
    // Encoded JSON inside a meta tag so the client script can read publishable
    // config without an extra round-trip. The store Cloud Token is publishable.
    data.metaTags = data.metaTags || [];
    data.metaTags.push({
        name: 'ucashpay-config',
        content: encodeURIComponent(JSON.stringify(cfg))
    });
    callback(null, data);
};

/* ------------------------------------------------------------------ */
/* Shared attach logic                                                 */
/* ------------------------------------------------------------------ */

function attachButtonData(payload, kind, callback) {
    const posts = Array.isArray(payload) ? payload : (payload && payload.posts);
    if (!posts || !posts.length) {
        return callback(null, payload);
    }

    const cloud = getSetting('cloudToken', '');
    const currency = getSetting('defaultCurrency', 'USD');
    const amount = getSetting('defaultAmount', '');
    const label = getSetting('buttonLabel', 'Tip');
    const serverTracked = toBool(getSetting('serverTracked', false), false);
    const enabledForKind = (kind === 'post')
        ? toBool(getSetting('enablePosts', true), true)
        : toBool(getSetting('enableProfiles', false), false);

    posts.forEach((post) => {
        if (!post) return;
        if (!cloud || !enabledForKind) {
            post.ucashpay = null;
            return;
        }

        const ref = ['nodebb', kind, String(post.pid || post.uid || '')].join(':');
        const title = 'Tip for ' + (post.user && post.user.username ? post.user.username : 'this post');

        if (serverTracked) {
            post.ucashpay = {
                enabled: true,
                label: label,
                href: '/ucashpay/checkout?ref=' + encodeURIComponent(ref) +
                      '&title=' + encodeURIComponent(title) +
                      (amount ? '&amount=' + encodeURIComponent(amount) : '') +
                      '&currency=' + encodeURIComponent(currency)
            };
        } else {
            post.ucashpay = {
                enabled: true,
                label: label,
                href: buildEmbedUrl({
                    cloud: cloud, amount: amount, currency: currency,
                    title: title, external_reference: ref, redirect: ''
                })
            };
        }
    });

    callback(null, payload);
}

module.exports = plugin;
module.exports.buildEmbedUrl = buildEmbedUrl;
module.exports.postForm = postForm;
module.exports.extractPaymentUrl = extractPaymentUrl;