bea/HidekoBot
1
0
Fork 0
Code Issues 8 Pull Requests 4 Packages Projects Releases Wiki Activity

Compare commits

base: bea:main
Branches Tags
bea:main bea:renovate/com.google.protobuf-protobuf-java-4.x bea:renovate/org.owasp-dependency-check-maven-12.x bea:renovate/org.sonarsource.scanner.maven-sonar-maven-plugin-5.x bea:renovate/net.dv8tion-jda-6.x bea:develop
..
compare: bea:495f16455274464003596fb876786047f145e7e3
Branches Tags
bea:renovate/com.google.protobuf-protobuf-java-4.x bea:renovate/org.owasp-dependency-check-maven-12.x bea:renovate/org.sonarsource.scanner.maven-sonar-maven-plugin-5.x bea:main bea:renovate/net.dv8tion-jda-6.x bea:develop

15 Commits
main ... 495f164552

Author SHA1 Message Date
Lorenzo Dellacà
495f164552 Ignore bots interacting with hideko
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 16:54:15 +01:00
Lorenzo Dellacà
fd100649a7 Remove unneeded todo 2022-12-19 16:48:20 +01:00
Lorenzo Dellacà
b3990ff04f Make clear command also delete the sender's message
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 16:47:49 +01:00
Lorenzo Dellacà
f5238ced89 Bump version to 0.5.3
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 01:41:04 +01:00
Lorenzo Dellacà
f0ee565185 Implement basic functional diceroll command
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 01:36:43 +01:00
Lorenzo Dellacà
a21d179308 Fix command label being passed as arg in case of no args
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:22:51 +01:00
Lorenzo Dellacà
36ad728bbc Fallback to 0 instead of 1
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:14:30 +01:00
Lorenzo Dellacà
1a6fe6465c Fix console error when int parsing fails in clear message
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:13:14 +01:00
Lorenzo Dellacà
f0004dc555 Re-register accidentally removed invite command
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:10:15 +01:00
Lorenzo Dellacà
8ddf0ab80d Bump JDA version to more stable beta
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:07:02 +01:00
Lorenzo Dellacà
660e18d1f4 Bump version to 0.5.2
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:05:49 +01:00
Lorenzo Dellacà
db943f7e05 Fix messages with newlines not being handled for commands
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-19 00:05:36 +01:00
Lorenzo Dellacà
cb49bda84a Make say support both slash and message commands 2022-12-19 00:05:13 +01:00
Lorenzo Dellacà
b318b9f22b Bump version to 0.5.1
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-18 23:49:00 +01:00
Lorenzo Dellacà
1447f8c177 Make avatar support both slash and message commands
All checks were successful
continuous-integration/drone/push Build is passing
Details
2022-12-18 23:47:54 +01:00
95 changed files with 990 additions and 5474 deletions
Expand all files Collapse all files

26
.drone.yml
View File

@@ -1,14 +1,14 @@
kind: template kind: pipeline
load: java-build-deploy.yaml name: default
data:
arch: arm64 trigger:
os: linux branch:
build_branches:
- main - main
- develop
build_events: steps:
- push - name: build
- pull_request image: maven:3-eclipse-temurin-16
sonar_project_key: HidekoBot commands:
deploy_targets: - mvn install -DskipTests=true -Dmaven.javadoc.skip=true -B -V
- production - mvn javadoc:javadoc
- mvn test -B

3
.gitignore vendored
View File

@@ -1,4 +1,3 @@
target/ target/
.idea/ .idea/
scripts/ *.sqlite
*.sqlite

88
.pipelines/java-build-deploy.yaml
View File

@@ -1,88 +0,0 @@
---
kind: pipeline
type: docker
name: build
platform:
os: {{ .input.os }}
arch: {{ .input.arch }}
trigger:
branch:
{{- range .input.build_branches }}
- {{ . }}
{{- end }}
event:
{{- range .input.build_events }}
- {{ . }}
{{- end }}
# Global project-specific environment variables
environment:
{{- range .input.envs }}
{{ .name }}: {{ .value }}
{{- end }}
steps:
# Test if it compiles correctly
- name: build
image: maven:3-eclipse-temurin-21
commands:
- mvn verify --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V
# Run unit tests
- name: test
image: maven:3-eclipse-temurin-21
commands:
- mvn test --no-transfer-progress -B -V
# Check maven dependencies
- name: dependency-check
image: owasp/dependency-check:latest
commands:
- dependency-check --scan /src --format ALL --out /src/target --nvdApiKey $NVD_API_KEY
environment:
NVD_API_KEY:
from_secret: nvd_api_key
# Run code analysis
- name: code-analysis
when:
event:
- push
image: maven:3-eclipse-temurin-21
commands:
- mvn sonar:sonar --no-transfer-progress -Dsonar.projectKey={{ .input.sonar_project_key }} -Dsonar.host.url=$SONAR_INSTANCE_URL -Dsonar.token=$SONAR_LOGIN_KEY -B -V
environment:
SONAR_INSTANCE_URL:
from_secret: sonar_instance_url
SONAR_LOGIN_KEY:
from_secret: sonar_login_key
---
kind: pipeline
type: kubernetes
name: deploy
trigger:
event:
- promote
target:
{{- range .input.deploy_targets }}
- {{ . }}
{{- end }}
# Global project-specific environment variables
environment:
{{- range .input.envs }}
{{ .name }}: {{ .value }}
{{- end }}
steps:
# Upload to Maven repository
- name: maven-deploy
image: maven:3-eclipse-temurin-21
commands:
- mvn deploy --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V -gs settings.xml -Dmaven.repo.username=$MAVEN_REPO_USERNAME -Dmaven.repo.password=$MAVEN_REPO_PASSWORD
environment:
MAVEN_REPO_USERNAME:
from_secret: maven_repo_username
MAVEN_REPO_PASSWORD:
from_secret: maven_repo_password

31
README.MD
View File

