cloudreve/models/folder.go

package model

import (
	"errors"
	"github.com/HFO4/cloudreve/pkg/conf"
	"github.com/HFO4/cloudreve/pkg/util"
	"github.com/jinzhu/gorm"
	"path"
	"strings"
)

// Folder 目录
type Folder struct {
	// 表字段
	gorm.Model
	Name             string `gorm:"unique_index:idx_only_one_name"`
	ParentID         uint   `gorm:"index:parent_id;unique_index:idx_only_one_name"`
	Position         string `gorm:"size:65536"`
	OwnerID          uint   `gorm:"index:owner_id"`
	PositionAbsolute string `gorm:"size:65536"`
}

// Create 创建目录
func (folder *Folder) Create() (uint, error) {
	if err := DB.Create(folder).Error; err != nil {
		util.Log().Warning("无法插入目录记录, %s", err)
		return 0, err
	}
	return folder.ID, nil
}

// GetFolderByPath 根据绝对路径和UID查找目录
func GetFolderByPath(path string, uid uint) (Folder, error) {
	var folder Folder
	result := DB.Where("owner_id = ? AND position_absolute = ?", uid, path).First(&folder)
	return folder, result.Error
}

// GetChildFolder 查找子目录
func (folder *Folder) GetChildFolder() ([]Folder, error) {
	var folders []Folder
	result := DB.Where("parent_id = ?", folder.ID).Find(&folders)
	return folders, result.Error
}

// GetRecursiveChildFolder 查找所有递归子目录，包括自身
func GetRecursiveChildFolder(dirs []string, uid uint, includeSelf bool) ([]Folder, error) {
	folders := make([]Folder, 0, len(dirs))
	var err error
	if conf.DatabaseConfig.Type == "mysql" {

		// MySQL 下使用正则查询
		search := util.BuildRegexp(dirs, "^", "/", "|")
		result := DB.Where("(owner_id = ? and position_absolute REGEXP ?) or (owner_id = ? and position_absolute in (?))", uid, search, uid, dirs).Find(&folders)
		err = result.Error

	} else {

		// SQLite 下使用递归查询
		var parFolders []Folder
		result := DB.Where("owner_id = ? and position_absolute in (?)", uid, dirs).Find(&parFolders)
		if result.Error != nil {
			return folders, err
		}

		// 整理父目录的ID
		var parentIDs = make([]uint, 0, len(parFolders))
		for _, folder := range parFolders {
			parentIDs = append(parentIDs, folder.ID)
		}

		if includeSelf {
			// 合并至最终结果
			folders = append(folders, parFolders...)
		}
		parFolders = []Folder{}

		// 递归查询子目录,最大递归65535次
		for i := 0; i < 65535; i++ {

			result = DB.Where("owner_id = ? and parent_id in (?)", uid, parentIDs).Find(&parFolders)

			// 查询结束条件
			if len(parFolders) == 0 {
				break
			}

			// 整理父目录的ID
			parentIDs = make([]uint, 0, len(parFolders))
			for _, folder := range parFolders {
				parentIDs = append(parentIDs, folder.ID)
			}

			// 合并至最终结果
			folders = append(folders, parFolders...)
			parFolders = []Folder{}

		}

	}

	return folders, err
}

// DeleteFolderByIDs 根据给定ID批量删除目录记录
func DeleteFolderByIDs(ids []uint) error {
	result := DB.Where("id in (?)", ids).Unscoped().Delete(&Folder{})
	return result.Error
}

// MoveOrCopyFileTo 将此目录下的files移动或复制至dstFolder，
// 返回此操作新增的容量
func (folder *Folder) MoveOrCopyFileTo(files []string, dstFolder *Folder, isCopy bool) (uint64, error) {
	// 已复制文件的总大小
	var copiedSize uint64

	if isCopy {
		// 检索出要复制的文件
		var originFiles = make([]File, 0, len(files))
		if err := DB.Where(
			"name in (?) and user_id = ? and dir = ?",
			files,
			folder.OwnerID,
			folder.PositionAbsolute,
		).Find(&originFiles).Error; err != nil {
			return 0, err
		}

		// 复制文件记录
		for _, oldFile := range originFiles {
			oldFile.Model = gorm.Model{}
			oldFile.FolderID = dstFolder.ID
			oldFile.Dir = dstFolder.PositionAbsolute

			if err := DB.Create(&oldFile).Error; err != nil {
				return copiedSize, err
			}

			copiedSize += oldFile.Size
		}

	} else {
		// 更改顶级要移动文件的父目录指向
		err := DB.Model(File{}).Where(
			"name in (?) and user_id = ? and dir = ?",
			files,
			folder.OwnerID,
			folder.PositionAbsolute,
		).
			Update(map[string]interface{}{
				"folder_id": dstFolder.ID,
				"dir":       dstFolder.PositionAbsolute,
			}).
			Error
		if err != nil {
			return 0, err
		}

	}

	return copiedSize, nil

}

