예제 #1
0
        /// <summary>
        /// Initializes new instance of <see cref="CommonViewItemModel"/> from artist entity.
        /// </summary>
        /// <param name="artist">Instance of <see cref="DbArtist"/>.</param>
        public CommonViewItemModel(DbArtist artist)
        {
            if (artist == null)
            {
                throw new ArgumentNullException(nameof(artist));
            }
            Type = CommonItemType.Artist;

            Title = artist.Name ?? "Artist";
            InternalDbEntityId = artist.Id;
            ExtendedArtistName = artist.Name;

            var songsCount = artist.FileCount;
            var albumCount = artist.AlbumCount;

            if (songsCount > 0 && albumCount > 0)
            {
                Content = string.Format(CommonSharedStrings.ArtistSubtitleFormat, albumCount, songsCount);
            }
            else if (songsCount > 0)
            {
                Content = string.Format(CommonSharedStrings.ArtistSubtitleFallbackFormat2, songsCount);
            }
            else
            {
                Content = CommonSharedStrings.ArtistSubtitleFallbackFormat;
            }

            Genre                 = ReleaseDate = string.Empty;
            ImagePath             = ImageHash = artist.ImagePath;
            ExtendedFilePath      = string.Empty;
            DatabaseItemAddedDate = artist.DatabaseItemAddedDate;
        }
예제 #2
0
        /// <summary>
        /// Load artist online data.
        /// </summary>
        /// <param name="elem"></param>
        /// <returns></returns>
        private async Task LoadArtistOnlineContentAsync(DbArtist elem)
        {
            // Check internet connection
            if (InternetConnectivityDetector.HasInternetConnection)
            {
                // Load Online content
                try
                {
                    var modifyFlag = false;

                    if (string.IsNullOrEmpty(elem.Intro))
                    {
                        elem = await elem.LoadOnlineArtistInfoAsync();

                        modifyFlag = !string.IsNullOrEmpty(elem.Intro);
                    }

                    if (!modifyFlag)
                    {
                        return;
                    }

                    ArtistBio = elem.Intro;

                    await CommitOnlineData(elem);
                }
                catch (Exception ex)
                {
                    TelemetryHelper.TrackExceptionAsync(ex);
                }
            }
        }
예제 #3
0
        /// <summary>
        /// Load online information for a specific artist.
        /// </summary>
        /// <param name="artist"></param>
        /// <returns></returns>
        public static async Task <DbArtist> LoadOnlineArtistInfoAsync(this DbArtist artist)
        {
            if (artist == null)
            {
                throw new ArgumentNullException(nameof(artist));
            }

            if (InternetConnectivityDetector.HasInternetConnection)
            {
                try
                {
                    if (string.IsNullOrEmpty(artist.Intro))
                    {
                        artist = await artist.LoadArtistIntroAsync();
                    }

                    return(artist);
                }
                catch (Exception ex)
                {
                    TelemetryHelper.TrackExceptionAsync(ex);
                    return(artist);
                }
            }

            return(artist);
        }
예제 #4
0
        async Task <List <DbArtist> > IndexArtistsAsync(
            IEnumerable <string> artists,
            Dictionary <string, DbArtist> artistsCache)
        {
            var artistsDelta = new List <DbArtist>();

            foreach (var a in artists)
            {
                // Empty Artist: Ignore artist relationship
                if (string.IsNullOrEmpty(a) || artistsCache.ContainsKey(a))
                {
                    continue;
                }

                var dbA = new DbArtist {
                    Name = a
                };
                m_dbContext.Artists.Add(dbA);
                artistsCache.Add(a, dbA);
                artistsDelta.Add(dbA);
            }
            await m_dbContext.SaveChangesAsync();

            return(artistsDelta);
        }
        public Album Insert(CreateAlbum value)
        {
            using (var tran = db.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead))
            {
                if (db.Albums.Any(t => EF.Functions.Like(t.Title, value.Title)))
                {
                    throw new ArgumentException("name must be unique");
                }

                DbGenre genre;
                if (db.Genres.Any(s => EF.Functions.Like(s.Name, value.Genre)))
                {
                    genre = db.Genres.FirstOrDefault(s => EF.Functions.Like(s.Name, value.Genre));
                }
                else
                {
                    var toInsert2 = new DbGenre()
                    {
                        Name = value.Genre
                    };
                    db.Genres.Add(toInsert2);

                    db.SaveChanges();

                    genre = toInsert2;
                }

                DbArtist artist;
                if (db.Artists.Any(s => EF.Functions.Like(s.Name, value.Artist)))
                {
                    artist = db.Artists.FirstOrDefault(s => EF.Functions.Like(s.Name, value.Artist));
                }
                else
                {
                    var toInsert2 = new DbArtist()
                    {
                        Name = value.Artist
                    };
                    db.Artists.Add(toInsert2);

                    db.SaveChanges();

                    artist = toInsert2;
                }

                var toInsert = new DbAlbum()
                {
                    Title = value.Title, ArtistId = artist.Id, GenreId = genre.Id
                };
                db.Albums.Add(toInsert);

                db.SaveChanges();
                tran.Commit();

                return(FindById(toInsert.Id));
            }
        }
        public void MapToDetailRep_HasExpectedBioImageUrl_WithValidInput()
        {
            DbArtist sourceObj = _validDbArtist;

            sourceObj.BioImageId = 1515;
            ArtistMapper mapper = new ArtistMapper();
            ArtistDetail result = mapper.MapToDetailRep(_validDbArtist);

            Assert.Equal("/api/image/1515", result.BioImageUrl);
        }
        public void MapToDetailRep_HasNullBioImageId_WithNullInput()
        {
            DbArtist sourceObj = _validDbArtist;

            sourceObj.BioImageId = null;
            ArtistMapper mapper = new ArtistMapper();
            ArtistDetail result = mapper.MapToDetailRep(_validDbArtist);

            Assert.Null(result.BioImageId);
        }
