Files
bj_power/bj_power_wms/internal/handler/attachment_lifecycle.go
T
SunYF 1e92b2a596 feat: 核心业务实体扩充(混产模板/产品BOM/试制记录)、WMS 库存检验增强与前端通用能力
- MES 新增实体:混产模板、产品BOM、产品工艺物料、试制记录(schema + ent 生成码 + logic/handler/前端页)
- WMS 实体增强:检验记录、库存、半成品重构;新增序列号库存与短缺代报
- AGV 与产能:AGV 手动点位与链路、物料守卫、短缺预测、原因字典
- 前端通用能力:新增下一步引导组件 NextStepBar,统一帮助文档/布局/请求拦截与操作列
- 工位终端:界面与各 handler 调整(api/store/绑定/PLC/拧紧/上报等)
- 配置与文档:更新 mes-api.yaml、WMS README 及案例/产线API/问题记录/项目说明/流程说明
2026-11-15 12:17:39 +08:00

508 lines
19 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package handler
// 附件生命周期(2026-10-28 重构):
// - 附件中心转纯查阅;删除/恢复/彻底清除唯一入口 = 数据归档页「磁盘空间回收」(admin/attachment:manage)。
// - 删除前提示清楚(本文件 deletePrecheck):保护期、禁删保护、引用校验、备份覆盖情况,全部透明列出。
// - 两道闸:① 时间保护期(仅允许删除 N 天前数据,sys_config: archive.protect.days,默认 180);
// ② 确认弹窗完整提示 + 实名(姓名/手机号)留痕。误删是用户行为,系统不建补救层、不承诺备份介质可读。
// - 引用校验器:biz_type+biz_id 反查业务表;引用=0 视为孤儿(无保留价值),>0 拒删并列出引用方;
// 未注册的业务类型按"有引用"处理(fail-safe,宁可拒删不误删)。
// - 业务面板「移除」:上传人本人撤回误传附件(物理删除文件+记录),不受保护期约束(新传数据),
// 但禁删保护仍然生效。
import (
"fmt"
"net/http"
"os"
"regexp"
"strconv"
"strings"
"time"
"bj_power_wms/ent"
"bj_power_wms/ent/attachment"
"bj_power_wms/ent/backuprecord"
"bj_power_wms/ent/inboundorder"
"bj_power_wms/ent/inspectionrecord"
"bj_power_wms/ent/material"
"bj_power_wms/ent/outboundorder"
"bj_power_wms/ent/semifinished"
"bj_power_wms/internal/svc"
)
// ackPhoneRe 实名留痕手机号校验。
var ackPhoneRe = regexp.MustCompile(`^1\d{10}$`)
func checkAckNamePhone(name, phone string) error {
if strings.TrimSpace(name) == "" {
return fmt.Errorf("须填写确认人姓名(警示留痕)")
}
if !ackPhoneRe.MatchString(strings.TrimSpace(phone)) {
return fmt.Errorf("须填写有效的 11 位手机号(警示留痕)")
}
return nil
}
// attachmentProtectDays 数据保护期(天)。
func attachmentProtectDays(ctx *svc.ServiceContext) int {
return CfgIntFromSysConfig(ctx, CfgArchiveProtectDays, 180)
}
// attachmentProtectCheck 保护期校验:created_at 须早于保护期。返回非空即拦截原因。
func attachmentProtectCheck(ctx *svc.ServiceContext, createdAt int64) string {
days := attachmentProtectDays(ctx)
if days <= 0 {
return ""
}
cutoff := timeNow().Unix() - int64(days)*86400
if createdAt > cutoff {
return fmt.Sprintf("该数据在保护期内(仅允许删除 %d 天前的数据,即 %s 之前上传的)",
days, time.Unix(cutoff, 0).Format("2006-01-02"))
}
return ""
}
// attachmentFileTypeProtect 禁删保护(关键业务附件):返回非空即拦截原因。
func attachmentFileTypeProtect(ctx *svc.ServiceContext, rec *ent.Attachment) string {
switch rec.FileType {
case FileTypeProcessPDF, FileTypeProcessCard:
return "工艺流程 / 流程卡为关键工艺文件,禁止删除"
case FileTypeInspectionPhoto, FileTypeInspectionPDF:
years := ctx.Config.Attachment.LocalRetentionYears
if years <= 0 {
years = 1
}
cutYear := timeNow().Year() - years
if time.Unix(rec.CreatedAt, 0).Year() >= cutYear {
return fmt.Sprintf("检验记录在质量追溯保留期(%d 年)内,禁止删除", years)
}
}
return ""
}
// attachmentRefs 引用校验器:返回(引用数, 引用方描述列表)。
func attachmentRefs(ctx *svc.ServiceContext, bizType, bizId string) (int, []string) {
bizId = strings.TrimSpace(bizId)
if bizId == "" {
return 0, nil
}
c := ctx.EntClient
switch bizType {
case "inbound":
n, err := c.InboundOrder.Query().Where(inboundorder.InboundNoEQ(bizId)).Count(ctx0())
return refResult(err, n, fmt.Sprintf("入库单 %s", bizId))
case "outbound":
n, err := c.OutboundOrder.Query().Where(outboundorder.OutboundNoEQ(bizId)).Count(ctx0())
return refResult(err, n, fmt.Sprintf("出库单 %s", bizId))
case "material":
n, err := c.Material.Query().Where(material.CodeEQ(bizId)).Count(ctx0())
return refResult(err, n, fmt.Sprintf("物料档案 %s", bizId))
case "semi":
n, err := c.SemiFinished.Query().Where(semifinished.SnEQ(bizId)).Count(ctx0())
return refResult(err, n, fmt.Sprintf("在制品 %s", bizId))
case "inspection":
id, perr := strconv.Atoi(bizId)
if perr != nil {
return 1, []string{"检验记录 ID 非法,按有引用处理"}
}
n, err := c.InspectionRecord.Query().Where(inspectionrecord.IDEQ(id)).Count(ctx0())
return refResult(err, n, fmt.Sprintf("检验记录 #%s", bizId))
default:
// fail-safe:未注册引用校验的业务类型一律视为有引用
return 1, []string{fmt.Sprintf("业务类型 %s 未注册引用校验,按有引用处理", bizType)}
}
}
func refResult(err error, n int, label string) (int, []string) {
if err != nil {
return 1, []string{"引用校验查询失败:" + err.Error()}
}
if n > 0 {
return n, []string{label}
}
return 0, nil
}
// attachmentBackupInfo 透明信息:上传时间是否落在某次成功备份的时间窗内(不承诺介质可读)。
func attachmentBackupInfo(ctx *svc.ServiceContext, createdAt int64) string {
recs, err := ctx.EntClient.BackupRecord.Query().
Where(backuprecord.StatusEQ("success"),
backuprecord.RangeStartLTE(createdAt), backuprecord.RangeEndGTE(createdAt)).
All(ctx0())
if err != nil {
return "备份覆盖情况查询失败"
}
if len(recs) == 0 {
return "无备份记录覆盖该文件的上传时间"
}
parts := make([]string, 0, len(recs))
for _, r := range recs {
parts = append(parts, fmt.Sprintf("#%d(%s ~ %s)", r.ID,
time.Unix(r.RangeStart, 0).Format("2006-01-02"), time.Unix(r.RangeEnd, 0).Format("2006-01-02")))
}
return "该文件上传时间在备份记录覆盖范围内:" + strings.Join(parts, "、")
}
// deletePrecheckVO 删除前提示清楚所需的全部信息。
type deletePrecheckVO struct {
ID int64 `json:"id"`
FileName string `json:"fileName"`
FileSize int64 `json:"fileSize"`
CreatedAt int64 `json:"createdAt"`
BizType string `json:"bizType"`
BizID string `json:"bizId"`
ProtectDays int `json:"protectDays"`
ProtectBlocked string `json:"protectBlocked"` // 非空=保护期/禁删保护拦截原因
RefCount int `json:"refCount"`
Refs []string `json:"refs"`
BackupInfo string `json:"backupInfo"`
}
// deletePrecheckHandler POST /api/attachments/delete-precheck {id}
func deletePrecheckHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ID int64 `json:"id"`
}
if err := parseJSON(r, &req); err != nil || req.ID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:id 必填")
return
}
rec, err := ctx.EntClient.Attachment.Get(ctx0(), int(req.ID))
if err != nil {
fail(w, http.StatusNotFound, "附件不存在")
return
}
refCount, refs := attachmentRefs(ctx, rec.BizType, rec.BizID)
ok(w, deletePrecheckVO{
ID: int64(rec.ID), FileName: rec.FileName, FileSize: rec.FileSize,
CreatedAt: rec.CreatedAt, BizType: rec.BizType, BizID: rec.BizID,
ProtectDays: attachmentProtectDays(ctx),
ProtectBlocked: attachmentProtectCheck(ctx, rec.CreatedAt) + attachmentFileTypeProtect(ctx, rec),
RefCount: refCount, Refs: refs,
BackupInfo: attachmentBackupInfo(ctx, rec.CreatedAt),
})
}
}
// deleteAttachmentHandler 重构:逻辑删除(数据归档页入口)。
// POST /api/attachments/delete body: { id, reason, ackName, ackPhone }
// 校验:禁删保护 + 保护期 + 引用校验(有引用拒删)+ 实名留痕。
func deleteAttachmentHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ID int64 `json:"id"`
Reason string `json:"reason"`
AckName string `json:"ackName"`
AckPhone string `json:"ackPhone"`
}
if err := parseJSON(r, &req); err != nil || req.ID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:id 必填")
return
}
rec, err := ctx.EntClient.Attachment.Get(ctx0(), int(req.ID))
if err != nil {
fail(w, http.StatusNotFound, "附件不存在")
return
}
if rec.Deleted {
fail(w, http.StatusBadRequest, "该附件已是删除状态")
return
}
if blocked := attachmentProtectCheck(ctx, rec.CreatedAt) + attachmentFileTypeProtect(ctx, rec); blocked != "" {
fail(w, http.StatusForbidden, blocked)
return
}
refCount, refs := attachmentRefs(ctx, rec.BizType, rec.BizID)
if refCount > 0 {
fail(w, http.StatusForbidden, "该附件仍被业务数据引用,禁止删除:"+strings.Join(refs, "、"))
return
}
if err := checkAckNamePhone(req.AckName, req.AckPhone); err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
if _, err := ctx.EntClient.Attachment.UpdateOneID(int(req.ID)).
SetDeleted(true).SetDeletedAt(timeNow().Unix()).
SetNillableDeletedBy(strPtr(r.Header.Get("X-Username"))).
SetNillableDeletedReason(strPtr(strings.TrimSpace(req.Reason))).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "删除附件失败: "+err.Error())
return
}
ctx.EventLog.Write(ctx0(), "attachment.delete", r.Header.Get("X-Username"), rec.BizType, rec.BizID,
fmt.Sprintf("删除附件 %s(%.2f MB;确认人:%s %s;说明:%s)",
rec.FileName, float64(rec.FileSize)/1024/1024,
strings.TrimSpace(req.AckName), strings.TrimSpace(req.AckPhone),
ornull(req.Reason)), nil)
ok(w, map[string]any{"id": req.ID})
}
}
// restoreAttachmentHandler 恢复逻辑删除(未彻底清除前可反悔)。
// POST /api/attachments/restore body: { id }
func restoreAttachmentHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ID int64 `json:"id"`
}
if err := parseJSON(r, &req); err != nil || req.ID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:id 必填")
return
}
rec, err := ctx.EntClient.Attachment.Get(ctx0(), int(req.ID))
if err != nil {
fail(w, http.StatusNotFound, "附件不存在")
return
}
if !rec.Deleted {
fail(w, http.StatusBadRequest, "该附件不是删除状态,无需恢复")
return
}
if rec.PurgedAt != 0 {
fail(w, http.StatusBadRequest, "该附件已彻底清除(磁盘文件已删除),无法恢复;如需找回请使用对应备份包")
return
}
if _, err := ctx.EntClient.Attachment.UpdateOneID(int(req.ID)).SetDeleted(false).Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "恢复附件失败: "+err.Error())
return
}
ctx.EventLog.Write(ctx0(), "attachment.restore", r.Header.Get("X-Username"), rec.BizType, rec.BizID,
"恢复附件 "+rec.FileName, nil)
ok(w, map[string]any{"id": req.ID})
}
}
// purgeAttachmentHandler 彻底清除单个已删除附件:物理删除磁盘文件,索引保留(purged_at/by 留痕)。
// POST /api/attachments/purge body: { id, ackName, ackPhone }
func purgeAttachmentHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ID int64 `json:"id"`
AckName string `json:"ackName"`
AckPhone string `json:"ackPhone"`
}
if err := parseJSON(r, &req); err != nil || req.ID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:id 必填")
return
}
rec, err := ctx.EntClient.Attachment.Get(ctx0(), int(req.ID))
if err != nil {
fail(w, http.StatusNotFound, "附件不存在")
return
}
if !rec.Deleted {
fail(w, http.StatusBadRequest, "请先删除(逻辑删除)后再彻底清除")
return
}
if rec.PurgedAt != 0 {
fail(w, http.StatusBadRequest, "该附件已彻底清除")
return
}
if blocked := attachmentProtectCheck(ctx, rec.CreatedAt) + attachmentFileTypeProtect(ctx, rec); blocked != "" {
fail(w, http.StatusForbidden, blocked)
return
}
if err := checkAckNamePhone(req.AckName, req.AckPhone); err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
root := attRoot(ctx)
removed := false
if abs, okp := safeAbsPath(root, rec.FilePath); okp {
if rerr := osRemoveIfExist(abs); rerr == "" {
removed = true
}
}
now := timeNow().Unix()
if _, err := ctx.EntClient.Attachment.UpdateOneID(int(req.ID)).
SetNillablePurgedAt(&now).
SetNillablePurgedBy(strPtr(r.Header.Get("X-Username"))).
Save(ctx0()); err != nil {
fail(w, http.StatusInternalServerError, "清除标记失败: "+err.Error())
return
}
ctx.EventLog.Write(ctx0(), "attachment.purge", r.Header.Get("X-Username"), rec.BizType, rec.BizID,
fmt.Sprintf("彻底清除附件 %s(%.2f MB,文件已删除%s;确认人:%s %s)",
rec.FileName, float64(rec.FileSize)/1024/1024,
map[bool]string{true: "", false: ",文件本已缺失"}[removed],
strings.TrimSpace(req.AckName), strings.TrimSpace(req.AckPhone)), nil)
ok(w, map[string]any{"id": req.ID, "removed": removed})
}
}
// removeAttachmentHandler 业务面板「移除」:上传人本人撤回误传附件(物理删除文件+记录)。
// POST /api/attachments/remove body: { id, reason }
// 仅上传人本人可操作;禁删保护生效;不受保护期约束(针对刚上传的数据)。
func removeAttachmentHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
ID int64 `json:"id"`
Reason string `json:"reason"`
}
if err := parseJSON(r, &req); err != nil || req.ID <= 0 {
fail(w, http.StatusBadRequest, "参数错误:id 必填")
return
}
rec, err := ctx.EntClient.Attachment.Get(ctx0(), int(req.ID))
if err != nil {
fail(w, http.StatusNotFound, "附件不存在")
return
}
if rec.Deleted {
fail(w, http.StatusBadRequest, "该附件已是删除状态")
return
}
user := r.Header.Get("X-Username")
if rec.UploadedBy != user {
fail(w, http.StatusForbidden, "仅上传人本人可移除附件;其他情况请管理员在「数据归档」页处理")
return
}
if blocked := attachmentFileTypeProtect(ctx, rec); blocked != "" {
fail(w, http.StatusForbidden, blocked)
return
}
root := attRoot(ctx)
if abs, okp := safeAbsPath(root, rec.FilePath); okp {
_ = osRemoveIfExist(abs)
}
if _, derr := ctx.EntClient.Attachment.Delete().Where(attachment.ID(rec.ID)).Exec(ctx0()); derr != nil {
fail(w, http.StatusInternalServerError, "移除附件失败: "+derr.Error())
return
}
ctx.EventLog.Write(ctx0(), "attachment.remove", user, rec.BizType, rec.BizID,
fmt.Sprintf("移除附件 %s(上传人本人撤回,物理删除;说明:%s)", rec.FileName, ornull(req.Reason)), nil)
ok(w, map[string]any{"id": req.ID})
}
}
// orphanScanHandler 扫描无引用附件(孤儿):附件正常状态但业务单据已不存在。
// GET /api/attachments/orphans → { total, totalSize, list(截断500) }
func orphanScanHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
recs, err := ctx.EntClient.Attachment.Query().
Where(attachment.DeletedEQ(false)).Order(ent.Desc("created_at")).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
type orphanVO struct {
ID int64 `json:"id"`
FileName string `json:"fileName"`
FileSize int64 `json:"fileSize"`
BizType string `json:"bizType"`
BizID string `json:"bizId"`
CreatedAt int64 `json:"createdAt"`
Reason string `json:"reason"`
}
var total int64
list := make([]orphanVO, 0, 16)
const capN = 500
for _, rec := range recs {
// 已彻底清除的(文件没了)不再列为孤儿
if rec.PurgedAt != 0 {
continue
}
n, refs := attachmentRefs(ctx, rec.BizType, rec.BizID)
if n > 0 {
continue
}
total += rec.FileSize
if len(list) < capN {
reason := "业务单据不存在(可能未保存即取消,或单据已删除)"
if len(refs) > 0 {
reason = refs[0]
}
list = append(list, orphanVO{
ID: int64(rec.ID), FileName: rec.FileName, FileSize: rec.FileSize,
BizType: rec.BizType, BizID: rec.BizID, CreatedAt: rec.CreatedAt, Reason: reason,
})
}
}
ok(w, map[string]any{"count": len(list), "truncated": len(recs) > capN, "totalSize": total, "list": list})
}
}
// orphanPurgeHandler 批量清除孤儿附件:物理删除文件 + 删除索引记录(无引用数据无保留价值)。
// POST /api/attachments/orphans/purge body: { ids: [], ackName, ackPhone }(ids 空=全部扫描到的)
func orphanPurgeHandler(ctx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var req struct {
IDs []int64 `json:"ids"`
AckName string `json:"ackName"`
AckPhone string `json:"ackPhone"`
}
if err := parseJSON(r, &req); err != nil {
fail(w, http.StatusBadRequest, "请求体解析失败:"+err.Error())
return
}
if err := checkAckNamePhone(req.AckName, req.AckPhone); err != nil {
fail(w, http.StatusBadRequest, err.Error())
return
}
if len(req.IDs) == 0 {
// 扫描全部孤儿
recs, err := ctx.EntClient.Attachment.Query().Where(attachment.DeletedEQ(false)).All(ctx0())
if err != nil {
fail(w, http.StatusInternalServerError, err.Error())
return
}
for _, rec := range recs {
if rec.PurgedAt != 0 {
continue
}
if n, _ := attachmentRefs(ctx, rec.BizType, rec.BizID); n == 0 {
req.IDs = append(req.IDs, int64(rec.ID))
}
}
}
root := attRoot(ctx)
removed, failed, freed := 0, 0, int64(0)
for _, id := range req.IDs {
rec, err := ctx.EntClient.Attachment.Get(ctx0(), int(id))
if err != nil {
failed++
continue
}
if rec.Deleted || rec.PurgedAt != 0 {
continue
}
if n, _ := attachmentRefs(ctx, rec.BizType, rec.BizID); n > 0 {
failed++ // 执行时引用出现(如单据刚保存),跳过
continue
}
if abs, okp := safeAbsPath(root, rec.FilePath); okp {
if info, serr := os.Stat(abs); serr == nil {
freed += info.Size()
}
_ = osRemoveIfExist(abs)
}
if _, derr := ctx.EntClient.Attachment.Delete().Where(attachment.ID(rec.ID)).Exec(ctx0()); derr != nil {
failed++
continue
}
removed++
}
ctx.EventLog.Write(ctx0(), "attachment.orphan.purge", r.Header.Get("X-Username"), "attachment", "orphan",
fmt.Sprintf("清除无引用附件:删除%d 释放%.2fMB 失败%d(确认人:%s %s)",
removed, float64(freed)/1024/1024, failed,
strings.TrimSpace(req.AckName), strings.TrimSpace(req.AckPhone)), nil)
ok(w, map[string]any{"removed": removed, "failed": failed, "freed": freed})
}
}
// osRemoveIfExist 物理删除文件(不存在视为成功)。返回空串=成功。
func osRemoveIfExist(abs string) string {
if err := os.Remove(abs); err != nil && !os.IsNotExist(err) {
return err.Error()
}
return ""
}
func ornull(s string) string {
if strings.TrimSpace(s) == "" {
return "无"
}
return strings.TrimSpace(s)
}