adding gitea flows

.gitea/workflows/ci.yml

@@ -0,0 +1,26 @@
+name: CI
+
+on:
+  # push:
+  #   branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Setup .NET
+      uses: actions/setup-dotnet@v3
+      with:
+        dotnet-version: 6.0.x
+    - name: Restore dependencies
+      run: dotnet restore
+    - name: Build
+      run: dotnet build --no-restore
+    # - name: Test
+    #   run: dotnet test --no-build --verbosity normal
+

.gitea/workflows/master.yml

@@ -0,0 +1,98 @@
+name: Master Build
+
+on:
+  push:
+    branches: [ "master" ]
+
+jobs:
+  build_amd64:
+    name: Build and Push Docker Image (amd64)
+    runs-on: self-hosted-ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to Docker Hub
+        uses: https://github.com/docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v1
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: https://github.com/docker/setup-buildx-action@v1
+
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
+
+      - name: Build Docker image and push
+        id: docker_build
+        uses: https://github.com/docker/build-push-action@v2
+        with:
+          context: ./
+          file: ./Dockerfile
+          push: true
+          tags: ${{ secrets.DOCKER_USERNAME }}/kasbot:latest
+          platforms: linux/amd64
+
+      - name: Image digest
+        run: echo ${{ steps.docker_build.outputs.digest }}
+
+  build_arm64:
+    name: Build and Push Docker Image (arm64)
+    runs-on: self-hosted-ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v1
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_ACCESS_TOKEN }}
+
+      - name: Set up QEMU
+        uses: https://github.com/docker/setup-qemu-action@v1
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: https://github.com/docker/setup-buildx-action@v1
+
+      - name: Available platforms
+        run: echo ${{ steps.buildx.outputs.platforms }}
+
+      - name: Build Docker image and push
+        id: docker_build
+        uses: https://github.com/docker/build-push-action@v2
+        with:
+          context: ./
+          file: ./Dockerfile
+          push: true
+          tags: ${{ secrets.DOCKER_USERNAME }}/kasbot:latest
+          platforms: linux/arm64
+
+      - name: Image digest
+        run: echo ${{ steps.docker_build.outputs.digest }}
+
+
+  deploy:
+    name: Update running container
+    runs-on: self-hosted-ubuntu-latest
+    needs: build_arm64
+
+    steps:
+    - name: Recreate container
+      uses: https://github.com/appleboy/ssh-action@v1.2.0
+      with:
+        host: ${{ secrets.HOST }}
+        username: ${{ secrets.USERNAME }}
+        key: ${{ secrets.KEY }}
+        port: ${{ secrets.PORT }}
+        script: |
+          cd docker/kasbot
+          docker compose down
+          docker compose rm
+          docker compose pull
+          docker compose up -d

Kasbot.API/Kasbot.API.csproj

@@ -16,7 +16,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.VisualStudio.Azure.Containers.Tools.Targets" Version="1.19.5" />
-    <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
+    <PackageReference Include="Swashbuckle.AspNetCore" Version="7.2.0" />
   </ItemGroup>
 
   <ItemGroup>

Kasbot.APP/Extensions/IListExtensions.cs

@@ -0,0 +1,21 @@
+using Discord.WebSocket;
+
+namespace Kasbot.Extensions
+{
+    public static class IListExtensions
+    {
+        public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
+        {
+            var rng = new Random();
+
+            var buffer = source.ToList();
+            for (int i = 0; i < buffer.Count; i++)
+            {
+                int j = rng.Next(i, buffer.Count);
+                yield return buffer[j];
+
+                buffer[j] = buffer[i];
+            }
+        }
+    }
+}

Kasbot.APP/Kasbot.App.csproj

@@ -14,16 +14,21 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.13.0" />
+    <PackageReference Include="Discord.Net" Version="3.17.1" />
     <PackageReference Include="Google.Protobuf" Version="3.25.1" />
     <PackageReference Include="Grpc.AspNetCore" Version="2.59.0" />
     <PackageReference Include="Grpc.Net.Client" Version="2.59.0" />
-    <PackageReference Include="Grpc.Tools" Version="2.59.0">
+    <PackageReference Include="Grpc.Tools" Version="2.60.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="8.0.0" />
-    <PackageReference Include="YoutubeExplode" Version="6.3.7" />
+    <PackageReference Include="Serilog" Version="3.1.1" />
+    <PackageReference Include="Serilog.Enrichers.Context" Version="4.6.5" />
+    <PackageReference Include="Serilog.Extensions.Hosting" Version="8.0.0" />
+    <PackageReference Include="Serilog.Sinks.Console" Version="5.0.1" />
+    <PackageReference Include="SpotifyAPI.Web" Version="7.2.1" />
+    <PackageReference Include="YoutubeExplode" Version="6.5.1" />
   </ItemGroup>
 
     <ItemGroup>

Kasbot.APP/Models/Connection.cs

@@ -1,6 +1,6 @@
 using Discord;
 using Discord.Audio;
-using Kasbot.Services.Internal;
+using Kasbot.App.Services.Internal;
 
 namespace Kasbot.Models
 {

Kasbot.APP/Modules/CommandModule.cs

@@ -56,6 +56,7 @@ namespace Kasbot.Modules
             await PlayerService.Stop(Context.Guild.Id);
         }
 
+        [Alias("s", "next", "n")]
         [Command("skip", RunMode = RunMode.Async)]
         public async Task SkipAsync()
         {
@@ -74,5 +75,11 @@ namespace Kasbot.Modules
         {
             await PlayerService.Repeat(Context.Guild.Id);
         }
+
+        [Command("shuffle", RunMode = RunMode.Async)]
+        public async Task Shuffle()
+        {
+            await PlayerService.Shuffle(Context.Guild.Id);
+        }
     }
 }

Kasbot.APP/Program.cs

@@ -1,12 +1,16 @@
 using Discord;
 using Discord.Commands;
 using Discord.WebSocket;
-using Google.Protobuf.WellKnownTypes;
 using Kasbot.App.Internal.Services;
+using Kasbot.App.Services.Internal;
 using Kasbot.Services;
 using Kasbot.Services.Internal;
 using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Options;
