feat(oss): 增加接口代理模块

aspnet-core/modules/oss-management/LINGYUN.Abp.BlobStoring.OssManagement/LINGYUN/Abp/BlobStoring/OssManagement/OssManagementBlobProvider.cs

@@ -1,4 +1,5 @@
 using LINGYUN.Abp.OssManagement;
+using LINGYUN.Abp.OssManagement.Integration;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using System;
@@ -14,9 +15,9 @@ public class OssManagementBlobProvider : BlobProviderBase, ITransientDependency
 {
     public ILogger<OssManagementBlobProvider> Logger { protected get; set; }
 
-    private readonly IOssObjectAppService _ossObjectAppService;
+    private readonly IOssObjectIntegrationService _ossObjectAppService;
     public OssManagementBlobProvider(
-        IOssObjectAppService ossObjectAppService)
+        IOssObjectIntegrationService ossObjectAppService)
     {
         _ossObjectAppService = ossObjectAppService;
 
@@ -37,47 +38,27 @@ public class OssManagementBlobProvider : BlobProviderBase, ITransientDependency
 
     public override async Task<bool> ExistsAsync(BlobProviderExistsArgs args)
     {
-        try
-        {
-            var configuration = args.Configuration.GetOssManagementConfiguration();
-            var oss = await _ossObjectAppService.GetAsync(new GetOssObjectInput
-            {
-                Bucket = configuration.Bucket,
-                Path = GetOssPath(args),
-                Object = GetOssName(args),
-            });
-            return oss != null;
-        }
-        catch (Exception ex)
+        var configuration = args.Configuration.GetOssManagementConfiguration();
+        var result = await _ossObjectAppService.ExistsAsync(new GetOssObjectInput
         {
-            Logger.LogWarning("An error occurred while getting the OSS object, always returning that the object does not exist");
-            Logger.LogWarning(ex.Message);
-
-            return false;
-        }
+            Bucket = configuration.Bucket,
+            Path = GetOssPath(args),
+            Object = GetOssName(args),
+        });
+        return result.IsExists;
     }
 
     public override async Task<Stream> GetOrNullAsync(BlobProviderGetArgs args)
     {
-        try
-        {
-            var configuration = args.Configuration.GetOssManagementConfiguration();
-            var content = await _ossObjectAppService.GetContentAsync(new GetOssObjectInput
-            {
-                Bucket = configuration.Bucket,
-                Path = GetOssPath(args),
-                Object = GetOssName(args),
-            });
-
-            return content?.GetStream();
-        }
-        catch (Exception ex)
+        var configuration = args.Configuration.GetOssManagementConfiguration();
+        var content = await _ossObjectAppService.GetAsync(new GetOssObjectInput
         {
-            Logger.LogWarning("An error occurred while getting the OSS object and an empty data stream will be returned");
-            Logger.LogWarning(ex.Message);
+            Bucket = configuration.Bucket,
+            Path = GetOssPath(args),
+            Object = GetOssName(args),
+        });
 
-            return null;
-        }
+        return content?.GetStream();
     }
 
     public override async Task SaveAsync(BlobProviderSaveArgs args)

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application.Contracts/LINGYUN/Abp/OssManagement/IFileAppService.cs

@@ -13,7 +13,7 @@ public interface IFileAppService : IApplicationService
 
     Task<ListResultDto<OssObjectDto>> GetListAsync(GetFilesInput input);
 
-    Task UploadAsync(UploadFileChunkInput input);
+    Task UploadChunkAsync(UploadFileChunkInput input);
 
     Task DeleteAsync(GetPublicFileInput input);
 }

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application.Contracts/LINGYUN/Abp/OssManagement/Integration/GetOssObjectExistsResult.cs

