feat: 大屏新增虚拟工位滚动栏与多订单轮播,附件表增加删除原因及彻底清除留痕字段

This commit is contained in:
SunYF
2026-10-29 18:16:53 +08:00
parent 4d3c4e2c3a
commit 11dbdaae75
75 changed files with 6801 additions and 965 deletions
+163 -40
View File
@@ -20,6 +20,7 @@ import (
"io"
"os"
"path/filepath"
"sort"
"strings"
"sync"
"time"
@@ -40,16 +41,22 @@ import (
type ItemDef struct {
Key string `json:"key"`
Name string `json:"name"`
Desc string `json:"desc"` // 业务说明(index.html 与前端展示用)
Kind string `json:"kind"` // log | attachment
}
// MESItems MES 端可选数据项(event_log/plc_send_log/workpiece_lifecycle_log/alert/attachment)。
var MESItems = []ItemDef{
{Key: "event_log", Name: "操作日志", Kind: "log"},
{Key: "plc_send_log", Name: "PLC下发日志", Kind: "log"},
{Key: "workpiece_lifecycle_log", Name: "工件生命周期日志", Kind: "log"},
{Key: "alert", Name: "预警消息", Kind: "log"},
{Key: "attachment", Name: "业务附件", Kind: "attachment"},
{Key: "event_log", Name: "操作日志", Kind: "log",
Desc: "系统操作日志:记录用户登录及工单/设备/参数等操作流水,用于安全审计与责任追溯。"},
{Key: "plc_send_log", Name: "PLC下发日志", Kind: "log",
Desc: "PLC 下发指令流水:记录系统向 PLC/设备下发的每条指令与执行结果,用于设备动作追溯。"},
{Key: "workpiece_lifecycle_log", Name: "工件生命周期日志", Kind: "log",
Desc: "工件生命周期日志:记录工件从上线到下线在各工位的流转事件,用于生产过程追溯。"},
{Key: "alert", Name: "预警消息", Kind: "log",
Desc: "预警消息:设备与生产过程产生的异常、预警记录,用于问题回溯分析。"},
{Key: "attachment", Name: "业务附件", Kind: "attachment",
Desc: "业务附件:工单/检验等上传的图片与文档,按原始相对路径存放在包内 attachments/ 目录。"},
}
// BackupRequest 备份请求。
@@ -62,11 +69,17 @@ type BackupRequest struct {
}
// CleanupRequest 清理请求。
// Mode: ""=整窗清理(须完整备份覆盖);"covered"=仅清理已覆盖段(未备份段保留)。
// Force=true 时无视覆盖直接整窗清理,须填写 AckName/AckPhone 留痕(警示用)。
type CleanupRequest struct {
Start int64 `json:"start"`
End int64 `json:"end"`
Items []string `json:"items"`
Operator string `json:"operator"`
Mode string `json:"mode"`
Force bool `json:"force"`
AckName string `json:"ackName"`
AckPhone string `json:"ackPhone"`
}
// ItemResult 单项导出结果。
@@ -99,10 +112,23 @@ type MissingSeg struct {
End int64 `json:"end"`
}
// CoverageResult 覆盖校验结果。
// CoverageRecord 覆盖该时间窗的备份记录(供前端覆盖地图展示)。
type CoverageRecord struct {
ID int `json:"id"`
ExecutedAt int64 `json:"executedAt"`
RangeStart int64 `json:"rangeStart"`
RangeEnd int64 `json:"rangeEnd"`
BackupPath string `json:"backupPath"`
Operator string `json:"operator"`
TotalSize int64 `json:"totalSize"`
}
// CoverageResult 覆盖校验结果(Covered=已覆盖段,Missing=缺失段,Records=覆盖本窗的备份记录)。
type CoverageResult struct {
OK bool `json:"ok"`
Missing []MissingSeg `json:"missing"`
OK bool `json:"ok"`
Covered []MissingSeg `json:"covered"`
Missing []MissingSeg `json:"missing"`
Records []CoverageRecord `json:"records"`
}
// Progress 任务进度。
@@ -243,6 +269,8 @@ func (s *Service) runBackup(jobID string, req BackupRequest) {
"rangeStartText": tStart.Format("2006-01-02 15:04:05"),
"rangeEndText": tEnd.Format("2006-01-02 15:04:05"),
"operator": req.Operator,
"targetPath": req.TargetPath,
"zipPath": zipPath,
"items": results,
"totalSize": total,
"checksum": "",
@@ -256,8 +284,8 @@ func (s *Service) runBackup(jobID string, req BackupRequest) {
return
}
// index.html(清单 + 校验,不内嵌预览)
indexHTML := buildIndexHTML("MES 备份清单", manifest, "")
// index.html(清单 + 目录/使用/恢复说明,不内嵌预览)
indexHTML := buildIndexHTML("MES 数据备份清单", manifest, "", MESItems)
if err := zw.WriteFile("index.html", []byte(indexHTML)); err != nil {
_ = zw.Close()
_ = f.Close()
@@ -321,6 +349,7 @@ func (s *Service) exportLog(ctx context.Context, zw *zipWriter, h io.Writer, key
}
func (s *Service) exportAttachment(ctx context.Context, zw *zipWriter, h io.Writer, tStart, tEnd time.Time) (ItemResult, error) {
// 全量快照:不过滤删除状态(含已删除附件),元数据标注删除信息,确保彻底清除后仍可从备份包找回
rows, err := s.client.Attachment.Query().
Where(attachment.CreatedAtGTE(tStart), attachment.CreatedAtLTE(tEnd)).All(ctx)
if err != nil {
@@ -338,7 +367,7 @@ func (s *Service) exportAttachment(ctx context.Context, zw *zipWriter, h io.Writ
// 文件不存在(可能已挪走):仅记录元数据
meta = append(meta, map[string]any{
"id": r.ID, "fileName": r.FileName, "filePath": r.FilePath,
"fileSize": r.FileSize, "missing": true,
"fileSize": r.FileSize, "missing": true, "deleted": r.Deleted,
})
continue
}
@@ -355,7 +384,7 @@ func (s *Service) exportAttachment(ctx context.Context, zw *zipWriter, h io.Writ
ir.Bytes += n
meta = append(meta, map[string]any{
"id": r.ID, "fileName": r.FileName, "filePath": r.FilePath,
"fileSize": r.FileSize, "bytes": n,
"fileSize": r.FileSize, "bytes": n, "deleted": r.Deleted,
})
}
mb, _ := json.MarshalIndent(meta, "", " ")
@@ -504,6 +533,9 @@ func (s *Service) StartCleanup(req CleanupRequest) (string, error) {
if len(req.Items) == 0 {
return "", fmt.Errorf("请至少选择一个数据项")
}
if req.Force && req.Mode == "covered" {
return "", fmt.Errorf("参数冲突:强制清理与仅清理已覆盖段不可同时选择")
}
jobID := newJobID()
s.mu.Lock()
s.jobs[jobID] = &Progress{JobID: jobID, Phase: "cleanup", Stage: "checking", Percent: 0}
@@ -513,17 +545,28 @@ func (s *Service) StartCleanup(req CleanupRequest) (string, error) {
}
// CheckCoverage 校验备份覆盖(供前端预检)。
// 返回:Covered=已覆盖段(可用于「仅清理已覆盖部分」),Missing=缺失段,
// Records=与本时间窗相交的 success 备份记录(供覆盖地图展示)。
func (s *Service) CheckCoverage(start, end int64) (CoverageResult, error) {
recs, err := s.client.BackupRecord.Query().Where(backuprecord.StatusEQ("success")).All(context.Background())
if err != nil {
return CoverageResult{}, err
}
ivs := make([][2]int64, 0, len(recs))
outRecs := make([]CoverageRecord, 0, len(recs))
for _, r := range recs {
if r.RangeEnd < start || r.RangeStart > end {
continue
}
ivs = append(ivs, [2]int64{r.RangeStart, r.RangeEnd})
outRecs = append(outRecs, CoverageRecord{
ID: r.ID, ExecutedAt: r.ExecutedAt, RangeStart: r.RangeStart, RangeEnd: r.RangeEnd,
BackupPath: r.BackupPath, Operator: r.Operator, TotalSize: r.TotalSize,
})
}
missing := complement(ivs, start, end)
return CoverageResult{OK: len(missing) == 0, Missing: missing}, nil
sort.Slice(outRecs, func(i, j int) bool { return outRecs[i].RangeStart < outRecs[j].RangeStart })
covered, missing := coverageSegments(ivs, start, end)
return CoverageResult{OK: len(missing) == 0, Covered: covered, Missing: missing, Records: outRecs}, nil
}
func (s *Service) runCleanup(jobID string, req CleanupRequest) {
@@ -542,30 +585,96 @@ func (s *Service) runCleanup(jobID string, req CleanupRequest) {
s.failCleanup(jobID, req, fmt.Errorf("覆盖校验失败:%w", err))
return
}
if !cov.OK {
s.failCleanup(jobID, req, fmt.Errorf("该时间窗未被完整备份,禁止清理。缺失时间段:%s",
var deleted, skipped []ItemResult
forced := false
if cov.OK {
// 整窗均已被备份覆盖:直接清理
tStart, tEnd := time.Unix(req.Start, 0), time.Unix(req.End, 0)
if deleted, skipped, err = s.cleanWindow(ctx, tStart, tEnd, req.Items, setStage); err != nil {
s.failCleanup(jobID, req, err)
return
}
} else if req.Mode == "covered" {
// 部分清理:逐段清理已覆盖部分,未备份段保留
if len(cov.Covered) == 0 {
s.failCleanup(jobID, req, fmt.Errorf("该时间窗内没有任何已被备份的数据段,无法清理。缺失时间段:%s", formatMissing(cov.Missing)))
return
}
for i, seg := range cov.Covered {
setStage("cleaning", i*90/len(cov.Covered),
fmt.Sprintf("清理已覆盖段 %s ~ %s …", time.Unix(seg.Start, 0).Format("2006-01-02"), time.Unix(seg.End, 0).Format("2006-01-02")))
tStart, tEnd := time.Unix(seg.Start, 0), time.Unix(seg.End, 0)
var d, sk []ItemResult
if d, sk, err = s.cleanWindow(ctx, tStart, tEnd, req.Items, setStage); err != nil {
s.failCleanup(jobID, req, err)
return
}
deleted = append(deleted, d...)
skipped = append(skipped, sk...)
}
} else if req.Force {
// 强制清理:未完整备份仍坚持整窗清理,须实名留痕
if err = validateAck(req); err != nil {
s.failCleanup(jobID, req, err)
return
}
forced = true
tStart, tEnd := time.Unix(req.Start, 0), time.Unix(req.End, 0)
if deleted, skipped, err = s.cleanWindow(ctx, tStart, tEnd, req.Items, setStage); err != nil {
s.failCleanup(jobID, req, err)
return
}
} else {
s.failCleanup(jobID, req, fmt.Errorf(
"该时间窗未被完整备份,禁止清理。缺失时间段:%s。可选:① 先补齐缺失段备份;② 仅清理已覆盖部分(未备份段保留);③ 强制清理(需实名确认,风险自担)。",
formatMissing(cov.Missing)))
return
}
tStart := time.Unix(req.Start, 0)
tEnd := time.Unix(req.End, 0)
deleted := make([]ItemResult, 0, len(req.Items))
skipped := make([]ItemResult, 0, len(req.Items))
// 2) 清理记录 + event_log
status := "cleanup"
evKind, detail := "backup.cleanup", fmt.Sprintf("按时间窗清理(%s ~ %s):%s",
time.Unix(req.Start, 0).Format("2006-01-02"), time.Unix(req.End, 0).Format("2006-01-02"),
summaryDeleted(deleted, skipped))
if forced {
status = "cleanup_forced"
evKind = "backup.cleanup.forced"
detail = fmt.Sprintf("强制清理(该时间窗未被完整备份,缺失:%s;操作确认人:%s,手机号:%s):%s",
formatMissing(cov.Missing), req.AckName, req.AckPhone, summaryDeleted(deleted, skipped))
} else if !cov.OK { // covered 模式
detail += fmt.Sprintf("(仅清理已覆盖部分,未备份段已保留:%s)", formatMissing(cov.Missing))
}
s.writeCleanupRecord(req, status, deleted, skipped)
s.ev.Write(ctx, evKind, "", req.Operator, "backup", "", detail, nil)
setStage("done", 100, "清理完成")
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Done = true
j.Result = CleanupResult{RangeStart: req.Start, RangeEnd: req.End, Deleted: deleted, Skipped: skipped}
}
s.mu.Unlock()
}
// cleanWindow 清理单个时间窗内的指定数据项(物理删除)。
func (s *Service) cleanWindow(ctx context.Context, tStart, tEnd time.Time, keys []string, setStage func(string, int, string)) ([]ItemResult, []ItemResult, error) {
deleted := make([]ItemResult, 0, len(keys))
skipped := make([]ItemResult, 0, len(keys))
itemNames := make(map[string]string, len(MESItems))
for _, it := range MESItems {
itemNames[it.Key] = it.Name
}
// 2) 逐表清理
for i, key := range req.Items {
setStage("cleaning", int(float64(i)/float64(len(req.Items))*90), "清理 "+itemName(itemNames, key)+" …")
for i, key := range keys {
pct := 0
if len(keys) > 0 {
pct = i * 90 / len(keys)
}
setStage("cleaning", pct, "清理 "+itemName(itemNames, key)+" …")
if key == "attachment" {
d, sk, e := s.cleanupAttachment(ctx, tStart, tEnd)
if e != nil {
s.failCleanup(jobID, req, fmt.Errorf("清理附件失败:%w", e))
return
return nil, nil, fmt.Errorf("清理附件失败:%w", e)
}
d.Key, d.Name = key, itemName(itemNames, key)
sk.Key, sk.Name = key, itemName(itemNames, key)
@@ -576,26 +685,40 @@ func (s *Service) runCleanup(jobID string, req CleanupRequest) {
} else {
n, e := s.cleanupLog(ctx, key, tStart, tEnd)
if e != nil {
s.failCleanup(jobID, req, fmt.Errorf("清理 %s 失败:%w", itemName(itemNames, key), e))
return
return nil, nil, fmt.Errorf("清理 %s 失败:%w", itemName(itemNames, key), e)
}
deleted = append(deleted, ItemResult{Key: key, Name: itemName(itemNames, key), Rows: n, Bytes: 0})
}
}
return deleted, skipped, nil
}
// 3) 清理动作本身写一条 event_log
s.ev.Write(ctx, "backup.cleanup", "", req.Operator, "backup", "",
fmt.Sprintf("按时间窗清理(%s ~ %s):%s",
time.Unix(req.Start, 0).Format("2006-01-02"), time.Unix(req.End, 0).Format("2006-01-02"),
summaryDeleted(deleted, skipped)), nil)
setStage("done", 100, "清理完成")
s.mu.Lock()
if j, ok := s.jobs[jobID]; ok {
j.Done = true
j.Result = CleanupResult{RangeStart: req.Start, RangeEnd: req.End, Deleted: deleted, Skipped: skipped}
// writeCleanupRecord 清理成功后写一条 backup_record(status=cleanup / cleanup_forced),
// 备份记录与清理记录统一在「备份/清理历史」中展示;覆盖校验仅认 success,不受影响。
func (s *Service) writeCleanupRecord(req CleanupRequest, status string, deleted, skipped []ItemResult) {
items := make([]ItemResult, 0, len(deleted)+len(skipped))
items = append(items, deleted...)
items = append(items, skipped...)
itemsJSON, _ := json.Marshal(items)
var total int64
for _, d := range deleted {
total += d.Bytes
}
s.mu.Unlock()
c := s.client.BackupRecord.Create().
SetExecutedAt(time.Now().Unix()).
SetRangeStart(req.Start).
SetRangeEnd(req.End).
SetBackupPath("").
SetTotalSize(total).
SetItemsJSON(string(itemsJSON)).
SetStatus(status).
SetOperator(req.Operator).
SetChecksum("").
SetScope("mes")
if status == "cleanup_forced" {
c = c.SetAckName(strings.TrimSpace(req.AckName)).SetAckPhone(strings.TrimSpace(req.AckPhone))
}
_, _ = c.Save(context.Background())
}
func (s *Service) cleanupLog(ctx context.Context, key string, tStart, tEnd time.Time) (int64, error) {