devproje/px32-bot
1
2
Fork 0
mirror of https://github.com/devproje/px32-bot.git synced 2024-11-26 10:43:05 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

feat: middle save

Browse source
This commit is contained in:
Project_IO 2024-09-19 00:51:42 +09:00
parent e4afe685f7
commit ab91c823eb
25 changed files with 345 additions and 269 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
.dockerfile
View file

@ -1,45 +0,0 @@
.gradle
build/
!gradle/wrapper/gradle-wrapper.jar
!**/src/main/**/build/
!**/src/test/**/build/
.fleet/
.kotlin/
.env
!.env.example
### IntelliJ IDEA ###
.idea/
*.iws
*.iml
*.ipr
out/
!**/src/main/**/out/
!**/src/test/**/out/
### Eclipse ###
.apt_generated
.classpath
.factorypath
.project
.settings
.springBeans
.sts4-cache
bin/
!**/src/main/**/bin/
!**/src/test/**/bin/
### NetBeans ###
/nbproject/private/
/nbbuild/
/dist/
/nbdist/
/.nb-gradle/
### VS Code ###
.vscode/
### Mac OS ###
.DS_Store

17
Dockerfile
View file

@ -1,17 +0,0 @@
FROM amazoncorretto:21-alpine3.20
ARG BOT_TOKEN
ENV BOT_TOKEN=${BOT_TOKEN}
WORKDIR /opt/bot/build
COPY . .
RUN chmod a+x ./gradlew
RUN ./gradlew shadowJar
RUN cp ./build/libs/px32-bot.jar ../
WORKDIR /opt/bot
RUN rm -rf ./build
RUN export BOT_TOKEN=${BOT_TOKEN}
ENTRYPOINT ["java", "-Xmx4096M", "-jar", "/opt/bot/px32-bot.jar"]

60
build.gradle.kts
View file