@@ -0,0 +1,6 @@
+namespace LINGYUN.Abp.OssManagement.Integration;
+
+public class GetOssObjectExistsResult
+{
+    public bool IsExists { get; set; }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application.Contracts/LINGYUN/Abp/OssManagement/Integration/IOssObjectIntegrationService.cs

@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Services;
+using Volo.Abp.Content;
+
+namespace LINGYUN.Abp.OssManagement.Integration;
+
+[IntegrationService]
+public interface IOssObjectIntegrationService : IApplicationService
+{
+    Task<OssObjectDto> CreateAsync(CreateOssObjectInput input);
+
+    Task DeleteAsync(GetOssObjectInput input);
+
+    Task<GetOssObjectExistsResult> ExistsAsync(GetOssObjectInput input);
+
+    Task<IRemoteStreamContent> GetAsync(GetOssObjectInput input);
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application.Contracts/LINGYUN/Abp/OssManagement/OssManagementRemoteServiceConsts.cs

@@ -3,4 +3,6 @@
 public static class OssManagementRemoteServiceConsts
 {
     public const string RemoteServiceName = "AbpOssManagement";
+
+    public const string ModuleName = "oss-management";
 }

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application/LINGYUN/Abp/OssManagement/FileAppServiceBase.cs

@@ -31,7 +31,7 @@ public abstract class FileAppServiceBase : OssManagementApplicationServiceBase,
     }
 
     [RequiresFeature(AbpOssManagementFeatureNames.OssObject.UploadFile)]
-    public async virtual Task UploadAsync(UploadFileChunkInput input)
+    public async virtual Task UploadChunkAsync(UploadFileChunkInput input)
     {
         input.Bucket = GetCurrentBucket();
         input.Path = GetCurrentPath(HttpUtility.UrlDecode(input.Path));

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application/LINGYUN/Abp/OssManagement/Integration/OssObjectIntegrationService.cs

@@ -0,0 +1,94 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using System.Web;
+using Volo.Abp.Content;
+
+namespace LINGYUN.Abp.OssManagement.Integration;
+
+public class OssObjectIntegrationService : OssManagementApplicationServiceBase, IOssObjectIntegrationService
+{
+    protected FileUploadMerger Merger { get; }
+    protected IOssContainerFactory OssContainerFactory { get; }
+
+    public OssObjectIntegrationService(
+        FileUploadMerger merger,
+        IOssContainerFactory ossContainerFactory)
+    {
+        Merger = merger;
+        OssContainerFactory = ossContainerFactory;
+    }
+
+    public async virtual Task<OssObjectDto> CreateAsync(CreateOssObjectInput input)
+    {
+        // 内容为空时建立目录
+        if (input.File == null || !input.File.ContentLength.HasValue)
+        {
+            var oss = CreateOssContainer();
+            var request = new CreateOssObjectRequest(
+                HttpUtility.UrlDecode(input.Bucket),
+                HttpUtility.UrlDecode(input.FileName),
+                Stream.Null,
+                HttpUtility.UrlDecode(input.Path));
+            var ossObject = await oss.CreateObjectAsync(request);
+
+            return ObjectMapper.Map<OssObject, OssObjectDto>(ossObject);
+        }
+        else
+        {
+            var ossObject = await Merger.MergeAsync(input);
+
+            return ObjectMapper.Map<OssObject, OssObjectDto>(ossObject);
+        }
+    }
+
+    public async virtual Task DeleteAsync(GetOssObjectInput input)
+    {
+        var oss = CreateOssContainer();
+
+        await oss.DeleteObjectAsync(input.Bucket, input.Object, input.Path);
+    }
+
+    public async virtual Task<GetOssObjectExistsResult> ExistsAsync(GetOssObjectInput input)
+    {
+        try
+        {
+            var oss = CreateOssContainer();
+
+            var ossObject = await oss.GetObjectAsync(input.Bucket, input.Object, input.Path, input.MD5);
+
+            return new GetOssObjectExistsResult
+            {
+                IsExists = ossObject != null
+            };
+        }
+        catch (Exception)
+        {
+            return new GetOssObjectExistsResult
+            {
+                IsExists = false,
+            };
+        }
+    }
+
+    public async virtual Task<IRemoteStreamContent> GetAsync(GetOssObjectInput input)
+    {
+        try
+        {
+            var oss = CreateOssContainer();
+
+            var ossObject = await oss.GetObjectAsync(input.Bucket, input.Object, input.Path, input.MD5);
+
+            return new RemoteStreamContent(ossObject.Content, ossObject.Name);
+        }
+        catch (Exception)
+        {
+            return new RemoteStreamContent(Stream.Null);
+        }
+    }
+
+    protected virtual IOssContainer CreateOssContainer()
+    {
+        return OssContainerFactory.Create();
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application/LINGYUN/Abp/OssManagement/PrivateFileAppService.cs

@@ -93,9 +93,9 @@ public class PrivateFileAppService : FileAppServiceBase, IPrivateFileAppService
     }
 
     [Authorize]
-    public override async Task UploadAsync(UploadFileChunkInput input)
+    public override async Task UploadChunkAsync(UploadFileChunkInput input)
     {
-        await base.UploadAsync(input);
+        await base.UploadChunkAsync(input);
     }
 
     [Authorize]

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.Application/LINGYUN/Abp/OssManagement/PublicFileAppService.cs

@@ -28,12 +28,12 @@ public class PublicFileAppService : FileAppServiceBase, IPublicFileAppService
         await base.DeleteAsync(input);
     }
 
-    public override async Task UploadAsync(UploadFileChunkInput input)
+    public override async Task UploadChunkAsync(UploadFileChunkInput input)
     {
         await CheckPublicAccessAsync();
         await FeatureChecker.CheckEnabledAsync(AbpOssManagementFeatureNames.OssObject.UploadFile);
 
-        await base.UploadAsync(input);
+        await base.UploadChunkAsync(input);
     }
 
     [RequiresLimitFeature(

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/Integration/OssObjectIntegrationClientProxy.Generated.cs

@@ -0,0 +1,54 @@
+// This file is automatically generated by ABP framework to use MVC Controllers from CSharp
+using LINGYUN.Abp.OssManagement;
+using LINGYUN.Abp.OssManagement.Integration;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Content;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.ClientProxying;
+using Volo.Abp.Http.Modeling;
+
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement.Integration;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IOssObjectIntegrationService), typeof(OssObjectIntegrationClientProxy))]
+[IntegrationService]
+public partial class OssObjectIntegrationClientProxy : ClientProxyBase<IOssObjectIntegrationService>, IOssObjectIntegrationService
+{
+    public virtual async Task<OssObjectDto> CreateAsync(CreateOssObjectInput input)
+    {
+        return await RequestAsync<OssObjectDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(CreateOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task DeleteAsync(GetOssObjectInput input)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task<GetOssObjectExistsResult> ExistsAsync(GetOssObjectInput input)
+    {
+        return await RequestAsync<GetOssObjectExistsResult>(nameof(ExistsAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task<IRemoteStreamContent> GetAsync(GetOssObjectInput input)
+    {
+        return await RequestAsync<IRemoteStreamContent>(nameof(GetAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectInput), input }
+        });
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/Integration/OssObjectIntegrationClientProxy.cs

@@ -0,0 +1,7 @@
+// This file is part of OssObjectIntegrationClientProxy, you can customize it here
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement.Integration;
+
+public partial class OssObjectIntegrationClientProxy
+{
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/OssContainerClientProxy.Generated.cs

@@ -0,0 +1,59 @@
+// This file is automatically generated by ABP framework to use MVC Controllers from CSharp
+using LINGYUN.Abp.OssManagement;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.ClientProxying;
+using Volo.Abp.Http.Modeling;
+
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IOssContainerAppService), typeof(OssContainerClientProxy))]
+public partial class OssContainerClientProxy : ClientProxyBase<IOssContainerAppService>, IOssContainerAppService
+{
+    public virtual async Task<OssContainerDto> CreateAsync(string name)
+    {
+        return await RequestAsync<OssContainerDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(string), name }
+        });
+    }
+
+    public virtual async Task DeleteAsync(string name)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(string), name }
+        });
+    }
+
+    public virtual async Task<OssContainerDto> GetAsync(string name)
+    {
+        return await RequestAsync<OssContainerDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(string), name }
+        });
+    }
+
+    public virtual async Task<OssContainersResultDto> GetListAsync(GetOssContainersInput input)
+    {
+        return await RequestAsync<OssContainersResultDto>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssContainersInput), input }
+        });
+    }
+
+    public virtual async Task<OssObjectsResultDto> GetObjectListAsync(GetOssObjectsInput input)
+    {
+        return await RequestAsync<OssObjectsResultDto>(nameof(GetObjectListAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectsInput), input }
+        });
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/OssContainerClientProxy.cs

