JCS-pub/client/sdk/api/v1/package.go

package api

import (
	"fmt"
	"io"
	"mime"
	"net/http"
	"net/url"
	"strings"

	"gitlink.org.cn/cloudream/common/consts/errorcode"
	"gitlink.org.cn/cloudream/common/pkgs/iterator"
	"gitlink.org.cn/cloudream/common/sdks"
	"gitlink.org.cn/cloudream/common/utils/http2"
	"gitlink.org.cn/cloudream/common/utils/serder"
	jcstypes "gitlink.org.cn/cloudream/jcs-pub/common/types"
)

type PackageService struct {
	*Client
}

func (c *Client) Package() *PackageService {
	return &PackageService{c}
}

const PackageGetPath = "/package/get"

type PackageGet struct {
	PackageID jcstypes.PackageID `form:"packageID" url:"packageID" binding:"required"`
}

func (r *PackageGet) MakeParam() *sdks.RequestParam {
	return sdks.MakeQueryParam(http.MethodGet, PackageGetPath, r)
}

type PackageGetResp struct {
	Package jcstypes.Package `json:"package"`
}

func (r *PackageGetResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (c *PackageService) Get(req PackageGet) (*PackageGetResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &PackageGetResp{})
}

const PackageGetByFullNamePath = "/package/getByFullName"

type PackageGetByFullName struct {
	BucketName  string `form:"bucketName" url:"bucketName" binding:"required"`
	PackageName string `form:"packageName" url:"packageName" binding:"required"`
}

func (r *PackageGetByFullName) MakeParam() *sdks.RequestParam {
	return sdks.MakeQueryParam(http.MethodGet, PackageGetByFullNamePath, r)
}

type PackageGetByFullNameResp struct {
	Package jcstypes.Package `json:"package"`
}

func (r *PackageGetByFullNameResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (c *PackageService) GetByFullName(req PackageGetByFullName) (*PackageGetByFullNameResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &PackageGetByFullNameResp{})
}

const PackageCreatePath = "/package/create"

type PackageCreate struct {
	BucketID jcstypes.BucketID `json:"bucketID"`
	Name     string            `json:"name"`
}

func (r *PackageCreate) MakeParam() *sdks.RequestParam {
	return sdks.MakeJSONParam(http.MethodPost, PackageCreatePath, r)
}

type PackageCreateResp struct {
	Package jcstypes.Package `json:"package"`
}

func (r *PackageCreateResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (s *PackageService) Create(req PackageCreate) (*PackageCreateResp, error) {
	return JSONAPI(&s.cfg, s.httpCli, &req, &PackageCreateResp{})
}

const PackageCreateUploadPath = "/package/createUpload"

type PackageCreateUpload struct {
	PackageCreateUploadInfo
	Files UploadObjectIterator `json:"-"`
}
type PackageCreateUploadInfo struct {
	BucketID   jcstypes.BucketID      `json:"bucketID" binding:"required"`
	Name       string                 `json:"name" binding:"required"`
	CopyTo     []jcstypes.UserSpaceID `json:"copyTo"`
	CopyToPath []string               `json:"copyToPath"`
}
type PackageCreateUploadResp struct {
	Package jcstypes.Package  `json:"package"`
	Objects []jcstypes.Object `json:"objects"`
}

func (c *PackageService) CreateUpload(req PackageCreateUpload) (*PackageCreateUploadResp, error) {
	url, err := url.JoinPath(c.cfg.EndPoint, "v1", PackageCreateUploadPath)
	if err != nil {
		return nil, err
	}

	infoJSON, err := serder.ObjectToJSON(req)
	if err != nil {
		return nil, fmt.Errorf("upload info to json: %w", err)
	}

	resp, err := PostMultiPart(&c.cfg, c.httpCli, url,
		map[string]string{"info": string(infoJSON)},
		iterator.Map(req.Files, func(src *UploadingObject) (*http2.IterMultiPartFile, error) {
			return &http2.IterMultiPartFile{
				FieldName: "files",
				FileName:  src.Path,
				File:      src.File,
			}, nil
		}))
	if err != nil {
		return nil, err
	}

	codeResp, err := ParseJSONResponse[response[PackageCreateUploadResp]](resp)
	if err != nil {
		return nil, err
	}

	if codeResp.Code == errorcode.OK {
		return &codeResp.Data, nil
	}

	return nil, codeResp.ToError()
}

const PackageDownloadPath = "/package/download"

type PackageDownload struct {
	PackageID jcstypes.PackageID `url:"packageID" form:"packageID" binding:"required"`
	Prefix    string             `url:"prefix" form:"prefix"`
	NewPrefix *string            `url:"newPrefix,omitempty" form:"newPrefix"`
	Zip       bool               `url:"zip,omitempty" form:"zip"`
}

func (r *PackageDownload) MakeParam() *sdks.RequestParam {
	return sdks.MakeQueryParam(http.MethodGet, PackageDownloadPath, r)
}

type DownloadingPackage struct {
	Name string
	File io.ReadCloser
}

func (c *PackageService) Download(req PackageDownload) (*DownloadingPackage, error) {
	url, err := url.JoinPath(c.cfg.EndPoint, "v1")
	if err != nil {
		return nil, err
	}

	httpReq, err := req.MakeParam().MakeRequest(url)
	if err != nil {
		return nil, err
	}

	resp, err := c.Client.httpCli.Do(httpReq)
	if err != nil {
		return nil, err
	}

	contType := resp.Header.Get("Content-Type")

	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("response status code: %d", resp.StatusCode)
	}

	if strings.Contains(contType, http2.ContentTypeJSON) {
		var codeResp response[any]
		if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
			return nil, fmt.Errorf("parsing response: %w", err)
		}

		return nil, codeResp.ToError()
	}

	_, params, err := mime.ParseMediaType(resp.Header.Get("Content-Disposition"))
	if err != nil {
		return nil, fmt.Errorf("parsing content disposition: %w", err)
	}

	return &DownloadingPackage{
		Name: params["filename"],
		File: resp.Body,
	}, nil
}

