create-chapterjs 0.2.2 → 0.3.0

package/templates/tickets/src/tickets/messages.ts

@@ -0,0 +1,68 @@
+import { language } from 'chapterjs';
+
+// The texts of the bot, one language() per language. `t` picks the one of
+// who will read the message: the person for a private answer, the server
+// otherwise. `commands` is what Discord shows of each command.
+export const en = language({
+  locale: 'en-US',
+  default: true,
+  texts: {
+    panelTitle: 'Need help?',
+    panelText:
+      'Open a ticket and the staff will answer you in a private thread.',
+    panelPosted: 'The panel is posted.',
+    openButton: 'Open a ticket',
+    formTitle: 'New ticket',
+    formSubject: 'Subject',
+    formCategory: 'What is it about?',
+    formDetails: 'Tell us more',
+    notHere: 'Tickets can only be opened from a text channel.',
+    opened: 'Thanks {user}, the staff will be with you shortly.',
+    created: 'Your ticket is open: {thread}',
+    alreadyOpen: 'You already have a ticket open: {thread}. Close it first.',
+    category: 'Category',
+    openedBy: 'Opened by',
+    closeButton: 'Close the ticket',
+    notATicket: 'This button only works inside a ticket.',
+    notYours: 'Only the staff, or who opened this ticket, can close it.',
+    closing: 'Ticket closed by {user}.',
+    closedDm: 'Your ticket "{ticket}" on {server} was closed.',
+  },
+  commands: {
+    'ticket panel': {
+      description: 'Posts the message people open tickets from',
+    },
+  },
+});
+
+export const fr = language({
+  locale: 'fr',
+  texts: {
+    panelTitle: 'Besoin d’aide ?',
+    panelText: 'Ouvrez un ticket et le staff vous répondra dans un fil privé.',
+    panelPosted: 'Le panneau est posté.',
+    openButton: 'Ouvrir un ticket',
+    formTitle: 'Nouveau ticket',
+    formSubject: 'Sujet',
+    formCategory: 'De quoi s’agit-il ?',
+    formDetails: 'Dites-nous en plus',
+    notHere: 'Un ticket ne peut être ouvert que depuis un salon textuel.',
+    opened: 'Merci {user}, le staff arrive.',
+    created: 'Votre ticket est ouvert : {thread}',
+    alreadyOpen:
+      'Vous avez déjà un ticket ouvert : {thread}. Fermez-le d’abord.',
+    category: 'Catégorie',
+    openedBy: 'Ouvert par',
+    closeButton: 'Fermer le ticket',
+    notATicket: 'Ce bouton ne fonctionne que dans un ticket.',
+    notYours:
+      'Seul le staff, ou la personne qui a ouvert ce ticket, peut le fermer.',
+    closing: 'Ticket fermé par {user}.',
+    closedDm: 'Votre ticket « {ticket} » sur {server} a été fermé.',
+  },
+  commands: {
+    'ticket panel': {
+      description: 'Poste le message depuis lequel on ouvre un ticket',
+    },
+  },
+});

package/templates/tickets/src/tickets/open.ts

@@ -0,0 +1,81 @@
+import { ChannelType, modal, store } from 'chapterjs';
+import { close } from './close';
+
+// The ticket each person has open: the id of its thread, by person. A
+// store keeps data from one restart to the next, per server: in this
+// server, `tickets.get(member.id)` is the ticket of that member here.
+export const tickets = store<string>();
+
+// The form a ticket starts with. `run` receives the fields typed from
+// their kind: `subject` and `details` are strings, `category` is one of
+// the three values below.
+export const openTicket = modal({
+  title: ({ t }) => t('formTitle'),
+  fields: {
+    subject: {
+      type: 'text',
+      label: ({ t }) => t('formSubject'),
+      style: 'short',
+      maxLength: 80,
+    },
+    category: {
+      type: 'radio',
+      label: ({ t }) => t('formCategory'),
+      options: { Bug: 'bug', Question: 'question', Other: 'other' },
+    },
+    details: {
+      type: 'text',
+      label: ({ t }) => t('formDetails'),
+      style: 'paragraph',
+      minLength: 20,
+      maxLength: 1000,
+    },
+  },
+  async run({ interaction, fields, channel, member, t }) {
+    if (!channel.isText()) {
+      await interaction.reply({ content: t('notHere'), ephemeral: true });
+      return;
+    }
+    // One ticket at a time per person.
+    const open = await tickets.get(member.id);
+    if (open) {
+      await interaction.reply({
+        content: t('alreadyOpen', { thread: `<#${open}>` }),
+        ephemeral: true,
+      });
+      return;
+    }
+    // A private thread: only the people added to it, and the staff, see it.
+    const thread = await channel.startThread(
+      {
+        name: `${fields.category}-${member.displayName}`.slice(0, 100),
+        type: ChannelType.PrivateThread,
+        invitable: false,
+      },
+      `Ticket opened by ${member.user.username}`
+    );
+    await thread.addMember(member);
+    await tickets.set(member.id, thread.id);
+    await thread.send({
+      content: t('opened', { user: member.toString() }),
+      embeds: [
+        {
+          title: fields.subject,
+          description: fields.details,
+          color: 0xc026d3,
+          fields: [
+            { name: t('category'), value: fields.category, inline: true },
+            { name: t('openedBy'), value: member.toString(), inline: true },
+          ],
+        },
+      ],
+      // The close button carries who opened the ticket, so it knows who may
+      // close it besides the staff, and who to tell when it is closed.
+      components: [close({ userId: member.id })],
+    });
+    await interaction.reply({
+      content: t('created', { thread: thread.toString() }),
+      ephemeral: true,
+    });
+  },
+});

