create-chapterjs 0.2.3 → 0.3.0

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"
+    }
+  ]
+}