@@ -0,0 +1,7 @@
+// This file is part of OssContainerClientProxy, you can customize it here
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+public partial class OssContainerClientProxy
+{
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/OssObjectClientProxy.Generated.cs

@@ -0,0 +1,60 @@
+// This file is automatically generated by ABP framework to use MVC Controllers from CSharp
+using LINGYUN.Abp.OssManagement;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Content;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.ClientProxying;
+using Volo.Abp.Http.Modeling;
+
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IOssObjectAppService), typeof(OssObjectClientProxy))]
+public partial class OssObjectClientProxy : ClientProxyBase<IOssObjectAppService>, IOssObjectAppService
+{
+    public virtual async Task<OssObjectDto> CreateAsync(CreateOssObjectInput input)
+    {
+        return await RequestAsync<OssObjectDto>(nameof(CreateAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(CreateOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task BulkDeleteAsync(BulkDeleteOssObjectInput input)
+    {
+        await RequestAsync(nameof(BulkDeleteAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(BulkDeleteOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task DeleteAsync(GetOssObjectInput input)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task<OssObjectDto> GetAsync(GetOssObjectInput input)
+    {
+        return await RequestAsync<OssObjectDto>(nameof(GetAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectInput), input }
+        });
+    }
+
+    public virtual async Task<IRemoteStreamContent> GetContentAsync(GetOssObjectInput input)
+    {
+        return await RequestAsync<IRemoteStreamContent>(nameof(GetContentAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetOssObjectInput), input }
+        });
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/OssObjectClientProxy.cs

@@ -0,0 +1,7 @@
+// This file is part of OssObjectClientProxy, you can customize it here
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+public partial class OssObjectClientProxy
+{
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/PrivateFilesClientProxy.Generated.cs

@@ -0,0 +1,73 @@
+// This file is automatically generated by ABP framework to use MVC Controllers from CSharp
+using LINGYUN.Abp.OssManagement;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Content;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.ClientProxying;
+using Volo.Abp.Http.Modeling;
+
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IFileAppService), typeof(PrivateFilesClientProxy))]
+public partial class PrivateFilesClientProxy : ClientProxyBase<IFileAppService>, IFileAppService
+{
+    public virtual async Task<OssObjectDto> UploadAsync(UploadFileInput input)
+    {
+        return await RequestAsync<OssObjectDto>(nameof(UploadAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(UploadFileInput), input }
+        });
+    }
+
+    public virtual async Task UploadChunkAsync(UploadFileChunkInput input)
+    {
+        await RequestAsync(nameof(UploadChunkAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(UploadFileChunkInput), input }
+        });
+    }
+
+    public virtual async Task<ListResultDto<OssObjectDto>> GetListAsync(GetFilesInput input)
+    {
+        return await RequestAsync<ListResultDto<OssObjectDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetFilesInput), input }
+        });
+    }
+
+    public virtual async Task<IRemoteStreamContent> GetAsync(GetPublicFileInput input)
+    {
+        return await RequestAsync<IRemoteStreamContent>(nameof(GetAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetPublicFileInput), input }
+        });
+    }
+
+    public virtual async Task DeleteAsync(GetPublicFileInput input)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetPublicFileInput), input }
+        });
+    }
+
+    public virtual async Task<ListResultDto<MyFileShareDto>> GetShareListAsync()
+    {
+        return await RequestAsync<ListResultDto<MyFileShareDto>>(nameof(GetShareListAsync));
+    }
+
+    public virtual async Task<FileShareDto> ShareAsync(FileShareInput input)
+    {
+        return await RequestAsync<FileShareDto>(nameof(ShareAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(FileShareInput), input }
+        });
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/PrivateFilesClientProxy.cs

