Example #1
0
        public async Task CreateTasteTextTest()
        {
            // given: user api mock
            string            username = "******";
            LastStatsTimeSpan timeSpan = LastStatsTimeSpan.Overall;

            // create test data
            int amount = 3;
            IEnumerable <LastArtist> responseArtists = TestHelper.CreateGenericArtists(amount);

            Mock <IUserApi> userApiMock = new Mock <IUserApi>(MockBehavior.Strict);

            userApiMock.Setup(u => u.GetTopArtists(username, timeSpan, It.IsAny <int>(), amount))
            .Returns(Task.Run(() => PageResponse <LastArtist> .CreateSuccessResponse(responseArtists)));

            PasteYourTasteViewModel vm = new PasteYourTasteViewModel(userApiMock.Object)
            {
                Username = username,
                Amount   = amount
            };

            // when: getting the taste text
            await vm.GetTopArtists();

            // then: taste text contains artists
            foreach (var artist in responseArtists)
            {
                Assert.That(vm.TasteText.Contains(artist.Name), Is.True);
            }
        }
Example #2
0
        // Top artists
        public async Task <PageResponse <LastArtist> > GetTopArtistsAsync(string lastFMUserName,
                                                                          LastStatsTimeSpan timespan, int count = 2)
        {
            var topArtists = await this._lastFMClient.User.GetTopArtists(lastFMUserName, timespan, 1, count);

            Statistics.LastfmApiCalls.Inc();

            return(topArtists);
        }
Example #3
0
        public async Task <PageResponse <LastAlbum> > GetTopAlbums(string username, LastStatsTimeSpan span, int pagenumber = 0, int count = LastFm.DefaultPageLength)
        {
            var command = new GetTopAlbumsCommand(Auth, username, span)
            {
                Page  = pagenumber,
                Count = count
            };

            return(await command.ExecuteAsync());
        }
Example #4
0
        public async Task<PageResponse<LastArtist>> GetTopArtists(string username, LastStatsTimeSpan span, int pagenumber = 0, int count = LastFm.DefaultPageLength)
        {
            var command = new GetTopArtistsCommand(Auth, username, span)
            {
                Page = pagenumber,
                Count = count,
                HttpClient = HttpClient
            };

            return await command.ExecuteAsync();
        }
Example #5
0
        public void CreateTasteTextTest()
        {
            // given: user api mock
            string            username = "******";
            int               amount   = 3;
            LastStatsTimeSpan timeSpan = LastStatsTimeSpan.Overall;

            // create test data
            List <LastArtist> responseArtists = new List <LastArtist>();

            for (int i = 0; i < amount; i++)
            {
                responseArtists.Add(new LastArtist()
                {
                    Name = "TestArtist" + i
                });
            }

            Mock <IUserApi> userApiMock = new Mock <IUserApi>(MockBehavior.Strict);

            userApiMock.Setup(u => u.GetTopArtists(username, timeSpan, It.IsAny <int>(), amount))
            .Returns(Task.Run(() => PageResponse <LastArtist> .CreateSuccessResponse(responseArtists)));

            PasteYourTasteViewModel vm = new PasteYourTasteViewModel(userApiMock.Object)
            {
                Username = username,
                Amount   = amount
            };

            // when: getting the taste text
            vm.GetTopArtists();

            // then: taste text contains artists
            foreach (var artist in responseArtists)
            {
                Assert.That(vm.TasteText.Contains(artist.Name), Is.True);
            }
        }
