.eslintrc.json

@@ -0,0 +1,49 @@
+{
+	"extends": "eslint:recommended",
+	"env": {
+		"node": true,
+		"es6": true
+	},
+	"parserOptions": {
+		"ecmaVersion": 2021
+	},
+	"rules": {
+		"arrow-spacing": ["warn", { "before": true, "after": true }],
+		"brace-style": ["error", "stroustrup", { "allowSingleLine": true }],
+		"comma-dangle": ["error", "always-multiline"],
+		"comma-spacing": "error",
+		"comma-style": "error",
+		"curly": ["error", "multi-line", "consistent"],
+		"dot-location": ["error", "property"],
+		"handle-callback-err": "off",
+		"indent": ["error", "tab"],
+		"keyword-spacing": "error",
+		"max-nested-callbacks": ["error", { "max": 4 }],
+		"max-statements-per-line": ["error", { "max": 2 }],
+		"no-console": "off",
+		"no-empty-function": "error",
+		"no-floating-decimal": "error",
+		"no-inline-comments": "error",
+		"no-lonely-if": "error",
+		"no-multi-spaces": "error",
+		"no-multiple-empty-lines": ["error", { "max": 2, "maxEOF": 1, "maxBOF": 0 }],
+		"no-shadow": ["error", { "allow": ["err", "resolve", "reject"] }],
+		"no-trailing-spaces": ["error"],
+		"no-var": "error",
+		"object-curly-spacing": ["error", "always"],
+		"prefer-const": "error",
+		"quotes": ["error", "single"],
+		"semi": ["error", "always"],
+		"space-before-blocks": "error",
+		"space-before-function-paren": ["error", {
+			"anonymous": "never",
+			"named": "never",
+			"asyncArrow": "always"
+		}],
+		"space-in-parens": "error",
+		"space-infix-ops": "error",
+		"space-unary-ops": "error",
+		"spaced-comment": "error",
+		"yoda": "error"
+	}
+}

.gitignore

@@ -1,2 +1,4 @@
-node_modules
 .env
+config.json
+node_modules
+keyfile.json

README.md

@@ -0,0 +1,22 @@
+<h1>BreadBot</h1>
+
+BreadBot helps, BreadBot does the things. Whatever things I'm willing to add to BreadBot. 
+
+BreadBot is the breadiest bread. 
+
+In all seriousness, BreadBot is my first real attempt at a Discord bot. I'm writing it such that it can really only be used in one server at the moment, although that will hopefully change in the future. The intention is really for it only to be used for the Team 2648 Discord server. 
+
+I have a subset of features that I want it to have before I call it "production ready" and a set of features that I want if I'm feeling adventurous and want to put in a lot of work. 
+
+"Production Ready" Features
+- [ ] Google Calendar Integration for Event Management
+    - [ ] Create/Manage/Remove Events and Calendars
+        - [ ] Add Autocomplete for common elements like Calendar Names, Event Names, Timezones, etc.
+    - [ ] Calendar Announcements for Upcoming Events
+- [ ] Poll Creation and Results Announcements
+- [ ] Conversation Archiving (May be Removed)
+
+"Adventurous (Lots of Work)" Features
+- [ ] BreadBot Voice Chat Hall Monitor
+- [ ] Breadle (BreadBot Idle Bread Baking Game)
+- [ ] BreadBot Calendar Send To Email

breadbot.js

@@ -0,0 +1,67 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { Client, Events, GatewayIntentBits, Collection } = require('discord.js');
+const { token } = require('./config.json');
+
+const getAllFiles = function(directoryPath, arrayOfFiles) {
+	const files = fs.readdirSync(directoryPath);
+
+	arrayOfFiles = arrayOfFiles || [];
+
+	files.forEach(file => {
+		if (fs.statSync(directoryPath + path.sep + file).isDirectory()) {
+			arrayOfFiles = getAllFiles(directoryPath + path.sep + file, arrayOfFiles);
+		}
+		else {
+			arrayOfFiles.push(path.join(__dirname, directoryPath, path.sep, file));
+		}
+	});
+
+	return arrayOfFiles;
+};
+
+const allFiles = [];
+getAllFiles('.' + path.sep + 'commands', allFiles);
+
+const client = new Client({ intents: [GatewayIntentBits.Guilds] });
+
+client.commands = new Collection();
+
+const commandFiles = allFiles.filter(file => file.endsWith('.js'));
+
+for (const file of commandFiles) {
+	const command = require(file);
+
+	if ('data' in command && 'execute' in command) {
+		client.commands.set(command.data.name, command);
+		console.log(`[INFO] Loaded command at ${file}`);
+	}
+	else {
+		console.log(`[WARNING] The command at ${file} is missing a required "data" or "execute" property.`);
+	}
+}
+
+client.on(Events.InteractionCreate, async interaction => {
+	if (!interaction.isChatInputCommand()) return;
+
+	const command = interaction.client.commands.get(interaction.commandName);
+
+	if (!command) {
+		console.error(`No command matching ${interaction.commandName} was found.`);
+		return;
+	}
+
+	try {
+		await command.execute(interaction);
+	}
+	catch (error) {
+		console.error(error);
+		await interaction.reply({ content: 'There was an error while executing this command!', ephemeral: true });
+	}
+});
+
+client.once(Events.ClientReady, c => {
+	console.log(`Ready! Logged in as ${c.user.tag}`);
+});
+
+client.login(token);

