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, Stream output, CancellationToken token)
{
using (var input = ((LocalFile)driveFile).File.OpenRead())
{
await Common.CopyStreamAsync(input, output, 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);
}
}
public WorkerRequest(HttpRequest request, DriveFile file, string virtualDir, string physicalDir)
{
this.request = request;
this.file = file;
this.virtualDir = virtualDir;
this.physicalDir = physicalDir;
}
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);
}
}
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);
}