예제 #8
0
 /// <summary>
 /// Share an artist.
 /// </summary>
 /// <param name="artist">The artist to be shared.</param>
 public static void Share(this DbArtist artist)
 {
     if (artist != null)
     {
         var shareService = ShareServices.GetForCurrentView();
         shareService.PrecleanForSession();
         shareService.SetArtistContent(artist);
         shareService.ShowShareUI();
     }
 }
예제 #9
0
 /// <summary>
 /// Helper that verifies and creates new instance of <see cref="CommonViewItemModel"/> from artist entity.
 /// </summary>
 /// <param name="artist">Instance of <see cref="DbArtist"/>.</param>
 /// <returns>Instance of <see cref="CommonViewItemModel"/>. Will return null if given artist has null or empty name.</returns>
 public static CommonViewItemModel CreateFromDbArtistAndCheck(DbArtist artist)
 {
     if (string.IsNullOrEmpty(artist?.Name))
     {
         return(null);
     }
     else
     {
         return(new CommonViewItemModel(artist));
     }
 }
        private async Task <DbArtist> CreateArtist(string name, string bioText, string[] genres, string bioImagePath)
        {
            foreach (string genre in genres)
            {
                await this.CreateGenre(genre);
            }
            var existing = await this._context.Artists.FirstOrDefaultAsync(a => a.Name == name);

            if (existing != null)
            {
                return(existing);
            }
            var artist = new DbArtist()
            {
                Name          = name,
                BioText       = bioText,
                CreatedUtc    = DateTime.UtcNow,
                UpdatedUtc    = DateTime.UtcNow,
                PublishStatus = DbPublishedStatus.PUBLISHED
            };

            foreach (string genre in genres)
            {
                var dbGenre = await _context.Genres.FirstAsync(x => x.Name == genre);

                if (dbGenre != null)
                {
                    artist.ArtistGenres.Add(new DbArtistGenre()
                    {
                        Genre      = dbGenre,
                        CreatedUtc = DateTime.UtcNow
                    });
                }
            }

            if (!string.IsNullOrWhiteSpace(bioImagePath))
            {
                string fullPath = Path.Combine(Directory.GetCurrentDirectory(), bioImagePath);
                if (File.Exists(fullPath))
                {
                    artist.BioImage = new DbImageResource()
                    {
                        Data     = File.ReadAllBytes(fullPath),
                        MimeType = "image/png"
                    };
                }
            }

            _context.Artists.Add(artist);
            await _context.SaveChangesAsync();

            return(artist);
        }
예제 #11
0
 public static async void Shuffle(this DbArtist artist)
 {
     if (artist?.MediaFiles != null)
     {
         var random        = new Random();
         var shuffledFiles = artist.MediaFiles
                             .OrderBy(file => random.Next())
                             .Select(file => MusicPlaybackItem.CreateFromMediaFile(file));
         PlaybackControl.Instance.Clear();
         await PlaybackControl.Instance.AddFile(shuffledFiles.ToList(), -1);
     }
 }
        public void MapToDetailRep_HasPublishedStatus_WithValidInput(DbPublishedStatus publishedStatusTestCase)
        {
            DbArtist sourceObj = _validDbArtist;

            sourceObj.PublishStatus = publishedStatusTestCase;
            PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
            ArtistMapper         mapper            = new ArtistMapper();
            PublishStatus        expetedStatus     = statusMapper.Map(publishedStatusTestCase);
            ArtistDetail         result            = mapper.MapToDetailRep(sourceObj);
            ICollection <string> dbGenres          = _validDbArtist.ArtistGenres.Select(x => x.Genre.Name).ToList();

            Assert.Equal(expetedStatus, result.PublishedStatus);
        }
예제 #13
0
 public SearchResultModel(DbArtist artist)
 {
     Entity       = artist;
     Title        = artist.Name;
     Artist       = artist.Name;
     Subtitle     = CommonSharedStrings.ArtistText;
     ItemType     = CommonItemType.Artist;
     HasThumbnail = true;
     Thumbnail    = new ThumbnailTag
     {
         ArtistName = artist.Name,
         Fallback   = "Artist,ArtistPlaceholder"
     };
 }
예제 #14
0
 /// <summary>
 /// Play all songs by a specific artist.
 /// </summary>
 /// <param name="artist"></param>
 /// <param name="requireClear"></param>
 /// <param name="isInsert"></param>
 public static async void Play(this DbArtist artist, bool requireClear = false, bool isInsert = false)
 {
     if (artist?.MediaFiles != null)
     {
         var sortedFiles = artist.MediaFiles
                           .OrderBy(file => file.Title, new AlphabetAscendComparer())
                           .Select(file => MusicPlaybackItem.CreateFromMediaFile(file));
         if (requireClear)
         {
             PlaybackControl.Instance.Clear();
         }
         await PlaybackControl.Instance.AddFile(sortedFiles.ToList(), isInsert? -2 : -1);
     }
 }
