nodebb-plugin-onekite-calendar 1.0.12 → 1.0.13

package/lib/controllers.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const controllers = {};
+
+controllers.renderCalendar = async function (req, res) {
+  res.render('calendar-onekite', {
+    title: 'Calendar',
+  });
+};
+
+module.exports = controllers;

package/lib/db.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const db = require.main.require('./src/database');
+
+const KEY_ZSET = 'calendar-onekite:reservations';
+const KEY_OBJ = (rid) => `calendar-onekite:reservation:${rid}`;
+const KEY_CHECKOUT_INTENT_TO_RID = 'calendar-onekite:helloasso:checkoutIntentToRid';
+
+// Special events (non-reservation events shown in a different colour)
+const KEY_SPECIAL_ZSET = 'calendar-onekite:special';
+const KEY_SPECIAL_OBJ = (eid) => `calendar-onekite:special:${eid}`;
+
+// Helpers
+function reservationKey(rid) {
+  return KEY_OBJ(rid);
+}
+
+function specialKey(eid) {
+  return KEY_SPECIAL_OBJ(eid);
+}
+
+async function getReservation(rid) {
+  return await db.getObject(KEY_OBJ(rid));
+}
+
+/**
+ * Batch fetch reservations in one DB roundtrip.
+ * Returns an array aligned with rids (missing objects => null).
+ */
+async function getReservations(rids) {
+  const ids = Array.isArray(rids) ? rids.filter(Boolean) : [];
+  if (!ids.length) return [];
+  const keys = ids.map(reservationKey);
+  const rows = await db.getObjects(keys);
+  // Ensure rid is present even if older objects were missing it.
+  return (rows || []).map((row, idx) => {
+    if (!row) return null;
+    if (!row.rid) row.rid = String(ids[idx]);
+    return row;
+  });
+}
+
+async function saveReservation(resv) {
+  await db.setObject(KEY_OBJ(resv.rid), resv);
+  // score = start timestamp
+  await db.sortedSetAdd(KEY_ZSET, resv.start, resv.rid);
+  // Optional mapping to help reconcile HelloAsso webhooks that don't include metadata
+  if (resv.checkoutIntentId) {
+    try {
+      await db.setObjectField(KEY_CHECKOUT_INTENT_TO_RID, String(resv.checkoutIntentId), String(resv.rid));
+    } catch (e) {
+      // ignore
+    }
+  }
+}
+
+async function removeReservation(rid) {
+  await db.sortedSetRemove(KEY_ZSET, rid);
+  await db.delete(KEY_OBJ(rid));
+}
+
+async function listReservationIdsByStartRange(startTs, endTs, limit = 1000) {
+  // NodeBB db method name is getSortedSetRangeByScore(set, start, stop, min, max)
+  // (start/stop are index offsets, min/max are score range)
+  const start = 0;
+  const stop = Math.max(0, (parseInt(limit, 10) || 1000) - 1);
+  return await db.getSortedSetRangeByScore(KEY_ZSET, start, stop, startTs, endTs);
+}
+
+async function listAllReservationIds(limit = 5000) {
+  return await db.getSortedSetRange(KEY_ZSET, 0, limit - 1);
+}
+
+module.exports = {
+  KEY_ZSET,
+  KEY_SPECIAL_ZSET,
+  KEY_CHECKOUT_INTENT_TO_RID,
+  getReservation,
+  getReservations,
+  saveReservation,
+  removeReservation,
+  // Special events
+  getSpecialEvent: async (eid) => await db.getObject(KEY_SPECIAL_OBJ(eid)),
+  getSpecialEvents: async (eids) => {
+    const ids = Array.isArray(eids) ? eids.filter(Boolean) : [];
+    if (!ids.length) return [];
+    const keys = ids.map(specialKey);
+    const rows = await db.getObjects(keys);
+    return (rows || []).map((row, idx) => {
+      if (!row) return null;
+      if (!row.eid) row.eid = String(ids[idx]);
+      return row;
+    });
+  },
+  saveSpecialEvent: async (ev) => {
+    await db.setObject(KEY_SPECIAL_OBJ(ev.eid), ev);
+    await db.sortedSetAdd(KEY_SPECIAL_ZSET, ev.start, ev.eid);
+  },
+  removeSpecialEvent: async (eid) => {
+    await db.sortedSetRemove(KEY_SPECIAL_ZSET, eid);
+    await db.delete(KEY_SPECIAL_OBJ(eid));
+  },
+  listSpecialIdsByStartRange: async (startTs, endTs, limit = 2000) => {
+    const start = 0;
+    const stop = Math.max(0, (parseInt(limit, 10) || 2000) - 1);
+    return await db.getSortedSetRangeByScore(KEY_SPECIAL_ZSET, start, stop, startTs, endTs);
+  },
+  listReservationIdsByStartRange,
+  listAllReservationIds,
+};

