public ScopeItemViewModel(ScopeItemViewModel parent, IFolderItem folderItem, IFolderPath folderPath)
{
// parent can be null.
_parent = parent;
if (folderItem == null)
throw new ArgumentNullException("folderItem");
_folderItem = folderItem;
if (folderPath == null)
throw new ArgumentNullException("folderPath");
_folderPath = folderPath;
// TODO: Use the WeakPropertyChangedEventHandler (in CLINQ) to bind to some interesting properties on the IFolderItem?
_realChildren = _folderItem.Children.Select(x => new ScopeItemViewModel(this, x, folderPath));
//_folderItem.Children.CollectionChanged += (sender, e) => { Children = _realChildren; };
//_realChildren.CollectionChanged += (sender, e) => { Children = _realChildren; };
// If it can contain folders, but we don't know what they are yet, put a fake child in.
if (_folderItem.CanContainFolders && _realChildren.Count == 0)
Children = DeferredChildren;
else
Children = _realChildren;
}
public EmpegQueryFolderItem(IFolderItem parent, EmpegCarDatabase database, string name, Func<DatabaseItem, string> selector)
{
_database = database;
_selector = selector;
Parent = parent;
Name = name;
}
private static void PushAncestors(IFolderItem folderItem, ICollection<IFolderItem> components)
{
if (folderItem == null)
return;
PushAncestors(folderItem.Parent, components);
components.Add(folderItem);
}
public FolderNode(IFolderItem folder)
: this()
{
Id = folder.Id;
Name = folder.Name;
folder.Folders.ToList().ForEach(AddFolder);
folder.Pages.ToList().ForEach(AddPage);
}
/// <summary>
/// Обработать элемент.
/// </summary>
/// <param name="item">
/// Элемент.
/// </param>
public void Visit(IFolderItem item)
{
if (item.DateTaken == null)
{
return;
}
var dateTime = item.DateTaken.Value;
dateTime = dateTime
.AddYears(this.dateSpan.Years)
.AddMonths(this.dateSpan.Months)
.AddDays(this.dateSpan.Days)
.AddHours(this.dateSpan.Hours)
.AddMinutes(this.dateSpan.Minutes)
.AddSeconds(this.dateSpan.Seconds);
PhotoDateTakenHelper.SetDateTaken(item.Path, dateTime);
item.Reset();
}
public void Set(IFolderItem folderItem)
{
var path = folderItem.GetPath();
var prefix = _components.CommonPrefix(path, (x, y) => x.Id == y.Id).ToArray();
// If there's no change, don't bother.
if (path.Count == prefix.Length && prefix.Length == _components.Count)
return;
// Back up _components until we get to the prefix
while (_components.Count > prefix.Length)
_components.RemoveAt(_components.Count - 1);
_components.AddRange(path.Skip(prefix.Length));
if (Changed != null)
Changed(this, new FolderPathChangedEventArgs { Top = Top });
OnPropertyChanged("Top");
}
public FolderItemLocation Find(IFolderItem item)
{
int j = 0;
foreach (var i in Items)
{
if (i == item)
{
return(new FolderItemLocation(this, j));
}
if (i is Folder)
{
var l = (i as Folder).Find(item);
if (l.Folder != null)
{
return(l);
}
}
j++;
}
return(new FolderItemLocation(null, -1));
}
public FolderItemViewModel(IFolderItem item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
_item = item;
OpenCommand = new RelayCommand(Open);
GroupCommand = new RelayCommand <ArrayList>(GroupItems, CanGroupItems);
UpCommand = new RelayCommand(Up, CanUp);
RemoveCommand = new RelayCommand(Remove);
if (IsPhoto)
{
var filePath = Photo.OriginalFileName;
OriginalName = Path.GetFileName(filePath);
}
else if (IsFolder)
{
MessengerInstance.Register <RemoveItemMessage>(this, OnItemRemoving);
}
}
private static async Task FileWatchTestsAsync(IFolderItem folder)
{
bool fileAddedTrigger = false;
bool fileUpdatedTrigger = false;
var poll = folder.CreateFileWatcher(FileWatcherType.Created,
(fr, obj) =>
{
Console.WriteLine("File {0} was added.", fr.Path);
var uri = obj as Uri;
if (uri != null)
{
Console.WriteLine("Next Uri: {0}", uri.AbsolutePath);
}
fileAddedTrigger = true;
return(Task.FromResult(0));
}, null, 1);
var poll2 = folder.CreateFileWatcher(FileWatcherType.Updated,
(fr, obj) =>
{
Console.WriteLine("File {0} was updated.", fr.Path);
var uri = obj as Uri;
if (uri != null)
{
Console.WriteLine("Next Uri: {0}", uri.AbsolutePath);
}
fileUpdatedTrigger = true;
return(Task.FromResult(0));
}, null, 1);
var newFile = folder.GetFileReference(Guid.NewGuid().ToString());
await newFile.WriteAsync(new byte[0]);
// Adding some wait to make sure triggers are fired.
await Task.Delay(1000);
await newFile.WriteAsync(new byte[1] {
0
});
// Adding some wait to make sure triggers are fired.
Console.WriteLine("Waiting for 20 seconds...");
await Task.Delay(20000);
if (!fileAddedTrigger)
{
Console.WriteLine("Error: New file was not triggered when a new file was added.");
}
if (!fileUpdatedTrigger)
{
Console.WriteLine("Error: Update file was not triggered when an existing file was updated.");
}
var trigger = await folder.CheckForFileAsync(FileWatcherType.Updated);
await newFile.WriteAsync(new byte[1] {
1
});
trigger = await folder.CheckForFileAsync(FileWatcherType.Updated, trigger.NextUri);
if (trigger.FileItem != null)
{
Console.WriteLine("Updated file: {0}", trigger.FileItem.Path);
}
await newFile.DeleteAsync();
}
private void AddFolder(IFolderItem folder)
{
Children.Add(new FolderNode(folder));
}
/// <summary>
/// Обработать элемент.
/// </summary>
/// <param name="item">
/// Элемент.
/// </param>
public void Visit(IFolderItem item)
{
PhotoDateTakenHelper.SetDateTaken(item.Path, this.dateTime);
item.Reset();
}
public static bool HasTemplateConfigDirectory(this IFolderItem folderItem)
{
FilePath templateConfigDirectory = folderItem.GetTemplateConfigDirectory();
return(Directory.Exists(templateConfigDirectory));
}
internal static async Task <ApiHubFile> New(IFolderItem rootFolder, string path)
{
var fileSource = await rootFolder.GetFileReferenceAsync(path, true);
return(new ApiHubFile(fileSource));
}
public FolderItemUpdateRecord(IFolderItem source, IFolderItem dest)
{
Source = source;
Dest = dest;
}
public async Task NonExistenceTestsAsync()
{
string cdpTestRoot = "tests/" + Guid.NewGuid().ToString();
string fileName = Guid.NewGuid().ToString();
var folder = _rootFolder.GetFolderReference(cdpTestRoot);
// file doesn't exist test
var fileItem = await folder.GetFileItemAsync(Guid.NewGuid().ToString());
Assert.Null(fileItem);
IFolderItem nullFolder = folder.GetFolderReference(string.Empty);
Assert.Null(nullFolder);
var nullFile = folder.GetFileReference(string.Empty);
Assert.Null(nullFile);
var newFolder = folder.GetFolderReference(Guid.NewGuid().ToString());
// listing items for a folder which doesn't exist
var listItems = await newFolder.ListAsync();
Assert.Equal(listItems.Length, 0);
var newFile = newFolder.GetFileReference(Guid.NewGuid().ToString());
try
{
// trying to read from a file which doesn't exist should throw an exception.
var bytes = await newFile.ReadAsync();
}
catch (Exception ex)
{
// Expected exception was thrown when attempting to read from a file which doesn't exist.
Assert.IsType(typeof(FileNotFoundException), ex);
}
var metadata = await newFile.GetMetadataAsync();
// Metadata should be null for a file which doesn't exist.
Assert.Null(metadata);
// Deleting for a file which doesn't exist should do nothing.
await newFile.DeleteAsync();
// Writing null or empty should create an empty file
await newFile.WriteAsync(null);
metadata = await newFile.GetMetadataAsync();
// empty file should have size of 0
Assert.Equal(metadata.Size, 0);
await newFile.WriteAsync(new byte[] { 0 });
metadata = await newFile.GetMetadataAsync();
Assert.Equal(metadata.Size, 1);
string newFolderName = Guid.NewGuid().ToString();
string newFileName = Guid.NewGuid().ToString();
Assert.False(await folder.FolderExistsAsync(newFolderName));
Assert.False(await folder.FileExistsAsync(newFileName));
newFile = folder.GetFileReference(newFolderName + "/" + newFileName);
await newFile.WriteAsync(null);
Assert.True(await folder.FolderExistsAsync(newFolderName));
Assert.True(await folder.FileExistsAsync(newFolderName + "/" + newFileName));
await newFile.DeleteAsync();
// TODO: Cdp needs to support deleting empty folders.
}
private MoveNodes(Node container, FolderItemLocation location, FolderItemLocation prevLocation, IFolderItem item)
{
Container = container;
Location = location;
Item = item;
PrevLocation = prevLocation;
}
private static FolderItemLocation GetParentFolder(IFolderItem item) => Document.Current.Container.RootFolder().Find(item);
private UnlinkFolderItem(Node container, IFolderItem item)
{
Container = container;
Item = item;
}
public static void Perform(Node container, IFolderItem item)
{
DocumentHistory.Current.Perform(new UnlinkFolderItem(container, item));
}
private InsertFolderItem(Node container, FolderItemLocation location, IFolderItem item)
{
Container = container;
Location = location;
Item = item;
}
public static void Perform(IFolderItem item, bool aboveSelected = true)
{
Perform(Document.Current.Container, GetNewFolderItemLocation(aboveSelected), item);
}
private static async Task ListTestsAsync(string cdpTestRoot, IFolderItem root, IFolderItem folder)
{
var currentList = await folder.ListAsync(false);
Console.WriteLine("Number of items in {0} : {1}", folder.Path, currentList.Count());
currentList = await folder.ListAsync(true);
Console.WriteLine("Number of items in {0} and all its subfolders: {1}", folder.Path, currentList.Count());
var nestedFolder = folder.GetFolderReference("nestedFolder");
currentList = await nestedFolder.ListAsync(false);
Console.WriteLine("Number of items in {0} : {1}", nestedFolder.Path, currentList.Count());
currentList = await nestedFolder.ListAsync(true);
Console.WriteLine("Number of items in {0} and all its subfolders: {1}", nestedFolder.Path, currentList.Count());
folder = root.GetFolderReference(cdpTestRoot);
var NestedFolderTwoLevel = await folder.GetFolderItemAsync("nestedFolder/nested2");
if (NestedFolderTwoLevel != null)
{
currentList = await NestedFolderTwoLevel.ListAsync(true);
Console.WriteLine("Number of items in {0} and all its subfolders: {1}", NestedFolderTwoLevel.Path, currentList.Count());
}
currentList = await root.ListAsync(false);
Console.WriteLine("Number of items in root folder {0} : {1}", root.Path, currentList.Count());
}
private static async Task NonExistenceTestsAsync(string cdpTestRoot, IFolderItem root, IFolderItem folder)
{
// file doesn't exist test
var fileItem = await folder.GetFileItemAsync(Guid.NewGuid().ToString());
if (fileItem != null)
{
Console.WriteLine("Error: Files which do not exist should return null when calling GetFileItemAsync");
}
IFolderItem nullFolder = folder.GetFolderReference(string.Empty);
if (nullFolder != null)
{
Console.WriteLine("Error: null folder expected.");
}
var nullFile = folder.GetFileReference(string.Empty);
if (nullFile != null)
{
Console.WriteLine("Error: null file expected.");
}
var newFolder = folder.GetFolderReference(Guid.NewGuid().ToString());
// listing items for a folder which doesn't exist
var listItems = await newFolder.ListAsync();
if (listItems.Length > 0)
{
Console.WriteLine("Error: A folder which doesn't exist returned content.");
}
var newFile = newFolder.GetFileReference(Guid.NewGuid().ToString());
try
{
// trying to read from a file which doesn't exist should throw an exception.
var bytes = await newFile.ReadAsync();
}
catch (FileNotFoundException ex)
{
Console.WriteLine("Expected exception was thrown when attempting to read from a file which doesn't exist.");
}
var metadata = await newFile.GetMetadataAsync();
if (metadata != null)
{
Console.WriteLine("Error: Metadata should be null for a file which doesn't exist.");
}
// Deleting for a file which doesn't exist should do nothing.
await newFile.DeleteAsync();
// Writing null or empty should create an empty file
await newFile.WriteAsync(null);
metadata = await newFile.GetMetadataAsync();
if (metadata == null || metadata.Size > 0)
{
Console.WriteLine("Error: Unable to create an empty file.");
}
await newFile.WriteAsync(new byte[] { 0 });
metadata = await newFile.GetMetadataAsync();
listItems = await newFolder.ListAsync();
if (listItems.Length != 1)
{
Console.WriteLine("Error: there should only be one item in the directory.");
}
await newFile.DeleteAsync();
listItems = await newFolder.ListAsync();
if (listItems.Length != 0)
{
Console.WriteLine("Error: there should be no items in the directory.");
}
string newFolderName = Guid.NewGuid().ToString();
string newFileName = Guid.NewGuid().ToString();
if (await folder.FolderExistsAsync(newFolderName))
{
Console.WriteLine("Error: Folder must not yet exist.");
}
if (await folder.FileExistsAsync(newFileName))
{
Console.WriteLine("Error: File must not yet exist.");
}
newFile = folder.GetFileReference(newFolderName + "/" + newFileName);
await newFile.WriteAsync(null);
if (!await folder.FolderExistsAsync(newFolderName))
{
Console.WriteLine("Error: Folder must now exist.");
}
if (!await folder.FileExistsAsync(newFolderName + "/" + newFileName))
{
Console.WriteLine("Error: File must now exist.");
}
await newFile.DeleteAsync();
// TODO: Cdp needs to support deleting empty folders.
}
public static FilePath GetTemplateConfigDirectory(this IFolderItem folderItem)
{
return(folderItem.BaseDirectory.Combine(".template.config"));
}
public bool Contains(IFolderItem item)
{
return(Find(item).Folder != null);
}
private void AddFolder(IFolderItem folder)
{
Children.Add(new FolderNode(folder));
}
public EmpegResultFolderItem(IFolderItem parent, string name)
{
Parent = parent;
Name = name;
}
public static FilePath GetTemplateJsonFilePath(this IFolderItem folderItem)
{
FilePath templateConfigDirectory = folderItem.GetTemplateConfigDirectory();
return(templateConfigDirectory.Combine("template.json"));
}
internal static ApiHubFile New(IFolderItem rootFolder, string path)
{
var fileSource = rootFolder.GetFileReference(path, true);
return(new ApiHubFile(fileSource));
}
public static bool HasTemplateJsonFile(this IFolderItem folderItem)
{
FilePath fileName = folderItem.GetTemplateJsonFilePath();
return(File.Exists(fileName));
}
