WIP: receipt feature implementation

commands/utility/receiptCommands.js

@@ -0,0 +1,52 @@
+const { SlashCommandBuilder, EmbedBuilder } = require('discord.js');
+
+module.exports = {
+    category: 'utility',
+    global: true,
+    data: new SlashCommandBuilder()
+        .setName('budget')
+        .setDescription('The thing')
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('set')
+                .setDescription('Set weekly budget')
+                .addIntegerOption(option =>
+                    option.setName('amount')
+                        .setRequired(true)
+                        .setDescription('Amount as int'))
+        )
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('show')
+                .setDescription('not implemented')
+        ),
+    async execute(interaction) {
+        console.log('budget command entrypoint');
+        let db = await interaction.client.localDB;
+        let discordId = interaction.member.id;
+        console.log(db, discordId);
+        let allowed = ['372115788498468864', '222457277708369928'].includes(discordId);
+        console.log(allowed);
+        if (!allowed) {
+            console.log('budget command denied');
+            await interaction.reply('This command may only be invoked by Miffy!');
+            return;
+		}
+        console.log(`Switcching on sub ${interaction.options.getSubcommand()}`);
+        switch (interaction.options.getSubcommand()) {
+            case 'set':
+                console.log('budget command set');
+                let budget = interaction.options.get('amount').value
+                db.prepare(`INSERT OR REPLACE INTO bot_config (id, weekly_budget) VALUES (1, ?)`).run(budget);
+                await interaction.reply(`Budget set to ${budget}`);
+                break;
+                case 'show':
+                console.log('budget command show');
+                await interaction.reply('Not implemented');
+                break
+            default:
+                await interaction.reply(`Sub mismatch. Switching on ${interaction.options.getSubcommand()}`);
+                break;
+        }
+    },
+};

core/db.js

@@ -1,20 +1,21 @@
 const fs = require("fs");