@@ -1,16 +1,7 @@
# HidekoBot # HidekoBot
[![Reliability Rating](https://sonar.beatrice.wtf/api/project_badges/measure?project=HidekoBot&metric=reliability_rating&token=0a63c149148555d6d2ee40665af1afae8f67cc3f)](https://sonar.beatrice.wtf/dashboard?id=HidekoBot)
[![Maintainability Rating](https://sonar.beatrice.wtf/api/project_badges/measure?project=HidekoBot&metric=sqale_rating&token=0a63c149148555d6d2ee40665af1afae8f67cc3f)](https://sonar.beatrice.wtf/dashboard?id=HidekoBot)
[![Security Rating](https://sonar.beatrice.wtf/api/project_badges/measure?project=HidekoBot&metric=security_rating&token=0a63c149148555d6d2ee40665af1afae8f67cc3f)](https://sonar.beatrice.wtf/dashboard?id=HidekoBot)
[![Build Status](https://drone.beatrice.wtf/api/badges/bea/HidekoBot/status.svg)](https://drone.beatrice.wtf/bea/HidekoBot)
[![Lines of Code](https://sonar.beatrice.wtf/api/project_badges/measure?project=HidekoBot&metric=ncloc&token=0a63c149148555d6d2ee40665af1afae8f67cc3f)](https://sonar.beatrice.wtf/dashboard?id=HidekoBot)
Hideko is a general-purpose Discord bot. Hideko is a general-purpose Discord bot.
## Download
The latest stable version is always uploaded automatically to the [Maven repository](https://nexus.beatrice.wtf/#browse/browse:maven-releases:wtf%2Fbeatrice%2Fhidekobot%2FHidekoBot).
You can download the JAR directly by clicking [here](https://nexus.beatrice.wtf/service/rest/v1/search/assets/download?sort=version&repository=maven-releases&maven.groupId=wtf.beatrice.hidekobot&maven.artifactId=HidekoBot&maven.extension=jar).
## Startup ## Startup
Download a prebuilt JAR file or build it from source, then run it with: Download a prebuilt JAR file or build it from source, then run it with:
```bash ```bash
@@ -21,28 +12,16 @@ make the bot change its behavior.
Additionally available parameters are: Additionally available parameters are:
- **verbose**: log every message that the bot receives, plus additional debugging messages. Very spammy and performance heavy. - **verbose**: log every message that the bot receives, plus additional debugging messages. Very spammy and performance heavy.
- **refresh**: force refresh the slash commands. This is useful in case there was a simple update to a command that did not drastically change it, so no changes are found at bootup (eg: fixing a typo in the command description). - **refresh**: force refresh the bot's commands.
*Note: Java 21 or later is required.* *Note: Java 16 or later is required.*
## Initial setup ## Initial setup
Run the startup command once. The bot will generate a `config.yml` file in your current directory (`$PWD` on GNU/Linux). Run the startup command once. The bot will generate a `config.yml` file in the directory you were when you ran it.
Edit the configuration file and set all values according to your needs. Edit the configuration file and set all values according to your needs.
Save the file and start the bot again. If there are no issues, everything will load and it will print an Save the file and start the bot again. If there are no issues, everything will load and it will print an
invite-link in your console. Click on the link to add your bot to any server with the correct permissions invite-link in your console. Click on the link to add your bot to any server with the correct permissions
already set-up. The bot supports both slash commands and message commands, with prefix `hideko`. Most already set-up.
commands support both systems, but some of them are limited in one way or another.
The bot currently supports SQLite as a database backend. A database file will be created after the first boot
in your current directory. Do not delete the database file to avoid corruption and unpredictable
behavior.
# Development
## Versioning
This project uses the `x.y.z-releaseType` schema for releases.
Development builds are tagged as `x.y.z-SNAPSHOT` and sometimes pushed to the snapshots Maven repository.
Stable builds are tagged as `x.y.z` and always pushed to the releases Maven repository, by promoting the build on
[Drone](https://drone.beatrice.wtf/). Currently, promoting stable builds is a manual process.

121
pom.xml
View File

@@ -6,107 +6,42 @@
<groupId>wtf.beatrice.hidekobot</groupId> <groupId>wtf.beatrice.hidekobot</groupId>
<artifactId>HidekoBot</artifactId> <artifactId>HidekoBot</artifactId>
<version>0.6.3-SNAPSHOT</version> <version>0.5.3</version>
<properties> <properties>
<maven.compiler.source>21</maven.compiler.source> <maven.compiler.source>16</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target> <maven.compiler.target>16</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<sonar.dependencyCheck.htmlReportPath>./target/dependency-check-report.html</sonar.dependencyCheck.htmlReportPath>
<sonar.dependencyCheck.jsonReportPath>./target/dependency-check-report.json</sonar.dependencyCheck.jsonReportPath>
<sonar.dependencyCheck.summarize>true</sonar.dependencyCheck.summarize>
</properties> </properties>
<dependencies> <dependencies>
<!-- Basic JDA dependency for Discord API -->
<dependency> <dependency>
<groupId>net.dv8tion</groupId> <groupId>net.dv8tion</groupId>
<artifactId>JDA</artifactId> <artifactId>JDA</artifactId>
<version>5.6.1</version> <version>5.0.0-beta.2</version>
</dependency> </dependency>
<!-- JDA depends on SLF4J for logging -->
<dependency> <dependency>
<groupId>org.slf4j</groupId> <groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId> <artifactId>slf4j-api</artifactId>
<version>2.0.17</version> <version>2.0.4</version>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.slf4j</groupId> <groupId>org.slf4j</groupId>
<artifactId>slf4j-simple</artifactId> <artifactId>slf4j-simple</artifactId>
<version>2.0.17</version> <version>2.0.4</version>
</dependency> </dependency>
<!-- Dependency used for SQLite database connections-->
<dependency> <dependency>
<groupId>org.xerial</groupId> <groupId>org.xerial</groupId>
<artifactId>sqlite-jdbc</artifactId> <artifactId>sqlite-jdbc</artifactId>
<version>3.51.0.0</version> <version>3.39.4.1</version>
</dependency> </dependency>
<!-- Dependency used for YAML configuration files -->
<dependency> <dependency>
<groupId>org.yaml</groupId> <groupId>org.yaml</groupId>
<artifactId>snakeyaml</artifactId> <artifactId>snakeyaml</artifactId>
<version>2.5</version> <version>1.33</version>
</dependency>
<!-- JSoup is used to parse HTML into JSON objects for better handling in Java -->
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.21.2</version>
</dependency>
<!-- Various String manipulation utils -->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-text</artifactId>
<version>1.14.0</version>
</dependency>
<!-- JSON dependency used for better parsing of JSON files -->
<dependency>
<groupId>org.json</groupId>
<artifactId>json</artifactId>
<version>20250517</version>
</dependency>
<!-- Start Random.org dependencies -->
<dependency>
<groupId>com.github.jinahya</groupId>
<artifactId>random-org-json-rpc</artifactId>
<version>0.0.1</version>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.13.2</version>
</dependency>
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.20.0</version>
</dependency>
<!-- End Random.org dependencies -->
<!-- Unit Tests Dependencies -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter-api</artifactId>
<version>6.0.1</version>
<scope>test</scope>
</dependency> </dependency>
</dependencies> </dependencies>
<!-- override dependencies to use newer versions -->
<dependencyManagement>
<dependencies>
<dependency>
<groupId>com.google.protobuf</groupId>
<artifactId>protobuf-java</artifactId>
<version>4.33.0</version>
</dependency>
</dependencies>
</dependencyManagement>
<build> <build>
<resources> <resources>
@@ -143,46 +78,10 @@
<plugin> <plugin>
<groupId>org.apache.maven.plugins</groupId> <groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId> <artifactId>maven-javadoc-plugin</artifactId>
<version>3.12.0</version> <version>3.4.1</version>
</plugin>
<plugin>
<groupId>org.sonarsource.scanner.maven</groupId>
<artifactId>sonar-maven-plugin</artifactId>
<version>5.2.0.4988</version>
</plugin>
<plugin>
<groupId>org.owasp</groupId>
<artifactId>dependency-check-maven</artifactId>
<version>12.1.8</version>
<configuration>
<failBuildOnCVSS>8</failBuildOnCVSS>
<!--suppress UnresolvedMavenProperty -->
<nvdApiKey>${nvdApiKey}</nvdApiKey>
<knownExploitedUrl>https://raw.githubusercontent.com/EugenMayer/cisa-known-exploited-mirror/main/known_exploited_vulnerabilities.json</knownExploitedUrl>
<formats>
<format>html</format>
<format>json</format>
</formats>
<suppressionFiles>
<suppressionFile>./suppressions.xml</suppressionFile>
</suppressionFiles>
</configuration>
</plugin> </plugin>
</plugins> </plugins>
</build> </build>
<distributionManagement> </project>
<repository>
<id>nexus-releases</id>
<url>https://nexus.beatrice.wtf/repository/maven-releases/</url>
</repository>
<snapshotRepository>
<id>nexus-snapshots</id>
<url>https://nexus.beatrice.wtf/repository/maven-snapshots/</url>
</snapshotRepository>
</distributionManagement>
</project>

3
renovate.json
View File

@@ -1,3 +0,0 @@
{
"$schema": "https://docs.renovatebot.com/renovate-schema.json"
}

20
settings.xml
View File

@@ -1,20 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<settings xmlns="http://maven.apache.org/SETTINGS/1.1.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.1.0 http://maven.apache.org/xsd/settings-1.1.0.xsd">
<servers>
<server>
<id>nexus-snapshots</id>
<username>${maven.repo.username}</username>
<password>${maven.repo.password}</password>
</server>
<server>
<id>nexus-releases</id>
<username>${maven.repo.username}</username>
<password>${maven.repo.password}</password>
</server>
</servers>
</settings>

242
src/main/java/wtf/beatrice/hidekobot/Cache.java
View File

@@ -1,8 +1,6 @@
package wtf.beatrice.hidekobot; package wtf.beatrice.hidekobot;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.datasources.ConfigurationEntry; import wtf.beatrice.hidekobot.datasources.ConfigurationEntry;
import wtf.beatrice.hidekobot.datasources.ConfigurationSource; import wtf.beatrice.hidekobot.datasources.ConfigurationSource;
import wtf.beatrice.hidekobot.datasources.DatabaseSource; import wtf.beatrice.hidekobot.datasources.DatabaseSource;
@@ -11,67 +9,48 @@ import wtf.beatrice.hidekobot.listeners.MessageCommandListener;
import wtf.beatrice.hidekobot.listeners.MessageLogger; import wtf.beatrice.hidekobot.listeners.MessageLogger;
import wtf.beatrice.hidekobot.listeners.SlashCommandCompletionListener; import wtf.beatrice.hidekobot.listeners.SlashCommandCompletionListener;
import wtf.beatrice.hidekobot.listeners.SlashCommandListener; import wtf.beatrice.hidekobot.listeners.SlashCommandListener;
import wtf.beatrice.hidekobot.util.Logger;
import java.awt.*; import java.awt.*;
import java.lang.reflect.Field; import java.lang.reflect.Field;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
public class Cache public class Cache
{ {
private Cache()
{
throw new IllegalStateException("Utility class");
}
// todo: make this compatible with the message listener's regex // todo: make this compatible with the message listener's regex
private static final String BOT_PREFIX = "hideko"; private static final String botPrefix = "hideko";
private static final Logger LOGGER = LoggerFactory.getLogger(Cache.class); private static final Logger logger = new Logger(Cache.class);
// map to store results of "love calculator", to avoid people re-running the same command until
// they get what they wanted.
// i didn't think this was worthy of a whole database table with a runnable checking for expiration,
// and it will get cleared after a few minutes anyway, so RAM caching is more than good enough.
private static final HashMap<String, Integer> loveCalculatorValues = new HashMap<>();
private static PropertiesSource propertiesSource = null; private static PropertiesSource propertiesSource = null;
private static ConfigurationSource configurationSource = null; private static ConfigurationSource configurationSource = null;
private static DatabaseSource databaseSource = null; private static DatabaseSource databaseSource = null;
private static boolean verbose = false; private static boolean verbose = false;
private static MessageLogger verbosityLogger = null; private static MessageLogger verbosityLogger = null;
private static final long BOT_MAINTAINER_ID = 979809420714332260L; private static final long botMaintainerId = 979809420714332260L;
private static final String EXPIRY_TIMESTAMP_FORMAT = "yy/MM/dd HH:mm:ss"; private final static String expiryTimestampFormat = "yy/MM/dd HH:mm:ss";
// note: discord sets interactions' expiry time to 15 minutes by default, so we can't go higher than that. // note: discord sets interactions' expiry time to 15 minutes by default, so we can't go higher than that.
private static final long EXPIRY_TIME_SECONDS = 30L; private final static long expiryTimeSeconds = 15L;
// used to count e.g. uptime // used to count e.g. uptime
private static LocalDateTime startupTime = null; private static LocalDateTime startupTime = null;
// date of when the first bot commit was made (CEST time) private final static String execPath = System.getProperty("user.dir");
private static final LocalDateTime botBirthDate = LocalDateTime.of(2022, 8, 25, 21, 50); private static final String botName = "Hideko";
// the scheduler that should always be used when running a scheduled task.
private static final ScheduledExecutorService taskScheduler = Executors.newSingleThreadScheduledExecutor(); // todo: try-with-resources
private static final String EXEC_PATH = System.getProperty("user.dir");
private static final String BOT_NAME = "Hideko";
private static SlashCommandListener slashCommandListener = null; private static SlashCommandListener slashCommandListener = null;
private static SlashCommandCompletionListener slashCommandCompletionListener = null; private static SlashCommandCompletionListener slashCommandCompletionListener = null;
private static MessageCommandListener messageCommandListener = null; private static MessageCommandListener messageCommandListener = null;
private static final String DEFAULT_INVITE_LINK = private final static String defaultInviteLink =
"https://discord.com/api/oauth2/authorize?client_id=%userid%&scope=bot+applications.commands&permissions=8"; "https://discord.com/api/oauth2/authorize?client_id=%userid%&scope=bot+applications.commands&permissions=8";
private static String botApplicationId = ""; private static String botApplicationId = "";
// discord api returns a broken image if you don't use specific sizes (powers of 2), so we limit it to these // discord api returns a broken image if you don't use specific sizes (powers of 2), so we limit it to these
private static final int[] supportedAvatarResolutions = {16, 32, 64, 128, 256, 512, 1024}; private static final int[] supportedAvatarResolutions = { 16, 32, 64, 128, 256, 512, 1024 };
/** /**
* Get an array of all the Discord-supported avatar resolutions. * Get an array of all the Discord-supported avatar resolutions.
@@ -79,21 +58,14 @@ public class Cache
* *
* @return array of supported resolutions. * @return array of supported resolutions.
*/ */
public static int[] getSupportedAvatarResolutions() public static int[] getSupportedAvatarResolutions() { return supportedAvatarResolutions; }
{
return supportedAvatarResolutions;
}
/** /**
* Checks if the bot has been started with the verbose argument. * Checks if the bot has been started with the verbose argument.
* *
* @return a boolean which is true if the bot is in verbose-mode * @return a boolean which is true if the bot is in verbose-mode
*/ */
public static synchronized boolean isVerbose() public static boolean isVerbose() { return verbose; }
{
return verbose;
}
/** /**
* Set the bot's verbosity status at runtime. * Set the bot's verbosity status at runtime.
@@ -101,20 +73,24 @@ public class Cache
* *
* @param v the verbosity boolean value * @param v the verbosity boolean value
*/ */
public static synchronized void setVerbose(boolean v) public static void setVerbose(boolean v)
{ {
verbose = v; verbose = v;
if (verbosityLogger != null) if(v)
{ {
HidekoBot.getAPI().removeEventListener(verbosityLogger); if(verbosityLogger == null)
verbosityLogger = null; {
} verbosityLogger = new MessageLogger();
}
if (v)
{
verbosityLogger = new MessageLogger();
HidekoBot.getAPI().addEventListener(verbosityLogger); HidekoBot.getAPI().addEventListener(verbosityLogger);
} else {
if(verbosityLogger != null)
{
HidekoBot.getAPI().removeEventListener(verbosityLogger);
verbosityLogger = null;
}
} }
} }
@@ -123,8 +99,7 @@ public class Cache
* *
* @return a long of the account's id * @return a long of the account's id
*/ */
public static long getBotOwnerId() public static long getBotOwnerId() {
{
return configurationSource == null ? 0L : (Long) configurationSource.getConfigValue(ConfigurationEntry.BOT_OWNER_ID); return configurationSource == null ? 0L : (Long) configurationSource.getConfigValue(ConfigurationEntry.BOT_OWNER_ID);
} }
@@ -134,22 +109,17 @@ public class Cache
* *
* @return a String of the bot's token. * @return a String of the bot's token.
*/ */
public static String getBotToken() public static String getBotToken() {
{
return configurationSource == null ? null : (String) configurationSource.getConfigValue(ConfigurationEntry.BOT_TOKEN); return configurationSource == null ? null : (String) configurationSource.getConfigValue(ConfigurationEntry.BOT_TOKEN);
} }
/** /**
* Get the bot maintainer's profile id. * Get the bot maintainer's profile id.
* *
* @return a long of the account's id * @return a long of the account's id
*/ */
public static long getBotMaintainerId() public static long getBotMaintainerId() { return botMaintainerId; }
{
return BOT_MAINTAINER_ID;
}
/** /**
* Set the bot's application id. * Set the bot's application id.
@@ -166,19 +136,15 @@ public class Cache
* *
* @return a string of the bot's application id * @return a string of the bot's application id
*/ */
public static String getBotApplicationId() public static String getBotApplicationId() { return botApplicationId; }
{
return botApplicationId;
}
/** /**
* Function to generate an invite link for the bot * Function to generate an invite link for the bot
* *
* @return a string containing the invite link * @return a string containing the invite link
*/ */
public static String getInviteUrl() public static String getInviteUrl() {
{ return defaultInviteLink.replace("%userid%", botApplicationId);
return DEFAULT_INVITE_LINK.replace("%userid%", botApplicationId);
} }
/** /**
@@ -196,10 +162,7 @@ public class Cache
* *
* @return the DatabaseSource instance. * @return the DatabaseSource instance.
*/ */
public static @Nullable DatabaseSource getDatabaseSource() public static @Nullable DatabaseSource getDatabaseSource() { return databaseSource; }
{
return databaseSource;
}
/** /**
* Set the properties source instance loaded from the JAR archive. * Set the properties source instance loaded from the JAR archive.
@@ -216,67 +179,43 @@ public class Cache
* *
* @return the String of the DateTimeFormatter format. * @return the String of the DateTimeFormatter format.
*/ */
public static String getExpiryTimestampFormat() public static String getExpiryTimestampFormat(){ return expiryTimestampFormat; }
{
return EXPIRY_TIMESTAMP_FORMAT;
}
/** /**
* Get the amount of seconds after which a message expires. * Get the amount of seconds after which a message expires.
* *
* @return long value of the expiry seconds. * @return long value of the expiry seconds.
*/ */
public static long getExpiryTimeSeconds() public static long getExpiryTimeSeconds() { return expiryTimeSeconds; }
{
return EXPIRY_TIME_SECONDS;
}
public static String getBotName() public static String getBotName() { return botName; };
{
return BOT_NAME;
}
/** /**
* Get the bot's version. * Get the bot's version.
* *
* @return a String of the bot version. * @return a String of the bot version.
*/ */
public static String getBotVersion() public static String getBotVersion() {
{
return propertiesSource.getProperty("bot.version"); return propertiesSource.getProperty("bot.version");
} }
/**
* Get the bot's source code URL.
*
* @return a String containing the base URL of the repository, including a <b>trailing slash</b>.
*/
public static String getRepositoryUrl()
{
String url = propertiesSource.getProperty("repo.base_url");
return url.endsWith("/") ? url : url + "/";
}
/** /**
* Get the bot's global color. * Get the bot's global color.
* *
* @return the Color object. * @return the Color object.
*/ */
public static Color getBotColor() public static Color getBotColor() {
{
Color defaultColor = Color.PINK; Color defaultColor = Color.PINK;
if (configurationSource == null) return defaultColor; if(configurationSource == null) return defaultColor;
String colorName = (String) configurationSource.getConfigValue(ConfigurationEntry.BOT_COLOR); String colorName = (String) configurationSource.getConfigValue(ConfigurationEntry.BOT_COLOR);
Color color = null; Color color = null;
try try {
{
Field field = Color.class.getField(colorName); Field field = Color.class.getField(colorName);
color = (Color) field.get(null); color = (Color)field.get(null);
} catch (RuntimeException | NoSuchFieldException | IllegalAccessException e) } catch (Exception e) {
{ logger.log("Unknown color: " + colorName);
LOGGER.error("Unknown color: {}", colorName);
} }
return color == null ? defaultColor : color; return color == null ? defaultColor : color;
} }
@@ -284,36 +223,21 @@ public class Cache
//todo javadocs //todo javadocs
public static void setSlashCommandListener(SlashCommandListener commandListener) public static void setSlashCommandListener(SlashCommandListener commandListener)
{ { slashCommandListener = commandListener; }
slashCommandListener = commandListener;
}
public static SlashCommandListener getSlashCommandListener() public static SlashCommandListener getSlashCommandListener() { return slashCommandListener; }
{
return slashCommandListener;
}
public static void setSlashCommandCompletionListener(SlashCommandCompletionListener commandCompletionListener) public static void setSlashCommandCompletionListener(SlashCommandCompletionListener commandCompletionListener)
{ { slashCommandCompletionListener = commandCompletionListener; }
slashCommandCompletionListener = commandCompletionListener;
}
public static SlashCommandCompletionListener getSlashCommandCompletionListener() public static SlashCommandCompletionListener getSlashCommandCompletionListener() { return slashCommandCompletionListener; }
{
return slashCommandCompletionListener;
}
public static void setMessageCommandListener(MessageCommandListener commandListener) public static void setMessageCommandListener(MessageCommandListener commandListener)
{ { messageCommandListener = commandListener; }
messageCommandListener = commandListener;
}
public static MessageCommandListener getMessageCommandListener() public static MessageCommandListener getMessageCommandListener() { return messageCommandListener; }
{
return messageCommandListener;
}
/** /**
* Set the bot's startup time. Generally only used at boot time. * Set the bot's startup time. Generally only used at boot time.
@@ -321,9 +245,7 @@ public class Cache
* @param time a LocalDateTime of the startup moment. * @param time a LocalDateTime of the startup moment.
*/ */
public static void setStartupTime(LocalDateTime time) public static void setStartupTime(LocalDateTime time)
{ { startupTime = time; }
startupTime = time;
}
/** /**
@@ -331,81 +253,25 @@ public class Cache
* *
* @return a LocalDateTime object of the startup instant. * @return a LocalDateTime object of the startup instant.
*/ */
public static LocalDateTime getStartupTime() public static LocalDateTime getStartupTime() { return startupTime; }
{
return startupTime;
}
/** public static String getFullHeartBeatLink() {
* Get the time of when the bot was created.
*
* @return a LocalDateTime object of the first commit's instant.
*/
public static LocalDateTime getBotBirthDate()
{
return botBirthDate;
}
public static String getFullHeartBeatLink()
{
return configurationSource == null ? null : (String) configurationSource.getConfigValue(ConfigurationEntry.HEARTBEAT_LINK); return configurationSource == null ? null : (String) configurationSource.getConfigValue(ConfigurationEntry.HEARTBEAT_LINK);
} }
//todo javadocs //todo javadocs
public static String getExecPath() public static String getExecPath() { return execPath; }
{
return EXEC_PATH;
}
/*private static ConfigurationSource getConfigurationSource() /*private static ConfigurationSource getConfigurationSource()
{ return configurationSource; }*/ { return configurationSource; }*/
public static String getRandomOrgApiKey()
{
return configurationSource == null ? null : (String) configurationSource.getConfigValue(ConfigurationEntry.RANDOM_ORG_API_KEY);
}
public static void setConfigurationSource(ConfigurationSource configurationSource) public static void setConfigurationSource(ConfigurationSource configurationSource)
{ { Cache.configurationSource = configurationSource; }
Cache.configurationSource = configurationSource;
}
/** /**
* Get the bot's prefix * Get the bot's prefix
* *
* @return a String of the bot's prefix. * @return a String of the bot's prefix.
*/ */
public static String getBotPrefix() public static String getBotPrefix() { return botPrefix; }
{
return BOT_PREFIX;
}
public static void cacheLoveCalculatorValue(String userId1, String userId2, int value)
{
String merged = userId1 + "|" + userId2;
loveCalculatorValues.put(merged, value);
}
@Nullable
public static Integer getLoveCalculatorValue(String userId1, String userId2)
{
String merged1 = userId1 + "|" + userId2;
String merged2 = userId2 + "|" + userId1;
Integer value = null;
value = loveCalculatorValues.get(merged1);
if (value == null) value = loveCalculatorValues.get(merged2);
return value;
}
public static void removeLoveCalculatorValue(String userId1, String userId2)
{
loveCalculatorValues.remove(userId1 + "|" + userId2);
loveCalculatorValues.remove(userId2 + "|" + userId1);
}
public static ScheduledExecutorService getTaskScheduler()
{
return taskScheduler;
}
} }

146
src/main/java/wtf/beatrice/hidekobot/HidekoBot.java
View File

@@ -3,23 +3,23 @@ package wtf.beatrice.hidekobot;
import net.dv8tion.jda.api.JDA; import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.JDABuilder; import net.dv8tion.jda.api.JDABuilder;
import net.dv8tion.jda.api.OnlineStatus; import net.dv8tion.jda.api.OnlineStatus;
import net.dv8tion.jda.api.entities.Activity;
import net.dv8tion.jda.api.requests.GatewayIntent; import net.dv8tion.jda.api.requests.GatewayIntent;
import org.slf4j.Logger; import sun.misc.Signal;
import org.slf4j.LoggerFactory; import wtf.beatrice.hidekobot.commands.completer.AvatarCommandCompleter;
import wtf.beatrice.hidekobot.commands.completer.ProfileImageCommandCompleter;
import wtf.beatrice.hidekobot.commands.message.HelloCommand; import wtf.beatrice.hidekobot.commands.message.HelloCommand;
import wtf.beatrice.hidekobot.commands.slash.*; import wtf.beatrice.hidekobot.commands.slash.*;
import wtf.beatrice.hidekobot.datasources.ConfigurationSource; import wtf.beatrice.hidekobot.datasources.ConfigurationSource;
import wtf.beatrice.hidekobot.datasources.DatabaseSource; import wtf.beatrice.hidekobot.datasources.DatabaseSource;
import wtf.beatrice.hidekobot.datasources.PropertiesSource; import wtf.beatrice.hidekobot.datasources.PropertiesSource;
import wtf.beatrice.hidekobot.listeners.*; import wtf.beatrice.hidekobot.listeners.ButtonInteractionListener;
import wtf.beatrice.hidekobot.listeners.MessageCommandListener;
import wtf.beatrice.hidekobot.listeners.SlashCommandCompletionListener;
import wtf.beatrice.hidekobot.listeners.SlashCommandListener;
import wtf.beatrice.hidekobot.runnables.ExpiredMessageTask; import wtf.beatrice.hidekobot.runnables.ExpiredMessageTask;
import wtf.beatrice.hidekobot.runnables.HeartBeatTask; import wtf.beatrice.hidekobot.runnables.HeartBeatTask;
import wtf.beatrice.hidekobot.runnables.RandomOrgSeedTask; import wtf.beatrice.hidekobot.util.Logger;
import wtf.beatrice.hidekobot.runnables.StatusUpdateTask; import wtf.beatrice.hidekobot.util.SlashCommandUtil;
import wtf.beatrice.hidekobot.util.CommandUtil;
import wtf.beatrice.hidekobot.util.FormatUtil;
import wtf.beatrice.hidekobot.util.RandomUtil;
import java.io.File; import java.io.File;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@@ -34,31 +34,31 @@ public class HidekoBot
{ {
private static JDA jda; private static JDA jda;
private static final Logger LOGGER = LoggerFactory.getLogger(HidekoBot.class); private static final Logger logger = new Logger(HidekoBot.class);
public static void main(String[] args) public static void main(String[] args)
{ {
// load configuration // load configuration
LOGGER.info("Loading configuration..."); logger.log("Loading configuration...");
String configFilePath = Cache.getExecPath() + File.separator + "config.yml"; String configFilePath = Cache.getExecPath() + File.separator + "config.yml";
ConfigurationSource configurationSource = new ConfigurationSource(configFilePath); ConfigurationSource configurationSource = new ConfigurationSource(configFilePath);
configurationSource.initConfig(); configurationSource.initConfig();
Cache.setConfigurationSource(configurationSource); Cache.setConfigurationSource(configurationSource);
LOGGER.info("Configuration loaded!"); logger.log("Configuration loaded!");
// load properties // load properties
LOGGER.info("Loading properties..."); logger.log("Loading properties...");
PropertiesSource propertiesSource = new PropertiesSource(); PropertiesSource propertiesSource = new PropertiesSource();
propertiesSource.load(); propertiesSource.load();
Cache.setPropertiesSourceInstance(propertiesSource); Cache.setPropertiesSourceInstance(propertiesSource);
LOGGER.info("Properties loaded!"); logger.log("Properties loaded!");
// check loaded bot token // check loaded bot token
String botToken = Cache.getBotToken(); String botToken = Cache.getBotToken();
if (botToken == null || botToken.isEmpty()) if(botToken == null || botToken.isEmpty())
{ {
LOGGER.error("Invalid bot token!"); logger.log("Invalid bot token!");
shutdown(); shutdown();
return; return;
} }
@@ -76,14 +76,9 @@ public class HidekoBot
); );
jda = jdaBuilder.build().awaitReady(); jda = jdaBuilder.build().awaitReady();
} catch (InterruptedException e)
{
LOGGER.error(e.getMessage()); // print the error message, omit the stack trace.
Thread.currentThread().interrupt(); // send interrupt to the thread.
shutdown(); // if we failed connecting and authenticating, then quit.
} catch (Exception e) } catch (Exception e)
{ {
LOGGER.error(e.getMessage()); // print the error message, omit the stack trace. logger.log(e.getMessage()); // print the error message, omit the stack trace.
shutdown(); // if we failed connecting and authenticating, then quit. shutdown(); // if we failed connecting and authenticating, then quit.
} }
@@ -94,156 +89,108 @@ public class HidekoBot
// store if we have to force refresh commands despite no apparent changes. // store if we have to force refresh commands despite no apparent changes.
boolean forceUpdateCommands = false; boolean forceUpdateCommands = false;
// if there is at least one arg, then iterate through them because we have additional things to do. // if there is more than 1 arg, then iterate through them because we have additional things to do.
// we are doing this at the end because we might need the API to be already initialized for some things. // we are doing this at the end because we might need the API to be already initialized for some things.
if (args.length > 0) if(args.length > 1) {
{
List<String> argsList = new ArrayList<>(Arrays.asList(args)); List<String> argsList = new ArrayList<>(Arrays.asList(args));
// NOTE: do not replace with enhanced for, since we might need // NOTE: do not replace with enhanced for, since we might need
// to know what position we're at or do further elaboration of the string. // to know what position we're at or do further elaboration of the string.
// we were using this for api key parsing in the past. // we were using this for api key parsing in the past.
for (int i = 0; i < argsList.size(); i++) for(int i = 0; i < argsList.size(); i++)
{ {
String arg = argsList.get(i); String arg = argsList.get(i);
if (arg.equals("verbose")) Cache.setVerbose(true); if(arg.equals("verbose")) Cache.setVerbose(true);
if (arg.equals("refresh")) forceUpdateCommands = true; if(arg.equals("refresh")) forceUpdateCommands = true;
} }
} }
boolean enableRandomSeedUpdaterTask = false;
// initialize random.org object if API key is provided
{
if (RandomUtil.isRandomOrgKeyValid())
{
LOGGER.info("Enabling Random.org integration... This might take a while!");
RandomUtil.initRandomOrg();
enableRandomSeedUpdaterTask = true;
LOGGER.info("Random.org integration enabled!");
}
}
// register slash commands and completers // register slash commands and completers
SlashCommandListener slashCommandListener = new SlashCommandListener(); SlashCommandListener slashCommandListener = new SlashCommandListener();
SlashCommandCompletionListener slashCommandCompletionListener = new SlashCommandCompletionListener(); SlashCommandCompletionListener slashCommandCompletionListener = new SlashCommandCompletionListener();
AvatarCommand avatarCommand = new AvatarCommand(); AvatarCommand avatarCommand = new AvatarCommand();
ProfileImageCommandCompleter avatarCommandCompleter = new ProfileImageCommandCompleter(avatarCommand); AvatarCommandCompleter avatarCommandCompleter = new AvatarCommandCompleter(avatarCommand);
slashCommandListener.registerCommand(avatarCommand); slashCommandListener.registerCommand(avatarCommand);
slashCommandCompletionListener.registerCommandCompleter(avatarCommandCompleter); slashCommandCompletionListener.registerCommandCompleter(avatarCommandCompleter);
slashCommandListener.registerCommand(new BanCommand());
BannerCommand bannerCommand = new BannerCommand();
ProfileImageCommandCompleter bannerCommandCompleter = new ProfileImageCommandCompleter(bannerCommand);
slashCommandListener.registerCommand(bannerCommand);
slashCommandCompletionListener.registerCommandCompleter(bannerCommandCompleter);
slashCommandListener.registerCommand(new BotInfoCommand()); slashCommandListener.registerCommand(new BotInfoCommand());
slashCommandListener.registerCommand(new ClearCommand()); slashCommandListener.registerCommand(new ClearCommand());
slashCommandListener.registerCommand(new CoinFlipCommand()); slashCommandListener.registerCommand(new CoinFlipCommand());
slashCommandListener.registerCommand(new DiceRollCommand());
slashCommandListener.registerCommand(new DieCommand()); slashCommandListener.registerCommand(new DieCommand());
slashCommandListener.registerCommand(new HelpCommand()); slashCommandListener.registerCommand(new HelpCommand());
slashCommandListener.registerCommand(new InviteCommand()); slashCommandListener.registerCommand(new InviteCommand());
slashCommandListener.registerCommand(new KickCommand());
slashCommandListener.registerCommand(new LoveCalculatorCommand());
slashCommandListener.registerCommand(new MagicBallCommand());
slashCommandListener.registerCommand(new PingCommand()); slashCommandListener.registerCommand(new PingCommand());
slashCommandListener.registerCommand(new SayCommand()); slashCommandListener.registerCommand(new SayCommand());
slashCommandListener.registerCommand(new TimeoutCommand()); Cache.setSlashCommandListener(slashCommandListener);
slashCommandListener.registerCommand(new TriviaCommand()); Cache.setSlashCommandCompletionListener(slashCommandCompletionListener);
slashCommandListener.registerCommand(new UrbanDictionaryCommand());
// register message commands // register message commands
MessageCommandListener messageCommandListener = new MessageCommandListener(); MessageCommandListener messageCommandListener = new MessageCommandListener();
messageCommandListener.registerCommand(new HelloCommand()); messageCommandListener.registerCommand(new HelloCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.AliasCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.AvatarCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.AvatarCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.BanCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.BannerCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.BotInfoCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.BotInfoCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.CoinFlipCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.CoinFlipCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.ClearCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.ClearCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.DiceRollCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.DiceRollCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.HelpCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.InviteCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.InviteCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.KickCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.LoveCalculatorCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.MagicBallCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.SayCommand()); messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.SayCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.TimeoutCommand()); Cache.setMessageCommandListener(messageCommandListener);
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.TriviaCommand());
messageCommandListener.registerCommand(new wtf.beatrice.hidekobot.commands.message.UrbanDictionaryCommand());
// register listeners // register listeners
Cache.setSlashCommandListener(slashCommandListener);
Cache.setSlashCommandCompletionListener(slashCommandCompletionListener);
Cache.setMessageCommandListener(messageCommandListener);
jda.addEventListener(messageCommandListener); jda.addEventListener(messageCommandListener);
jda.addEventListener(slashCommandListener); jda.addEventListener(slashCommandListener);
jda.addEventListener(slashCommandCompletionListener); jda.addEventListener(slashCommandCompletionListener);
jda.addEventListener(new ButtonInteractionListener()); jda.addEventListener(new ButtonInteractionListener());
jda.addEventListener(new SelectMenuInteractionListener());
// update slash commands (delayed) // update slash commands (delayed)
final boolean finalForceUpdateCommands = forceUpdateCommands; final boolean finalForceUpdateCommands = forceUpdateCommands;
try (ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor()) Executors.newSingleThreadScheduledExecutor().schedule(() -> // todo: try-with-resources
{ SlashCommandUtil.updateSlashCommands(finalForceUpdateCommands), 1, TimeUnit.SECONDS);
executor.schedule(() -> CommandUtil.updateSlashCommands(finalForceUpdateCommands),
1, TimeUnit.SECONDS);
}
// set the bot's status // set the bot's status
jda.getPresence().setStatus(OnlineStatus.ONLINE); jda.getPresence().setStatus(OnlineStatus.ONLINE);
jda.getPresence().setActivity(Activity.playing("Hatsune Miku: Project DIVA"));
// connect to database // connect to database
LOGGER.info("Connecting to database..."); logger.log("Connecting to database...");
String dbFilePath = Cache.getExecPath() + File.separator + "db.sqlite"; // in current directory String dbFilePath = Cache.getExecPath() + File.separator + "db.sqlite"; // in current directory
DatabaseSource databaseSource = new DatabaseSource(dbFilePath); DatabaseSource databaseSource = new DatabaseSource(dbFilePath);
if (databaseSource.connect() && databaseSource.initDb()) if(databaseSource.connect() && databaseSource.initDb())
{ {
LOGGER.info("Database connection initialized!"); logger.log("Database connection initialized!");
Cache.setDatabaseSourceInstance(databaseSource); Cache.setDatabaseSourceInstance(databaseSource);
// load data here... // load data here...
LOGGER.info("Database data loaded into memory!"); logger.log("Database data loaded into memory!");
} else } else {
{ logger.log("Error initializing database connection!");
LOGGER.error("Error initializing database connection!");
} }
// start scheduled runnables // start scheduled runnables
ScheduledExecutorService scheduler = Cache.getTaskScheduler(); ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); // todo: try-with-resources
ExpiredMessageTask expiredMessageTask = new ExpiredMessageTask(); ExpiredMessageTask expiredMessageTask = new ExpiredMessageTask();
scheduler.scheduleAtFixedRate(expiredMessageTask, 5L, 5L, TimeUnit.SECONDS); //every 5 seconds scheduler.scheduleAtFixedRate(expiredMessageTask, 5, 5, TimeUnit.SECONDS); //every 5 seconds
HeartBeatTask heartBeatTask = new HeartBeatTask(); HeartBeatTask heartBeatTask = new HeartBeatTask();
scheduler.scheduleAtFixedRate(heartBeatTask, 10L, 30L, TimeUnit.SECONDS); //every 30 seconds scheduler.scheduleAtFixedRate(heartBeatTask, 10, 30, TimeUnit.SECONDS); //every 30 seconds
StatusUpdateTask statusUpdateTask = new StatusUpdateTask();
scheduler.scheduleAtFixedRate(statusUpdateTask, 0L, 60L * 5L, TimeUnit.SECONDS); // every 5 minutes
if (enableRandomSeedUpdaterTask)
{
RandomOrgSeedTask randomSeedTask = new RandomOrgSeedTask();
scheduler.scheduleAtFixedRate(randomSeedTask, 15L, 15L, TimeUnit.MINUTES); // every 15 minutes
}
// register shutdown interrupt signal listener for proper shutdown. // register shutdown interrupt signal listener for proper shutdown.
Runtime.getRuntime().addShutdownHook(new Thread(HidekoBot::preShutdown)); Signal.handle(new Signal("INT"), signal -> shutdown());
// set startup time. // set startup time.
Cache.setStartupTime(LocalDateTime.now()); Cache.setStartupTime(LocalDateTime.now());
// print the bot logo. // print the bot logo.
LOGGER.info("\n\n{}\nv{} - bot is ready!\n", FormatUtil.getLogo(), Cache.getBotVersion()); logger.log("\n\n" + logger.getLogo() + "\nv" + Cache.getBotVersion() + " - bot is ready!\n", 2);
// log the invite-link to console so noob users can just click on it. // log the invite-link to console so noob users can just click on it.
LOGGER.info("Bot User ID: {}", botUserId); logger.log("Bot User ID: " + botUserId, 3);
LOGGER.info("Invite Link: {}", Cache.getInviteUrl()); logger.log("Invite Link: " + Cache.getInviteUrl(), 4);
} }
public static JDA getAPI() public static JDA getAPI()
{ {
return jda; return jda;
@@ -251,14 +198,9 @@ public class HidekoBot
public static void shutdown() public static void shutdown()
{ {
preShutdown(); logger.log("WARNING! Shutting down!");
if(jda != null) jda.shutdown();
System.exit(0); System.exit(0);
} }
private static void preShutdown()
{
LOGGER.warn("WARNING! Shutting down!");
if (jda != null) jda.shutdown();
}
} }

28
src/main/java/wtf/beatrice/hidekobot/commands/base/Alias.java
View File

@@ -1,28 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.LinkedList;
public class Alias
{
private Alias()
{
throw new IllegalStateException("Utility class");
}
public static String generateNiceAliases(MessageCommand command)
{
LinkedList<String> aliases = command.getCommandLabels();
StringBuilder aliasesStringBuilder = new StringBuilder();
for (int i = 0; i < aliases.size(); i++)
{
aliasesStringBuilder.append("`").append(aliases.get(i)).append("`");
if (i + 1 != aliases.size())
aliasesStringBuilder.append(", "); // separate with comma except on last iteration
}
return aliasesStringBuilder.toString();
}
}

62
src/main/java/wtf/beatrice/hidekobot/commands/base/Avatar.java Normal file
View File

@@ -0,0 +1,62 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User;
import wtf.beatrice.hidekobot.Cache;
public class Avatar
{
public static int parseResolution(int resolution)
{
int[] acceptedSizes = Cache.getSupportedAvatarResolutions();
// method to find closest value to accepted values
int distance = Math.abs(acceptedSizes[0] - resolution);
int idx = 0;
for(int c = 1; c < acceptedSizes.length; c++){
int cdistance = Math.abs(acceptedSizes[c] - resolution);
if(cdistance < distance){
idx = c;
distance = cdistance;
}
}
return acceptedSizes[idx];
}
public static MessageEmbed buildEmbed(int resolution, User user)
{
int[] acceptedSizes = Cache.getSupportedAvatarResolutions();
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle("Profile picture");
embedBuilder.addField("User", "<@" + user.getId() + ">", false);
embedBuilder.addField("Current resolution", resolution + " × " + resolution, false);
// string builder to create a string that links to all available resolutions
StringBuilder links = new StringBuilder();
for(int pos = 0; pos < acceptedSizes.length; pos++)
{
int currSize = acceptedSizes[pos];
String currLink = user.getEffectiveAvatar().getUrl(currSize);
links.append("[").append(currSize).append("px](").append(currLink).append(")");
if(pos + 1 != acceptedSizes.length) // don't add a separator on the last iteration
{
links.append(" | ");
}
}
embedBuilder.addField("Available resolutions", links.toString(), false);
embedBuilder.setImage(user.getEffectiveAvatar().getUrl(resolution));
return embedBuilder.build();
}
}

67
src/main/java/wtf/beatrice/hidekobot/commands/base/BotInfo.java
View File

@@ -5,7 +5,6 @@ import net.dv8tion.jda.api.entities.MessageEmbed;
import wtf.beatrice.hidekobot.Cache; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot; import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.util.FormatUtil; import wtf.beatrice.hidekobot.util.FormatUtil;
import wtf.beatrice.hidekobot.util.RandomUtil;
import java.lang.management.ManagementFactory; import java.lang.management.ManagementFactory;
import java.text.DecimalFormat; import java.text.DecimalFormat;
@@ -13,11 +12,6 @@ import java.util.List;
public class BotInfo public class BotInfo
{ {
private BotInfo()
{
throw new IllegalStateException("Utility class");
}
public static MessageEmbed generateEmbed(List<String> commandLabels) public static MessageEmbed generateEmbed(List<String> commandLabels)
{ {
EmbedBuilder embedBuilder = new EmbedBuilder(); EmbedBuilder embedBuilder = new EmbedBuilder();
@@ -26,7 +20,7 @@ public class BotInfo
// thumbnail // thumbnail
String botAvatarUrl = HidekoBot.getAPI().getSelfUser().getAvatarUrl(); String botAvatarUrl = HidekoBot.getAPI().getSelfUser().getAvatarUrl();
if (botAvatarUrl != null) embedBuilder.setThumbnail(botAvatarUrl); if(botAvatarUrl != null) embedBuilder.setThumbnail(botAvatarUrl);
// help field // help field
long ownerId = Cache.getBotOwnerId(); long ownerId = Cache.getBotOwnerId();
@@ -38,12 +32,12 @@ public class BotInfo
// type-specific commands list field // type-specific commands list field
StringBuilder commandsListBuilder = new StringBuilder(); StringBuilder commandsListBuilder = new StringBuilder();
commandsListBuilder.append(commandLabels.size()).append(" total - "); commandsListBuilder.append(commandLabels.size()).append( " total - ");
for (int i = 0; i < commandLabels.size(); i++) for(int i = 0; i < commandLabels.size(); i++)
{ {
commandsListBuilder.append("`").append(commandLabels.get(i)).append("`"); commandsListBuilder.append("`").append(commandLabels.get(i)).append("`");
if (i + 1 != commandLabels.size()) // don't add comma in last iteration if(i + 1 != commandLabels.size()) // don't add comma in last iteration
{ {
commandsListBuilder.append(", "); commandsListBuilder.append(", ");
} }
@@ -54,38 +48,25 @@ public class BotInfo
// keep track of how many total commands we have // keep track of how many total commands we have
int commandsCount = 0; int commandsCount = 0;
// message commands info field // message commands info fields
String messageCommandsInfo; StringBuilder messageCommandsInfoBuilder = new StringBuilder();
if (Cache.getMessageCommandListener() == null) if(Cache.getMessageCommandListener() == null)
messageCommandsInfo = "❌ disabled"; messageCommandsInfoBuilder.append("❌ disabled");
else else {
{ messageCommandsInfoBuilder.append("✅ available");
messageCommandsInfo = "✅ available";
commandsCount += Cache.getMessageCommandListener().getRegisteredCommands().size(); commandsCount += Cache.getMessageCommandListener().getRegisteredCommands().size();
} }
embedBuilder.addField("Message commands", messageCommandsInfo, true); embedBuilder.addField("Message commands", messageCommandsInfoBuilder.toString(), true);
// slash commands info field // slash commands info fields
String slashCommandsInfo; StringBuilder slashCommandsInfoBuilder = new StringBuilder();
if (Cache.getMessageCommandListener() == null) if(Cache.getMessageCommandListener() == null)
slashCommandsInfo = "❌ disabled"; slashCommandsInfoBuilder.append("❌ disabled");
else else {
{ slashCommandsInfoBuilder.append("✅ available");
slashCommandsInfo = "✅ available";
commandsCount += Cache.getSlashCommandListener().getRegisteredCommands().size(); commandsCount += Cache.getSlashCommandListener().getRegisteredCommands().size();
} }
embedBuilder.addField("Slash commands", slashCommandsInfo, true); embedBuilder.addField("Slash commands", slashCommandsInfoBuilder.toString(), true);
// random.org integration field
String randomOrgInfo;
if (RandomUtil.isRandomOrgKeyValid())
{
randomOrgInfo = "✅ connected";
} else
{
randomOrgInfo = "❌ disabled";
}
embedBuilder.addField("Random.org", randomOrgInfo, true);
// commands count fields // commands count fields
embedBuilder.addField("Total commands", "Loaded: `" + commandsCount + "`", true); embedBuilder.addField("Total commands", "Loaded: `" + commandsCount + "`", true);
@@ -110,18 +91,12 @@ public class BotInfo
embedBuilder.addField("Maintainer", developerMention, true); embedBuilder.addField("Maintainer", developerMention, true);
// uptime field // uptime field
embedBuilder.addField("Uptime", FormatUtil.getNiceTimeDiff(Cache.getStartupTime()), true); embedBuilder.addField("Uptime", FormatUtil.getNiceUptime(), true);
// issue tracker field // issue tracker field
String link = "[Issue tracker](" + Cache.getRepositoryUrl() + "issues)";
embedBuilder.addField("Support", embedBuilder.addField("Support",
link, true); "[Issue tracker](https://git.beatrice.wtf/mind-overflow/HidekoBot/issues)",
true); //todo: we should probably make this a final field in the config class
// bot birthday field
embedBuilder.addField("Bot age",
Cache.getBotName() + " was created " + FormatUtil.getNiceTimeDiff(Cache.getBotBirthDate()) + "ago!",
false);
return embedBuilder.build(); return embedBuilder.build();
} }

108
src/main/java/wtf/beatrice/hidekobot/commands/base/ClearChat.java
View File

@@ -3,53 +3,46 @@ package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.Message; import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageHistory; import net.dv8tion.jda.api.entities.MessageHistory;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.Channel; import net.dv8tion.jda.api.entities.channel.Channel;
import net.dv8tion.jda.api.entities.channel.concrete.TextChannel; import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel; import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.entities.emoji.Emoji; import net.dv8tion.jda.api.entities.emoji.Emoji;
import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
import net.dv8tion.jda.api.interactions.InteractionHook;
import net.dv8tion.jda.api.interactions.components.buttons.Button; import net.dv8tion.jda.api.interactions.components.buttons.Button;
import wtf.beatrice.hidekobot.Cache;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class ClearChat public class ClearChat
{ {
private ClearChat()
{
throw new IllegalStateException("Utility class");
}
public static String getLabel() public static String getLabel() {
{
return "clear"; return "clear";
} }
public static String getDescription() public static String getDescription() {
{
return "Clear the current channel's chat."; return "Clear the current channel's chat.";
} }
public static Permission getPermission() public static Permission getPermission() {
{
return Permission.MESSAGE_MANAGE; return Permission.MESSAGE_MANAGE;
} }
public static String checkDMs(Channel channel) public static String checkDMs(Channel channel)
{ {
if (!(channel instanceof TextChannel)) if(!(channel instanceof TextChannel))
{ { return "\uD83D\uDE22 Sorry! I can't delete messages here."; }
return "\uD83D\uDE22 Sorry! I can't delete messages here.";
}
return null; return null;
} }
public static String checkDeleteAmount(int toDeleteAmount) public static String checkDeleteAmount(int toDeleteAmount)
{ {
if (toDeleteAmount <= 0) if(toDeleteAmount <= 0)
{ { return "\uD83D\uDE22 Sorry, I can't delete that amount of messages!"; }
return "\uD83D\uDE22 Sorry, I can't delete that amount of messages!";
}
return null; return null;
} }
@@ -61,8 +54,7 @@ public class ClearChat
// int to keep track of how many messages we actually deleted. // int to keep track of how many messages we actually deleted.
int deleted = 0; int deleted = 0;
int limit = 95; //discord limits this method to only 2<x<100 deletions per run. int limit = 95; //discord limits this method to range 2-100. we set it to 95 to be safe.
// we set this slightly lower to be safe, and iterate as needed.
// increase the count by 1, because we technically aren't clearing the first ID ever // increase the count by 1, because we technically aren't clearing the first ID ever
// which is actually the slash command's ID and not a message. // which is actually the slash command's ID and not a message.
@@ -73,7 +65,7 @@ public class ClearChat
//if there are some messages left, but less than <limit>, we need one more iterations. //if there are some messages left, but less than <limit>, we need one more iterations.
int remainder = toDeleteAmount % limit; int remainder = toDeleteAmount % limit;
if (remainder != 0) iterations++; if(remainder != 0) iterations++;
// set the starting point. // set the starting point.
long messageId = startingMessageId; long messageId = startingMessageId;
@@ -82,70 +74,70 @@ public class ClearChat
boolean outOfBounds = false; boolean outOfBounds = false;
// do iterate. // do iterate.
for (int iteration = 0; iteration < iterations; iteration++) for(int iteration = 0; iteration < iterations; iteration++)
{ {
if (outOfBounds) break; if(outOfBounds) break;
// set how many messages to delete for this iteration (usually <limit> unless there's a remainder) // set how many messages to delete for this iteration (usually <limit> unless there's a remainder)
int iterationSize = limit; int iterationSize = limit;
// if we are at the last iteration... check if we have <limit> or fewer messages to delete // if we are at the last iteration...
if (iteration + 1 == iterations && remainder != 0) if(iteration+1 == iterations)
{ {
iterationSize = remainder; // check if we have <limit> or fewer messages to delete
if(remainder != 0) iterationSize = remainder;
} }
if (iterationSize == 1) if(iterationSize == 1)
{ {
// grab the message // grab the message
Message toDelete = channel.retrieveMessageById(messageId).complete(); Message toDelete = channel.retrieveMessageById(messageId).complete();
//only delete one message //only delete one message
if (toDelete != null) toDelete.delete().queue(); if(toDelete != null) toDelete.delete().queue();
else outOfBounds = true; else outOfBounds = true;
// increase deleted counter by 1 // increase deleted counter by 1
deleted++; deleted++;
} else } else {
{
// get the last <iterationSize - 1> messages. // get the last <iterationSize - 1> messages.
MessageHistory.MessageRetrieveAction action = channel.getHistoryBefore(messageId, iterationSize - 1); MessageHistory.MessageRetrieveAction action = channel.getHistoryBefore(messageId, iterationSize - 1);
// note: first one is the most recent, last one is the oldest message. // note: first one is the most recent, last one is the oldest message.
List<Message> messages = new ArrayList<>(); List<Message> messages = new ArrayList<>();
// (we are skipping first iteration since it would return an error, given that the id is the slash command and not a message) // (we are skipping first iteration since it would return an error, given that the id is the slash command and not a message)
if (iteration != 0) messages.add(channel.retrieveMessageById(messageId).complete()); if(iteration!=0) messages.add(channel.retrieveMessageById(messageId).complete());
messages.addAll(action.complete().getRetrievedHistory()); messages.addAll(action.complete().getRetrievedHistory());
// check if we only have one or zero messages left (trying to delete more than possible) // check if we only have one or zero messages left (trying to delete more than possible)
if (messages.size() <= 1) if(messages.size() <= 1)
{ {
outOfBounds = true; outOfBounds = true;
} else } else {
{
// before deleting, we need to grab the <previous to the oldest> message's id for next iteration. // before deleting, we need to grab the <previous to the oldest> message's id for next iteration.
action = channel.getHistoryBefore(messages.getLast().getIdLong(), 1); action = channel.getHistoryBefore(messages.get(messages.size() - 1).getIdLong(), 1);
List<Message> previousMessage = action.complete().getRetrievedHistory(); List<Message> previousMessage = action.complete().getRetrievedHistory();
// if that message exists (we are not out of bounds)... store it // if that message exists (we are not out of bounds)... store it
if (!previousMessage.isEmpty()) messageId = previousMessage.getFirst().getIdLong(); if(!previousMessage.isEmpty()) messageId = previousMessage.get(0).getIdLong();
else outOfBounds = true; else outOfBounds = true;
} }
// queue messages for deletion // queue messages for deletion
if (messages.size() == 1) if(messages.size() == 1)
{ {
messages.getFirst().delete().queue(); messages.get(0).delete().queue();
} else if (!messages.isEmpty()) }
else if(!messages.isEmpty())
{ {
try try {
{
((TextChannel) channel).deleteMessages(messages).complete(); ((TextChannel) channel).deleteMessages(messages).complete();
/* alternatively, we could use purgeMessages, which is smarter... /* alternatively, we could use purgeMessages, which is smarter...
however, it also tries to delete messages older than 2 weeks however, it also tries to delete messages older than 2 weeks
which are restricted by discord, and thus has to use which are restricted by discord, and thus has to use
a less efficient way that triggers rate-limiting very quickly. */ a less efficient way that triggers rate-limiting very quickly. */
} catch (RuntimeException ignored) } catch (Exception e)
{ {
return -1; return -1;
} }
} }
@@ -160,29 +152,45 @@ public class ClearChat
public static Button getDismissButton() public static Button getDismissButton()
{ {
return Button.primary("generic_dismiss", "Dismiss") return Button.primary("clear_dismiss", "Dismiss")
.withEmoji(Emoji.fromUnicode("❌")); .withEmoji(Emoji.fromUnicode("❌"));
} }
public static String parseAmount(int deleted) public static String parseAmount(int deleted)
{ {
if (deleted < 1) if(deleted < 1)
{ {
return "\uD83D\uDE22 Couldn't clear any message!"; return "\uD83D\uDE22 Couldn't clear any message!";
} else if (deleted == 1) } else if(deleted == 1)
{ {
return "✂ Cleared 1 message!"; return "✂ Cleared 1 message!";
} else } else {
{
return "✂ Cleared " + deleted + " messages!"; return "✂ Cleared " + deleted + " messages!";
} }
} }
// cap the amount to avoid abuse. private void respond(Object responseFlowObj, String content)
public static int getMaxAmount()
{ {
return 1000; if(responseFlowObj instanceof InteractionHook) {
((InteractionHook) responseFlowObj).editOriginal(content).queue();
} else if (responseFlowObj instanceof Message) {
((Message) responseFlowObj).reply(content).queue();
}
}
public static void dismissMessage(ButtonInteractionEvent event)
{
if(!(Cache.getDatabaseSource().isUserTrackedFor(event.getUser().getId(), event.getMessageId())))
{
event.reply("❌ You did not run this command!").setEphemeral(true).queue();
} else
{
event.getInteraction().getMessage().delete().queue();
}
} }
} }

21
src/main/java/wtf/beatrice/hidekobot/commands/base/CoinFlip.java
View File

@@ -14,15 +14,10 @@ import java.util.List;
public class CoinFlip public class CoinFlip
{ {
private CoinFlip()
{
throw new IllegalStateException("Utility class");
}
public static Button getReflipButton() public static Button getReflipButton() {
{
return Button.primary("coinflip_reflip", "Flip again") return Button.primary("coinflip_reflip", "Flip again")
.withEmoji(Emoji.fromUnicode("\uD83E\uDE99")); .withEmoji(Emoji.fromFormatted("\uD83E\uDE99"));
} }
public static String genRandom() public static String genRandom()
@@ -30,11 +25,10 @@ public class CoinFlip
int rand = RandomUtil.getRandomNumber(0, 1); int rand = RandomUtil.getRandomNumber(0, 1);
String msg; String msg;
if (rand == 1) if(rand == 1)
{ {
msg = ":coin: It's **Heads**!"; msg = ":coin: It's **Heads**!";
} else } else {
{
msg = "It's **Tails**! :coin:"; msg = "It's **Tails**! :coin:";
} }
@@ -44,7 +38,7 @@ public class CoinFlip
public static void buttonReFlip(ButtonInteractionEvent event) public static void buttonReFlip(ButtonInteractionEvent event)
{ {
// check if the user interacting is the same one who ran the command // check if the user interacting is the same one who ran the command
if (!(Cache.getDatabaseSource().isUserTrackedFor(event.getUser().getId(), event.getMessageId()))) if(!(Cache.getDatabaseSource().isUserTrackedFor(event.getUser().getId(), event.getMessageId())))
{ {
event.reply("❌ You did not run this command!").setEphemeral(true).queue(); event.reply("❌ You did not run this command!").setEphemeral(true).queue();
return; return;
@@ -62,12 +56,13 @@ public class CoinFlip
{ {
// set the command as expiring and restrict it to the user who ran it // set the command as expiring and restrict it to the user who ran it
trackAndRestrict(message, event.getUser()); trackAndRestrict(message, event.getUser());
}, (error) -> { }, (error) -> {});
});
} }
public static void trackAndRestrict(Message replyMessage, User user) public static void trackAndRestrict(Message replyMessage, User user)
{ {
String replyMessageId = replyMessage.getId();
Cache.getDatabaseSource().queueDisabling(replyMessage); Cache.getDatabaseSource().queueDisabling(replyMessage);
Cache.getDatabaseSource().trackRanCommandReply(replyMessage, user); Cache.getDatabaseSource().trackRanCommandReply(replyMessage, user);
} }

174
src/main/java/wtf/beatrice/hidekobot/commands/base/DiceRoll.java
View File

@@ -1,174 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.User;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.fun.Dice;
import wtf.beatrice.hidekobot.util.RandomUtil;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.UUID;
public class DiceRoll
{
private DiceRoll()
{
throw new IllegalStateException("Utility class");
}
public static MessageResponse buildResponse(User author, String[] args)
{
LinkedHashMap<Dice, Integer> dicesToRoll = new LinkedHashMap<>();
String diceRegex = "d\\d+";
String amountRegex = "\\d+";
Dice currentDice = null;
int currentAmount;
UUID lastPushedDice = null;
int totalRolls = 0;
for (String arg : args)
{
if (totalRolls > 200)
{
return new MessageResponse("Too many total rolls!", null);
}
if (arg.matches(amountRegex))
{
currentAmount = Integer.parseInt(arg);
if (currentDice == null)
{
currentDice = new Dice(6);
} else
{
currentDice = new Dice(currentDice);
}
if (currentAmount > 100)
{
return new MessageResponse("Too many rolls (`" + currentAmount + "`)!", null);
}
lastPushedDice = currentDice.getUUID();
dicesToRoll.put(currentDice, currentAmount);
totalRolls += currentAmount;
} else if (arg.matches(diceRegex))
{
int sides = Integer.parseInt(arg.substring(1));
if (sides > 10000)
{
return new MessageResponse("Too many sides (`" + sides + "`)!", null);
}
if (args.length == 1)
{
dicesToRoll.put(new Dice(sides), 1);
totalRolls++;
} else
{
if (currentDice != null)
{
if (lastPushedDice == null || !lastPushedDice.equals(currentDice.getUUID()))
{
dicesToRoll.put(currentDice, 1);
lastPushedDice = currentDice.getUUID();
totalRolls++;
}
}
currentDice = new Dice(sides);
}
}
}
if (lastPushedDice == null)
{
if (currentDice != null)
{
dicesToRoll.put(currentDice, 1);
totalRolls++;
}
} else
{
if (!lastPushedDice.equals(currentDice.getUUID()))
{
dicesToRoll.put(new Dice(currentDice), 1);
totalRolls++;
}
}
LinkedList<Dice> rolledDices = new LinkedList<>();
// in case no dice was specified (or invalid), roll a standard 6-sided dice.
if (dicesToRoll.isEmpty())
{
Dice standardDice = new Dice(6);
dicesToRoll.put(standardDice, 1);
totalRolls = 1;
}
for (Map.Entry<Dice, Integer> entry : dicesToRoll.entrySet())
{
Dice dice = entry.getKey();
Integer rollsToMake = entry.getValue();
for (int roll = 0; roll < rollsToMake; roll++)
{
dice.roll();
rolledDices.add(new Dice(dice));
}
}
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setAuthor(author.getAsTag(), null, author.getAvatarUrl());
embedBuilder.setTitle("Dice Roll");
if (RandomUtil.isRandomOrgKeyValid())
embedBuilder.setFooter("Seed provided by random.org");
StringBuilder message = new StringBuilder();
int total = 0;
int previousDiceSides = 0;
for (Dice dice : rolledDices)
{
int diceSize = dice.getSides();
if (previousDiceSides != diceSize)
{
message.append("\nd").append(diceSize).append(": ");
previousDiceSides = diceSize;
} else if (previousDiceSides != 0)
{
message.append(", ");
}
message.append("`").append(dice.getValue()).append("`");
total += dice.getValue();
}
// discord doesn't allow embed fields to be longer than 1024 and errors out
if (message.length() > 1024)
{
return new MessageResponse("Too many rolls!", null);
}
embedBuilder.addField("\uD83C\uDFB2 Rolls", message.toString(), false);
String rolls = totalRolls == 1 ? "roll" : "rolls";
embedBuilder.addField("✨ Total", totalRolls + " " + rolls + ": " + total, false);
return new MessageResponse(null, embedBuilder.build());
}
}

7
src/main/java/wtf/beatrice/hidekobot/commands/base/Invite.java
View File

@@ -10,11 +10,6 @@ import wtf.beatrice.hidekobot.HidekoBot;
public class Invite public class Invite
{ {
private Invite()
{
throw new IllegalStateException("Utility class");
}
public static MessageEmbed generateEmbed() public static MessageEmbed generateEmbed()
{ {
EmbedBuilder embedBuilder = new EmbedBuilder(); EmbedBuilder embedBuilder = new EmbedBuilder();
@@ -23,7 +18,7 @@ public class Invite
{ {
embedBuilder.setColor(Cache.getBotColor()); embedBuilder.setColor(Cache.getBotColor());
String avatarUrl = HidekoBot.getAPI().getSelfUser().getAvatarUrl(); String avatarUrl = HidekoBot.getAPI().getSelfUser().getAvatarUrl();
if (avatarUrl != null) embedBuilder.setThumbnail(avatarUrl); if(avatarUrl != null) embedBuilder.setThumbnail(avatarUrl);
embedBuilder.setTitle("Invite"); embedBuilder.setTitle("Invite");
embedBuilder.appendDescription("Click on the button below to invite " + embedBuilder.appendDescription("Click on the button below to invite " +
Cache.getBotName() + Cache.getBotName() +

54
src/main/java/wtf/beatrice/hidekobot/commands/base/LoveCalculator.java
View File

@@ -1,54 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.util.RandomUtil;
import java.util.concurrent.TimeUnit;
public class LoveCalculator
{
private LoveCalculator()
{
throw new IllegalStateException("Utility class");
}
public static MessageEmbed buildEmbedAndCacheResult(User author, User user1, User user2)
{
String userId1 = user1.getId();
String userId2 = user2.getId();
Integer loveAmount = Cache.getLoveCalculatorValue(userId1, userId2);
if (loveAmount == null)
{
loveAmount = RandomUtil.getRandomNumber(0, 100);
Cache.cacheLoveCalculatorValue(userId1, userId2, loveAmount);
Cache.getTaskScheduler().schedule(() ->
Cache.removeLoveCalculatorValue(userId1, userId2), 10, TimeUnit.MINUTES);
}
String formattedAmount = loveAmount + "%";
if (loveAmount <= 30) formattedAmount += "... \uD83D\uDE22";
else if (loveAmount < 60) formattedAmount += "! \uD83E\uDDD0";
else if (loveAmount < 75) formattedAmount += "!!! \uD83E\uDD73";
else formattedAmount = "✨ " + formattedAmount + "!!! \uD83D\uDE0D\uD83D\uDCA5";
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setAuthor(author.getAsTag(), null, author.getAvatarUrl());
embedBuilder.setTitle("Love Calculator");
embedBuilder.addField("\uD83D\uDC65 People",
user1.getAsMention() + " & " + user2.getAsMention(),
false);
embedBuilder.addField("❤️\u200D\uD83D\uDD25 Match",
formattedAmount,
false);
return embedBuilder.build();
}
}

72
src/main/java/wtf/beatrice/hidekobot/commands/base/MagicBall.java
View File

@@ -1,72 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.util.RandomUtil;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class MagicBall
{
private MagicBall()
{
throw new IllegalStateException("Utility class");
}
public static LinkedList<String> getLabels()
{
return new LinkedList<>(Arrays.asList("8ball", "8b", "eightball", "magicball"));
}
private static final List<String> answers = new ArrayList<>(
Arrays.asList("It is certain.",
"It is decidedly so.",
"Without a doubt.",
"Yes, definitely.",
"That would be a yes.",
"As I see it, yes.",
"Most likely.",
"Looks like it.",
"Yes.",
"Signs point to yes.",
"Reply hazy, try again.",
"Ask again later.",
"Better not tell you now.",
"Seems uncertain.",
"Concentrate and ask again.",
"Don't count on it.",
"My answer is no.",
"My sources say no.",
"Outlook not so good.",
"Very doubtful."));
public static String getRandomAnswer()
{
int answerPos = RandomUtil.getRandomNumber(0, answers.size() - 1);
return answers.get(answerPos);
}
public static MessageEmbed generateEmbed(String question, User author)
{
// add a question mark at the end, if missing.
// this might not always apply but it's fun
if (!question.endsWith("?")) question += "?";
String answer = getRandomAnswer();
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setAuthor(author.getAsTag(), null, author.getAvatarUrl());
embedBuilder.setTitle("Magic Ball");
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.addField("❓ Question", question, false);
embedBuilder.addField("\uD83C\uDFB1 Answer", answer, false);
return embedBuilder.build();
}
}

113
src/main/java/wtf/beatrice/hidekobot/commands/base/ProfileImage.java
View File

@@ -1,113 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.utils.ImageProxy;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.objects.MessageResponse;
public class ProfileImage
{
private ProfileImage()
{
throw new IllegalStateException("Utility class");
}
public static int parseResolution(int resolution)
{
int[] acceptedSizes = Cache.getSupportedAvatarResolutions();
// method to find closest value to accepted values
int distance = Math.abs(acceptedSizes[0] - resolution);
int idx = 0;
for (int c = 1; c < acceptedSizes.length; c++)
{
int cdistance = Math.abs(acceptedSizes[c] - resolution);
if (cdistance < distance)
{
idx = c;
distance = cdistance;
}
}
return acceptedSizes[idx];
}
public static MessageResponse buildResponse(int resolution, User user, ImageType imageType)
{
String imageTypeName = imageType.name().toLowerCase();
String resolutionString;
String imageLink = null;
User.Profile userProfile = user.retrieveProfile().complete();
ImageProxy bannerProxy = userProfile.getBanner();
if (imageType == ImageType.AVATAR)
{
resolutionString = resolution + " × " + resolution;
imageLink = user.getEffectiveAvatar().getUrl(resolution);
} else
{
int verticalRes = 361 * resolution / 1024;
resolutionString = resolution + " × " + verticalRes;
if (bannerProxy != null)
imageLink = bannerProxy.getUrl(resolution);
}
int[] acceptedSizes = Cache.getSupportedAvatarResolutions();
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle("Profile " + imageTypeName);
embedBuilder.addField("User", user.getAsMention(), false);
embedBuilder.addField("Current resolution", resolutionString, false);
// string builder to create a string that links to all available resolutions
StringBuilder links = new StringBuilder();
for (int pos = 0; pos < acceptedSizes.length; pos++)
{
int currSize = acceptedSizes[pos];
String currLink;
if (imageType == ImageType.AVATAR)
{
currLink = user.getEffectiveAvatar().getUrl(currSize);
} else
{
if (bannerProxy == null) break;
currLink = bannerProxy.getUrl(currSize);
}
links.append("**[").append(currSize).append("px](").append(currLink).append(")**");
if (pos + 1 != acceptedSizes.length) // don't add a separator on the last iteration
{
links.append(" | ");
}
}
embedBuilder.addField("Available resolutions", links.toString(), false);
if (imageLink != null)
embedBuilder.setImage(imageLink);
if (imageLink == null)
{
String error = "I couldn't find " + user.getAsMention() + "'s " + imageTypeName + "!";
return new MessageResponse(error, null);
} else
{
return new MessageResponse(null, embedBuilder.build());
}
}
public enum ImageType
{
AVATAR, BANNER;
}
}

8
src/main/java/wtf/beatrice/hidekobot/commands/base/Say.java
View File

@@ -5,13 +5,7 @@ import net.dv8tion.jda.api.Permission;
public class Say public class Say
{ {
private Say() public static Permission getPermission() {
{
throw new IllegalStateException("Utility class");
}
public static Permission getPermission()
{
return Permission.MESSAGE_MANAGE; return Permission.MESSAGE_MANAGE;
} }
} }

312
src/main/java/wtf/beatrice/hidekobot/commands/base/Trivia.java
View File

@@ -1,312 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
import net.dv8tion.jda.api.events.interaction.component.StringSelectInteractionEvent;
import net.dv8tion.jda.api.interactions.components.selections.SelectOption;
import net.dv8tion.jda.api.interactions.components.selections.StringSelectMenu;
import org.apache.commons.text.StringEscapeUtils;
import org.json.JSONArray;
import org.json.JSONObject;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.comparators.TriviaCategoryComparator;
import wtf.beatrice.hidekobot.objects.fun.TriviaCategory;
import wtf.beatrice.hidekobot.objects.fun.TriviaQuestion;
import wtf.beatrice.hidekobot.objects.fun.TriviaScore;
import wtf.beatrice.hidekobot.runnables.TriviaTask;
import wtf.beatrice.hidekobot.util.CommandUtil;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
public class Trivia
{
private Trivia()
{
throw new IllegalStateException("Utility class");
}
private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(Trivia.class);
private static final String TRIVIA_API_LINK = "https://opentdb.com/api.php?amount=10&type=multiple&category=";
private static final String TRIVIA_API_CATEGORIES_LINK = "https://opentdb.com/api_category.php";
public static List<String> channelsRunningTrivia = new ArrayList<>();
// first string is the channelId, the list contain all users who responded there
public static HashMap<String, List<String>> channelAndWhoResponded = new HashMap<>();
// first string is the channelId, the list contain all score records for that channel
public static HashMap<String, LinkedList<TriviaScore>> channelAndScores = new HashMap<>();
public static String getTriviaLink(int categoryId)
{
return TRIVIA_API_LINK + categoryId;
}
public static String getCategoriesLink()
{
return TRIVIA_API_CATEGORIES_LINK;
}
public static String getNoDMsError()
{
return "\uD83D\uDE22 Sorry! Trivia doesn't work in DMs.";
}
public static String getTriviaAlreadyRunningError()
{
// todo nicer looking
return "Trivia is already running here!";
}
public static MessageResponse generateMainScreen()
{
JSONObject categoriesJson = Trivia.fetchJson(Trivia.getCategoriesLink());
if (categoriesJson == null)
return new MessageResponse("Error fetching trivia!", null); // todo nicer with emojis
List<TriviaCategory> categories = Trivia.parseCategories(categoriesJson);
if (categories.isEmpty())
return new MessageResponse("Error parsing trivia categories!", null); // todo nicer with emojis
categories.sort(new TriviaCategoryComparator());
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle("\uD83C\uDFB2 Trivia");
embedBuilder.addField("\uD83D\uDCD6 Begin here",
"Select a category from the dropdown menu to start a match!",
false);
embedBuilder.addField("❓ How to play",
"A new question gets posted every few seconds." +
"\nIf you get it right, you earn points!" +
"\nIf you choose a wrong answer, you lose points." +
"\nIf you are unsure, you can wait without answering and your score won't change!",
false);
StringSelectMenu.Builder menuBuilder = StringSelectMenu.create("trivia_categories");
for (TriviaCategory category : categories)
{
String name = category.categoryName();
int id = category.categoryId();
menuBuilder.addOption(name, String.valueOf(id));
}
return new MessageResponse(null, embedBuilder.build(), menuBuilder.build());
}
public static JSONObject fetchJson(String link)
{
try
{
URL url = new URL(link);
URLConnection connection = url.openConnection();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
String currentChar;
StringBuilder jsonStrBuilder = new StringBuilder();
while ((currentChar = bufferedReader.readLine()) != null)
{
jsonStrBuilder.append(currentChar);
}
bufferedReader.close();
return new JSONObject(jsonStrBuilder.toString());
} catch (IOException e)
{
LOGGER.error("JSON Parsing Exception", e);
}
return null;
}
public static List<TriviaQuestion> parseQuestions(JSONObject jsonObject)
{
List<TriviaQuestion> questions = new ArrayList<>();
JSONArray results = jsonObject.getJSONArray("results");
for (Object currentQuestionGeneric : results)
{
JSONObject questionJson = (JSONObject) currentQuestionGeneric;
String question = StringEscapeUtils.unescapeHtml4(questionJson.getString("question"));
String correctAnswer = StringEscapeUtils.unescapeHtml4(questionJson.getString("correct_answer"));
List<String> incorrectAnswersList = new ArrayList<>();
JSONArray incorrectAnswers = questionJson.getJSONArray("incorrect_answers");
for (Object incorrectAnswerGeneric : incorrectAnswers)
{
String incorrectAnswer = (String) incorrectAnswerGeneric;
incorrectAnswersList.add(StringEscapeUtils.unescapeHtml4(incorrectAnswer));
}
TriviaQuestion triviaQuestion = new TriviaQuestion(question, correctAnswer, incorrectAnswersList);
questions.add(triviaQuestion);
}
return questions;
}
public static List<TriviaCategory> parseCategories(JSONObject jsonObject)
{
List<TriviaCategory> categories = new ArrayList<>();
JSONArray categoriesArray = jsonObject.getJSONArray("trivia_categories");
for (Object categoryObject : categoriesArray)
{
JSONObject categoryJson = (JSONObject) categoryObject;
String name = categoryJson.getString("name");
int id = categoryJson.getInt("id");
categories.add(new TriviaCategory(name, id));
}
return categories;
}
public static void handleAnswer(ButtonInteractionEvent event, AnswerType answerType)
{
User user = event.getUser();
String channelId = event.getChannel().getId();
if (trackResponse(user, event.getChannel()))
{
LinkedList<TriviaScore> scores = channelAndScores.get(channelId);
if (scores == null) scores = new LinkedList<>();
TriviaScore currentUserScore = null;
for (TriviaScore score : scores)
{
if (score.getUser().equals(user))
{
currentUserScore = score;
scores.remove(score);
break;
}
}
if (currentUserScore == null)
{
currentUserScore = new TriviaScore(user);
}
if (answerType.equals(AnswerType.CORRECT))
{
event.reply(user.getAsMention() + " got it right! \uD83E\uDD73 (**+3**)").queue();
currentUserScore.changeScore(3);
} else
{
event.reply("❌ " + user.getAsMention() + ", that's not the right answer! (**-1**)").queue();
currentUserScore.changeScore(-1);
}
scores.add(currentUserScore);
channelAndScores.put(channelId, scores);
} else
{
event.reply("☹️ " + user.getAsMention() + ", you can't answer twice!")
.queue(interaction ->
Cache.getTaskScheduler().schedule(() ->
interaction.deleteOriginal().queue(), 3, TimeUnit.SECONDS));
}
}
private static boolean trackResponse(User user, MessageChannel channel)
{
String userId = user.getId();
String channelId = channel.getId();
List<String> responders = channelAndWhoResponded.get(channelId);
if (responders == null)
{
responders = new ArrayList<>();
}
if (responders.isEmpty() || !responders.contains(userId))
{
responders.add(userId);
channelAndWhoResponded.put(channelId, responders);
return true; // response was successfully tracked
} else
{
return false; // response wasn't tracked because there already was an entry
}
}
public static void handleMenuSelection(StringSelectInteractionEvent event)
{
// check if the user interacting is the same one who ran the command
if (!(Cache.getDatabaseSource().isUserTrackedFor(event.getUser().getId(), event.getMessageId())))
{
event.reply("❌ You did not run this command!").setEphemeral(true).queue();
return;
}
// todo: we shouldn't use this method, since it messes with the database... look at coin reflip
CommandUtil.disableExpired(event.getMessageId());
SelectOption pickedOption = event.getInteraction().getSelectedOptions().get(0);
String categoryName = pickedOption.getLabel();
String categoryIdString = pickedOption.getValue();
Integer categoryId = Integer.parseInt(categoryIdString);
TriviaCategory category = new TriviaCategory(categoryName, categoryId);
startTrivia(event, category);
}
public static void startTrivia(StringSelectInteractionEvent event, TriviaCategory category)
{
User author = event.getUser();
Message message = event.getMessage();
MessageChannel channel = message.getChannel();
if (Trivia.channelsRunningTrivia.contains(channel.getId()))
{
// todo nicer looking
// todo: also what if the bot stops (database...?)
// todo: also what if the message is already deleted
Message err = event.reply("Trivia is already running here!").complete().retrieveOriginal().complete();
Cache.getTaskScheduler().schedule(() -> err.delete().queue(), 10, TimeUnit.SECONDS);
return;
} else
{
// todo nicer looking
event.reply("Starting new Trivia session!").queue();
}
TriviaTask triviaTask = new TriviaTask(author, channel, category);
ScheduledFuture<?> future =
Cache.getTaskScheduler().scheduleAtFixedRate(triviaTask,
0,
15,
TimeUnit.SECONDS);
triviaTask.setScheduledFuture(future);
Trivia.channelsRunningTrivia.add(channel.getId());
}
public enum AnswerType
{
CORRECT, WRONG
}
}

344
src/main/java/wtf/beatrice/hidekobot/commands/base/UrbanDictionary.java
View File

@@ -1,344 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.emoji.Emoji;
import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
import net.dv8tion.jda.api.interactions.components.ActionRow;
import net.dv8tion.jda.api.interactions.components.ItemComponent;
import net.dv8tion.jda.api.interactions.components.buttons.Button;
import org.apache.commons.text.StringEscapeUtils;
import org.apache.commons.text.WordUtils;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.datasources.DatabaseSource;
import wtf.beatrice.hidekobot.util.SerializationUtil;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class UrbanDictionary
{
private UrbanDictionary()
{
throw new IllegalStateException("Utility class");
}
public static LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Arrays.asList("urban", "urbandictionary", "ud"));
}
public static String getBaseUrl()
{
return "https://www.urbandictionary.com/define.php?term=";
}
public static Button getPreviousPageButton()
{
return Button.primary("urban_previouspage", "Back")
.withEmoji(Emoji.fromFormatted("⬅️"));
}
public static Button getNextPageButton()
{
return Button.primary("urban_nextpage", "Next")
.withEmoji(Emoji.fromFormatted("➡️"));
}
public static Button getDeleteButton()
{
return Button.danger("generic_dismiss", "Delete")
.withEmoji(Emoji.fromFormatted("\uD83D\uDDD1️"));
}
public static String getNoArgsError()
{
return "\uD83D\uDE22 I need to know what to search for!";
}
public static String sanitizeArgs(String term, boolean forUrl)
{
term = term.replaceAll("[^\\w\\s]", ""); // only keep letters, numbers and spaces
term = WordUtils.capitalizeFully(term); // Make Every Word Start With A Capital Letter
if (forUrl) term = term.replaceAll("\\s+", "+"); // replace all whitespaces with + for the url
if (term.length() > 64) term = term.substring(0, 64); // cut it to length to avoid abuse
return term;
}
public static String generateUrl(String term)
{
return getBaseUrl() + sanitizeArgs(term, true);
}
public static MessageEmbed buildEmbed(String term,
String url,
User author,
UrbanSearch search,
int page)
{
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle(term + ", on Urban Dictionary", url);
embedBuilder.setAuthor(author.getAsTag(), null, author.getAvatarUrl());
embedBuilder.addField("\uD83D\uDCD6 Definition", search.getPlaintextMeanings().get(page), false);
embedBuilder.addField("\uD83D\uDCAD Example", search.getPlaintextExamples().get(page), false);
embedBuilder.addField("\uD83D\uDCCC Submission",
"*Entry " + (page + 1) + " | Sent by " + search.getContributorsNames().get(page) +
" on" + search.getSubmissionDates().get(page) + "*",
false);
return embedBuilder.build();
}
public static String getTermNotFoundError()
{
return "\uD83D\uDE22 I couldn't find that term!";
}
public static void track(Message message, User user, UrbanSearch search, String sanitizedTerm)
{
Cache.getDatabaseSource().queueDisabling(message);
Cache.getDatabaseSource().trackRanCommandReply(message, user);
Cache.getDatabaseSource().trackUrban(search.getSerializedMeanings(),
search.getSerializedExamples(),
search.getSerializedContributors(),
search.getSerializedDates(),
message,
sanitizedTerm);
}
public static void changePage(ButtonInteractionEvent event, ChangeType changeType)
{
String messageId = event.getMessageId();
DatabaseSource database = Cache.getDatabaseSource();
// check if the user interacting is the same one who ran the command
if (!(database.isUserTrackedFor(event.getUser().getId(), messageId)))
{
event.reply("❌ You did not run this command!").setEphemeral(true).queue();
return;
}
// get current page and calculate how many pages there are
int page = Cache.getDatabaseSource().getUrbanPage(messageId);
String term = database.getUrbanTerm(messageId);
String url = generateUrl(term);
// get serialized parameters
String serializedMeanings = database.getUrbanMeanings(messageId);
String serializedExamples = database.getUrbanExamples(messageId);
String serializedContributors = database.getUrbanContributors(messageId);
String serializedDates = database.getUrbanDates(messageId);
// construct object by passing serialized parameters
UrbanSearch search = new UrbanSearch(serializedMeanings,
serializedExamples, serializedContributors, serializedDates);
// move to new page
if (changeType == ChangeType.NEXT)
page++;
else if (changeType == ChangeType.PREVIOUS)
page--;
term = UrbanDictionary.sanitizeArgs(term, false);
// generate embed with new results
MessageEmbed updatedEmbed = UrbanDictionary.buildEmbed(term, url, event.getUser(), search, page);
// get all attached components and check which ones need to be enabled or disabled
List<ItemComponent> components = new ArrayList<>();
if (page > 0)
{
components.add(UrbanDictionary.getPreviousPageButton().asEnabled());
} else
{
components.add(UrbanDictionary.getPreviousPageButton().asDisabled());
}
if (page + 1 == search.getPages())
{
components.add(UrbanDictionary.getNextPageButton().asDisabled());
} else
{
components.add(UrbanDictionary.getNextPageButton().asEnabled());
}
// update the components on the object
components.add(UrbanDictionary.getDeleteButton());
ActionRow currentRow = ActionRow.of(components);
// update the message
event.editComponents(currentRow).setEmbeds(updatedEmbed).queue();
database.setUrbanPage(messageId, page);
database.resetExpiryTimestamp(messageId);
}
public static class UrbanSearch
{
final LinkedList<String> plaintextMeanings;
final LinkedList<String> plaintextExamples;
final LinkedList<String> contributorsNames;
final LinkedList<String> submissionDates;
final String serializedMeanings;
final String serializedExamples;
final String serializedContributors;
final String serializedDates;
final int pages;
public UrbanSearch(String serializedMeanings,
String serializedExamples,
String serializedContributors,
String serializedDates)
{
this.serializedMeanings = serializedMeanings;
this.serializedExamples = serializedExamples;
this.serializedContributors = serializedContributors;
this.serializedDates = serializedDates;
this.plaintextMeanings = SerializationUtil.deserializeBase64(serializedMeanings);
this.plaintextExamples = SerializationUtil.deserializeBase64(serializedExamples);
this.contributorsNames = SerializationUtil.deserializeBase64(serializedContributors);
this.submissionDates = SerializationUtil.deserializeBase64(serializedDates);
this.pages = submissionDates.size();
}
public UrbanSearch(Elements definitions)
{
plaintextMeanings = new LinkedList<>();
plaintextExamples = new LinkedList<>();
contributorsNames = new LinkedList<>();
submissionDates = new LinkedList<>();
for (Element definition : definitions)
{
Elements meaningSingleton = definition.getElementsByClass("meaning");
if (meaningSingleton.isEmpty())
{
plaintextMeanings.add(" ");
} else
{
Element meaning = meaningSingleton.get(0);
String text = meaning.html()
.replaceAll("<br\\s*?>", "\n") // keep newlines
.replaceAll("<.*?>", ""); // remove all other html tags
// this is used to fix eg. &amp; being shown literally instead of being parsed
text = StringEscapeUtils.unescapeHtml4(text);
// discord only allows 1024 characters for embed fields
if (text.length() > 1024) text = text.substring(0, 1020) + "...";
plaintextMeanings.add(text);
}
Elements exampleSingleton = definition.getElementsByClass("example");
if (exampleSingleton.isEmpty())
{
plaintextExamples.add(" ");
} else
{
Element example = exampleSingleton.get(0);
String text = example.html()
.replaceAll("<br\\s*?>", "\n") // keep newlines
.replaceAll("<.*?>", ""); // remove all other html tags
// this is used to fix eg. &amp; being shown literally instead of being parsed
text = StringEscapeUtils.unescapeHtml4(text);
// discord only allows 1024 characters for embed fields
if (text.length() > 1024) text = text.substring(0, 1020) + "...";
plaintextExamples.add(text);
}
Elements contributorSingleton = definition.getElementsByClass("contributor");
if (contributorSingleton.isEmpty())
{
contributorsNames.add("Unknown");
} else
{
Element contributor = contributorSingleton.get(0);
String htmlContributor = contributor.html();
String htmlContributorName = contributor.select("a").html();
String htmlSubmitDate = htmlContributor.substring(
htmlContributor.indexOf("</a>") + 4);
contributorsNames.add(htmlContributorName
.replaceAll("<.*?>", "")); // remove all html tags
submissionDates.add(htmlSubmitDate
.replaceAll("<.*?>", "")); // remove all html tags
}
}
serializedMeanings = SerializationUtil.serializeBase64(plaintextMeanings);
serializedExamples = SerializationUtil.serializeBase64(plaintextExamples);
serializedContributors = SerializationUtil.serializeBase64(contributorsNames);
serializedDates = SerializationUtil.serializeBase64(submissionDates);
pages = submissionDates.size();
}
public List<String> getPlaintextMeanings()
{
return this.plaintextMeanings;
}
public List<String> getPlaintextExamples()
{
return this.plaintextExamples;
}
public List<String> getContributorsNames()
{
return this.contributorsNames;
}
public List<String> getSubmissionDates()
{
return this.submissionDates;
}
public String getSerializedMeanings()
{
return serializedMeanings;
}
public String getSerializedExamples()
{
return serializedExamples;
}
public String getSerializedContributors()
{
return serializedContributors;
}
public String getSerializedDates()
{
return serializedDates;
}
public int getPages()
{
return pages;
}
}
public enum ChangeType
{
NEXT,
PREVIOUS;
}
}

279
src/main/java/wtf/beatrice/hidekobot/commands/base/UserPunishment.java
View File

@@ -1,279 +0,0 @@
package wtf.beatrice.hidekobot.commands.base;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.IMentionable;
import net.dv8tion.jda.api.entities.Mentions;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
import net.dv8tion.jda.api.entities.channel.unions.MessageChannelUnion;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.requests.restaction.AuditableRestAction;
import org.apache.commons.lang3.ArrayUtils;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.util.FormatUtil;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class UserPunishment
{
private UserPunishment()
{
throw new IllegalStateException("Utility class");
}
private static final Duration maxTimeoutDuration = Duration.of(28, ChronoUnit.DAYS);
private static final Duration minTimeoutDuration = Duration.of(30, ChronoUnit.SECONDS);
public static void handle(SlashCommandInteractionEvent event, PunishmentType punishmentType)
{
// this might take a sec
event.deferReply().queue();
User targetUser = null;
OptionMapping targetUserArg = event.getOption("target");
if (targetUserArg != null)
{
targetUser = targetUserArg.getAsUser();
}
List<IMentionable> mentions = null;
if (targetUser != null) mentions = new ArrayList<>(Collections.singletonList(targetUser));
String reason = null;
OptionMapping reasonArg = event.getOption("reason");
if (reasonArg != null)
{
reason = reasonArg.getAsString();
}
String timeDiff = null;
OptionMapping timeDiffArg = event.getOption("duration");
if (timeDiffArg != null)
{
timeDiff = timeDiffArg.getAsString();
}
// todo: the following code is not great, because we are making an array and then
// we are also recreating the string later in code. this is useless and a bit hacked on,
// but works for now. this happened because the function was NOT written with slash commands
// in mind, but with message commands, that send every word as a separate argument.
// we should probably rework the it so that it works better in both scenarios.
String[] reasonSplit = null;
// generate the arguments array by splitting the string
if (reason != null) reasonSplit = reason.split("\\s+");
//prepend timediff at index 0
if (timeDiff != null) reasonSplit = ArrayUtils.insert(0, reasonSplit, timeDiff);
// in message-commands, the first arg would contain the user mention. since we have no one mentioned here,
// because it's in its own argument, we just prepend an empty string. note that this makes relying on the
// first argument BAD, because it is no longer ensured that it contains the user mention.
if (timeDiff != null) reasonSplit = ArrayUtils.insert(0, reasonSplit, "");
MessageResponse response = getResponse(event.getUser(),
punishmentType,
event.getChannel(),
mentions,
reasonSplit);
if (response.embed() != null)
event.getHook().editOriginalEmbeds(response.embed()).queue();
else if (response.content() != null)
event.getHook().editOriginal(response.content()).queue();
}
public static void handle(MessageReceivedEvent event, String[] args, PunishmentType punishmentType)
{
Mentions msgMentions = event.getMessage().getMentions();
List<IMentionable> mentions = msgMentions.getMentions();
MessageResponse response = getResponse(event.getAuthor(),
punishmentType,
event.getChannel(),
mentions,
args);
if (response.embed() != null)
event.getMessage().replyEmbeds(response.embed()).queue();
else if (response.content() != null)
event.getMessage().reply(response.content()).queue();
}
public static MessageResponse getResponse(User author,
PunishmentType punishmentType,
MessageChannelUnion channel,
List<IMentionable> mentions,
String[] args)
{
String punishmentTypeName = punishmentType.name().toLowerCase();
if (!(channel instanceof TextChannel))
{
// todo nicer looking with emojis
return new MessageResponse("Sorry! I can't " + punishmentTypeName + " people in DMs.", null);
}
if (mentions == null || mentions.isEmpty())
{
// todo nicer looking with emojis
return new MessageResponse("You have to tell me who to " + punishmentTypeName + "!", null);
}
String mentionedId = mentions.get(0).getId();
User mentioned = null;
try
{
mentioned = HidekoBot.getAPI().retrieveUserById(mentionedId).complete();
} catch (RuntimeException ignored)
{
// todo nicer looking with emojis
return new MessageResponse("I can't " + punishmentTypeName + " that user!", null);
}
StringBuilder reasonBuilder = new StringBuilder();
String reason = "";
// some commands require an additional parameter before the reason, so in that case, we should start at 2.
int startingPoint = punishmentType == PunishmentType.TIMEOUT ? 2 : 1;
if (args != null && args.length > startingPoint)
{
for (int i = startingPoint; i < args.length; i++)
{
String arg = args[i];
reasonBuilder.append(arg);
if (i + 1 != arg.length())
reasonBuilder.append(" "); // separate args with a space except on last iteration.
}
reason = reasonBuilder.toString();
}
if (mentioned == null)
{
// todo nicer looking with emojis
return new MessageResponse("I can't " + punishmentTypeName + " that user!", null);
}
Guild guild = ((TextChannel) channel).getGuild();
Duration duration = null;
AuditableRestAction<Void> punishmentAction = null;
boolean impossible = false;
try
{
switch (punishmentType)
{
case BAN -> punishmentAction = guild.ban(mentioned, 0, TimeUnit.SECONDS);
case KICK -> punishmentAction = guild.kick(mentioned);
case TIMEOUT ->
{
if (args != null)
{
String durationStr = args[1];
duration = FormatUtil.parseDuration(durationStr);
}
boolean isDurationValid = true;
if (duration == null) isDurationValid = false;
else
{
if (duration.compareTo(maxTimeoutDuration) > 0) isDurationValid = false;
if (minTimeoutDuration.compareTo(duration) > 0) isDurationValid = false;
}
if (duration == null || !isDurationValid)
{
// todo nicer looking with emojis
return new MessageResponse("Sorry, but the specified duration is invalid!", null);
}
punishmentAction = guild.timeoutFor(mentioned, duration);
}
}
} catch (RuntimeException ignored)
{
impossible = true;
}
if (punishmentAction == null)
impossible = true;
if (impossible)
{
// todo nicer looking with emojis
return new MessageResponse("Sorry, I couldn't " + punishmentTypeName + " " + mentioned.getAsMention() + "!",
null);
}
if (!reason.isEmpty() && !reasonBuilder.isEmpty())
punishmentAction.reason("[" + author.getAsTag() + "] " + reason);
try
{
punishmentAction.complete();
} catch (RuntimeException ignored)
{
// todo nicer looking with emojis
return new MessageResponse("Sorry, I couldn't " + punishmentTypeName + " " + mentioned.getAsMention() + "!",
null);
}
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setAuthor(author.getAsTag(), null, author.getAvatarUrl());
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle("User " + punishmentType.getPastTense());
embedBuilder.addField("\uD83D\uDC64 User", mentioned.getAsMention(), false);
embedBuilder.addField("✂️ By", author.getAsMention(), false);
if (duration != null)
embedBuilder.addField("⏱️ Duration", FormatUtil.getNiceDuration(duration), false);
if (reason.isEmpty())
reason = "*No reason specified*";
embedBuilder.addField("\uD83D\uDCD6 Reason", reason, false);
return new MessageResponse(null, embedBuilder.build());
}
public enum PunishmentType
{
KICK("kicked"),
BAN("banned"),
TIMEOUT("timed out"),
;
private final String pastTense;
PunishmentType(String pastTense)
{
this.pastTense = pastTense;
}
public String getPastTense()
{
return pastTense;
}
}
}

14
src/main/java/wtf/beatrice/hidekobot/commands/completer/ProfileImageCommandCompleter.java → src/main/java/wtf/beatrice/hidekobot/commands/completer/AvatarCommandCompleter.java
View File

@@ -10,28 +10,26 @@ import wtf.beatrice.hidekobot.objects.commands.SlashCommand;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
public class ProfileImageCommandCompleter extends SlashArgumentsCompleterImpl public class AvatarCommandCompleter extends SlashArgumentsCompleterImpl
{ {
public ProfileImageCommandCompleter(SlashCommand parentCommand) public AvatarCommandCompleter(SlashCommand parentCommand) {
{
super(parentCommand); super(parentCommand);
} }
@Override @Override
public void runCompletion(@NotNull CommandAutoCompleteInteractionEvent event) public void runCompletion(@NotNull CommandAutoCompleteInteractionEvent event) {
{ if(event.getFocusedOption().getName().equals("size"))
if (event.getFocusedOption().getName().equals("size"))
{ {
List<Command.Choice> options = new ArrayList<>(); List<Command.Choice> options = new ArrayList<>();
for (int res : Cache.getSupportedAvatarResolutions()) for(int res : Cache.getSupportedAvatarResolutions())
{ {
String resString = String.valueOf(res); String resString = String.valueOf(res);
String userInput = event.getFocusedOption().getValue(); String userInput = event.getFocusedOption().getValue();
if (resString.startsWith(userInput)) if(resString.startsWith(userInput))
options.add(new Command.Choice(resString, res)); options.add(new Command.Choice(resString, res));
} }

84
src/main/java/wtf/beatrice/hidekobot/commands/message/AliasCommand.java
View File

@@ -1,84 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.Alias;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class AliasCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Arrays.asList("alias", "aliases"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null; // anyone can use it
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.TOOLS;
}
@NotNull
@Override
public String getDescription()
{
return "See other command aliases.";
}
@Nullable
@Override
public String getUsage()
{
return "<command>";
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
if (args.length == 0)
{
event.getMessage().reply("\uD83D\uDE20 Hey, you have to specify a command!").queue();
return;
}
String commandLabel = args[0].toLowerCase();
MessageCommand command = Cache.getMessageCommandListener().getRegisteredCommand(commandLabel);
if (command == null)
{
event.getMessage().reply("Unrecognized command: `" + commandLabel + "`!").queue(); // todo prettier
return;
}
String aliases = Alias.generateNiceAliases(command);
aliases = "Aliases for **" + command.getCommandLabels().get(0) + "**: " + aliases;
event.getMessage()
.reply(aliases)
.queue();
}
}

72
src/main/java/wtf/beatrice/hidekobot/commands/message/AvatarCommand.java
View File

@@ -1,94 +1,68 @@
package wtf.beatrice.hidekobot.commands.message; package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.IMentionable;
import net.dv8tion.jda.api.entities.Mentions; import net.dv8tion.jda.api.entities.Mentions;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User; import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot; import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.commands.base.ProfileImage; import wtf.beatrice.hidekobot.commands.base.Avatar;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Collections; import java.util.Collections;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
public class AvatarCommand implements MessageCommand public class AvatarCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{
return new LinkedList<>(Collections.singletonList("avatar")); return new LinkedList<>(Collections.singletonList("avatar"));
} }
@Nullable @Nullable
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() {
{
return null; // anyone can use it return null; // anyone can use it
} }
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return false; return false;
} }
@NotNull
@Override
public String getDescription()
{
return "Get someone's avatar, or your own. You can additionally specify a resolution.";
}
@Nullable
@Override
public String getUsage()
{
return "[mentioned user] [resolution]";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.TOOLS;
}
@Override @Override
public void runCommand(MessageReceivedEvent event, String label, String[] args) public void runCommand(MessageReceivedEvent event, String label, String[] args)
{ {
User user; int[] acceptedSizes = Cache.getSupportedAvatarResolutions();
User user = null;
int resolution = -1; int resolution = -1;
// we have no specific order for user and resolution, so let's try parsing any arg as resolution // we have no specific order for user and resolution, so let's try parsing any arg as resolution
// (mentions are handled differently by a specific method) // (mentions are handled differently by a specific method)
boolean resFound = false; boolean resFound = false;
for (String arg : args) for (String arg : args) {
{ try {
try
{
int givenRes = Integer.parseInt(arg); int givenRes = Integer.parseInt(arg);
resolution = ProfileImage.parseResolution(givenRes); resolution = Avatar.parseResolution(givenRes);
resFound = true; resFound = true;
break; break;
} catch (NumberFormatException ignored) } catch (NumberFormatException ignored) {
{
// ignored because we're running a check after this block
} }
} }
// fallback in case we didn't find any specified resolution // fallback in case we didn't find any specified resolution
if (!resFound) resolution = ProfileImage.parseResolution(512); if(!resFound) resolution = Avatar.parseResolution(512);
// check if someone is mentioned // check if someone is mentioned
Mentions mentions = event.getMessage().getMentions(); Mentions mentions = event.getMessage().getMentions();
if (mentions.getMentions().isEmpty()) if(mentions.getMentions().isEmpty())
{ {
user = event.getAuthor(); user = event.getAuthor();
} else } else
@@ -98,16 +72,10 @@ public class AvatarCommand implements MessageCommand
} }
// in case of issues, fallback to the sender // in case of issues, fallback to the sender
if (user == null) user = event.getAuthor(); if(user == null) user = event.getAuthor();
// send a response // send a response
MessageResponse response = ProfileImage.buildResponse(resolution, user, ProfileImage.ImageType.AVATAR); MessageEmbed embed = Avatar.buildEmbed(resolution, user);
if (response.content() != null) event.getMessage().replyEmbeds(embed).queue();
{
event.getMessage().reply(response.content()).queue();
} else if (response.embed() != null)
{
event.getMessage().replyEmbeds(response.embed()).queue();
}
} }
} }

64
src/main/java/wtf/beatrice/hidekobot/commands/message/BanCommand.java
View File

@@ -1,64 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.UserPunishment;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class BanCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Collections.singletonList("ban"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return new ArrayList<Permission>(Collections.singletonList(Permission.BAN_MEMBERS));
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.MODERATION;
}
@NotNull
@Override
public String getDescription()
{
return "Ban the mentioned user.";
}
@Nullable
@Override
public String getUsage()
{
return "<mentioned user> [reason]";
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
UserPunishment.handle(event, args, UserPunishment.PunishmentType.BAN);
}
}

113
src/main/java/wtf/beatrice/hidekobot/commands/message/BannerCommand.java
View File

@@ -1,113 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.Mentions;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.commands.base.ProfileImage;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class BannerCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Collections.singletonList("banner"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null; // anyone can use it
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public String getDescription()
{
return "Get someone's profile banner, or your own.";
}
@Nullable
@Override
public String getUsage()
{
return "[mentioned user] [resolution]";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.TOOLS;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
User user;
int resolution = -1;
// we have no specific order for user and resolution, so let's try parsing any arg as resolution
// (mentions are handled differently by a specific method)
boolean resFound = false;
for (String arg : args)
{
try
{
int givenRes = Integer.parseInt(arg);
resolution = ProfileImage.parseResolution(givenRes);
resFound = true;
break;
} catch (NumberFormatException ignored)
{
// ignored because we're running a check after this block
}
}
// fallback in case we didn't find any specified resolution
if (!resFound) resolution = ProfileImage.parseResolution(512);
// check if someone is mentioned
Mentions mentions = event.getMessage().getMentions();
if (mentions.getMentions().isEmpty())
{
user = event.getAuthor();
} else
{
String mentionedId = mentions.getMentions().get(0).getId();
user = HidekoBot.getAPI().retrieveUserById(mentionedId).complete();
}
// in case of issues, fallback to the sender
if (user == null) user = event.getAuthor();
// send a response
MessageResponse response = ProfileImage.buildResponse(resolution, user, ProfileImage.ImageType.BANNER);
if (response.content() != null)
{
event.getMessage().reply(response.content()).queue();
} else if (response.embed() != null)
{
event.getMessage().replyEmbeds(response.embed()).queue();
}
}
}

42
src/main/java/wtf/beatrice/hidekobot/commands/message/BotInfoCommand.java
View File

@@ -3,14 +3,12 @@ package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.MessageEmbed; import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.Cache; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.BotInfo; import wtf.beatrice.hidekobot.commands.base.BotInfo;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Arrays; import java.util.Collections;
import java.util.LinkedList; import java.util.LinkedList;
import java.util.List; import java.util.List;
@@ -18,54 +16,28 @@ public class BotInfoCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{ return new LinkedList<>(Collections.singletonList("botinfo"));
return new LinkedList<>(Arrays.asList("botinfo", "info"));
} }
@Nullable @Nullable
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() {
{
return null; // anyone can use it return null; // anyone can use it
} }
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return false; return false;
} }
@NotNull
@Override @Override
public String getDescription() public void runCommand(MessageReceivedEvent event, String label, String[] args) {
{
return "Get general info about the bot.";
}
@Nullable
@Override
public String getUsage()
{
return null;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.TOOLS;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
// get a list of message commands // get a list of message commands
LinkedList<MessageCommand> messageCommands = Cache.getMessageCommandListener().getRegisteredCommands(); LinkedList<MessageCommand> messageCommands = Cache.getMessageCommandListener().getRegisteredCommands();
LinkedList<String> commandNames = new LinkedList<>(); LinkedList<String> commandNames = new LinkedList<>();
for (MessageCommand command : messageCommands) for (MessageCommand command : messageCommands) {
{
commandNames.add(command.getCommandLabels().get(0)); commandNames.add(command.getCommandLabels().get(0));
} }

49
src/main/java/wtf/beatrice/hidekobot/commands/message/ClearCommand.java
View File

@@ -4,11 +4,8 @@ import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.Message; import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.interactions.components.buttons.Button; import net.dv8tion.jda.api.interactions.components.buttons.Button;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.Cache; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.ClearChat; import wtf.beatrice.hidekobot.commands.base.ClearChat;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Collections; import java.util.Collections;
@@ -19,51 +16,26 @@ public class ClearCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{
return new LinkedList<>(Collections.singletonList(ClearChat.getLabel())); return new LinkedList<>(Collections.singletonList(ClearChat.getLabel()));
} }
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() { return Collections.singletonList(ClearChat.getPermission()); }
{
return Collections.singletonList(ClearChat.getPermission());
}
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return false; return false;
} }
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.MODERATION;
}
@NotNull
@Override
public String getDescription()
{
return "Clear the current channel's chat history.";
}
@Nullable
@Override
public String getUsage()
{
return "[amount]";
}
@Override @Override
public void runCommand(MessageReceivedEvent event, String label, String[] args) public void runCommand(MessageReceivedEvent event, String label, String[] args)
{ {
String senderId = event.getMessage().getAuthor().getId();
// check if user is trying to run command in dms. // check if user is trying to run command in dms.
String error = ClearChat.checkDMs(event.getChannel()); String error = ClearChat.checkDMs(event.getChannel());
if (error != null) if (error != null) {
{
event.getMessage().reply(error).queue(); event.getMessage().reply(error).queue();
return; return;
} }
@@ -73,8 +45,7 @@ public class ClearCommand implements MessageCommand
if (args.length == 0) toDeleteAmount = 1; if (args.length == 0) toDeleteAmount = 1;
else else
{ {
try try {
{
toDeleteAmount = Integer.parseInt(args[0]); toDeleteAmount = Integer.parseInt(args[0]);
} catch (NumberFormatException e) } catch (NumberFormatException e)
{ {
@@ -82,12 +53,8 @@ public class ClearCommand implements MessageCommand
} }
} }
// cap the amount to avoid abuse.
if (toDeleteAmount > ClearChat.getMaxAmount()) toDeleteAmount = 0;
error = ClearChat.checkDeleteAmount(toDeleteAmount); error = ClearChat.checkDeleteAmount(toDeleteAmount);
if (error != null) if (error != null) {
{
event.getMessage().reply(error).queue(); event.getMessage().reply(error).queue();
return; return;
} }

38
src/main/java/wtf/beatrice/hidekobot/commands/message/CoinFlipCommand.java
View File

@@ -2,10 +2,8 @@ package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.CoinFlip; import wtf.beatrice.hidekobot.commands.base.CoinFlip;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Arrays; import java.util.Arrays;
@@ -16,48 +14,23 @@ public class CoinFlipCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{
return new LinkedList<>(Arrays.asList("coinflip", "flip", "flipcoin")); return new LinkedList<>(Arrays.asList("coinflip", "flip", "flipcoin"));
} }
@Nullable @Nullable
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() {
{
return null; // null because it can be used anywhere return null; // null because it can be used anywhere
} }
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return false; return false;
} }
@NotNull
@Override @Override
public String getDescription() public void runCommand(MessageReceivedEvent event, String label, String[] args) {
{
return "Flip a coin.";
}
@Nullable
@Override
public String getUsage()
{
return null;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
// perform coin flip // perform coin flip
event.getMessage().reply(CoinFlip.genRandom()) event.getMessage().reply(CoinFlip.genRandom())
@@ -66,7 +39,6 @@ public class CoinFlipCommand implements MessageCommand
{ {
// set the command as expiring and restrict it to the user who ran it // set the command as expiring and restrict it to the user who ran it
CoinFlip.trackAndRestrict(message, event.getAuthor()); CoinFlip.trackAndRestrict(message, event.getAuthor());
}, (error) -> { }, (error) -> {});
});
} }
} }

181
src/main/java/wtf/beatrice/hidekobot/commands/message/DiceRollCommand.java
View File

@@ -2,80 +2,127 @@ package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.DiceRoll; import wtf.beatrice.hidekobot.objects.Dice;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Arrays; import java.util.*;
import java.util.LinkedList;
import java.util.List;
public class DiceRollCommand implements MessageCommand public class DiceRollCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{ return new LinkedList<>(Arrays.asList("diceroll", "droll", "roll"));
return new LinkedList<>(Arrays.asList("diceroll", "droll", "roll"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null; // anyone can use it
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public String getDescription()
{
return """
Roll dice. You can roll multiple dice at the same time.
Examples:
- `d8 10` to roll an 8-sided die 10 times.
- `d12 3 d5 10` to roll a 12-sided die 3 times, and then a 5-sided die 10 times.
- `30` to roll a standard 6-sided die 30 times.
- `d10` to roll a 10-sided die once.
""";
}
@Nullable
@Override
public String getUsage()
{
return "[dice size] [rolls]";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
MessageResponse response = DiceRoll.buildResponse(event.getAuthor(), args);
if (response.content() != null)
{
event.getMessage().reply(response.content()).queue();
} else if (response.embed() != null)
{
event.getMessage().replyEmbeds(response.embed()).queue();
} }
} @Nullable
@Override
public List<Permission> getPermissions() {
return null; // anyone can use it
}
@Override
public boolean passRawArgs() {
return false;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
LinkedHashMap<Dice, Integer> dicesToRoll = new LinkedHashMap<Dice, Integer>();
String diceRegex = "d[0-9]+";
String amountRegex = "[0-9]+";
Dice currentDice = null;
int currentAmount;
UUID lastPushedDice = null;
for(String arg : args)
{
if(arg.matches(amountRegex))
{
currentAmount = Integer.parseInt(arg);
if(currentDice == null)
{
currentDice = new Dice(6);
} else {
currentDice = new Dice(currentDice);
}
lastPushedDice = currentDice.getUUID();
dicesToRoll.put(currentDice, currentAmount);
}
else if(arg.matches(diceRegex))
{
int sides = Integer.parseInt(arg.substring(1));
if(args.length == 1)
{
dicesToRoll.put(new Dice(sides), 1);
} else
{
if(currentDice != null)
{
if(lastPushedDice == null || !lastPushedDice.equals(currentDice.getUUID()))
{
dicesToRoll.put(currentDice, 1);
lastPushedDice = currentDice.getUUID();
}
}
currentDice = new Dice(sides);
}
}
}
if(lastPushedDice == null)
{
if(currentDice != null)
{
dicesToRoll.put(currentDice, 1);
}
} else
{
if(!lastPushedDice.equals(currentDice.getUUID()))
{
dicesToRoll.put(new Dice(currentDice), 1);
}
}
LinkedList<Dice> rolledDices = new LinkedList<>();
for(Dice dice : dicesToRoll.keySet())
{
for(int roll = 0; roll < dicesToRoll.get(dice); roll++)
{
dice.roll();
rolledDices.add(new Dice(dice));
}
}
StringBuilder message = new StringBuilder();
int total = 0;
int previousDiceSides = 0;
for (Dice dice : rolledDices) {
int diceSize = dice.getSides();
if (previousDiceSides != diceSize) {
message.append("\nd").append(diceSize).append(": ");
previousDiceSides = diceSize;
} else if (previousDiceSides != 0) {
message.append(", ");
}
message.append(dice.getValue());
total += dice.getValue();
}
message.append("\n\n").append("**Total**: ").append(total);
event.getMessage().reply(message.toString()).queue();
}
} }

39
src/main/java/wtf/beatrice/hidekobot/commands/message/HelloCommand.java
View File

@@ -2,9 +2,6 @@ package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Arrays; import java.util.Arrays;
@@ -15,49 +12,23 @@ public class HelloCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{
return new LinkedList<>(Arrays.asList("hi", "hello", "heya")); return new LinkedList<>(Arrays.asList("hi", "hello", "heya"));
} }
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() { return null; }
{
return null;
}
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return false; return false;
} }
@NotNull
@Override
public String getDescription()
{
return "Get pinged by the bot.";
}
@Nullable
@Override
public String getUsage()
{
return null;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@Override @Override
public void runCommand(MessageReceivedEvent event, String label, String[] args) public void runCommand(MessageReceivedEvent event, String label, String[] args)
{ {
String sender = event.getMessage().getAuthor().getAsMention(); String senderId = event.getMessage().getAuthor().getId();
event.getMessage().reply("Hi, " + sender + "! :sparkles:").queue(); event.getMessage().reply("Hi, <@" + senderId + ">! :sparkles:").queue();
} }
} }

165
src/main/java/wtf/beatrice/hidekobot/commands/message/HelpCommand.java
View File

@@ -1,165 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.apache.commons.text.WordUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.Alias;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.*;
public class HelpCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Collections.singletonList("help"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null;
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public String getDescription()
{
return "Get general help on the bot. Specify a command if you want specific help about that command.";
}
@Nullable
@Override
public String getUsage()
{
return "[command]";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.TOOLS;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
LinkedHashMap<CommandCategory, LinkedList<MessageCommand>> commandCategories = new LinkedHashMap<>();
if (args.length == 0)
{
for (CommandCategory category : CommandCategory.values())
{
LinkedList<MessageCommand> commandsOfThisCategory = new LinkedList<>();
for (MessageCommand command : Cache.getMessageCommandListener().getRegisteredCommands())
{
if (command.getCategory().equals(category))
{
commandsOfThisCategory.add(command);
}
}
commandCategories.put(category, commandsOfThisCategory);
}
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle("Bot Help");
embedBuilder.addField("General Help",
"Type `" + Cache.getBotPrefix() + " help [command]` to get help on a specific command." +
"\nYou will find a list of commands organized in categories below.",
false);
for (Map.Entry<CommandCategory, LinkedList<MessageCommand>> entry : commandCategories.entrySet())
{
StringBuilder commandsList = new StringBuilder();
CommandCategory category = entry.getKey();
LinkedList<MessageCommand> commandsOfThisCategory = entry.getValue();
for (int pos = 0; pos < commandsOfThisCategory.size(); pos++)
{
MessageCommand command = commandsOfThisCategory.get(pos);
commandsList.append("`").append(command.getCommandLabels().get(0)).append("`");
if (pos + 1 != commandsOfThisCategory.size())
commandsList.append(", "); // separate with comma except on last run
}
String niceCategoryName = category.name().replace("_", " ");
niceCategoryName = WordUtils.capitalizeFully(niceCategoryName);
niceCategoryName = category.getEmoji() + " " + niceCategoryName;
embedBuilder.addField(niceCategoryName, commandsList.toString(), false);
}
event.getMessage().replyEmbeds(embedBuilder.build()).queue();
} else
{
String commandLabel = args[0].toLowerCase();
MessageCommand command = Cache.getMessageCommandListener().getRegisteredCommand(commandLabel);
if (command == null)
{
event.getMessage().reply("Unrecognized command: `" + commandLabel + "`!").queue(); // todo prettier
return;
}
commandLabel = command.getCommandLabels().get(0);
String usage = "`" + Cache.getBotPrefix() + " " + commandLabel;
String internalUsage = command.getUsage();
if (internalUsage != null) usage += " " + internalUsage;
usage += "`";
String aliases = Alias.generateNiceAliases(command);
List<Permission> permissions = command.getPermissions();
StringBuilder permissionsStringBuilder = new StringBuilder();
if (permissions == null)
{
permissionsStringBuilder = new StringBuilder("Available to everyone");
} else
{
for (int i = 0; i < permissions.size(); i++)
{
Permission permission = permissions.get(i);
permissionsStringBuilder.append("**").append(permission.getName()).append("**");
if (i + 1 != permissions.size())
permissionsStringBuilder.append(", "); // separate with comma expect on last iteration
}
}
String title = command.getCategory().getEmoji() +
" \"" + WordUtils.capitalizeFully(commandLabel + "\" help");
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle(title);
embedBuilder.addField("Description", command.getDescription(), false);
embedBuilder.addField("Usage", usage, false);
embedBuilder.addField("Aliases", aliases, false);
embedBuilder.addField("Permissions", permissionsStringBuilder.toString(), false);
event.getMessage().replyEmbeds(embedBuilder.build()).queue();
}
}
}

41
src/main/java/wtf/beatrice/hidekobot/commands/message/InviteCommand.java
View File

@@ -5,10 +5,8 @@ import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.emoji.Emoji; import net.dv8tion.jda.api.entities.emoji.Emoji;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.interactions.components.buttons.Button; import net.dv8tion.jda.api.interactions.components.buttons.Button;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.Invite; import wtf.beatrice.hidekobot.commands.base.Invite;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Collections; import java.util.Collections;
@@ -19,45 +17,21 @@ public class InviteCommand implements MessageCommand
{ {
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{
return new LinkedList<>(Collections.singletonList("invite")); return new LinkedList<>(Collections.singletonList("invite"));
} }
@Nullable @Nullable
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() {
{
return null; return null;
} }
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return false; return false;
} }
@NotNull
@Override
public String getDescription()
{
return "Get the bot's invite link.";
}
@Nullable
@Override
public String getUsage()
{
return null;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.MODERATION;
}
@Override @Override
public void runCommand(MessageReceivedEvent event, String label, String[] args) public void runCommand(MessageReceivedEvent event, String label, String[] args)
{ {
@@ -67,7 +41,7 @@ public class InviteCommand implements MessageCommand
Button inviteButton = Invite.getInviteButton(); Button inviteButton = Invite.getInviteButton();
// if this is a guild, don't spam the invite in public but DM it // if this is a guild, don't spam the invite in public but DM it
if (event.getChannelType().isGuild()) if(event.getChannelType().isGuild())
{ {
event.getAuthor().openPrivateChannel().queue(privateChannel -> event.getAuthor().openPrivateChannel().queue(privateChannel ->
{ {
@@ -75,9 +49,10 @@ public class InviteCommand implements MessageCommand
.addActionRow(inviteButton) .addActionRow(inviteButton)
.queue(); .queue();
event.getMessage().addReaction(Emoji.fromUnicode("✅")).queue(); event.getMessage().addReaction(Emoji.fromUnicode("✅")).queue();
}, error -> event.getMessage().addReaction(Emoji.fromUnicode("❌")).queue()); }, (error) -> {
} else event.getMessage().addReaction(Emoji.fromUnicode("❌")).queue();
{ });
} else {
event.getMessage() event.getMessage()
.replyEmbeds(inviteEmbed) .replyEmbeds(inviteEmbed)
.addActionRow(inviteButton) .addActionRow(inviteButton)

64
src/main/java/wtf/beatrice/hidekobot/commands/message/KickCommand.java
View File

@@ -1,64 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.UserPunishment;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class KickCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Collections.singletonList("kick"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return new ArrayList<Permission>(Collections.singletonList(Permission.KICK_MEMBERS));
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.MODERATION;
}
@NotNull
@Override
public String getDescription()
{
return "Kick the mentioned user from the guild.";
}
@Nullable
@Override
public String getUsage()
{
return "<mentioned user> [reason]";
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
UserPunishment.handle(event, args, UserPunishment.PunishmentType.KICK);
}
}

98
src/main/java/wtf/beatrice/hidekobot/commands/message/LoveCalculatorCommand.java
View File

@@ -1,98 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.IMentionable;
import net.dv8tion.jda.api.entities.Mentions;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.commands.base.LoveCalculator;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class LoveCalculatorCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Arrays.asList("lovecalc", "lovecalculator", "lc"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null; //anyone can use it
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public String getDescription()
{
return "Calculate how much two people love each other. You can mention two people or just one.";
}
@Nullable
@Override
public String getUsage()
{
return "<person 1> [person 2]";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
Mentions mentionsObj = event.getMessage().getMentions();
List<IMentionable> mentions = mentionsObj.getMentions();
if (args.length == 0 || mentions.isEmpty())
{
event.getMessage()
.reply("\uD83D\uDE22 I need to know who to check! Please mention them.")
.queue();
return;
}
User user1, user2;
String mentionedUserId = mentions.get(0).getId();
user1 = HidekoBot.getAPI().retrieveUserById(mentionedUserId).complete();
if (mentions.size() == 1)
{
user2 = event.getAuthor();
} else
{
mentionedUserId = mentions.get(1).getId();
user2 = HidekoBot.getAPI().retrieveUserById(mentionedUserId).complete();
}
MessageEmbed embed = LoveCalculator.buildEmbedAndCacheResult(event.getAuthor(), user1, user2);
event.getChannel().sendMessageEmbeds(embed).queue();
}
}

80
src/main/java/wtf/beatrice/hidekobot/commands/message/MagicBallCommand.java
View File

@@ -1,80 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.MagicBall;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.LinkedList;
import java.util.List;
public class MagicBallCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return MagicBall.getLabels();
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null; // anyone can use it
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public String getDescription()
{
return "Ask a question to the Magic Ball.";
}
@Nullable
@Override
public String getUsage()
{
return "<question>";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
if (args.length == 0)
{
event.getMessage().reply("You need to specify a question!").queue();
return;
}
StringBuilder questionBuilder = new StringBuilder();
for (int i = 0; i < args.length; i++)
{
String arg = args[i];
questionBuilder.append(arg);
if (i + 1 != args.length) // don't add a separator on the last iteration
questionBuilder.append(" ");
}
String question = questionBuilder.toString();
event.getChannel().sendMessageEmbeds(MagicBall.generateEmbed(question, event.getAuthor())).queue();
}
}

52
src/main/java/wtf/beatrice/hidekobot/commands/message/SayCommand.java
View File

@@ -1,12 +1,11 @@
package wtf.beatrice.hidekobot.commands.message; package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.channel.concrete.TextChannel; import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.ClearChat;
import wtf.beatrice.hidekobot.commands.base.Say; import wtf.beatrice.hidekobot.commands.base.Say;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Collections; import java.util.Collections;
@@ -18,70 +17,35 @@ public class SayCommand implements MessageCommand
@Override @Override
public LinkedList<String> getCommandLabels() public LinkedList<String> getCommandLabels() {
{
return new LinkedList<>(Collections.singletonList("say")); return new LinkedList<>(Collections.singletonList("say"));
} }
@Nullable @Nullable
@Override @Override
public List<Permission> getPermissions() public List<Permission> getPermissions() { return Collections.singletonList(Say.getPermission()); }
{
return Collections.singletonList(Say.getPermission());
}
@Override @Override
public boolean passRawArgs() public boolean passRawArgs() {
{
return true; return true;
} }
@NotNull
@Override
public String getDescription()
{
return "Make the bot say something for you.";
}
@Nullable
@Override
public String getUsage()
{
return "<text>";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.TOOLS;
}
@Override @Override
public void runCommand(MessageReceivedEvent event, String label, String[] args) public void runCommand(MessageReceivedEvent event, String label, String[] args)
{ {
String messageContent; String messageContent;
if (args.length != 0 && !args[0].isEmpty()) if(args.length != 0 && !args[0].isEmpty())
{ {
messageContent = args[0]; messageContent = args[0];
} else } else {
{
event.getMessage().reply("\uD83D\uDE20 Hey, you have to tell me what to say!") event.getMessage().reply("\uD83D\uDE20 Hey, you have to tell me what to say!")
.queue(); .queue();
return; return;
} }
event.getChannel().sendMessage(messageContent).queue(); event.getChannel().sendMessage(messageContent).queue();
event.getMessage().delete().queue();
if (event.getChannel() instanceof TextChannel)
{
event.getMessage().delete().queue(response -> {
// nothing to do with the response
}, error -> {
// ignore the error if we couldn't delete it, we were probably missing permissions
// without this block it would print a stack trace in console
});
}
} }
} }

64
src/main/java/wtf/beatrice/hidekobot/commands/message/TimeoutCommand.java
View File

@@ -1,64 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.commands.base.UserPunishment;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
public class TimeoutCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Collections.singletonList("timeout"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return new ArrayList<Permission>(Collections.singletonList(Permission.MODERATE_MEMBERS));
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.MODERATION;
}
@NotNull
@Override
public String getDescription()
{
return "Timeout the mentioned user.";
}
@Nullable
@Override
public String getUsage()
{
return "<mentioned user> <duration> [reason]";
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
UserPunishment.handle(event, args, UserPunishment.PunishmentType.TIMEOUT);
}
}

104
src/main/java/wtf/beatrice/hidekobot/commands/message/TriviaCommand.java
View File

@@ -1,104 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.requests.restaction.MessageCreateAction;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.Trivia;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.TimeUnit;
public class TriviaCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return new LinkedList<>(Collections.singletonList("trivia"));
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null;
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@NotNull
@Override
public String getDescription()
{
return "Start a Trivia session and play with others!";
}
@Nullable
@Override
public String getUsage()
{
return null;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
MessageChannel channel = event.getChannel();
if (!(channel instanceof TextChannel))
{
channel.sendMessage(Trivia.getNoDMsError()).queue();
return;
}
if (Trivia.channelsRunningTrivia.contains(channel.getId()))
{
// todo: also what if the bot stops (database...?)
// todo: also what if the message is already deleted
Message err = event.getMessage().reply(Trivia.getTriviaAlreadyRunningError()).complete();
Cache.getTaskScheduler().schedule(() -> err.delete().queue(), 10, TimeUnit.SECONDS);
return;
}
MessageResponse response = Trivia.generateMainScreen();
Message recvMessage = event.getMessage();
MessageCreateAction responseAction = null;
if (response.content() != null) responseAction = recvMessage.reply(response.content());
else if (response.embed() != null) responseAction = recvMessage.replyEmbeds(response.embed());
if (responseAction != null)
{
if (response.components() != null) responseAction = responseAction.addActionRow(response.components());
responseAction.queue(message -> {
Cache.getDatabaseSource().trackRanCommandReply(message, event.getAuthor());
Cache.getDatabaseSource().queueDisabling(message);
});
}
}
}

115
src/main/java/wtf/beatrice/hidekobot/commands/message/UrbanDictionaryCommand.java
View File

@@ -1,115 +0,0 @@
package wtf.beatrice.hidekobot.commands.message;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.interactions.components.buttons.Button;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;
import wtf.beatrice.hidekobot.commands.base.UrbanDictionary;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import java.io.IOException;
import java.util.LinkedList;
import java.util.List;
public class UrbanDictionaryCommand implements MessageCommand
{
@Override
public LinkedList<String> getCommandLabels()
{
return UrbanDictionary.getCommandLabels();
}
@Nullable
@Override
public List<Permission> getPermissions()
{
return null; //anyone can use it
}
@Override
public boolean passRawArgs()
{
return false;
}
@NotNull
@Override
public String getDescription()
{
return "Look something up in the Urban Dictionary.";
}
@Nullable
@Override
public String getUsage()
{
return "<query>";
}
@NotNull
@Override
public CommandCategory getCategory()
{
return CommandCategory.FUN;
}
@Override
public void runCommand(MessageReceivedEvent event, String label, String[] args)
{
if (args.length == 0)
{
event.getMessage().reply(UrbanDictionary.getNoArgsError()).queue();
return;
}
// sanitize args by only keeping letters and numbers, and adding "+" instead of spaces for HTML parsing
StringBuilder termBuilder = new StringBuilder();
for (int i = 0; i < args.length; i++)
{
String arg = args[i];
termBuilder.append(arg);
if (i + 1 != args.length) // add spaces between args, but not on the last run
termBuilder.append(" ");
}
String term = UrbanDictionary.sanitizeArgs(termBuilder.toString(), false);
String url = UrbanDictionary.generateUrl(term);
Document doc;
try
{
doc = Jsoup.connect(url).get();
} catch (IOException e)
{
event.getMessage().reply(UrbanDictionary.getTermNotFoundError()).queue();
return;
}
Elements definitions = doc.getElementsByClass("definition");
UrbanDictionary.UrbanSearch search = new UrbanDictionary.UrbanSearch(definitions);
MessageEmbed embed = UrbanDictionary.buildEmbed(term, url, event.getAuthor(), search, 0);
// disable next page if we only have one result
Button nextPageBtnLocal = UrbanDictionary.getNextPageButton();
if (search.getPages() == 1) nextPageBtnLocal = nextPageBtnLocal.asDisabled();
event.getChannel()
.sendMessageEmbeds(embed)
.addActionRow(UrbanDictionary.getPreviousPageButton().asDisabled(),
//disabled by default because we're on page 0
nextPageBtnLocal,
UrbanDictionary.getDeleteButton())
.queue(message -> UrbanDictionary.track(message, event.getAuthor(), search, term));
}
}

33
src/main/java/wtf/beatrice/hidekobot/commands/slash/AvatarCommand.java
View File

@@ -1,5 +1,7 @@
package wtf.beatrice.hidekobot.commands.slash; package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User; import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent; import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping; import net.dv8tion.jda.api.interactions.commands.OptionMapping;
@@ -7,15 +9,14 @@ import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData; import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands; import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.ProfileImage; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.objects.MessageResponse; import wtf.beatrice.hidekobot.commands.base.Avatar;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl; import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class AvatarCommand extends SlashCommandImpl public class AvatarCommand extends SlashCommandImpl
{ {
@Override @Override
public CommandData getSlashCommandData() public CommandData getSlashCommandData() {
{
return Commands.slash("avatar", "Get someone's profile picture.") return Commands.slash("avatar", "Get someone's profile picture.")
.addOption(OptionType.USER, "user", "User you want to grab the avatar of.") .addOption(OptionType.USER, "user", "User you want to grab the avatar of.")
.addOption(OptionType.INTEGER, "size", "The size of the returned image.", .addOption(OptionType.INTEGER, "size", "The size of the returned image.",
@@ -33,30 +34,22 @@ public class AvatarCommand extends SlashCommandImpl
int resolution; int resolution;
OptionMapping userArg = event.getOption("user"); OptionMapping userArg = event.getOption("user");
if (userArg != null) if(userArg != null)
{ {
user = userArg.getAsUser(); user = userArg.getAsUser();
} else } else {
{
user = event.getUser(); user = event.getUser();
} }
OptionMapping sizeArg = event.getOption("size"); OptionMapping sizeArg = event.getOption("size");
if (sizeArg != null) if(sizeArg != null)
{ {
resolution = ProfileImage.parseResolution(sizeArg.getAsInt()); resolution = Avatar.parseResolution(sizeArg.getAsInt());
} else } else {
{ resolution = Avatar.parseResolution(512);
resolution = ProfileImage.parseResolution(512);
} }
MessageResponse response = ProfileImage.buildResponse(resolution, user, ProfileImage.ImageType.AVATAR); MessageEmbed embed = Avatar.buildEmbed(resolution, user);
if (response.content() != null) event.getHook().editOriginalEmbeds(embed).queue();
{
event.getHook().editOriginal(response.content()).queue();
} else if (response.embed() != null)
{
event.getHook().editOriginalEmbeds(response.embed()).queue();
}
} }
} }

36
src/main/java/wtf/beatrice/hidekobot/commands/slash/BanCommand.java
View File

@@ -1,36 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.DefaultMemberPermissions;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.UserPunishment;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class BanCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("ban", "Ban someone from the guild.")
.addOption(OptionType.MENTIONABLE, "target",
"The member user to ban.",
true,
false)
.addOption(OptionType.STRING, "reason",
"The reason for the punishment.",
false,
false)
.setDefaultPermissions(DefaultMemberPermissions.enabledFor(Permission.BAN_MEMBERS));
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
UserPunishment.handle(event, UserPunishment.PunishmentType.BAN);
}
}

62
src/main/java/wtf/beatrice/hidekobot/commands/slash/BannerCommand.java
View File

@@ -1,62 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.ProfileImage;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class BannerCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("banner", "Get someone's profile banner.")
.addOption(OptionType.USER, "user", "User you want to grab the banner of.")
.addOption(OptionType.INTEGER, "size", "The size of the returned image.",
false,
true);
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
// defer reply because this might take a moment
event.deferReply().queue();
User user;
int resolution;
OptionMapping userArg = event.getOption("user");
if (userArg != null)
{
user = userArg.getAsUser();
} else
{
user = event.getUser();
}
OptionMapping sizeArg = event.getOption("size");
if (sizeArg != null)
{
resolution = ProfileImage.parseResolution(sizeArg.getAsInt());
} else
{
resolution = ProfileImage.parseResolution(512);
}
MessageResponse response = ProfileImage.buildResponse(resolution, user, ProfileImage.ImageType.BANNER);
if (response.content() != null)
{
event.getHook().editOriginal(response.content()).queue();
} else if (response.embed() != null)
{
event.getHook().editOriginalEmbeds(response.embed()).queue();
}
}
}

5
src/main/java/wtf/beatrice/hidekobot/commands/slash/BotInfoCommand.java
View File

@@ -16,8 +16,7 @@ import java.util.List;
public class BotInfoCommand extends SlashCommandImpl public class BotInfoCommand extends SlashCommandImpl
{ {
@Override @Override
public CommandData getSlashCommandData() public CommandData getSlashCommandData() {
{
return Commands.slash("botinfo", "Get info about the bot."); return Commands.slash("botinfo", "Get info about the bot.");
} }
@@ -30,7 +29,7 @@ public class BotInfoCommand extends SlashCommandImpl
// get a list of slash commands // get a list of slash commands
List<SlashCommand> registeredCommands = Cache.getSlashCommandListener().getRegisteredCommands(); List<SlashCommand> registeredCommands = Cache.getSlashCommandListener().getRegisteredCommands();
LinkedList<String> registeredCommandNames = new LinkedList<>(); LinkedList<String> registeredCommandNames = new LinkedList<>();
for (SlashCommand command : registeredCommands) for(SlashCommand command : registeredCommands)
{ {
// node: adding slash so people realize that this is specific about slash commands. // node: adding slash so people realize that this is specific about slash commands.
registeredCommandNames.add("/" + command.getCommandName()); registeredCommandNames.add("/" + command.getCommandName());

10
src/main/java/wtf/beatrice/hidekobot/commands/slash/ClearCommand.java
View File

@@ -17,8 +17,7 @@ public class ClearCommand extends SlashCommandImpl
{ {
@Override @Override
public CommandData getSlashCommandData() public CommandData getSlashCommandData() {
{
return Commands.slash(ClearChat.getLabel(), return Commands.slash(ClearChat.getLabel(),
ClearChat.getDescription()) ClearChat.getDescription())
.addOption(OptionType.INTEGER, "amount", "The amount of messages to delete.") .addOption(OptionType.INTEGER, "amount", "The amount of messages to delete.")
@@ -33,7 +32,7 @@ public class ClearCommand extends SlashCommandImpl
// check if user is trying to run command in dms. // check if user is trying to run command in dms.
String error = ClearChat.checkDMs(event.getChannel()); String error = ClearChat.checkDMs(event.getChannel());
if (error != null) if(error != null)
{ {
event.getHook().editOriginal(error).queue(); event.getHook().editOriginal(error).queue();
return; return;
@@ -45,11 +44,8 @@ public class ClearCommand extends SlashCommandImpl
OptionMapping amountOption = event.getOption("amount"); OptionMapping amountOption = event.getOption("amount");
int toDeleteAmount = amountOption == null ? 1 : amountOption.getAsInt(); int toDeleteAmount = amountOption == null ? 1 : amountOption.getAsInt();
// cap the amount to avoid abuse.
if (toDeleteAmount > ClearChat.getMaxAmount()) toDeleteAmount = 0;
error = ClearChat.checkDeleteAmount(toDeleteAmount); error = ClearChat.checkDeleteAmount(toDeleteAmount);
if (error != null) if(error != null)
{ {
event.getHook().editOriginal(error).queue(); event.getHook().editOriginal(error).queue();
return; return;

9
src/main/java/wtf/beatrice/hidekobot/commands/slash/CoinFlipCommand.java
View File

@@ -29,11 +29,12 @@ public class CoinFlipCommand extends SlashCommandImpl
interaction.retrieveOriginal().queue((message) -> interaction.retrieveOriginal().queue((message) ->
{ {
CoinFlip.trackAndRestrict(message, event.getUser()); CoinFlip.trackAndRestrict(message, event.getUser());
}, (error) -> { }, (error) -> {});
}); }, (error) -> {});
}, (error) -> {
});
} }
} }

50
src/main/java/wtf/beatrice/hidekobot/commands/slash/DiceRollCommand.java
View File

@@ -1,50 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.DiceRoll;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class DiceRollCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("diceroll", "Roll dice. You can roll multiple dice at the same time.")
.addOption(OptionType.STRING, "query",
"The dice to roll.",
false,
false);
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
event.deferReply().queue();
OptionMapping textOption = event.getOption("query");
String messageContent = "";
if (textOption != null)
{
messageContent = textOption.getAsString();
}
String[] args = messageContent.split("\\s");
MessageResponse response = DiceRoll.buildResponse(event.getUser(), args);
if (response.content() != null)
{
event.getHook().editOriginal(response.content()).queue();
} else if (response.embed() != null)
{
event.getHook().editOriginalEmbeds(response.embed()).queue();
}
}
}

14
src/main/java/wtf/beatrice/hidekobot/commands/slash/DieCommand.java
View File

@@ -10,14 +10,12 @@ import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl; import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
public class DieCommand extends SlashCommandImpl public class DieCommand extends SlashCommandImpl
{ {
@Override @Override
public CommandData getSlashCommandData() public CommandData getSlashCommandData() {
{
return Commands.slash("die", "Stop the bot's process.") return Commands.slash("die", "Stop the bot's process.")
.setDefaultPermissions(DefaultMemberPermissions.DISABLED); .setDefaultPermissions(DefaultMemberPermissions.DISABLED);
} }
@@ -25,16 +23,12 @@ public class DieCommand extends SlashCommandImpl
@Override @Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event) public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{ {
if (Cache.getBotOwnerId() != event.getUser().getIdLong()) if(Cache.getBotOwnerId() != event.getUser().getIdLong())
{ {
event.reply("Sorry, only the bot owner can run this command!").setEphemeral(true).queue(); event.reply("Sorry, only the bot owner can run this command!").setEphemeral(true).queue();
} else } else {
{
event.reply("Going to sleep! Cya ✨").queue(); event.reply("Going to sleep! Cya ✨").queue();
try (ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor()) Executors.newSingleThreadScheduledExecutor().schedule(HidekoBot::shutdown, 3, TimeUnit.SECONDS);
{
executor.schedule(HidekoBot::shutdown, 3, TimeUnit.SECONDS);
}
} }
} }
} }

2
src/main/java/wtf/beatrice/hidekobot/commands/slash/InviteCommand.java
View File

@@ -30,7 +30,7 @@ public class InviteCommand extends SlashCommandImpl
ReplyCallbackAction replyCallbackAction = event.deferReply(); ReplyCallbackAction replyCallbackAction = event.deferReply();
// only make message permanent in DMs // only make message permanent in DMs
if (event.getChannelType() != ChannelType.PRIVATE) if(event.getChannelType() != ChannelType.PRIVATE)
{ {
replyCallbackAction = replyCallbackAction.setEphemeral(true); replyCallbackAction = replyCallbackAction.setEphemeral(true);
} }

36
src/main/java/wtf/beatrice/hidekobot/commands/slash/KickCommand.java
View File

@@ -1,36 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.DefaultMemberPermissions;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.UserPunishment;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class KickCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("kick", "Kick someone from the guild.")
.addOption(OptionType.MENTIONABLE, "target",
"The member user to kick.",
true,
false)
.addOption(OptionType.STRING, "reason",
"The reason for the punishment.",
false,
false)
.setDefaultPermissions(DefaultMemberPermissions.enabledFor(Permission.KICK_MEMBERS));
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
UserPunishment.handle(event, UserPunishment.PunishmentType.KICK);
}
}