예제 #15
0
        public async Task LoadTitleAsync(bool artistFallbackLarge = false)
        {
            _backendArtist = await _itemId.GetArtistByIdAsync();

            if (_backendArtist == null)
            {
                return;
            }

            ArtistBio          = !string.IsNullOrEmpty(_backendArtist.Intro) ? _backendArtist.Intro : string.Empty;
            ArtistName         = _backendArtist.Name;
            BackgroundImageTag = new ThumbnailTag
            {
                Fallback   = artistFallbackLarge ? "Artist,DefaultArtistLarge" : "Artist,ArtistPlaceholder",
                ArtistName = _backendArtist.Name,
            };
        }
        public async Task <ArtistDetail> AddAsync(Artist artist)
        {
            PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();
            var newArtistEntity = new DbArtist()
            {
                CreatedUtc    = DateTime.Now,
                UpdatedUtc    = DateTime.Now,
                Name          = artist.Name,
                BioText       = artist.BioText,
                PublishStatus = statusMapper.Map(artist.PublishedStatus)
            };

            foreach (string genre in artist.Genres)
            {
                var dbGenre = await _context.Genres.SingleOrDefaultAsync(x => x.Name == genre);

                if (dbGenre != null)
                {
                    newArtistEntity.ArtistGenres.Add((new DbArtistGenre()
                    {
                        Genre = dbGenre
                    }));
                }
                else
                {
                    throw new RepositoryException($"The supplied genre '{genre}' does not exist.");
                }
            }
            if (artist.BioImageId.HasValue)
            {
                var img = await this._context.ImageResources.SingleOrDefaultAsync(x => x.Id == artist.BioImageId.Value);

                if (img != null)
                {
                    newArtistEntity.BioImage = img;
                }
                else
                {
                    throw new RepositoryException($"Invalid {nameof(artist.BioImageId)}, no image for ID");
                }
            }
            this._context.Artists.Add(newArtistEntity);
            await this._context.SaveChangesAsync();

            return(_mapper.MapToDetailRep(newArtistEntity));
        }
예제 #17
0
        /// <summary>
        /// Load artist intro for a specific artist.
        /// </summary>
        /// <param name="elem"></param>
        /// <returns></returns>
        public static async Task <DbArtist> LoadArtistIntroAsync(this DbArtist elem)
        {
            if (InternetConnectivityDetector.HasInternetConnection)
            {
                try
                {
                    var bio = await GrooveMusicMetadata.GetArtistBio(elem.Name);

                    elem.Intro = bio;
                }
                catch (Exception ex)
                {
                    TelemetryHelper.TrackExceptionAsync(ex);
                }
            }

            return(elem);
        }
예제 #18
0
        /// <summary>
        /// Load online content for a specific artist.
        /// </summary>
        /// <param name="elem"></param>
        /// <returns></returns>
        public static async Task <string> LoadArtistOnlineContentAsync(this DbArtist elem)
        {
            // Check internet connection
            if (InternetConnectivityDetector.HasInternetConnection)
            {
                // Return Online content
                try
                {
                    var modifyFlag = false;

                    if (string.IsNullOrEmpty(elem.Intro))
                    {
                        var bio = await GrooveMusicMetadata.GetArtistBio(elem.Name);

                        if (!string.IsNullOrEmpty(bio))
                        {
                            modifyFlag = true;
                        }
                    }

                    if (modifyFlag)
                    {
                        using (var scope = ApplicationServiceBase.App.GetScope())
                            using (var context = scope.ServiceProvider.GetRequiredService <MedialibraryDbContext>())
                            {
                                context.Entry(elem).Entity.ImagePath = elem.ImagePath;
                                context.Entry(elem).Entity.Intro     = elem.Intro;
                                context.Entry(elem).State            = EntityState.Modified;
                                await context.SaveChangesAsync();
                            }

                        return(elem.ImagePath);
                    }
                }
                catch (Exception ex)
                {
                    TelemetryHelper.TrackExceptionAsync(ex);
                }
            }

            return(string.Empty);
        }
        public Artist Insert(CreateArtist value)
        {
            using (var tran = db.Database.BeginTransaction(System.Data.IsolationLevel.RepeatableRead))
            {
                if (db.Artists.Any(t => EF.Functions.Like(t.Name, value.Name)))
                {
                    throw new ArgumentException("name must be unique");
                }

                var toInsert = new DbArtist()
                {
                    Name = value.Name
                };
                db.Artists.Add(toInsert);

                db.SaveChanges();
                tran.Commit();

                return(ToModel(toInsert));
            }
        }
예제 #20
0
        public ArtistDetail MapToDetailRep(DbArtist a)
        {
            PublishedStatusEnumMapper statusMapper = new PublishedStatusEnumMapper();

            if (a == null)
            {
                throw new NullReferenceException($"A null value was passed to the mapper. Expected an object of type {nameof(DbArtist)}");
            }
            return(new ArtistDetail
            {
                Id = a.Id,
                Name = a.Name,
                BioText = a.BioText,
                BioImageId = a.BioImageId,
                  BioImageUrl = (a.BioImageId.HasValue ? $"/api/image/{a.BioImageId.Value}" : null),
                Genres = a.ArtistGenres.Select(g => g.Genre.Name).ToList(),
                CreatedUtc = new DateTime(a.CreatedUtc.Ticks, DateTimeKind.Utc),
                UpdatedUtc = new DateTime(a.UpdatedUtc.Ticks, DateTimeKind.Utc),
                PublishedStatus = statusMapper.Map(a.PublishStatus)
            });
        }
