1471 lines
44 KiB
Go
1471 lines
44 KiB
Go
package usecase
|
||
|
||
import (
|
||
"context"
|
||
"encoding/json"
|
||
"fmt"
|
||
"net/url"
|
||
"strings"
|
||
"time"
|
||
"unicode/utf8"
|
||
|
||
"apps/backend/internal/module/ai"
|
||
"apps/backend/internal/module/scout/domain"
|
||
studioPublish "apps/backend/internal/module/studio/publish"
|
||
threadsDomain "apps/backend/internal/module/threads/domain"
|
||
usageDomain "apps/backend/internal/module/usage/domain"
|
||
usageUC "apps/backend/internal/module/usage/usecase"
|
||
|
||
"github.com/google/uuid"
|
||
"github.com/zeromicro/go-zero/core/logx"
|
||
)
|
||
|
||
// SettingsReader for dev_mode
|
||
type SettingsReader interface {
|
||
DevModeEnabled(ctx context.Context, uid int64) (bool, error)
|
||
}
|
||
|
||
type ReplyQueue interface {
|
||
QueueExternalReply(ctx context.Context, ownerUID int64, accountID, replyToMediaID, text, title string) (outboxID string, err error)
|
||
}
|
||
|
||
// OutreachPublishedHook fires after mark-published / successful outreach send path.
|
||
type OutreachPublishedHook func(ctx context.Context, ownerUID int64, postID, accountID string)
|
||
|
||
// ProductWatchLifecycle is a narrow bridge to Radar; Scout owns product CRUD,
|
||
// while Radar owns watch state and historical sweep semantics.
|
||
type ProductWatchLifecycle interface {
|
||
PauseProductWatches(ctx context.Context, ownerUID int64, productID string) (int, error)
|
||
}
|
||
|
||
type Service struct {
|
||
Repo domain.Repository
|
||
Settings SettingsReader
|
||
// Transport is retained only for test construction compatibility. Scout never publishes directly.
|
||
Transport studioPublish.Transport
|
||
AI ai.Client // drafts 不用；話題關鍵字 AI 擴充可走此 fallback
|
||
AIRegistry *ai.Registry
|
||
ResolveAI func(ctx context.Context, uid int64) (provider, model, apiKey string, err error)
|
||
Usage *usageUC.Service // 可空：單元測試不扣點
|
||
ReplyQueue ReplyQueue
|
||
Provider ThreadSearchProvider
|
||
Crawler ChromeCrawlerProvider
|
||
SessionSecret string
|
||
// OnOutreachPublished optional growth-loop outcome hook.
|
||
OnOutreachPublished OutreachPublishedHook
|
||
RadarLifecycle ProductWatchLifecycle
|
||
}
|
||
|
||
func New(repo domain.Repository) *Service {
|
||
return &Service{Repo: repo, Provider: newDefaultExaThreadsProvider()}
|
||
}
|
||
|
||
func (s *Service) ListBrands(ctx context.Context, ownerUID int64) ([]*domain.Brand, error) {
|
||
return s.Repo.ListBrands(ctx, ownerUID)
|
||
}
|
||
|
||
func (s *Service) GetBrand(ctx context.Context, ownerUID int64, id string) (*domain.Brand, error) {
|
||
b, err := s.Repo.GetBrand(ctx, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if b.OwnerUID != ownerUID {
|
||
return nil, domain.ErrForbidden
|
||
}
|
||
return b, nil
|
||
}
|
||
|
||
func (s *Service) CreateBrand(ctx context.Context, ownerUID int64, name, brief string) (*domain.Brand, error) {
|
||
now := domain.NowNano()
|
||
if name == "" {
|
||
name = "未命名品牌"
|
||
}
|
||
b := &domain.Brand{
|
||
ID: "br_" + uuid.NewString()[:10], OwnerUID: ownerUID,
|
||
DisplayName: name, Brief: brief, CreatedAt: now, UpdatedAt: now,
|
||
}
|
||
if err := s.Repo.SaveBrand(ctx, b); err != nil {
|
||
return nil, err
|
||
}
|
||
aid, _ := s.Repo.GetActiveBrandID(ctx, ownerUID)
|
||
if aid == "" {
|
||
_ = s.Repo.SetActiveBrandID(ctx, ownerUID, b.ID)
|
||
}
|
||
return b, nil
|
||
}
|
||
|
||
func (s *Service) SaveBrand(ctx context.Context, ownerUID int64, b *domain.Brand) (*domain.Brand, error) {
|
||
now := domain.NowNano()
|
||
if b.ID == "" {
|
||
return s.CreateBrand(ctx, ownerUID, b.DisplayName, b.Brief)
|
||
}
|
||
ex, err := s.GetBrand(ctx, ownerUID, b.ID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
b.OwnerUID = ownerUID
|
||
b.CreatedAt = ex.CreatedAt
|
||
b.UpdatedAt = now
|
||
if err := s.Repo.SaveBrand(ctx, b); err != nil {
|
||
return nil, err
|
||
}
|
||
return b, nil
|
||
}
|
||
|
||
func (s *Service) RemoveBrand(ctx context.Context, ownerUID int64, id string) error {
|
||
if _, err := s.GetBrand(ctx, ownerUID, id); err != nil {
|
||
return err
|
||
}
|
||
prods, _ := s.Repo.ListProducts(ctx, ownerUID, id)
|
||
if len(prods) > 0 {
|
||
return domain.ErrHasProducts
|
||
}
|
||
if err := s.Repo.DeleteBrand(ctx, id); err != nil {
|
||
return err
|
||
}
|
||
aid, _ := s.Repo.GetActiveBrandID(ctx, ownerUID)
|
||
if aid == id {
|
||
list, _ := s.Repo.ListBrands(ctx, ownerUID)
|
||
next := ""
|
||
if len(list) > 0 {
|
||
next = list[0].ID
|
||
}
|
||
_ = s.Repo.SetActiveBrandID(ctx, ownerUID, next)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) GetActiveBrandID(ctx context.Context, ownerUID int64) (string, error) {
|
||
return s.Repo.GetActiveBrandID(ctx, ownerUID)
|
||
}
|
||
|
||
func (s *Service) SetActiveBrandID(ctx context.Context, ownerUID int64, id string) error {
|
||
if id != "" {
|
||
if _, err := s.GetBrand(ctx, ownerUID, id); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return s.Repo.SetActiveBrandID(ctx, ownerUID, id)
|
||
}
|
||
|
||
func (s *Service) ListProducts(ctx context.Context, ownerUID int64, brandID string) ([]*domain.Product, error) {
|
||
return s.Repo.ListProducts(ctx, ownerUID, brandID)
|
||
}
|
||
|
||
func (s *Service) ListAllProducts(ctx context.Context, ownerUID int64) ([]*domain.Product, error) {
|
||
return s.Repo.ListProducts(ctx, ownerUID, "")
|
||
}
|
||
|
||
func (s *Service) GetProduct(ctx context.Context, ownerUID int64, id string) (*domain.Product, error) {
|
||
p, err := s.Repo.GetProduct(ctx, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.OwnerUID != ownerUID {
|
||
return nil, domain.ErrForbidden
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
func (s *Service) SaveProduct(ctx context.Context, ownerUID int64, p *domain.Product) (*domain.Product, error) {
|
||
now := domain.NowNano()
|
||
if p.BrandID == "" {
|
||
return nil, fmt.Errorf("%w: brand_id required", domain.ErrValidation)
|
||
}
|
||
if _, err := s.GetBrand(ctx, ownerUID, p.BrandID); err != nil {
|
||
return nil, err
|
||
}
|
||
if p.ID == "" {
|
||
p.ID = "prd_" + uuid.NewString()[:10]
|
||
p.CreatedAt = now
|
||
} else {
|
||
ex, err := s.GetProduct(ctx, ownerUID, p.ID)
|
||
if err == nil {
|
||
p.CreatedAt = ex.CreatedAt
|
||
} else if err != domain.ErrNotFound {
|
||
return nil, err
|
||
} else {
|
||
p.CreatedAt = now
|
||
}
|
||
}
|
||
p.OwnerUID = ownerUID
|
||
p.UpdatedAt = now
|
||
if p.Label == "" {
|
||
p.Label = "未命名產品"
|
||
}
|
||
if err := s.Repo.SaveProduct(ctx, p); err != nil {
|
||
return nil, err
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
func (s *Service) RemoveProduct(ctx context.Context, ownerUID int64, id string) error {
|
||
if _, err := s.GetProduct(ctx, ownerUID, id); err != nil {
|
||
return err
|
||
}
|
||
if s.RadarLifecycle != nil {
|
||
if _, err := s.RadarLifecycle.PauseProductWatches(ctx, ownerUID, id); err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return s.Repo.DeleteProduct(ctx, id)
|
||
}
|
||
|
||
func (s *Service) ImportProductFromURL(_ context.Context, raw string) (*domain.ImportDraft, error) {
|
||
raw = strings.TrimSpace(raw)
|
||
if raw == "" {
|
||
return nil, fmt.Errorf("%w: empty url", domain.ErrValidation)
|
||
}
|
||
u, err := url.Parse(raw)
|
||
if err != nil || (u.Host == "" && !strings.HasPrefix(raw, "http")) {
|
||
return nil, fmt.Errorf("%w: bad url", domain.ErrValidation)
|
||
}
|
||
host := ""
|
||
if u != nil {
|
||
host = u.Host
|
||
}
|
||
label := "匯入商品"
|
||
if host != "" {
|
||
label = host + " 商品"
|
||
}
|
||
return &domain.ImportDraft{
|
||
Label: label,
|
||
// 痛點／標籤要用「飼主正在煩惱的話」，不是產品賣點；匯入後請再改成真痛點
|
||
ProductContext: "從 " + raw + " 推估的產品情境（請改寫成實際賣點與使用場景）",
|
||
PainPoints: []string{"不知道怎麼選", "用了沒感覺", "擔心不適合／有副作用"},
|
||
MatchTags: []string{"求推薦", "有沒有人用過", "怎麼辦"},
|
||
PlacementURL: raw,
|
||
SourceNote: "importProductFromUrl · " + host,
|
||
}, nil
|
||
}
|
||
|
||
func (s *Service) PrepareBrief(ctx context.Context, ownerUID int64, intent, brandID, productID, purpose string, deep bool) (*domain.RunBrief, error) {
|
||
intent = strings.TrimSpace(intent)
|
||
if intent == "" && purpose != "provider" && purpose != "demand" {
|
||
return nil, fmt.Errorf("%w: intent required", domain.ErrValidation)
|
||
}
|
||
|
||
// 話題靈感：真正「產」關鍵字（規則變體 + 可選 AI），不再只拆使用者原句。
|
||
if purpose == "activity" {
|
||
return s.prepareActivityBrief(ctx, ownerUID, intent, deep)
|
||
}
|
||
|
||
mode := domain.ModeTheme
|
||
brief := &domain.RunBrief{
|
||
Intent: intent, Mode: mode, BrandID: brandID, ProductID: productID,
|
||
Pains: []string{}, Tags: []string{}, Periphery: []string{}, ScanTerms: []string{},
|
||
}
|
||
if productID != "" {
|
||
p, err := s.GetProduct(ctx, ownerUID, productID)
|
||
if err != nil && purpose == "provider" {
|
||
return nil, err
|
||
}
|
||
if err == nil {
|
||
mode = domain.ModeProduct
|
||
brief.Mode = mode
|
||
brief.ProductLabel = p.Label
|
||
brief.ProductContext = p.ProductContext
|
||
brief.Pains = append([]string(nil), p.PainPoints...)
|
||
brief.Tags = append([]string(nil), p.MatchTags...)
|
||
brief.BrandID = p.BrandID
|
||
brief.PlacementNote = "軟性經驗分享，避免硬廣"
|
||
}
|
||
}
|
||
if purpose == "provider" {
|
||
if productID == "" {
|
||
return nil, fmt.Errorf("%w: product required for provider matching", domain.ErrValidation)
|
||
}
|
||
p, err := s.GetProduct(ctx, ownerUID, productID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
pains, capabilities, excludes := providerMatchingFields(p)
|
||
brief.Mode = domain.ModeProvider
|
||
brief.BrandID = p.BrandID
|
||
brief.ProductLabel = p.Label
|
||
brief.ProductContext = p.ProductContext
|
||
brief.Pains = pains
|
||
brief.Tags = capabilities
|
||
brief.Periphery = excludes
|
||
brief.Intent = p.Label
|
||
brief.ResponseStance = "找可驗證的解法提供者，不推產品"
|
||
brief.ScanTerms = planScanTerms(brief)
|
||
brief.ThemeLabel = truncate(p.Label+" 解法媒合", 36)
|
||
brief.ThemeKey = brief.Mode + "|" + productID
|
||
return brief, nil
|
||
}
|
||
if purpose == "demand" {
|
||
if productID == "" {
|
||
return nil, fmt.Errorf("%w: product required for demand matching", domain.ErrValidation)
|
||
}
|
||
p, err := s.GetProduct(ctx, ownerUID, productID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
pains, excludes := demandMatchingFields(p)
|
||
brief.Mode = domain.ModeDemand
|
||
brief.BrandID = p.BrandID
|
||
brief.ProductLabel = p.Label
|
||
brief.ProductContext = p.ProductContext
|
||
brief.Pains = pains
|
||
brief.Periphery = excludes
|
||
brief.Intent = p.Label
|
||
brief.ResponseStance = "找正在求助的需求貼文，再決定如何回應"
|
||
brief.ScanTerms = planScanTerms(brief)
|
||
brief.ThemeLabel = truncate(p.Label+" 需求痛點", 36)
|
||
brief.ThemeKey = brief.Mode + "|" + productID
|
||
return brief, nil
|
||
}
|
||
if len(brief.Pains) == 0 {
|
||
// 預設用「求助／求推」語感，避免把產品賣點當搜尋詞
|
||
brief.Pains = []string{intent}
|
||
}
|
||
if len(brief.Tags) == 0 {
|
||
brief.Tags = tokenize(intent)
|
||
}
|
||
// periphery 只當作業備註，不進 scan_terms（否則會污染 Exa 查詢）
|
||
brief.Periphery = []string{"使用情境", "替代方案", "成分／規格"}
|
||
brief.ScanTerms = planScanTerms(brief)
|
||
brief.ThemeLabel = truncate(intent, 36)
|
||
brief.ThemeKey = mode + "|" + productID + "|" + truncate(intent, 48)
|
||
brief.ResponseStance = "先共鳴再給建議"
|
||
return brief, nil
|
||
}
|
||
|
||
func (s *Service) prepareActivityBrief(ctx context.Context, ownerUID int64, intent string, deep bool) (*domain.RunBrief, error) {
|
||
ruleTerms := planActivityTerms(intent)
|
||
// 預設就試 AI 產詞；deep 預留給前端「再想一輪」等同義，不額外收費路徑分叉。
|
||
_ = deep
|
||
aiTerms, err := s.suggestActivityTermsAI(ctx, ownerUID, intent, 8)
|
||
if err != nil {
|
||
// AI 不可用只降級規則，不擋話題工坊。
|
||
logx.Infof("scout activity terms AI unavailable uid=%d: %v", ownerUID, err)
|
||
}
|
||
terms := mergeActivityTerms(aiTerms, ruleTerms, 8)
|
||
if len(terms) == 0 {
|
||
// 最後防線：至少給可搜的核或原句截斷
|
||
if c := compactCore(intent); c != "" {
|
||
terms = []string{c}
|
||
} else {
|
||
terms = []string{truncateRunes(intent, 4)}
|
||
}
|
||
}
|
||
return &domain.RunBrief{
|
||
Intent: intent,
|
||
Mode: domain.ModeActivity,
|
||
Pains: []string{intent},
|
||
Tags: extractTopicCores(intent),
|
||
Periphery: []string{},
|
||
ScanTerms: terms,
|
||
ThemeLabel: truncate(intent, 36),
|
||
ThemeKey: domain.ModeActivity + "||" + truncate(intent, 48),
|
||
ResponseStance: "先共鳴再給建議",
|
||
}, nil
|
||
}
|
||
|
||
/*
|
||
suggestActivityTermsAI 請模型依意圖產生 Threads 短詞；失敗回 error，呼叫端降級規則。
|
||
計費：有 Usage 時走 ai_copy／source=scout.topic.suggest；無 Usage（測試）不扣點。
|
||
*/
|
||
func (s *Service) suggestActivityTermsAI(ctx context.Context, ownerUID int64, intent string, limit int) (_ []string, err error) {
|
||
if s == nil || (s.ResolveAI == nil && s.AI == nil) {
|
||
return nil, fmt.Errorf("ai not configured")
|
||
}
|
||
if limit <= 0 {
|
||
limit = 8
|
||
}
|
||
|
||
// 預留點數（Usage 可空）
|
||
var charged bool
|
||
var mode string
|
||
if s.Usage != nil {
|
||
m, berr := s.Usage.PrepareCall(ctx, ownerUID, usageDomain.MeterAICopy)
|
||
if berr != nil {
|
||
return nil, berr
|
||
}
|
||
mode = m
|
||
charged = true
|
||
defer func() {
|
||
if !charged {
|
||
return
|
||
}
|
||
if err != nil {
|
||
_ = s.Usage.ReleaseCall(ctx, ownerUID, usageDomain.MeterAICopy, mode)
|
||
return
|
||
}
|
||
if _, rerr := s.Usage.RecordCall(ctx, ownerUID, usageDomain.MeterAICopy, mode, "話題關鍵字建議", "scout.topic.suggest"); rerr != nil {
|
||
logx.Errorf("scout topic suggest record uid=%d: %v", ownerUID, rerr)
|
||
}
|
||
}()
|
||
}
|
||
|
||
raw, cerr := s.completeActivityAI(ctx, ownerUID, activityTermsPrompt(intent, limit))
|
||
if cerr != nil {
|
||
err = cerr
|
||
return nil, err
|
||
}
|
||
parsed := filterThreadsSearchableTerms(parseActivityAITerms(raw))
|
||
if len(parsed) == 0 {
|
||
err = fmt.Errorf("ai returned no searchable terms")
|
||
return nil, err
|
||
}
|
||
return capTerms(parsed, limit), nil
|
||
}
|
||
|
||
func (s *Service) completeActivityAI(ctx context.Context, ownerUID int64, prompt string) (string, error) {
|
||
if s.ResolveAI != nil && s.AIRegistry != nil {
|
||
provider, model, apiKey, rerr := s.ResolveAI(ctx, ownerUID)
|
||
if rerr != nil {
|
||
return "", rerr
|
||
}
|
||
if strings.TrimSpace(apiKey) == "" || strings.HasPrefix(strings.ToLower(apiKey), "fake") {
|
||
return "", fmt.Errorf("ai key empty")
|
||
}
|
||
c, cerr := s.AIRegistry.Client(provider)
|
||
if cerr != nil {
|
||
return "", cerr
|
||
}
|
||
return c.Complete(ctx, apiKey, model, prompt)
|
||
}
|
||
// 單元測試路徑：未接 ResolveAI 時才用注入的 AI client
|
||
if s.AI != nil {
|
||
return s.AI.Complete(ctx, "test-key", "grok-3", prompt)
|
||
}
|
||
return "", fmt.Errorf("ai not configured")
|
||
}
|
||
|
||
// providerMatchingFields keeps existing products usable: their established match
|
||
// tags become matching terms until the more specific provider terms are added.
|
||
func providerMatchingFields(p *domain.Product) (pains, capabilities, excludes []string) {
|
||
pains = nonEmptyTerms(p.PainPoints)
|
||
if len(pains) == 0 {
|
||
pains = nonEmptyTerms(p.MatchTags)
|
||
}
|
||
capabilities = nonEmptyTerms(p.ProviderCapabilityTerms)
|
||
if len(capabilities) == 0 {
|
||
capabilities = nonEmptyTerms(p.MatchTags)
|
||
}
|
||
if label := strings.TrimSpace(p.Label); label != "" {
|
||
if len(pains) == 0 {
|
||
pains = []string{label}
|
||
}
|
||
if len(capabilities) == 0 {
|
||
capabilities = []string{label}
|
||
}
|
||
}
|
||
excludes = nonEmptyTerms(p.ProviderExcludeTerms)
|
||
if label := strings.TrimSpace(p.Label); label != "" && !containsTerm(pains, label) && !containsTerm(capabilities, label) {
|
||
excludes = dedupeTerms(excludes, []string{label})
|
||
}
|
||
return pains, capabilities, excludes
|
||
}
|
||
|
||
func containsTerm(terms []string, want string) bool {
|
||
for _, term := range terms {
|
||
if strings.EqualFold(strings.TrimSpace(term), want) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func demandMatchingFields(p *domain.Product) (pains, excludes []string) {
|
||
pains = nonEmptyTerms(p.PainPoints)
|
||
if len(pains) == 0 {
|
||
pains = nonEmptyTerms(p.MatchTags)
|
||
}
|
||
if len(pains) == 0 && strings.TrimSpace(p.Label) != "" {
|
||
pains = []string{strings.TrimSpace(p.Label)}
|
||
}
|
||
excludes = nonEmptyTerms(p.ProviderExcludeTerms)
|
||
return pains, excludes
|
||
}
|
||
|
||
// SearchHitsOnly runs the dual-path Threads search without persisting Scout posts.
|
||
// Radar reuses this so the crawl split (api vs crawler via dev_mode) stays one code path (RG-01).
|
||
//
|
||
// Terms are searched one-by-one (fan-out) then deduped by canonical permalink — joining all
|
||
// terms into a single query dilutes Threads/Exa recall (daily radar sweep bug).
|
||
func (s *Service) SearchHitsOnly(ctx context.Context, ownerUID int64, terms []string, limit int) (hits []ThreadSearchResult, path string, err error) {
|
||
terms = nonEmptyTerms(terms)
|
||
if len(terms) == 0 {
|
||
return nil, "", fmt.Errorf("%w: need search terms", domain.ErrValidation)
|
||
}
|
||
if limit <= 0 {
|
||
limit = 10
|
||
}
|
||
if limit > 40 {
|
||
limit = 40
|
||
}
|
||
// per-query budget mirrors RunScanFromBrief / fanOutSearch.
|
||
perQuery := 8
|
||
if len(terms) == 1 {
|
||
perQuery = 20
|
||
} else if len(terms) >= 6 {
|
||
perQuery = 5
|
||
}
|
||
if perQuery > limit {
|
||
perQuery = limit
|
||
}
|
||
path = domain.PathAPI
|
||
devMode := false
|
||
if s.Settings != nil {
|
||
if d, derr := s.Settings.DevModeEnabled(ctx, ownerUID); derr == nil {
|
||
devMode = d
|
||
}
|
||
}
|
||
if devMode {
|
||
var storageState string
|
||
var serr error
|
||
if s.Repo != nil {
|
||
storageState, serr = s.GetCrawlerSessionToken(ctx, ownerUID)
|
||
} else {
|
||
serr = domain.ErrNoCrawlerSession
|
||
}
|
||
if serr != nil || strings.TrimSpace(storageState) == "" {
|
||
if s.Provider == nil {
|
||
return nil, domain.PathCrawler, domain.ErrNoCrawlerSession
|
||
}
|
||
logx.Infof("scout SearchHitsOnly: no crawler session uid=%d; falling back to api", ownerUID)
|
||
} else if s.Crawler == nil {
|
||
if s.Provider == nil {
|
||
return nil, domain.PathCrawler, fmt.Errorf("Chrome crawler is not configured")
|
||
}
|
||
logx.Infof("scout SearchHitsOnly: crawler not configured uid=%d; falling back to api", ownerUID)
|
||
} else {
|
||
path = domain.PathCrawler
|
||
hits, err = fanOutSearch(ctx, terms, perQuery, func(ctx context.Context, q string, n int) ([]ThreadSearchResult, error) {
|
||
return s.Crawler.SearchChrome(ctx, storageState, []string{q}, n)
|
||
})
|
||
if err == nil {
|
||
hits = fillSearchHitsToTarget(ctx, s, terms, hits, limit, path, storageState)
|
||
return capHits(hits, limit), path, nil
|
||
}
|
||
if s.Provider == nil {
|
||
return nil, path, err
|
||
}
|
||
logx.Errorf("scout SearchHitsOnly: crawler failed uid=%d: %v; falling back to api", ownerUID, err)
|
||
}
|
||
}
|
||
if s.Provider == nil {
|
||
return nil, path, fmt.Errorf("scout search provider is not configured")
|
||
}
|
||
path = domain.PathAPI
|
||
hits, err = fanOutSearch(ctx, terms, perQuery, func(ctx context.Context, q string, n int) ([]ThreadSearchResult, error) {
|
||
return s.Provider.SearchThreads(ctx, []string{q}, n)
|
||
})
|
||
if err != nil {
|
||
return nil, path, err
|
||
}
|
||
hits = fillSearchHitsToTarget(ctx, s, terms, hits, limit, path, "")
|
||
return capHits(hits, limit), path, nil
|
||
}
|
||
|
||
func capHits(hits []ThreadSearchResult, limit int) []ThreadSearchResult {
|
||
if limit > 0 && len(hits) > limit {
|
||
return hits[:limit]
|
||
}
|
||
return hits
|
||
}
|
||
|
||
func (s *Service) RunScanFromBrief(ctx context.Context, ownerUID int64, brief *domain.RunBrief) ([]*domain.Post, error) {
|
||
return s.runScanFromBrief(ctx, ownerUID, brief, "")
|
||
}
|
||
|
||
// RunScanForRun executes the same search pipeline without making results
|
||
// visible through the legacy posts collection. Results are staged under the
|
||
// running run; PublishRun opens the visibility barrier after the whole scan.
|
||
func (s *Service) RunScanForRun(ctx context.Context, ownerUID int64, runID string, brief *domain.RunBrief) ([]*domain.Post, error) {
|
||
if runID == "" {
|
||
return nil, domain.ErrValidation
|
||
}
|
||
posts, err := s.runScanFromBrief(ctx, ownerUID, brief, runID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if err := s.StageRunPosts(ctx, ownerUID, runID, posts); err != nil {
|
||
return nil, err
|
||
}
|
||
return posts, nil
|
||
}
|
||
|
||
func (s *Service) runScanFromBrief(ctx context.Context, ownerUID int64, brief *domain.RunBrief, runID string) ([]*domain.Post, error) {
|
||
if brief == nil {
|
||
return nil, fmt.Errorf("%w: nil brief", domain.ErrValidation)
|
||
}
|
||
terms := nonEmptyTerms(brief.ScanTerms)
|
||
if len(terms) == 0 {
|
||
return nil, fmt.Errorf("%w: need scan_terms", domain.ErrValidation)
|
||
}
|
||
if brief.Mode == domain.ModeProvider {
|
||
p, err := s.GetProduct(ctx, ownerUID, brief.ProductID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
pains, capabilities, excludes := providerMatchingFields(p)
|
||
brief.BrandID = p.BrandID
|
||
brief.ProductLabel = p.Label
|
||
brief.Pains = pains
|
||
brief.Tags = capabilities
|
||
brief.Periphery = excludes
|
||
terms = filterProviderScanTerms(terms, p)
|
||
if len(terms) == 0 {
|
||
return nil, fmt.Errorf("%w: provider scan terms cannot be product/category exclusions", domain.ErrValidation)
|
||
}
|
||
}
|
||
if brief.Mode == domain.ModeDemand {
|
||
p, err := s.GetProduct(ctx, ownerUID, brief.ProductID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
brief.BrandID = p.BrandID
|
||
brief.ProductLabel = p.Label
|
||
brief.Pains, brief.Periphery = demandMatchingFields(p)
|
||
}
|
||
path := domain.PathAPI
|
||
devMode := false
|
||
if s.Settings != nil {
|
||
if d, err := s.Settings.DevModeEnabled(ctx, ownerUID); err == nil {
|
||
devMode = d
|
||
}
|
||
}
|
||
// 每條關鍵字獨立搜尋再合併（使用者已審過的 scan_terms）
|
||
perQuery := 8
|
||
if len(terms) == 1 {
|
||
perQuery = 20
|
||
} else if len(terms) >= 6 {
|
||
perQuery = 5
|
||
}
|
||
target := brief.TargetCount
|
||
if target < 0 {
|
||
target = 0
|
||
}
|
||
if target > 40 {
|
||
target = 40
|
||
}
|
||
// 有目標時略抬高 per-query，減少第一輪就差很多則。
|
||
if target > 0 {
|
||
needPerTerm := (target + len(terms) - 1) / len(terms)
|
||
if needPerTerm > perQuery {
|
||
perQuery = needPerTerm
|
||
}
|
||
if perQuery > 20 {
|
||
perQuery = 20
|
||
}
|
||
}
|
||
|
||
var err error
|
||
var storageState string
|
||
if devMode {
|
||
storageState, err = s.GetCrawlerSessionToken(ctx, ownerUID)
|
||
if err != nil {
|
||
return nil, domain.ErrNoCrawlerSession
|
||
}
|
||
path = domain.PathCrawler
|
||
if s.Crawler == nil {
|
||
return nil, fmt.Errorf("Chrome crawler is not configured")
|
||
}
|
||
} else {
|
||
if s.Provider == nil {
|
||
return nil, fmt.Errorf("scout search provider is not configured")
|
||
}
|
||
}
|
||
pipeline, err := s.searchEligiblePipeline(ctx, ownerUID, terms, brief, target, path, storageState, perQuery)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return s.persistSearchHitsWithRun(ctx, ownerUID, brief, path, runID, pipeline.Hits)
|
||
}
|
||
|
||
// fillSearchHitsToTarget tops up hits when the first fan-out misses the daily goal.
|
||
// 1) Same path with higher per-query 2) If primary is crawler, secondary is search Provider.
|
||
func fillSearchHitsToTarget(
|
||
ctx context.Context,
|
||
s *Service,
|
||
terms []string,
|
||
hits []ThreadSearchResult,
|
||
target int,
|
||
primaryPath string,
|
||
crawlerState string,
|
||
) []ThreadSearchResult {
|
||
if target <= 0 || len(hits) >= target {
|
||
return hits
|
||
}
|
||
// Stage A: same path, boost per-query (cap 20).
|
||
boost := 20
|
||
need := target - len(hits)
|
||
if need < boost {
|
||
// still request up to boost so sparse terms can contribute
|
||
_ = need
|
||
}
|
||
var more []ThreadSearchResult
|
||
var err error
|
||
if primaryPath == domain.PathCrawler && s.Crawler != nil && crawlerState != "" {
|
||
more, err = fanOutSearch(ctx, terms, boost, func(ctx context.Context, q string, limit int) ([]ThreadSearchResult, error) {
|
||
return s.Crawler.SearchChrome(ctx, crawlerState, []string{q}, limit)
|
||
})
|
||
} else if s.Provider != nil {
|
||
more, err = fanOutSearch(ctx, terms, boost, func(ctx context.Context, q string, limit int) ([]ThreadSearchResult, error) {
|
||
return s.Provider.SearchThreads(ctx, []string{q}, limit)
|
||
})
|
||
}
|
||
if err == nil && len(more) > 0 {
|
||
hits = mergeHitsDedupe(hits, more)
|
||
}
|
||
if len(hits) >= target {
|
||
return hits
|
||
}
|
||
// Stage B: crawler primary → top up with search provider (Exa / Threads-domain search).
|
||
if primaryPath == domain.PathCrawler && s.Provider != nil {
|
||
topup, terr := fanOutSearch(ctx, terms, boost, func(ctx context.Context, q string, limit int) ([]ThreadSearchResult, error) {
|
||
return s.Provider.SearchThreads(ctx, []string{q}, limit)
|
||
})
|
||
if terr == nil && len(topup) > 0 {
|
||
hits = mergeHitsDedupe(hits, topup)
|
||
}
|
||
}
|
||
return hits
|
||
}
|
||
|
||
func mergeHitsDedupe(groups ...[]ThreadSearchResult) []ThreadSearchResult {
|
||
seen := make(map[string]struct{})
|
||
var out []ThreadSearchResult
|
||
for _, group := range groups {
|
||
for _, hit := range group {
|
||
permalink := canonicalPermalink(hit.URL)
|
||
key := canonicalPostIdentity(hit.URL)
|
||
if key == "" {
|
||
key = permalink
|
||
}
|
||
if key == "" {
|
||
continue
|
||
}
|
||
if _, ok := seen[key]; ok {
|
||
continue
|
||
}
|
||
seen[key] = struct{}{}
|
||
if permalink != "" {
|
||
hit.URL = permalink
|
||
}
|
||
out = append(out, hit)
|
||
}
|
||
}
|
||
return out
|
||
}
|
||
|
||
func filterProviderScanTerms(terms []string, p *domain.Product) []string {
|
||
var out []string
|
||
for _, term := range terms {
|
||
term = strings.TrimSpace(term)
|
||
if term == "" || strings.EqualFold(term, p.Label) || hasMatchingTerm(strings.ToLower(term), p.ProviderExcludeTerms) {
|
||
continue
|
||
}
|
||
out = append(out, term)
|
||
}
|
||
return dedupeTerms(out)
|
||
}
|
||
|
||
// fanOutSearch runs one search per query term and dedupes by canonical permalink.
|
||
func fanOutSearch(ctx context.Context, terms []string, perQuery int, search func(context.Context, string, int) ([]ThreadSearchResult, error)) ([]ThreadSearchResult, error) {
|
||
if perQuery < 1 {
|
||
perQuery = 5
|
||
}
|
||
seen := make(map[string]struct{})
|
||
out := make([]ThreadSearchResult, 0, len(terms)*perQuery)
|
||
var firstErr error
|
||
for _, term := range terms {
|
||
hits, err := search(ctx, term, perQuery)
|
||
if err != nil {
|
||
if firstErr == nil {
|
||
firstErr = err
|
||
}
|
||
if isCrawlerSessionDead(err) {
|
||
break
|
||
}
|
||
continue
|
||
}
|
||
for _, hit := range hits {
|
||
permalink := canonicalPermalink(hit.URL)
|
||
identity := canonicalPostIdentity(hit.URL)
|
||
if identity == "" || permalink == "" {
|
||
continue
|
||
}
|
||
if _, ok := seen[identity]; ok {
|
||
continue
|
||
}
|
||
seen[identity] = struct{}{}
|
||
hit.URL = permalink
|
||
// 記住是哪條 query 命中，方便 search_tag
|
||
if hit.MatchedQuery == "" {
|
||
hit.MatchedQuery = term
|
||
}
|
||
out = append(out, hit)
|
||
}
|
||
}
|
||
if len(out) == 0 && firstErr != nil {
|
||
return nil, firstErr
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *Service) persistSearchHits(ctx context.Context, ownerUID int64, brief *domain.RunBrief, path string, hits []ThreadSearchResult) ([]*domain.Post, error) {
|
||
return s.persistSearchHitsWithRun(ctx, ownerUID, brief, path, "", hits)
|
||
}
|
||
|
||
func (s *Service) persistSearchHitsWithRun(ctx context.Context, ownerUID int64, brief *domain.RunBrief, path, runID string, hits []ThreadSearchResult) ([]*domain.Post, error) {
|
||
now := domain.NowNano()
|
||
// Provider 原始順序只用於 deterministic created_at；最終結果由
|
||
// evaluator score 排序，不能再被來源的時間／track 順序覆蓋。
|
||
hasTrack := hitsHaveTrack(hits)
|
||
out := make([]*domain.Post, 0, len(hits))
|
||
evaluator := NewCandidateEvaluator(brief)
|
||
evaluator.SetHistoricalSeenLookup(func(identity string) (bool, error) {
|
||
return s.Repo.HasSeenIdentity(ctx, ownerUID, identity)
|
||
})
|
||
for i, hit := range hits {
|
||
evaluation := evaluator.EvaluateAt(hit, now)
|
||
if evaluation.Decision != CandidateEligible {
|
||
continue
|
||
}
|
||
text := evaluation.Text
|
||
permalink := evaluation.Permalink
|
||
postedAt := evaluation.PostedAt
|
||
// created_at：保 crawler 回傳序（i 越小越前）；有發文時間仍寫 PostedAt 供 UI
|
||
createdAt := now - int64(i)*1000
|
||
if postedAt > 0 && !hasTrack {
|
||
// 非 crawler 路徑仍用發文時間當 created 序
|
||
createdAt = postedAt
|
||
}
|
||
p := &domain.Post{
|
||
ID: permalinkID(ownerUID, permalink), ExternalID: permalink, Permalink: permalink,
|
||
OwnerUID: ownerUID, RunID: runID, BrandID: brief.BrandID, Author: authorFromThreadsURL(permalink), Text: text,
|
||
SearchTag: evaluation.SearchTag, Opportunity: "", OutreachStatus: domain.OutreachNew,
|
||
Score: evaluation.Score, Classification: evaluation.Classification, MatchedProductID: brief.ProductID, MatchedProductLabel: brief.ProductLabel,
|
||
MatchReason: evaluation.Reason, ScoutMode: brief.Mode, IntentSnippet: brief.Intent,
|
||
ThemeKey: brief.ThemeKey, ThemeLabel: brief.ThemeLabel, ScanPath: path,
|
||
PostedAt: postedAt, CreatedAt: createdAt,
|
||
}
|
||
if runID == "" {
|
||
if err := s.Repo.SavePost(ctx, p); err != nil {
|
||
return nil, err
|
||
}
|
||
}
|
||
out = append(out, p)
|
||
}
|
||
// Score is the primary quality order. Posted/created time and ID only make
|
||
// equal scores deterministic; an old but highly relevant post can therefore
|
||
// still be returned ahead of a newer weak match.
|
||
sortPostsByScore(out)
|
||
return out, nil
|
||
}
|
||
|
||
func sortPostsByScore(posts []*domain.Post) {
|
||
for i := 0; i < len(posts); i++ {
|
||
for j := i + 1; j < len(posts); j++ {
|
||
a, b := posts[i], posts[j]
|
||
shouldSwap := false
|
||
if a.Score != b.Score {
|
||
shouldSwap = b.Score > a.Score
|
||
} else if (a.PostedAt > 0) != (b.PostedAt > 0) {
|
||
shouldSwap = b.PostedAt > 0
|
||
} else if a.PostedAt > 0 && a.PostedAt != b.PostedAt {
|
||
shouldSwap = b.PostedAt > a.PostedAt
|
||
} else if a.CreatedAt != b.CreatedAt {
|
||
shouldSwap = b.CreatedAt > a.CreatedAt
|
||
} else {
|
||
shouldSwap = b.ID > a.ID
|
||
}
|
||
if shouldSwap {
|
||
posts[i], posts[j] = posts[j], posts[i]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// sortPostsByResultTime is kept as a package-local compatibility name for
|
||
// older tests/callers; result ordering now intentionally delegates to score.
|
||
func sortPostsByResultTime(posts []*domain.Post) { sortPostsByScore(posts) }
|
||
|
||
func hitsHaveTrack(hits []ThreadSearchResult) bool {
|
||
for _, h := range hits {
|
||
if h.Track != "" {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
// searchAnchors 是產詞常用的口語後綴，不能單獨當「主題相關」依據。
|
||
var searchAnchors = map[string]bool{
|
||
"求推薦": true, "推薦": true, "分享": true, "心得": true,
|
||
"活動": true, "怎麼辦": true, "詢問": true, "討論": true,
|
||
"有人知道": true, "請問": true,
|
||
"熱門": true, "最新": true, "近期": true,
|
||
}
|
||
|
||
// textMatchesSearchTerm：正文須含查詢的主題核（非口語錨點）。
|
||
// 「外包 求推薦」→ 必須含「外包」；純「求推薦」才允許只命中錨點。
|
||
func textMatchesSearchTerm(text, term string) bool {
|
||
body := normalizeSignal(text)
|
||
if body == "" || strings.TrimSpace(term) == "" {
|
||
return false
|
||
}
|
||
tokens := strings.Fields(strings.TrimSpace(term))
|
||
if len(tokens) == 0 {
|
||
tokens = []string{strings.TrimSpace(term)}
|
||
}
|
||
var content, anchors []string
|
||
for _, tok := range tokens {
|
||
t := strings.ToLower(strings.TrimSpace(tok))
|
||
if t == "" || utf8.RuneCountInString(t) < 2 {
|
||
continue
|
||
}
|
||
if searchAnchors[t] {
|
||
anchors = append(anchors, t)
|
||
} else {
|
||
content = append(content, strings.ReplaceAll(t, " ", ""))
|
||
}
|
||
}
|
||
// 有主題核：每個主題核都要命中；錨點只是搜尋修飾，不要求正文出現。
|
||
// 「後端 外包」不能因為只提到「外包」就混入其他職種。
|
||
if len(content) > 0 {
|
||
for _, c := range content {
|
||
if !strings.Contains(body, c) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
// 只有錨點：放寬（使用者刻意只搜「求推薦」）
|
||
for _, a := range anchors {
|
||
if strings.Contains(body, strings.ReplaceAll(a, " ", "")) {
|
||
return true
|
||
}
|
||
}
|
||
// 無可用 token：不誤殺
|
||
return true
|
||
}
|
||
|
||
func matchingSearchTerm(text string, terms []string) string {
|
||
for _, term := range terms {
|
||
if term = strings.TrimSpace(term); term != "" && textMatchesSearchTerm(text, term) {
|
||
return term
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func maxInt(a, b int) int {
|
||
if a > b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func minInt(a, b int) int {
|
||
if a < b {
|
||
return a
|
||
}
|
||
return b
|
||
}
|
||
|
||
func sortHitsByTrackAndPostedAt(hits []ThreadSearchResult) {
|
||
trackRank := func(t string) int {
|
||
switch t {
|
||
case "both":
|
||
return 0
|
||
case "recent":
|
||
return 1
|
||
case "top":
|
||
return 2
|
||
default:
|
||
return 3
|
||
}
|
||
}
|
||
for i := 0; i < len(hits); i++ {
|
||
for j := i + 1; j < len(hits); j++ {
|
||
ri, rj := trackRank(hits[i].Track), trackRank(hits[j].Track)
|
||
if rj < ri {
|
||
hits[i], hits[j] = hits[j], hits[i]
|
||
continue
|
||
}
|
||
if rj > ri {
|
||
continue
|
||
}
|
||
ai, aj := hits[i].PublishedAt, hits[j].PublishedAt
|
||
if ai == 0 && aj == 0 {
|
||
continue
|
||
}
|
||
if ai == 0 || (aj > 0 && aj > ai) {
|
||
hits[i], hits[j] = hits[j], hits[i]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// sortPostsByTrackAndPostedAt 保留相容：目前先 track 再時間在 sortHits 已做；此函式 no-op 佔位避免誤用。
|
||
func sortPostsByTrackAndPostedAt(_ []*domain.Post, _ []ThreadSearchResult) {}
|
||
|
||
func sortHitsByPostedAt(hits []ThreadSearchResult) {
|
||
// newest first; unknown published time last
|
||
for i := 0; i < len(hits); i++ {
|
||
for j := i + 1; j < len(hits); j++ {
|
||
ai, aj := hits[i].PublishedAt, hits[j].PublishedAt
|
||
if ai == 0 && aj == 0 {
|
||
continue
|
||
}
|
||
if ai == 0 || (aj > 0 && aj > ai) {
|
||
hits[i], hits[j] = hits[j], hits[i]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func sortPostsByPostedAt(posts []*domain.Post) {
|
||
for i := 0; i < len(posts); i++ {
|
||
for j := i + 1; j < len(posts); j++ {
|
||
ai := posts[i].PostedAt
|
||
if ai == 0 {
|
||
ai = posts[i].CreatedAt
|
||
}
|
||
aj := posts[j].PostedAt
|
||
if aj == 0 {
|
||
aj = posts[j].CreatedAt
|
||
}
|
||
if aj > ai {
|
||
posts[i], posts[j] = posts[j], posts[i]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func sortActivityPostsByMomentum(posts []*domain.Post) {
|
||
for i := 0; i < len(posts); i++ {
|
||
for j := i + 1; j < len(posts); j++ {
|
||
if posts[j].Score > posts[i].Score ||
|
||
(posts[j].Score == posts[i].Score && postTime(posts[j]) > postTime(posts[i])) {
|
||
posts[i], posts[j] = posts[j], posts[i]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
func postTime(post *domain.Post) int64 {
|
||
if post.PostedAt > 0 {
|
||
return post.PostedAt
|
||
}
|
||
return post.CreatedAt
|
||
}
|
||
|
||
func matchingTerm(text string, terms []string) string {
|
||
for _, term := range terms {
|
||
if term = strings.TrimSpace(term); term != "" && strings.Contains(strings.ToLower(text), strings.ToLower(term)) {
|
||
return term
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func authorFromThreadsURL(raw string) string {
|
||
u, err := url.Parse(raw)
|
||
if err != nil {
|
||
return ""
|
||
}
|
||
for _, segment := range strings.Split(u.Path, "/") {
|
||
segment = strings.TrimPrefix(strings.TrimSpace(segment), "@")
|
||
if segment != "" {
|
||
return segment
|
||
}
|
||
}
|
||
return ""
|
||
}
|
||
|
||
func (s *Service) ListPosts(ctx context.Context, ownerUID int64, brandID string) ([]*domain.Post, error) {
|
||
posts, err := s.Repo.ListPosts(ctx, ownerUID, brandID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return dedupePostsByIdentity(posts), nil
|
||
}
|
||
|
||
// dedupePostsByIdentity hides legacy duplicates that were stored before IDs
|
||
// were based on Threads post shortcodes. It is read-only: no user history is deleted.
|
||
func dedupePostsByIdentity(posts []*domain.Post) []*domain.Post {
|
||
seen := make(map[string]int, len(posts))
|
||
out := make([]*domain.Post, 0, len(posts))
|
||
for _, post := range posts {
|
||
if post == nil {
|
||
continue
|
||
}
|
||
key := canonicalPostIdentity(post.Permalink)
|
||
if key == "" {
|
||
key = canonicalPostIdentity(post.ExternalID)
|
||
}
|
||
if key == "" {
|
||
key = "id:" + post.ID
|
||
}
|
||
if idx, ok := seen[key]; ok {
|
||
if preferScoutPost(post, out[idx]) {
|
||
out[idx] = post
|
||
}
|
||
continue
|
||
}
|
||
seen[key] = len(out)
|
||
out = append(out, post)
|
||
}
|
||
sortPostsByScore(out)
|
||
return out
|
||
}
|
||
|
||
func preferScoutPost(candidate, current *domain.Post) bool {
|
||
statusRank := func(status string) int {
|
||
switch status {
|
||
case domain.OutreachPublished:
|
||
return 5
|
||
case domain.OutreachQueued:
|
||
return 4
|
||
case domain.OutreachDrafted, domain.OutreachSkipped:
|
||
return 3
|
||
case domain.OutreachNew:
|
||
return 1
|
||
default:
|
||
return 0
|
||
}
|
||
}
|
||
if a, b := statusRank(candidate.OutreachStatus), statusRank(current.OutreachStatus); a != b {
|
||
return a > b
|
||
}
|
||
if candidate.CreatedAt != current.CreatedAt {
|
||
return candidate.CreatedAt > current.CreatedAt
|
||
}
|
||
return candidate.Score > current.Score
|
||
}
|
||
|
||
func (s *Service) DraftOutreach(ctx context.Context, ownerUID int64, postID, personaID string) (*domain.Post, error) {
|
||
_ = personaID
|
||
p, err := s.getPostOwned(ctx, ownerUID, postID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.ScoutMode == domain.ModeProvider {
|
||
return nil, fmt.Errorf("%w: provider matches do not support outreach drafts", domain.ErrValidation)
|
||
}
|
||
draft := "嗨 @" + p.Author + "，看到你提到「" + p.SearchTag + "」，我也遇過類似情況。若你願意，想聽聽你後來怎麼處理。"
|
||
if p.ScoutMode == domain.ModeActivity {
|
||
draft = "嗨 @" + p.Author + "，這個「" + p.SearchTag + "」很有意思。你自己最在意哪一部分？"
|
||
}
|
||
p.DraftText = draft
|
||
p.OutreachStatus = domain.OutreachDrafted
|
||
if err := s.Repo.SavePost(ctx, p); err != nil {
|
||
return nil, err
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
func (s *Service) SkipOutreach(ctx context.Context, ownerUID int64, postID string) (*domain.Post, error) {
|
||
p, err := s.getPostOwned(ctx, ownerUID, postID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
p.OutreachStatus = domain.OutreachSkipped
|
||
if err := s.Repo.SavePost(ctx, p); err != nil {
|
||
return nil, err
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
func (s *Service) MarkPublished(ctx context.Context, ownerUID int64, postID string) (*domain.Post, error) {
|
||
p, err := s.getPostOwned(ctx, ownerUID, postID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.ScoutMode == domain.ModeProvider {
|
||
return nil, fmt.Errorf("%w: provider matches cannot be marked as outreach", domain.ErrValidation)
|
||
}
|
||
p.OutreachStatus = domain.OutreachPublished
|
||
if err := s.Repo.SavePost(ctx, p); err != nil {
|
||
return nil, err
|
||
}
|
||
// growth-loop: brand learning bump when brand known
|
||
if p.BrandID != "" {
|
||
if b, berr := s.Repo.GetBrand(ctx, p.BrandID); berr == nil && b != nil && b.OwnerUID == ownerUID {
|
||
b.LearningVersion++
|
||
b.LearnedFromPostsCount++
|
||
b.LastLearnedAt = domain.NowNano()
|
||
b.LearningSummary = fmt.Sprintf("海巡外展累積 %d 則 · 知識 v%d", b.LearnedFromPostsCount, b.LearningVersion)
|
||
b.UpdatedAt = domain.NowNano()
|
||
_ = s.Repo.SaveBrand(ctx, b)
|
||
}
|
||
}
|
||
if s.OnOutreachPublished != nil {
|
||
s.OnOutreachPublished(ctx, ownerUID, postID, "")
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
func (s *Service) SendOutreach(ctx context.Context, ownerUID int64, postID, text, accountID string) (*domain.Post, error) {
|
||
p, err := s.getPostOwned(ctx, ownerUID, postID)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.ScoutMode == domain.ModeProvider {
|
||
return nil, fmt.Errorf("%w: provider matches do not support outreach", domain.ErrValidation)
|
||
}
|
||
text = strings.TrimSpace(text)
|
||
if text == "" {
|
||
text = p.DraftText
|
||
}
|
||
if text == "" {
|
||
return nil, fmt.Errorf("%w: empty outreach text", domain.ErrValidation)
|
||
}
|
||
if s.ReplyQueue == nil {
|
||
return nil, fmt.Errorf("Scout reply Outbox is not configured")
|
||
}
|
||
mediaID := p.ExternalID
|
||
// A permalink can be resolved to a real Threads media ID before the official
|
||
// API sends. This also refreshes any legacy IDs that were not Graph media IDs.
|
||
if strings.TrimSpace(p.Permalink) != "" && s.Crawler != nil {
|
||
state, err := s.GetCrawlerSessionToken(ctx, ownerUID)
|
||
if err != nil {
|
||
return nil, domain.ErrNoCrawlerSession
|
||
}
|
||
mediaID, err = s.Crawler.ResolveMediaID(ctx, state, p.Permalink)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("%w: unable to resolve the target Threads post: %v", domain.ErrValidation, err)
|
||
}
|
||
}
|
||
if !isNumericMediaID(mediaID) {
|
||
if s.Crawler == nil {
|
||
return nil, fmt.Errorf("%w: target Threads media ID is not resolved; configure Chrome crawler", domain.ErrValidation)
|
||
}
|
||
state, err := s.GetCrawlerSessionToken(ctx, ownerUID)
|
||
if err != nil {
|
||
return nil, domain.ErrNoCrawlerSession
|
||
}
|
||
mediaID, err = s.Crawler.ResolveMediaID(ctx, state, p.Permalink)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("%w: unable to resolve the target Threads post: %v", domain.ErrValidation, err)
|
||
}
|
||
}
|
||
p.ExternalID = mediaID
|
||
outboxID, err := s.ReplyQueue.QueueExternalReply(ctx, ownerUID, accountID, mediaID, text, "Scout 回覆 · "+truncate(p.Author, 30))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
p.DraftText = text
|
||
p.OutboxID = outboxID
|
||
p.OutreachStatus = domain.OutreachQueued
|
||
if err := s.Repo.SavePost(ctx, p); err != nil {
|
||
return nil, err
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
/*
|
||
ResolveMediaID turns a Threads permalink into a numeric Graph media ID via the
|
||
configured Chrome crawler. Already-numeric input is returned unchanged.
|
||
|
||
Exported so other modules (radar 商機回覆一鍵送出) can reuse the same resolver
|
||
instead of re-implementing crawler session handling.
|
||
*/
|
||
func (s *Service) ResolveMediaID(ctx context.Context, ownerUID int64, permalink string) (string, error) {
|
||
if isNumericMediaID(permalink) {
|
||
return permalink, nil
|
||
}
|
||
if s.Crawler == nil {
|
||
return "", fmt.Errorf("%w: target Threads media ID is not resolved; configure Chrome crawler", domain.ErrValidation)
|
||
}
|
||
state, err := s.GetCrawlerSessionToken(ctx, ownerUID)
|
||
if err != nil {
|
||
return "", domain.ErrNoCrawlerSession
|
||
}
|
||
mediaID, err := s.Crawler.ResolveMediaID(ctx, state, permalink)
|
||
if err != nil {
|
||
return "", fmt.Errorf("%w: unable to resolve the target Threads post: %v", domain.ErrValidation, err)
|
||
}
|
||
return mediaID, nil
|
||
}
|
||
|
||
func isNumericMediaID(value string) bool {
|
||
if value == "" {
|
||
return false
|
||
}
|
||
for _, ch := range value {
|
||
if ch < '0' || ch > '9' {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
|
||
func (s *Service) RemovePost(ctx context.Context, ownerUID int64, postID string) error {
|
||
if _, err := s.getPostOwned(ctx, ownerUID, postID); err != nil {
|
||
return err
|
||
}
|
||
return s.Repo.DeletePost(ctx, postID)
|
||
}
|
||
|
||
func (s *Service) RemoveTheme(ctx context.Context, ownerUID int64, themeKey string) error {
|
||
if err := s.Repo.DeletePostsByTheme(ctx, ownerUID, themeKey); err != nil {
|
||
return err
|
||
}
|
||
// A patrol batch owns both its hits and its research snapshot.
|
||
if err := s.Repo.DeleteHomework(ctx, ownerUID, themeKey); err != nil && err != domain.ErrNotFound {
|
||
return err
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *Service) ListHomework(ctx context.Context, ownerUID int64) ([]*domain.Homework, error) {
|
||
return s.Repo.ListHomework(ctx, ownerUID)
|
||
}
|
||
|
||
func (s *Service) SaveHomework(ctx context.Context, ownerUID int64, h *domain.Homework) (*domain.Homework, error) {
|
||
if h.ThemeKey == "" {
|
||
return nil, fmt.Errorf("%w: theme_key required", domain.ErrValidation)
|
||
}
|
||
h.OwnerUID = ownerUID
|
||
if h.CreatedAt == 0 {
|
||
h.CreatedAt = domain.NowNano()
|
||
}
|
||
if err := s.Repo.SaveHomework(ctx, h); err != nil {
|
||
return nil, err
|
||
}
|
||
return h, nil
|
||
}
|
||
|
||
func (s *Service) GetHomework(ctx context.Context, ownerUID int64, themeKey string) (*domain.Homework, error) {
|
||
return s.Repo.GetHomework(ctx, ownerUID, themeKey)
|
||
}
|
||
|
||
func (s *Service) RemoveHomework(ctx context.Context, ownerUID int64, themeKey string) error {
|
||
return s.Repo.DeleteHomework(ctx, ownerUID, themeKey)
|
||
}
|
||
|
||
func (s *Service) SetCrawlerSession(ctx context.Context, ownerUID int64, storageState string) error {
|
||
expiresAt, err := validateStorageState(storageState)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
if s.SessionSecret == "" {
|
||
return fmt.Errorf("%w: crawler session secret is required", domain.ErrValidation)
|
||
}
|
||
storageStateEnc, err := threadsDomain.Seal(s.SessionSecret, storageState)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
now := domain.NowNano()
|
||
return s.Repo.SetCrawlerSession(ctx, &domain.CrawlerSession{
|
||
OwnerUID: ownerUID, StorageStateEnc: storageStateEnc, UpdatedAt: now, ExpiresAt: expiresAt,
|
||
})
|
||
}
|
||
|
||
// GetCrawlerSessionToken returns decrypted Playwright storageState JSON for browser crawl.
|
||
func (s *Service) GetCrawlerSessionToken(ctx context.Context, ownerUID int64) (string, error) {
|
||
sess, err := s.Repo.GetCrawlerSession(ctx, ownerUID)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
if sess == nil || sess.StorageStateEnc == "" || (sess.ExpiresAt > 0 && sess.ExpiresAt <= domain.NowNano()) {
|
||
return "", domain.ErrNoCrawlerSession
|
||
}
|
||
if s.SessionSecret == "" {
|
||
return "", fmt.Errorf("%w: crawler session secret is required", domain.ErrValidation)
|
||
}
|
||
storageState, err := threadsDomain.Open(s.SessionSecret, sess.StorageStateEnc)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
return storageState, nil
|
||
}
|
||
|
||
type storageStateCookie struct {
|
||
Domain string `json:"domain"`
|
||
Expires float64 `json:"expires"`
|
||
}
|
||
|
||
func validateStorageState(storageState string) (int64, error) {
|
||
if len(storageState) > 256*1024 {
|
||
return 0, fmt.Errorf("%w: storage state exceeds 256KB", domain.ErrValidation)
|
||
}
|
||
var state map[string]json.RawMessage
|
||
if err := json.Unmarshal([]byte(storageState), &state); err != nil || state == nil {
|
||
return 0, fmt.Errorf("%w: storage state must be a JSON object", domain.ErrValidation)
|
||
}
|
||
rawCookies, ok := state["cookies"]
|
||
if !ok {
|
||
return 0, fmt.Errorf("%w: cookies required", domain.ErrValidation)
|
||
}
|
||
var cookies []storageStateCookie
|
||
if err := json.Unmarshal(rawCookies, &cookies); err != nil || len(cookies) == 0 {
|
||
return 0, fmt.Errorf("%w: cookies must be a nonempty array", domain.ErrValidation)
|
||
}
|
||
var expiresAt int64
|
||
for _, cookie := range cookies {
|
||
domainName := strings.TrimPrefix(strings.ToLower(strings.TrimSpace(cookie.Domain)), ".")
|
||
if !allowedCookieDomain(domainName) {
|
||
return 0, fmt.Errorf("%w: cookie domain %q is not allowed", domain.ErrValidation, cookie.Domain)
|
||
}
|
||
if cookie.Expires > 0 {
|
||
expires := int64(cookie.Expires * float64(time.Second))
|
||
if expiresAt == 0 || expires < expiresAt {
|
||
expiresAt = expires
|
||
}
|
||
}
|
||
}
|
||
return expiresAt, nil
|
||
}
|
||
|
||
func allowedCookieDomain(domainName string) bool {
|
||
for _, allowed := range []string{"threads.net", "threads.com", "instagram.com", "facebook.com"} {
|
||
if domainName == allowed || strings.HasSuffix(domainName, "."+allowed) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
func (s *Service) ClearCrawlerSession(ctx context.Context, ownerUID int64) error {
|
||
return s.Repo.ClearCrawlerSession(ctx, ownerUID)
|
||
}
|
||
|
||
// TopicRemoved — SC: ScoutTopic CRUD not implemented
|
||
func (s *Service) TopicRemoved() error { return domain.ErrTopicRemoved }
|
||
|
||
func (s *Service) getPostOwned(ctx context.Context, ownerUID int64, id string) (*domain.Post, error) {
|
||
p, err := s.Repo.GetPost(ctx, id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
if p.OwnerUID != ownerUID {
|
||
return nil, domain.ErrForbidden
|
||
}
|
||
return p, nil
|
||
}
|
||
|
||
// GetPost returns one owned scout post (promote / detail).
|
||
func (s *Service) GetPost(ctx context.Context, ownerUID int64, id string) (*domain.Post, error) {
|
||
return s.getPostOwned(ctx, ownerUID, id)
|
||
}
|
||
|
||
func tokenize(s string) []string {
|
||
parts := strings.FieldsFunc(s, func(r rune) bool {
|
||
return r == ' ' || r == '、' || r == ',' || r == '/'
|
||
})
|
||
if len(parts) == 0 {
|
||
return []string{s}
|
||
}
|
||
if len(parts) > 4 {
|
||
parts = parts[:4]
|
||
}
|
||
return parts
|
||
}
|
||
|
||
func truncate(s string, n int) string {
|
||
r := []rune(s)
|
||
if len(r) <= n {
|
||
return s
|
||
}
|
||
return string(r[:n])
|
||
}
|