root
439 lines
12 KiB
Go
439 lines
12 KiB
Go
package service
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"math"
|
|
"time"
|
|
|
|
"gorm.io/gorm"
|
|
|
|
smokemodel "wx_service/internal/smoke/model"
|
|
)
|
|
|
|
const defaultCigsPerPack = 20
|
|
|
|
type SmokeStatsRequest struct {
|
|
Range string
|
|
Start time.Time
|
|
End time.Time
|
|
PrevStart time.Time
|
|
PrevEnd time.Time
|
|
TrendUnit string
|
|
AsOf time.Time
|
|
}
|
|
|
|
type SmokeStatsResult struct {
|
|
Range string `json:"range"`
|
|
Start string `json:"start"`
|
|
End string `json:"end"`
|
|
TrendUnit string `json:"trend_unit"`
|
|
Trend []SmokeStatsTrend `json:"trend"`
|
|
DailyAverage int `json:"daily_average"`
|
|
ChangePercent int `json:"change_percent"`
|
|
Money SmokeStatsMoney `json:"money"`
|
|
Health SmokeStatsHealth `json:"health"`
|
|
StreakDays int `json:"streak_days"`
|
|
ResistedTotal int `json:"resisted_total"`
|
|
}
|
|
|
|
type SmokeStatsTrend struct {
|
|
Label string `json:"label"`
|
|
Count int `json:"count"`
|
|
}
|
|
|
|
type SmokeStatsMoney struct {
|
|
Available bool `json:"available"`
|
|
PackPriceCent int `json:"pack_price_cent,omitempty"`
|
|
CigsPerPack int `json:"cigs_per_pack,omitempty"`
|
|
ExpectedTotal int `json:"expected_total,omitempty"`
|
|
ActualTotal int `json:"actual_total,omitempty"`
|
|
SavedCent int `json:"saved_cent,omitempty"`
|
|
}
|
|
|
|
type SmokeStatsHealth struct {
|
|
Available bool `json:"available"`
|
|
SmokeFreeMinutes int `json:"smoke_free_minutes,omitempty"`
|
|
LungRecoveryPercent int `json:"lung_recovery_percent,omitempty"`
|
|
Milestones []HealthMilestone `json:"milestones,omitempty"`
|
|
}
|
|
|
|
type HealthMilestone struct {
|
|
Name string `json:"name"`
|
|
Minutes int `json:"minutes"`
|
|
Reached bool `json:"reached"`
|
|
}
|
|
|
|
func (s *SmokeLogService) Stats(ctx context.Context, uid int, req SmokeStatsRequest, profile *smokemodel.SmokeUserProfile) (SmokeStatsResult, error) {
|
|
start := dateOnly(req.Start)
|
|
end := dateOnly(req.End)
|
|
trendUnit := req.TrendUnit
|
|
|
|
var (
|
|
trend []SmokeStatsTrend
|
|
total int64
|
|
err error
|
|
)
|
|
|
|
if trendUnit == "month" {
|
|
trend, total, err = s.loadMonthlyTrend(ctx, uid, start, end)
|
|
} else {
|
|
trend, total, err = s.loadDailyTrend(ctx, uid, start, end)
|
|
}
|
|
if err != nil {
|
|
return SmokeStatsResult{}, err
|
|
}
|
|
trend = limitTrend(trend, 7)
|
|
|
|
dayCount := daysBetweenInclusive(start, end)
|
|
dailyAvg := 0
|
|
if dayCount > 0 {
|
|
dailyAvg = int(math.Round(float64(total) / float64(dayCount)))
|
|
}
|
|
|
|
prevTotal, err := s.sumCigs(ctx, uid, req.PrevStart, req.PrevEnd)
|
|
if err != nil {
|
|
return SmokeStatsResult{}, err
|
|
}
|
|
changePercent := 0
|
|
if prevTotal > 0 {
|
|
changePercent = int(math.Round((float64(total) - float64(prevTotal)) / float64(prevTotal) * 100))
|
|
}
|
|
|
|
resistedTotal, err := s.countResisted(ctx, uid, start, end)
|
|
if err != nil {
|
|
return SmokeStatsResult{}, err
|
|
}
|
|
|
|
streakDays, err := s.computeStreakDays(ctx, uid, req.AsOf)
|
|
if err != nil {
|
|
return SmokeStatsResult{}, err
|
|
}
|
|
|
|
money := s.computeMoney(ctx, uid, profile, int(total), start, end)
|
|
health, err := s.computeHealth(ctx, uid, req.AsOf)
|
|
if err != nil {
|
|
return SmokeStatsResult{}, err
|
|
}
|
|
|
|
return SmokeStatsResult{
|
|
Range: req.Range,
|
|
Start: start.Format("2006-01-02"),
|
|
End: end.Format("2006-01-02"),
|
|
TrendUnit: trendUnit,
|
|
Trend: trend,
|
|
DailyAverage: dailyAvg,
|
|
ChangePercent: changePercent,
|
|
Money: money,
|
|
Health: health,
|
|
StreakDays: streakDays,
|
|
ResistedTotal: resistedTotal,
|
|
}, nil
|
|
}
|
|
|
|
func limitTrend(items []SmokeStatsTrend, max int) []SmokeStatsTrend {
|
|
if max <= 0 || len(items) <= max {
|
|
return items
|
|
}
|
|
lastIndex := len(items) - 1
|
|
out := make([]SmokeStatsTrend, 0, max)
|
|
seen := make(map[int]struct{}, max)
|
|
for i := 0; i < max; i++ {
|
|
pos := int(math.Round(float64(i) * float64(lastIndex) / float64(max-1)))
|
|
if _, ok := seen[pos]; ok {
|
|
continue
|
|
}
|
|
seen[pos] = struct{}{}
|
|
out = append(out, items[pos])
|
|
}
|
|
return out
|
|
}
|
|
|
|
func (s *SmokeLogService) loadDailyTrend(ctx context.Context, uid int, start, end time.Time) ([]SmokeStatsTrend, int64, error) {
|
|
type dailyCount struct {
|
|
SmokeTime time.Time `gorm:"column:smoke_time"`
|
|
Total int64 `gorm:"column:total"`
|
|
}
|
|
|
|
var rows []dailyCount
|
|
if err := s.db.WithContext(ctx).
|
|
Model(&smokemodel.SmokeLog{}).
|
|
Select("smoke_time, SUM(num) AS total").
|
|
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")).
|
|
Group("smoke_time").
|
|
Order("smoke_time ASC").
|
|
Find(&rows).Error; err != nil {
|
|
return nil, 0, fmt.Errorf("load daily trend: %w", err)
|
|
}
|
|
|
|
counts := make(map[string]int64, len(rows))
|
|
var total int64
|
|
for _, row := range rows {
|
|
key := dateOnly(row.SmokeTime).Format("2006-01-02")
|
|
counts[key] = row.Total
|
|
total += row.Total
|
|
}
|
|
|
|
out := make([]SmokeStatsTrend, 0, daysBetweenInclusive(start, end))
|
|
for day := start; !day.After(end); day = day.AddDate(0, 0, 1) {
|
|
label := day.Format("2006-01-02")
|
|
out = append(out, SmokeStatsTrend{
|
|
Label: label,
|
|
Count: int(counts[label]),
|
|
})
|
|
}
|
|
return out, total, nil
|
|
}
|
|
|
|
func (s *SmokeLogService) loadMonthlyTrend(ctx context.Context, uid int, start, end time.Time) ([]SmokeStatsTrend, int64, error) {
|
|
type monthlyCount struct {
|
|
Month string `gorm:"column:month"`
|
|
Total int64 `gorm:"column:total"`
|
|
}
|
|
|
|
var rows []monthlyCount
|
|
if err := s.db.WithContext(ctx).
|
|
Model(&smokemodel.SmokeLog{}).
|
|
Select("DATE_FORMAT(smoke_time, '%Y-%m') AS month, SUM(num) AS total").
|
|
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")).
|
|
Group("month").
|
|
Order("month ASC").
|
|
Find(&rows).Error; err != nil {
|
|
return nil, 0, fmt.Errorf("load monthly trend: %w", err)
|
|
}
|
|
|
|
counts := make(map[string]int64, len(rows))
|
|
var total int64
|
|
for _, row := range rows {
|
|
counts[row.Month] = row.Total
|
|
total += row.Total
|
|
}
|
|
|
|
out := make([]SmokeStatsTrend, 0, 12)
|
|
for cursor := time.Date(start.Year(), start.Month(), 1, 0, 0, 0, 0, time.Local); !cursor.After(end); cursor = cursor.AddDate(0, 1, 0) {
|
|
label := cursor.Format("2006-01")
|
|
out = append(out, SmokeStatsTrend{
|
|
Label: label,
|
|
Count: int(counts[label]),
|
|
})
|
|
}
|
|
return out, total, nil
|
|
}
|
|
|
|
func (s *SmokeLogService) sumCigs(ctx context.Context, uid int, start, end time.Time) (int64, error) {
|
|
start = dateOnly(start)
|
|
end = dateOnly(end)
|
|
var total int64
|
|
if err := s.db.WithContext(ctx).
|
|
Model(&smokemodel.SmokeLog{}).
|
|
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")).
|
|
Select("COALESCE(SUM(num), 0)").
|
|
Scan(&total).Error; err != nil {
|
|
return 0, fmt.Errorf("sum cigs: %w", err)
|
|
}
|
|
return total, nil
|
|
}
|
|
|
|
func (s *SmokeLogService) countResisted(ctx context.Context, uid int, start, end time.Time) (int, error) {
|
|
start = dateOnly(start)
|
|
end = dateOnly(end)
|
|
var count int64
|
|
if err := s.db.WithContext(ctx).
|
|
Model(&smokemodel.SmokeLog{}).
|
|
Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
|
|
Where("level = 0 AND num = 0").
|
|
Where("smoke_time BETWEEN ? AND ?", start.Format("2006-01-02"), end.Format("2006-01-02")).
|
|
Count(&count).Error; err != nil {
|
|
return 0, fmt.Errorf("count resisted: %w", err)
|
|
}
|
|
return int(count), nil
|
|
}
|
|
|
|
func (s *SmokeLogService) computeStreakDays(ctx context.Context, uid int, asOf time.Time) (int, error) {
|
|
asOf = dateOnly(asOf)
|
|
start := asOf.AddDate(0, 0, -400)
|
|
|
|
type row struct {
|
|
SmokeTime time.Time `gorm:"column:smoke_time"`
|
|
}
|
|
var rows []row
|
|
if err := s.db.WithContext(ctx).
|
|
Model(&smokemodel.SmokeLog{}).
|
|
Distinct("smoke_time").
|
|
Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
|
|
Where("smoke_time BETWEEN ? AND ?", start.Format("2006-01-02"), asOf.Format("2006-01-02")).
|
|
Order("smoke_time DESC").
|
|
Find(&rows).Error; err != nil {
|
|
return 0, fmt.Errorf("load streak days: %w", err)
|
|
}
|
|
|
|
daySet := make(map[string]bool, len(rows))
|
|
for _, r := range rows {
|
|
daySet[dateOnly(r.SmokeTime).Format("2006-01-02")] = true
|
|
}
|
|
|
|
streak := 0
|
|
for day := asOf; ; day = day.AddDate(0, 0, -1) {
|
|
key := day.Format("2006-01-02")
|
|
if !daySet[key] {
|
|
break
|
|
}
|
|
streak++
|
|
}
|
|
return streak, nil
|
|
}
|
|
|
|
func (s *SmokeLogService) computeMoney(ctx context.Context, uid int, profile *smokemodel.SmokeUserProfile, actualTotal int, start, end time.Time) SmokeStatsMoney {
|
|
if profile == nil || profile.BaselineCigsPerDay <= 0 || profile.PackPriceCent <= 0 {
|
|
return SmokeStatsMoney{Available: false}
|
|
}
|
|
|
|
activeDays, err := s.countLogDays(ctx, uid, start, end)
|
|
if err != nil {
|
|
return SmokeStatsMoney{Available: false}
|
|
}
|
|
if activeDays <= 0 {
|
|
return SmokeStatsMoney{
|
|
Available: true,
|
|
PackPriceCent: profile.PackPriceCent,
|
|
CigsPerPack: defaultCigsPerPack,
|
|
ExpectedTotal: 0,
|
|
ActualTotal: actualTotal,
|
|
SavedCent: 0,
|
|
}
|
|
}
|
|
|
|
expectedTotal := profile.BaselineCigsPerDay * activeDays
|
|
savedCigs := expectedTotal - actualTotal
|
|
if savedCigs < 0 {
|
|
savedCigs = 0
|
|
}
|
|
savedPacks := float64(savedCigs) / float64(defaultCigsPerPack)
|
|
savedCent := int(math.Round(savedPacks * float64(profile.PackPriceCent)))
|
|
return SmokeStatsMoney{
|
|
Available: true,
|
|
PackPriceCent: profile.PackPriceCent,
|
|
CigsPerPack: defaultCigsPerPack,
|
|
ExpectedTotal: expectedTotal,
|
|
ActualTotal: actualTotal,
|
|
SavedCent: savedCent,
|
|
}
|
|
}
|
|
|
|
func (s *SmokeLogService) countLogDays(ctx context.Context, uid int, start, end time.Time) (int, error) {
|
|
start = dateOnly(start)
|
|
end = dateOnly(end)
|
|
|
|
type row struct {
|
|
SmokeTime time.Time `gorm:"column:smoke_time"`
|
|
}
|
|
var rows []row
|
|
if err := s.db.WithContext(ctx).
|
|
Model(&smokemodel.SmokeLog{}).
|
|
Distinct("smoke_time").
|
|
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")).
|
|
Find(&rows).Error; err != nil {
|
|
return 0, fmt.Errorf("count log days: %w", err)
|
|
}
|
|
return len(rows), nil
|
|
}
|
|
|
|
func (s *SmokeLogService) computeHealth(ctx context.Context, uid int, asOf time.Time) (SmokeStatsHealth, error) {
|
|
lastSmokeAt, err := s.loadLastActualSmokeAt(ctx, uid)
|
|
if err != nil {
|
|
return SmokeStatsHealth{}, err
|
|
}
|
|
if lastSmokeAt == nil {
|
|
return SmokeStatsHealth{Available: false}, nil
|
|
}
|
|
|
|
minutes := int(asOf.Sub(*lastSmokeAt).Minutes())
|
|
if minutes < 0 {
|
|
minutes = 0
|
|
}
|
|
|
|
return SmokeStatsHealth{
|
|
Available: true,
|
|
SmokeFreeMinutes: minutes,
|
|
LungRecoveryPercent: computeLungRecoveryPercent(minutes),
|
|
Milestones: buildHealthMilestones(minutes),
|
|
}, nil
|
|
}
|
|
|
|
func (s *SmokeLogService) loadLastActualSmokeAt(ctx context.Context, uid int) (*time.Time, error) {
|
|
var last smokemodel.SmokeLog
|
|
if err := s.db.WithContext(ctx).
|
|
Where("uid = ? AND (deletetime IS NULL OR deletetime = 0)", uid).
|
|
Where("num > 0").
|
|
Order("COALESCE(smoke_at, FROM_UNIXTIME(createtime), smoke_time) DESC").
|
|
Order("id DESC").
|
|
Limit(1).
|
|
Take(&last).Error; err != nil {
|
|
if err == gorm.ErrRecordNotFound {
|
|
return nil, nil
|
|
}
|
|
return nil, fmt.Errorf("load last smoke log: %w", err)
|
|
}
|
|
if t, ok := lastEventTime(last); ok {
|
|
return &t, nil
|
|
}
|
|
return nil, nil
|
|
}
|
|
|
|
func computeLungRecoveryPercent(smokeFreeMinutes int) int {
|
|
days := float64(smokeFreeMinutes) / (24 * 60)
|
|
switch {
|
|
case days < 14:
|
|
return int(math.Round((days / 14) * 15))
|
|
case days < 30:
|
|
return int(math.Round(15 + ((days-14)/16)*15))
|
|
case days < 90:
|
|
return int(math.Round(30 + ((days-30)/60)*20))
|
|
default:
|
|
val := 50 + ((days-90)/275)*50
|
|
if val > 100 {
|
|
val = 100
|
|
}
|
|
return int(math.Round(val))
|
|
}
|
|
}
|
|
|
|
func buildHealthMilestones(smokeFreeMinutes int) []HealthMilestone {
|
|
steps := []struct {
|
|
name string
|
|
minutes int
|
|
}{
|
|
{"心率血压恢复正常", 20},
|
|
{"血氧水平恢复", 8 * 60},
|
|
{"心脏病风险开始下降", 24 * 60},
|
|
{"嗅觉味觉开始恢复", 48 * 60},
|
|
{"肺功能提升 15%", 14 * 24 * 60},
|
|
{"肺功能提升 30%", 30 * 24 * 60},
|
|
{"肺功能提升 50%", 90 * 24 * 60},
|
|
{"心脏病风险降低 50%", 365 * 24 * 60},
|
|
}
|
|
|
|
out := make([]HealthMilestone, 0, len(steps))
|
|
for _, step := range steps {
|
|
out = append(out, HealthMilestone{
|
|
Name: step.name,
|
|
Minutes: step.minutes,
|
|
Reached: smokeFreeMinutes >= step.minutes,
|
|
})
|
|
}
|
|
return out
|
|
}
|
|
|
|
func daysBetweenInclusive(start, end time.Time) int {
|
|
start = dateOnly(start)
|
|
end = dateOnly(end)
|
|
if end.Before(start) {
|
|
return 0
|
|
}
|
|
return int(end.Sub(start).Hours()/24) + 1
|
|
}
|