예제 #21
0
        public AlbumRepositoryTests()
        {
            // set up test data
            var options = new DbContextOptionsBuilder <MusicStoreDbContext>()
                          .UseInMemoryDatabase(databaseName: "test_db" + Guid.NewGuid().ToString())
                          .Options;

            this.db = new MusicStoreDbContext(options);
            foreach (string g in _validGenres)
            {
                this.db.Genres.Add(new DbGenre {
                    Name = g, CreatedUtc = DateTime.UtcNow
                });
            }
            var imageResource = new DbImageResource()
            {
                MimeType = "img/png",
                Data     = new byte[10]
            };
            var artist = new DbArtist
            {
                BioText       = "",
                CreatedUtc    = DateTime.UtcNow,
                Name          = "test artist",
                PublishStatus = DbPublishedStatus.PUBLISHED,
                UpdatedUtc    = DateTime.UtcNow
            };

            db.ImageResources.Add(imageResource);
            db.Artists.Add(artist);

            db.SaveChanges();
            _validImageId  = imageResource.Id;
            _validArtistId = artist.Id;
            var loggerMock = new Mock <ILogger <ArtistController> >();

            this.repo = new AlbumRepository(this.db, new AlbumMapper());
        }
        public ArtistMapperTests()
        {
            ICollection <DbArtistGenre> artistGenres = (new List <string> {
                "genre1", "genre2", "genre3"
            }).Select(x =>
                      new DbArtistGenre {
                Genre = new DbGenre()
                {
                    Name = x, CreatedUtc = DateTime.UtcNow, UpdatedUtc = DateTime.UtcNow
                }
            }).ToList();

            DbArtist artist = new DbArtist()
            {
                Id            = 44,
                Name          = "SampleName",
                BioText       = "SampleText",
                CreatedUtc    = DateTime.UtcNow,
                UpdatedUtc    = DateTime.UtcNow,
                PublishStatus = DbPublishedStatus.PUBLISHED,
            };

            // artist genres is a virtual readonly property mock this property
            // and manualy set the rest of the values on the resulting object
            var stub = new Mock <DbArtist>();

            stub.SetupGet(x => x.ArtistGenres).Returns(artistGenres);

            stub.Object.Id            = 44;
            stub.Object.Name          = "SampleName";
            stub.Object.BioText       = "SampleText";
            stub.Object.CreatedUtc    = DateTime.UtcNow;
            stub.Object.UpdatedUtc    = DateTime.UtcNow;
            stub.Object.PublishStatus = DbPublishedStatus.PUBLISHED;
            _validDbArtist            = stub.Object;
        }
