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));
}
/// <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 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);
}
}
