Stockage

import { command, store } from 'chapterjs';

interface Warning {
  reason: string;
  by: string;
  at: number;
}

export const warnings = store<Warning[]>({ expires: '30d' });

export default command({
  name: 'warn',
  description: 'Avertit un membre',
  permissions: ['ModerateMembers'],
  options: {
    who: { type: 'user', description: 'Qui', required: true },
    reason: { type: 'string', description: 'Pourquoi', required: true },
  },
  async run({ interaction, options, user }) {
    const list = await warnings.update(options.who.id, (list = []) => [
      ...list,
      { reason: options.reason, by: user.id, at: Date.now() },
    ]);
    await interaction.reply(
      `${options.who} a maintenant ${list.length} avertissement(s). Le dernier : ${options.reason}`
    );
  },
});

import { task } from 'chapterjs';
import { warnings } from './warn';

export default task({
  cron: '0 9 * * 1',
  async run({ guilds }) {
    for (const guild of guilds.values()) {
      const entries = await warnings.in(guild).entries();
      const total = entries.reduce((sum, entry) => sum + entry.value.length, 0);
      console.log(`${guild.name} : ${total} avertissement(s) sur ${entries.length} membre(s)`);
    }
  },
});

import { command, timestamp } from 'chapterjs';
import { warnings } from './warn';

export default command({
  name: 'warnings',
  description: 'Liste les avertissements d’un membre',
  permissions: ['ModerateMembers'],
  options: {
    who: { type: 'user', description: 'Qui', required: true },
  },
  async run({ interaction, options }) {
    const list = (await warnings.get(options.who.id)) ?? [];
    if (list.length === 0) {
      await interaction.reply({ content: `${options.who} n’a aucun avertissement.`, ephemeral: true });
      return;
    }
    await interaction.reply({
      content: list
        .map(warning => `${timestamp(warning.at, 'R')} par <@${warning.by}> : ${warning.reason}`)
        .join('\n'),
      ephemeral: true,
    });
  },
});

import { command, event, ranking } from 'chapterjs';

export const talkers = ranking();

export const count = event({
  name: 'messageCreate',
  async run({ message }) {
    await talkers.add(message.author.id, 1);
  },
});

export default command({
  name: 'talkers',
  description: 'Montre qui a écrit le plus de messages ici',
  async run({ interaction }) {
    const best = await talkers.top(5);
    const lines = best.map(entry => `${entry.rank}. <@${entry.id}> : ${entry.score} messages`);
    await interaction.reply({
      content: lines.length > 0 ? lines.join('\n') : 'Personne n’a encore rien écrit.',
      ephemeral: true,
    });
  },
});