refactor(vfs): 重构VFS模块，拆分数据访问逻辑与路径解析逻辑

将原先的 `vfs.go` 文件中的功能进行拆分，创建了独立的 DAO 层文件 `vfs_dao.go`
和路径处理文件 `vfs_path.go`，以提升代码结构清晰度和可维护性。

- 将数据库操作相关方法迁移至 `VfsDAO` 结构体中
- 新增 `vfs_dao.go` 文件用于管理底层数据访问对象
- 新增 `vfs_path.go` 文件专门处理路径解析逻辑
- 移除了原 `vfs.go` 中的数据库初始化、用户及节点操作等冗余代码

internal/vfs/vfs_impl.go

@@ -8,61 +8,40 @@ import (
 
 	api "git.zzyxyz.com/zzy/zzyxyz_go_api/gen/vfs_server"
 	"git.zzyxyz.com/zzy/zzyxyz_go_api/internal/vfs/models"
+	vfs_service "git.zzyxyz.com/zzy/zzyxyz_go_api/internal/vfs/services"
 )
 
 // TODO 重命名名称冲突，以及合法名称检测，以及JSONBody and TextBody的检测
+// TODO: 特殊字符过滤
 
 // CreateVFSNode implements server.StrictServerInterface.
 func (v *VfsImpl) CreateVFSNode(ctx context.Context, request api.CreateVFSNodeRequestObject) (api.CreateVFSNodeResponseObject, error) {
-	// 解析路径组件
-	parentPath, nodeName, nodeType, err := models.ParsePathComponents(request.Params.Path)
-	if err != nil {
-		return api.CreateVFSNode400JSONResponse{
-			ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-				Errtype: api.ErrorErrtypeParameterError,
-				Message: err.Error(),
-			},
-		}, nil
+	var content []byte
+	if request.Body != nil {
+		content = []byte(*request.Body)
 	}
+	res, err := v.Core.CreateVFSNode(request.Params.Path, content, func(this any, node *models.VfsNode, input []byte) ([]byte, error) {
+		if svc, ok := this.(*vfs_service.ProxyService); ok {
+			result, err := svc.StrictProxy2Service(http.MethodPost, input, node)
+			return result, err
+		} else {
+			// 可选日志记录或错误处理
+			log.Println("this is not of type ProxyService")
+			return nil, nil
+		}
+	}, v.Proxy)
 
-	// 读取请求体数据
-	// FIXME: 使用stream可能更好
-	var content []byte = []byte(*request.Body)
-
-	// 创建节点 (可能需要传递content数据到vfs层)
-	node, err := v.vfs.CreateNodeByComponents(parentPath, nodeName, nodeType)
 	if err != nil {
+		log.Printf("Error creating VFS node: %+v", err)
 		return api.CreateVFSNode500JSONResponse{
 			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
 				Errtype: api.ErrorErrtypeInternalServerError,
-				Message: err.Error(),
+				Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
 			},
 		}, nil
 	}
 
-	// 处理服务类型节点
-	if nodeType == models.VfsNodeTypeService {
-		// 这里可能需要将content传递给服务处理
-		if result, err := v.StrictProxy2Service(http.MethodPost, content, node); err != nil {
-			// 回滚操作
-			delete_err := v.vfs.DeleteVFSNode(node)
-			log.Printf("service node: %s, err %s", node.Name, err.Error())
-			if delete_err != nil {
-				// FIXME: 需要解决这种原子性
-				return nil, fmt.Errorf("consistency error: %w", err)
-			}
-			return api.CreateVFSNode500JSONResponse{
-				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeServiceProxyError,
-					Message: err.Error(),
-				},
-			}, nil
-		} else {
-			// 返回二进制数据响应
-			return api.CreateVFSNode201TextResponse(result), nil
-		}
-	}
-
+	node := res.Node
 	// 返回JSON响应
 	return api.CreateVFSNode201JSONResponse{
 		Name:      node.Name,
@@ -72,172 +51,97 @@ func (v *VfsImpl) CreateVFSNode(ctx context.Context, request api.CreateVFSNodeRe
 	}, nil
 }
 
