private void Button_Click(Object sender, RoutedEventArgs e)
{
AlbumViewModel viewModel = (AlbumViewModel)base.DataContext;
if (sender == this.ButtonTestAddSong)
{
ICommand cmdAddSong =
viewModel.CommandAddSongFromDatabase;
if (cmdAddSong.CanExecute(null))
{
cmdAddSong.Execute(null);
}
}
else if (sender == this.ButtonTestUpdateArtist)
{
int numberOfSongs = viewModel.Songs.Count;
if (numberOfSongs == 0)
{
return;
}
int randomIndex = (new Random()).Next() % numberOfSongs;
SongViewModel songViewModel = viewModel.Songs[randomIndex];
ICommand cmdUpdateSongTitle =
songViewModel.CommandUpdateSongTitle;
if (cmdUpdateSongTitle.CanExecute(null))
{
cmdUpdateSongTitle.Execute(null);
}
}
}
private static void PostSong(Uri uri, string title, int year, int genre)
{
using (var client = new HttpClient())
{
client.BaseAddress = uri;
Console.WriteLine("Creating song");
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var song = new SongViewModel
{
Title = title,
Year = year,
Genre = (GenreType)genre
};
var httpContent = new StringContent(JsonConvert.SerializeObject(song), Encoding.UTF8, "application/json");
HttpResponseMessage response = client.PostAsync("api/Songs/Create", httpContent).Result;
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Created");
}
else
{
Console.WriteLine("{0} ({1})", (int)response.StatusCode, response.ReasonPhrase);
}
}
}
async Task <SongViewModel> GetSongViewModelFromSong(Song song = null)
{
SongViewModel model = new SongViewModel();
List <Artist> artistsDB = (await repository.GetListAsync <Artist>()).ToList <Artist>();
List <Genre> genresDB = (await repository.GetListAsync <Genre>()).ToList <Genre>();
List <SelectListItem> genres = new List <SelectListItem>();
List <SelectListItem> artists = new List <SelectListItem>();
foreach (var genre in genresDB)
{
genres.Add(new SelectListItem {
Text = genre.Name, Value = genre.Name,
Selected = (song != null && song.Genre != null ? genre.Id == song.GenreId : false)
});
}
foreach (var artist in artistsDB)
{
artists.Add(new SelectListItem {
Text = artist.Name, Value = artist.Name,
Selected = (song != null && song.Artist != null ? artist.Id == song.ArtistId : false)
});
}
model.Name = song != null ? song.Name : "";
model.Artist = song != null && song.Artist != null ? song.Artist.Name : "No artist";
model.Genre = song != null && song.Genre != null ? song.Genre.Name : "No genre";
model.Artists = artists;
model.Genres = genres;
return(model);
}
public async Task <IActionResult> PutSong(int id, SongViewModel song)
{
var user = await userManager.FindByNameAsync(User.Identity.Name);
if (user == null)
{
return(Unauthorized("It stops here"));
}
var songToEdit = await _context.Songs.Where(x => x.Id == id).Include(p => p.Album).FirstOrDefaultAsync();
if (songToEdit != null)
{
var artist = await _context.Artists.Where(x => x.Id == songToEdit.Album.ArtistId).FirstOrDefaultAsync();
if (artist.UserId == user.Id)
{
songToEdit.Name = song.Name;
_context.SaveChanges();
}
else
{
return(Unauthorized());
}
}
else
{
return(NotFound());
}
return(Ok());
}
public ActionResult GetSongs(string id)
{
var songIds = albumService.GetAlbumById(id).Songs;
var songs = new List <SongViewModel>();
foreach (var s in songIds)
{
var dbSong = songRepo.GetById(s);
var album = albumService.GetAlbumById(dbSong.Album);
var artist = artistService.GetArtistById(album.ArtistName);
var song = new SongViewModel()
{
Name = dbSong.Name,
Album = new AlbumLink()
{
Name = album.AlbumName, Link = "javascript: void(0)"
},
Artist = new ArtistLink()
{
Name = artist.ArtistName, Link = "javascript: void(0)"
},
Likes = dbSong.Likes.ToString(),
SongId = dbSong.SongId.ToString(),
songRef = dbSong.songRef
};
songs.Add(song);
}
return(Json(songs, JsonRequestBehavior.AllowGet));
}
public void CallSongModifyServiceMethodUpdateSongOnce_WhenInvoked()
{
// Arrange
var songService = new Mock <ISongService>();
var userService = new Mock <IUserService>();
var artistService = new Mock <IArtistService>();
var albumService = new Mock <IAlbumService>();
var genreService = new Mock <IGenreService>();
var songModifyService = new Mock <ISongModifyService>();
songModifyService.Setup(x => x.UpdateSong(
It.IsAny <Guid>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <int?>(),
It.IsAny <ICollection <string> >(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()));
var sut = new SongController(
songService.Object,
userService.Object,
artistService.Object,
albumService.Object,
genreService.Object,
songModifyService.Object);
var model = new SongViewModel()
{
Id = Guid.NewGuid(),
Title = "Title",
Artist = "Artist",
Album = "Album",
Duration = 5,
Genres = new List <string>()
{
"Genre"
},
Lyrics = "Lyrics",
VideoUrl = "VideoUrl",
CoverUrl = "CoverUrl"
};
// Act
sut.EditSong(model);
// Assert
songModifyService.Verify(x => x.UpdateSong(
It.IsAny <Guid>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <int?>(),
It.IsAny <ICollection <string> >(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()), Times.Once);
}
public IActionResult Create(SongViewModel model)
{
if (!this.ModelState.IsValid)
{
return(this.View(model));
}
var userId = this.usersService.GetIdFromUsername(this.User.Identity.Name);
if (userId == null)
{
this.TempData["Error"] = string.Format(GenericMessages.CouldntDoSomething, "find artist");
return(this.View(model));
}
var creationInfo = this.mapper.Map <CreateSongDto>(model);
creationInfo.ArtistId = userId;
var creationResult = this.songsService.Create(creationInfo);
if (creationResult)
{
this.TempData["Success"] = string.Format(GenericMessages.SuccessfullyDidSomething, "submitted song for approval");
return(this.RedirectToAction("MyRequests", "Approval"));
}
this.TempData["Error"] = string.Format(GenericMessages.CouldntDoSomething, "submit song for approval");
return(this.View(model));
}
public IActionResult Delete(SongViewModel model)
{
var userId = this.usersService.GetIdFromUsername(this.User.Identity.Name);
if (userId == null)
{
this.TempData["Error"] = string.Format(GenericMessages.CouldntDoSomething, "find artist");
return(this.View(model));
}
var userIsCreator = this.songsService.IsUserCreatorById(userId, model.Id.Value);
if (!userIsCreator)
{
this.TempData["Error"] = string.Format(GenericMessages.CouldntDoSomething, "load item");
return(this.Redirect(Url.Action("Index", "Home", new { area = "" })));
}
var deletionResult = this.songsService.Delete(model.Id.Value);
if (deletionResult)
{
this.TempData["Success"] = string.Format(GenericMessages.SuccessfullyDidSomething, "deleted song");
return(this.RedirectToAction("My", "Songs"));
}
this.TempData["Error"] = string.Format(GenericMessages.CouldntDoSomething, "delete song");
return(this.RedirectToAction("My", "Songs"));
}
public async Task <IActionResult> Upload(SongViewModel model)
{
if (ModelState.IsValid && model.File != null)
{
if (model.File.ContentType != "audio/x-wav")
{
ModelState.AddModelError("", "Uploaded file is not an audio file.");
}
else
{
try
{
string path = _appEnvironment.WebRootPath + "/files/" + model.File.FileName;
using (var fileStream = new FileStream(path, FileMode.Create))
await model.File.CopyToAsync(fileStream);
var song = new Song()
{
Tittle = model.Tittle, FilePath = path
};
await _audioService.SongProcess(song);
return(RedirectToAction("History"));
}
catch (Exception e)
{
ModelState.AddModelError("", e.Message);
}
}
}
return(View(model));
}
internal async void HandleFilePickerLaunch(IStorageFile pickedFile)
{
if (!IsNoSyncInProgress)
{
return;
}
CurrentAction = ActionType.ImportStats;
StatImportSongsFound = 0;
StatImportSongsSkipped = 0;
using (Stream stream = await pickedFile.OpenStreamForReadAsync())
{
using (StreamReader reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
string[] parts = line.Split(new char[] { '|' });
if (parts.Count() == 6)
{
string TrackName = parts[0];
string AlbumName = parts[1];
string ArtistName = parts[2];
string Rating = parts[3];
string PlayCount = parts[4];
string LastPlayed = parts[5];
SongViewModel song = LibraryViewModel.Current.LookupSongByName(TrackName, ArtistName);
if (song != null)
{
song.Rating = uint.Parse(Rating);
// TODO: let user toggle this
song.PlayCount = uint.Parse(PlayCount);
DateTime realLastPlayed = new DateTime(long.Parse(LastPlayed));
if (song.LastPlayed < realLastPlayed)
{
song.LastPlayed = realLastPlayed;
}
StatImportSongsFound++;
}
else
{
StatImportSongsSkipped++;
}
}
}
}
}
CurrentAction = ActionType.None;
}
private void SongRatingUp(SongViewModel currentSong)
{
var song = dbWorker.Songs.GetById(currentSong.Id);
dbWorker.Songs.RatingUpdate(song);
dbWorker.Save();
}
public bool Eval(SongViewModel song)
{
T targetValue = DebugHelper.CastAndAssert <T>(TargetProperty.GetValue(song));
switch (EvalType)
{
case NumericEvalType.StrictLess:
return(targetValue.CompareTo(Target) < 0);
case NumericEvalType.Less:
return(targetValue.CompareTo(Target) <= 0);
case NumericEvalType.Equal:
return(targetValue.CompareTo(Target) == 0);
case NumericEvalType.More:
return(targetValue.CompareTo(Target) >= 0);
case NumericEvalType.StrictMore:
return(targetValue.CompareTo(Target) > 0);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected NumericEvalType: {0}", EvalType);
return(false);
}
}
public CurMusic()
{
InitializeComponent();
SongViewModel songViewModel = new SongViewModel(mediaElement);
BindingContext = songViewModel;
}
// GET: Song/Edit/5
public async Task <IActionResult> Edit(long?id)
{
if (id == null)
{
return(NotFound());
}
var songModel = await _context.Songs.SingleOrDefaultAsync(m => m.Id == id);
if (songModel == null)
{
return(NotFound());
}
_context.Entry(songModel).Reference(x => x.Album).Load();
var p = new SongViewModel();
p.Id = songModel.Id;
p.Name = songModel.Name;
p.SongText = songModel.SongText;
p.Album = songModel.Album;
p.AlbumsList = _context.Albums.ToList();
return(View(p));
}
// GET: Song/Create
public IActionResult Create()
{
var p = new SongViewModel();
p.AlbumsList = _context.Albums.ToList();
return(View(p));
}
public async Task <ActionResult> Edit(int id, SongViewModel song)
{
song.Id = id;
try
{
using (var client = new HttpClient())
{
var token = await GetToken();//the method that generate the token
client.DefaultRequestHeaders.Add(HEADER_AUTHORIZATION, token);
var serializedContent = JsonConvert.SerializeObject(song);
var stringContent = new StringContent(serializedContent, Encoding.UTF8, JSON_MEDIA_TYPE);
HttpResponseMessage response = await client.PutAsync($"{ songsUri}/{ id}", stringContent);
if (!response.IsSuccessStatusCode)
{
return(RedirectToAction(nameof(HomeController.Error), "Home"));
}
return(RedirectToAction(nameof(Index)));
}
}
catch
{
return(RedirectToAction(nameof(HomeController.Error), "Home"));
}
}
public async Task <ActionResult> AddSong(SongViewModel model)
{
if (model.File != null && !String.IsNullOrEmpty(model.Name))
{
if (Path.GetExtension(model.File.FileName).ToLower() != ".mp3")
{
return(RedirectToAction("Index", new { status = "bad" }));
}
if (await repository.GetAsync <Song>(x => x.FilePath == "/Music/" + model.File.FileName) == null)
{
if (await repository.GetAsync <Song>(x => x.Name == model.Name && x.Artist.Name == model.Artist) != null)
{
return(RedirectToAction("Index", new { status = "repeat" }));
}
model.File.SaveAs(Server.MapPath("~/Music/" + model.File.FileName));
Song sng = await GetSongFromSongViewModel(model);
await repository.CreateAsync <Song>(sng);
}
else
{
return(RedirectToAction("Index", new { status = "repeat" }));
}
}
else
{
return(RedirectToAction("Index", new { status = "required" }));
}
return(RedirectToAction("Index", new { status = "success" }));
}
private void CreatePagesWithoutChords(SongViewModel song)
{
if (String.IsNullOrWhiteSpace(Song.Text))
{
Pages.Add(new PresentationPageModel()
{
Title = song.Title,
Text = AppResources.SongTextPresentation_EmptyText,
SongKey = song.SongKey,
FontSize = FontSize
});
return;
}
Label testLabel = SongTextPresentationView.GetGhostLabelInstance();
string[] allText = song.Text.Split(Environment.NewLine.ToCharArray());
int linesLeft = allText.Length;
List <string> leftText = allText.ToList();
while (linesLeft > 0)
{
int linesFitted = PresentationPageHelper.GetFitPageModel(leftText.ToArray(), testLabel, song.Title, FontSize, song.SongKey);
if (linesFitted != -1)
{
Pages.Add(PresentationPageHelper.PresentationPageModel);
linesLeft -= linesFitted + 1;
leftText.RemoveRange(0, linesFitted + 1);
}
}
}
public bool Eval(SongViewModel song)
{
switch (EvalType)
{
case MemberEvalType.Playlist:
PlaylistViewModel playlist = LibraryViewModel.Current.LookupPlaylistById(Target);
if (playlist == null)
{
return(false);
}
return(playlist.ContainsSong(song));
case MemberEvalType.Mix:
MixViewModel mix = LibraryViewModel.Current.LookupMixById(Target);
if (mix == null)
{
return(false);
}
return(mix.ContainsSong(song));
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MemberEvalType: {0}", EvalType);
return(false);
}
}
public async Task <IActionResult> Create(SongViewModel model)
{
ViewBag.Albums = dataManager.AlbumRepository.GetAll();
ViewBag.Tags = dataManager.TagRepository.GetAll();
if (ModelState.IsValid)
{
List <Tag> tags = new List <Tag>();
foreach (var id in model.TagIds)
{
tags.Add(dataManager.TagRepository.Get(id));
}
string fileName = null;
if (model.File != null)
{
fileName = await fileService.UploadFile(model.File, Path.Combine(environment.WebRootPath, "audio"));
}
if (fileName == null)
{
ModelState.AddModelError(nameof(model.File), "Choose a file");
return(View(model));
}
Song song = new Song
{
Name = model.Name, Album = dataManager.AlbumRepository.Get(model.AlbumId), Tags = tags, FilePath = fileName
};
dataManager.SongRepository.Save(song);
return(Redirect("/admin/songs"));
}
return(View(model));
}
private async Task StartPresentation(int id)
{
SongViewModel song = Songs.Where(s => s.Id == id).FirstOrDefault();
await _pageService.ChangePageAsync(new SongTextPresentationView());
MessagingCenter.Send(this, Events.SendSongToPresentation, song);
}
public ActionResult EditSong(SongViewModel song, int[] chordsId)
{
var songDto = Mapper.Map <SongViewModel, SongDTO>(song);
songService.Update(songDto, chordsId);
return(RedirectToAction("Song", new { id = song.Id }));
}
private void Recover()
{
App.Log("Recover MediaPlayer");
graph.Stop();
try
{
mainInputNode.Dispose();
}
catch (Exception) { }
try
{
subInputNode.Dispose();
}
catch (Exception) { }
try
{
outputNode.Dispose();
}
catch (Exception) { }
mainInputNode = null;
subInputNode = null;
outputNode = null;
mainSong = null;
subSong = null;
try
{
graph.Dispose();
}
catch (Exception) { }
graph = null;
Init();
}
public MainWindow()
{
InitializeComponent();
// We have declared the view model instance declaratively in the xaml.
// Get the reference to it here, so we can use it in the button click event.
_viewModel = (SongViewModel)base.DataContext;
}
public ActionResult Edit(int id)
{
var song = _context.Songs.SingleOrDefault(s => s.SongId == id);
if (song == null)
{
return(HttpNotFound());
}
var genres = _context.Genres.ToList();
var artists = _context.Artists.Select(a => new
{
ArtistId = a.ArtistId,
Name = a.Name
}).ToList();
var defaultSelected = _context.Artists.Where(x => x.Songs.Any(y => y.SongId == id));
int[] artistsId = new int[defaultSelected.Count()];
int i = 0;
foreach (var a in defaultSelected)
{
artistsId[i] = a.ArtistId;
i++;
}
var viewModel = new SongViewModel
{
Song = song,
Artists = new MultiSelectList(artists, "ArtistID", "Name"),
Genres = genres,
ArtistId = artistsId
};
return(View("SongForm", viewModel));
}
public async Task <IActionResult> Edit(SongViewModel model)
{
ViewBag.Albums = dataManager.AlbumRepository.GetAll();
ViewBag.Tags = dataManager.TagRepository.GetAll();
if (ModelState.IsValid)
{
Song song = dataManager.SongRepository.Get(model.Id);
if (song != null)
{
song.Tags.Clear();
List <Tag> tags = new List <Tag>();
foreach (var id in model.TagIds)
{
tags.Add(dataManager.TagRepository.Get(id));
}
if (model.File != null)
{
if (song.FilePath != null)
{
fileService.DeleteFile(song.FilePath, Path.Combine(environment.WebRootPath, "audio"));
}
song.FilePath = await fileService.UploadFile(model.File, Path.Combine(environment.WebRootPath, "audio"));
}
song.Name = model.Name;
song.Album = dataManager.AlbumRepository.Get(model.AlbumId);
song.Tags = tags;
dataManager.SongRepository.Save(song);
return(Redirect("/admin/songs"));
}
}
return(View(model));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
this.AddNotification("Song does not exist", NotificationType.ERROR);
return(RedirectToAction("MySongs"));
}
Song song = db.Songs.Find(id);
if (song == null)
{
this.AddNotification("Song does not exist", NotificationType.ERROR);
return(RedirectToAction("MySongs"));
}
if (!IsAuthorizedToOperate(song))
{
this.AddNotification("You don't have permission to edit this song.", NotificationType.ERROR);
return(RedirectToAction("MySongs"));
}
var viewModel = new SongViewModel();
viewModel.Artist = song.Artist;
viewModel.Title = song.Title;
viewModel.Description = song.Description;
viewModel.GenreId = song.GenreId;
viewModel.Genre = db.Genres.OrderBy(g => g.Name).ToList();
viewModel.Tags = string.Join(", ", song.Tags.Select(t => t.Name));
return(View(viewModel));
}
public IHttpActionResult Update(int id, SongViewModel song)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingSong = this.data.Songs.All().FirstOrDefault(s => s.Id == id);
if (existingSong == null)
{
return(BadRequest("Such song does not exists!"));
}
var albumId = this.data.Albums.All().FirstOrDefault(a => a.Title == song.Album).Id;
if (albumId == null)
{
return(BadRequest("Such album doesn't exist"));
}
existingSong.Title = song.Title;
existingSong.Year = song.Year;
existingSong.AlbumId = albumId;
existingSong.Genre = song.Genre;
this.data.SaveChanges();
song.Id = id;
return(Ok(song));
}
public IHttpActionResult Create(SongViewModel song)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var albumId = this.data.Albums.All().FirstOrDefault(a => a.Title == song.Album).Id;
if (albumId == null)
{
return(BadRequest("Such album doesn't exist"));
}
var newSong = new Song
{
Title = song.Title,
Year = song.Year,
AlbumId = albumId,
Genre = song.Genre
};
this.data.Songs.Add(newSong);
this.data.SaveChanges();
song.Id = newSong.Id;
return(Ok(song));
}
// GET: Song/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Song song = ss.GetSongById(id);
//song.Genre = new Genre();
if (song == null)
{
return(HttpNotFound());
}
ViewBag.GenreId = new SelectList(db.Genres, "Id", "Title", song.GenreId);
var songVM = new SongViewModel
{
Id = song.Id,
Title = song.Title,
Duration = song.Duration,
Appearances = song.Appearances,
IsCover = song.IsCover,
Genre = song.Genre,
GenreId = song.GenreId
};
//List<Genre> genres = db.Genres.ToList();
//ViewBag.Genres = genres;
return(View(songVM));
}
public void SaveSongFromVkUpdatePicture(SongViewModel song, string userid)
{
var songInfo = SongPictureGetter.GetPictureByWebService(null, song.Title, song.Artist, "");
if (songInfo != null)
{
song.SongAlbumCoverPath = songInfo.PicturePath;
}
TimeSpan temp;
TimeSpan.TryParse(song.DurationFormatted, out temp);
song.Duration = temp;
_playlistRepository.AddToVkPlayList(userid, ModelConverters.ToSongModel(song));
}
public bool Eval(SongViewModel song)
{
DateTime targetValue = DebugHelper.CastAndAssert<DateTime>(TargetProperty.GetValue(song));
switch (EvalType)
{
case RangeEvalType.Days:
DateTime target = DateTime.Now - TimeSpan.FromDays(Target);
return (target < targetValue);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MemberEvalType: {0}", EvalType);
return false;
}
}
public bool Eval(SongViewModel song)
{
string targetValue = DebugHelper.CastAndAssert<string>(TargetProperty.GetValue(song));
switch (EvalType)
{
case StringEvalType.Equal:
return targetValue == Target;
case StringEvalType.SubString:
return targetValue.Contains(Target);
case StringEvalType.StartsWith:
return targetValue.StartsWith(Target);
case StringEvalType.EndsWith:
return targetValue.EndsWith(Target);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected StringEvalType: {0}", EvalType);
return false;
}
}
public bool Eval(SongViewModel song)
{
switch (EvalType)
{
case MemberEvalType.Playlist:
PlaylistViewModel playlist = LibraryViewModel.Current.LookupPlaylistById(Target);
if (playlist == null)
{
return false;
}
return playlist.ContainsSong(song);
case MemberEvalType.Mix:
MixViewModel mix = LibraryViewModel.Current.LookupMixById(Target);
if (mix == null)
{
return false;
}
return mix.ContainsSong(song);
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected MemberEvalType: {0}", EvalType);
return false;
}
}
public bool Eval(SongViewModel song)
{
switch (EvalType)
{
case NestedEvalType.Any:
foreach (IMixEvaluator nestedMix in Mixes)
{
if (nestedMix.Eval(song))
{
return true;
}
}
return false;
case NestedEvalType.All:
foreach (IMixEvaluator nestedMix in Mixes)
{
if (!nestedMix.Eval(song))
{
return false;
}
}
return true;
case NestedEvalType.None:
foreach (IMixEvaluator nestedMix in Mixes)
{
if (nestedMix.Eval(song))
{
return false;
}
}
return true;
default:
DebugHelper.Alert(new CallerInfo(), "Unexpected NestedEvalType: {0}", EvalType);
return false;
}
}
private SongViewModel LookupSong(SongModel song)
{
if (song == null) return null;
if (SongLookupMap.ContainsKey(song.SongId))
{
return SongLookupMap[song.SongId];
}
else
{
ArtistViewModel artist = LookupArtistById(song.ArtistId);
AlbumViewModel album = LookupAlbumById(song.AlbumId);
SongViewModel newSongViewModel = new SongViewModel(song, artist, album);
SongLookupMap.Add(newSongViewModel.SongId, newSongViewModel);
SongCollection.Add(newSongViewModel, newSongViewModel.SortName);
FlatSongCollection.Add(newSongViewModel);
if (LibraryLoaded)
{
NotifyPropertyChanged(Properties.IsEmpty);
}
return newSongViewModel;
}
}
internal void DeleteSong(SongViewModel song)
{
foreach (PlaylistViewModel playlist in PlaylistCollection)
{
playlist.RemoveAllInstancesOfSong(song);
}
PlayQueue.RemoveAllInstancesOfSong(song);
AlbumViewModel album = song.Album;
ArtistViewModel artist = song.Artist;
LibraryModel.Current.DeleteSong(song.SongId);
RemoveAlbumIfNeeded(album);
RemoveArtistIfNeeded(artist);
}
internal void AlertSongChanged(SongViewModel songViewModel, string propertyName)
{
foreach (MixViewModel mix in MixCollection)
{
mix.OnSongPropertyChanged(songViewModel, propertyName);
}
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate (bundle);
ListAdapter = new SongViewModel (this, ListView);
}
public EditSong(SongViewModel songToEdit)
{
this.InitializeComponent();
this.DataContext = songToEdit;
}
public void AddSong()
{
Songs.Add(_songToAdd);
SongToAdd = new SongViewModel();
}
public void RemoveSong(SongViewModel song)
{
Songs.Remove(song);
}
public bool Eval(SongViewModel song)
{
return false;
}
internal void AlertSongNameChanged(SongViewModel songViewModel, string oldName)
{
SongCollection.Remove(songViewModel, oldName);
SongCollection.Add(songViewModel, songViewModel.SortName);
}
public MainViewModel()
{
_viewModels = new ObservableCollection<ViewModelBase>();
_playlistRepository = new PlaylistRepository();
_songRepository = new SongRepository();
_userRepo = new UserRepository();
_playlistListViewModel = new PlaylistListViewModel(_playlistRepository);
_songListViewModel = new SongListViewModel(_songRepository);
_songViewModel = new SongViewModel();
_menuViewModel = new MenuViewModel();
_viewModels.Add(_playlistListViewModel);
_viewModels.Add(_songListViewModel);
_viewModels.Add(_songViewModel);
_viewModels.Add(_menuViewModel);
#region Registering for ViewModel Commands
// Listens for a click in menuViewModel
Messenger.Default.Register<bool>(this, SetCreatePlaylistViewModel, "CreatePlaylistView");
Messenger.Default.Register<bool>(this, CloseCreatePlaylistView, "CloseCreatePlaylistView");
// Listens for click in menuViewModel
Messenger.Default.Register<bool>(this, SetLoginViewModel, "CreateLoginView");
// Listens for LoginUserViewModel to send this message
Messenger.Default.Register<bool>(this, CloseLoginViewModel, "CloseLoginView");
// Listens for menuViewModel logout button click
Messenger.Default.Register<bool>(this, LogoutUser, "LogoutUser");
// Listens for register button click in MenuViewModel
Messenger.Default.Register<bool>(this, SetRegisterViewModel, "CreateRegisterView");
Messenger.Default.Register<bool>(this, CloseRegisterViewModel, "CloseRegisterView");
// Listens for menuviewModel AddNewSong button click
Messenger.Default.Register<bool>(this, SetAddNewSongViewModel, "CreateAddNewSongView");
Messenger.Default.Register<bool>(this, CloseAddNewSongViewModel, "CloseAddNewSongView");
// Listenes for menuviewModel EditPlaylist button click
Messenger.Default.Register<Playlist>(this, SetEditPlaylistViewModel, "CreateEditPlaylistView");
Messenger.Default.Register<bool>(this, CloseEditPlaylistView, "CloseEditPlaylistView");
// listens for menuviewmodel Edit Song button click
Messenger.Default.Register<Song>(this, SetEditSongViewModel, "CreateEditSongView");
Messenger.Default.Register<bool>(this, CloseEditSongView, "CloseEditSongView");
// Listenes for menuvireModel Credits button
Messenger.Default.Register<bool>(this, SetCreditTransactionViewModel, "CreateCreditTransactionView");
Messenger.Default.Register<bool>(this, CloseCreditTransactionView, "CloseCreditTransactionView");
// Listens for LoginViewModel successful login, or a RegisterViewModel sucessful registration
Messenger.Default.Register<User>(this, LoginUser, "UserLogin");
// Listens for when song is selected, changed, etc
Messenger.Default.Register<bool>(this, UserPlayedSong, "UserCreditCheck");
// Listens from MenuViewModel for delete commands
Messenger.Default.Register<Playlist>(this, DeletePlaylist, "DeletePlaylist");
Messenger.Default.Register<Song>(this, DeleteSong, "DeleteSong");
#endregion
User = new User();
}
