Add OneDrive, Google Drive, and Dropbox storage providers

ManagedCode.Storage.slnx

@@ -16,6 +16,9 @@
     <Project Path="Storages/ManagedCode.Storage.FileSystem/ManagedCode.Storage.FileSystem.csproj" />
     <Project Path="Storages/ManagedCode.Storage.Sftp/ManagedCode.Storage.Sftp.csproj" />
     <Project Path="Storages/ManagedCode.Storage.Google/ManagedCode.Storage.Google.csproj" />
+    <Project Path="Storages/ManagedCode.Storage.GoogleDrive/ManagedCode.Storage.GoogleDrive.csproj" />
+    <Project Path="Storages/ManagedCode.Storage.OneDrive/ManagedCode.Storage.OneDrive.csproj" />
+    <Project Path="Storages/ManagedCode.Storage.Dropbox/ManagedCode.Storage.Dropbox.csproj" />
   </Folder>
   <Folder Name="/Tests/">
     <Project Path="Tests/ManagedCode.Storage.Tests/ManagedCode.Storage.Tests.csproj" />

Storages/ManagedCode.Storage.Dropbox/Clients/DropboxClientWrapper.cs

@@ -0,0 +1,154 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Threading.Tasks;
+using Dropbox.Api;
+using Dropbox.Api.Files;
+
+namespace ManagedCode.Storage.Dropbox.Clients;
+
+public class DropboxClientWrapper : IDropboxClientWrapper
+{
+    private readonly DropboxClient _client;
+
+    public DropboxClientWrapper(DropboxClient client)
+    {
+        _client = client ?? throw new ArgumentNullException(nameof(client));
+    }
+
+    public async Task EnsureRootAsync(string rootPath, bool createIfNotExists, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(rootPath))
+        {
+            return;
+        }
+
+        var normalized = Normalize(rootPath);
+        try
+        {
+            await _client.Files.GetMetadataAsync(normalized);
+        }
+        catch (ApiException<GetMetadataError> ex) when (ex.ErrorResponse.IsPath && ex.ErrorResponse.AsPath.Value.IsNotFound)
+        {
+            if (!createIfNotExists)
+            {
+                return;
+            }
+
+            await _client.Files.CreateFolderV2Async(normalized, autorename: false);
+        }
+    }
+
+    public async Task<DropboxItemMetadata> UploadAsync(string rootPath, string path, Stream content, string? contentType, CancellationToken cancellationToken)
+    {
+        var fullPath = Combine(rootPath, path);
+        var uploaded = await _client.Files.UploadAsync(fullPath, WriteMode.Overwrite.Instance, body: content);
+        var metadata = (await _client.Files.GetMetadataAsync(uploaded.PathLower)).AsFile;
+        return ToItem(metadata);
+    }
+
+    public async Task<Stream> DownloadAsync(string rootPath, string path, CancellationToken cancellationToken)
+    {
+        var fullPath = Combine(rootPath, path);
+        var response = await _client.Files.DownloadAsync(fullPath);
+        return await response.GetContentAsStreamAsync();
+    }
+
+    public async Task<bool> DeleteAsync(string rootPath, string path, CancellationToken cancellationToken)
+    {
+        var fullPath = Combine(rootPath, path);
+        await _client.Files.DeleteV2Async(fullPath);
+        return true;
+    }
+
+    public async Task<bool> ExistsAsync(string rootPath, string path, CancellationToken cancellationToken)
+    {
+        var fullPath = Combine(rootPath, path);
+        try
+        {
+            await _client.Files.GetMetadataAsync(fullPath);
+            return true;
+        }
+        catch (ApiException<GetMetadataError> ex) when (ex.ErrorResponse.IsPath && ex.ErrorResponse.AsPath.Value.IsNotFound)
+        {
+            return false;
+        }
+    }
+
+    public async Task<DropboxItemMetadata?> GetMetadataAsync(string rootPath, string path, CancellationToken cancellationToken)
+    {
+        var fullPath = Combine(rootPath, path);
+        try
+        {
+            var metadata = await _client.Files.GetMetadataAsync(fullPath);
+            return metadata.IsFile ? ToItem(metadata.AsFile) : null;
+        }
+        catch (ApiException<GetMetadataError> ex) when (ex.ErrorResponse.IsPath && ex.ErrorResponse.AsPath.Value.IsNotFound)
+        {
+            return null;
+        }
+    }
+
+    public async IAsyncEnumerable<DropboxItemMetadata> ListAsync(string rootPath, string? directory, [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        var fullPath = Combine(rootPath, directory ?? string.Empty);
+        var list = await _client.Files.ListFolderAsync(fullPath);
+        foreach (var item in list.Entries)
+        {
+            if (item.IsFile)
+            {
+                yield return ToItem(item.AsFile);
+            }
+        }
+
+        while (list.HasMore)
+        {
+            list = await _client.Files.ListFolderContinueAsync(list.Cursor);
+            foreach (var item in list.Entries)
+            {
+                if (item.IsFile)
+                {
+                    yield return ToItem(item.AsFile);
+                }
+            }
+        }
+    }
+
+    private static DropboxItemMetadata ToItem(FileMetadata file)
+    {
+        return new DropboxItemMetadata
+        {
+            Name = file.Name,
+            Path = file.PathLower ?? file.PathDisplay ?? string.Empty,
+            Size = file.Size,
+            ClientModified = file.ClientModified,
+            ServerModified = file.ServerModified
+        };
+    }
+
+    private static string Normalize(string path)
+    {
+        var normalized = path.Replace("\\", "/");
+        if (!normalized.StartsWith('/'))
+        {
+            normalized = "/" + normalized;
+        }
+
+        return normalized.TrimEnd('/') == string.Empty ? "/" : normalized.TrimEnd('/');
+    }
+
+    private static string Combine(string root, string path)
+    {
+        var normalizedRoot = Normalize(root);
+        var normalizedPath = path.Replace("\\", "/").Trim('/');
+        if (string.IsNullOrWhiteSpace(normalizedPath))
+        {
+            return normalizedRoot;
+        }
+
+        return normalizedRoot.EndsWith("/") ? normalizedRoot + normalizedPath : normalizedRoot + "/" + normalizedPath;
+    }
+}

