domma-cms 0.112.1 → 0.114.0

package/plugins/support/lib/sender.js

@@ -0,0 +1,213 @@
+/**
+ * Support - the SITE side, on every site the manager started.
+ *
+ * Everything the customer writes goes into this site's outbox FIRST and is then
+ * sent. The manager's token for this site rotates whenever either end restarts,
+ * and for those seconds a send answers 401 or does not connect at all - so a
+ * request is never "sent or lost", it is "sent, or waiting". Waiting ones go
+ * again on the next sync (every few minutes) and whenever the screen is opened.
+ *
+ * Requests are known here by `ref` (made on this site) because a waiting one
+ * has no manager id yet. A follow-up message carries its request's ref, and
+ * waits behind it if the request itself has not gone.
+ *
+ * The outbox also keeps the last view of each request from the manager (for the
+ * sidebar badge, which must never call the manager), which Domma replies this
+ * site has seen, and the contact card the manager last sent.
+ *
+ * @module support/lib/sender
+ */
+import {randomUUID} from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import {lastDommaAt} from './shape.js';
+
+/**
+ * Where this site's manager is, from the environment its manager set.
+ * @returns {{url: string, token: string, slug: string}|null}
+ */
+export function managerOf(env = process.env) {
+    if (!env.MANAGER_URL || !env.FLEET_TOKEN) return null;
+    return {url: String(env.MANAGER_URL).replace(/\/+$/, ''), token: String(env.FLEET_TOKEN), slug: String(env.SITE_SLUG || '')};
+}
+
+export const newRef = () => randomUUID();
+
+/** The outbox, in data/outbox.json. Written whole, through a temp file. */
+export function createOutbox(dataDir) {
+    const file = path.join(dataDir, 'outbox.json');
+    const read = () => {
+        try {
+            const j = JSON.parse(fs.readFileSync(file, 'utf8'));
+            return {
+                items: Array.isArray(j.items) ? j.items : [],
+                seen: j.seen && typeof j.seen === 'object' ? j.seen : {},
+                tickets: Array.isArray(j.tickets) ? j.tickets : [],
+                contact: j.contact && typeof j.contact === 'object' ? j.contact : null
+            };
+        } catch { return {items: [], seen: {}, tickets: [], contact: null}; }
+    };
+    const write = (state) => {
+        fs.mkdirSync(dataDir, {recursive: true});
+        fs.writeFileSync(`${file}.tmp`, JSON.stringify(state, null, 2));
+        fs.renameSync(`${file}.tmp`, file);
+    };
+    const update = (fn) => { const s = read(); const r = fn(s); write(s); return r; };
+    return {
+        all: () => read().items,
+        seen: () => read().seen,
+        tickets: () => read().tickets,
+        contact: () => read().contact,
+        add(kind, payload, ticketRef) {
+            return update(s => {
+                const item = {ref: payload.ref, kind, ticketRef: ticketRef || payload.ref, state: 'waiting', payload,
+                    createdAt: new Date().toISOString(), lastError: ''};
+                s.items.push(item);
+                return item;
+            });
+        },
+        mark(ref, patch) {
+            return update(s => {
+                const item = s.items.find(i => i.ref === ref);
+                if (item) Object.assign(item, patch);
+                return item || null;
+            });
+        },
+        markSeen(ticketRef, at) { update(s => { s.seen[ticketRef] = at; }); },
+        /** The manager's latest view: what the badge reads. Sent items it already has are dropped from the outbox. */
+        remember(remote, contact) {
+            update(s => {
+                s.tickets = remote.map(t => ({ref: t.ref, subject: t.subject, status: t.status, dommaAt: lastDommaAt(t)}));
+                if (contact) s.contact = contact;
+                const byRef = new Map(remote.map(t => [t.ref, t]));
+                const have = new Set(remote.flatMap(t => [t.ref, ...(t.messages || []).map(m => m.id)]));
+                s.items = s.items.filter((i) => {
+                    if (i.state !== 'sent') return true;
+                    if (have.has(i.ref)) return false;                                  // arrived: done with it
+                    const t = byRef.get(i.kind === 'ticket' ? i.ref : i.ticketRef);
+                    if (!t) return true;                                                // not in the view yet
+                    if (i.kind === 'message' && !i.payload?.body) return false;         // a close: no message to look for
+                    // The manager answered 2xx yet its request lacks this message (lost to a concurrent
+                    // write, say): send it again. Not once the conversation is long enough to have trimmed it.
+                    if (i.kind === 'message' && (t.messages || []).length < 500) { i.state = 'waiting'; i.lastError = 'Sent again: it did not arrive.'; }
+                    return true;
+                });
+            });
+        }
+    };
+}
+
+/**
+ * Talk to the manager. `fetchImpl` is swapped in tests; nothing here throws -
+ * every call answers `{ok, status?, body?, error?}`.
+ */
+export function managerApi(manager, fetchImpl = globalThis.fetch) {
+    const call = async (method, route, body) => {
+        try {
+            const res = await fetchImpl(`${manager.url}/api/plugins/support/fleet/${route}`, {
+                method,
+                headers: {authorization: `Bearer ${manager.token}`, ...(body && {'content-type': 'application/json'})},
+                ...(body && {body: JSON.stringify(body)}),
+                signal: AbortSignal.timeout(10_000)
+            });
+            let json = null;
+            try { json = await res.json(); } catch { /* not JSON */ }
+            if (res.status >= 200 && res.status < 300) return {ok: true, status: res.status, body: json};
+            return {ok: false, status: res.status, error: json?.error || `The Domma server answered ${res.status}.`};
+        } catch (err) {
+            return {ok: false, error: `Could not reach the Domma server: ${err.message}`};
+        }
+    };
+    return {
+        open: (payload) => call('POST', 'tickets', payload),
+        message: (payload) => call('POST', 'messages', payload),
+        mine: () => call('GET', 'mine')
+    };
+}
+
+/**
+ * Send whatever is waiting, oldest first. Safe to repeat: the manager answers a
+ * request or message it already has with what it already made.
+ *
+ * @returns {Promise<{sent: number, waiting: number, error: string}>}
+ */
+export function flush(outbox, api) {
+    // One flush at a time per outbox: the timer, the badge's nudge, a screen load and a send can
+    // all ask at once, and two flushes would POST the same waiting item twice.
+    if (!outbox.flushing) outbox.flushing = flushOnce(outbox, api).finally(() => { outbox.flushing = null; });
+    return outbox.flushing;
+}
+
+/** Statuses that mean "try again later"; any other 4xx means the manager will never take it. */
+const RETRY = new Set([401, 408, 429]);
+
+async function flushOnce(outbox, api) {
+    let sent = 0;
+    let error = '';
+    for (const item of outbox.all().filter(i => i.state === 'waiting')) {
+        if (item.kind === 'message') {
+            const parent = outbox.all().find(i => i.kind === 'ticket' && i.ref === item.ticketRef);
+            if (parent?.state === 'waiting') continue;          // goes after its request
+            if (parent?.state === 'refused') { outbox.mark(item.ref, {state: 'refused', lastError: 'Its request was not accepted.'}); continue; }
+        }
+        const r = item.kind === 'ticket' ? await api.open(item.payload) : await api.message(item.payload);
+        if (r.ok) {
+            outbox.mark(item.ref, {state: 'sent', lastError: '', sentAt: new Date().toISOString()});
+            sent++;
+        } else {
+            error = r.error || 'Not sent.';
+            // A 4xx other than 401/408/429 is permanent (400 malformed, 404 its request is gone, 413 too big):
+            // stop retrying it. 401 is a token the manager does not know yet; 5xx and no answer are transient.
+            const permanent = r.status >= 400 && r.status < 500 && !RETRY.has(r.status);
+            outbox.mark(item.ref, {lastError: error, triedAt: new Date().toISOString(), ...(permanent && {state: 'refused'})});
+        }
+    }
+    return {sent, waiting: outbox.all().filter(i => i.state === 'waiting').length, error};
+}
+
+/**
+ * The requests the screen shows: the manager's view of each, plus anything
+ * still waiting here (a request the manager has never seen, or a message it
+ * has not got yet, shown at the end of its conversation as "sending").
+ *
+ * @param {object[]} items - the outbox
+ * @param {object[]|null} remote - the manager's /mine, or null when it could not be reached
+ * @param {Object<string, string>} seen - request ref -> the Domma message time this site has read
+ * @param {object[]} [cached] - the last remote view, used while the manager cannot be reached
+ * @returns {object[]}
+ */
+export function mergeTickets(items, remote, seen = {}, cached = []) {
+    const out = new Map();
+    for (const t of remote || []) {
+        const dommaAt = lastDommaAt(t);
+        out.set(t.ref, {...t, local: false, unread: Boolean(dommaAt && seen[t.ref] !== dommaAt)});
+    }
+    if (!remote) {
+        // Offline: what we last heard, so the list does not empty while the manager restarts.
+        for (const c of cached) {
+            out.set(c.ref, {ref: c.ref, id: '', subject: c.subject, status: c.status, statusLabel: '', messages: [], local: false, stale: true,
+                unread: Boolean(c.dommaAt && seen[c.ref] !== c.dommaAt)});
+        }
+    }
+    for (const i of items) {
+        const p = i.payload || {};
+        if (i.kind === 'ticket' && !out.has(i.ref) && i.state !== 'sent') {
+            out.set(i.ref, {
+                id: '', ref: i.ref, category: p.category, priority: p.priority, subject: p.subject, where: p.where || '',
+                userName: p.user?.name || '', status: i.state === 'refused' ? 'refused' : 'waiting',
+                statusLabel: i.state === 'refused' ? 'Not accepted' : 'Waiting to send',
+                messages: [{id: i.ref, from: 'customer', name: p.user?.name || '', body: p.body, at: i.createdAt, pending: true}],
+                lastFrom: 'customer', lastAt: i.createdAt, createdAt: i.createdAt, updatedAt: i.createdAt,
+                local: true, unread: false, lastError: i.lastError || ''
+            });
+        }
+        if (i.kind === 'message' && i.state !== 'sent' && p.body) {
+            const t = out.get(i.ticketRef);
+            if (t && !(t.messages || []).some(m => m.id === i.ref)) {
+                t.messages = [...(t.messages || []), {id: i.ref, from: 'customer', name: p.user?.name || '', body: p.body, at: i.createdAt,
+                    pending: i.state === 'waiting', refused: i.state === 'refused'}];
+            }
+        }
+    }
+    return [...out.values()].sort((a, b) => String(b.lastAt || b.createdAt).localeCompare(String(a.lastAt || a.createdAt)));
+}