-// DeleteVFSNode implements server.StrictServerInterface.
-func (v *VfsImpl) DeleteVFSNode(ctx context.Context, request api.DeleteVFSNodeRequestObject) (api.DeleteVFSNodeResponseObject, error) {
-	// 获取节点
-	node, err := v.vfs.GetNodeByPath(request.Params.Path)
+// GetVFSNode implements server.StrictServerInterface.
+func (v *VfsImpl) GetVFSNode(ctx context.Context, request api.GetVFSNodeRequestObject) (api.GetVFSNodeResponseObject, error) {
+	res, err := v.Core.GetVFSNode(request.Params.Path, func(this any, node *models.VfsNode, input []byte) ([]byte, error) {
+		if svc, ok := this.(*vfs_service.ProxyService); ok {
+			result, err := svc.StrictProxy2Service(http.MethodGet, nil, node)
+			return result, err
+		} else {
+			// 可选日志记录或错误处理
+			log.Println("this is not of type ProxyService")
+			return nil, nil
+		}
+	}, v.Proxy)
+
 	if err != nil {
-		return api.DeleteVFSNode404JSONResponse{
-			PathNotFoundErrorJSONResponse: api.PathNotFoundErrorJSONResponse{
-				Errtype: api.ErrorErrtypePathNotFound,
-				Message: err.Error(),
+		return api.GetVFSNode500JSONResponse{
+			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
+				Errtype: api.ErrorErrtypeInternalServerError,
+				Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
 			},
 		}, nil
 	}
 
-	// 根据节点类型进行不同处理
-	switch node.Type {
-	case models.VfsNodeTypeService:
-		// 对于服务类型节点，通过代理删除
-		_, err := v.StrictProxy2Service(http.MethodDelete, nil, node)
+	if res.Node.Type == models.VfsNodeTypeDirectory {
+		// 手动构造响应对象
+		entries := make([]api.VFSDirectoryEntry, len(res.Entries))
+		for i, entry := range res.Entries {
+			entries[i] = api.VFSDirectoryEntry{
+				Name: entry.Name,
+				Type: ModelType2ResponseType(entry.Type),
+			}
+		}
+		return api.GetVFSNode200JSONResponse(entries), nil
+	} else {
+		return api.GetVFSNode200TextResponse(res.Content), nil
+	}
+}
+
+// DeleteVFSNode implements server.StrictServerInterface.
+func (v *VfsImpl) DeleteVFSNode(ctx context.Context, request api.DeleteVFSNodeRequestObject) (api.DeleteVFSNodeResponseObject, error) {
+	op := request.Params.Op
+	if op == nil {
+		_, err := v.Core.DeleteVFSNode(request.Params.Path, func(this any, node *models.VfsNode, input []byte) ([]byte, error) {
+			if svc, ok := this.(*vfs_service.ProxyService); ok {
+				result, err := svc.StrictProxy2Service(http.MethodDelete, nil, node)
+				return result, err
+			} else {
+				// 可选日志记录或错误处理
+				log.Println("this is not of type ProxyService")
+				return nil, nil
+			}
+		}, v.Proxy)
+
 		if err != nil {
 			return api.DeleteVFSNode500JSONResponse{
 				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeServiceProxyError,
-					Message: err.Error(),
+					Errtype: api.ErrorErrtypeInternalServerError,
+					Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
 				},
 			}, nil
 		}
-	case models.VfsNodeTypeDirectory:
 
-		if request.Params.Op != nil && *request.Params.Op == api.Recursive {
-			if sericeIDs, err := v.vfs.DeleteNodeRecursively(node.ID); err != nil {
-				return api.DeleteVFSNode500JSONResponse{
-					ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-						Errtype: api.ErrorErrtypeInternalServerError,
-						Message: "Failed to delete node: " + err.Error(),
-					},
-				}, nil
+		// 成功删除返回204状态
+		return api.DeleteVFSNode204Response{}, nil
+	} else if *op == api.Recursive {
+		_, err := v.Core.DeleteVFSNodeRecursively(request.Params.Path, func(this any, node *models.VfsNode, input []byte) ([]byte, error) {
+			if svc, ok := this.(*vfs_service.ProxyService); ok {
+				result, err := svc.StrictProxy2Service(http.MethodDelete, nil, node)
+				return result, err
 			} else {
-				for _, serviceID := range sericeIDs {
-					// 对于服务类型节点，通过代理删除
-					_, err := v.StrictProxy2Service(http.MethodDelete, nil, v.vfs.GetVFSNode(serviceID))
-					if err != nil {
-						return api.DeleteVFSNode500JSONResponse{
-							ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-								Errtype: api.ErrorErrtypeServiceProxyError,
-								Message: err.Error(),
-							},
-						}, nil
-					}
-				}
-				return api.DeleteVFSNode204Response{}, nil
-			}
-		} else {
-			// 检查目录是否为空
-			children, err := v.vfs.GetChildren(node.ID)
-			if err != nil {
-				return api.DeleteVFSNode500JSONResponse{
-					ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-						Errtype: api.ErrorErrtypeInternalServerError,
-						Message: "Failed to get directory children: " + err.Error(),
-					},
-				}, nil
+				// 可选日志记录或错误处理
+				log.Println("this is not of type ProxyService")
+				return nil, nil
 			}
+		}, v.Proxy)
 
-			if len(children) != 0 {
-				return api.DeleteVFSNode400JSONResponse{
-					ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-						Errtype: api.ErrorErrtypeConflictError,
-						Message: "Directory is not empty",
-					},
-				}, nil
-			}
+		if err != nil {
+			return api.DeleteVFSNode500JSONResponse{
+				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
+					Errtype: api.ErrorErrtypeInternalServerError,
+					Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
+				},
+			}, nil
 		}
-	default:
-		return api.DeleteVFSNode400JSONResponse{
-			ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-				Errtype: api.ErrorErrtypeParameterError,
-				Message: "Node type not supported for deletion",
-			},
-		}, nil
-	}
 