Storages/ManagedCode.Storage.Dropbox/Clients/DropboxItemMetadata.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace ManagedCode.Storage.Dropbox.Clients;
+
+public class DropboxItemMetadata
+{
+    public required string Name { get; set; }
+    public required string Path { get; set; }
+    public ulong Size { get; set; }
+    public DateTime ClientModified { get; set; }
+    public DateTime ServerModified { get; set; }
+}

Storages/ManagedCode.Storage.Dropbox/Clients/IDropboxClientWrapper.cs

@@ -0,0 +1,24 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using Dropbox.Api.Files;
+
+namespace ManagedCode.Storage.Dropbox.Clients;
+
+public interface IDropboxClientWrapper
+{
+    Task EnsureRootAsync(string rootPath, bool createIfNotExists, CancellationToken cancellationToken);
+
+    Task<DropboxItemMetadata> UploadAsync(string rootPath, string path, Stream content, string? contentType, CancellationToken cancellationToken);
+
+    Task<Stream> DownloadAsync(string rootPath, string path, CancellationToken cancellationToken);
+
+    Task<bool> DeleteAsync(string rootPath, string path, CancellationToken cancellationToken);
+
+    Task<bool> ExistsAsync(string rootPath, string path, CancellationToken cancellationToken);
+
+    Task<DropboxItemMetadata?> GetMetadataAsync(string rootPath, string path, CancellationToken cancellationToken);
+
+    IAsyncEnumerable<DropboxItemMetadata> ListAsync(string rootPath, string? directory, CancellationToken cancellationToken);
+}