63
src/main/java/wtf/beatrice/hidekobot/commands/slash/LoveCalculatorCommand.java
View File

@@ -1,63 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.LoveCalculator;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class LoveCalculatorCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("lovecalc",
"Calculate how much two people love each other.")
.addOption(OptionType.MENTIONABLE,
"first",
"The first person to account for",
true)
.addOption(OptionType.MENTIONABLE,
"second",
"The second person to account for",
false);
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
User firstUser, secondUser;
OptionMapping firsUserArg = event.getOption("first");
if (firsUserArg != null)
{
firstUser = firsUserArg.getAsUser(); //todo null check?
} else
{
event.reply("\uD83D\uDE22 I need to know who to check! Please mention them.")
.setEphemeral(true)
.queue();
return;
}
OptionMapping secondUserArg = event.getOption("second");
if (secondUserArg != null)
{
secondUser = secondUserArg.getAsUser(); //todo null check?
} else
{
secondUser = event.getUser();
}
MessageEmbed embed = LoveCalculator.buildEmbedAndCacheResult(event.getUser(), firstUser, secondUser);
event.replyEmbeds(embed).queue();
}
}

49
src/main/java/wtf/beatrice/hidekobot/commands/slash/MagicBallCommand.java
View File

@@ -1,49 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.MagicBall;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class MagicBallCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash(MagicBall.getLabels().get(0),
"Ask a question to the magic ball.")
.addOption(OptionType.STRING, "question",
"The question to ask.",
true,
false);
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
// get the asked question
OptionMapping textOption = event.getOption("question");
String question = "";
if (textOption != null)
{
question = textOption.getAsString();
}
if (textOption == null || question.isEmpty())
{
event.reply("\uD83D\uDE20 Hey, you have to ask me a question!")
.setEphemeral(true)
.queue();
return;
}
MessageEmbed response = MagicBall.generateEmbed(question, event.getUser());
event.replyEmbeds(response).queue();
}
}