calendarpulltest.js

@@ -0,0 +1,33 @@
+const { google } = require('googleapis');
+const { googlePrivateKey, googleClientEmail, googleProjectNumber } = require('./config.json');
+
+const SCOPES = ['https://www.googleapis.com/auth/calendar'];
+
+async function main() {
+	const jwtClient = new google.auth.JWT(
+		googleClientEmail,
+		null,
+		googlePrivateKey,
+		SCOPES,
+	);
+
+	const calendar = new google.calendar({
+		version: 'v3',
+		project: googleProjectNumber,
+		auth: jwtClient,
+	});
+
+	calendar.calendarList.list({}, (err, res) => {
+		if (err) {
+			console.log('[ERROR]');
+			console.log(err.errors);
+			return;
+		}
+		console.log(res.data.items.map(x => x.summary + '---' + x.timeZone));
+	});
+}
+
+main().catch(e => {
+	console.error(e);
+	throw e;
+});

commands/googlecalendar/addcalendar.js

@@ -0,0 +1,37 @@
+const { SlashCommandBuilder, EmbedBuilder } = require('discord.js');
+const { addCalendar } = require('../../utilities/googlecalendar.js');
+// const { getTimeZones } = require('@vvo/tzdb');
+
+module.exports = {
+	data: new SlashCommandBuilder()
+		.setName('addcalendar')
+		.setDescription('Creates a new Google Calendar')
+		.addStringOption(option =>
+			option
+				.setName('name')
+				.setDescription('The new name for the calendar')
+				.setRequired(true))
+		.addStringOption(option =>
+			option
+				.setName('timezone')
+				.setDescription('The Time Zone of this new calendar, must be in IANA format')
+				.setRequired(true)),
+	// .addChoices(getTimeZones().map(tz => {
+	//	return { name: tz.name, value: tz.name };
+	// }))),
+	async execute(interaction) {
+		await interaction.deferReply({ ephemeral: true });
+
+		const name = interaction.options.getString('name');
+		const timezone = interaction.options.getString('timezone');
+
+		// eslint-disable-next-line no-unused-vars
+		addCalendar(name, timezone, async (success, message, extra) => {
+			const embedResponse = new EmbedBuilder()
+				.setColor(success ? 0x00FF00 : 0xFF0000)
+				.setTitle(message);
+
+			await interaction.editReply({ embeds: [ embedResponse ] });
+		});
+	},
+};

commands/googlecalendar/deletecalendar.js

@@ -0,0 +1,27 @@
+const { SlashCommandBuilder, EmbedBuilder } = require('discord.js');
+const { deleteCalendar } = require('../../utilities/googlecalendar.js');
+
+module.exports = {
+	data: new SlashCommandBuilder()
+		.setName('deletecalendar')
+		.setDescription('Permanently deletes a calendar and it\'s associated events')
+		.addStringOption(option =>
+			option
+				.setName('name')
+				.setDescription('The name of the calendar you want to delete')
+				.setRequired(true)),
+	async execute(interaction) {
+		await interaction.deferReply({ ephemeral: true });
+
+		const name = interaction.options.getString('name');
+
+		// eslint-disable-next-line no-unused-vars
+		deleteCalendar(name, async (success, message, extra) => {
+			const embedResponse = new EmbedBuilder()
+				.setColor(success ? 0x0FF00 : 0xFF0000)
+				.setTitle(message);
+
+			await interaction.editReply({ embeds: [ embedResponse ] });
+		});
+	},
+};

commands/googlecalendar/listcalendar.js

@@ -0,0 +1,20 @@
+const { SlashCommandBuilder, EmbedBuilder } = require('discord.js');
+const { getListOfCalendars } = require('../../utilities/googlecalendar');
+
+module.exports = {
+	data: new SlashCommandBuilder()
+		.setName('listcalendars')
+		.setDescription('Lists the currently available calendars'),
+	async execute(interaction) {
+		await interaction.deferReply({ ephemeral: true });
+
+		getListOfCalendars({}, async (success, message, extra) => {
+			const embedResponse = new EmbedBuilder()
+				.setColor(success ? 0x00FF00 : 0xFF0000)
+				.setTitle(message)
+				.setDescription(extra.map(x => x.summary + ' --- ' + x.timeZone).join('\n\n'));
+
+			await interaction.editReply({ embeds: [ embedResponse ] });
+		});
+	},
+};

commands/ping.js

@@ -0,0 +1,10 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+	data: new SlashCommandBuilder()
+		.setName('ping')
+		.setDescription('Replies with Pong!'),
+	async execute(interaction) {
+		await interaction.reply('Pong!');
+	},
+};

commands/server.js

@@ -0,0 +1,11 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+	data: new SlashCommandBuilder()
+		.setName('server')
+		.setDescription('Provides information about the server.'),
+	async execute(interaction) {
+		// interaction.guild is the object representing the Guild in which the command was run
+		await interaction.reply(`This server is ${interaction.guild.name} and has ${interaction.guild.memberCount} members.`);
+	},
+};

commands/user.js

