public void Can_Watch_Directory_For_New_Items() { // Arrange IDirectory directory = new InMemoryDirectory(); var watcher = new DirectoryWatcher(directory); var watchPattern = "/some/dir/folder/newfile.*"; watcher.AddFilter(watchPattern); // bool notified = false; watcher.ItemAdded += (sender, e) => { DirectoryItemAddedEventArgs args = e.DirectoryItemEventArgs; var matchedFilters = e.MatchedFilters; IDirectoryItem newItem = args.NewItem; Assert.Equal("newfile.txt", newItem.Name); notified = true; }; directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "newfile.txt")); Assert.True(notified); notified = false; directory.AddFile("/some/dir/folder/", new StringFileInfo("shouldnt trigger", "anotherfile.txt")); Assert.False(notified); }
private void HandleDirectoryChanged(string path) { // Do these one at a time. lock (directoryChangeLock) { var info = new DirectoryInfo(path); IDirectoryItem item = GetFromLocalPath(path); if (item == null && info != null) { // New Directory! var parentDirectory = GetParentDirectory(info); if (parentDirectory != null) { LoggingService.LogDebug("NEW DIR !! " + path); parentDirectory.CreateSubDirectory(core.FileSystem, info.Name, info.FullName); } else { // No parent directory, this happens because // we can get events out of order. LoggingService.LogDebug("NEW DIR NO PARENT !! " + path); CreateDirectoryForLocalPath(path); } } } }
private void on_filesList_row_activated(object o, RowActivatedArgs e) { try { TreeIter iter; if (filesListStore.GetIter(out iter, e.Path) == true) { IDirectoryItem thisItem = (IDirectoryItem)filesListStore.GetValue(iter, 0); if (thisItem is IDirectory) { /* * if (selectedRows [currentPath] == null) * selectedRows.Add (currentPath, e.Path.ToString ()); * else * selectedRows [currentPath] = e.Path.ToString (); */ NavigateTo(PathUtil.Join(currentPath, thisItem.Name)); } else { DownloadItem(thisItem); } } } catch (Exception ex) { Core.LoggingService.LogError(ex); Gui.ShowErrorDialog(ex.Message); } }
public void Can_Add_Or_Update_File_In_A_Folder() { var rootFolder = new FolderDirectoryItem("root", null); bool addNotified = false; bool updateNotified = false; rootFolder.ItemAdded += (sender, e) => { DirectoryItemAddedEventArgs args = e; IDirectoryItem newItem = e.NewItem; Assert.Equal("foo.txt", newItem.Name); addNotified = true; }; var addedFile = rootFolder.AddOrUpdateFile(new StringFileInfo("hi there", "foo.txt")); Assert.True(addNotified); Assert.False(updateNotified); addNotified = false; addedFile.Updated += (sender, e) => { Assert.Equal("foo.txt", e.NewItem.Name); updateNotified = true; }; var updatedFile = rootFolder.AddOrUpdateFile(new StringFileInfo("hi there modified", "foo.txt")); Assert.True(updateNotified); Assert.False(addNotified); }
private void FileNameIconFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter) { IDirectoryItem item = (IDirectoryItem)model.GetValue(iter, 0); if (item is IDirectory) { if (item is NetworkDirectory) { (cell as CellRendererPixbuf).Pixbuf = networkIcon; } else if (item is NodeDirectory || item is MyDirectory) { var nodeId = (item is NodeDirectory) ? ((NodeDirectory)item).Node.NodeID : Core.MyNodeID; var avatar = Gui.AvatarManager.GetMiniAvatar(nodeId); (cell as CellRendererPixbuf).Pixbuf = avatar; } else { (cell as CellRendererPixbuf).Pixbuf = stockDirectoryPixbuf; } } else { /* * //ALREADY DOWNLOADING * foreach (ITransferItem transfer in network.Transfers) { * if (transfer.RemotePath == item.FullPath) { * (cell as CellRendererPixbuf).Pixbuf = ; * return; * } * }*/ (cell as CellRendererPixbuf).Pixbuf = stockFilePixbuf; } }
public void analyze_series_folder( IDirectoryItem folder ) { this._seriesFolder = folder; Factory.Instance.WindowFileBotPp.set_status_text( "Analysing " + folder.FullName + " ..." ); this._scanSeriesAnalyzer = new BackgroundWorker {WorkerReportsProgress = true}; this._scanSeriesAnalyzer.DoWork += this.ScanSeriesAnalyzerDoWork; this._scanSeriesAnalyzer.RunWorkerCompleted += this.ScanSeriesAnalyzerRunWorkerCompleted; this._scanSeriesAnalyzer.RunWorkerAsync(); }
private void filePropertiesMenuItem_Activated(object sender, EventArgs args) { IDirectoryItem item = GetSelectedItem(); if (item is IFile) { FilePropertiesWindow win = new FilePropertiesWindow((IFile)item); win.Show(); } }
///// <summary> ///// Updates an existing item in the folder. ///// </summary> ///// <param name="name"></param> ///// <param name="updatedItem"></param> ///// <returns></returns> //private IDirectoryItem UpdateItem(string name, IDirectoryItem updatedItem) //{ // var existingItem = GetChildDirectoryItem(name); // if (existingItem == null) // { // throw new InvalidOperationException("No such item exists."); // } // if (!existingItem.IsFolder) // { // var file = existingItem as IFile // } // Items[name] = updatedItem; // OnRaiseItemUpdated(existingItem, updatedItem); // return updatedItem; //} /// <summary> /// Adds an item to folder directory. /// </summary> /// <param name="name"></param> /// <returns></returns> private IDirectoryItem AddItem(string name, IDirectoryItem newItem) { if (Items.ContainsKey(name)) { throw new InvalidOperationException("Cannot add item to the directory, as an item with the same name already exists."); } Items.Add(name, newItem); OnRaiseItemAdded(newItem); return(newItem); }
public void check_series( IDirectoryItem directory ) { Factory.Instance.WindowFileBotPp.set_status_text( "Checking names in Series: " + directory.FullName ); this._checkSeasonDirectory = directory; this._worker = new BackgroundWorker(); this._worker.RunWorkerCompleted += this._worker_RunWorkerCompleted; this._worker.ProgressChanged += this._worker_ProgressChanged; this._worker.DoWork += this._worker_DoWork; this._worker.WorkerReportsProgress = true; this._worker.RunWorkerAsync(); }
private void FileInfoHashFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter) { IDirectoryItem item = (IDirectoryItem)model.GetValue(iter, 0); if (item is IFile) { (cell as CellRendererText).Text = ((IFile)item).InfoHash; } else { (cell as CellRendererText).Text = String.Empty; } }
public IFileDirectoryItem GetFile(string path) { IDirectoryItem result = GetItem(path); if (result != null) { if (!result.IsFolder) { var fileItem = ((IFileDirectoryItem)result); return(fileItem); } } return(null); }
public void Can_Rename_A_Folder_With_Child_Items() { // arrange // build a directory /root/child/grandchild var rootFolder = new FolderDirectoryItem("root", null); var childFolder = rootFolder.GetOrAddFolder("child"); var grandChildFolder = childFolder.GetOrAddFolder("grandchild"); // add a file /root/child/foo.txt var fileInfo = new StringFileInfo("contents", "foo.txt"); var someOtherFile = childFolder.AddFile(fileInfo); // add a file /root/child/grandchild/bar.txt var barFile = grandChildFolder.AddFile(new StringFileInfo("should trigger", "bar.txt")); // Subscribe to event handlers as we want to test if we are notified appropriately when // a folder is renamed. bool notified = false; bool fileNotified = false; // We are going to rename this folder, so we should see if we get notified that it is // updated. grandChildFolder.Updated += (sender, e) => { DirectoryItemUpdatedEventArgs args = e; IDirectoryItem oldItem = e.OldItem; IDirectoryItem newItem = e.NewItem; Assert.Equal("grandchild", oldItem.Name); Assert.Equal("grandchild-renamed", newItem.Name); notified = true; }; // We are going to rename the folder which this file lives in, which means this files // path will have changed. We should register to see if we get notified that it was updated. barFile.Updated += (sender, e) => { DirectoryItemUpdatedEventArgs args = e; IDirectoryItem oldItem = e.OldItem; IDirectoryItem newItem = e.NewItem; Assert.Equal("bar.txt", oldItem.Name); Assert.Equal("bar.txt", newItem.Name); Assert.Equal("root/child/grandchild/bar.txt", oldItem.Path); Assert.Equal("root/child/grandchild-renamed/bar.txt", newItem.Path); fileNotified = true; }; grandChildFolder.Rename("grandchild-renamed"); Assert.True(notified); Assert.True(fileNotified); }
/// <summary> /// Returns an item from the directory based on its path, if it exists. /// </summary> /// <param name="path"></param> /// <param name="item"></param> /// <returns></returns> public IDirectoryItem GetItem(string path) { //IDirectoryItem result = null; if (string.IsNullOrWhiteSpace(path)) { // result = this._rootFolder; // return root folder if path is null or empty. return(this._rootFolder); } var segments = PathUtils.SplitPathIntoSegments(path); IDirectoryItem currentDirectoryItem = _rootFolder; // if the root folder has a name then all paths must start // with this name. int segmentStart = 0; if (!String.IsNullOrWhiteSpace(_rootFolder.Name)) { if (segments[0] != _rootFolder.Name) { return(null); } segmentStart = 1; // skip the first segment as it matches the root folder rname. } for (int i = segmentStart; i < segments.Length; i++) { var segment = segments[i]; if (currentDirectoryItem.IsFolder) { var folderItem = currentDirectoryItem as IFolderDirectoryItem; currentDirectoryItem = folderItem.NavigateToNext(segment); } else { // the path of the item leads to a non existing directory. return(null); } if (currentDirectoryItem == null) { // the item doesn't exist in the directory. return(null); } } return(currentDirectoryItem); }
public void ReplaceItem(IDirectoryItem existingItem, IFileInfo newItem) { if (Items.ContainsKey(newItem.Name)) { throw new InvalidOperationException("Cannot rename item as an item already exists with the same name."); } if (existingItem != null) { Items.Remove(existingItem.Name); } Items[newItem.Name] = existingItem; existingItem.ApplyUpdate(newItem); }
public IFolderDirectoryItem GetFolder(string path) { IDirectoryItem result = GetItem(path); if (result != null) { if (result.IsFolder) { var item = ((IFolderDirectoryItem)result); return(item); } } return(null); }
// public event EventHandler<DirectoryItemDeletedEventArgs> ItemDeleted; #endregion protected void OnRaiseItemUpdated(IDirectoryItem oldItem) { // Make a temporary copy of the event to avoid possibility of // a race condition if the last subscriber unsubscribes // immediately after the null check and before the event is raised. EventHandler <DirectoryItemUpdatedEventArgs> handler = Updated; // Event will be null if there are no subscribers if (handler != null) { var args = new DirectoryItemUpdatedEventArgs(oldItem, this); // Use the () operator to raise the event. handler(this, args); } }
public void Can_Add_A_File_To_A_Folder() { var rootFolder = new FolderDirectoryItem("root", null); bool notified = false; rootFolder.ItemAdded += (sender, e) => { DirectoryItemAddedEventArgs args = e; IDirectoryItem newItem = e.NewItem; Assert.Equal("child", newItem.Name); notified = true; }; var childFolder = rootFolder.GetOrAddFolder("child"); Assert.True(notified); }
private void DownloadItem(IDirectoryItem item) { if (item is ILocalDirectoryItem) { throw new Exception("You cannot download files from yourself."); } if (item is RemoteFile) { RemoteFile remoteFile = (RemoteFile)item; Network network = remoteFile.Network; network.DownloadFile(remoteFile.Node, remoteFile); } else { throw new Exception("Downloading directories is not currently supported."); } }
public void Can_Delete_A_Folder() { var rootFolder = new FolderDirectoryItem("root", null); var childFolder = rootFolder.GetOrAddFolder("child"); bool notified = false; childFolder.Deleted += (sender, e) => { DirectoryItemDeletedEventArgs args = e; IDirectoryItem deletedItem = e.DeletedItem; Assert.True(deletedItem.IsFolder); Assert.Equal("child", deletedItem.Name); notified = true; }; childFolder.Delete(); Assert.True(notified); }
private void HandleFileChanged(string path) { var info = new FileInfo(path); IDirectoryItem item = GetFromLocalPath(path); if (item == null) { // New File! var parentDirectory = GetParentDirectory(info); LoggingService.LogDebug("NEW FILE!! IN " + parentDirectory.FullPath); } else { // Updated File! LoggingService.LogWarning("NOTE: Changed file detected, however handling this is not currently supported. Path: {0}", item.FullPath); } }
public void on_mnuFileDownload_activate(object o, EventArgs e) { try { TreeIter iter; if (filesList.Selection.GetSelected(out iter) == true) { IDirectoryItem thisItem = (IDirectoryItem)filesListStore.GetValue(iter, 0); DownloadItem(thisItem); } else { Gui.ShowMessageDialog("Nothing selected"); } } catch (Exception ex) { Core.LoggingService.LogError(ex); Gui.ShowErrorDialog(ex.Message); } }
private void FileNameTextFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter) { IDirectoryItem item = (IDirectoryItem)model.GetValue(iter, 0); if (item is IDirectory) { if (item is MyDirectory) { (cell as CellRendererText).Text = "My Shared Files"; } else if (item is NodeDirectory) { Node node = ((NodeDirectory)item).Node; if (node != null) { (cell as CellRendererText).Text = node.NickName; } else { (cell as CellRendererText).Text = "<error>"; } } else if (item is NetworkDirectory) { Network network = ((NetworkDirectory)item).Network; if (network != null) { (cell as CellRendererText).Text = network.NetworkName; } else { (cell as CellRendererText).Text = "AAHHH"; } } else { (cell as CellRendererText).Text = item.Name; } } else { (cell as CellRendererText).Text = item.Name; } }
private void clean_series_season_duplicates( IDirectoryItem directory ) { var checklist = new List< IFileItem >(); foreach ( var fileitem in directory.Items.OfType< IFileItem >() ) { foreach ( var checkitem in checklist ) { if ( checkitem.ShortName != fileitem.ShortName ) { continue; } Factory.Instance.ItemProvider.DuplicateFiles.Enqueue( new DuplicateUpdate {Directory = directory, FileA = checkitem, FileB = fileitem} ); } checklist.Add( fileitem ); } }
public void Can_Rename_A_Folder() { var rootFolder = new FolderDirectoryItem("root", null); var childFolder = rootFolder.GetOrAddFolder("child"); var fileInfo = new StringFileInfo("contents", "foo.txt"); var someOtherFile = childFolder.AddFile(fileInfo); bool notified = false; childFolder.Updated += (sender, e) => { DirectoryItemUpdatedEventArgs args = e; IDirectoryItem oldItem = e.OldItem; IDirectoryItem newItem = e.NewItem; Assert.Equal("child", oldItem.Name); Assert.Equal("child-renamed", newItem.Name); notified = true; }; childFolder.Rename("child-renamed"); Assert.True(notified); Assert.Equal("root/child-renamed/foo.txt", someOtherFile.Path); }
private void FileSizeFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter) { IDirectoryItem item = (IDirectoryItem)model.GetValue(iter, 0); //if (item is IDirectory & item.Parent.Parent == Core.FileSystem.RootDirectory) // (cell as CellRendererText).Text = network.Nodes [item.Name].GetAmountSharedString (); //else if (item is IDirectory) { if (item is LocalDirectory || (item is RemoteDirectory && ((RemoteDirectory)item).State == RemoteDirectoryState.ContentsReceived)) { (cell as CellRendererText).Text = String.Format("{0} items", item.Size.ToString()); } else { (cell as CellRendererText).Text = String.Empty; } } else if (item is IFile) { (cell as CellRendererText).Text = FileFind.Common.FormatBytes(item.Size); } }
public void Can_Watch_Directory_For_Deleted_Items() { // Arrange IDirectory directory = new InMemoryDirectory(); directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "foo.txt")); directory.AddFile("/some/dir/folder/", new StringFileInfo("hi", "bar.txt")); var watcher = new DirectoryWatcher(directory); var watchPattern = "/some/dir/folder/foo.txt"; watcher.AddFilter(watchPattern); // bool notified = false; watcher.ItemDeleted += (sender, e) => { DirectoryItemDeletedEventArgs args = e.DirectoryItemEventArgs; var matchedFilters = e.MatchedFilters; IDirectoryItem deletedItem = args.DeletedItem; Assert.Equal("foo.txt", deletedItem.Name); notified = true; }; var fooFile = directory.GetFile("/some/dir/folder/foo.txt"); fooFile.Delete(); Assert.True(notified); notified = false; var barFile = directory.GetFile("/some/dir/folder/bar.txt"); barFile.Delete(); Assert.False(notified); }
private void filesList_ButtonPressEvent(object sender, ButtonPressEventArgs args) { TreePath path; if (filesList.GetPathAtPos((int)args.Event.X, (int)args.Event.Y, out path)) { filesList.Selection.SelectPath(path); } else { filesList.Selection.UnselectAll(); } IDirectoryItem item = GetSelectedItem(); if (args.Event.Button == 3) { if (item is IFile) { resultPopupMenu.ShowAll(); resultPopupMenu.Popup(); } } }
private void scan_folder( IDirectoryItem directory ) { foreach ( var item in directory.Items.OfType< IDirectoryItem >() ) { this.scan_folder( item ); } foreach ( var item in directory.Items.OfType< IFileItem >().Where( item => item.Missing != true ) ) { this.scan_file( item ); } }
public FfmpegCorruptWorker( IDirectoryItem directory ) { this._brokenFiles = new ConcurrentQueue< IFileItem >(); this._directory = directory; }
private void clean_series_season_files_check_episode_name( IDirectoryItem directory, IItem subdirectory, IFileItem item ) { if ( Factory.Instance.Tvdb == null ) { return; } var cSeasonNum = int.Parse( subdirectory.FullName.Substring( 7 ).Trim() ); var series = Factory.Instance.Tvdb.get_series_by_name( directory.FullName ); if ( series == null ) { return; } if ( series.has_seasons( cSeasonNum ) == false ) { return; } var season = series.get_season( cSeasonNum ); var episodes = season.get_episodes(); var clean = false; foreach ( var episode in episodes ) { var epnameclean = episode.get_episode_name().ToLower(); epnameclean = epnameclean.Replace( ":", "" ); epnameclean = epnameclean.Replace( "?", "" ); epnameclean = Regex.Replace( epnameclean, ".+", "." ); if ( item.FullName.ToLower().Contains( epnameclean ) ) { clean = true; break; } } if ( clean == false ) { Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = item, SuggestName = ""} ); } }
public FsPoller( IDirectoryItem directory ) { this._directory = directory; this._directoryInfo = new DirectoryInfo( this._directory.Path ); Fspollers.Add( this ); }
public DirectoryItemDeletedEventArgs(IDirectoryItem deletedItem) { DeletedItem = deletedItem; }
public FfmpegConvertWorker( IDirectoryItem directory ) { this._unconvertedFiles = new ConcurrentQueue< IFileItem >(); this._directory = directory; }
private void clean_series_top_level_directories( IDirectoryItem directory ) { if ( directory?.Items == null ) { return; } foreach ( var inode in directory.Items.OfType< IDirectoryItem >() ) { if ( Regex.IsMatch( inode.FullName, @"^Season ([0-9]+)" ) ) { continue; } Factory.Instance.LogLines.Enqueue( @"Dirty directory name : " + inode.Path ); Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = inode, File = null, SuggestName = ""} ); } if ( Factory.Instance.Tvdb == null ) { return; } foreach ( var series in Factory.Instance.Tvdb.get_series() ) { if ( String.Compare( directory.FullName, series.get_name(), StringComparison.Ordinal ) != 0 ) { continue; } foreach ( var season in series.get_seasons() ) { var check = @"Season " + season.get_season_num(); if ( Factory.Instance.ItemProvider.contains_child( directory, check ) ) { continue; } var missingseason = new DirectoryItem {FullName = check, Path = directory.Path + "\\" + check, Missing = true, Parent = directory}; foreach ( var episode in season.get_episodes() ) { var epnum = season.get_season_num() + "x" + string.Format( "{0:00}", episode.get_episode_num() ); var fileitem = new FileItem {FullName = directory.FullName + " - " + epnum + " - " + episode.get_episode_name(), Missing = true, Parent = missingseason, Path = directory.Path + "\\" + check + "\\" + directory.FullName + " - " + epnum + " - " + episode.get_episode_name()}; missingseason.Items.Add( fileitem ); var torrent = this.clean_series_season_files_find_torrent( series.ImdbId, episode.get_episode_num(), season.get_season_num() ); if ( torrent.Epname != null && String.CompareOrdinal( torrent.Epname, "" ) != 0 ) { fileitem.Torrent = true; fileitem.TorrentLink = torrent.Magnetlink; } } var di = new DirectoryInsert {Directory = directory, SubDirectory = missingseason, Seasonnum = season.get_season_num()}; Factory.Instance.ItemProvider.NewDirectoryUpdates.Enqueue( di ); } break; } }
private void clean_series_top_level_files( IDirectoryItem directory ) { foreach ( var item in directory.Items.OfType< IFileItem >() ) { Factory.Instance.LogLines.Enqueue( @"Found files at top level " + directory.FullName ); if ( String.Compare( item.FullName, "Thumbs.db", StringComparison.Ordinal ) == 0 ) { Factory.Instance.ItemProvider.DirectoryDeletions.Enqueue( new DeletionUpdate {Directory = directory, File = item} ); continue; } var match = Regex.Match( item.FullName, "^" + Regex.Escape( directory.FullName ) + "\\.? - (\\d+)x[0-9]+" ); if ( match.Success ) { var seasonNum = int.Parse( match.Groups[ 1 ].ToString() ); var checkdir = directory.Path + "\\Season " + seasonNum; item.BadLocation = true; if ( File.Exists( checkdir ) == false ) { Factory.Instance.LogLines.Enqueue( @"Created season directory: " + checkdir ); } if ( File.Exists( checkdir + "\\" + item.FullName ) ) { item.NewPathExists = true; } Factory.Instance.ItemProvider.BadLocationFiles.Enqueue( new BadLocationUpdate {Directory = directory, File = item, NewPath = checkdir + "\\" + item.FullName} ); } else { Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = item, SuggestName = ""} ); } } }
private void clean_series_season_files( IDirectoryItem directory ) { foreach ( var subdirectory in directory.Items.OfType< IDirectoryItem >() ) { string seasonNum; try { seasonNum = subdirectory.FullName?.Length < 8 ? "99" : subdirectory.FullName?.Substring( 7 ).Trim(); } catch ( Exception ex ) { Factory.Instance.LogLines.Enqueue( ex.Message ); Factory.Instance.LogLines.Enqueue( ex.StackTrace ); Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = subdirectory, File = null, SuggestName = ""} ); seasonNum = "99"; } foreach ( var file in subdirectory.Items.OfType< IFileItem >() ) { if ( String.Compare( file.FullName, "Thumbs.db", StringComparison.Ordinal ) == 0 ) { Factory.Instance.ItemProvider.DirectoryDeletions.Enqueue( new DeletionUpdate {Directory = subdirectory, File = file} ); continue; } var test1 = @"^" + Regex.Escape( directory.FullName ) + @"\s+-\s+(" + seasonNum + @")x[0-9]{2}"; var test2 = @"^" + Regex.Escape( directory.FullName ) + @"\s+-\s+(" + seasonNum + @")xSpecial\s+[0-9]+"; if ( Regex.IsMatch( file.FullName, test1, RegexOptions.IgnoreCase ) || Regex.IsMatch( file.FullName, test2, RegexOptions.IgnoreCase ) ) { this.clean_series_season_files_check_episode_name( directory, subdirectory, file ); this.clean_series_season_file_check_extra( directory, subdirectory, file ); continue; } if ( Regex.IsMatch( file.FullName, @"^" + Regex.Escape( directory.FullName ) + @"\.? - (\[(.*?)\]).*?(\[(.*)\])", RegexOptions.IgnoreCase ) ) { continue; } if ( Regex.IsMatch( file.FullName, @"^" + Regex.Escape( directory.FullName ) + @".*" ) == false ) { Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = file, SuggestName = ""} ); } else if ( Regex.IsMatch( file.FullName, @".*?(" + seasonNum + @")x([0-9]{2}|(" + seasonNum + @")xSpecial\s+?[0-9]+)" ) == false ) { const string stest1 = @".*?([0-9]+)x([0-9]{2})"; const string stest2 = @"([0-9]+)xSpecial\s+?([0-9]+)"; var match1 = Regex.Match( file.FullName, stest1 ); var match2 = Regex.Match( file.FullName, stest2 ); if ( !match1.Success && !match2.Success ) { Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = file, SuggestName = ""} ); continue; } var seasonint = match1.Success ? match1.Groups[ 1 ].Value : match2.Groups[ 1 ].Value; var newdirectory = directory.Path + "\\Season " + seasonint; var newfilelocation = directory.Path + "\\Season " + seasonint + "\\" + file.FullName; Factory.Instance.ItemProvider.BadLocationFiles.Enqueue( new BadLocationUpdate {Directory = subdirectory, File = file, NewPath = newfilelocation} ); if ( Directory.Exists( newdirectory ) ) { continue; } var missingdirectory = new DirectoryItem {Parent = directory, FullName = "Season " + seasonint, Path = newdirectory}; var di = new DirectoryInsert {Directory = directory, SubDirectory = missingdirectory, Seasonnum = int.Parse( seasonint )}; Factory.Instance.ItemProvider.NewDirectoryUpdates.Enqueue( di ); } } this.clean_series_season_files_find_missing( directory, subdirectory ); this.clean_series_season_duplicates( directory ); } }
private void _worker_DoWork( object sender, DoWorkEventArgs e ) { if ( this._checkSeasonDirectory == null ) { this._toCheckCount = Factory.Instance.ItemProvider.Items.Count; foreach ( var series in Factory.Instance.ItemProvider.Items ) { if ( this._stop ) { break; } this.check_series_names( series ); this._checkedCount++; this._lastChecked = ( IDirectoryItem ) series; this._worker.ReportProgress( 1 ); } return; } this._toCheckCount = 1; this._checkedCount++; this.check_series_names( this._checkSeasonDirectory ); this._lastChecked = this._checkSeasonDirectory; this._worker.ReportProgress( 1 ); }
public MediaInfoWorker( IDirectoryItem directory ) { this._brokenFiles = new ConcurrentQueue< IFileItem >(); this._directory = directory; }
public FsPoller() { this._directory = null; this._directoryInfo = new DirectoryInfo( Factory.Instance.ScanLocation ); Fspollers.Add( this ); }
public override bool Rename( string newName, IDirectoryItem sender = null ) { var newpath = System.IO.Path.GetDirectoryName( this.Path ) + "\\" + newName; if ( sender == null ) { if ( System.IO.Directory.Exists( newpath ) ) { Factory.Instance.LogLines.Enqueue( "Unable to rename, new file name exists" ); return false; } try { File.Move( this.Path, newpath ); this.Path = newpath; this.FullName = newName; this.Extension = System.IO.Path.GetExtension( this.Path ).Substring( 1 ); this.ShortName = System.IO.Path.GetFileNameWithoutExtension( this.Path ); Factory.Instance.ItemProvider.move_item( this, ( IDirectoryItem ) this.Parent ); return true; } catch ( Exception ex ) { Factory.Instance.LogLines.Enqueue( ex.Message ); Factory.Instance.LogLines.Enqueue( ex.StackTrace ); return false; } } newpath = sender.Path + "\\" + this.FullName; this.Path = newpath; return true; }
private void clean_series_season_file_check_extra( IDirectoryItem directory, IItem subdirectory, IFileItem item ) { if ( Factory.Instance.Tvdb == null ) { return; } var cSeasonNum = int.Parse( subdirectory.FullName.Substring( 7 ).Trim() ); var series = Factory.Instance.Tvdb.get_series_by_name( directory.FullName ); if ( series == null ) { return; } if ( series.has_seasons( cSeasonNum ) == false ) { return; } const string stest1 = @".*?([0-9]+)x([0-9]{2})"; const string stest2 = @"([0-9]+)xSpecial\s+?([0-9]+)"; var match1 = Regex.Match( item.FullName, stest1 ); var match2 = Regex.Match( item.FullName, stest2 ); var epint = match1.Success ? match1.Groups[ 2 ].Value : match2.Groups[ 2 ].Value; if ( series.get_season( cSeasonNum ).get_episodes().Any( episode => episode.get_episode_num() == int.Parse( epint ) ) ) { return; } Factory.Instance.ItemProvider.ExtraFiles.Enqueue( new ExtraFileUpdate {Directory = directory, File = item} ); }
public virtual bool Rename( string newName, IDirectoryItem sender = null ) { return false; }
private void clean_series_season_files_find_missing( IDirectoryItem directory, IDirectoryItem subdirectory ) { if ( Factory.Instance.Tvdb == null ) { return; } int cSeasonNum; try { if ( subdirectory.FullName.ToLower().Contains( "season " ) == false ) { Factory.Instance.LogLines.Enqueue( "Unable to determine season number: " + subdirectory.Path ); Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = null, SuggestName = ""} ); return; } if ( Regex.IsMatch( subdirectory.FullName.Substring( 7 ).Trim(), @"^\d+$", RegexOptions.IgnoreCase ) == false ) { Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = null, SuggestName = ""} ); return; } cSeasonNum = int.Parse( subdirectory.FullName.Substring( 7 ).Trim() ); } catch ( Exception ex ) { Factory.Instance.LogLines.Enqueue( ex.Message ); Factory.Instance.LogLines.Enqueue( ex.StackTrace ); Factory.Instance.LogLines.Enqueue( "Unable to determine season number: " + subdirectory.Path ); Factory.Instance.ItemProvider.BadNameFiles.Enqueue( new BadNameUpdate {Directory = directory, File = null, SuggestName = ""} ); return; } var series = Factory.Instance.Tvdb.get_series_by_name( directory.FullName ); if ( series == null ) { return; } if ( series.has_seasons( cSeasonNum ) == false ) { return; } var episodes = series.get_season( cSeasonNum ).get_episodes(); foreach ( var episode in episodes ) { var epnum = cSeasonNum + "x" + string.Format( "{0:00}", episode.get_episode_num() ); var found = subdirectory.Items.OfType< IFileItem >().Any( file => Regex.IsMatch( file.FullName, ".*?" + epnum + ".*?" ) ); if ( found ) { continue; } var newfile = new FileItem {FullName = directory.FullName + " - " + epnum + " - " + episode.get_episode_name(), Parent = subdirectory, Missing = true}; var fi = new FileInsert {Directory = subdirectory, File = newfile, EpisodeNum = episode.get_episode_num()}; var torrent = this.clean_series_season_files_find_torrent( series.ImdbId, episode.get_episode_num(), cSeasonNum ); if ( torrent.Epname != null && String.CompareOrdinal( torrent.Epname, "" ) != 0 ) { newfile.Torrent = true; newfile.TorrentLink = torrent.Magnetlink; } Factory.Instance.ItemProvider.NewFilesUpdates.Enqueue( fi ); } }
private void DownloadItem(IDirectoryItem item) { if (item is ILocalDirectoryItem) { throw new Exception ("You cannot download files from yourself."); } if (item is RemoteFile) { RemoteFile remoteFile = (RemoteFile)item; Network network = remoteFile.Network; network.DownloadFile(remoteFile.Node, remoteFile); } else { throw new Exception("Downloading directories is not currently supported."); } }
private void FileTypeFunc(TreeViewColumn column, CellRenderer cell, TreeModel model, TreeIter iter) { IDirectoryItem item = (IDirectoryItem)model.GetValue(iter, 0); (cell as CellRendererText).Text = item.Type; }
public void Can_Delete_A_Folder_Containing_Items() { // given /root/child/grandchild/foo.txt // deleting the "child" folder should also delete all descendents which are // "grandchild" folder, and foo.txt. var rootFolder = new FolderDirectoryItem("root", null); var childFolder = rootFolder.GetOrAddFolder("child"); var grandchildFolder = childFolder.GetOrAddFolder("grandchild"); var fileInfo = new StringFileInfo("contents", "foo.txt"); var fileItem = grandchildFolder.AddFile(fileInfo); // Should get notified when each folder and file is deleted. bool childDeletionNotified = false; childFolder.Deleted += (sender, e) => { DirectoryItemDeletedEventArgs args = e; IDirectoryItem deletedItem = e.DeletedItem; Assert.True(deletedItem.IsFolder); Assert.Equal("child", deletedItem.Name); childDeletionNotified = true; }; bool grandchildDeletionNotified = false; grandchildFolder.Deleted += (sender, e) => { DirectoryItemDeletedEventArgs args = e; IDirectoryItem deletedItem = e.DeletedItem; Assert.True(deletedItem.IsFolder); Assert.Equal("grandchild", deletedItem.Name); grandchildDeletionNotified = true; }; bool fileDeletionNotified = false; fileItem.Deleted += (sender, e) => { DirectoryItemDeletedEventArgs args = e; IDirectoryItem deletedItem = e.DeletedItem; Assert.False(deletedItem.IsFolder); Assert.Equal("foo.txt", deletedItem.Name); fileDeletionNotified = true; }; childFolder.Delete(true); Assert.True(childDeletionNotified); Assert.True(grandchildDeletionNotified); Assert.True(fileDeletionNotified); // the deleted items should have had their fileinfo's set to not exist. Assert.False(childFolder.FileInfo.Exists); Assert.False(grandchildFolder.FileInfo.Exists); Assert.False(fileItem.FileInfo.Exists); // verify child items are no longer in directory. var item = rootFolder.NavigateToNext("child"); Assert.Null(item); item = childFolder.NavigateToNext("grandchild"); Assert.Null(item); item = grandchildFolder.NavigateToNext("foo.txt"); Assert.Null(item); }
public DirectoryItemUpdatedEventArgs(IDirectoryItem oldItem, IDirectoryItem newItem) { OldItem = oldItem; NewItem = newItem; }
public DirectoryItemAddedEventArgs(IDirectoryItem newItem) { NewItem = newItem; }
public override bool Rename( string newName, IDirectoryItem sender = null ) { var currentPath = System.IO.Directory.GetParent( this.Path ); var newpath = currentPath.FullName + "\\" + newName; if ( sender != null ) { this.Path = sender.Path + "\\" + this.FullName; foreach ( var child in this.Items ) { child.Rename( "", this ); } return true; } if ( System.IO.Directory.Exists( newpath ) ) { Factory.Instance.LogLines.Enqueue( "Unable to rename, new directory name exists" ); return false; } try { System.IO.Directory.Move( this.Path, newpath ); this.Path = newpath; this.FullName = newName; Factory.Instance.ItemProvider.move_item( this ); this.Polling = false; this.Polling = true; foreach ( var child in this.Items ) { child.Rename( "", this ); } return true; } catch ( Exception ex ) { Factory.Instance.LogLines.Enqueue( ex.Message ); Factory.Instance.LogLines.Enqueue( ex.StackTrace ); return false; } }