7
src/main/java/wtf/beatrice/hidekobot/commands/slash/SayCommand.java
View File

@@ -1,5 +1,6 @@
package wtf.beatrice.hidekobot.commands.slash; package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel; import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent; import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.DefaultMemberPermissions; import net.dv8tion.jda.api.interactions.commands.DefaultMemberPermissions;
@@ -33,12 +34,12 @@ public class SayCommand extends SlashCommandImpl
// get the text to send // get the text to send
OptionMapping textOption = event.getOption("text"); OptionMapping textOption = event.getOption("text");
String messageContent = ""; String messageContent = "";
if (textOption != null) if(textOption != null)
{ {
messageContent = textOption.getAsString(); messageContent = textOption.getAsString();
} }
if (textOption == null || messageContent.isEmpty()) if(textOption == null || messageContent.isEmpty())
{ {
event.reply("\uD83D\uDE20 Hey, you have to tell me what to say!") event.reply("\uD83D\uDE20 Hey, you have to tell me what to say!")
.setEphemeral(true) .setEphemeral(true)

40
src/main/java/wtf/beatrice/hidekobot/commands/slash/TimeoutCommand.java
View File

@@ -1,40 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.DefaultMemberPermissions;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.commands.base.UserPunishment;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class TimeoutCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("timeout", "Timeout someone in the guild.")
.addOption(OptionType.MENTIONABLE, "target",
"The member user to time out.",
true,
false)
.addOption(OptionType.STRING, "duration",
"The duration of the timeout.",
true,
false)
.addOption(OptionType.STRING, "reason",
"The reason for the punishment.",
false,
false)
.setDefaultPermissions(DefaultMemberPermissions.enabledFor(Permission.MODERATE_MEMBERS));
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
UserPunishment.handle(event, UserPunishment.PunishmentType.TIMEOUT);
}
}