-	// 执行实际的删除操作
-	if err := v.vfs.DeleteVFSNode(node); err != nil {
+		// 成功删除返回204状态
+		return api.DeleteVFSNode204Response{}, nil
+	} else {
 		return api.DeleteVFSNode500JSONResponse{
 			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
 				Errtype: api.ErrorErrtypeInternalServerError,
-				Message: "Failed to delete node: " + err.Error(),
-			},
-		}, nil
-	}
-
-	// 成功删除返回204状态
-	return api.DeleteVFSNode204Response{}, nil
-}
-
-// GetVFSNode implements server.StrictServerInterface.
-func (v *VfsImpl) GetVFSNode(ctx context.Context, request api.GetVFSNodeRequestObject) (api.GetVFSNodeResponseObject, error) {
-	// 获取节点
-	node, err := v.vfs.GetNodeByPath(request.Params.Path)
-	if err != nil {
-		return api.GetVFSNode404JSONResponse{
-			PathNotFoundErrorJSONResponse: api.PathNotFoundErrorJSONResponse{
-				Errtype: api.ErrorErrtypePathNotFound,
-				Message: err.Error(),
-			},
-		}, nil
-	}
-
-	switch node.Type {
-	case models.VfsNodeTypeDirectory:
-		// 处理目录类型
-		entries, err := v.vfs.GetChildren(node.ID)
-		if err != nil {
-			return api.GetVFSNode500JSONResponse{
-				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeInternalServerError,
-					Message: err.Error(),
-				},
-			}, nil
-		}
-
-		var responseEntries []api.VFSDirectoryEntry
-		for _, entry := range entries {
-			responseEntries = append(responseEntries, api.VFSDirectoryEntry{
-				Name: entry.Name,
-				Type: ModelType2ResponseType(entry.Type),
-			})
-		}
-		return api.GetVFSNode200JSONResponse(responseEntries), nil
-
-	// case models.VfsNodeTypeFile:
-	// 	// 处理文件类型，返回二进制数据
-	// 	// 这里需要从vfs中获取文件内容
-	// 	fileContent, err := v.vfs.GetFileContent(node.ID) // 假设有此方法
-	// 	if err != nil {
-	// 		return api.GetVFSNode500JSONResponse{
-	// 			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-	// 				Errtype: api.ErrorErrtypeInternalServerError,
-	// 				Message: err.Error(),
-	// 			},
-	// 		}, nil
-	// 	}
-	// 	return api.GetVFSNode200ApplicationoctetStreamResponse{
-	// 		Body:          bytes.NewReader(fileContent),
-	// 		ContentLength: int64(len(fileContent)),
-	// 	}, nil
-
-	case models.VfsNodeTypeService:
-		// 处理服务类型
-		result, err := v.StrictProxy2Service(http.MethodGet, nil, node)
-		if err != nil {
-			return api.GetVFSNode500JSONResponse{
-				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeServiceProxyError,
-					Message: err.Error(),
-				},
-			}, nil
-		}
-
-		return api.GetVFSNode200TextResponse(result), nil
-
-	default:
-		return api.GetVFSNode400JSONResponse{
-			ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-				Errtype: api.ErrorErrtypeParameterError,
-				Message: "Not a valid node type",
+				Message: fmt.Errorf("not suported op").Error(),
 			},
 		}, nil
 	}