@@ -0,0 +1,7 @@
+// This file is part of PrivateFilesClientProxy, you can customize it here
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+public partial class PrivateFilesClientProxy
+{
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/PublicFilesClientProxy.Generated.cs

@@ -0,0 +1,60 @@
+// This file is automatically generated by ABP framework to use MVC Controllers from CSharp
+using LINGYUN.Abp.OssManagement;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Content;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.ClientProxying;
+using Volo.Abp.Http.Modeling;
+
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IFileAppService), typeof(PublicFilesClientProxy))]
+public partial class PublicFilesClientProxy : ClientProxyBase<IFileAppService>, IFileAppService
+{
+    public virtual async Task<OssObjectDto> UploadAsync(UploadFileInput input)
+    {
+        return await RequestAsync<OssObjectDto>(nameof(UploadAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(UploadFileInput), input }
+        });
+    }
+
+    public virtual async Task UploadChunkAsync(UploadFileChunkInput input)
+    {
+        await RequestAsync(nameof(UploadChunkAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(UploadFileChunkInput), input }
+        });
+    }
+
+    public virtual async Task<ListResultDto<OssObjectDto>> GetListAsync(GetFilesInput input)
+    {
+        return await RequestAsync<ListResultDto<OssObjectDto>>(nameof(GetListAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetFilesInput), input }
+        });
+    }
+
+    public virtual async Task<IRemoteStreamContent> GetAsync(GetPublicFileInput input)
+    {
+        return await RequestAsync<IRemoteStreamContent>(nameof(GetAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetPublicFileInput), input }
+        });
+    }
+
+    public virtual async Task DeleteAsync(GetPublicFileInput input)
+    {
+        await RequestAsync(nameof(DeleteAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetPublicFileInput), input }
+        });
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/PublicFilesClientProxy.cs