package/plugins/support/lib/shape.js

@@ -0,0 +1,302 @@
+/**
+ * Support - the pure half: what a request is, what a conversation holds, what
+ * each side may say, and the emails both sides get.
+ *
+ * Nothing here touches the disk, the network or the clock (callers pass `now`),
+ * so all of it is tested on its own (tests/shape.test.js).
+ *
+ * A request is a CONVERSATION: the customer's opening message, then turns from
+ * either side. Its status follows whose turn it is:
+ *
+ *   open      waiting on Domma   - a new request, or the customer wrote again
+ *   answered  waiting on you     - Domma replied
+ *   closed    resolved           - either side said so; writing again reopens it
+ *
+ * @module support/lib/shape
+ */
+
+/** What a request is about. The icon is a Domma icon name. */
+export const CATEGORIES = [
+    {key: 'help', label: 'I need help with something', short: 'Help', icon: 'help-circle'},
+    {key: 'problem', label: 'Something is not working', short: 'Problem', icon: 'alert-triangle'},
+    {key: 'billing', label: 'Billing or my account', short: 'Billing', icon: 'credit-card'},
+    {key: 'other', label: 'Something else', short: 'Other', icon: 'message-square'}
+];
+
+export const PRIORITIES = [
+    {key: 'normal', label: 'Normal', hint: 'We answer in order, usually within a working day.'},
+    {key: 'urgent', label: 'Urgent', hint: 'My site is down, or I cannot take orders, bookings or payments.'}
+];
+
+export const STATUSES = [
+    {key: 'open', label: 'Waiting on Domma', inboxLabel: 'Open', tone: 'warning'},
+    {key: 'answered', label: 'Domma replied', inboxLabel: 'Answered', tone: 'info'},
+    {key: 'closed', label: 'Resolved', inboxLabel: 'Resolved', tone: 'success'}
+];
+
+export const CATEGORY_KEYS = CATEGORIES.map(c => c.key);
+export const PRIORITY_KEYS = PRIORITIES.map(p => p.key);
+export const STATUS_KEYS = STATUSES.map(s => s.key);
+export const statusLabel = (key) => STATUSES.find(s => s.key === key)?.label ?? key;
+export const categoryLabel = (key) => CATEGORIES.find(c => c.key === key)?.short ?? key;
+
+/** Longest a field may be. The routes' bodyLimit (32 KB) is the outer wall. */
+export const LIMITS = {subject: 140, body: 8000, where: 300, notes: 8000, messages: 500};
+
+// Control characters go (all but tab and newline): each is 6 bytes once JSON-escaped, so 8000 of them
+// would pass here and then be refused by the manager's 32 KB body limit, forever.
+const text = (v, max) => String(v ?? '').replace(/\r\n?/g, '\n').replace(/[\u0000-\u0008\u000B-\u001F\u007F]/g, '').trim().slice(0, max);
+const line = (v, max) => text(v, max).replace(/\s*\n\s*/g, ' ');
+const EMAIL_RE = /^[^\s@<>"]+@[^\s@<>"]+\.[^\s@<>"]+$/;
+
+/**
+ * A new request as the customer typed it, cleaned. Never carries who sent it -
+ * that comes from the signed-in user on the server, not from the form.
+ *
+ * @param   {object} body
+ * @returns {{request?: object, error?: string}}
+ */
+export function cleanRequest(body = {}) {
+    const category = CATEGORY_KEYS.includes(body.category) ? body.category : 'help';
+    const priority = PRIORITY_KEYS.includes(body.priority) ? body.priority : 'normal';
+    const subject = line(body.subject, LIMITS.subject);
+    const message = text(body.body, LIMITS.body);
+    if (!subject) return {error: 'Give it a short subject.'};
+    if (!message) return {error: 'Tell us what you need.'};
+    return {request: {category, priority, subject, body: message, where: line(body.where, LIMITS.where)}};
+}
+
+/** One more message in a conversation. */
+export function cleanMessage(body = {}) {
+    const message = text(body.body, LIMITS.body);
+    if (!message) return {error: 'Write a message first.'};
+    return {message: {body: message}};
+}
+
+const who = (user = {}) => ({id: text(user.id, 64), name: line(user.name, 120), email: text(user.email, 200)});
+
+/**
+ * What a site sends the manager for a new request. `site` is informational
+ * only - the manager files it under the site its token names.
+ */
+export function buildTicketPayload({request, user = {}, cmsVersion = '', site = '', ref}) {
+    return {ref: text(ref, 64), ...request, cmsVersion: text(cmsVersion, 20), site: text(site, 64), user: who(user)};
+}
+
+/** What a site sends for another message, or to close a request (`body` empty, `close: true`). */
+export function buildMessagePayload({ticketRef, ref, body = '', close = false, user = {}}) {
+    return {ticketRef: text(ticketRef, 64), ref: text(ref, 64), body: text(body, LIMITS.body), close: Boolean(close), user: who(user)};
+}
+
+/**
+ * A request as the MANAGER stores it. The slug is the one the token resolved
+ * to; anything the body claims about the site is ignored.
+ *
+ * @param   {object} payload
+ * @param   {string} slug
+ * @param   {string} now - ISO time
+ * @returns {{data?: object, error?: string}}
+ */
+export function receivedTicket(payload = {}, slug, now) {
+    const {request, error} = cleanRequest(payload);
+    if (error) return {error};
+    const u = who(payload.user && typeof payload.user === 'object' ? payload.user : {});
+    const ref = text(payload.ref, 64);
+    return {
+        data: {
+            category: request.category,
+            priority: request.priority,
+            subject: request.subject,
+            where: request.where,
+            site: slug,
+            ref,
+            cmsVersion: text(payload.cmsVersion, 20),
+            userId: u.id,
+            userName: u.name || 'A site admin',
+            userEmail: EMAIL_RE.test(u.email) ? u.email : '',
+            status: 'open',
+            messages: [{id: ref || 'm0', from: 'customer', name: u.name || 'A site admin', body: request.body, at: now}],
+            lastFrom: 'customer',
+            lastAt: now,
+            notes: '',
+            history: [{at: now, by: u.name || 'A site admin', what: 'Opened'}]
+        }
+    };
+}
+
+/**
+ * Add a turn to a conversation, PURE: returns the new data. A message whose id
+ * is already there (a retry that did arrive) changes nothing.
+ *
+ * @param {object} data - the stored request
+ * @param {{from: 'customer'|'domma', name: string, body?: string, id: string, at: string, status?: string, close?: boolean}} turn
+ * @returns {{data: object, added: boolean}}
+ */
+export function addTurn(data, {from, name, body = '', id, at, status, close = false}) {
+    const messages = Array.isArray(data.messages) ? [...data.messages] : [];
+    if (id && messages.some(m => m.id === id)) return {data, added: false};
+    const history = Array.isArray(data.history) ? [...data.history] : [];
+    const next = {...data};
+    let added = false;
+    if (body) {
+        messages.push({id, from, name, body, at});
+        next.lastFrom = from;
+        next.lastAt = at;
+        added = true;
+        history.push({at, by: name, what: from === 'domma' ? 'Replied' : 'Wrote'});
+    }
+    // Whose turn it is now. Domma may choose (answered, or closed); the customer reopens by writing.
+    let to = data.status;
+    if (close) to = 'closed';
+    else if (from === 'customer' && body) to = 'open';
+    else if (from === 'domma') to = STATUS_KEYS.includes(status) ? status : (body ? 'answered' : data.status);
+    if (to !== data.status) {
+        history.push({at, by: name, what: to === 'closed' ? 'Resolved' : to === 'open' && data.status === 'closed' ? 'Reopened' : `Status: ${statusLabel(to)}`});
+        added = true;
+    }
+    next.status = to;
+    next.messages = messages.slice(-LIMITS.messages);
+    next.history = history.slice(-200);
+    return {data: next, added};
+}
+
+/**
+ * What a site may read of one of its own requests. A whitelist: internal notes,
+ * history and other sites stay on the manager.
+ */
+export function senderView(entry) {
+    const d = entry?.data || {};
+    return {
+        id: entry.id,
+        ref: d.ref || '',
+        category: d.category,
+        priority: d.priority,
+        subject: d.subject,
+        where: d.where || '',
+        userName: d.userName || '',
+        status: d.status,
+        statusLabel: statusLabel(d.status),
+        messages: (d.messages || []).map(m => ({id: m.id, from: m.from, name: m.name, body: m.body, at: m.at})),
+        lastFrom: d.lastFrom || 'customer',
+        lastAt: d.lastAt || '',
+        createdAt: entry.meta?.createdAt || '',
+        updatedAt: entry.meta?.updatedAt || ''
+    };
+}
+
+/** The newest message from Domma, for "unread" - its time, or ''. */
+export function lastDommaAt(ticket) {
+    const ms = (ticket?.messages || []).filter(m => m.from === 'domma');
+    return ms.length ? String(ms[ms.length - 1].at || '') : '';
+}
+
+/** What the inbox may change without writing: status and internal notes. */
+export function cleanUpdate(body = {}) {
+    const patch = {};
+    if (body.status !== undefined) {
+        if (!STATUS_KEYS.includes(body.status)) return {error: 'That is not a status.'};
+        patch.status = body.status;
+    }
+    if (body.notes !== undefined) patch.notes = text(body.notes, LIMITS.notes);
+    if (body.priority !== undefined) {
+        if (!PRIORITY_KEYS.includes(body.priority)) return {error: 'That is not a priority.'};
+        patch.priority = body.priority;
+    }
+    if (!Object.keys(patch).length) return {error: 'Nothing to change.'};
+    return {patch};
+}
+
+/**
+ * The contact card every site shows, from settings. Only what is safe and
+ * well-formed gets through: an email that looks like one, a phone of phone
+ * characters, short plain text otherwise.
+ */
+export function contactCard(s = {}) {
+    const email = text(s.email, 200);
+    const phone = line(s.phone, 40);
+    return {
+        email: EMAIL_RE.test(email) ? email : '',
+        phone: /^[+\d][\d\s().-]{4,}$/.test(phone) ? phone : '',
+        hours: line(s.hours, 200),
+        responseTime: line(s.responseTime, 300)
+    };
+}
+
+/** The tel: form of a phone number. */
+export const telHref = (phone) => `tel:${String(phone || '').replace(/[^\d+]/g, '')}`;
+
+/**
+ * How many a site may send: `max` in any `windowMs`. The manager's global
+ * limiter exempts loopback, which is where every site calls from, so this is
+ * the only brake.
+ */
+export function createThrottle({max = 20, windowMs = 10 * 60_000} = {}) {
+    const seen = new Map();
+    return (key, now = Date.now()) => {
+        const recent = (seen.get(key) || []).filter(t => now - t < windowMs);
+        if (recent.length >= max) { seen.set(key, recent); return false; }
+        recent.push(now);
+        seen.set(key, recent);
+        return true;
+    };
+}
+
+// ---------------------------------------------------------------------------------
+// Emails
+// ---------------------------------------------------------------------------------
+
+export const escapeHtml = (s) => String(s ?? '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
+
+/** A plain message: paragraphs, a quoted block and a button. Everything escaped. */
+function compose({intro = [], quote = '', facts = [], link = '', linkText = 'Open'}) {
+    const text = [
+        ...intro, '',
+        ...(quote ? [quote.split('\n').map(l => `> ${l}`).join('\n'), ''] : []),
+        ...facts.map(([k, v]) => `${k}: ${v}`),
+        ...(link ? ['', `${linkText}: ${link}`] : [])
+    ].join('\n');
+    const html = `<div style="font-family:system-ui,-apple-system,Segoe UI,Roboto,sans-serif;font-size:15px;line-height:1.5;color:#1f2937;max-width:600px">
+${intro.map(p => `<p>${escapeHtml(p)}</p>`).join('\n')}
+${quote ? `<blockquote style="margin:16px 0;padding:12px 16px;border-left:3px solid #6366f1;background:#f5f5ff;white-space:pre-wrap">${escapeHtml(quote)}</blockquote>` : ''}
+${facts.length ? `<table style="font-size:13px;color:#4b5563">${facts.map(([k, v]) => `<tr><td style="padding:2px 12px 2px 0">${escapeHtml(k)}</td><td>${escapeHtml(v)}</td></tr>`).join('')}</table>` : ''}
+${link ? `<p style="margin-top:20px"><a href="${escapeHtml(link)}" style="background:#4f46e5;color:#fff;padding:10px 18px;border-radius:6px;text-decoration:none">${escapeHtml(linkText)}</a></p>` : ''}
+</div>`;
+    return {text, html};
+}
+
+/**
+ * To Domma: a site opened a request, or wrote again. Reply-To is the customer,
+ * so answering from the mailbox reaches them - but the inbox link is the way to
+ * keep the conversation in one place.
+ */
+export function toDommaEmail({ticket, siteName, link, body, isNew}) {
+    const urgent = ticket.priority === 'urgent';
+    const subject = `${urgent ? '[URGENT] ' : ''}${isNew ? 'Support request' : 'Reply'} from ${siteName}: ${ticket.subject}`;
+    return {
+        subject,
+        replyTo: ticket.userEmail || '',
+        ...compose({
+            intro: [isNew ? `${ticket.userName} at ${siteName} needs help.` : `${ticket.userName} at ${siteName} wrote again.`],
+            quote: body,
+            facts: [['Site', siteName], ['Category', categoryLabel(ticket.category)], ['Priority', urgent ? 'URGENT' : 'Normal'],
+                ...(ticket.where ? [['Where', ticket.where]] : []), ...(ticket.cmsVersion ? [['CMS', ticket.cmsVersion]] : []),
+                ...(ticket.userEmail ? [['Email', ticket.userEmail]] : [])],
+            link, linkText: 'Open in the Support inbox'
+        })
+    };
+}
+
+/** To the customer: Domma replied (or resolved the request). */
+export function toCustomerEmail({ticket, siteName, link, body, resolved}) {
+    return {
+        subject: `Re: ${ticket.subject}`,
+        ...compose({
+            intro: [`Hello ${ticket.userName || ''}`.trim() + ',',
+                body ? 'Domma Support has replied to your request.' : 'Domma Support has marked your request as resolved.',
+                ...(resolved && body ? ['We have marked it as resolved. If it is not, just reply in your admin and it reopens.'] : [])],
+            quote: body,
+            facts: [['Request', ticket.subject], ['Site', siteName]],
+            link, linkText: 'Open it in your admin'
+        })
+    };
+}