Files
bj_power/bj_power_wms/internal/handler/attachment.go
T

612 lines
22 KiB
Go
Raw Normal View History

2026-09-15 16:37:39 +08:00
package handler
import (
"crypto/md5"
"encoding/hex"
"fmt"
2026-09-15 16:37:39 +08:00
"io"
"net/http"
"net/url"
2026-09-15 16:37:39 +08:00
"os"
"path/filepath"
"strings"
"time"
2026-09-15 16:37:39 +08:00
"bj_power_wms/ent"
"bj_power_wms/ent/attachment"
"bj_power_wms/internal/svc"
"github.com/google/uuid"
"github.com/zeromicro/go-zero/core/logx"
2026-09-15 16:37:39 +08:00
)
// 文件类型(大写枚举):决定存储目录 <根目录>/年/月/日/<文件类型>/<uuid>.<ext>。
// 与 biz_type(业务对象:inbound/material/inspection/semi/outbound)正交——
// 目录按"文件类型"分层,业务归属仍由 biz_type+biz_id 表达。
2026-09-15 16:37:39 +08:00
const (
FileTypeProcessPDF = "PROCESS_PDF" // 工艺流程作业指导书
FileTypeInspectionPhoto = "INSPECTION_PHOTO" // 检验照片
FileTypeInspectionPDF = "INSPECTION_PDF" // 检验报告
FileTypeDrawing = "DRAWING" // 图纸
FileTypeProcessCard = "PROCESS_CARD" // 流程卡
FileTypePackagePhoto = "PACKAGE_PHOTO" // 包装照片
FileTypeExcelImport = "EXCEL_IMPORT" // Excel 导入
2026-10-26 16:32:35 +08:00
FileTypeImage = "IMAGE" // 图片(通用,不细分业务:png/jpg/jpeg/gif/webp)
FileTypeOther = "OTHER" // 其他
2026-09-15 16:37:39 +08:00
)
var validFileTypes = map[string]bool{
FileTypeProcessPDF: true, FileTypeInspectionPhoto: true, FileTypeInspectionPDF: true,
FileTypeDrawing: true, FileTypeProcessCard: true, FileTypePackagePhoto: true,
2026-10-26 16:32:35 +08:00
FileTypeExcelImport: true, FileTypeImage: true, FileTypeOther: true,
}
// allowedAttachmentExt 允许的附件扩展名白名单(图纸/报告/图片/表格)。白名单而非黑名单:避免上传可执行文件。
2026-09-15 16:37:39 +08:00
var allowedAttachmentExt = map[string]bool{
".pdf": true, ".png": true, ".jpg": true, ".jpeg": true, ".gif": true,
".xlsx": true, ".xls": true, ".doc": true, ".docx": true,
".dwg": true, ".dxf": true, ".zip": true, ".txt": true, ".csv": true,
}
// attRoot 附件根目录(etc/*.yaml 的 Attachment.RootDir;缺省 attachments,不硬编码绝对路径)。
func attRoot(ctx *svc.ServiceContext) string {
if ctx != nil && strings.TrimSpace(ctx.Config.Attachment.RootDir) != "" {
return strings.TrimSpace(ctx.Config.Attachment.RootDir)
}
return "attachments"
}
// maxSizeFor 单文件上限:按文件类型取配置,未配置用 DefaultMaxSize。
func maxSizeFor(ctx *svc.ServiceContext, fileType string) int64 {
cfg := ctx.Config.Attachment
if cfg.MaxSize != nil {
if v, ok := cfg.MaxSize[fileType]; ok && v > 0 {
return v
}
}
if cfg.DefaultMaxSize > 0 {
return cfg.DefaultMaxSize
}
return 20 << 20
}
2026-10-26 16:32:35 +08:00
// deriveFileType 未显式指定文件类型时,按「扩展名优先」推断:
// 1) 图片类(png/jpg/jpeg/gif/webp)→ 按业务类型细分(检验/来料/半成品→检验照片,包裹/出库→包裹照片),无更细业务类型归「图片(IMAGE)」;
// 2) 非图片按业务类型 + 扩展名细分(PDF/DWG 等);
// 3) 兜底 OTHER。
// 扩展名优先可避免「material 的 png 照片被误判为其他」等问题。
func deriveFileType(bizType, ext string) string {
ext = strings.ToLower(ext)
2026-10-26 16:32:35 +08:00
// 扩展名优先:图片类
if ext == ".png" || ext == ".jpg" || ext == ".jpeg" || ext == ".gif" || ext == ".webp" {
switch bizType {
case "inspection", "inbound", "semi":
return FileTypeInspectionPhoto
case "outbound", "package":
return FileTypePackagePhoto
default:
return FileTypeImage
}
}
// 非图片:按业务类型 + 扩展名细分
switch bizType {
case "inspection":
if ext == ".pdf" {
return FileTypeInspectionPDF
}
2026-10-26 16:32:35 +08:00
case "material":
if ext == ".pdf" || ext == ".dwg" || ext == ".dxf" {
return FileTypeDrawing
}
2026-10-26 16:32:35 +08:00
case "outbound":
if ext == ".pdf" {
return FileTypeProcessPDF
}
}
2026-10-26 16:32:35 +08:00
if ext == ".xlsx" || ext == ".xls" || ext == ".csv" {
return FileTypeExcelImport
}
return FileTypeOther
}
// buildRelDir 相对目录 年/月/日/文件类型(月/日补零)。
func buildRelDir(fileType string, t time.Time) string {
return fmt.Sprintf("%d/%02d/%02d/%s", t.Year(), int(t.Month()), t.Day(), fileType)
}
// safeAbsPath 把库内相对路径安全解析为根目录内的绝对路径(阻断 ../ 穿越)。
func safeAbsPath(root, rel string) (string, bool) {
rel = strings.ReplaceAll(rel, "\\", "/")
clean := filepath.Clean(filepath.Join(root, rel))
rootAbs, err := filepath.Abs(root)
if err != nil {
return "", false
}
abs, err := filepath.Abs(clean)
if err != nil {
return "", false
}
if abs != rootAbs && !strings.HasPrefix(abs, rootAbs+string(os.PathSeparator)) {
return "", false
}
return abs, true
}
// uploadAttachmentHandler 上传附件(multipart/form-data,流式写入)。
// 表单字段:bizType、bizId、file、fileType(可选,大写枚举)。
// 落盘:<根目录>/年/月/日/<文件类型>/<uuid>.<ext>;库内只存相对路径。
2026-09-15 16:37:39 +08:00
func uploadAttachmentHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseMultipartForm(4 << 20); err != nil && err != http.ErrNotMultipart {
// 允许继续(大文件会经 MultipartReader 流式读取;此处仅先解析小字段)
2026-09-15 16:37:39 +08:00
}
bizType := strings.TrimSpace(r.FormValue("bizType"))
bizId := strings.TrimSpace(r.FormValue("bizId"))
fileTypeReq := strings.ToUpper(strings.TrimSpace(r.FormValue("fileType")))
2026-09-15 16:37:39 +08:00
if bizType == "" || bizId == "" {
fail(w, http.StatusBadRequest, "bizType 与 bizId 必填")
return
}
file, header, err := r.FormFile("file")
if err != nil {
fail(w, http.StatusBadRequest, "未取到上传文件: "+err.Error())
return
}
defer file.Close()
ext := strings.ToLower(filepath.Ext(header.Filename))
if ext == "" || !allowedAttachmentExt[ext] {
fail(w, http.StatusBadRequest, "不支持的文件类型(仅支持 PDF/图片/Office/图纸/压缩包)")
return
}
fileType := fileTypeReq
if fileType == "" || !validFileTypes[fileType] {
fileType = deriveFileType(bizType, ext)
}
maxSize := maxSizeFor(ctx, fileType)
if header.Size > 0 && header.Size > maxSize {
fail(w, http.StatusBadRequest, fmt.Sprintf("文件超过 %dMB 上限,请压缩后重传", maxSize>>20))
return
}
2026-09-15 16:37:39 +08:00
// 流式落盘:边写边算 MD5,内存占用恒定(绝不 ReadAll)
root := attRoot(ctx)
relDir := buildRelDir(fileType, timeNow())
absDir, okPath := safeAbsPath(root, relDir)
if !okPath {
fail(w, http.StatusBadRequest, "非法存储路径")
return
}
if err := os.MkdirAll(absDir, 0o755); err != nil {
2026-09-15 16:37:39 +08:00
fail(w, http.StatusInternalServerError, "创建附件目录失败: "+err.Error())
return
}
storedName := uuid.NewString() + ext
relPath := relDir + "/" + storedName
dst := filepath.Join(absDir, storedName)
2026-09-15 16:37:39 +08:00
out, err := os.Create(dst)
if err != nil {
fail(w, http.StatusInternalServerError, "写入附件失败: "+err.Error())
return
}
hash := md5.New()
written, err := io.Copy(io.MultiWriter(out, hash), io.LimitReader(file, maxSize+1))
_ = out.Close()
2026-09-15 16:37:39 +08:00
if err != nil {
_ = os.Remove(dst)
fail(w, http.StatusInternalServerError, "保存附件失败: "+err.Error())
return
}
if written > maxSize {
_ = os.Remove(dst)
fail(w, http.StatusBadRequest, fmt.Sprintf("文件超过 %dMB 上限,请压缩后重传", maxSize>>20))
return
}
fileMD5 := hex.EncodeToString(hash.Sum(nil))
// MD5 秒传:同业务对象 + 同 MD5 已存在 → 直接返回既有记录(不重复落盘)
if exist, e := ctx.EntClient.Attachment.Query().
Where(attachment.BizTypeEQ(bizType), attachment.BizIDEQ(bizId),
attachment.FileMd5EQ(fileMD5), attachment.DeletedEQ(false)).
Only(ctx0()); e == nil && exist != nil {
_ = os.Remove(dst)
ok(w, attachmentView(ctx, exist))
return
}
2026-09-15 16:37:39 +08:00
rec, err := ctx.EntClient.Attachment.Create().
SetBizType(bizType).
SetBizID(bizId).
SetFileName(header.Filename).
SetFilePath(relPath).
SetFileType(fileType).
SetFileExt(strings.TrimPrefix(ext, ".")).
SetFileMd5(fileMD5).
SetFileSize(written).
2026-09-15 16:37:39 +08:00
SetNillableMimeType(strPtr(header.Header.Get("Content-Type"))).
SetNillableUploadedBy(strPtr(r.Header.Get("X-Username"))).
Save(ctx0())
if err != nil {
_ = os.Remove(dst)
fail(w, http.StatusInternalServerError, "登记附件失败: "+err.Error())
return
}
ctx.EventLog.Write(ctx0(), "attachment.upload", r.Header.Get("X-Username"), bizType, bizId,
"上传附件 "+header.Filename, map[string]any{"fileSize": written, "fileType": fileType})
ok(w, attachmentView(ctx, rec))
2026-09-15 16:37:39 +08:00
}
}
// attachmentViewRow 附件返回视图:附带可直接预览/下载的 URL(按 id 提供,避免中文/多级路径问题)。
2026-09-15 16:37:39 +08:00
type attachmentViewRow struct {
ID int64 `json:"id"`
BizType string `json:"bizType"`
BizID string `json:"bizId"`
FileType string `json:"fileType"`
FileName string `json:"fileName"`
FileSize int64 `json:"fileSize"`
FileExt string `json:"fileExt"`
MimeType string `json:"mimeType"`
UploadedBy string `json:"uploadedBy"`
CreatedAt int64 `json:"createdAt"`
Deleted bool `json:"deleted"`
DeletedAt int64 `json:"deletedAt"`
DeletedBy string `json:"deletedBy"`
DeletedReason string `json:"deletedReason"`
PurgedAt int64 `json:"purgedAt"`
PurgedBy string `json:"purgedBy"`
URL string `json:"url"`
2026-09-15 16:37:39 +08:00
}
func attachmentView(ctx *svc.ServiceContext, rec *ent.Attachment) *attachmentViewRow {
2026-09-15 16:37:39 +08:00
return &attachmentViewRow{
ID: int64(rec.ID), BizType: rec.BizType, BizID: rec.BizID, FileType: rec.FileType,
FileName: rec.FileName, FileSize: rec.FileSize, FileExt: rec.FileExt, MimeType: rec.MimeType,
UploadedBy: rec.UploadedBy, CreatedAt: rec.CreatedAt, Deleted: rec.Deleted,
DeletedAt: rec.DeletedAt, DeletedBy: rec.DeletedBy, DeletedReason: rec.DeletedReason,
PurgedAt: rec.PurgedAt, PurgedBy: rec.PurgedBy,
// 公开预览 URL 用磁盘 UUID 文件名(不可枚举),杜绝顺序 ID 越权遍历(安全审计 #8)
URL: "/uploads/" + filepath.Base(rec.FilePath),
2026-09-15 16:37:39 +08:00
}
}
// listAttachmentsHandler 查询某业务对象的附件列表(排除逻辑删除)
2026-09-15 16:37:39 +08:00
// GET /api/attachments?bizType=&bizId=
func listAttachmentsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
bizType := r.URL.Query().Get("bizType")
bizId := r.URL.Query().Get("bizId")
if bizType == "" || bizId == "" {
fail(w, http.StatusBadRequest, "bizType 与 bizId 必填")
return
}
list, err := ctx.EntClient.Attachment.Query().
Where(attachment.BizTypeEQ(bizType), attachment.BizIDEQ(bizId), attachment.DeletedEQ(false)).
2026-09-15 16:37:39 +08:00
Order(ent.Desc("created_at"), ent.Desc("id")).
All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
rows := make([]*attachmentViewRow, 0, len(list))
for _, rec := range list {
rows = append(rows, attachmentView(ctx, rec))
2026-09-15 16:37:39 +08:00
}
ok(w, map[string]any{"list": rows, "total": len(rows)})
}
}
// listAllAttachmentsHandler 附件中心:全量分页查询(按文件类型/业务类型/业务标识/文件名/时间筛选)
// GET /api/attachments/all?fileType=&bizType=&bizId=&fileName=&startDate=&endDate=&includeDeleted=&page=&pageSize=
func listAllAttachmentsHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
page := atoi(r.URL.Query().Get("page"), 1)
pageSize := atoi(r.URL.Query().Get("pageSize"), 20)
if page < 1 {
page = 1
}
if pageSize < 1 || pageSize > 200 {
pageSize = 20
}
q := ctx.EntClient.Attachment.Query()
if v := strings.TrimSpace(r.URL.Query().Get("fileType")); v != "" {
q = q.Where(attachment.FileTypeEQ(strings.ToUpper(v)))
}
if v := strings.TrimSpace(r.URL.Query().Get("bizType")); v != "" {
q = q.Where(attachment.BizTypeEQ(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("bizId")); v != "" {
q = q.Where(attachment.BizIDContainsFold(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("fileName")); v != "" {
q = q.Where(attachment.FileNameContainsFold(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("startDate")); v != "" {
if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
q = q.Where(attachment.CreatedAtGTE(t.Unix()))
}
}
if v := strings.TrimSpace(r.URL.Query().Get("endDate")); v != "" {
if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
q = q.Where(attachment.CreatedAtLTE(t.Add(24 * time.Hour).Unix()))
}
}
includeDeleted := r.URL.Query().Get("includeDeleted") == "true"
if !includeDeleted {
q = q.Where(attachment.DeletedEQ(false))
}
total, err := q.Count(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
// 视角死角提示:未勾选含已删除时,告知当前筛选下有多少已删除附件被隐藏
hiddenDeleted := 0
if !includeDeleted {
hq := ctx.EntClient.Attachment.Query().Where(attachment.DeletedEQ(true))
if v := strings.TrimSpace(r.URL.Query().Get("fileType")); v != "" {
hq = hq.Where(attachment.FileTypeEQ(strings.ToUpper(v)))
}
if v := strings.TrimSpace(r.URL.Query().Get("bizType")); v != "" {
hq = hq.Where(attachment.BizTypeEQ(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("bizId")); v != "" {
hq = hq.Where(attachment.BizIDContainsFold(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("fileName")); v != "" {
hq = hq.Where(attachment.FileNameContainsFold(v))
}
if v := strings.TrimSpace(r.URL.Query().Get("startDate")); v != "" {
if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
hq = hq.Where(attachment.CreatedAtGTE(t.Unix()))
}
}
if v := strings.TrimSpace(r.URL.Query().Get("endDate")); v != "" {
if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
hq = hq.Where(attachment.CreatedAtLTE(t.Add(24 * time.Hour).Unix()))
}
}
if n, e := hq.Count(ctx0()); e == nil {
hiddenDeleted = n
}
}
list, err := q.Order(ent.Desc("created_at"), ent.Desc("id")).
Offset((page - 1) * pageSize).Limit(pageSize).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
rows := make([]*attachmentViewRow, 0, len(list))
for _, rec := range list {
rows = append(rows, attachmentView(ctx, rec))
}
// 磁盘状态一并返回,供页面顶部告警条展示
ok(w, map[string]any{"total": total, "list": rows, "page": page, "pageSize": pageSize,
"hiddenDeleted": hiddenDeleted, "disk": diskStatus(ctx)})
2026-09-15 16:37:39 +08:00
}
}
// serveUploadFileHandler 附件文件服务(按 UUID 存储名提供,免鉴权便于 <img>/新窗口预览;支持 Range 断点续传)。
// GET /uploads/:name(name = 磁盘 UUID 文件名,如 <uuid>.pdf)。顺序 ID 已被移除,杜绝越权遍历(安全审计 #8)。
func serveUploadFileHandler(ctx *svc.ServiceContext) http.HandlerFunc {
2026-09-15 16:37:39 +08:00
return func(w http.ResponseWriter, r *http.Request) {
// 仅接受 UUID 存储名(库内 FilePath 末尾一段),顺序 ID 不再作为访问入口
name := filepath.Base(r.URL.Path)
2026-09-15 16:37:39 +08:00
if name == "" || name == "." || name == "/" {
http.NotFound(w, r)
return
}
rec, err := ctx.EntClient.Attachment.Query().
Where(attachment.FilePathHasSuffix("/" + name), attachment.DeletedEQ(false)).Only(ctx0())
if err != nil || rec == nil {
http.NotFound(w, r)
return
}
root := attRoot(ctx)
p, ok := safeAbsPath(root, rec.FilePath)
if !ok {
http.NotFound(w, r)
return
}
absPath, fileName := p, rec.FileName
if _, err := os.Stat(absPath); err != nil {
2026-09-15 16:37:39 +08:00
http.NotFound(w, r)
return
}
if fileName != "" {
2026-10-26 16:32:35 +08:00
// 中文文件名走 RFC 5987;图片/PDF 内联预览,其他类型强制下载;
// 显式 dl=1 一律强制下载。与 MES 附件服务判定保持一致(B1.1)。
ext := strings.ToLower(filepath.Ext(fileName))
disp := "attachment"
if isInlineExt(ext) {
disp = "inline"
}
if r.URL.Query().Get("dl") == "1" {
disp = "attachment"
}
w.Header().Set("Content-Disposition", fmt.Sprintf(`%s; filename*=UTF-8''%s`, disp, url.QueryEscape(fileName)))
}
http.ServeFile(w, r, absPath) // ServeFile 自带 Range 支持
}
}
// diskStatusView 磁盘状态视图(供接口/页面告警条使用)。
type diskStatusView struct {
RootDir string `json:"rootDir"`
UsedPercent int `json:"usedPercent"`
FreeBytes uint64 `json:"freeBytes"`
TotalBytes uint64 `json:"totalBytes"`
WarnPercent int `json:"warnPercent"`
CritPercent int `json:"critPercent"`
Level string `json:"level"` // ok / warn / critical
Message string `json:"message"`
CheckedUnix int64 `json:"checkedAt"`
}
// diskStatus 读取附件根目录所在磁盘剩余空间并给出告警级别。
func diskStatus(ctx *svc.ServiceContext) diskStatusView {
cfg := ctx.Config.Attachment
root := attRoot(ctx)
v := diskStatusView{RootDir: root, WarnPercent: cfg.DiskWarnPercent, CritPercent: cfg.DiskCriticalPercent,
Level: "ok", Message: "磁盘空间正常", CheckedUnix: timeNow().Unix()}
used, free, total, err := diskUsage(root)
if err != nil {
// 目录尚不存在时退化为父目录统计
_ = os.MkdirAll(root, 0o755)
used, free, total, err = diskUsage(root)
}
if err != nil {
v.Level = "unknown"
v.Message = "磁盘空间检测失败:" + err.Error()
return v
}
v.UsedPercent, v.FreeBytes, v.TotalBytes = used, free, total
freePercent := 100 - used
switch {
case freePercent < cfg.DiskCriticalPercent:
v.Level = "critical"
v.Message = fmt.Sprintf("磁盘剩余空间仅 %d%%,低于 %d%%,请立即执行备份归档清理(附件中心可一键归档)", freePercent, cfg.DiskCriticalPercent)
case freePercent < cfg.DiskWarnPercent:
v.Level = "warn"
v.Message = fmt.Sprintf("磁盘剩余空间 %d%%,低于 %d%% 告警线,请及时清理", freePercent, cfg.DiskWarnPercent)
}
return v
}
// diskStatusHandler GET /api/attachments/disk-status
func diskStatusHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
ok(w, diskStatus(ctx))
}
}
2026-10-26 16:32:35 +08:00
// isInlineExt 判断扩展名是否可在浏览器内联预览(图片 / PDF)。
// 与 MES attachment 包的判定保持一致:只有这类文件才允许 inline,其余一律强制下载,
// 避免 docx/xlsx/zip 等被当垃圾数据内联打开(B1.1 对齐两端行为)。
func isInlineExt(ext string) bool {
switch strings.ToLower(ext) {
case ".png", ".jpg", ".jpeg", ".gif", ".webp", ".pdf":
return true
}
return false
}
// StartDiskMonitor 启动磁盘空间监控:每天 DiskCheckHour(默认7点) 检测一次,
// 剩余空间 <20% 告警、<10% 提示清理(写日志 + 操作日志,页面顶部同步提示)。
func StartDiskMonitor(ctx *svc.ServiceContext) {
go func() {
hour := ctx.Config.Attachment.DiskCheckHour
if hour < 0 || hour > 23 {
hour = 7
}
for {
now := time.Now()
next := time.Date(now.Year(), now.Month(), now.Day(), hour, 0, 0, 0, time.Local)
if !next.After(now) {
next = next.Add(24 * time.Hour)
}
time.Sleep(time.Until(next))
checkDiskOnce(ctx)
}
}()
}
func checkDiskOnce(ctx *svc.ServiceContext) {
st := diskStatus(ctx)
switch st.Level {
case "critical":
logx.Errorf("[磁盘监控] %s(已用 %d%%,剩余 %d%%)", st.Message, st.UsedPercent, 100-st.UsedPercent)
ctx.EventLog.Write(ctx0(), "system.disk", "system", "disk", "attachment",
st.Message, map[string]any{"usedPercent": st.UsedPercent, "freeBytes": st.FreeBytes})
case "warn":
logx.Alert("[磁盘监控] " + st.Message)
ctx.EventLog.Write(ctx0(), "system.disk", "system", "disk", "attachment",
st.Message, map[string]any{"usedPercent": st.UsedPercent, "freeBytes": st.FreeBytes})
default:
logx.Infof("[磁盘监控] 正常:剩余 %d%%(%s)", 100-st.UsedPercent, st.RootDir)
2026-09-15 16:37:39 +08:00
}
}
// purgeDeletedHandler 批量物理清理已逻辑删除的附件(数据归档页「磁盘空间回收」批量入口):
// 扫描 deleted=true 且未清除的索引,物理删除对应磁盘文件释放本地空间;
// 索引保留(purged_at/by 留痕)以便追溯。dryRun 预检返回将清理数量与释放字节;
// 执行须实名留痕;保护期/禁删保护的附件跳过(计入 protected)。
// POST /api/attachments/purge-deleted body: { dryRun, ackName, ackPhone }
func purgeDeletedHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
DryRun bool `json:"dryRun"`
AckName string `json:"ackName"`
AckPhone string `json:"ackPhone"`
}
_ = parseJSON(r, &req)
if !req.DryRun {
if err := checkAckNamePhone(req.AckName, req.AckPhone); err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
}
root := attRoot(ctx)
recs, err := ctx.EntClient.Attachment.Query().
Where(attachment.DeletedEQ(true)).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
removed, freed, missing, failed, protected := 0, int64(0), 0, 0, 0
user := r.Header.Get("X-Username")
for _, rec := range recs {
if rec.PurgedAt != 0 {
missing++ // 已清除过(文件已删),仅计数
continue
}
if blocked := attachmentProtectCheck(ctx, rec.CreatedAt) + attachmentFileTypeProtect(ctx, rec); blocked != "" {
protected++
continue
}
abs, okp := safeAbsPath(root, rec.FilePath)
if !okp {
failed++
continue
}
info, statErr := os.Stat(abs)
if statErr != nil {
missing++ // 文件已不存在(已清理或丢失),仅计数
// 补标记:索引侧注明已清除,避免反复扫描
now := timeNow().Unix()
_, _ = ctx.EntClient.Attachment.UpdateOneID(rec.ID).
SetNillablePurgedAt(&now).SetNillablePurgedBy(strPtr(user)).Save(ctx0())
continue
}
size := info.Size()
if req.DryRun {
removed++
freed += size
continue
}
if err := os.Remove(abs); err != nil {
failed++
continue
}
now := timeNow().Unix()
_, _ = ctx.EntClient.Attachment.UpdateOneID(rec.ID).
SetNillablePurgedAt(&now).SetNillablePurgedBy(strPtr(user)).Save(ctx0())
removed++
freed += size
}
if !req.DryRun {
ctx.EventLog.Write(ctx0(), "attachment.purge", user, "attachment", "purge",
fmt.Sprintf("批量物理清理已删附件:删除%d 释放%.2fMB 缺失%d 失败%d 保护期跳过%d(确认人:%s %s)",
removed, float64(freed)/1024/1024, missing, failed, protected,
strings.TrimSpace(req.AckName), strings.TrimSpace(req.AckPhone)),
map[string]any{"removed": removed, "freed": freed, "missing": missing, "failed": failed, "protected": protected})
}
ok(w, map[string]any{"removed": removed, "freed": freed, "missing": missing, "failed": failed,
"protected": protected, "dryRun": req.DryRun})
}
}