Merge pull request 'chore/upgrade-lavakord' (#7) from chore/upgrade-lavakord into master

Reviewed-on: #7

build.gradle.kts

@@ -35,9 +35,10 @@ version = System.getenv("CI_COMMIT_TAG")?.let { "$it-${System.getenv("CI_COMMIT_
     ?: System.getenv("CI_COMMIT_SHORT_SHA")?.let { "$it-dev" }
             ?: "6.5.1"
 
-val kordver = "1.7.1-SNAPSHOT"
+val kordext_ver = "1.7.1-SNAPSHOT"
-val lavaver = "4.0.0"
+val lavakord_ver = "6.0.0"
-val coroutinesver = "1.1.0"
+val coroutines_ver = "1.7.3"
+val slf4j_ver = "2.0.9"
 
 val mavenArtifact = "Botendo"
 project.base.archivesName.set(mavenArtifact)
@@ -86,15 +87,15 @@ implementation.extendsFrom(shadow)
 
 dependencies {
     //Discord
-    shadow("com.kotlindiscord.kord.extensions:kord-extensions:$kordver")
+    shadow("com.kotlindiscord.kord.extensions:kord-extensions:$kordext_ver")
-    shadow("dev.schlaubi.lavakord:kord:$lavaver")
+    shadow("dev.schlaubi.lavakord:kord:$lavakord_ver")
 
     //Util
-    shadow("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutinesver")
+    shadow("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_ver")
 
     //Logging
-    shadow("org.slf4j:slf4j-api:2.0.3")
+    shadow("org.slf4j:slf4j-api:$slf4j_ver")
-    shadow("org.slf4j:slf4j-simple:2.0.3")
+    shadow("org.slf4j:slf4j-simple:$slf4j_ver")
 }
 
 
@@ -104,9 +105,9 @@ val templateDest = project.buildDir.resolve("generated/templates")
 val templateProps = mapOf(
     "version" to project.version as String,
     "ownerID" to ownerID,
-    "kordversion" to kordver,
+    "kordversion" to kordext_ver,
-    "lavaversion" to lavaver,
+    "lavaversion" to lavakord_ver,
-    "coroutinesversion" to coroutinesver
+    "coroutinesversion" to coroutines_ver
 )
 
 

src/main/kotlin/net/moonleay/botendo/buttons/music/QueueButton.kt

@@ -58,8 +58,7 @@ class QueueButton : net.moonleay.botendo.buttons.Button("btn.music.queue") {
             return
         }
 
-        val track = player.playingTrack
+        if (player.playingTrack == null) {
-        if (track == null) {
             response.respond {
                 this.embed {
                     this.color = Color(0xE0311A)
@@ -72,10 +71,11 @@ class QueueButton : net.moonleay.botendo.buttons.Button("btn.music.queue") {
             }
             return
         }
+        val track = player.playingTrack!!.info
         val gts = MusicManager.getGuildTrackScheduler(guild.asGuild(), player)
         val q = gts.getQueue()
         var desc =
-            """${"**" + track.title + " - " + TimeUtil.getTimeFormatedShortend(track.length.inWholeMilliseconds)} (${track.author})**""" + "\n"
+            """${"**" + track.title + " - " + TimeUtil.getTimeFormatedShortend(track.length)} (${track.author})**""" + "\n"
         for ((i, tr) in q.withIndex()) {
             if (i >= 14)
                 continue

src/main/kotlin/net/moonleay/botendo/buttons/music/SkipButton.kt

@@ -83,8 +83,7 @@ class SkipButton : net.moonleay.botendo.buttons.Button("btn.music.skip") {
             }
             return
         }
-        var track = player.playingTrack
+        if (player.playingTrack == null) {
-        if (track == null) {
             response.respond {
                 this.embed {
                     this.color = Color(0xE0311A)
@@ -97,9 +96,10 @@ class SkipButton : net.moonleay.botendo.buttons.Button("btn.music.skip") {
             }
             return
         }
+        var track = player.playingTrack!!.info
         val gts = MusicManager.getGuildTrackScheduler(guild.asGuild(), player)
         if (!gts.isEmpty()) {
-            track = gts.getHead().toTrack()
+            track = gts.getHead().info
             gts.playNext(link)
             response.respond {
                 this.embed {
@@ -107,7 +107,7 @@ class SkipButton : net.moonleay.botendo.buttons.Button("btn.music.skip") {
                     this.title = "Skipped song; now playing"
                     this.description = "**${track.title}**\n*Now Playing*\nby ${track.author} :: ${
                         TimeUtil.getTimeFormatedRaw(
-                            track.length.inWholeMilliseconds
+                            track.length
                         )
                     }\n" +
                             ">>>${track.uri}"

src/main/kotlin/net/moonleay/botendo/extensions/music/NowPlayingExtension.kt

@@ -75,21 +75,23 @@ class NowPlayingExtension : Extension() {
                     this.embed {
                         this.color = Color(0x52E01A)
                         this.title = "Currently playing"
-                        this.description = "**${track.title}**\n*Now Playing*\nby ${track.author} ;    ${
+                        this.description = "**${track.info.title}**\n*Now Playing*\nby ${track.info.author} ;    ${
                             TimeUtil.getTimeFormatedRaw(
                                 player.position
                             )
                         }: ${
                             TimeUtil.getTimeFormatedRaw(
-                                track.length.inWholeMilliseconds
+                                track.info.length
                             )
                         }\n" +
-                                ">>>${track.uri}"
+                                ">>>${track.info.uri}"
                         this.footer {
                             this.text = MessageUtil.getFooter(u)
                         }
+                        if(track.info.uri == null){
                             this.thumbnail {
-                            this.url = "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(track.uri.toString()) + "/maxresdefault.jpg"
+                                this.url = "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(track.info.uri!!) + "/maxresdefault.jpg"
+                            }
                         }
                     }
 

src/main/kotlin/net/moonleay/botendo/extensions/music/QueueExtension.kt

@@ -23,6 +23,7 @@ import com.kotlindiscord.kord.extensions.extensions.Extension
 import com.kotlindiscord.kord.extensions.extensions.publicSlashCommand
 import dev.kord.common.Color
 import dev.kord.rest.builder.component.ActionRowBuilder
+import dev.kord.rest.builder.message.EmbedBuilder.Limits.title
 import dev.kord.rest.builder.message.actionRow
 import dev.kord.rest.builder.message.create.actionRow
 import dev.kord.rest.builder.message.embed
@@ -74,7 +75,7 @@ class QueueExtension : Extension() {
                 val gts = MusicManager.getGuildTrackScheduler(this.guild!!.asGuild(), player)
                 val q = gts.getQueue()
                 var desc =
-                    """${"**" + track.title + " - " + TimeUtil.getTimeFormatedShortend(track.length.inWholeMilliseconds)} (${track.author})**""" + "\n"
+                    """${"**" + track.info.title + " - " + TimeUtil.getTimeFormatedShortend(track.info.length)} (${track.info.author})**""" + "\n"
                 for ((i, tr) in q.withIndex()) {
                     if (i >= 14)
                         continue

src/main/kotlin/net/moonleay/botendo/extensions/music/SeekExtension.kt

@@ -82,8 +82,7 @@ class SeekExtension : Extension() {
                     }
                     return@action
                 }
-                var track = player.playingTrack
+                if (player.playingTrack == null) {
-                if (track == null) {
                     this.respond {
                         this.embed {
                             this.color = Color(0xE0311A)
@@ -96,9 +95,10 @@ class SeekExtension : Extension() {
                     }
                     return@action
                 }
+                var track = player.playingTrack!!.info
                 val gts = MusicManager.getGuildTrackScheduler(this.guild!!.asGuild(), player)
                 val targetPos = TimeUtil.getTimeUnformated(this.arguments.position)
-                if (player.playingTrack!!.length.inWholeMilliseconds > targetPos && targetPos >= 0) {
+                if (player.playingTrack!!.info.length > targetPos && targetPos >= 0) {
                     player.seekTo(targetPos)
                 } else {
                     this.respond {
@@ -125,7 +125,7 @@ class SeekExtension : Extension() {
                             )
                         }: ${
                             TimeUtil.getTimeFormatedRaw(
-                                track.length.inWholeMilliseconds
+                                track.length
                             )
                         }\n" +
                                 ">>>${track.uri}"

src/main/kotlin/net/moonleay/botendo/extensions/music/SkipExtension.kt

@@ -82,7 +82,7 @@ class SkipExtension : Extension() {
                     }
                     return@action
                 }
-                var track = player.playingTrack
+                var track = player.playingTrack!!.info
                 if (track == null) {
                     this.respond {
                         this.embed {
@@ -98,7 +98,7 @@ class SkipExtension : Extension() {
                 }
                 val gts = MusicManager.getGuildTrackScheduler(this.guild!!.asGuild(), player)
                 if (!gts.isEmpty()) {
-                    track = gts.getHead().toTrack()
+                    track = gts.getHead().info
                     gts.playNext(link)
                 } else {
                     player.stopTrack()
@@ -111,7 +111,7 @@ class SkipExtension : Extension() {
                         this.title = "Skipped song; now playing"
                         this.description = "**${track.title}**\n*Now Playing*\nby ${track.author} ;: ${
                             TimeUtil.getTimeFormatedRaw(
-                                track.length.inWholeMilliseconds
+                                track.length
                             )
                         }\n" +
                                 ">>>${track.uri}"

src/main/kotlin/net/moonleay/botendo/extensions/music/components/GuildTrackScheduler.kt

@@ -19,21 +19,22 @@
 
 package net.moonleay.botendo.extensions.music.components
 
+import dev.arbjerg.lavalink.protocol.v4.LoadResult
+import dev.arbjerg.lavalink.protocol.v4.Track
 import dev.schlaubi.lavakord.audio.*
 import dev.schlaubi.lavakord.audio.player.Player
-import dev.schlaubi.lavakord.rest.models.PartialTrack
 import net.moonleay.botendo.util.Logger
 import java.util.concurrent.BlockingQueue
 import java.util.concurrent.LinkedBlockingQueue
 
 class GuildTrackScheduler(val pl: Player) {
 
-    private var queue: BlockingQueue<PartialTrack> = LinkedBlockingQueue()
+    private var queue: BlockingQueue<Track> = LinkedBlockingQueue()
     var repeating = false
     private var hasRegisteredEvents = false
 
     ///Add a track to queue and start playing, if there is no song currently playing
-    suspend fun queue(track: PartialTrack, type: MusicManager.AddType) {
+    suspend fun queue(track: Track, type: MusicManager.AddType) {
         if (this.pl.playingTrack == null) {
             play(track)
             return
@@ -44,7 +45,7 @@ class GuildTrackScheduler(val pl: Player) {
             }
 
             MusicManager.AddType.UPSERT -> {
-                val nq = LinkedBlockingQueue<PartialTrack>()
+                val nq = LinkedBlockingQueue<Track>()
                 nq.offer(track)
                 for (t in queue.toList()) {
                     nq.offer(t)
@@ -56,7 +57,7 @@ class GuildTrackScheduler(val pl: Player) {
 
     suspend fun playNext(link: Link) {
         if (!queue.isEmpty())
-            this.pl.playTrack(queue.poll())
+            this.pl.playTrack(track = queue.poll())
         else {
             this.pl.stopTrack()
             link.destroy()
@@ -64,8 +65,8 @@ class GuildTrackScheduler(val pl: Player) {
         }
     }
 
-    private suspend fun play(tr: PartialTrack) {
+    private suspend fun play(track: Track) {
-        this.pl.playTrack(tr)
+        this.pl.playTrack(track)
     }
 
     fun addEvents() {
@@ -92,7 +93,7 @@ class GuildTrackScheduler(val pl: Player) {
         if (e.reason.mayStartNext) {
             if (repeating) {
                 Logger.out("Repeating track...")
-                this.pl.playTrack(e.getTrack().copy())
+                this.pl.playTrack(e.track.copy())
                 return
             }
             Logger.out("Track has ended; Playing next...")
@@ -102,12 +103,12 @@ class GuildTrackScheduler(val pl: Player) {
 
     private suspend fun onTrackStuck(e: TrackStuckEvent) {
         Logger.out("Track is stuck, retrying...")
-        this.pl.playTrack(e.getTrack().copy())
+        this.pl.playTrack(e.track.copy())
     }
 
     private suspend fun onTrackExc(e: TrackExceptionEvent) {
         Logger.out("Track had an exception, retrying...")
-        this.pl.playTrack(e.getTrack().copy())
+        this.pl.playTrack(e.track.copy())
     }
 
     fun clear() {
@@ -116,11 +117,11 @@ class GuildTrackScheduler(val pl: Player) {
         queue.clear()
     }
 
-    fun getQueue(): List<PartialTrack> {
+    fun getQueue(): List<Track> {
         return queue.toList()
     }
 
-    fun getHead(): PartialTrack {
+    fun getHead(): Track {
         return queue.first()
     }
 

src/main/kotlin/net/moonleay/botendo/extensions/music/components/MusicManager.kt

@@ -21,17 +21,16 @@ package net.moonleay.botendo.extensions.music.components
 
 import com.kotlindiscord.kord.extensions.commands.application.slash.PublicSlashCommandContext
 import com.kotlindiscord.kord.extensions.components.forms.ModalForm
+import dev.arbjerg.lavalink.protocol.v4.LoadResult
 import dev.kord.common.Color
 import dev.kord.common.entity.Snowflake
 import dev.kord.core.entity.Guild
 import dev.kord.rest.builder.component.ActionRowBuilder
 import dev.kord.rest.builder.message.actionRow
-import dev.kord.rest.builder.message.create.actionRow
 import dev.kord.rest.builder.message.embed
 import dev.schlaubi.lavakord.audio.Link
 import dev.schlaubi.lavakord.audio.player.Player
 import dev.schlaubi.lavakord.rest.loadItem
-import dev.schlaubi.lavakord.rest.models.TrackResponse
 import net.moonleay.botendo.util.*
 
 object MusicManager {
@@ -68,32 +67,32 @@ object MusicManager {
         silent: Boolean
     ) {
         val player = link.player
-        val item = link.loadItem(search)
         val gts = getGuildTrackScheduler(ctx.guild!!.asGuild(), player)
         val u = ctx.user.asUser()
-
         gts.addEvents()
 
-        when (item.loadType) {
+        when (val itm = link.loadItem(search)) {
-            TrackResponse.LoadType.TRACK_LOADED -> {
+            is LoadResult.TrackLoaded -> {
-                gts.queue(item.track, type)
+                gts.queue(itm.data, type)
                 if (!silent)
                     ctx.respond {
                         this.embed {
                             this.color = Color(0x52E01A)
                             this.title = "${type.s} track from link"
-                            this.description = "**${item.track.info.title}**\n*Queue*\nby ${item.track.info.author} ;: ${
+                            this.description = "**${itm.data.info.title}**\n*Queue*\nby ${itm.data.info.author} ;: ${
                                 TimeUtil.getTimeFormatedRaw(
-                                    item.track.info.length
+                                    itm.data.info.length
                                 )
                             }\n" +
-                                    ">>>${item.track.info.uri}"
+                                    ">>>${itm.data.info.uri}"
                             this.footer {
                                 this.text = MessageUtil.getFooter(u)
                             }
+                            if (itm.data.info.uri != null) {
                                 this.thumbnail {
                                     this.url =
-                                    "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(item.track.info.uri) + "/maxresdefault.jpg"
+                                        "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(itm.data.info.uri!!) + "/maxresdefault.jpg"
+                                }
                             }
                         }
 
@@ -107,9 +106,9 @@ object MusicManager {
                         })
                     }
             }
-
+            is LoadResult.PlaylistLoaded -> {
-            TrackResponse.LoadType.PLAYLIST_LOADED -> {
+                player.playTrack(track = itm.data.tracks.first())
-                val l = item.tracks.reversed()
+                val l= itm.data.tracks.toList().reversed()
                 for (partialTrack in l) {
                     gts.queue(partialTrack, type)
                 }
@@ -118,18 +117,20 @@ object MusicManager {
                         this.embed {
                             this.color = Color(0x52E01A)
                             this.title = "${type.s} playlist from link"
-                            this.description = "**${item.tracks.first().info.title}**\n*${item.playlistInfo.name}*\nby ${item.tracks.first().info.author} ;: ${
+                            this.description = "**${itm.data.tracks.first().info.title}**\n*${itm.data.info.name}*\nby ${itm.data.tracks.first().info.author} ;: ${
                                 TimeUtil.getTimeFormatedRaw(
-                                    item.tracks.first().info.length
+                                    itm.data.tracks.first().info.length
                                 )
                             }\n" +
-                                    ">>>${item.tracks.first().info.uri}"
+                                    ">>>${itm.data.tracks.first().info.uri}"
                             this.footer {
                                 this.text = MessageUtil.getFooter(u)
                             }
+                            if (itm.data.tracks.first().info.uri != null) {
                                 this.thumbnail {
                                     this.url =
-                                    "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(item.tracks.first().info.uri) + "/maxresdefault.jpg"
+                                        "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(itm.data.tracks.first().info.uri!!) + "/maxresdefault.jpg"
+                                }
                             }
                         }
 
@@ -142,27 +143,29 @@ object MusicManager {
                             )
                         }
                     }
-            }
 
-            TrackResponse.LoadType.SEARCH_RESULT -> {
+            }
-                gts.queue(item.tracks.first(), type)
+            is LoadResult.SearchResult -> {
+                gts.queue(itm.data.tracks.first(), type)
                 if (!silent)
                     ctx.respond {
                         this.embed {
                             this.color = Color(0x52E01A)
                             this.title = "${type.s} track from query"
-                            this.description = "**${item.tracks.first().info.title}**\n*Queue*\nby ${item.tracks.first().info.author} ;: ${
+                            this.description = "**${itm.data.tracks.first().info.title}**\n*Queue*\nby ${itm.data.tracks.first().info.author} ;: ${
                                 TimeUtil.getTimeFormatedRaw(
-                                    item.tracks.first().info.length
+                                    itm.data.tracks.first().info.length
                                 )
                             }\n" +
-                                    ">>>${item.tracks.first().info.uri}"
+                                    ">>>${itm.data.tracks.first().info.uri}"
                             this.footer {
                                 this.text = MessageUtil.getFooter(u)
                             }
+                            if (itm.data.tracks.first().info.uri != null) {
                                 this.thumbnail {
                                     this.url =
-                                    "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(item.tracks.first().info.uri) + "/maxresdefault.jpg"
+                                        "https://img.youtube.com/vi/" + UrlUtil.getYtThumbnailUrl(itm.data.tracks.first().info.uri!!) + "/maxresdefault.jpg"
+                                }
                             }
                         }
 
@@ -175,9 +178,9 @@ object MusicManager {
                             )
                         }
                     }
-            }
 
-            TrackResponse.LoadType.NO_MATCHES -> {
+            }
+            is LoadResult.NoMatches -> {
                 if (!silent)
                     ctx.respond {
                         this.embed {
@@ -190,8 +193,7 @@ object MusicManager {
                         }
                     }
             }
-
+            is LoadResult.LoadFailed -> {
-            TrackResponse.LoadType.LOAD_FAILED -> {
                 if (!silent)
                     ctx.respond {
                         this.embed {
@@ -206,9 +208,9 @@ object MusicManager {
             }
         }
     }
-
     enum class AddType(val s: String) {
         QUEUE("Added"),
         UPSERT("Upserted")
     }
 }
+