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