private async Task DeletePlaylistAsync(PlaylistViewModel playlist)
        {
            DeletePlaylistsResult result = await this.playlistService.DeletePlaylistAsync(playlist);

            if (result == DeletePlaylistsResult.Error)
            {
                this.dialogService.ShowNotification(
                    0xe711,
                    16,
                    ResourceUtils.GetString("Language_Error"),
                    ResourceUtils.GetString("Language_Error_Deleting_Playlist").Replace("{playlistname}", playlist.Name),
                    ResourceUtils.GetString("Language_Ok"),
                    true,
                    ResourceUtils.GetString("Language_Log_File"));
            }
        }
        private async Task DeletePlaylistAsync(string playlistName)
        {
            DeletePlaylistsResult result = await this.PlaylistService.DeletePlaylistAsync(playlistName);

            if (result == DeletePlaylistsResult.Error)
            {
                this.DialogService.ShowNotification(
                    0xe711,
                    16,
                    ResourceUtils.GetStringResource("Language_Error"),
                    ResourceUtils.GetStringResource("Language_Error_Deleting_Playlist").Replace("%playlistname%", playlistName),
                    ResourceUtils.GetStringResource("Language_Ok"),
                    true,
                    ResourceUtils.GetStringResource("Language_Log_File"));
            }
        }
Example #3
0
        public async Task<DeletePlaylistsResult> DeletePlaylistAsync(PlaylistViewModel playlist)
        {
            if (playlist == null)
            {
                LogClient.Error($"{nameof(playlist)} is null");
                return DeletePlaylistsResult.Error;
            }

            DeletePlaylistsResult result = DeletePlaylistsResult.Success;

            this.watcher.Suspend(); // Stop watching the playlist folder

            string filename = string.Empty;

            await Task.Run(() =>
            {
                try
                {
                    if (System.IO.File.Exists(playlist.Path))
                    {
                        System.IO.File.Delete(playlist.Path);
                    }
                    else
                    {
                        result = DeletePlaylistsResult.Error;
                    }
                }
                catch (Exception ex)
                {
                    LogClient.Error("Error while deleting playlist '{0}'. Exception: {1}", playlist.Path, ex.Message);
                    result = DeletePlaylistsResult.Error;
                }
            });

            if (result == DeletePlaylistsResult.Success)
            {
                this.PlaylistFolderChanged(this, new EventArgs());
            }

            this.watcher.Resume(); // Start watching the playlist folder

            return result;
        }
Example #4
0
        public async Task <DeletePlaylistsResult> DeletePlaylistAsync(string playlistName)
        {
            if (string.IsNullOrWhiteSpace(playlistName))
            {
                LogClient.Error("PlaylistName is empty");
                return(DeletePlaylistsResult.Error);
            }

            DeletePlaylistsResult result = DeletePlaylistsResult.Success;

            watcher.EnableRaisingEvents = false; // Stop watching the playlist folder

            await Task.Run(() =>
            {
                try
                {
                    string filename = this.CreatePlaylistFilename(playlistName);

                    if (System.IO.File.Exists(filename))
                    {
                        System.IO.File.Delete(filename);
                    }
                    else
                    {
                        result = DeletePlaylistsResult.Error;
                    }
                }
                catch (Exception ex)
                {
                    LogClient.Error("Error while deleting playlist '{0}'. Exception: {1}", playlistName, ex.Message);
                    result = DeletePlaylistsResult.Error;
                }
            });

            if (result == DeletePlaylistsResult.Success)
            {
                this.PlaylistDeleted(playlistName);
            }

            watcher.EnableRaisingEvents = true; // Start watching the playlist folder

            return(result);
        }
Example #5
0
        public async Task <DeletePlaylistsResult> DeletePlaylistsAsync(IList <string> playlists)
        {
            DeletePlaylistsResult result           = DeletePlaylistsResult.Success;
            List <string>         deletedPlaylists = new List <string>();

            await Task.Run(() =>
            {
                foreach (string playlist in playlists)
                {
                    try
                    {
                        string filename = this.CreatePlaylistFilename(playlist);

                        if (System.IO.File.Exists(filename))
                        {
                            System.IO.File.Delete(filename);
                            deletedPlaylists.Add(playlist);
                        }
                        else
                        {
                            result = DeletePlaylistsResult.Error;
                        }
                    }
                    catch (Exception ex)
                    {
                        LogClient.Error("Error while deleting playlist '{0}'. Exception: {1}", playlist, ex.Message);
                        result = DeletePlaylistsResult.Error;
                    }
                }
            });

            if (deletedPlaylists.Count > 0)
            {
                this.PlaylistsDeleted(deletedPlaylists);
            }

            return(result);
        }
        private async Task DeletePlaylistsAsync(IList <string> playlists)
        {
            DeletePlaylistsResult result = await this.playlistService.DeletePlaylistsAsync(playlists);

            if (result == DeletePlaylistsResult.Error)
            {
                string message = ResourceUtils.GetStringResource("Language_Error_Deleting_Playlists");

                if (playlists.Count == 1)
                {
                    message = ResourceUtils.GetStringResource("Language_Error_Deleting_Playlist").Replace("%playlistname%", playlists[0]);
                }

                this.dialogService.ShowNotification(
                    0xe711,
                    16,
                    ResourceUtils.GetStringResource("Language_Error"),
                    message,
                    ResourceUtils.GetStringResource("Language_Ok"),
                    true,
                    ResourceUtils.GetStringResource("Language_Log_File"));
            }
        }