第一次提交

2026-04-29 15:54:14 +08:00
parent 50d2eadbd1
commit e81df5ce5a
51 changed files with 4571 additions and 0 deletions
--- a/dao/model_dao.go
+++ b/dao/model_dao.go
@@ -0,0 +1,104 @@
+package dao
+
+import (
+	"context"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+var Model = &modelDao{}
+
+type modelDao struct{}
+
+func (d *modelDao) Insert(ctx context.Context, m *entity.AsynchModel) (id int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModel).Data(m).Insert()
+	if err != nil {
+		return 0, err
+	}
+	return r.LastInsertId()
+}
+
+func (d *modelDao) UpdateByID(ctx context.Context, id int64, data map[string]any) (rows int64, err error) {
+	// 触发 gfdb 的 updateHook 自动填充 updater，需要显式带 updater 字段
+	data[entity.AsynchModelCol.Updater] = ""
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModel).
+		Where(entity.AsynchModelCol.Id, id).
+		Data(data).
+		Update()
+	if err != nil {
+		return 0, err
+	}
+	return r.RowsAffected()
+}
+
+func (d *modelDao) DeleteByID(ctx context.Context, id int64) (rows int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModel).
+		Where(entity.AsynchModelCol.Id, id).
+		Delete()
+	if err != nil {
+		return 0, err
+	}
+	return r.RowsAffected()
+}
+
+func (d *modelDao) GetByModelName(ctx context.Context, modelName string) (m *entity.AsynchModel, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModel).
+		Where(entity.AsynchModelCol.ModelName, modelName).
+		One()
+	if err != nil {
+		return nil, err
+	}
+	if r.IsEmpty() {
+		return nil, nil
+	}
+	err = r.Struct(&m)
+	return
+}
+
+func (d *modelDao) GetByID(ctx context.Context, id int64) (m *entity.AsynchModel, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModel).
+		Where(entity.AsynchModelCol.Id, id).
+		One()
+	if err != nil {
+		return nil, err
+	}
+	if r.IsEmpty() {
+		return nil, nil
+	}
+	err = r.Struct(&m)
+	return
+}
+
+func (d *modelDao) List(ctx context.Context, pageNum, pageSize int, modelNameLike string) (list []*entity.AsynchModel, total int64, err error) {
+	model := gfdb.DB(ctx).Model(ctx, public.TableNameModel).Where("deleted_at IS NULL").OrderDesc(entity.AsynchModelCol.CreatedAt)
+	if modelNameLike != "" {
+		model = model.WhereLike(entity.AsynchModelCol.ModelName, "%"+modelNameLike+"%")
+	}
+	if pageNum > 0 && pageSize > 0 {
+		model = model.Page(pageNum, pageSize)
+	}
+	r, totalInt, err := model.AllAndCount(false)
+	if err != nil {
+		return nil, 0, err
+	}
+	total = gconv.Int64(totalInt)
+	err = r.Structs(&list)
+	return
+}
+
+// ListAll 用于分组展示：查询全部模型（不按类型过滤，类型拆分在 service 层处理）
+func (d *modelDao) ListAll(ctx context.Context) (list []*entity.AsynchModel, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModel).
+		Where("deleted_at IS NULL").
+		OrderDesc(entity.AsynchModelCol.CreatedAt).
+		All()
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
--- a/dao/model_dao_bg.go
+++ b/dao/model_dao_bg.go
@@ -0,0 +1,32 @@
+package dao
+
+import (
+	"context"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+)
+
+// GetByModelNameForTenant 后台任务使用：按 tenant_id + model_name 查询，不依赖 gfdb Hook/Trace/用户上下文
+func (d *modelDao) GetByModelNameForTenant(ctx context.Context, tenantId uint64, modelName string) (m *entity.AsynchModel, err error) {
+	r, err := gfdb.DB(ctx).GetAll(ctx,
+		"SELECT * FROM "+public.TableNameModel+" WHERE tenant_id=? AND model_name=? AND deleted_at IS NULL LIMIT 1",
+		tenantId, modelName,
+	)
+	if err != nil {
+		return nil, err
+	}
+	if r.IsEmpty() {
+		return nil, nil
+	}
+	var list []*entity.AsynchModel
+	if err := r.Structs(&list); err != nil {
+		return nil, err
+	}
+	if len(list) == 0 {
+		return nil, nil
+	}
+	return list[0], nil
+}
--- a/dao/model_type_dao.go
+++ b/dao/model_type_dao.go
@@ -0,0 +1,74 @@
+package dao
+
+import (
+	"context"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+type modelTypeDao struct{}
+
+var ModelType = &modelTypeDao{}
+
+func (d *modelTypeDao) Insert(ctx context.Context, t *entity.AsynchModelType) (id int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModelType).Data(t).Insert()
+	if err != nil {
+		return 0, err
+	}
+	return r.LastInsertId()
+}
+
+func (d *modelTypeDao) UpdateByID(ctx context.Context, id int64, data gdb.Map) (rows int64, err error) {
+	// 触发 gfdb 的 updateHook 自动填充 updater，需要显式带 updater 字段
+	data[entity.AsynchModelTypeCol.Updater] = ""
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModelType).Where(entity.AsynchModelTypeCol.Id, id).Data(data).Update()
+	if err != nil {
+		return 0, err
+	}
+	n, _ := r.RowsAffected()
+	return n, nil
+}
+
+func (d *modelTypeDao) DeleteByID(ctx context.Context, id int64) (rows int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModelType).Where(entity.AsynchModelTypeCol.Id, id).Delete()
+	if err != nil {
+		return 0, err
+	}
+	n, _ := r.RowsAffected()
+	return n, nil
+}
+
+func (d *modelTypeDao) GetByID(ctx context.Context, id int64) (*entity.AsynchModelType, error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameModelType).Where(entity.AsynchModelTypeCol.Id, id).One()
+	if err != nil {
+		return nil, err
+	}
+	if r.IsEmpty() {
+		return nil, nil
+	}
+	var t *entity.AsynchModelType
+	_ = r.Struct(&t)
+	return t, nil
+}
+
+func (d *modelTypeDao) List(ctx context.Context, pageNum, pageSize int, typeNameLike string) (list []*entity.AsynchModelType, total int64, err error) {
+	m := gfdb.DB(ctx).Model(ctx, public.TableNameModelType).Where("deleted_at IS NULL").OrderAsc(entity.AsynchModelTypeCol.TypeID)
+	if typeNameLike != "" {
+		m = m.WhereLike(entity.AsynchModelTypeCol.TypeName, "%"+typeNameLike+"%")
+	}
+	if pageNum > 0 && pageSize > 0 {
+		m = m.Page(pageNum, pageSize)
+	}
+	r, totalInt, err := m.AllAndCount(false)
+	if err != nil {
+		return nil, 0, err
+	}
+	total = gconv.Int64(totalInt)
+	err = r.Structs(&list)
+	return
+}
--- a/dao/op_log_dao.go
+++ b/dao/op_log_dao.go
@@ -0,0 +1,22 @@
+package dao
+
+import (
+	"context"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+)
+
+type opLogDao struct{}
+
+var OpLog = &opLogDao{}
+
+func (d *opLogDao) Insert(ctx context.Context, log *entity.AsynchOpLog) (id int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameOpLog).Data(log).Insert()
+	if err != nil {
+		return 0, err
+	}
+	return r.LastInsertId()
+}
--- a/dao/stat_dao.go
+++ b/dao/stat_dao.go
@@ -0,0 +1,61 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+type statDao struct{}
+
+var Stat = &statDao{}
+
+// IncRequestCount 原子累加（支持分布式/多协程）：按天+租户+创建人+模型 +1
+func (d *statDao) IncRequestCount(ctx context.Context, day time.Time, tenantId int64, creator, modelName string) error {
+	sql := fmt.Sprintf(`
+INSERT INTO %s(day, tenant_id, creator, model_name, request_count, created_at, updated_at)
+VALUES(?, ?, ?, ?, 1, NOW(), NOW())
+ON CONFLICT (day, tenant_id, creator, model_name)
+DO UPDATE SET request_count = %s.request_count + 1, updated_at = NOW()`,
+		public.TableNameStat, public.TableNameStat,
+	)
+	_, err := gfdb.DB(ctx).Exec(ctx, sql, gtime.New(day).Format("Y-m-d"), tenantId, creator, modelName)
+	return err
+}
+
+func (d *statDao) List(ctx context.Context, pageNum, pageSize int, startDay, endDay string, tenantId *int64, creator, modelName string) (list []*entity.AsynchModelStat, total int64, err error) {
+	m := gfdb.DB(ctx).Model(ctx, public.TableNameStat).Where("1=1")
+	if startDay != "" {
+		m = m.Where("day >= ?", startDay)
+	}
+	if endDay != "" {
+		m = m.Where("day <= ?", endDay)
+	}
+	if tenantId != nil {
+		m = m.Where("tenant_id = ?", *tenantId)
+	}
+	if creator != "" {
+		m = m.WhereLike("creator", "%"+creator+"%")
+	}
+	if modelName != "" {
+		m = m.WhereLike("model_name", "%"+modelName+"%")
+	}
+	m = m.OrderDesc("day").OrderDesc("request_count")
+	if pageNum > 0 && pageSize > 0 {
+		m = m.Page(pageNum, pageSize)
+	}
+	r, totalInt, err := m.AllAndCount(false)
+	if err != nil {
+		return nil, 0, err
+	}
+	total = int64(totalInt)
+	err = r.Structs(&list)
+	return
+}
+
--- a/dao/task_dao.go
+++ b/dao/task_dao.go
@@ -0,0 +1,250 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/gtime"
+	"github.com/gogf/gf/v2/util/gconv"
+)
+
+var Task = &taskDao{}
+
+type taskDao struct{}
+
+func (d *taskDao) Insert(ctx context.Context, t *entity.AsynchTask) (id int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).Data(t).Insert()
+	if err != nil {
+		return 0, err
+	}
+	return r.LastInsertId()
+}
+
+func (d *taskDao) GetByTaskID(ctx context.Context, taskID string) (t *entity.AsynchTask, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.TaskID, taskID).
+		One()
+	if err != nil {
+		return nil, err
+	}
+	if r.IsEmpty() {
+		return nil, nil
+	}
+	err = r.Struct(&t)
+	return
+}
+
+// ListByTaskIDs 批量查询任务（会受 gfdb 的租户 Hook 影响，只返回当前租户数据）
+func (d *taskDao) ListByTaskIDs(ctx context.Context, taskIDs []string) (list []*entity.AsynchTask, err error) {
+	if len(taskIDs) == 0 {
+		return nil, nil
+	}
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		WhereIn(entity.AsynchTaskCol.TaskID, taskIDs).
+		All()
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
+
+// MarkDownloadedByID 将成功任务标记为已下载(state=4)，并写入过期时间
+func (d *taskDao) MarkDownloadedByID(ctx context.Context, id int64, expireAt *gtime.Time) error {
+	data := gdb.Map{
+		entity.AsynchTaskCol.State:    4,
+		entity.AsynchTaskCol.ExpireAt: expireAt,
+		entity.AsynchTaskCol.Updater:  "",
+	}
+	_, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.Id, id).
+		Where(entity.AsynchTaskCol.State, 2).
+		Data(data).
+		Update()
+	return err
+}
+
+func (d *taskDao) UpdateRunning(ctx context.Context, id int64) error {
+	now := gtime.Now()
+	data := gdb.Map{
+		entity.AsynchTaskCol.State:     1,
+		entity.AsynchTaskCol.StartedAt: now,
+		entity.AsynchTaskCol.Updater:   "",
+	}
+	_, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.Id, id).
+		Data(data).
+		Update()
+	return err
+}
+
+func (d *taskDao) UpdateSuccess(ctx context.Context, id int64, ossFile, fileType string, fileSize int64, expireAt *gtime.Time) error {
+	now := gtime.Now()
+	data := gdb.Map{
+		entity.AsynchTaskCol.State:      2,
+		entity.AsynchTaskCol.OssFile:    ossFile,
+		entity.AsynchTaskCol.FileType:   fileType,
+		entity.AsynchTaskCol.FileSize:   fileSize,
+		entity.AsynchTaskCol.ErrorMsg:   "",
+		entity.AsynchTaskCol.FinishedAt: now,
+		entity.AsynchTaskCol.ExpireAt:   expireAt,
+		entity.AsynchTaskCol.Updater:    "",
+	}
+	_, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.Id, id).
+		Data(data).
+		Update()
+	return err
+}
+
+func (d *taskDao) UpdateFailed(ctx context.Context, id int64, errorMsg string) error {
+	now := gtime.Now()
+	data := gdb.Map{
+		entity.AsynchTaskCol.State:      3,
+		entity.AsynchTaskCol.ErrorMsg:   errorMsg,
+		entity.AsynchTaskCol.FinishedAt: now,
+		entity.AsynchTaskCol.Updater:    "",
+	}
+	_, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.Id, id).
+		Data(data).
+		Update()
+	return err
+}
+
+func (d *taskDao) SoftDeleteByTaskID(ctx context.Context, taskID string) (rows int64, err error) {
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.TaskID, taskID).
+		Delete()
+	if err != nil {
+		return 0, err
+	}
+	return r.RowsAffected()
+}
+
+// CountActiveByModel 统计某模型排队中/执行中的任务数，用于 queue_limit 限制（近似值）
+func (d *taskDao) CountActiveByModel(ctx context.Context, modelName string) (int64, error) {
+	n, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.ModelName, modelName).
+		WhereIn(entity.AsynchTaskCol.State, []int{0, 1}).
+		Count()
+	return int64(n), err
+}
+
+// List 任务分页查询（受 gfdb 租户 Hook 影响）
+func (d *taskDao) List(ctx context.Context, pageNum, pageSize int, modelNameLike, taskIDLike string, state *int) (list []*entity.AsynchTask, total int64, err error) {
+	m := gfdb.DB(ctx).Model(ctx, public.TableNameTask).Where("deleted_at IS NULL")
+	if modelNameLike != "" {
+		m = m.WhereLike(entity.AsynchTaskCol.ModelName, "%"+modelNameLike+"%")
+	}
+	if taskIDLike != "" {
+		m = m.WhereLike(entity.AsynchTaskCol.TaskID, "%"+taskIDLike+"%")
+	}
+	if state != nil {
+		m = m.Where(entity.AsynchTaskCol.State, *state)
+	}
+	m = m.OrderDesc(entity.AsynchTaskCol.CreatedAt)
+	if pageNum > 0 && pageSize > 0 {
+		m = m.Page(pageNum, pageSize)
+	}
+	r, totalInt, err := m.AllAndCount(false)
+	if err != nil {
+		return nil, 0, err
+	}
+	total = gconv.Int64(totalInt)
+	err = r.Structs(&list)
+	return
+}
+
+// ClaimPending 抢占 pending 任务（state=0），并在同一事务中更新为 running（state=1）
+// 使用 PostgreSQL: FOR UPDATE SKIP LOCKED 避免多 worker 重复消费
+func (d *taskDao) ClaimPending(ctx context.Context, batchSize int) (tasks []*entity.AsynchTask, err error) {
+	if batchSize <= 0 {
+		batchSize = 1
+	}
+	err = gfdb.DB(ctx).Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		sql := fmt.Sprintf(
+			`SELECT id, tenant_id, model_name, task_id, input_ref, request_payload
+			   FROM %s
+			  WHERE deleted_at IS NULL AND state = 0
+			  ORDER BY created_at ASC
+			  LIMIT %d
+			  FOR UPDATE SKIP LOCKED`,
+			public.TableNameTask,
+			batchSize,
+		)
+		r, err := tx.GetAll(sql)
+		if err != nil {
+			return err
+		}
+		if r.IsEmpty() {
+			tasks = nil
+			return nil
+		}
+		if err := r.Structs(&tasks); err != nil {
+			return err
+		}
+		// 更新为 running
+		now := time.Now()
+		for _, t := range tasks {
+			// tx.Model 不走 gfdb Hook，这里手动更新必要字段
+			_, err = tx.Exec(
+				fmt.Sprintf(`UPDATE %s SET state=1, started_at=?, updated_at=? WHERE id=?`, public.TableNameTask),
+				now, now, t.Id,
+			)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return
+}
+
+// ListExpiredSuccess 获取已成功且过期的任务
+func (d *taskDao) ListExpiredSuccess(ctx context.Context, limit int) (list []*entity.AsynchTask, err error) {
+	if limit <= 0 {
+		limit = 100
+	}
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		Where(entity.AsynchTaskCol.State, 2).
+		Where(entity.AsynchTaskCol.ExpireAt+" IS NOT NULL").
+		Where(entity.AsynchTaskCol.ExpireAt+" < ?", gtime.Now()).
+		Limit(limit).
+		All()
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
+
+// ListTimeoutTasks 获取超时的排队/执行中任务
+func (d *taskDao) ListTimeoutTasks(ctx context.Context, timeout time.Duration, limit int) (list []*entity.AsynchTask, err error) {
+	if limit <= 0 {
+		limit = 100
+	}
+	deadline := gtime.New(time.Now().Add(-timeout))
+	r, err := gfdb.DB(ctx).Model(ctx, public.TableNameTask).
+		WhereIn(entity.AsynchTaskCol.State, []int{0, 1}).
+		Where(entity.AsynchTaskCol.UpdatedAt+" < ?", deadline).
+		Limit(limit).
+		All()
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
+
+// DebugPing 用于启动时检测数据库连通性（可选）
+func (d *taskDao) DebugPing(ctx context.Context) error {
+	_, err := gfdb.DB(ctx).GetAll(ctx, "SELECT 1")
+	return err
+}
--- a/dao/task_dao_bg.go
+++ b/dao/task_dao_bg.go
@@ -0,0 +1,248 @@
+package dao
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"model-asynch/consts/public"
+	"model-asynch/model/entity"
+
+	"gitea.com/red-future/common/db/gfdb"
+	"github.com/gogf/gf/v2/database/gdb"
+	"github.com/gogf/gf/v2/os/gtime"
+)
+
+// ClaimPendingGlobal 后台任务使用：全局抢占 pending 任务（不加 tenant 过滤）
+func (d *taskDao) ClaimPendingGlobal(ctx context.Context, batchSize int) (tasks []*entity.AsynchTask, err error) {
+	if batchSize <= 0 {
+		batchSize = 1
+	}
+	err = gfdb.DB(ctx).Transaction(ctx, func(ctx context.Context, tx gdb.TX) error {
+		sql := fmt.Sprintf(
+			`SELECT id, tenant_id, creator, model_name, task_id, model_key, input_ref, request_payload, phase, tmp_file
+			   FROM %s
+			  WHERE deleted_at IS NULL AND state = 0
+			  ORDER BY enqueue_at ASC
+			  LIMIT %d
+			  FOR UPDATE SKIP LOCKED`,
+			public.TableNameTask,
+			batchSize,
+		)
+		r, err := tx.GetAll(sql)
+		if err != nil {
+			return err
+		}
+		if r.IsEmpty() {
+			tasks = nil
+			return nil
+		}
+		if err := r.Structs(&tasks); err != nil {
+			return err
+		}
+		now := time.Now()
+		for _, t := range tasks {
+			_, err = tx.Exec(
+				fmt.Sprintf(`UPDATE %s SET state=1, started_at=?, updated_at=? WHERE id=?`, public.TableNameTask),
+				now, now, t.Id,
+			)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	return
+}
+
+func (d *taskDao) UpdateSuccessGlobal(ctx context.Context, id int64, ossFile, fileType string, fileSize int64, expireAt *gtime.Time) error {
+	now := gtime.Now()
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s
+SET state=2,
+    oss_file=?,
+    file_type=?,
+    file_size=?,
+    error_msg='',
+    finished_at=?,
+    duration_seconds=EXTRACT(EPOCH FROM (? - created_at))::BIGINT,
+    expire_at=NULL,
+    phase=0,
+    tmp_file='',
+    updated_at=?
+WHERE id=?`, public.TableNameTask),
+		ossFile, fileType, fileSize, now, now, now, id,
+	)
+	return err
+}
+
+func (d *taskDao) UpdateFailedGlobal(ctx context.Context, id int64, errorMsg string) error {
+	now := gtime.Now()
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s
+SET state=3,
+    error_msg=?,
+    finished_at=?,
+    duration_seconds=EXTRACT(EPOCH FROM (? - created_at))::BIGINT,
+    phase=0,
+    tmp_file='',
+    updated_at=?
+WHERE id=?`, public.TableNameTask),
+		errorMsg, now, now, now, id,
+	)
+	return err
+}
+
+// UpdateFailedKeepTmpGlobal OSS 上传失败：保留 phase/tmp_file，下一轮仅重试 OSS 上传
+func (d *taskDao) UpdateFailedKeepTmpGlobal(ctx context.Context, id int64, errorMsg string) error {
+	now := gtime.Now()
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s SET state=3, error_msg=?, finished_at=?, phase=1, updated_at=? WHERE id=?`, public.TableNameTask),
+		errorMsg, now, now, id,
+	)
+	return err
+}
+
+// UpdateTmpAfterModelGlobal 模型调用成功后，写入临时文件路径并标记 phase=1
+func (d *taskDao) UpdateTmpAfterModelGlobal(ctx context.Context, id int64, tmpFile string) error {
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s SET phase=1, tmp_file=?, updated_at=NOW() WHERE id=?`, public.TableNameTask),
+		tmpFile, id,
+	)
+	return err
+}
+
+func (d *taskDao) SoftDeleteByTaskIDGlobal(ctx context.Context, taskID string) error {
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s SET deleted_at=NOW(), updated_at=NOW() WHERE task_id=? AND deleted_at IS NULL`, public.TableNameTask),
+		taskID,
+	)
+	return err
+}
+
+func (d *taskDao) RollbackToPendingGlobal(ctx context.Context, id int64) error {
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s SET state=0, enqueue_at=NOW(), updated_at=NOW() WHERE id=? AND state=1`, public.TableNameTask),
+		id,
+	)
+	return err
+}
+
+// ListExpiredDownloadedGlobal 获取已下载(state=4)且过期的任务，用于清理
+func (d *taskDao) ListExpiredDownloadedGlobal(ctx context.Context, limit int) (list []*entity.AsynchTask, err error) {
+	if limit <= 0 {
+		limit = 200
+	}
+	r, err := gfdb.DB(ctx).GetAll(ctx,
+		fmt.Sprintf(`SELECT * FROM %s WHERE deleted_at IS NULL AND state=4 AND expire_at IS NOT NULL AND expire_at < ? LIMIT ?`, public.TableNameTask),
+		gtime.Now(), limit,
+	)
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
+
+// ListFailedRetryableGlobal 获取失败(state=3)且仍可重试的任务
+// retry_count 不含首次执行；retry_times 表示失败后最多再重试 N 次
+func (d *taskDao) ListFailedRetryableGlobal(ctx context.Context, limit int) (list []*entity.AsynchTask, err error) {
+	if limit <= 0 {
+		limit = 200
+	}
+	r, err := gfdb.DB(ctx).GetAll(ctx,
+		fmt.Sprintf(`
+SELECT t.*,
+       m.retry_queue_max_seconds AS retry_queue_max_seconds
+  FROM %s t
+  JOIN %s m
+    ON t.tenant_id = m.tenant_id
+   AND t.model_name = m.model_name
+ WHERE t.deleted_at IS NULL
+   AND t.state = 3
+   AND t.retry_count < m.retry_times
+ ORDER BY t.updated_at ASC
+ LIMIT ?`, public.TableNameTask, public.TableNameModel),
+		limit,
+	)
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
+
+// RequeueForRetryGlobal 将任务重新入队（state=0），并将 retry_count +1
+// enqueueAt 用于控制重试任务在队列中的位置：
+// - enqueueAt 越早，越靠前（ClaimPendingGlobal 按 enqueue_at ASC 抢占）
+func (d *taskDao) RequeueForRetryGlobal(ctx context.Context, id int64, enqueueAt time.Time) error {
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`UPDATE %s SET state=0, retry_count=retry_count+1, enqueue_at=?, updated_at=NOW() WHERE id=? AND state=3 AND deleted_at IS NULL`, public.TableNameTask),
+		enqueueAt, id,
+	)
+	return err
+}
+
+// ListFailedExhaustedGlobal 获取失败(state=3)且超过重试次数的任务，用于硬删除
+func (d *taskDao) ListFailedExhaustedGlobal(ctx context.Context, limit int) (list []*entity.AsynchTask, err error) {
+	if limit <= 0 {
+		limit = 200
+	}
+	r, err := gfdb.DB(ctx).GetAll(ctx,
+		fmt.Sprintf(`
+SELECT t.*
+  FROM %s t
+  JOIN %s m
+    ON t.tenant_id = m.tenant_id
+   AND t.model_name = m.model_name
+ WHERE t.deleted_at IS NULL
+   AND t.state = 3
+   AND t.retry_count >= m.retry_times
+ ORDER BY t.updated_at ASC
+ LIMIT ?`, public.TableNameTask, public.TableNameModel),
+		limit,
+	)
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}
+
+// HardDeleteByIDGlobal 硬删除任务记录
+func (d *taskDao) HardDeleteByIDGlobal(ctx context.Context, id int64) error {
+	_, err := gfdb.DB(ctx).Exec(ctx,
+		fmt.Sprintf(`DELETE FROM %s WHERE id=?`, public.TableNameTask),
+		id,
+	)
+	return err
+}
+
+// ListTimeoutTasksGlobal 根据模型配置 expected_seconds 判定超时任务：
+// - state in (0,1)
+// - 模型 expected_seconds > 0
+// - now - created_at >= expected_seconds
+func (d *taskDao) ListTimeoutTasksGlobal(ctx context.Context, limit int) (list []*entity.AsynchTask, err error) {
+	if limit <= 0 {
+		limit = 200
+	}
+	r, err := gfdb.DB(ctx).GetAll(ctx,
+		fmt.Sprintf(`
+SELECT t.*
+  FROM %s t
+  JOIN %s m
+    ON t.tenant_id = m.tenant_id
+   AND t.model_name = m.model_name
+ WHERE t.deleted_at IS NULL
+   AND t.state IN (0,1)
+   AND m.expected_seconds > 0
+   AND t.created_at < (NOW() - (m.expected_seconds || ' seconds')::interval)
+ LIMIT ?`, public.TableNameTask, public.TableNameModel),
+		limit,
+	)
+	if err != nil {
+		return nil, err
+	}
+	err = r.Structs(&list)
+	return
+}