51
src/main/java/wtf/beatrice/hidekobot/commands/slash/TriviaCommand.java
View File

@@ -1,51 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.Trivia;
import wtf.beatrice.hidekobot.objects.MessageResponse;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
public class TriviaCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash("trivia",
"Start a Trivia session and play with others!");
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
MessageChannel channel = event.getChannel();
if (!(channel instanceof TextChannel))
{
event.reply(Trivia.getNoDMsError()).queue();
return;
}
if (Trivia.channelsRunningTrivia.contains(channel.getId()))
{
event.reply(Trivia.getTriviaAlreadyRunningError()).setEphemeral(true).queue();
return;
}
// if we got here, this might take a bit
event.deferReply().queue();
MessageResponse response = Trivia.generateMainScreen();
event.getHook().editOriginalEmbeds(response.embed()).setActionRow(response.components()).queue(message ->
{
Cache.getDatabaseSource().trackRanCommandReply(message, event.getUser());
Cache.getDatabaseSource().queueDisabling(message);
});
}
}

83
src/main/java/wtf/beatrice/hidekobot/commands/slash/UrbanDictionaryCommand.java
View File

@@ -1,83 +0,0 @@
package wtf.beatrice.hidekobot.commands.slash;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.commands.OptionType;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.commands.build.Commands;
import net.dv8tion.jda.api.interactions.components.ActionRow;
import net.dv8tion.jda.api.interactions.components.buttons.Button;
import org.jetbrains.annotations.NotNull;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.select.Elements;
import wtf.beatrice.hidekobot.commands.base.UrbanDictionary;
import wtf.beatrice.hidekobot.objects.commands.SlashCommandImpl;
import java.io.IOException;
public class UrbanDictionaryCommand extends SlashCommandImpl
{
@Override
public CommandData getSlashCommandData()
{
return Commands.slash(UrbanDictionary.getCommandLabels().get(0),
"Look up a term on Urban Dictionary.")
.addOption(OptionType.STRING, "term", "The term to look up", true);
}
@Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event)
{
event.deferReply().queue();
// get the term to look up
OptionMapping textOption = event.getOption("term");
String term = "";
if (textOption != null)
{
term = textOption.getAsString();
}
if (textOption == null || term.isEmpty())
{
event.reply(UrbanDictionary.getNoArgsError())
.setEphemeral(true)
.queue();
return;
}
final String sanitizedTerm = UrbanDictionary.sanitizeArgs(term, false);
String url = UrbanDictionary.generateUrl(sanitizedTerm);
Document doc;
try
{
doc = Jsoup.connect(url).get();
} catch (IOException e)
{
event.reply(UrbanDictionary.getTermNotFoundError())
.setEphemeral(true)
.queue();
return;
}
Elements definitions = doc.getElementsByClass("definition");
UrbanDictionary.UrbanSearch search = new UrbanDictionary.UrbanSearch(definitions);
MessageEmbed embed = UrbanDictionary.buildEmbed(sanitizedTerm, url, event.getUser(), search, 0);
// disable next page if we only have one result
Button nextPageBtnLocal = UrbanDictionary.getNextPageButton();
if (search.getPages() == 1) nextPageBtnLocal = nextPageBtnLocal.asDisabled();
ActionRow actionRow = ActionRow.of(UrbanDictionary.getPreviousPageButton().asDisabled(),
//disabled by default because we're on page 0
nextPageBtnLocal,
UrbanDictionary.getDeleteButton());
event.getHook().editOriginalEmbeds(embed).setComponents(actionRow).queue(message ->
UrbanDictionary.track(message, event.getUser(), search, sanitizedTerm));
}
}

