fisp/libfisp/fisp.cs

using COSXML;
using COSXML.Auth;
using COSXML.Model.Object;
using COSXML.Transfer;
using static COSXML.Model.Tag.ListAllMyBuckets;

namespace libfisp
{
    public class fisp
    {
        private const string _bucket = @"app-1300984704";
        private readonly CosXmlServer _cosXml;

        public fisp()
        {
            var secretId = "AKIDMSIsADUUpvJGwJOKvsb5IDrGtGNBRzzi";
            var secretKey = "4sQhdJBl5HI7f3oLbZIlwqXOyILyLWP0";
            var region = "ap-shanghai";

            var config = new CosXmlConfig.Builder()
                .SetRegion(region)
                .SetConnectionTimeoutMs(10000)
                .SetReadWriteTimeoutMs(10000)
                .SetDebugLog(true)
                .Build();

            var qCloudCredentialProvider = new DefaultQCloudCredentialProvider(secretId, secretKey, 3600);
            _cosXml = new CosXmlServer(config, qCloudCredentialProvider);
        }

        private async Task<string> PutObject(string file, string fileName, Action<long,long> progressCallback)
        {
            var transferConfig = new TransferConfig();
            var transferManager = new TransferManager(_cosXml, transferConfig);
            var uploadTask = new COSXMLUploadTask(_bucket, fileName);
            uploadTask.SetSrcPath(file);
            uploadTask.progressCallback = new COSXML.Callback.OnProgressCallback(progressCallback);
            try
            {
                var result = await transferManager.UploadAsync(uploadTask);
                if (result.IsSuccessful())
                {
                    return "success";
                }
                else
                {
                    return result.GetResultInfo();
                }
            }
            catch (Exception e)
            {
                return e.ToString();
            }
        }

        public List<string> ListFolders(string prefix)
        {
            var request = new COSXML.Model.Bucket.GetBucketRequest(_bucket);
            if (!string.IsNullOrEmpty(prefix))
            {
                request.SetPrefix(prefix);
            }
            request.SetDelimiter("/");
            var result = _cosXml.GetBucket(request);
            if (result.IsSuccessful())
            {
                return result.listBucket.commonPrefixesList.Select(x => x.prefix).ToList();
            }
            else
            {
                throw new InvalidOperationException("List bucket failed.");
            }
        }

        public DeleteTask DeleteFolder(string folderName)
        {
            var deleteTask = new DeleteTask();
            Task.Run(() =>
            {
                try
                {
                    var isSuccess = true;
                    var getRequest = new COSXML.Model.Bucket.GetBucketRequest(_bucket);
                    getRequest.SetPrefix(folderName);
                    var getResult = _cosXml.GetBucket(getRequest);
                    if (getResult.IsSuccessful())
                    {
                        var files = getResult.listBucket.contentsList.Select(x => x.key).ToArray();
                        for (var i = 0; i < files.Length; i++)
                        {
                            var file = files[i];
                            var deleteRequest = new DeleteObjectRequest(_bucket, file);
                            var deleteResult = _cosXml.DeleteObject(deleteRequest);
                            if (deleteResult.IsSuccessful())
                            {
                                deleteTask.UpdateProgress((i + 1) * 100 / files.Length);
                            }
                            else
                            {
                                deleteTask.UpdateFailed(deleteResult.GetResultInfo());
                                isSuccess = false;
                                break;
                            }
                        }
                        if (isSuccess)
                        {
                            deleteTask.UpdateSuccess();
                        }
                    }
                    else
                    {
                        deleteTask.UpdateFailed("List folders failed.");
                    }
                }
                catch (Exception ex)
                {
                    deleteTask.UpdateFailed(ex.Message);
                }
            });
            return deleteTask;
            

        }

        private Dictionary<string, string> GetDirFiles(DirectoryInfo dirInfo, string parentDirName)
        {
            var files = new Dictionary<string, string>();
            var subDirInfos = dirInfo.GetDirectories();
            foreach (var subDirInfo in subDirInfos)
            {
                var subFiles = GetDirFiles(subDirInfo, parentDirName + "/" + subDirInfo.Name);
                foreach (var subFilePath in subFiles.Keys)
                {
                    files.Add(subFilePath, subFiles[subFilePath]);
                }
            }
            var dirFiles = dirInfo.GetFiles();
            foreach (var dirFile in dirFiles)
            {
                var fileName = parentDirName + "/" + dirFile.Name;
                files.Add(dirFile.FullName, fileName);
            }
            return files;
        }


        public UploadTask UploadFile(string file, string fileName)
        {
            var uploadTask = new UploadTask();
            Task.Run(async () =>
            {
                var result = await PutObject(file, fileName, (progress, total) => { uploadTask.UpdateUploadProgress(file, progress * 100 / total); });
                if (result == "success")
                {
                    uploadTask.UpdateSuccess();
                }
                else
                {
                    uploadTask.UpdateFailed(result);
                }
            });
            return uploadTask;
        }

        public UploadTask UploadDir(string dir, string dirName)
        {
            var dirInfo = new DirectoryInfo(dir);
            var uploadFiles = GetDirFiles(dirInfo, dirName);
            var uploadTask = new UploadTask();
            Task.Run(async () =>
            {
                bool isSuccess = true;
                var files = uploadFiles.Keys.ToArray();
                for(var i=0;i< files.Length; i++)
                {
                    var file = files[i];
                    var fileName = uploadFiles[file];
                    var result = await PutObject(file, fileName, (progress, total) => { uploadTask.UpdateUploadProgress(file, progress * 100 / total); });
                    if (result == "success")
                    {
                        uploadTask.UpdateTotalProgress((i + 1) * 100 / files.Length);
                    }
                    else
                    {
                        uploadTask.UpdateFailed(result);
                        isSuccess = false;
                        break;
                    }
                }
                if (isSuccess)
                {
                    uploadTask.UpdateSuccess();
                }
            });
            return uploadTask;
        }
    }
}