root
9f721f6088
- Implemented `resolveApiURL` function to handle various URL formats. - Updated `ArticleDetail` and `UpdateArticleRequest` interfaces to include `cover_asset_url`. - Enhanced `ArticleEditorView` to manage cover image uploads, including a new `CoverPickerModal` component. - Added cover image requirements logic in `cover-requirements.ts` to enforce platform-specific cover image rules. - Modified backend services to handle cover image uploads and validations, including checks for required cover images for specific platforms. - Improved error handling for cover image requirements during article publishing.
630 lines
19 KiB
Go
630 lines
19 KiB
Go
package app
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
|
|
"github.com/geo-platform/tenant-api/internal/shared/auth"
|
|
"github.com/geo-platform/tenant-api/internal/shared/config"
|
|
"github.com/geo-platform/tenant-api/internal/shared/llm"
|
|
"github.com/geo-platform/tenant-api/internal/shared/response"
|
|
"github.com/geo-platform/tenant-api/internal/shared/stream"
|
|
"github.com/geo-platform/tenant-api/internal/tenant/prompts"
|
|
"github.com/geo-platform/tenant-api/internal/tenant/repository"
|
|
)
|
|
|
|
type PromptRuleGenerationService struct {
|
|
pool *pgxpool.Pool
|
|
llm llm.Client
|
|
knowledge *KnowledgeService
|
|
streams *stream.GenerationHub
|
|
streamEnabled bool
|
|
articleTimeout time.Duration
|
|
maxOutputTokens int64
|
|
jobs chan promptRuleGenerationJob
|
|
}
|
|
|
|
type promptRuleGenerationJob struct {
|
|
OperatorID int64
|
|
TenantID int64
|
|
ArticleID int64
|
|
TaskID int64
|
|
ReservationID int64
|
|
Prompt string
|
|
InputParams map[string]interface{}
|
|
InitialTitle string
|
|
WebSearch llm.WebSearchOptions
|
|
}
|
|
|
|
type GenerateFromRuleRequest struct {
|
|
PromptRuleID int64 `json:"prompt_rule_id" binding:"required"`
|
|
BrandID *int64 `json:"brand_id"`
|
|
TargetPlatform *string `json:"target_platform"`
|
|
ExtraParams map[string]interface{} `json:"extra_params"`
|
|
}
|
|
|
|
type GenerateFromRuleResponse struct {
|
|
ArticleID int64 `json:"article_id"`
|
|
TaskID int64 `json:"task_id"`
|
|
}
|
|
|
|
type promptRuleGenerationRecord struct {
|
|
ID int64
|
|
Name string
|
|
PromptContent string
|
|
Scene *string
|
|
DefaultTone *string
|
|
DefaultWordCount *int
|
|
KnowledgeGroupIDs []int64
|
|
KnowledgeGroups []PromptRuleKnowledgeGroup
|
|
Status string
|
|
}
|
|
|
|
const promptRuleGeneratingTitlePlaceholder = "标题生成中"
|
|
|
|
func NewPromptRuleGenerationService(
|
|
pool *pgxpool.Pool,
|
|
llmClient llm.Client,
|
|
knowledge *KnowledgeService,
|
|
streams *stream.GenerationHub,
|
|
cfg config.GenerationConfig,
|
|
llmMaxOutputTokens int64,
|
|
) *PromptRuleGenerationService {
|
|
queueSize := cfg.QueueSize
|
|
if queueSize <= 0 {
|
|
queueSize = 128
|
|
}
|
|
|
|
workerCount := cfg.WorkerConcurrency
|
|
if workerCount <= 0 {
|
|
workerCount = 1
|
|
}
|
|
|
|
articleTimeout := cfg.ArticleTimeout
|
|
if articleTimeout <= 0 {
|
|
articleTimeout = 8 * time.Minute
|
|
}
|
|
|
|
svc := &PromptRuleGenerationService{
|
|
pool: pool,
|
|
llm: llmClient,
|
|
knowledge: knowledge,
|
|
streams: streams,
|
|
streamEnabled: cfg.StreamEnabled,
|
|
articleTimeout: articleTimeout,
|
|
maxOutputTokens: llmMaxOutputTokens,
|
|
jobs: make(chan promptRuleGenerationJob, queueSize),
|
|
}
|
|
|
|
for i := 0; i < workerCount; i++ {
|
|
go svc.runGenerationWorker()
|
|
}
|
|
|
|
return svc
|
|
}
|
|
|
|
func (s *PromptRuleGenerationService) GenerateFromRule(ctx context.Context, req GenerateFromRuleRequest) (*GenerateFromRuleResponse, error) {
|
|
actor := auth.MustActor(ctx)
|
|
|
|
if err := s.llm.Validate(); err != nil {
|
|
return nil, response.ErrServiceUnavailable(50311, "llm_unavailable", err.Error())
|
|
}
|
|
|
|
rule, err := s.loadPromptRule(ctx, actor.TenantID, req.PromptRuleID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if rule.Status != "enabled" {
|
|
return nil, response.ErrBadRequest(40017, "prompt_rule_disabled", "prompt rule is disabled")
|
|
}
|
|
|
|
extra := req.ExtraParams
|
|
if extractGenerateCount(extra) > 1 {
|
|
return nil, response.ErrBadRequest(40018, "generate_count_not_supported", "prompt rule instant generation currently supports generate_count = 1 only")
|
|
}
|
|
|
|
taskName := strings.TrimSpace(extractString(extra, "task_name"))
|
|
if taskName == "" {
|
|
taskName = strings.TrimSpace(rule.Name)
|
|
}
|
|
if taskName == "" {
|
|
taskName = "即时任务"
|
|
}
|
|
|
|
quotaRepo := repository.NewQuotaRepository(s.pool)
|
|
balance, err := quotaRepo.GetCurrentBalance(ctx, actor.TenantID, "article_generation")
|
|
if err != nil || balance < 1 {
|
|
return nil, response.ErrForbidden(40301, "quota_insufficient", "generation quota insufficient, please upgrade your plan")
|
|
}
|
|
|
|
inputParams := map[string]interface{}{
|
|
"prompt_rule_id": req.PromptRuleID,
|
|
"task_name": taskName,
|
|
"target_platform": strings.TrimSpace(derefString(req.TargetPlatform)),
|
|
"enable_web_search": extractBool(extra, "enable_web_search"),
|
|
}
|
|
if generationMode := strings.TrimSpace(extractString(extra, "generation_mode")); generationMode != "" {
|
|
inputParams["generation_mode"] = generationMode
|
|
}
|
|
platformIDs := parsePlatformIDs(derefString(req.TargetPlatform))
|
|
if len(platformIDs) > 0 {
|
|
inputParams["target_platforms"] = platformIDs
|
|
}
|
|
if req.BrandID != nil {
|
|
inputParams["brand_id"] = *req.BrandID
|
|
}
|
|
if len(rule.KnowledgeGroupIDs) > 0 {
|
|
inputParams["knowledge_group_ids"] = rule.KnowledgeGroupIDs
|
|
}
|
|
|
|
knowledgePrompt := ""
|
|
if len(rule.KnowledgeGroupIDs) > 0 {
|
|
if s.knowledge == nil {
|
|
return nil, response.ErrServiceUnavailable(50352, "knowledge_unavailable", "knowledge service is not configured")
|
|
}
|
|
knowledgeContext, resolveErr := s.knowledge.ResolveContext(
|
|
ctx,
|
|
actor.TenantID,
|
|
rule.KnowledgeGroupIDs,
|
|
buildPromptRuleKnowledgeQuery(rule, inputParams),
|
|
)
|
|
if resolveErr != nil {
|
|
return nil, resolveErr
|
|
}
|
|
knowledgePrompt = s.knowledge.RenderPromptSection(knowledgeContext)
|
|
}
|
|
|
|
inputJSON, _ := json.Marshal(inputParams)
|
|
wizardStateJSON, _ := mergeArticleWizardState(nil, promptRuleGeneratingTitlePlaceholder, platformIDs, nil)
|
|
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to begin generation transaction")
|
|
}
|
|
defer func() {
|
|
_ = tx.Rollback(ctx)
|
|
}()
|
|
|
|
quotaTx := repository.NewQuotaRepository(tx)
|
|
auditTx := repository.NewAuditRepository(tx)
|
|
|
|
newBalance := balance - 1
|
|
reason := "generation_reserve"
|
|
referenceType := "generation_task"
|
|
_, err = quotaTx.InsertQuotaLedger(ctx, repository.QuotaLedgerInput{
|
|
TenantID: actor.TenantID,
|
|
OperatorID: actor.UserID,
|
|
QuotaType: "article_generation",
|
|
Delta: -1,
|
|
BalanceAfter: newBalance,
|
|
Reason: &reason,
|
|
ReferenceType: &referenceType,
|
|
})
|
|
if err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to reserve generation quota")
|
|
}
|
|
|
|
reservationID, err := quotaTx.CreateQuotaReservation(ctx, repository.QuotaReservationInput{
|
|
TenantID: actor.TenantID,
|
|
OperatorID: actor.UserID,
|
|
QuotaType: "article_generation",
|
|
ResourceType: "article",
|
|
ResourceID: nil,
|
|
ReservedAmount: 1,
|
|
ExpireAt: time.Now().Add(time.Hour),
|
|
})
|
|
if err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to create quota reservation")
|
|
}
|
|
|
|
var articleID int64
|
|
err = tx.QueryRow(ctx, `
|
|
INSERT INTO articles (tenant_id, source_type, prompt_rule_id, generate_status, publish_status, wizard_state_json)
|
|
VALUES ($1, 'custom_generation', $2, 'generating', 'unpublished', $3)
|
|
RETURNING id
|
|
`, actor.TenantID, req.PromptRuleID, wizardStateJSON).Scan(&articleID)
|
|
if err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to create prompt rule article")
|
|
}
|
|
|
|
if err := quotaTx.UpdateQuotaReservationResource(ctx, reservationID, actor.TenantID, articleID); err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to update quota reservation resource")
|
|
}
|
|
|
|
taskID, err := auditTx.CreateGenerationTask(ctx, repository.GenerationTaskInput{
|
|
OperatorID: actor.UserID,
|
|
TenantID: actor.TenantID,
|
|
ArticleID: &articleID,
|
|
QuotaReservationID: &reservationID,
|
|
TaskType: "custom_generation",
|
|
InputParamsJSON: inputJSON,
|
|
})
|
|
if err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to create generation task")
|
|
}
|
|
|
|
if err := tx.Commit(ctx); err != nil {
|
|
return nil, response.ErrInternal(50012, "create_failed", "failed to commit generation task")
|
|
}
|
|
|
|
job := promptRuleGenerationJob{
|
|
OperatorID: actor.UserID,
|
|
TenantID: actor.TenantID,
|
|
ArticleID: articleID,
|
|
TaskID: taskID,
|
|
ReservationID: reservationID,
|
|
Prompt: buildPromptRuleGenerationPrompt(rule, inputParams, knowledgePrompt),
|
|
InputParams: inputParams,
|
|
InitialTitle: promptRuleGeneratingTitlePlaceholder,
|
|
WebSearch: llm.WebSearchOptions{
|
|
Enabled: extractBool(extra, "enable_web_search"),
|
|
},
|
|
}
|
|
|
|
if err := s.enqueueGeneration(job); err != nil {
|
|
s.failGeneration(context.Background(), job, job.InitialTitle, "queue_enqueue", err)
|
|
return nil, response.ErrServiceUnavailable(50310, "generation_queue_unavailable", "generation queue is busy, please retry")
|
|
}
|
|
|
|
if s.streamEnabled {
|
|
s.streams.Start(articleID, taskID, promptRuleGeneratingTitlePlaceholder)
|
|
}
|
|
|
|
return &GenerateFromRuleResponse{ArticleID: articleID, TaskID: taskID}, nil
|
|
}
|
|
|
|
func (s *PromptRuleGenerationService) loadPromptRule(ctx context.Context, tenantID, promptRuleID int64) (*promptRuleGenerationRecord, error) {
|
|
record := &promptRuleGenerationRecord{}
|
|
err := s.pool.QueryRow(ctx, `
|
|
SELECT id, name, prompt_content, scene, default_tone, default_word_count, status
|
|
FROM prompt_rules
|
|
WHERE id = $1 AND tenant_id = $2 AND deleted_at IS NULL
|
|
`, promptRuleID, tenantID).Scan(
|
|
&record.ID,
|
|
&record.Name,
|
|
&record.PromptContent,
|
|
&record.Scene,
|
|
&record.DefaultTone,
|
|
&record.DefaultWordCount,
|
|
&record.Status,
|
|
)
|
|
if err != nil {
|
|
return nil, response.ErrNotFound(40431, "rule_not_found", "prompt rule not found")
|
|
}
|
|
knowledgeRows, err := s.pool.Query(ctx, `
|
|
SELECT kg.id, kg.name
|
|
FROM prompt_rule_knowledge_groups prkg
|
|
JOIN knowledge_groups kg ON kg.id = prkg.knowledge_group_id
|
|
WHERE prkg.prompt_rule_id = $1
|
|
AND kg.tenant_id = $2
|
|
AND kg.deleted_at IS NULL
|
|
ORDER BY kg.sort_order, kg.created_at, kg.id
|
|
`, promptRuleID, tenantID)
|
|
if err != nil {
|
|
return nil, response.ErrInternal(50010, "knowledge_group_query_failed", "failed to query knowledge groups")
|
|
}
|
|
defer knowledgeRows.Close()
|
|
|
|
for knowledgeRows.Next() {
|
|
var group PromptRuleKnowledgeGroup
|
|
if err := knowledgeRows.Scan(&group.ID, &group.Name); err != nil {
|
|
return nil, response.ErrInternal(50010, "knowledge_group_query_failed", err.Error())
|
|
}
|
|
record.KnowledgeGroups = append(record.KnowledgeGroups, group)
|
|
record.KnowledgeGroupIDs = append(record.KnowledgeGroupIDs, group.ID)
|
|
}
|
|
return record, nil
|
|
}
|
|
|
|
func (s *PromptRuleGenerationService) enqueueGeneration(job promptRuleGenerationJob) error {
|
|
select {
|
|
case s.jobs <- job:
|
|
return nil
|
|
default:
|
|
return fmt.Errorf("generation queue is full")
|
|
}
|
|
}
|
|
|
|
func (s *PromptRuleGenerationService) runGenerationWorker() {
|
|
for job := range s.jobs {
|
|
s.executeGeneration(context.Background(), job)
|
|
}
|
|
}
|
|
|
|
func (s *PromptRuleGenerationService) executeGeneration(ctx context.Context, job promptRuleGenerationJob) {
|
|
now := time.Now()
|
|
title := strings.TrimSpace(job.InitialTitle)
|
|
if title == "" {
|
|
title = "Generated Article"
|
|
}
|
|
|
|
auditRepo := repository.NewAuditRepository(s.pool)
|
|
_ = auditRepo.UpdateGenerationTaskStatus(ctx, repository.GenerationTaskStatusInput{
|
|
ID: job.TaskID,
|
|
TenantID: job.TenantID,
|
|
Status: "running",
|
|
StartedAt: &now,
|
|
})
|
|
|
|
req := llm.GenerateRequest{
|
|
Prompt: job.Prompt,
|
|
Timeout: s.articleTimeout,
|
|
MaxOutputTokens: s.maxOutputTokens,
|
|
}
|
|
if job.WebSearch.Enabled {
|
|
req.WebSearch = &job.WebSearch
|
|
}
|
|
|
|
result, err := s.llm.Generate(ctx, req, func(delta string) {
|
|
if s.streamEnabled && delta != "" {
|
|
s.streams.AppendDelta(job.ArticleID, job.TaskID, title, delta)
|
|
}
|
|
})
|
|
if err != nil {
|
|
s.failGeneration(ctx, job, title, "llm_generate", err)
|
|
return
|
|
}
|
|
|
|
content := strings.TrimSpace(result.Content)
|
|
if content == "" {
|
|
s.failGeneration(ctx, job, title, "llm_generate", fmt.Errorf("模型返回空内容"))
|
|
return
|
|
}
|
|
|
|
title = resolveArticleTitle(job.InputParams, content)
|
|
wordCount := estimateWordCount(content)
|
|
|
|
tx, err := s.pool.Begin(ctx)
|
|
if err != nil {
|
|
s.failGeneration(ctx, job, title, "persist_begin_tx", err)
|
|
return
|
|
}
|
|
defer func() {
|
|
_ = tx.Rollback(ctx)
|
|
}()
|
|
|
|
articleRepo := repository.NewArticleRepository(tx)
|
|
quotaRepo := repository.NewQuotaRepository(tx)
|
|
auditTx := repository.NewAuditRepository(tx)
|
|
|
|
versionID, err := articleRepo.CreateArticleVersion(ctx, repository.CreateArticleVersionInput{
|
|
ArticleID: job.ArticleID,
|
|
VersionNo: 1,
|
|
Title: title,
|
|
HTMLContent: "",
|
|
MarkdownContent: content,
|
|
WordCount: wordCount,
|
|
SourceLabel: result.Model,
|
|
})
|
|
if err != nil {
|
|
s.failGeneration(ctx, job, title, "persist_create_version", err)
|
|
return
|
|
}
|
|
|
|
if err := articleRepo.UpdateArticleCurrentVersion(ctx, job.ArticleID, job.TenantID, versionID); err != nil {
|
|
s.failGeneration(ctx, job, title, "persist_current_version", err)
|
|
return
|
|
}
|
|
if err := articleRepo.UpdateArticleGenerateStatus(ctx, job.ArticleID, job.TenantID, "completed"); err != nil {
|
|
s.failGeneration(ctx, job, title, "persist_article_status", err)
|
|
return
|
|
}
|
|
|
|
completed := time.Now()
|
|
if err := auditTx.UpdateGenerationTaskStatus(ctx, repository.GenerationTaskStatusInput{
|
|
ID: job.TaskID,
|
|
TenantID: job.TenantID,
|
|
Status: "completed",
|
|
StartedAt: &now,
|
|
CompletedAt: &completed,
|
|
}); err != nil {
|
|
s.failGeneration(ctx, job, title, "persist_task_status", err)
|
|
return
|
|
}
|
|
|
|
if err := quotaRepo.ConfirmReservation(ctx, job.ReservationID, job.TenantID); err != nil {
|
|
s.failGeneration(ctx, job, title, "confirm_reservation", err)
|
|
return
|
|
}
|
|
if err := tx.Commit(ctx); err != nil {
|
|
s.failGeneration(ctx, job, title, "persist_commit", err)
|
|
return
|
|
}
|
|
|
|
if s.streamEnabled {
|
|
s.streams.Complete(job.ArticleID, job.TaskID, title, content)
|
|
}
|
|
}
|
|
|
|
func (s *PromptRuleGenerationService) failGeneration(ctx context.Context, job promptRuleGenerationJob, title, stage string, genErr error) {
|
|
errMsg := formatGenerationFailure(stage, genErr)
|
|
now := time.Now()
|
|
failureTitle := strings.TrimSpace(extractString(job.InputParams, "task_name"))
|
|
if failureTitle == "" {
|
|
failureTitle = title
|
|
}
|
|
|
|
auditRepo := repository.NewAuditRepository(s.pool)
|
|
articleRepo := repository.NewArticleRepository(s.pool)
|
|
quotaRepo := repository.NewQuotaRepository(s.pool)
|
|
|
|
_ = auditRepo.UpdateGenerationTaskStatus(ctx, repository.GenerationTaskStatusInput{
|
|
ID: job.TaskID,
|
|
TenantID: job.TenantID,
|
|
Status: "failed",
|
|
ErrorMessage: &errMsg,
|
|
CompletedAt: &now,
|
|
})
|
|
_ = articleRepo.UpdateArticleGenerateStatus(ctx, job.ArticleID, job.TenantID, "failed")
|
|
if failureTitle != "" {
|
|
_, _ = s.pool.Exec(ctx, `
|
|
UPDATE articles
|
|
SET wizard_state_json = jsonb_set(COALESCE(wizard_state_json, '{}'::jsonb), '{title}', to_jsonb($1::text), true),
|
|
updated_at = NOW()
|
|
WHERE id = $2 AND tenant_id = $3
|
|
`, failureTitle, job.ArticleID, job.TenantID)
|
|
}
|
|
|
|
balance, balanceErr := quotaRepo.GetCurrentBalance(ctx, job.TenantID, "article_generation")
|
|
if balanceErr == nil {
|
|
reason := "generation_refund"
|
|
referenceType := "generation_task"
|
|
taskReferenceID := job.TaskID
|
|
_, _ = quotaRepo.InsertQuotaLedger(ctx, repository.QuotaLedgerInput{
|
|
TenantID: job.TenantID,
|
|
OperatorID: job.OperatorID,
|
|
QuotaType: "article_generation",
|
|
Delta: 1,
|
|
BalanceAfter: balance + 1,
|
|
Reason: &reason,
|
|
ReferenceType: &referenceType,
|
|
ReferenceID: &taskReferenceID,
|
|
})
|
|
}
|
|
|
|
_ = quotaRepo.RefundReservation(ctx, job.ReservationID, job.TenantID)
|
|
|
|
if s.streamEnabled {
|
|
s.streams.Fail(job.ArticleID, job.TaskID, failureTitle, errMsg)
|
|
}
|
|
}
|
|
|
|
func buildPromptRuleGenerationPrompt(rule *promptRuleGenerationRecord, params map[string]interface{}, knowledgePrompt string) string {
|
|
sections := []string{strings.TrimSpace(rule.PromptContent)}
|
|
|
|
var supplements []string
|
|
if taskName := strings.TrimSpace(extractString(params, "task_name")); taskName != "" {
|
|
supplements = append(supplements, prompts.PromptRuleTaskNameSupplement(taskName))
|
|
}
|
|
if rule.Scene != nil && strings.TrimSpace(*rule.Scene) != "" {
|
|
supplements = append(supplements, prompts.PromptRuleSceneSupplement(strings.TrimSpace(*rule.Scene)))
|
|
}
|
|
if rule.DefaultTone != nil && strings.TrimSpace(*rule.DefaultTone) != "" {
|
|
supplements = append(supplements, prompts.PromptRuleToneSupplement(strings.TrimSpace(*rule.DefaultTone)))
|
|
}
|
|
if rule.DefaultWordCount != nil && *rule.DefaultWordCount > 0 {
|
|
supplements = append(supplements, prompts.PromptRuleWordCountSupplement(*rule.DefaultWordCount))
|
|
}
|
|
if target := strings.TrimSpace(extractString(params, "target_platform")); target != "" {
|
|
supplements = append(supplements, prompts.PromptRuleTargetPlatformSupplement(target))
|
|
}
|
|
|
|
if len(supplements) > 0 {
|
|
sections = append(sections, prompts.PromptRuleSupplementSection(supplements))
|
|
}
|
|
|
|
if strings.TrimSpace(knowledgePrompt) != "" {
|
|
sections = append(sections, knowledgePrompt)
|
|
}
|
|
|
|
sections = append(sections, prompts.PromptRuleOutputRequirementsSection())
|
|
return strings.Join(sections, "\n\n")
|
|
}
|
|
|
|
func buildPromptRuleKnowledgeQuery(rule *promptRuleGenerationRecord, params map[string]interface{}) string {
|
|
parts := make([]string, 0, 6)
|
|
if rule != nil {
|
|
if text := strings.TrimSpace(rule.Name); text != "" {
|
|
parts = append(parts, text)
|
|
}
|
|
if rule.Scene != nil && strings.TrimSpace(*rule.Scene) != "" {
|
|
parts = append(parts, strings.TrimSpace(*rule.Scene))
|
|
}
|
|
if text := strings.TrimSpace(rule.PromptContent); text != "" {
|
|
parts = append(parts, text)
|
|
}
|
|
}
|
|
if taskName := strings.TrimSpace(extractString(params, "task_name")); taskName != "" {
|
|
parts = append(parts, taskName)
|
|
}
|
|
if target := strings.TrimSpace(extractString(params, "target_platform")); target != "" {
|
|
parts = append(parts, target)
|
|
}
|
|
return strings.Join(parts, "\n")
|
|
}
|
|
|
|
func extractGenerateCount(extra map[string]interface{}) int {
|
|
value := extractInt(extra, "generate_count")
|
|
if value <= 0 {
|
|
return 1
|
|
}
|
|
return value
|
|
}
|
|
|
|
func extractBool(extra map[string]interface{}, key string) bool {
|
|
if len(extra) == 0 {
|
|
return false
|
|
}
|
|
raw, ok := extra[key]
|
|
if !ok || raw == nil {
|
|
return false
|
|
}
|
|
switch typed := raw.(type) {
|
|
case bool:
|
|
return typed
|
|
case string:
|
|
normalized := strings.TrimSpace(strings.ToLower(typed))
|
|
return normalized == "true" || normalized == "1" || normalized == "yes"
|
|
case float64:
|
|
return typed != 0
|
|
case int:
|
|
return typed != 0
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func extractInt(extra map[string]interface{}, key string) int {
|
|
if len(extra) == 0 {
|
|
return 0
|
|
}
|
|
raw, ok := extra[key]
|
|
if !ok || raw == nil {
|
|
return 0
|
|
}
|
|
switch typed := raw.(type) {
|
|
case int:
|
|
return typed
|
|
case int32:
|
|
return int(typed)
|
|
case int64:
|
|
return int(typed)
|
|
case float64:
|
|
return int(typed)
|
|
case string:
|
|
value, _ := strconv.Atoi(strings.TrimSpace(typed))
|
|
return value
|
|
default:
|
|
return 0
|
|
}
|
|
}
|
|
|
|
func extractString(payload map[string]interface{}, key string) string {
|
|
if len(payload) == 0 {
|
|
return ""
|
|
}
|
|
raw, ok := payload[key]
|
|
if !ok || raw == nil {
|
|
return ""
|
|
}
|
|
switch typed := raw.(type) {
|
|
case string:
|
|
return typed
|
|
default:
|
|
return fmt.Sprintf("%v", typed)
|
|
}
|
|
}
|
|
|
|
func derefString(value *string) string {
|
|
if value == nil {
|
|
return ""
|
|
}
|
|
return *value
|
|
}
|