Added relational-based warns and mutes.

Author: andrewlalis

.gitignore

@@ -1,4 +1,6 @@
 .idea/
 .gradle/
 build/
-/javabot_config/
+/javabot_config/
+/javabot.mv.db
+/javabot.trace.db

build.gradle

@@ -11,17 +11,20 @@ targetCompatibility = 16
 
 repositories {
     mavenCentral()
+    maven {
+        url "https://oss.sonatype.org/content/repositories/snapshots/"
+    }
 }
 
 dependencies {
-    implementation 'org.javacord:javacord:3.3.2'
+    implementation 'org.javacord:javacord:3.4.0-SNAPSHOT'
 
     implementation 'org.yaml:snakeyaml:1.29'
     implementation 'com.google.code.gson:gson:2.8.9'
 
     // Persistence Dependencies
     implementation 'org.mongodb:mongodb-driver:3.12.10'
-    implementation 'org.postgresql:postgresql:42.3.0'
+    implementation 'com.h2database:h2:1.4.200'
     implementation 'com.zaxxer:HikariCP:5.0.0'
 
     // Lombok annotations

docker-compose.yaml

@@ -22,27 +22,3 @@ services:
       ME_CONFIG_MONGODB_ADMINUSERNAME: root
       ME_CONFIG_MONGODB_ADMINPASSWORD: example
       ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/
-  # Postgresql Relational Database
-  postgres:
-    image: postgres:latest
-    container_name: javabot_postgres
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: javabot_dev
-      POSTGRES_PASSWORD: javabot_dev_pass
-      POSTGRES_DB: javabot
-    ports:
-      - "27172:5432"
-
-  # Admin site for postgres. Connect via http://localhost:5051
-  pgadmin:
-    image: dpage/pgadmin4
-    container_name: javabot_pgadmin
-    environment:
-      PGADMIN_DEFAULT_EMAIL: pgadmin4@pgadmin.org
-      PGADMIN_DEFAULT_PASSWORD: admin
-      PGADMIN_CONFIG_SERVER_MODE: 'False'
-    depends_on:
-      - postgres
-    ports:
-      - "5051:80"

src/main/java/net/javadiscord/javabot2/Bot.java

@@ -5,21 +5,28 @@
 import com.mongodb.client.MongoDatabase;
 import com.mongodb.client.model.IndexOptions;
 import com.mongodb.client.model.Indexes;
-import com.zaxxer.hikari.HikariConfig;
 import com.zaxxer.hikari.HikariDataSource;
+import lombok.extern.slf4j.Slf4j;
 import net.javadiscord.javabot2.command.SlashCommandListener;
 import net.javadiscord.javabot2.config.BotConfig;
+import net.javadiscord.javabot2.db.DbHelper;
+import net.javadiscord.javabot2.systems.moderation.ModerationService;
 import org.javacord.api.DiscordApi;
 import org.javacord.api.DiscordApiBuilder;
 import org.javacord.api.entity.intent.Intent;
 
 import java.nio.file.Path;
+import java.sql.SQLException;
+import java.time.ZoneOffset;
+import java.util.TimeZone;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
 
 /**
  * The main program entry point.
  */
+@Slf4j
 public class Bot {
 	/**
 	 * A connection pool that can be used to obtain new JDBC connections.
@@ -54,6 +61,7 @@ private Bot() {}
 	 * @param args Command-line arguments.
 	 */
 	public static void main(String[] args) {
+		TimeZone.setDefault(TimeZone.getTimeZone(ZoneOffset.UTC));
 		initDataSources();
 		asyncPool = Executors.newScheduledThreadPool(config.getSystems().getAsyncPoolSize());
 		DiscordApi api = new DiscordApiBuilder()
@@ -68,6 +76,7 @@ public static void main(String[] args) {
 				"commands/moderation.yaml"
 		);
 		api.addSlashCommandCreateListener(commandListener);
+		initScheduledTasks(api);
 	}
 
 	/**
@@ -80,14 +89,13 @@ private static void initDataSources() {
 		if (config.getSystems().getDiscordBotToken() == null || config.getSystems().getDiscordBotToken().isBlank()) {
 			throw new IllegalStateException("Missing required Discord bot token! Please edit config/systems.json to add it, then run again.");
 		}
-		var hikariConfig = new HikariConfig();
-		var hikariConfigSource = config.getSystems().getHikariConfig();
-		hikariConfig.setJdbcUrl(hikariConfigSource.getJdbcUrl());
-		hikariConfig.setUsername(hikariConfigSource.getUsername());
-		hikariConfig.setPassword(hikariConfigSource.getPassword());
-		hikariConfig.setMaximumPoolSize(hikariConfigSource.getMaximumPoolSize());
-		hikariConfig.setConnectionInitSql(hikariConfigSource.getConnectionInitSql());
-		hikariDataSource = new HikariDataSource(hikariConfig);
+
+		try {
+			hikariDataSource = DbHelper.initDataSource(config);
+		} catch (SQLException e) {
+			log.error("Could not initialize Hikari data source.");
+			throw new IllegalStateException(e);
+		}
 		mongoDb = initMongoDatabase();
 	}
 
@@ -99,4 +107,13 @@ private static MongoDatabase initMongoDatabase() {
 		warnCollection.createIndex(Indexes.descending("createdAt"), new IndexOptions().unique(false));
 		return db;
 	}
+
+	private static void initScheduledTasks(DiscordApi api) {
+		asyncPool.scheduleAtFixedRate(() -> {
+			for (var server : api.getServers()) {
+				new ModerationService(api, config.get(server).getModeration());
+				// TODO: Figure out how to periodically unmute people. Consider tracking each muted person.
+			}
+		}, 3L, 3L, TimeUnit.MINUTES);
+	}
 }

src/main/java/net/javadiscord/javabot2/command/Responses.java

@@ -4,6 +4,7 @@
 import org.javacord.api.entity.message.embed.EmbedBuilder;
 import org.javacord.api.event.interaction.SlashCommandCreateEvent;
 import org.javacord.api.interaction.InteractionBase;
+import org.javacord.api.interaction.callback.InteractionCallbackDataFlag;
 import org.javacord.api.interaction.callback.InteractionImmediateResponseBuilder;
 import org.javacord.api.interaction.callback.InteractionOriginalResponseUpdater;
 
@@ -90,7 +91,7 @@ private static InteractionImmediateResponseBuilder reply(
 					.setTimestampToNow()
 					.setDescription(message));
 		if (ephemeral) {
-			responder.setFlags(MessageFlag.EPHEMERAL);
+			responder.setFlags(InteractionCallbackDataFlag.EPHEMERAL);
 		}
 		return responder;
 	}

src/main/java/net/javadiscord/javabot2/config/SystemsConfig.java

@@ -38,10 +38,7 @@ public class SystemsConfig {
 	@Data
 	public static class HikariConfig {
 		private static final int DEFAULT_POOL_SIZE = 5;
-		private String jdbcUrl = "jdbc:postgresql://localhost:27172/javabot";
-		private String username = "javabot_dev";
-		private String password = "javabot_dev_pass";
+		private String jdbcUrl = "jdbc:h2:tcp://localhost:9123/./javabot";
 		private int maximumPoolSize = DEFAULT_POOL_SIZE;
-		private String connectionInitSql = "SET TIME ZONE 'UTC'";
 	}
 }

src/main/java/net/javadiscord/javabot2/config/guild/ModerationConfig.java

@@ -3,6 +3,7 @@
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import net.javadiscord.javabot2.config.GuildConfigItem;
+import org.javacord.api.entity.channel.ServerTextChannel;
 import org.javacord.api.entity.permission.Role;
 
 /**
@@ -29,7 +30,25 @@ public class ModerationConfig extends GuildConfigItem {
 	 */
 	private int maxWarnSeverity;
 
+	/**
+	 * The id of the server's mute role.
+	 */
+	private long muteRoleId;
+
+	/**
+	 * The id of the channel where log messages are sent.
+	 */
+	private long logChannelId;
+
 	public Role getStaffRole() {
 		return this.getGuild().getRoleById(staffRoleId).orElseThrow();
 	}
+
+	public Role getMuteRole() {
+		return this.getGuild().getRoleById(muteRoleId).orElseThrow();
+	}
+
+	public ServerTextChannel getLogChannel() {
+		return this.getGuild().getChannelById(logChannelId).orElseThrow().asServerTextChannel().orElseThrow();
+	}
 }

src/main/java/net/javadiscord/javabot2/db/ConnectionConsumer.java

@@ -0,0 +1,9 @@
+package net.javadiscord.javabot2.db;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+@FunctionalInterface
+public interface ConnectionConsumer {
+	void consume(Connection con) throws SQLException;
+}

src/main/java/net/javadiscord/javabot2/db/DbHelper.java

@@ -0,0 +1,105 @@
+package net.javadiscord.javabot2.db;
+
+import com.zaxxer.hikari.HikariConfig;
+import com.zaxxer.hikari.HikariDataSource;
+import lombok.extern.slf4j.Slf4j;
+import net.javadiscord.javabot2.Bot;
+import net.javadiscord.javabot2.config.BotConfig;
+import org.h2.tools.Server;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+import java.util.regex.Pattern;
+
+/**
+ * Class that provides helper methods for dealing with the database.
+ */
+@Slf4j
+public class DbHelper {
+	/**
+	 * Initializes the data source that'll be used throughout the bot to access
+	 * the database.
+	 * @param config The bot's configuration.
+	 * @return The data source.
+	 * @throws SQLException If an error occurs.
+	 */
+	public static HikariDataSource initDataSource(BotConfig config) throws SQLException {
+		// Determine if we need to initialize the schema, before starting up the server.
+		boolean shouldInitSchema = shouldInitSchema(config.getSystems().getHikariConfig().getJdbcUrl());
+
+		// Now that we have remembered whether we need to initialize the schema, start up the server.
+		var server = Server.createTcpServer("-tcpPort", "9123", "-ifNotExists").start();
+		var hikariConfig = new HikariConfig();
+		var hikariConfigSource = config.getSystems().getHikariConfig();
+		hikariConfig.setJdbcUrl(hikariConfigSource.getJdbcUrl());
+		hikariConfig.setMaximumPoolSize(hikariConfigSource.getMaximumPoolSize());
+		var ds = new HikariDataSource(hikariConfig);
+		Runtime.getRuntime().addShutdownHook(new Thread(() -> {
+			ds.close();
+			server.stop();
+		}));
+		if (shouldInitSchema) {
+			try {
+				initializeSchema(ds);
+			} catch (IOException e) {
+				e.printStackTrace();
+				throw new IllegalStateException(e);
+			}
+		}
+		return ds;
+	}
+
+	/**
+	 * Does an asynchronous database action using the bot's async pool.
+	 * @param consumer The consumer that will use a connection.
+	 * @return A future that completes when the action is complete.
+	 */
+	public static CompletableFuture<Void> doDbAction(ConnectionConsumer consumer) {
+		CompletableFuture<Void> future = new CompletableFuture<>();
+		Bot.asyncPool.submit(() -> {
+			try (var c = Bot.hikariDataSource.getConnection()) {
+				consumer.consume(c);
+				future.complete(null);
+			} catch (SQLException e) {
+				future.completeExceptionally(e);
+			}
+		});
+		return future;
+	}
+
+	private static boolean shouldInitSchema(String jdbcUrl) {
+		var p = Pattern.compile("jdbc:h2:tcp://localhost:\\d+/(.*)");
+		var m = p.matcher(jdbcUrl);
+		boolean shouldInitSchema = false;
+		if (m.find()) {
+			String dbFilePath = m.group(1) + ".mv.db";
+			if (Files.notExists(Path.of(dbFilePath))) {
+				log.info("Database file doesn't exist yet. Initializing schema.");
+				shouldInitSchema = true;
+			}
+		} else {
+			throw new IllegalArgumentException("Invalid JDBC URL. Should point to a file.");
+		}
+		return shouldInitSchema;
+	}
+
+	private static void initializeSchema(HikariDataSource dataSource) throws IOException, SQLException {
+		InputStream is = DbHelper.class.getResourceAsStream("/db/schema.sql");
+		if (is == null) throw new IOException("Could not load schema.sql.");
+		var queries = Arrays.stream(new String(is.readAllBytes()).split(";"))
+				.filter(s -> !s.isBlank()).toList();
+		try (var c = dataSource.getConnection()) {
+			for (var query : queries) {
+				var stmt = c.createStatement();
+				stmt.executeUpdate(query);
+				stmt.close();
+			}
+		}
+		log.info("Successfully initialized H2 database.");
+	}
+}

src/main/java/net/javadiscord/javabot2/systems/moderation/BanCommand.java

@@ -22,8 +22,9 @@ public InteractionImmediateResponseBuilder handle(SlashCommandInteraction intera
 				.orElseThrow(ResponseException.warning("This command can only be performed in a channel."))
 				.asServerTextChannel()
 				.orElseThrow(ResponseException.warning("This command can only be performed in a server text channel."));
-		var moderationService = new ModerationService(interaction.getApi(), Bot.mongoDb, Bot.config.get(channel.getServer()).getModeration());
-		moderationService.ban(user, reason, interaction.getUser(), channel);
+		var quiet = interaction.getOptionBooleanValueByName("quiet").orElse(false);
+		var moderationService = new ModerationService(interaction.getApi(), Bot.config.get(channel.getServer()).getModeration());
+		moderationService.ban(user, reason, interaction.getUser(), channel, quiet);
 		return Responses.successBuilder(interaction)
 				.title("User Banned")
 				.messageFormat("User %s has been banned.", user.getMentionTag())