Add bulk resolve command

README.md

@@ -16,6 +16,7 @@ A simple Discord bot for manually tracking bets and ROI per user. Each Discord u
 
 - `/bet` opens a modal so users can log bets privately
 - `/resolve` grades a bet as `win`, `loss`, or `void`
+- `/resolveall` grades multiple bet IDs to the same result
 - `/roi` shows net profit, ROI percent, and a cumulative profit chart
 - `/bets` shows total bet count and the latest 5 bets
 - `/summary` shows win/loss totals plus a chart

src/commands.js

@@ -34,6 +34,26 @@ export const commands = [
           { name: 'void', value: 'void' }
         )
     ),
+  new SlashCommandBuilder()
+    .setName('resolveall')
+    .setDescription('Resolve multiple of your tracked bets with the same result.')
+    .addStringOption((option) =>
+      option
+        .setName('bet_ids')
+        .setDescription('Comma-separated bet IDs, for example: 12, 13, 14')
+        .setRequired(true)
+    )
+    .addStringOption((option) =>
+      option
+        .setName('result')
+        .setDescription('The final result for all listed bets.')
+        .setRequired(true)
+        .addChoices(
+          { name: 'win', value: 'win' },
+          { name: 'loss', value: 'loss' },
+          { name: 'void', value: 'void' }
+        )
+    ),
   new SlashCommandBuilder()
     .setName('roi')
     .setDescription('Show your ROI, net profit, and cumulative profit chart.'),

src/embeds.js

@@ -117,6 +117,7 @@ export function buildCommandsEmbed() {
     .addFields(
       { name: '/bet', value: 'Open a private modal to log a new bet.' },
       { name: '/resolve', value: 'Grade one of your bet IDs as win, loss, or void.' },
+      { name: '/resolveall', value: 'Grade multiple bet IDs to the same result in one command.' },
       { name: '/roi', value: 'Show your net profit, ROI %, and cumulative chart.' },
       { name: '/bets', value: 'Show your total tracked bets and latest 5 bets.' },
       { name: '/summary', value: 'Show full totals, record, ROI %, and chart.' },
@@ -172,3 +173,22 @@ export function buildBooksEmbed(bookRows) {
 
   return embed;
 }
+
+export function buildResolveAllEmbed(result, summary) {
+  const colorMap = {
+    win: 0x15803d,
+    loss: 0xb91c1c,
+    void: 0x475569,
+  };
+
+  const embed = new EmbedBuilder()
+    .setColor(colorMap[result] ?? 0x475569)
+    .setTitle(`Bulk resolve complete: ${result.toUpperCase()}`)
+    .addFields(
+      { name: 'Resolved', value: summary.resolved.length > 0 ? summary.resolved.map((id) => `#${id}`).join(', ') : 'None' },
+      { name: 'Already settled', value: summary.alreadyResolved.length > 0 ? summary.alreadyResolved.map((id) => `#${id}`).join(', ') : 'None', inline: true },
+      { name: 'Not found', value: summary.missing.length > 0 ? summary.missing.map((id) => `#${id}`).join(', ') : 'None', inline: true }
+    );
+
+  return embed;
+}

src/index.js

@@ -21,10 +21,12 @@ import {
   buildChartCaption,
   buildCommandsEmbed,
   buildErrorEmbed,
+  buildResolveAllEmbed,
   buildResolveEmbed,
   buildSummaryEmbed,
   buildWelcomeEmbed,
 } from './embeds.js';
+import { parseBetIdList } from './resolve-bulk.js';
 
 const BET_MODAL_PREFIX = 'bet-entry-modal';
 const BET_PROP_INPUT_ID = 'bet-prop';
@@ -119,6 +121,11 @@ async function handleChatInput(interaction, store, config) {
     return;
   }
 
+  if (commandName === 'resolveall') {
+    await handleResolveAll(interaction, store);
+    return;
+  }
+
   if (commandName === 'roi') {
     await handleRoi(interaction, store);
     return;
@@ -266,6 +273,46 @@ async function handleResolve(interaction, store) {
   });
 }
 
+async function handleResolveAll(interaction, store) {
+  const betIdsRaw = interaction.options.getString('bet_ids', true);
+  const result = interaction.options.getString('result', true);
+  const parsedIds = parseBetIdList(betIdsRaw);
+
+  if (!parsedIds.ok) {
+    await interaction.reply({
+      embeds: [buildErrorEmbed('Invalid bet IDs', parsedIds.error)],
+      flags: MessageFlags.Ephemeral,
+    });
+    return;
+  }
+
+  const summary = {
+    resolved: [],
+    alreadyResolved: [],
+    missing: [],
+  };
+
+  for (const betId of parsedIds.ids) {
+    const resolution = await store.resolveBet(interaction.user.id, betId, result);
+    if (resolution.type === 'resolved') {
+      summary.resolved.push(betId);
+      continue;
+    }
+
+    if (resolution.type === 'already_resolved') {
+      summary.alreadyResolved.push(betId);
+      continue;
+    }
+
+    summary.missing.push(betId);
+  }
+
+  await interaction.reply({
+    embeds: [buildResolveAllEmbed(result, summary)],
+    flags: MessageFlags.Ephemeral,
+  });
+}
+
 async function handleRoi(interaction, store) {
   const summary = await store.getUserSummary(interaction.user.id);
   const points = await store.getChartPoints(interaction.user.id);

src/resolve-bulk.js

@@ -0,0 +1,39 @@
+export function parseBetIdList(input) {
+  const tokens = String(input ?? '')
+    .split(/[,\s]+/)
+    .map((token) => token.trim())
+    .filter(Boolean);
+
+  if (tokens.length === 0) {
+    return { ok: false, error: 'Please provide at least one bet ID.' };
+  }
+
+  const ids = [];
+  const invalid = [];
+
+  for (const token of tokens) {
+    if (!/^\d+$/.test(token)) {
+      invalid.push(token);
+      continue;
+    }
+
+    const value = Number(token);
+    if (!Number.isSafeInteger(value) || value <= 0) {
+      invalid.push(token);
+      continue;
+    }
+
+    if (!ids.includes(value)) {
+      ids.push(value);
+    }
+  }
+
+  if (invalid.length > 0) {
+    return {
+      ok: false,
+      error: `Invalid bet ID value(s): ${invalid.join(', ')}`,
+    };
+  }
+
+  return { ok: true, ids };
+}

test/resolve-bulk.test.js

@@ -0,0 +1,24 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { parseBetIdList } from '../src/resolve-bulk.js';
+
+test('parses comma-separated bet ids', () => {
+  const parsed = parseBetIdList('12, 13,14');
+
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.ids, [12, 13, 14]);
+});
+
+test('deduplicates repeated ids', () => {
+  const parsed = parseBetIdList('7 7 8');
+
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.ids, [7, 8]);
+});
+
+test('rejects invalid ids', () => {
+  const parsed = parseBetIdList('4, nope, 6');
+
+  assert.equal(parsed.ok, false);
+  assert.match(parsed.error, /nope/);
+});