/// <param name="observer">To be added.</param>
/// <param name="startPage">To be added.</param>
/// <summary>To be added.</summary>
/// <remarks>To be added.</remarks>
public void EnumerateItems(INSFileProviderEnumerationObserver observer, NSData startPage)
{
try
{
FolderMetadata metadata = storageManager.GetFolderMetadata(this.enumeratedItemIdentifier);
if (!metadata.IsExists)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreateNonExistentItemError(enumeratedItemIdentifier));
return;
}
ItemMetadata[] metadatas = this.storageManager.GetFolderChildrenMetadatas(metadata);
this.SyncAnchor = this.synchronizationSimulator.AddChangeSet(metadatas);
INSFileProviderItem[] items = ProviderItem.CreateFromMetadatas(metadatas);
observer.DidEnumerateItems(items);
observer.FinishEnumerating((NSData)null);
}
catch (UnauthorizedException)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreatesNotAuthenticatedError());
}
catch (WebDavHttpException)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedNetworkError());
}
catch (Exception)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedError());
}
}
public static void FolderSuccess(FolderMetadata folder, string rename)
{
SuccessBlock("FOLDER RENAMED");
Console.WriteLine($"[{GrayedText(folder.ParentDirectory)}]");
Console.WriteLine(GrayedText(folder.Name));
Console.WriteLine(SuccessText($"{rename}\n"));
}
/// <summary>
/// Gets a user file system item info from the remote storage data.
/// </summary>
/// <param name="remoteStorageItem">Remote storage item info.</param>
/// <returns>User file system item info.</returns>
public static IFileSystemItemMetadata GetUserFileSysteItemMetadata(FileSystemInfo remoteStorageItem)
{
IFileSystemItemMetadata userFileSystemItem;
if (remoteStorageItem is FileInfo)
{
userFileSystemItem = new FileMetadata();
((FileMetadata)userFileSystemItem).Length = ((FileInfo)remoteStorageItem).Length;
}
else
{
userFileSystemItem = new FolderMetadata();
}
// Store you item ID here. It will be passed to IEngine.GetFileSystemItemAsync() during every operation.
// Note that the file is deleted during MS Office transactional save and iten ID will be deleted with it.
// See Virtual Drive sample for MS Office documents editing.
userFileSystemItem.ItemId = WindowsFileSystemItem.GetItemIdByPath(remoteStorageItem.FullName);
userFileSystemItem.Name = remoteStorageItem.Name;
userFileSystemItem.Attributes = remoteStorageItem.Attributes;
userFileSystemItem.CreationTime = remoteStorageItem.CreationTime;
userFileSystemItem.LastWriteTime = remoteStorageItem.LastWriteTime;
userFileSystemItem.LastAccessTime = remoteStorageItem.LastAccessTime;
userFileSystemItem.ChangeTime = remoteStorageItem.LastWriteTime;
return(userFileSystemItem);
}
protected Folder <string> ToFolder(FolderMetadata dropboxFolder)
{
if (dropboxFolder == null)
{
return(null);
}
if (dropboxFolder is ErrorFolder)
{
//Return error entry
return(ToErrorFolder(dropboxFolder as ErrorFolder));
}
var isRoot = IsRoot(dropboxFolder);
var folder = GetFolder();
folder.ID = MakeId(dropboxFolder);
folder.FolderID = isRoot ? null : MakeId(GetParentFolderPath(dropboxFolder));
folder.CreateOn = isRoot ? ProviderInfo.CreateOn : default;
folder.ModifiedOn = isRoot ? ProviderInfo.CreateOn : default;
folder.Title = MakeFolderTitle(dropboxFolder);
if (folder.CreateOn != DateTime.MinValue && folder.CreateOn.Kind == DateTimeKind.Utc)
{
folder.CreateOn = TenantUtil.DateTimeFromUtc(folder.CreateOn);
}
if (folder.ModifiedOn != DateTime.MinValue && folder.ModifiedOn.Kind == DateTimeKind.Utc)
{
folder.ModifiedOn = TenantUtil.DateTimeFromUtc(folder.ModifiedOn);
}
return(folder);
}
/// <param name="fileUrl">The URL for the file.</param>
/// <param name="parentItemIdentifier">The parent directory's persistent identifier.</param>
/// <param name="completionHandler">A handler to run after the operation completes.</param>
/// <summary>When implemented by the developer, imports the resource at the specified <paramref name="fileUrl" /> into the directory that is identified by <paramref name="parentItemIdentifier" />.</summary>
/// <remarks>
/// <para>(More documentation for this node is coming)</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void ImportDocument(NSUrl fileUrl, string parentItemIdentifier, Action <INSFileProviderItem, NSError> completionHandler)
{
try
{
fileUrl.StartAccessingSecurityScopedResource();
FolderMetadata parentMetadata = StorageManager.GetFolderMetadata(parentItemIdentifier);
if (!parentMetadata.IsExists)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateNonExistentItemError(parentItemIdentifier));
return;
}
IEnumerable <string> existsNames = StorageManager.GetFolderChildrenMetadatas(parentMetadata).Select(x => x.Name);
string fileName = GetNewFileName(fileUrl.LastPathComponent, existsNames);
FileMetadata createdFile = StorageManager.CreateFileOnServer(parentMetadata, fileName);
createdFile = StorageManager.WriteFileContentOnServer(createdFile, fileUrl.Path);
completionHandler?.Invoke(ProviderItem.CreateFromMetadata(createdFile), null);
this.StorageManager.NotifyEnumerator(parentItemIdentifier);
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(null, error);
}
finally
{
fileUrl.StopAccessingSecurityScopedResource();
}
}
/// <param name="itemIdentifier">The persistent identifier for the item.</param>
/// <param name="destParentItemIdentifier">The parent directory's persistent identifier.</param>
/// <param name="newName">
/// <para>The new name for the item.</para>
/// <para tool="nullallowed">This parameter can be <see langword="null" />.</para>
/// </param>
/// <param name="completionHandler">A handler to run after the operation completes.</param>
/// <summary>When implemented by the developer, moves the identified item to a new name under a new parent.</summary>
/// <remarks>
/// <para>(More documentation for this node is coming)</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void ReparentItem(string itemIdentifier, string destParentItemIdentifier, string newName, Action <INSFileProviderItem, NSError> completionHandler)
{
try
{
ItemMetadata item = this.StorageManager.GetItemMetadata(itemIdentifier);
FolderMetadata destinationFolder = this.StorageManager.GetFolderMetadata(destParentItemIdentifier);
string name = newName ?? item.Name;
this.StorageManager.MoveItem(item, destinationFolder, name);
// Only item's name and parent identifier should be changed.
string oldParentIdentifier = item.ParentIdentifier;
item.ParentIdentifier = destParentItemIdentifier;
item.Name = name;
completionHandler(ProviderItem.CreateFromMetadata(item), null);
this.StorageManager.NotifyEnumerator(oldParentIdentifier, item.ParentIdentifier);
}
catch (PreconditionFailedException)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateFilenameCollisionError());
}
catch (ForbiddenException)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateFilenameCollisionError());
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(null, error);
}
}
public DropBoxFolder(FolderMetadata metadata)
{
FolderMetadata = metadata;
Name = metadata.Name;
FullName = metadata.PathDisplay;
Elements = new List <DropBoxElement>();
}
/// <param name="directoryName">The directory name.</param>
/// <param name="parentItemIdentifier">The parent directory's persistent identifier.</param>
/// <param name="completionHandler">A handler to run after the operation completes.</param>
/// <summary>When implemented by the developer, creates a new directory in the specified location and runs a handler when the operation is complete.</summary>
/// <remarks>
/// <para>(More documentation for this node is coming)</para>
/// <para tool="threads">This can be used from a background thread.</para>
/// </remarks>
public override void CreateDirectory(string directoryName, string parentItemIdentifier, Action <INSFileProviderItem, NSError> completionHandler)
{
try
{
FolderMetadata parentFolder = this.StorageManager.GetFolderMetadata(parentItemIdentifier);
if (!parentFolder.ExistsOnServer)
{
completionHandler?.Invoke(null, NSErrorFactory.CreateUnspecifiedError());
return;
}
FolderMetadata createdFolder = this.StorageManager.CreateFolderOnServer(parentFolder, directoryName);
completionHandler?.Invoke(ProviderItem.CreateFromMetadata(createdFolder), null);
this.StorageManager.NotifyEnumerator(parentItemIdentifier);
}
catch (MethodNotAllowedException)
{
completionHandler?.Invoke(null, NSFileProviderErrorFactory.CreateFilenameCollisionError());
}
catch (Exception ex)
{
NSError error = this.MapError(ex);
completionHandler?.Invoke(null, error);
}
}
public void EnumerateChanges(INSFileProviderChangeObserver observer, NSData syncAnchor)
{
uint anchor = GetAnchorFromNsData(syncAnchor);
try
{
FolderMetadata metadata = storageManager.GetFolderMetadata(this.enumeratedItemIdentifier);
if (!metadata.IsExists)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreateNonExistentItemError(enumeratedItemIdentifier));
return;
}
ItemMetadata[] metadatas = this.storageManager.GetFolderChildrenMetadatas(metadata);
ChangeSet diff = this.synchronizationSimulator.GetDiff(anchor, metadatas);
observer.DidDeleteItems(diff.DeletedId);
INSFileProviderItem[] updatedItems = ProviderItem.CreateFromMetadatas(diff.Updated);
observer.DidUpdateItems(updatedItems);
this.SyncAnchor = this.synchronizationSimulator.AddChangeSet(metadatas);
observer.FinishEnumeratingChanges(this.GetCurrentAnchorNsData(this.SyncAnchor), false);
}
catch (UnauthorizedException)
{
observer.FinishEnumerating(NSFileProviderErrorFactory.CreatesNotAuthenticatedError());
}
catch (WebDavHttpException)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedNetworkError());
}
catch (Exception)
{
observer.FinishEnumerating(NSErrorFactory.CreateUnspecifiedError());
}
}
private async void CreateRequest_Button_Click(object sender, RoutedEventArgs e)
{
Metadata selectedItem = DropboxFolderContent.SelectedIndex > -1 ? ((Metadata)DropboxFolderContent.SelectedItem) : null;
if (selectedItem == null)
{
return;
}
if (selectedItem.IsFile)
{
MessageBox.Show("This is a file. Please select a folder to create an upload request.");
return;
}
if (selectedItem.IsDeleted)
{
MessageBox.Show("This item has been deleted. I don't even know why it's displaying here. I don't even know why I'm making this error, you should never see it... In fact it might be possible to share the file, I haven't checked. I'm just not going to let you try.");
return;
}
FolderMetadata folder = selectedItem.AsFolder;
if (folder == null)
{
return;
}
await GetFileRequestLink(folder);
}
public void UpdateFolderMetaData(FolderMetadata folderMetadata)
{
var folder = _folderContentFolderRepository.GetFolder(folderMetadata.Name, folderMetadata.Path);
folder.SortType = folderMetadata.SortType;
folder.NumberOfElementPerPage = folderMetadata.NumberOfPagesPerPage;
_folderContentFolderRepository.CreateOrUpdateFolder(folderMetadata.Name, folderMetadata.Path, folder);
}
public static void FolderRenameConflict(FolderMetadata folder, string rename)
{
WarningBlock("FOLDER RENAME CONFLICT");
Console.WriteLine($"[{GrayedText(folder.ParentDirectory)}]");
Console.WriteLine(GrayedText(folder.Name));
Console.WriteLine(WarningText($"{rename}"));
Console.WriteLine("Folder with same name already exists. Fix manually.\n");
}
public FolderItem(FolderMetadata createdFolder) : base(createdFolder)
{
TypeIdentifier = UTTypeHelper.GetFolderTypeIdentifier();
this.Capabilities = NSFileProviderItemCapabilities.AddingSubItems
| NSFileProviderItemCapabilities.ContentEnumerating
| NSFileProviderItemCapabilities.Reading
| NSFileProviderItemCapabilities.Renaming
| NSFileProviderItemCapabilities.Deleting;
}
protected String MakeFolderTitle(FolderMetadata dropboxFolder)
{
if (dropboxFolder == null || IsRoot(dropboxFolder))
{
return(DropboxProviderInfo.CustomerTitle);
}
return(Global.ReplaceInvalidCharsAndTruncate(dropboxFolder.Name));
}
private async Task GetFileRequestLink(FolderMetadata folder)
{
FileRequest fileRequest = await DropboxHandler.HandleCreateFileRequest(client, folder.PathLower, folder.Name, DateTime.Now + new TimeSpan(7, 0, 0, 0));
if (fileRequest == null)
{
return;
}
RequestLink_TextBox.Text = fileRequest.Url;
}
public static void SimplifyFolder(JsonConfig prefs, string fullPath, ref Counter counter)
{
// Create folder metadata object [creates an immutable object (record)]
var folder = new FolderMetadata(fullPath.Replace('\\', '/'));
string rename = folder.Name;
ApplySimplificationFunctions(ref rename, prefs);
// Full address of processed filename
string simplifiedFolderAddress = $"{folder.ParentDirectory}/{rename}";
// Already simplified form
if (folder.Name == rename)
{
Print.NoFolderChangeRequired(folder);
counter.Unchanged++;
}
// Rename conflict
else if (File.Exists(simplifiedFolderAddress))
{
// Check for Windows specific case-insensitive directory
if (string.Equals(folder.Name, rename, StringComparison.OrdinalIgnoreCase))
{
if (prefs.MakeChangesPermanent)
{
Directory.Move(folder.FullPath, $"{folder.FullPath}_TEMP_SIMPLIFY_RENAME");
Directory.Move($"{folder.FullPath}_TEMP_SIMPLIFY_RENAME", simplifiedFolderAddress);
}
Print.FolderSuccess(folder, rename);
counter.Renamed++;
}
// Actual conflict
else
{
Print.FolderRenameConflict(folder, rename);
counter.Conflict++;
}
}
// Can be renamed without any conflict
else
{
Print.FolderSuccess(folder, rename);
if (prefs.MakeChangesPermanent)
{
Directory.Move(folder.FullPath, simplifiedFolderAddress);
}
counter.Renamed++;
}
}
public static async Task <FolderMetadata> HandleCreateFolder(DropboxClient client, string path)
{
FolderMetadata currentFolder = await GetFolder(client, path);
if (currentFolder == null)
{
return(await CreateFolder(client, path));
}
else
{
return(currentFolder);
}
}
private async void CreateFolder_Button_Click(object sender, RoutedEventArgs e)
{
string path = String.Format("/ExternalUpload/Cloud Data/{0} - {1}", CreateFolder_AccountName_TextBox.Text, CreateFolder_TicketNumber_TextBox.Text);
FolderMetadata folder = await DropboxHandler.HandleCreateFolder(client, path);
if (folder == null)
{
return;
}
await ChangeToFolder(client, "/ExternalUpload/Cloud Data/");
await GetFileRequestLink(folder);
}
public static object ToSerialisable(FolderMetadata f)
{
return(new
{
Id = f.Id,
IsDeleted = f.IsDeleted,
IsFile = f.IsFile,
IsFolder = f.IsFolder,
Name = f.Name,
ParentSharedFolderId = f.ParentSharedFolderId,
PathDisplay = f.PathDisplay,
PathLower = f.PathLower,
SharedFolderId = f.SharedFolderId,
SharingInfo = f.SharingInfo
});
}
protected Folder ToFolder(FolderMetadata dropboxFolder)
{
if (dropboxFolder == null)
{
return(null);
}
if (dropboxFolder is ErrorFolder)
{
//Return error entry
return(ToErrorFolder(dropboxFolder as ErrorFolder));
}
var isRoot = IsRoot(dropboxFolder);
var folder = new Folder
{
ID = MakeId(dropboxFolder),
ParentFolderID = isRoot ? null : MakeId(GetParentFolderPath(dropboxFolder)),
CreateBy = DropboxProviderInfo.Owner,
CreateOn = isRoot ? DropboxProviderInfo.CreateOn : default(DateTime),
FolderType = FolderType.DEFAULT,
ModifiedBy = DropboxProviderInfo.Owner,
ModifiedOn = isRoot ? DropboxProviderInfo.CreateOn : default(DateTime),
ProviderId = DropboxProviderInfo.ID,
ProviderKey = DropboxProviderInfo.ProviderKey,
RootFolderCreator = DropboxProviderInfo.Owner,
RootFolderId = MakeId(),
RootFolderType = DropboxProviderInfo.RootFolderType,
Shareable = false,
Title = MakeFolderTitle(dropboxFolder),
TotalFiles = 0,
TotalSubFolders = 0,
};
if (folder.CreateOn != DateTime.MinValue && folder.CreateOn.Kind == DateTimeKind.Utc)
{
folder.CreateOn = TenantUtil.DateTimeFromUtc(folder.CreateOn);
}
if (folder.ModifiedOn != DateTime.MinValue && folder.ModifiedOn.Kind == DateTimeKind.Utc)
{
folder.ModifiedOn = TenantUtil.DateTimeFromUtc(folder.ModifiedOn);
}
return(folder);
}
public static FileItem Create(FolderMetadata dbxFolder)
{
return(new FileItem
{
Source = FileService.Dropbox,
IsFolder = true,
IsDeleted = dbxFolder.IsDeleted,
Name = dbxFolder.Name,
Path = dbxFolder.PathDisplay,
Id = dbxFolder.Id,
ServerRev = string.Empty,
Size = 0,
LastModified = DateTime.MinValue,
ClientModified = DateTime.MinValue,
Object = dbxFolder
});
}
public DropBoxProvider(string accessToken, string baseFolder)
{
var httpClient = new HttpClient()
{
Timeout = TimeSpan.FromMinutes(20)
};
var config = new DropboxClientConfig("SimpleTestApp")
{
HttpClient = httpClient
};
_client = new DropboxClient(accessToken, config);
FolderMetadata folder = CreateFolder(baseFolder).Result;
_baseFolder = baseFolder;
}
public async Task LoadFor(String folder, DropboxClient client)
{
if (client == null)
{
throw new NullReferenceException(nameof(client));
}
var elements = await client.Files.ListFolderAsync(folder);
if (!folders.ContainsKey(folder))
{
try
{
if (folder != "")
{
FolderMetadata folderMetadata = (await client.Files.GetMetadataAsync(new GetMetadataArg(folder))).AsFolder;
folders.Add(folder, new DropBoxFolder(folderMetadata));
}
else
{
folders.Add(folder, new DropBoxFolder(folder));
}
}
catch (Exception exception)
{
Console.WriteLine(exception);
return;
}
}
foreach (var element in elements.Entries)
{
if (element.IsFile)
{
folders[folder].Elements.Add(new DropBoxFile(element.AsFile));
}
else
{
await LoadFor(element.PathDisplay, client);
folders[folder].Elements.Add(folders[element.PathDisplay]);
}
}
}
public FolderMetadata CreateFolder(String path)
{
PathArg pa = new PathArg();
pa.path = path;
var url = string.Format("{0}/files/create_folder", API_URL);
try
{
FolderMetadata fm = PostAndGetJSONData <FolderMetadata>(url, pa);
return(fm);
}
catch (Exception ex)
{
handleDropboxException(ex);
throw;
}
}
public async Task <IResult <Void> > UpdateFolderMetaData(FolderMetadata folderMetadata)
{
var pathResult = PathManager.Combine(folderMetadata.Path, folderMetadata.Name);
if (!pathResult.IsSuccess)
{
return(new FailureResult(pathResult.Exception));
}
var folderResult = FolderProvider.GetFolder(pathResult.Data);
if (!folderResult.IsSuccess)
{
return(new FailureResult(folderResult.Exception));
}
folderResult.Data.SortType = folderMetadata.SortType;
folderResult.Data.NumberOfElementToShowOnPage = folderMetadata.NumberOfPagesPerPage;
return(await folderResult.Data.SaveAsync());
}
/// <summary>
/// Creates the specified folder.
/// </summary>
/// <remarks>This demonstrates calling an rpc style api in the Files namespace.</remarks>
/// <param name="path">The path of the folder to create.</param>
/// <param name="client">The Dropbox client.</param>
/// <returns>The result from the ListFolderAsync call.</returns>
private static FolderMetadata CreateFolder(DropboxClient client, string path)
{
FolderMetadata folder = null;
try
{
folder = client.Files.GetMetadataAsync(path).Result as FolderMetadata;
}
catch (Exception ex)
{
if (ex.InnerException is ApiException <GetMetadataError> && ((ex.InnerException as ApiException <GetMetadataError>).ErrorResponse as GetMetadataError.Path).Value is LookupError.NotFound)
{
var folderArg = new CreateFolderArg(path);
folder = client.Files.CreateFolderV2Async(folderArg).Result.Metadata;
}
else
{
throw;
}
}
return(folder);
}
//create dir
private async void button4_Click(object sender, EventArgs e)
{
try
{
CreateDir cd = new CreateDir();
string path = treeView1.SelectedNode.FullPath;
path = path.Replace("\\", "/");
path = path.Remove(0, 4);
if (cd.ShowDialog(this) == DialogResult.OK)
{
if (cd.richTextBox1.Text.Equals(string.Empty))
{
MessageBox.Show("Directory name cant be empty", "Error", MessageBoxButtons.OK);
}
else
{
path += "/" + cd.richTextBox1.Text;
}
}
toolStripStatusLabel1.Text = "Creating directory...";
FolderMetadata metadata = await client.Files.CreateFolderAsync(new CreateFolderArg(path));
if (!metadata.Name.Equals(string.Empty))
{
toolStripStatusLabel1.Text = "Creating directory succeed!";
}
button3_Click(sender, e);
//cd.Close();
cd.Dispose();
}
catch (NullReferenceException er)
{
MessageBox.Show("Choose branch were to create dir first ", "Error", MessageBoxButtons.OK);
}
catch (Exception err)
{
MessageBox.Show(err.Message, "Error", MessageBoxButtons.OK);
}
}
//Dropbox Get All Folder/Files
public async Task Run()
{
//Get all files and folders from dropbox
//bool isNoFile = false;
File.Delete(list);
using (var _c = new DropboxClient(SoulDB.GetAccessTokenFromFile())) {
var listOfFoldrs = await _c.Files.ListFolderAsync(string.Empty, true);
//get the number of folders on dropbox
int x = listOfFoldrs.Entries.Count;
//4 is the number of folder generated by the app
//Darksouls, DarkSoulsII, DarkSOulsIII, Sekiro
if (x > 4)
{
FolderMetadata FolderInfo = new FolderMetadata();
FileMetadata FileInfo = new FileMetadata();
foreach (var item in listOfFoldrs.Entries)
{
try {
if (item.IsFile)
{
FileInfo = (FileMetadata)item;
File.WriteToTextFile(FileInfo.PathDisplay.ToString(), list);
}
} catch (Exception ex) {
throw;
}
}
}
else
{
MessageBox.Show("There were no files", "Soul Save", MessageBoxButtons.OK, MessageBoxIcon.Information);;
}
}
}
private static async Task <FolderMetadata> createFolder(string path, string folderName)
{
FolderMetadata folder = null;
try
{
clientConf = new DropboxClientConfig("ScandaV1");
client = new DropboxClient(APITOKEN);
folder = await client.Files.CreateFolderAsync("/" + path + "/" + folderName);
}
catch (ApiException <CreateFolderError> ex)
{
CreateFolderError err = ex.ErrorResponse;
if (err.AsPath.Value.IsConflict)
{
Console.WriteLine("Nombre Conflictivo");
}
if (err.AsPath.Value.IsInsufficientSpace)
{
Console.WriteLine("No hay Espacio");
}
if (err.AsPath.Value.IsNoWritePermission)
{
Console.WriteLine("No hay PErmisos de Escritura");
}
if (err.AsPath.Value.IsMalformedPath)
{
Console.WriteLine("Ruta Invalida");
}
}
catch (Exception)
{
Console.WriteLine("Fallo Desconocido");
}
return(folder);
}
/// <summary>
/// Gets a user file system item info from the remote storage data.
/// </summary>
/// <param name="remoteStorageItem">Remote storage item info.</param>
/// <returns>User file system item info.</returns>
public static IFileSystemItemMetadata GetUserFileSysteItemMetadata(FileSystemInfo remoteStorageItem)
{
IFileSystemItemMetadata userFileSystemItem;
if (remoteStorageItem is FileInfo)
{
userFileSystemItem = new FileMetadata();
((FileMetadata)userFileSystemItem).Length = ((FileInfo)remoteStorageItem).Length;
}
else
{
userFileSystemItem = new FolderMetadata();
}
userFileSystemItem.Name = remoteStorageItem.Name;
userFileSystemItem.Attributes = remoteStorageItem.Attributes;
userFileSystemItem.CreationTime = remoteStorageItem.CreationTime;
userFileSystemItem.LastWriteTime = remoteStorageItem.LastWriteTime;
userFileSystemItem.LastAccessTime = remoteStorageItem.LastAccessTime;
userFileSystemItem.ChangeTime = remoteStorageItem.LastWriteTime;
return(userFileSystemItem);
}