@@ -0,0 +1,7 @@
+// This file is part of PublicFilesClientProxy, you can customize it here
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+public partial class PublicFilesClientProxy
+{
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/StaticFilesClientProxy.Generated.cs

@@ -0,0 +1,28 @@
+// This file is automatically generated by ABP framework to use MVC Controllers from CSharp
+using LINGYUN.Abp.OssManagement;
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.Application.Dtos;
+using Volo.Abp.Content;
+using Volo.Abp.DependencyInjection;
+using Volo.Abp.Http.Client;
+using Volo.Abp.Http.Client.ClientProxying;
+using Volo.Abp.Http.Modeling;
+
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+[Dependency(ReplaceServices = true)]
+[ExposeServices(typeof(IStaticFilesAppService), typeof(StaticFilesClientProxy))]
+public partial class StaticFilesClientProxy : ClientProxyBase<IStaticFilesAppService>, IStaticFilesAppService
+{
+    public virtual async Task<IRemoteStreamContent> GetAsync(GetStaticFileInput input)
+    {
+        return await RequestAsync<IRemoteStreamContent>(nameof(GetAsync), new ClientProxyRequestTypeValue
+        {
+            { typeof(GetStaticFileInput), input }
+        });
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/ClientProxies/LINGYUN/Abp/OssManagement/StaticFilesClientProxy.cs

@@ -0,0 +1,7 @@
+// This file is part of StaticFilesClientProxy, you can customize it here
+// ReSharper disable once CheckNamespace
+namespace LINGYUN.Abp.OssManagement;
+
+public partial class StaticFilesClientProxy
+{
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/LINGYUN.Abp.OssManagement.HttpApi.Client.csproj

@@ -13,6 +13,14 @@
 		<RootNamespace />
 	</PropertyGroup>
 
+	<ItemGroup>
+		<None Remove="ClientProxies\oss-management-generate-proxy.json" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<EmbeddedResource Include="ClientProxies\oss-management-generate-proxy.json" />
+	</ItemGroup>
+
 	<ItemGroup>
 		<PackageReference Include="Volo.Abp.Http.Client" />
 	</ItemGroup>

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi.Client/LINGYUN/Abp/OssManagement/AbpOssManagementHttpApiClientModule.cs

@@ -11,7 +11,7 @@ public class AbpOssManagementHttpApiClientModule : AbpModule
 {
     public override void ConfigureServices(ServiceConfigurationContext context)
     {
-        context.Services.AddHttpClientProxies(
+        context.Services.AddStaticHttpClientProxies(
                typeof(AbpOssManagementApplicationContractsModule).Assembly,
                OssManagementRemoteServiceConsts.RemoteServiceName
            );

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi/LINGYUN.Abp.OssManagement.HttpApi.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
 	<Import Project="..\..\..\..\configureawait.props" />
 	<Import Project="..\..\..\..\common.props" />

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi/LINGYUN/Abp/OssManagement/Integration/OssObjectIntegrationController.cs

@@ -0,0 +1,47 @@
+using Asp.Versioning;
+using Microsoft.AspNetCore.Mvc;
+using System.Threading.Tasks;
+using Volo.Abp;
+using Volo.Abp.AspNetCore.Mvc;
+using Volo.Abp.Content;
+
+namespace LINGYUN.Abp.OssManagement.Integration;
+
+[Area(OssManagementRemoteServiceConsts.ModuleName)]
+[ControllerName("OssObjectIntegration")]
+[RemoteService(Name = OssManagementRemoteServiceConsts.RemoteServiceName)]
+[Route($"integration-api/{OssManagementRemoteServiceConsts.ModuleName}/objects")]
+public class OssObjectIntegrationController : AbpControllerBase, IOssObjectIntegrationService
+{
+    private readonly IOssObjectIntegrationService _service;
+    public OssObjectIntegrationController(IOssObjectIntegrationService service)
+    {
+        _service = service;
+    }
+
+    [HttpPost]
+    public virtual Task<OssObjectDto> CreateAsync([FromForm] CreateOssObjectInput input)
+    {
+        return _service.CreateAsync(input);
+    }
+
+    [HttpDelete]
+    public virtual Task DeleteAsync(GetOssObjectInput input)
+    {
+        return _service.DeleteAsync(input);
+    }
+
+    [HttpGet]
+    [Route("exists")]
+    public virtual Task<GetOssObjectExistsResult> ExistsAsync(GetOssObjectInput input)
+    {
+        return _service.ExistsAsync(input);
+    }
+
+    [HttpGet]
+    [Route("download")]
+    public virtual Task<IRemoteStreamContent> GetAsync(GetOssObjectInput input)
+    {
+        return _service.GetAsync(input);
+    }
+}

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi/LINGYUN/Abp/OssManagement/PrivateFilesController.cs

@@ -34,9 +34,9 @@ public class PrivateFilesController : AbpControllerBase, IPrivateFileAppService
 
     [HttpPost]
     [Route("upload")]
-    public async virtual Task UploadAsync([FromForm] UploadFileChunkInput input)
+    public async virtual Task UploadChunkAsync([FromForm] UploadFileChunkInput input)
     {
-        await _service.UploadAsync(input);
+        await _service.UploadChunkAsync(input);
     }
 
     [HttpGet]

aspnet-core/modules/oss-management/LINGYUN.Abp.OssManagement.HttpApi/LINGYUN/Abp/OssManagement/PublicFilesController.cs

@@ -32,9 +32,9 @@ public class PublicFilesController : AbpControllerBase, IPublicFileAppService
 
     [HttpPost]
     [Route("upload")]
-    public async virtual Task UploadAsync([FromForm] UploadFileChunkInput input)
+    public async virtual Task UploadChunkAsync([FromForm] UploadFileChunkInput input)
     {
-        await _publicFileAppService.UploadAsync(input);
+        await _publicFileAppService.UploadChunkAsync(input);
     }
 
     [HttpGet]