package/lib/discord.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const https = require('https');
+const { URL } = require('url');
+
+function isEnabled(v, defaultValue) {
+  if (v === undefined || v === null || v === '') return defaultValue !== false;
+  const s = String(v).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(s)) return true;
+  if (['0', 'false', 'no', 'off'].includes(s)) return false;
+  return defaultValue !== false;
+}
+
+function formatFRShort(ts) {
+  const d = new Date(ts);
+  const dd = String(d.getDate()).padStart(2, '0');
+  const mm = String(d.getMonth() + 1).padStart(2, '0');
+  const yy = String(d.getFullYear()).slice(-2);
+  return `${dd}/${mm}/${yy}`;
+}
+
+function postWebhook(webhookUrl, payload) {
+  return new Promise((resolve, reject) => {
+    try {
+      const u = new URL(String(webhookUrl));
+      if (u.protocol !== 'https:') {
+        return reject(new Error('discord-webhook-must-be-https'));
+      }
+
+      const body = Buffer.from(JSON.stringify(payload || {}), 'utf8');
+      const req = https.request({
+        method: 'POST',
+        hostname: u.hostname,
+        port: u.port || 443,
+        path: u.pathname + (u.search || ''),
+        headers: {
+          'Content-Type': 'application/json',
+          'Content-Length': body.length,
+          'User-Agent': 'nodebb-plugin-calendar-onekite',
+        },
+      }, (res) => {
+        const ok = res.statusCode && res.statusCode >= 200 && res.statusCode < 300;
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => {
+          if (ok) return resolve(true);
+          const msg = Buffer.concat(chunks).toString('utf8');
+          return reject(new Error(`discord-webhook-http-${res.statusCode}: ${msg}`));
+        });
+      });
+      req.on('error', reject);
+      req.write(body);
+      req.end();
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+
+function buildReservationMessage(kind, reservation) {
+  const calUrl = 'https://www.onekite.com/calendar';
+  const username = reservation && reservation.username ? String(reservation.username) : '';
+  const items = (reservation && Array.isArray(reservation.itemNames) && reservation.itemNames.length)
+    ? reservation.itemNames.map(String)
+    : (reservation && Array.isArray(reservation.itemIds) ? reservation.itemIds.map(String) : []);
+  const start = reservation && reservation.start ? Number(reservation.start) : NaN;
+  const end = reservation && reservation.end ? Number(reservation.end) : NaN;
+
+  const title = kind === 'paid'
+    ? `**[Paiement reçu](${calUrl})** — ${username}`
+    : `**[Demande réservation](${calUrl})** — ${username}`;
+
+  const lines = [
+    title,
+    '',
+    kind === 'paid' ? '**Matériel :**' : '**Matériel demandé :**',
+  ];
+  for (const it of items) {
+    lines.push(`- ${it}`);
+  }
+  if (Number.isFinite(start) && Number.isFinite(end)) {
+    lines.push('');
+    lines.push(`Du ${formatFRShort(start)} au ${formatFRShort(end)}`);
+  }
+  return lines.join('\n');
+}
+
+function buildWebhookPayload(kind, reservation) {
+  // Discord "regroupe" visuellement les messages consécutifs d'un même auteur.
+  // En utilisant un username différent par action, on obtient un message bien distinct.
+  const webhookUsername = kind === 'paid' ? 'Onekite • Paiement' : 'Onekite • Réservation';
+
+  const calUrl = 'https://www.onekite.com/calendar';
+  const username = reservation && reservation.username ? String(reservation.username) : '';
+  const items = (reservation && Array.isArray(reservation.itemNames) && reservation.itemNames.length)
+    ? reservation.itemNames.map(String)
+    : (reservation && Array.isArray(reservation.itemIds) ? reservation.itemIds.map(String) : []);
+  const start = reservation && reservation.start ? Number(reservation.start) : NaN;
+  const end = reservation && reservation.end ? Number(reservation.end) : NaN;
+
+  const title = kind === 'paid' ? '💳 Paiement reçu' : '⏳ Demande de réservation';
+
+  const fields = [];
+  if (username) {
+    fields.push({ name: 'Membre', value: username, inline: true });
+  }
+  if (items.length) {
+    const label = kind === 'paid' ? 'Matériel' : 'Matériel demandé';
+    fields.push({ name: label, value: items.map((it) => `• ${it}`).join('\n'), inline: false });
+  }
+  if (Number.isFinite(start) && Number.isFinite(end)) {
+    fields.push({ name: 'Période', value: `Du ${formatFRShort(start)} au ${formatFRShort(end)}`, inline: false });
+  }
+
+  return {
+    username: webhookUsername,
+    // On laisse "content" vide pour privilégier l'embed (plus lisible sur Discord)
+    content: '',
+    embeds: [
+      {
+        title,
+        url: calUrl,
+        description: kind === 'paid'
+          ? 'Un paiement a été reçu pour une réservation.'
+          : 'Une nouvelle demande de réservation a été créée.',
+        fields,
+        footer: { text: 'Onekite • Calendrier' },
+        timestamp: new Date().toISOString(),
+      },
+    ],
+  };
+}
+
+async function notifyReservationRequested(settings, reservation) {
+  const url = settings && settings.discordWebhookUrl ? String(settings.discordWebhookUrl).trim() : '';
+  if (!url) return;
+  if (!isEnabled(settings.discordNotifyOnRequest, true)) return;
+
+  try {
+    await postWebhook(url, buildWebhookPayload('request', reservation));
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('[calendar-onekite] Discord webhook failed (request)', e && e.message ? e.message : String(e));
+  }
+}
+
+async function notifyPaymentReceived(settings, reservation) {
+  const url = settings && settings.discordWebhookUrl ? String(settings.discordWebhookUrl).trim() : '';
+  if (!url) return;
+  if (!isEnabled(settings.discordNotifyOnPaid, true)) return;
+
+  try {
+    await postWebhook(url, buildWebhookPayload('paid', reservation));
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.warn('[calendar-onekite] Discord webhook failed (paid)', e && e.message ? e.message : String(e));
+  }
+}
+
+module.exports = {
+  notifyReservationRequested,
+  notifyPaymentReceived,
+};

package/lib/helloasso.js

@@ -0,0 +1,352 @@
+'use strict';
+
+const https = require('https');
+
+function requestJson(method, url, headers = {}, bodyObj = null) {
+  return new Promise((resolve) => {
+    const u = new URL(url);
+    const body = bodyObj ? JSON.stringify(bodyObj) : null;
+
+    const req = https.request(
+      {
+        method,
+        hostname: u.hostname,
+        port: u.port || 443,
+        path: u.pathname + u.search,
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+          ...(body ? { 'Content-Length': Buffer.byteLength(body) } : {}),
+          ...headers,
+        },
+      },
+      (resp) => {
+        let data = '';
+        resp.setEncoding('utf8');
+        resp.on('data', (chunk) => { data += chunk; });
+        resp.on('end', () => {
+          const status = resp.statusCode || 0;
+
+          // Try JSON first, but never throw from here (avoid crashing NodeBB).
+          try {
+            const json = data ? JSON.parse(data) : null;
+            return resolve({ status, json });
+          } catch (e) {
+            // Non-JSON response (HTML/proxy error/etc.)
+            const snippet = String(data || '').slice(0, 500);
+            return resolve({ status, json: null, raw: snippet });
+          }
+        });
+      }
+    );
+
+    req.on('error', (err) => {
+      resolve({ status: 0, json: null, error: err && err.message ? err.message : String(err) });
+    });
+    if (body) req.write(body);
+    req.end();
+  });
+}
+
+function baseUrl(env) {
+  return env === 'sandbox'
+    ? 'https://api.helloasso-sandbox.com'
+    : 'https://api.helloasso.com';
+}
+
+// In-memory access token cache (per NodeBB process)
+let _tokenCache = { token: null, expiresAt: 0 };
+let _tokenInFlight = null;
+
+function _sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function _tokenLooksValid() {
+  // Refresh 60s before expiration to avoid edge cases
+  return !!(_tokenCache.token && Date.now() < (_tokenCache.expiresAt - 60_000));
+}
+
+function _isRateLimited(status, parsedJson, bodySnippet) {
+  if (status === 429) return true;
+  const snip = String(bodySnippet || '').toLowerCase();
+  if (snip.includes('1015')) return true; // Cloudflare rate limited
+  if (parsedJson && typeof parsedJson === 'object') {
+    const j = JSON.stringify(parsedJson).toLowerCase();
+    if (j.includes('1015')) return true;
+    if (j.includes('rate') && j.includes('limit')) return true;
+  }
+  return false;
+}
+
+function _retryAfterMs(headers) {
+  if (!headers) return 0;
+  const ra = headers['retry-after'] || headers['Retry-After'];
+  if (!ra) return 0;
+  const n = parseInt(Array.isArray(ra) ? ra[0] : String(ra), 10);
+  if (!Number.isFinite(n) || n <= 0) return 0;
+  return Math.min(120_000, n * 1000);
+}
+
+function _requestAccessTokenRaw({ env, clientId, clientSecret }) {
+  const url = `${baseUrl(env)}/oauth2/token`;
+  const body = new URLSearchParams({
+    grant_type: 'client_credentials',
+    client_id: clientId,
+    client_secret: clientSecret,
+  }).toString();
+
+  return new Promise((resolve) => {
+    try {
+      const u = new URL(url);
+      const req = https.request(
+        {
+          method: 'POST',
+          hostname: u.hostname,
+          port: u.port || 443,
+          path: u.pathname + u.search,
+          headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'Content-Length': Buffer.byteLength(body),
+          },
+        },
+        (res) => {
+          let data = '';
+          res.setEncoding('utf8');
+          res.on('data', (chunk) => (data += chunk));
+          res.on('end', () => {
+            const status = res.statusCode || 0;
+            const headers = res.headers || {};
+            const snippet = String(data || '').slice(0, 1000);
+            resolve({ status, headers, bodyText: data || '', snippet });
+          });
+        }
+      );
+      req.on('error', (err) => {
+        resolve({ status: 0, headers: {}, bodyText: '', snippet: err && err.message ? String(err.message) : String(err) });
+      });
+      req.write(body);
+      req.end();
+    } catch (e) {
+      resolve({ status: 0, headers: {}, bodyText: '', snippet: e && e.message ? String(e.message) : String(e) });
+    }
+  });
+}
+
+async function _fetchAccessTokenWithRetry(params) {
+  // 3 attempts max with exponential backoff on rate-limit/network
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const { status, headers, bodyText, snippet } = await _requestAccessTokenRaw(params);
+
+    // 2xx: parse and return token (+ cache expiry)
+    if (status >= 200 && status < 300) {
+      try {
+        const json = JSON.parse(bodyText || '{}');
+        const token = json && json.access_token ? String(json.access_token) : null;
+        const expiresIn = parseInt(json && json.expires_in ? String(json.expires_in) : '3600', 10) || 3600;
+        if (token) {
+          const expiresAt = Date.now() + Math.max(60, expiresIn) * 1000;
+          return { token, expiresAt };
+        }
+        return { token: null, expiresAt: 0 };
+      } catch (e) {
+        return { token: null, expiresAt: 0 };
+      }
+    }
+
+    // Non-2xx: decide whether to retry
+    let parsed = null;
+    try { parsed = bodyText ? JSON.parse(bodyText) : null; } catch (e) { /* ignore */ }
+
+    const rateLimited = _isRateLimited(status, parsed, snippet);
+    const networkish = status === 0;
+
+    if ((rateLimited || networkish) && attempt < 2) {
+      const base = 1500 * (2 ** attempt);
+      const ra = _retryAfterMs(headers);
+      const jitter = Math.floor(Math.random() * 250);
+      const waitMs = Math.min(60_000, Math.max(base, ra) + jitter);
+      await _sleep(waitMs);
+      continue;
+    }
+
+    return { token: null, expiresAt: 0 };
+  }
+
+  return { token: null, expiresAt: 0 };
+}
+
+async function getAccessToken({ env, clientId, clientSecret }) {
+  if (!clientId || !clientSecret) return null;
+
+  if (_tokenLooksValid()) return _tokenCache.token;
+
+  // De-duplicate concurrent token requests (prevents bursts -> 429/1015)
+  if (_tokenInFlight) return _tokenInFlight;
+
+  _tokenInFlight = (async () => {
+    const { token, expiresAt } = await _fetchAccessTokenWithRetry({ env, clientId, clientSecret });
+    if (token) {
+      _tokenCache = { token, expiresAt };
+    }
+    return token || null;
+  })();
+
+  try {
+    return await _tokenInFlight;
+  } finally {
+    _tokenInFlight = null;
+  }
+}
+
+async function listItems({ env, token, organizationSlug, formType, formSlug }) {
+  if (!token || !organizationSlug || !formType || !formSlug) return [];
+  // This endpoint returns *sold items* (i.e., items present in orders). If your shop has
+  // no sales yet, it will legitimately return an empty list.
+  const url = `${baseUrl(env)}/v5/organizations/${encodeURIComponent(organizationSlug)}/forms/${encodeURIComponent(formType)}/${encodeURIComponent(formSlug)}/items?pageIndex=1&pageSize=200`;
+  const { status, json } = await requestJson('GET', url, { Authorization: `Bearer ${token}` });
+  if (status >= 200 && status < 300 && json) {
+    return json.data || json.items || [];
+  }
+  return [];
+}
+
+async function getFormPublic({ env, token, organizationSlug, formType, formSlug }) {
+  if (!token || !organizationSlug || !formType || !formSlug) return null;
+  // Public form details contains extraOptions/customFields and (for Shop) usually the catalog structure.
+  const url = `${baseUrl(env)}/v5/organizations/${encodeURIComponent(organizationSlug)}/forms/${encodeURIComponent(formType)}/${encodeURIComponent(formSlug)}/public`;
+  const { status, json } = await requestJson('GET', url, { Authorization: `Bearer ${token}` });
+  if (status >= 200 && status < 300) {
+    return json || null;
+  }
+  return null;
+}
+
+function extractCatalogItems(publicFormJson) {
+  if (!publicFormJson || typeof publicFormJson !== 'object') return [];
+
+  // Try a few common shapes used in HelloAsso "public" form responses.
+  const candidates = [];
+  const pushArr = (arr) => {
+    if (Array.isArray(arr)) candidates.push(...arr);
+  };
+
+  pushArr(publicFormJson.items);
+  pushArr(publicFormJson.tiers);
+  pushArr(publicFormJson.products);
+  pushArr(publicFormJson.data);
+  if (publicFormJson.form) {
+    pushArr(publicFormJson.form.items);
+    pushArr(publicFormJson.form.tiers);
+    pushArr(publicFormJson.form.products);
+  }
+
+  // Some responses nest in "campaign" or "publicForm".
+  if (publicFormJson.publicForm) {
+    pushArr(publicFormJson.publicForm.items);
+    pushArr(publicFormJson.publicForm.tiers);
+    pushArr(publicFormJson.publicForm.products);
+  }
+  if (publicFormJson.campaign) {
+    pushArr(publicFormJson.campaign.items);
+    pushArr(publicFormJson.campaign.tiers);
+    pushArr(publicFormJson.campaign.products);
+  }
+
+  // Normalize to { id, name, price }
+  return candidates
+    .map((it) => {
+      if (!it || typeof it !== 'object') return null;
+      const id = it.id ?? it.itemId ?? it.tierId;
+      const name = it.name ?? it.label ?? it.title;
+      const price =
+        (it.amount && (it.amount.total ?? it.amount.value)) ??
+        it.price ??
+        it.unitPrice ??
+        it.totalAmount ??
+        it.initialAmount;
+      if (!id || !name) return null;
+      return { id, name, price: typeof price === 'number' ? price : 0, raw: it };
+    })
+    .filter(Boolean);
+}
+
+async function listCatalogItems({ env, token, organizationSlug, formType, formSlug }) {
+  const publicForm = await getFormPublic({ env, token, organizationSlug, formType, formSlug });
+  const extracted = extractCatalogItems(publicForm);
+  return {
+    publicForm,
+    items: extracted.map(({ id, name, price, raw }) => ({ id, name, price, raw })),
+  };
+}
+
+async function createCheckoutIntent({ env, token, organizationSlug, formType, formSlug, totalAmount, payerEmail, callbackUrl, webhookUrl, itemName, containsDonation, metadata }) {
+  if (!token || !organizationSlug) return null;
+  if (!callbackUrl || !/^https?:\/\//i.test(String(callbackUrl))) {
+    console.warn('[calendar-onekite] HelloAsso invalid return/back/error URL', { callbackUrl });
+    return null;
+  }
+  if (webhookUrl && !/^https?:\/\//i.test(String(webhookUrl))) {
+    console.warn('[calendar-onekite] HelloAsso invalid webhook URL', { webhookUrl });
+  }
+  // Checkout intents are created at organization level.
+  const url = `${baseUrl(env)}/v5/organizations/${encodeURIComponent(organizationSlug)}/checkout-intents`;
+  const payload = {
+    totalAmount: totalAmount,
+    initialAmount: totalAmount,
+    itemName: itemName || 'Réservation matériel',
+    containsDonation: (typeof containsDonation === 'boolean' ? containsDonation : false),
+    payer: payerEmail ? { email: payerEmail } : undefined,
+    metadata: metadata || undefined,
+    backUrl: callbackUrl || '',
+    errorUrl: callbackUrl || '',
+    returnUrl: callbackUrl || '',
+    notificationUrl: webhookUrl || callbackUrl || '',
+  };
+  const { status, json } = await requestJson('POST', url, { Authorization: `Bearer ${token}` }, payload);
+  if (status >= 200 && status < 300 && json) {
+    return { paymentUrl: (json.redirectUrl || json.checkoutUrl || json.url || null), checkoutIntentId: (json.id || json.checkoutIntentId || null), raw: json };
+  }
+  // Log the error payload to help diagnose configuration issues (slug, env, urls, amount, etc.)
+  try {
+    // eslint-disable-next-line no-console
+    console.warn('[calendar-onekite] HelloAsso checkout-intent failed', { status, json });
+  } catch (e) { /* ignore */ }
+  return null;
+}
+
+// Fetch detailed payment information (used to recover metadata when webhook payload is incomplete)
+// HelloAsso exposes GET /payments/{paymentId} in its v5 API.
+async function getPaymentDetails({ env, token, paymentId }) {
+  if (!token || !paymentId) return null;
+  const url = `${baseUrl(env)}/v5/payments/${encodeURIComponent(String(paymentId))}`;
+  const { status, json } = await requestJson('GET', url, { Authorization: `Bearer ${token}` });
+  if (status >= 200 && status < 300) {
+    return json || null;
+  }
+  return null;
+}
+
+
+
+async function getCheckoutIntentDetails({ env, token, organizationSlug, checkoutIntentId }) {
+  if (!token || !organizationSlug || !checkoutIntentId) return null;
+  const url = `${baseUrl(env)}/v5/organizations/${encodeURIComponent(String(organizationSlug))}/checkout-intents/${encodeURIComponent(String(checkoutIntentId))}`;
+  const { status, json } = await requestJson('GET', url, { Authorization: `Bearer ${token}` });
+  if (status >= 200 && status < 300) {
+    return json || null;
+  }
+  return null;
+}
+
+module.exports = {
+  getAccessToken,
+  listItems,
+  getFormPublic,
+  extractCatalogItems,
+  listCatalogItems,
+  createCheckoutIntent,
+  getPaymentDetails,
+  getCheckoutIntentDetails,
+};