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

package api

import (
	"net/http"

	"gitlink.org.cn/cloudream/common/sdks"
	jcstypes "gitlink.org.cn/cloudream/jcs-pub/common/types"
)

type UserSpaceService struct {
	*Client
}

func (c *Client) UserSpace() *UserSpaceService {
	return &UserSpaceService{c}
}

const UserSpaceDownloadPackagePath = "/userSpace/downloadPackage"

type UserSpaceDownloadPackage struct {
	PackageID   jcstypes.PackageID   `json:"packageID" binding:"required"`
	UserSpaceID jcstypes.UserSpaceID `json:"userSpaceID" binding:"required"`
	RootPath    string               `json:"rootPath"`
	Concurrency int                  `json:"concurrency"`
}

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

type UserSpaceDownloadPackageResp struct{}

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

func (c *UserSpaceService) DownloadPackage(req UserSpaceDownloadPackage) (*UserSpaceDownloadPackageResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceDownloadPackageResp{})
}

const UserSpaceCreatePackagePath = "/userSpace/createPackage"

type UserSpaceCreatePackageReq struct {
	UserSpaceID   jcstypes.UserSpaceID `json:"userSpaceID" binding:"required"`
	Path          string               `json:"path" binding:"required"`
	BucketID      jcstypes.BucketID    `json:"bucketID" binding:"required"`
	Name          string               `json:"name" binding:"required"`
	SpaceAffinity jcstypes.UserSpaceID `json:"spaceAffinity"`
}

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

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

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

func (c *UserSpaceService) CreatePackage(req UserSpaceCreatePackageReq) (*UserSpaceCreatePackageResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceCreatePackageResp{})
}

const UserSpaceGetPath = "/userSpace/get"

type UserSpaceGet struct {
	UserSpaceID jcstypes.UserSpaceID `form:"userSpaceID" url:"userSpaceID" binding:"required"`
}

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

type UserSpaceGetResp struct {
	UserSpace jcstypes.UserSpace `json:"userSpace"`
}

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

func (c *UserSpaceService) Get(req UserSpaceGet) (*UserSpaceGetResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceGetResp{})
}

const UserSpaceGetByNamePath = "/userSpace/getByName"

type UserSpaceGetByName struct {
	Name string `form:"name" url:"name" binding:"required"`
}

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

type UserSpaceGetByNameResp struct {
	UserSpace jcstypes.UserSpace `json:"userSpace"`
}

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

func (c *UserSpaceService) GetByName(req UserSpaceGetByName) (*UserSpaceGetByNameResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceGetByNameResp{})
}

const UserSpaceGetAllPath = "/userSpace/getAll"

type UserSpaceGetAll struct{}

func (r *UserSpaceGetAll) MakeParam() *sdks.RequestParam {
	return sdks.MakeQueryParam(http.MethodGet, UserSpaceGetAllPath, nil)
}

type UserSpaceGetAllResp struct {
	UserSpaces []jcstypes.UserSpace `json:"userSpaces"`
}

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

func (c *UserSpaceService) GetAll() (*UserSpaceGetAllResp, error) {
	req := UserSpaceGetAll{}
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceGetAllResp{})
}

// 创建用户空间
const UserSpaceCreatePath = "/userSpace/create"

type UserSpaceCreate struct {
	Name       string                         `json:"name" binding:"required"`
	Storage    jcstypes.StorageType           `json:"storage" binding:"required"`
	Credential jcstypes.StorageCredential     `json:"credential" binding:"required"`
	ShardStore *jcstypes.ShardStoreUserConfig `json:"shardStore"`
	Features   []jcstypes.StorageFeature      `json:"features"`
	WorkingDir string                         `json:"workingDir"`
}

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

type UserSpaceCreateResp struct {
	UserSpace jcstypes.UserSpace `json:"userSpace"`
}

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

func (c *UserSpaceService) Create(req UserSpaceCreate) (*UserSpaceCreateResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceCreateResp{})
}

// 更新用户空间。一些重要的配置不可再二次修改
const UserSpaceUpdatePath = "/userSpace/update"

type UserSpaceUpdate struct {
	UserSpaceID jcstypes.UserSpaceID       `json:"userSpaceID" binding:"required"`
	Name        string                     `json:"name" binding:"required"`
	Credential  jcstypes.StorageCredential `json:"credential" binding:"required"`
	Features    []jcstypes.StorageFeature  `json:"features"`
}

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

type UserSpaceUpdateResp struct {
	UserSpace jcstypes.UserSpace `json:"userSpace"`
}

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

func (c *UserSpaceService) Update(req UserSpaceUpdate) (*UserSpaceUpdateResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceUpdateResp{})
}

// 删除用户空间
const UserSpaceDeletePath = "/userSpace/delete"

type UserSpaceDelete struct {
	UserSpaceID jcstypes.UserSpaceID `json:"userSpaceID" binding:"required"`
}

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

type UserSpaceDeleteResp struct{}

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

func (c *UserSpaceService) Delete(req UserSpaceDelete) (*UserSpaceDeleteResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceDeleteResp{})
}

// 测试给定用户空间的配置是否有效
const UserSpaceTestPath = "/userSpace/test"

type UserSpaceTest struct {
	Storage     jcstypes.StorageType       `json:"storage" binding:"required"`
	Credential  jcstypes.StorageCredential `json:"credential" binding:"required"`
	WorikingDir string                     `json:"workingDir"`
}

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

type UserSpaceTestResp struct {
	// TODO 可以考虑返回WorkingDir内的文件列表
}

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

func (c *UserSpaceService) Test(req UserSpaceTest) (*UserSpaceTestResp, error) {
	return JSONAPI(&c.cfg, c.httpCli, &req, &UserSpaceTestResp{})
}