public bool Exists(string path, FileSystemItem type = FileSystemItem.Both)
{
path = PreparePath(path);
if (type != FileSystemItem.Directory && File.Exists(path))
return true;
if (type != FileSystemItem.File && Directory.Exists(path))
return true;
return false;
}
public bool Delete(string path, FileSystemItem type = FileSystemItem.Both)
{
path = PreparePath(path);
if (type != FileSystemItem.Directory && File.Exists(path))
{
File.Delete(path);
return true;
}
if (type != FileSystemItem.File && Directory.Exists(path))
{
RecursiveDeleteDirectory(path);
return true;
}
return false;
}
public CacheItem GetCacheEntry(FileSystemItem item)
{
CacheComplexKey cacheKey;
return(GetCacheEntry(item, out cacheKey));
}
public MatchedFileSystemItem(FileSystemItem fileSystemItem, MatchString matchedString)
{
Name = fileSystemItem.Name;
FullPath = fileSystemItem.FullPath;
MatchedItemName = matchedString;
}
public override void CopyTo(FileSystemItem item)
{
var destinationPath = PrepareCopyTo(item);
LongPathFile.Copy(Path, destinationPath, true);
}
private bool IsCopy(FileSystemItem a, FileSystemItem b)
{
//TODO
return(a.Name == b.Name);
}
public FileSystemItem MoveTo(FileSystemItem item)
{
UnderlyingDirectory.MoveTo(item);
return item;
}
public FileSystemItem MoveTo(FileSystemItem item)
{
Contract.Requires(item != null);
throw new System.NotImplementedException();
}
public MatchedFileSystemItem(FileSystemItem fileSystemItem, MatchString matchedString)
{
Name = fileSystemItem.Name;
FullPath = fileSystemItem.FullPath;
MatchedItemName = matchedString;
}
public FileSystemItem(FileSystemItem parent)
{
this.parent = parent;
}
public FileSystemItem()
{
parent = null;
}
private void TagList_LoadPath(FileSystemItem directory)
{
//Set
currentDirectory = directory;
selectedId = TagId.Null;
//Build Directory Path
directoryBox.Text = string.Empty;
FileSystemItem parent = directory.Parent;
while (parent != null)
{
directoryBox.Text = $@"{parent.Name}\" + directoryBox.Text; parent = parent.Parent;
}
directoryBox.Text += directory.Name;
//Check
if (directory.Parent != null)
{
TagList.Items.Add(new ListViewItem("...")
{
Tag = directory.Parent, ImageIndex = 0
});
}
//Loop
foreach (FileSystemItem item in directory.Children)
{
//Get Length
float length = item.Length;
string suffix = "B";
//Simplify String
if (length > 1024) //Kibibyte
{
length /= 1024;
suffix = "KiB";
}
if (length > 1024) //Mebibyte
{
length /= 1024;
suffix = "MiB";
}
if (length > 1024) //Gibibyte
{
length /= 1024;
suffix = "GiB";
}
if (length > 1024) //Tebibyte
{
length /= 1024;
suffix = "TiB";
}
//Prepare
string[] parts = new string[4];
parts[0] = item.Name;
parts[1] = item.Type;
parts[2] = item.Length > 0 ? $"{length:0} {suffix}" : string.Empty;
parts[3] = item.ID != 0 ? item.ID.ToString() : string.Empty;
//Create
ListViewItem listItem = new ListViewItem(parts);
listItem.ImageIndex = item.IsFolder ? 0 : 1;
listItem.Tag = item;
//Add
TagList.Items.Add(listItem);
}
}
public FileSystemItem MoveTo(FileSystemItem item)
{
UnderlyingDirectory.MoveTo(item);
return(item);
}
public void CopyTo(FileSystemItem item)
{
UnderlyingDirectory.CopyTo(item);
}
public abstract void CopyTo(FileSystemItem item);
/// <inheritdoc/>
protected override IEnumerable <FileSystemItem> EnumerateItemsImpl(UPath path, SearchOption searchOption, SearchPredicate?searchPredicate)
{
// Internal method used to retrieve the list of search locations
List <SearchLocation> GetSearchLocations(UPath basePath)
{
var locations = new List <SearchLocation>();
var matchedMount = false;
foreach (var kvp in _mounts)
{
// Check if path partially matches a mount name
var remainingPath = GetRemaining(basePath, kvp.Key);
if (!remainingPath.IsNull && remainingPath != UPath.Root)
{
locations.Add(new SearchLocation(this, basePath, remainingPath));
continue;
}
if (!matchedMount)
{
// Check if path fully matches a mount name
remainingPath = GetRemaining(kvp.Key, basePath);
if (!remainingPath.IsNull)
{
matchedMount = true; // don't check other mounts, we don't want to merge them together
if (kvp.Value.DirectoryExists(remainingPath))
{
locations.Add(new SearchLocation(kvp.Value, kvp.Key, remainingPath));
}
}
}
}
if (!matchedMount && Fallback != null && Fallback.DirectoryExists(basePath))
{
locations.Add(new SearchLocation(Fallback, UPath.Null, basePath));
}
return(locations);
}
var directoryToVisit = new List <UPath> {
path
};
var entries = new HashSet <UPath>();
var sortedDirectories = new SortedSet <UPath>();
var first = true;
while (directoryToVisit.Count > 0)
{
var pathToVisit = directoryToVisit[0];
directoryToVisit.RemoveAt(0);
var dirIndex = 0;
entries.Clear();
sortedDirectories.Clear();
var locations = GetSearchLocations(pathToVisit);
// Only need to search within one filesystem, no need to sort or do other work
if (locations.Count == 1 && locations[0].FileSystem != this && (!first || searchOption == SearchOption.AllDirectories))
{
var last = locations[0];
foreach (var item in last.FileSystem.EnumerateItems(last.Path, searchOption, searchPredicate))
{
var localItem = item;
localItem.Path = CombinePrefix(last.Prefix, item.Path);
if (entries.Add(localItem.Path))
{
yield return(localItem);
}
}
}
else
{
for (var i = locations.Count - 1; i >= 0; i--)
{
var location = locations[i];
var fileSystem = location.FileSystem;
var searchPath = location.Path;
if (fileSystem == this)
{
// List a single part of a mount name, queue it to be visited if needed
var mountPart = new UPath(searchPath.GetFirstDirectory(out _)).ToRelative();
var mountPath = location.Prefix / mountPart;
var item = new FileSystemItem(this, mountPath, true);
if (searchPredicate == null || searchPredicate(ref item))
{
if (entries.Add(item.Path))
{
yield return(item);
}
}
if (searchOption == SearchOption.AllDirectories)
{
sortedDirectories.Add(mountPath);
}
}
else
{
// List files in the mounted filesystems, merged and sorted into one list
foreach (var item in fileSystem.EnumerateItems(searchPath, SearchOption.TopDirectoryOnly, searchPredicate))
{
var publicName = CombinePrefix(location.Prefix, item.Path);
if (entries.Add(publicName))
{
var localItem = item;
localItem.Path = publicName;
yield return(localItem);
if (searchOption == SearchOption.AllDirectories && item.IsDirectory)
{
sortedDirectories.Add(publicName);
}
}
}
}
}
}
if (first)
{
if (locations.Count == 0 && path != UPath.Root)
{
throw NewDirectoryNotFoundException(path);
}
first = false;
}
// Enqueue directories and respect order
foreach (var nextDir in sortedDirectories)
{
directoryToVisit.Insert(dirIndex++, nextDir);
}
}
}
public abstract void CopyTo(FileSystemItem item);
public override Stream ReadFile(FileManagerFile file)
{
FileSystemItem fileItem = FindFileItem(file);
return(new MemoryStream(fileItem.Content.ToArray()));
}
protected override Clue MakeClueImpl(FileSystemItem <DirectoryInfo> input, Guid accountId)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
var value = input.Item;
var uriBuilder = new FileSystemInfoUriBuilder();
var clue = _factory.Create(EntityType.Files.Directory, uriBuilder.GetUri(value).AbsoluteUri, accountId);
var data = clue.Data.EntityData;
var uri = uriBuilder.GetUri(value);
data.Name = value.Name; // + crawl.FileSystemInfo.Extension;
data.DisplayName = value.Name;
data.Uri = uri;
data.Culture = CultureInfo.InvariantCulture;
var attributes = value.Attributes;
var isReadOnly = (attributes & FileAttributes.ReadOnly) == FileAttributes.ReadOnly;
var isHidden = (attributes & FileAttributes.Hidden) == FileAttributes.Hidden;
var isArchive = (attributes & FileAttributes.Archive) == FileAttributes.Archive;
var isSystem = (attributes & FileAttributes.System) == FileAttributes.System;
var vocab = new DirectoryInfoVocabulary();
var securityVocab = new FileSecurityVocabulary();
data.Properties[vocab.IsReadOnly] = isReadOnly.ToString();
data.Properties[vocab.IsHidden] = isHidden.ToString();
data.Properties[vocab.IsArchive] = isArchive.ToString();
data.Properties[vocab.IsSystem] = isSystem.ToString();
data.Properties[securityVocab.OwnerSID] = input.Owner.PrintIfAvailable(v => v.Sid.ToString());
data.Properties[securityVocab.OwnerNTAccount] = input.Owner.PrintIfAvailable(v => v.Account?.ToString());
data.Properties[securityVocab.OwnerDisplayName] = input.Owner.PrintIfAvailable(v => v.Principal?.DisplayName);
data.Properties[vocab.CreationTimeUtc] = value.CreationTimeUtc.ToString("o");
data.Properties[vocab.LastWriteTimeUtc] = value.LastWriteTimeUtc.ToString("o");
clue.ValidationRuleSuppressions.AddRange(new[]
{
RuleConstants.METADATA_002_Uri_MustBeSet
});
try
{
if (IsDirectoryInfoEntry(input, value.FullName))
{
_factory.CreateOutgoingEntityReference(clue, EntityType.Infrastructure.Host.Computer, EntityEdgeType.Parent, Environment.MachineName, p => p);
}
else if (value.Parent != null)
{
var parentUri = uriBuilder.GetUri(value.Parent);
_factory.CreateOutgoingEntityReference(clue, EntityType.Files.Directory, EntityEdgeType.Parent, parentUri, p => p.AbsoluteUri, p => value.Parent.Name);
}
}
catch (PathTooLongException)
{
}
if (input.Owner != null && input.Owner.Sid != null)
{
_factory.CreateOutgoingEntityReference(clue, EntityType.Infrastructure.User, EntityEdgeType.OwnedBy, input.Owner, p => p.Sid.ToString(), p => p?.Principal?.DisplayName ?? p?.Principal?.Name ?? p?.Principal?.SamAccountName ?? p?.Account?.ToString());
}
return(clue);
}
public override DateTime GetLastWriteTime(FileManagerFile file)
{
FileSystemItem fileItem = FindFileItem(file);
return(fileItem.LastWriteTime);
}
public void Copy(string source, string dest, bool overwrite = false, FileSystemItem type = FileSystemItem.Both)
{
source = PreparePath(source);
dest = PreparePath(dest);
if (type != FileSystemItem.Directory && File.Exists(source))
{
string destDir = Path.GetDirectoryName(dest);
if (destDir == null)
throw new ArgumentException("Invalid destination path: " + dest);
if (!Directory.Exists(destDir))
Directory.CreateDirectory(destDir);
File.Copy(source, dest, overwrite);
}
else if (type != FileSystemItem.File && Directory.Exists(source))
{
DirectoryCopy(source, dest, overwrite);
}
else
throw new FileNotFoundException("File not found", source);
}
public override DateTime GetLastWriteTime(FileManagerFolder folder)
{
FileSystemItem folderItem = FindFolderItem(folder);
return(folderItem.LastWriteTime);
}
public void CopyTo(FileSystemItem item)
{
_backingFile.CopyTo(item);
}
public override long GetLength(FileManagerFile file)
{
FileSystemItem fileItem = FindFileItem(file);
return(fileItem.Content.Length);
}
public override FileSystemItem MoveTo(FileSystemItem item)
{
LongPathFile.Move(Path, item.Path);
return item;
}
public override void CopyFile(FileManagerFile file, FileManagerFolder newParentFolder)
{
FileSystemItem fileItem = FindFileItem(file);
CopyCore(fileItem, newParentFolder.RelativeName, false);
}
private void FillItemInfo(FileSystemItem fileSystemItem)
{
var fileInfo = new FileInfo(fileSystemItem.Path);
var fileAccessInfo = fileInfo.GetAccessControl();
var owner = fileAccessInfo.GetOwner(accouuntType).ToString();
var currentUser = $"{(string.IsNullOrEmpty(Environment.UserDomainName) ? string.Empty : $"{Environment.UserDomainName}\\" )}{Environment.UserName}";
protected void UpdateAndSubmitChangesCore(FileSystemItem item, Action <FileSystemItem> update)
{
update(item);
Data.SaveChanges();
RefreshFolderCache();
}
public CacheItem RecognizeTitle(FileSystemItem item)
{
var cacheKey = GetCacheKey(item);
CacheItem cacheItem = null;
switch (item.TitleType)
{
case TitleType.Profile:
var content = GetProfileData(item, cacheKey.Item);
if (content == null && RecognizeInaccessibleProfile != null)
{
RecognizeInaccessibleProfile.Invoke(item);
}
cacheItem = SaveProfileCache(cacheKey, item, content);
break;
case TitleType.Game:
if (item.Type == ItemType.File)
{
GetGameDataFromGpd(item);
}
else if (!GetGameData(item))
{
if (_userSettingsProvider.UseUnity)
{
GetGameDataFromUnity(item);
}
}
cacheItem = SaveGameCache(cacheKey, item);
break;
case TitleType.Content:
cacheItem = _cacheManager.Set(cacheKey.Key, item);
item.IsCached = true;
break;
case TitleType.DataFile:
if (item.Type == ItemType.File)
{
try
{
var header = _fileManager.ReadFileContent(item.Path, StfsPackage.DefaultHeaderSizeVersion1 + 12);
var svod = ModelFactory.GetModel <SvodPackage>(header);
if (svod.IsValid)
{
item.Title = svod.DisplayName;
if (svod.InstallerType == InstallerType.TitleUpdate)
{
var ver = svod.ReadValue <Version>(StfsPackage.DefaultHeaderSizeVersion1 + 8, 4, new BinaryDataAttribute(EndianType.BigEndian));
item.Title = string.Format("{0} (TU{1})", svod.DisplayName, ver.Build);
}
if (!svod.ThumbnailImage.All(b => b == 0))
{
item.Thumbnail = svod.ThumbnailImage;
}
item.ContentType = svod.ContentType;
item.RecognitionState = RecognitionState.Recognized;
}
cacheItem = SaveDataFileCache(cacheKey, item);
}
catch
{
item.IsLocked = true;
item.LockMessage = Resx.InaccessibleFileErrorMessage;
}
item.IsCached = true;
}
break;
}
return(cacheItem);
}
private string Write55_ItemCapability(FileSystemItem.ItemCapability v)
{
switch (v)
{
case FileSystemItem.ItemCapability.IsShellFolderShortcut:
return "IsShellFolderShortcut";
case FileSystemItem.ItemCapability.HasShellFolderShortcut:
return "HasShellFolderShortcut";
case FileSystemItem.ItemCapability.Deleted:
return "Deleted";
case FileSystemItem.ItemCapability.None:
return "None";
case FileSystemItem.ItemCapability.HasParent:
return "HasParent";
case FileSystemItem.ItemCapability.HasExtender:
return "HasExtender";
case FileSystemItem.ItemCapability.HasTarget:
return "HasTarget";
case FileSystemItem.ItemCapability.HasSize:
return "HasSize";
case FileSystemItem.ItemCapability.HasThumbnail:
return "HasThumbnail";
case FileSystemItem.ItemCapability.IsParentReal:
return "IsParentReal";
case FileSystemItem.ItemCapability.UseTargetIcon:
return "UseTargetIcon";
case FileSystemItem.ItemCapability.GlobalFileChangedAssigned:
return "GlobalFileChangedAssigned";
case FileSystemItem.ItemCapability.IsShellLink:
return "IsShellLink";
case FileSystemItem.ItemCapability.IsUrlLink:
return "IsUrlLink";
case FileSystemItem.ItemCapability.HasCreationTime:
return "HasCreationTime";
case FileSystemItem.ItemCapability.HasLastWriteTime:
return "HasLastWriteTime";
case FileSystemItem.ItemCapability.HasVolume:
return "HasVolume";
case FileSystemItem.ItemCapability.QueryRemoveAssigned:
return "QueryRemoveAssigned";
case FileSystemItem.ItemCapability.VolumeEventsAssigned:
return "VolumeEventsAssigned";
case FileSystemItem.ItemCapability.HasLastAccessTime:
return "HasLastAccessTime";
case FileSystemItem.ItemCapability.Unreadable:
return "Unreadable";
case FileSystemItem.ItemCapability.GlobalFolderChangedAssigned:
return "GlobalFolderChangedAssigned";
case FileSystemItem.ItemCapability.CheckNetworkShare:
return "CheckNetworkShare";
case FileSystemItem.ItemCapability.DisableContentMap:
return "DisableContentMap";
case FileSystemItem.ItemCapability.ItemRefreshNeeded:
return "ItemRefreshNeeded";
case FileSystemItem.ItemCapability.HasShellItem:
return "HasShellItem";
case FileSystemItem.ItemCapability.HasExtension:
return "HasExtension";
case FileSystemItem.ItemCapability.IsElevated:
return "IsElevated";
case FileSystemItem.ItemCapability.HasContentFolder:
return "HasContentFolder";
}
return XmlSerializationWriter.FromEnum((long) v, new string[] {
"None", "HasParent", "HasExtender", "HasTarget", "HasSize", "HasThumbnail", "IsParentReal", "IsShellFolderShortcut", "HasShellFolderShortcut", "Deleted", "UseTargetIcon", "GlobalFileChangedAssigned", "IsShellLink", "IsUrlLink", "HasCreationTime", "HasLastWriteTime",
"HasLastAccessTime", "Unreadable", "GlobalFolderChangedAssigned", "HasVolume", "QueryRemoveAssigned", "VolumeEventsAssigned", "CheckNetworkShare", "DisableContentMap", "ItemRefreshNeeded", "IsElevated", "HasContentFolder", "HasShellItem", "HasExtension"
}, new long[] {
0L, 1L, 2L, 4L, 8L, 0x10L, 0x20L, 0x40L, 0x80L, 0x100L, 0x200L, 0x400L, 0x800L, 0x1000L, 0x2000L, 0x4000L,
0x8000L, 0x10000L, 0x20000L, 0x40000L, 0x80000L, 0x100000L, 0x200000L, 0x400000L, 0x800000L, 0x1000000L, 0x2000000L, 0x4000000L, 0x8000000L
}, "Nomad.FileSystem.LocalFile.FileSystemItem.ItemCapability");
}
public CacheItem GetCacheEntry(FileSystemItem item, out CacheComplexKey cacheKey)
{
cacheKey = GetCacheKey(item);
return(_cacheManager.Get(cacheKey));
}
private ImageSource getIcon(FileSystemItem item = null)
{
string header = "pack://application:,,,/Prime;component/Resources/";
string icon = "modern-files/file.png";
if (item == null)
{
icon = "empty.png";
}
else if (item is Drive)
{
icon = "drive.png";
}
else if (item is Directory || item is Jump)
{
//icon = "folder.png";
//icon = "folder-vi.png";
icon = "modern-files/folder.png";
}
//icon = "dir32.png";
else
{
string ext = (item as File).Extension;
switch (ext.ToLower())
{
case "":
icon = "empty.png";
break;
case ".doc":
case ".docx":
case ".rtf":
icon = "modern-files/doc.png";
break;
/*case ".xls":
* case ".xlsx":
* icon = "excel.png";
* break;
* case ".ppt":
* case ".pptx":
* icon = "slides.png";
* break;*/
case ".jar":
case ".exe":
case ".bat":
case ".msi":
case ".clickonce":
case ".com":
icon = "modern-files/exe.png";
break;
case ".img":
case ".bmp":
case ".jpg":
case ".jpeg":
case ".png":
case ".gif":
case ".ico":
icon = "modern-files/img.png";
break;
case ".pdf":
icon = "modern-files/doc.png";
break;
/*case ".dll":
* case ".lib":
* case ".sys":
* icon = "plugin.png";
* break;
* case ".html":
* case ".htm":
* case ".url":
* icon = "url.png";
* break;*/
case ".wma":
case ".wav":
case ".mp3":
case ".ogg":
icon = "modern-files/vid.png";
break;
case ".zip":
case ".rar":
case ".gz":
case ".tar":
case ".7z":
icon = "modern-files/zip.png";
break;
case ".avi":
case ".mkv":
case ".mov":
case ".wmv":
case ".mp4":
case ".mpeg":
case ".mpg":
case ".vob":
icon = "modern-files/vid.png";
break;
case ".php":
case ".cs":
case ".java":
case ".js":
case ".ini":
case ".vb":
case ".frm":
case ".frx":
case ".txt":
case ".text":
case ".py":
case ".c":
case ".h":
case ".cpp":
case ".vbs":
case ".sql":
case ".xml":
case ".xhtml":
case ".manifest":
icon = "modern-files/code.png";
break;
default:
break;
}
}
return(new BitmapImage(new Uri(header + icon, UriKind.Absolute)));
}
public abstract FileSystemItem MoveTo(FileSystemItem item);
public async Task <ProjectModel> Post(ProjectModel model)
{
using (var db = new ScribsDbContext()) {
var user = GetUser(db);
int index = user.GetProjects().Count();
var project = new Project(user, model.Name, false);
if (project.ExistsItem())
{
throw new System.Exception("This project already exists");
}
project.CreateItem();
project.Load();
project.Type = (Project.ProjectTypes)model.Type;
project.Description = model.Description;
project.Structure = model.Structure.Aggregate((a, b) => a + ";" + b);
project.Index = 0;
project.Key = Guid.NewGuid().ToString();
// Basic sheet templates
var charTemplate = SheetTemplate.Factory.CreateInstance(db);
charTemplate.User = user;
charTemplate.ProjectKey = project.Key;
charTemplate.Name = "Characters";
int i = 0;
foreach (string label in new List <string> {
"Name",
"Description",
"Personality",
"Occupation",
"Objective",
"Habits",
"Conflicts",
"Relatives",
"Notes"
})
{
var field = SheetTemplateField.Factory.CreateInstance(db);
field.Index = i++;
field.Label = label;
field.SheetTemplate = charTemplate;
charTemplate.SheetTemplateFields.Add(field);
}
var setTemplate = SheetTemplate.Factory.CreateInstance(db);
setTemplate.User = user;
setTemplate.ProjectKey = project.Key;
setTemplate.Name = "Settings";
i = 0;
foreach (string label in new List <string> {
"Name",
"Description",
"Sights",
"Sounds",
"Smells",
"Notes"
})
{
var field = SheetTemplateField.Factory.CreateInstance(db);
field.Index = i++;
field.Label = label;
field.SheetTemplate = setTemplate;
setTemplate.SheetTemplateFields.Add(field);
}
await db.SaveChangesAsync();
// Drafts
var draftDirectory = FileSystemItem.Create(project, Directory.Type, ".Drafts", Guid.NewGuid().ToString(), 0) as Directory;
FileSystemItem.Create(draftDirectory, File.Type, "Draft 1", Guid.NewGuid().ToString(), 0);
// Structure generation
var folders = model.Structure.Length > 1 ? model.Structure.Take(model.Structure.Length - 1) :
new List <string> {
"folder"
};
var file = model.Structure.Length > 0 ? model.Structure.Last() : "file";
var directory = project as Directory;
foreach (string folder in folders)
{
string directoryName = folder.Substring(0, 1).ToUpper() + folder.Substring(1, folder.Length - 1) + " 1";
directory = FileSystemItem.Create(directory, Directory.Type, directoryName, Guid.NewGuid().ToString(), 0) as Directory;
}
string fileName = file.Substring(0, 1).ToUpper() + file.Substring(1, file.Length - 1) + " 1";
FileSystemItem.Create(directory, File.Type, fileName, Guid.NewGuid().ToString(), 0);
project.Save();
return(new ProjectModel {
Name = model.Name,
Discriminator = Discriminator.Directory,
Key = project.Key
});
}
}
public FileSystemItem MoveTo(FileSystemItem newFileName)
{
LongPathDirectory.Move(Path, newFileName.Path);
return(newFileName);
}
private static FileSystemItem FindItem(List <FileSystemItem> items, string fullPath)
{
FileSystemItem item = items.FirstOrDefault(i => String.Equals(i.FullPath, fullPath, StringComparison.Ordinal));
return(item);
}
protected bool IsDirectoryInfoEntry(FileSystemItem <DirectoryInfo> input, string name)
{
return(input._startingPoints.Any(p => new DirectoryInfo(p.EntryPoint).FullName.Equals(name, StringComparison.InvariantCultureIgnoreCase)));
}
public void AddPicture(FileSystemItem aFile)
{
Console.WriteLine(Indent(aFile.Level) + aFile.Name);
}
private void ProcessSuccess(OperationResult result)
{
FileSystemItem deselect = null;
var queueItem = _queue.Peek();
switch (result.Result)
{
case TransferResult.Ok:
if (queueItem.Operation == FileOperation.Copy)
{
_targetChanged = true;
}
if (queueItem.Operation == FileOperation.Copy && IsVerificationSupported && IsVerificationEnabled && queueItem.FileSystemItem.Type == ItemType.File)
{
queueItem.Operation = FileOperation.Verify;
queueItem.Payload = result.TargetPath;
}
else if ((queueItem.Operation == FileOperation.Copy || queueItem.Operation == FileOperation.Verify) && UserAction == FileOperation.Move)
{
if (queueItem.FileSystemItem.Type == ItemType.Directory)
{
_queue.Dequeue();
_queue.Enqueue(new QueueItem(queueItem.FileSystemItem, FileOperation.Delete));
}
else
{
queueItem.Operation = FileOperation.Delete;
}
}
else
{
if (queueItem.Operation == FileOperation.Delete)
{
_sourceChanged = true;
}
if (UserAction != FileOperation.Delete)
{
_statistics.FilesTransferred++;
}
FilesTransferred++;
deselect = queueItem.FileSystemItem;
_queue.Dequeue();
}
break;
case TransferResult.Skipped:
_queue.Dequeue();
break;
case TransferResult.Aborted:
if (queueItem.Operation == FileOperation.Copy)
{
_targetChanged = true;
}
if (IsPaused)
{
queueItem.CopyAction = CopyAction.Resume;
}
else
{
_queue.Dequeue();
}
break;
}
_currentFileBytesTransferred = 0;
if (deselect != null)
{
var vm = SourcePane.SelectedItems.FirstOrDefault(i => deselect.Path.StartsWith(i.Path));
if (vm != null && (vm.Type == ItemType.File || !_queue.Any(q => q.FileSystemItem.Path.StartsWith(vm.Path))))
{
vm.IsSelected = false;
}
}
if (IsPaused)
{
PauseMeters();
}
else
{
ProcessQueueItem();
}
}
public FileSystemItem MoveTo(FileSystemItem newFileName)
{
var currentLock = _lock;
if (currentLock != null)
throw new IOException("File is locked, please try again later.");
CopyTo(newFileName);
Delete();
return newFileName;
}
public void CopyTo(FileSystemItem where)
{
VerifyExists();
var currentLock = _lock;
if (currentLock != null && currentLock.Value != FileShare.Read && currentLock.Value != FileShare.ReadWrite)
throw new IOException("Cannot copy file as someone opened it without shared read access");
if (where is InMemoryFile)
{
if (@where.Exists())
throw new IOException("File already exists");
((InMemoryFile) where).CopyFromFile(this);
}
else if (where is InMemoryDirectory)
((InMemoryFile) ((InMemoryDirectory) where).GetFile(Name)).CopyFromFile(this);
else
throw new InvalidOperationException("The target type doesn't match the file system of the current file.");
}
public virtual void CopyTo(FileSystemItem item)
{
var destinationPath = PrepareCopyTo(item);
System.IO.File.Copy(Path.FullPath, destinationPath.FullPath, true);
}
public FileSystemItem MoveTo(FileSystemItem item)
{
Contract.Requires(item != null);
throw new System.NotImplementedException();
}
public virtual FileSystemItem MoveTo(FileSystemItem item)
{
System.IO.File.Move(Path.FullPath, item.Path.FullPath);
return(item);
}
public void CopyTo(FileSystemItem item)
{
UnderlyingDirectory.CopyTo(item);
}
public FileSystemItem MoveTo(FileSystemItem target)
{
return _backingFile.MoveTo(target);
}