@ -1,6 +1,7 @@
plugins {
id("java")
kotlin("jvm") version "2.0.20"
id("com.gradleup.shadow") version "8.3.0"
}
group = property("group")!!
@ -10,42 +11,37 @@ val ktor_version: String by project
val log4j_version: String by project
val exposed_version: String by project
allprojects {
apply(plugin = "java")
apply(plugin = "org.jetbrains.kotlin.jvm")
java {
toolchain {
languageVersion.set(JavaLanguageVersion.of(21))
}
sourceCompatibility = JavaVersion.VERSION_21
targetCompatibility = JavaVersion.VERSION_21
java {
toolchain {
languageVersion.set(JavaLanguageVersion.of(21))
}
repositories {
mavenCentral()
}
sourceCompatibility = JavaVersion.VERSION_21
targetCompatibility = JavaVersion.VERSION_21
}
subprojects {
dependencies {
implementation(kotlin("stdlib"))
implementation(kotlin("reflect"))
implementation("net.dv8tion:JDA:5.1.0")
implementation("io.ktor:ktor-client-cio:$ktor_version")
implementation("io.ktor:ktor-client-core:$ktor_version")
implementation("org.apache.logging.log4j:log4j-api:$log4j_version")
implementation("org.apache.logging.log4j:log4j-core:$log4j_version")
implementation("org.jetbrains.exposed:exposed-core:$exposed_version")
implementation("org.jetbrains.exposed:exposed-jdbc:$exposed_version")
implementation("org.apache.logging.log4j:log4j-slf4j2-impl:$log4j_version")
implementation("io.ktor:ktor-client-okhttp-jvm:2.3.12")
testImplementation(platform("org.junit:junit-bom:5.10.0"))
testImplementation("org.junit.jupiter:junit-jupiter")
}
repositories {
mavenCentral()
}
tasks.test {
useJUnitPlatform()
dependencies {
implementation(kotlin("stdlib"))
implementation(kotlin("reflect"))
implementation("net.dv8tion:JDA:5.1.0")
implementation("io.ktor:ktor-client-cio:$ktor_version")
implementation("io.ktor:ktor-client-core:$ktor_version")
implementation("org.apache.logging.log4j:log4j-api:$log4j_version")
implementation("org.apache.logging.log4j:log4j-core:$log4j_version")
implementation("org.jetbrains.exposed:exposed-core:$exposed_version")
implementation("org.jetbrains.exposed:exposed-jdbc:$exposed_version")
implementation("org.apache.logging.log4j:log4j-slf4j2-impl:$log4j_version")
implementation("io.ktor:ktor-client-okhttp-jvm:2.3.12")
testImplementation(platform("org.junit:junit-bom:5.10.0"))
testImplementation("org.junit.jupiter:junit-jupiter")
}
tasks {
test {
useJUnitPlatform()
}
}

17
compose.yml
View file

@ -1,17 +0,0 @@
services:
bot:
container_name: "P_x32-bot"
build:
context: .
dockerfile: "./Dockerfile"
env_file:
- ".env"
environment:
- BOT_TOKEN=${BOT_TOKEN}
networks:
- "bot"
volumes:
- "/etc/localtime:/etc/localtime:ro"
networks:
bot: {}

15
px32-bot-api/build.gradle.kts
View file

@ -1,15 +0,0 @@
plugins {
id("java")
}
group = rootProject.group
version = rootProject.version
dependencies {
testImplementation(platform("org.junit:junit-bom:5.10.0"))
testImplementation("org.junit.jupiter:junit-jupiter")
}
tasks.test {
useJUnitPlatform()
}

14
px32-bot-core/build.gradle.kts
View file

@ -1,14 +0,0 @@
plugins {
id("java")
}
group = rootProject.group
version = rootProject.version
repositories {
mavenCentral()
}
tasks.test {
useJUnitPlatform()
}

18
px32-bot-core/src/main/java/net/wh64/p/x32/KernelCore.java
View file

@ -1,18 +0,0 @@
package net.wh64.p.x32;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.JDABuilder;
public class KernelCore {
private final JDABuilder builder;
public KernelCore(String token) {
this.builder = JDABuilder.createDefault(token);
}
public JDA build() {
JDA jda = builder.build();
return jda;
}
}

17
px32-bot-core/src/main/kotlin/net/wh64/p/x32/GlobalCommandHandler.kt
View file

@ -1,17 +0,0 @@
package net.wh64.p.x32
import net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.UserContextInteractionEvent
import net.dv8tion.jda.api.hooks.ListenerAdapter
class GlobalCommandHandler : ListenerAdapter() {
override fun onSlashCommandInteraction(event: SlashCommandInteractionEvent) {
}
override fun onUserContextInteraction(event: UserContextInteractionEvent) {
}
override fun onMessageContextInteraction(event: MessageContextInteractionEvent) {
}
}

39
px32-bot-core/src/main/kotlin/net/wh64/p/x32/SlashCommandExecutor.kt
View file

@ -1,39 +0,0 @@
package net.wh64.p.x32
import net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.UserContextInteractionEvent
import net.dv8tion.jda.api.interactions.commands.build.CommandData
interface SlashCommandExecutor {
val data: CommandData
fun execute(ev: SlashCommandInteractionEvent)
}
interface UserContextExecutor {
val data: CommandData
fun execute(ev: UserContextInteractionEvent)
}
interface MessageContextExecutor {
val data: CommandData
fun execute(ev: MessageContextInteractionEvent)
}
abstract class CommandAdapter : SlashCommandExecutor, UserContextExecutor, MessageContextExecutor {
abstract override val data: CommandData
override fun execute(ev: SlashCommandInteractionEvent) {
executor(ev)
}
override fun execute(ev: UserContextInteractionEvent) {
executor(ev)
}
override fun execute(ev: MessageContextInteractionEvent) {
executor(ev)
}
abstract fun executor(ev: Any)
}

31
px32-bot-runner/build.gradle.kts
View file

@ -1,31 +0,0 @@
import org.jetbrains.kotlin.gradle.dsl.JvmTarget
import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
plugins {
id("com.gradleup.shadow") version "8.3.0"
}
group = rootProject.group
version = rootProject.version
tasks {
test {
useJUnitPlatform()
}
processResources {
filesMatching("default.properties") {
expand(project.properties)
}
}
withType<JavaCompile> {
options.encoding = "UTF-8"
}
withType<KotlinCompile> {
compilerOptions {
jvmTarget.set(JvmTarget.JVM_21)
}
}
}

20
px32-bot-runner/src/main/java/net/projecttl/p/x32/exec/Px32.java
View file

@ -1,20 +0,0 @@
package net.projecttl.p.x32.exec;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.JDABuilder;
import net.projecttl.p.x32.exec.config.DefaultConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class Px32 {
public static final Logger log = LoggerFactory.getLogger(Px32.class);
private static JDA jda;
public static void main(String[] args) {
JDABuilder builder = JDABuilder.createDefault(System.getenv("BOT_TOKEN"));
log.info("Px32 {}", DefaultConfig.INSTANCE.getVersion());
builder.setAutoReconnect(true);
jda = builder.build();
}
}

3
settings.gradle.kts
View file

@ -1,4 +1 @@
rootProject.name = "px32-bot"
include("px32-bot-runner")
include("px32-bot-core")
include("px32-bot-api")

16
src/main/kotlin/net/projecttl/p/x32/DefaultConfig.kt Normal file
View file

@ -0,0 +1,16 @@
package net.projecttl.p.x32
import java.util.*
import kotlin.reflect.KProperty
private class DefaultConfigDelegate {
private val props = Properties()
init {
props.load(this.javaClass.getResourceAsStream("/default.properties"))
}
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return props.getProperty(property.name).toString()
}
}

23
src/main/kotlin/net/projecttl/p/x32/Px32.kt Normal file
View file

@ -0,0 +1,23 @@
package net.projecttl.p.x32
import net.projecttl.p.x32.command.Avatar
import net.projecttl.p.x32.command.Ping
import net.projecttl.p.x32.handler.Ready
import net.projecttl.p.x32.kernel.CoreKernel
import org.slf4j.Logger
import org.slf4j.LoggerFactory
val logger: Logger = LoggerFactory.getLogger(Px32::class.java)
fun main() {
val kernel = CoreKernel(System.getenv("TOKEN"))
kernel.addHandler(Ready)
val handler = kernel.getGlobalCommandHandler()
handler.addCommand(Avatar)
handler.addCommand(Ping)
kernel.build()
}
class Px32

21
src/main/kotlin/net/projecttl/p/x32/command/Avatar.kt Normal file
View file

@ -0,0 +1,21 @@
package net.projecttl.p.x32.command
import net.dv8tion.jda.api.EmbedBuilder
import net.dv8tion.jda.api.events.interaction.command.UserContextInteractionEvent
import net.dv8tion.jda.api.interactions.commands.build.CommandData
import net.dv8tion.jda.internal.interactions.CommandDataImpl
import net.projecttl.p.x32.handler.UserContext
import net.projecttl.p.x32.util.colour
object Avatar : UserContext {
override val data = CommandData.fromData(CommandDataImpl("avatar", "유저의 프로필 이미지를 가져 옵니다").toData())
override suspend fun execute(ev: UserContextInteractionEvent) {
val embed = EmbedBuilder()
embed.setTitle(":frame_photo: ${ev.name} Avatar")
embed.setImage(ev.target.effectiveAvatarUrl)
embed.colour()
ev.replyEmbeds(embed.build()).queue()
}
}

32
src/main/kotlin/net/projecttl/p/x32/command/Ping.kt Normal file
View file

@ -0,0 +1,32 @@
package net.projecttl.p.x32.command
import net.dv8tion.jda.api.EmbedBuilder
import net.dv8tion.jda.api.JDA
import net.dv8tion.jda.api.entities.MessageEmbed
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import net.dv8tion.jda.api.interactions.commands.build.CommandData
import net.dv8tion.jda.internal.interactions.CommandDataImpl
import net.projecttl.p.x32.handler.GlobalCommand
import net.projecttl.p.x32.util.colour
import kotlin.random.Random
object Ping : GlobalCommand {
override val data: CommandData = CommandData.fromData(CommandDataImpl(
"ping",
"Discord API 레이턴시 확인 합니다"
).toData())
override suspend fun execute(ev: SlashCommandInteractionEvent) {
val embed = measure(ev.jda)
ev.replyEmbeds(embed).queue()
}
private fun measure(jda: JDA): MessageEmbed {
val embed = EmbedBuilder()
embed.setTitle(":ping_pong: **Pong!**")
embed.addField(":electric_plug: **API**", "`${jda.gatewayPing}ms`", true)
embed.colour()
return embed.build()
}
}

7
src/main/kotlin/net/projecttl/p/x32/config/Config.kt Normal file
View file

@ -0,0 +1,7 @@
package net.projecttl.p.x32.config
object Config {
}
class ConfigDelegate {
}

2
px32-bot-runner/src/main/kotlin/net/projecttl/p/x32/exec/config/DefaultConfig.kt → src/main/kotlin/net/projecttl/p/x32/config/DefaultConfig.kt
View file

@ -1,4 +1,4 @@
package net.projecttl.p.x32.exec.config
package net.projecttl.p.x32.config
import java.util.*
import kotlin.reflect.KProperty

25
src/main/kotlin/net/projecttl/p/x32/handler/CommandExecutor.kt Normal file
View file

@ -0,0 +1,25 @@
package net.projecttl.p.x32.handler
import net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.UserContextInteractionEvent
import net.dv8tion.jda.api.interactions.commands.build.CommandData
interface CommandExecutor {
val data: CommandData
}
interface GlobalCommand : CommandExecutor {
override val data: CommandData
suspend fun execute(ev: SlashCommandInteractionEvent)
}
interface UserContext : CommandExecutor {
override val data: CommandData
suspend fun execute(ev: UserContextInteractionEvent)
}
interface MessageContext : CommandExecutor {
override val data: CommandData
suspend fun execute(ev: MessageContextInteractionEvent)
}

130
src/main/kotlin/net/projecttl/p/x32/handler/CommandHandler.kt Normal file
View file

@ -0,0 +1,130 @@
package net.projecttl.p.x32.handler
import kotlinx.coroutines.runBlocking
import net.dv8tion.jda.api.JDA
import net.dv8tion.jda.api.events.interaction.command.MessageContextInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent
import net.dv8tion.jda.api.events.interaction.command.UserContextInteractionEvent
import net.dv8tion.jda.api.hooks.ListenerAdapter
import net.dv8tion.jda.api.interactions.commands.Command
import net.dv8tion.jda.api.interactions.commands.build.Commands
import net.projecttl.p.x32.logger
class CommandHandler(val guildId: Long = 0L) : ListenerAdapter() {
private val commands = mutableListOf<CommandExecutor>()
override fun onSlashCommandInteraction(ev: SlashCommandInteractionEvent) {
val name = ev.interaction.name
commands.forEach { command ->
if (command.data.name == name) {
if (command is GlobalCommand) {
runBlocking {
command.execute(ev)
}
return@forEach
}
}
}
}
override fun onUserContextInteraction(ev: UserContextInteractionEvent) {
val name = ev.interaction.name
commands.forEach { command ->
if (command.data.name == name) {
if (command is UserContext) {
runBlocking {
command.execute(ev)
}
return@forEach
}
}
}
}
override fun onMessageContextInteraction(ev: MessageContextInteractionEvent) {
val name = ev.interaction.name
commands.forEach { command ->
if (command.data.name == name) {
if (command is MessageContext) {
runBlocking {
command.execute(ev)
}
return@forEach
}
}
}
}
fun addCommand(command: CommandExecutor) {
commands.add(command)
}
fun delCommand(command: CommandExecutor) {
commands.remove(command)
}
fun register(jda: JDA) {
val guild = jda.getGuildById(guildId)
if (guildId != 0L) {
if (guild == null) {
logger.info("'${guildId}' guild is not exists!")
return
}
}
commands.forEach { command ->
val data = command.data
if (command is GlobalCommand) {
if (guild == null) {
jda.upsertCommand(data).queue()
logger.info("Register Global Command: /${data.name}")
} else {
guild.upsertCommand(data).queue()
logger.info("Register '${guild.id}' Guild's Command: /${data.name}")
}
}
if (command is UserContext) {
if (guild == null) {
jda.updateCommands().addCommands(
Commands.context(Command.Type.USER, data.name),
Commands.message(data.name)
).queue()
logger.info("Register User Context Command: /${data.name}")
} else {
guild.updateCommands().addCommands(
Commands.context(Command.Type.USER, data.name),
Commands.message(data.name)
).queue()
logger.info("Register '${guild.id}' Guild's User Context Command: /${data.name}")
}
}
if (command is MessageContext) {
if (guild == null) {
jda.updateCommands().addCommands(
Commands.context(Command.Type.MESSAGE, data.name),
Commands.message(data.name)
)
logger.info("Register Message Context Command: /${data.name}")
} else {
guild.updateCommands().addCommands(
Commands.context(Command.Type.MESSAGE, data.name),
Commands.message(data.name)
)
logger.info("Register '${guild.id}' Guild's Message Context Command: /${data.name}")
}
}
}
}
}

11
src/main/kotlin/net/projecttl/p/x32/handler/Ready.kt Normal file
View file

@ -0,0 +1,11 @@
package net.projecttl.p.x32.handler
import net.dv8tion.jda.api.events.session.ReadyEvent
import net.dv8tion.jda.api.hooks.ListenerAdapter
import net.projecttl.p.x32.logger
object Ready : ListenerAdapter() {
override fun onReady(ev: ReadyEvent) {
logger.info("Logged in as ${ev.jda.selfUser.asTag}")
}
}

42
src/main/kotlin/net/projecttl/p/x32/kernel/CoreKernel.kt Normal file
View file

@ -0,0 +1,42 @@
package net.projecttl.p.x32.kernel
import net.dv8tion.jda.api.JDA
import net.dv8tion.jda.api.JDABuilder
import net.dv8tion.jda.api.hooks.ListenerAdapter
import net.projecttl.p.x32.handler.CommandHandler
class CoreKernel(token: String) {
private val builder = JDABuilder.createDefault(token)
private val handlers = mutableListOf<ListenerAdapter>()
private val handler = CommandHandler()
fun getGlobalCommandHandler(): CommandHandler {
return handler
}
fun addHandler(handler: ListenerAdapter) {
handlers.add(handler)
}
fun delHandler(handler: ListenerAdapter) {
handlers.remove(handler)
}
fun build(): JDA {
handlers.map {
builder.addEventListeners(it)
}
builder.addEventListeners(handler)
val jda = builder.build()
handler.register(jda)
handlers.forEach { h ->
if (h is CommandHandler) {
h.register(jda)
}
}
return jda
}
}

9
src/main/kotlin/net/projecttl/p/x32/util/Color.kt Normal file
View file

@ -0,0 +1,9 @@
package net.projecttl.p.x32.util
import net.dv8tion.jda.api.EmbedBuilder
import kotlin.random.Random
fun EmbedBuilder.colour(): EmbedBuilder {
val rand = Random.nextInt(0x000001, 0xffffff)
return this.setColor(rand)
}

0
px32-bot-runner/src/main/resources/default.properties → src/main/resources/default.properties
View file

0
px32-bot-runner/src/main/resources/log4j2.xml → src/main/resources/log4j2.xml
View file