public PinAlbumCommand( IAlbumArtStorage albumArtStorage, AlbumViewModel albumViewModel) { _albumArtStorage = albumArtStorage; _albumViewModel = albumViewModel; }
public ActionResult Create(AlbumViewModel album, string userId) { if (!ModelState.IsValid) { return View("_CreateAlbum", album); } var loggedUserId = this.User.Identity.GetUserId(); if (userId != loggedUserId) { return new EmptyResult(); } var newAlbum = new Album() { Title = album.Title, Description = album.Description, UserId = loggedUserId, AlbumPhotos = new List<AlbumPhoto>() }; this.Data.Albums.Add(newAlbum); this.Data.SaveChanges(); ViewBag.profileId = userId; return RedirectToAction("Index", new { id = loggedUserId }); }
public AlbumController( IMusicProvider musicProvider, AlbumViewModel.Factory albumViewModelFactory) { _musicProvider = musicProvider; _albumViewModelFactory = albumViewModelFactory; }
public ArtistsController( IMusicProvider musicProvider, ArtistsViewModel.Factory artistsViewModelFactory, AlbumViewModel.Factory albumViewModelFactory, ArtistViewModel.Factory artistViewModelFactory) { _musicProvider = musicProvider; _artistsViewModelFactory = artistsViewModelFactory; _albumViewModelFactory = albumViewModelFactory; _artistViewModelFactory = artistViewModelFactory; }
public async Task<bool> UpdateAlbumAsync(AlbumViewModel albumViewModel, CancellationToken ct = default(CancellationToken)) { var album = await _albumRepository.GetByIdAsync(albumViewModel.AlbumId, ct); if (album == null) return false; album.AlbumId = albumViewModel.AlbumId; album.Title = albumViewModel.Title; album.ArtistId = albumViewModel.ArtistId; return await _albumRepository.UpdateAsync(album, ct); }
private void BeginMoveAlbum() { if (SelectedAlbum == null) { return; } _albumToMove = SelectedAlbum; _albumToMovePerformer = SelectedPerformer; MessageBox.Show("Now select the performer and click the 'Move album here' button"); }
//[HttpPost] public async Task <IActionResult> AddPhoto(String name, AlbumViewModel model) { var newFileName = string.Empty; if (HttpContext.Request.Form.Files != null) { var user = await _userManager.GetUserAsync(HttpContext.User); var modelUser = _repository.GetUser(user.Id); var fileName = string.Empty; string PathDB = string.Empty; var files = HttpContext.Request.Form.Files; foreach (var file in files) { if (file.Length > 0) { //Getting FileName fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.ToString().Replace('"', ' ').Trim(); //Assigning Unique Filename (Guid) var myUniqueFileName = Convert.ToString(Guid.NewGuid()); //Getting file Extension var FileExtension = Path.GetExtension(fileName); // concating FileName + FileExtension newFileName = myUniqueFileName + FileExtension; // Combines two strings into a path. fileName = Path.Combine(_environment.WebRootPath, "uploads") + $@"\{newFileName}"; string thumbnail = Path.Combine(_environment.WebRootPath, "uploads") + $@"\thumbs" + $@"\{newFileName}"; // if you want to store path of folder in database PathDB = "~/uploads/" + newFileName; string thumbnailDB = "~/uploads/thumbs/" + newFileName; using (FileStream fs = System.IO.File.Create(fileName)) { file.CopyTo(fs); fs.Flush(); } CreateThumbnail(150, fileName, thumbnail); await _repository.AddPhotoToAlbumAsync(model.Id, user.Id, PathDB, thumbnailDB); } } return(RedirectToAction("ShowAlbumPhotos", new RouteValueDictionary( new { controller = "Album", action = "ShowAlbumPhotos", id = model.Id })));//popraviti } return(View("AddPhoto", model)); }
public ActionResult Edit(AlbumViewModel albumViewModel) { if (ModelState.IsValid) { //var errors = ModelState.Values.SelectMany(v => v.Errors); _albumAppService.Atualizar(albumViewModel); return(RedirectToAction("Index")); } IEnumerable <AlbumViewModel> AlbumViewModels = _albumAppService.ObterTodos(); return(View(AlbumViewModels)); }
public bool Upload(IEnumerable <HttpPostedFileBase> files, string Album, String Artist) { bool _state = false; // var _RootDir = "~/Content/Media/Music"; var _RootDir = Path.Combine(System.Web.Hosting.HostingEnvironment.MapPath(System.Web.HttpRuntime.AppDomainAppVirtualPath), "Content", "Media", "Music"); if (!System.IO.Directory.Exists(_RootDir)) { System.IO.Directory.CreateDirectory(_RootDir); } foreach (var file in files) { if (!(file == null)) { if (! ( file.FileName.Contains(".mp3") || file.FileName.Contains(".wmv") || file.FileName.Contains(".wav") ) ) { return(false); } if (file.ContentLength > 0) { var _fileName = Path.GetFileName(file.FileName); var path = Path.Combine(_RootDir, Album, Artist); if (!System.IO.Directory.Exists(path)) { System.IO.Directory.CreateDirectory(path); } file.SaveAs(Path.Combine(path, _fileName)); AlbumViewModel ThisAlbum = AddAlbum(Album); ArtistViewModel ThisArtist = AddArtist(Artist); TrackViewModel Track = new TrackViewModel { TrackName = _fileName, AlbumId = ThisAlbum.AlbumId, ArtistId = ThisArtist.ArtistId, TrackURL = Path.Combine(path, _fileName) }; repo.Add(Track.ToData()); repo.SaveChanges(); _state = true; } } } return(_state); }
public static AlbumViewModel ToModel(this Album Entity) { var Model = new AlbumViewModel() { Id = Entity.Id, Name = Entity.Name, Topic = (AlbumTopic)((int)Entity.Topic), DateCreated = (DateTime)Entity.DateCreated }; return(Model); }
public ActionResult CreateAlbum(AlbumViewModel collection, HttpPostedFileBase file) { if (ModelState.IsValid) { Artist artist = db.Artists.Find(collection.SelectedArtistId); if (file != null && file.ContentLength > 0) { var fileName = Path.GetFileName(file.FileName); string path1 = Server.MapPath("/Content/images/covers/"); if (!Directory.Exists(path1 + artist.Name)) { Directory.CreateDirectory(path1 + artist.Name); } if (!Directory.Exists(path1 + artist.Name + "/" + collection.Album.Name)) { Directory.CreateDirectory(path1 + artist.Name + "/" + collection.Album.Name); } var path = Server.MapPath("/Content/images/covers/" + artist.Name + "/" + collection.Album.Name + "/" + fileName); file.SaveAs(path); collection.Album.Cover = "/Content/images/covers/" + artist.Name + "/" + collection.Album.Name + "/" + fileName; } else { collection.Album.Cover = "/Content/images/covers/unknown_album.png"; } collection.Album.Position = -1; collection.Album.Songs = new List <Song>(); if (string.IsNullOrEmpty(collection.Album.Cover)) { collection.Album.Cover = "/Content/images/covers/unknown_album.png"; } collection.Album.ArtistName = artist.Name; artist.Albums.Add(collection.Album); db.Entry(artist).State = EntityState.Modified; db.SaveChanges(); return(RedirectToAction("Artist", new { artist = artist.Name })); } collection.Artists = db.Artists.ToList().Select(x => new SelectListItem { Text = x.Name, Value = x.Id.ToString() }); return(View(collection)); }
public ActionResult Create(AlbumViewModel collection) { if (ModelState.IsValid) { collection.UserEmail = User.Identity.Name; collection.Id = Guid.NewGuid(); AlbumRepository.AddOrUpdate(collection.ToEntity()); } return(List()); }
public async Task <AlbumViewModel> Remover(Guid id) { var album = new AlbumViewModel(); var response = await _httpClient.DeleteAsync($"albuns/{id}"); if (!TratarErrosResponse(response)) { album.ResponseResult = await DeserializarResponse <ResponseResult>(response); } return(album); }
public ActionResult Edit([Bind(Include = "ID,Nome,Ano,Observacoes,Email")] AlbumViewModel viewModel) { if (ModelState.IsValid) { Album album = Mapper.Map <AlbumViewModel, Album>(viewModel); //db.Entry(album).State = EntityState.Modified; //db.SaveChanges(); repositorioAlbuns.Alterar(album); return(RedirectToAction("Index")); } return(View(viewModel)); }
public static Album ToData(this AlbumViewModel item) { if (item == null) { return(null); } return(new Album { AlbumId = item.AlbumId, AlbumName = item.AlbumName }); }
public IActionResult Update(AlbumViewModel albumViewModel) { if (!ModelState.IsValid) { albumViewModel.Bands = _bandRepository.GetAll(); return(View(albumViewModel)); } _albumRepository.Update(albumViewModel.Album); return(RedirectToAction("List")); }
void dpt_Tick(object sender, System.EventArgs e) { ticks++; if (incremented | Player.Instance.NetStreamingConfigsLoaded) { return; } if (Player.Instance.Wave != null && ticks > Player.Instance.Wave.Duration / 2 | ticks > 4000) { incremented = true; EventHandler handler = IncrementListens; if (handler != null) { handler(this, EventArgs.Empty); } //track update Track existingTrack = TrackQuery.GetTrack(CoreMain.CurrentTrack.Path); if (existingTrack != null) { existingTrack.Listens++; TrackQuery.SaveTrack(existingTrack); } //artistUpdate ArtistViewModel existingArtist = ArtistQuery.GetArtistViewModel(CoreMain.CurrentTrack.Artist); if (existingArtist != null) { existingArtist.Listens++; existingArtist.SaveArtist(); } //albumUpdate AlbumViewModel existingAlbum = AlbumQuery.GetAlbumViewModel(CoreMain.CurrentTrack.Album); if (existingAlbum != null) { existingAlbum.Listens++; existingAlbum.SaveAlbum(); } //a;bumUpdate ViewModels.GenreViewModel existingGenre = GenreQuery.GetGenreViewModel(CoreMain.CurrentTrack.Genre); if (existingGenre != null) { existingGenre.Listens++; existingGenre.SaveGenre(); } //scrobble LastFm.ScrobbleTrack(LastFm.CurrentTrack); } }
public ActionResult Create(AlbumViewModel viewModel) { if (ModelState.IsValid) { var album = viewModel.ConvertToAlbum(db); db.Album.Add(album); db.SaveChanges(); return(RedirectToAction("Grid")); } return(View(viewModel)); }
public void BeginMoveAlbum(AlbumViewModel album, PerformerViewModel performer) { if (album is null) { return; } AlbumToMove = album; InitialPerformer = performer; MessageBox.Show("Now select the performer and click the 'Move album here' button"); }
/// <summary> /// Used when going back to the dialog after selecting a file for album art /// </summary> /// <param name="albumToEdit"></param> /// <param name="storageFile"></param> public EditAlbum(AlbumViewModel albumToEdit, StorageFile storageFile) : this(albumToEdit) { albumArtStorageFile = storageFile; this.Loaded += HandleEditAlbumLoaded; DebugHelper.Assert(new CallerInfo(), NavigationManager.Current.ContinuationInfo != null); updateArt.IsChecked = true; editAlbumArtistName.Text = (NavigationManager.Current.ContinuationInfo as EditAlbumContinuationInfo).ArtistName; editAlbumName.Text = (NavigationManager.Current.ContinuationInfo as EditAlbumContinuationInfo).AlbumName; }
public ActionResult Create([Bind(Include = "AlbumID,Ano,Nome,Descricao,Email")] AlbumViewModel albViewModel) { if (ModelState.IsValid) { //Mapa para realizar a converção do ViewModel-Álbum Exibição para Domínio-Álbum Album album = Mapper.Map <AlbumViewModel, Album>(albViewModel); repositorioAlbuns.InserirDados(album); return(RedirectToAction("Index")); } return(View(albViewModel)); }
public ActionResult Create([Bind(Include = "Id,Nome,Ano,Observacoes,Email")] AlbumViewModel viewModel) { if (ModelState.IsValid) { Album album = Mapper.Map <AlbumViewModel, Album>(viewModel); db.Albuns.Add(album); db.SaveChanges(); return(RedirectToAction("Index")); } return(View(viewModel)); }
public static List <AlbumViewModel> ConvertList(IEnumerable <Album> albums) { return(albums.Select(a => { var model = new AlbumViewModel(); model.AlbumId = a.AlbumId; model.ArtistId = a.ArtistId; model.Title = a.Title; return model; }) .ToList()); }
public static AlbumViewModel DbToModelAlb(Album db) { var AlbMod = new AlbumViewModel(); AlbMod.AlbumId = db.AlbumId; AlbMod.AlbumName = db.AlbumName; AlbMod.AlbumDate = db.AlbumDate; AlbMod.Description = db.Description; AlbMod.UserId = db.UserId; AlbMod.UserAView = DbToModelUser(db.User); return(AlbMod); }
public static void PersistAlbum(AlbumViewModel album) { using (var ctx = new ChinookContext()) { Album pAlbum = album.AlbumId.HasValue ? ctx.Album.First(t => t.AlbumId == album.AlbumId) : new Album(); pAlbum.Title = album.Name; ctx.SaveChanges(); } }
public async Task <IActionResult> Create([Bind("Name")] AlbumViewModel album) { if (ModelState.IsValid) { album.Id = Guid.NewGuid(); // _context.Add(album); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(album)); }
public IHttpActionResult Post(AlbumViewModel albumViewModel) { var requestorid = GetRequestorId(); var albumDto = AlbumViewModelAdapter.BuildAlbumDto(albumViewModel); _albumService.Create(albumDto, requestorid); var response = Request.CreateResponse(HttpStatusCode.Created, albumViewModel); return(ResponseMessage(response)); }
public void Album_Edit() { ISixteenBarsDb mockDb = new MockSixteenBarsDb(); AlbumController ctrl = new AlbumController(mockDb); AlbumViewModel editedAlbum = new AlbumViewModel() { Id = 1, Title = "Because of the interwebs", ReleaseDate = new DateTime(2015, 5, 4), ArtistId = 10 }; ctrl.Edit(editedAlbum); Assert.AreEqual(editedAlbum.Title, mockDb.Albums.Find(1).Title, "Title not changed to 'Because of the interwebs'."); Assert.AreEqual(editedAlbum.ReleaseDate, mockDb.Albums.Find(1).ReleaseDate, "Release date not changed to '5/4/15'."); Assert.AreEqual(editedAlbum.ArtistId, mockDb.Albums.Find(1).Artist.Id, "Artist not changed to 'Dr. Dre'."); editedAlbum = new AlbumViewModel() { Id = 1, Title = ".~`!@#$%^&*()_+-={}|:\"<>?[]\\;',./", ReleaseDate = new DateTime(1993, 11, 23), ArtistName = ".~`!@#$%^&*()_+-={}|:\"<>?[]\\;',./" }; ctrl.Edit(editedAlbum); Assert.AreEqual(editedAlbum.Title, mockDb.Albums.Find(1).Title, "Title not changed to .~`!@#$%^&*()_+-={}|:\"<>?[]\\;',./"); Assert.AreEqual(editedAlbum.ReleaseDate, mockDb.Albums.Find(1).ReleaseDate, "Release date not changed to 11/23/93."); Assert.AreEqual(editedAlbum.ArtistName, mockDb.Albums.Find(1).Artist.Name, "Artist not chnaged to .~`!@#$%^&*()_+-={}|:\"<>?[]\\;',./"); editedAlbum = new AlbumViewModel() { Id = 1, Title = "The Blueprint2", ReleaseDate = new DateTime(2002, 9, 11), ArtistId = 9 }; ctrl.Edit(editedAlbum); Assert.AreEqual(editedAlbum.Title, mockDb.Albums.Find(1).Title, "Title not changed to The Blueprint2."); Assert.AreEqual(editedAlbum.ReleaseDate, mockDb.Albums.Find(1).ReleaseDate, "Release date not changed to 9/11/02."); Assert.AreEqual("50 Cent", mockDb.Albums.Find(1).Artist.Name, "Artist not changed to 50 Cent"); //editedAlbum = new AlbumViewModel() //{ // Id = 1, // Title = "Because the Internet", // ReleaseDate = new DateTime(2013, 12, 3), // ArtistName = "Childish Gambino" //}; //ctrl.Edit(editedAlbum); //Assert.AreEqual(1,mockDb.Artists.f, "Because the Internet was created twice"); }
public async Task <object> Get(string id) { try { var playlistDB = await _context.Playlists .Where(x => x.IdString == id) .Include(x => x.Songs) .ThenInclude(x => x.Song) .ThenInclude(x => x.SongFile) .Include(x => x.Songs) .ThenInclude(x => x.Song) .ThenInclude(x => x.Album) .ThenInclude(x => x.Artist) .Include(x => x.User) .FirstOrDefaultAsync(); var result = new PlaylistViewModel(); result.Name = playlistDB.Name; result.IdString = playlistDB.IdString; result.User = playlistDB.User.UserName; var album = new AlbumViewModel(); album.IdString = playlistDB.IdString; album.Name = playlistDB.Name; album.Songs = playlistDB.Songs.Select(x => new SongViewModel() { Path = x.Song.SongFile.Path, Name = x.Song.Name, Length = x.Song.Length.ToString(), IdString = x.Song.IdString, Album = new AlbumViewModel() { ArtistName = x.Song.Album.Artist.Name, ArtistIdString = x.Song.Album.Artist.IdString, IdString = x.Song.Album.IdString, Name = x.Song.Album.Name } }).ToList(); result.Playlist = album; return(new { Succeeded = true, Playlist = result }); } catch (Exception e) { return(new { Succeeded = false, }); } }
public static Album ToEntity(this AlbumViewModel model) { var entity = new Album() { Id = model.Id, Name = model.Name, UserEmail = model.UserEmail, Comments = model.Comments.ToEntity(), Photos = model.Photos.ToEntity(), }; return(entity); }
public static AlbumViewModel ToModel(this Album entity) { var model = new AlbumViewModel() { Id = entity.Id, Name = entity.Name, UserEmail = entity.UserEmail, Comments = entity.Comments.ToModel(), Photos = entity.Photos.ToModel(), }; return(model); }
private AlbumViewModel MapToModel(Album album) { AlbumViewModel albumViewModel = new AlbumViewModel(); albumViewModel.AlbumId = album.AlbumId; albumViewModel.AlbumName = album.AlbumName; albumViewModel.Price = album.Price; albumViewModel.ShelfTime = album.ShelfTime; albumViewModel.GenreName = album.Genre.GenreName; albumViewModel.SingerName = album.Singer.SingerName; albumViewModel.Website = album.Website; return(albumViewModel); }
private AlbumViewModel CreateAlbumViewModel(Album album) { AlbumViewModel albumViewModel = new AlbumViewModel() { Name = album.Name, Type = album.Type, ReleaseDate = album.ReleaseDate, NumberOfTracks = album.NumberOfTracks, Artists = string.Join(", ", album.Artists.ToArray()) }; return(albumViewModel); }
public ActionResult Create(AlbumViewModel album) { if (ModelState.IsValid) { if (albumService.CreateNewAlbum(User.Identity.Name, album.Name)) { return(RedirectToAction("EditAlbums")); } ModelState.AddModelError("", "The album with the same name already exists."); } return(View(album)); }
internal void AlertAlbumNameChanged(AlbumViewModel albumViewModel, string oldName) { AlbumCollection.Remove(albumViewModel, oldName); AlbumCollection.Add(albumViewModel, albumViewModel.SortName); }
private void OnAlbumSelected(AlbumViewModel album) { SelectedAlbum = album; }
public AlbumPage() { this.InitializeComponent(); DataContext = new AlbumViewModel(); }
private void AddAlbum(ISearchResultViewModel artist, AlbumViewModel album) { Action action = () => artist.AddAlbum(album); Dispatcher.Invoke(action, DispatcherPriority.DataBind); }
private AlbumViewModel LookupAlbum(AlbumModel album) { if (AlbumLookupMap.ContainsKey(album.AlbumId)) { return AlbumLookupMap[album.AlbumId]; } else { ArtistViewModel artist = LookupArtistById(album.ArtistId); AlbumViewModel newAlbumViewModel = new AlbumViewModel(album, artist); AlbumLookupMap.Add(newAlbumViewModel.AlbumId, newAlbumViewModel); AlbumCollection.Add(newAlbumViewModel, newAlbumViewModel.SortName); return newAlbumViewModel; } }
public EditAlbum(AlbumViewModel albumToEdit) { this.InitializeComponent(); this.DataContext = albumToEdit; }
internal void RemoveAlbumIfNeeded(AlbumViewModel albumViewModel) { if (albumViewModel.Songs.Count == 0) { if (albumViewModel.Artist.Albums.Contains(albumViewModel)) { albumViewModel.Artist.Albums.Remove(albumViewModel); RemoveArtistIfNeeded(albumViewModel.Artist); AlbumCollection.Remove(albumViewModel, albumViewModel.SortName); AlbumLookupMap.Remove(albumViewModel.AlbumId); albumViewModel.IsBeingDeleted = true; LibraryModel.Current.DeleteAlbum(albumViewModel.AlbumId); } } }
public void HandleSearchResult(IMetadata result) { try { if (result == null) return; if (result is IArtist) { var artistKey = result.Location.ToString(); if (!artistResults.ContainsKey(artistKey)) { var artistViewModel = new ArtistViewModel(mediaItemController, result as IArtist); //result.Location, result.Name, result.Summary, result.FromDate, result.ToDate, result.Thumbnail, result.ThumbnailData); var resultViewModel = new SearchResultViewModel(artistViewModel); artistResults.Add(artistKey, resultViewModel); AddResult(resultViewModel); } } else if (result is IAlbum) { var albumViewModel = new AlbumViewModel(mediaItemController, result as IAlbum); //result.Location, result.Name, result.Summary, result.Creator, result.CreatorName, result.FromDate, result.Thumbnail, result.ThumbnailData); var artistKey = result.Creator.ToString(); var albumKey = result.Location.ToString(); if (!artistResults.ContainsKey(artistKey)) { if (!albumResults.ContainsKey(albumKey)) { var resultViewModel = new SearchResultViewModel(albumViewModel); AddResult(resultViewModel); albumResults.Add(albumKey, resultViewModel); } } else { if (!albumResults.ContainsKey(albumKey)) { var existing = artistResults[artistKey].Albums.Where(x => x.Id.ToString() == albumViewModel.Id.ToString()).FirstOrDefault(); if (existing == null) { AddAlbum(artistResults[artistKey], albumViewModel); } } } } else if (result is ITrack) { var trackViewModel = new TrackViewModel(mediaItemController, result as ITrack); //result.Location, result.Name, result.Summary, result.Number, result.Duration, result.FromDate, result.Creator, result.CreatorName, result.Catalog, result.CatalogName, result.Target, result.TargetType, result.Thumbnail, result.ThumbnailData); var albumKey = result.Catalog.ToString(); var trackKey = result.Location.ToString(); if (!albumResults.ContainsKey(albumKey)) { if (!trackResults.ContainsKey(trackKey)) { var resultViewModel = new SearchResultViewModel(trackViewModel); trackResults.Add(trackKey, resultViewModel); AddResult(resultViewModel); } } else { if (!trackResults.ContainsKey(trackKey)) { //var existing = albumResults[albumKey].Tracks.Where(x => x.Album.ToString() == trackViewModel.Album.ToString()).FirstOrDefault(); //if (existing == null) //{ AddTrack(albumResults[albumKey], trackViewModel); //} } } } else if (result is IClip) { var clipViewModel = new ClipViewModel(mediaItemController, result as IClip); //result.Location, result.Name, result.Summary, result.Number, result.Duration, result.Height, result.Width, result.FromDate, result.Creator, result.CreatorName, result.Catalog, result.CatalogName, result.Target, result.TargetType, result.Thumbnail, result.ThumbnailData); var albumKey = result.Catalog.ToString(); var clipKey = result.Location.ToString(); if (!albumResults.ContainsKey(albumKey)) { if (!clipResults.ContainsKey(clipKey)) { var resultViewModel = new SearchResultViewModel(clipViewModel); clipResults.Add(clipKey, resultViewModel); AddResult(resultViewModel); } } else { if (!clipResults.ContainsKey(clipKey)) { //var existing = albumResults[albumKey].Tracks.Where(x => x.Album.ToString() == trackViewModel.Album.ToString()).FirstOrDefault(); //if (existing == null) //{ AddClip(albumResults[albumKey], clipViewModel); //} } } } } catch (Exception ex) { logger.Error(" HandleSearchResults", ex); } }
public AlbumDetails(AlbumViewModel model) { InitializeComponent(); DataContext = model; }
public RequestAlbumsViewMessage(AlbumViewModel requester) { Requester = requester; }
public void BuildArtistItems(IEnumerable<SynoItem> albums) { this.ArtistAlbums.Clear(); // add the page for the list of albums. //var albumsListPanelViewModel = new ArtistPanoramaAlbumsListItemViewModel(albums, _artist, this._pageSwitchingService, this._panoramaItemSwitchingService); //this.ArtistAlbums.Add(albumsListPanelViewModel); // the "all albums" items var allmusic = albums.Where(o => o.ItemID.StartsWith("musiclib_music_artist")); foreach (var album in albums.Except(allmusic)) { // Fixme : use a factory var albumDetail = new AlbumViewModel(album); this.ArtistAlbums.Add(albumDetail); } foreach (var album in allmusic) { // Fixme : use a factory var albumDetail = new AlbumViewModel(album); this.ArtistAlbums.Add(albumDetail); } }