break
62419d4b17
All checks were successful
构建并部署到测试环境（无 SSH） / build-and-deploy (push) Successful in 13m40s
统一时间筛选：新增共享严格解析器 pkg/utils/time_range.go，只接受带显式时区的 RFC3339 秒级时间（拒绝小数秒、无时区、date-only、空格分隔、±hhmm、未补零、非法日期与越界偏移），闭区间含两端、归一为 UTC 瞬时，创建期与执行期共用同一份实现。 端点改造（13 个入口）：IoT 卡导入任务、设备导入任务、导出任务列表、订单列表参数名不变仅收紧解析；换货、分配记录、代理充值、临期列表改名 start_time/end_time（旧参数名显式拒绝）；提现记录两处删除解析失败静默跳过，非法参数一律 1001；授权记录由起始闭结束开改为闭区间含两端；临期列表改按当前生效主套餐最终到期时刻比较，保留剩余天数上下限与既有粗放窗口。 临期导出新建：新场景 expiring_asset 与受控入口 POST /api/admin/expiring-assets/export，复用列表候选预筛与最终到期推算，一行一资产、加油包不单独成行，列序与 111 §18.1 逐列一致，店铺/业务员/用户组按执行时当前归属补充且不超出创建时冻结范围。 佣金明细导出新增按创建时间闭区间筛选（原佣金与回溯两条分支各自创建时间列），记录粒度、列定义与余额口径不变。 冻结与遗留任务：创建期把筛选与时间边界规范化为 UTC RFC3339 秒级串写入既有 query_json，无新列无迁移；执行期只按冻结值严格解析，非法冻结值在任何分片与文件动作前落任务失败并写安全摘要，不放行全量；重试沿用原快照。达量预警导出执行期同样纳入严格解析（其入口契约、列定义与触发快照口径不变）。 归档 add-export-time-filter-standards 并新建主 Spec openspec/specs/export-time-filter/spec.md，同步 requirement-evidence.json 与入口能力矩阵，README 导出场景清单更新为 11 个场景。 验证：junhong_cmp_test + 本地隔离 Redis（DB7，测试部署共享队列 DB6 未被占用）实跑 85 PASS / 0 FAIL（接受/拒绝集合、区间与顺序语义、列表与导出同筛选行集一致、代理 HTTP 全链路与范围冻结、遗留旧格式任务安全失败、列与余额口径回归、表头逐字），门禁 gofmt/go build/gendocs 两次一致/openspec validate/doctor/context-health 全绿；无 Schema 变更、无迁移、无运行时开关。
377 lines
13 KiB
Go
377 lines
13 KiB
Go
package export_task
|
|
|
|
import (
|
|
"context"
|
|
stderrors "errors"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/bytedance/sonic"
|
|
"github.com/hibiken/asynq"
|
|
"gorm.io/datatypes"
|
|
"gorm.io/gorm"
|
|
|
|
"github.com/break/junhong_cmp_fiber/internal/exporter"
|
|
"github.com/break/junhong_cmp_fiber/internal/infrastructure/audit"
|
|
"github.com/break/junhong_cmp_fiber/internal/model"
|
|
"github.com/break/junhong_cmp_fiber/internal/model/dto"
|
|
"github.com/break/junhong_cmp_fiber/internal/store"
|
|
"github.com/break/junhong_cmp_fiber/internal/store/postgres"
|
|
"github.com/break/junhong_cmp_fiber/pkg/auditfailure"
|
|
"github.com/break/junhong_cmp_fiber/pkg/constants"
|
|
"github.com/break/junhong_cmp_fiber/pkg/errors"
|
|
"github.com/break/junhong_cmp_fiber/pkg/middleware"
|
|
"github.com/break/junhong_cmp_fiber/pkg/queue"
|
|
"github.com/break/junhong_cmp_fiber/pkg/storage"
|
|
)
|
|
|
|
// Service 导出任务服务。
|
|
type Service struct {
|
|
db *gorm.DB
|
|
taskStore *postgres.ExportTaskStore
|
|
queueClient *queue.Client
|
|
storageSvc *storage.Service
|
|
sceneRegistry *exporter.Registry
|
|
auditWriter *audit.Writer
|
|
}
|
|
|
|
type dispatchPayload struct {
|
|
TaskID uint `json:"task_id"`
|
|
}
|
|
|
|
// New 创建导出任务服务。
|
|
func New(db *gorm.DB, taskStore *postgres.ExportTaskStore, queueClient *queue.Client, storageSvc *storage.Service, auditWriters ...*audit.Writer) *Service {
|
|
service := &Service{
|
|
db: db,
|
|
taskStore: taskStore,
|
|
queueClient: queueClient,
|
|
storageSvc: storageSvc,
|
|
sceneRegistry: exporter.NewDefaultRegistry(db),
|
|
}
|
|
if len(auditWriters) > 0 {
|
|
service.auditWriter = auditWriters[0]
|
|
}
|
|
return service
|
|
}
|
|
|
|
// CreateTask 创建导出任务并入队 dispatch。
|
|
func (s *Service) CreateTask(ctx context.Context, req *dto.CreateExportTaskRequest) (*dto.CreateExportTaskResponse, error) {
|
|
userID := middleware.GetUserIDFromContext(ctx)
|
|
if userID == 0 {
|
|
return nil, errors.New(errors.CodeUnauthorized)
|
|
}
|
|
|
|
userType := middleware.GetUserTypeFromContext(ctx)
|
|
if userType != constants.UserTypeSuperAdmin && userType != constants.UserTypePlatform && userType != constants.UserTypeAgent {
|
|
return nil, errors.New(errors.CodeForbidden, "当前账号无权限创建导出任务")
|
|
}
|
|
|
|
if req.Scene == "" || !s.sceneRegistry.IsSupported(req.Scene) {
|
|
return nil, errors.New(errors.CodeInvalidParam, "导出场景不支持")
|
|
}
|
|
if req.Format != constants.ExportTaskFormatXLSX && req.Format != constants.ExportTaskFormatCSV {
|
|
return nil, errors.New(errors.CodeInvalidParam, "导出格式不支持")
|
|
}
|
|
|
|
// 受影响场景的时间边界在创建期校验并规范化为 UTC RFC3339 秒级字符串后随筛选一起冻结，
|
|
// 执行期只按冻结值严格解析；旧参数键与非法格式一律在创建期拒绝。
|
|
if err := exporter.NormalizeTaskTimeFilters(req.Scene, req.Query); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
queryJSON := datatypes.JSON("{}")
|
|
if req.Query != nil {
|
|
raw, err := sonic.Marshal(req.Query)
|
|
if err != nil {
|
|
return nil, errors.Wrap(errors.CodeInvalidParam, err, "导出筛选参数格式不正确")
|
|
}
|
|
queryJSON = datatypes.JSON(raw)
|
|
}
|
|
|
|
shopID := middleware.GetShopIDFromContext(ctx)
|
|
enterpriseID := middleware.GetEnterpriseIDFromContext(ctx)
|
|
|
|
var (
|
|
creatorShopID *uint
|
|
creatorEnterpriseID *uint
|
|
)
|
|
if shopID > 0 {
|
|
creatorShopID = &shopID
|
|
}
|
|
if enterpriseID > 0 {
|
|
creatorEnterpriseID = &enterpriseID
|
|
}
|
|
|
|
scopeShopIDs := model.UIntListJSON{}
|
|
if userType == constants.UserTypeAgent {
|
|
subordinateShopIDs := middleware.GetSubordinateShopIDs(ctx)
|
|
if subordinateShopIDs == nil {
|
|
if shopID == 0 {
|
|
return nil, errors.New(errors.CodeForbidden, "代理账号缺少店铺信息")
|
|
}
|
|
subordinateShopIDs = []uint{shopID}
|
|
}
|
|
if len(subordinateShopIDs) == 0 {
|
|
return nil, errors.New(errors.CodeForbidden, "当前账号无可导出的数据范围")
|
|
}
|
|
scopeShopIDs = subordinateShopIDs
|
|
}
|
|
|
|
task := &model.ExportTask{
|
|
TaskNo: s.taskStore.GenerateTaskNo(),
|
|
Scene: req.Scene,
|
|
Format: req.Format,
|
|
Status: constants.ExportTaskStatusPending,
|
|
Progress: 0,
|
|
QueryJSON: queryJSON,
|
|
ScopeShopIDs: scopeShopIDs,
|
|
CreatorUserID: userID,
|
|
CreatorUserType: userType,
|
|
CreatorShopID: creatorShopID,
|
|
CreatorEnterpriseID: creatorEnterpriseID,
|
|
}
|
|
task.Creator = userID
|
|
task.Updater = userID
|
|
|
|
if s.auditWriter == nil {
|
|
return nil, errors.New(errors.CodeInvalidStatus, "导出任务统一审计接缝未配置")
|
|
}
|
|
if err := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := s.taskStore.WithTx(tx).Create(ctx, task); err != nil {
|
|
return err
|
|
}
|
|
return s.writeTaskAudit(ctx, tx, constants.AuditActionExportTaskCreated, "创建业务导出任务", task, nil, exportTaskState(task), constants.AuditResultSuccess, "created", "", "")
|
|
}); err != nil {
|
|
s.recordTaskAudit(ctx, constants.AuditActionExportTaskCreated, "创建业务导出任务失败", task, nil, exportTaskState(task), constants.AuditResultFailed, "create_failed", errors.CodeDatabaseError)
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "创建导出任务失败")
|
|
}
|
|
|
|
if err := s.queueClient.EnqueueTask(
|
|
ctx,
|
|
constants.TaskTypeExportDispatch,
|
|
dispatchPayload{TaskID: task.ID},
|
|
asynq.MaxRetry(constants.ExportDispatchRetryMax),
|
|
asynq.Timeout(constants.ExportDispatchTaskTimeout),
|
|
asynq.Queue(constants.QueueForTaskType(constants.TaskTypeExportDispatch)),
|
|
); err != nil {
|
|
secondaryErr := s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
if err := s.taskStore.WithTx(tx).MarkFailed(ctx, task.ID, userID, "导出任务入队失败"); err != nil {
|
|
return err
|
|
}
|
|
before := exportTaskState(task)
|
|
task.Status = constants.ExportTaskStatusFailed
|
|
task.ErrorMessage = "导出任务入队失败"
|
|
return s.writeTaskAudit(ctx, tx, constants.AuditActionExportTaskCreated, "导出任务入队失败", task, before, exportTaskState(task), constants.AuditResultFailed, "enqueue_failed", strconv.Itoa(errors.CodeTaskQueueError), "导出任务入队失败")
|
|
})
|
|
if secondaryErr != nil {
|
|
auditfailure.RecordSecondaryWriteFailure(constants.AuditActionExportTaskCreated, task.TaskNo, "", task.TaskNo, strconv.Itoa(errors.CodeTaskQueueError), secondaryErr)
|
|
}
|
|
return nil, errors.Wrap(errors.CodeTaskQueueError, err, "导出任务入队失败")
|
|
}
|
|
|
|
return &dto.CreateExportTaskResponse{
|
|
TaskID: task.ID,
|
|
TaskNo: task.TaskNo,
|
|
Status: task.Status,
|
|
StatusName: constants.GetExportTaskStatusName(task.Status),
|
|
Message: "导出任务创建成功，系统将异步处理",
|
|
}, nil
|
|
}
|
|
|
|
// ListTasks 查询导出任务列表。
|
|
func (s *Service) ListTasks(ctx context.Context, req *dto.ListExportTaskRequest, startTime, endTime *time.Time) (*dto.ListExportTaskResponse, error) {
|
|
page := req.Page
|
|
if page <= 0 {
|
|
page = 1
|
|
}
|
|
|
|
pageSize := req.PageSize
|
|
if pageSize <= 0 {
|
|
pageSize = constants.DefaultPageSize
|
|
}
|
|
if pageSize > constants.MaxPageSize {
|
|
pageSize = constants.MaxPageSize
|
|
}
|
|
|
|
filters := make(map[string]any)
|
|
if req.Scene != "" {
|
|
filters["scene"] = req.Scene
|
|
}
|
|
if req.Status != nil {
|
|
filters["status"] = *req.Status
|
|
}
|
|
if startTime != nil {
|
|
filters["start_time"] = *startTime
|
|
}
|
|
if endTime != nil {
|
|
filters["end_time"] = *endTime
|
|
}
|
|
|
|
items, total, err := s.taskStore.List(ctx, &store.QueryOptions{
|
|
Page: page,
|
|
PageSize: pageSize,
|
|
OrderBy: "created_at DESC",
|
|
}, filters)
|
|
if err != nil {
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询导出任务列表失败")
|
|
}
|
|
|
|
result := make([]*dto.ExportTaskItem, 0, len(items))
|
|
for _, item := range items {
|
|
result = append(result, toTaskItemDTO(item))
|
|
}
|
|
|
|
return &dto.ListExportTaskResponse{
|
|
List: result,
|
|
Total: total,
|
|
Page: page,
|
|
PageSize: pageSize,
|
|
}, nil
|
|
}
|
|
|
|
// GetTaskDetail 查询导出任务详情。
|
|
func (s *Service) GetTaskDetail(ctx context.Context, id uint) (*dto.ExportTaskDetailResponse, error) {
|
|
task, err := s.taskStore.GetByID(ctx, id)
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeForbidden, "无权限操作该资源或资源不存在")
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询导出任务详情失败")
|
|
}
|
|
|
|
resp := &dto.ExportTaskDetailResponse{ExportTaskItem: *toTaskItemDTO(task)}
|
|
if task.Status == constants.ExportTaskStatusCompleted && task.FileKey != "" && s.storageSvc != nil && s.storageSvc.Provider() != nil {
|
|
url, err := s.storageSvc.Provider().GetDownloadURL(ctx, task.FileKey, constants.ExportDownloadURLExpire)
|
|
if err != nil {
|
|
return nil, errors.Wrap(errors.CodeInternalError, err, "生成下载链接失败")
|
|
}
|
|
expiresAt := time.Now().Add(constants.ExportDownloadURLExpire)
|
|
resp.DownloadURL = url
|
|
resp.DownloadExpiresAt = &expiresAt
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
// CancelTask 取消导出任务。
|
|
func (s *Service) CancelTask(ctx context.Context, id uint) (*dto.CancelExportTaskResponse, error) {
|
|
userID := middleware.GetUserIDFromContext(ctx)
|
|
if userID == 0 {
|
|
return nil, errors.New(errors.CodeUnauthorized)
|
|
}
|
|
|
|
task, err := s.taskStore.GetByID(ctx, id)
|
|
if err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, errors.New(errors.CodeForbidden, "无权限操作该资源或资源不存在")
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "查询导出任务失败")
|
|
}
|
|
|
|
if s.auditWriter == nil {
|
|
return nil, errors.New(errors.CodeInvalidStatus, "导出任务统一审计接缝未配置")
|
|
}
|
|
message := "取消请求已提交"
|
|
before := exportTaskState(task)
|
|
changed := false
|
|
err = s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
|
|
txStore := s.taskStore.WithTx(tx)
|
|
switch task.Status {
|
|
case constants.ExportTaskStatusPending:
|
|
ok, updateErr := txStore.CancelPendingTask(ctx, id, userID)
|
|
if updateErr != nil {
|
|
return updateErr
|
|
}
|
|
if !ok {
|
|
return errors.New(errors.CodeInvalidStatus, "当前状态不支持取消")
|
|
}
|
|
task.Status, task.CancelRequested, task.Progress = constants.ExportTaskStatusCancelled, true, 100
|
|
message, changed = "任务已取消", true
|
|
case constants.ExportTaskStatusProcessing:
|
|
if task.CancelRequested {
|
|
message = "取消请求已提交，请稍后刷新状态"
|
|
return nil
|
|
}
|
|
ok, updateErr := txStore.SetCancelRequested(ctx, id, userID)
|
|
if updateErr != nil {
|
|
return updateErr
|
|
}
|
|
if !ok {
|
|
return errors.New(errors.CodeInvalidStatus, "当前状态不支持取消")
|
|
}
|
|
task.CancelRequested, changed = true, true
|
|
case constants.ExportTaskStatusCompleted, constants.ExportTaskStatusFailed, constants.ExportTaskStatusCancelled:
|
|
return errors.New(errors.CodeInvalidStatus, "当前状态不支持取消")
|
|
default:
|
|
return errors.New(errors.CodeInvalidStatus, "当前状态不支持取消")
|
|
}
|
|
if !changed {
|
|
return nil
|
|
}
|
|
return s.writeTaskAudit(ctx, tx, constants.AuditActionExportTaskCancelled, message, task, before, exportTaskState(task), constants.AuditResultSuccess, "cancelled", "", "")
|
|
})
|
|
if err != nil {
|
|
result := constants.AuditResultFailed
|
|
errorCode := errors.CodeDatabaseError
|
|
var appErr *errors.AppError
|
|
if stderrors.As(err, &appErr) && appErr.Code == errors.CodeInvalidStatus {
|
|
result = constants.AuditResultDenied
|
|
errorCode = appErr.Code
|
|
}
|
|
s.recordTaskAudit(ctx, constants.AuditActionExportTaskCancelled, "取消业务导出任务失败", task, before, exportTaskState(task), result, "", errorCode)
|
|
if appErr != nil {
|
|
return nil, appErr
|
|
}
|
|
return nil, errors.Wrap(errors.CodeDatabaseError, err, "取消导出任务失败")
|
|
}
|
|
|
|
return &dto.CancelExportTaskResponse{
|
|
TaskID: task.ID,
|
|
Status: task.Status,
|
|
StatusName: constants.GetExportTaskStatusName(task.Status),
|
|
CancelRequested: task.CancelRequested,
|
|
Message: message,
|
|
}, nil
|
|
}
|
|
|
|
func toTaskItemDTO(task *model.ExportTask) *dto.ExportTaskItem {
|
|
return &dto.ExportTaskItem{
|
|
ID: task.ID,
|
|
TaskID: task.ID,
|
|
TaskNo: task.TaskNo,
|
|
Scene: task.Scene,
|
|
Format: task.Format,
|
|
Status: task.Status,
|
|
StatusName: constants.GetExportTaskStatusName(task.Status),
|
|
Progress: task.Progress,
|
|
TotalRows: task.TotalRows,
|
|
ProcessedRows: task.ProcessedRows,
|
|
TotalShards: task.TotalShards,
|
|
SuccessShards: task.SuccessShards,
|
|
FailedShards: task.FailedShards,
|
|
TotalCount: task.TotalShards,
|
|
SuccessCount: task.SuccessShards,
|
|
FailedCount: task.FailedShards,
|
|
CancelRequested: task.CancelRequested,
|
|
FileKey: task.FileKey,
|
|
ErrorMessage: task.ErrorMessage,
|
|
ErrorCode: exportTaskErrorCode(task),
|
|
ErrorSummary: task.ErrorMessage,
|
|
CreatedAt: task.CreatedAt,
|
|
UpdatedAt: task.UpdatedAt,
|
|
StartedAt: task.StartedAt,
|
|
CompletedAt: task.CompletedAt,
|
|
CreatorUserID: task.CreatorUserID,
|
|
CreatorUserType: task.CreatorUserType,
|
|
CreatorShopID: task.CreatorShopID,
|
|
CreatorEnterpriseID: task.CreatorEnterpriseID,
|
|
}
|
|
}
|
|
|
|
func exportTaskErrorCode(task *model.ExportTask) string {
|
|
if task.ErrorMessage == "" {
|
|
return ""
|
|
}
|
|
return "EXPORT_TASK_FAILED"
|
|
}
|