예제 #23
0
 /// <summary>
 /// Write online data into database.
 /// </summary>
 /// <param name="elem"></param>
 /// <returns></returns>
 private async Task CommitOnlineData(DbArtist elem)
 {
     using (var scope = ApplicationServiceBase.App.GetScope())
         using (var context = scope.ServiceProvider.GetRequiredService <MedialibraryDbContext>())
         {
             try
             {
                 var query = context.Artists.Where(i => i.Id == elem.Id);
                 if (query.Any())
                 {
                     var item = query.FirstOrDefault();
                     context.Entry(item).Entity.Intro = elem.Intro;
                     // ArtistImagePath is the absoulte path on disk.
                     context.Entry(item).Entity.ImagePath = elem.ImagePath;
                     context.Entry(item).State            = EntityState.Modified;
                     await context.SaveChangesAsync();
                 }
             }
             catch (Exception ex)
             {
                 TelemetryHelper.TrackExceptionAsync(ex);
             }
         }
 }
        public async Task CreateSeedContent()
        {
            DbArtist tempArtistResult = null;

            tempArtistResult = await CreateArtist("Beck", "Bio text...", new string[] { "Indie", "Electronic" }, null);

            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Modern Guilt",
                description : "",
                genres : new string[] { "Alternative" },
                producer : "Danger Mouse, Beck",
                label : "DGC Records",
                releaseDate : new DateTime(2008, 7, 8),
                price : 13.99,
                coverImagePath : "Images/Covers/Beck_ModernGuilt.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("Orphans", "3:15"),
                new TrackStruct("Gamma Ray", "2:57"),
                new TrackStruct("Chemtrails", "4:40"),
                new TrackStruct("Modern Guilt", "3:14"),
                new TrackStruct("Youthless", "3:00"),
                new TrackStruct("Walls", "2:22"),
                new TrackStruct("Replica", "3:25"),
                new TrackStruct("Soul of a Man", "2:36"),
                new TrackStruct("Profanity Prayers", "3:43"),
                new TrackStruct("Volcano", "4:26")
            });
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Guero",
                description : "",
                genres : new string[] { "Electronic", "Hip Hop", "Rock" },
                producer : "Beck Hansen, Dust Brothers, Tony Hoffer",
                label : "Interscope Records",
                releaseDate : new DateTime(2005, 3, 21),
                price : 13.99,
                coverImagePath : "Images/Covers/beckguero.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("E-Pro", "3:22"),
                new TrackStruct("Qué Onda Guero", "3:29"),
                new TrackStruct("Girl", "3:30"),
                new TrackStruct("Missing", "4:44"),
                new TrackStruct("lack Tambourine", "2:46"),
                new TrackStruct("Earthquake Weather", "4:26"),
                new TrackStruct("Hell Yes", "3:18"),
                new TrackStruct("Broken Drum", "4:30"),
                new TrackStruct("Scarecrow", "4:16"),
                new TrackStruct("Go It Alone", "4:09"),
                new TrackStruct("Farewell Ride", "4:19"),
                new TrackStruct("Rental Car", "3:05"),
                new TrackStruct("Emergency Exit", "4:01"),
                new TrackStruct("Send A Message To Her", "4:28"),
                new TrackStruct("Chain Reaction", "3:27"),
                new TrackStruct("Clap Hands", "3:19")
            });

            tempArtistResult = await CreateArtist("Fleetwood Mac", "Bio text...", new string[] { "Rock" }, null);

            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Rumours",
                description : "",
                genres : new string[] { "Rock" },
                producer : "Fleetwood Mac, Ken Caillat, Richard Dashut",
                label : "Warner Bros",
                releaseDate : new DateTime(1977, 2, 4),
                price : 13.99,
                coverImagePath : "Images/Covers/FMacRumours.png",
                tracks : new TrackStruct[] {
                new TrackStruct("Second Hand News", "2:56"),
                new TrackStruct("Dreams", "4:14"),
                new TrackStruct("Never Going Back Again", "2:14"),
                new TrackStruct("Dont Stop", "3:13"),
                new TrackStruct("Go Your Own Way", "3:13"),
                new TrackStruct("Songbird", "3:30"),
                new TrackStruct("The Chain", "4:30"),
                new TrackStruct("You Make Loving Fun", "3:31"),
                new TrackStruct("I Don't Want to Know", "3:15"),
                new TrackStruct("Oh Daddy", "3:56"),
                new TrackStruct("Gold Dust Woman", "4:56")
            });

            tempArtistResult = await CreateArtist("LCD Soundsystem", "", new string[] { "Dance-Punk", "Electronica", "Electronic Rock", "Alt-Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Sound of Silver",
                description : "",
                genres : new string[] { "Dance-Punk", "Electronica", "Electronic Rock" },
                producer : "DFA, Capitol, EMI",
                label : "The DFA",
                releaseDate : new DateTime(2007, 3, 12),
                price : 13.99,
                coverImagePath : "Images/Covers/SoundOfSilver.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("Get Innocuous!", "7:11"),
                new TrackStruct("Time to Get Away", "4:11"),
                new TrackStruct("North American scum", "5:25"),
                new TrackStruct("Someone Great", "6:25"),
                new TrackStruct("All My Friends", "7:37"),
                new TrackStruct("Us v Them", "8:29"),
                new TrackStruct("Watch the Tapes", "3:55"),
                new TrackStruct("Sound of Silver", "7:07"),
                new TrackStruct("New York, I Love You but You're Bringing Me Down", "5:35")
            });

            tempArtistResult = await CreateArtist("Arcade Fire", "", new string[] { "Rock", "Indie-Rock" }, null);

            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Funeral",
                description : "",
                genres : new string[] { "Indie-Rock", "Rock" },
                producer : "Arcade Fire",
                label : "Merge",
                releaseDate : new DateTime(2004, 9, 14),
                price : 13.99,
                coverImagePath : "Images/Covers/afFuneral.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("Neighborhood #1 (Tunnels)", "4:48"),
                new TrackStruct("Neighborhood #2 (Laïka)", "3:32"),
                new TrackStruct("Une Année Sans Lumière", "3:41"),
                new TrackStruct("Neighborhood #3 (Power Out)", "5:12"),
                new TrackStruct("Neighborhood #4 (7 Kettles)", "4:49"),
                new TrackStruct("Crown Of Love", "4:42"),
                new TrackStruct("Wake Up", "5:35"),
                new TrackStruct("Haïti", "4:07"),
                new TrackStruct("Rebellion(Lies)", "5:12"),
                new TrackStruct("In The Backseat", "6:20")
            });

            tempArtistResult = await CreateArtist("Pixies", "", new string[] { "Noise-Pop", "Alt-Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Doolittle",
                description : "",
                genres : new string[] { "Noise-Pop", "Alt-Rock" },
                producer : "Gil Norton",
                label : "4AD, Elektra",
                releaseDate : new DateTime(1998, 10, 23),
                price : 13.99,
                coverImagePath : "Images/Covers/Pixies-Doolittle.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("Debaser", "2:52"),
                new TrackStruct("Tame", "1:55"),
                new TrackStruct("Wave Of Mutilation", "2:04"),
                new TrackStruct("I Bleed", "2:34"),
                new TrackStruct("Here Comes Your Man", "3:21"),
                new TrackStruct("Dead", "2:21"),
                new TrackStruct("Monkey Gone To Heaven", "2:57"),
                new TrackStruct("Mr.Grieves", "2:05"),
                new TrackStruct("Crackity Jones", "1:24"),
                new TrackStruct("La La Love You", "2:43"),
                new TrackStruct("No. 13 Baby", "3:51"),
                new TrackStruct("There Goes My Gun", "1:49"),
                new TrackStruct("Hey", "3:31"),
                new TrackStruct("Silver", "2:25"),
                new TrackStruct("Gouge Away", "2:45")
            });

            tempArtistResult = await CreateArtist("Wilco", "", new string[] { "Alt-rock", "Indie-Rock", "Alternative country" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Yankee Hotel Foxtrot",
                description : "",
                genres : new string[] { "Alt-rock", "Indie-Rock" },
                producer : "Wilco",
                label : "Nonesuch",
                releaseDate : new DateTime(1998, 10, 23),
                price : 13.99,
                coverImagePath : "Images/Covers/yankeehotelfoxtrot.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("I Am Trying To Break Your Heart", "6:57"),
                new TrackStruct("Kamera", "3:29"),
                new TrackStruct("Radio Cure ", "5:08"),
                new TrackStruct("War On War", "3:47"),
                new TrackStruct("Jesus, Etc.", "3:50"),
                new TrackStruct("Ashes Of American Flags", "4:43"),
                new TrackStruct("Heavy Metal Drummer", "3:08"),
                new TrackStruct("I'm The Man Who Loves You", "3:55"),
                new TrackStruct("Pot Kettle Black", "4:00"),
                new TrackStruct("Poor Places", "5:15"),
                new TrackStruct("Reservations", "7:22")
            });
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Sky Blue Sky",
                description : "",
                genres : new string[] { "Alt-rock", "Indie-Rock" },
                producer : "Wilco",
                label : "Nonesuch",
                releaseDate : new DateTime(2007, 5, 15),
                price : 13.99,
                coverImagePath : "Images/Covers/skybluesky.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("Either Way", "3:01"),
                new TrackStruct("You Are My Face", "4:39"),
                new TrackStruct("Impossible Germany", "5:58"),
                new TrackStruct("Sky Blue Sky", "3:24"),
                new TrackStruct("Side With The Seeds", "4:16"),
                new TrackStruct("Shake It Off", "5:43"),
                new TrackStruct("Please Be Patient With Me", "3:20"),
                new TrackStruct("Hate It Here", "4:34"),
                new TrackStruct("Leave Me(Like You Found Me)", "4:11"),
                new TrackStruct("Walken", "4:28"),
                new TrackStruct("What Light ", "3:36"),
                new TrackStruct("On And On And On", "4:02"),
            });

            tempArtistResult = await CreateArtist("Pearl Jam", "Bio text...", new string[] { "Grunge", "Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Ten",
                description : "",
                genres : new string[] { "Alt-rock", "Grunge" },
                producer : "Rick Parashar, Pearl Jam",
                label : "Epic",
                releaseDate : new DateTime(1991, 8, 27),
                price : 9.99,
                coverImagePath : "Images/Covers/pjTen.jpg",
                tracks : new TrackStruct[] {
                new TrackStruct("Once", "3:51"),
                new TrackStruct("Even Flow", "4:53"),
                new TrackStruct("Alive", "5:40"),
                new TrackStruct("Why Go", "3:19"),
                new TrackStruct("Black", "5:43"),
                new TrackStruct("Jeremy", "5:18"),
                new TrackStruct("Oceans", "2:41"),
                new TrackStruct("Porch", "3:30"),
                new TrackStruct("Garden", "4:58"),
                new TrackStruct("Deep", "4:13"),
                new TrackStruct("Release", "5:05"),
                new TrackStruct("Master / Slave", "3:43"),
            });

            tempArtistResult = await CreateArtist("Graham Coxon", "Bio text...", new string[] { "Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Love Travels At Illegal Speeds",
                description : "",
                genres : new string[] { "Rock", "Alternative Rock", "Brit Pop" },
                producer : "Stephen Street",
                label : "Parlophone",
                releaseDate : new DateTime(2006, 3, 8),
                price : 9.99,
                coverImagePath : "Images/Covers/gc-ltais.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Standing On My Own Again", "4:29"),
                new TrackStruct("I Can't Look At Your Skin", "3:35"),
                new TrackStruct("Don't Let Your Man Know", "2:54"),
                new TrackStruct("Just A State Of Mind", "4:36"),
                new TrackStruct("You & I", "3:42"),
                new TrackStruct("Gimme Some Love", "2:32"),
                new TrackStruct("I Don't Wanna Go Out", "4:17"),
                new TrackStruct("Don't Believe Anything I Say", "5:26"),
                new TrackStruct("Tell It Like It Is", "4:02"),
                new TrackStruct("Flights To The Sea (Lovely Rain)", "3:25"),
                new TrackStruct("What's He Got?", "3:42"),
                new TrackStruct("You Always Let Me Down", "2:49"),
                new TrackStruct("See A Better Day", "5:10"),
                new TrackStruct("Click Click Click", "2:54"),
                new TrackStruct("Livin'", "3:42"),
            });

            tempArtistResult = await CreateArtist("Yeah Yeah Yeahs", "Bio text...", new string[] { "Rock", "Electronic", "Alternative Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "It's Blitz!",
                description : "",
                genres : new string[] { "Rock", "Alternative Rock", "Electronic" },
                producer : "Nick Launay, David Sitek",
                label : "Dress Up, DGC, Interscope",
                releaseDate : new DateTime(2009, 3, 6),
                price : 9.99,
                coverImagePath : "Images/Covers/itsblitz.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Zero", "4:26"),
                new TrackStruct("Heads Will Roll", "3:42"),
                new TrackStruct("Soft Shock", "3:53"),
                new TrackStruct("Skeletons", "5:02"),
                new TrackStruct("Dull Life", "4:08"),
                new TrackStruct("Shame And Fortune", "3:31"),
                new TrackStruct("Runaway", "5:13"),
                new TrackStruct("Dragon Queen", "4:02"),
                new TrackStruct("Hysteric", "3:52"),
                new TrackStruct("Little Shadow", "3:57"),
            });

            tempArtistResult = await CreateArtist("The Flaming Lips", "Bio text...", new string[] { "Experimental", "Indie Rock", "Psychedelic Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "The Soft Bulletin",
                description : "",
                genres : new string[] { "Experimental", "Indie Rock", "Psychedelic Rock" },
                producer : "Dave Fridmann",
                label : "Warner Bros",
                releaseDate : new DateTime(1999, 5, 17),
                price : 9.99,
                coverImagePath : "Images/Covers/flaminglipstsb.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Race For The Prize", "4:18"),
                new TrackStruct("A Spoonful Weighs A Ton", "3:32"),
                new TrackStruct("The Spark That Bled", "5:55"),
                new TrackStruct("Slow Motion", "3:53"),
                new TrackStruct("What Is The Light?", "4:05"),
                new TrackStruct("The Observer", "4:10"),
                new TrackStruct("Waitin' For A Superman", "4:17"),
                new TrackStruct("Suddenly Everything Has Changed", "3:54"),
                new TrackStruct("The Gash", "4:02"),
                new TrackStruct("Feeling Yourself Disintegrate", "5:17"),
                new TrackStruct("Sleeping On The Roof", "3:10"),
                new TrackStruct("Race For The Prize", "4:09"),
                new TrackStruct("Waitin' For A Superman", "4:19"),
                new TrackStruct("Buggin'", "3:16")
            });

            tempArtistResult = await CreateArtist("Pavement", "Bio text...", new string[] { "Indie Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Crooked Rain, Crooked Rain",
                description : "",
                genres : new string[] { "Indie Rock" },
                producer : "Pavement",
                label : "Big Cat",
                releaseDate : new DateTime(1999, 5, 17),
                price : 9.99,
                coverImagePath : "Images/Covers/crookedrain.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Silence Kit", "3:00"),
                new TrackStruct("Elevate Me Later", "2:51"),
                new TrackStruct("Stop Breathin", "4:27"),
                new TrackStruct("Cut Your Hair", "3:06"),
                new TrackStruct("Newark Wilder", "3:53"),
                new TrackStruct("Unfair", "2:33"),
                new TrackStruct("Gold Soundz", "2:39"),
                new TrackStruct("5-4 = Unity", "2:09"),
                new TrackStruct("Range Life", "4:54"),
                new TrackStruct("Heaven Is A Truck", "2:30"),
                new TrackStruct("Hit The Plane Down", "3:36"),
                new TrackStruct("Fillmore Jive", "6:38")
            });

            tempArtistResult = await CreateArtist("Doves", "Bio text...", new string[] { "Indie Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Lost Souls",
                description : "",
                genres : new string[] { "Brit Pop", "Indie Rock" },
                producer : "Doves; Steve Osborne",
                label : "Heavenly Records",
                releaseDate : new DateTime(2000, 5, 3),
                price : 9.99,
                coverImagePath : "Images/Covers/lostsouls.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Firesuite", "4:36"),
                new TrackStruct("Here It Comes", "4:50"),
                new TrackStruct("Break Me Gently", "4:38"),
                new TrackStruct("Sea Song", "6:12"),
                new TrackStruct("Rise", "5:38"),
                new TrackStruct("Lost Souls", "6:09"),
                new TrackStruct("Melody Calls", "3:27"),
                new TrackStruct("Catch The Sun", "4:49"),
                new TrackStruct("The Man Who Told Everything", "5:47"),
                new TrackStruct("The Cedar Room", "7:38"),
                new TrackStruct("Reprise", "1:45"),
                new TrackStruct("A House", "3:40")
            });

            tempArtistResult = await CreateArtist("Queens of the Stone Age", "Bio text...", new string[] { "Rock", "Indie Rock" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Rated R",
                description : "",
                genres : new string[] { "Rock" },
                producer : "Chris Goss, Joshua Homme",
                label : "Heavenly Records",
                releaseDate : new DateTime(2000, 6, 5),
                price : 9.99,
                coverImagePath : "Images/Covers/qotsar.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Feel Good Hit Of The Summer", "2:43"),
                new TrackStruct("The Lost Art Of Keeping A Secret", "3:36"),
                new TrackStruct("Leg Of Lamb", "2:48"),
                new TrackStruct("Auto Pilot", "4:01"),
                new TrackStruct("Better Living Through Chemistry", "5:49"),
                new TrackStruct("Monsters In The Parasol", "3:27"),
                new TrackStruct("Quick And To The Pointless", "1:42"),
                new TrackStruct("In The Fade", "3:51"),
                new TrackStruct("Untitled", "0:34"),
                new TrackStruct("Tension Head", "2:52"),
                new TrackStruct("Lightning Song", "2:07"),
                new TrackStruct("I Think I Lost My Headache", "8:40")
            });


            tempArtistResult = await CreateArtist("The Go! Team", "Bio text...", new string[] { "Leftfield", "Abstract", "Electro", "Future Jazz" }, null);
            await CreateAlbum(
                artistId : tempArtistResult.Id,
                title : "Thunder, Lightning, Strike",
                description : "",
                genres : new string[] { "Leftfield", "Abstract", "Electro", "Future Jazz" },
                producer : "The Go! Team, Gareth Parton",
                label : "Memphis Industries",
                releaseDate : new DateTime(2004, 9, 13),
                price : 9.99,
                coverImagePath : "Images/Covers/thunderlightningstrike.jpeg",
                tracks : new TrackStruct[] {
                new TrackStruct("Panther Dash", "2:42"),
                new TrackStruct("Ladyflash", "4:07"),
                new TrackStruct("Feelgood By Numbers", "1:56"),
                new TrackStruct("The Power Is On", "3:11"),
                new TrackStruct("Get It Together", "3:24"),
                new TrackStruct("Junior Kickstart", "3:30"),
                new TrackStruct("Air Raid Gtr", "0:41"),
                new TrackStruct("Bottle Rocket", "3:40"),
                new TrackStruct("Friendship Update", "3:58"),
                new TrackStruct("Huddle Formation", "3:09"),
                new TrackStruct("Everyone's A V.I.P. To Someone", "4:55")
            });

            List <int> groupIds = _context.AlbumGroups.Select(x => x.Id).ToList();

            // randomize the item order in each group
            foreach (var groupId in groupIds)
            {
                var items = _context.AlbumGroupListPositions.Where(x => x.GroupId == groupId)
                            .AsEnumerable()
                            .OrderBy(x => Guid.NewGuid());
                int i = 1;
                foreach (var itm in items)
                {
                    itm.PositionIndex = i;
                    i++;
                }
                await _context.SaveChangesAsync();
            }
        }
 private Artist ToModel(DbArtist value)
 {
     return(new Artist(value.Id, value.Name));
 }