Example #6
0
        public static SettingsModel StringOptionsToSettings(
            string[] extraOptions,
            LastStatsTimeSpan defaultLastStatsTimeSpan = LastStatsTimeSpan.Week,
            ChartTimePeriod defaultChartTimePeriod     = ChartTimePeriod.Weekly,
            string defaultUrlParameter = "LAST_7_DAYS",
            string defaultApiParameter = "7day")
        {
            var settingsModel = new SettingsModel();

            // time period
            if (extraOptions.Contains("weekly") || extraOptions.Contains("week") || extraOptions.Contains("w"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Week;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Weekly;
                settingsModel.Description       = "Weekly";
                settingsModel.UrlParameter      = "LAST_7_DAYS";
                settingsModel.ApiParameter      = "7day";
            }
            else if (extraOptions.Contains("monthly") || extraOptions.Contains("month") || extraOptions.Contains("m"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Month;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Monthly;
                settingsModel.Description       = "Monthly";
                settingsModel.UrlParameter      = "LAST_30_DAYS";
                settingsModel.ApiParameter      = "1month";
            }
            else if (extraOptions.Contains("quarterly") || extraOptions.Contains("quarter") || extraOptions.Contains("q"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Quarter;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Quarterly;
                settingsModel.Description       = "Quarterly";
                settingsModel.UrlParameter      = "LAST_90_DAYS";
                settingsModel.ApiParameter      = "3month";
            }
            else if (extraOptions.Contains("halfyearly") || extraOptions.Contains("half") || extraOptions.Contains("h"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Half;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Half;
                settingsModel.Description       = "Half-yearly";
                settingsModel.UrlParameter      = "LAST_180_DAYS";
                settingsModel.ApiParameter      = "6month";
            }
            else if (extraOptions.Contains("yearly") || extraOptions.Contains("year") || extraOptions.Contains("y"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Year;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Yearly;
                settingsModel.Description       = "Yearly";
                settingsModel.UrlParameter      = "LAST_365_DAYS";
                settingsModel.ApiParameter      = "12month";
            }
            else if (extraOptions.Contains("overall") || extraOptions.Contains("alltime") || extraOptions.Contains("o") ||
                     extraOptions.Contains("at") ||
                     extraOptions.Contains("a"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Overall;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.AllTime;
                settingsModel.Description       = "Overall";
                settingsModel.UrlParameter      = "ALL";
                settingsModel.ApiParameter      = "overall";
            }
            else
            {
                settingsModel.LastStatsTimeSpan = defaultLastStatsTimeSpan;
                settingsModel.ChartTimePeriod   = defaultChartTimePeriod;
                settingsModel.Description       = "";
                settingsModel.UrlParameter      = defaultUrlParameter;
                settingsModel.ApiParameter      = defaultApiParameter;
            }

            settingsModel.Amount = 10;
            foreach (var extraOption in extraOptions)
            {
                if (int.TryParse(extraOption, out var result))
                {
                    if (result > 0 && result <= 50)
                    {
                        if (result > 16)
                        {
                            result = 16;
                        }

                        settingsModel.Amount = result;
                    }
                }

                if (extraOption.Contains("<@") || extraOption.Length == 18)
                {
                    var id = extraOption.Trim('@', '!', '<', '>');

                    if (ulong.TryParse(id, out var discordUserId))
                    {
                        settingsModel.OtherDiscordUserId = discordUserId;
                    }
                }
            }

            return(settingsModel);
        }
Example #7
0
 public GetTopAlbumsCommand(ILastAuth auth, string username, LastStatsTimeSpan span) : base(auth)
 {
     Username = username;
     TimeSpan = span;
 }
Example #8
0
        public async Task fmArtistsAsync(string time = "weekly", int num = 6, string user = null)
        {
            User userSettings = await _userService.GetUserSettingsAsync(Context.User);

            if (userSettings?.UserNameLastFM == null)
            {
                await UsernameNotSetErrorResponseAsync();

                return;
            }
            if (time == "help")
            {
                await ReplyAsync(
                    "Usage: `.fmartists 'weekly/monthly/yearly/alltime' 'number of artists (max 10)'` \n" +
                    "You can set your default user and your display mode through the `.fmset 'username' 'embedfull/embedmini/textfull/textmini'` command.");

                return;
            }

            if (!Enum.TryParse(time, ignoreCase: true, out ChartTimePeriod timePeriod))
            {
                await ReplyAsync("Invalid time period. Please use 'weekly', 'monthly', 'yearly', or 'alltime'.");

                return;
            }

            if (num > 10)
            {
                num = 10;
            }

            LastStatsTimeSpan timeSpan = _lastFmService.GetLastStatsTimeSpan(timePeriod);

            try
            {
                string lastFMUserName = userSettings.UserNameLastFM;

                if (user != null)
                {
                    if (await _lastFmService.LastFMUserExistsAsync(user))
                    {
                        lastFMUserName = user;
                    }
                    else if (!_guildService.CheckIfDM(Context))
                    {
                        IGuildUser guildUser = await _guildService.FindUserFromGuildAsync(Context, user);

                        if (guildUser != null)
                        {
                            User guildUserLastFM = await _userService.GetUserSettingsAsync(guildUser);

                            if (guildUserLastFM?.UserNameLastFM != null)
                            {
                                lastFMUserName = guildUserLastFM.UserNameLastFM;
                            }
                        }
                    }
                }

                PageResponse <LastArtist> artists = await _lastFmService.GetTopArtistsAsync(lastFMUserName, timeSpan, num);

                if (artists?.Any() != true)
                {
                    await ReplyAsync("No artists found on this profile. (" + lastFMUserName + ")");

                    return;
                }

                EmbedAuthorBuilder eab = new EmbedAuthorBuilder
                {
                    IconUrl = Context.User.GetAvatarUrl(),
                    Name    = userSettings.UserNameLastFM
                };

                EmbedBuilder builder = new EmbedBuilder
                {
                    Color = new Discord.Color(186, 0, 0),
                };

                builder.WithUrl("https://www.last.fm/user/" + lastFMUserName + "/library/artists");
                builder.Title = lastFMUserName + " top " + num + " artists (" + timePeriod + ")";

                const string nulltext = "[undefined]";
                int          indexval = (num - 1);
                for (int i = 0; i <= indexval; i++)
                {
                    LastArtist artist = artists.Content[i];

                    string artistName = string.IsNullOrWhiteSpace(artist.Name) ? nulltext : artist.Name;

                    int correctnum = (i + 1);
                    builder.AddField("#" + correctnum + ": " + artist.Name, artist.PlayCount.Value.ToString("N0") + " times scrobbled");
                }

                EmbedFooterBuilder embedFooter = new EmbedFooterBuilder();

                LastResponse <LastUser> userinfo = await _lastFmService.GetUserInfoAsync(lastFMUserName);

                embedFooter.Text = lastFMUserName + "'s total scrobbles: " + userinfo.Content.Playcount.ToString("N0");

                builder.WithFooter(embedFooter);

                await Context.Channel.SendMessageAsync("", false, builder.Build());

                this._logger.LogCommandUsed(Context.Guild?.Id, Context.Channel.Id, Context.User.Id, Context.Message.Content);
            }
            catch (Exception e)
            {
                _logger.LogError(e.Message, Context.Message.Content, Context.User.Username, Context.Guild?.Name, Context.Guild?.Id);
                await ReplyAsync("Unable to show Last.FM info due to an internal error.");
            }
        }
Example #9
0
 // Top artists
 public async Task <PageResponse <LastArtist> > GetTopArtistsAsync(string lastFMUserName, LastStatsTimeSpan timespan, int count = 2)
 {
     return(await LastfmClient.User.GetTopArtists(lastFMUserName, timespan, 1, count).ConfigureAwait(false));
 }
Example #10
0
        public async Task GenerateChartAsync(FMBotChart chart)
        {
            try
            {
                LastStatsTimeSpan timespan = LastStatsTimeSpan.Week;

                const string nulltext = "[undefined]";

                if (!Directory.Exists(GlobalVars.CacheFolder))
                {
                    Directory.CreateDirectory(GlobalVars.CacheFolder);
                }

                // Album mode
                if (chart.mode == 0)
                {
                    for (int albumIndex = 0; albumIndex < chart.albums.Count(); ++albumIndex)
                    {
                        LastAlbum track = chart.albums.Content[albumIndex];

                        string ArtistName = string.IsNullOrWhiteSpace(track.ArtistName) ? nulltext : track.ArtistName;
                        string AlbumName  = string.IsNullOrWhiteSpace(track.Name) ? nulltext : track.Name;

                        LastImageSet albumImages = await GetAlbumImagesAsync(ArtistName, AlbumName).ConfigureAwait(false);

                        Bitmap cover;

                        if (albumImages?.Large != null)
                        {
                            string url  = albumImages.Large.AbsoluteUri;
                            string path = Path.GetFileName(url);

                            if (File.Exists(GlobalVars.CacheFolder + path))
                            {
                                cover = new Bitmap(GlobalVars.CacheFolder + path);
                            }
                            else
                            {
                                WebRequest request = WebRequest.Create(url);
                                using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
                                {
                                    using (Stream responseStream = response.GetResponseStream())
                                    {
                                        Bitmap bitmap = new Bitmap(responseStream);

                                        cover = bitmap;
                                        using (MemoryStream memory = new MemoryStream())
                                        {
                                            using (FileStream fs = new FileStream(GlobalVars.CacheFolder + path, FileMode.Create, FileAccess.ReadWrite))
                                            {
                                                bitmap.Save(memory, System.Drawing.Imaging.ImageFormat.Png);
                                                byte[] bytes = memory.ToArray();
                                                fs.Write(bytes, 0, bytes.Length);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            cover = new Bitmap(GlobalVars.ImageFolder + "unknown.png");
                        }

                        if (chart.titles)
                        {
                            Graphics text = Graphics.FromImage(cover);
                            text.DrawColorString(cover, ArtistName, new Font("Arial", 8.0f, FontStyle.Bold), new PointF(2.0f, 2.0f));
                            text.DrawColorString(cover, AlbumName, new Font("Arial", 8.0f, FontStyle.Bold), new PointF(2.0f, 12.0f));
                        }

                        chart.images.Add(cover);
                    }
                }
                // Artist mode
                else if (chart.mode == 1)
                {
                    PageResponse <LastArtist> artists = await GetTopArtistsAsync(chart.LastFMName, timespan, chart.max).ConfigureAwait(false);

                    for (int al = 0; al < chart.max; ++al)
                    {
                        LastArtist artist = artists.Content[al];

                        string ArtistName = string.IsNullOrWhiteSpace(artist.Name) ? nulltext : artist.Name;

                        LastImageSet artistImage = await GetArtistImageAsync(ArtistName).ConfigureAwait(false);

                        Bitmap cover;

                        if (artistImage?.Large != null)
                        {
                            string url  = artistImage.Large.AbsoluteUri;
                            string path = Path.GetFileName(url);

                            if (File.Exists(GlobalVars.CacheFolder + path))
                            {
                                cover = new Bitmap(GlobalVars.CacheFolder + path);
                            }
                            else
                            {
                                WebRequest request = WebRequest.Create(url);
                                using (WebResponse response = await request.GetResponseAsync().ConfigureAwait(false))
                                {
                                    using (Stream responseStream = response.GetResponseStream())
                                    {
                                        Bitmap bitmap = new Bitmap(responseStream);

                                        cover = bitmap;
                                        using (MemoryStream memory = new MemoryStream())
                                        {
                                            using (FileStream fs = new FileStream(GlobalVars.CacheFolder + path, FileMode.Create, FileAccess.ReadWrite))
                                            {
                                                bitmap.Save(memory, System.Drawing.Imaging.ImageFormat.Png);
                                                byte[] bytes = memory.ToArray();
                                                fs.Write(bytes, 0, bytes.Length);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        else
                        {
                            cover = new Bitmap(GlobalVars.ImageFolder + "unknown.png");
                        }

                        if (chart.titles)
                        {
                            Graphics text = Graphics.FromImage(cover);
                            text.DrawColorString(cover, ArtistName, new Font("Arial", 8.0f, FontStyle.Bold), new PointF(2.0f, 2.0f));
                        }

                        chart.images.Add(cover);
                    }
                }
            }
            catch (Exception e)
            {
                //_logger.LogException("GenerateChartAsync", e);
            }
            finally
            {
                List <List <Bitmap> > ImageLists = GlobalVars.splitBitmapList(chart.images, chart.rows);

                List <Bitmap> BitmapList = new List <Bitmap>();

                foreach (List <Bitmap> list in ImageLists.ToArray())
                {
                    //combine them into one image
                    Bitmap stitchedRow = GlobalVars.Combine(list);
                    BitmapList.Add(stitchedRow);
                }

                lock (GlobalVars.charts.SyncRoot)
                {
                    GlobalVars.charts[GlobalVars.GetChartFileName(chart.DiscordUser.Id)] = GlobalVars.Combine(BitmapList, true);
                }

                foreach (Bitmap image in BitmapList.ToArray())
                {
                    image.Dispose();
                }
            }
        }
Example #11
0
        public static TimeSettingsModel GetTimePeriod(
            string[] extraOptions,
            LastStatsTimeSpan defaultLastStatsTimeSpan = LastStatsTimeSpan.Week,
            ChartTimePeriod defaultChartTimePeriod     = ChartTimePeriod.Weekly,
            string defaultUrlParameter = "LAST_7_DAYS",
            string defaultApiParameter = "7day",
            string defaultDescription  = "Weekly")
        {
            var settingsModel = new TimeSettingsModel();

            // time period
            if (extraOptions.Contains("weekly") || extraOptions.Contains("week") || extraOptions.Contains("w"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Week;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Weekly;
                settingsModel.Description       = "Weekly";
                settingsModel.UrlParameter      = "date_preset=LAST_7_DAYS";
                settingsModel.ApiParameter      = "7day";
            }
            else if (extraOptions.Contains("monthly") || extraOptions.Contains("month") || extraOptions.Contains("m"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Month;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Monthly;
                settingsModel.Description       = "Monthly";
                settingsModel.UrlParameter      = "date_preset=LAST_30_DAYS";
                settingsModel.ApiParameter      = "1month";
            }
            else if (extraOptions.Contains("quarterly") || extraOptions.Contains("quarter") || extraOptions.Contains("q"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Quarter;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Quarterly;
                settingsModel.Description       = "Quarterly";
                settingsModel.UrlParameter      = "date_preset=LAST_90_DAYS";
                settingsModel.ApiParameter      = "3month";
            }
            else if (extraOptions.Contains("halfyearly") || extraOptions.Contains("half") || extraOptions.Contains("h"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Half;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Half;
                settingsModel.Description       = "Half-yearly";
                settingsModel.UrlParameter      = "date_preset=LAST_180_DAYS";
                settingsModel.ApiParameter      = "6month";
            }
            else if (extraOptions.Contains("yearly") || extraOptions.Contains("year") || extraOptions.Contains("y"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Year;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.Yearly;
                settingsModel.Description       = "Yearly";
                settingsModel.UrlParameter      = "date_preset=LAST_365_DAYS";
                settingsModel.ApiParameter      = "12month";
            }
            else if (extraOptions.Contains("overall") || extraOptions.Contains("alltime") || extraOptions.Contains("o") ||
                     extraOptions.Contains("at") ||
                     extraOptions.Contains("a"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Overall;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.AllTime;
                settingsModel.Description       = "Overall";
                settingsModel.UrlParameter      = "date_preset=ALL";
                settingsModel.ApiParameter      = "overall";
            }
            else if (extraOptions.Contains("6day") || extraOptions.Contains("6-day") || extraOptions.Contains("day6") || extraOptions.Contains("6d"))
            {
                var dateString = DateTime.Today.AddDays(-6).ToString("yyyy-M-dd");
                settingsModel.Description  = "6-day";
                settingsModel.UrlParameter = $"from={dateString}";
                settingsModel.UsePlays     = true;
                settingsModel.PlayDays     = 6;
            }
            else if (extraOptions.Contains("5day") || extraOptions.Contains("5-day") || extraOptions.Contains("day5") || extraOptions.Contains("5d"))
            {
                var dateString = DateTime.Today.AddDays(-5).ToString("yyyy-M-dd");
                settingsModel.Description  = "5-day";
                settingsModel.UrlParameter = $"from={dateString}";
                settingsModel.UsePlays     = true;
                settingsModel.PlayDays     = 5;
            }
            else if (extraOptions.Contains("4day") || extraOptions.Contains("4-day") || extraOptions.Contains("day4") || extraOptions.Contains("4d"))
            {
                var dateString = DateTime.Today.AddDays(-4).ToString("yyyy-M-dd");
                settingsModel.Description  = "4-day";
                settingsModel.UrlParameter = $"from={dateString}";
                settingsModel.UsePlays     = true;
                settingsModel.PlayDays     = 4;
            }
            else if (extraOptions.Contains("3day") || extraOptions.Contains("3-day") || extraOptions.Contains("day3") || extraOptions.Contains("3d"))
            {
                var dateString = DateTime.Today.AddDays(-3).ToString("yyyy-M-dd");
                settingsModel.Description  = "3-day";
                settingsModel.UrlParameter = $"from={dateString}";
                settingsModel.UsePlays     = true;
                settingsModel.PlayDays     = 3;
            }
            else if (extraOptions.Contains("2day") || extraOptions.Contains("2-day") || extraOptions.Contains("day2") || extraOptions.Contains("2d"))
            {
                var dateString = DateTime.Today.AddDays(-2).ToString("yyyy-M-dd");
                settingsModel.Description  = "2-day";
                settingsModel.UrlParameter = $"from={dateString}";
                settingsModel.UsePlays     = true;
                settingsModel.PlayDays     = 2;
            }
            else if (extraOptions.Contains("1day") || extraOptions.Contains("1-day") || extraOptions.Contains("day1") || extraOptions.Contains("1d") || extraOptions.Contains("today"))
            {
                var dateString = DateTime.Today.AddDays(-1).ToString("yyyy-M-dd");
                settingsModel.Description  = "1-day";
                settingsModel.UrlParameter = $"from={dateString}";
                settingsModel.UsePlays     = true;
                settingsModel.PlayDays     = 1;
            }
            else if (extraOptions.Contains("overall") || extraOptions.Contains("alltime") || extraOptions.Contains("o") ||
                     extraOptions.Contains("at") ||
                     extraOptions.Contains("a"))
            {
                settingsModel.LastStatsTimeSpan = LastStatsTimeSpan.Overall;
                settingsModel.ChartTimePeriod   = ChartTimePeriod.AllTime;
                settingsModel.Description       = "Overall";
                settingsModel.UrlParameter      = "date_preset=ALL";
                settingsModel.ApiParameter      = "overall";
            }
            else
            {
                settingsModel.LastStatsTimeSpan = defaultLastStatsTimeSpan;
                settingsModel.ChartTimePeriod   = defaultChartTimePeriod;
                settingsModel.Description       = defaultDescription;
                settingsModel.UrlParameter      = defaultUrlParameter;
                settingsModel.ApiParameter      = defaultApiParameter;
                settingsModel.UsePlays          = false;
            }

            return(settingsModel);
        }