你çnepiedg
12619aa4ab
- Implemented repairSmokeAIAdviceIndexes to manage the unique index for fa_smoke_ai_advice. - Added unit tests for the new function to ensure correct index recreation and validation. - Updated AutoMigrate to include the new index repair function.
769 lines
24 KiB
Go
769 lines
24 KiB
Go
package service
|
||
|
||
import (
|
||
"bytes"
|
||
"context"
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"io"
|
||
"log"
|
||
"net/http"
|
||
"strings"
|
||
"time"
|
||
|
||
"gorm.io/gorm"
|
||
|
||
"wx_service/config"
|
||
usermodel "wx_service/internal/model"
|
||
smokemodel "wx_service/internal/smoke/model"
|
||
)
|
||
|
||
var (
|
||
ErrAINextServiceDisabled = errors.New("ai service is not configured")
|
||
ErrAINextLocked = errors.New("ai next smoke is locked, ad unlock required")
|
||
)
|
||
|
||
type SmokeAINextSmokeService struct {
|
||
db *gorm.DB
|
||
cfg config.AIConfig
|
||
client *http.Client
|
||
}
|
||
|
||
func NewSmokeAINextSmokeService(db *gorm.DB, cfg config.AIConfig) *SmokeAINextSmokeService {
|
||
timeout := cfg.RequestTimeout
|
||
if timeout <= 0 {
|
||
timeout = 15 * time.Second
|
||
}
|
||
return &SmokeAINextSmokeService{
|
||
db: db,
|
||
cfg: cfg,
|
||
client: &http.Client{
|
||
Timeout: timeout,
|
||
},
|
||
}
|
||
}
|
||
|
||
type aiNextSmokeInput struct {
|
||
AsOf string `json:"as_of"`
|
||
PlanDate string `json:"plan_date"`
|
||
MinNotBeforeAt string `json:"min_not_before_at"`
|
||
DefaultSuggestion NextSmokeSuggestion `json:"default_suggestion"`
|
||
Profile *adviceUserProfile `json:"profile,omitempty"`
|
||
Recent3Days []recentDaySnapshot `json:"recent_3_days"`
|
||
}
|
||
|
||
type aiNextSmokeOutput struct {
|
||
NotBeforeAt string `json:"not_before_at"`
|
||
SuggestedAt string `json:"suggested_at"`
|
||
TimeNodes []string `json:"time_nodes"`
|
||
Advice string `json:"advice"`
|
||
}
|
||
|
||
type recentDaySnapshot struct {
|
||
Date string `json:"date"`
|
||
TotalNum int `json:"total_num"`
|
||
ResistedCount int `json:"resisted_count"`
|
||
Nodes []recentDayNode `json:"nodes"`
|
||
}
|
||
|
||
type recentDayNode struct {
|
||
Time string `json:"time"`
|
||
Num int `json:"num"`
|
||
Level int64 `json:"level"`
|
||
IsResisted bool `json:"is_resisted"`
|
||
Remark string `json:"remark,omitempty"`
|
||
}
|
||
|
||
type AINextSmokeSuggestion struct {
|
||
PlanDate string `json:"plan_date"`
|
||
NotBeforeAt string `json:"not_before_at"`
|
||
SuggestedAt string `json:"suggested_at"`
|
||
TimeNodes []string `json:"time_nodes"`
|
||
Advice string `json:"advice"`
|
||
PromptVersion string `json:"prompt_version"`
|
||
Model string `json:"model,omitempty"`
|
||
Provider string `json:"provider,omitempty"`
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) GetOrGenerate(ctx context.Context, user *usermodel.User, asOf time.Time, planDate time.Time, promptVersion string, defaultSuggestion NextSmokeSuggestion) (AINextSmokeSuggestion, error) {
|
||
if promptVersion == "" {
|
||
promptVersion = "v1"
|
||
}
|
||
|
||
planDate = dateOnly(planDate)
|
||
cachedAdvice, err := s.getCachedAdvice(ctx, int(user.ID), planDate, promptVersion)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
var cachedSuggestion *AINextSmokeSuggestion
|
||
if cachedAdvice != nil {
|
||
v, buildErr := s.buildFromCache(ctx, cachedAdvice)
|
||
if buildErr != nil {
|
||
log.Printf("[smoke_ai_next] cache_build_failed uid=%d plan_date=%s advice_id=%d err=%v", user.ID, planDate.Format("2006-01-02"), cachedAdvice.ID, buildErr)
|
||
} else if !s.shouldRefreshCache(asOf, planDate, v) {
|
||
log.Printf("[smoke_ai_next] cache_hit uid=%d plan_date=%s advice_id=%d", user.ID, planDate.Format("2006-01-02"), cachedAdvice.ID)
|
||
return v, nil
|
||
} else {
|
||
log.Printf("[smoke_ai_next] cache_stale uid=%d plan_date=%s advice_id=%d suggested_at=%s nodes=%d", user.ID, planDate.Format("2006-01-02"), cachedAdvice.ID, v.SuggestedAt, len(v.TimeNodes))
|
||
cachedSuggestion = &v
|
||
}
|
||
}
|
||
|
||
if s.cfg.APIKey == "" || s.cfg.Model == "" || s.cfg.BaseURL == "" {
|
||
if cachedSuggestion != nil {
|
||
log.Printf("[smoke_ai_next] ai_disabled_reuse_cache uid=%d plan_date=%s", user.ID, planDate.Format("2006-01-02"))
|
||
return *cachedSuggestion, nil
|
||
}
|
||
return AINextSmokeSuggestion{}, ErrAINextServiceDisabled
|
||
}
|
||
|
||
allowed, err := s.isAllowed(ctx, user, planDate)
|
||
if err != nil {
|
||
if cachedSuggestion != nil {
|
||
log.Printf("[smoke_ai_next] allow_check_failed_reuse_cache uid=%d plan_date=%s err=%v", user.ID, planDate.Format("2006-01-02"), err)
|
||
return *cachedSuggestion, nil
|
||
}
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
if !allowed {
|
||
if cachedSuggestion != nil {
|
||
log.Printf("[smoke_ai_next] no_refresh_permission_reuse_cache uid=%d plan_date=%s", user.ID, planDate.Format("2006-01-02"))
|
||
return *cachedSuggestion, nil
|
||
}
|
||
return AINextSmokeSuggestion{}, ErrAINextLocked
|
||
}
|
||
|
||
// 尝试复用 profile（用于 sleep window / 动机动力）；如果读取失败则忽略。
|
||
profile := loadAdviceUserProfile(ctx, s.db, int(user.ID))
|
||
|
||
recent, err := s.loadRecent3Days(ctx, int(user.ID), planDate)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
|
||
minNotBefore := s.computeMinNotBefore(asOf, planDate, defaultSuggestion, profile)
|
||
|
||
input := aiNextSmokeInput{
|
||
AsOf: asOf.In(time.Local).Format(time.RFC3339),
|
||
PlanDate: planDate.Format("2006-01-02"),
|
||
MinNotBeforeAt: minNotBefore.In(time.Local).Format(time.RFC3339),
|
||
DefaultSuggestion: defaultSuggestion,
|
||
Profile: profile,
|
||
Recent3Days: recent,
|
||
}
|
||
inputJSON, _ := json.Marshal(input)
|
||
|
||
output, outputJSON, modelName, tokensIn, tokensOut, err := s.callAI(ctx, int(user.ID), input)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
|
||
notBeforeAt, err := parseFlexibleTime(output.NotBeforeAt, planDate)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, fmt.Errorf("parse not_before_at: %w", err)
|
||
}
|
||
suggestedAt, err := parseFlexibleTime(output.SuggestedAt, planDate)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, fmt.Errorf("parse suggested_at: %w", err)
|
||
}
|
||
|
||
// 强制：AI 的“不早于”不可以早于 minNotBefore（避免比默认更激进，且支持明天计划）。
|
||
if notBeforeAt.Before(minNotBefore) {
|
||
notBeforeAt = minNotBefore
|
||
}
|
||
if suggestedAt.Before(notBeforeAt) {
|
||
suggestedAt = notBeforeAt
|
||
}
|
||
|
||
// 避免睡眠时间：若 profile 有作息，则把 not_before/suggested 落在睡眠区间的情况顺延到起床。
|
||
if profile != nil && strings.TrimSpace(profile.WakeUpTime) != "" && strings.TrimSpace(profile.SleepTime) != "" {
|
||
if adjusted, ok, _ := adjustToWakeIfInSleep(notBeforeAt, profile.WakeUpTime, profile.SleepTime); ok {
|
||
notBeforeAt = adjusted
|
||
}
|
||
if adjusted, ok, _ := adjustToWakeIfInSleep(suggestedAt, profile.WakeUpTime, profile.SleepTime); ok {
|
||
suggestedAt = adjusted
|
||
}
|
||
if suggestedAt.Before(notBeforeAt) {
|
||
suggestedAt = notBeforeAt
|
||
}
|
||
}
|
||
|
||
nowUnix := time.Now().Unix()
|
||
createTime := nowUnix
|
||
updateTime := nowUnix
|
||
|
||
// 1) 写入 AI 元信息与建议（复用 fa_smoke_ai_advice + type 区分）
|
||
adviceRecord := smokemodel.SmokeAIAdvice{
|
||
UID: int(user.ID),
|
||
Type: SmokeAIAdviceTypeNextSmoke,
|
||
AdviceDate: planDate,
|
||
PromptVersion: promptVersion,
|
||
Provider: "openai-compatible",
|
||
Model: modelName,
|
||
InputSnapshot: inputJSON,
|
||
Advice: strings.TrimSpace(output.Advice),
|
||
TokensIn: tokensIn,
|
||
TokensOut: tokensOut,
|
||
UpdateTime: &updateTime,
|
||
}
|
||
|
||
if cachedAdvice == nil {
|
||
adviceRecord.CreateTime = &createTime
|
||
if err := s.db.WithContext(ctx).Create(&adviceRecord).Error; err != nil {
|
||
return AINextSmokeSuggestion{}, fmt.Errorf("save ai next smoke advice: %w", err)
|
||
}
|
||
log.Printf("[smoke_ai_next] cache_write_create uid=%d plan_date=%s advice_id=%d", user.ID, planDate.Format("2006-01-02"), adviceRecord.ID)
|
||
} else {
|
||
adviceRecord.ID = cachedAdvice.ID
|
||
adviceRecord.CreateTime = cachedAdvice.CreateTime
|
||
|
||
var tokensInValue interface{}
|
||
if tokensIn != nil {
|
||
tokensInValue = *tokensIn
|
||
}
|
||
var tokensOutValue interface{}
|
||
if tokensOut != nil {
|
||
tokensOutValue = *tokensOut
|
||
}
|
||
|
||
if err := s.db.WithContext(ctx).
|
||
Model(&smokemodel.SmokeAIAdvice{}).
|
||
Where("id = ?", cachedAdvice.ID).
|
||
Updates(map[string]interface{}{
|
||
"provider": adviceRecord.Provider,
|
||
"model": adviceRecord.Model,
|
||
"input_snapshot": adviceRecord.InputSnapshot,
|
||
"advice": adviceRecord.Advice,
|
||
"tokens_in": tokensInValue,
|
||
"tokens_out": tokensOutValue,
|
||
"updatetime": updateTime,
|
||
}).Error; err != nil {
|
||
return AINextSmokeSuggestion{}, fmt.Errorf("refresh ai next smoke advice: %w", err)
|
||
}
|
||
log.Printf("[smoke_ai_next] cache_write_refresh uid=%d plan_date=%s advice_id=%d", user.ID, planDate.Format("2006-01-02"), adviceRecord.ID)
|
||
}
|
||
|
||
// 2) 写入时间节点（每个时间点一条）
|
||
nodes, err := s.normalizeNodes(output.TimeNodes, asOf, planDate, notBeforeAt, profile)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
if len(nodes) > 0 {
|
||
if firstNodeAt, err := parseFlexibleTime(nodes[0], planDate); err == nil {
|
||
suggestedAt = firstNodeAt.In(time.Local)
|
||
if suggestedAt.Before(notBeforeAt) {
|
||
suggestedAt = notBeforeAt
|
||
}
|
||
}
|
||
}
|
||
|
||
if cachedAdvice != nil {
|
||
if err := s.db.WithContext(ctx).
|
||
Where("ai_advice_id = ?", adviceRecord.ID).
|
||
Delete(&smokemodel.SmokeAINextSmoke{}).Error; err != nil {
|
||
return AINextSmokeSuggestion{}, fmt.Errorf("clear old ai next smoke nodes: %w", err)
|
||
}
|
||
}
|
||
|
||
if err := s.saveNodes(ctx, int(user.ID), planDate, adviceRecord.ID, notBeforeAt, suggestedAt, nodes); err != nil {
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
|
||
_ = outputJSON
|
||
return AINextSmokeSuggestion{
|
||
PlanDate: planDate.Format("2006-01-02"),
|
||
NotBeforeAt: notBeforeAt.In(time.Local).Format(time.RFC3339),
|
||
SuggestedAt: suggestedAt.In(time.Local).Format(time.RFC3339),
|
||
TimeNodes: nodes,
|
||
Advice: adviceRecord.Advice,
|
||
PromptVersion: adviceRecord.PromptVersion,
|
||
Model: adviceRecord.Model,
|
||
Provider: adviceRecord.Provider,
|
||
}, nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) GetCached(ctx context.Context, user *usermodel.User, planDate time.Time, promptVersion string) (AINextSmokeSuggestion, bool, error) {
|
||
if promptVersion == "" {
|
||
promptVersion = "v1"
|
||
}
|
||
|
||
planDate = dateOnly(planDate)
|
||
cachedAdvice, err := s.getCachedAdvice(ctx, int(user.ID), planDate, promptVersion)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, false, err
|
||
}
|
||
if cachedAdvice == nil {
|
||
return AINextSmokeSuggestion{}, false, nil
|
||
}
|
||
|
||
suggestion, err := s.buildFromCache(ctx, cachedAdvice)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, false, err
|
||
}
|
||
if s.shouldRefreshCache(time.Now().In(time.Local), planDate, suggestion) {
|
||
log.Printf("[smoke_ai_next] cache_auto_expired uid=%d plan_date=%s advice_id=%d", user.ID, planDate.Format("2006-01-02"), cachedAdvice.ID)
|
||
return AINextSmokeSuggestion{}, false, nil
|
||
}
|
||
log.Printf("[smoke_ai_next] cache_auto_hit uid=%d plan_date=%s advice_id=%d", user.ID, planDate.Format("2006-01-02"), cachedAdvice.ID)
|
||
return suggestion, true, nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) getCachedAdvice(ctx context.Context, uid int, planDate time.Time, promptVersion string) (*smokemodel.SmokeAIAdvice, error) {
|
||
var record smokemodel.SmokeAIAdvice
|
||
err := s.db.WithContext(ctx).
|
||
Where("uid = ? AND type = ? AND advice_date = ? AND prompt_version = ? AND (deletetime IS NULL OR deletetime = 0)",
|
||
uid, SmokeAIAdviceTypeNextSmoke, dateOnly(planDate).Format("2006-01-02"), promptVersion).
|
||
Order("id DESC").
|
||
First(&record).Error
|
||
if err == nil {
|
||
return &record, nil
|
||
}
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return nil, nil
|
||
}
|
||
return nil, fmt.Errorf("load cached ai next smoke advice: %w", err)
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) buildFromCache(ctx context.Context, advice *smokemodel.SmokeAIAdvice) (AINextSmokeSuggestion, error) {
|
||
nodes, notBeforeAt, suggestedAt, err := s.loadNodes(ctx, advice.ID)
|
||
if err != nil {
|
||
return AINextSmokeSuggestion{}, err
|
||
}
|
||
return AINextSmokeSuggestion{
|
||
PlanDate: dateOnly(advice.AdviceDate).Format("2006-01-02"),
|
||
NotBeforeAt: notBeforeAt.In(time.Local).Format(time.RFC3339),
|
||
SuggestedAt: suggestedAt.In(time.Local).Format(time.RFC3339),
|
||
TimeNodes: nodes,
|
||
Advice: advice.Advice,
|
||
PromptVersion: advice.PromptVersion,
|
||
Model: advice.Model,
|
||
Provider: advice.Provider,
|
||
}, nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) loadNodes(ctx context.Context, aiAdviceID uint) ([]string, time.Time, time.Time, error) {
|
||
var rows []smokemodel.SmokeAINextSmoke
|
||
if err := s.db.WithContext(ctx).
|
||
Where("ai_advice_id = ? AND (deletetime IS NULL OR deletetime = 0)", aiAdviceID).
|
||
Order("node_at ASC").
|
||
Find(&rows).Error; err != nil {
|
||
return nil, time.Time{}, time.Time{}, fmt.Errorf("load ai next nodes: %w", err)
|
||
}
|
||
|
||
var notBeforeAt, suggestedAt time.Time
|
||
var nodes []string
|
||
for _, r := range rows {
|
||
switch r.NodeType {
|
||
case "not_before":
|
||
notBeforeAt = r.NodeAt.In(time.Local)
|
||
case "suggested":
|
||
suggestedAt = r.NodeAt.In(time.Local)
|
||
case "node":
|
||
nodes = append(nodes, r.NodeAt.In(time.Local).Format("15:04"))
|
||
}
|
||
}
|
||
if notBeforeAt.IsZero() {
|
||
notBeforeAt = time.Now().In(time.Local)
|
||
}
|
||
if suggestedAt.IsZero() {
|
||
suggestedAt = notBeforeAt
|
||
}
|
||
return nodes, notBeforeAt, suggestedAt, nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) normalizeNodes(raw []string, asOf time.Time, planDate time.Time, notBeforeAt time.Time, profile *adviceUserProfile) ([]string, error) {
|
||
now := asOf.In(time.Local)
|
||
seen := map[string]bool{}
|
||
out := make([]string, 0, 6)
|
||
|
||
for _, v := range raw {
|
||
if len(out) >= 6 {
|
||
break
|
||
}
|
||
t, err := parseFlexibleTime(v, planDate)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
t = t.In(time.Local)
|
||
if dateOnly(t) != dateOnly(planDate) {
|
||
continue
|
||
}
|
||
// 计划日期=今天：不能早于当前时间；计划日期=明天：这里通常不会早于 now。
|
||
if t.Before(now) && dateOnly(planDate).Equal(dateOnly(now)) {
|
||
continue
|
||
}
|
||
if t.Before(notBeforeAt) {
|
||
continue
|
||
}
|
||
if profile != nil && strings.TrimSpace(profile.WakeUpTime) != "" && strings.TrimSpace(profile.SleepTime) != "" {
|
||
if adjusted, ok, _ := adjustToWakeIfInSleep(t, profile.WakeUpTime, profile.SleepTime); ok {
|
||
t = adjusted
|
||
}
|
||
if t.Before(notBeforeAt) {
|
||
continue
|
||
}
|
||
if dateOnly(t) != dateOnly(planDate) {
|
||
continue
|
||
}
|
||
}
|
||
label := t.Format("15:04")
|
||
if seen[label] {
|
||
continue
|
||
}
|
||
seen[label] = true
|
||
out = append(out, label)
|
||
}
|
||
|
||
return out, nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) shouldRefreshCache(asOf time.Time, planDate time.Time, suggestion AINextSmokeSuggestion) bool {
|
||
if len(suggestion.TimeNodes) == 0 {
|
||
return true
|
||
}
|
||
|
||
suggestedAt, err := parseFlexibleTime(suggestion.SuggestedAt, planDate)
|
||
if err != nil {
|
||
return true
|
||
}
|
||
|
||
asOf = asOf.In(time.Local)
|
||
planDate = dateOnly(planDate)
|
||
if dateOnly(suggestedAt) != planDate {
|
||
return true
|
||
}
|
||
|
||
// 当天建议如果已经到点（或过期），视为缓存失效，触发刷新。
|
||
if planDate.Equal(dateOnly(asOf)) && !suggestedAt.After(asOf.Add(2*time.Minute)) {
|
||
return true
|
||
}
|
||
|
||
return false
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) computeMinNotBefore(asOf time.Time, planDate time.Time, defaultSuggestion NextSmokeSuggestion, profile *adviceUserProfile) time.Time {
|
||
asOf = asOf.In(time.Local)
|
||
planDate = dateOnly(planDate)
|
||
today := dateOnly(asOf)
|
||
|
||
if planDate.After(today) {
|
||
min := time.Date(planDate.Year(), planDate.Month(), planDate.Day(), 7, 0, 0, 0, time.Local)
|
||
if profile != nil && strings.TrimSpace(profile.WakeUpTime) != "" {
|
||
if m, err := parseHHMMToMinutes(profile.WakeUpTime); err == nil {
|
||
min = time.Date(planDate.Year(), planDate.Month(), planDate.Day(), m/60, m%60, 0, 0, time.Local)
|
||
}
|
||
}
|
||
return min
|
||
}
|
||
|
||
if defaultSuggestion.NextSmokeAt != nil && !defaultSuggestion.NextSmokeAt.IsZero() {
|
||
return defaultSuggestion.NextSmokeAt.In(time.Local)
|
||
}
|
||
return asOf.Add(5 * time.Minute)
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) loadRecent3Days(ctx context.Context, uid int, planDate time.Time) ([]recentDaySnapshot, error) {
|
||
planDate = dateOnly(planDate)
|
||
today := dateOnly(time.Now().In(time.Local))
|
||
|
||
end := planDate
|
||
if end.After(today) {
|
||
end = today
|
||
}
|
||
start := end.AddDate(0, 0, -2)
|
||
|
||
var logs []smokemodel.SmokeLog
|
||
if err := s.db.WithContext(ctx).
|
||
Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
|
||
Where("smoke_time BETWEEN ? AND ?", start.Format("2006-01-02"), end.Format("2006-01-02")).
|
||
Order("smoke_time ASC").
|
||
Order("COALESCE(smoke_at, FROM_UNIXTIME(createtime)) ASC").
|
||
Order("id ASC").
|
||
Find(&logs).Error; err != nil {
|
||
return nil, fmt.Errorf("load recent logs: %w", err)
|
||
}
|
||
|
||
byDay := map[string]*recentDaySnapshot{}
|
||
ensure := func(day time.Time) *recentDaySnapshot {
|
||
key := dateOnly(day).Format("2006-01-02")
|
||
if existing, ok := byDay[key]; ok {
|
||
return existing
|
||
}
|
||
snap := &recentDaySnapshot{Date: key, Nodes: []recentDayNode{}}
|
||
byDay[key] = snap
|
||
return snap
|
||
}
|
||
|
||
for _, l := range logs {
|
||
day := start
|
||
if l.SmokeTime != nil {
|
||
day = dateOnly(*l.SmokeTime)
|
||
}
|
||
snap := ensure(day)
|
||
|
||
isResisted := l.Level == 0 && l.Num == 0
|
||
if isResisted {
|
||
snap.ResistedCount++
|
||
} else if l.Num > 0 {
|
||
snap.TotalNum += l.Num
|
||
}
|
||
|
||
if len(snap.Nodes) >= 50 {
|
||
continue
|
||
}
|
||
|
||
eventAt, ok := lastEventTime(l)
|
||
timeLabel := ""
|
||
if ok {
|
||
timeLabel = eventAt.In(time.Local).Format("15:04")
|
||
}
|
||
|
||
remark := strings.TrimSpace(l.Remark)
|
||
if len(remark) > 80 {
|
||
remark = remark[:80]
|
||
}
|
||
|
||
snap.Nodes = append(snap.Nodes, recentDayNode{
|
||
Time: timeLabel,
|
||
Num: l.Num,
|
||
Level: l.Level,
|
||
IsResisted: isResisted,
|
||
Remark: remark,
|
||
})
|
||
}
|
||
|
||
out := make([]recentDaySnapshot, 0, 3)
|
||
for d := start; !d.After(end); d = d.AddDate(0, 0, 1) {
|
||
key := d.Format("2006-01-02")
|
||
if snap, ok := byDay[key]; ok {
|
||
out = append(out, *snap)
|
||
} else {
|
||
out = append(out, recentDaySnapshot{Date: key, Nodes: []recentDayNode{}})
|
||
}
|
||
}
|
||
return out, nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) isAllowed(ctx context.Context, user *usermodel.User, planDate time.Time) (bool, error) {
|
||
isVIP, err := hasActiveMembership(ctx, s.db, user.MiniProgramID, user.ID, time.Now())
|
||
if err != nil {
|
||
return false, err
|
||
}
|
||
if isVIP {
|
||
return true, nil
|
||
}
|
||
return s.isUnlocked(ctx, int(user.ID), planDate)
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) isUnlocked(ctx context.Context, uid int, planDate time.Time) (bool, error) {
|
||
startOfDay := dateOnly(planDate)
|
||
var unlock smokemodel.SmokeAIAdviceUnlock
|
||
err := s.db.WithContext(ctx).
|
||
Where("uid = ? AND unlock_date = ? AND (deletetime IS NULL OR deletetime = 0)", uid, startOfDay.Format("2006-01-02")).
|
||
First(&unlock).Error
|
||
if err == nil {
|
||
return true, nil
|
||
}
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
return false, nil
|
||
}
|
||
return false, fmt.Errorf("check unlock: %w", err)
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) saveNodes(ctx context.Context, uid int, planDate time.Time, aiAdviceID uint, notBeforeAt time.Time, suggestedAt time.Time, nodes []string) error {
|
||
nowUnix := time.Now().Unix()
|
||
createTime := nowUnix
|
||
updateTime := nowUnix
|
||
|
||
rows := []smokemodel.SmokeAINextSmoke{
|
||
{
|
||
UID: uid,
|
||
PlanDate: planDate,
|
||
AIAdviceID: aiAdviceID,
|
||
NodeType: "not_before",
|
||
NodeAt: notBeforeAt,
|
||
CreateTime: &createTime,
|
||
UpdateTime: &updateTime,
|
||
},
|
||
{
|
||
UID: uid,
|
||
PlanDate: planDate,
|
||
AIAdviceID: aiAdviceID,
|
||
NodeType: "suggested",
|
||
NodeAt: suggestedAt,
|
||
CreateTime: &createTime,
|
||
UpdateTime: &updateTime,
|
||
},
|
||
}
|
||
|
||
ref := planDate.In(time.Local)
|
||
for _, label := range nodes {
|
||
t, err := parseFlexibleTime(label, ref)
|
||
if err != nil {
|
||
continue
|
||
}
|
||
rows = append(rows, smokemodel.SmokeAINextSmoke{
|
||
UID: uid,
|
||
PlanDate: planDate,
|
||
AIAdviceID: aiAdviceID,
|
||
NodeType: "node",
|
||
NodeAt: t.In(time.Local),
|
||
CreateTime: &createTime,
|
||
UpdateTime: &updateTime,
|
||
})
|
||
}
|
||
|
||
if err := s.db.WithContext(ctx).Create(&rows).Error; err != nil {
|
||
return fmt.Errorf("save ai next smoke nodes: %w", err)
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func (s *SmokeAINextSmokeService) callAI(ctx context.Context, uid int, input aiNextSmokeInput) (aiNextSmokeOutput, []byte, string, *int, *int, error) {
|
||
requestModel := preferredSmokeAIModel(s.cfg.Model)
|
||
|
||
systemPrompt := strings.TrimSpace(`
|
||
你是一名专业的戒烟教练与行为改变顾问。你将收到一段 JSON，包含：
|
||
- 现在时间(as_of)
|
||
- 计划日期(plan_date)：你输出的时间必须属于该日期
|
||
- 最小不早于时间(min_not_before_at)：你输出的 not_before_at 必须 >= 该值
|
||
- 最近3天数据(recent_3_days)：用于判断近期模式（含忍住记录）
|
||
- 后端默认策略(default_suggestion)：仅供参考
|
||
- 可选的用户 profile：包含作息时间、动机/动力
|
||
|
||
你必须只输出一段严格的 JSON（不要 Markdown、不要解释文字），格式：
|
||
{
|
||
"not_before_at": "RFC3339 时间字符串(含时区)",
|
||
"suggested_at": "RFC3339 时间字符串(含时区)",
|
||
"time_nodes": ["HH:MM", "HH:MM", ...],
|
||
"advice": "一句话建议(<=200字)"
|
||
}
|
||
|
||
约束：
|
||
1) not_before_at 必须 >= min_not_before_at；
|
||
2) suggested_at 必须 >= not_before_at；
|
||
3) 如果 profile 提供了 wake_up_time/sleep_time，建议时间与 time_nodes 不要落在睡眠区间；如不可避免，顺延到起床后；
|
||
4) time_nodes 只需要给出 plan_date 的 3~6 个“关键节点”（字符串 HH:MM），并且都不早于 not_before_at。
|
||
`)
|
||
|
||
userPrompt := fmt.Sprintf("输入(JSON)：\n%s", mustJSON(input))
|
||
appendSmokeAIDebugLog("next_smoke.request", map[string]interface{}{
|
||
"uid": uid,
|
||
"model": requestModel,
|
||
"system_prompt": systemPrompt,
|
||
"user_prompt": userPrompt,
|
||
"input": input,
|
||
})
|
||
|
||
reqBody := chatCompletionRequest{
|
||
Model: requestModel,
|
||
Messages: []chatMessage{
|
||
{Role: "system", Content: systemPrompt},
|
||
{Role: "user", Content: userPrompt},
|
||
},
|
||
Temperature: defaultTemperature,
|
||
}
|
||
|
||
payload, err := json.Marshal(reqBody)
|
||
if err != nil {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("marshal ai request: %w", err)
|
||
}
|
||
|
||
endpoint := strings.TrimRight(s.cfg.BaseURL, "/") + "/chat/completions"
|
||
httpReq, err := http.NewRequestWithContext(ctx, http.MethodPost, endpoint, bytes.NewReader(payload))
|
||
if err != nil {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("build ai request: %w", err)
|
||
}
|
||
httpReq.Header.Set("Content-Type", "application/json")
|
||
httpReq.Header.Set("Authorization", "Bearer "+s.cfg.APIKey)
|
||
|
||
resp, err := s.client.Do(httpReq)
|
||
if err != nil {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("call ai: %w", err)
|
||
}
|
||
defer resp.Body.Close()
|
||
|
||
body, err := io.ReadAll(resp.Body)
|
||
if err != nil {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("read ai response: %w", err)
|
||
}
|
||
appendSmokeAIDebugLog("next_smoke.response", map[string]interface{}{
|
||
"uid": uid,
|
||
"model": requestModel,
|
||
"http_status": resp.StatusCode,
|
||
"response_body": string(body),
|
||
})
|
||
if resp.StatusCode != http.StatusOK {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("ai http %d: %s", resp.StatusCode, truncateString(string(body), 512))
|
||
}
|
||
|
||
var parsed chatCompletionResponse
|
||
if err := json.Unmarshal(body, &parsed); err != nil {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("parse ai response: %w", err)
|
||
}
|
||
if len(parsed.Choices) == 0 {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, errors.New("ai response has no choices")
|
||
}
|
||
|
||
content := strings.TrimSpace(parsed.Choices[0].Message.Content)
|
||
if content == "" {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, errors.New("ai response content is empty")
|
||
}
|
||
|
||
jsonPart := extractJSONObject(content)
|
||
if jsonPart == "" {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("ai response is not json: %s", truncateString(content, 256))
|
||
}
|
||
|
||
var out aiNextSmokeOutput
|
||
if err := json.Unmarshal([]byte(jsonPart), &out); err != nil {
|
||
return aiNextSmokeOutput{}, nil, "", nil, nil, fmt.Errorf("unmarshal ai json: %w", err)
|
||
}
|
||
|
||
modelName := parsed.Model
|
||
if modelName == "" {
|
||
modelName = requestModel
|
||
}
|
||
|
||
var tokensIn, tokensOut *int
|
||
if parsed.Usage != nil {
|
||
tokensIn = &parsed.Usage.PromptTokens
|
||
tokensOut = &parsed.Usage.CompletionTokens
|
||
}
|
||
|
||
return out, []byte(jsonPart), modelName, tokensIn, tokensOut, nil
|
||
}
|
||
|
||
func extractJSONObject(s string) string {
|
||
start := strings.Index(s, "{")
|
||
end := strings.LastIndex(s, "}")
|
||
if start < 0 || end < 0 || end <= start {
|
||
return ""
|
||
}
|
||
return s[start : end+1]
|
||
}
|
||
|
||
func parseFlexibleTime(value string, ref time.Time) (time.Time, error) {
|
||
value = strings.TrimSpace(value)
|
||
if value == "" {
|
||
return time.Time{}, errors.New("empty time")
|
||
}
|
||
if t, err := time.Parse(time.RFC3339, value); err == nil {
|
||
return t.In(time.Local), nil
|
||
}
|
||
if t, err := time.ParseInLocation("2006-01-02 15:04:05", value, time.Local); err == nil {
|
||
return t.In(time.Local), nil
|
||
}
|
||
// 仅提供 HH:MM：使用 ref 的日期
|
||
if len(value) == 5 && value[2] == ':' {
|
||
min, err := parseHHMMToMinutes(value)
|
||
if err != nil {
|
||
return time.Time{}, err
|
||
}
|
||
r := ref.In(time.Local)
|
||
return time.Date(r.Year(), r.Month(), r.Day(), min/60, min%60, 0, 0, time.Local), nil
|
||
}
|
||
return time.Time{}, fmt.Errorf("unsupported time format: %s", value)
|
||
}
|