// MoveOrCopyFolderTo 将folder目录下的dirs子目录复制或移动到dstFolder，
// 返回此过程中增加的容量
func (folder *Folder) MoveOrCopyFolderTo(dirs []string, dstFolder *Folder, isCopy bool) (uint64, error) {
	// 生成绝对路径
	fullDirs := make([]string, len(dirs))
	for i := 0; i < len(dirs); i++ {
		fullDirs[i] = path.Join(
			folder.PositionAbsolute,
			path.Base(dirs[i]),
		)
	}

	var subFolders = make([][]Folder, len(fullDirs))

	// 更新被移动的目录递归的子目录和文件
	for key, parentDir := range fullDirs {
		// 检索被移动的目录的所有子目录
		toBeMoved, err := GetRecursiveChildFolder([]string{parentDir}, folder.OwnerID, true)
		if err != nil {
			return 0, err
		}
		subFolders[key] = toBeMoved
	}

	// 记录复制要用到的父目录源路径和新的ID
	var copyCache = make(map[string]uint)
	// 记录已复制文件的容量
	var newUsedStorage uint64

	var err error
	if isCopy {
		// 复制
		// TODO:支持多目录
		origin := Folder{}
		if DB.Where(
			"position_absolute in (?) and owner_id = ?",
			fullDirs,
			folder.OwnerID,
		).Find(&origin).Error != nil {
			return 0, errors.New("找不到原始目录")
		}

		oldPosition := origin.PositionAbsolute

		// 更新复制后的相关属性
		origin.PositionAbsolute = util.FillSlash(dstFolder.PositionAbsolute) + origin.Name
		origin.Position = dstFolder.PositionAbsolute
		origin.ParentID = dstFolder.ID

		// 清空主键
		origin.Model = gorm.Model{}

		if err := DB.Create(&origin).Error; err != nil {
			return 0, err
		}

		// 记录新的主键
		copyCache[oldPosition] = origin.Model.ID

	} else {
		// 移动
		// 更改顶级要移动目录的父目录指向
		err = DB.Model(Folder{}).
			Where("position_absolute in (?) and owner_id = ?",
				fullDirs,
				folder.OwnerID,
			).
			Update(map[string]interface{}{
				"parent_id": dstFolder.ID,
				"position":  dstFolder.PositionAbsolute,
				"position_absolute": gorm.Expr(
					util.BuildConcat("?",
						"name",
						conf.DatabaseConfig.Type,
					),
					util.FillSlash(dstFolder.PositionAbsolute),
				),
			}).Error
	}

	if err != nil {
		return 0, err
	}

	// 更新被移动的目录递归的子目录和文件
	for parKey, toBeMoved := range subFolders {
		ignorePath := fullDirs[parKey]
		// TODO 找到更好的修改办法

		// 抽离所有子目录的ID
		var subFolderIDs = make([]uint, len(toBeMoved))
		for key, subFolder := range toBeMoved {
			subFolderIDs[key] = subFolder.ID
		}

		if isCopy {
			index := 0
			for len(toBeMoved) != 0 {
				innerIndex := index % len(toBeMoved)
				index++
				// 限制循环次数
				if index > 65535 {
					return 0, errors.New("循环超出限制")
				}

				// 如果是顶级父目录，直接删除，不需要复制
				if toBeMoved[innerIndex].PositionAbsolute == ignorePath {
					toBeMoved = append(toBeMoved[:innerIndex], toBeMoved[innerIndex+1:]...)
					continue
				}

				// 如果缓存中存在父目录ID，执行复制,并删除
				if newID, ok := copyCache[toBeMoved[innerIndex].Position]; ok {
					// 记录目录原来的路径
					oldPosition := toBeMoved[innerIndex].PositionAbsolute

					// 设置目录i虚拟的路径
					newPosition := path.Join(
						dstFolder.PositionAbsolute, strings.Replace(
							toBeMoved[innerIndex].Position,
							folder.PositionAbsolute, "", 1),
					)
					toBeMoved[innerIndex].Position = newPosition
					toBeMoved[innerIndex].PositionAbsolute = path.Join(
						newPosition,
						toBeMoved[innerIndex].Name,
					)
					toBeMoved[innerIndex].ParentID = newID
					toBeMoved[innerIndex].Model = gorm.Model{}
					if err := DB.Create(&toBeMoved[innerIndex]).Error; err != nil {
						return 0, err
					}

					// 将当前目录老路径和新ID保存，以便后续待处理目录文件使用
					copyCache[oldPosition] = toBeMoved[innerIndex].Model.ID
					toBeMoved = append(toBeMoved[:innerIndex], toBeMoved[innerIndex+1:]...)
				}
			}

		} else {
			for _, subFolder := range toBeMoved {
				// 每个分组的第一个目录已经变更指向，直接跳过
				if subFolder.PositionAbsolute != ignorePath {
					newPosition := path.Join(dstFolder.PositionAbsolute,
						strings.Replace(subFolder.Position,
							folder.PositionAbsolute,
							"",
							1,
						),
					)
					// 移动
					DB.Model(&subFolder).Updates(map[string]interface{}{
						"position":          newPosition,
						"position_absolute": path.Join(newPosition, subFolder.Name),
					})
				}
			}
		}

		// 获取子目录下的所有子文件
		toBeMovedFile, err := GetFilesByParentIDs(subFolderIDs, folder.OwnerID)
		if err != nil {
			return 0, err
		}

		// 开始复制或移动子文件
		for _, subFile := range toBeMovedFile {
			newPosition := path.Join(dstFolder.PositionAbsolute,
				strings.Replace(
					subFile.Dir,
					folder.PositionAbsolute,
					"",
					1,
				),
			)
			if isCopy {
				// 复制
				if newID, ok := copyCache[subFile.Dir]; ok {
					subFile.FolderID = newID
				} else {
					util.Log().Debug("无法找到文件的父目录ID，原始路径：%s", subFile.Dir)
				}
				subFile.Dir = newPosition
				subFile.Model = gorm.Model{}

				// 复制文件记录
				if err := DB.Create(&subFile).Error; err != nil {
					util.Log().Warning("无法复制子文件：%s", err)
				} else {
					// 记录此文件容量
					newUsedStorage += subFile.Size
				}
			} else {
				DB.Model(&subFile).Updates(map[string]interface{}{
					"dir": newPosition,
				})
			}

		}

	}

	return newUsedStorage, nil

}