private async Task <IList <TrackViewModel> > GetStaticPlaylistTracksAsync(PlaylistViewModel playlist)
{
var tracks = new List <TrackViewModel>();
var decoder = new PlaylistDecoder();
await Task.Run(async() =>
{
DecodePlaylistResult decodeResult = null;
decodeResult = decoder.DecodePlaylist(playlist.Path);
if (decodeResult.DecodeResult.Result)
{
foreach (string path in decodeResult.Paths)
{
try
{
tracks.Add(await this.fileService.CreateTrackAsync(path));
}
catch (Exception ex)
{
LogClient.Error("Could not get track information from file. Exception: {0}", ex.Message);
}
}
}
});
return(tracks);
}
private async Task <RenamePlaylistResult> RenameStaticPlaylistAsync(PlaylistViewModel playlistToRename, string newPlaylistName)
{
string oldFilename = playlistToRename.Path;
if (!System.IO.File.Exists(oldFilename))
{
LogClient.Error("Error while renaming playlist. The playlist '{0}' could not be found", playlistToRename.Path);
return(RenamePlaylistResult.Error);
}
string sanitizedNewPlaylistName = FileUtils.SanitizeFilename(newPlaylistName);
string newFilename = this.CreatePlaylistFilePath(sanitizedNewPlaylistName, PlaylistType.Static);
if (System.IO.File.Exists(newFilename))
{
return(RenamePlaylistResult.Duplicate);
}
RenamePlaylistResult result = RenamePlaylistResult.Success;
await Task.Run(() =>
{
try
{
System.IO.File.Move(oldFilename, newFilename);
}
catch (Exception ex)
{
LogClient.Error("Error while renaming playlist '{0}' to '{1}'. Exception: {2}", playlistToRename.Name, newPlaylistName, ex.Message);
result = RenamePlaylistResult.Error;
}
});
return(result);
}
public void ThrottlesTimeChangesToNetworkByTime()
{
var messenger = CreateDefaultPlaylistMessenger();
NetworkMessenger.Override(messenger);
new TestScheduler().With(sched =>
{
var vm = new PlaylistViewModel();
vm.Activator.Activate();
vm.CurrentTimeSeconds = 10;
sched.AdvanceByMs(1);
vm.CurrentTimeSeconds = 20;
sched.AdvanceByMs(1);
vm.CurrentTimeSeconds = 30;
sched.AdvanceByMs(PlaylistViewModel.TimeThrottleDuration.TotalMilliseconds + 1);
messenger.ReceivedWithAnyArgs(2).SetCurrentTime(Arg.Any <TimeSpan>());
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(10));
messenger.Received(1).SetCurrentTime(TimeSpan.FromSeconds(30));
});
}
public async Task <IActionResult> Edit(User user)
{
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://musicparserapi.azurewebsites.net");
var plResponse = client.GetAsync("/api/playlist").Result;
if (plResponse.EnsureSuccessStatusCode().IsSuccessStatusCode)
{
var jsonDataPl = await plResponse.Content.ReadAsStringAsync();
List <Playlist> rawAllPlaylists = JsonConvert.DeserializeObject <List <Playlist> >(jsonDataPl);
var allPlaylists = from a in rawAllPlaylists
select a;
PlaylistViewModel mylistVM = new PlaylistViewModel();
user.DatListEyeDee = allPlaylists.FirstOrDefault(pl => pl.GenreID == user.DatGenreEyeDee).Id.Value;
_context.Users.Update(user);
await _context.SaveChangesAsync();
return(RedirectToAction("Get", "Playlist", new { id = user.Id }));
}
return(NotFound());
}
}
public override async Task <IList <TrackViewModel> > GetTracksAsync(PlaylistViewModel playlist)
{
// If no playlist was selected, return no tracks.
if (playlist == null)
{
LogClient.Error($"{nameof(playlist)} is null. Returning empty list of tracks.");
return(new List <TrackViewModel>());
}
var tracks = new List <TrackViewModel>();
var decoder = new PlaylistDecoder();
await Task.Run(async() =>
{
DecodePlaylistResult decodeResult = null;
decodeResult = decoder.DecodePlaylist(playlist.Path);
if (decodeResult.DecodeResult.Result)
{
foreach (string path in decodeResult.Paths)
{
try
{
tracks.Add(await this.fileService.CreateTrackAsync(path));
}
catch (Exception ex)
{
LogClient.Error("Could not get track information from file. Exception: {0}", ex.Message);
}
}
}
});
return(tracks);
}
public async Task <JsonResult> Post([FromBody] PlaylistViewModel model)
{
string token = Request.Headers["Authorization"];
var res = await _playlistService.CreatePlaylist(model, token);
return(new JsonResult(res));
}
public async Task <ActionResult <PlaylistViewModel> > Put(int id, [FromBody] PlaylistViewModel input,
CancellationToken ct = default)
{
try
{
if (input == null)
{
return(BadRequest());
}
if (await _chinookSupervisor.GetPlaylistByIdAsync(id, ct) == null)
{
return(NotFound());
}
var errors = JsonConvert.SerializeObject(ModelState.Values
.SelectMany(state => state.Errors)
.Select(error => error.ErrorMessage));
Debug.WriteLine(errors);
if (await _chinookSupervisor.UpdatePlaylistAsync(input, ct))
{
return(Ok(input));
}
return(StatusCode(500));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public SinglePlaylistViewModel(PlaylistViewModel playlist, Player player, User user)
{
this.user = user;
this.player = player;
Playlist = playlist;
CollectionInitialized();
}
private void OpenPlaylist_Click(object sender, RoutedEventArgs e)
{
PlaylistViewModel PlaylistVM = new PlaylistViewModel();
PlaylistVM.OpenPlaylist();
PlaylistNameHolder.Content = PlaylistViewModel.CurrentPlaylist;
}
public async Task <IActionResult> Create([Bind] PlaylistViewModel playlistSongs)
{
// Keeping for potential future projects
/*foreach (var value in ModelState.Values)
* {
* foreach (ModelError error in value.Errors)
* {
* Debug.WriteLine(error.ErrorMessage);
* }
* }*/
if (ModelState.IsValid)
{
if (playlistSongs.Image != null)
{
foreach (var item in playlistSongs.Image)
{
if (item.Length > 0)
{
using var stream = new MemoryStream();
await item.CopyToAsync(stream);
playlistSongs.Playlist.Image = stream.ToArray();
}
}
}
playlistDataLayer.CreatePlaylist(playlistSongs.Playlist, _userManager.GetUserId(User));
return(RedirectToAction("Index"));
}
return(View(playlistSongs));
}
private void Application_Startup(object sender, StartupEventArgs e)
{
var ambientViewModel = new PlaylistViewModel("Ambient", "Music that plays when no other criteria are met");
var battleViewModel = new PlaylistViewModel("Battle", "Music that plays in \"large\" fights involving many foes (~5 or more enemies); some personal story steps; PvP");
var bossBattleViewModel = new PlaylistViewModel("BossBattle", "Music that plays when fighting world bosses and some Dungeon bosses; some personal story steps; some Activities");
var cityViewModel = new PlaylistViewModel("City", "Music that plays when inside one of the main cities, such as The Black Citadel, but not always");
var defeatedViewModel = new PlaylistViewModel("Defeated", "Music that plays upon being Defeated");
var mainMenuViewModel = new PlaylistViewModel("MainMenu", "Music that plays at the character select screen");
var nightTimeViewModel = new PlaylistViewModel("NightTime", "Music that plays when in some explorable areas and it is nighttime (the moon is out)");
var underwaterViewModel = new PlaylistViewModel("Underwater", "Music that plays any time the breathing apparatus is equipped. Overrides most other playlists");
var victoryViewModel = new PlaylistViewModel("Victory", "Music that plays after World bosses or Meta events");
List <TabContainer> containers = new List <TabContainer>
{
new TabContainer(ambientViewModel.Header, new PlaylistView(ambientViewModel), ambientViewModel),
new TabContainer(battleViewModel.Header, new PlaylistView(battleViewModel), battleViewModel),
new TabContainer(bossBattleViewModel.Header, new PlaylistView(bossBattleViewModel), bossBattleViewModel),
new TabContainer(cityViewModel.Header, new PlaylistView(cityViewModel), cityViewModel),
new TabContainer(defeatedViewModel.Header, new PlaylistView(defeatedViewModel), defeatedViewModel),
new TabContainer(mainMenuViewModel.Header, new PlaylistView(mainMenuViewModel), mainMenuViewModel),
new TabContainer(nightTimeViewModel.Header, new PlaylistView(nightTimeViewModel), nightTimeViewModel),
new TabContainer(underwaterViewModel.Header, new PlaylistView(underwaterViewModel), underwaterViewModel),
new TabContainer(victoryViewModel.Header, new PlaylistView(victoryViewModel), victoryViewModel)
};
ViewModel viewModel = new ViewModel(containers);
View view = new View(viewModel);
view.Show();
}
public async Task <ActionResult> Playlist(string playlistUuId)
{
var session = await OpenTidlIntegrator.RestoreSessionFromClaimsIdentity(User.Identity);
if (session == null)
{
return(new EmptyResult());
}
var playlist = await session.GetPlaylist(playlistUuId);
if (playlist == null)
{
return(new EmptyResult());
}
var tracks = await session.GetPlaylistTracks(playlistUuId);
var playlistViewModel = new PlaylistViewModel
{
Playlist = playlist,
Tracks = tracks
};
return(View("Playlist", playlistViewModel));
}
private async Task <IList <TrackViewModel> > GetStaticPlaylistTracksAsync(PlaylistViewModel playlist)
{
var tracks = new List <TrackViewModel>();
var decoder = new PlaylistDecoder();
await Task.Run(async() =>
{
DecodePlaylistResult decodeResult = null;
decodeResult = decoder.DecodePlaylist(playlist.Path);
if (decodeResult.DecodeResult.Result)
{
foreach (PlaylistEntry entry in decodeResult.PlaylistEntries)
{
try
{
TrackViewModel track = await this.fileService.CreateTrackAsync(entry.DecodedPath);
track.PlaylistEntry = entry.ReferencePath; // This will allow deleting the correct entry in a playlist file
tracks.Add(track);
}
catch (Exception ex)
{
LogClient.Error("Could not get track information from file. Exception: {0}", ex.Message);
}
}
}
});
return(tracks);
}
public ActionResult Edit([Bind(Include = "Id,Name,TotalDuration, Videos")] PlaylistViewModel playList)
{
using (SignageContainer db = new SignageContainer())
{
if (ModelState.IsValid)
{
var videos = db.Videos
.Where(v => playList.Videos.Contains(v.Id))
.ToArray();
var totalDuration = TimeSpan.FromSeconds(videos.Sum(v => v.Duration.TotalSeconds));
var pl = db.Playlists.Find(playList.Id);
pl.Videos.Clear();
//db.SaveChanges();
//foreach(var v in pl.Videos.ToArray())
//{
// pl.Videos.Remove(v);
//}
pl.Name = playList.Name;
pl.TotalDuration = totalDuration;
foreach (var v in videos)
{
pl.Videos.Add(v);
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(Edit(playList.Id));
}
}
public async Task <IActionResult> PostPic(string pic)
{
if (pic == null)
{
return(NoContent());
}
string replaced = pic.Substring(22);
string filePath = Path.GetTempFileName();
byte[] bytes = Convert.FromBase64String(replaced);
using (FileStream fs = new FileStream(filePath, FileMode.Create))
{
using (BinaryWriter bw = new BinaryWriter(fs))
{
byte[] data = Convert.FromBase64String(replaced);
bw.Write(data);
bw.Close();
}
}
var result = await MakeAnalysisRequest(filePath);
string emotionResult = ConvertToEmotion(result);
PlaylistViewModel playlist = GetPlaylistByEmotion(emotionResult);
SaveToHistory(emotionResult, playlist);
return(View(emotionResult, playlist));
}
// GET: User/PlaylistToBeEdited
public ActionResult PlaylistToBeEdited(int?id)
{
if (id == null)
{
this.AddNotification("Invalid playlist id!", NotificationType.ERROR);
return(RedirectToAction("Index"));
}
Playlist playlist = db.Playlists.Find(id);
if (playlist == null)
{
this.AddNotification("Invalid playlist id!", NotificationType.ERROR);
return(RedirectToAction("Index"));
}
if (!IsAuthorizedToOperate(playlist))
{
this.AddNotification("You are not authorized to edit this playlist!", NotificationType.ERROR);
return(RedirectToAction("Index"));
}
var model = new PlaylistViewModel
{
Id = playlist.Id,
PlaylistName = playlist.PlaylistName,
IsPublic = playlist.IsPublic
};
return(View(model));
}
public ActionResult Create([Bind(Include = "Id,Name,TotalDuration, Videos")] PlaylistViewModel playList)
{
using (SignageContainer db = new SignageContainer())
{
if (ModelState.IsValid)
{
var videos = db.Videos
.Where(v => playList.Videos.Contains(v.Id))
.ToArray();
var totalDuration = TimeSpan.FromSeconds(videos.Sum(v => v.Duration.TotalSeconds));
var p = new Playlist
{
Name = playList.Name,
TotalDuration = totalDuration,
Videos = videos
};
db.Playlists.Add(p);
db.SaveChanges();
return(RedirectToAction("Index"));
}
}
return(Create());
}
public PlaylistPage(PlaylistItem playlistItem)
{
_vm = new PlaylistViewModel(playlistItem);
this.BindingContext = _vm;
InitializeComponent();
_nav = Navigation;
}
public async Task <object> CreatePlaylist(PlaylistViewModel model, string token)
{
try
{
var userToken = JwtDecode.User(token);
var user = await _context.Users
.Where(x => x.UserName == userToken)
.Include(x => x.Playlists)
.FirstOrDefaultAsync();
var playlist = new Playlist();
playlist.Name = model.Name;
string idStringTMP = model.Name.Replace("/", "");
if (idStringTMP.Length >= 8)
{
idStringTMP = idStringTMP.Substring(0, 8);
}
playlist.IdString = (idStringTMP + Guid.NewGuid().ToString().Substring(0, 8)).ToLower();
playlist.Id = new Guid();
user.Playlists.Add(playlist);
await _context.SaveChangesAsync();
return(new
{
Succeeded = true
});
}
catch
{
return(new
{
Succeeded = false
});
}
}
private void Button_Clicked_1(object sender, EventArgs e)
{
PlaylistViewModel vm = this.BindingContext as PlaylistViewModel;
DependencyService.Get <IMusicManager>().AddToEndOfQueue(new ObservableCollection <Song>(
vm.Songs.Select(s => new Models.Song(s))));
}
public async Task <IActionResult> Create(int id)
{
var user = await _context.Users.FirstOrDefaultAsync(u => u.Id == id);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri("http://musicparserapi.azurewebsites.net");
var plResponse = client.GetAsync("/api/playlist").Result;
if (plResponse.EnsureSuccessStatusCode().IsSuccessStatusCode)
{
var jsonDataPl = await plResponse.Content.ReadAsStringAsync();
List <Playlist> rawAllPlaylists = JsonConvert.DeserializeObject <List <Playlist> >(jsonDataPl);
//var allPlaylists = from a in rawAllPlaylists
// select a;
PlaylistViewModel plVM = new PlaylistViewModel();
plVM.Playlists = rawAllPlaylists;
plVM.User = user;
return(View(plVM));
}
}
return(RedirectToAction("Home"));
}
public PlaylistView()
{
_viewModel = new PlaylistViewModel();
InitializeComponent();
DataContext = _viewModel;
}
protected override void OnInitialize()
{
base.OnInitialize();
musicFileContext = Container.GetExportedValue <MockMusicFileContext>();
musicFiles = new ObservableCollection <MusicFile>()
{
musicFileContext.Create(@"C:\Users\Public\Music\Dancefloor\Culture Beat - Serenity.wav"),
musicFileContext.Create(@"C:\Culture Beat - Serenity - Epilog.wma"),
};
selectionService = Container.GetExportedValue <SelectionService>();
selectionService.Initialize(musicFiles);
playlistManager = new PlaylistManager();
controller = Container.GetExportedValue <PlaylistController>();
controller.PlaylistSettings = new PlaylistSettings();
controller.PlaylistManager = playlistManager;
controller.Initialize();
controller.Run();
shellService = Container.GetExportedValue <ShellService>();
var view = shellService.PlaylistView;
viewModel = ViewHelper.GetViewModel <PlaylistViewModel>((IView)view);
}
public static UpdatePlaylistViewModel CreateUpdatePlaylistViewModel(PlaylistViewModel playlist, PropertyChangedEventHandler callback)
{
UpdatePlaylistViewModel updatePlaylistViewModel = new UpdatePlaylistViewModel(playlist);
updatePlaylistViewModel.PropertyChanged += callback;
return(updatePlaylistViewModel);
}
private async Task <RenamePlaylistResult> RenameSmartPlaylistAsync(PlaylistViewModel playlistToRename, string newPlaylistName)
{
IList <PlaylistViewModel> existingSmartPlaylists = await this.GetSmartPlaylistsAsync();
if (existingSmartPlaylists.Any(x => x.Name.ToLower().Equals(newPlaylistName.ToLower())))
{
return(RenamePlaylistResult.Duplicate);
}
RenamePlaylistResult result = RenamePlaylistResult.Success;
await Task.Run(() =>
{
try
{
this.SetSmartPlaylistNameIfDifferent(playlistToRename.Path, newPlaylistName);
}
catch (Exception ex)
{
LogClient.Error("Error while renaming playlist '{0}' to '{1}'. Exception: {2}", playlistToRename.Name, newPlaylistName, ex.Message);
result = RenamePlaylistResult.Error;
}
});
return(result);
}
protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
{
_playlistVm.Reset();
_playlistVm = null;
this.Loaded -= OnPageLoaded;
//fileBox.ItemsSource = null;
}
public async Task IsCurrentPlaylingSong()
{
var song = new NetworkSong {
Title = "A"
};
var playlist = new NetworkPlaylist
{
Name = "A",
Songs = new List <NetworkSong> {
song
}.AsReadOnly(),
CurrentIndex = 0
};
var messenger = CreateDefaultPlaylistMessenger();
messenger.GetCurrentPlaylistAsync().Returns(playlist.ToTaskResult());
var vm = new PlaylistViewModel();
vm.Activator.Activate();
await vm.LoadPlaylistCommand.ExecuteAsync();
Assert.Equal("A", vm.CurrentSong.Title);
}
public ActionResult Edit(PlaylistViewModel playlist)
{
if (ModelState.IsValid)
{
var MyPlaylist = db.Playlists.Find(playlist.PlaylistId);
MyPlaylist.PlaylistName = playlist.PlaylistName;
foreach (var item in db.FilesToPlaylists)
{
if (item.PlaylistID == playlist.PlaylistId)
{
db.Entry(item).State = System.Data.Entity.EntityState.Deleted;
}
}
foreach (var item in playlist.Songs)
{
if (item.Checked)
{
db.FilesToPlaylists.Add(new SongsToPlaylist()
{
PlaylistID = playlist.PlaylistId, FileID = item.Id
});
}
}
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(playlist));
}
public async Task SmokeTest()
{
var songs = Helpers.SetupSongs(2);
var playlist = new NetworkPlaylist
{
Name = "A",
Songs = songs,
CurrentIndex = 0
};
var messenger = CreateDefaultPlaylistMessenger();
messenger.GetCurrentPlaylistAsync().Returns(playlist.ToTaskResult());
messenger.PlayPlaylistSongAsync(songs[1].Guid)
.Returns(new ResponseInfo {
Status = ResponseStatus.Success
}.ToTaskResult());
var vm = new PlaylistViewModel();
vm.Activator.Activate();
await vm.LoadPlaylistCommand.ExecuteAsync();
vm.SelectedEntry = vm.Entries[1];
await vm.PlayPlaylistSongCommand.ExecuteAsync();
messenger.Received(1).PlayPlaylistSongAsync(songs[1].Guid);
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
_playlistVm = Application.Current.Resources["PlaylistVM"] as PlaylistViewModel;
_playlistVm.Init(e.Parameter);
DataContext = _playlistVm;
base.OnNavigatedTo(e);
}
public MainWindowViewModel()
{
// init instance of wmp-player from wmp.dll
PlayerEngineModel playerEngine = new PlayerEngineModel(false,false);
// init view-models taking wmp-player as argument
Player = new PlayerEngineViewModel(playerEngine);
CurrentSong = new CurrentSongViewModel(playerEngine);
Playlist = new PlaylistViewModel(playerEngine);
Navigation = new Server.ServerNavigationViewModel();
Servers = new ConnectionLibrary();
// undo/redo
CommandLib = new CommandLibrary();
Player.Volume = 80;
_this = this;
}
protected override void OnInitialize()
{
base.OnInitialize();
musicFileContext = Container.GetExportedValue<MockMusicFileContext>();
musicFiles = new ObservableCollection<MusicFile>()
{
musicFileContext.Create(@"C:\Users\Public\Music\Dancefloor\Culture Beat - Serenity.wav"),
musicFileContext.Create(@"C:\Culture Beat - Serenity - Epilog.wma"),
};
selectionService = Container.GetExportedValue<SelectionService>();
selectionService.Initialize(musicFiles);
playlistManager = new PlaylistManager();
controller = Container.GetExportedValue<PlaylistController>();
controller.PlaylistSettings = new PlaylistSettings();
controller.PlaylistManager = playlistManager;
controller.Initialize();
controller.Run();
shellService = Container.GetExportedValue<ShellService>();
var view = shellService.PlaylistView;
viewModel = ViewHelper.GetViewModel<PlaylistViewModel>((IView)view);
}
public PlaylistViewModel LookupPlaylist(PlaylistModel playlist)
{
if (PlaylistLookupMap.ContainsKey(playlist.PlaylistId))
{
return PlaylistLookupMap[playlist.PlaylistId];
}
else
{
PlaylistViewModel newViewModel = new PlaylistViewModel(playlist);
PlaylistLookupMap.Add(newViewModel.PlaylistId, newViewModel);
PlaylistCollection.Add(newViewModel);
return newViewModel;
}
}
public void AddPlayList(string userId, PlaylistViewModel playListModel)
{
_playlistRepository.AddPlayList(userId, ModelConverters.ToPlaylistModel(playListModel));
}
public SavePlaylistCommand(PlaylistViewModel plvm)
{
this._plvm = plvm;
}
public EditPlaylist(PlaylistViewModel playlistToEdit)
{
this.InitializeComponent();
this.DataContext = playlistToEdit;
}
internal void DeletePlaylist(PlaylistViewModel playlist)
{
playlist.IsBeingDeleted = true;
LibraryModel.Current.DeletePlaylist(playlist.PlaylistId);
}
private void SetSelection(PlaylistViewModel viewModel, params PlaylistItem[] items)
{
viewModel.SelectedPlaylistItem = items.Last();
viewModel.SelectedPlaylistItems.Clear();
foreach (var item in items)
{
viewModel.SelectedPlaylistItems.Add(item);
}
}
