// public async Task<List<AlbumJson>> GetTopSelling([FromQuery] int count = 6)
        public List <AlbumJson> GetTopSelling([FromQuery] int count = 6)
        {
            _logger.LogDebug("GetTopSelling");
            // TODO: Current MySQL provider has a Take() bug
            // See: http://forums.mysql.com/read.php?38,650020,650020#msg-650020

            //var albumModel = await DbContext.Albums
            //    .OrderByDescending(a => a.OrderCount)
            //    .Include(a => a.Artist)
            //    .Include(a => a.Genre)
            //    .Take(count)
            //    .ToListAsync();
            //return AlbumJson.From(albumModel);

            var ordered = DbContext.Albums
                          .OrderByDescending(a => a.OrderCount)
                          .Include(a => a.Artist)
                          .Include(a => a.Genre);

            List <Album> results = new List <Album>();

            foreach (var a in ordered.AsEnumerable())
            {
                results.Add(a);
                count--;
                if (count == 0)
                {
                    break;
                }
            }

            return(AlbumJson.From(results));
        }
        public async Task <IActionResult> GetAlbum(
            [FromQuery] int?id, [FromQuery] string title)
        {
            _logger.LogDebug("GetAlbum");

            Album album = null;

            if (id.HasValue)
            {
                album = await DbContext.Albums
                        .Where(a => a.AlbumId == id.Value)
                        .Include(a => a.Artist)
                        .Include(a => a.Genre)
                        .FirstOrDefaultAsync();
            }
            else if (!string.IsNullOrEmpty(title))
            {
                album = await DbContext.Albums
                        .Include(a => a.Artist)
                        .Include(a => a.Genre)
                        .Where(a => a.Title == title).FirstOrDefaultAsync();
            }

            if (album == null)
            {
                return(NotFound());
            }
            var result = AlbumJson.From(album);

            return(new ObjectResult(result));
        }
예제 #3
0
        public async Task <List <AlbumJson> > GetTopSelling([FromQuery] int count = 6)
        {
            var albumModel = await DbContext.Albums
                             .OrderByDescending(a => a.OrderCount)
                             .Include(a => a.Artist)
                             .Include(a => a.Genre)
                             .Take(count)
                             .ToListAsync();

            return(AlbumJson.From(albumModel));
        }
예제 #4
0
        public async Task <bool> UpdateAlbumAsync(Album album)
        {
            if (album == null)
            {
                return(false);
            }

            var request = new HttpRequestMessage(HttpMethod.Put, ALBUM_URL);
            var result  = await Invoke(request, AlbumJson.From(album));

            return(result);
        }
        public async Task <IActionResult> GetAlbums([FromQuery] string genre)
        {
            _logger.LogDebug("GetAlbums");
            // Retrieve Genre genre and its Associated associated Albums albums from database
            List <Album> albums = null;

            if ("All".Equals(genre))
            {
                albums = await DbContext.Albums
                         .Include(g => g.Artist)
                         .Include(g => g.Genre)
                         .ToListAsync();
            }
            else
            {
                var genreModel = await DbContext.Genres
                                 .Where(g => g.Name == genre)
                                 .Include(g => g.Albums)
                                 .FirstOrDefaultAsync();

                if (genreModel == null)
                {
                    return(NotFound());
                }

                albums = new List <Album>();
                foreach (var a in genreModel.Albums)
                {
                    var album = await DbContext.Albums
                                .Where(g => g.AlbumId == a.AlbumId)
                                .Include(g => g.Artist)
                                .Include(g => g.Genre)
                                .FirstOrDefaultAsync();

                    if (album != null)
                    {
                        albums.Add(album);
                    }
                }
            }

            var result = AlbumJson.From(albums);

            return(new ObjectResult(result));
        }