private async Task CopyAsync(IStoreItem source, IStoreCollection destinationCollection, string name, bool overwrite, int depth, IHttpContext httpContext, Uri baseUri, UriResultCollection errors)
{
// Determine the new base Uri
var newBaseUri = UriHelper.Combine(baseUri, name);
// Copy the item
var copyResult = await source.CopyAsync(destinationCollection, name, overwrite, httpContext).ConfigureAwait(false);
if (copyResult.Result != DavStatusCode.Created && copyResult.Result != DavStatusCode.NoContent)
{
errors.AddResult(newBaseUri, copyResult.Result);
return;
}
// Check if the source is a collection and we are requested to copy recursively
var sourceCollection = source as IStoreCollection;
if (sourceCollection != null && depth > 0)
{
// The result should also contain a collection
var newCollection = (IStoreCollection)copyResult.Item;
// Copy all childs of the source collection
foreach (var entry in await sourceCollection.GetItemsAsync(httpContext).ConfigureAwait(false))
{
await CopyAsync(entry, newCollection, entry.Name, overwrite, depth - 1, httpContext, newBaseUri, errors).ConfigureAwait(false);
}
}
}
private async Task MoveAsync(IStoreCollection sourceCollection, IStoreItem moveItem, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext, Uri baseUri, UriResultCollection errors)
{
// Determine the new base URI
var subBaseUri = UriHelper.Combine(baseUri, destinationName);
// Obtain the actual item
if (moveItem is IStoreCollection moveCollection && !moveCollection.SupportsFastMove(destinationCollection, destinationName, overwrite, httpContext))
{
// Create a new collection
var newCollectionResult = await destinationCollection.CreateCollectionAsync(destinationName, overwrite, httpContext).ConfigureAwait(false);
if (newCollectionResult.Result != DavStatusCode.Created && newCollectionResult.Result != DavStatusCode.NoContent)
{
errors.AddResult(subBaseUri, newCollectionResult.Result);
return;
}
// Move all sub items
foreach (var entry in await moveCollection.GetItemsAsync(httpContext).ConfigureAwait(false))
{
await MoveAsync(moveCollection, entry, newCollectionResult.Collection, entry.Name, overwrite, httpContext, subBaseUri, errors).ConfigureAwait(false);
}
// Delete the source collection
var deleteResult = await sourceCollection.DeleteItemAsync(moveItem.Name, httpContext).ConfigureAwait(false);
if (deleteResult != DavStatusCode.Ok)
{
errors.AddResult(subBaseUri, newCollectionResult.Result);
}
}
public async Task <StoreItemResult> CopyAsync(IStoreCollection destinationCollection, string name, bool overwrite, IHttpContext httpContext)
{
var instance = CloudManager.Instance(httpContext.Session.Principal.Identity);
var res = await instance.Copy(_directoryInfo, destinationCollection.GetFullPath());
return(new StoreItemResult(res ? DavStatusCode.Created : DavStatusCode.InternalServerError, null));
}
public async Task <StoreItemResult> CopyAsync(IStoreCollection destinationCollection, string name, bool overwrite, IHttpContext httpContext)
{
// Just create the folder itself
var result = await destinationCollection.CreateCollectionAsync(name, overwrite, httpContext);
return(new StoreItemResult(result.Result, result.Collection));
}
public async Task <StoreItemResult> CopyAsync(IStoreCollection destination, string name, bool overwrite, IHttpContext httpContext)
{
try
{
// If the destination is also a disk-store, then we can use the FileCopy API
// (it's probably a bit more efficient than copying in C#)
var diskCollection = destination as DiskStoreCollection;
if (diskCollection != null)
{
// Check if the collection is writable
if (!diskCollection.IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
var destinationPath = Path.Combine(diskCollection.FullPath, name);
// Check if the file already exists
var fileExists = File.Exists(destinationPath);
if (fileExists && !overwrite)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Copy the file
File.Copy(_fileInfo.FullName, destinationPath, true);
// Return the appropriate status
return(new StoreItemResult(fileExists ? DavStatusCode.NoContent : DavStatusCode.Created));
}
else
{
// Create the item in the destination collection
var result = await destination.CreateItemAsync(name, overwrite, httpContext).ConfigureAwait(false);
// Check if the item could be created
if (result.Item != null)
{
using (var sourceStream = await GetReadableStreamAsync(httpContext).ConfigureAwait(false))
{
var copyResult = await result.Item.UploadFromStreamAsync(httpContext, sourceStream).ConfigureAwait(false);
if (copyResult != DavStatusCode.Ok)
{
return(new StoreItemResult(copyResult, result.Item));
}
}
}
// Return result
return(new StoreItemResult(result.Result, result.Item));
}
}
catch (Exception exc)
{
s_log.Log(LogLevel.Error, () => "Unexpected exception while copying data.", exc);
return(new StoreItemResult(DavStatusCode.InternalServerError));
}
}
private async Task MoveAsync(IStoreCollection sourceCollection, string sourceName, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext, WebDavUri baseUri, UriResultCollection errors)
{
// Determine the new base URI
var subBaseUri = UriHelper.Combine(baseUri, destinationName);
// Items should be moved directly
var result = await sourceCollection.MoveItemAsync(sourceName, destinationCollection, destinationName, overwrite, httpContext).ConfigureAwait(false);
if (result.Result != DavStatusCode.Created && result.Result != DavStatusCode.NoContent)
{
errors.AddResult(subBaseUri, result.Result);
}
}
public async Task <StoreItemResult> CopyAsync(IStoreCollection destination, string name, bool overwrite, IHttpContext httpContext)
{
try
{
var collection = destination as MailruStoreCollection;
if (collection != null)
{
if (!collection.IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
var destinationPath = WebDavPath.Combine(collection.FullPath, name);
// check if the file already exists??
await Cloud.Instance(httpContext).Copy(_fileInfo, destinationPath);
return(new StoreItemResult(DavStatusCode.Created));
}
// Create the item in the destination collection
var result = await destination.CreateItemAsync(name, overwrite, httpContext).ConfigureAwait(false);
if (result.Item != null)
{
using (var sourceStream = await GetReadableStreamAsync(httpContext).ConfigureAwait(false))
{
var copyResult = await result.Item.UploadFromStreamAsync(httpContext, sourceStream).ConfigureAwait(false);
if (copyResult != DavStatusCode.Ok)
{
return(new StoreItemResult(copyResult, result.Item));
}
}
}
return(new StoreItemResult(result.Result, result.Item));
}
catch (IOException ioException) when(ioException.IsDiskFull())
{
SLog.Log(LogLevel.Error, () => "Out of disk space while copying data.", ioException);
return(new StoreItemResult(DavStatusCode.InsufficientStorage));
}
catch (Exception exc)
{
SLog.Log(LogLevel.Error, () => "Unexpected exception while copying data.", exc);
return(new StoreItemResult(DavStatusCode.InternalServerError));
}
}
//TODO: something wrong with unused depth?
private async Task CopyAsync(IStoreItem source, IStoreCollection destinationCollection, string name, bool overwrite, int depth, IHttpContext httpContext, WebDavUri baseUri, UriResultCollection errors)
{
// Determine the new base Uri
var newBaseUri = UriHelper.Combine(baseUri, name);
// Copy the item
var copyResult = await source.CopyAsync(destinationCollection, name, overwrite, httpContext).ConfigureAwait(false);
if (copyResult.Result != DavStatusCode.Created && copyResult.Result != DavStatusCode.NoContent)
{
errors.AddResult(newBaseUri, copyResult.Result);
}
//do not copy recursively
}
private async Task MoveAsync(IStoreCollection sourceCollection, string sourceName, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext, Uri baseUri, UriResultCollection errors)
{
// Determine the new base URI
var subBaseUri = UriHelper.Combine(baseUri, destinationName);
// Obtain the actual item
var moveCollection = await sourceCollection.GetItemAsync(sourceName, httpContext).ConfigureAwait(false) as IStoreCollection;
if (moveCollection != null)
{
// Create a new collection
var newCollectionResult = await destinationCollection.CreateCollectionAsync(destinationName, overwrite, httpContext);
if (newCollectionResult.Result != DavStatusCode.Created && newCollectionResult.Result != DavStatusCode.NoContent)
{
errors.AddResult(subBaseUri, newCollectionResult.Result);
return;
}
// Move all subitems
foreach (var entry in await moveCollection.GetItemsAsync(httpContext).ConfigureAwait(false))
{
await MoveAsync(moveCollection, entry.Name, newCollectionResult.Collection, entry.Name, overwrite, httpContext, subBaseUri, errors);
}
// Delete the source collection
var deleteResult = await sourceCollection.DeleteItemAsync(sourceName, httpContext);
if (deleteResult != DavStatusCode.Ok)
{
errors.AddResult(subBaseUri, newCollectionResult.Result);
return;
}
}
else
{
// Items should be moved directly
var result = await sourceCollection.MoveItemAsync(sourceName, destinationCollection, destinationName, overwrite, httpContext);
if (result.Result != DavStatusCode.Created && result.Result != DavStatusCode.NoContent)
{
errors.AddResult(subBaseUri, result.Result);
return;
}
}
}
private async Task <DavStatusCode> DeleteItemAsync(IStoreCollection collection, string name, IHttpContext httpContext, Uri baseUri, UriResultCollection errors)
{
// Obtain the actual item
var deleteCollection = await collection.GetItemAsync(name, httpContext).ConfigureAwait(false) as IStoreCollection;
if (deleteCollection != null)
{
// Determine the new base URI
var subBaseUri = UriHelper.Combine(baseUri, name);
// Delete all entries first
foreach (var entry in await deleteCollection.GetItemsAsync(httpContext).ConfigureAwait(false))
{
await DeleteItemAsync(deleteCollection, entry.Name, httpContext, subBaseUri, errors);
}
}
// Attempt to delete the item
return(await collection.DeleteItemAsync(name, httpContext).ConfigureAwait(false));
}
private async Task AddEntriesAsync(IStoreCollection collection, int depth, IHttpContext httpContext, Uri uri, IList <PropertyEntry> entries)
{
// Add the collection to the list
entries.Add(new PropertyEntry(uri, collection));
// If we have enough depth, then add the children
if (depth > 0)
{
// Add all child collections
foreach (var childEntry in await collection.GetItemsAsync(httpContext).ConfigureAwait(false))
{
var subUri = UriHelper.Combine(uri, childEntry.Name);
if (childEntry is IStoreCollection subCollection)
{
await AddEntriesAsync(subCollection, depth - 1, httpContext, subUri, entries).ConfigureAwait(false);
}
else
{
entries.Add(new PropertyEntry(subUri, childEntry));
}
}
}
}
public Task <StoreItemResult> MoveItemAsync(string sourceName, IStoreCollection destination, string destinationName, bool overwrite, IHttpContext context)
{
throw new NotImplementedException();
}
public async Task <StoreItemResult> MoveItemAsync(string sourceName, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext)
{
// Return error
if (!IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Determine the object that is being moved
var item = await GetItemAsync(sourceName, httpContext);
if (item == null)
{
return(new StoreItemResult(DavStatusCode.NotFound));
}
// Check if the item is actually a file
var storeItem = item as MailruStoreItem;
if (storeItem != null)
{
// If the destination collection is a directory too, then we can simply move the file
var destinationStoreCollection = destinationCollection as MailruStoreCollection;
if (destinationStoreCollection != null)
{
if (!destinationStoreCollection.IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Check if the file already exists
DavStatusCode result;
var itemexist = destinationStoreCollection.FindSubItem(destinationName);
if (itemexist != null)
{
if (!overwrite)
{
return(new StoreItemResult(DavStatusCode.Forbidden));
}
await Cloud.Instance.Remove(itemexist);
result = DavStatusCode.NoContent;
}
else
{
result = DavStatusCode.Created;
}
// Move the file
//await Cloud.Instance.Rename(FindSubItem(sourceName), destinationName);
if (destinationStoreCollection.FullPath == FullPath)
{
await Cloud.Instance.Rename(storeItem.FileInfo, destinationName);
}
else
{
await Cloud.Instance.Move(storeItem.FileInfo, destinationStoreCollection.FullPath);
}
return(new StoreItemResult(result, new MailruStoreItem(LockingManager, null, IsWritable)));
}
else
{
// Attempt to copy the item to the destination collection
var result = await item.CopyAsync(destinationCollection, destinationName, overwrite, httpContext);
if (result.Result == DavStatusCode.Created || result.Result == DavStatusCode.NoContent)
{
await DeleteItemAsync(sourceName, httpContext);
}
// Return the result
return(result);
}
}
// If it's not a plain item, then it's a collection
Debug.Assert(item is MailruStoreCollection);
// Collections will never be moved, but always be created
// (we always move the individual items to make sure locking is checked properly)
throw new InvalidOperationException("Collections should never be moved directly.");
}
public bool SupportsFastMove(IStoreCollection destination, string destinationName, bool overwrite, IHttpContext httpContext)
{
// We can only move disk-store collections
return(destination is DiskStoreCollection);
}
public async Task <StoreItemResult> MoveItemAsync(string sourceName, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext)
{
// Return error
if (!IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Determine the object that is being moved
var item = await GetItemAsync(sourceName, httpContext);
if (item == null)
{
return(new StoreItemResult(DavStatusCode.NotFound));
}
// Check if the item is actually a file
var diskStoreItem = item as DiskStoreItem;
if (diskStoreItem != null)
{
// If the destination collection is a directory too, then we can simply move the file
var destinationDiskStoreCollection = destinationCollection as DiskStoreCollection;
if (destinationDiskStoreCollection != null)
{
// Return error
if (!destinationDiskStoreCollection.IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Determine source and destination paths
var sourcePath = Path.Combine(_directoryInfo.FullName, sourceName);
var destinationPath = Path.Combine(destinationDiskStoreCollection._directoryInfo.FullName, destinationName);
// Check if the file already exists
DavStatusCode result;
if (File.Exists(destinationPath))
{
// Remove the file if it already exists (if allowed)
if (!overwrite)
{
return(new StoreItemResult(DavStatusCode.Forbidden));
}
// The file will be overwritten
File.Delete(destinationPath);
result = DavStatusCode.NoContent;
}
else
{
// The file will be "created"
result = DavStatusCode.Created;
}
// Move the file
File.Move(sourcePath, destinationPath);
return(new StoreItemResult(result, new DiskStoreItem(LockingManager, new FileInfo(destinationPath), IsWritable)));
}
else
{
// Attempt to copy the item to the destination collection
var result = await item.CopyAsync(destinationCollection, destinationName, overwrite, httpContext);
if (result.Result == DavStatusCode.Created || result.Result == DavStatusCode.NoContent)
{
await DeleteItemAsync(sourceName, httpContext);
}
// Return the result
return(result);
}
}
// If it's not a plain item, then it's a collection
Debug.Assert(item is DiskStoreCollection);
// Collections will never be moved, but always be created
// (we always move the individual items to make sure locking is checked properly)
throw new InvalidOperationException("Collections should never be moved directly.");
}
private static async Task <DavStatusCode> DeleteItemAsync(IStoreCollection collection, string name, IHttpContext httpContext)
{
// Attempt to delete the item
return(await collection.DeleteItemAsync(name, httpContext).ConfigureAwait(false));
}
public bool SupportsFastMove(IStoreCollection destination, string destinationName, bool overwrite, IHttpContext httpContext)
{
return(false);
}
public virtual Task <StoreItemResult> CopyAsync(IStoreCollection destination, string name, bool overwrite, IHttpContext context)
{
throw new NotImplementedException();
}
public DavDirectory(IStoreCollection parent, IDirectory coll) : base(parent, coll)
{
this.coll = coll;
}
public Task <StoreItemResult> CopyAsync(IStoreCollection destination, string name, bool overwrite, IHttpContext httpContext, CancellationToken cancellationToken)
{
return(Task.FromResult(new StoreItemResult(DavStatusCode.NotImplemented)));
}
public async Task <StoreItemResult> MoveItemAsync(string sourceName, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext)
{
// Return error
if (!IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Determine the object that is being moved
var item = await GetItemAsync(sourceName, httpContext);
if (item == null)
{
return(new StoreItemResult(DavStatusCode.NotFound));
}
var destinationStoreCollection = destinationCollection as MailruStoreCollection;
if (destinationStoreCollection != null)
{
if (!destinationStoreCollection.IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
var itemexist = destinationStoreCollection.FindSubItem(destinationName);
DavStatusCode result;
if (itemexist != null)
{
if (!overwrite)
{
return(new StoreItemResult(DavStatusCode.Forbidden));
}
await Cloud.Instance(httpContext).Remove(itemexist);
result = DavStatusCode.NoContent;
}
else
{
result = DavStatusCode.Created;
}
if (destinationStoreCollection.FullPath == FullPath)
{
await Cloud.Instance(httpContext).Rename(item, destinationName);
}
else
{
if (sourceName == destinationName || string.IsNullOrEmpty(destinationName))
{
await Cloud.Instance(httpContext).Move(item, destinationStoreCollection.FullPath);
}
else
{
var fi = ((MailruStoreItem)item).FileInfo;
string tmpName = Guid.NewGuid().ToString();
await Cloud.Instance(httpContext).Rename(item, tmpName);
fi.SetName(tmpName);
await Cloud.Instance(httpContext).Move(fi, destinationStoreCollection.FullPath);
fi.SetPath(destinationStoreCollection.FullPath);
await Cloud.Instance(httpContext).Rename(fi, destinationName);
}
}
return(new StoreItemResult(result, new MailruStoreItem(LockingManager, null, IsWritable)));
}
else
{
// Attempt to copy the item to the destination collection
var result = await item.CopyAsync(destinationCollection, destinationName, overwrite, httpContext);
if (result.Result == DavStatusCode.Created || result.Result == DavStatusCode.NoContent)
{
await DeleteItemAsync(sourceName, httpContext);
}
return(result);
}
}
public DavFile(IStoreCollection parent, IFile doc) : base(parent, doc)
{
this.doc = doc;
}
protected DavEntry(IStoreCollection parent, IEntry entry)
{
this.parent = parent;
this.entry = entry;
}
public async Task <StoreItemResult> MoveItemAsync(string sourceName, IStoreCollection destinationCollection, string destinationName, bool overwrite, IHttpContext httpContext)
{
// Return error
if (!IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Determine the object that is being moved
var item = await GetItemAsync(sourceName, httpContext).ConfigureAwait(false);
if (item == null)
{
return(new StoreItemResult(DavStatusCode.NotFound));
}
// If the destination collection is a directory too, then we can simply move the file
if (destinationCollection is DiskStoreCollection destinationDiskStoreCollection)
{
// Return error
if (!destinationDiskStoreCollection.IsWritable)
{
return(new StoreItemResult(DavStatusCode.PreconditionFailed));
}
// Determine source and destination paths
var sourcePath = Path.Combine(_directoryInfo.FullName, sourceName);
var destinationPath = Path.Combine(destinationDiskStoreCollection._directoryInfo.FullName, destinationName);
// Check if the file already exists
DavStatusCode result;
if (File.Exists(destinationPath))
{
// Remove the file if it already exists (if allowed)
if (!overwrite)
{
return(new StoreItemResult(DavStatusCode.Forbidden));
}
// The file will be overwritten
File.Delete(destinationPath);
result = DavStatusCode.NoContent;
}
else if (Directory.Exists(destinationPath))
{
// Remove the directory if it already exists (if allowed)
if (!overwrite)
{
return(new StoreItemResult(DavStatusCode.Forbidden));
}
// The file will be overwritten
Directory.Delete(destinationPath, true);
result = DavStatusCode.NoContent;
}
else
{
// The file will be "created"
result = DavStatusCode.Created;
}
switch (item)
{
case DiskStoreItem _:
// Move the file
File.Move(sourcePath, destinationPath);
return(new StoreItemResult(result, new DiskStoreItem(LockingManager, new FileInfo(destinationPath), IsWritable)));
case DiskStoreCollection _:
// Move the directory
Directory.Move(sourcePath, destinationPath);
return(new StoreItemResult(result, new DiskStoreCollection(LockingManager, new DirectoryInfo(destinationPath), IsWritable)));
default:
// Invalid item
Debug.Fail($"Invalid item {item.GetType()} inside the {nameof(DiskStoreCollection)}.");
return(new StoreItemResult(DavStatusCode.InternalServerError));
}
}
else
{
// Attempt to copy the item to the destination collection
var result = await item.CopyAsync(destinationCollection, destinationName, overwrite, httpContext).ConfigureAwait(false);
if (result.Result == DavStatusCode.Created || result.Result == DavStatusCode.NoContent)
{
await DeleteItemAsync(sourceName, httpContext).ConfigureAwait(false);
}
// Return the result
return(result);
}
}
public StoreCollectionResult(DavStatusCode result, IStoreCollection collection = null)
{
Result = result;
Collection = collection;
}
private async Task <DavStatusCode> DeleteItemAsync(IStoreCollection collection, string name, IHttpContext httpContext, Uri baseUri, UriResultCollection errors)
{
// Attempt to delete the item
return(await collection.DeleteItemAsync(name, httpContext).ConfigureAwait(false));
}