@@ -245,172 +149,48 @@ func (v *VfsImpl) GetVFSNode(ctx context.Context, request api.GetVFSNodeRequestO
 
 // UpdateVFSNode implements server.StrictServerInterface.
 func (v *VfsImpl) UpdateVFSNode(ctx context.Context, request api.UpdateVFSNodeRequestObject) (api.UpdateVFSNodeResponseObject, error) {
-	// 获取节点
-	node, err := v.vfs.GetNodeByPath(request.Params.Path)
-	if err != nil {
-		return api.UpdateVFSNode404JSONResponse{
-			PathNotFoundErrorJSONResponse: api.PathNotFoundErrorJSONResponse{
-				Errtype: api.ErrorErrtypePathNotFound,
-				Message: err.Error(),
-			},
-		}, nil
+	var content []byte
+	if request.JSONBody != nil {
+		content = []byte(*request.JSONBody)
+	} else if request.TextBody != nil {
+		content = []byte(*request.TextBody)
 	}
-
-	// 根据操作类型进行不同处理
+	var op vfs_service.UpdateOperation
 	switch request.Params.Op {
-	case api.Rename:
-		// 检查请求体
-		if request.JSONBody == nil {
-			return api.UpdateVFSNode400JSONResponse{
-				ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-					Errtype: api.ErrorErrtypeParameterError,
-					Message: "Request body is required for rename operation",
-				},
-			}, nil
-		}
-
-		newName := string(*request.JSONBody)
-		if err := v.vfs.CheckNameValid(newName); err != nil {
-			return api.UpdateVFSNode400JSONResponse{
-				ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-					Errtype: api.ErrorErrtypeParameterError,
-					Message: err.Error(),
-				},
-			}, nil
-		}
-
-		// FIXME: 检查新名称是否合法
-		// 对于服务类型节点，可能需要保留特定后缀
-		if node.Type == models.VfsNodeTypeService {
-			// 可以添加对服务节点重命名的特殊处理
-			// 例如确保保留.service后缀
-		}
-
-		// 更新节点名称
-		node.Name = newName
-		if err := v.vfs.UpdateVFSNode(node); err != nil {
-			return api.UpdateVFSNode500JSONResponse{
-				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeInternalServerError,
-					Message: "Failed to rename node: " + err.Error(),
-				},
-			}, nil
-		}
-
 	case api.Change:
-		// Change操作仅适用于文件和服务类型节点
-		if node.Type != models.VfsNodeTypeFile && node.Type != models.VfsNodeTypeService {
-			return api.UpdateVFSNode400JSONResponse{
-				ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-					Errtype: api.ErrorErrtypeParameterError,
-					Message: "Change operation is only supported for file and service nodes",
-				},
-			}, nil
-		}
-
-		// 读取请求体数据
-		// FIXME: 使用stream可能更好
-		var content []byte = []byte(*request.TextBody)
-
-		// 对于服务节点，通过代理发送变更
-		if node.Type == models.VfsNodeTypeService {
-			_, err := v.StrictProxy2Service(http.MethodPatch, content, node)
-			if err != nil {
-				return api.UpdateVFSNode500JSONResponse{
-					ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-						Errtype: api.ErrorErrtypeServiceProxyError,
-						Message: "Failed to proxy change to service: " + err.Error(),
-					},
-				}, nil
-			}
-		} else {
-			// 对于文件节点，可能需要更新文件内容
-			// 这里可以根据需要实现文件内容更新逻辑
-			return api.UpdateVFSNode500JSONResponse{
-				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeInternalServerError,
-					Message: "File Opreation Not Supported",
-				},
-			}, nil
-		}
-
-	case api.Move:
-		// FIXME: 需要添加权限控制
-		if request.JSONBody == nil {
-			return api.UpdateVFSNode400JSONResponse{
-				ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-					Errtype: api.ErrorErrtypeParameterError,
-					Message: "Request body is required for move operation",
-				},
-			}, nil
-		}
-
-		targetPath := string(*request.JSONBody)
-		if targetPath == "" {
-			return api.UpdateVFSNode400JSONResponse{
-				ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-					Errtype: api.ErrorErrtypeParameterError,
-					Message: "Target path cannot be empty",
-				},
-			}, nil
-		}
-
-		// 移动节点到新路径
-		if err := v.vfs.MoveToPath(node, targetPath); err != nil {
-			return api.UpdateVFSNode500JSONResponse{
-				ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-					Errtype: api.ErrorErrtypeInternalServerError,
-					Message: "Failed to move node: " + err.Error(),
-				},
-			}, nil
-		}
-
+		op = vfs_service.UpdateOperationChange
 	case api.Copy:
-		fallthrough
-		// if request.Body == nil {
-		// 	return api.UpdateVFSNode400JSONResponse{
-		// 		ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-		// 			Errtype: api.ErrorErrtypeParameterError,
-		// 			Message: "Request body is required for copy operation",
-		// 		},
-		// 	}, nil
-		// }
+		op = vfs_service.UpdateOperationCopy
+	case api.Move:
+		op = vfs_service.UpdateOperationMove
+	case api.Rename:
+		op = vfs_service.UpdateOperationRename
+	}
+	res, err := v.Core.UpdateVFSNode(request.Params.Path, op, content, func(this any, node *models.VfsNode, input []byte) ([]byte, error) {
+		if svc, ok := this.(*vfs_service.ProxyService); ok {
+			result, err := svc.StrictProxy2Service(http.MethodPut, input, node)
+			return result, err
+		} else {
+			// 可选日志记录或错误处理
+			log.Println("this is not of type ProxyService")
+			return nil, nil
+		}
+	}, v.Proxy)
 
-		// targetPath := string(*request.Body)
-		// if targetPath == "" {
-		// 	return api.UpdateVFSNode400JSONResponse{
-		// 		ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-		// 			Errtype: api.ErrorErrtypeParameterError,
-		// 			Message: "Target path cannot be empty",
-		// 		},
-		// 	}, nil
-		// }
-
-		// // 复制节点到新路径
-		// if err := v.vfs.CopyToPath(node, targetPath); err != nil {
-		// 	return api.UpdateVFSNode500JSONResponse{
-		// 		ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-		// 			Errtype: api.ErrorErrtypeInternalServerError,
-		// 			Message: "Failed to copy node: " + err.Error(),
-		// 		},
-		// 	}, nil
-		// }
-
-	default:
-		return api.UpdateVFSNode400JSONResponse{
-			ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-				Errtype: api.ErrorErrtypeParameterError,
-				Message: "Unsupported operation type",
+	if err != nil {
+		return api.UpdateVFSNode500JSONResponse{
+			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
+				Errtype: api.ErrorErrtypeInternalServerError,
+				Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
 			},
 		}, nil
 	}
-
 	// 返回更新后的节点信息
 	return api.UpdateVFSNode200JSONResponse{
-		Name:      node.Name,
-		Type:      ModelType2ResponseType(node.Type),
-		CreatedAt: node.CreatedAt,
-		UpdatedAt: node.UpdatedAt,
+		Name:      res.Name,
+		Type:      ModelType2ResponseType(res.Type),
+		CreatedAt: res.CreatedAt,
+		UpdatedAt: res.UpdatedAt,
 	}, nil
 }
 
