From d84c4ee82db6ecb49fc9118ae349e3d7e765ec4d Mon Sep 17 00:00:00 2001 From: Sydonian <794346190@qq.com> Date: Thu, 11 Apr 2024 09:29:39 +0800 Subject: [PATCH] =?UTF-8?q?cds=E6=94=AF=E6=8C=81rclone=E6=8C=82=E8=BD=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- sdks/storage/bucket.go | 61 ++++++++++++++++++++++++++++-------- sdks/storage/cache.go | 2 +- sdks/storage/models.go | 2 +- sdks/storage/node.go | 2 +- sdks/storage/object.go | 57 +++++++++++++++++---------------- sdks/storage/package.go | 60 ++++++++++++++++++++++++++++------- sdks/storage/storage.go | 4 +-- sdks/storage/storage_test.go | 50 ++++++++++++++--------------- sdks/storage/utils.go | 33 ++++++++++++++++++- utils/http/http.go | 28 ++++++++++++----- utils/serder/serder.go | 12 +++++++ 11 files changed, 221 insertions(+), 90 deletions(-) diff --git a/sdks/storage/bucket.go b/sdks/storage/bucket.go index 19cb5de..15bfac8 100644 --- a/sdks/storage/bucket.go +++ b/sdks/storage/bucket.go @@ -15,18 +15,53 @@ func (c *Client) Bucket() *BucketService { return &BucketService{c} } +const BucketGetByNamePath = "/bucket/getByName" + +type BucketGetByName struct { + UserID UserID `json:"userID" form:"userID" binding:"required"` + Name string `json:"name" form:"name" binding:"required"` +} +type BucketGetByNameResp struct { + Bucket Bucket `json:"bucket"` +} + +func (c *BucketService) GetByName(req BucketGetByName) (*BucketGetByNameResp, error) { + url, err := url.JoinPath(c.baseURL, BucketGetByNamePath) + if err != nil { + return nil, err + } + + resp, err := myhttp.GetForm(url, myhttp.RequestParam{ + Query: req, + }) + if err != nil { + return nil, err + } + + codeResp, err := ParseJSONResponse[response[BucketGetByNameResp]](resp) + if err != nil { + return nil, err + } + + if codeResp.Code == errorcode.OK { + return &codeResp.Data, nil + } + + return nil, codeResp.ToError() +} + const BucketCreatePath = "/bucket/create" -type BucketCreateReq struct { +type BucketCreate struct { UserID UserID `json:"userID" binding:"required"` Name string `json:"name" binding:"required"` } type BucketCreateResp struct { - BucketID BucketID `json:"bucketID"` + Bucket Bucket `json:"bucket"` } -func (c *BucketService) Create(req BucketCreateReq) (*BucketCreateResp, error) { +func (c *BucketService) Create(req BucketCreate) (*BucketCreateResp, error) { url, err := url.JoinPath(c.baseURL, BucketCreatePath) if err != nil { return nil, err @@ -39,7 +74,7 @@ func (c *BucketService) Create(req BucketCreateReq) (*BucketCreateResp, error) { return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[BucketCreateResp]](resp) + codeResp, err := ParseJSONResponse[response[BucketCreateResp]](resp) if err != nil { return nil, err } @@ -53,36 +88,36 @@ func (c *BucketService) Create(req BucketCreateReq) (*BucketCreateResp, error) { const BucketDeletePath = "/bucket/delete" -type BucketDeleteReq struct { +type BucketDelete struct { UserID UserID `json:"userID" binding:"required"` BucketID BucketID `json:"bucketID" binding:"required"` } type BucketDeleteResp struct{} -func (c *BucketService) Delete(req BucketDeleteReq) (*BucketDeleteResp, error) { +func (c *BucketService) Delete(req BucketDelete) error { url, err := url.JoinPath(c.baseURL, BucketDeletePath) if err != nil { - return nil, err + return err } resp, err := myhttp.PostJSON(url, myhttp.RequestParam{ Body: req, }) if err != nil { - return nil, err + return err } - codeResp, err := myhttp.ParseJSONResponse[response[BucketDeleteResp]](resp) + codeResp, err := ParseJSONResponse[response[BucketDeleteResp]](resp) if err != nil { - return nil, err + return err } if codeResp.Code == errorcode.OK { - return &codeResp.Data, nil + return nil } - return nil, codeResp.ToError() + return codeResp.ToError() } const BucketListUserBucketsPath = "/bucket/listUserBuckets" @@ -108,7 +143,7 @@ func (c *BucketService) ListUserBuckets(req BucketListUserBucketsReq) (*BucketLi return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[BucketListUserBucketsResp]](resp) + codeResp, err := ParseJSONResponse[response[BucketListUserBucketsResp]](resp) if err != nil { return nil, err } diff --git a/sdks/storage/cache.go b/sdks/storage/cache.go index e7574dd..74d02b7 100644 --- a/sdks/storage/cache.go +++ b/sdks/storage/cache.go @@ -29,7 +29,7 @@ func (c *Client) CacheMovePackage(req CacheMovePackageReq) (*CacheMovePackageRes return nil, err } - jsonResp, err := myhttp.ParseJSONResponse[response[CacheMovePackageResp]](resp) + jsonResp, err := ParseJSONResponse[response[CacheMovePackageResp]](resp) if err != nil { return nil, err } diff --git a/sdks/storage/models.go b/sdks/storage/models.go index 0ad6b81..74128f4 100644 --- a/sdks/storage/models.go +++ b/sdks/storage/models.go @@ -10,7 +10,7 @@ import ( ) const ( - ObjectPathSeperator = "/" + ObjectPathSeparator = "/" ) type NodeID int64 diff --git a/sdks/storage/node.go b/sdks/storage/node.go index 050e859..111135f 100644 --- a/sdks/storage/node.go +++ b/sdks/storage/node.go @@ -30,7 +30,7 @@ func (c *Client) NodeGetNodes(req NodeGetNodesReq) (*NodeGetNodesResp, error) { return nil, err } - jsonResp, err := myhttp.ParseJSONResponse[response[NodeGetNodesResp]](resp) + jsonResp, err := ParseJSONResponse[response[NodeGetNodesResp]](resp) if err != nil { return nil, err } diff --git a/sdks/storage/object.go b/sdks/storage/object.go index e30af8e..0af5f41 100644 --- a/sdks/storage/object.go +++ b/sdks/storage/object.go @@ -25,7 +25,7 @@ func (c *Client) Object() *ObjectService { const ObjectUploadPath = "/object/upload" -type ObjectUploadReq struct { +type ObjectUpload struct { ObjectUploadInfo Files UploadObjectIterator `json:"-"` } @@ -43,9 +43,15 @@ type UploadingObject struct { type UploadObjectIterator = iterator.Iterator[*UploadingObject] -type ObjectUploadResp struct{} +type ObjectUploadResp struct { + Uploadeds []UploadedObject `json:"uploadeds"` +} +type UploadedObject struct { + Object *Object `json:"object"` + Error string `json:"error"` +} -func (c *ObjectService) Upload(req ObjectUploadReq) (*ObjectUploadResp, error) { +func (c *ObjectService) Upload(req ObjectUpload) (*ObjectUploadResp, error) { url, err := url.JoinPath(c.baseURL, ObjectUploadPath) if err != nil { return nil, err @@ -72,8 +78,9 @@ func (c *ObjectService) Upload(req ObjectUploadReq) (*ObjectUploadResp, error) { contType := resp.Header.Get("Content-Type") if strings.Contains(contType, myhttp.ContentTypeJSON) { + var err error var codeResp response[ObjectUploadResp] - if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil { + if codeResp, err = serder.JSONToObjectStreamEx[response[ObjectUploadResp]](resp.Body); err != nil { return nil, fmt.Errorf("parsing response: %w", err) } @@ -90,7 +97,7 @@ func (c *ObjectService) Upload(req ObjectUploadReq) (*ObjectUploadResp, error) { const ObjectDownloadPath = "/object/download" -type ObjectDownloadReq struct { +type ObjectDownload struct { UserID UserID `form:"userID" json:"userID" binding:"required"` ObjectID ObjectID `form:"objectID" json:"objectID" binding:"required"` } @@ -99,7 +106,7 @@ type DownloadingObject struct { File io.ReadCloser } -func (c *ObjectService) Download(req ObjectDownloadReq) (*DownloadingObject, error) { +func (c *ObjectService) Download(req ObjectDownload) (*DownloadingObject, error) { url, err := url.JoinPath(c.baseURL, ObjectDownloadPath) if err != nil { return nil, err @@ -123,10 +130,6 @@ func (c *ObjectService) Download(req ObjectDownloadReq) (*DownloadingObject, err return nil, codeResp.ToError() } - if !strings.Contains(contType, myhttp.ContentTypeMultiPart) { - return nil, fmt.Errorf("unknow response content type: %s", contType) - } - _, files, err := myhttp.ParseMultiPartResponse(resp) if err != nil { return nil, err @@ -157,7 +160,7 @@ func (u *UpdatingObject) ApplyTo(obj *Object) { obj.UpdateTime = u.UpdateTime } -type ObjectUpdateInfoReq struct { +type ObjectUpdateInfo struct { UserID UserID `json:"userID" binding:"required"` Updatings []UpdatingObject `json:"updatings" binding:"required"` } @@ -166,7 +169,7 @@ type ObjectUpdateInfoResp struct { Successes []ObjectID `json:"successes"` } -func (c *ObjectService) Update(req ObjectUpdateInfoReq) (*ObjectUpdateInfoResp, error) { +func (c *ObjectService) UpdateInfo(req ObjectUpdateInfo) (*ObjectUpdateInfoResp, error) { url, err := url.JoinPath(c.baseURL, ObjectUpdateInfoPath) if err != nil { return nil, err @@ -179,7 +182,7 @@ func (c *ObjectService) Update(req ObjectUpdateInfoReq) (*ObjectUpdateInfoResp, return nil, err } - jsonResp, err := myhttp.ParseJSONResponse[response[ObjectUpdateInfoResp]](resp) + jsonResp, err := ParseJSONResponse[response[ObjectUpdateInfoResp]](resp) if err != nil { return nil, err } @@ -204,7 +207,7 @@ func (m *MovingObject) ApplyTo(obj *Object) { obj.Path = m.Path } -type ObjectMoveReq struct { +type ObjectMove struct { UserID UserID `json:"userID" binding:"required"` Movings []MovingObject `json:"movings" binding:"required"` } @@ -213,7 +216,7 @@ type ObjectMoveResp struct { Successes []ObjectID `json:"successes"` } -func (c *ObjectService) Move(req ObjectMoveReq) (*ObjectMoveResp, error) { +func (c *ObjectService) Move(req ObjectMove) (*ObjectMoveResp, error) { url, err := url.JoinPath(c.baseURL, ObjectMovePath) if err != nil { return nil, err @@ -226,7 +229,7 @@ func (c *ObjectService) Move(req ObjectMoveReq) (*ObjectMoveResp, error) { return nil, err } - jsonResp, err := myhttp.ParseJSONResponse[response[ObjectMoveResp]](resp) + jsonResp, err := ParseJSONResponse[response[ObjectMoveResp]](resp) if err != nil { return nil, err } @@ -240,41 +243,41 @@ func (c *ObjectService) Move(req ObjectMoveReq) (*ObjectMoveResp, error) { const ObjectDeletePath = "/object/delete" -type ObjectDeleteReq struct { +type ObjectDelete struct { UserID UserID `json:"userID" binding:"required"` ObjectIDs []ObjectID `json:"objectIDs" binding:"required"` } type ObjectDeleteResp struct{} -func (c *ObjectService) Delete(req ObjectDeleteReq) (*ObjectDeleteResp, error) { +func (c *ObjectService) Delete(req ObjectDelete) error { url, err := url.JoinPath(c.baseURL, ObjectDeletePath) if err != nil { - return nil, err + return err } resp, err := myhttp.PostJSON(url, myhttp.RequestParam{ Body: req, }) if err != nil { - return nil, err + return err } - jsonResp, err := myhttp.ParseJSONResponse[response[ObjectDeleteResp]](resp) + jsonResp, err := ParseJSONResponse[response[ObjectDeleteResp]](resp) if err != nil { - return nil, err + return err } if jsonResp.Code == errorcode.OK { - return &jsonResp.Data, nil + return nil } - return nil, jsonResp.ToError() + return jsonResp.ToError() } const ObjectGetPackageObjectsPath = "/object/getPackageObjects" -type ObjectGetPackageObjectsReq struct { +type ObjectGetPackageObjects struct { UserID UserID `form:"userID" json:"userID" binding:"required"` PackageID PackageID `form:"packageID" json:"packageID" binding:"required"` } @@ -282,7 +285,7 @@ type ObjectGetPackageObjectsResp struct { Objects []Object `json:"objects"` } -func (c *ObjectService) GetPackageObjects(req ObjectGetPackageObjectsReq) (*ObjectGetPackageObjectsResp, error) { +func (c *ObjectService) GetPackageObjects(req ObjectGetPackageObjects) (*ObjectGetPackageObjectsResp, error) { url, err := url.JoinPath(c.baseURL, ObjectGetPackageObjectsPath) if err != nil { return nil, err @@ -295,7 +298,7 @@ func (c *ObjectService) GetPackageObjects(req ObjectGetPackageObjectsReq) (*Obje return nil, err } - jsonResp, err := myhttp.ParseJSONResponse[response[ObjectGetPackageObjectsResp]](resp) + jsonResp, err := ParseJSONResponse[response[ObjectGetPackageObjectsResp]](resp) if err != nil { return nil, err } diff --git a/sdks/storage/package.go b/sdks/storage/package.go index 988030c..6655e48 100644 --- a/sdks/storage/package.go +++ b/sdks/storage/package.go @@ -41,7 +41,43 @@ func (c *PackageService) Get(req PackageGetReq) (*PackageGetResp, error) { return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[PackageGetResp]](resp) + codeResp, err := ParseJSONResponse[response[PackageGetResp]](resp) + if err != nil { + return nil, err + } + + if codeResp.Code == errorcode.OK { + return &codeResp.Data, nil + } + + return nil, codeResp.ToError() +} + +const PackageGetByNamePath = "/package/getByName" + +type PackageGetByName struct { + UserID UserID `form:"userID" json:"userID" binding:"required"` + BucketName string `form:"bucketName" json:"bucketName" binding:"required"` + PackageName string `form:"packageName" json:"packageName" binding:"required"` +} +type PackageGetByNameResp struct { + Package Package `json:"package"` +} + +func (c *PackageService) GetByName(req PackageGetByName) (*PackageGetByNameResp, error) { + url, err := url.JoinPath(c.baseURL, PackageGetByNamePath) + if err != nil { + return nil, err + } + + resp, err := myhttp.GetForm(url, myhttp.RequestParam{ + Query: req, + }) + if err != nil { + return nil, err + } + + codeResp, err := ParseJSONResponse[response[PackageGetByNameResp]](resp) if err != nil { return nil, err } @@ -55,17 +91,17 @@ func (c *PackageService) Get(req PackageGetReq) (*PackageGetResp, error) { const PackageCreatePath = "/package/create" -type PackageCreateReq struct { +type PackageCreate struct { UserID UserID `json:"userID"` BucketID BucketID `json:"bucketID"` Name string `json:"name"` } type PackageCreateResp struct { - PackageID PackageID `json:"packageID,string"` + Package Package `json:"package"` } -func (s *PackageService) Create(req PackageCreateReq) (*PackageCreateResp, error) { +func (s *PackageService) Create(req PackageCreate) (*PackageCreateResp, error) { url, err := url.JoinPath(s.baseURL, PackageCreatePath) if err != nil { return nil, err @@ -78,7 +114,7 @@ func (s *PackageService) Create(req PackageCreateReq) (*PackageCreateResp, error return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[PackageCreateResp]](resp) + codeResp, err := ParseJSONResponse[response[PackageCreateResp]](resp) if err != nil { return nil, err } @@ -92,12 +128,12 @@ func (s *PackageService) Create(req PackageCreateReq) (*PackageCreateResp, error const PackageDeletePath = "/package/delete" -type PackageDeleteReq struct { +type PackageDelete struct { UserID UserID `json:"userID" binding:"required"` PackageID PackageID `json:"packageID" binding:"required"` } -func (c *PackageService) Delete(req PackageDeleteReq) error { +func (c *PackageService) Delete(req PackageDelete) error { url, err := url.JoinPath(c.baseURL, PackageDeletePath) if err != nil { return err @@ -130,7 +166,7 @@ func (c *PackageService) Delete(req PackageDeleteReq) error { const PackageListBucketPackagesPath = "/package/listBucketPackages" -type PackageListBucketPackagesReq struct { +type PackageListBucketPackages struct { UserID UserID `form:"userID" json:"userID" binding:"required"` BucketID BucketID `form:"bucketID" json:"bucketID" binding:"required"` } @@ -139,7 +175,7 @@ type PackageListBucketPackagesResp struct { Packages []Package `json:"packages"` } -func (c *PackageService) ListBucketPackages(req PackageListBucketPackagesReq) (*PackageListBucketPackagesResp, error) { +func (c *PackageService) ListBucketPackages(req PackageListBucketPackages) (*PackageListBucketPackagesResp, error) { url, err := url.JoinPath(c.baseURL, PackageListBucketPackagesPath) if err != nil { return nil, err @@ -152,7 +188,7 @@ func (c *PackageService) ListBucketPackages(req PackageListBucketPackagesReq) (* return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[PackageListBucketPackagesResp]](resp) + codeResp, err := ParseJSONResponse[response[PackageListBucketPackagesResp]](resp) if err != nil { return nil, err } @@ -187,7 +223,7 @@ func (c *PackageService) GetCachedNodes(req PackageGetCachedNodesReq) (*PackageG return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[PackageGetCachedNodesResp]](resp) + codeResp, err := ParseJSONResponse[response[PackageGetCachedNodesResp]](resp) if err != nil { return nil, err } @@ -222,7 +258,7 @@ func (c *PackageService) GetLoadedNodes(req PackageGetLoadedNodesReq) (*PackageG return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[PackageGetLoadedNodesResp]](resp) + codeResp, err := ParseJSONResponse[response[PackageGetLoadedNodesResp]](resp) if err != nil { return nil, err } diff --git a/sdks/storage/storage.go b/sdks/storage/storage.go index 827d06e..92f63ef 100644 --- a/sdks/storage/storage.go +++ b/sdks/storage/storage.go @@ -32,7 +32,7 @@ func (c *Client) StorageLoadPackage(req StorageLoadPackageReq) (*StorageLoadPack return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[StorageLoadPackageResp]](resp) + codeResp, err := ParseJSONResponse[response[StorageLoadPackageResp]](resp) if err != nil { return nil, err } @@ -109,7 +109,7 @@ func (c *Client) StorageGetInfo(req StorageGetInfoReq) (*StorageGetInfoResp, err return nil, err } - codeResp, err := myhttp.ParseJSONResponse[response[StorageGetInfoResp]](resp) + codeResp, err := ParseJSONResponse[response[StorageGetInfoResp]](resp) if err != nil { return nil, err } diff --git a/sdks/storage/storage_test.go b/sdks/storage/storage_test.go index 0527fbe..a5a7d6c 100644 --- a/sdks/storage/storage_test.go +++ b/sdks/storage/storage_test.go @@ -23,21 +23,21 @@ func Test_PackageGet(t *testing.T) { } pkgName := uuid.NewString() - createResp, err := cli.Package().Create(PackageCreateReq{ + createResp, err := cli.Package().Create(PackageCreate{ UserID: 1, BucketID: 1, Name: pkgName, }) So(err, ShouldBeNil) - _, err = cli.Object().Upload(ObjectUploadReq{ + _, err = cli.Object().Upload(ObjectUpload{ ObjectUploadInfo: ObjectUploadInfo{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }, Files: iterator.Array( &UploadingObject{ - Path: "test", + Path: "abc/test", File: io.NopCloser(bytes.NewBuffer(fileData)), }, &UploadingObject{ @@ -50,16 +50,16 @@ func Test_PackageGet(t *testing.T) { getResp, err := cli.Package().Get(PackageGetReq{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }) So(err, ShouldBeNil) - So(getResp.PackageID, ShouldEqual, createResp.PackageID) + So(getResp.PackageID, ShouldEqual, createResp.Package.PackageID) So(getResp.Package.Name, ShouldEqual, pkgName) - err = cli.Package().Delete(PackageDeleteReq{ + err = cli.Package().Delete(PackageDelete{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }) So(err, ShouldBeNil) }) @@ -79,17 +79,17 @@ func Test_Object(t *testing.T) { nodeAff := NodeID(2) pkgName := uuid.NewString() - createResp, err := cli.Package().Create(PackageCreateReq{ + createResp, err := cli.Package().Create(PackageCreate{ UserID: 1, BucketID: 1, Name: pkgName, }) So(err, ShouldBeNil) - _, err = cli.Object().Upload(ObjectUploadReq{ + _, err = cli.Object().Upload(ObjectUpload{ ObjectUploadInfo: ObjectUploadInfo{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, NodeAffinity: &nodeAff, }, Files: iterator.Array( @@ -116,9 +116,9 @@ func Test_Object(t *testing.T) { // So(downFileData, ShouldResemble, fileData) // downFs.Close() - err = cli.Package().Delete(PackageDeleteReq{ + err = cli.Package().Delete(PackageDelete{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }) So(err, ShouldBeNil) }) @@ -136,17 +136,17 @@ func Test_Storage(t *testing.T) { } pkgName := uuid.NewString() - createResp, err := cli.Package().Create(PackageCreateReq{ + createResp, err := cli.Package().Create(PackageCreate{ UserID: 1, BucketID: 1, Name: pkgName, }) So(err, ShouldBeNil) - _, err = cli.Object().Upload(ObjectUploadReq{ + _, err = cli.Object().Upload(ObjectUpload{ ObjectUploadInfo: ObjectUploadInfo{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }, Files: iterator.Array( &UploadingObject{ @@ -163,14 +163,14 @@ func Test_Storage(t *testing.T) { _, err = cli.StorageLoadPackage(StorageLoadPackageReq{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, StorageID: 1, }) So(err, ShouldBeNil) - err = cli.Package().Delete(PackageDeleteReq{ + err = cli.Package().Delete(PackageDelete{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }) So(err, ShouldBeNil) }) @@ -188,17 +188,17 @@ func Test_Cache(t *testing.T) { } pkgName := uuid.NewString() - createResp, err := cli.Package().Create(PackageCreateReq{ + createResp, err := cli.Package().Create(PackageCreate{ UserID: 1, BucketID: 1, Name: pkgName, }) So(err, ShouldBeNil) - _, err = cli.Object().Upload(ObjectUploadReq{ + _, err = cli.Object().Upload(ObjectUpload{ ObjectUploadInfo: ObjectUploadInfo{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }, Files: iterator.Array( &UploadingObject{ @@ -215,14 +215,14 @@ func Test_Cache(t *testing.T) { _, err = cli.CacheMovePackage(CacheMovePackageReq{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, NodeID: 1, }) So(err, ShouldBeNil) - err = cli.Package().Delete(PackageDeleteReq{ + err = cli.Package().Delete(PackageDelete{ UserID: 1, - PackageID: createResp.PackageID, + PackageID: createResp.Package.PackageID, }) So(err, ShouldBeNil) }) diff --git a/sdks/storage/utils.go b/sdks/storage/utils.go index 89cb5a2..fdbf25b 100644 --- a/sdks/storage/utils.go +++ b/sdks/storage/utils.go @@ -1,7 +1,38 @@ package cdssdk -import "path/filepath" +import ( + "fmt" + "io" + "net/http" + "path/filepath" + "strings" + + myhttp "gitlink.org.cn/cloudream/common/utils/http" + "gitlink.org.cn/cloudream/common/utils/math" + "gitlink.org.cn/cloudream/common/utils/serder" +) func MakeIPFSFilePath(fileHash string) string { return filepath.Join("ipfs", fileHash) } + +func ParseJSONResponse[TBody any](resp *http.Response) (TBody, error) { + var ret TBody + contType := resp.Header.Get("Content-Type") + if strings.Contains(contType, myhttp.ContentTypeJSON) { + var err error + if ret, err = serder.JSONToObjectStreamEx[TBody](resp.Body); err != nil { + return ret, fmt.Errorf("parsing response: %w", err) + } + + return ret, nil + } + + cont, err := io.ReadAll(resp.Body) + if err != nil { + return ret, fmt.Errorf("unknow response content type: %s, status: %d", contType, resp.StatusCode) + } + strCont := string(cont) + + return ret, fmt.Errorf("unknow response content type: %s, status: %d, body(prefix): %s", contType, resp.StatusCode, strCont[:math.Min(len(strCont), 200)]) +} diff --git a/utils/http/http.go b/utils/http/http.go index bab12e6..94f5241 100644 --- a/utils/http/http.go +++ b/utils/http/http.go @@ -133,8 +133,9 @@ func ParseJSONResponse[TBody any](resp *http.Response) (TBody, error) { } type MultiPartFile struct { - FileName string - File io.ReadCloser + FieldName string + FileName string + File io.ReadCloser } type multiPartFileIterator struct { @@ -146,9 +147,16 @@ func (m *multiPartFileIterator) MoveNext() (*MultiPartFile, error) { if m.firstFile != nil { f := m.firstFile m.firstFile = nil + + fileName, err := ul.PathUnescape(f.FileName()) + if err != nil { + return nil, fmt.Errorf("unescape file name: %w", err) + } + return &MultiPartFile{ - FileName: f.FileName(), - File: f, + FieldName: f.FormName(), + FileName: fileName, + File: f, }, nil } @@ -161,10 +169,16 @@ func (m *multiPartFileIterator) MoveNext() (*MultiPartFile, error) { return nil, err } + fileName, err := ul.PathUnescape(part.FileName()) + if err != nil { + return nil, fmt.Errorf("unescape file name: %w", err) + } + if part.FileName() != "" { return &MultiPartFile{ - FileName: part.FileName(), - File: part, + FieldName: part.FormName(), + FileName: fileName, + File: part, }, nil } } @@ -292,7 +306,7 @@ func PostMultiPart(url string, param MultiPartRequestParam) (*http.Response, err err = func() error { defer file.File.Close() - w, err := muWriter.CreateFormFile(file.FieldName, file.FileName) + w, err := muWriter.CreateFormFile(file.FieldName, ul.PathEscape(file.FileName)) if err != nil { return fmt.Errorf("create form file failed, err: %w", err) } diff --git a/utils/serder/serder.go b/utils/serder/serder.go index 911e8ae..e8ded8c 100644 --- a/utils/serder/serder.go +++ b/utils/serder/serder.go @@ -53,6 +53,18 @@ func JSONToObjectEx[T any](data []byte) (T, error) { return ret, nil } +// 将JSON字符串转为对象。支持TypeUnion。 +func JSONToObjectStreamEx[T any](stream io.Reader) (T, error) { + var ret T + dec := defaultAPI.NewDecoder(stream) + err := dec.Decode(&ret) + if err != nil { + return ret, err + } + + return ret, nil +} + // 将对象转为JSON字符串。如果需要支持解析TypeUnion类型，则使用"Ex"结尾的同名函数。 func ObjectToJSON(obj any) ([]byte, error) { return json.Marshal(obj)