public async Task CopyTo(MusicFileDo sourceFile, IFolder targetFolder) { var sourceFileService = driveServiceFactory.GetService(sourceFile.DriveType, sourceFile.Root); var targetDriveService = driveServiceFactory.GetService(targetFolder.DriveType, targetFolder.Root); var fs = new DriveFile(sourceFile.FileId, sourceFile.Name, sourceFile.Root, sourceFile.DriveType, sourceFile.Length); var sourceStream = await sourceFileService.GetFileContentStreamAsync(fs); var name = Guid.NewGuid() + sourceFileService.GetExtension(sourceFile.FileId); var targetFile = await targetDriveService.CopyToAsync(targetFolder, sourceStream, name); var targetMusicFile = new MusicFileDo { TrackId = sourceFile.TrackId, FileId = targetFile.Id, DriveType = targetFile.DriveType, Length = targetFile.Size, Name = targetFile.Name, Root = targetFile.Root, MachineId = MusicLibraryData.MachineId }; await context.MusicFileRepository.Save(new List <MusicFileDo> { targetMusicFile }); }
public override async Task DownloadFileAsync(DriveFile driveFile, Stream output, CancellationToken token) { using (var input = ((LocalFile)driveFile).File.OpenRead()) { await Common.CopyStreamAsync(input, output, token); } }
public WorkerRequest(HttpRequest request, DriveFile file, string virtualDir, string physicalDir) { this.request = request; this.file = file; this.virtualDir = virtualDir; this.physicalDir = physicalDir; }
public string f_uploadFile(DriveFile df) { if (this._authenticator == null || this._driveService == null) { return(JsonConvert.SerializeObject(new { Ok = false, tokenAccess = this._token, File = df, Message = "redirect user to authentication" })); } try { // File's metadata. Google.Apis.Drive.v2.Data.File body = new Google.Apis.Drive.v2.Data.File(); body.Title = df.title; body.Description = df.description; body.MimeType = df.mimeType; byte[] byteArray = Encoding.ASCII.GetBytes(df.content); MemoryStream stream = new MemoryStream(byteArray); FilesResource.InsertMediaUpload request = this._driveService.Files.Insert(body, stream, df.mimeType); request.Upload(); Google.Apis.Drive.v2.Data.File file = request.ResponseBody; Permission newPermission = new Permission(); newPermission.Type = "anyone"; newPermission.Role = "reader"; newPermission.Value = ""; newPermission.WithLink = true; this._driveService.Permissions.Insert(newPermission, file.Id).Fetch(); return(JsonConvert.SerializeObject(new { Ok = false, tokenAccess = this._token, File = new DriveFile(file, df.content) })); } catch (Exception e) { return(JsonConvert.SerializeObject(new { Ok = false, tokenAccess = this._token, Message = e.Message, File = df })); } }
public object Resolve(object source, Dictionary <String, IResolver> resolvers = null, Boolean recursive = false) { var result = new DriveRootFolder(); var driveItems = source.GetPublicInstancePropertyValue("DriveItems") ?? source.GetPublicInstancePropertyValue("Items"); var driveFolderTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.DriveFolder, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}"; var driveFolderType = Type.GetType(driveFolderTypeName, true); var driveFileTypeName = $"{PnPSerializationScope.Current?.BaseSchemaNamespace}.DriveFile, {PnPSerializationScope.Current?.BaseSchemaAssemblyName}"; var driveFileType = Type.GetType(driveFileTypeName, true); if (null != driveItems) { foreach (var d in ((IEnumerable)driveItems)) { if (driveFolderType.IsInstanceOfType(d)) { // If the item is a Folder var targetItem = new DriveFolder(); PnPObjectsMapper.MapProperties(d, targetItem, resolvers, recursive); result.DriveFolders.Add(targetItem); } else if (driveFileType.IsInstanceOfType(d)) { // Else if the item is a File var targetItem = new DriveFile(); PnPObjectsMapper.MapProperties(d, targetItem, resolvers, recursive); result.DriveFiles.Add(targetItem); } } } return(result); }
public override async Task <DriveFile> UploadFileAsync(System.IO.Stream stream, string fileName, DriveFile destFolder, string storageFileId, CancellationToken token) { var props = new List <Property> { new Property { Key = string.Format("{0}.sid", Storage.Kind), Value = Storage.Id, Visibility = "PRIVATE" }, new Property { Key = "src", Value = Storage.Kind, Visibility = "PRIVATE" } }; // // // Storage file ID. var storageFileIdPropertyKeyLen = string.Format(StorageFileIdFormat, Storage.Kind, 0).Length; var storageFileIdPropertyValueLen = GoogleFile.PropertyMaxLength - storageFileIdPropertyKeyLen; var storageFileIdParts = Common.SplitBy(storageFileId ?? "", storageFileIdPropertyValueLen); if (storageFileIdParts.Length > 9) { throw new Exception("Storage file ID is too long"); } props.AddRange(storageFileIdParts.Select((t, i) => new Property { Key = string.Format(StorageFileIdFormat, Storage.Kind, i), Value = t, Visibility = "PRIVATE" })); return(await UploadFileAsync(stream, fileName, (GoogleFile)destFolder, props, token)); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public override async Task <DriveFile> CreateFolderAsync(string folderName, DriveFile destFolder, CancellationToken token) #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously { var dir = Directory.CreateDirectory(((LocalFile)destFolder).file.FullName + Path.DirectorySeparatorChar + folderName); return(LocalFileFactory.Instance.Create(this, dir, false)); }
public override Task <ICollection <DriveFile> > GetSubfoldersAsync(DriveFile driveFolder, CancellationToken token) { var folder = (GlacierPseudoFile)driveFolder; var files = folder.Element.Elements("folder").Select(x => new GlacierPseudoFile(this, x)).Cast <DriveFile>().ToList(); return(Task.FromResult <ICollection <DriveFile> >(files)); }
public override async Task DownloadFileAsync(DriveFile driveFile, System.IO.Stream fileStream, CancellationToken token) { var url = ((GoogleFile)driveFile).File.DownloadUrl; if (url == null) { throw new TaskException("Can't download this file"); } var service = await GetServiceAsync(token); var stream = await service.HttpClient.GetStreamAsync(url); if (stream == null) { throw new Exception("Can't download this file"); } var buffer = new byte[1000]; var n = await stream.ReadAsync(buffer, 0, buffer.Length, token); while (n > 0) { await fileStream.WriteAsync(buffer, 0, n, token); n = await stream.ReadAsync(buffer, 0, buffer.Length, token); } }
public override async Task DownloadFileAsync(DriveFile driveFile, string destFolder, ActionIfFileExists actionIfFileExists, CancellationToken token) { // TODO: use actionIfFileExists using (var output = File.OpenWrite(destFolder + Path.DirectorySeparatorChar + driveFile.Name)) { await DownloadFileAsync(driveFile, output, token); } }
private void ServePHPImage(HttpRequest request, DriveFile file) { request.Response.ContentType = MiniHttpd.ContentTypes.GetExtensionType(".gif"); request.Response.ResponseContent = Assembly.GetExecutingAssembly().GetManifestResourceStream( request.Uri.AbsoluteUri.IndexOf("PHPE9568F34") > 0 ? "MiniHttpd.Php.php.gif" : "MiniHttpd.Php.zend1.gif"); }
private void FilesList_ItemSelected(object sender, SelectedItemChangedEventArgs e) { DriveFile file = e.SelectedItem as DriveFile; GlobalConfig.Instance.Properties[GlobalConfig.Options.DSaveFolderId] = file.Id; GlobalConfig.Instance.Properties[GlobalConfig.Options.DSaveFolderName] = file.Name; GlobalConfig.Instance.Save(); Navigation.PopAsync(); }
/// <summary> /// 根据id获取项目 /// </summary> /// <param name="id"></param> /// <returns></returns> public async Task <DriveFile> GetDriveItemById(string id, string siteName = "onedrive") { string siteId = GetSiteId(siteName); var drive = (siteName != "onedrive") ? graph.Sites[siteId].Drive : graph.Me.Drive; var result = await drive.Items[id].Request().GetAsync(); DriveFile file = GetItem(result); return(file); }
public override async Task EnumerateFilesRecursive(DriveFile driveFolder, Action <DriveFile> action, CancellationToken token) { await Task.Run(() => { foreach (var file in ((LocalFile)driveFolder).Directory.EnumerateFiles()) { action(LocalFileFactory.Instance.Create(this, file, false)); } }); }
public override async Task EnumerateFilesRecursive(DriveFile driveFolder, Action<DriveFile> action, CancellationToken token) { await Task.Run(() => { foreach (var file in ((LocalFile)driveFolder).Directory.EnumerateFiles()) { action(LocalFileFactory.Instance.Create(this, file, false)); } }); }
public DownloadProgressBar(DriveFile file, IMediaDownloader mediaDownloader) : base(file.Size, file.Name.Length, '─') { _file = file; Refresh(0, _file.Name); _mediaDownloader = mediaDownloader; _mediaDownloader.ProgressChanged += OnProgressChanged; }
public override async Task<ICollection<DriveFile>> GetSubfoldersAsync(DriveFile folder, CancellationToken token) { var dir = ((LocalFile)folder).Directory; if (!dir.Exists) { dir.Create(); } return await Task.Run(() => dir.EnumerateDirectories() .Select(file => LocalFileFactory.Instance.Create(this, file, false)) .Cast<DriveFile>().ToList()); }
public override Task EnumerateFilesRecursive(DriveFile driveFolder, Action <DriveFile> action, CancellationToken token) { var folder = (GlacierPseudoFile)driveFolder; var files = folder.Element.Elements("file").Select(x => new GlacierPseudoFile(this, x)); foreach (var f in files) { action(f); } return(Task.FromResult(0)); }
public override async Task <System.IO.Stream> ReadFileAsync(DriveFile file, CancellationToken token) { var service = await GetServiceAsync(token); var gFile = await service.Files.Get(file.Id).ExecuteAsync(token); if (String.IsNullOrEmpty(gFile.DownloadUrl)) { return(null); } return(await service.HttpClient.GetStreamAsync(gFile.DownloadUrl)); }
public override async Task <ICollection <DriveFile> > GetSubfoldersAsync(DriveFile folder, CancellationToken token) { var dir = ((LocalFile)folder).Directory; if (!dir.Exists) { dir.Create(); } return(await Task.Run(() => dir.EnumerateDirectories() .Select(file => LocalFileFactory.Instance.Create(this, file, false)) .Cast <DriveFile>().ToList())); }
#pragma warning disable 1998 public override async Task <Image> GetThumbnailAsync(DriveFile file, CancellationToken token) #pragma warning restore 1998 { var gFile = ((GoogleFile)file).File; if (gFile.Thumbnail == null) { throw new Exception("File has no thumbnail"); } var bytes = Convert.FromBase64String(gFile.Thumbnail.Image); return(new Bitmap(new System.IO.MemoryStream(bytes))); }
public override async Task <Image> GetThumbnailAsync(DriveFile file, CancellationToken token) { if (!((LocalFile)file).IsImage) { return(null); } return(await Task.Run(() => { using (var stream = ((LocalFile)file).File.OpenRead()) { return Image.FromStream(stream); } })); }
public override async Task <DriveFile> CreateFolderAsync(string folderName, DriveFile destFolder, CancellationToken token) { var folder = new File { Title = folderName, MimeType = GoogleMimeTypes.Folder, Parents = new[] { new ParentReference { Id = destFolder.Id } } }; var service = await GetServiceAsync(token); var file = await service.Files.Insert(folder).ExecuteAsync(token); return(new GoogleFile(this, file)); }
public async Task ExecuteAsync(DriveFile driveFile) { foreach (IDriveFileTask task in _googleDriveFileTasks) { try { _logger.LogInformation($"Starting executing '{task.Name}' on file '{driveFile.FullName}'"); await task.ExecuteAsync(driveFile); _logger.LogInformation($"Completed executing '{task.Name}' on file '{driveFile.FullName}'"); } catch (Exception ex) { _logger.LogError(ex, $"Error occurred while executing '{task.Name}' on file '{driveFile.FullName}'"); } } }
/// <summary> /// 根据路径获取项目 /// </summary> /// <param name="path"></param> /// <returns></returns> public async Task <DriveFile> GetDriveItemByPath(string path, string siteName = "onedrive") { string[] imgArray = { ".png", ".jpg", ".jpeg", ".bmp", ".webp" }; string extension = Path.GetExtension(path); var drive = siteName != "onedrive" ? _graph.Sites[GetSiteId(siteName)].Drive : _graph.Me.Drive; //这么写是因为:分块上传图片后直接获取会报错。 if (imgArray.Contains(extension)) { await drive.Root.ItemWithPath(path).Thumbnails.Request().GetAsync(); } var result = await drive.Root.ItemWithPath(path).Request().GetAsync(); DriveFile file = GetItem(result); return(file); }
public override async Task EnumerateFilesRecursive(DriveFile driveFolder, Action <DriveFile> action, CancellationToken token) { var files = await GetFilesAsync(driveFolder, token); foreach (var file in files) { if (file.IsFolder) { await EnumerateFilesRecursive(file, action, token); } else { var f = file; await Task.Run(() => action(f), token); } } }
public override async Task DeleteFolderAsync(DriveFile driveFolder, CancellationToken token) { var service = await GetServiceAsync(token); if (driveFolder.Id == RootId) { var files = await GetFilesAsync(rootFolder, "", token); foreach (var file in files) { await service.Files.Delete(file.Id).ExecuteAsync(token); } } else { await service.Files.Delete(driveFolder.Id).ExecuteAsync(token); } }
public bool UploadFile(HttpPostedFileBase file, string v) { httpClient.DefaultRequestHeaders.Add("Authorization", "Bearer " + v); //httpClient.DefaultRequestHeaders.Add("Content-Type", "multipart/related"); httpClient.BaseAddress = new Uri("https://www.googleapis.com/upload/drive/v3/"); var _file = new DriveFile() { name = Path.GetFileName(file.FileName), mimeType = file.ContentType, parents = new List <string>() { "1crgdmvhinXCTDH-wkRmjFOIxsEhECEQj" } }; HttpRequestMessage httpRequestMessage = new HttpRequestMessage(HttpMethod.Post, "files?uploadType=multipart"); // httpRequestMessage.Headers.Add("Content-Type", "multipart/related"); var ft = new MultipartFormDataContent(); var stContent = new StreamContent(file.InputStream); stContent.Headers.Add("Content-Type", file.ContentType); var json = new StringContent(JsonConvert.SerializeObject(_file), Encoding.UTF8, "application/json"); //json.Headers.Add("Content-Type", "Application/json"); ft.Add(json); ft.Add(stContent); httpRequestMessage.Content = ft; //var multi = new MultipartContent(); //multi.Add() //var fileUploadTask = httpClient.PostAsync("files?uploadType=multipart", ft); var fileUploadTask = httpClient.SendAsync(httpRequestMessage); var fileUploadResponse = fileUploadTask.Result; return(fileUploadResponse.IsSuccessStatusCode); }
private async Task <List <DriveFile> > GetItems(IDriveItemChildrenCollectionPage result, string siteName = "onedrive", bool showHiddenFolders = false) { var files = new List <DriveFile>(); foreach (var item in result) { //要隐藏文件 if (!showHiddenFolders) { //跳过隐藏的文件 var hiddenFolders = _driveContext.Sites.Single(site => site.Name == siteName).HiddenFolders; if (hiddenFolders != null) { if (hiddenFolders.Any(str => str == item.Name)) { continue; } } } var file = new DriveFile() { CreatedTime = item.CreatedDateTime, Name = item.Name, Size = item.Size, Id = item.Id }; if (item.AdditionalData != null) { //可能是文件夹 if (item.AdditionalData.TryGetValue("@microsoft.graph.downloadUrl", out var downloadUrl)) { file.DownloadUrl = ReplaceCDNUrls(downloadUrl.ToString()); } } files.Add(file); } if (result.Count == 200) { files.AddRange(await GetItems(await result.NextPageRequest.GetAsync(), siteName, showHiddenFolders)); } return(files); }
/// <summary> /// Returns the file or index page for the given request and resource. /// </summary> /// <param name="request">The request to which to respond.</param> /// <param name="resource">The requested resource.</param> protected override void SendFileOrIndex(HttpRequest request, IResource resource) { for (IResource current = resource; current != null; current = current.Parent) { if (current is AspxAppDirectory) { AspxAppDirectory app = current as AspxAppDirectory; if (resource is DriveFile) { DriveFile file = resource as DriveFile; if (IsAspxFile(file.Path)) { app.ProcessRequest(request, file); return; } } else if (resource is IDirectory) { IDirectory targetDir = resource as IDirectory; IFile defaultPage = null; foreach (string page in DefaultPages) { defaultPage = targetDir.GetFile(page); if (defaultPage != null) { DriveFile file = defaultPage as DriveFile; if (file != null && IsAspxFile(file.Path)) { throw new MovedException(request.Uri.AbsolutePath + defaultPage.Name); } else { base.SendFileOrIndex(request, resource); return; } } } } } } base.SendFileOrIndex(request, resource); }
// DriveFiles = null; public List <DriveFile> GetFilesFromGDrive() { List <DriveFile> driveFiles = new List <DriveFile>(); UserCredential credential = GetCredential(); if (credential != null) { // Create Drive API service. var service = new DriveService(new BaseClientService.Initializer() { HttpClientInitializer = credential, ApplicationName = applicationName, }); // Define parameters of request. FilesResource.ListRequest listRequest = service.Files.List(); listRequest.Q = "parents in '0B0a2qZk7n1UQcE91anYybHJnNzQ' and mimeType='image/jpeg'"; listRequest.Fields = "nextPageToken,files(id, name,mimeType,thumbnailLink,webViewLink,webContentLink,hasThumbnail)"; listRequest.PageSize = 18; // List files. IList <Google.Apis.Drive.v3.Data.File> files = listRequest.Execute() .Files; if (files != null && files.Count > 0) { foreach (var file in files) { DriveFile objFile = new DriveFile() { FileId = file.Id, FileName = file.Name, Description = file.Description, MimeType = file.MimeType, ThumbnailLink = file.ThumbnailLink, HasThumbnail = file.HasThumbnail, WebViewLink = file.WebViewLink, WebContentLink = file.WebContentLink, }; driveFiles.Add(objFile); } } } return(driveFiles); }
private List <DriveFile> GetItems(IDriveItemChildrenCollectionPage result, string siteName = "onedrive", bool showHiddenFolders = false) { List <DriveFile> files = new List <DriveFile>(); string[] hiddenFolders = siteContext.Sites.Single(site => site.Name == siteName).HiddenFolders; foreach (var item in result) { //要隐藏文件 if (!showHiddenFolders) { //跳过隐藏的文件 if (hiddenFolders != null) { if (hiddenFolders.Any(str => str == item.Name)) { continue; } } } DriveFile file = new DriveFile() { CreatedTime = item.CreatedDateTime, Name = item.Name, Size = item.Size, Id = item.Id }; object downloadUrl; if (item.AdditionalData != null) { //可能是文件夹 if (item.AdditionalData.TryGetValue("@microsoft.graph.downloadUrl", out downloadUrl)) { var dlurl = (string)downloadUrl; ReplaceCDNUrls(ref dlurl); file.DownloadUrl = dlurl; } } files.Add(file); } return(files); }
public LocalDrive(Account account, string id, string rootPath) : base(account, id) { rootFolder = LocalFileFactory.Instance.Create(this, new DirectoryInfo(rootPath), true); }
public override async Task DeleteFolderAsync(DriveFile driveFolder, CancellationToken token) { var service = await GetServiceAsync(token); if (driveFolder.Id == RootId) { var files = await GetFilesAsync(rootFolder, "", token); foreach (var file in files) await service.Files.Delete(file.Id).ExecuteAsync(token); } else await service.Files.Delete(driveFolder.Id).ExecuteAsync(token); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public override async Task<DriveFile> CreateFolderAsync(string folderName, DriveFile destFolder, CancellationToken token) #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously { var dir = Directory.CreateDirectory(((LocalFile)destFolder).file.FullName + Path.DirectorySeparatorChar + folderName); return LocalFileFactory.Instance.Create(this, dir, false); }
public override async Task EnumerateFilesRecursive(DriveFile driveFolder, Action<DriveFile> action, CancellationToken token) { var files = await GetFilesAsync(driveFolder, token); foreach (var file in files) { if (file.IsFolder) await EnumerateFilesRecursive(file, action, token); else { var f = file; await Task.Run(() => action(f), token); } } }
public override async Task DeleteFileAsync(DriveFile driveFile, CancellationToken token) { var service = await GetServiceAsync(token); await service.Files.Delete(driveFile.Id).ExecuteAsync(token); }
public override async Task DeleteFolderAsync(DriveFile driveFolder, CancellationToken token) { await Task.Run(() => ((LocalFile)driveFolder).Directory.Delete()); }
public override async Task DeleteFileAsync(DriveFile driveFile, CancellationToken token) { await Task.Run(() => ((LocalFile)driveFile).File.Delete()); }
public override async Task<ICollection<DriveFile>> GetSubfoldersAsync(DriveFile folder, CancellationToken token) { return await GetFilesAsync(folder, string.Format("mimeType = '{0}'", GoogleMimeTypes.Folder), token); }
public override async Task DownloadFileAsync(DriveFile driveFile, System.IO.Stream fileStream, CancellationToken token) { var url = ((GoogleFile)driveFile).File.DownloadUrl; if (url == null) throw new TaskException("Can't download this file"); var service = await GetServiceAsync(token); var stream = await service.HttpClient.GetStreamAsync(url); if (stream == null) { throw new Exception("Can't download this file"); } var buffer = new byte[1000]; var n = await stream.ReadAsync(buffer, 0, buffer.Length, token); while (n > 0) { await fileStream.WriteAsync(buffer, 0, n, token); n = await stream.ReadAsync(buffer, 0, buffer.Length, token); } }
private async Task<ICollection<DriveFile>> GetFilesAsync(DriveFile folder, string q, CancellationToken token) { try { var service = await GetServiceAsync(token); var request = service.Files.List(); request.MaxResults = 1000; if (!string.IsNullOrWhiteSpace(q)) q = string.Format("and ({0})", q); request.Q = string.Format("'{0}' in parents and trashed = false {1}", folder.Id, q); request.Fields = "items(downloadUrl,webContentLink,thumbnailLink,id,mimeType,createdDate,modifiedDate,fileSize,title,properties)"; var files = await request.ExecuteAsync(token); return await GoogleFileList.Get(this, (GoogleFile)folder, files, service, token); } catch (TokenResponseException ex) { throw new ConnectionException(Owner, ex.Message, ex); } }
#pragma warning disable 1998 public override async Task<Image> GetThumbnailAsync(DriveFile file, CancellationToken token) #pragma warning restore 1998 { var gFile = ((GoogleFile) file).File; if (gFile.Thumbnail == null) throw new Exception("File has no thumbnail"); var bytes = Convert.FromBase64String(gFile.Thumbnail.Image); return new Bitmap(new System.IO.MemoryStream(bytes)); }
public override async Task<System.IO.Stream> ReadFileAsync(DriveFile file, CancellationToken token) { var service = await GetServiceAsync(token); var gFile = await service.Files.Get(file.Id).ExecuteAsync(token); if (String.IsNullOrEmpty(gFile.DownloadUrl)) return null; return await service.HttpClient.GetStreamAsync(gFile.DownloadUrl); }
public override async Task<DriveFile> UploadFileAsync(Stream stream, string fileName, DriveFile destFolder, string storageFileId, CancellationToken token) { Stream scaled; var f = new FileInfo(((LocalFile)destFolder).file.FullName + Path.DirectorySeparatorChar + fileName); var localFile = LocalFileFactory.Instance.Create(this, f, false); ImageFormat imageType; if (!ImageMaxSize.IsEmpty && TryGetImageType(fileName, out imageType)) { using (var image = Image.FromStream(stream)) { scaled = await ScaleImageAsync(image, imageType, token); await localFile.SetAttributeAsync("OriginalImageHeight", image.Height.ToString(), token); await localFile.SetAttributeAsync("OriginalImageWidth", image.Width.ToString(), token); } } else { scaled = stream; } var observed = new ObserverStream(scaled); observed.PositionChanged += (sender, e) => { }; using (var outStream = f.Create()) { await scaled.CopyToAsync(outStream); } await localFile.SetStorageFileIdAsync(storageFileId, token); return localFile; }
public override async Task<DriveFile> UploadFileAsync(System.IO.Stream stream, string fileName, DriveFile destFolder, string storageFileId, CancellationToken token) { var props = new List<Property> { new Property {Key = string.Format("{0}.sid", Storage.Kind), Value = Storage.Id, Visibility = "PRIVATE"}, new Property {Key = "src", Value = Storage.Kind, Visibility = "PRIVATE"} }; // // // Storage file ID. var storageFileIdPropertyKeyLen = string.Format(StorageFileIdFormat, Storage.Kind, 0).Length; var storageFileIdPropertyValueLen = GoogleFile.PropertyMaxLength - storageFileIdPropertyKeyLen; var storageFileIdParts = Common.SplitBy(storageFileId ?? "", storageFileIdPropertyValueLen); if (storageFileIdParts.Length > 9) throw new Exception("Storage file ID is too long"); props.AddRange(storageFileIdParts.Select((t, i) => new Property { Key = string.Format(StorageFileIdFormat, Storage.Kind, i), Value = t, Visibility = "PRIVATE" })); return await UploadFileAsync(stream, fileName, (GoogleFile)destFolder, props, token); }
public override async Task<Stream> ReadFileAsync(DriveFile file, CancellationToken token) { return ((LocalFile)file).File.OpenRead(); }
public override async Task<Image> GetThumbnailAsync(DriveFile file, CancellationToken token) { if (!((LocalFile)file).IsImage) { return null; } return await Task.Run(() => { using (var stream = ((LocalFile)file).File.OpenRead()) { return Image.FromStream(stream); } }); }
public void ProcessRequest(HttpRequest request, DriveFile file, string virtualPath, string physicalDir) { HttpRuntime.ProcessRequest(new WorkerRequest(request, file, virtualPath, physicalDir)); }
public override async Task<ICollection<DriveFile>> GetFilesAsync(DriveFile folder, CancellationToken token) { return await Task.Run(() => ((LocalFile)folder).Directory.EnumerateFiles() .Select(file => LocalFileFactory.Instance.Create(this, file, false)) .Cast<DriveFile>().ToList()); }
public override async Task DownloadFileAsync(DriveFile driveFile, string destFolder, ActionIfFileExists actionIfFileExists, CancellationToken token) { var fileName = Common.AppendToPath(destFolder, driveFile.Name); if (System.IO.File.Exists(fileName)) { switch (actionIfFileExists) { case ActionIfFileExists.Skip: return; case ActionIfFileExists.Rewrite: fileName = GetAvailableFileName(fileName); break; } } using (var fileStream = System.IO.File.Create(fileName)) { await DownloadFileAsync(driveFile, fileStream, token); } }
public override async Task<DriveFile> CreateFolderAsync(string folderName, DriveFile destFolder, CancellationToken token) { var folder = new File { Title = folderName, MimeType = GoogleMimeTypes.Folder, Parents = new[] {new ParentReference {Id = destFolder.Id}} }; var service = await GetServiceAsync(token); var file = await service.Files.Insert(folder).ExecuteAsync(token); return new GoogleFile(this, file); }