@@ -430,42 +210,23 @@ func ModelType2ResponseType(nodeType models.VfsNodeType) api.VFSNodeType {
 // CreateUser implements server.StrictServerInterface.
 func (v *VfsImpl) CreateUser(ctx context.Context, request api.CreateUserRequestObject) (api.CreateUserResponseObject, error) {
 	// 创建用户
-	token, err := v.vfs.CreateUser(request.Username)
-	if err != nil {
-		// 检查是否是用户已存在的错误
-		if err.Error() == "user already exists" {
-			return api.CreateUser400JSONResponse{
-				ParameterErrorJSONResponse: api.ParameterErrorJSONResponse{
-					Errtype: api.ErrorErrtypeConflictError,
-					Message: "User already exists",
-				},
-			}, nil
-		}
-
+	token, err := v.User.CreateUser(request.Username)
+	if err != nil || token == nil {
 		return api.CreateUser500JSONResponse{
 			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
 				Errtype: api.ErrorErrtypeInternalServerError,
-				Message: "Failed to create user: " + err.Error(),
+				Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
 			},
 		}, nil
 	}
 
-	// 为新用户添加角色
-	_, err = v.enfocer.AddRoleForUser(request.Username, "user")
-	if err != nil {
-		log.Printf("Failed to add role for user %s: %v", request.Username, err)
-		// 注意：这里即使添加角色失败，我们也不会回滚用户创建
-		// 因为用户创建已经成功，且这是两个独立的系统
-		// FIXME: unknown
-	}
-
-	// 保存策略
-	v.enfocer.SavePolicy()
+	v.Core.CreateVFSNode("/home/"+request.Username+"/", nil, nil, nil)
+	v.Core.CreateVFSNode("/home/"+request.Username+"/.Recycle_Bin/", nil, nil, nil)
 
 	// 返回带有token的响应
 	return api.CreateUser201Response{
 		Headers: api.CreateUser201ResponseHeaders{
-			XVFSToken: token,
+			XVFSToken: *token,
 		},
 	}, nil
 }
@@ -473,58 +234,36 @@ func (v *VfsImpl) CreateUser(ctx context.Context, request api.CreateUserRequestO
 // DeleteUser implements server.StrictServerInterface.
 func (v *VfsImpl) DeleteUser(ctx context.Context, request api.DeleteUserRequestObject) (api.DeleteUserResponseObject, error) {
 	// 删除用户
-	err := v.vfs.DeleteUser(request.Username)
-	if err != nil {
-		// 检查是否是用户未找到的错误
-		if err.Error() == "user not found" {
-			return api.DeleteUser404JSONResponse{
-				Errtype: api.ErrorErrtypeNotFoundError,
-				Message: "User not found",
-			}, nil
-		}
-
+	if err := v.User.DeleteUser(request.Username); err != nil {
 		return api.DeleteUser500JSONResponse{
 			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
 				Errtype: api.ErrorErrtypeInternalServerError,
-				Message: "Failed to delete user: " + err.Error(),
+				Message: err.Error.Error(),
 			},
 		}, nil
 	}
 
-	if userDir, err := v.vfs.GetNodeByPath("/home/" + request.Username + "/"); err != nil {
-		panic(err)
-	} else {
-		if serviceIDs, err := v.vfs.DeleteNodeRecursively(userDir.ID); err != nil {
-			panic(err)
+	// TODO: Remove User DIR
+	_, err := v.Core.DeleteVFSNodeRecursively("/home/"+request.Username+"/", func(this any, node *models.VfsNode, input []byte) ([]byte, error) {
+		if svc, ok := this.(*vfs_service.ProxyService); ok {
+			result, err := svc.StrictProxy2Service(http.MethodDelete, nil, node)
+			return result, err
 		} else {
-			for _, serviceID := range serviceIDs {
-				// 对于服务类型节点，通过代理删除
-				_, err := v.StrictProxy2Service(http.MethodDelete, nil, v.vfs.GetVFSNode(serviceID))
-				if err != nil {
-					return api.DeleteUser500JSONResponse{
-						ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
-							Errtype: api.ErrorErrtypeServiceProxyError,
-							Message: err.Error(),
-						},
-					}, nil
-				}
-			}
+			// 可选日志记录或错误处理
+			log.Println("this is not of type ProxyService")
+			return nil, nil
 		}
-	}
+	}, v.Proxy)
 
-	// 从权限系统中移除用户
-	// 移除用户的所有角色
-	_, err = v.enfocer.DeleteRolesForUser(request.Username)
 	if err != nil {
-		log.Printf("Failed to delete roles for user %s: %v", request.Username, err)
-		// 注意：这里即使删除角色失败，我们也不会回滚用户删除
-		// 因为数据库中的用户已经删除，且这是两个独立的系统
-		// FIXME: unknown
+		return api.DeleteUser500JSONResponse{
+			ServerInternalErrorJSONResponse: api.ServerInternalErrorJSONResponse{
+				Errtype: api.ErrorErrtypeInternalServerError,
+				Message: fmt.Errorf("failed to delete node: %+v", err).Error(),
+			},
+		}, nil
 	}
 
-	// 保存策略
-	v.enfocer.SavePolicy()
-
 	// 成功删除返回204状态
 	return api.DeleteUser204Response{}, nil
 }