public void AddPlaylist(string name)
{
if (mPlayer.playlistCollection.getByName(name).count > 0)
{
Playlists.Add(mPlayer.playlistCollection.getByName(name).Item(0));
}
}
public virtual void AddPlaylist(Playlist playlist)
{
// Playlist must be removed from other Folder before AddPlaylist affects it.
if (playlist.Folder != null && playlist.Folder.Id != Id)
{
string message = string.Format("Playlist {0} is already a child of Folder {1}", playlist.Title, playlist.Folder.Title);
throw new Exception(message);
}
if (Playlists.Count == 0)
{
FirstPlaylist = playlist;
playlist.NextPlaylist = playlist;
playlist.PreviousPlaylist = playlist;
}
else
{
Playlist firstPlayist = FirstPlaylist;
Playlist lastPlaylist = firstPlayist.PreviousPlaylist;
// Adjust our linked list and add the item.
lastPlaylist.NextPlaylist = playlist;
playlist.PreviousPlaylist = lastPlaylist;
firstPlayist.PreviousPlaylist = playlist;
playlist.NextPlaylist = firstPlayist;
}
playlist.Folder = this;
Playlists.Add(playlist);
}
async Task ExecuteLoadChannelCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try {
Playlists.Clear();
var items = await VideoRepository.LoadChannelAsync("");
foreach (var item in items)
{
Playlists.Add(item);
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
CurrentPlayList = Playlists.FirstOrDefault(pl => pl.Id == "PLlZwsUoL6TOaEwk2wkvVrrZnsSiCl7VKb");
}
private void RefreshITunesPlaylists()
{
new Thread(() =>
{
Playlists.Clear();
Playlists.Add("Disabled");
_playlists.Clear();
_playlists.Add(null);
var i = 1;
foreach (var playlist in ITunesSync.GetAllPlaylists())
{
Playlists.Add(playlist.Name);
_playlists.Add(playlist);
if (playlist.Name == _workspaceViewModel.Workspace.Settings.ITunesSyncPlaylist)
{
SelectedPlaylistIndex = i;
}
i++;
}
if (SelectedPlaylistIndex == -1)
{
SelectedPlaylistIndex = 0;
}
}).Start();
}
/// <summary>
/// hinzufügen einer neuen Playlist
/// </summary>
private void AddPlaylist()
{
tpadd.Visibility = Visibility.Hidden;
string plvalue = tpadd.tbflex.Text;
if (Playlists.GetPlaylistNames.Contains(plvalue))
{
var resultDialog = MessageBox.Show("Soll die Wiedergabeliste überschrieben werden?",
"Wiedergabeliste schon vorhanden", MessageBoxButton.YesNoCancel,
MessageBoxImage.Question);
switch (resultDialog)
{
case MessageBoxResult.Yes:
tpadd.tbflex.Text = String.Empty;
int pl = Playlists.GetPlaylistNames.IndexOf(plvalue);
Playlists.GetPlaylists[pl].Playlist = plvalue;
Playlists.GetPlaylists[pl].PlaylistConditionGroups.Clear();
ResetDatabinds();
break;
case MessageBoxResult.No:
tpadd.Visibility = Visibility.Visible;
break;
}
}
else
{
Playlists.Add(new PlaylistClass(plvalue));
Functions.PlaylistChanged = true;
lbPlaylist.ItemsSource = null;
lbPlaylist.ItemsSource = Playlists.GetPlaylistNames;
tpadd.tbflex.Text = String.Empty;
lbPlaylist.SelectedIndex = Playlists.GetPlaylistNames.IndexOf(plvalue);
}
}
//Fills ObservableCollection<Sound> Playlists with files found in /user/MyDocuments/AudioPlayer directory.
private void FillPlaylist()
{
string docPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), @"AudioPlayer");
var playlists = new List <Sound>();
try
{
var allFiles = Directory.GetFiles(docPath);
foreach (var file in allFiles)
{
var pathExtension = Path.GetExtension(file);
if (pathExtension?.ToUpper() == ".TXT")
{
playlists.Add(new Sound()
{
Name = Path.GetFileNameWithoutExtension(file),
Path = file
});
}
}
Playlists.Clear();
playlists.ForEach(c => Playlists.Add(c));
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
/// <summary>
/// Bind the users list of playlists to the view
/// </summary>
/// <returns></returns>
private async Task BindPlaylists()
{
try
{
var page = await SpotifyService.GetPlaylists(AuthenticationService.User, AuthenticationService.AuthenticationToken);
do
{
foreach (var playlist in page.Items)
{
Playlists.Add(playlist);
}
if (page.HasNextPage)
{
page = await SpotifyService.GetNextPage(page, AuthenticationService.AuthenticationToken);
}
else
{
page = null;
}
}while (page != null);
}
catch (Exception ex)
{
PageException = ex;
}
Loaded = true;
StateHasChanged();
}
public void LoadPlaylists(string path)
{
using (FileStream fileStream = File.OpenRead(@path))
using (StreamReader reader = new StreamReader(fileStream))
{
while (!reader.EndOfStream)
{
int i = 0;
string line = reader.ReadLine();
if (line == "" || line[0] == '#')
{
continue;
}
string[] values = line.Split(',');
Playlist playlist = new Playlist();
playlist.Id = Int32.Parse(values[i++]);
playlist.Title = values[i++];
playlist.Owner = GetUser(values[i++]);
playlist.Rating = float.Parse(values[i++]);
Playlists.Add(playlist);
}
}
}
public void GenerateLibraryThreadPlaylist(object param)
{
var handler = (ManualResetEvent)param;
try
{
var files = Directory.GetFiles(PlaylistPath, "*" + PlaylistExtension, SearchOption.AllDirectories);
foreach (String file in files)
{
var playlist = new Playlist(file);
lock (Playlists)
Playlists.Add(playlist);
}
}
catch (DirectoryNotFoundException)
{
try
{
Directory.CreateDirectory(PlaylistPath);
}
catch (DirectoryNotFoundException) { }
}
lock (MW)
MW.UpdateCurrentPanel(ClickStyle.SELECTION);
handler.Set();
}
public async void RenamePlaylist(string oldName, string newName, RenameOption option, object data = null)
{
switch (option)
{
case RenameOption.New:
Playlist playlist = new Playlist(newName);
if (data != null)
{
playlist.Add(data);
}
await playlist.SetDisplayItemAsync();
Playlists.Add(playlist);
PlaylistsPage.Playlists.Add(playlist);
foreach (var listener in PlaylistAddedListeners)
{
listener.Invoke(playlist);
}
break;
case RenameOption.Rename:
if (oldName == newName)
{
break;
}
int index = Playlists.FindIndex(p => p.Name == oldName);
Playlists[index].Name = newName;
PlaylistsPage.Playlists[index].Name = newName;
break;
}
}
public void RefreshData()
{
try
{
IsLoadingData = true;
// clear all displayed data
Application.Current.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Normal, (Action) delegate
{
Playlists.Clear();
CurrentPlaylistObjects.Clear();
ViewCurrentPlaylistObjects.Refresh();
ViewPlaylists.Refresh();
});
// load the playlists
List <VM_Playlist> rawPlaylists = VM_ShokoServer.Instance.ShokoServices.GetAllPlaylists().CastList <VM_Playlist>();
foreach (VM_Playlist contract in rawPlaylists)
{
Playlists.Add(contract);
}
IsLoadingData = false;
}
catch (Exception ex)
{
Utils.ShowErrorMessage(ex);
}
}
private void ViewModelAddData(Search result)
{
result.Albums.Items.ForEach(a => Albums.Add(a));
result.Artists.Items.ForEach(a => Artists.Add(a));
result.Playlists.Items.ForEach(p => Playlists.Add(p));
result.Tracks.Items.ForEach(t => Tracks.Add(t));
}
public async Task <Playlist> CopyPlaylist(Models.PlaylistRequest request)
{
var playlist = Playlists.First(t => t.Id == request.PlaylistId);
var savedCopy = await _spotifyWebApi.CreatePlaylist(playlist, SpotifyApi.Playlists(Me), Token);
Playlists.Add(savedCopy);
return(savedCopy);
}
public void AddPlaylist()
{
var newPlaylist = "Playlist " + (Playlists.Count + 1);
Playlists.Add(new Playlist {
Title = newPlaylist
});
}
private void AddPlaylist()
{
var newPlaylist = "Playlist " + (Playlists.Count + 1);
Playlists.Add(new PlaylistViewModel {
Title = newPlaylist
});
}
public void AddPlaylist(IPlaylist playlist)
{
if (Playlists.Contains(playlist))
{
return;
}
Playlists.Add(playlist);
playlist.MediaAdded += OnPlaylistMediaAdded;
}
private void ResetITunesPlaylists()
{
Playlists.Clear();
Playlists.Add("Disabled");
_playlists.Clear();
_playlists.Add(null);
SelectedPlaylistIndex = 0;
}
/// <summary>
/// Synchronize locale Database with Server
/// </summary>
private void synchronizeDatabase()
{
NetworkHandler.SyncLocalDbWithServerDb();
// Synchronize View with local database
foreach (Playlist playlist in PlaylistsManager.db_GetAllPlaylists())
{
Playlists.Add(playlist.name);
}
}
private void OnClickCreatePlaylist(object sender, RoutedEventArgs e)
{
LocalPlaylist playlist = new LocalPlaylist()
{
Name = m_playListTextBox.Text
};
playlist.Save(System.IO.Path.Combine(PLAYLISTS_DIRECTORY, playlist.Name + ".xml"));
Playlists.Add(playlist.Name);
}
// Public Methods //
public void AddPlaylist(SpotifyPlaylist playlist)
{
if (playlist == null)
{
return;
}
Playlists = Playlists ?? new List <SpotifyPlaylist>();
Playlists.Add(playlist);
}
public void AddPlaylist(string name)
{
PlaylistTable table = new PlaylistTable(name);
DatabaseManager.Current.AddPlaylist(table);
PlaylistModel playlistModel = new PlaylistModel(table);
Playlists.Add(playlistModel);
playlistLookupDictionary.Add(playlistModel.PlaylistId, playlistModel);
}
private async Task LoadPlaylists()
{
if (Playlists != null && Playlists.Count > 0)
{
Playlists.Clear();
}
var playlists = await playlistRepository.GetAllPlaylistAsync();
foreach (var playlist in playlists)
{
Playlists.Add(new PlaylistViewModel(playlist));
}
}
public Config(SDAT sdat)
{
SDAT = sdat;
if (sdat.INFOBlock.SequenceInfos.NumEntries == 0)
{
throw new Exception(Strings.ErrorSDATNoSequences);
}
IEnumerable <Song> songs = Enumerable.Range(0, sdat.INFOBlock.SequenceInfos.NumEntries)
.Where(i => sdat.INFOBlock.SequenceInfos.Entries[i] != null)
.Select(i => new Song(i, sdat.SYMBBlock == null ? i.ToString() : sdat.SYMBBlock.SequenceSymbols.Entries[i]));
Playlists.Add(new Playlist(Strings.PlaylistMusic, songs));
}
public void SaveAsPlaylist()
{
Skin.Render("Enter the name of playlist");
Playlist playlist = new Playlist(Console.ReadLine(), Songs);
Playlists.Add(playlist);
XmlSerializer xmlSerializer = new XmlSerializer(Playlists.GetType());
using (FileStream fs = new FileStream("Playlists.xml", FileMode.OpenOrCreate))
{
playlist.Path = fs.Name;
xmlSerializer.Serialize(fs, Playlists);
}
}
public void AddPlaylist(Model.Playlist newPlaylist)
{
if (Playlists.Any(cus => cus.Name == newPlaylist.Name) == false)
{
XML.PlaylistXML playlistXML = new XML.PlaylistXML();
playlistXML.Load("playlists.xml");
if (!playlistXML.HasPlaylist(newPlaylist.Name))
{
playlistXML.AddPlaylist(newPlaylist.Name);
playlistXML.WriteInFile("playlists.xml");
Playlists.Add(newPlaylist);
}
}
}
public async Task StartConveirToGetPlaylist(IMusicService musicService)
{
try
{
PlaylistsTemp = await musicService.ParsePlaylistFromJson();
for (int i = 0; i < PlaylistsTemp.Count; i++)
{
Playlists.Add(PlaylistsTemp[i]);
}
}
catch (ArgumentNullException eNullExc)
{
MessageBox.Show(eNullExc.Message);
}
}
public async void Handle(AddPlaylistReplyEvent message)
{
if (String.IsNullOrEmpty(message.Content))
{
return;
}
var invalidUrlEvent = new NotificationEvent(Localization.Common.Error,
String.Format(Localization.Playlists.AddPlaylistInvalidLinkDialogMessage, message.Content));
if (!Regex.IsMatch(message.Content,
@"((?:(?:http|https)://open.spotify.com/user/[a-zA-Z0-9]+/playlist/[a-zA-Z0-9]+)|(?:spotify:user:[a-zA-Z0-9]+:playlist:[a-zA-Z0-9]+))"))
{
_Logger.Info("Loadify detected that the playlist link entered is not a valid Spotify playlist link");
_EventAggregator.PublishOnUIThread(invalidUrlEvent);
}
else
{
try
{
_EventAggregator.PublishOnUIThread(new DisplayProgressEvent("Adding Playlist...",
Localization.Playlists.AddPlaylistProcessingDialogMessage));
_Logger.Debug(String.Format("Resolving playlist link {0}...", message.Content));
var playlist = await PlaylistModel.FromLibrary(message.Session.GetPlaylist(message.Content), message.Session);
_Logger.Info(String.Format("Playlist {0} ({1} tracks) was resolved and added to the playlist collection", playlist.Name, playlist.Tracks.Count));
Playlists.Add(new PlaylistViewModel(playlist, _EventAggregator, _SettingsManager));
if (message.Permanent)
{
var playlistCollection = await message.Session.GetPlaylistCollection();
_Logger.Debug(String.Format("Adding playlist {0} permanently to the logged-in Spotify account...", playlist.Name));
await playlistCollection.Add(playlist.UnmanagedPlaylist);
_Logger.Info(String.Format("Playlist {0} was added permanently to the logged-in Spotify account", playlist.Name));
}
_EventAggregator.PublishOnUIThread(new HideProgressEvent());
}
catch (InvalidSpotifyUrlException exception)
{
_Logger.Error(String.Format("Playlist link {0} is invalid but was not detected to be invalid by Loadify. Please report this incident", message.Content), exception);
_EventAggregator.PublishOnUIThread(invalidUrlEvent);
}
}
}
private void AddPlaylist(object obj)
{
var dialog = new TextBoxWindow();
var playlist = new PlaylistObject();
if (dialog.ShowDialog() == true)
{
playlist.Name = dialog.ResponseText;
if (String.IsNullOrWhiteSpace(playlist.Name))
{
return;
}
}
_musicLog.AddPlaylist(playlist);
Playlists.Add(playlist);
}
private async void LoadPlaylists()
{
var playlists = _sqlService.SelectAll <Playlist>().OrderByDescending(p => p.Id);
var playlistSongs = _sqlService.SelectAll <PlaylistSong>();
foreach (var playlist in playlists)
{
var songs = playlistSongs.Where(p => p.PlaylistId == playlist.Id).ToList();
PlaylistSong head = null;
foreach (var playlistSong in songs)
{
playlistSong.Song = Songs.FirstOrDefault(p => p.Id == playlistSong.SongId);
playlist.LookupMap.TryAdd(playlistSong.Id, playlistSong);
if (playlistSong.PrevId == 0)
{
head = playlistSong;
}
}
if (head != null)
{
for (var i = 0; i < songs.Count; i++)
{
playlist.Songs.Add(head);
if (head.NextId != 0)
{
head = playlist.LookupMap[head.NextId];
}
}
}
if (_dispatcher != null)
{
await _dispatcher.RunAsync(() => Playlists.Add(playlist));
}
else
{
Playlists.Add(playlist);
}
}
}
public Config(SDAT sdat)
{
if (sdat.INFOBlock.SequenceInfos.NumEntries == 0)
{
throw new Exception(Strings.ErrorSDATNoSequences);
}
SDAT = sdat;
var songs = new List <Song>(sdat.INFOBlock.SequenceInfos.NumEntries);
for (int i = 0; i < sdat.INFOBlock.SequenceInfos.NumEntries; i++)
{
if (sdat.INFOBlock.SequenceInfos.Entries[i] != null)
{
songs.Add(new Song(i, sdat.SYMBBlock is null ? i.ToString() : sdat.SYMBBlock.SequenceSymbols.Entries[i]));
}
}
Playlists.Add(new Playlist(Strings.PlaylistMusic, songs));
}
public Playlists GetPlaylists(bool includeTracks = true)
{
Playlists playlists = null;
string jsArray = String.Format(@"[[""{0}"",1],[""all""]]", _sessionId);
string response = GoogleMusicService(Service.loadplaylists, jsArray);
if (!String.IsNullOrEmpty(response))
{
ArrayList array = (_parser.Parse(response)[1] as ArrayList)[0] as ArrayList;
playlists = new Playlists();
playlists.lastUpdatedTimestamp = DateTime.Now;
foreach (ArrayList pl in array)
{
Playlist playlist = new Playlist();
for (int i = 0; i < playlistProperties.Length; i++)
{
string property = playlistProperties[i];
if (!String.IsNullOrEmpty(property))
{
MethodInfo info = typeof(Playlist).GetMethod("set_" + property, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (info != null && i < pl.Count)
{
object pli = pl[i];
if (pli != null) pli = Convert.ChangeType(pli, info.GetParameters()[0].ParameterType);
info.Invoke(playlist, new[] { pli });
}
else
ThrowError(String.Format("Playlist property '{0}' not matched!", property));
}
}
playlists.Add(playlist);
}
if (includeTracks)
{
foreach (Playlist playlist in playlists)
playlist.entries = GetPlaylistEntries(playlist.id).entries;
}
}
return playlists;
}