+using Serilog;
 
 namespace Kasbot
 {
@@ -39,9 +43,18 @@ namespace Kasbot
         {
             var builder = WebApplication.CreateBuilder(args);
             builder.Services.AddGrpc();
+            builder.WebHost.ConfigureKestrel(options =>
+            {
+                options.Listen(System.Net.IPAddress.Any, 5001, listenOptions =>
+                {
+                    listenOptions.Protocols = Microsoft.AspNetCore.Server.Kestrel.Core.HttpProtocols.Http1;
+                });
+            });
 
             var app = builder.Build();
             app.MapGrpcService<StatusService>();
+
+
             app.Run(url: "https://localhost:7042");
         }
 
@@ -102,15 +115,23 @@ namespace Kasbot
 
         private ServiceProvider ConfigureServices()
         {
+            var logger = new LoggerConfiguration()
+                .MinimumLevel.Debug()
+                .WriteTo.Console(outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss} [{Level}] {Message}{NewLine}{Exception}")
+                .CreateBootstrapLogger();
+
             return new ServiceCollection()
                 .AddSingleton(new DiscordSocketConfig
                 {
                     GatewayIntents = GatewayIntents.AllUnprivileged | GatewayIntents.MessageContent,
                     TotalShards = SHARDS
                 })
+                .AddSerilog(logger)
                 .AddSingleton<DiscordShardedClient>()
                 .AddSingleton<CommandService>()
+                .AddSingleton<SpotifyService>()
                 .AddSingleton<YoutubeService>()
+                .AddSingleton<MediaService>()
                 .AddSingleton<AudioService>()
                 .AddSingleton<PlayerService>()
                 .AddSingleton<CommandHandlingService>()

Kasbot.APP/Services/Internal/MediaService.cs

@@ -0,0 +1,112 @@
+using Discord.Rest;
+using Discord.WebSocket;
+using Kasbot.Models;
+using Kasbot.Services.Internal;
+using Serilog;
+using YoutubeExplode.Videos;
+
+namespace Kasbot.App.Services.Internal
+{
+    public class MediaService
+    {
+        private YoutubeService YoutubeService { get; set; }
+        private SpotifyService SpotifyService { get; set; }
+        private ILogger Logger { get; set; }
+
+
+        public MediaService(YoutubeService youtubeService, SpotifyService spotifyService, ILogger logger)
+        {
+            this.YoutubeService = youtubeService;
+            this.SpotifyService = spotifyService;
+            this.Logger = logger;
+        }
+
+        public async Task<Media> FetchSingleMedia(Media media, SearchType mediaType)
+        {
+            if (mediaType == SearchType.SpotifyTrack)
+            {
+                Logger.Debug($"Fetching single media: {media.Search}");
+                media = await SpotifyService.FetchSingleMedia(media);
+            }
+
+            Logger.Debug($"Fetching single media (YouTube): {media.Search}");
+            media = await YoutubeService.FetchSingleMedia(media);
+
+            if (media.VideoId == null)
+            {
+                Logger.Error($"No video found for \"{media.Search}\".");
+                throw new Exception($"No video found for \"{media.Search}\".");
+            }
+
+            return media;
+        }
+
+        public async Task<MediaCollection> FetchMediaCollection(Media rawMedia, SearchType mediaType)
+        {
+            var collection = new MediaCollection();
+
+            if (mediaType == SearchType.SpotifyPlaylist)
+            {
+                Logger.Debug($"Fetching playlist from Spotify: {rawMedia.Search}");
+                collection = await SpotifyService.FetchPlaylist(rawMedia);
+                var tasks = collection.Medias.ToList().Select(media => YoutubeService.FetchSingleMedia(media));
+                var results = await Task.WhenAll(tasks);
+                Logger.Debug($"Fetched playlist from Spotify: {rawMedia.Search}");
+            }
+
+            if (mediaType == SearchType.SpotifyAlbum)
+            {
+                Logger.Debug($"Fetching album from Spotify: {rawMedia.Search}");
+                collection = await SpotifyService.FetchAlbum(rawMedia);
+                var tasks = collection.Medias.ToList().Select(media => YoutubeService.FetchSingleMedia(media));
+                var results = await Task.WhenAll(tasks);
+                Logger.Debug($"Fetched album from Spotify: {rawMedia.Search}");
+            }
+
+            if (mediaType == SearchType.YoutubePlaylist)
+            {
+                Logger.Debug($"Fetching playlist from YouTube: {rawMedia.Search}");
+                collection = await YoutubeService.FetchPlaylist(rawMedia);
+                Logger.Debug($"Fetched playlist from YouTube: {rawMedia.Search}");
+            }
+
+            return collection;
+        }
+
+        public async Task<MemoryStream?> DownloadAudioFromYoutube(Media media)
+        {
+            return await YoutubeService.DownloadAudioFromYoutube(media);
+        }
+    }
+
+    public class Media
+    {
+        public string Search { get; set; }
+
+        public string Name { get; set; }
+        public TimeSpan Length { get; set; }
+        public Flags Flags { get; set; }
+
+        public VideoId? VideoId { get; set; }
+        public RestUserMessage PlayMessage { get; set; }
+        public RestUserMessage? QueueMessage { get; set; }
+
+        private SocketUserMessage message;
+        public SocketUserMessage Message
+        {
+            get => message;
+            set
+            {
+                message = value;
+                Channel = value.Channel;
+            }
+        }
+        public ISocketMessageChannel Channel { get; private set; }
+    }
+
+    public class MediaCollection
+    {
+        public string CollectionName { get; set; }
+        public List<Media> Medias { get; set; } = new List<Media>();
+    }
+}

Kasbot.APP/Services/Internal/SpotifyService.cs

@@ -0,0 +1,166 @@
+using Serilog;
+using SpotifyAPI.Web;
+
+namespace Kasbot.App.Services.Internal
+{
+    public class SpotifyService
+    {
+        private readonly string spotifyClientId = Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_ID") ?? string.Empty;
+        private readonly string spotifyClientSecret = Environment.GetEnvironmentVariable("SPOTIFY_CLIENT_SECRET") ?? string.Empty;
+
+        private SpotifyClient? spotifyClient = null;
+        private ILogger Logger { get; set; }
+
+        public SpotifyService(ILogger logger)
+        {
+            this.Logger = logger;
+
+            SetupSpotifyClient();
+        }
+
+        private void SetupSpotifyClient()
+        {
+            if (string.IsNullOrWhiteSpace(spotifyClientId) ||
+                string.IsNullOrWhiteSpace(spotifyClientSecret))
+            {
+                Logger.Warning("Spotify Token was not found. Will disable Spotify integration.");
+                return;
+            }
+
+            if (RefreshToken().IsFaulted)
+            {
+                throw new Exception("Failed to create Spotify client.");
+            }
+        }
+
+        private async Task CheckTokenValid()
+        {
+            if (spotifyClient == null)
+            {
+                Logger.Warning("Spotify integration is disabled.");
+                throw new Exception("Spotify integration is disabled.");
+            }
+
+            try
+            {
+                await spotifyClient.Browse.GetCategories();
+            }
+            catch (Exception)
+            {
+                await RefreshToken();
+            }
+        }
+
+        private async Task RefreshToken()
+        {
+            if (spotifyClient == null)
+            {
+                spotifyClient = null;
+            }
+
+            var config = SpotifyClientConfig.CreateDefault();
+
+            var request = new ClientCredentialsRequest(spotifyClientId, spotifyClientSecret);
+            var response = await (new OAuthClient(config)).RequestToken(request);
+
+            spotifyClient = new SpotifyClient(config.WithToken(response.AccessToken));
+        }
+
+        public async Task<Media> FetchSingleMedia(Media media)
+        {
+            await CheckTokenValid();
+
+            var trackId = UrlResolver.GetSpotifyResourceId(media.Search);
+            var spotifyTrack = await spotifyClient.Tracks.Get(trackId);
+
+            if (spotifyTrack == null)
+            {
+                Logger.Error($"No track found on Spotify for \"{media.Search}\".");    
+                throw new Exception($"No track found on Spotify for \"{media.Search}\".");
+            }
+
+            media.Search = spotifyTrack.Name;
+
+            return media;
+        }
+
+        public async Task<MediaCollection> FetchPlaylist(Media rawMedia)
+        {
+            await CheckTokenValid();
+
+            var playlistId = UrlResolver.GetSpotifyResourceId(rawMedia.Search);
+            var spotifyPlaylist = await spotifyClient.Playlists.Get(playlistId);
+
+            if (spotifyPlaylist == null || spotifyPlaylist.Tracks == null)
+            {
+                Logger.Error($"No playlist found on Spotify for \"{rawMedia.Search}\".");
+                throw new Exception($"No playlist found on Spotify for \"{rawMedia.Search}\".");
+            }
+
+            var collection = new MediaCollection();
+            collection.CollectionName = spotifyPlaylist.Name ?? string.Empty;
+
+            if (spotifyPlaylist.Tracks.Items == null || spotifyPlaylist.Tracks.Items.Count == 0)
+            {
+                Logger.Error($"No tracks found for playlist \"{spotifyPlaylist.Name}\".");
+                throw new Exception($"No tracks found for playlist \"{spotifyPlaylist.Name}\".");
+            }
+
+            Logger.Debug($"Found {spotifyPlaylist.Tracks.Items.Count} tracks for playlist \"{spotifyPlaylist.Name}\".");
+
+            foreach (var playlistTrack in spotifyPlaylist.Tracks.Items)
+            {
+                if (playlistTrack.Track is not FullTrack track)
+                {
+                    continue;
+                }
+
+                collection.Medias.Add(new Media
+                {
+                    Search = track.Name,
+                    Message = rawMedia.Message,
+                    Flags = rawMedia.Flags,
+                });
+            }
+
+            return collection;
+        }
+
+        public async Task<MediaCollection> FetchAlbum(Media rawMedia)
+        {
+            await CheckTokenValid();
+
+            var albumId = UrlResolver.GetSpotifyResourceId(rawMedia.Search);
+            var spotifyAlbum = await spotifyClient.Albums.Get(albumId);
+
+            if (spotifyAlbum == null || spotifyAlbum.Tracks == null)
+            {
+                Logger.Error($"No album found on Spotify for \"{rawMedia.Search}\".");
+                throw new Exception($"No album found on Spotify for \"{rawMedia.Search}\".");
+            }
+
+            var collection = new MediaCollection();
+            collection.CollectionName = spotifyAlbum.Name ?? string.Empty;
+
+            if (spotifyAlbum.Tracks.Items == null || spotifyAlbum.Tracks.Items.Count == 0)
+            {
+                Logger.Error($"No tracks found for album \"{spotifyAlbum.Name}\".");
+                throw new Exception($"No tracks found for album \"{spotifyAlbum.Name}\".");
+            }
+
+            Logger.Debug($"Found {spotifyAlbum.Tracks.Items.Count} tracks for album \"{spotifyAlbum.Name}\".");
+
+            foreach (var track in spotifyAlbum.Tracks.Items)
+            {
+                collection.Medias.Add(new Media
+                {
+                    Search = track.Name,
+                    Message = rawMedia.Message,
+                    Flags = rawMedia.Flags,
+                });
+            }
+
+            return collection;
+        }
+    }
+}

Kasbot.APP/Services/Internal/UrlResolver.cs

@@ -0,0 +1,93 @@
+using System.Web;
+
+namespace Kasbot.App.Services.Internal
+{
+    public static class UrlResolver
+    {
+        private const string SpotifyUrl = "open.spotify.com";
+
+        public static SearchType GetSearchType(string query)
+        {
+            if (string.IsNullOrEmpty(query))
+                return SearchType.None;
+
+            if (IsURL(query))
+            {
+                if (IsSpotifyUrl(query))
+                {
+                    if (query.Contains("/track/"))
+                        return SearchType.SpotifyTrack;
+
+                    if (query.Contains("/album/"))
+                        return SearchType.SpotifyAlbum;
+
+                    if (query.Contains("/playlist/"))
+                        return SearchType.SpotifyPlaylist;
+
+                    if (query.Contains("/artist/"))
+                        return SearchType.SpotifyArtist;
+                }
+
+                if (query.Contains("playlist?list="))
+                    return SearchType.YoutubePlaylist;
+
+                if (query.Contains("list="))
+                    return SearchType.VideoPlaylistURL;
+
+                return SearchType.VideoURL;
+            }
+
+            return SearchType.StringSearch;
+        }
+
+        public static string GetVideoId(string url)
+        {
+            if (url.Contains("v="))
+            {
+                var uri = new Uri(url);
+                var query = HttpUtility.ParseQueryString(uri.Query);
+                return query["v"] ?? string.Empty;
+            }
+
+            if (url.Contains("youtu.be/"))
+            {
+                var uri = new Uri(url);
+                return uri.Segments[1];
+            }
+
+            return url;
+        }
+
+        public static string GetSpotifyResourceId(string url)
+        {
+            if (string.IsNullOrEmpty(url))
+                return string.Empty;
+
+            var uri = new Uri(url);
+            return uri.Segments[uri.Segments.Length - 1];
+        }
+
+        private static bool IsURL(string url)
+        {
+            return url.StartsWith("http://") || url.StartsWith("https://");
+        }
+
+        private static bool IsSpotifyUrl(string url)
+        {
+            return url.Contains(SpotifyUrl);
+        }
+    }
+
+    public enum SearchType
+    {
+        None,
+        StringSearch,
+        VideoURL,
+        VideoPlaylistURL,
+        YoutubePlaylist,
+        SpotifyTrack,
+        SpotifyAlbum,
+        SpotifyPlaylist,
+        SpotifyArtist
+    }
+}

Kasbot.APP/Services/Internal/YoutubeService.cs

@@ -1,34 +1,37 @@
-using Discord.WebSocket;
-using YoutubeExplode.Videos;
+using Kasbot.App.Services.Internal;
+using Serilog;
 using YoutubeExplode;
-using Discord.Rest;
+using YoutubeExplode.Videos;
 using YoutubeExplode.Videos.Streams;
-using Kasbot.Models;
 
 namespace Kasbot.Services.Internal
 {
     public class YoutubeService
     {
-        public YoutubeService()
-        {
+        private ILogger Logger { get; set; }
 
+        public YoutubeService(ILogger logger)
+        {
+            this.Logger = logger;
         }
 
-        public async Task<MediaCollection> DownloadPlaylistMetadataFromYoutube(SocketUserMessage message, string search)
+        public async Task<MediaCollection> FetchPlaylist(Media rawMedia)
         {
             var collection = new MediaCollection();
             var youtube = new YoutubeClient();
 
-            var playlistInfo = await youtube.Playlists.GetAsync(search);
-            await youtube.Playlists.GetVideosAsync(search).ForEachAsync(videoId =>
+            Logger.Debug($"Fetching playlist from YouTube: {rawMedia.Search}");
+
+            var playlistInfo = await youtube.Playlists.GetAsync(rawMedia.Search);
+            await youtube.Playlists.GetVideosAsync(rawMedia.Search).ForEachAsync(videoId =>
             {
                 var media = new Media
                 {
                     Name = videoId.Title,
                     Length = videoId.Duration ?? new TimeSpan(0),
                     VideoId = videoId.Id,
-                    Message = message,
-                    Flags = new Flags()
+                    Message = rawMedia.Message,
+                    Flags = rawMedia.Flags
                 };
 
                 collection.Medias.Add(media);
@@ -36,11 +39,15 @@ namespace Kasbot.Services.Internal
 
             collection.CollectionName = playlistInfo.Title;
 
+            Logger.Debug($"Fetched playlist from YouTube: {rawMedia.Search}");
+
             return collection;
         }
 
-        public async Task<Media> DownloadMetadataFromYoutube(Media media)
+        public async Task<Media> FetchSingleMedia(Media media)
         {
+            Logger.Debug($"Fetching single media: {media.Search}");
+
             var youtube = new YoutubeClient();
 
             IVideo? videoId;
@@ -52,9 +59,12 @@ namespace Kasbot.Services.Internal
 
             if (videoId == null)
             {
+                Logger.Error($"No video found for \"{media.Search}\".");
                 return media;
             }
 
+            Logger.Debug($"Found video: {videoId.Title}");
+
             media.Name = videoId.Title;
             media.Length = videoId.Duration ?? new TimeSpan(0);
             media.VideoId = videoId.Id;
@@ -82,63 +92,5 @@ namespace Kasbot.Services.Internal
 
             return memoryStream;
         }
-
-        public SearchType GetSearchType(string query)
-        {
-            if (string.IsNullOrEmpty(query))
-                return SearchType.None;
-
-            if (query.StartsWith("http://") || query.StartsWith("https://"))
-            {
-                if (query.Contains("playlist?list="))
-                    return SearchType.PlaylistURL;
-
-                // need to add 'else if' for ChannelURL
-
-                return SearchType.VideoURL;
-            }
-
-            return SearchType.StringSearch;
-        }
-    }
-
-    public enum SearchType
-    {
-        None,
-        StringSearch,
-        VideoURL,
-        PlaylistURL,
-        ChannelURL
-    }
-
-    public class Media
-    {
-        public string Search { get; set; }
-
-        public string Name { get; set; }
-        public TimeSpan Length { get; set; }
-        public Flags Flags { get; set; }
-
-        public VideoId? VideoId { get; set; }
-        public RestUserMessage PlayMessage { get; set; }
-        public RestUserMessage? QueueMessage { get; set; }
-
-        private SocketUserMessage message;
-        public SocketUserMessage Message
-        {
-            get => message;
-            set
-            {
-                message = value;
-                Channel = value.Channel;
-            }
-        }
-        public ISocketMessageChannel Channel { get; private set; }
-    }
-
-    public class MediaCollection
-    {
-        public string CollectionName { get; set; }
-        public List<Media> Medias { get; set; } = new List<Media>();
     }
 }

Kasbot.APP/Services/PlayerService.cs

@@ -1,24 +1,28 @@
 using Discord;
 using Discord.Audio;
 using Discord.Commands;
+using Kasbot.App.Services.Internal;
 using Kasbot.Extensions;
 using Kasbot.Models;
 using Kasbot.Services.Internal;
+using Serilog;
 
 namespace Kasbot.Services
 {
     public class PlayerService
     {
-        public Dictionary<ulong, Connection> Clients { get; set; }
-        public YoutubeService YoutubeService { get; set; }
-        public AudioService AudioService { get; set; }
+        private Dictionary<ulong, Connection> Clients { get; set; }
+        private AudioService AudioService { get; set; }
+        private MediaService MediaService { get; set; }
+        private ILogger Logger { get; set; }
 
-        public PlayerService(YoutubeService youtubeService, AudioService audioService)
+        public PlayerService(AudioService audioService, MediaService mediaService, ILogger logger)
         {
-            YoutubeService = youtubeService;
-            AudioService = audioService;
-
             Clients = new Dictionary<ulong, Connection>();
+
+            AudioService = audioService;
+            MediaService = mediaService;
+            this.Logger = logger;
         }
 
         private async Task<Connection> CreateConnection(ulong guildId, IVoiceChannel voiceChannel)
@@ -42,9 +46,9 @@ namespace Kasbot.Services
             var media = new Media()
             {
                 Message = Context.Message,
-                Search = arguments,
+                Search = arguments.Trim(),
                 Flags = flags,
-                Name = "",
+                Name = string.Empty,
             };
             var guildId = Context.Guild.Id;
             var userVoiceChannel = (Context.User as IVoiceState).VoiceChannel;
@@ -69,46 +73,49 @@ namespace Kasbot.Services
         {
             var startPlay = conn.Queue.Count == 0;
 
-            media.Search.Trim();
+            var mediaType = UrlResolver.GetSearchType(media.Search);
 
-            switch (YoutubeService.GetSearchType(media.Search))
+            Logger.Debug($"Enqueueing {media.Search} as {mediaType}");
+
+            switch (mediaType)
             {
                 case SearchType.StringSearch:
                 case SearchType.VideoURL:
-                    media = await YoutubeService.DownloadMetadataFromYoutube(media);
+                case SearchType.VideoPlaylistURL:
+                case SearchType.SpotifyTrack:
+                    Logger.Debug($"Fetching {media.Search} as {mediaType}");
 
-                    if (media.VideoId == null)
-                    {
-                        await media.Channel.SendTemporaryMessageAsync($"No video found for \"{media.Search}\".");
-                        return;
-                    }
+                    media = await MediaService.FetchSingleMedia(media, mediaType);
 
-                    conn.Queue.Enqueue(media);
-                    if (startPlay)
-                        await PlayNext(guildId);
-                    else
+                    if (!startPlay && !media.Flags.Silent)
                     {
                         var message = $"Queued **{media.Name}** *({media.Length.TotalMinutes:00}:{media.Length.Seconds:00})*";
                         media.QueueMessage = await media.Channel.SendMessageAsync(message);
                     }
 
-                    break;
-                case SearchType.ChannelURL:
-                case SearchType.PlaylistURL:
-                    var collection = await YoutubeService.DownloadPlaylistMetadataFromYoutube(media.Message, media.Search);
+                    Logger.Debug($"Enqueueing {media.Search} as {mediaType}");
 
-                    collection.Medias.ForEach(m => conn.Queue.Enqueue(m));
-                    
-                    await media.Channel.SendMessageAsync($"Queued **{collection.Medias.Count}** items from *{collection.CollectionName}* playlist.");
-
-                    if (startPlay)
-                        await PlayNext(guildId);
+                    conn.Queue.Enqueue(media);
 
                     break;
-                case SearchType.None:
-                default:
+                case SearchType.YoutubePlaylist:
+                case SearchType.SpotifyPlaylist:
+                case SearchType.SpotifyAlbum:
+                    Logger.Debug($"Fetching {media.Search} as {mediaType}");
+
+                    var mediaCollection = await MediaService.FetchMediaCollection(media, mediaType);
+
+                    mediaCollection.Medias.ForEach(m => conn.Queue.Enqueue(m));
+
+                    Logger.Debug($"Enqueueing {media.Search} as {mediaType}");
+
+                    await media.Channel.SendMessageAsync($"Queued **{mediaCollection.Medias.Count}** items from *{mediaCollection.CollectionName}* playlist.");
+
                     break;
             }
+
+            if (startPlay)
+                await PlayNext(guildId);
         }
 
         private async Task PlayNext(ulong guildId)
@@ -134,16 +141,23 @@ namespace Kasbot.Services
                 await CreateConnection(guildId, voiceChannel);
             }
 
-            var mp3Stream = await YoutubeService.DownloadAudioFromYoutube(nextMedia);
+            Logger.Debug($"Downloading {nextMedia.Name}");
+
+            var mp3Stream = await MediaService.DownloadAudioFromYoutube(nextMedia);
+
+            Logger.Debug($"Playing {nextMedia.Name}");
 
             if (mp3Stream == null)
             {
+                Logger.Error($"Failed to download {nextMedia.Name}");
                 await Stop(guildId);
                 return;
             }
 
             var audioClient = Clients[guildId].AudioClient;
 
+            Logger.Information($"Playing {nextMedia.Name}");
+
             if (!nextMedia.Flags.Silent)
             {
                 var message = $"⏯ Playing: **{nextMedia.Name}** *({nextMedia.Length.TotalMinutes:00}:{nextMedia.Length.Seconds:00})*";
@@ -164,6 +178,7 @@ namespace Kasbot.Services
                 {
                     if (ac.Exception != null)
                     {
+                        Logger.Error(ac.Exception, $"Error in stream: {ac.Exception.Message}");
                         await nextMedia.Channel.SendTemporaryMessageAsync("Error in stream: " + ac.Exception.ToString());
                     }
                 });
@@ -245,5 +260,25 @@ namespace Kasbot.Services
 
             await CreateConnection(guildId, (Context.User as IVoiceState).VoiceChannel);
         }
+
+        public async Task Shuffle(ulong guildId)
+        {
+            if (!Clients.ContainsKey(guildId))
+                throw new Exception("Bot is not connected!");
+
+            var media = Clients[guildId];
+
+            if (media.Queue.Count == 0)
+                throw new Exception("The queue is empty!");
+
+            var shuffled = media.Queue.Shuffle();
+            var newQueue = new Queue<Media>();
+
+            shuffled.ToList().ForEach(m => newQueue.Enqueue(m));
+
+            media.Queue = newQueue;
+
+            await media.Queue.First().Channel.SendTemporaryMessageAsync(":call_me: Queue shuffled!");
+        }
     }
 }

Kasbot.APP/appsettings.json

@@ -0,0 +1,6 @@
+{
+  "Serilog": {
+    "Using": [ "Serilog.Sinks.Console" ],
+    "MinimumLevel": "Debug"
+  }
+}

README.md

@@ -2,14 +2,23 @@
 #### Inspired by a Brazilian DJ
 
 ## Running
+
+### Docker
 If using Docker, just put a token on the `docker-compose.yml` file and run it using `docker-compose up -d`.
 
+### Manual
 If deploying it by hand, you can run:
 ```shell
 dotnet build -c Release -o bin
 dotnet bin/Kasbot.dll
 ```
 
+##### Windows
+If you're using Windows, you will have to download these dependencies and put in the same folder as the executable:
+* [FFmpeg](https://ffmpeg.org/download.html)
+* [opus.dll](win-x64/opus.dll)
+* [libsodium.dll](win-x64/libsodium.dll)
+
 ## Commands
 | Command | Description
 | -- | -- |

docker-compose.yml

@@ -4,7 +4,9 @@ services:
     image: ivanch/kasbot:latest
     container_name: kasbot
     environment:
-      - TOKEN=<Your bot token here>
+      - TOKEN=<Your Discord bot token here>
+      - SPOTIFY_CLIENT_ID=<Your Spotify dev client token here>
+      - SPOTIFY_CLIENT_SECRET=<Your Spotify dev client secret here>
       - COMMAND_PREFIX=!
       - SHARDS=3
     restart: unless-stopped

legacy/.gitignore

@@ -1,2 +0,0 @@
-__pycache__
-.env

legacy/README.md

@@ -1,55 +0,0 @@
-# KasBot
-## Bot do Kasino para o Discord.
-
-## Executar
-1. Tenha `python3`, `pip3` e `ffmpeg` instalado.
-2. `git checkout https://github.com/ivanch/kasbot`
-3. `pip3 install -r requirements.txt`
-3. Exporte o token do seu bot com `export TOKEN=[token]`
-4. `python main.py`
-
-#### Keepalive
-Para executar com *keepalive* (manter o servidor vivo com um servidor web):
-1. Instale o flask utilizando `pip3 install flask`
-2. Defina uma variável de ambiente *alive* com `export alive`
-3. Execute os [passos acima](#executar).
-
-## Comandos
-* `kasino`
-    * Toca o famoso SABADAÇO.
-* `shakeit`
-    * Toca o hit SHAKE IT.
-* `jetmusic`
-    * NAS PISTAS DO JET MUSIC!
-* `pare`
-    * Para de tocar e desconecta.
-* `companhia`
-    * Entra no canal e te faz companhia, sem falar nem ouvir nada, apenas o doce som do silêncio.
-
-## Player
-* `-play [url/query]` (`-p`)
-    * Toca música do u2b.
-    * Flags:
-        * `-q`: não envia mensagem (e remove o comando)
-* `-stop`
-    * Para de tocar.
-* `-leave` (`-disconnect`, `-dc`, `-q`)
-    * Desconecta do canal.
-* `-volume [volume]`
-    * Ajuda volume (WIP).
-* `-now` (`-current`, `-playing`)
-    * Mostra o que tá tocando atualmente.
-* `-pause`
-    * Pausa.
-* `-resume` (`-r`)
-    * Dá play de novo (depois de pausar).
-* `-skip` (`-next`, `-s`, `-n`)
-    * Pula pra próxima música na fila.
-* `-queue`
-    * Mostra a fila de músicas.
-* `-shuffle` (`-sf`)
-    * Embaralha as músicas dentro da fila.
-* `-remove [indice]`
-    * Remove uma música baseada no indice na fila.
-* `-loop` (`-l`)
-    * Deixa a música atual em loop.

legacy/kasino.py

@@ -1,74 +0,0 @@
-import discord
-import asyncio
-from discord.ext import commands
-
-class Kasino(commands.Cog):
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-
-    @commands.command(name='kasino')
-    async def _kasino(self, ctx: commands.Context):
-        await self.play_song("./mp3/sabadaco.mp3", ctx)
-        await ctx.message.delete()
-
-    @commands.command(name='shakeit')
-    async def _shake_it(self, ctx: commands.Context):
-        await self.play_song("./mp3/shake it.mp3", ctx)
-        await ctx.message.delete()
-
-    @commands.command(name='jetmusic')
-    async def _jet_music(self, ctx: commands.Context):
-        await self.play_song("./mp3/jet music.mp3", ctx)
-        await ctx.message.delete()
-
-    @commands.command(name='companhia', aliases=['compania'])
-    async def _companhia(self, ctx: commands.Context):
-        voice_state = ctx.message.author.voice
-        if voice_state == None:
-            return
-
-        voice_channel = voice_state.channel
-        await voice_channel.connect()
-        await ctx.message.delete()
-
-    @commands.command(name='pare')
-    async def _pare(self, ctx: commands.Context):
-        voice_channel = ctx.message.author.voice
-        if voice_channel == None:
-            return
-
-        voice_clients = self.bot.voice_clients
-        for vc in voice_clients:
-            if vc.channel == voice_channel.channel:
-                await vc.disconnect()
-                break
-
-        # Delete command after action is done.
-        await ctx.message.delete()
-
-    async def play_song(self, filename: str, ctx: commands.Context):
-        if ctx.author.voice == None:
-            return
-
-        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
-
-        if voice_client == None:
-            voice_channel = ctx.message.author.voice.channel
-            voice_client = await voice_channel.connect()
-        elif voice_client.is_playing():
-            return
-
-        voice_client.play(discord.FFmpegPCMAudio(source=filename))
-
-        # Sleep while audio is playing, then disconnect
-        while voice_client.is_playing() and voice_client.is_connected():
-            await asyncio.sleep(0.3)
-        await voice_client.disconnect()
-
-    async def join(self, ctx: commands.Context):
-        destination = ctx.author.voice.channel
-
-        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
-
-        if voice_client == None or voice_client.channel != destination:
-            voice_client = await destination.connect()

legacy/main.py

@@ -1,44 +0,0 @@
-import os
-import discord
-
-from discord.ext import commands
-from player import Music
-from kasino import Kasino
-
-from dotenv import load_dotenv
-load_dotenv()
-
-# Setup suffixes, set env suffixes if they're set, otherwise default
-MUSIC_SUFFIX = os.getenv("MUSIC_SUFFIX") or "-"
-KASINO_SUFFIX = os.getenv('KASINO_SUFFIX') or ""
-
-client = commands.Bot(command_prefix=[MUSIC_SUFFIX, KASINO_SUFFIX], description='Kasino DEEJAY.')
-music = Music(client)
-kasino = Kasino(client)
-client.add_cog(music)
-client.add_cog(kasino)
-
-kasino_commands = []
-for cmd in kasino.get_commands():
-	kasino_commands.append(KASINO_SUFFIX + cmd.name)
-
-@client.event
-async def on_ready():
-	print('Logged in as {0.user}!'.format(client))
-
-@client.event
-async def on_message(message: discord.Message):
-	# Verifica se é um comando ou não
-	if message.content in kasino_commands or message.content.startswith(MUSIC_SUFFIX):
-		await client.process_commands(message)
-
-# #
-# Init KASINÂO
-# #
-
-alive = os.getenv('alive')
-if alive is not None:
-	from utils.keepalive import keep_alive
-	keep_alive()
-
-client.run(os.getenv("TOKEN"))

legacy/player.py

@@ -1,249 +0,0 @@
-import math
-
-import discord
-from discord import guild
-from discord.ext.commands.errors import CommandError
-import youtube_dl
-from discord.ext import commands
-
-from utils.models import VoiceState,YTDLSource, YTDLError, Song, VoiceError
-
-# Silence useless bug reports messages
-youtube_dl.utils.bug_reports_message = lambda: ''
-
-class Music(commands.Cog):
-    def __init__(self, bot: commands.Bot):
-        self.bot = bot
-        self.voice_states = {}
-
-    def get_voice_state(self, ctx: commands.Context):
-        state = VoiceState(self.bot, ctx)
-
-        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
-        if voice_client is not None:
-            state.voice = voice_client
-
-        self.voice_states[ctx.guild.id] = state
-
-        return state
-
-    def cog_unload(self):
-        for state in self.voice_states.values():
-            self.bot.loop.create_task(state.stop())
-
-    def cog_check(self, ctx: commands.Context):
-        if not ctx.guild:
-            raise commands.NoPrivateMessage('This command can\'t be used in DM channels.')
-
-        return True
-
-    async def cog_before_invoke(self, ctx: commands.Context):
-        ctx.voice_state = self.get_voice_state(ctx)
-
-    async def cog_command_error(self, ctx: commands.Context, error: commands.CommandError):
-        # await ctx.send('An error occurred: {}'.format(str(error)))
-        pass
-
-    @commands.command(name='join', invoke_without_subcommand=True)
-    async def _join(self, ctx: commands.Context):
-        """Joins a voice channel."""
-
-        destination = ctx.author.voice.channel
-        if ctx.voice_state.voice:
-            await ctx.voice_state.voice.move_to(destination)
-            return
-
-        voice_client = discord.utils.get(self.bot.voice_clients, guild=ctx.guild)
-
-        if voice_client == None:
-            ctx.voice_state.voice = await destination.connect()
-        else:
-            ctx.voice_state.voice = voice_client
-
-    @commands.command(name='summon')
-    async def _summon(self, ctx: commands.Context, *, channel: discord.VoiceChannel = None):
-        """Summons the bot to a voice channel.
-
-        If no channel was specified, it joins your channel.
-        """
-
-        if not channel and not ctx.author.voice:
-            raise VoiceError('You are neither connected to a voice channel nor specified a channel to join.')
-
-        destination = channel or ctx.author.voice.channel
-        if ctx.voice_state.voice:
-            await ctx.voice_state.voice.move_to(destination)
-            return
-
-        ctx.voice_state.voice = await destination.connect()
-
-    @commands.command(name='leave', aliases=['disconnect', 'q', 'dc'])
-    async def _leave(self, ctx: commands.Context):
-        """Clears the queue and leaves the voice channel."""
-
-        if not ctx.voice_state.voice:
-            return await ctx.send('Not connected to any voice channel.')
-
-        await ctx.voice_state.stop()
-        del self.voice_states[ctx.guild.id]
-
-    @commands.command(name='volume')
-    async def _volume(self, ctx: commands.Context, *, volume: int):
-        """Sets the volume of the player."""
-
-        if not ctx.voice_state.is_playing:
-            return await ctx.send('Nothing being played at the moment.')
-
-        if 0 > volume > 100:
-            return await ctx.send('Volume must be between 0 and 100')
-
-        ctx.voice_state.volume = volume / 100
-        await ctx.send('Volume of the player set to {}%'.format(volume))
-
-    @commands.command(name='now', aliases=['current', 'playing'])
-    async def _now(self, ctx: commands.Context):
-        """Displays the currently playing song."""
-
-        await ctx.send(embed=ctx.voice_state.current.create_embed())
-
-    @commands.command(name='pause')
-    async def _pause(self, ctx: commands.Context):
-        """Pauses the currently playing song."""
-
-        if ctx.voice_state.is_playing and ctx.voice_state.voice.is_playing():
-            ctx.voice_state.voice.pause()
-            await ctx.message.add_reaction('⏯')
-
-    @commands.command(name='resume', aliases=['r'])
-    async def _resume(self, ctx: commands.Context):
-        """Resumes a currently paused song."""
-
-        if ctx.voice_state.is_playing and ctx.voice_state.voice.is_paused():
-            ctx.voice_state.voice.resume()
-            await ctx.message.add_reaction('⏯')
-
-    @commands.command(name='stop')
-    async def _stop(self, ctx: commands.Context):
-        """Stops playing song and clears the queue."""
-
-        ctx.voice_state.songs.clear()
-
-        if ctx.voice_state.is_playing:
-            ctx.voice_state.voice.stop()
-            await ctx.message.add_reaction('⏹')
-
-    @commands.command(name='skip', aliases=['s', 'next', 'n'])
-    async def _skip(self, ctx: commands.Context):
-        """Vote to skip a song. The requester can automatically skip."""
-
-        if not ctx.voice_state.is_playing:
-            return await ctx.send('Not playing any music right now...')
-
-
-        await ctx.message.add_reaction('⏭')
-        ctx.voice_state.skip()
-
-
-    @commands.command(name='queue')
-    async def _queue(self, ctx: commands.Context, *, page: int = 1):
-        """Shows the player's queue.
-
-        You can optionally specify the page to show. Each page contains 10 elements.
-        """
-
-        if len(ctx.voice_state.songs) == 0:
-            return await ctx.send('Empty queue.')
-
-        items_per_page = 10
-        pages = math.ceil(len(ctx.voice_state.songs) / items_per_page)
-
-        start = (page - 1) * items_per_page
-        end = start + items_per_page
-
-        queue = ''
-        for i, song in enumerate(ctx.voice_state.songs[start:end], start=start):
-            queue += '`{0}.` [**{1.source.title}**]({1.source.url})\n'.format(i + 1, song)
-
-        embed = (discord.Embed(description='**{} tracks:**\n\n{}'.format(len(ctx.voice_state.songs), queue))
-                 .set_footer(text='Viewing page {}/{}'.format(page, pages)))
-        await ctx.send(embed=embed)
-
-    @commands.command(name='shuffle', aliases=['sf'])
-    async def _shuffle(self, ctx: commands.Context):
-        """Shuffles the queue."""
-
-        if len(ctx.voice_state.songs) == 0:
-            return await ctx.send('Empty queue.')
-
-        ctx.voice_state.songs.shuffle()
-        await ctx.message.add_reaction('✅')
-
-    @commands.command(name='remove')
-    async def _remove(self, ctx: commands.Context, index: int):
-        """Removes a song from the queue at a given index."""
-
-        if len(ctx.voice_state.songs) == 0:
-            return await ctx.send('Empty queue.')
-
-        ctx.voice_state.songs.remove(index - 1)
-        await ctx.message.add_reaction('✅')
-
-    @commands.command(name='loop', aliases=['l'])
-    async def _loop(self, ctx: commands.Context):
-        """Loops the currently playing song.
-
-        Invoke this command again to unloop the song.
-        """
-
-        if not ctx.voice_state.is_playing:
-            return await ctx.send('Nothing being played at the moment.')
-
-        # Inverse boolean value to loop and unloop.
-        ctx.voice_state.loop = not ctx.voice_state.loop
-        await ctx.message.add_reaction('✅')
-
-    @commands.command(name='play', aliases=['p'])
-    async def _play(self, ctx: commands.Context, *, search: str):
-        """Plays a song.
-
-        If there are songs in the queue, this will be queued until the
-        other songs finished playing.
-
-        This command automatically searches from various sites if no URL is provided.
-        A list of these sites can be found here: https://rg3.github.io/youtube-dl/supportedsites.html
-        """
-
-        quiet_flag = False
-        flags = ['-q']
-        for flag in flags:
-            if ' ' + flag in search:
-                search = search.replace(' ' + flag, '')
-                if flag == '-q':
-                    quiet_flag = True
-
-        if not ctx.voice_state.voice:
-            await ctx.invoke(self._join)
-
-        async with ctx.typing():
-            try:
-                source = await YTDLSource.create_source(ctx, search, loop=self.bot.loop, quiet=quiet_flag)
-            except YTDLError as e:
-                await ctx.send('An error occurred while processing this request: {}'.format(str(e)))
-            else:
-                song = Song(source)
-
-                await ctx.voice_state.songs.put(song)
-
-                if not quiet_flag:
-                    await ctx.send('Enqueued {}'.format(str(source)))
-                else:
-                    await ctx.message.delete()
-
-    @_join.before_invoke
-    @_play.before_invoke
-    async def ensure_voice_state(self, ctx: commands.Context):
-        if not ctx.author.voice or not ctx.author.voice.channel:
-            raise commands.CommandError('You are not connected to any voice channel.')
-
-        if ctx.voice_client and ctx.voice_client.channel != ctx.author.voice.channel:
-                raise commands.CommandError('Bot is already in a voice channel.')

legacy/pyproject.toml

@@ -1,18 +0,0 @@
-[tool.poetry]
-name = "repl_python3_kasbot"
-version = "0.1.0"
-description = ""
-authors = ["Your Name <you@example.com>"]
-
-[tool.poetry.dependencies]
-python = "^3.8"
-discord = "^1.7.3"
-Flask = "^2.0.1"
-youtube_dl = "^2021.6.6"
-PyNaCl = "^1.4.0"
-
-[tool.poetry.dev-dependencies]
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

legacy/requirements.txt

@@ -1,4 +0,0 @@
-discord[voice]
-pynacl
-youtube-dl
-python-dotenv

legacy/utils/keepalive.py

@@ -1,15 +0,0 @@
-from flask import Flask
-from threading import Thread
-
-app = Flask('')
-
-@app.route('/')
-def home():
-    return "I'm alive"
-
-def run():
-  app.run(host='0.0.0.0',port=8080)
-
-def keep_alive():
-    t = Thread(target=run)
-    t.start()

legacy/utils/models.py

@@ -1,253 +0,0 @@
-import asyncio
-import functools
-import itertools
-import random
-
-import discord
-import youtube_dl
-from async_timeout import timeout
-from discord.ext import commands
-
-class VoiceError(Exception):
-    pass
-
-
-class YTDLError(Exception):
-    pass
-
-
-class YTDLSource(discord.PCMVolumeTransformer):
-    YTDL_OPTIONS = {
-        'format': 'bestaudio/best',
-        'extractaudio': True,
-        'audioformat': 'mp3',
-        'outtmpl': '%(extractor)s-%(id)s-%(title)s.%(ext)s',
-        'restrictfilenames': True,
-        'noplaylist': True,
-        'nocheckcertificate': True,
-        'ignoreerrors': False,
-        'logtostderr': False,
-        'quiet': True,
-        'no_warnings': True,
-        'default_search': 'auto',
-        'source_address': '0.0.0.0',
-    }
-
-    FFMPEG_OPTIONS = {
-        'before_options': '-reconnect 1 -reconnect_streamed 1 -reconnect_delay_max 5',
-        'options': '-vn',
-    }
-
-    ytdl = youtube_dl.YoutubeDL(YTDL_OPTIONS)
-
-    def __init__(self, ctx: commands.Context, source: discord.FFmpegPCMAudio, *, data: dict, volume: float = 0.5, quiet: bool = False):
-        super().__init__(source, volume)
-
-        self.requester = ctx.author
-        self.channel = ctx.channel
-        self.data = data
-
-        self.uploader = data.get('uploader')
-        self.uploader_url = data.get('uploader_url')
-        date = data.get('upload_date')
-        self.upload_date = date[6:8] + '.' + date[4:6] + '.' + date[0:4]
-        self.title = data.get('title')
-        self.thumbnail = data.get('thumbnail')
-        self.description = data.get('description')
-        self.duration = self.parse_duration(int(data.get('duration')))
-        self.tags = data.get('tags')
-        self.url = data.get('webpage_url')
-        self.views = data.get('view_count')
-        self.likes = data.get('like_count')
-        self.dislikes = data.get('dislike_count')
-        self.stream_url = data.get('url')
-        self.quiet = quiet
-
-    def __str__(self):
-        return '**{0.title}** by **{0.uploader}**'.format(self)
-
-    @classmethod
-    async def create_source(cls, ctx: commands.Context, search: str, *, loop: asyncio.BaseEventLoop = None, quiet: bool = False):
-        loop = loop or asyncio.get_event_loop()
-
-        partial = functools.partial(cls.ytdl.extract_info, search, download=False, process=False)
-        data = await loop.run_in_executor(None, partial)
-
-        if data is None:
-            raise YTDLError('Couldn\'t find anything that matches `{}`'.format(search))
-
-        if 'entries' not in data:
-            process_info = data
-        else:
-            process_info = None
-            for entry in data['entries']:
-                if entry:
-                    process_info = entry
-                    break
-
-            if process_info is None:
-                raise YTDLError('Couldn\'t find anything that matches `{}`'.format(search))
-
-        webpage_url = process_info['webpage_url']
-        partial = functools.partial(cls.ytdl.extract_info, webpage_url, download=False)
-        processed_info = await loop.run_in_executor(None, partial)
-
-        if processed_info is None:
-            raise YTDLError('Couldn\'t fetch `{}`'.format(webpage_url))
-
-        if 'entries' not in processed_info:
-            info = processed_info
-        else:
-            info = None
-            while info is None:
-                try:
-                    info = processed_info['entries'].pop(0)
-                except IndexError:
-                    raise YTDLError('Couldn\'t retrieve any matches for `{}`'.format(webpage_url))
-
-        return cls(ctx, discord.FFmpegPCMAudio(info['url'], **cls.FFMPEG_OPTIONS), data=info, quiet=quiet)
-
-    @staticmethod
-    def parse_duration(duration: int):
-        minutes, seconds = divmod(duration, 60)
-        hours, minutes = divmod(minutes, 60)
-        days, hours = divmod(hours, 24)
-
-        duration = []
-        if days > 0:
-            duration.append('{} days'.format(days))
-        if hours > 0:
-            duration.append('{} hours'.format(hours))
-        if minutes > 0:
-            duration.append('{} minutes'.format(minutes))
-        if seconds > 0:
-            duration.append('{} seconds'.format(seconds))
-
-        return ', '.join(duration)
-
-
-class Song:
-    __slots__ = ('source', 'requester')
-
-    def __init__(self, source: YTDLSource):
-        self.source = source
-        self.requester = source.requester
-
-    def create_embed(self):
-        embed = (discord.Embed(title='Now playing',
-                               description='```css\n{0.source.title}\n```'.format(self),
-                               color=discord.Color.blurple())
-                 .add_field(name='Duration', value=self.source.duration)
-                 .add_field(name='Requested by', value=self.requester.mention)
-                 .add_field(name='Uploader', value='[{0.source.uploader}]({0.source.uploader_url})'.format(self))
-                 .add_field(name='URL', value='[Click]({0.source.url})'.format(self))
-                 .set_thumbnail(url=self.source.thumbnail))
-
-        return embed
-
-
-class SongQueue(asyncio.Queue):
-    def __getitem__(self, item):
-        if isinstance(item, slice):
-            return list(itertools.islice(self._queue, item.start, item.stop, item.step))
-        else:
-            return self._queue[item]
-
-    def __iter__(self):
-        return self._queue.__iter__()
-
-    def __len__(self):
-        return self.qsize()
-
-    def clear(self):
-        self._queue.clear()
-
-    def shuffle(self):
-        random.shuffle(self._queue)
-
-    def remove(self, index: int):
-        del self._queue[index]
-
-
-class VoiceState:
-    def __init__(self, client: commands.Bot, ctx: commands.Context):
-        self.client = client
-        self._ctx = ctx
-
-        self.current = None
-        self.voice = None
-        self.next = asyncio.Event()
-        self.songs = SongQueue()
-
-        self._loop = False
-        self._volume = 0.5
-        self.skip_votes = set()
-
-        self.audio_player = client.loop.create_task(self.audio_player_task())
-
-    def __del__(self):
-        self.audio_player.cancel()
-
-    @property
-    def loop(self):
-        return self._loop
-
-    @loop.setter
-    def loop(self, value: bool):
-        self._loop = value
-
-    @property
-    def volume(self):
-        return self._volume
-
-    @volume.setter
-    def volume(self, value: float):
-        self._volume = value
-
-    @property
-    def is_playing(self):
-        return self.voice and self.current
-
-    async def audio_player_task(self):
-        while True:
-            self.next.clear()
-
-            if not self.loop:
-                # Try to get the next song within 3 minutes.
-                # If no song will be added to the queue in time,
-                # the player will disconnect due to performance
-                # reasons.
-                # try:
-                #     async with timeout(180):  # 3 minutes
-                #         self.current = await self.songs.get()
-                # except asyncio.TimeoutError:
-                #     self.client.loop.create_task(self.stop())
-                #     return
-                self.current = await self.songs.get()
-
-            self.current.source.volume = self._volume
-            self.voice.play(self.current.source, after=self.play_next_song)
-
-            if not self.current.source.quiet:
-                await self.current.source.channel.send(embed=self.current.create_embed())
-
-            await self.next.wait()
-
-    def play_next_song(self, error=None):
-        if error:
-            raise VoiceError(str(error))
-
-        self.next.set()
-
-    def skip(self):
-        self.skip_votes.clear()
-
-        if self.is_playing:
-            self.voice.stop()
-
-    async def stop(self):
-        self.songs.clear()
-
-        if self.voice:
-            await self.voice.disconnect()
-            self.voice = None