nodebb-plugin-calendar-onekite 11.1.25 → 11.1.27

package/lib/helloasso.js

@@ -3,123 +3,114 @@
 const https = require('https');
 const querystring = require('querystring');
 
-function requestJson(method, host, path, headers, body) {
-  return new Promise((resolve, reject) => {
-    const opts = { method, host, path, headers: headers || {} };
-    const req = https.request(opts, (res) => {
-      let data = '';
-      res.on('data', (d) => { data += d; });
-      res.on('end', () => {
-        const ct = res.headers['content-type'] || '';
-        let parsed = null;
-        try { parsed = data ? JSON.parse(data) : null; } catch (e) { /* ignore */ }
-        if (res.statusCode >= 200 && res.statusCode < 300) {
-          resolve({ statusCode: res.statusCode, body: parsed, raw: data, headers: res.headers });
-        } else {
-          const err = new Error('HelloAsso request failed');
-          err.statusCode = res.statusCode;
-          err.body = parsed;
-          err.raw = data;
-          resolve({ statusCode: res.statusCode, body: parsed, raw: data, headers: res.headers, error: err });
-        }
+class HelloAsso {
+  constructor(settings) {
+    this.settings = settings || {};
+    this.tokenCache = null;
+    this.tokenExp = 0;
+  }
+
+  get host() {
+    return this.settings.helloassoEnv === 'production' ? 'api.helloasso.com' : 'api.helloasso-sandbox.com';
+  }
+
+  _request(method, path, { headers = {}, body = null } = {}) {
+    return new Promise((resolve, reject) => {
+      const opts = {
+        method,
+        hostname: this.host,
+        path,
+        headers,
+      };
+      const req = https.request(opts, (res) => {
+        let data = '';
+        res.on('data', (c) => { data += c; });
+        res.on('end', () => {
+          const code = res.statusCode || 0;
+          if (code >= 200 && code < 300) {
+            if (!data) return resolve({});
+            try { return resolve(JSON.parse(data)); } catch (e) { return resolve({ raw: data }); }
+          }
+          return reject(Object.assign(new Error('helloasso_http_' + code), { statusCode: code, body: data }));
+        });
       });
+      req.on('error', reject);
+      if (body) req.write(body);
+      req.end();
     });
-    req.on('error', reject);
-    if (body) req.write(body);
-    req.end();
-  });
-}
+  }
 
-function apiHost(env) {
-  return env === 'sandbox' ? 'api.helloasso-sandbox.com' : 'api.helloasso.com';
-}
+  async getToken() {
+    const now = Date.now();
+    if (this.tokenCache && now < this.tokenExp - 30*1000) return this.tokenCache;
 
-async function getToken(settings) {
-  const host = apiHost(settings.helloassoEnv);
-  const body = querystring.stringify({
-    grant_type: 'client_credentials',
-    client_id: settings.helloassoClientId,
-    client_secret: settings.helloassoClientSecret,
-  });
-  const headers = {
-    'Content-Type': 'application/x-www-form-urlencoded',
-    'Content-Length': Buffer.byteLength(body),
-  };
-  const r = await requestJson('POST', host, '/oauth2/token', headers, body);
-  if (r.error || !r.body || !r.body.access_token) {
-    return { ok: false, error: r.body || r.raw || 'token-error' };
-  }
-  return { ok: true, token: r.body.access_token, expires_in: r.body.expires_in };
-}
+    const clientId = this.settings.helloassoClientId;
+    const clientSecret = this.settings.helloassoClientSecret;
+    if (!clientId || !clientSecret) throw new Error('missing-credentials');
 
-async function getPublicForm(settings, token) {
-  const host = apiHost(settings.helloassoEnv);
-  const path = `/v5/organizations/${encodeURIComponent(settings.helloassoOrganizationSlug)}/forms/${encodeURIComponent(settings.helloassoFormType)}/${encodeURIComponent(settings.helloassoFormSlug)}/public`;
-  const headers = { Authorization: `Bearer ${token}` };
-  return await requestJson('GET', host, path, headers);
-}
+    const body = querystring.stringify({
+      grant_type: 'client_credentials',
+      client_id: clientId,
+      client_secret: clientSecret,
+    });
 
-function extractCatalogItems(publicFormBody) {
-  const out = [];
-  if (!publicFormBody) return out;
-
-  // Try common shapes:
-  // 1) publicFormBody.items
-  // 2) publicFormBody.form && form.items
-  // 3) tiers/products-like lists
-  const candidates = [];
-  if (Array.isArray(publicFormBody.items)) candidates.push(...publicFormBody.items);
-  if (publicFormBody.form && Array.isArray(publicFormBody.form.items)) candidates.push(...publicFormBody.form.items);
-  if (Array.isArray(publicFormBody.products)) candidates.push(...publicFormBody.products);
-  if (Array.isArray(publicFormBody.tiers)) candidates.push(...publicFormBody.tiers);
-
-  for (const it of candidates) {
-    const id = it.id || it.itemId || it.publicId || it.tierId;
-    const name = it.name || it.label || it.title;
-    let priceCents = null;
-
-    // HelloAsso often uses "price" as cents, or "amount" fields.
-    if (typeof it.price === 'number') priceCents = it.price;
-    if (priceCents == null && typeof it.amount === 'number') priceCents = it.amount;
-    if (priceCents == null && it.unitPrice && typeof it.unitPrice === 'number') priceCents = it.unitPrice;
-    if (priceCents == null && it.pricing && typeof it.pricing.price === 'number') priceCents = it.pricing.price;
-
-    if (!id || !name) continue;
-    out.push({ id: String(id), name: String(name), priceCents: Number(priceCents || 0) });
+    const resp = await this._request('POST', '/oauth2/token', {
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+        'Content-Length': Buffer.byteLength(body),
+      },
+      body,
+    });
+
+    this.tokenCache = resp.access_token;
+    this.tokenExp = now + (resp.expires_in ? resp.expires_in*1000 : 3600*1000);
+    return this.tokenCache;
   }
-  // de-dup by id
-  const seen = new Set();
-  return out.filter(x => (seen.has(x.id) ? false : (seen.add(x.id), true)));
-}
 
-async function createCheckoutIntent(settings, token, reservation, payer) {
-  const host = apiHost(settings.helloassoEnv);
-
-  // Minimal checkout-intent for shop: amount + payer + metadata
-  const path = `/v5/organizations/${encodeURIComponent(settings.helloassoOrganizationSlug)}/checkout-intents`;
-  const payload = {
-    totalAmount: reservation.totalCents,
-    initialAmount: reservation.totalCents,
-    returnUrl: reservation.returnUrl || '',
-    errorUrl: reservation.errorUrl || '',
-    metadata: {
-      source: 'nodebb-plugin-calendar-onekite',
-      rid: String(reservation.rid),
-    },
-    payer: payer || {},
-  };
-  const body = JSON.stringify(payload);
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    'Content-Type': 'application/json',
-    'Content-Length': Buffer.byteLength(body),
-  };
-  return await requestJson('POST', host, path, headers, body);
+  async getCatalog() {
+    const org = this.settings.helloassoOrganizationSlug;
+    const formType = this.settings.helloassoFormType || 'shop';
+    const formSlug = this.settings.helloassoFormSlug;
+    if (!org || !formSlug) return { items: [] };
+
+    const token = await this.getToken();
+    const path = `/v5/organizations/${encodeURIComponent(org)}/forms/${encodeURIComponent(formType)}/${encodeURIComponent(formSlug)}/public`;
+    const resp = await this._request('GET', path, {
+      headers: { Authorization: `Bearer ${token}` },
+    });
+
+    // Try to extract items from known shapes
+    const items = [];
+    const pushItem = (id, name, priceCents) => {
+      if (!id || !name) return;
+      items.push({ id: String(id), name: String(name), priceCents: parseInt(priceCents || 0, 10) || 0 });
+    };
+
+    // Common shapes: resp.items / resp.publicForm?.items / resp.tiers / resp.products
+    const candidates = []
+      .concat(resp.items || [])
+      .concat((resp.publicForm && resp.publicForm.items) || [])
+      .concat(resp.tiers || [])
+      .concat(resp.products || [])
+      .concat((resp.shop && resp.shop.products) || []);
+
+    for (const it of candidates) {
+      const id = it.id || it.itemId || it.productId || it.tierId;
+      const name = it.name || it.label || it.title;
+      const price = it.price || it.amount || it.unitPrice || it.minimumAmount || (it.prices && it.prices[0] && it.prices[0].price);
+      pushItem(id, name, price);
+    }
+
+    // Deduplicate by id
+    const seen = new Set();
+    const uniq = [];
+    for (const it of items) {
+      if (seen.has(it.id)) continue;
+      seen.add(it.id);
+      uniq.push(it);
+    }
+    return { items: uniq };
+  }
 }
 
-module.exports = {
-  getToken,
-  getPublicForm,
-  extractCatalogItems,
-  createCheckoutIntent,
-};
+module.exports = HelloAsso;

package/lib/store.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const db = require.main.require('./src/database');
+
+const KEY_NEXT = 'onekite:cal:nextRid';
+const KEY_HASH = (rid) => `onekite:cal:r:${rid}`;
+const KEY_Z_START = 'onekite:cal:z:start';
+const KEY_Z_STATUS = (status) => `onekite:cal:z:status:${status}`;
+const KEY_Z_EXPIRES = 'onekite:cal:z:expires';
+
+function toDayString(ms) {
+  return new Date(ms).toISOString().slice(0, 10);
+}
+
+async function nextRid() {
+  const v = await db.incrObjectField('global', KEY_NEXT);
+  return String(v);
+}
+
+async function setReservation(rid, data) {
+  await db.setObject(KEY_HASH(rid), data);
+}
+
+async function getReservation(rid) {
+  const obj = await db.getObject(KEY_HASH(rid));
+  if (!obj || !obj.rid) return null;
+  // parse
+  obj.startMs = parseInt(obj.startMs, 10);
+  obj.endMs = parseInt(obj.endMs, 10);
+  obj.uid = parseInt(obj.uid, 10);
+  obj.expiresAt = parseInt(obj.expiresAt || '0', 10);
+  obj.days = parseInt(obj.days || '0', 10);
+  obj.totalCents = parseInt(obj.totalCents || '0', 10);
+  try { obj.itemIds = JSON.parse(obj.itemIds || '[]'); } catch (e) { obj.itemIds = []; }
+  return obj;
+}
+
+async function indexReservation(rid, r) {
+  await db.sortedSetAdd(KEY_Z_START, r.startMs, rid);
+  await db.sortedSetAdd(KEY_Z_STATUS(r.status), r.startMs, rid);
+  if (r.expiresAt && r.expiresAt > 0) {
+    await db.sortedSetAdd(KEY_Z_EXPIRES, r.expiresAt, rid);
+  }
+}
+
+async function deindexStatus(rid, oldStatus) {
+  await db.sortedSetRemove(KEY_Z_STATUS(oldStatus), rid);
+}
+
+async function updateStatusIndex(rid, oldStatus, newStatus, startMs) {
+  if (oldStatus) await deindexStatus(rid, oldStatus);
+  await db.sortedSetAdd(KEY_Z_STATUS(newStatus), startMs, rid);
+}
+
+async function removeExpireIndex(rid) {
+  await db.sortedSetRemove(KEY_Z_EXPIRES, rid);
+}
+
+async function createReservation(input) {
+  const rid = await nextRid();
+  const r = {
+    rid,
+    uid: input.uid,
+    startMs: input.startMs,
+    endMs: input.endMs,
+    status: input.status,
+    expiresAt: input.expiresAt || 0,
+    days: input.days || 0,
+    totalCents: input.totalCents || 0,
+    itemIds: JSON.stringify(input.itemIds || []),
+  };
+  await setReservation(rid, r);
+  await indexReservation(rid, r);
+  return rid;
+}
+
+async function updateReservation(rid, patch) {
+  const existing = await getReservation(rid);
+  if (!existing) return null;
+  const updated = Object.assign({}, existing, patch);
+  // indexes
+  if (patch.status && patch.status !== existing.status) {
+    await updateStatusIndex(rid, existing.status, patch.status, existing.startMs);
+  }
+  if (typeof patch.expiresAt !== 'undefined') {
+    await removeExpireIndex(rid);
+    if (patch.expiresAt && patch.expiresAt > 0) {
+      await db.sortedSetAdd(KEY_Z_EXPIRES, patch.expiresAt, rid);
+    }
+  }
+  // persist
+  const obj = Object.assign({}, updated, {
+    itemIds: JSON.stringify(updated.itemIds || existing.itemIds || []),
+  });
+  await setReservation(rid, obj);
+  return updated;
+}
+
+async function listByStatus(status, start, stop) {
+  const ids = await db.getSortedSetRange(KEY_Z_STATUS(status), start, stop);
+  const out = [];
+  for (const rid of ids) {
+    // eslint-disable-next-line no-await-in-loop
+    const r = await getReservation(rid);
+    if (r) out.push(r);
+  }
+  return out;
+}
+
+function overlaps(aStart, aEnd, bStart, bEnd) {
+  return aStart < bEnd && bStart < aEnd;
+}
+
+async function checkConflicts(itemIds, startMs, endMs, blockingStatuses) {
+  // candidates: reservations with start <= endMs
+  const ids = await db.getSortedSetRangeByScore(KEY_Z_START, 0, 2000, 0, endMs);
+  const conflicts = [];
+  for (const rid of ids) {
+    // eslint-disable-next-line no-await-in-loop
+    const r = await getReservation(rid);
+    if (!r) continue;
+    if (!blockingStatuses.has(r.status)) continue;
+    if (!overlaps(startMs, endMs, r.startMs, r.endMs)) continue;
+    const set = new Set(r.itemIds || []);
+    const hit = itemIds.filter(id => set.has(String(id)));
+    if (hit.length) conflicts.push({ rid, status: r.status, itemIds: hit, start: toDayString(r.startMs), end: toDayString(r.endMs) });
+  }
+  return conflicts;
+}
+
+async function getEventsInRange(startMs, endMs) {
+  const ids = await db.getSortedSetRangeByScore(KEY_Z_START, 0, 2000, startMs - 365*24*3600*1000, endMs);
+  const events = [];
+  for (const rid of ids) {
+    // eslint-disable-next-line no-await-in-loop
+    const r = await getReservation(rid);
+    if (!r) continue;
+    if (!overlaps(startMs, endMs, r.startMs, r.endMs)) continue;
+    const icon = r.status === 'pending' ? '⏳' : (r.status === 'refused' ? '⛔' : (r.status === 'awaiting_payment' ? '💳' : '✅'));
+    const title = `${icon} #${r.rid}`;
+    events.push({
+      id: r.rid,
+      title,
+      start: toDayString(r.startMs),
+      end: toDayString(r.endMs),
+      allDay: true,
+      extendedProps: {
+        status: r.status,
+        itemIds: r.itemIds || [],
+        uid: r.uid,
+        days: r.days,
+        totalCents: r.totalCents,
+      },
+    });
+  }
+  return events;
+}
+
+async function sweepExpired() {
+  const now = Date.now();
+  const ids = await db.getSortedSetRangeByScore(KEY_Z_EXPIRES, 0, 500, 0, now);
+  for (const rid of ids) {
+    // eslint-disable-next-line no-await-in-loop
+    const r = await getReservation(rid);
+    if (!r) {
+      // eslint-disable-next-line no-await-in-loop
+      await removeExpireIndex(rid);
+      continue;
+    }
+    if (r.status === 'pending' && r.expiresAt && r.expiresAt <= now) {
+      // eslint-disable-next-line no-await-in-loop
+      await updateReservation(rid, { status: 'expired', expiresAt: 0 });
+    } else {
+      // eslint-disable-next-line no-await-in-loop
+      await removeExpireIndex(rid);
+    }
+  }
+}
+
+async function purgeRange(startMs, endMs) {
+  const ids = await db.getSortedSetRangeByScore(KEY_Z_START, 0, 100000, startMs, endMs);
+  let count = 0;
+  for (const rid of ids) {
+    // eslint-disable-next-line no-await-in-loop
+    const r = await getReservation(rid);
+    if (!r) continue;
+    // eslint-disable-next-line no-await-in-loop
+    await db.delete(KEY_HASH(rid));
+    // eslint-disable-next-line no-await-in-loop
+    await db.sortedSetRemove(KEY_Z_START, rid);
+    // eslint-disable-next-line no-await-in-loop
+    await db.sortedSetRemove(KEY_Z_STATUS(r.status), rid);
+    // eslint-disable-next-line no-await-in-loop
+    await db.sortedSetRemove(KEY_Z_EXPIRES, rid);
+    count++;
+  }
+  return count;
+}
+
+module.exports = {
+  createReservation,
+  getReservation,
+  updateReservation,
+  listByStatus,
+  getEventsInRange,
+  sweepExpired,
+  purgeRange,
+  checkConflicts,
+};