13
src/main/java/wtf/beatrice/hidekobot/datasources/ConfigurationEntry.java
View File

@@ -7,27 +7,18 @@ public enum ConfigurationEntry
BOT_OWNER_ID("bot-owner-id", 100000000000000000L), BOT_OWNER_ID("bot-owner-id", 100000000000000000L),
BOT_COLOR("bot-color", "PINK"), BOT_COLOR("bot-color", "PINK"),
HEARTBEAT_LINK("heartbeat-link", "https://your-heartbeat-api.com/api/push/apikey?status=up&msg=OK&ping="), HEARTBEAT_LINK("heartbeat-link", "https://your-heartbeat-api.com/api/push/apikey?status=up&msg=OK&ping="),
RANDOM_ORG_API_KEY("random-org-api-key", "00000000-0000-0000-0000-000000000000"),
; ;
private String path; private String path;
private Object defaultValue; private Object defaultValue;
ConfigurationEntry(String path, Object defaultValue) ConfigurationEntry(String path, Object defaultValue)
{ {
this.path = path; this.path = path;
this.defaultValue = defaultValue; this.defaultValue = defaultValue;
} }
public String getPath() public String getPath() { return path; }
{ public Object getDefaultValue() { return defaultValue; }
return path;
}
public Object getDefaultValue()
{
return defaultValue;
}
} }

77
src/main/java/wtf/beatrice/hidekobot/datasources/ConfigurationSource.java
View File

