feat(desktop): drop parked review flow, add publish management

SaaS 侧人工审核后才创建 publish job，desktop 不再做二次审核：移除 manual/waiting_user/parked/from_parked 状态机与 LeaseFromParked 查询， desktop client 只执行发布并新增"发布管理"页（待发布队列 / 历史 / 再次发送）。同时抽离 @geo/publisher-platforms 共享适配器包、新增 Redis-based desktop_presence 与 publish_record_support，刷新 admin-web 发布弹窗与媒体库；plan A / spec 文档同步口径。
2026-04-20 09:52:48 +08:00
parent b16e9f0bd1
commit a617d39a4a
93 changed files with 5519 additions and 3594 deletions
@@ -9,28 +9,39 @@ import (

 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgtype"
+	"github.com/jackc/pgx/v5/pgxpool"
 	"go.uber.org/zap"

 	"github.com/geo-platform/tenant-api/internal/shared/auth"
+	sharedcache "github.com/geo-platform/tenant-api/internal/shared/cache"
 	"github.com/geo-platform/tenant-api/internal/shared/messaging/rabbitmq"
 	"github.com/geo-platform/tenant-api/internal/shared/response"
 	"github.com/geo-platform/tenant-api/internal/tenant/repository"
 )

 type DesktopTaskService struct {
+	pool      *pgxpool.Pool
 	repo      repository.DesktopTaskRepository
+	cache     sharedcache.Cache
 	messaging *rabbitmq.Client
 	logger    *zap.Logger
 }