@@ -0,0 +1,12 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+	data: new SlashCommandBuilder()
+		.setName('user')
+		.setDescription('Provides information about the user.'),
+	async execute(interaction) {
+		// interaction.user is the object representing the User who ran the command
+		// interaction.member is the GuildMember object, which represents the user in the specific guild
+		await interaction.reply(`This command was run by ${interaction.user.username}, who joined on ${interaction.member.joinedAt}.`);
+	},
+};

datetesting.js

@@ -0,0 +1,35 @@
+const readline = require('readline');
+
+const r1 = readline.createInterface({
+	input: process.stdin,
+	output: process.stdout,
+	terminal: false,
+});
+
+let date1 = null;
+let date2 = null;
+let result = null;
+
+r1.on('line', line => {
+	if (line.startsWith('date1')) {
+		date1 = new Date(line.split(':')[1]);
+	}
+	else if (line.startsWith('date2')) {
+		date2 = new Date(line.split(':')[1]);
+	}
+	else if (line.startsWith('result')) {
+		if (date1 !== null && date2 !== null) {
+			result = new Date(date1.getFullYear(), date1.getMonth(), date1.getDate(),
+				date2.getHours(), date2.getMinutes(), date2.getSeconds());
+
+			console.log(result);
+		}
+	}
+	else {
+		console.log('Bad command');
+	}
+});
+
+r1.once('close', () => {
+	console.log('Closing');
+});

deploy-commands.js

@@ -0,0 +1,63 @@
+const { REST, Routes } = require('discord.js');
+const { clientId, guildId, token } = require('./config.json');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const getAllFiles = function(directoryPath, arrayOfFiles) {
+	const files = fs.readdirSync(directoryPath);
+
+	arrayOfFiles = arrayOfFiles || [];
+
+	files.forEach(file => {
+		if (fs.statSync(directoryPath + path.sep + file).isDirectory()) {
+			arrayOfFiles = getAllFiles(directoryPath + path.sep + file, arrayOfFiles);
+		}
+		else {
+			arrayOfFiles.push(path.join(__dirname, directoryPath, path.sep, file));
+		}
+	});
+
+	return arrayOfFiles;
+};
+
+const commands = [];
+const allFiles = [];
+getAllFiles('.' + path.sep + 'commands', allFiles);
+allFiles.forEach(file => {
+	console.log(file);
+});
+// Grab all the command files from the commands directory you created earlier
+const commandFiles = allFiles.filter(file => file.endsWith('.js'));
+
+// Grab the SlashCommandBuilder#toJSON() output of each command's data for deployment
+for (const file of commandFiles) {
+	const command = require(`${file}`);
+	if ('data' in command && 'execute' in command) {
+		commands.push(command.data.toJSON());
+	}
+	else {
+		console.log(`Skipping ${file} as it is missing one or more required exported fields`);
+	}
+}
+
+// Construct and prepare an instance of the REST module
+const rest = new REST({ version: '10' }).setToken(token);
+
+// and deploy your commands!
+(async () => {
+	try {
+		console.log(`Started refreshing ${commands.length} application (/) commands.`);
+
+		// The put method is used to fully refresh all commands in the guild with the current set
+		const data = await rest.put(
+			Routes.applicationGuildCommands(clientId, guildId),
+			{ body: commands },
+		);
+
+		console.log(`Successfully reloaded ${data.length} application (/) commands.`);
+	}
+	catch (error) {
+		// And of course, make sure you catch and log any errors!
+		console.error(error);
+	}
+})();

package.json

@@ -1,24 +1,19 @@
 {
-  "name": "breadbot-test",
+  "name": "breadbot",
   "version": "1.0.0",
-  "main": "breadbot.ts",
+  "description": "A very bready Discord bot",
+  "main": "breadbot.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "dev": "tsx watch src/breadbot.ts",
-    "start": "node dist/breadbot.js",
-    "build": "tsup src/breadbot.ts --minify"
+    "test": "echo \"Error: no test specified\" && exit 1"
   },
-  "author": "",
+  "author": "Bradley Bickford",
   "license": "ISC",
-  "description": "",
   "dependencies": {
-    "discord.js": "^14.20.0",
-    "dotenv": "^16.5.0",
-    "sqlite3": "^5.1.7"
+    "@vvo/tzdb": "^6.77.0",
+    "discord.js": "^14.6.0",
+    "googleapis": "^109.0.1"
   },
   "devDependencies": {
-    "tsup": "^8.5.0",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3"
+    "eslint": "^8.27.0"
   }
 }

src/breadbot.ts

