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

package http

import (
	"fmt"
	"net/http"
	"time"

	"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 BucketService struct {
	*Server
}

func (s *Server) Bucket() *BucketService {
	return &BucketService{
		Server: s,
	}
}

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

	var req cliapi.BucketGet
	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
	}

	bucket, err := s.svc.DB.Bucket().GetByID(s.svc.DB.DefCtx(), req.BucketID)
	if err != nil {
		log.Warnf("getting bucket by name: %s", err.Error())
		ctx.JSON(http.StatusOK, types.FailedError(err))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.BucketGetResp{
		Bucket: bucket,
	}))
}

func (s *BucketService) GetByName(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Bucket.GetByName")

	var req cliapi.BucketGetByName
	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
	}

	bucket, err := s.svc.BucketSvc().GetBucketByName(req.Name)
	if err != nil {
		log.Warnf("getting bucket by name: %s", err.Error())
		ctx.JSON(http.StatusOK, types.FailedError(err))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.BucketGetByNameResp{
		Bucket: bucket,
	}))
}

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

	var req cliapi.BucketCreate
	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
	}

	bucket, err := s.svc.BucketSvc().CreateBucket(req.Name, time.Now())
	if err != nil {
		log.Warnf("creating bucket: %s", err.Error())
		ctx.JSON(http.StatusOK, types.FailedError(err))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.BucketCreateResp{
		Bucket: bucket,
	}))
}

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

	var req cliapi.BucketDelete
	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
	}

	if err := s.svc.BucketSvc().DeleteBucket(req.BucketID); err != nil {
		log.Warnf("deleting bucket: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, "delete bucket types.Failed"))
		return
	}

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

func (s *BucketService) ListAll(ctx *gin.Context) {
	log := logger.WithField("HTTP", "Bucket.ListAll")

	var req cliapi.BucketListAll
	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
	}

	buckets, err := s.svc.BucketSvc().ListAllBuckets()
	if err != nil {
		log.Warnf("list all buckets: %s", err.Error())
		ctx.JSON(http.StatusOK, types.Failed(ecode.OperationFailed, fmt.Sprintf("list all buckets: %v", err)))
		return
	}

	ctx.JSON(http.StatusOK, types.OK(cliapi.BucketListAllResp{
		Buckets: buckets,
	}))
}