-const sqlite3 = require("sqlite3").verbose();
+const Database = require("better-sqlite3");
+const path = require("path");
 const { open } = require('sqlite');
 const filepath = "./data/minzbot.db";
 
 async function createDbConnection() {
-    if (fs.existsSync(filepath)) {
+    const dir = path.dirname(filepath);
-        //new sqlite3.Database(filepath);
+    if (!fs.existsSync(dir)) {
-        const db = await open({filename: filepath, driver: sqlite3.Database});
+        fs.mkdirSync(dir, { recursive: true });
-        await initDB(db);
-        return db;
-    } else {
-        const db = await open({filename: filepath, driver: sqlite3.Database});
-        await initDB(db);
-        console.log("[DATABASE] Connection with SQLite has been established");
-        return db;
     }
+
+    const db = new Database(filepath, { verbose: console.log });
+
+    initDB(db);
+
+    console.log("[DATABASE] Connection with better-sqlite3 established");
+    return db;
 }
 
 async function initDB(db) {
@@ -33,7 +34,29 @@ async function initDB(db) {
             lastfm_name TEXT
         );
     `);
+    await db.exec(`
+        CREATE TABLE IF NOT EXISTS bot_config (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            weekly_budget REAL DEFAULT 0,
+            exchange_rate_eur_kr REAL DEFAULT 0,
+            last_budget_notification_date TEXT
+        );
+    `);
+    await db.exec(`
+        CREATE TABLE IF NOT EXISTS grocery_budgets (
+            ID INTEGER PRIMARY KEY AUTOINCREMENT,
+            discord_id   VARCHAR(50) NOT NULL,
+            budget_spent REAL,
+            total_spent REAL
+        );
+    `);
+
+    // Optional: Initialize the row if it doesn't exist yet
+    await db.exec(`
+        INSERT OR IGNORE INTO bot_config (id, weekly_budget, last_budget_notification_date) 
+        VALUES (1, 0, NULL);
+    `);
     console.log('[DATABASE] Created new DB table');
 }
 
-module.exports = createDbConnection();
+module.exports = createDbConnection;

deploy-commands.js

@@ -36,14 +36,14 @@ const rest = new REST().setToken(token);
 // and deploy your commands!
 (async () => {
 	try {
-		console.log(`[GUILD] Started refreshing ${guildCommands.length} application (/) commands.`);
+		console.log(`[GUILD] Started refreshing ${guildCommands.length} Guild (/) commands.`);
 
 		let data = await rest.put(
 			Routes.applicationGuildCommands(clientId, guildId),
 			{ body: guildCommands },
 		);
 
-		console.log(`[GUILD] Successfully reloaded ${data.length} application (/) commands.`);
+		console.log(`[GUILD] Successfully reloaded ${data.length} Guild (/) commands.`);
 
 		console.log(`[GLOBAL] Started refreshing ${globalCommands.length} application (/) commands.`);
 

events/receiptsMessageCreate.js

@@ -0,0 +1,46 @@
+const { Events, channelLink, discordSort } = require('discord.js');
+
+module.exports = {
+	name: Events.MessageCreate,
+	async execute(message) {
+        if (message.author.bot) return;
+
+        if(message.channel.id === '1462060674766344370') {
+
+            let reply = "";
+            let db = await message.client.localDB;
+            const receiptsChannel = message.channel; 
+            const authorId = message.author.id;
+            
+            let budgets = await db.prepare(`SELECT * FROM grocery_budgets WHERE discord_id = ?`).get(authorId);
+            let weeklyBudget = await (await db.prepare(`SELECT weekly_budget FROM bot_config`).get()).weekly_budget;
+            
+            console.log(weeklyBudget, budgets);
+            if (budgets === undefined) {
+                console.log(`No budget row in db for ${authorId}`);
+                db.prepare(`INSERT OR REPLACE INTO grocery_budgets (discord_id, budget_spent, total_spent) VALUES (?,0,0)`).run(authorId);
+            }
+
+            let matches = [];
+            let lines = message.content.split("\n");
+            let additionalSpent = 0.0;
+            lines.forEach(line => {0
+                if (line.startsWith('-')) {
+                    console.log(`Matching on line ${line}`);
+                    const regex = /-(?=[0-9])([0-9]*,?[0-9]*)/m;
+                    let match = regex.exec(line)
+                    console.log(match);
+                    additionalSpent = additionalSpent + parseFloat(match[1]);
+                }
+            });
+            
+            if (additionalSpent > 0) {
+                db.prepare(`UPDATE grocery_budgets SET budget_spent = ?, total_spent = ? WHERE discord_id = ?`).run(budgets.budget_spent + additionalSpent, budgets.total_spent + additionalSpent, authorId);
+                let remainingBudget = weeklyBudget - (budgets.budget_spent + additionalSpent);
+
+                reply = `${message.author.globalName} spent ${additionalSpent} of their budget.\nThey have ${remainingBudget} remaining.`;
+                await receiptsChannel.send(reply);
+            }
+        }
+	},
+};

main.js

@@ -2,65 +2,71 @@ const fs = require('node:fs');
 const path = require('node:path');
 const { Client, Collection, Events, GatewayIntentBits, Options, Partials } = require('discord.js');
 const { token } = require('./config.json');
+const createDbConnection = require('./core/db.js');
 
-const localDB = require('./core/db');
 
-const client = new Client({ 
+async function entrypoint() {
-	intents: [GatewayIntentBits.Guilds, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildPresences, GatewayIntentBits.GuildMessageReactions],
+	const localDB = await createDbConnection();
-	partials: [Partials.Message, Partials.Channel, Partials.Reaction],
-	sweepers: { 
-		...Options.DefaultSweeperSettings, 
-		reactions: { interval: 300, filter: () => () => { return true } } 
-	}
-});
 	
-client.localDB = localDB;
+	const client = new Client({
-client.commands = new Collection();
+		intents: [GatewayIntentBits.Guilds, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildPresences, GatewayIntentBits.GuildMessageReactions],
-const foldersPath = path.join(__dirname, 'commands');
+		partials: [Partials.Message, Partials.Channel, Partials.Reaction],
-const commandFolders = fs.readdirSync(foldersPath);
+		sweepers: {
+			...Options.DefaultSweeperSettings,
+			reactions: { interval: 300, filter: () => () => { return true } }
+		}
+	});
 
-for (const folder of commandFolders) {
+	client.localDB = localDB;
-	const commandsPath = path.join(foldersPath, folder);
+	client.commands = new Collection();
-	const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));
+	const foldersPath = path.join(__dirname, 'commands');
-	for (const file of commandFiles) {
+	const commandFolders = fs.readdirSync(foldersPath);
-		const filePath = path.join(commandsPath, file);
+
-		const command = require(filePath);
+	for (const folder of commandFolders) {
-		if ('data' in command && 'execute' in command) {
+		const commandsPath = path.join(foldersPath, folder);
-			client.commands.set(command.data.name, command);
+		const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));
-		} else {
+		for (const file of commandFiles) {
-			console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`);
+			const filePath = path.join(commandsPath, file);
+			const command = require(filePath);
+			if ('data' in command && 'execute' in command) {
+				client.commands.set(command.data.name, command);
+			} else {
+				console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`);
+			}
 		}
 	}
-}
 
-const eventsPath = path.join(__dirname, 'events');
+	const eventsPath = path.join(__dirname, 'events');
-const eventFiles = fs.readdirSync(eventsPath).filter(file => file.endsWith('.js'));
+	const eventFiles = fs.readdirSync(eventsPath).filter(file => file.endsWith('.js'));
 
-for (const file of eventFiles) {
+	for (const file of eventFiles) {
-	const filePath = path.join(eventsPath, file);
+		const filePath = path.join(eventsPath, file);
-	const event = require(filePath);
+		const event = require(filePath);
-	if (event.once) {
+		if (event.once) {
-		client.once(event.name, (...args) => event.execute(...args));
+			client.once(event.name, (...args) => event.execute(...args));
-	} else {
+		} else {
-		console.log(`Registered event ${event.name} ${file}`);
+			console.log(`Registered event ${event.name} ${file}`);
-		client.on(event.name, (...args) => event.execute(...args));
+			client.on(event.name, (...args) => event.execute(...args));
+		}
 	}
-}
 
-client.on(Events.ClientReady, () => {
+	client.on(Events.ClientReady, () => {
-	//setup timers
+		//setup timers
-	const timersPath = path.join(__dirname, 'timers');
+		const timersPath = path.join(__dirname, 'timers');
-	const timerFiles = fs.readdirSync(timersPath).filter(file => file.endsWith('.js'));
+		const timerFiles = fs.readdirSync(timersPath).filter(file => file.endsWith('.js'));
-	for (const file of timerFiles) {
+		for (const file of timerFiles) {
-		const filePath = path.join(timersPath, file);
+			const filePath = path.join(timersPath, file);
-		const timer = require(filePath);
+			const timer = require(filePath);
-		console.log(`Started Timer ${timer.name}`);
+			console.log(`Started Timer ${timer.name}`);
-		let timerInstance = setInterval(() => {
+			let timerInstance = setInterval(() => {
-			timer.tick(client, timer);
+				timer.tick(client, timer);
-		}, timer.timeout);
+			}, timer.timeout);
-		timer.instance = timerInstance;
+			timer.instance = timerInstance;
-		if (timer.immediate) { timer.tick(client, timer) }
+			if (timer.immediate) { timer.tick(client, timer) }
-	}
+		}
-});
+	});
 
-client.login(token);
+	client.login(token);
+};
+
+entrypoint();

package.json

@@ -1,11 +1,11 @@
 {
   "dependencies": {
     "axios": "^1.6.8",
+    "better-sqlite3": "^12.6.2",
     "discord.js": "^14.13.0",
     "dotenv": "^16.3.1",
     "spotify-web-api-node": "^5.0.2",
-    "sqlite": "^5.1.1",
+    "sqlite": "^5.1.1"
-    "sqlite3": "^5.1.7"
   },
   "name": "minzbot",
   "description": "Successor of the Discord.py implementation",

timers/cleanupMessages.js

@@ -1,10 +1,10 @@
 const { MessageActivityType } = require("discord.js");
 
 module.exports = {
-	timeout: 60000,
+    timeout: 60000,
     immediate: true,
-	name: 'Cleanup tasks',
+    name: 'Cleanup tasks',
-	async tick(client, timer) {
+    async tick(client, timer) {
         const keepMessageEmoteId = '1214140438265724980';
         const channelConfigs = [
             { channelId: '1214134516247957504', keepTimeMinutes: 2, keepAttachment: true }, //toho-test/mnzbot-test
@@ -13,8 +13,8 @@ module.exports = {
             { channelId: '1101703550070947920', keepTimeMinutes: 2880, keepAttachment: true }, //cotr/Memes
         ];
         function isMessageLocked(message) {
-            for(const [id, reaction] of message.reactions.cache) {
+            for (const [id, reaction] of message.reactions.cache) {
-                if(id === keepMessageEmoteId) {
+                if (id === keepMessageEmoteId) {
                     return true;
                 }
             }
@@ -22,34 +22,39 @@ module.exports = {
             return false;
         }
 
+
         for (let i = 0; i < channelConfigs.length; i++) {
-            const config = channelConfigs[i];
+            try {
-            const channel = await client.channels.fetch(config.channelId);
+                const config = channelConfigs[i];
+                const channel = await client.channels.fetch(config.channelId);
 
-            console.log(`[TIMER] Running cleanup task for ${channel.guild.name}/${channel.name}`);
+                console.log(`[TIMER] Running cleanup task for ${channel.guild.name}/${channel.name}`);
-            channel.messages.fetch({ limit: 100 }).then(messages => {
+                channel.messages.fetch({ limit: 100 }).then(messages => {
-                messages.forEach(message => {
+                    messages.forEach(message => {
-                    if(isMessageLocked(message)) {
+                        if (isMessageLocked(message)) {
-                        //skip if message has mnzboKeepMessage reaction
+                            //skip if message has mnzboKeepMessage reaction
-                        console.log(`[LOCKED] [${message.guild.name}/${message.channel.name}] | ${message.author.globalName}: ${message.content}`);
+                            console.log(`[LOCKED] [${message.guild.name}/${message.channel.name}] | ${message.author.globalName}: ${message.content}`);
-                        return;
+                            return;
-                    }                    
+                        }
 
-                    if(message.attachments.size > 0 && config.keepAttachment) {
+                        if (message.attachments.size > 0 && config.keepAttachment) {
-                        //Skip messages with attachment
+                            //Skip messages with attachment
-                        return;
+                            return;
-                    }
+                        }
 
-                    let ageInMinutes = Math.ceil((Date.now() - message.createdTimestamp) / 1000 / 60);
+                        let ageInMinutes = Math.ceil((Date.now() - message.createdTimestamp) / 1000 / 60);
-                    if(ageInMinutes < config.keepTimeMinutes) {
+                        if (ageInMinutes < config.keepTimeMinutes) {
-                        //Skip messages posted within last 48 Hours
+                            //Skip messages posted within last 48 Hours
-                        return;
+                            return;
-                    }
+                        }
 
-                    console.log(`[CLEANUP] [${message.guild.name}/${message.channel.name}] | ${message.author.globalName}: ${message.content}`);
+                        console.log(`[CLEANUP] [${message.guild.name}/${message.channel.name}] | ${message.author.globalName}: ${message.content}`);
-                    message.delete();
+                        message.delete();
+                    });
                 });
-            });
+            } catch (error) {
+                console.log(`[CLEANUP] Failed for ${channelConfigs[i].channelId}`);
+            }
         }
-	},
+    },
 };

timers/receiptTimer.js

@@ -17,17 +17,29 @@ module.exports = {
                 year: 'numeric'
             });
             const channel = await client.channels.fetch(timer.data.channelId);
-            if (channel) await channel.send(`Today is ${currentDate}`);
+            await channel.send(`${currentDate}`);
+            if (currentDate.startsWith('Sunday')) {
+                const response = await fetch(`https://api.frankfurter.dev/v1/latest?amount=1&from=EUR&to=SEK`);
+
+                if (!response.ok) await channel.send(`Failed to fetch exchange rate:\n${response.statusText}`);
+                let db = await client.localDB;
+                const data = await response.json();
+                db.prepare(`UPDATE bot_config SET exchange_rate_eur_kr = ? WHERE id = 1`).run(data.rates.SEK);
+                let weeklyBudget = await (await db.prepare(`SELECT weekly_budget FROM bot_config`).get()).weekly_budget;
+                await channel.send(`Fetched new exchange rate:\n${JSON.stringify(data)}`);
+                db.prepare(`UPDATE grocery_budgets SET budget_spent = 0`).run();
+                await channel.send(`Reset weekly budget to ${weeklyBudget}EUR / ${weeklyBudget*data.rates.SEK}SEK`);
+            }
 
         } catch (error) {
             console.error('[TIMER] Error:', error);
         } finally {
             // 2. Schedule the NEXT tick manually
-            this.scheduleNext(client, timer);
+            await this.scheduleNext(client, timer);
         }
     },
 
-    scheduleNext(client, timer) {
+    async scheduleNext(client, timer) {
         const now = new Date();
         const next = new Date();
 
@@ -45,6 +57,8 @@ module.exports = {
             this.tick(client, timer);
         }, delay);
 
+        const channel = await client.channels.fetch(timer.data.channelId);
+        if (channel) await channel.send(`Next message scheduled for: ${next.toLocaleString()} with ms delta of ${delay} / ${delay/3600000}`);
         console.log(`[TIMER] Next message scheduled for: ${next.toLocaleString()}`);
     }
 };