robotfs/api_directory.go

package main

import (
	"context"

	"gosvc/httpserver"
	"gosvc/logger"
	"gosvc/validator"
	"robotfs/entity"
	"robotfs/utils"
)

type ListResult struct {
	Entries       []Entry `json:"entries"`
	MoreAvailable bool    `json:"more_available"`
	IsEmptyFolder bool    `json:"is_empty_folder"`
	LastFileName  string  `json:"last_file_name"`
}

type Entry struct {
	Name        string `json:"name"`
	IsDir       bool   `json:"is_dir"`
	Size        uint64 `json:"size"`
	ContentType string `json:"content_type"`
	CreateTime  int64  `json:"create_time"`
	S3Key       string `json:"s3key"`
}

type MkdirParams struct {
	Path string
}

func (m *MkdirParams) Validate() error {
	return validator.WithIf(
		m.Path == "", "Path is empty",
	).Validate()
}

func (s *Service) HandleMkdir(
	req *httpserver.Request,
	resp *httpserver.Response,
) *httpserver.Response {
	params := req.Binded.(*MkdirParams)
	path := params.Path
	newPath := utils.NormalizePath(path)

	err := s.FileSystemManager.MakeDirectory(req.Context(), utils.FullPath(newPath))
	if err != nil {
		logger.Error("mkdir %s:  %v", path, err)
		out := entity.NewError[any](
			entity.CodeInternalServer,
			entity.ErrMkDir,
			map[string]interface{}{
				"detail": "mkdir failed, " + err.Error(),
			},
		)
		return resp.OK(out).JSON()
	}

	return resp.OK(entity.NewSuccess("")).JSON()
}

func (s *Service) HandleListDirectory(
	req *httpserver.Request,
	resp *httpserver.Response,
) *httpserver.Response {
	path := req.QueryString("path")
	startFileName := req.QueryString("startFileName")
	inclusive := req.QueryBool("inclusive")
	limit := req.QueryInt("limit")
	newPath := utils.NormalizePath(path)

	rawEntries, moreAvailable, lastFileName, err := s.FileSystemManager.ListDirectoryEntries(
		context.Background(),
		utils.FullPath(newPath),
		startFileName,
		inclusive,
		limit,
	)
	if err != nil {
		logger.Error("list dir %s %s %d: %v", path, startFileName, limit, err)
		out := entity.NewError[any](
			entity.CodeInternalServer,
			entity.ErrListDir,
			map[string]interface{}{
				"detail": "list directory failed, " + err.Error(),
			},
		)
		return resp.OK(out).JSON()
	}

	result := ListResult{
		MoreAvailable: moreAvailable,
		IsEmptyFolder: len(rawEntries) == 0,
		LastFileName:  lastFileName,
	}

	if len(rawEntries) > 0 {
		entries := make([]Entry, len(rawEntries))
		for i, e := range rawEntries {
			entries[i] = Entry{
				Name:        e.FullPath.Name(),
				IsDir:       e.IsDir,
				Size:        e.Size,
				ContentType: e.ContentType,
				CreateTime:  e.CreateTime,
				S3Key:       e.S3Key,
			}
		}

		result.Entries = entries
	}

	return resp.OK(entity.NewSuccess(result)).JSON()
}

func (s *Service) HandleDeleteDirectory(
	req *httpserver.Request,
	resp *httpserver.Response,
) *httpserver.Response {
	params := req.Binded.(*DeleteParams)
	path := params.Path
	isDir := params.IsDir
	newPath := utils.NormalizePath(path)

	if !isDir {
		out := entity.NewError[any](
			entity.CodeBadRequest,
			entity.ErrDeleteDir,
			map[string]interface{}{
				"detail": "is dir param must be true",
			},
		)
		return resp.OK(out).JSON()
	}

	if err := s.FileSystemManager.DeleteDirectory(req.Context(), utils.FullPath(newPath), isDir, false); err != nil {
		logger.Error("del dir %s: %v", path, err)
		out := entity.NewError[any](
			entity.CodeInternalServer,
			entity.ErrDeleteDir,
			map[string]interface{}{
				"detail": "delete directory failed, " + err.Error(),
			},
		)
		return resp.OK(out).JSON()
	}

	return resp.OK(entity.NewSuccess("")).JSON()
}

func (s *Service) HandleRenameDirectory(
	req *httpserver.Request,
	resp *httpserver.Response,
) *httpserver.Response {
	params := req.Binded.(*RenameParams)
	srcPath := utils.NormalizePath(params.SrcPath)
	dstPath := utils.NormalizePath(params.DstPath)
	isDir := params.IsDir

	oldPath := utils.FullPath(srcPath)
	newPath := utils.FullPath(dstPath)
	if err := s.FileSystemManager.RenameDirectory(req.Context(), oldPath, newPath, isDir); err != nil {
		logger.Error("move dir %s => %s: %v", params.SrcPath, params.DstPath, err)
		out := entity.NewError[any](
			entity.CodeInternalServer,
			entity.ErrRenameDir,
			map[string]interface{}{
				"detail": "move directory failed, " + err.Error(),
			},
		)
		return resp.OK(out).JSON()
	}

	return resp.OK(entity.NewSuccess("")).JSON()
}

func (s *Service) HandleCopyDirectory(
	req *httpserver.Request,
	resp *httpserver.Response,
) *httpserver.Response {
	params := req.Binded.(*CopyParams)
	srcPath := utils.NormalizePath(params.SrcPath)
	dstPath := utils.NormalizePath(params.DstPath)
	isDir := params.IsDir

	oldPath := utils.FullPath(srcPath)
	newPath := utils.FullPath(dstPath)
	if err := s.FileSystemManager.CopyDirectory(req.Context(), oldPath, newPath, isDir); err != nil {
		logger.Error("copy dir %s => %s: %v", params.SrcPath, params.DstPath, err)
		out := entity.NewError[any](
			entity.CodeInternalServer,
			entity.ErrCopyDir,
			map[string]interface{}{
				"detail": "copy directory failed, " + err.Error(),
			},
		)
		return resp.OK(out).JSON()
	}

	return resp.OK(entity.NewSuccess("")).JSON()
}