JCS-pub/client/internal/http/v1/user_space.go

package http

import (
	"fmt"
	"net/http"

	"github.com/gin-gonic/gin"
	"gitlink.org.cn/cloudream/common/pkgs/logger"
	"gitlink.org.cn/cloudream/jcs-pub/client/internal/http/types"
	cliapi "gitlink.org.cn/cloudream/jcs-pub/client/sdk/api/v1"
	"gitlink.org.cn/cloudream/jcs-pub/common/ecode"
)

type UserSpaceService struct {
	*Server
}

func (s *Server) UserSpace() *UserSpaceService {
	return &UserSpaceService{
		Server: s,
	}
}

func (s *UserSpaceService) DownloadPackage(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.DownloadPackage")

	var req cliapi.UserSpaceDownloadPackageReq
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	err := s.svc.UserSpaceSvc().DownloadPackage(req.PackageID, req.UserSpaceID, req.RootPath)
	if err != nil {
		log.Warnf("downloading package: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "%v", err))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.UserSpaceDownloadPackageResp{}))
}

func (s *UserSpaceService) CreatePackage(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.CreatePackage")

	var req cliapi.UserSpaceCreatePackageReq
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	pkg, err := s.svc.Uploader.UserSpaceUpload(req.UserSpaceID, req.Path, req.BucketID, req.Name, req.SpaceAffinity)
	if err != nil {
		log.Warnf("userspace create package: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("userspace create package: %v", err)))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.UserSpaceCreatePackageResp{
		Package: *pkg,
	}))
}

func (s *UserSpaceService) Get(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.Get")

	var req cliapi.UserSpaceGet
	if err := ctx.ShouldBindQuery(&req); err != nil {
		log.Warnf("binding query: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	info, err := s.svc.UserSpaceSvc().Get(req.UserSpaceID)
	if err != nil {
		log.Warnf("getting info: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "get userspace inf failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.UserSpaceGetResp{
		UserSpace: info,
	}))
}

func (s *UserSpaceService) Create(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.Create")

	req, err := types.ShouldBindJSONEx[cliapi.UserSpaceCreate](ctx)
	if err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, cerr := s.svc.UserSpaceSvc().Create(req)
	if cerr != nil {
		log.Warnf("creating userspace: %v", cerr)
		ctx.JSON(http.StatusOK, types.Failed(cerr.Code, cerr.Message))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(resp))
}

func (s *UserSpaceService) Update(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.Update")

	var req cliapi.UserSpaceUpdate
	req, err := types.ShouldBindJSONEx[cliapi.UserSpaceUpdate](ctx)
	if err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, cerr := s.svc.UserSpaceSvc().Update(req)
	if cerr != nil {
		log.Warnf("updating userspace: %v", cerr)
		ctx.JSON(http.StatusOK, types.Failed(cerr.Code, cerr.Message))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(resp))
}

func (s *UserSpaceService) Delete(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.Delete")

	var req cliapi.UserSpaceDelete
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, cerr := s.svc.UserSpaceSvc().Delete(req)
	if cerr != nil {
		log.Warnf("deleting userspace: %v", cerr)
		ctx.JSON(http.StatusOK, types.Failed(cerr.Code, cerr.Message))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(resp))
}

func (s *UserSpaceService) Test(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.Test")

	var req cliapi.UserSpaceTest
	req, err := types.ShouldBindJSONEx[cliapi.UserSpaceTest](ctx)
	if err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	resp, cerr := s.svc.UserSpaceSvc().Test(req)
	if cerr != nil {
		log.Warnf("testing userspace: %v", cerr)
		ctx.JSON(http.StatusOK, types.Failed(cerr.Code, cerr.Message))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(resp))
}

func (s *UserSpaceService) SpaceToSpace(ctx *gin.Context) {
	log := logger.WithField("HTTP", "UserSpace.SpaceToSpace")

	var req cliapi.UserSpaceSpaceToSpace
	if err := ctx.ShouldBindJSON(&req); err != nil {
		log.Warnf("binding body: %s", err.Error())
		ctx.JSON(http.StatusBadRequest, types.Failed(ecode.BadArgument, "missing argument or invalid argument"))
		return
	}

	ret, err := s.svc.UserSpaceSvc().SpaceToSpace(req.SrcUserSpaceID, req.SrcPath, req.DstUserSpaceID, req.DstPath)
	if err != nil {
		log.Warnf("space2space: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "space2space failed"))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.UserSpaceSpaceToSpaceResp{
		SpaceToSpaceResult: ret,
	}))
}