-func NewDesktopTaskService(repo repository.DesktopTaskRepository, messaging *rabbitmq.Client, logger *zap.Logger) *DesktopTaskService {
+func NewDesktopTaskService(pool *pgxpool.Pool, messaging *rabbitmq.Client, logger *zap.Logger) *DesktopTaskService {
 	return &DesktopTaskService{
-		repo:      repo,
+		pool:      pool,
+		repo:      repository.NewDesktopTaskRepository(pool),
 		messaging: messaging,
 		logger:    logger,
 	}
 }

+func (s *DesktopTaskService) WithCache(c sharedcache.Cache) *DesktopTaskService {
+	s.cache = c
+	return s
+}
+
 type DesktopTaskView struct {
 	ID              string          `json:"id"`
 	JobID           string          `json:"job_id"`
@@ -46,7 +57,6 @@ type DesktopTaskView struct {
 	ActiveAttemptID *string         `json:"active_attempt_id"`
 	LeaseExpiresAt  *time.Time      `json:"lease_expires_at"`
 	Attempts        int             `json:"attempts"`
-	ParkedReason    *string         `json:"parked_reason"`
 	Result          json.RawMessage `json:"result"`
 	Error           json.RawMessage `json:"error"`
 	CreatedAt       time.Time       `json:"created_at"`
@@ -69,11 +79,6 @@ type ExtendDesktopTaskRequest struct {
 	LeaseToken string `json:"lease_token" binding:"required"`
 }

-type ParkDesktopTaskRequest struct {
-	LeaseToken string `json:"lease_token" binding:"required"`
-	Reason     string `json:"reason" binding:"required,oneof=waiting_user captcha"`
-}
-
 type CompleteDesktopTaskRequest struct {
 	LeaseToken string         `json:"lease_token" binding:"required"`
 	Status     string         `json:"status" binding:"required,oneof=succeeded failed unknown"`
@@ -92,7 +97,22 @@ type ReconcileDesktopTaskRequest struct {
 	Error  map[string]any `json:"error"`
 }

-func (s *DesktopTaskService) Lease(ctx context.Context, client *repository.DesktopClient, req LeaseDesktopTaskRequest, routeTaskID *uuid.UUID, fromParked bool) (*LeaseDesktopTaskResponse, error) {
+type ListPublishTasksRequest struct {
+	Page     int    `form:"page"`
+	PageSize int    `form:"page_size"`
+	Title    string `form:"title"`
+}
+
+type DesktopPublishTaskList struct {
+	Items        []DesktopTaskView `json:"items"`
+	Page         int               `json:"page"`
+	PageSize     int               `json:"page_size"`
+	Total        int               `json:"total"`
+	PendingCount int               `json:"pending_count"`
+	HistoryTotal int               `json:"history_total"`
+}
+
+func (s *DesktopTaskService) Lease(ctx context.Context, client *repository.DesktopClient, req LeaseDesktopTaskRequest, routeTaskID *uuid.UUID) (*LeaseDesktopTaskResponse, error) {
 	if client == nil {
 		return nil, response.ErrUnauthorized(40108, "desktop_client_missing", "desktop client context is required")
 	}
@@ -119,11 +139,6 @@ func (s *DesktopTaskService) Lease(ctx context.Context, client *repository.Deskt

 	var task *repository.DesktopTask
 	switch {
-	case fromParked:
-		if taskID == nil {
-			return nil, response.ErrBadRequest(40085, "missing_desktop_task_id", "task id is required when from_parked=true")
-		}
-		task, err = s.repo.LeaseParked(ctx, *taskID, client.ID, leaseParams)
 	case taskID != nil:
 		task, err = s.repo.LeaseQueuedByDesktopID(ctx, *taskID, client.ID, leaseParams)
 	default:
@@ -131,10 +146,10 @@ func (s *DesktopTaskService) Lease(ctx context.Context, client *repository.Deskt
 	}
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
-			if taskID == nil && !fromParked {
+			if taskID == nil {
 				return &LeaseDesktopTaskResponse{}, nil
 			}
-			return nil, s.classifyLeaseError(ctx, client, taskID, fromParked)
+			return nil, s.classifyLeaseError(ctx, client, taskID)
 		}
 		return nil, response.ErrInternal(50088, "desktop_task_lease_failed", "failed to lease desktop task")
 	}
@@ -179,46 +194,11 @@ func (s *DesktopTaskService) Extend(ctx context.Context, client *repository.Desk
 	return &view, nil
 }

-func (s *DesktopTaskService) Park(ctx context.Context, client *repository.DesktopClient, desktopID uuid.UUID, req ParkDesktopTaskRequest) (*DesktopTaskView, error) {
-	if client == nil {
-		return nil, response.ErrUnauthorized(40108, "desktop_client_missing", "desktop client context is required")
-	}
-
-	previousTask, _ := s.repo.GetByDesktopID(ctx, desktopID, client.WorkspaceID)
-	previousAttemptID := activeAttemptID(previousTask)
-
-	task, err := s.repo.Park(ctx, desktopID, HashDesktopClientToken(strings.TrimSpace(req.LeaseToken)), req.Reason)
-	if err != nil {
-		if errors.Is(err, pgx.ErrNoRows) {
-			return nil, response.ErrConflict(40983, "desktop_task_lease_invalid", "desktop task lease token is invalid or expired")
-		}
-		return nil, response.ErrInternal(50090, "desktop_task_park_failed", "failed to park desktop task")
-	}
-
-	if previousAttemptID != nil {
-		if finishErr := s.repo.FinishAttempt(ctx, repository.FinishDesktopTaskAttemptParams{
-			TaskID:      task.DesktopID,
-			AttemptID:   *previousAttemptID,
-			FinalStatus: literalStringPtr("waiting_user"),
-		}); finishErr != nil {
-			s.logWarn("desktop task attempt finish failed after park", finishErr, zap.String("task_id", task.DesktopID.String()))
-		}
-	}
-
-	s.publishTaskEvent(ctx, task, "task_parked")
-
-	view := buildDesktopTaskView(task)
-	return &view, nil
-}
-
 func (s *DesktopTaskService) Complete(ctx context.Context, client *repository.DesktopClient, desktopID uuid.UUID, req CompleteDesktopTaskRequest) (*DesktopTaskView, error) {
 	if client == nil {
 		return nil, response.ErrUnauthorized(40108, "desktop_client_missing", "desktop client context is required")
 	}

-	previousTask, _ := s.repo.GetByDesktopID(ctx, desktopID, client.WorkspaceID)
-	previousAttemptID := activeAttemptID(previousTask)
-
 	resultJSON, err := marshalOptionalJSON(req.Payload)
 	if err != nil {
 		return nil, response.ErrBadRequest(40086, "invalid_desktop_task_payload", "payload must be serializable")
@@ -228,7 +208,17 @@ func (s *DesktopTaskService) Complete(ctx context.Context, client *repository.De
 		return nil, response.ErrBadRequest(40087, "invalid_desktop_task_error", "error must be serializable")
 	}

-	task, err := s.repo.Complete(ctx, desktopID, HashDesktopClientToken(strings.TrimSpace(req.LeaseToken)), req.Status, resultJSON, errorJSON)
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50103, "desktop_task_complete_begin_failed", "failed to start desktop task completion")
+	}
+	defer tx.Rollback(ctx)
+
+	taskRepo := repository.NewDesktopTaskRepository(tx)
+	previousTask, _ := taskRepo.GetByDesktopID(ctx, desktopID, client.WorkspaceID)
+	previousAttemptID := activeAttemptID(previousTask)
+
+	task, err := taskRepo.Complete(ctx, desktopID, HashDesktopClientToken(strings.TrimSpace(req.LeaseToken)), req.Status, resultJSON, errorJSON)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, response.ErrConflict(40983, "desktop_task_lease_invalid", "desktop task lease token is invalid or expired")
@@ -237,7 +227,7 @@ func (s *DesktopTaskService) Complete(ctx context.Context, client *repository.De
 	}

 	if previousAttemptID != nil {
-		if finishErr := s.repo.FinishAttempt(ctx, repository.FinishDesktopTaskAttemptParams{
+		if finishErr := taskRepo.FinishAttempt(ctx, repository.FinishDesktopTaskAttemptParams{
 			TaskID:      task.DesktopID,
 			AttemptID:   *previousAttemptID,
 			FinalStatus: &req.Status,
@@ -247,6 +237,19 @@ func (s *DesktopTaskService) Complete(ctx context.Context, client *repository.De
 		}
 	}

+	publishOutcome, err := syncDesktopPublishTaskState(ctx, tx, task)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50104, "desktop_task_complete_commit_failed", "failed to commit desktop task completion")
+	}
+
+	if publishOutcome != nil {
+		invalidateArticleCaches(ctx, s.cache, publishOutcome.TenantID, &publishOutcome.ArticleID)
+	}
+
 	s.publishTaskEvent(ctx, task, "task_completed")

 	view := buildDesktopTaskView(task)
@@ -340,7 +343,14 @@ func (s *DesktopTaskService) Reconcile(ctx context.Context, actor auth.Actor, de
 		return nil, response.ErrBadRequest(40090, "invalid_desktop_task_reconcile_error", "error must be serializable")
 	}

-	task, err := s.repo.Reconcile(ctx, desktopID, actor.PrimaryWorkspaceID, req.Status, resultJSON, errorJSON)
+	tx, err := s.pool.Begin(ctx)
+	if err != nil {
+		return nil, response.ErrInternal(50105, "desktop_task_reconcile_begin_failed", "failed to start desktop task reconcile")
+	}
+	defer tx.Rollback(ctx)
+
+	taskRepo := repository.NewDesktopTaskRepository(tx)
+	task, err := taskRepo.Reconcile(ctx, desktopID, actor.PrimaryWorkspaceID, req.Status, resultJSON, errorJSON)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, response.ErrConflict(40985, "desktop_task_reconcile_conflict", "desktop task is not waiting for reconcile")
@@ -348,13 +358,280 @@ func (s *DesktopTaskService) Reconcile(ctx context.Context, actor auth.Actor, de
 		return nil, response.ErrInternal(50094, "desktop_task_reconcile_failed", "failed to reconcile desktop task")
 	}

+	publishOutcome, err := syncDesktopPublishTaskState(ctx, tx, task)
+	if err != nil {
+		return nil, err
+	}
+
+	if err := tx.Commit(ctx); err != nil {
+		return nil, response.ErrInternal(50106, "desktop_task_reconcile_commit_failed", "failed to commit desktop task reconcile")
+	}
+
+	if publishOutcome != nil {
+		invalidateArticleCaches(ctx, s.cache, publishOutcome.TenantID, &publishOutcome.ArticleID)
+	}
+
 	s.publishTaskEvent(ctx, task, "task_reconciled")

 	view := buildDesktopTaskView(task)
 	return &view, nil
 }

-func (s *DesktopTaskService) classifyLeaseError(ctx context.Context, client *repository.DesktopClient, taskID *uuid.UUID, fromParked bool) error {
+func (s *DesktopTaskService) ListPublishTasks(ctx context.Context, client *repository.DesktopClient, req ListPublishTasksRequest) (*DesktopPublishTaskList, error) {
+	if client == nil {
+		return nil, response.ErrUnauthorized(40108, "desktop_client_missing", "desktop client context is required")
+	}
+	if s.pool == nil {
+		return nil, response.ErrServiceUnavailable(50342, "desktop_publish_job_store_unavailable", "desktop publish job store is unavailable")
+	}
+
+	page := req.Page
+	if page <= 0 {
+		page = 1
+	}
+	pageSize := req.PageSize
+	if pageSize <= 0 || pageSize > 50 {
+		pageSize = 10
+	}
+
+	title := strings.TrimSpace(req.Title)
+	pendingStatuses := []string{"queued", "in_progress"}
+	historyStatuses := []string{"succeeded", "failed", "unknown", "aborted"}
+
+	pendingItems, err := s.listPublishTasksByStatuses(
+		ctx,
+		client,
+		pendingStatuses,
+		title,
+		0,
+		0,
+		`CASE WHEN status = 'in_progress' THEN 0 ELSE 1 END ASC, created_at ASC, desktop_id DESC`,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	historyTotal, err := s.countPublishTasksByStatuses(ctx, client, historyStatuses, title)
+	if err != nil {
+		return nil, err
+	}
+
+	offset := (page - 1) * pageSize
+	items := make([]DesktopTaskView, 0, pageSize)
+	total := len(pendingItems) + historyTotal
+
+	if offset < len(pendingItems) {
+		end := offset + pageSize
+		if end > len(pendingItems) {
+			end = len(pendingItems)
+		}
+		items = append(items, pendingItems[offset:end]...)
+	}
+
+	remaining := pageSize - len(items)
+	historyOffset := offset - len(pendingItems)
+	if historyOffset < 0 {
+		historyOffset = 0
+	}
+
+	if remaining > 0 && historyOffset < historyTotal {
+		historyItems, listErr := s.listPublishTasksByStatuses(
+			ctx,
+			client,
+			historyStatuses,
+			title,
+			remaining,
+			historyOffset,
+			`updated_at DESC, desktop_id DESC`,
+		)
+		if listErr != nil {
+			return nil, listErr
+		}
+		items = append(items, historyItems...)
+	}
+
+	return &DesktopPublishTaskList{
+		Items:        items,
+		Page:         page,
+		PageSize:     pageSize,
+		Total:        total,
+		PendingCount: len(pendingItems),
+		HistoryTotal: historyTotal,
+	}, nil
+}
+
+func (s *DesktopTaskService) listPublishTasksByStatuses(
+	ctx context.Context,
+	client *repository.DesktopClient,
+	statuses []string,
+	title string,
+	limit int,
+	offset int,
+	orderBy string,
+) ([]DesktopTaskView, error) {
+	query := `
+		SELECT
+			desktop_id,
+			job_id,
+			tenant_id,
+			workspace_id,
+			target_account_id,
+			target_client_id,
+			platform_id,
+			kind,
+			payload,
+			status,
+			dedup_key,
+			active_attempt_id,
+			lease_expires_at,
+			attempts,
+			result,
+			error,
+			created_at,
+			updated_at
+		FROM desktop_tasks
+		WHERE workspace_id = $1
+		  AND target_client_id = $2
+		  AND kind = 'publish'
+		  AND status = ANY($3)
+		  AND ($4 = '' OR COALESCE(payload->>'title', '') ILIKE '%' || $4 || '%')
+	`
+	args := []any{client.WorkspaceID, client.ID, statuses, title}
+
+	if strings.TrimSpace(orderBy) != "" {
+		query += "\nORDER BY " + orderBy
+	}
+	if limit > 0 {
+		query += "\nLIMIT $5 OFFSET $6"
+		args = append(args, limit, offset)
+	}
+
+	rows, err := s.pool.Query(ctx, query, args...)
+	if err != nil {
+		return nil, response.ErrInternal(50109, "desktop_publish_tasks_query_failed", "failed to list desktop publish tasks")
+	}
+	defer rows.Close()
+
+	return scanDesktopTaskRows(rows)
+}
+
+func (s *DesktopTaskService) countPublishTasksByStatuses(
+	ctx context.Context,
+	client *repository.DesktopClient,
+	statuses []string,
+	title string,
+) (int, error) {
+	var count int
+	err := s.pool.QueryRow(ctx, `
+		SELECT COUNT(1)
+		FROM desktop_tasks
+		WHERE workspace_id = $1
+		  AND target_client_id = $2
+		  AND kind = 'publish'
+		  AND status = ANY($3)
+		  AND ($4 = '' OR COALESCE(payload->>'title', '') ILIKE '%' || $4 || '%')
+	`, client.WorkspaceID, client.ID, statuses, title).Scan(&count)
+	if err != nil {
+		return 0, response.ErrInternal(50109, "desktop_publish_tasks_query_failed", "failed to list desktop publish tasks")
+	}
+	return count, nil
+}
+
+func scanDesktopTaskRows(rows pgx.Rows) ([]DesktopTaskView, error) {
+	items := make([]DesktopTaskView, 0)
+	for rows.Next() {
+		var (
+			desktopID       uuid.UUID
+			jobID           uuid.UUID
+			tenantID        int64
+			workspaceID     int64
+			targetAccountID uuid.UUID
+			targetClientID  uuid.UUID
+			platform        string
+			kind            string
+			payload         []byte
+			status          string
+			dedupKey        pgtype.Text
+			activeAttemptID pgtype.UUID
+			leaseExpiresAt  pgtype.Timestamptz
+			attempts        int32
+			resultJSON      []byte
+			errorJSON       []byte
+			createdAt       time.Time
+			updatedAt       time.Time
+		)
+		if err := rows.Scan(
+			&desktopID,
+			&jobID,
+			&tenantID,
+			&workspaceID,
+			&targetAccountID,
+			&targetClientID,
+			&platform,
+			&kind,
+			&payload,
+			&status,
+			&dedupKey,
+			&activeAttemptID,
+			&leaseExpiresAt,
+			&attempts,
+			&resultJSON,
+			&errorJSON,
+			&createdAt,
+			&updatedAt,
+		); err != nil {
+			return nil, response.ErrInternal(50110, "desktop_publish_tasks_scan_failed", "failed to scan desktop publish tasks")
+		}
+
+		var dedupKeyText *string
+		if dedupKey.Valid {
+			value := dedupKey.String
+			dedupKeyText = &value
+		}
+
+		var activeAttemptIDText *string
+		if activeAttemptID.Valid {
+			value, convErr := uuid.FromBytes(activeAttemptID.Bytes[:])
+			if convErr == nil {
+				text := value.String()
+				activeAttemptIDText = &text
+			}
+		}
+
+		var leaseExpiresAtValue *time.Time
+		if leaseExpiresAt.Valid {
+			value := leaseExpiresAt.Time
+			leaseExpiresAtValue = &value
+		}
+
+		items = append(items, DesktopTaskView{
+			ID:              desktopID.String(),
+			JobID:           jobID.String(),
+			TenantID:        tenantID,
+			WorkspaceID:     workspaceID,
+			TargetAccountID: targetAccountID.String(),
+			TargetClientID:  targetClientID.String(),
+			Platform:        platform,
+			Kind:            kind,
+			Payload:         json.RawMessage(payload),
+			Status:          status,
+			DedupKey:        dedupKeyText,
+			ActiveAttemptID: activeAttemptIDText,
+			LeaseExpiresAt:  leaseExpiresAtValue,
+			Attempts:        int(attempts),
+			Result:          json.RawMessage(resultJSON),
+			Error:           json.RawMessage(errorJSON),
+			CreatedAt:       createdAt,
+			UpdatedAt:       updatedAt,
+		})
+	}
+	if err := rows.Err(); err != nil {
+		return nil, response.ErrInternal(50109, "desktop_publish_tasks_query_failed", "failed to list desktop publish tasks")
+	}
+	return items, nil
+}
+
+func (s *DesktopTaskService) classifyLeaseError(ctx context.Context, client *repository.DesktopClient, taskID *uuid.UUID) error {
 	if taskID == nil {
 		return response.ErrConflict(40986, "desktop_task_unavailable", "no desktop task is currently available")
 	}
@@ -371,19 +648,6 @@ func (s *DesktopTaskService) classifyLeaseError(ctx context.Context, client *rep
 		return response.ErrForbidden(40381, "desktop_task_not_target_client", "desktop task is assigned to another desktop client")
 	}

-	if fromParked {
-		switch task.Status {
-		case "aborted":
-			return response.ErrConflict(40987, "desktop_task_aborted", "desktop task has already been aborted")
-		case "succeeded", "failed", "unknown":
-			return response.ErrConflict(40988, "desktop_task_terminal", "desktop task is already in a terminal state")
-		case "in_progress":
-			return response.ErrConflict(40989, "desktop_task_already_in_progress", "desktop task is already in progress")
-		default:
-			return response.ErrConflict(40990, "desktop_task_not_parked", "desktop task is not waiting_user")
-		}
-	}
-
 	if task.Status == "in_progress" {
 		return response.ErrConflict(40989, "desktop_task_already_in_progress", "desktop task is already in progress")
 	}
@@ -413,7 +677,6 @@ func buildDesktopTaskView(task *repository.DesktopTask) DesktopTaskView {
 		ActiveAttemptID: activeAttemptID,
 		LeaseExpiresAt:  task.LeaseExpiresAt,
 		Attempts:        task.Attempts,
-		ParkedReason:    task.ParkedReason,
 		Result:          json.RawMessage(task.Result),
 		Error:           json.RawMessage(task.Error),
 		CreatedAt:       task.CreatedAt,