const PackageDeletePath = "/package/delete"

type PackageDelete struct {
	PackageID jcstypes.PackageID `json:"packageID" binding:"required"`
}

func (r *PackageDelete) MakeParam() *sdks.RequestParam {
	return sdks.MakeJSONParam(http.MethodPost, PackageDeletePath, r)
}

type PackageDeleteResp struct{}

func (r *PackageDeleteResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (c *PackageService) Delete(req PackageDelete) error {
	return JSONAPINoData(&c.cfg, c.httpCli, &req)
}

const PackageClonePath = "/package/clone"

type PackageClone struct {
	PackageID jcstypes.PackageID `json:"packageID" binding:"required"`
	BucketID  jcstypes.BucketID  `json:"bucketID" binding:"required"`
	Name      string             `json:"name" binding:"required"`
}

func (r *PackageClone) MakeParam() *sdks.RequestParam {
	return sdks.MakeJSONParam(http.MethodPost, PackageClonePath, r)
}

type PackageCloneResp struct {
	Package jcstypes.Package `json:"package"`
}

func (r *PackageCloneResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (c *PackageService) Clone(req PackageClone) (*PackageCloneResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &PackageCloneResp{})
}

const PackageListBucketPackagesPath = "/package/listBucketPackages"

type PackageListBucketPackages struct {
	BucketID jcstypes.BucketID `form:"bucketID" url:"bucketID" binding:"required"`
}

func (r *PackageListBucketPackages) MakeParam() *sdks.RequestParam {
	return sdks.MakeQueryParam(http.MethodGet, PackageListBucketPackagesPath, r)
}

type PackageListBucketPackagesResp struct {
	Packages []jcstypes.Package `json:"packages"`
}

func (r *PackageListBucketPackagesResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (c *PackageService) ListBucketPackages(req PackageListBucketPackages) (*PackageListBucketPackagesResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &PackageListBucketPackagesResp{})
}

const PackagePinPath = "/package/pin"

type PackagePin struct {
	PackageID jcstypes.PackageID `json:"packageID" binding:"required"`
	Pin       bool               `json:"pin" binding:"required"`
}

func (r *PackagePin) MakeParam() *sdks.RequestParam {
	return sdks.MakeJSONParam(http.MethodPost, PackagePinPath, r)
}

type PackagePinResp struct{}

func (r *PackagePinResp) ParseResponse(resp *http.Response) error {
	return sdks.ParseCodeDataJSONResponse(resp, r)
}

func (c *PackageService) Pin(req PackagePin) (*PackagePinResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &PackagePinResp{})
}