package app import ( "context" "encoding/json" "errors" "fmt" "strings" "time" "github.com/google/uuid" "github.com/jackc/pgx/v5" "github.com/jackc/pgx/v5/pgtype" "github.com/jackc/pgx/v5/pgxpool" "golang.org/x/sync/singleflight" "github.com/geo-platform/tenant-api/internal/shared/auditlog" "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/middleware" "github.com/geo-platform/tenant-api/internal/shared/response" sharedschedule "github.com/geo-platform/tenant-api/internal/shared/schedule" "github.com/geo-platform/tenant-api/internal/tenant/repository" ) type ScheduleTaskService struct { pool *pgxpool.Pool auditLogs *auditlog.AsyncWriter promptAsset *KolPromptAsset cache sharedcache.Cache cacheGroup singleflight.Group } func NewScheduleTaskService(pool *pgxpool.Pool, auditLogs *auditlog.AsyncWriter, promptAsset *KolPromptAsset) *ScheduleTaskService { return &ScheduleTaskService{pool: pool, auditLogs: auditLogs, promptAsset: promptAsset} } func (s *ScheduleTaskService) WithCache(c sharedcache.Cache) *ScheduleTaskService { s.cache = c return s } type ScheduleTaskRequest struct { TargetType string `json:"target_type"` PromptRuleID *int64 `json:"prompt_rule_id"` SubscriptionPromptID *int64 `json:"subscription_prompt_id"` BrandID *int64 `json:"brand_id"` Name string `json:"name" binding:"required"` CronExpr string `json:"cron_expr"` ScheduleKind string `json:"schedule_kind"` ScheduleDays []string `json:"schedule_days"` ScheduleTimeMode string `json:"schedule_time_mode"` RandomWindowStart string `json:"random_window_start"` RandomWindowEnd string `json:"random_window_end"` GenerationInput map[string]interface{} `json:"generation_input"` AutoPublish *bool `json:"auto_publish"` PublishAccountIDs []string `json:"publish_account_ids"` PublishEnterpriseSiteTargets []ScheduleEnterpriseSiteTarget `json:"publish_enterprise_site_targets"` CoverAssetURL *string `json:"cover_asset_url"` CoverImageAssetID *int64 `json:"cover_image_asset_id"` CoverMode string `json:"cover_mode"` CoverRandomScope string `json:"cover_random_scope"` CoverRandomFolderID *int64 `json:"cover_random_folder_id"` EnableWebSearch *bool `json:"enable_web_search"` GenerateCount *int `json:"generate_count"` StartAt *string `json:"start_at"` EndAt *string `json:"end_at"` } type ScheduleTaskResponse struct { ID int64 `json:"id"` WorkspaceID *int64 `json:"workspace_id"` TargetType string `json:"target_type"` PromptRuleID *int64 `json:"prompt_rule_id"` PromptRuleName *string `json:"prompt_rule_name"` SubscriptionPromptID *int64 `json:"subscription_prompt_id"` SubscriptionPromptName *string `json:"subscription_prompt_name"` SubscriptionPackageName *string `json:"subscription_package_name"` SubscriptionKolName *string `json:"subscription_kol_name"` BrandID *int64 `json:"brand_id"` BrandName *string `json:"brand_name"` Name string `json:"name"` CronExpr string `json:"cron_expr"` ScheduleKind string `json:"schedule_kind"` ScheduleDays []string `json:"schedule_days"` ScheduleTimeMode string `json:"schedule_time_mode"` RandomWindowStart string `json:"random_window_start"` RandomWindowEnd string `json:"random_window_end"` GenerationInput map[string]interface{} `json:"generation_input"` AutoPublish bool `json:"auto_publish"` PublishAccountIDs []string `json:"publish_account_ids"` PublishEnterpriseSiteTargets []ScheduleEnterpriseSiteTarget `json:"publish_enterprise_site_targets"` AutoPublishPlatforms []string `json:"auto_publish_platforms"` CoverAssetURL *string `json:"cover_asset_url"` CoverImageAssetID *int64 `json:"cover_image_asset_id"` CoverMode string `json:"cover_mode"` CoverRandomScope string `json:"cover_random_scope"` CoverRandomFolderID *int64 `json:"cover_random_folder_id"` EnableWebSearch bool `json:"enable_web_search"` GenerateCount int `json:"generate_count"` StartAt *string `json:"start_at"` EndAt *string `json:"end_at"` NextRunAt *string `json:"next_run_at"` Status string `json:"status"` LastRunAt *string `json:"last_run_at"` LastDispatchStatus *string `json:"last_dispatch_status"` LastDispatchError *string `json:"last_dispatch_error"` ConsecutiveFailures int `json:"consecutive_failures"` GenerationStatus *string `json:"generation_status"` ExecutionTime *string `json:"execution_time"` GeneratedArticles []InstantTaskArticleLink `json:"generated_articles"` CreatedAt string `json:"created_at"` UpdatedAt string `json:"updated_at"` } type ScheduleTaskListParams struct { PromptRuleID *int64 `json:"prompt_rule_id"` SubscriptionPromptID *int64 `json:"subscription_prompt_id"` TargetType *string `json:"target_type"` Status *string `json:"status"` Keyword *string `json:"keyword"` CreatedFrom *time.Time CreatedTo *time.Time Page int `json:"page"` PageSize int `json:"page_size"` } type ScheduleTaskListResponse struct { Items []ScheduleTaskResponse `json:"items"` Total int64 `json:"total"` } type ScheduleTaskStatusRequest struct { Status string `json:"status" binding:"required,oneof=enabled disabled"` } func (s *ScheduleTaskService) List(ctx context.Context, params ScheduleTaskListParams) (*ScheduleTaskListResponse, error) { actor := auth.MustActor(ctx) brandID, err := requireCurrentBrandID(ctx) if err != nil { return nil, err } return sharedcache.LoadJSON(ctx, s.cache, &s.cacheGroup, scheduleTaskListCacheKey(actor.TenantID, brandID, params), defaultCacheTTL(), func(loadCtx context.Context) (*ScheduleTaskListResponse, error) { return s.loadScheduleTasks(loadCtx, actor.TenantID, brandID, params) }) } func (s *ScheduleTaskService) Detail(ctx context.Context, id int64) (*ScheduleTaskResponse, error) { actor := auth.MustActor(ctx) brandID, err := requireCurrentBrandID(ctx) if err != nil { return nil, err } record, found, err := sharedcache.LoadJSONWithEmpty(ctx, s.cache, &s.cacheGroup, scheduleTaskDetailCacheKey(actor.TenantID, brandID, id), defaultCacheTTL(), defaultCacheEmptyTTL(), func(loadCtx context.Context) (*ScheduleTaskResponse, bool, error) { return s.loadScheduleTaskDetail(loadCtx, actor.TenantID, brandID, id) }) if err != nil { return nil, err } if !found || record == nil { return nil, response.ErrNotFound(40432, "schedule_not_found", "schedule task not found") } return record, nil } func (s *ScheduleTaskService) Create(ctx context.Context, req ScheduleTaskRequest) (*ScheduleTaskResponse, error) { actor := auth.MustActor(ctx) brandID, err := requireCurrentBrandID(ctx) if err != nil { return nil, err } req.BrandID = &brandID targetType, promptRuleID, subscriptionPromptID, err := normalizeScheduleTarget(req) if err != nil { return nil, err } plan, err := normalizeSchedulePlan(req) if err != nil { return nil, err } generationInput := clonePromptRuleExtraParams(req.GenerationInput) if targetType == ScheduleTargetPromptRule { if err := s.ensurePromptRuleExists(ctx, actor.TenantID, brandID, *promptRuleID); err != nil { return nil, err } generationInput = map[string]interface{}{} } else { generationInput, err = s.validateKolScheduleGenerationInput(ctx, actor.TenantID, *subscriptionPromptID, generationInput) if err != nil { return nil, err } } generateCount, err := normalizeScheduleGenerateCount(req.GenerateCount) if err != nil { return nil, err } enableWebSearch := boolValue(req.EnableWebSearch) publishConfig, err := s.normalizeAutoPublishConfig(ctx, actor, req) if err != nil { return nil, err } tx, err := s.pool.Begin(ctx) if err != nil { return nil, response.ErrInternal(50010, "create_failed", "failed to begin schedule task transaction") } defer tx.Rollback(ctx) var id int64 var createdAt time.Time var startAt pgtype.Timestamptz var endAt pgtype.Timestamptz var status string err = tx.QueryRow(ctx, ` INSERT INTO schedule_tasks ( tenant_id, workspace_id, operator_id, target_type, prompt_rule_id, subscription_prompt_id, brand_id, name, cron_expr, schedule_kind, schedule_days, schedule_time_mode, random_window_start, random_window_end, generation_input_json, enable_web_search, generate_count, auto_publish, publish_account_ids, publish_enterprise_site_targets, cover_asset_url, cover_image_asset_id, cover_mode, cover_random_scope, cover_random_folder_id, start_at, end_at ) VALUES ( $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11::jsonb, $12, $13::time, $14::time, $15::jsonb, $16, $17, $18, $19::jsonb, $20::jsonb, $21, $22, $23, $24, $25, $26::timestamptz, $27::timestamptz ) RETURNING id, created_at, start_at, end_at, status `, actor.TenantID, actor.PrimaryWorkspaceID, actor.UserID, targetType, promptRuleID, subscriptionPromptID, req.BrandID, req.Name, plan.CronExpr, plan.ScheduleKind, encodeScheduleDayKeys(plan.ScheduleDays), plan.ScheduleTimeMode, plan.RandomWindowStart, plan.RandomWindowEnd, encodeScheduleGenerationInput(generationInput), enableWebSearch, generateCount, publishConfig.AutoPublish, publishConfig.AccountIDsJSON, publishConfig.EnterpriseTargetsJSON, publishConfig.CoverAssetURL, publishConfig.CoverImageAssetID, publishConfig.CoverMode, publishConfig.CoverRandomScope, publishConfig.CoverRandomFolderID, req.StartAt, req.EndAt). Scan(&id, &createdAt, &startAt, &endAt, &status) if err != nil { return nil, response.ErrInternal(50010, "create_failed", "failed to create schedule task") } nextRunAt, err := computeScheduleNextRun(status, id, plan.CronExpr, plan.ScheduleDays, plan.ScheduleTimeMode, plan.RandomWindowStart, plan.RandomWindowEnd, timePtrFromTimestamp(startAt), timePtrFromTimestamp(endAt), time.Now()) if err != nil { return nil, response.ErrBadRequest(40015, "invalid_cron_expr", err.Error()) } if _, err := tx.Exec(ctx, ` UPDATE schedule_tasks SET next_run_at = $1, updated_at = NOW() WHERE id = $2 AND tenant_id = $3 `, nextRunAt, id, actor.TenantID); err != nil { return nil, response.ErrInternal(50010, "create_failed", "failed to initialize next run time") } if err := tx.Commit(ctx); err != nil { return nil, response.ErrInternal(50010, "create_failed", "failed to commit schedule task") } afterJSON, _ := json.Marshal(map[string]interface{}{ "id": id, "name": req.Name, "target_type": targetType, "cron_expr": plan.CronExpr, "schedule_days": plan.ScheduleDays, "schedule_time_mode": plan.ScheduleTimeMode, "enable_web_search": enableWebSearch, "generate_count": generateCount, "auto_publish": publishConfig.AutoPublish, }) result := "success" resourceType := "schedule_task" requestID := middleware.RequestIDFromContext(ctx) s.auditLogs.Log(auditlog.Entry{ OperatorID: actor.UserID, TenantID: &actor.TenantID, Module: "schedule_task", Action: "create", ResourceType: &resourceType, ResourceID: &id, RequestID: nilIfEmptyString(requestID), AfterJSON: afterJSON, Result: &result, }) invalidateScheduleTaskCaches(ctx, s.cache, actor.TenantID, &id) workspaceID := actor.PrimaryWorkspaceID return &ScheduleTaskResponse{ ID: id, WorkspaceID: &workspaceID, TargetType: targetType, PromptRuleID: promptRuleID, SubscriptionPromptID: subscriptionPromptID, BrandID: req.BrandID, Name: req.Name, CronExpr: plan.CronExpr, ScheduleKind: plan.ScheduleKind, ScheduleDays: plan.ScheduleDays, ScheduleTimeMode: plan.ScheduleTimeMode, RandomWindowStart: plan.RandomWindowStart, RandomWindowEnd: plan.RandomWindowEnd, GenerationInput: generationInput, AutoPublish: publishConfig.AutoPublish, PublishAccountIDs: publishConfig.AccountIDs, PublishEnterpriseSiteTargets: publishConfig.EnterpriseTargets, AutoPublishPlatforms: publishConfig.PlatformIDs, CoverAssetURL: publishConfig.CoverAssetURL, CoverImageAssetID: publishConfig.CoverImageAssetID, CoverMode: publishConfig.CoverMode, CoverRandomScope: publishConfig.CoverRandomScope, CoverRandomFolderID: publishConfig.CoverRandomFolderID, EnableWebSearch: enableWebSearch, GenerateCount: generateCount, Status: status, CreatedAt: timeStringFromDBValue(createdAt), NextRunAt: timeStringPtr(nextRunAt), }, nil } func (s *ScheduleTaskService) Update(ctx context.Context, id int64, req ScheduleTaskRequest) error { actor := auth.MustActor(ctx) brandID, err := requireCurrentBrandID(ctx) if err != nil { return err } req.BrandID = &brandID targetType, promptRuleID, subscriptionPromptID, err := normalizeScheduleTarget(req) if err != nil { return err } plan, err := normalizeSchedulePlan(req) if err != nil { return err } generationInput := clonePromptRuleExtraParams(req.GenerationInput) if targetType == ScheduleTargetPromptRule { if err := s.ensurePromptRuleExists(ctx, actor.TenantID, brandID, *promptRuleID); err != nil { return err } generationInput = map[string]interface{}{} } else { generationInput, err = s.validateKolScheduleGenerationInput(ctx, actor.TenantID, *subscriptionPromptID, generationInput) if err != nil { return err } } generateCount, err := normalizeScheduleGenerateCount(req.GenerateCount) if err != nil { return err } enableWebSearch := boolValue(req.EnableWebSearch) publishConfig, err := s.normalizeAutoPublishConfig(ctx, actor, req) if err != nil { return err } tx, err := s.pool.Begin(ctx) if err != nil { return response.ErrInternal(50010, "update_failed", "failed to begin schedule task transaction") } defer tx.Rollback(ctx) var status string var startAt pgtype.Timestamptz var endAt pgtype.Timestamptz err = tx.QueryRow(ctx, ` UPDATE schedule_tasks SET target_type = $1, prompt_rule_id = $2, subscription_prompt_id = $3, brand_id = $4, name = $5, cron_expr = $6, schedule_kind = $7, schedule_days = $8::jsonb, schedule_time_mode = $9, random_window_start = $10::time, random_window_end = $11::time, generation_input_json = $12::jsonb, enable_web_search = $13, generate_count = $14, workspace_id = $15, auto_publish = $16, publish_account_ids = $17::jsonb, publish_enterprise_site_targets = $18::jsonb, cover_asset_url = $19, cover_image_asset_id = $20, cover_mode = $21, cover_random_scope = $22, cover_random_folder_id = $23, start_at = $24::timestamptz, end_at = $25::timestamptz, operator_id = $26, last_dispatch_status = NULL, last_dispatch_error = NULL, consecutive_failures = 0, updated_at = NOW() WHERE id = $27 AND tenant_id = $28 AND brand_id = $29 AND deleted_at IS NULL RETURNING status, start_at, end_at `, targetType, promptRuleID, subscriptionPromptID, req.BrandID, req.Name, plan.CronExpr, plan.ScheduleKind, encodeScheduleDayKeys(plan.ScheduleDays), plan.ScheduleTimeMode, plan.RandomWindowStart, plan.RandomWindowEnd, encodeScheduleGenerationInput(generationInput), enableWebSearch, generateCount, actor.PrimaryWorkspaceID, publishConfig.AutoPublish, publishConfig.AccountIDsJSON, publishConfig.EnterpriseTargetsJSON, publishConfig.CoverAssetURL, publishConfig.CoverImageAssetID, publishConfig.CoverMode, publishConfig.CoverRandomScope, publishConfig.CoverRandomFolderID, req.StartAt, req.EndAt, actor.UserID, id, actor.TenantID, brandID). Scan(&status, &startAt, &endAt) if err != nil { return response.ErrNotFound(40432, "schedule_not_found", "schedule task not found") } nextRunAt, err := computeScheduleNextRun(status, id, plan.CronExpr, plan.ScheduleDays, plan.ScheduleTimeMode, plan.RandomWindowStart, plan.RandomWindowEnd, timePtrFromTimestamp(startAt), timePtrFromTimestamp(endAt), time.Now()) if err != nil { return response.ErrBadRequest(40015, "invalid_cron_expr", err.Error()) } if _, err := tx.Exec(ctx, ` UPDATE schedule_tasks SET next_run_at = $1, updated_at = NOW() WHERE id = $2 AND tenant_id = $3 `, nextRunAt, id, actor.TenantID); err != nil { return response.ErrInternal(50010, "update_failed", "failed to refresh next run time") } if err := tx.Commit(ctx); err != nil { return response.ErrInternal(50010, "update_failed", "failed to commit schedule task") } invalidateScheduleTaskCaches(ctx, s.cache, actor.TenantID, &id) return nil } func (s *ScheduleTaskService) Delete(ctx context.Context, id int64) error { actor := auth.MustActor(ctx) brandID, err := requireCurrentBrandID(ctx) if err != nil { return err } tag, err := s.pool.Exec(ctx, ` UPDATE schedule_tasks SET deleted_at = NOW(), updated_at = NOW() WHERE id = $1 AND tenant_id = $2 AND brand_id = $3 AND deleted_at IS NULL `, id, actor.TenantID, brandID) if err != nil || tag.RowsAffected() == 0 { return response.ErrNotFound(40432, "schedule_not_found", "schedule task not found") } afterJSON, _ := json.Marshal(map[string]interface{}{"id": id}) result := "success" resourceType := "schedule_task" requestID := middleware.RequestIDFromContext(ctx) s.auditLogs.Log(auditlog.Entry{ OperatorID: actor.UserID, TenantID: &actor.TenantID, Module: "schedule_task", Action: "delete", ResourceType: &resourceType, ResourceID: &id, RequestID: nilIfEmptyString(requestID), AfterJSON: afterJSON, Result: &result, }) invalidateScheduleTaskCaches(ctx, s.cache, actor.TenantID, &id) return nil } func (s *ScheduleTaskService) ToggleStatus(ctx context.Context, id int64, req ScheduleTaskStatusRequest) error { actor := auth.MustActor(ctx) brandID, err := requireCurrentBrandID(ctx) if err != nil { return err } tx, err := s.pool.Begin(ctx) if err != nil { return response.ErrInternal(50010, "update_failed", "failed to begin schedule task transaction") } defer tx.Rollback(ctx) var cronExpr string var status string var scheduleTimeMode string var randomWindowStart string var randomWindowEnd string var scheduleDaysJSON []byte var startAt pgtype.Timestamptz var endAt pgtype.Timestamptz err = tx.QueryRow(ctx, ` UPDATE schedule_tasks SET status = $1, operator_id = $2, updated_at = NOW() WHERE id = $3 AND tenant_id = $4 AND brand_id = $5 AND deleted_at IS NULL RETURNING cron_expr, status, schedule_days, schedule_time_mode, random_window_start::text, random_window_end::text, start_at, end_at `, req.Status, actor.UserID, id, actor.TenantID, brandID). Scan(&cronExpr, &status, &scheduleDaysJSON, &scheduleTimeMode, &randomWindowStart, &randomWindowEnd, &startAt, &endAt) if err != nil { return response.ErrNotFound(40432, "schedule_not_found", "schedule task not found") } nextRunAt, err := computeScheduleNextRun(status, id, cronExpr, decodeScheduleDayKeys(scheduleDaysJSON), scheduleTimeMode, randomWindowStart, randomWindowEnd, timePtrFromTimestamp(startAt), timePtrFromTimestamp(endAt), time.Now()) if err != nil { return response.ErrBadRequest(40015, "invalid_cron_expr", err.Error()) } if _, err := tx.Exec(ctx, ` UPDATE schedule_tasks SET next_run_at = $1, updated_at = NOW() WHERE id = $2 AND tenant_id = $3 `, nextRunAt, id, actor.TenantID); err != nil { return response.ErrInternal(50010, "update_failed", "failed to refresh next run time") } if err := tx.Commit(ctx); err != nil { return response.ErrInternal(50010, "update_failed", "failed to commit schedule task") } invalidateScheduleTaskCaches(ctx, s.cache, actor.TenantID, &id) return nil } func (s *ScheduleTaskService) loadScheduleTasks(ctx context.Context, tenantID, brandID int64, params ScheduleTaskListParams) (*ScheduleTaskListResponse, error) { if params.Page < 1 { params.Page = 1 } if params.PageSize < 1 || params.PageSize > 100 { params.PageSize = 20 } offset := (params.Page - 1) * params.PageSize var total int64 if err := s.pool.QueryRow(ctx, ` SELECT COUNT(*) FROM schedule_tasks WHERE tenant_id = $1 AND brand_id = $2 AND deleted_at IS NULL AND ($3::bigint IS NULL OR prompt_rule_id = $3) AND ($4::text IS NULL OR status = $4) AND ($5::text IS NULL OR name ILIKE '%' || $5 || '%') AND ($6::timestamptz IS NULL OR created_at >= $6) AND ($7::timestamptz IS NULL OR created_at <= $7) AND ($8::text IS NULL OR target_type = $8) AND ($9::bigint IS NULL OR subscription_prompt_id = $9) `, tenantID, brandID, params.PromptRuleID, params.Status, params.Keyword, params.CreatedFrom, params.CreatedTo, params.TargetType, params.SubscriptionPromptID).Scan(&total); err != nil { return nil, response.ErrInternal(50010, "count_failed", "failed to count schedule tasks") } rows, err := s.pool.Query(ctx, ` SELECT st.id, st.workspace_id, st.target_type, st.prompt_rule_id, st.subscription_prompt_id, st.brand_id, st.name, st.cron_expr, st.schedule_kind, st.schedule_days, st.schedule_time_mode, st.random_window_start::text, st.random_window_end::text, st.generation_input_json, st.auto_publish, st.publish_account_ids, st.publish_enterprise_site_targets, st.cover_asset_url, st.cover_image_asset_id, st.cover_mode, st.cover_random_scope, st.cover_random_folder_id, st.enable_web_search, st.generate_count, st.start_at, st.end_at, st.next_run_at, st.status, st.last_run_at, st.last_dispatch_status, st.last_dispatch_error, st.consecutive_failures, st.created_at, st.updated_at, pr.name AS prompt_rule_name, sp_prompt.name AS subscription_prompt_name, sp_pkg.name AS subscription_package_name, sp_profile.display_name AS subscription_kol_name, b.name AS brand_name FROM schedule_tasks st LEFT JOIN prompt_rules pr ON pr.id = st.prompt_rule_id LEFT JOIN kol_subscription_prompts sp ON sp.id = st.subscription_prompt_id LEFT JOIN kol_prompts sp_prompt ON sp_prompt.id = sp.prompt_id LEFT JOIN kol_packages sp_pkg ON sp_pkg.id = sp.package_id LEFT JOIN kol_profiles sp_profile ON sp_profile.id = sp_pkg.kol_profile_id LEFT JOIN brands b ON b.id = st.brand_id WHERE st.tenant_id = $1 AND st.brand_id = $2 AND st.deleted_at IS NULL AND ($3::bigint IS NULL OR st.prompt_rule_id = $3) AND ($4::text IS NULL OR st.status = $4) AND ($5::text IS NULL OR st.name ILIKE '%' || $5 || '%') AND ($6::timestamptz IS NULL OR st.created_at >= $6) AND ($7::timestamptz IS NULL OR st.created_at <= $7) AND ($10::text IS NULL OR st.target_type = $10) AND ($11::bigint IS NULL OR st.subscription_prompt_id = $11) ORDER BY st.created_at DESC LIMIT $8 OFFSET $9 `, tenantID, brandID, params.PromptRuleID, params.Status, params.Keyword, params.CreatedFrom, params.CreatedTo, params.PageSize, offset, params.TargetType, params.SubscriptionPromptID) if err != nil { return nil, response.ErrInternal(50010, "query_failed", "failed to list schedule tasks") } defer rows.Close() items := make([]ScheduleTaskResponse, 0) for rows.Next() { item, err := scanScheduleTaskResponse(rows) if err != nil { return nil, err } items = append(items, item) } if err := rows.Err(); err != nil { return nil, response.ErrInternal(50010, "scan_failed", "failed to iterate schedule tasks") } if err := s.populateScheduleTaskListDecorations(ctx, tenantID, items); err != nil { return nil, err } return &ScheduleTaskListResponse{Items: items, Total: total}, nil } func (s *ScheduleTaskService) loadScheduleTaskDetail(ctx context.Context, tenantID, brandID, taskID int64) (*ScheduleTaskResponse, bool, error) { row := s.pool.QueryRow(ctx, ` SELECT st.id, st.workspace_id, st.target_type, st.prompt_rule_id, st.subscription_prompt_id, st.brand_id, st.name, st.cron_expr, st.schedule_kind, st.schedule_days, st.schedule_time_mode, st.random_window_start::text, st.random_window_end::text, st.generation_input_json, st.auto_publish, st.publish_account_ids, st.publish_enterprise_site_targets, st.cover_asset_url, st.cover_image_asset_id, st.cover_mode, st.cover_random_scope, st.cover_random_folder_id, st.enable_web_search, st.generate_count, st.start_at, st.end_at, st.next_run_at, st.status, st.last_run_at, st.last_dispatch_status, st.last_dispatch_error, st.consecutive_failures, st.created_at, st.updated_at, pr.name AS prompt_rule_name, sp_prompt.name AS subscription_prompt_name, sp_pkg.name AS subscription_package_name, sp_profile.display_name AS subscription_kol_name, b.name AS brand_name FROM schedule_tasks st LEFT JOIN prompt_rules pr ON pr.id = st.prompt_rule_id LEFT JOIN kol_subscription_prompts sp ON sp.id = st.subscription_prompt_id LEFT JOIN kol_prompts sp_prompt ON sp_prompt.id = sp.prompt_id LEFT JOIN kol_packages sp_pkg ON sp_pkg.id = sp.package_id LEFT JOIN kol_profiles sp_profile ON sp_profile.id = sp_pkg.kol_profile_id LEFT JOIN brands b ON b.id = st.brand_id WHERE st.id = $1 AND st.tenant_id = $2 AND st.brand_id = $3 AND st.deleted_at IS NULL `, taskID, tenantID, brandID) item, err := scanScheduleTaskResponse(row) if err != nil { if errors.Is(err, pgx.ErrNoRows) { return nil, false, nil } return nil, false, err } if err := s.populateScheduleAutoPublishPlatforms(ctx, tenantID, &item); err != nil { return nil, false, err } if err := s.populateScheduleLatestGeneratedArticles(ctx, tenantID, &item); err != nil { return nil, false, err } return &item, true, nil } func (s *ScheduleTaskService) populateScheduleTaskListDecorations(ctx context.Context, tenantID int64, items []ScheduleTaskResponse) error { if len(items) == 0 { return nil } if err := s.populateScheduleAutoPublishPlatformsBatch(ctx, tenantID, items); err != nil { return err } return s.populateScheduleLatestGeneratedArticlesBatch(ctx, tenantID, items) } func (s *ScheduleTaskService) populateScheduleAutoPublishPlatforms(ctx context.Context, tenantID int64, item *ScheduleTaskResponse) error { if item == nil || !item.AutoPublish { return nil } platformIDs, err := loadPublishAccountPlatformsByIDs(ctx, s.pool, tenantID, item.PublishAccountIDs) if err != nil { return response.ErrInternal(50010, "query_failed", "failed to resolve schedule auto publish platforms") } item.AutoPublishPlatforms = platformIDs return nil } func (s *ScheduleTaskService) populateScheduleAutoPublishPlatformsBatch(ctx context.Context, tenantID int64, items []ScheduleTaskResponse) error { accountSet := make(map[string]struct{}) for _, item := range items { if !item.AutoPublish { continue } for _, accountID := range item.PublishAccountIDs { normalized := normalizeSchedulePublishAccountIDs([]string{accountID}) if len(normalized) == 0 { continue } accountSet[normalized[0]] = struct{}{} } } if len(accountSet) == 0 { return nil } accountIDs := make([]string, 0, len(accountSet)) for accountID := range accountSet { accountIDs = append(accountIDs, accountID) } rows, err := s.pool.Query(ctx, ` SELECT desktop_id::text, platform_id FROM platform_accounts WHERE tenant_id = $1 AND desktop_id::text = ANY($2::text[]) AND deleted_at IS NULL `, tenantID, accountIDs) if err != nil { return response.ErrInternal(50010, "query_failed", "failed to resolve schedule auto publish platforms") } defer rows.Close() platformsByAccount := make(map[string][]string, len(accountIDs)) for rows.Next() { var accountID string var platformID string if err := rows.Scan(&accountID, &platformID); err != nil { return response.ErrInternal(50010, "scan_failed", "failed to scan schedule auto publish platforms") } platformsByAccount[accountID] = append(platformsByAccount[accountID], platformID) } if err := rows.Err(); err != nil { return response.ErrInternal(50010, "scan_failed", "failed to iterate schedule auto publish platforms") } for idx := range items { if !items[idx].AutoPublish { continue } platformIDs := make([]string, 0, len(items[idx].PublishAccountIDs)) for _, accountID := range items[idx].PublishAccountIDs { normalized := normalizeSchedulePublishAccountIDs([]string{accountID}) if len(normalized) == 0 { continue } platformIDs = append(platformIDs, platformsByAccount[normalized[0]]...) } items[idx].AutoPublishPlatforms = emptyStringSliceIfNil(normalizePlatformIDs(platformIDs)) } return nil } func (s *ScheduleTaskService) populateScheduleLatestGeneratedArticles(ctx context.Context, tenantID int64, item *ScheduleTaskResponse) error { if item == nil || item.ID <= 0 { return nil } taskType := "custom_generation" if item.TargetType == ScheduleTargetKolSubscriptionPrompt { taskType = kolGenerationTaskType } rows, err := s.pool.Query(ctx, ` WITH latest_run AS ( SELECT COALESCE(NULLIF(gt.input_params_json ->> 'scheduled_for', ''), to_char(date_trunc('second', gt.created_at), 'YYYY-MM-DD"T"HH24:MI:SS"Z"')) AS run_key FROM generation_tasks gt WHERE gt.tenant_id = $1 AND gt.task_type = $3 AND COALESCE(NULLIF(gt.input_params_json ->> 'generation_mode', ''), '') = 'schedule' AND NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint = $2 ORDER BY gt.created_at DESC, gt.id DESC LIMIT 1 ) SELECT gt.id, COALESCE(a.id, gt.article_id) AS article_id, COALESCE(av.title, NULLIF(a.wizard_state_json ->> 'title', ''), NULLIF(gt.input_params_json ->> 'title', ''), NULLIF(gt.input_params_json ->> 'task_name', '')) AS article_title, COALESCE(a.generate_status, gt.status) AS article_generate_status, COALESCE(a.created_at, gt.created_at) AS article_created_at, COALESCE(gt.started_at, gt.completed_at, gt.created_at) AS execution_time FROM generation_tasks gt JOIN latest_run lr ON COALESCE(NULLIF(gt.input_params_json ->> 'scheduled_for', ''), to_char(date_trunc('second', gt.created_at), 'YYYY-MM-DD"T"HH24:MI:SS"Z"')) = lr.run_key LEFT JOIN articles a ON a.id = gt.article_id AND a.deleted_at IS NULL LEFT JOIN article_versions av ON av.id = a.current_version_id WHERE gt.tenant_id = $1 AND gt.task_type = $3 AND COALESCE(NULLIF(gt.input_params_json ->> 'generation_mode', ''), '') = 'schedule' AND NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint = $2 ORDER BY gt.created_at, gt.id `, tenantID, item.ID, taskType) if err != nil { return response.ErrInternal(50010, "query_failed", "failed to load schedule generated articles") } defer rows.Close() articles := make([]InstantTaskArticleLink, 0) statuses := make([]string, 0) var executionTime *string for rows.Next() { var taskID int64 var articleID *int64 var title *string var generateStatus string var createdAt interface{} var executionAt interface{} if err := rows.Scan(&taskID, &articleID, &title, &generateStatus, &createdAt, &executionAt); err != nil { return response.ErrInternal(50010, "scan_failed", err.Error()) } if executionTime == nil { executionTime = timeStringPtrFromDBValue(executionAt) } statuses = append(statuses, generateStatus) if articleID != nil && *articleID > 0 { articles = append(articles, InstantTaskArticleLink{ ArticleID: *articleID, Title: title, GenerateStatus: generateStatus, CreatedAt: timeStringFromDBValue(createdAt), }) } else { _ = taskID } } if err := rows.Err(); err != nil { return response.ErrInternal(50010, "scan_failed", "failed to iterate schedule generated articles") } item.GeneratedArticles = articles item.ExecutionTime = executionTime status := aggregateGeneratedArticleStatus(statuses) if status != "" { item.GenerationStatus = &status } return nil } func (s *ScheduleTaskService) populateScheduleLatestGeneratedArticlesBatch(ctx context.Context, tenantID int64, items []ScheduleTaskResponse) error { if len(items) == 0 { return nil } promptRuleTaskIDs := make([]int64, 0, len(items)) kolTaskIDs := make([]int64, 0, len(items)) indexByTaskID := make(map[int64]int, len(items)) for idx, item := range items { if item.ID <= 0 { continue } indexByTaskID[item.ID] = idx if item.TargetType == ScheduleTargetKolSubscriptionPrompt { kolTaskIDs = append(kolTaskIDs, item.ID) } else { promptRuleTaskIDs = append(promptRuleTaskIDs, item.ID) } } if err := s.populateScheduleLatestGeneratedArticlesBatchByType(ctx, tenantID, items, indexByTaskID, promptRuleTaskIDs, "custom_generation"); err != nil { return err } return s.populateScheduleLatestGeneratedArticlesBatchByType(ctx, tenantID, items, indexByTaskID, kolTaskIDs, kolGenerationTaskType) } func (s *ScheduleTaskService) populateScheduleLatestGeneratedArticlesBatchByType( ctx context.Context, tenantID int64, items []ScheduleTaskResponse, indexByTaskID map[int64]int, taskIDs []int64, taskType string, ) error { if len(taskIDs) == 0 { return nil } rows, err := s.pool.Query(ctx, ` WITH latest_run AS ( SELECT DISTINCT ON (NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint) NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint AS schedule_task_id, COALESCE(NULLIF(gt.input_params_json ->> 'scheduled_for', ''), to_char(date_trunc('second', gt.created_at), 'YYYY-MM-DD"T"HH24:MI:SS"Z"')) AS run_key FROM generation_tasks gt WHERE gt.tenant_id = $1 AND gt.task_type = $2 AND COALESCE(NULLIF(gt.input_params_json ->> 'generation_mode', ''), '') = 'schedule' AND NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint = ANY($3::bigint[]) ORDER BY NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint, gt.created_at DESC, gt.id DESC ) SELECT lr.schedule_task_id, gt.id, COALESCE(a.id, gt.article_id) AS article_id, COALESCE(av.title, NULLIF(a.wizard_state_json ->> 'title', ''), NULLIF(gt.input_params_json ->> 'title', ''), NULLIF(gt.input_params_json ->> 'task_name', '')) AS article_title, COALESCE(a.generate_status, gt.status) AS article_generate_status, COALESCE(a.created_at, gt.created_at) AS article_created_at, COALESCE(gt.started_at, gt.completed_at, gt.created_at) AS execution_time FROM latest_run lr JOIN generation_tasks gt ON gt.tenant_id = $1 AND gt.task_type = $2 AND COALESCE(NULLIF(gt.input_params_json ->> 'generation_mode', ''), '') = 'schedule' AND NULLIF(gt.input_params_json ->> 'schedule_task_id', '')::bigint = lr.schedule_task_id AND COALESCE(NULLIF(gt.input_params_json ->> 'scheduled_for', ''), to_char(date_trunc('second', gt.created_at), 'YYYY-MM-DD"T"HH24:MI:SS"Z"')) = lr.run_key LEFT JOIN articles a ON a.id = gt.article_id AND a.deleted_at IS NULL LEFT JOIN article_versions av ON av.id = a.current_version_id ORDER BY lr.schedule_task_id, gt.created_at, gt.id `, tenantID, taskType, taskIDs) if err != nil { return response.ErrInternal(50010, "query_failed", "failed to load schedule generated articles") } defer rows.Close() statusesByTask := make(map[int64][]string, len(taskIDs)) for rows.Next() { var scheduleTaskID int64 var taskID int64 var articleID *int64 var title *string var generateStatus string var createdAt interface{} var executionAt interface{} if err := rows.Scan(&scheduleTaskID, &taskID, &articleID, &title, &generateStatus, &createdAt, &executionAt); err != nil { return response.ErrInternal(50010, "scan_failed", err.Error()) } idx, ok := indexByTaskID[scheduleTaskID] if !ok { continue } if items[idx].ExecutionTime == nil { items[idx].ExecutionTime = timeStringPtrFromDBValue(executionAt) } statusesByTask[scheduleTaskID] = append(statusesByTask[scheduleTaskID], generateStatus) if articleID != nil && *articleID > 0 { items[idx].GeneratedArticles = append(items[idx].GeneratedArticles, InstantTaskArticleLink{ ArticleID: *articleID, Title: title, GenerateStatus: generateStatus, CreatedAt: timeStringFromDBValue(createdAt), }) } else { _ = taskID } } if err := rows.Err(); err != nil { return response.ErrInternal(50010, "scan_failed", "failed to iterate schedule generated articles") } for scheduleTaskID, statuses := range statusesByTask { status := aggregateGeneratedArticleStatus(statuses) if status == "" { continue } idx, ok := indexByTaskID[scheduleTaskID] if ok { items[idx].GenerationStatus = &status } } return nil } func aggregateGeneratedArticleStatus(statuses []string) string { if len(statuses) == 0 { return "" } completed := 0 failed := 0 running := 0 queued := 0 for _, status := range statuses { switch status { case "completed": completed++ case "failed": failed++ case "generating", "running": running++ case "queued", "pending": queued++ } } if running > 0 { return "running" } if queued > 0 { return "queued" } if completed > 0 && failed > 0 { return "partial_success" } if failed == len(statuses) { return "failed" } if completed == len(statuses) { return "completed" } return statuses[len(statuses)-1] } func scanScheduleTaskResponse(scanner interface { Scan(dest ...interface{}) error }) (ScheduleTaskResponse, error) { var item ScheduleTaskResponse var createdAt interface{} var updatedAt interface{} var startAt interface{} var endAt interface{} var nextRunAt interface{} var lastRunAt interface{} var publishAccountIDsJSON []byte var publishEnterpriseSiteTargetsJSON []byte var scheduleDaysJSON []byte var generationInputJSON []byte if err := scanner.Scan(&item.ID, &item.WorkspaceID, &item.TargetType, &item.PromptRuleID, &item.SubscriptionPromptID, &item.BrandID, &item.Name, &item.CronExpr, &item.ScheduleKind, &scheduleDaysJSON, &item.ScheduleTimeMode, &item.RandomWindowStart, &item.RandomWindowEnd, &generationInputJSON, &item.AutoPublish, &publishAccountIDsJSON, &publishEnterpriseSiteTargetsJSON, &item.CoverAssetURL, &item.CoverImageAssetID, &item.CoverMode, &item.CoverRandomScope, &item.CoverRandomFolderID, &item.EnableWebSearch, &item.GenerateCount, &startAt, &endAt, &nextRunAt, &item.Status, &lastRunAt, &item.LastDispatchStatus, &item.LastDispatchError, &item.ConsecutiveFailures, &createdAt, &updatedAt, &item.PromptRuleName, &item.SubscriptionPromptName, &item.SubscriptionPackageName, &item.SubscriptionKolName, &item.BrandName); err != nil { if errors.Is(err, pgx.ErrNoRows) { return ScheduleTaskResponse{}, pgx.ErrNoRows } return ScheduleTaskResponse{}, response.ErrInternal(50010, "scan_failed", err.Error()) } if item.TargetType == "" { item.TargetType = ScheduleTargetPromptRule } if item.ScheduleKind == "" { item.ScheduleKind = scheduleKindDaily } if item.ScheduleTimeMode == "" { item.ScheduleTimeMode = sharedschedule.TimeModeFixed } if item.RandomWindowStart == "" { item.RandomWindowStart = defaultRandomWindowStart } if item.RandomWindowEnd == "" { item.RandomWindowEnd = defaultRandomWindowEnd } if item.CoverMode == "" { item.CoverMode = ScheduleCoverModeSpecific } if item.CoverRandomScope == "" { item.CoverRandomScope = ScheduleCoverRandomScopeAll } item.ScheduleDays = decodeScheduleDayKeys(scheduleDaysJSON) item.GenerationInput = decodeScheduleGenerationInput(generationInputJSON) item.PublishAccountIDs = decodeSchedulePublishAccountIDs(publishAccountIDsJSON) item.PublishEnterpriseSiteTargets = DecodeScheduleEnterpriseSiteTargets(publishEnterpriseSiteTargetsJSON) item.CreatedAt = timeStringFromDBValue(createdAt) item.UpdatedAt = timeStringFromDBValue(updatedAt) item.StartAt = timeStringPtrFromDBValue(startAt) item.EndAt = timeStringPtrFromDBValue(endAt) item.NextRunAt = timeStringPtrFromDBValue(nextRunAt) item.LastRunAt = timeStringPtrFromDBValue(lastRunAt) return item, nil } func (s *ScheduleTaskService) ensurePromptRuleExists(ctx context.Context, tenantID, brandID, promptRuleID int64) error { var exists bool _ = s.pool.QueryRow(ctx, ` SELECT EXISTS(SELECT 1 FROM prompt_rules WHERE id = $1 AND tenant_id = $2 AND brand_id = $3 AND deleted_at IS NULL) `, promptRuleID, tenantID, brandID).Scan(&exists) if !exists { return response.ErrBadRequest(40001, "invalid_rule", "prompt rule not found or not active") } return nil } func (s *ScheduleTaskService) validateKolScheduleGenerationInput(ctx context.Context, tenantID, subscriptionPromptID int64, input map[string]interface{}) (map[string]interface{}, error) { input = normalizeKolScheduleGenerationInput(input) row, err := repository.NewKolSubscriptionRepository(s.pool).GetSubscriptionPromptByID(ctx, tenantID, subscriptionPromptID) if err != nil { return input, response.ErrInternal(50109, "kol_subscription_prompt_query_failed", err.Error()) } if row == nil { return input, ErrKolGenerationForbidden } now := time.Now() switch { case row.Status != "active": return input, ErrKolGenerationForbidden case row.SubscriptionStatus != "active": return input, ErrKolGenerationForbidden case row.SubscriptionEndAt != nil && row.SubscriptionEndAt.Before(now): return input, ErrKolGenerationForbidden case row.PackageStatus != "published": return input, ErrKolGenerationForbidden case row.PromptStatus != "active": return input, ErrKolGenerationForbidden } prompt, err := repository.NewKolPromptRepository(s.pool).GetByID(ctx, row.CreatorTenantID, row.PromptID) if err != nil { return input, response.ErrInternal(50110, "kol_prompt_query_failed", err.Error()) } if prompt == nil { return input, response.ErrInternal(50111, "kol_prompt_content_missing", "published prompt content not found") } content, err := loadKolPromptContent(ctx, s.cache, &s.cacheGroup, repository.NewKolPromptRepository(s.pool), s.promptAsset, prompt) if err != nil { return input, response.ErrInternal(50110, "kol_prompt_query_failed", err.Error()) } if strings.TrimSpace(content) == "" { return input, response.ErrInternal(50111, "kol_prompt_content_missing", "published prompt content not found") } schema, err := decodeKolSchema(prompt.SchemaJSON) if err != nil { return input, response.ErrInternal(50096, "kol_generation_schema_decode_failed", err.Error()) } cardConfig, err := decodeKolCardConfig(prompt.CardConfigJSON) if err != nil { return input, response.ErrInternal(50097, "kol_generation_card_config_decode_failed", err.Error()) } variables, _ := input["variables"].(map[string]interface{}) if variables == nil { variables = map[string]interface{}{} input["variables"] = variables } missing := make([]string, 0) for _, variable := range schema.Variables { _, hasValue, err := resolveKolVariableValue(variables, variable, variable.Key) if err != nil { return input, response.ErrBadRequest(40071, "kol_generation_variables_invalid", err.Error()) } if variable.Required && !hasValue { missing = append(missing, variable.Label) } } if len(missing) > 0 { return input, response.ErrBadRequest(40071, "kol_generation_variables_invalid", "missing variables: "+strings.Join(missing, ", ")) } if extractBool(input, "enable_web_search") && !kolCardConfigAllowsWebSearch(cardConfig) { return input, response.ErrBadRequest(40073, "kol_generation_web_search_disabled", "web search is disabled for this prompt") } knowledgeGroupIDs := extractKnowledgeGroupIDs(input["knowledge_group_ids"]) if len(knowledgeGroupIDs) > 0 && !kolCardConfigAllowsUserKnowledge(cardConfig) { return input, response.ErrBadRequest(40074, "kol_generation_knowledge_disabled", "knowledge selection is disabled for this prompt") } if len(knowledgeGroupIDs) > 0 { input["knowledge_group_ids"] = knowledgeGroupIDs } else { delete(input, "knowledge_group_ids") } return input, nil } type scheduleAutoPublishConfig struct { AutoPublish bool AccountIDs []string EnterpriseTargets []ScheduleEnterpriseSiteTarget PlatformIDs []string AccountIDsJSON []byte EnterpriseTargetsJSON []byte CoverAssetURL *string CoverImageAssetID *int64 CoverMode string CoverRandomScope string CoverRandomFolderID *int64 } func (s *ScheduleTaskService) normalizeAutoPublishConfig(ctx context.Context, actor auth.Actor, req ScheduleTaskRequest) (scheduleAutoPublishConfig, error) { autoPublish := boolValue(req.AutoPublish) accountIDs := normalizeSchedulePublishAccountIDs(req.PublishAccountIDs) enterpriseTargets := NormalizeScheduleEnterpriseSiteTargets(req.PublishEnterpriseSiteTargets) config := scheduleAutoPublishConfig{ AutoPublish: autoPublish, AccountIDs: accountIDs, EnterpriseTargets: enterpriseTargets, CoverMode: ScheduleCoverModeSpecific, CoverRandomScope: ScheduleCoverRandomScopeAll, } if !autoPublish { config.AccountIDs = []string{} config.EnterpriseTargets = []ScheduleEnterpriseSiteTarget{} config.AccountIDsJSON = []byte("[]") config.EnterpriseTargetsJSON = []byte("[]") return config, nil } if actor.PrimaryWorkspaceID <= 0 { return config, response.ErrBadRequest(40023, "workspace_required", "自动发布需要工作区上下文") } if len(accountIDs) == 0 && len(enterpriseTargets) == 0 { return config, response.ErrBadRequest(40024, "publish_targets_required", "开启自动发布后，请至少选择一个发布目标") } if err := validateOptionalPositiveInt64(req.CoverImageAssetID, "cover_image_asset_id"); err != nil { return config, err } coverMode, err := normalizeScheduleCoverMode(req.CoverMode) if err != nil { return config, err } randomScope := ScheduleCoverRandomScopeAll var randomFolderID *int64 if coverMode == ScheduleCoverModeRandom { randomScope, randomFolderID, err = s.normalizeScheduleCoverRandomSource(ctx, actor.TenantID, req.CoverRandomScope, req.CoverRandomFolderID) if err != nil { return config, err } } coverURL := strings.TrimSpace(stringPointerValue(req.CoverAssetURL)) if len(accountIDs) > 0 { platformIDs, err := s.loadPublishAccountPlatformIDs(ctx, actor.TenantID, actor.PrimaryWorkspaceID, accountIDs) if err != nil { return config, err } config.PlatformIDs = normalizePlatformIDs(platformIDs) if schedulePublishPlatformsRequireCover(platformIDs) && coverMode == ScheduleCoverModeSpecific && coverURL == "" { return config, response.ErrBadRequest(40025, "cover_required", "已选媒体账号的平台要求封面图，请先设置封面") } } if len(enterpriseTargets) > 0 { if err := s.validateScheduleEnterpriseSiteTargets(ctx, actor.TenantID, actor.PrimaryWorkspaceID, enterpriseTargets); err != nil { return config, err } } accountIDsJSON, err := json.Marshal(accountIDs) if err != nil { return config, response.ErrBadRequest(40026, "invalid_publish_account_ids", "媒体账号发布目标格式不正确") } enterpriseTargetsJSON, err := encodeScheduleEnterpriseSiteTargets(enterpriseTargets) if err != nil { return config, err } config.AccountIDsJSON = accountIDsJSON config.EnterpriseTargetsJSON = enterpriseTargetsJSON config.CoverMode = coverMode config.CoverRandomScope = randomScope config.CoverRandomFolderID = randomFolderID if coverMode == ScheduleCoverModeSpecific && coverURL != "" { config.CoverAssetURL = &coverURL config.CoverImageAssetID = req.CoverImageAssetID } return config, nil } func normalizeScheduleCoverMode(value string) (string, error) { switch strings.TrimSpace(value) { case "", ScheduleCoverModeSpecific: return ScheduleCoverModeSpecific, nil case ScheduleCoverModeRandom: return ScheduleCoverModeRandom, nil default: return "", response.ErrBadRequest(40076, "invalid_cover_mode", "封面图模式不正确") } } func (s *ScheduleTaskService) normalizeScheduleCoverRandomSource(ctx context.Context, tenantID int64, scope string, folderID *int64) (string, *int64, error) { normalizedScope := strings.TrimSpace(scope) if normalizedScope == "" { normalizedScope = ScheduleCoverRandomScopeAll } switch normalizedScope { case ScheduleCoverRandomScopeAll: return ScheduleCoverRandomScopeAll, nil, nil case ScheduleCoverRandomScopeFolder: if folderID == nil || *folderID <= 0 { return "", nil, response.ErrBadRequest(40077, "cover_random_folder_required", "请选择随机封面图片文件夹") } if err := s.ensureImageFolderExists(ctx, tenantID, *folderID); err != nil { return "", nil, err } return ScheduleCoverRandomScopeFolder, folderID, nil default: return "", nil, response.ErrBadRequest(40078, "invalid_cover_random_scope", "随机封面范围不正确") } } func (s *ScheduleTaskService) ensureImageFolderExists(ctx context.Context, tenantID, folderID int64) error { var exists bool if err := s.pool.QueryRow(ctx, ` SELECT EXISTS ( SELECT 1 FROM image_folders WHERE id = $1 AND tenant_id = $2 AND deleted_at IS NULL ) `, folderID, tenantID).Scan(&exists); err != nil { return response.ErrInternal(50010, "query_failed", "failed to validate image folder") } if !exists { return response.ErrBadRequest(40079, "image_folder_not_found", "随机封面图片文件夹不存在") } return nil } func (s *ScheduleTaskService) validateScheduleEnterpriseSiteTargets(ctx context.Context, tenantID, workspaceID int64, targets []ScheduleEnterpriseSiteTarget) error { for _, target := range targets { var status string if err := s.pool.QueryRow(ctx, ` SELECT status FROM enterprise_site_connections WHERE id = $1 AND tenant_id = $2 AND workspace_id = $3 AND deleted_at IS NULL `, target.SiteID, tenantID, workspaceID).Scan(&status); err != nil { if errors.Is(err, pgx.ErrNoRows) { return response.ErrBadRequest(40050, "invalid_publish_enterprise_site_targets", "企业站点连接不存在或已删除") } return response.ErrInternal(50231, "enterprise_site_lookup_failed", "企业站点连接读取失败") } if status == "disabled" { return response.ErrConflict(40942, "enterprise_site_disabled", "企业站点已禁用") } if strings.TrimSpace(target.CategoryID) == "" { return response.ErrBadRequest(40047, "enterprise_site_category_required", "请选择企业站点栏目") } var categoryExists bool if err := s.pool.QueryRow(ctx, ` SELECT EXISTS ( SELECT 1 FROM enterprise_site_categories WHERE tenant_id = $1 AND workspace_id = $2 AND connection_id = $3 AND remote_id = $4 ) `, tenantID, workspaceID, target.SiteID, target.CategoryID).Scan(&categoryExists); err != nil { return response.ErrInternal(50230, "enterprise_site_category_lookup_failed", "企业站点栏目校验失败") } if !categoryExists { return response.ErrBadRequest(40049, "enterprise_site_category_not_found", "企业站点栏目不存在，请先同步栏目") } } return nil } func (s *ScheduleTaskService) loadPublishAccountPlatformIDs(ctx context.Context, tenantID, workspaceID int64, accountIDs []string) ([]string, error) { rows, err := s.pool.Query(ctx, ` SELECT platform_id FROM platform_accounts WHERE tenant_id = $1 AND workspace_id = $2 AND desktop_id::text = ANY($3::text[]) AND deleted_at IS NULL `, tenantID, workspaceID, accountIDs) if err != nil { return nil, response.ErrInternal(50010, "publish_account_check_failed", "failed to validate publish accounts") } defer rows.Close() platformIDs := make([]string, 0, len(accountIDs)) for rows.Next() { var platformID string if err := rows.Scan(&platformID); err != nil { return nil, response.ErrInternal(50010, "publish_account_check_failed", "failed to parse publish accounts") } platformIDs = append(platformIDs, strings.TrimSpace(platformID)) } if err := rows.Err(); err != nil { return nil, response.ErrInternal(50010, "publish_account_check_failed", "failed to iterate publish accounts") } if len(platformIDs) != len(accountIDs) { return nil, response.ErrBadRequest(40027, "invalid_publish_accounts", "one or more publish accounts do not exist") } return platformIDs, nil } func schedulePublishPlatformsRequireCover(platformIDs []string) bool { for _, platformID := range platformIDs { if publishPlatformRequiresCover(platformID) { return true } } return false } func validateScheduleCronExpr(cronExpr string) error { if _, err := sharedschedule.Parse(cronExpr); err != nil { return response.ErrBadRequest(40015, "invalid_cron_expr", err.Error()) } return nil } func normalizeScheduleGenerateCount(value *int) (int, error) { if value == nil { return 1, nil } if *value < 1 || *value > 20 { return 0, response.ErrBadRequest(40022, "invalid_generate_count", "generate_count must be between 1 and 20") } return *value, nil } func boolValue(value *bool) bool { return value != nil && *value } func normalizeSchedulePublishAccountIDs(values []string) []string { seen := make(map[string]struct{}, len(values)) normalized := make([]string, 0, len(values)) for _, value := range values { raw := strings.TrimSpace(value) if raw == "" { continue } id, err := uuid.Parse(raw) if err != nil { continue } key := id.String() if _, ok := seen[key]; ok { continue } seen[key] = struct{}{} normalized = append(normalized, key) } return normalized } func decodeSchedulePublishAccountIDs(raw []byte) []string { var values []string if len(raw) == 0 { return []string{} } if err := json.Unmarshal(raw, &values); err != nil { return []string{} } return normalizeSchedulePublishAccountIDs(values) } func validateOptionalPositiveInt64(value *int64, field string) error { if value != nil && *value <= 0 { return response.ErrBadRequest(40028, "invalid_"+field, field+" must be a positive integer or null") } return nil } func timePtrFromTimestamp(value pgtype.Timestamptz) *time.Time { if !value.Valid { return nil } result := value.Time.Round(0) return &result } func timeStringPtr(value *time.Time) *string { if value == nil { return nil } text := value.Format(time.RFC3339) return &text } func timeStringFromDBValue(value interface{}) string { if value == nil { return "" } if timestamp, ok := value.(time.Time); ok { return timestamp.Round(0).Format(time.RFC3339) } return fmt.Sprintf("%v", value) } func timeStringPtrFromDBValue(value interface{}) *string { if value == nil { return nil } text := timeStringFromDBValue(value) return &text }