@@ -1,26 +1,25 @@
package wtf.beatrice.hidekobot.datasources; package wtf.beatrice.hidekobot.datasources;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.yaml.snakeyaml.DumperOptions; import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.LoaderOptions;
import org.yaml.snakeyaml.Yaml; import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.SafeConstructor;
import wtf.beatrice.hidekobot.HidekoBot; import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.util.Logger;
import java.io.*; import java.io.*;
import java.util.LinkedHashMap; import java.util.LinkedHashMap;
import java.util.Map;
public class ConfigurationSource public class ConfigurationSource
{ {
private final LinkedHashMap<String, Object> configurationEntries = new LinkedHashMap<>(); private final LinkedHashMap<String, Object> configurationEntries = new LinkedHashMap<>();
private static final Logger LOGGER = LoggerFactory.getLogger(ConfigurationSource.class); private final Logger logger;
private final String configFilePath; private final String configFilePath;
public ConfigurationSource(String configFilePath) public ConfigurationSource(String configFilePath)
{ {
this.configFilePath = configFilePath; this.configFilePath = configFilePath;
logger = new Logger(getClass());
} }
public void initConfig() public void initConfig()
@@ -32,52 +31,40 @@ public class ConfigurationSource
* we used to have a config.yml file in the "resources" folder, but that is no longer necessary. * we used to have a config.yml file in the "resources" folder, but that is no longer necessary.
*/ */
LinkedHashMap<String, Object> internalConfigContents = new LinkedHashMap<>(); // map holding all file entries LinkedHashMap<String, Object> internalConfigContents = new LinkedHashMap<>(); // map holding all file entries
for (ConfigurationEntry entry : ConfigurationEntry.values()) for(ConfigurationEntry entry : ConfigurationEntry.values())
{ {
internalConfigContents.put(entry.getPath(), entry.getDefaultValue()); internalConfigContents.put(entry.getPath(), entry.getDefaultValue());
} }
if (internalConfigContents.isEmpty()) if(internalConfigContents.isEmpty())
{ {
LOGGER.error("Error reading internal configuration!"); logger.log("Error reading internal configuration!");
HidekoBot.shutdown(); HidekoBot.shutdown();
return; return;
} }
// check if config files exists in filesystem // check if config files exists in filesystem
File fsConfigFile = new File(configFilePath); File fsConfigFile = new File(configFilePath);
if (!fsConfigFile.exists()) if(!fsConfigFile.exists())
{ {
// try to create config file // try to create config file
try try { fsConfigFile.createNewFile(); }
{ catch (IOException e) {
if (!fsConfigFile.createNewFile()) logger.log("Error creating configuration file!");
{ logger.log(e.getMessage());
LOGGER.error("We tried creating a file that already exists!");
HidekoBot.shutdown();
return;
}
} catch (IOException e)
{
LOGGER.error("Error creating configuration file!", e);
HidekoBot.shutdown(); HidekoBot.shutdown();
return; return;
} }
} }
// load the YAML file from the filesystem // load the YAML file from the filesystem
LoaderOptions options = new LoaderOptions(); Yaml fsConfigYaml = new Yaml();
Yaml fsConfigYaml = new Yaml(new SafeConstructor(options));
LinkedHashMap<String, Object> fsConfigContents = null; // map holding all file entries LinkedHashMap<String, Object> fsConfigContents = null; // map holding all file entries
try (InputStream fsConfigStream = new FileInputStream(fsConfigFile)) try (InputStream fsConfigStream = new FileInputStream(fsConfigFile))
{ { fsConfigContents = fsConfigYaml.load(fsConfigStream); }
fsConfigContents = fsConfigYaml.load(fsConfigStream); catch (IOException e) { logger.log(e.getMessage()); }
} catch (IOException e)
{
LOGGER.error(e.getMessage());
}
if (fsConfigContents == null) // if file contents are empty or corrupted... if(fsConfigContents == null) // if file contents are empty or corrupted...
{ {
// "clean" them (this effectively forces a config file reset) // "clean" them (this effectively forces a config file reset)
fsConfigContents = new LinkedHashMap<>(); fsConfigContents = new LinkedHashMap<>();
@@ -85,10 +72,10 @@ public class ConfigurationSource
// check for missing keys // check for missing keys
boolean missingKeys = false; boolean missingKeys = false;
for (String key : internalConfigContents.keySet()) for(String key : internalConfigContents.keySet())
{ {
// if key is missing // if key is missing
if (!fsConfigContents.containsKey(key)) if(!fsConfigContents.containsKey(key))
{ {
// quit and flag it, as we need to complete the file with the missing ones // quit and flag it, as we need to complete the file with the missing ones
missingKeys = true; missingKeys = true;
@@ -97,29 +84,24 @@ public class ConfigurationSource
} }
// if keys are missing // if keys are missing
if (missingKeys) if(missingKeys)
{ {
// create a new mixed map that will take existing values from the non-missing keys // create a new mixed map that will take existing values from the non-missing keys
// and fill everything else with the default values // and fill everything else with the default values
LinkedHashMap<String, Object> filledEntries = new LinkedHashMap<>(); LinkedHashMap<String, Object> filledEntries = new LinkedHashMap<>();
for(String key : internalConfigContents.keySet())
for (Map.Entry<String, Object> entry : internalConfigContents.entrySet())
{ {
String key = entry.getKey(); if(fsConfigContents.containsKey(key))
if (fsConfigContents.containsKey(key))
{ {
// if the key already exists, copy the original value // if the key already exists, copy the original value
filledEntries.put(key, fsConfigContents.get(key)); filledEntries.put(key, fsConfigContents.get(key));
} else } else {
{
// else, copy the value from the example config file // else, copy the value from the example config file
filledEntries.put(key, entry.getValue()); filledEntries.put(key, internalConfigContents.get(key));
} }
} }
try try {
{
// new writer to actually write the contents to the file // new writer to actually write the contents to the file
PrintWriter missingKeysWriter = new PrintWriter(fsConfigFile); PrintWriter missingKeysWriter = new PrintWriter(fsConfigFile);
@@ -132,17 +114,15 @@ public class ConfigurationSource
// create the yaml object and dump the values to filesystem // create the yaml object and dump the values to filesystem
Yaml yaml = new Yaml(dumperOptions); Yaml yaml = new Yaml(dumperOptions);
yaml.dump(filledEntries, missingKeysWriter); yaml.dump(filledEntries, missingKeysWriter);
} catch (FileNotFoundException e) } catch (FileNotFoundException e) {
{ logger.log(e.getMessage());
LOGGER.error(e.getMessage());
HidekoBot.shutdown(); HidekoBot.shutdown();
return; return;
} }
// finally, dump all entries to cache. // finally, dump all entries to cache.
loadConfig(filledEntries); loadConfig(filledEntries);
} else } else {
{
// if no key is missing, just cache all entries and values from filesystem. // if no key is missing, just cache all entries and values from filesystem.
loadConfig(fsConfigContents); loadConfig(fsConfigContents);
} }
@@ -153,7 +133,6 @@ public class ConfigurationSource
{ {
this.configurationEntries.putAll(configurationEntries); this.configurationEntries.putAll(configurationEntries);
} }
public Object getConfigValue(ConfigurationEntry key) public Object getConfigValue(ConfigurationEntry key)
{ {
return configurationEntries.get(key.getPath()); return configurationEntries.get(key.getPath());

499
src/main/java/wtf/beatrice/hidekobot/datasources/DatabaseSource.java
View File

@@ -3,8 +3,8 @@ package wtf.beatrice.hidekobot.datasources;
import net.dv8tion.jda.api.entities.Message; import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.User; import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.ChannelType; import net.dv8tion.jda.api.entities.channel.ChannelType;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.Cache; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.util.Logger;
import java.sql.*; import java.sql.*;
import java.time.LocalDateTime; import java.time.LocalDateTime;
@@ -15,35 +15,29 @@ import java.util.List;
public class DatabaseSource public class DatabaseSource
{ {
private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(DatabaseSource.class); private final static String sqliteURL = "jdbc:sqlite:%path%";
private static final String JDBC_URL = "jdbc:sqlite:%path%";
private Connection dbConnection = null; private Connection dbConnection = null;
private final String dbPath; private final String dbPath;
private final Logger logger;
public DatabaseSource(String dbPath) public DatabaseSource(String dbPath)
{ {
this.dbPath = dbPath; this.dbPath = dbPath;
} this.logger = new Logger(getClass());
private void logException(SQLException e)
{
LOGGER.error("Database Exception", e);
} }
public boolean connect() public boolean connect()
{ {
String url = JDBC_URL.replace("%path%", dbPath); String url = sqliteURL.replace("%path%", dbPath);
if (!close()) return false; if(!close()) return false;
try try {
{
dbConnection = DriverManager.getConnection(url); dbConnection = DriverManager.getConnection(url);
LOGGER.info("Database connection established!"); logger.log("Database connection established!");
return true; return true;
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
return false; return false;
} }
@@ -54,15 +48,13 @@ public class DatabaseSource
{ {
if (dbConnection != null) if (dbConnection != null)
{ {
try try {
{ if(!dbConnection.isClosed())
if (!dbConnection.isClosed())
{ {
dbConnection.close(); dbConnection.close();
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
return false; return false;
} }
@@ -89,57 +81,36 @@ public class DatabaseSource
* | 39402849302 | 39402849302 | 39402849302 | 39402849302 | PRIVATE | * | 39402849302 | 39402849302 | 39402849302 | 39402849302 | PRIVATE |
* -------------------------------------------------------------------------------------------- * --------------------------------------------------------------------------------------------
* *
* TABLE 3: urban_dictionary
* -----------------------------------------------------------------------------------------------------
* | message_id | page | meanings | examples | contributors | dates | term |
* -----------------------------------------------------------------------------------------------------
* | 39402849302 | 0 | base64 | base64 | base64 | base64 | miku |
* -----------------------------------------------------------------------------------------------------
*/ */
//todo: javadocs //todo: javadocs
public boolean initDb() public boolean initDb()
{ {
List<String> newTables = new ArrayList<>(); List<String> newTables = new ArrayList<>();
newTables.add(""" newTables.add("CREATE TABLE IF NOT EXISTS pending_disabled_messages (" +
CREATE TABLE IF NOT EXISTS pending_disabled_messages ( "guild_id TEXT NOT NULL, " +
guild_id TEXT NOT NULL, "channel_id TEXT NOT NULL," +
channel_id TEXT NOT NULL, "message_id TEXT NOT NULL," +
message_id TEXT NOT NULL, "expiry_timestamp TEXT NOT NULL " +
expiry_timestamp TEXT NOT NULL); ");");
""");
newTables.add(""" newTables.add("CREATE TABLE IF NOT EXISTS command_runners (" +
CREATE TABLE IF NOT EXISTS command_runners ( "guild_id TEXT NOT NULL, " +
guild_id TEXT NOT NULL, "channel_id TEXT NOT NULL," + // channel the command was run in
channel_id TEXT NOT NULL, "message_id TEXT NOT NULL," + // message id of the bot's response
message_id TEXT NOT NULL, "user_id TEXT NOT NULL, " + // user who ran the command
user_id TEXT NOT NULL, "channel_type TEXT NOT NULL" + // channel type (PRIVATE, FORUM, ...)
channel_type TEXT NOT NULL); ");");
""");
newTables.add(""" for(String sql : newTables)
CREATE TABLE IF NOT EXISTS urban_dictionary (
message_id TEXT NOT NULL,
page INTEGER NOT NULL,
meanings TEXT NOT NULL,
examples TEXT NOT NULL,
contributors TEXT NOT NULL,
dates TEXT NOT NULL,
term TEXT NOT NULL
);
""");
for (String sql : newTables)
{ {
try (Statement stmt = dbConnection.createStatement()) try (Statement stmt = dbConnection.createStatement()) {
{
// execute the statement // execute the statement
stmt.execute(sql); stmt.execute(sql);
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
return false; return false;
} }
} }
@@ -153,11 +124,10 @@ public class DatabaseSource
String guildId; String guildId;
ChannelType channelType = message.getChannelType(); ChannelType channelType = message.getChannelType();
if (!(channelType.isGuild())) if(!(channelType.isGuild()))
{ {
guildId = userId; guildId = userId;
} else } else {
{
guildId = message.getGuild().getId(); guildId = message.getGuild().getId();
} }
@@ -165,13 +135,11 @@ public class DatabaseSource
String messageId = message.getId(); String messageId = message.getId();
String query = """ String query = "INSERT INTO command_runners " +
INSERT INTO command_runners "(guild_id, channel_id, message_id, user_id, channel_type) VALUES " +
(guild_id, channel_id, message_id, user_id, channel_type) VALUES " (?, ?, ?, ?, ?);";
(?, ?, ?, ?, ?);
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, guildId); preparedStatement.setString(1, guildId);
preparedStatement.setString(2, channelId); preparedStatement.setString(2, channelId);
@@ -184,7 +152,7 @@ public class DatabaseSource
return true; return true;
} catch (SQLException e) } catch (SQLException e)
{ {
logException(e); e.printStackTrace();
} }
return false; return false;
@@ -193,32 +161,29 @@ public class DatabaseSource
public boolean isUserTrackedFor(String userId, String messageId) public boolean isUserTrackedFor(String userId, String messageId)
{ {
String trackedUserId = getTrackedReplyUserId(messageId); String trackedUserId = getTrackedReplyUserId(messageId);
if (trackedUserId == null) return false; if(trackedUserId == null) return false;
return userId.equals(trackedUserId); return userId.equals(trackedUserId);
} }
public ChannelType getTrackedMessageChannelType(String messageId) public ChannelType getTrackedMessageChannelType(String messageId)
{ {
String query = """ String query = "SELECT channel_type " +
SELECT channel_type "FROM command_runners " +
FROM command_runners "WHERE message_id = ?;";
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery(); ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null; if(resultSet.isClosed()) return null;
while (resultSet.next()) while(resultSet.next())
{ {
String channelTypeName = resultSet.getString("channel_type"); String channelTypeName = resultSet.getString("channel_type");
return ChannelType.valueOf(channelTypeName); return ChannelType.valueOf(channelTypeName);
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
} }
return null; return null;
@@ -227,25 +192,22 @@ public class DatabaseSource
public String getTrackedReplyUserId(String messageId) public String getTrackedReplyUserId(String messageId)
{ {
String query = """ String query = "SELECT user_id " +
SELECT user_id "FROM command_runners " +
FROM command_runners "WHERE message_id = ?;";
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery(); ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null; if(resultSet.isClosed()) return null;
while (resultSet.next()) while(resultSet.next())
{ {
return resultSet.getString("user_id"); return resultSet.getString("user_id");
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
} }
return null; return null;
@@ -258,11 +220,10 @@ public class DatabaseSource
String guildId; String guildId;
ChannelType channelType = message.getChannelType(); ChannelType channelType = message.getChannelType();
if (!(channelType.isGuild())) if(!(channelType.isGuild()))
{ {
guildId = "PRIVATE"; guildId = "PRIVATE";
} else } else {
{
guildId = message.getGuild().getId(); guildId = message.getGuild().getId();
} }
@@ -271,13 +232,11 @@ public class DatabaseSource
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(Cache.getExpiryTimestampFormat()); DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(Cache.getExpiryTimestampFormat());
String expiryTimeFormatted = dateTimeFormatter.format(expiryTime); String expiryTimeFormatted = dateTimeFormatter.format(expiryTime);
String query = """ String query = "INSERT INTO pending_disabled_messages " +
INSERT INTO pending_disabled_messages "(guild_id, channel_id, message_id, expiry_timestamp) VALUES " +
(guild_id, channel_id, message_id, expiry_timestamp) VALUES " (?, ?, ?, ?);";
(?, ?, ?, ?);
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, guildId); preparedStatement.setString(1, guildId);
preparedStatement.setString(2, channelId); preparedStatement.setString(2, channelId);
@@ -289,7 +248,7 @@ public class DatabaseSource
return true; return true;
} catch (SQLException e) } catch (SQLException e)
{ {
logException(e); e.printStackTrace();
} }
return false; return false;
@@ -299,22 +258,19 @@ public class DatabaseSource
{ {
List<String> messages = new ArrayList<>(); List<String> messages = new ArrayList<>();
String query = """ String query = "SELECT message_id " +
SELECT message_id "FROM pending_disabled_messages ";
FROM pending_disabled_messages;
""";
try (Statement statement = dbConnection.createStatement()) try (Statement statement = dbConnection.createStatement())
{ {
ResultSet resultSet = statement.executeQuery(query); ResultSet resultSet = statement.executeQuery(query);
if (resultSet.isClosed()) return messages; if(resultSet.isClosed()) return messages;
while (resultSet.next()) while(resultSet.next())
{ {
messages.add(resultSet.getString("message_id")); messages.add(resultSet.getString("message_id"));
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
} }
return messages; return messages;
@@ -324,35 +280,24 @@ public class DatabaseSource
{ {
String query = "DELETE FROM pending_disabled_messages WHERE message_id = ?;"; String query = "DELETE FROM pending_disabled_messages WHERE message_id = ?;";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
preparedStatement.execute(); preparedStatement.execute();
} catch (SQLException e) } catch (SQLException e)
{ {
logException(e); e.printStackTrace();
return false; return false;
} }
query = "DELETE FROM command_runners WHERE message_id = ?;"; query = "DELETE FROM command_runners WHERE message_id = ?;";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
preparedStatement.execute(); preparedStatement.execute();
} catch (SQLException e) } catch (SQLException e)
{ {
logException(e); e.printStackTrace();
return false;
}
query = "DELETE FROM urban_dictionary WHERE message_id = ?;";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
preparedStatement.execute();
} catch (SQLException e)
{
logException(e);
return false; return false;
} }
@@ -361,25 +306,22 @@ public class DatabaseSource
public String getQueuedExpiringMessageExpiryDate(String messageId) public String getQueuedExpiringMessageExpiryDate(String messageId)
{ {
String query = """ String query = "SELECT expiry_timestamp " +
SELECT expiry_timestamp "FROM pending_disabled_messages " +
FROM pending_disabled_messages "WHERE message_id = ?;";
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery(); ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null; if(resultSet.isClosed()) return null;
while (resultSet.next()) while(resultSet.next())
{ {
return resultSet.getString("expiry_timestamp"); return resultSet.getString("expiry_timestamp");
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
} }
return null; return null;
@@ -387,25 +329,22 @@ public class DatabaseSource
public String getQueuedExpiringMessageChannel(String messageId) public String getQueuedExpiringMessageChannel(String messageId)
{ {
String query = """ String query = "SELECT channel_id " +
SELECT channel_id "FROM pending_disabled_messages " +
FROM pending_disabled_messages "WHERE message_id = ?;";
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery(); ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null; if(resultSet.isClosed()) return null;
while (resultSet.next()) while(resultSet.next())
{ {
return resultSet.getString("channel_id"); return resultSet.getString("channel_id");
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
} }
return null; return null;
@@ -413,270 +352,26 @@ public class DatabaseSource
public String getQueuedExpiringMessageGuild(String messageId) public String getQueuedExpiringMessageGuild(String messageId)
{ {
String query = """ String query = "SELECT guild_id " +
SELECT guild_id "FROM pending_disabled_messages " +
FROM pending_disabled_messages "WHERE message_id = ?;";
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query)) try(PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{ {
preparedStatement.setString(1, messageId); preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery(); ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null; if(resultSet.isClosed()) return null;
while (resultSet.next()) while(resultSet.next())
{ {
return resultSet.getString("guild_id"); return resultSet.getString("guild_id");
} }
} catch (SQLException e) } catch (SQLException e) {
{ e.printStackTrace();
logException(e);
} }
return null; return null;
} }
public boolean trackUrban(String meanings, String examples,
String contributors, String dates,
Message message, String term)
{
String query = """
INSERT INTO urban_dictionary
(message_id, page, meanings, examples, contributors, dates, term) VALUES
(?, ?, ?, ?, ?, ?, ?);
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, message.getId());
preparedStatement.setInt(2, 0);
preparedStatement.setString(3, meanings);
preparedStatement.setString(4, examples);
preparedStatement.setString(5, contributors);
preparedStatement.setString(6, dates);
preparedStatement.setString(7, term);
preparedStatement.executeUpdate();
return true;
} catch (SQLException e)
{
logException(e);
}
return false;
}
public int getUrbanPage(String messageId)
{
String query = """
SELECT page
FROM urban_dictionary
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return 0;
while (resultSet.next())
{
return resultSet.getInt("page");
}
} catch (SQLException e)
{
logException(e);
}
return 0;
}
public String getUrbanMeanings(String messageId)
{
String query = """
SELECT meanings
FROM urban_dictionary
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null;
while (resultSet.next())
{
return resultSet.getString("meanings");
}
} catch (SQLException e)
{
logException(e);
}
return null;
}
public String getUrbanExamples(String messageId)
{
String query = """
SELECT examples
FROM urban_dictionary
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null;
while (resultSet.next())
{
return resultSet.getString("examples");
}
} catch (SQLException e)
{
logException(e);
}
return null;
}
public String getUrbanContributors(String messageId)
{
String query = """
SELECT contributors
FROM urban_dictionary
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null;
while (resultSet.next())
{
return resultSet.getString("contributors");
}
} catch (SQLException e)
{
logException(e);
}
return null;
}
public String getUrbanDates(String messageId)
{
String query = """
SELECT dates
FROM urban_dictionary
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null;
while (resultSet.next())
{
return resultSet.getString("dates");
}
} catch (SQLException e)
{
logException(e);
}
return null;
}
public String getUrbanTerm(String messageId)
{
String query = """
SELECT term
FROM urban_dictionary
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, messageId);
ResultSet resultSet = preparedStatement.executeQuery();
if (resultSet.isClosed()) return null;
while (resultSet.next())
{
return resultSet.getString("term");
}
} catch (SQLException e)
{
logException(e);
}
return null;
}
public boolean setUrbanPage(String messageId, int page)
{
String query = """
UPDATE urban_dictionary
SET page = ?
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setInt(1, page);
preparedStatement.setString(2, messageId);
preparedStatement.executeUpdate();
return true;
} catch (SQLException e)
{
logException(e);
}
return false;
}
public boolean resetExpiryTimestamp(String messageId)
{
LocalDateTime expiryTime = LocalDateTime.now().plusSeconds(Cache.getExpiryTimeSeconds());
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern(Cache.getExpiryTimestampFormat());
String expiryTimeFormatted = dateTimeFormatter.format(expiryTime);
String query = """
UPDATE pending_disabled_messages
SET expiry_timestamp = ?
WHERE message_id = ?;
""";
try (PreparedStatement preparedStatement = dbConnection.prepareStatement(query))
{
preparedStatement.setString(1, expiryTimeFormatted);
preparedStatement.setString(2, messageId);
preparedStatement.executeUpdate();
return true;
} catch (SQLException e)
{
logException(e);
}
return false;
}
} }

15
src/main/java/wtf/beatrice/hidekobot/datasources/PropertiesSource.java
View File

@@ -1,8 +1,7 @@
package wtf.beatrice.hidekobot.datasources; package wtf.beatrice.hidekobot.datasources;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.HidekoBot; import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.util.Logger;
import java.io.IOException; import java.io.IOException;
import java.io.InputStream; import java.io.InputStream;
@@ -13,7 +12,7 @@ public class PropertiesSource
private Properties properties = null; private Properties properties = null;
private final String fileName = "default.properties"; private final String fileName = "default.properties";
private static final Logger LOGGER = LoggerFactory.getLogger(PropertiesSource.class); private final Logger logger = new Logger(getClass());
public void load() public void load()
{ {
@@ -25,16 +24,14 @@ public class PropertiesSource
{ {
properties.load(internalPropertiesStream); properties.load(internalPropertiesStream);
} catch (IOException e) }
{ catch (IOException e) {
LOGGER.error(e.getMessage()); logger.log(e.getMessage());
HidekoBot.shutdown(); HidekoBot.shutdown();
return; return;
} }
} }
public String getProperty(String property) public String getProperty(String property)
{ { return properties == null ? "" : properties.getProperty(property); }
return properties == null ? "" : properties.getProperty(property);
}
} }

28
src/main/java/wtf/beatrice/hidekobot/listeners/ButtonInteractionListener.java
View File

@@ -2,43 +2,23 @@ package wtf.beatrice.hidekobot.listeners;
import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent; import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter; import net.dv8tion.jda.api.hooks.ListenerAdapter;
import org.slf4j.Logger; import wtf.beatrice.hidekobot.commands.base.ClearChat;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.commands.base.CoinFlip; import wtf.beatrice.hidekobot.commands.base.CoinFlip;
import wtf.beatrice.hidekobot.commands.base.Trivia;
import wtf.beatrice.hidekobot.commands.base.UrbanDictionary;
import wtf.beatrice.hidekobot.util.CommandUtil;
public class ButtonInteractionListener extends ListenerAdapter public class ButtonInteractionListener extends ListenerAdapter
{ {
private static final Logger LOGGER = LoggerFactory.getLogger(ButtonInteractionListener.class);
@Override @Override
public void onButtonInteraction(ButtonInteractionEvent event) public void onButtonInteraction(ButtonInteractionEvent event)
{ {
switch (event.getComponentId().toLowerCase()) switch (event.getComponentId().toLowerCase()) {
{
// coinflip // coinflip
case "coinflip_reflip" -> CoinFlip.buttonReFlip(event); case "coinflip_reflip" -> CoinFlip.buttonReFlip(event);
// generic dismiss button // clearchat command
case "generic_dismiss" -> CommandUtil.delete(event); case "clear_dismiss" -> ClearChat.dismissMessage(event);
// urban dictionary navigation
case "urban_nextpage" -> UrbanDictionary.changePage(event, UrbanDictionary.ChangeType.NEXT);
case "urban_previouspage" -> UrbanDictionary.changePage(event, UrbanDictionary.ChangeType.PREVIOUS);
// trivia
case "trivia_correct" -> Trivia.handleAnswer(event, Trivia.AnswerType.CORRECT);
case "trivia_wrong_1", "trivia_wrong_2", "trivia_wrong_3" ->
Trivia.handleAnswer(event, Trivia.AnswerType.WRONG);
// error handling
default -> LOGGER.warn("Received unhandled {}", event.getClass().getSimpleName());
} }

77
src/main/java/wtf/beatrice/hidekobot/listeners/MessageCommandListener.java
View File

@@ -7,25 +7,23 @@ import net.dv8tion.jda.api.entities.channel.middleman.GuildChannel;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter; import net.dv8tion.jda.api.hooks.ListenerAdapter;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.objects.commands.CommandCategory;
import wtf.beatrice.hidekobot.objects.commands.MessageCommand; import wtf.beatrice.hidekobot.objects.commands.MessageCommand;
import wtf.beatrice.hidekobot.objects.comparators.MessageCommandAliasesComparator; import wtf.beatrice.hidekobot.objects.comparators.MessageCommandAliasesComparator;
import wtf.beatrice.hidekobot.util.Logger;
import java.util.*; import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
import java.util.TreeMap;
public class MessageCommandListener extends ListenerAdapter public class MessageCommandListener extends ListenerAdapter
{ {
// map storing command labels and command object alphabetically. // map storing command labels and command object alphabetically.
private final TreeMap<LinkedList<String>, MessageCommand> registeredCommands = private final TreeMap<LinkedList<String>, MessageCommand> registeredCommands =
new TreeMap<>(new MessageCommandAliasesComparator()); new TreeMap<LinkedList<String>, MessageCommand>(new MessageCommandAliasesComparator());
// map commands and their categories. private final String commandRegex = "(?i)^(hideko|hde)\\b";
// this is not strictly needed but it's better to have it so we avoid looping every time we need to check the cat.
LinkedHashMap<CommandCategory, LinkedList<MessageCommand>> commandCategories = new LinkedHashMap<>();
private static final String COMMAND_REGEX = "(?i)^(hideko|hde)\\b";
// (?i) -> case insensitive flag // (?i) -> case insensitive flag
// ^ -> start of string (not in middle of a sentence) // ^ -> start of string (not in middle of a sentence)
// \b -> the word has to end here // \b -> the word has to end here
@@ -38,16 +36,12 @@ public class MessageCommandListener extends ListenerAdapter
public MessageCommand getRegisteredCommand(String label) public MessageCommand getRegisteredCommand(String label)
{ {
for (Map.Entry<LinkedList<String>, MessageCommand> entry : registeredCommands.entrySet()) for(LinkedList<String> aliases : registeredCommands.keySet())
{ {
LinkedList<String> aliases = entry.getKey(); for(String currentAlias : aliases)
for (String currentAlias : aliases)
{ {
if (label.equals(currentAlias)) if(label.equals(currentAlias))
{ { return registeredCommands.get(aliases); }
return entry.getValue();
}
} }
} }
@@ -55,25 +49,26 @@ public class MessageCommandListener extends ListenerAdapter
} }
public LinkedList<MessageCommand> getRegisteredCommands() public LinkedList<MessageCommand> getRegisteredCommands()
{ { return new LinkedList<>(registeredCommands.values()); }
return new LinkedList<>(registeredCommands.values());
}
private final Logger logger = new Logger(MessageCommandListener.class);
@Override @Override
public void onMessageReceived(@NotNull MessageReceivedEvent event) public void onMessageReceived(@NotNull MessageReceivedEvent event)
{ {
// check if a bot is sending this message, and ignore it // check if a bot is sending this message, and ignore it
if (event.getAuthor().isBot()) return; if(event.getAuthor().isBot()) return;
// warning: we are getting the RAW value of the message content, not the DISPLAY value! // warning: we are getting the RAW value of the message content, not the DISPLAY value!
String eventMessage = event.getMessage().getContentRaw(); String eventMessage = event.getMessage().getContentRaw();
// check if the sent message matches the bot activation regex (prefix, name, ...) // check if the sent message matches the bot activation regex (prefix, name, ...)
if (!eventMessage.toLowerCase().matches("(?s)" + COMMAND_REGEX + ".*")) if(!eventMessage.toLowerCase().matches(commandRegex + "((.|\\n)*)"))
return; return;
// generate args from the string // generate args from the string
String argsString = eventMessage.replaceAll(COMMAND_REGEX + "\\s*", ""); String argsString = eventMessage.replaceAll(commandRegex + "\\s*", "");
// if no args were specified apart from the bot prefix // if no args were specified apart from the bot prefix
@@ -81,11 +76,9 @@ public class MessageCommandListener extends ListenerAdapter
// and that element is the whole string passed as a single argument, which would be empty in this case // and that element is the whole string passed as a single argument, which would be empty in this case
// (or contain text in other cases like "string split ," if the passed text doesn't contain any comma -> // (or contain text in other cases like "string split ," if the passed text doesn't contain any comma ->
// it will be the whole text as a single element. // it will be the whole text as a single element.
if (argsString.isEmpty()) if(argsString.isEmpty())
{ {
event.getMessage() event.getMessage().reply("Hello there! ✨").queue();
.reply("Hello there! ✨ Type `" + Cache.getBotPrefix() + " help` to get started!")
.queue();
return; return;
} }
@@ -96,13 +89,9 @@ public class MessageCommandListener extends ListenerAdapter
String commandLabel = argsRaw[0]; String commandLabel = argsRaw[0];
MessageCommand commandObject = getRegisteredCommand(commandLabel); MessageCommand commandObject = getRegisteredCommand(commandLabel);
if (commandObject == null) if(commandObject == null)
{ {
/* temporarily disabled because when people talk about the bot, it replies with this spammy message.
event.getMessage().reply("Unrecognized command: `" + commandLabel + "`!").queue(); // todo prettier event.getMessage().reply("Unrecognized command: `" + commandLabel + "`!").queue(); // todo prettier
*/
return; return;
} }
@@ -111,33 +100,37 @@ public class MessageCommandListener extends ListenerAdapter
// permissions check // permissions check
List<Permission> requiredPermissions = commandObject.getPermissions(); List<Permission> requiredPermissions = commandObject.getPermissions();
if (requiredPermissions != null && !requiredPermissions.isEmpty()) if(requiredPermissions != null && !requiredPermissions.isEmpty())
{ {
if (channelType.isGuild()) //todo: what about forum post if(channelType.isGuild()) //todo: what about forum post
{ {
Member member = event.getMember(); Member member = event.getMember();
GuildChannel channel = event.getGuildChannel(); //todo: what about forum post GuildChannel channel = event.getGuildChannel(); //todo: what about forum post
if (member != null && !member.hasPermission(channel, requiredPermissions)) if(member != null)
{ {
event.getMessage() if(!member.hasPermission(channel, requiredPermissions))
.reply("You do not have permissions to run this command!") {
.queue(); // todo prettier event.getMessage()
// todo: queue message deletion in 15 seconds or so .reply("You do not have permissions to run this command!")
return; .queue(); // todo prettier
// todo: queue message deletion in 15 seconds or so
return;
}
} }
} }
} }
String[] commandArgs; String[] commandArgs;
if (commandObject.passRawArgs()) if(commandObject.passRawArgs())
{ {
// remove first argument, which is the command label // remove first argument, which is the command label
argsString = argsString.replaceAll("^[\\S]+\\s*", ""); argsString = argsString.replaceAll("^[\\S]+\\s*", "");
// pass all other arguments as a single argument as the first array element // pass all other arguments as a single argument as the first array element
commandArgs = new String[]{argsString}; commandArgs = new String[]{argsString};
} else }
else
{ {
// copy all split arguments to the array, except from the command label // copy all split arguments to the array, except from the command label
commandArgs = Arrays.copyOfRange(argsRaw, 1, argsRaw.length); commandArgs = Arrays.copyOfRange(argsRaw, 1, argsRaw.length);

28
src/main/java/wtf/beatrice/hidekobot/listeners/MessageLogger.java
View File

@@ -6,17 +6,16 @@ import net.dv8tion.jda.api.entities.channel.concrete.TextChannel;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter; import net.dv8tion.jda.api.hooks.ListenerAdapter;
import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.NotNull;
import org.slf4j.Logger; import wtf.beatrice.hidekobot.util.Logger;
import org.slf4j.LoggerFactory;
public class MessageLogger extends ListenerAdapter public class MessageLogger extends ListenerAdapter
{ {
// this class only gets loaded as a listener if verbosity is set to true on startup. // this class only gets loaded as a listener if verbosity is set to true on startup.
private static final String GUILD_MESSAGE_LOG_FORMAT = "[%guild%] [#%channel%] %user%: %message%"; private final static String guildChannelFormat = "[%guild%] [#%channel%] %user%: %message%";
private static final String DIRECT_MESSAGE_LOG_FORMAT = "[DM] %user%: %message%"; private final static String dmFormat = "[DM] %user%: %message%";
private static final Logger LOGGER = LoggerFactory.getLogger(MessageLogger.class); private final Logger logger = new Logger(MessageLogger.class);
@Override @Override
public void onMessageReceived(@NotNull MessageReceivedEvent event) public void onMessageReceived(@NotNull MessageReceivedEvent event)
@@ -25,30 +24,31 @@ public class MessageLogger extends ListenerAdapter
String userName = event.getAuthor().getAsTag(); String userName = event.getAuthor().getAsTag();
String message = event.getMessage().getContentDisplay(); String message = event.getMessage().getContentDisplay();
if (event.getChannel() instanceof TextChannel channel) if(event.getChannel() instanceof TextChannel)
{ {
String guildName = channel.getGuild().getName(); String guildName = ((TextChannel) event.getChannel()).getGuild().getName();
String channelName = event.getChannel().getName(); String channelName = event.getChannel().getName();
toLog = GUILD_MESSAGE_LOG_FORMAT toLog = guildChannelFormat
.replace("%guild%", guildName) .replace("%guild%", guildName)
.replace("%channel%", channelName); .replace("%channel%", channelName);
} else if (event.getChannel() instanceof PrivateChannel) }
else if(event.getChannel() instanceof PrivateChannel)
{ {
toLog = DIRECT_MESSAGE_LOG_FORMAT; toLog = dmFormat;
} }
toLog = toLog toLog = toLog
.replace("%user%", userName) .replace("%user%", userName)
.replace("%message%", message); .replace("%message%", message);
LOGGER.info(toLog); logger.log(toLog);
if (!event.getMessage().getAttachments().isEmpty()) if(!event.getMessage().getAttachments().isEmpty())
{ {
for (Message.Attachment atch : event.getMessage().getAttachments()) for(Message.Attachment atch : event.getMessage().getAttachments())
{ {
LOGGER.info(atch.getUrl()); logger.log(atch.getUrl());
} }
} }
} }

27
src/main/java/wtf/beatrice/hidekobot/listeners/SelectMenuInteractionListener.java
View File

@@ -1,27 +0,0 @@
package wtf.beatrice.hidekobot.listeners;
import net.dv8tion.jda.api.events.interaction.component.StringSelectInteractionEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.commands.base.Trivia;
public class SelectMenuInteractionListener extends ListenerAdapter
{
private static final Logger LOGGER = LoggerFactory.getLogger(SelectMenuInteractionListener.class);
@Override
public void onStringSelectInteraction(StringSelectInteractionEvent event)
{
switch (event.getComponentId().toLowerCase())
{
// trivia
case "trivia_categories" -> Trivia.handleMenuSelection(event);
// error handling
default -> LOGGER.warn("Received unhandled {}", event.getClass().getSimpleName());
}
}
}

11
src/main/java/wtf/beatrice/hidekobot/listeners/SlashCommandCompletionListener.java
View File

@@ -21,21 +21,16 @@ public class SlashCommandCompletionListener extends ListenerAdapter
} }
public SlashArgumentsCompleter getRegisteredCompleter(String label) public SlashArgumentsCompleter getRegisteredCompleter(String label)
{ { return registeredCompleters.get(label); }
return registeredCompleters.get(label);
}
public LinkedList<SlashArgumentsCompleter> getRegisteredCompleters() public LinkedList<SlashArgumentsCompleter> getRegisteredCompleters()
{ { return new LinkedList<>(registeredCompleters.values()); }
return new LinkedList<>(registeredCompleters.values());
}
@Override @Override
public void onCommandAutoCompleteInteraction(CommandAutoCompleteInteractionEvent event) public void onCommandAutoCompleteInteraction(CommandAutoCompleteInteractionEvent event)
{ {
String commandName = event.getName().toLowerCase(); String commandName = event.getName().toLowerCase();
SlashArgumentsCompleter completer = registeredCompleters.get(commandName); SlashArgumentsCompleter completer = registeredCompleters.get(commandName);
if (completer == null) return; if(completer == null) return;
// not running in a thread because nothing heavy should be done here... // not running in a thread because nothing heavy should be done here...
completer.runCompletion(event); completer.runCompletion(event);

12
src/main/java/wtf/beatrice/hidekobot/listeners/SlashCommandListener.java
View File

@@ -21,24 +21,20 @@ public class SlashCommandListener extends ListenerAdapter
} }
public SlashCommand getRegisteredCommand(String label) public SlashCommand getRegisteredCommand(String label)
{ { return registeredCommands.get(label); }
return registeredCommands.get(label);
}
public LinkedList<SlashCommand> getRegisteredCommands() public LinkedList<SlashCommand> getRegisteredCommands()
{ { return new LinkedList<>(registeredCommands.values()); }
return new LinkedList<>(registeredCommands.values());
}
@Override @Override
public void onSlashCommandInteraction(@NotNull SlashCommandInteractionEvent event) public void onSlashCommandInteraction(@NotNull SlashCommandInteractionEvent event)
{ {
String commandName = event.getName().toLowerCase(); String commandName = event.getName().toLowerCase();
SlashCommand command = registeredCommands.get(commandName); SlashCommand command = registeredCommands.get(commandName);
if (command == null) return; if(command == null) return;
// finally run the command, in a new thread to avoid locking the main one. // finally run the command, in a new thread to avoid locking.
new Thread(() -> command.runSlashCommand(event)).start(); new Thread(() -> command.runSlashCommand(event)).start();
} }
} }

2
src/main/java/wtf/beatrice/hidekobot/objects/fun/Dice.java → src/main/java/wtf/beatrice/hidekobot/objects/Dice.java
View File

@@ -1,4 +1,4 @@
package wtf.beatrice.hidekobot.objects.fun; package wtf.beatrice.hidekobot.objects;
import wtf.beatrice.hidekobot.util.RandomUtil; import wtf.beatrice.hidekobot.util.RandomUtil;

44
src/main/java/wtf/beatrice/hidekobot/objects/MessageResponse.java
View File

@@ -1,44 +0,0 @@
package wtf.beatrice.hidekobot.objects;
import net.dv8tion.jda.api.entities.MessageEmbed;
import net.dv8tion.jda.api.interactions.components.ItemComponent;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.Objects;
public record MessageResponse(@Nullable String content,
@Nullable MessageEmbed embed,
@Nullable ItemComponent... components)
{
@Override
public boolean equals(Object o)
{
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MessageResponse response = (MessageResponse) o;
return Objects.equals(content, response.content) &&
Objects.equals(embed, response.embed) &&
Arrays.equals(components, response.components);
}
@Override
public int hashCode()
{
int result = Objects.hash(content, embed);
result = 31 * result + Arrays.hashCode(components);
return result;
}
@Override
public String toString()
{
return "MessageResponse{" +
"content=" + content +
", embed=" + embed +
", components=" + Arrays.toString(components) +
'}';
}
}

22
src/main/java/wtf/beatrice/hidekobot/objects/commands/CommandCategory.java
View File

@@ -1,22 +0,0 @@
package wtf.beatrice.hidekobot.objects.commands;
public enum CommandCategory
{
MODERATION("️\uD83D\uDC40"),
FUN("\uD83C\uDFB2"),
TOOLS("\uD83D\uDEE0"),
;
private String emoji;
CommandCategory(String emoji)
{
this.emoji = emoji;
}
public String getEmoji()
{
return emoji;
}
}

34
src/main/java/wtf/beatrice/hidekobot/objects/commands/MessageCommand.java
View File

@@ -2,7 +2,6 @@ package wtf.beatrice.hidekobot.objects.commands;
import net.dv8tion.jda.api.Permission; import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent; import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.Nullable;
import java.util.LinkedList; import java.util.LinkedList;
@@ -40,40 +39,17 @@ public interface MessageCommand
*/ */
boolean passRawArgs(); boolean passRawArgs();
/**
* Say what category this command belongs to.
*
* @return the command category.
*/
@NotNull
CommandCategory getCategory();
/**
* Say what this command does.
*
* @return a String explaining what this command does.
*/
@NotNull
String getDescription();
/**
* Say how people should use this command.
*
* @return a String explaining how to use the command, excluding the bot prefix and command name. Null if no parameter is needed
*/
@Nullable
String getUsage();
/** /**
* Run the command logic by parsing the event and replying accordingly. * Run the command logic by parsing the event and replying accordingly.
* *
* @param event the received message event. It should not be used for parsing message contents data as * @param event the received message event. It should not be used for parsing message contents data as
* the arguments already account for it in a better way. * the arguments already account for it in a better way.
*
* @param label the command label that was used, taken from all available command aliases. * @param label the command label that was used, taken from all available command aliases.
* @param args a pre-formatted list of arguments, excluding the bot prefix and the command name. *
* This is useful because command logic won't have to change in case the bot prefix is changed, * @param args a pre-formatted list of arguments, excluding the bot prefix and the command name.
* removed, or we switch to another method of triggering commands (ping, trigger words, ...). * This is useful because command logic won't have to change in case the bot prefix is changed,
* removed, or we switch to another method of triggering commands (ping, trigger words, ...).
*/ */
void runCommand(MessageReceivedEvent event, String label, String[] args); void runCommand(MessageReceivedEvent event, String label, String[] args);
} }

1
src/main/java/wtf/beatrice/hidekobot/objects/commands/SlashArgumentsCompleter.java
View File

@@ -12,7 +12,6 @@ public interface SlashArgumentsCompleter
* @return the command object. * @return the command object.
*/ */
SlashCommand getCommand(); SlashCommand getCommand();
/** /**
* Run the argument-completion logic by parsing the event and replying accordingly. * Run the argument-completion logic by parsing the event and replying accordingly.
* *

5
src/main/java/wtf/beatrice/hidekobot/objects/commands/SlashArgumentsCompleterImpl.java
View File

@@ -6,16 +6,13 @@ import org.jetbrains.annotations.NotNull;
public class SlashArgumentsCompleterImpl implements SlashArgumentsCompleter public class SlashArgumentsCompleterImpl implements SlashArgumentsCompleter
{ {
private final SlashCommand parentCommand; private final SlashCommand parentCommand;
public SlashArgumentsCompleterImpl(SlashCommand parentCommand) public SlashArgumentsCompleterImpl(SlashCommand parentCommand)
{ {
this.parentCommand = parentCommand; this.parentCommand = parentCommand;
} }
public SlashCommand getCommand() public SlashCommand getCommand()
{ { return parentCommand; }
return parentCommand;
}
public void runCompletion(@NotNull CommandAutoCompleteInteractionEvent event) public void runCompletion(@NotNull CommandAutoCompleteInteractionEvent event)
{ {

1
src/main/java/wtf/beatrice/hidekobot/objects/commands/SlashCommand.java
View File

@@ -21,7 +21,6 @@ public interface SlashCommand
* @return the command data object. * @return the command data object.
*/ */
CommandData getSlashCommandData(); CommandData getSlashCommandData();
/** /**
* Run the command logic by parsing the event and replying accordingly. * Run the command logic by parsing the event and replying accordingly.
* *

9
src/main/java/wtf/beatrice/hidekobot/objects/commands/SlashCommandImpl.java
View File

@@ -8,20 +8,17 @@ public class SlashCommandImpl implements SlashCommand
{ {
@Override @Override
public String getCommandName() public String getCommandName() {
{
return getSlashCommandData().getName(); return getSlashCommandData().getName();
} }
@Override @Override
public CommandData getSlashCommandData() public CommandData getSlashCommandData() {
{
return null; return null;
} }
@Override @Override
public void runSlashCommand(@NotNull SlashCommandInteractionEvent event) public void runSlashCommand(@NotNull SlashCommandInteractionEvent event) {
{
event.reply("Base command implementation").queue(); event.reply("Base command implementation").queue();
} }
} }

10
src/main/java/wtf/beatrice/hidekobot/objects/comparators/MessageCommandAliasesComparator.java
View File

@@ -6,15 +6,13 @@ import java.util.LinkedList;
/** /**
* This class gets two linked lists, and compares their first value alphabetically. * This class gets two linked lists, and compares their first value alphabetically.
*/ */
public class MessageCommandAliasesComparator implements Comparator<LinkedList<String>> public class MessageCommandAliasesComparator implements Comparator<LinkedList<String>> {
{
@Override @Override
public int compare(LinkedList<String> linkedList, LinkedList<String> t1) public int compare(LinkedList<String> linkedList, LinkedList<String> t1) {
{
if (linkedList.isEmpty()) return 0; if(linkedList.isEmpty()) return 0;
if (t1.isEmpty()) return 0; if(t1.isEmpty()) return 0;
return linkedList.get(0).compareTo(t1.get(0)); return linkedList.get(0).compareTo(t1.get(0));
} }

18
src/main/java/wtf/beatrice/hidekobot/objects/comparators/TriviaCategoryComparator.java
View File

@@ -1,18 +0,0 @@
package wtf.beatrice.hidekobot.objects.comparators;
import wtf.beatrice.hidekobot.objects.fun.TriviaCategory;
import java.util.Comparator;
/**
* This class gets two trivia categories, and compares them by their name.
*/
public class TriviaCategoryComparator implements Comparator<TriviaCategory>
{
@Override
public int compare(TriviaCategory o1, TriviaCategory o2)
{
return CharSequence.compare(o1.categoryName(), o2.categoryName());
}
}

18
src/main/java/wtf/beatrice/hidekobot/objects/comparators/TriviaScoreComparator.java
View File

@@ -1,18 +0,0 @@
package wtf.beatrice.hidekobot.objects.comparators;
import wtf.beatrice.hidekobot.objects.fun.TriviaScore;
import java.util.Comparator;
/**
* This class gets two trivia scores, and compares their score.
*/
public class TriviaScoreComparator implements Comparator<TriviaScore>
{
@Override
public int compare(TriviaScore o1, TriviaScore o2)
{
return Integer.compare(o2.getScore(), o1.getScore()); // inverted, because higher number should come first
}
}

6
src/main/java/wtf/beatrice/hidekobot/objects/fun/TriviaCategory.java
View File

@@ -1,6 +0,0 @@
package wtf.beatrice.hidekobot.objects.fun;
public record TriviaCategory(String categoryName, int categoryId)
{
}

9
src/main/java/wtf/beatrice/hidekobot/objects/fun/TriviaQuestion.java
View File

@@ -1,9 +0,0 @@
package wtf.beatrice.hidekobot.objects.fun;
import java.util.List;
public record TriviaQuestion(String question, String correctAnswer,
List<String> wrongAnswers)
{
}

37
src/main/java/wtf/beatrice/hidekobot/objects/fun/TriviaScore.java
View File

@@ -1,37 +0,0 @@
package wtf.beatrice.hidekobot.objects.fun;
import net.dv8tion.jda.api.entities.User;
public class TriviaScore
{
private final User user;
private int score = 0;
public TriviaScore(User user)
{
this.user = user;
}
public void changeScore(int add)
{
score += add;
}
public int getScore()
{
return score;
}
public User getUser()
{
return user;
}
@Override
public String toString()
{
return "[" + user.getAsTag() + "," + score + "]";
}
}

124
src/main/java/wtf/beatrice/hidekobot/runnables/ExpiredMessageTask.java
View File

@@ -1,20 +1,26 @@
package wtf.beatrice.hidekobot.runnables; package wtf.beatrice.hidekobot.runnables;
import org.slf4j.Logger; import net.dv8tion.jda.api.entities.Guild;
import org.slf4j.LoggerFactory; import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.ChannelType;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.interactions.components.LayoutComponent;
import net.dv8tion.jda.api.requests.RestAction;
import wtf.beatrice.hidekobot.Cache; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.datasources.DatabaseSource; import wtf.beatrice.hidekobot.datasources.DatabaseSource;
import wtf.beatrice.hidekobot.util.CommandUtil; import wtf.beatrice.hidekobot.util.Logger;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.List; import java.util.List;
public class ExpiredMessageTask implements Runnable public class ExpiredMessageTask implements Runnable {
{
private final DateTimeFormatter formatter; private final DateTimeFormatter formatter;
private static final Logger LOGGER = LoggerFactory.getLogger(ExpiredMessageTask.class); private final Logger logger;
private DatabaseSource databaseSource; private DatabaseSource databaseSource;
@@ -23,28 +29,28 @@ public class ExpiredMessageTask implements Runnable
String format = Cache.getExpiryTimestampFormat(); String format = Cache.getExpiryTimestampFormat();
formatter = DateTimeFormatter.ofPattern(format); formatter = DateTimeFormatter.ofPattern(format);
databaseSource = Cache.getDatabaseSource(); databaseSource = Cache.getDatabaseSource();
logger = new Logger(getClass());
} }
@Override @Override
public void run() public void run() {
{
databaseSource = Cache.getDatabaseSource(); databaseSource = Cache.getDatabaseSource();
if (databaseSource == null) return; if(databaseSource == null) return;
List<String> expiringMessages = Cache.getDatabaseSource().getQueuedExpiringMessages(); List<String> expiringMessages = Cache.getDatabaseSource().getQueuedExpiringMessages();
if (expiringMessages == null || expiringMessages.isEmpty()) return; if(expiringMessages == null || expiringMessages.isEmpty()) return;
LocalDateTime now = LocalDateTime.now(); LocalDateTime now = LocalDateTime.now();
for (String messageId : expiringMessages) for(String messageId : expiringMessages)
{ {
if (Cache.isVerbose()) LOGGER.info("expired check: {}", messageId); if(Cache.isVerbose()) logger.log("expired check: " + messageId);
String expiryTimestamp = databaseSource.getQueuedExpiringMessageExpiryDate(messageId); String expiryTimestamp = databaseSource.getQueuedExpiringMessageExpiryDate(messageId);
if (expiryTimestamp == null || expiryTimestamp.isEmpty()) // if missing timestamp if(expiryTimestamp == null || expiryTimestamp.equals("")) // if missing timestamp
{ {
// count it as already expired // count it as already expired
databaseSource.untrackExpiredMessage(messageId); databaseSource.untrackExpiredMessage(messageId);
@@ -54,12 +60,98 @@ public class ExpiredMessageTask implements Runnable
LocalDateTime expiryDate = LocalDateTime.parse(expiryTimestamp, formatter); LocalDateTime expiryDate = LocalDateTime.parse(expiryTimestamp, formatter);
if (now.isAfter(expiryDate)) if(now.isAfter(expiryDate))
{ {
if (Cache.isVerbose()) LOGGER.info("expired: {}", messageId); if(Cache.isVerbose()) logger.log("expired: " + messageId);
CommandUtil.disableExpired(messageId); disableExpired(messageId);
} }
} }
}
private void disableExpired(String messageId)
{
String channelId = databaseSource.getQueuedExpiringMessageChannel(messageId);
ChannelType msgChannelType = databaseSource.getTrackedMessageChannelType(messageId);
MessageChannel textChannel = null;
// this should never happen, but only message channels are supported.
if(!msgChannelType.isMessage())
{
databaseSource.untrackExpiredMessage(messageId);
return;
}
// if this is a DM
if(!(msgChannelType.isGuild()))
{
String userId = databaseSource.getTrackedReplyUserId(messageId);
User user = HidekoBot.getAPI().retrieveUserById(userId).complete();
if(user == null)
{
// if user is not found, consider it expired
// (deleted profile, or blocked the bot)
databaseSource.untrackExpiredMessage(messageId);
return;
}
textChannel = user.openPrivateChannel().complete();
}
else
{
String guildId = databaseSource.getQueuedExpiringMessageGuild(messageId);
Guild guild = HidekoBot.getAPI().getGuildById(guildId);
if(guild == null)
{
// if guild is not found, consider it expired
// (server was deleted or bot was kicked)
databaseSource.untrackExpiredMessage(messageId);
return;
}
textChannel = guild.getTextChannelById(channelId);
}
if(textChannel == null)
{
// if channel is not found, count it as expired
// (channel was deleted or bot permissions restricted)
databaseSource.untrackExpiredMessage(messageId);
return;
}
RestAction<Message> retrieveAction = textChannel.retrieveMessageById(messageId);
if(Cache.isVerbose()) logger.log("cleaning up: " + messageId);
retrieveAction.queue(
message -> {
if(message == null)
{
databaseSource.untrackExpiredMessage(messageId);
return;
}
List<LayoutComponent> components = message.getComponents();
List<LayoutComponent> newComponents = new ArrayList<>();
for (LayoutComponent component : components)
{
component = component.asDisabled();
newComponents.add(component);
}
message.editMessageComponents(newComponents).queue();
databaseSource.untrackExpiredMessage(messageId);
},
(error) -> {
databaseSource.untrackExpiredMessage(messageId);
});
} }
} }

31
src/main/java/wtf/beatrice/hidekobot/runnables/HeartBeatTask.java
View File

@@ -1,8 +1,7 @@
package wtf.beatrice.hidekobot.runnables; package wtf.beatrice.hidekobot.runnables;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.Cache; import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.util.Logger;
import java.io.IOException; import java.io.IOException;
import java.net.HttpURLConnection; import java.net.HttpURLConnection;
@@ -10,16 +9,22 @@ import java.net.URL;
public class HeartBeatTask implements Runnable public class HeartBeatTask implements Runnable
{ {
private static final Logger LOGGER = LoggerFactory.getLogger(HeartBeatTask.class); private final Logger logger;
public HeartBeatTask()
{
logger = new Logger(getClass());
}
@Override @Override
public void run() public void run()
{ {
String urlString = Cache.getFullHeartBeatLink(); String urlString = Cache.getFullHeartBeatLink();
if (urlString == null || urlString.isEmpty()) return; if(urlString == null || urlString.isEmpty()) return;
try try {
{
URL heartbeatUrl = new URL(urlString); URL heartbeatUrl = new URL(urlString);
@@ -29,18 +34,18 @@ public class HeartBeatTask implements Runnable
connection.setReadTimeout(5000); connection.setReadTimeout(5000);
int responseCode = connection.getResponseCode(); int responseCode = connection.getResponseCode();
if (200 <= responseCode && responseCode < 300) if(200 <= responseCode && responseCode < 300)
{ {
// only log ok response codes when verbosity is enabled // only log ok response codes when verbosity is enabled
if (Cache.isVerbose()) LOGGER.info("Heartbeat response code: {}", responseCode); if(Cache.isVerbose()) logger.log("Heartbeat response code: " + responseCode);
} else }
else
{ {
LOGGER.error("Heartbeat returned problematic response code: {}", responseCode); logger.log("Heartbeat returned problematic response code: " + responseCode);
} }
} catch (IOException e) } catch (IOException e) {
{ logger.log("Error while trying to push heartbeat: " + e.getMessage());
LOGGER.error("Error while trying to push heartbeat", e);
} }
} }

30
src/main/java/wtf/beatrice/hidekobot/runnables/RandomOrgSeedTask.java
View File

@@ -1,30 +0,0 @@
package wtf.beatrice.hidekobot.runnables;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.util.RandomUtil;
/**
* This runnable pulls a random seed from random.org and used it to feed a SecureRandom,
* if the integration is enabled.
* <br/>
* This is necessary since we are not directly accessing random.org for each random number we
* need, and thus, only the seed is random - not the algorithm applied to it to compute the numbers.
*/
public class RandomOrgSeedTask implements Runnable
{
private static final Logger LOGGER = LoggerFactory.getLogger(RandomOrgSeedTask.class);
@Override
public void run()
{
if (RandomUtil.isRandomOrgKeyValid())
{
if (Cache.isVerbose()) LOGGER.info("Updating Random seed from random.org...");
RandomUtil.initRandomOrg();
if (Cache.isVerbose()) LOGGER.info("Random.org seed updated!");
}
}
}

31
src/main/java/wtf/beatrice/hidekobot/runnables/StatusUpdateTask.java
View File

@@ -1,31 +0,0 @@
package wtf.beatrice.hidekobot.runnables;
import net.dv8tion.jda.api.entities.Activity;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.util.RandomUtil;
import java.util.Arrays;
import java.util.List;
public class StatusUpdateTask implements Runnable
{
List<String> statuses = Arrays.asList(
"Hatsune Miku: Project DIVA",
"Wii Sports",
"Excel",
"Mii Channel",
"Wii Speak",
"Minetest",
"Mario Kart Wii"
);
@Override
public void run()
{
int randomPos = RandomUtil.getRandomNumber(0, statuses.size() - 1);
String status = statuses.get(randomPos) + " | " + Cache.getBotPrefix() + " help";
HidekoBot.getAPI().getPresence().setActivity(Activity.playing(status));
}
}

205
src/main/java/wtf/beatrice/hidekobot/runnables/TriviaTask.java
View File

@@ -1,205 +0,0 @@
package wtf.beatrice.hidekobot.runnables;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.entities.emoji.Emoji;
import net.dv8tion.jda.api.interactions.components.buttons.Button;
import org.json.JSONObject;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.commands.base.Trivia;
import wtf.beatrice.hidekobot.objects.comparators.TriviaScoreComparator;
import wtf.beatrice.hidekobot.objects.fun.TriviaCategory;
import wtf.beatrice.hidekobot.objects.fun.TriviaQuestion;
import wtf.beatrice.hidekobot.objects.fun.TriviaScore;
import wtf.beatrice.hidekobot.util.CommandUtil;
import java.util.*;
import java.util.concurrent.ScheduledFuture;
public class TriviaTask implements Runnable
{
private final User author;
private final MessageChannel channel;
private Message previousMessage = null;
private final JSONObject triviaJson;
private final List<TriviaQuestion> questions;
private final TriviaCategory category;
ScheduledFuture<?> future = null;
private int iteration = 0;
public TriviaTask(User author, MessageChannel channel, TriviaCategory category)
{
this.author = author;
this.channel = channel;
this.category = category;
triviaJson = Trivia.fetchJson(Trivia.getTriviaLink(category.categoryId()));
questions = Trivia.parseQuestions(triviaJson); //todo: null check, rate limiting...
}
public void setScheduledFuture(ScheduledFuture<?> future)
{
this.future = future;
}
@Override
public void run()
{
if (previousMessage != null)
{
// todo: we shouldn't use this method, since it messes with the database... look at coin reflip
CommandUtil.disableExpired(previousMessage.getId());
String previousCorrectAnswer = questions.get(iteration - 1).correctAnswer();
// we need this to be thread-locking to avoid getting out of sync with the rest of the trivia features
previousMessage.reply("The correct answer was: **" + previousCorrectAnswer + "**!").complete();
// todo: maybe also add who replied correctly as a list
// clean the list of people who answered, so they can answer again for the new question
Trivia.channelAndWhoResponded.put(previousMessage.getChannel().getId(), new ArrayList<>());
}
if (iteration >= questions.size())
{
String scoreboardText = "\uD83D\uDC23 Trivia session is over!";
List<String> winners = new ArrayList<>();
int topScore = 0;
StringBuilder othersBuilder = new StringBuilder();
LinkedList<TriviaScore> triviaScores = Trivia.channelAndScores.get(channel.getId());
if (triviaScores == null) triviaScores = new LinkedList<>();
else triviaScores.sort(new TriviaScoreComparator());
int pos = 0;
Integer previousScore = null;
for (TriviaScore triviaScore : triviaScores)
{
if (pos > 10) break; // cap at top 10
String user = triviaScore.getUser().getAsMention();
int score = triviaScore.getScore();
if (previousScore == null)
{
previousScore = score;
topScore = score;
pos = 1;
} else
{
if (score != previousScore) pos++;
}
if (pos == 1) winners.add(user);
else
{
othersBuilder.append("\n").append(pos)
.append(" | ").append(user)
.append(": ").append(score).append(" points");
}
}
StringBuilder winnersBuilder = new StringBuilder();
for (int i = 0; i < winners.size(); i++)
{
String winner = winners.get(i);
winnersBuilder.append(winner);
if (i + 1 != winners.size())
{
winnersBuilder.append(", "); // separate with comma except on last run
} else
{
winnersBuilder.append(": ").append(topScore).append(" points \uD83C\uDF89");
}
}
String winnersTitle = "\uD83D\uDCAB ";
winnersTitle += winners.size() == 1 ? "Winner" : "Winners";
String winnersString = winnersBuilder.toString();
String othersString = othersBuilder.toString();
EmbedBuilder scoreboardBuilder = new EmbedBuilder();
scoreboardBuilder.setColor(Cache.getBotColor());
scoreboardBuilder.setTitle("\uD83C\uDF1F Trivia Scoreboard");
if (!winnersString.isEmpty()) scoreboardBuilder.addField(winnersTitle, winnersString, false);
else scoreboardBuilder.addField("\uD83D\uDE22 Sad Trivia",
"No one played \uD83D\uDE2D", false);
if (!othersString.isEmpty()) scoreboardBuilder.addField("☁️ Others", othersString, false);
channel.sendMessage(scoreboardText).addEmbeds(scoreboardBuilder.build()).queue();
// remove all cached data
Trivia.channelsRunningTrivia.remove(channel.getId());
Trivia.channelAndWhoResponded.remove(channel.getId());
Trivia.channelAndScores.remove(channel.getId());
future.cancel(false);
// we didn't implement null checks on the future on purpose, because we need to know if we were unable
// to cancel it (and console errors should make it clear enough).
return;
}
TriviaQuestion currentTriviaQuestion = questions.get(iteration);
List<Button> answerButtons = new ArrayList<>();
Button correctAnswerButton = Button.primary("trivia_correct", currentTriviaQuestion.correctAnswer());
answerButtons.add(correctAnswerButton);
int i = 0; // we need to add a number because buttons can't have the same id
for (String wrongAnswer : currentTriviaQuestion.wrongAnswers())
{
i++;
Button wrongAnswerButton = Button.primary("trivia_wrong_" + i, wrongAnswer);
answerButtons.add(wrongAnswerButton);
}
Collections.shuffle(answerButtons);
List<String> buttonEmojis = Arrays.asList("\uD83D\uDD34", "\uD83D\uDD35",
"\uD83D\uDFE2", "\uD83D\uDFE1", "\uD83D\uDFE4", "\uD83D\uDFE3", "\uD83D\uDFE0");
// add emojis to buttons
for (int emojiPos = 0; emojiPos < buttonEmojis.size(); emojiPos++)
{
if (emojiPos == answerButtons.size()) break;
String emoji = buttonEmojis.get(emojiPos);
Button button = answerButtons.get(emojiPos);
answerButtons.set(emojiPos, button.withEmoji(Emoji.fromUnicode(emoji)));
}
EmbedBuilder embedBuilder = new EmbedBuilder();
embedBuilder.setColor(Cache.getBotColor());
embedBuilder.setTitle("\uD83C\uDFB2 Trivia - " + category.categoryName() +
" (" + (iteration + 1) + "/" + questions.size() + ")");
embedBuilder.addField("❓ Question", currentTriviaQuestion.question(), false);
previousMessage = channel
.sendMessageEmbeds(embedBuilder.build())
.setActionRow(answerButtons)
.complete();
Cache.getDatabaseSource().trackRanCommandReply(previousMessage, author);
// todo: ^ we should get rid of this tracking, since we don't need to know who started the trivia.
// todo: however, for now, that's the only way to avoid a thread-locking scenario as some data is
// todo: only stored in that table. this should be solved when we merge / fix the two main tables.
// todo: then, we can remove this instruction.
Cache.getDatabaseSource().queueDisabling(previousMessage);
iteration++;
}
}

245
src/main/java/wtf/beatrice/hidekobot/util/CommandUtil.java
View File

@@ -1,245 +0,0 @@
package wtf.beatrice.hidekobot.util;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.entities.channel.ChannelType;
import net.dv8tion.jda.api.entities.channel.middleman.MessageChannel;
import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
import net.dv8tion.jda.api.interactions.commands.Command;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import net.dv8tion.jda.api.interactions.components.LayoutComponent;
import net.dv8tion.jda.api.requests.RestAction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.datasources.DatabaseSource;
import wtf.beatrice.hidekobot.objects.commands.SlashCommand;
import java.util.ArrayList;
import java.util.List;
public class CommandUtil
{
private static final Logger LOGGER = LoggerFactory.getLogger(CommandUtil.class);
private CommandUtil()
{
throw new IllegalStateException("Utility class");
}
/**
* Function to delete a message when a user clicks the "delete" button attached to that message.
* This will check in the database if that user ran the command originally.
*
* @param event the button interaction event.
*/
public static void delete(ButtonInteractionEvent event)
{
// check if the user interacting is the same one who ran the command
if (!(Cache.getDatabaseSource().isUserTrackedFor(event.getUser().getId(), event.getMessageId())))
{
event.reply("❌ You did not run this command!").setEphemeral(true).queue();
return;
}
// delete the message
event.getInteraction().getMessage().delete().queue();
// no need to manually untrack it from database, it will be purged on the next planned check.
}
/**
* Method to update slash commands registered on Discord's side.
* It runs automatically every time the bot starts, but only updates the commands in case differences
* are found, unless forced.
*
* @param force a boolean specifying if the update should be forced even if no differences were found.
*/
public static void updateSlashCommands(boolean force)
{
// populate commands list from registered commands
List<CommandData> allCommands = new ArrayList<>();
for (SlashCommand cmd : Cache.getSlashCommandListener().getRegisteredCommands())
{
allCommands.add(cmd.getSlashCommandData());
}
JDA jdaInstance = HidekoBot.getAPI();
// get all the already registered commands
List<Command> registeredCommands = jdaInstance.retrieveCommands().complete();
boolean update = false;
if (force)
{
update = true;
} else
{
// for each command that we have already registered...
for (Command currRegCmd : registeredCommands)
{
boolean found = false;
// iterate through all "recognized" commands
for (CommandData cmdData : allCommands)
{
// if we find the same command...
if (cmdData.getName().equals(currRegCmd.getName()))
{
// quit the loop since we found it.
found = true;
break;
}
}
// if no match was found, we need to send an updated command list because
// an old command was probably removed.
if (!found)
{
update = true;
// quit the loop since we only need to trigger this once.
break;
}
}
// if an update is not already queued...
if (!update)
{
// for each "recognized" valid command
for (CommandData currCmdData : allCommands)
{
boolean found = false;
// iterate through all already registered commands.
for (Command cmd : registeredCommands)
{
// if this command was already registered...
if (cmd.getName().equals(currCmdData.getName()))
{
// quit the loop since we found a match.
found = true;
break;
}
}
// if no match was found, we need to send an updated command list because
// a new command was probably added.
if (!found)
{
update = true;
// quit the loop since we only need to trigger this once.
break;
}
}
}
}
LOGGER.info("Found {} commands.", registeredCommands.size());
if (update)
{
// send updated command list.
jdaInstance.updateCommands().addCommands(allCommands).queue();
LOGGER.info("Commands updated. New total: {}.", allCommands.size());
}
}
/**
* Method to disable all buttons from an expired message.
*
* @param messageId the message id to disable.
*/
public static void disableExpired(String messageId)
{
DatabaseSource databaseSource = Cache.getDatabaseSource();
String channelId = databaseSource.getQueuedExpiringMessageChannel(messageId);
// todo: warning, the following method + related if check are thread-locking.
// todo: we should probably merge the two tables somehow, since they have redundant information.
ChannelType msgChannelType = databaseSource.getTrackedMessageChannelType(messageId);
MessageChannel textChannel = null;
// this should never happen, but only message channels are supported.
if (!msgChannelType.isMessage())
{
databaseSource.untrackExpiredMessage(messageId);
return;
}
// if this is a DM
if (!(msgChannelType.isGuild()))
{
String userId = databaseSource.getTrackedReplyUserId(messageId);
User user = userId == null ? null : HidekoBot.getAPI().retrieveUserById(userId).complete();
if (user == null)
{
// if user is not found, consider it expired
// (deleted profile, or blocked the bot)
databaseSource.untrackExpiredMessage(messageId);
return;
}
textChannel = user.openPrivateChannel().complete();
} else
{
String guildId = databaseSource.getQueuedExpiringMessageGuild(messageId);
Guild guild = guildId == null ? null : HidekoBot.getAPI().getGuildById(guildId);
if (guild == null)
{
// if guild is not found, consider it expired
// (server was deleted or bot was kicked)
databaseSource.untrackExpiredMessage(messageId);
return;
}
textChannel = guild.getTextChannelById(channelId);
}
if (textChannel == null)
{
// if channel is not found, count it as expired
// (channel was deleted or bot permissions restricted)
databaseSource.untrackExpiredMessage(messageId);
return;
}
RestAction<Message> retrieveAction = textChannel.retrieveMessageById(messageId);
if (Cache.isVerbose()) LOGGER.info("cleaning up: {}", messageId);
retrieveAction.queue(
message -> {
if (message == null)
{
databaseSource.untrackExpiredMessage(messageId);
return;
}
List<LayoutComponent> components = message.getComponents();
List<LayoutComponent> newComponents = new ArrayList<>();
for (LayoutComponent component : components)
{
component = component.asDisabled();
newComponents.add(component);
}
message.editMessageComponents(newComponents).queue();
databaseSource.untrackExpiredMessage(messageId);
},
error -> databaseSource.untrackExpiredMessage(messageId));
}
}

174
src/main/java/wtf/beatrice/hidekobot/util/FormatUtil.java
View File

@@ -1,170 +1,50 @@
package wtf.beatrice.hidekobot.util; package wtf.beatrice.hidekobot.util;
import org.jetbrains.annotations.NotNull; import wtf.beatrice.hidekobot.Cache;
import org.jetbrains.annotations.Nullable;
import java.time.Duration; import java.time.Duration;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit; import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalUnit;
import java.util.Arrays;
public class FormatUtil public class FormatUtil
{ {
private FormatUtil()
{
throw new IllegalStateException("Utility class");
}
// cosmetic string to print on startup.
private static final String LOGO = """
\s
██╗░░██╗██╗██████╗░███████╗██╗░░██╗░█████╗░
██║░░██║██║██╔══██╗██╔════╝██║░██╔╝██╔══██╗
███████║██║██║░░██║█████╗░░█████═╝░██║░░██║
██╔══██║██║██║░░██║██╔══╝░░██╔═██╗░██║░░██║
██║░░██║██║██████╔╝███████╗██║░╚██╗╚█████╔╝
╚═╝░░╚═╝╚═╝╚═════╝░╚══════╝╚═╝░░╚═╝░╚════╝░
\s""";
/** /**
* Returns ASCII art saying the bot name. * Generate a nicely formatted uptime String that omits unnecessary data
*
* @return a String containing the logo
*/
public static String getLogo()
{
return LOGO;
}
/**
* Generate a nicely formatted time-diff String that omits unnecessary data
* (e.g. 0 days, 0 hours, 4 minutes, 32 seconds -> 4m 32s) * (e.g. 0 days, 0 hours, 4 minutes, 32 seconds -> 4m 32s)
* *
* @return the formatted String * @return the formatter String
*/ */
public static String getNiceTimeDiff(LocalDateTime start) public static String getNiceUptime()
{ {
LocalDateTime now = LocalDateTime.now(); LocalDateTime now = LocalDateTime.now();
long uptimeSeconds = ChronoUnit.SECONDS.between(start, now); long uptimeSeconds = ChronoUnit.SECONDS.between(Cache.getStartupTime(), now);
Duration uptime = Duration.ofSeconds(uptimeSeconds); Duration uptime = Duration.ofSeconds(uptimeSeconds);
long seconds = uptime.toSecondsPart();
long minutes = uptime.toMinutesPart();
long hours = uptime.toHoursPart();
long days = uptime.toDays();
return getNiceDuration(uptime); StringBuilder uptimeStringBuilder = new StringBuilder();
} if(days == 0)
/**
* Generate a nicely formatted duration String that omits unnecessary data
* (e.g. 0 days, 0 hours, 4 minutes, 32 seconds -> 4m 32s)
*
* @return the formatted String
*/
public static String getNiceDuration(Duration duration)
{
long days = duration.toDays();
long hours = duration.toHoursPart();
long minutes = duration.toMinutesPart();
long seconds = duration.toSecondsPart();
StringBuilder sb = new StringBuilder();
if (days > 0)
{ {
sb.append(days).append("d "); if(hours == 0)
sb.append(hours).append("h "); {
sb.append(minutes).append("m "); if(minutes == 0)
} else if (hours > 0) {} else {
{ uptimeStringBuilder.append(minutes).append("m ");
sb.append(hours).append("h "); }
sb.append(minutes).append("m "); } else {
} else if (minutes > 0) uptimeStringBuilder.append(hours).append("h ");
{ uptimeStringBuilder.append(minutes).append("m ");
sb.append(minutes).append("m "); }
} else {
uptimeStringBuilder.append(days).append("d ");
uptimeStringBuilder.append(hours).append("h ");
uptimeStringBuilder.append(minutes).append("m ");
} }
sb.append(seconds).append("s"); uptimeStringBuilder.append(seconds).append("s ");
return sb.toString();
}
/**
* Method to parse a string into a duration.
* Warning: this only supports up to days; months and longer timeframes are unsupported.
*
* @param duration the String to parse.
* @return a Duration of the parsed timeframe, or null if parsing failed.
*/
@Nullable
public static Duration parseDuration(String duration)
{
// sanitize a bit to avoid cluttering with garbled strings
if (duration.length() > 16) duration = duration.substring(0, 16);
duration = duration.replaceAll("[^\\w]", ""); //only keep digits and word characters
duration = duration.toLowerCase();
/* the following regex matches any number followed by any amount of characters, any amount of times.
eg: 3d, 33hours, 32048dojg, 3d2h5m22s.
it does not match if the [digits and characters] blocks are missing.
eg: 33, asd, 3g5hj, 4 asd.
{1,10} is used to limit the size of the input to parse, to avoid stack overflows.
no one should be typing more than 10 arguments, or more than 10 digits for a single argument anyway.
*/
if (!duration.matches("(\\d{1,10}[a-zA-Z]{1,10}){1,10}"))
return null;
String[] durationTimes = duration.split("[a-zA-Z]+");
String[] durationUnits = duration.split("\\d+");
// remove first element, because it will always be empty (there's nothing before the first character)
durationUnits = Arrays.copyOfRange(durationUnits, 1, durationUnits.length);
Duration fullDuration = Duration.ZERO;
for (int i = 0; i < durationTimes.length; i++)
{
String durationTimeStr = durationTimes[i];
String durationUnitStr = durationUnits[i];
int durationValue = Integer.parseInt(durationTimeStr);
TemporalUnit unit = parseTimeUnit(durationUnitStr);
if (unit != null)
fullDuration = fullDuration.plus(durationValue, unit);
else return null; // if we failed finding the time unit, instantly quit with failed parsing.
}
return fullDuration;
}
@Nullable
private static TemporalUnit parseTimeUnit(@NotNull String unitName)
{
// we won't do any sanitization, because this is a private method, and
// we are only accessing it with things that we know for sure are already sanitized.
unitName = unitName.toLowerCase();
TemporalUnit timeUnit;
/*
parsing table
s, se, sec, second, seconds -> SECOND
m, mi, min, minute, minutes -> MINUTE
h, ho, hr, hour, hours -> HOUR
d, day, days -> DAY
(months and longer timeframes are unsupported due to Discord restrictions)
*/
switch (unitName)
{
case "s", "se", "sec", "second", "seconds" -> timeUnit = ChronoUnit.SECONDS;
case "m", "mi", "min", "minute", "minutes" -> timeUnit = ChronoUnit.MINUTES;
case "h", "ho", "hr", "hour", "hours" -> timeUnit = ChronoUnit.HOURS;
case "d", "day", "days" -> timeUnit = ChronoUnit.DAYS;
default -> timeUnit = null;
}
return timeUnit;
return uptimeStringBuilder.toString();
} }
} }

35
src/main/java/wtf/beatrice/hidekobot/util/Logger.java
View File

@@ -3,22 +3,29 @@ package wtf.beatrice.hidekobot.util;
import java.time.LocalDateTime; import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter; import java.time.format.DateTimeFormatter;
import java.util.concurrent.Executors; import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeUnit;
@Deprecated(since = "0.5.16", forRemoval = true) public class Logger
public class Logger<T>
{ {
// cosmetic string to print on startup.
private String logo =
"██╗░░██╗██╗██████╗░███████╗██╗░░██╗░█████╗░\n" +
"██║░░██║██║██╔══██╗██╔════╝██║░██╔╝██╔══██╗\n" +
"███████║██║██║░░██║█████╗░░█████═╝░██║░░██║\n" +
"██╔══██║██║██║░░██║██╔══╝░░██╔═██╗░██║░░██║\n" +
"██║░░██║██║██████╔╝███████╗██║░╚██╗╚█████╔╝\n" +
"╚═╝░░╚═╝╚═╝╚═════╝░╚══════╝╚═╝░░╚═╝░╚════╝░";
// objects that we need to have for a properly formatted message // objects that we need to have for a properly formatted message
private final String className; private String className;
private final String format = "[%date% %time%] [%class%] %message%"; private final String format = "[%date% %time%] [%class%] %message%";
private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd"); private final DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("YYYY-MM-dd");
private final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss"); private final DateTimeFormatter timeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
// when initializing a new logger, save variables in that instance // when initializing a new logger, save variables in that instance
public Logger(Class<T> logClass) public Logger(Class logClass)
{ {
className = logClass.getSimpleName(); className = logClass.getSimpleName();
} }
@@ -44,16 +51,13 @@ public class Logger<T>
* Logs a message to console, after delaying it. * Logs a message to console, after delaying it.
* *
* @param message the message to log * @param message the message to log
* @param delay the time to wait before logging, in seconds * @param delay the time to wait before logging, in seconds
*/ */
public void log(String message, int delay) public void log(String message, int delay)
{ {
// create a new scheduled executor with an anonymous runnable... // create a new scheduled executor with an anonymous runnable...
//... after waiting <delay> seconds. //... after waiting <delay> seconds.
try (ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor()) Executors.newSingleThreadScheduledExecutor().schedule(() -> log(message), delay, TimeUnit.SECONDS);
{
executor.schedule(() -> log(message), delay, TimeUnit.SECONDS);
}
} }
@@ -67,5 +71,14 @@ public class Logger<T>
System.out.println(message); System.out.println(message);
} }
/**
* Returns ASCII art saying the bot name.
*
* @return a String containing the logo
*/
public String getLogo()
{
return logo;
}
} }

55
src/main/java/wtf/beatrice/hidekobot/util/RandomUtil.java
View File

@@ -1,23 +1,11 @@
package wtf.beatrice.hidekobot.util; package wtf.beatrice.hidekobot.util;
import org.random.util.RandomOrgRandom;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.datasources.ConfigurationEntry;
import java.security.SecureRandom;
import java.util.Random; import java.util.Random;
public class RandomUtil public class RandomUtil
{ {
private static final Random random = new Random();
private RandomUtil()
{
throw new IllegalStateException("Utility class");
}
// the Random instance that we should always use when looking for an RNG based thing.
// the seed is updated periodically, if the random.org integration is enabled.
private static Random randomInstance = new SecureRandom();
/** /**
* Returns a random integer picked in a range. * Returns a random integer picked in a range.
@@ -28,8 +16,8 @@ public class RandomUtil
*/ */
public static int getRandomNumber(int min, int max) public static int getRandomNumber(int min, int max)
{ {
if (min == max) return min; // dumbass if(min == max) return min; // dumbass
if (min > max) // swap em if(min > max) // swap em
{ {
min = min - max; min = min - max;
max = min + max; max = min + max;
@@ -41,44 +29,9 @@ public class RandomUtil
int difference = (max - min) + 1; int difference = (max - min) + 1;
// find a number between 0 and our range (eg. 5 -> 8 = 0 -> 3) // find a number between 0 and our range (eg. 5 -> 8 = 0 -> 3)
int randomTemp = getRandom().nextInt(difference); int randomTemp = random.nextInt(difference);
// add the minimum value, so we are sure to be in the original range (0->5, 1->6, 2->7, 3->8) // add the minimum value, so we are sure to be in the original range (0->5, 1->6, 2->7, 3->8)
return randomTemp + min; return randomTemp + min;
} }
public static Random getRandom()
{
return randomInstance;
}
public static void initRandomOrg()
{
/* we use the random.org instance to generate 160 random bytes.
then, we're feeding those 160 bytes as a seed for a SecureRandom.
this is preferred to calling the RandomOrgRandom directly every time,
because it has to query the api and (1) takes a long time, especially with big
dice rolls, and (2) you'd run in the limits extremely quickly if the bot
was run publicly for everyone to use.
*/
String apiKey = Cache.getRandomOrgApiKey();
RandomOrgRandom randomOrg = new RandomOrgRandom(apiKey);
byte[] randomBytes = new byte[160];
randomOrg.nextBytes(randomBytes);
randomInstance = new SecureRandom(randomBytes);
}
public static boolean isRandomOrgKeyValid()
{
String apiKey = Cache.getRandomOrgApiKey();
return apiKey != null &&
!apiKey.isEmpty() &&
!apiKey.equals(ConfigurationEntry.RANDOM_ORG_API_KEY.getDefaultValue());
}
} }

48
src/main/java/wtf/beatrice/hidekobot/util/SerializationUtil.java
View File

@@ -1,48 +0,0 @@
package wtf.beatrice.hidekobot.util;
import org.apache.commons.lang3.SerializationException;
import java.io.*;
import java.util.Base64;
import java.util.LinkedList;
import java.util.List;
public class SerializationUtil
{
private SerializationUtil()
{
throw new IllegalStateException("Utility class");
}
public static <T> String serializeBase64(List<T> dataList)
{
try (ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream so = new ObjectOutputStream(bo))
{
so.writeObject(dataList);
so.flush();
return Base64.getEncoder().encodeToString(bo.toByteArray());
} catch (IOException e)
{
throw new SerializationException("Error during serialization", e);
}
}
public static <T> LinkedList<T> deserializeBase64(String dataStr)
{
byte[] b = Base64.getDecoder().decode(dataStr);
ByteArrayInputStream bi = new ByteArrayInputStream(b);
ObjectInputStream si;
try
{
si = new ObjectInputStream(bi);
return LinkedList.class.cast(si.readObject());
} catch (IOException | ClassNotFoundException e)
{
throw new SerializationException("Error during deserialization", e);
}
}
}

110
src/main/java/wtf/beatrice/hidekobot/util/SlashCommandUtil.java Normal file
View File

@@ -0,0 +1,110 @@
package wtf.beatrice.hidekobot.util;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.interactions.commands.Command;
import net.dv8tion.jda.api.interactions.commands.build.CommandData;
import wtf.beatrice.hidekobot.Cache;
import wtf.beatrice.hidekobot.HidekoBot;
import wtf.beatrice.hidekobot.listeners.MessageCommandListener;
import wtf.beatrice.hidekobot.objects.commands.SlashCommand;
import java.util.ArrayList;
import java.util.List;
public class SlashCommandUtil
{
private static final Logger logger = new Logger(MessageCommandListener.class);
public static void updateSlashCommands(boolean force)
{
// populate commands list from registered commands
List<CommandData> allCommands = new ArrayList<>();
for(SlashCommand cmd : Cache.getSlashCommandListener().getRegisteredCommands())
{ allCommands.add(cmd.getSlashCommandData()); }
JDA jdaInstance = HidekoBot.getAPI();
// get all the already registered commands
List<Command> registeredCommands = jdaInstance.retrieveCommands().complete();
boolean update = false;
if(force)
{
update = true;
} else
{
// for each command that we have already registered...
for(Command currRegCmd : registeredCommands)
{
boolean found = false;
// iterate through all "recognized" commands
for(CommandData cmdData : allCommands)
{
// if we find the same command...
if(cmdData.getName().equals(currRegCmd.getName()))
{
// quit the loop since we found it.
found = true;
break;
}
}
// if no match was found, we need to send an updated command list because
// an old command was probably removed.
if(!found)
{
update = true;
// quit the loop since we only need to trigger this once.
break;
}
}
// if an update is not already queued...
if(!update)
{
// for each "recognized" valid command
for(CommandData currCmdData : allCommands)
{
boolean found = false;
// iterate through all already registered commands.
for(Command cmd : registeredCommands)
{
// if this command was already registered...
if(cmd.getName().equals(currCmdData.getName()))
{
// quit the loop since we found a match.
found = true;
break;
}
}
// if no match was found, we need to send an updated command list because
// a new command was probably added.
if(!found)
{
update = true;
// quit the loop since we only need to trigger this once.
break;
}
}
}
}
logger.log("Found " + registeredCommands.size() + " commands.");
if(update)
{
// send updated command list.
jdaInstance.updateCommands().addCommands(allCommands).queue();
logger.log("Commands updated. New total: " + allCommands.size() + ".");
}
}
}

3
src/main/resources/default.properties
View File

@@ -1,2 +1 @@
bot.version=${project.version} bot.version=${project.version}
repo.base_url=https://git.beatrice.wtf/bea/HidekoBot/

12
suppressions.xml
View File

@@ -1,12 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<suppressions xmlns="https://jeremylong.github.io/DependencyCheck/dependency-suppression.1.3.xsd">
<!--
<suppress>
<notes><![CDATA[
file name: snakeyaml-1.33.jar
]]></notes>
<packageUrl regex="true">^pkg:maven/org\.yaml/snakeyaml@.*$</packageUrl>
<cve>CVE-2021-4235</cve>
</suppress>
-->
</suppressions>