291 lines
7.9 KiB
Go
291 lines
7.9 KiB
Go
package service
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
|
|
"seeyon-filesystem/config"
|
|
"seeyon-filesystem/dto"
|
|
"seeyon-filesystem/model"
|
|
"seeyon-filesystem/repository"
|
|
"seeyon-filesystem/utils"
|
|
)
|
|
|
|
// FolderService 文件夹业务服务
|
|
type FolderService struct {
|
|
folderRepo *repository.FolderRepository
|
|
fileRepo *repository.FileRepository
|
|
}
|
|
|
|
// NewFolderService 创建文件夹服务实例
|
|
func NewFolderService() *FolderService {
|
|
return &FolderService{
|
|
folderRepo: repository.NewFolderRepository(),
|
|
fileRepo: repository.NewFileRepository(),
|
|
}
|
|
}
|
|
|
|
// Create 创建文件夹
|
|
func (s *FolderService) Create(req *dto.CreateFolderRequest, ownerID uint64) (*dto.FolderVO, error) {
|
|
parentID := uint64(req.ParentID)
|
|
|
|
// 构建物化路径
|
|
parentPath := "/"
|
|
if parentID > 0 {
|
|
parent, err := s.folderRepo.FindByID(parentID)
|
|
if err != nil {
|
|
return nil, errors.New("父文件夹不存在")
|
|
}
|
|
if !s.canAccessFolder(parent.OwnerID, ownerID) {
|
|
return nil, errors.New("无权访问父文件夹")
|
|
}
|
|
parentPath = parent.Path
|
|
}
|
|
|
|
// 检查同名文件夹
|
|
existing, _ := s.folderRepo.FindByNameAndParent(req.Name, parentID, ownerID)
|
|
if existing != nil {
|
|
return nil, errors.New("同名文件夹已存在")
|
|
}
|
|
|
|
// 检查biz_id唯一性
|
|
if req.BizID != "" {
|
|
existingBiz, _ := s.folderRepo.FindByBizID(req.BizID, ownerID)
|
|
if existingBiz != nil {
|
|
return nil, fmt.Errorf("业务编号 %s 已存在", req.BizID)
|
|
}
|
|
}
|
|
|
|
folderID := utils.GenID()
|
|
folder := &model.Folder{
|
|
ID: folderID,
|
|
BizID: req.BizID,
|
|
Name: req.Name,
|
|
ParentID: parentID,
|
|
OwnerID: ownerID,
|
|
Path: fmt.Sprintf("%s%d/", parentPath, folderID),
|
|
Status: 1,
|
|
}
|
|
|
|
if err := s.folderRepo.Create(folder); err != nil {
|
|
return nil, fmt.Errorf("创建文件夹失败: %w", err)
|
|
}
|
|
|
|
return s.toFolderVO(folder), nil
|
|
}
|
|
|
|
// GetByID 根据ID获取文件夹
|
|
func (s *FolderService) GetByID(id uint64, ownerID uint64) (*dto.FolderVO, error) {
|
|
folder, err := s.folderRepo.FindByID(id)
|
|
if err != nil {
|
|
return nil, errors.New("文件夹不存在")
|
|
}
|
|
if !s.canAccessFolder(folder.OwnerID, ownerID) {
|
|
return nil, errors.New("无权访问此文件夹")
|
|
}
|
|
return s.toFolderVO(folder), nil
|
|
}
|
|
|
|
// GetByBizID 根据业务ID获取文件夹
|
|
func (s *FolderService) GetByBizID(bizID string, ownerID uint64) (*dto.FolderVO, error) {
|
|
folder, err := s.folderRepo.FindByBizID(bizID, ownerID)
|
|
if err != nil {
|
|
return nil, errors.New("文件夹不存在")
|
|
}
|
|
return s.toFolderVO(folder), nil
|
|
}
|
|
|
|
// ListChildren 获取文件夹的子项(文件+文件夹, 基于权限, 支持分页)
|
|
// 管理员看全部, 非管理员只看自己创建的 + 被授权的
|
|
func (s *FolderService) ListChildren(folderID uint64, userID uint64, page, pageSize int) (*dto.FileListVO, error) {
|
|
roleIDs := s.getUserRoleIDs(userID)
|
|
isAdmin := s.isAdmin(roleIDs)
|
|
|
|
// 如果指定了文件夹ID, 验证访问权限
|
|
if folderID > 0 {
|
|
folder, err := s.folderRepo.FindByID(folderID)
|
|
if err != nil {
|
|
return nil, errors.New("文件夹不存在")
|
|
}
|
|
if !isAdmin && folder.OwnerID != userID {
|
|
return nil, errors.New("无权访问此文件夹")
|
|
}
|
|
}
|
|
|
|
// 查询子文件夹
|
|
var folders []model.Folder
|
|
var totalFolders int64
|
|
if isAdmin {
|
|
folders, _ = s.folderRepo.ListByParentAll(folderID)
|
|
totalFolders, _ = s.folderRepo.CountByParentAll(folderID)
|
|
} else {
|
|
folders, _ = s.folderRepo.ListByParent(folderID, userID)
|
|
totalFolders, _ = s.folderRepo.CountByParent(folderID, userID)
|
|
}
|
|
|
|
// 分页查询子文件
|
|
var files []model.File
|
|
var totalFiles int64
|
|
var err error
|
|
if pageSize > 0 {
|
|
files, totalFiles, err = s.fileRepo.ListByFolderPaginated(folderID, userID, roleIDs, page, pageSize)
|
|
} else {
|
|
files, err = s.fileRepo.ListByFolder(folderID, userID, roleIDs)
|
|
totalFiles = int64(len(files))
|
|
}
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 组装响应
|
|
folderVOs := make([]dto.FolderVO, 0, len(folders))
|
|
for _, f := range folders {
|
|
folderVOs = append(folderVOs, *s.toFolderVO(&f))
|
|
}
|
|
|
|
fileVOs := make([]dto.FileVO, 0, len(files))
|
|
for _, f := range files {
|
|
fileVOs = append(fileVOs, *s.toFileVO(&f))
|
|
}
|
|
|
|
return &dto.FileListVO{
|
|
Folders: folderVOs,
|
|
Files: fileVOs,
|
|
TotalFiles: totalFiles,
|
|
TotalFolders: totalFolders,
|
|
Page: page,
|
|
PageSize: pageSize,
|
|
}, nil
|
|
}
|
|
|
|
// canAccessFolder 检查用户是否有权操作该文件夹(owner / admin)
|
|
func (s *FolderService) canAccessFolder(folderOwnerID, userID uint64) bool {
|
|
if folderOwnerID == userID {
|
|
return true
|
|
}
|
|
return s.isAdmin(s.getUserRoleIDs(userID))
|
|
}
|
|
|
|
// isAdmin 检查用户是否为管理员
|
|
func (s *FolderService) isAdmin(roleIDs []uint64) bool {
|
|
if len(roleIDs) == 0 {
|
|
return false
|
|
}
|
|
var count int64
|
|
config.DB.Model(&model.Role{}).Where("id IN ? AND name = ?", roleIDs, "admin").Count(&count)
|
|
return count > 0
|
|
}
|
|
|
|
// Rename 重命名文件夹(乐观锁)
|
|
func (s *FolderService) Rename(id uint64, newName string, ownerID uint64, version int) error {
|
|
folder, err := s.folderRepo.FindByID(id)
|
|
if err != nil {
|
|
return errors.New("文件夹不存在")
|
|
}
|
|
if !s.canAccessFolder(folder.OwnerID, ownerID) {
|
|
return errors.New("无权操作此文件夹")
|
|
}
|
|
|
|
// 乐观锁检查
|
|
if version > 0 && folder.Version != version {
|
|
return fmt.Errorf("文件夹已被其他人修改, 当前版本: %d, 请刷新后重试", folder.Version)
|
|
}
|
|
|
|
newVersion := folder.Version + 1
|
|
result := config.DB.Model(&model.Folder{}).
|
|
Where("id = ? AND version = ?", id, folder.Version).
|
|
Updates(map[string]interface{}{
|
|
"name": newName,
|
|
"version": newVersion,
|
|
})
|
|
|
|
if result.RowsAffected == 0 {
|
|
return fmt.Errorf("文件夹已被其他人修改, 请刷新后重试")
|
|
}
|
|
return result.Error
|
|
}
|
|
|
|
// Delete 删除文件夹(移入回收站)
|
|
func (s *FolderService) Delete(id uint64, ownerID uint64) error {
|
|
folder, err := s.folderRepo.FindByID(id)
|
|
if err != nil {
|
|
return errors.New("文件夹不存在")
|
|
}
|
|
if !s.canAccessFolder(folder.OwnerID, ownerID) {
|
|
return errors.New("无权操作此文件夹")
|
|
}
|
|
|
|
return s.folderRepo.SoftDelete(id)
|
|
}
|
|
|
|
// toFolderVO 转换为视图对象
|
|
func (s *FolderService) toFolderVO(folder *model.Folder) *dto.FolderVO {
|
|
return &dto.FolderVO{
|
|
ID: dto.StringID(folder.ID),
|
|
BizID: folder.BizID,
|
|
Name: folder.Name,
|
|
ParentID: dto.StringID(folder.ParentID),
|
|
OwnerID: dto.StringID(folder.OwnerID),
|
|
OwnerName: s.getUserName(folder.OwnerID),
|
|
Path: folder.Path,
|
|
Version: folder.Version,
|
|
CreatedAt: folder.CreatedAt,
|
|
UpdatedAt: folder.UpdatedAt,
|
|
}
|
|
}
|
|
|
|
// getUserName 根据用户ID获取显示名称
|
|
func (s *FolderService) getUserName(userID uint64) string {
|
|
var user model.User
|
|
if config.DB.Select("nickname", "username").First(&user, userID).Error != nil {
|
|
return ""
|
|
}
|
|
if user.Nickname != "" {
|
|
return user.Nickname
|
|
}
|
|
return user.Username
|
|
}
|
|
|
|
// getUserRoleIDs 获取用户的角色ID列表
|
|
func (s *FolderService) getUserRoleIDs(userID uint64) []uint64 {
|
|
var userRoles []model.UserRole
|
|
config.DB.Where("user_id = ?", userID).Find(&userRoles)
|
|
roleIDs := make([]uint64, 0, len(userRoles))
|
|
for _, ur := range userRoles {
|
|
roleIDs = append(roleIDs, ur.RoleID)
|
|
}
|
|
return roleIDs
|
|
}
|
|
|
|
// toFileVO 转换为视图对象
|
|
func (s *FolderService) toFileVO(file *model.File) *dto.FileVO {
|
|
vo := &dto.FileVO{
|
|
ID: dto.StringID(file.ID),
|
|
BizID: file.BizID,
|
|
Name: file.Name,
|
|
Extension: file.Extension,
|
|
FolderID: dto.StringID(file.FolderID),
|
|
OwnerID: dto.StringID(file.OwnerID),
|
|
OwnerName: s.getUserName(file.OwnerID),
|
|
Size: file.Size,
|
|
StorageKey: file.StorageKey,
|
|
StoragePolicyID: file.StoragePolicyID,
|
|
MimeType: file.MimeType,
|
|
IsFavorite: file.IsFavorite,
|
|
DownloadCount: file.DownloadCount,
|
|
Version: file.Version,
|
|
CreatedAt: file.CreatedAt,
|
|
UpdatedAt: file.UpdatedAt,
|
|
}
|
|
|
|
// 生成下载/预览链接
|
|
if file.StorageKey != "" {
|
|
downloadURL, _ := GenerateFileURL(file, "download")
|
|
previewURL, _ := GenerateFileURL(file, "preview")
|
|
vo.DownloadURL = downloadURL
|
|
vo.PreviewURL = previewURL
|
|
}
|
|
|
|
return vo
|
|
}
|