Esempio n. 1
0
        public async Task <RemoveFolderResult> RemoveFolderAsync(string path)
        {
            RemoveFolderResult result = RemoveFolderResult.Success;

            await Task.Run(() =>
            {
                try
                {
                    using (var conn = this.factory.GetConnection())
                    {
                        try
                        {
                            var obsoleteFolder = conn.Table <Folder>().Where((s) => s.Path.ToLower().Equals(path.ToLower())).Select((s) => s).FirstOrDefault();

                            if (obsoleteFolder != null)
                            {
                                conn.Delete(obsoleteFolder);
                                LogClient.Instance.Logger.Info("Removed the Folder {0}", path);
                            }
                        }
                        catch (Exception ex)
                        {
                            LogClient.Instance.Logger.Error("Could not remove the Folder {0}. Exception: {1}", path, ex.Message);
                            result = RemoveFolderResult.Error;
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogClient.Instance.Logger.Error("Could not connect to the database. Exception: {0}", ex.Message);
                }
            });

            return(result);
        }
        private async void RemoveFolder(long folderId)
        {
            try
            {
                this.IsLoadingFolders = true;
                RemoveFolderResult result = await this.foldersService.RemoveFolderAsync(folderId);

                this.IsLoadingFolders = false;

                switch (result)
                {
                case RemoveFolderResult.Success:
                    this.indexingService.OnFoldersChanged();
                    this.GetFoldersAsync();
                    break;

                case RemoveFolderResult.Error:
                    this.dialogService.ShowNotification(0xe711, 16, ResourceUtils.GetString("Language_Error"), ResourceUtils.GetString("Language_Error_Removing_Folder"), ResourceUtils.GetString("Language_Ok"), true, ResourceUtils.GetString("Language_Log_File"));
                    break;
                }
            }
            catch (Exception ex)
            {
                LogClient.Error("Exception: {0}", ex.Message);

                this.dialogService.ShowNotification(0xe711, 16, ResourceUtils.GetString("Language_Error"), ResourceUtils.GetString("Language_Error_Removing_Folder"), ResourceUtils.GetString("Language_Ok"), true, ResourceUtils.GetString("Language_Log_File"));
            }
            finally
            {
                this.IsLoadingFolders = false;
            }
        }
Esempio n. 3
0
        public async Task <RemoveFolderResult> RemoveFolderAsync(long folderId)
        {
            RemoveFolderResult result = RemoveFolderResult.Success;

            await Task.Run(() =>
            {
                try
                {
                    using (var conn = this.factory.GetConnection())
                    {
                        try
                        {
                            conn.Execute($"DELETE FROM Folder WHERE FolderID={folderId};");
                            conn.Execute($"DELETE FROM FolderTrack WHERE FolderID={folderId};");

                            LogClient.Info("Removed the Folder with FolderID={0}", folderId);
                        }
                        catch (Exception ex)
                        {
                            LogClient.Error("Could not remove the Folder with FolderID={0}. Exception: {1}", folderId, ex.Message);
                            result = RemoveFolderResult.Error;
                        }
                    }
                }
                catch (Exception ex)
                {
                    LogClient.Error("Could not connect to the database. Exception: {0}", ex.Message);
                }
            });

            return(result);
        }
        private async void RemoveFolder(string path)
        {
            try
            {
                this.IsLoadingFolders = true;
                RemoveFolderResult result = await this.folderRepository.RemoveFolderAsync(path);

                this.IsLoadingFolders = false;

                switch (result)
                {
                case RemoveFolderResult.Success:
                    await this.indexingService.RemoveFolderWatcherAsync(path);

                    this.GetFoldersAsync();
                    break;

                case RemoveFolderResult.Error:
                    this.dialogService.ShowNotification(0xe711, 16, ResourceUtils.GetStringResource("Language_Error"), ResourceUtils.GetStringResource("Language_Error_Removing_Folder"), ResourceUtils.GetStringResource("Language_Ok"), true, ResourceUtils.GetStringResource("Language_Log_File"));
                    break;
                }
            }
            catch (Exception ex)
            {
                CoreLogger.Current.Error("Exception: {0}", ex.Message);

                this.dialogService.ShowNotification(0xe711, 16, ResourceUtils.GetStringResource("Language_Error"), ResourceUtils.GetStringResource("Language_Error_Removing_Folder"), ResourceUtils.GetStringResource("Language_Ok"), true, ResourceUtils.GetStringResource("Language_Log_File"));
            }
            finally
            {
                this.IsLoadingFolders = false;
            }
        }
Esempio n. 5
0
        public override async Task <RemoveFolderResult> RemoveFolderAsync(string path)
        {
            RemoveFolderResult result = RemoveFolderResult.Success;

            await Task.Run(() =>
            {
                try
                {
                    using (var conn = this.Factory.GetConnection())
                    {
                        try
                        {
                            var obsoleteFolder = conn.Table <Folder>().Select((f) => f).ToList().Where((f) => f.SafePath.Equals(path.ToSafePath())).Select((f) => f).FirstOrDefault();

                            if (obsoleteFolder != null)
                            {
                                conn.Delete(obsoleteFolder);
                                CoreLogger.Current.Info("Removed the Folder {0}", path);
                            }
                        }
                        catch (Exception ex)
                        {
                            CoreLogger.Current.Error("Could not remove the Folder {0}. Exception: {1}", path, ex.Message);
                            result = RemoveFolderResult.Error;
                        }
                    }
                }
                catch (Exception ex)
                {
                    CoreLogger.Current.Error("Could not connect to the database. Exception: {0}", ex.Message);
                }
            });

            return(result);
        }
Esempio n. 6
0
        public async Task <RemoveFolderResult> RemoveFolderAsync(long folderId)
        {
            RemoveFolderResult result = await this.folderRepository.RemoveFolderAsync(folderId);

            this.FoldersChanged(this, new EventArgs());

            return(result);
        }
Esempio n. 7
0
        public async Task <RemoveFolderResult> RemoveFolderAsync(long folderId)
        {
            RemoveFolderResult result = await this.folderRepository.RemoveFolderAsync(folderId);

            return(result);
        }