예제 #26
0
        public AlbumRepository_ListByAlbumGroupKeyTests()
        {
            // set up test data
            var options = new DbContextOptionsBuilder <MusicStoreDbContext>()
                          .UseInMemoryDatabase(databaseName: "test_db" + Guid.NewGuid().ToString())
                          .Options;

            this.db = new MusicStoreDbContext(options);
            foreach (string g in _validGenres)
            {
                this.db.Genres.Add(new DbGenre {
                    Name = g, CreatedUtc = DateTime.UtcNow
                });
            }
            var imageResource = new DbImageResource()
            {
                MimeType = "img/png",
                Data     = new byte[10]
            };
            var artist = new DbArtist
            {
                BioText       = "",
                CreatedUtc    = DateTime.UtcNow,
                Name          = "test artist",
                PublishStatus = DbPublishedStatus.PUBLISHED,
                UpdatedUtc    = DateTime.UtcNow
            };

            db.ImageResources.Add(imageResource);
            db.Artists.Add(artist);

            List <DbAlbum> testAlbums = new List <DbAlbum>();

            for (int i = 0; i < 10; i++)
            {
                testAlbums.Add(new DbAlbum
                {
                    Title         = "test_album_" + i,
                    CreatedUtc    = DateTime.UtcNow,
                    PublishStatus = DbPublishedStatus.PUBLISHED,
                    ReleaseDate   = DateTime.Now,
                    UpdatedUtc    = DateTime.UtcNow,
                    Artist        = new DbArtist
                    {
                        Name          = "test artist " + i,
                        PublishStatus = DbPublishedStatus.PUBLISHED,
                        CreatedUtc    = DateTime.UtcNow,
                        UpdatedUtc    = DateTime.UtcNow
                    }
                });
            }
            this.db.Albums.AddRange(testAlbums);

            var group = new DbAlbumGroup
            {
                CreatedUtc = DateTime.UtcNow,
                Key        = VALID_GROUP_KEY,
                Name       = "test group",
                UpdatedUtc = DateTime.UtcNow
            };

            db.AlbumGroups.Add(group);
            db.SaveChanges();
            _validImageId  = imageResource.Id;
            _validArtistId = artist.Id;
            _validGroupId  = group.Id;
            _validAlbumIds = testAlbums.Select(x => x.Id).ToArray();
            for (int i = 0; i < _validAlbumIds.Length; i++)
            {
                // insert all albums into the test group
                db.AlbumGroupListPositions.Add(new DbAlbumGroupAlbumPosition
                {
                    AlbumId       = _validAlbumIds[i],
                    GroupId       = _validGroupId,
                    CreatedUtc    = DateTime.UtcNow,
                    PositionIndex = i
                });
            }
            db.SaveChanges();

            var loggerMock = new Mock <ILogger <ArtistController> >();

            this.repo = new AlbumRepository(this.db, new AlbumMapper());
        }
예제 #27
0
 /// <summary>
 /// Set content for artist.
 /// </summary>
 /// <param name="item">The artist information to be shared.</param>
 public void SetArtistContent(DbArtist artist)
 {
     Title       = artist.Name;
     Description = artist.Intro ?? string.Empty;
 }