@@ -1,66 +0,0 @@
-import { Client, Events, GatewayIntentBits, Guild, GuildBasedChannel, Interaction } from "discord.js"
-import { utilities } from "./utilties"
-import { commands } from "./commands"
-import { config } from "./config"
-import { SQLCommon } from "./utilties/storage/interfaces"
-
-export const client : Client = new Client({
-    intents: [
-        GatewayIntentBits.Guilds,
-        GatewayIntentBits.GuildMessages,
-        GatewayIntentBits.GuildMembers,
-        GatewayIntentBits.MessageContent
-    ]
-})
-
-let db: SQLCommon
-
-if (config.DB_MODE == "sqlite") {
-    db = new utilities.sqlite.SqliteDB("breadbot_test.db")
-
-    db.run("PRAGMA foreign_keys = ON")
-
-    utilities.tables.makeTables(db)
-    
-    //TODO I really don't want this to be here.
-    utilities.events.messages.setupMessageCapture(client, db)
-}
-
-client.once(Events.ClientReady, () => {
-    // TODO Winston should handle this
-    console.log("Breadbot is ready")
-
-    client.guilds.cache.forEach(async (guild: Guild) => {
-        await utilities.commands.deployCommands(guild.id)
-
-        // TODO handle failures?
-        await utilities.guilds.insertGuild(db, guild)
-
-        guild.channels.cache.forEach(async (channel: GuildBasedChannel) => {
-            await utilities.channels.insertChannel(db, channel)
-        })
-    })
-})
-
-client.on(Events.GuildCreate, async (guild : Guild) => {
-    await utilities.commands.deployCommands(guild.id)
-    await utilities.guilds.insertGuild(db, guild)
-
-    guild.channels.cache.forEach(async (channel: GuildBasedChannel) => {
-        await utilities.channels.insertChannel(db, channel)
-    })
-})
-
-client.on(Events.InteractionCreate, async (interaction: Interaction) => {
-    if (!interaction.isCommand()) {
-        return
-    }
-
-    if (commands[interaction.commandName as keyof typeof commands]) {
-        commands[interaction.commandName as keyof typeof commands].execute(interaction)
-    }
-})
-
-
-
-client.login(config.DISCORD_TOKEN)

src/commands/breadalert.ts

@@ -1,55 +0,0 @@
-import { CommandInteraction, SlashCommandBuilder } from "discord.js";
-
-export const enabled: boolean = true
-
-export const data = new SlashCommandBuilder()
-    .setName("breadalert")
-    .setDescription("Controls event alerting using the Bread Alert subsystem")
-    .addSubcommand((subcommand) => 
-        subcommand
-            .setName("list")
-            .setDescription("List the current Bread Alert active alerts")
-            .addIntegerOption(option => 
-                option
-                    .setName("count")
-                    .setDescription("The number of future alerts to return, default 5")
-                    .setRequired(false)
-            )
-    )
-    .addSubcommand(subcommand =>
-        subcommand
-            .setName("add")
-            .setDescription("Add a new Bread Alert")
-            .addStringOption(option =>
-                option
-                    .setName("name")
-                    .setDescription("The name of the event, must be unique")
-                    .setRequired(true)
-            )
-            .addStringOption(option =>
-                option
-                    .setName("date")
-                    .setDescription("The date and time of the event in YYYY-MM-DD HH:MM:SS format")
-                    .setRequired(true)
-            )
-            .addStringOption(option =>
-                option
-                    .setName("notifications")
-                    .setDescription("A comma separated list of time offsets that determine when to alert prior to the event")
-                    .setRequired(false)
-            )
-    )
-    .addSubcommand(subcommand =>
-        subcommand
-            .setName("delete")
-            .setDescription("Delete a Bread Alert")
-            .addStringOption(option =>
-                option
-                    .setName("name")
-                    .setDescription("The name of the event to remove")
-            )
-    )
-
-export async function execute(interaction: CommandInteraction) {
-    return interaction.reply("NOT IMPLEMENTED!")
-}

src/commands/breadthread.ts

@@ -1,40 +0,0 @@
-import { ChannelType, CommandInteraction, SlashCommandBuilder } from "discord.js";
-
-export const enabled: boolean = true
-
-export const data = new SlashCommandBuilder()
-    .setName("breadthread")
-    .setDescription("Manages Breadbot's extended thread features")
-    .addSubcommand(subcommand => 
-        subcommand
-            .setName("autolock")
-            .setDescription("Enables auto locking of a thread after a period of thread inactivity")
-            .addChannelOption(option =>
-                option
-                    .setName("channel")
-                    .setDescription("The name of the thread you want to autolock")
-                    .addChannelTypes(
-                        ChannelType.PublicThread,
-                        ChannelType.PrivateThread,
-                        ChannelType.AnnouncementThread
-                    )
-                    .setRequired(true)
-            )
-            .addBooleanOption(option =>
-                option
-                    .setName("enable")
-                    .setDescription("Enable or disable the auto locking")
-                    .setRequired(true)
-            )
-            .addStringOption(option =>
-                option
-                    .setName("timeinactive")
-                    .setDescription("How long the thread needs to be inactive before locking, default is 3 days")
-                    .setRequired(false)
-            )
-            
-    )
-
-export async function execute(interaction: CommandInteraction) {
-    return interaction.reply("NOT IMPLEMENTED!")
-}

src/commands/index.ts

@@ -1,9 +0,0 @@
-import * as ping from "./ping";
-import * as breadalert from "./breadalert"
-import * as breadthread from "./breadthread"
-
-export const commands = {
-    ping,
-    breadalert,
-    breadthread
-}

src/commands/ping.ts

@@ -1,11 +0,0 @@
-import { CommandInteraction, SlashCommandBuilder } from "discord.js"
-
-export const enabled : boolean = true
-
-export const data : SlashCommandBuilder = new SlashCommandBuilder()
-    .setName("ping")
-    .setDescription("Replies with Pong!")
-
-export async function execute(interaction: CommandInteraction) {
-    return interaction.reply("Pong!")
-}

src/config.ts

