1Panel/backend/app/service/file.go

239 lines
5.7 KiB
Go
Raw Normal View History

2022-08-24 11:10:50 +08:00
package service
import (
"fmt"
2022-12-01 10:36:49 +08:00
"io/fs"
"os"
"path/filepath"
"strings"
"time"
2023-03-02 13:54:07 +08:00
"github.com/1Panel-dev/1Panel/backend/app/dto/request"
"github.com/1Panel-dev/1Panel/backend/app/dto/response"
"github.com/1Panel-dev/1Panel/backend/buserr"
"github.com/1Panel-dev/1Panel/backend/constant"
"github.com/1Panel-dev/1Panel/backend/global"
"github.com/1Panel-dev/1Panel/backend/utils/common"
"github.com/1Panel-dev/1Panel/backend/utils/files"
"github.com/pkg/errors"
2022-09-14 19:09:39 +08:00
uuid "github.com/satori/go.uuid"
2022-08-24 11:10:50 +08:00
)
type FileService struct {
}
2022-12-14 15:39:13 +08:00
func (f FileService) GetFileList(op request.FileOption) (response.FileInfo, error) {
var fileInfo response.FileInfo
2022-12-01 10:36:49 +08:00
if _, err := os.Stat(op.Path); err != nil && os.IsNotExist(err) {
return fileInfo, nil
}
2022-08-24 11:10:50 +08:00
info, err := files.NewFileInfo(op.FileOption)
if err != nil {
return fileInfo, err
}
fileInfo.FileInfo = *info
return fileInfo, nil
}
2022-08-24 17:34:21 +08:00
2023-03-02 13:54:07 +08:00
func (f FileService) SearchUploadWithPage(req request.SearchUploadWithPage) (int64, interface{}, error) {
var (
files []response.UploadInfo
backDatas []response.UploadInfo
)
_ = filepath.Walk(req.Path, func(path string, info os.FileInfo, err error) error {
if err != nil {
return nil
}
if !info.IsDir() {
files = append(files, response.UploadInfo{
CreatedAt: info.ModTime().Format("2006-01-02 15:04:05"),
Size: int(info.Size()),
Name: info.Name(),
})
}
return nil
})
total, start, end := len(files), (req.Page-1)*req.PageSize, req.Page*req.PageSize
if start > total {
backDatas = make([]response.UploadInfo, 0)
} else {
if end >= total {
end = total
}
backDatas = files[start:end]
}
return int64(total), backDatas, nil
}
2022-12-14 15:39:13 +08:00
func (f FileService) GetFileTree(op request.FileOption) ([]response.FileTree, error) {
var treeArray []response.FileTree
2022-08-24 17:34:21 +08:00
info, err := files.NewFileInfo(op.FileOption)
if err != nil {
return nil, err
}
2022-12-14 15:39:13 +08:00
node := response.FileTree{
ID: common.GetUuid(),
2022-08-24 17:34:21 +08:00
Name: info.Name,
Path: info.Path,
}
for _, v := range info.Items {
if v.IsDir {
2022-12-14 15:39:13 +08:00
node.Children = append(node.Children, response.FileTree{
ID: common.GetUuid(),
2022-08-24 17:34:21 +08:00
Name: v.Name,
Path: v.Path,
})
}
}
return append(treeArray, node), nil
}
2022-12-14 15:39:13 +08:00
func (f FileService) Create(op request.FileCreate) error {
2022-08-25 17:54:52 +08:00
fo := files.NewFileOp()
if fo.Stat(op.Path) {
return errors.New("file is exist")
}
2022-08-25 17:54:52 +08:00
if op.IsDir {
return fo.CreateDir(op.Path, fs.FileMode(op.Mode))
} else {
if op.IsLink {
return fo.LinkFile(op.LinkPath, op.Path, op.IsSymlink)
} else {
return fo.CreateFile(op.Path)
}
2022-08-25 17:54:52 +08:00
}
}
2022-12-14 15:39:13 +08:00
func (f FileService) Delete(op request.FileDelete) error {
2022-08-25 18:48:03 +08:00
fo := files.NewFileOp()
if op.IsDir {
return fo.DeleteDir(op.Path)
} else {
return fo.DeleteFile(op.Path)
}
}
2022-12-14 15:39:13 +08:00
func (f FileService) BatchDelete(op request.FileBatchDelete) error {
2022-12-01 10:36:49 +08:00
fo := files.NewFileOp()
if op.IsDir {
for _, file := range op.Paths {
if err := fo.DeleteDir(file); err != nil {
return err
}
}
} else {
for _, file := range op.Paths {
if err := fo.DeleteFile(file); err != nil {
return err
}
}
}
return nil
}
2022-12-14 15:39:13 +08:00
func (f FileService) ChangeMode(op request.FileCreate) error {
fo := files.NewFileOp()
return fo.Chmod(op.Path, fs.FileMode(op.Mode))
}
2022-12-14 15:39:13 +08:00
func (f FileService) Compress(c request.FileCompress) error {
2022-08-30 17:59:59 +08:00
fo := files.NewFileOp()
if !c.Replace && fo.Stat(filepath.Join(c.Dst, c.Name)) {
return errors.New("file is exist")
}
return fo.Compress(c.Files, c.Dst, c.Name, files.CompressType(c.Type))
}
2022-12-14 15:39:13 +08:00
func (f FileService) DeCompress(c request.FileDeCompress) error {
2022-08-31 13:59:02 +08:00
fo := files.NewFileOp()
return fo.Decompress(c.Path, c.Dst, files.CompressType(c.Type))
}
2022-12-14 15:39:13 +08:00
func (f FileService) GetContent(op request.FileOption) (response.FileInfo, error) {
2022-09-06 17:48:49 +08:00
info, err := files.NewFileInfo(op.FileOption)
2022-09-01 19:02:33 +08:00
if err != nil {
2022-12-14 15:39:13 +08:00
return response.FileInfo{}, err
2022-09-01 19:02:33 +08:00
}
2022-12-14 15:39:13 +08:00
return response.FileInfo{FileInfo: *info}, nil
2022-09-01 19:02:33 +08:00
}
2022-12-14 15:39:13 +08:00
func (f FileService) SaveContent(edit request.FileEdit) error {
2022-09-01 19:02:33 +08:00
info, err := files.NewFileInfo(files.FileOption{
2022-09-06 17:48:49 +08:00
Path: edit.Path,
2022-09-01 19:02:33 +08:00
Expand: false,
})
if err != nil {
return err
}
fo := files.NewFileOp()
2022-09-06 17:48:49 +08:00
return fo.WriteFile(edit.Path, strings.NewReader(edit.Content), info.FileMode)
2022-09-01 19:02:33 +08:00
}
2022-12-14 15:39:13 +08:00
func (f FileService) ChangeName(req request.FileRename) error {
2022-09-03 22:22:40 +08:00
fo := files.NewFileOp()
2022-12-14 15:39:13 +08:00
return fo.Rename(req.OldName, req.NewName)
2022-09-03 22:22:40 +08:00
}
2022-12-14 15:39:13 +08:00
func (f FileService) Wget(w request.FileWget) (string, error) {
2022-09-05 16:25:26 +08:00
fo := files.NewFileOp()
2022-09-14 19:09:39 +08:00
key := "file-wget-" + uuid.NewV4().String()
2022-10-14 14:48:55 +08:00
return key, fo.DownloadFileWithProcess(w.Url, filepath.Join(w.Path, w.Name), key)
2022-09-05 16:25:26 +08:00
}
2022-12-14 15:39:13 +08:00
func (f FileService) MvFile(m request.FileMove) error {
2022-09-06 10:35:35 +08:00
fo := files.NewFileOp()
2023-02-09 14:31:05 +08:00
if !fo.Stat(m.NewPath) {
return buserr.New(constant.ErrPathNotFound)
}
2022-09-06 17:48:49 +08:00
if m.Type == "cut" {
return fo.Cut(m.OldPaths, m.NewPath)
2022-09-06 10:35:35 +08:00
}
2022-09-06 15:46:46 +08:00
var errs []error
2022-09-06 17:48:49 +08:00
if m.Type == "copy" {
for _, src := range m.OldPaths {
if err := fo.Copy(src, m.NewPath); err != nil {
2022-09-06 15:46:46 +08:00
errs = append(errs, err)
2022-09-06 17:48:49 +08:00
global.LOG.Errorf("copy file [%s] to [%s] failed, err: %s", src, m.NewPath, err.Error())
2022-09-06 15:46:46 +08:00
}
}
}
var errString string
for _, err := range errs {
errString += err.Error() + "\n"
}
if errString != "" {
return errors.New(errString)
}
2022-09-06 10:35:35 +08:00
return nil
}
2022-12-14 15:39:13 +08:00
func (f FileService) FileDownload(d request.FileDownload) (string, error) {
2022-09-06 17:48:49 +08:00
tempPath := filepath.Join(os.TempDir(), fmt.Sprintf("%d", time.Now().UnixNano()))
if err := os.MkdirAll(tempPath, os.ModePerm); err != nil {
return "", err
}
fo := files.NewFileOp()
if err := fo.Compress(d.Paths, tempPath, d.Name, files.CompressType(d.Type)); err != nil {
return "", err
}
filePath := filepath.Join(tempPath, d.Name)
return filePath, nil
}
2022-12-14 15:39:13 +08:00
func (f FileService) DirSize(req request.DirSizeReq) (response.DirSizeRes, error) {
fo := files.NewFileOp()
size, err := fo.GetDirSize(req.Path)
if err != nil {
2022-12-14 15:39:13 +08:00
return response.DirSizeRes{}, err
}
2022-12-14 15:39:13 +08:00
return response.DirSizeRes{Size: size}, nil
}