package/templates/tickets/src/tickets/panel.ts

@@ -0,0 +1,35 @@
+import { button, command } from 'chapterjs';
+import { openTicket } from './open';
+
+// /ticket panel posts the message people open a ticket from: an embed and
+// a button. Only the staff can post it (`permissions`); Discord hides the
+// command from everyone else. `t` speaks the language of the server.
+export default command({
+  name: 'ticket panel',
+  permissions: ['ManageThreads'],
+  async run({ interaction, channel, t }) {
+    await channel.send({
+      embeds: [
+        {
+          title: t('panelTitle'),
+          description: t('panelText'),
+          color: 0xc026d3,
+        },
+      ],
+      components: [open],
+    });
+    await interaction.reply({ content: t('panelPosted'), ephemeral: true });
+  },
+});
+
+// A button is named by its export (`open`): nothing to register, no id to
+// write. Its label is a function of `t`, run when the message is sent.
+export const open = button({
+  label: ({ t }) => t('openButton'),
+  style: 'primary',
+  emoji: '🎫',
+  async run({ interaction }) {
+    // A form must be the first answer to a click.
+    await interaction.showModal(openTicket);
+  },
+});

package/templates/tickets/src/tickets/tickets.test.ts

@@ -0,0 +1,72 @@
+import { scenario } from 'chapterjs/test';
+import { close } from './close';
+import { openTicket } from './open';
+import panel, { open } from './panel';
+
+// `chapterjs test` runs these against a Discord in memory: no token, no
+// server. `bot` is this bot in a test server, with people you name.
+export default [
+  scenario('the panel is posted by the staff only', async bot => {
+    const refused = await bot.use(panel);
+    refused.isEphemeral().says('ManageThreads');
+
+    const staff = bot.member('staff', { permissions: ['ManageThreads'] });
+    const reply = await bot.use(panel, {}, { by: staff });
+    reply.isEphemeral().says('The panel is posted.');
+    bot
+      .channel('general')
+      .last!.hasEmbed('Need help?')
+      .hasButton('Open a ticket');
+  }),
+
+  scenario('a ticket opens in a private thread, once per person', async bot => {
+    const click = await bot.click(open);
+    click.opensForm(openTicket);
+
+    const reply = await bot.submit(openTicket, {
+      subject: 'No sound',
+      category: 'bug',
+      details: 'The music stops after a minute, every single time.',
+    });
+    reply.isEphemeral().says('Your ticket is open');
+    const [thread] = bot.channel('general').threads;
+    thread!
+      .last!.says('Thanks')
+      .hasEmbed('No sound')
+      .hasButton('Close the ticket');
+
+    const again = await bot.submit(openTicket, {
+      subject: 'Another one',
+      category: 'question',
+      details: 'Can I open two tickets at the same time, please?',
+    });
+    again.isEphemeral().says('You already have a ticket open');
+  }),
+
+  scenario('only the staff or who opened a ticket closes it', async bot => {
+    await bot.click(open);
+    await bot.submit(openTicket, {
+      subject: 'Login',
+      category: 'other',
+      details: 'I can not log in since this morning, what can I do?',
+    });
+    const [thread] = bot.channel('general').threads;
+    const ticket = thread!.last!;
+
+    const stranger = await bot.click(ticket.button('Close the ticket'), {
+      by: bot.member('stranger'),
+      in: thread,
+      on: ticket,
+    });
+    stranger.isEphemeral().says('Only the staff');
+
+    const closed = await bot.click(ticket.button('Close the ticket'), {
+      in: thread,
+      on: ticket,
+    });
+    closed.isPublic().says('Ticket closed by');
+    if (!thread!.archived || !thread!.locked) {
+      throw new Error('The thread should be archived and locked.');
+    }
+  }),
+];

package/templates/tickets/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "erasableSyntaxOnly": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "files": [],
+  "references": [
+    {
+      "path": "./.chapterjs"
+    }
+  ]
+}