@@ -1,15 +0,0 @@
-import dotenv from "dotenv"
-
-dotenv.config()
-
-const { DISCORD_TOKEN, DISCORD_CLIENT_ID, DB_MODE } = process.env
-
-if (!DISCORD_TOKEN || !DISCORD_CLIENT_ID || !DB_MODE) {
-    throw new Error("Missing environment variables")
-}
-
-export const config = {
-    DISCORD_TOKEN,
-    DISCORD_CLIENT_ID,
-    DB_MODE
-}

src/utilties/discord/channels.ts

@@ -1,50 +0,0 @@
-import { SQLCommon } from "../storage/interfaces";
-import { DMChannel, GuildBasedChannel, PartialDMChannel } from "discord.js";
-import { SQLResult } from "../storage/enumerations";
-
-export async function doesChannelExistByID(db: SQLCommon, channelID: string) : Promise<boolean> {
-    const queryResult : Object[] = await db.getAllParameterized(
-        "SELECT * FROM channels WHERE channel_snowflake = ?",
-        [channelID]
-    )
-
-    return queryResult.length != 0
-}
-
-export async function doesChannelExist(db: SQLCommon, channel : GuildBasedChannel | DMChannel | PartialDMChannel) : Promise<boolean> {
-    const queryResult : Object[] = await db.getAllParameterized(
-        "SELECT * FROM channels WHERE channel_snowflake = ?",
-        [channel.id]
-    )
-
-    return queryResult.length != 0
-}
-
-export async function insertChannel(db: SQLCommon, channel: GuildBasedChannel | DMChannel | PartialDMChannel) : Promise<SQLResult> {
-    const alreadyExists: boolean = await doesChannelExist(db, channel)
-
-    if(alreadyExists) {
-        return SQLResult.ALREADYEXISTS
-    }
-
-    try {
-        if (channel.isDMBased()) {
-            await db.runParameterized(
-                "INSERT INTO channels VALUES (?, ?, ?, ?, ?)",
-                [channel.id, null, channel.recipient?.username, channel.isThread(), channel.isDMBased()]
-            )
-        } else {
-            await db.runParameterized(
-                "INSERT INTO channels VALUES (?, ?, ?, ?, ?)",
-                [channel.id, channel.guild.id, channel.name, channel.isThread(), channel.isDMBased()]
-            )
-        }
-        
-
-        return SQLResult.CREATED
-    } catch (err) {
-        //TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}

src/utilties/discord/commands.ts

@@ -1,32 +0,0 @@
-import { REST, Routes } from "discord.js"
-import { config } from "../../config"
-import { commands } from "../../commands"
-
-const commandsData = Object.values(commands)
-    .filter((command) => command.enabled)
-    .map((command) => command.data)
-
-const rest : REST = new REST({ version: "10" }).setToken(config.DISCORD_TOKEN)
-
-export async function deployCommands(guildId: string) {
-    try {
-        // TODO Winston should handle this
-        console.log(`Refreshing slash commands for ${guildId}`)
-
-        await rest.put(
-            Routes.applicationGuildCommands(
-                config.DISCORD_CLIENT_ID,
-                guildId
-            ),
-            {
-                body: commandsData
-            }
-        )
-
-        // TODO Winston should handle this
-        console.log(`Successfully reloaded slash commands for ${guildId}`)
-    } catch (error) {
-        // TODO Winston should handle this
-        console.error(error)
-    }
-}

src/utilties/discord/guilds.ts

@@ -1,33 +0,0 @@
-import { Guild } from "discord.js";
-import { SQLCommon } from "../storage/interfaces";
-import { SQLResult } from "../storage/enumerations";
-
-export async function doesGuildExist(db: SQLCommon, guild : Guild) : Promise<boolean> {
-    const queryResult : Object[] = await db.getAllParameterized(
-        "SELECT * FROM servers WHERE server_snowflake = ?",
-        [guild.id]
-    )
-
-    return queryResult.length != 0
-}
-
-export async function insertGuild(db: SQLCommon, guild: Guild) : Promise<SQLResult> {
-    const alreadyExists: boolean = await doesGuildExist(db, guild)
-
-    if (alreadyExists) {
-        return SQLResult.ALREADYEXISTS
-    }
-    try {
-        await db.runParameterized(
-            "INSERT INTO servers VALUES (?, ?, ?)",
-            [guild.id, guild.name, guild.description]
-        )
-
-        return SQLResult.CREATED
-    } catch (err) {
-        console.log("Insert Failed")
-        //TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}

src/utilties/discord/messages.ts

@@ -1,111 +0,0 @@
-import { Attachment, Message, OmitPartialGroupDMChannel, PartialMessage } from "discord.js";
-import { SQLCommon } from "../storage/interfaces";
-import { SQLResult } from "../storage/enumerations";
-
-// TODO Do partial messages affect other functionality elsewhere?
-
-export async function doesMessageExist(db: SQLCommon, message: OmitPartialGroupDMChannel<Message<boolean>> | PartialMessage) : Promise<boolean> {
-    const queryResult: Object[] = await db.getAllParameterized(
-        "SELECT * FROM messages WHERE message_snowflake = ?",
-        [message.id]
-    )
-
-    return queryResult.length != 0
-}
-
-export async function doesAttachmentExist(db: SQLCommon, attachment: Attachment) : Promise<boolean> {
-    const queryResult: Object[] = await db.getAllParameterized(
-        "SELECT * FROM message_attachments WHERE attachment_snowflake = ?",
-        [attachment.id]
-    )
-
-    return queryResult.length != 0
-}
-
-export async function insertMessage(db: SQLCommon, message: OmitPartialGroupDMChannel<Message<boolean>>) : Promise<SQLResult> {
-    const alreadyExists: boolean = await doesMessageExist(db, message)
-
-    if(alreadyExists) {
-        return SQLResult.ALREADYEXISTS
-    }
-
-    try {
-        await db.runParameterized(
-            "INSERT INTO messages VALUES (?, ?, ?, ?, ?, ?)",
-            [message.id, message.channel.id, message.author.id, 
-                message.content, message.createdTimestamp, 0]
-        )
-
-        return SQLResult.CREATED
-    } catch (err) {
-        //TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}
-
-export async function updateMessageContentHistory(db: SQLCommon, message: OmitPartialGroupDMChannel<Message<boolean>>) : Promise<SQLResult> {
-    const messageIDExists: boolean = await doesMessageExist(db, message)
-
-    if(!messageIDExists) {
-        return SQLResult.FAILED
-    }
-
-    try {
-        await db.runParameterized(
-            "INSERT INTO message_content_changes (message_snowflake, message_change_old_timestamp, message_change_old_content) " +
-            "SELECT message_snowflake, message_timestamp, message_content FROM messages WHERE message_snowflake = ?;" +
-            "UPDATE messages SET message_timestamp = ?, message_content = ? WHERE message_snowflake = ?;",
-            [message.id, message.editedTimestamp, message.content, message.id]
-        )
-
-        return SQLResult.UPDATED
-    } catch (err) {
-        //TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}
-
-export async function markMessageDeleted(db: SQLCommon, message: OmitPartialGroupDMChannel<Message<boolean>> | PartialMessage) : Promise<SQLResult> {
-    const messageIDExists: boolean = await doesMessageExist(db, message)
-
-    if(!messageIDExists) {
-        return SQLResult.FAILED
-    }
-
-    try {
-        await db.runParameterized(
-            "UPDATE messages SET message_deleted = 1 WHERE message_snowflake = ?",
-            [message.id]
-        )
-
-        return SQLResult.UPDATED
-    } catch (err) {
-        // TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}
-
-export async function insertAttachment(db: SQLCommon, attachment: Attachment, message: OmitPartialGroupDMChannel<Message<boolean>> | PartialMessage) : Promise<SQLResult> {
-    const alreadyExists: boolean = await doesAttachmentExist(db, attachment)
-
-    if(alreadyExists) {
-        return SQLResult.ALREADYEXISTS
-    }
-
-    try {
-        await db.runParameterized(
-            "INSERT INTO message_attachments VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
-            [attachment.id, message.id, attachment.name, attachment.description, message.createdTimestamp, 
-                attachment.contentType, attachment.url, 0]
-        )
-
-        return SQLResult.CREATED
-    } catch (err) {
-        // TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}

src/utilties/discord/users.ts

@@ -1,33 +0,0 @@
-import { User } from "discord.js";
-import { SQLCommon } from "../storage/interfaces";
-import { SQLResult } from "../storage/enumerations";
-
-export async function doesUserExist(db: SQLCommon, user: User): Promise<boolean> {
-    const queryResult: Object[] = await db.getAllParameterized(
-        "SELECT * FROM users WHERE user_snowflake = ?",
-        [user.id]
-    )
-
-    return queryResult.length != 0
-}
-
-export async function insertUser(db: SQLCommon, user: User): Promise<SQLResult> {
-    const alreadyExists: boolean = await doesUserExist(db, user)
-
-    if(alreadyExists) {
-        return SQLResult.ALREADYEXISTS
-    }
-
-    try {
-        await db.runParameterized(
-            "INSERT INTO users VALUES (?, ?, ?)",
-            [user.id, user.username, user.displayName]
-        )
-
-        return SQLResult.CREATED
-    } catch (err) {
-        //TODO Winston should handle this
-        console.log(err)
-        return SQLResult.FAILED
-    }
-}

src/utilties/events/messages.ts

@@ -1,62 +0,0 @@
-import { Client, Events, Message, OmitPartialGroupDMChannel, PartialMessage } from "discord.js";
-import { SQLResult } from "../storage/enumerations";
-import { SQLCommon } from "../storage/interfaces";
-import { insertChannel } from "../discord/channels";
-import { insertUser } from "../discord/users";
-import { insertAttachment, insertMessage, markMessageDeleted, updateMessageContentHistory } from "../discord/messages";
-
-export function setupMessageCapture(client: Client, db: SQLCommon) {
-    client.on(Events.MessageCreate, async (message) => {
-        processMessageCreate(db, message)
-    })
-
-    client.on(Events.MessageUpdate, async (oldMessage, newMessage) => {
-        await processMessageModify(db, newMessage)
-    })
-
-    client.on(Events.MessageDelete, async (deletedMessage) => {
-        await processMessageDeleted(db, deletedMessage)
-    })
-}
-
-async function processMessageCreate(db: SQLCommon, message: OmitPartialGroupDMChannel<Message<boolean>>) {
-    const channelOk: SQLResult = await insertChannel(db, message.channel)
-    const userOk: SQLResult = await insertUser(db, message.author)
-
-    if (channelOk == SQLResult.ALREADYEXISTS || channelOk == SQLResult.CREATED ||
-        userOk == SQLResult.ALREADYEXISTS || userOk == SQLResult.CREATED) {
-        
-        await insertMessage(db, message)
-        // TODO observe success of message insertion
-        if(message.attachments.size != 0) {
-            const allAttachments: void[] = message.attachments.map((attachment) => {
-                insertAttachment(db, attachment, message)
-            })
-
-            await Promise.all(allAttachments).catch((error) => {
-                // TODO Winston should handle this
-                console.log(error)
-            })
-        }
-    }
-}
-
-async function processMessageModify(db: SQLCommon, newMessage: OmitPartialGroupDMChannel<Message<boolean>>) {
-    await updateMessageContentHistory(db, newMessage)
-
-    if(newMessage.attachments.size != 0) {
-        const allAttachments: void[] = newMessage.attachments.map((attachment) => {
-            insertAttachment(db, attachment, newMessage)
-        })
-
-        await Promise.all(allAttachments).catch((error) => {
-            // TODO Winston should handle this
-            console.log(error)
-        })
-    }
-}
-
-
-async function processMessageDeleted(db: SQLCommon, deletedMessage: OmitPartialGroupDMChannel<Message<boolean>> | PartialMessage) {
-    await markMessageDeleted(db, deletedMessage)
-}

src/utilties/index.ts

@@ -1,21 +0,0 @@
-import * as commands from "./discord/commands"
-import * as sqlite from "./storage/sqlite"
-import * as tables from "./storage/tables"
-import * as guilds from "./discord/guilds"
-import * as channels from "./discord/channels"
-import * as users from "./discord/users"
-import * as messages from "./events/messages"
-
-const events = {
-    messages
-}
-
-export const utilities = {
-    commands,
-    sqlite,
-    tables,
-    guilds,
-    channels,
-    users,
-    events
-}

src/utilties/storage/enumerations.ts

@@ -1,7 +0,0 @@
-export enum SQLResult {
-    CREATED,
-    UPDATED,
-    DELETED,
-    ALREADYEXISTS,
-    FAILED
-}

src/utilties/storage/interfaces.ts

@@ -1,7 +0,0 @@
-export interface SQLCommon {
-    run(query: string) : Promise<number>
-    runParameterized(query: string, parameters: any[]): Promise<number>
-    getAll(query: string) : Promise<Object[]>
-    getAllParameterized(query: string, parameters: any[]) : Promise<Object[]>
-}
-

src/utilties/storage/sqlite.ts

@@ -1,69 +0,0 @@
-import * as sqlite3 from 'sqlite3'
-
-import { SQLCommon } from "./interfaces"
-
-export class SqliteDB implements SQLCommon {
-    private db : sqlite3.Database;
-
-    public constructor(private readonly dbName: string) {
-        this.db = new sqlite3.Database(this.dbName);
-    }
-    
-    async run(query: string): Promise<number> {
-        return new Promise((resolve, reject) => {
-            this.db.run(query, function (this : sqlite3.RunResult, err: Error) {
-                if (err) {
-                    // TODO Winston should handle this
-                    console.log(err)
-                    throw err
-                } else {
-                    resolve(this.changes)
-                }
-            })
-        })
-    }
-
-    async runParameterized(query: string, parameters: any[]): Promise<number> {
-        return new Promise((resolve, reject) => {
-            this.db.run(query, parameters, function (this : sqlite3.RunResult, err: Error) {
-                if (err) {
-                    // TODO Winston should handle this
-                    console.log(err)
-                    throw err
-                } else {
-                    resolve(this.changes)
-                }
-            })
-        })
-    }
-
-    async getAll(query: string): Promise<Object[]> {
-        return new Promise((resolve, reject) => {
-            this.db.all(query, (err: Error, rows: Object[]) => {
-                if (err) {
-                    // TODO Winston should handle this
-                    console.log(err)
-                    throw err
-                } else {
-                    console.log("Got rows")
-                    resolve(rows)
-                }
-            })
-        })
-    }
-
-    getAllParameterized(query: string, parameters: any[]): Promise<Object[]> {
-        return new Promise((resolve, reject) => {
-            this.db.all(query, parameters, (err: Error, rows: Object[]) => {
-                if (err) {
-                    // TODO Winston should handle this
-                    console.log(err)
-                    throw err
-                } else {
-                    resolve(rows)
-                }
-            })
-        })
-    }
-
-}

src/utilties/storage/tables.ts

@@ -1,23 +0,0 @@
-import { SQLCommon } from "./interfaces";
-
-const tables: string[] = [
-    "CREATE TABLE IF NOT EXISTS servers (server_snowflake bigint NOT NULL PRIMARY KEY,server_name text NOT NULL,server_description mediumtext);",
-    "CREATE TABLE IF NOT EXISTS channels (channel_snowflake bigint NOT NULL PRIMARY KEY,server_snowflake bigint,channel_name text,is_thread bit NOT NULL,is_dm bit NOT NULL);",
-    "CREATE TABLE IF NOT EXISTS users (user_snowflake bigint NOT NULL PRIMARY KEY,user_name text NOT NULL,user_displayname text);",
-    "CREATE TABLE IF NOT EXISTS messages (message_snowflake bigint NOT NULL PRIMARY KEY,channel_snowflake bigint NOT NULL,user_snowflake bigint NOT NULL,message_content longtext NOT NULL,message_timestamp datetime NOT NULL,message_deleted bit NOT NULL);",
-    "CREATE TABLE IF NOT EXISTS message_content_changes (message_change_id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,message_snowflake bigint NOT NULL,message_change_old_timestamp datetime NOT NULL,message_change_old_content longtext NOT NULL);",
-    "CREATE TABLE IF NOT EXISTS message_attachments (attachment_snowflake bigint NOT NULL PRIMARY KEY,message_snowflake bigint NOT NULL,attachment_name text NOT NULL,attachment_description text,attachment_timestamp datetime NOT NULL,attachment_mime_type text,attachment_url text NOT NULL,attachment_downloaded bit NOT NULL);"
-]
-
-const constraints: string[] = [
-    "ALTER TABLE channels ADD CONSTRAINT channels_server_snowflake_fk FOREIGN KEY (server_snowflake) REFERENCES servers (server_snowflake);"
-]
-
-export async function makeTables(db: SQLCommon): Promise<number[]> {
-    return Promise.all(tables.map((statement) => db.run(statement)))
-}
-
-export async function makeConstraints(db: SQLCommon): Promise<number[]> {
-    return Promise.all(constraints.map((statement) => db.run(statement)))
-}
-

tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "removeComments": true,
-    "resolveJsonModule": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "strictNullChecks": true,
-    "skipLibCheck": true
-  }
-}

utilities/googlecalendar.js

@@ -0,0 +1,122 @@
+const { google } = require('googleapis');
+const { googlePrivateKey, googleClientEmail, googleProjectNumber } = require('../config.json');
+const { stdout } = require('node:process');
+const SCOPES = ['https://www.googleapis.com/auth/calendar'];
+
+async function getCalendarReference() {
+	const jwtClient = new google.auth.JWT(
+		googleClientEmail,
+		'../keyfile.json',
+		googlePrivateKey,
+		SCOPES,
+	);
+
+	return new google.calendar({
+		version: 'v3',
+		project: googleProjectNumber,
+		auth: jwtClient,
+	});
+}
+
+async function doesCalendarExist(calendarName) {
+	const calendarReference = await getCalendarReference();
+	const listResults = await calendarReference.calendarList.list({});
+
+	for (const item of listResults.data.items) {
+		if (item.summary === calendarName) {
+			return item;
+		}
+	}
+
+	return null;
+}
+
+async function getListOfCalendars(options, callback) {
+	const calendarReference = await getCalendarReference();
+	calendarReference.calendarList.list(options, async (err, res) => {
+		if (err) {
+			callback(false, 'Failed to retrieve the list of calendars\nAsk Bradley to check Breadbot console');
+			stdout.write('[ERROR]:');
+			console.log(err.errors);
+			return;
+		}
+
+		callback(true, 'Calendar List', res.data.items);
+	});
+}
+
+async function addCalendar(calendarName, timezone, callback) {
+	const calendarReference = await getCalendarReference();
+	calendarReference.calendars.insert({
+		resource: {
+			summary: calendarName,
+			timeZone: timezone,
+		},
+	},
+	// eslint-disable-next-line no-unused-vars
+	async (err, res) => {
+		if (err) {
+			callback(false, 'Failed to create new calendar ' + calendarName + '\nAsk Bradley to check Breadbat console', err);
+			stdout.write('[ERROR]: ');
+			console.log(err.errors);
+			return;
+		}
+
+		callback(true, 'Successfully created new calendar ' + calendarName, null);
+	});
+}
+
+async function deleteCalendar(calendarName, callback) {
+	const exists = await doesCalendarExist(calendarName);
+
+	if (exists) {
+		const calendarReference = await getCalendarReference();
+		calendarReference.calendars.delete({
+			calendarId: exists.id,
+		},
+		// eslint-disable-next-line no-unused-vars
+		async (err, res) => {
+			if (err) {
+				callback(false, 'Failed to delete ' + calendarName + '\nAsk Bradley to check Breadbot console', err);
+				stdout.write('[ERROR]: ');
+				console.log(err);
+				return;
+			}
+
+			callback(true, 'Successfully deleted ' + calendarName, null);
+		});
+	}
+	else {
+		callback(false, 'The calendar name specified doesn\'t exist', null);
+	}
+}
+
+async function addEvent(calendarName, eventName, location, description, startDate, startTime, endDate, endTime) {
+	const exists = await doesCalendarExist(calendarName);
+
+	if (exists) {
+		const calendarReference = await getCalendarReference();
+		calendarReference.events.insert({
+			calendarId: exists.id,
+			resource: {
+				summary: eventName,
+				location: location,
+				description: description,
+				start: {
+					
+				}
+			},
+		})
+	}
+	else {
+		callback(false, 'The calendar name specified doesn\'t exist', null);
+	}
+}
+
+module.exports = {
+	getCalendarReference,
+	getListOfCalendars,
+	doesCalendarExist,
+	deleteCalendar,
+	addCalendar,
+};