DB: Add npm backup command for DB backups

Fix missing date utils import

.dockerignore

@@ -0,0 +1,6 @@
+node_modules
+npm-debug.log
+data/*.db
+config.json
+.git
+.env

.gitignore

@@ -2,3 +2,4 @@ node_modules/
 config.json
 old/
 bot.log
+data/

Dockerfile

@@ -0,0 +1,30 @@
+# Use Node.js 20 LTS as the base image
+FROM node:20-slim
+
+# Install dependencies needed for better-sqlite3 (if prebuilt binaries fail)
+RUN apt-get update && apt-get install -y \
+    python3 \
+    make \
+    g++ \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set the working directory
+WORKDIR /usr/src/app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm install --omit=dev
+
+# Copy the rest of the application code
+COPY . .
+
+# Create the data directory for the database
+RUN mkdir -p data
+
+# The bot uses config.json. In Docker, we'll likely mount this or use env vars, 
+# but for now, we ensure the structure is there.
+
+# Command to run the bot
+CMD [ "node", "main.js" ]

commands/receipts/receiptCommands.js

@@ -0,0 +1,170 @@
+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'))
+                .addBooleanOption(option =>
+                    option.setName('override')
+                        .setRequired(false)
+                        .setDescription('Override budget of current period'))
+        )
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('view')
+                .setDescription('View your grocery spendings for the current or previous week')
+                .addUserOption(option =>
+                    option.setName('user')
+                        .setRequired(false)
+                        .setDescription('User to view budget for'))
+                .addBooleanOption(option =>
+                    option
+                        .setName('lastweek')
+                        .setDescription('Show spendings from the previous budget cycle instead of the current one')
+                        .setRequired(false)
+                )
+        )
+        .addSubcommand(subcommand =>
+            subcommand
+                .setName('stats')
+                .setDescription('View detailed spending and savings statistics')
+                .addUserOption(option =>
+                    option.setName('user')
+                        .setRequired(false)
+                        .setDescription('User to view stats for'))
+        ),
+    async execute(interaction) {
+        console.log('budget command entrypoint');
+        let db = await interaction.client.localDB;
+        let targetUser = interaction.options.getUser('user') ?? interaction.user;
+        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 override = interaction.options.getBoolean('override') ?? false;
+                let budget = interaction.options.get('amount').value;
+                db.prepare(`INSERT OR REPLACE INTO bot_config (id, weekly_budget) VALUES (1, ?)`).run(budget);
+                if (override) {
+                    db.prepare(`
+                        UPDATE weekly_budgets 
+                        SET budget_amount = ?
+                        WHERE id = (
+                            SELECT id FROM weekly_budgets 
+                            WHERE date('now', 'localtime') BETWEEN start_date AND end_date
+                            ORDER BY id DESC
+                            LIMIT 1
+                        )`).run(budget);
+
+                }
+                await interaction.reply(`Budget set for ${targetUser.username} to ${Number(budget).toFixed(2)}.`);
+                break;
+            case 'view':
+                const lastWeek = interaction.options.getBoolean('lastweek') ?? false;
+                const currentBudget = db.prepare(`
+                    SELECT id, budget_amount, exchange_rate, start_date, end_date 
+                    FROM weekly_budgets 
+                    WHERE ${lastWeek ? "start_date < date('now', 'localtime')" : "date('now', 'localtime') BETWEEN start_date AND end_date"}
+                    ORDER BY start_date DESC
+                    LIMIT 1
+                `).get();
+
+                if (!currentBudget) {
+                    await interaction.reply("No budget period found.");
+                    return;
+                }
+
+                const userSpendings = db.prepare(`
+                    SELECT amount, message_raw 
+                    FROM grocery_spendings 
+                    WHERE budget_id = ? AND discord_id = ?
+                `).all(currentBudget.id, targetUser.id);
+
+                const totalSpentEur = userSpendings.reduce((acc, s) => {
+                    return acc + s.amount;
+                }, 0);
+
+                const remainingEur = currentBudget.budget_amount - totalSpentEur;
+                const remainingSek = remainingEur * currentBudget.exchange_rate;
+
+                const todayTimestamp = Math.floor(Date.now() / 1000);
+                const endTimestamp = Math.floor(new Date(`${currentBudget.end_date}T23:59:59`).getTime() / 1000);
+
+                const budgetEmbed = new EmbedBuilder()
+                    .setColor(remainingEur > 0 ? 0x00ff00 : 0xff0000)
+                    .setTitle(`${targetUser.globalName ?? targetUser.username} Budget as of <t:${todayTimestamp}:F>`)
+                    .setDescription(`Period: \`${currentBudget.start_date}\` to \`${currentBudget.end_date}\`\nReset <t:${endTimestamp}:R>`)
+                    .addFields(
+                        { name: 'Spent', value: `${totalSpentEur.toFixed(2)} €\n${(totalSpentEur * currentBudget.exchange_rate).toFixed(2)} kr`, inline: true },
+                        { name: 'Remaining', value: `${remainingEur.toFixed(2)} €\n${remainingSek.toFixed(2)} kr`, inline: true },
+                    )
+                    .setFooter({ text: `Exchange rate this week: 1 € = ${currentBudget.exchange_rate.toFixed(2)} kr` })
+                    .setTimestamp();
+
+                await interaction.reply({ embeds: [budgetEmbed] });
+                break
+            case 'stats':
+                const allBudgets = db.prepare(`
+                    SELECT id, budget_amount, exchange_rate, start_date, end_date 
+                    FROM weekly_budgets 
+                    ORDER BY start_date DESC
+                    LIMIT 4
+                `).all();
+
+                let statsDescription = "";
+                let cumulativeSavingsEur = 0;
+
+                for (const budgetPeriod of allBudgets) {
+                    const periodSpendings = db.prepare(`
+                        SELECT amount 
+                        FROM grocery_spendings 
+                        WHERE budget_id = ? AND discord_id = ?
+                    `).all(budgetPeriod.id, targetUser.id);
+
+                    const totalSpentInPeriodEur = periodSpendings.reduce((acc, s) => acc + s.amount, 0);
+                    const savedInPeriodEur = budgetPeriod.budget_amount - totalSpentInPeriodEur;
+                    cumulativeSavingsEur += savedInPeriodEur;
+
+                    statsDescription += `**Period: ${budgetPeriod.start_date} - ${budgetPeriod.end_date}**\n`;
+                    statsDescription += `Budget: ${budgetPeriod.budget_amount.toFixed(2)}€\n`;
+                    statsDescription += `Spent: ${totalSpentInPeriodEur.toFixed(2)}€ (${(totalSpentInPeriodEur * budgetPeriod.exchange_rate).toFixed(2)} kr)\n`;
+                    statsDescription += `Saved: ${savedInPeriodEur.toFixed(2)}€ (${(savedInPeriodEur * budgetPeriod.exchange_rate).toFixed(2)} kr)\n`;
+                    statsDescription += `Cumulative: ${cumulativeSavingsEur.toFixed(2)}€\n\n`;
+                }
+
+                if (allBudgets.length === 0) {
+                    statsDescription = "No budget periods on record.";
+                }
+
+                const statsEmbed = new EmbedBuilder()
+                    .setColor(0x0099ff)
+                    .setTitle(`${targetUser.globalName ?? targetUser.username}'s Budget Statistics`)
+                    .setDescription(statsDescription)
+                    .setTimestamp();
+
+                await interaction.reply({ embeds: [statsEmbed] });
+                break;
+            default:
+                await interaction.reply(`Sub mismatch. Switching on ${interaction.options.getSubcommand()}`);
+                break;
+        }
+    },
+};

commands/utility/grab.js

@@ -63,7 +63,7 @@ module.exports = {
 
 		collector.on('collect', m => {
 			m.stickers.forEach(sticker => {
-				stickers.push(`https://media.discordapp.net/stickers/${sticker.id}.png`);
+				stickers.push(`https://media.discordapp.net/stickers/${sticker.id}.png?size=1024`);
 				collector.stop();
 			});
 		});

commands/utility/linkTrack.js

@@ -41,10 +41,6 @@ module.exports = {
 			option.setName('songname')
 				.setDescription('Override song name, otherwise uses name from Spotify')
 				.setRequired(false))
-		.addStringOption(option =>
-			option.setName('footer_override')
-				.setDescription('Custom footer')
-				.setRequired(false))
 		.addAttachmentOption(option =>
 			option.setName('cover_override')
 			.setDescription('Uses this image instead of Spotofy metadata')
@@ -54,134 +50,146 @@ module.exports = {
 		clientSecret: spotify.clientSecret,
 	}),
 	async execute(interaction) {
-		let token = await this.spotifyAPI.clientCredentialsGrant().then(
+		try {
-			function(data) {
+			let token = await this.spotifyAPI.clientCredentialsGrant().then(
-			  return data.body['access_token'];
+				function(data) {
-			});
+				  return data.body['access_token'];
-		await this.spotifyAPI.setAccessToken(token);
+				});
-
+			await this.spotifyAPI.setAccessToken(token);
-		let urls = interaction.options.getString('links', true).split(" ");
+	
-		
+			let urls = interaction.options.getString('links', true).split(" ");
-		let title = ' ';
+			
-		let description = ' ';
+			let title = ' ';
-		let spotifyID = null;
+			let description = ' ';
-		let artists = '';
+			let spotifyID = null;
-		let songName = '';
+			let artists = '';
-		let mainArtist = '';
+			let songName = '';
-		
+			let mainArtist = '';
-		const trackEmbed = new EmbedBuilder()
+			
-		.setColor(Math.floor(Math.random() * 16777214) + 1)
+			const trackEmbed = new EmbedBuilder()
-		.setDescription(`asdasdasda`)
+			.setColor(Math.floor(Math.random() * 16777214) + 1)
-		.setTimestamp();
+			.setDescription(`asdasdasda`)
-		
+			.setTimestamp();
-		let links = [];
+			
-		for (let index = 0; index < urls.length; index++) {
+			let links = [];
-			let url = urls[index];
+			for (let index = 0; index < urls.length; index++) {
-
+				let url = urls[index];
-			if (url.startsWith('https://listen.minzkraut.com/')) {
+	
-				links.push(`[<:drmoe:1220702607836839956> Navidrome ](${url})`);
+				if (url.startsWith('https://listen.minzkraut.com/')) {
-				continue;
+					links.push(`[<:drmoe:1220702607836839956> Navidrome ](${url})`);
+					continue;
+				}
+				if (url.startsWith('https://open.spotify.com/')) {
+					url = url.split('?')[0];
+					links.push(`[<:sptfy:1224677302109995078> Spotify ](${url})`);
+					//https://open.spotify.com/track/4FuOHRPC3ZIQ7VQd7KMbds?si=cadd634ea5a14689
+					spotifyID = url.split('/').pop();
+					continue;
+				}
+				if (url.startsWith('https://listen.tidal.com/')) {
+					links.push(`[<:tidal:1221732946525032498> Tidal ](${url})`);
+					continue;
+				}
+				if (url.startsWith('https://www.youtube.com/')) {
+					links.push(`[<:ytbm:1224704771248750622>  Youtube ](${url})`);
+					continue;
+				}
+				if (url.startsWith('https://jelly.')) {
+					links.push(`[<:jelly:1225931843279519905>  Jellyfin (${url.split('.')[1]}) ](${url})`);
+					continue;
+				}
+				if (url.startsWith('https://soundcloud.com/') || url.startsWith('https://m.soundcloud.com/')) {
+					links.push(`[<:soundcld:1225702702135119902> Soundcloud ](${url})`);
+					continue;
+				}
 			}
-			if (url.startsWith('https://open.spotify.com/')) {
+			
-				url = url.split('?')[0];
+			
-				links.push(`[<:sptfy:1224677302109995078> Spotify ](${url})`);
+			if(spotifyID) {
-				//https://open.spotify.com/track/4FuOHRPC3ZIQ7VQd7KMbds?si=cadd634ea5a14689
+				let spotifyTrack = await this.spotifyAPI.getTrack(spotifyID);
-				spotifyID = url.split('/').pop();
+				trackEmbed.setThumbnail(spotifyTrack['body'].album.images[0].url);
-				continue;
+				songName = spotifyTrack['body'].name;
+				mainArtist = spotifyTrack['body'].artists[0].name;
+				artists = spotifyTrack['body'].artists.map(a => a.name).join(', ');
+				let releaseDate =  new Date(spotifyTrack['body'].album.release_date).toDateString();
+				description = `From the album **${spotifyTrack['body'].album.name}**\nReleased **${releaseDate}**\n\n` + description;
 			}
-			if (url.startsWith('https://listen.tidal.com/')) {
+			
-				links.push(`[<:tidal:1221732946525032498> Tidal ](${url})`);
+			if(interaction.options.getAttachment('cover_override')) {
-				continue;
+				trackEmbed.setThumbnail(interaction.options.getAttachment('cover_override').url);
 			}
-			if (url.startsWith('https://www.youtube.com/')) {
+			songName = interaction.options.getString('songname', false) ?? songName;
-				links.push(`[<:ytbm:1224704771248750622>  Youtube ](${url})`);
+			artists = interaction.options.getString('artist', false) ?? artists;
-				continue;
+			mainArtist = interaction.options.getString('artist', false) ?? mainArtist;
-			}
+			
-		}
+			title = `${songName} - ${artists}`;
-		
+	
-		
+			trackEmbed.setTitle(`${title}`);
-		if(spotifyID) {
+			
-			let spotifyTrack = await this.spotifyAPI.getTrack(spotifyID);
+			let submitterName = interaction.member.displayName;
-			trackEmbed.setImage(spotifyTrack['body'].album.images[0].url);
+			let footer = `Submitted by ${submitterName} `;
-			songName = spotifyTrack['body'].name;
+			
-			mainArtist = spotifyTrack['body'].artists[0].name;
+			if(interaction.options.getString('rating', false)) {
-			artists = spotifyTrack['body'].artists.map(a => a.name).join(', ');
-			let releaseDate =  new Date(spotifyTrack['body'].album.release_date).toDateString();
-			description = `From the album **${spotifyTrack['body'].album.name}**\nReleased **${releaseDate}**\n\n` + description;
-		}
-		
-		if(interaction.options.getAttachment('cover_override')) {
-			trackEmbed.setImage(interaction.options.getAttachment('cover_override').url);
-		}
-		songName = interaction.options.getString('songname', false) ?? songName;
-		artists = interaction.options.getString('artist', false) ?? artists;
-		mainArtist = interaction.options.getString('artist', false) ?? mainArtist;
-		
-		title = `${songName} - ${artists}`;
-
-		trackEmbed.setTitle(`${title}`);
-
-		let submitterName = interaction.member.displayName;
-		let footer = interaction.options.getString('footer_override', false) ?? `Submitted by ${submitterName}`;
-		trackEmbed.setFooter({text: footer });
-		
-		if(interaction.options.getString('rating', false)) {
-			trackEmbed.addFields(
-				{ name: `${submitterName} rated this`, value: `${interaction.options.getString('rating', false)} out of 10`, inline: true },
-			)
-		}
-
-		let db = await interaction.client.localDB;
-		let dbResult = await db.get(`SELECT * FROM lastfm WHERE discord_id = ?`,[interaction.member.id]);
-		let lfmUsername = dbResult?.['lastfm_name'];
-		let lfmData = await axios.get(`https://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key=${lfmKey}&artist=${mainArtist}&track=${songName}&format=json&user=${lfmUsername}`);
-
-		if(interaction.options.getInteger('scrobbles', false) || lfmData.data['track']?.['userplaycount'] > 0) {
-			trackEmbed.addFields(
-				{ name: `${submitterName} scrobbled this`, value: `${interaction.options.getInteger('scrobbles', false) ?? lfmData.data['track']['userplaycount']} times so far`, inline: true },
-			)
-		} 
-
-		if(lfmData.data['track']) {
-			links.push(`<:lfm:1225099203039203338> [View on LFM](${lfmData.data['track']['url']})`);
-			let tags = lfmData.data['track']['toptags']['tag'].map(a => a.name).filter(tag => tag.length >= 2);
-			console.log(tags);
-			let listeners = this.numToHumanReadable(lfmData.data['track']['listeners']);
-			let globalScrobbles = this.numToHumanReadable(lfmData.data['track']['playcount']);
-
-			trackEmbed.addFields(
-				{ name: `LFM Global`, value: `Listeners: ${listeners} • Scrobbles: ${globalScrobbles}\n`, inline: false },
-			)
-
-			let tagHeader = 'Tags';
-			if(tags.length === 0) {
-				//artist tag fallback
-				let lfmArtistTags = await axios.get(`https://ws.audioscrobbler.com/2.0/?method=artist.getTopTags&api_key=${lfmKey}&artist=${mainArtist}&format=json`);
-				console.log(lfmArtistTags);
-				tags = lfmArtistTags.data['toptags']['tag'].map(a => a.name);
-				tagHeader = `Artist ${tagHeader}`;
-			}
-			if(tags) {
-				tags = this.joinLineBreak(tags, ', ', 4);
 				trackEmbed.addFields(
-					{ name: `${tagHeader}`, value: `${tags.substr(0,60)}${tags.length > 60 ? '...' : ''}`, inline: true },
+					{ name: `${submitterName} rated this`, value: `${interaction.options.getString('rating', false)} out of **10**`, inline: true },
 				)
 			}
+	
+			let db = await interaction.client.localDB;
+			let dbResult = await db.get(`SELECT * FROM lastfm WHERE discord_id = ?`,[interaction.member.id]);
+			let lfmUsername = dbResult?.['lastfm_name'];
+			let lfmData = await axios.get(`https://ws.audioscrobbler.com/2.0/?method=track.getInfo&api_key=${lfmKey}&artist=${mainArtist}&track=${songName}&format=json&user=${lfmUsername}`);
+	
+			if(interaction.options.getInteger('scrobbles', false) || lfmData.data['track']?.['userplaycount'] > 0) {
+				trackEmbed.addFields(
+					{ name: `${submitterName} scrobbled this`, value: `**${interaction.options.getInteger('scrobbles', false) ?? lfmData.data['track']['userplaycount']}** times so far`, inline: true },
+				)
+			} 
+	
+			if(lfmData.data['track']) {
+				links.push(`<:lfm:1225099203039203338> [View on LFM](${lfmData.data['track']['url']})`);
+				let tags = lfmData.data['track']['toptags']['tag'].map(a => a.name).filter(tag => tag.length >= 2);
+				console.log(tags);
+				let listeners = this.numToHumanReadable(lfmData.data['track']['listeners']);
+				let globalScrobbles = this.numToHumanReadable(lfmData.data['track']['playcount']);
+				footer += `∘ Listeners: ${listeners} • Scrobbles: ${globalScrobbles}`;
+				
+				let tagContent = '';
+				if(tags.length === 0) {
+					//artist tag fallback
+					let lfmArtistTags = await axios.get(`https://ws.audioscrobbler.com/2.0/?method=artist.getTopTags&api_key=${lfmKey}&artist=${mainArtist}&format=json`);
+					console.log(lfmArtistTags);
+					tags = lfmArtistTags.data['toptags']['tag'].map(a => a.name);
+				}
+				if(tags.length > 1) {
+					tags = this.joinLineBreak(tags, ', ', 3);
+					trackEmbed.addFields(
+						{ name: `Tags`, value: `${tags.substr(0,60)}${tags.length > 60 ? '...' : ''}`, inline: true },
+					)
+				}
+	
+			}
+	
+			if(!description) {
+				await interaction.reply({content: 'Sorry, no valid link has bee supplied.', ephemeral: true });
+				return;
+			}
+	
+			trackEmbed.setDescription(description);
+			trackEmbed.addFields(
+				{ name: 'Links', value: `${this.joinLineBreak(links, ' ∘ ', 4)}` }
+			);
+	
+			trackEmbed.setFooter({text: footer });
+	
+			interaction.channel.send({ embeds: [trackEmbed] });
+	
+			let response = await interaction.reply({content: 'done', ephemeral: true});
+			await response.delete();
+		} catch (error) {
+			await interaction.reply(`# FUCK \n ${JSON.stringify(error)}`.substring(0,200));
 		}
-
-		description = `${description}\n${this.joinLineBreak(links, ' ∘ ', 3)}`
-
-		if(!description) {
-			await interaction.reply({content: 'Sorry, no valid link has bee supplied.', ephemeral: true });
-			return;
-		}
-
-		trackEmbed.setDescription(description);
 		
-        interaction.channel.send({ embeds: [trackEmbed] });
-
-		let response = await interaction.reply({content: 'done', ephemeral: true});
-		await response.delete();
 	},
 	numToHumanReadable: function(num) {
 		if (num > 1000000 ) {
@@ -200,4 +208,4 @@ module.exports = {
 		}
 		return groupedArray.join('\n');
 	}
-};
+};

core/db.js

@@ -1,39 +1,33 @@
 const fs = require("fs");
-const sqlite3 = require("sqlite3").verbose();
+const Database = require("better-sqlite3");
-const { open } = require('sqlite');
+const path = require("path");
+const { Umzug, JSONStorage } = require('umzug');
 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 });
+
+    await runMigrations(db);
+
+    console.log("[DATABASE] Connection with better-sqlite3 established");
+    return db;
 }
 
-async function initDB(db) {
+async function runMigrations(db) {
-    await db.exec(`
+    const umzug = new Umzug({
-        CREATE TABLE IF NOT EXISTS anniversaries (
+        migrations: { glob: 'migrations/*.js' },
-            ID INTEGER PRIMARY KEY AUTOINCREMENT,
+        context: db,
-            name   VARCHAR(50) NOT NULL,
+        storage: new JSONStorage({ path: './data/migrations.json' }),
-            guild_id TEXT NOT NULL,
+        logger: console,
-            discord_id   VARCHAR(50) NOT NULL,
+    });
-            last_anniversary_notification TEXT
+
-        );
+    await umzug.up();
-    `);
+    console.log('[DATABASE] Migrations applied successfully');
-    await db.exec(`
-        CREATE TABLE IF NOT EXISTS lastfm (
-            discord_id TEXT PRIMARY KEY NOT NULL,
-            lastfm_name TEXT
-        );
-    `);
-    console.log('[DATABASE] Created new DB table');
 }
 
-module.exports = createDbConnection();
+module.exports = createDbConnection;

core/utils.js

@@ -0,0 +1,8 @@
+module.exports = {
+    formatDate (date) {
+        const year = date.getFullYear();
+        const month = String(date.getMonth() + 1).padStart(2, '0');
+        const day = String(date.getDate()).padStart(2, '0');
+        return `${year}-${month}-${day}`;
+    }
+}

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.`);
 

docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  minzbot:
+    build: .
+    container_name: minzbot
+    restart: unless-stopped
+    volumes:
+      - ./config.json:/usr/src/app/config.json:ro
+      - ./data:/usr/src/app/data
+    environment:
+      - NODE_ENV=production

events/receiptsMessageCreate.js

@@ -0,0 +1,105 @@
+const { Events, channelLink, discordSort } = require('discord.js');
+
+module.exports = {
+	name: Events.MessageCreate,
+	async execute(message) {
+        if (message.author.bot) return;
+
+        const receiptsChannelId = process.env.NODE_ENV === 'development' ? '1468186493251227658' : '1462060674766344370';
+        if(message.channel.id === receiptsChannelId) {
+            const CURRENCY_MAP = {
+                "222457277708369928": "EUR", // Minz
+                "372115788498468864": "SEK", // Miffy
+            };
+
+            let reply = "";
+            let db = await message.client.localDB;
+            const receiptsChannel = message.channel; 
+            const authorId = message.author.id;
+
+
+            const currentBudget = db.prepare(`
+                    SELECT id, exchange_rate, budget_amount FROM weekly_budgets 
+                    WHERE date('now', 'localtime') BETWEEN start_date AND end_date
+                    ORDER BY created_at DESC
+                    LIMIT 1
+                `).get();
+
+            if (message.content === "fuck") {
+
+                let lastSpend = db.prepare(`
+                    SELECT id, amount, message_raw, created_at 
+                    FROM grocery_spendings 
+                    WHERE discord_id = ? AND budget_id = ?
+                    ORDER BY created_at DESC, id DESC 
+                    LIMIT 1
+                `).get(authorId, currentBudget.id);
+                if (lastSpend) {
+                    db.prepare(`DELETE FROM grocery_spendings WHERE id = ?`).run(lastSpend.id);
+                    await message.reply(`Your last spending of ${lastSpend.amount.toFixed(2)}€ has been deleted.`);
+                } else {
+                    await message.reply("You don't have any entries within the current budgeting period!");
+                }
+                return;
+            }
+
+            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);
+                    if (match) {
+                        additionalSpent = additionalSpent + parseFloat(match[1].replace(',', '.'));
+                    }
+                }
+            });
+            
+
+            if (additionalSpent > 0) {
+
+
+                const currency = CURRENCY_MAP[authorId] || "EUR"
+                switch (currency) {
+                    case "SEK":
+                        additionalSpent = additionalSpent / currentBudget.exchange_rate;
+                        break;
+                    default:
+                        break;
+                }
+
+                db.prepare(`
+                    INSERT INTO grocery_spendings (
+                        discord_id, 
+                        message_id, 
+                        message_raw, 
+                        amount, 
+                        budget_id
+                    ) VALUES (?, ?, ?, ?, ?)
+                `).run(
+                    authorId,
+                    message.id,
+                    message.content,
+                    additionalSpent,
+                    currentBudget.id
+                );
+                
+                const allSpendings = db.prepare(`
+                    SELECT amount 
+                    FROM grocery_spendings 
+                    WHERE budget_id = ? AND discord_id = ?
+                `).all(currentBudget.id, authorId);
+
+                const totalSpent = allSpendings.reduce((acc, entry) => {
+                    return acc + entry.amount;
+                }, 0);
+
+                reply = `${message.author.globalName} spent ${additionalSpent.toFixed(2)}€ / ${(additionalSpent * currentBudget.exchange_rate).toFixed(2)} kr of their budget.\nThey have ${(currentBudget.budget_amount - totalSpent).toFixed(2)}€ / ${((currentBudget.budget_amount - totalSpent) * currentBudget.exchange_rate).toFixed(2)} kr remaining.`;
+                await message.reply(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: { 
+	const client = new Client({
-		...Options.DefaultSweeperSettings, 
+		intents: [GatewayIntentBits.Guilds, GatewayIntentBits.MessageContent, GatewayIntentBits.GuildMessages, GatewayIntentBits.GuildMembers, GatewayIntentBits.GuildPresences, GatewayIntentBits.GuildMessageReactions],
-		reactions: { interval: 300, filter: () => () => { return true } } 
+		partials: [Partials.Message, Partials.Channel, Partials.Reaction],
-	}
+		sweepers: {
-});
+			...Options.DefaultSweeperSettings,
+			reactions: { interval: 300, filter: () => () => { return true } }
+		}
+	});
 
-client.localDB = localDB;
+	client.localDB = localDB;
-client.commands = new Collection();
+	client.commands = new Collection();
-const foldersPath = path.join(__dirname, 'commands');
+	const foldersPath = path.join(__dirname, 'commands');
-const commandFolders = fs.readdirSync(foldersPath);
+	const commandFolders = fs.readdirSync(foldersPath);
 
-for (const folder of commandFolders) {
+	for (const folder of commandFolders) {
-	const commandsPath = path.join(foldersPath, folder);
+		const commandsPath = path.join(foldersPath, folder);
-	const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));
+		const commandFiles = fs.readdirSync(commandsPath).filter(file => file.endsWith('.js'));
-	for (const file of commandFiles) {
+		for (const file of commandFiles) {
-		const filePath = path.join(commandsPath, file);
+			const filePath = path.join(commandsPath, file);
-		const command = require(filePath);
+			const command = require(filePath);
-		if ('data' in command && 'execute' in command) {
+			if ('data' in command && 'execute' in command) {
-			client.commands.set(command.data.name, command);
+				client.commands.set(command.data.name, command);
-		} else {
+			} else {
-			console.log(`[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`);
+				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();

migrations/00_initial_schema.js

@@ -0,0 +1,61 @@
+module.exports = {
+    up: async ({ context: db }) => {
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS anniversaries (
+                ID INTEGER PRIMARY KEY AUTOINCREMENT,
+                name   VARCHAR(50) NOT NULL,
+                guild_id TEXT NOT NULL,
+                discord_id   VARCHAR(50) NOT NULL,
+                last_anniversary_notification TEXT
+            );
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS lastfm (
+                discord_id TEXT PRIMARY KEY NOT NULL,
+                lastfm_name TEXT
+            );
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS bot_config (
+                id INTEGER PRIMARY KEY CHECK (id = 1),
+                weekly_budget REAL DEFAULT 0,
+                last_date_msg_receipts DATE NOT NULL DEFAULT CURRENT_TIMESTAMP
+            );
+        `);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS weekly_budgets (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                start_date DATE NOT NULL,
+                end_date DATE NOT NULL,
+                budget_amount DECIMAL(10, 2) NOT NULL,
+                exchange_rate DECIMAL(10, 6) NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                CONSTRAINT date_check CHECK (end_date > start_date)
+            );
+        `);
+        db.exec(`CREATE INDEX IF NOT EXISTS idx_budget_dates ON weekly_budgets (start_date, end_date);`);
+        db.exec(`
+            CREATE TABLE IF NOT EXISTS grocery_spendings (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                discord_id VARCHAR(50) NOT NULL,
+                message_id VARCHAR(50) NOT NULL,
+                message_raw TEXT DEFAULT "-",
+                amount DECIMAL(10, 2) NOT NULL,
+                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+                budget_id INTEGER,
+                FOREIGN KEY (budget_id) REFERENCES weekly_budgets(id)
+            );
+        `);
+        db.exec(`
+            INSERT OR IGNORE INTO bot_config (id, weekly_budget) 
+            VALUES (1, 10);
+        `);
+    },
+    down: async ({ context: db }) => {
+        db.exec(`DROP TABLE IF EXISTS grocery_spendings;`);
+        db.exec(`DROP TABLE IF EXISTS weekly_budgets;`);
+        db.exec(`DROP TABLE IF EXISTS bot_config;`);
+        db.exec(`DROP TABLE IF EXISTS lastfm;`);
+        db.exec(`DROP TABLE IF EXISTS anniversaries;`);
+    }
+};

package.json

@@ -1,18 +1,20 @@
 {
   "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",
-    "sqlite3": "^5.1.7"
+    "umzug": "^3.8.2"
   },
   "name": "minzbot",
   "description": "Successor of the Discord.py implementation",
   "version": "1.0.0",
   "main": "main.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "backup": "node scripts/backup.js"
   },
   "author": "Minz💕",
   "license": "ISC"

scripts/backup.js

@@ -0,0 +1,25 @@
+const fs = require('fs');
+const path = require('path');
+
+const dbPath = path.join(__dirname, '../data/minzbot.db');
+const backupDir = path.join(__dirname, '../data/backups');
+
+if (!fs.existsSync(backupDir)) {
+    fs.mkdirSync(backupDir, { recursive: true });
+}
+
+const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+const backupPath = path.join(backupDir, `${timestamp}_minzbot.db`);
+
+try {
+    if (fs.existsSync(dbPath)) {
+        fs.copyFileSync(dbPath, backupPath);
+        console.log(`Backup successful: ${backupPath}`);
+    } else {
+        console.error(`Database file not found at ${dbPath}`);
+        process.exit(1);
+    }
+} catch (error) {
+    console.error('Backup failed:', error);
+    process.exit(1);
+}

timers/botStatus.js

@@ -9,6 +9,7 @@ module.exports = {
         animeList: ["K-On!", "Spice and Wolf", "Bakemonogatari", "Your Lie in April", "Noragami", "Puella Magi Madoka Magica", "Akame ga Kill!", "Steins;Gate", "\u3086\u308b\u30ad\u30e3\u30f3\u25b3"]
     },
 	async tick(client, timer) {
+        return;
         client.user.setActivity(timer.data.animeList[timer.data.statusIndex], { type: ActivityType.Watching });
         timer.data.statusIndex = (timer.data.statusIndex + 1) % timer.data.animeList.length
 	},

timers/cleanupMessages.js

@@ -1,20 +1,17 @@
 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
-            { channelId: '1111054421091155978', keepTimeMinutes: 2880 }, //cotr/Spam
-            { channelId: '1170190197384814762', keepTimeMinutes: 2880, keepAttachment: true }, //cotr/Red
-            { 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 +19,39 @@ module.exports = {
             return false;
         }
 
-        for (let i = 0; i < channelConfigs.length; i++) {
-            const config = channelConfigs[i];
-            const channel = await client.channels.fetch(config.channelId);
-    
-            console.log(`[TIMER] Running cleanup task for ${channel.guild.name}/${channel.name}`);
-            channel.messages.fetch({ limit: 100 }).then(messages => {
-                messages.forEach(message => {
-                    if(isMessageLocked(message)) {
-                        //skip if message has mnzboKeepMessage reaction
-                        console.log(`[LOCKED] [${message.guild.name}/${message.channel.name}] | ${message.author.globalName}: ${message.content}`);
-                        return;
-                    }                    
 
-                    if(message.attachments.size > 0 && config.keepAttachment) {
+        for (let i = 0; i < channelConfigs.length; i++) {
-                        //Skip messages with attachment
+            try {
-                        return;
+                const config = channelConfigs[i];
-                    }
+                const channel = await client.channels.fetch(config.channelId);
-                    
+
-                    let ageInMinutes = Math.ceil((Date.now() - message.createdTimestamp) / 1000 / 60);
+                console.log(`[TIMER] Running cleanup task for ${channel.guild.name}/${channel.name}`);
-                    if(ageInMinutes < config.keepTimeMinutes) {
+                channel.messages.fetch({ limit: 100 }).then(messages => {
-                        //Skip messages posted within last 48 Hours
+                    messages.forEach(message => {
-                        return;
+                        if (isMessageLocked(message)) {
-                    }
+                            //skip if message has mnzboKeepMessage reaction
-                    
+                            console.log(`[LOCKED] [${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}`);
+                            return;
-                    message.delete();
+                        }
+
+                        if (message.attachments.size > 0 && config.keepAttachment) {
+                            //Skip messages with attachment
+                            return;
+                        }
+
+                        let ageInMinutes = Math.ceil((Date.now() - message.createdTimestamp) / 1000 / 60);
+                        if (ageInMinutes < config.keepTimeMinutes) {
+                            //Skip messages posted within last 48 Hours
+                            return;
+                        }
+
+                        console.log(`[CLEANUP] [${message.guild.name}/${message.channel.name}] | ${message.author.globalName}: ${message.content}`);
+                        message.delete();
+                    });
                 });
-            });
+            } catch (error) {
+                console.log(`[CLEANUP] Failed for ${channelConfigs[i].channelId}`);
+            }
         }
-	},
+    },
 };

timers/memberAnniversaries.js

@@ -1,78 +0,0 @@
-const db = require("../core/db");
-
-
-async function fetchAnniversary(id) {
-    console.log(await db);
-    let query = await db.prepare(`SELECT * FROM anniversaries WHERE discord_id = ?`)
-    return await query.get(id);
-}
-
-function insertNewMember(member) {
-    db.run(
-        `INSERT INTO anniversaries (name, guild_id, discord_id, last_anniversary_notification) VALUES (?, ?, ?, ?)`,
-        [member.user.username, member.guild.id, member.id, Date.now()],
-        function (error) {
-            if (error) {
-                console.error(error.message);
-            }
-            console.log(`Inserted a row with the ID: ${this.lastID}`);
-        }
-    );
-}
-
-function isAnniversary(date) {
-    const now = new Date("Thu Nov 11 2024");// new Date();
-    console.log(`${date.getDate()} - ${now.getDate()}`);
-    return date.getDate() === now.getDate() && date.getMonth() === now.getMonth();
-}
-
-function getTimeSince(date) {
-    const now = new Date();
-    const diff = now - date; // `date` is already a Date object
-
-    const seconds = Math.floor(diff / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    const days = Math.floor(hours / 24);
-    const weeks = Math.floor(days / 7);
-    const months = Math.floor(days / 30);
-    const years = Math.floor(days / 365);
-
-    if (years > 0) return `${years} years ago`;
-    if (months > 0) return `${months} months ago`;
-    if (weeks > 0) return `${weeks} weeks ago`;
-    if (days > 0) return `${days} days ago`;
-    if (hours > 0) return `${hours} hours ago`;
-    if (minutes > 0) return `${minutes} minutes ago`;
-    return `${seconds} seconds ago`;
-}
-
-module.exports = {
-    timeout: 60000,
-    immediate: true,
-    name: 'Daily member anniversary check',
-
-    async tick(client, timer) {
-        return;
-        console.log(`[TIMER] Anniversary Check`);
-        let debugChannel = await client.channels.fetch('1214134516247957504');
-
-        let subscribedChannels = [
-            { guild: '442059309581336578', channel: '1214134516247957504' } //toho-test
-        ]
-
-        for (let channelIndex = 0; channelIndex < subscribedChannels.length; channelIndex++) {
-            const guild = await client.guilds.fetch(subscribedChannels[channelIndex].guild);
-            const channel = await client.channels.fetch(subscribedChannels[channelIndex].channel);
-            let guildMembers = await guild.members.fetch();
-            guildMembers.forEach(member => {
-                if(isAnniversary(member.joinedAt)) {
-                    //debugChannel.send(`Upcoming anniversary ${member.displayName} ${member.joinedAt} ${getTimeSince(member.joinedAt)}`);
-                    console.log(`User anniversary ${member.displayName} ${member.joinedAt} ${getTimeSince(member.joinedAt)}`);
-                    let dbEntry = fetchAnniversary(member.id);
-                    console.log(dbEntry);
-                }
-            });
-        }
-    },
-};

timers/receiptTimer.js

@@ -0,0 +1,131 @@
+const { formatDate } = require('../core/utils.js');
+
+module.exports = {
+    timeout: 10000,
+    immediate: true,
+    name: 'Receipt Day Announcements',
+    data: {
+        channelId: process.env.NODE_ENV === 'development' ? '1468186493251227658' : '1462060674766344370',
+        targetHour: 0,
+        targetMinute: 1
+    },
+    async tick(client, timer) {
+
+        //format date because isostring is utc duh 
+        try {
+            const today = new Date();
+            const lastMonday = new Date(today);
+            lastMonday.setDate(today.getDate() - ((today.getDay() === 0) ? 6 : today.getDay() - 1));
+            const startDate = formatDate(lastMonday);
+
+            const nextSunday = new Date(lastMonday);
+            nextSunday.setDate(lastMonday.getDate() + 6);
+            const endDate = formatDate(nextSunday);
+            // 0 1 2 3 4 5 6
+            // S M T W T F S
+            let db = await client.localDB;
+            const channel = await client.channels.fetch(timer.data.channelId);
+            
+            const config = await (await db.prepare(`SELECT weekly_budget, last_date_msg_receipts FROM bot_config`).get());
+            const existingBudget = db.prepare(`SELECT id FROM weekly_budgets WHERE start_date = ?`).get(startDate);
+            
+            if (!existingBudget) {
+                await channel.send(`Format date last monday ${lastMonday} as startDate Format date next sunday ${nextSunday} as endDate`);
+                await channel.send(`\`\`\`SELECT id FROM weekly_budgets WHERE start_date = ${startDate}\`\`\`
+                ${JSON.stringify(existingBudget)}`);
+                console.log(`No budget found for week starting ${startDate}.`);
+                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}`);
+                const data = await response.json();
+                //await channel.send(`Fetched new exchange rate:\n${JSON.stringify(data)}`);
+                await channel.send(`Reset weekly budget to ${config.weekly_budget.toFixed(2)}€ / ${(config.weekly_budget * data.rates.SEK).toFixed(2)} kr`);
+
+
+                db.prepare(`
+                    INSERT INTO weekly_budgets (start_date, end_date, budget_amount, exchange_rate)
+                    VALUES (?, ?, ?, ?)
+                    `).run(startDate, endDate, config.weekly_budget, data.rates.SEK);
+
+                await channel.send(`\`\`\`INSERT INTO weekly_budgets (start_date, end_date, budget_amount, exchange_rate)
+                    VALUES (${startDate}, ${endDate}, ${config.weekly_budget}, ${data.rates.SEK})\`\`\``);
+            } else {
+                console.log(`budget found for week starting ${startDate}.`);
+            }
+
+            const notification = db.prepare(`
+                SELECT EXISTS (
+                    SELECT 1 FROM bot_config 
+                    WHERE date(last_date_msg_receipts, 'localtime') = date('now', 'localtime')
+                ) as was_sent_today
+            `).get();
+
+            const debug = db.prepare(`
+                SELECT 
+                    date(last_date_msg_receipts, 'localtime') AS last_date,
+                    datetime('now', 'localtime') AS current_time_full,
+                    (date(last_date_msg_receipts, 'localtime') = date('now', 'localtime')) AS was_sent_today
+                FROM bot_config
+                LIMIT 1;
+            `).get();
+
+
+            if (!notification.was_sent_today) {
+                await channel.send(`\`\`\`SELECT 
+                    date(last_date_msg_receipts, 'localtime') AS last_date,
+                    datetime('now', 'localtime') AS current_time_full,
+                    (date(last_date_msg_receipts, 'localtime') = date('now', 'localtime')) AS was_sent_today
+                FROM bot_config
+                LIMIT 1;\`\`\`
+    
+                ${JSON.stringify(debug)}`);
+                const currentDate = new Date().toLocaleDateString('en-GB', {
+                    weekday: 'long',
+                    day: '2-digit',
+                    month: '2-digit',
+                    year: 'numeric'
+                });
+                await channel.send(`${currentDate}`);
+                console.log("No notification today, sending...");
+                db.prepare(`
+                    UPDATE bot_config 
+                    SET last_date_msg_receipts = CURRENT_TIMESTAMP 
+                    WHERE id = 1
+                    `).run();
+            } else {
+                console.log("Notification already sent");
+            }
+
+
+        } catch (error) {
+            console.error('[TIMER] Error:', error);
+        } finally {
+            // 2. Schedule the NEXT tick manually
+            await this.scheduleNext(client, timer);
+        }
+    },
+
+    async scheduleNext(client, timer) {
+        const now = new Date();
+        const next = new Date();
+
+        next.setHours(timer.data.targetHour, timer.data.targetMinute, 0, 0);
+
+        if (next <= now) {
+            next.setDate(next.getDate() + 1);
+        }
+
+        const delay = next.getTime() - now.getTime();
+
+        if (timer.instance) clearTimeout(timer.instance);
+
+        timer.instance = setTimeout(() => {
+            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()}`);
+    }
+};