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;
}
}
