542 lines
15 KiB
Go
542 lines
15 KiB
Go
package controllers
|
||
|
||
import (
|
||
"gonum.org/v1/gonum/floats"
|
||
"gonum.org/v1/gonum/stat"
|
||
"gonum.org/v1/gonum/stat/distuv"
|
||
)
|
||
|
||
import (
|
||
"encoding/json"
|
||
"errors"
|
||
"fmt"
|
||
"time"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"gorm.io/gorm"
|
||
"gorm.io/gorm/clause"
|
||
"gorm.io/gorm/schema"
|
||
"hr_receiver/config"
|
||
"hr_receiver/models"
|
||
"math"
|
||
"net/http"
|
||
)
|
||
|
||
var analyzeRunTypes = []string{"6.5开始", "7开始", "8开始"} // 替换为你的具体值
|
||
|
||
func contains(s string) bool {
|
||
for _, item := range analyzeRunTypes {
|
||
if item == s {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
|
||
type TrainingController struct {
|
||
DB *gorm.DB
|
||
}
|
||
|
||
func NewTrainingController() *TrainingController {
|
||
return &TrainingController{DB: config.DB}
|
||
}
|
||
|
||
// @Summary 创建训练记录
|
||
// @Description 接收并保存训练记录及心率数据，支持重复上传（按train_id去重更新）
|
||
// @Tags 训练管理
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param record body SwagAPIResponse true "训练记录数据"
|
||
// @Success 201 {object} SwagAPIResponse "保存成功"
|
||
// @Failure 400 {object} SwagAPIResponse "请求参数错误"
|
||
// @Router /train-records [post]
|
||
func (tc *TrainingController) CreateTrainingRecord(c *gin.Context) {
|
||
var record models.TrainRecord
|
||
|
||
// 绑定并验证JSON数据
|
||
if err := c.ShouldBindJSON(&record); err != nil {
|
||
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
||
return
|
||
}
|
||
|
||
// 使用事务保存数据[4](@ref)
|
||
err := tc.DB.Transaction(func(tx *gorm.DB) error {
|
||
// 保存主记录
|
||
if err := tx.Clauses(clause.OnConflict{
|
||
Columns: []clause.Column{{Name: "train_id"}}, // 指定冲突的列
|
||
DoUpdates: clause.Assignments(map[string]interface{}{
|
||
"max_heart_rate": record.MaxHeartRate,
|
||
"start_time": record.StartTime,
|
||
"end_time": record.EndTime,
|
||
"duration": record.Duration,
|
||
"people_num": record.PeopleNum,
|
||
"name": record.Name,
|
||
"evaluation": record.Evaluation,
|
||
}),
|
||
}).Omit("HeartRates", "belts").Create(&record).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
// 保存关联的心率数据
|
||
for i := range record.HeartRates {
|
||
if err := tx.Clauses(
|
||
clause.OnConflict{
|
||
Columns: []clause.Column{{Name: "identifier"}}, // 指定冲突的列
|
||
DoUpdates: clause.Assignments(map[string]interface{}{"value": record.HeartRates[i].Value, "time": record.HeartRates[i].Time}),
|
||
},
|
||
).Create(&record.HeartRates[i]).Error; err != nil {
|
||
|
||
return err
|
||
}
|
||
}
|
||
if contains(record.RunType) {
|
||
err := tc.heartRateAnalyze(tx, record)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
}
|
||
|
||
return nil
|
||
})
|
||
|
||
if err != nil {
|
||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||
return
|
||
}
|
||
|
||
c.JSON(http.StatusCreated, gin.H{
|
||
"message": "数据保存成功",
|
||
"id": record.TrainId,
|
||
})
|
||
}
|
||
|
||
type trainingSessionRequest struct {
|
||
Tid int `json:"tid"`
|
||
Time int64 `json:"time"`
|
||
TestTime int64 `json:"testTime"`
|
||
EndTime int64 `json:"endTime"`
|
||
Name string `json:"name"`
|
||
RunType string `json:"runType"`
|
||
Gender string `json:"gender"`
|
||
Age int `json:"age"`
|
||
MaxHeartRate int `json:"maxHeartRate"`
|
||
Duration int `json:"duration"`
|
||
PeopleNum int `json:"peopleNum"`
|
||
Evaluation string `json:"evaluation"`
|
||
AiResult string `json:"aiResult"`
|
||
IsStart bool `json:"isStart"`
|
||
RegionID uint32 `json:"regionId"`
|
||
AppName string `json:"appName"`
|
||
}
|
||
|
||
// @Summary 上传训练会话
|
||
// @Description 上传训练开始/结束会话，用于MQTT训练会话追踪
|
||
// @Tags 训练管理
|
||
// @Accept json
|
||
// @Produce json
|
||
// @Param session body trainingSessionRequest true "训练会话数据"
|
||
// @Success 200 {object} SwagAPIResponse "操作成功"
|
||
// @Failure 400 {object} SwagAPIResponse "请求参数错误"
|
||
// @Router /train-records/session [post]
|
||
func (tc *TrainingController) UploadTrainingSession(c *gin.Context) {
|
||
var req trainingSessionRequest
|
||
if err := c.ShouldBindJSON(&req); err != nil {
|
||
writeError(c, http.StatusBadRequest, err.Error())
|
||
return
|
||
}
|
||
|
||
trainID := fmt.Sprintf("%d", req.Time)
|
||
now := time.Now().UnixMilli()
|
||
flavorType := "heartrate"
|
||
|
||
identifier := schema.NamingStrategy{}.IndexName(
|
||
"mqtt_training_session",
|
||
fmt.Sprintf("%s_%d_%s", flavorType, req.RegionID, trainID),
|
||
)
|
||
|
||
rawPayload, _ := json.Marshal(req)
|
||
|
||
if req.IsStart {
|
||
record := &models.MqttTrainingSessionRecord{
|
||
Identifier: identifier,
|
||
TestID: trainID,
|
||
EventType: "start_test",
|
||
RegionID: req.RegionID,
|
||
FlavorType: flavorType,
|
||
RawFlavor: "hr",
|
||
AppName: req.AppName,
|
||
TrainId: trainID,
|
||
PeopleNum: req.PeopleNum,
|
||
StartedAt: &req.Time,
|
||
PublishedAt: now,
|
||
ReceivedAt: now,
|
||
RawPayload: string(rawPayload),
|
||
}
|
||
err := tc.DB.Clauses(clause.OnConflict{
|
||
Columns: []clause.Column{{Name: "identifier"}},
|
||
DoUpdates: clause.Assignments(map[string]interface{}{"started_at": *record.StartedAt, "train_id": record.TrainId, "updated_at": time.Now()}),
|
||
}).Create(record).Error
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to save session")
|
||
return
|
||
}
|
||
writeSuccess(c, http.StatusOK, "session start registered", nil)
|
||
return
|
||
}
|
||
|
||
var existing models.MqttTrainingSessionRecord
|
||
err := tc.DB.Where("train_id = ?", trainID).First(&existing).Error
|
||
if err != nil {
|
||
record := &models.MqttTrainingSessionRecord{
|
||
Identifier: identifier,
|
||
TestID: trainID,
|
||
EventType: "stop_test",
|
||
RegionID: req.RegionID,
|
||
FlavorType: flavorType,
|
||
RawFlavor: "hr",
|
||
AppName: req.AppName,
|
||
TrainId: trainID,
|
||
PeopleNum: req.PeopleNum,
|
||
StartedAt: &req.Time,
|
||
EndedAt: &req.EndTime,
|
||
PublishedAt: now,
|
||
ReceivedAt: now,
|
||
RawPayload: string(rawPayload),
|
||
}
|
||
err = tc.DB.Clauses(clause.OnConflict{
|
||
Columns: []clause.Column{{Name: "identifier"}},
|
||
DoUpdates: clause.Assignments(map[string]interface{}{
|
||
"ended_at": *record.EndedAt,
|
||
"people_num": record.PeopleNum,
|
||
"event_type": record.EventType,
|
||
"updated_at": time.Now(),
|
||
}),
|
||
}).Create(record).Error
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to create session")
|
||
return
|
||
}
|
||
writeSuccess(c, http.StatusOK, "session created", nil)
|
||
return
|
||
}
|
||
|
||
updates := map[string]interface{}{
|
||
"event_type": "stop_test",
|
||
"ended_at": req.EndTime,
|
||
"people_num": req.PeopleNum,
|
||
"received_at": now,
|
||
"raw_payload": string(rawPayload),
|
||
"updated_at": time.Now(),
|
||
}
|
||
if err := tc.DB.Model(&existing).Updates(updates).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to update session")
|
||
return
|
||
}
|
||
writeSuccess(c, http.StatusOK, "session updated", nil)
|
||
}
|
||
|
||
type cloudLessonPlanItem struct {
|
||
ID uint `json:"id"`
|
||
OriginalFilename string `json:"originalFilename"`
|
||
FileSize int64 `json:"fileSize"`
|
||
UploaderName string `json:"uploaderName"`
|
||
}
|
||
|
||
// @Summary 获取云端教案列表
|
||
// @Description 获取所有云端教案文件列表
|
||
// @Tags 训练管理
|
||
// @Produce json
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /train-records/cloud-files [get]
|
||
func (tc *TrainingController) ListCloudLessonPlans(c *gin.Context) {
|
||
var records []models.AppFile
|
||
if err := tc.DB.Where("file_type = ?", models.AppFileTypeLessonPlan).Order("created_at DESC").Find(&records).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to list lesson plans")
|
||
return
|
||
}
|
||
items := make([]cloudLessonPlanItem, 0, len(records))
|
||
for _, r := range records {
|
||
items = append(items, cloudLessonPlanItem{
|
||
ID: r.ID,
|
||
OriginalFilename: r.OriginalFilename,
|
||
FileSize: r.FileSize,
|
||
UploaderName: r.UploaderName,
|
||
})
|
||
}
|
||
writeSuccess(c, http.StatusOK, "query success", items)
|
||
}
|
||
|
||
// analysis_response.go
|
||
type AnalysisResponse struct {
|
||
Status string `json:"status"` // 状态码
|
||
Message string `json:"message"` // 附加信息
|
||
Data struct {
|
||
Mean float64 `json:"mean"` // 均值
|
||
StdDev float64 `json:"stdDev"` // 标准差
|
||
Histogram []HistoBin `json:"histogram"` // 直方图数据
|
||
Curve []CurvePoint `json:"curve"` // 正态曲线数据
|
||
} `json:"data"`
|
||
}
|
||
|
||
type HistoBin struct {
|
||
BinStart float64 `json:"binStart"` // 区间起始值
|
||
BinEnd float64 `json:"binEnd"` // 区间结束值
|
||
Count int `json:"count"` // 该区间计数
|
||
}
|
||
|
||
type CurvePoint struct {
|
||
X float64 `json:"x"` // X坐标
|
||
Y float64 `json:"y"` // Y坐标
|
||
}
|
||
|
||
// @Summary 心率曲线分析
|
||
// @Description 对历史心率数据进行统计分析和正态分布曲线拟合
|
||
// @Tags 训练管理
|
||
// @Produce json
|
||
// @Success 200 {object} SwagAPIResponse "分析成功"
|
||
// @Failure 400 {object} SwagAPIResponse "数据量不足"
|
||
// @Router /train-records/analysis [get]
|
||
func (tc *TrainingController) HandleCurveAnalysis(c *gin.Context) {
|
||
// 获取数据库连接（根据实际项目配置调整）
|
||
|
||
// 1. 获取历史数据
|
||
aValues, err := collectCurveParams(tc.DB)
|
||
if err != nil {
|
||
c.JSON(500, gin.H{
|
||
"status": "error",
|
||
"message": "数据查询失败: " + err.Error(),
|
||
})
|
||
return
|
||
}
|
||
|
||
// 2. 检查数据有效性
|
||
if len(aValues) < 10 { // 至少需要10个样本
|
||
c.JSON(400, gin.H{
|
||
"status": "fail",
|
||
"message": "数据量不足，至少需要10个样本",
|
||
})
|
||
return
|
||
}
|
||
|
||
// 3. 计算统计量
|
||
mean, stddev := calculateStats(aValues)
|
||
|
||
// 4. 生成直方图数据
|
||
histogram := calculateHistogram(aValues, 20) // 20个分箱
|
||
|
||
// 5. 生成正态曲线
|
||
x, y := generateNormalCurve(mean, stddev, 100)
|
||
|
||
// 6. 构造响应
|
||
response := AnalysisResponse{
|
||
Status: "success",
|
||
Message: "分析完成",
|
||
Data: struct {
|
||
Mean float64 `json:"mean"`
|
||
StdDev float64 `json:"stdDev"`
|
||
Histogram []HistoBin `json:"histogram"`
|
||
Curve []CurvePoint `json:"curve"`
|
||
}{
|
||
Mean: mean,
|
||
StdDev: stddev,
|
||
Histogram: histogram,
|
||
Curve: convertToCurvePoints(x, y),
|
||
},
|
||
}
|
||
|
||
c.JSON(200, response)
|
||
}
|
||
|
||
// 直方图计算函数
|
||
func calculateHistogram(data []float64, bins int) []HistoBin {
|
||
minV, maxV := floats.Min(data), floats.Max(data)
|
||
binWidth := (maxV - minV) / float64(bins)
|
||
|
||
counts := make([]int, bins)
|
||
for _, v := range data {
|
||
idx := int((v - minV) / binWidth)
|
||
if idx == bins { // 处理最大值刚好等于maxV的情况
|
||
idx--
|
||
}
|
||
counts[idx]++
|
||
}
|
||
|
||
histogram := make([]HistoBin, bins)
|
||
for i := 0; i < bins; i++ {
|
||
start := minV + float64(i)*binWidth
|
||
end := minV + float64(i+1)*binWidth
|
||
histogram[i] = HistoBin{
|
||
BinStart: start,
|
||
BinEnd: end,
|
||
Count: counts[i],
|
||
}
|
||
}
|
||
return histogram
|
||
}
|
||
|
||
// 转换曲线数据格式
|
||
func convertToCurvePoints(x, y []float64) []CurvePoint {
|
||
points := make([]CurvePoint, len(x))
|
||
for i := range x {
|
||
points[i] = CurvePoint{
|
||
X: x[i],
|
||
Y: y[i],
|
||
}
|
||
}
|
||
return points
|
||
}
|
||
|
||
func (tc *TrainingController) heartRateAnalyze(tx *gorm.DB, record models.TrainRecord) error {
|
||
var startTime int64
|
||
if record.TestTime > 0 {
|
||
startTime = record.TestTime
|
||
} else {
|
||
startTime = record.StartTime
|
||
}
|
||
|
||
// 获取所有唯一的beltID
|
||
var beltIDs []uint
|
||
tx.Model(&models.HeartRate{}).Where("train_id = ?", record.TrainId).
|
||
Select("DISTINCT belt_id").Pluck("belt_id", &beltIDs)
|
||
|
||
// 对每个belt计算
|
||
for _, bid := range beltIDs {
|
||
// 计算平均心率
|
||
ranges := getTimeRanges(startTime)
|
||
averages, err := calculateAverages(tx, record.TrainId, bid, ranges)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
// 曲线拟合
|
||
x := []float64{2, 4, 6}
|
||
y := []float64{averages["2min"], averages["4min"], averages["6min"]}
|
||
a, b, _ := quadraticFit(x, y)
|
||
|
||
// 存储结果
|
||
analysis := models.BeltAnalysis{
|
||
TrainID: record.TrainId,
|
||
RunType: record.RunType,
|
||
BeltID: bid,
|
||
Avg2min: averages["2min"],
|
||
Avg4min: averages["4min"],
|
||
Avg6min: averages["6min"],
|
||
CurveParamA: a,
|
||
CurveParamB: b,
|
||
}
|
||
if err := tx.Create(&analysis).Error; err != nil {
|
||
return err
|
||
}
|
||
}
|
||
return nil
|
||
}
|
||
|
||
func collectCurveParams(tx *gorm.DB) ([]float64, error) {
|
||
var aValues []float64
|
||
// 查询所有记录的 CurveParamA 字段
|
||
err := tx.Model(&models.BeltAnalysis{}).Pluck("curve_param_a", &aValues).Error
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
return aValues, nil
|
||
}
|
||
func calculateStats(data []float64) (mean, stddev float64) {
|
||
mean = stat.Mean(data, nil)
|
||
variance := stat.Variance(data, nil)
|
||
stddev = math.Sqrt(variance)
|
||
return
|
||
}
|
||
|
||
func generateNormalCurve(mean, stddev float64, numPoints int) (x, y []float64) {
|
||
normal := distuv.Normal{
|
||
Mu: mean,
|
||
Sigma: stddev,
|
||
}
|
||
|
||
minV := mean - 3*stddev // 从均值-3σ开始
|
||
maxV := mean + 3*stddev // 到均值+3σ结束
|
||
step := (maxV - minV) / float64(numPoints-1)
|
||
|
||
for i := 0; i < numPoints; i++ {
|
||
xi := minV + float64(i)*step
|
||
yi := normal.Prob(xi)
|
||
x = append(x, xi)
|
||
y = append(y, yi)
|
||
}
|
||
return
|
||
}
|
||
func calculateAverages(tx *gorm.DB, trainID uint, beltID uint, ranges map[string]TimeRange) (map[string]float64, error) {
|
||
averages := make(map[string]float64)
|
||
for key, tr := range ranges {
|
||
var avg float64
|
||
// 使用GORM Raw SQL提高效率[6,10](@ref)
|
||
err := tx.Raw(`
|
||
SELECT COALESCE(AVG(value), 0) AS avg -- 关键修复
|
||
FROM heart_rates
|
||
WHERE train_id = ?
|
||
AND belt_id = ?
|
||
AND time BETWEEN ? AND ?`,
|
||
trainID, beltID, tr.Start, tr.End,
|
||
).Scan(&avg).Error
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
averages[key] = avg
|
||
}
|
||
return averages, nil
|
||
}
|
||
|
||
//func quadraticFit(x []float64, y []float64) (float64, error) {
|
||
// // 使用三点计算y=ax²+b的a值（x=[2,4,6]对应分钟）
|
||
// if len(x) != 3 || len(y) != 3 {
|
||
// return 0, errors.New("需要三个点")
|
||
// }
|
||
// // 构造方程组矩阵（简化计算）
|
||
// a := (y[2] - 2*y[1] + y[0]) / (x[2]*x[2] - 2*x[1]*x[1] + x[0]*x[0])
|
||
// return a, nil
|
||
//}
|
||
|
||
func quadraticFit(x []float64, y []float64) (float64, float64, error) {
|
||
// 校验输入长度
|
||
if len(x) != 3 || len(y) != 3 {
|
||
return 0, 0, errors.New("需要三个点")
|
||
}
|
||
|
||
// 计算各项累加值
|
||
var sumX4, sumX2, sumY, sumX2Y float64
|
||
for i := 0; i < 3; i++ {
|
||
xi := x[i]
|
||
xi2 := xi * xi
|
||
sumX4 += xi2 * xi2 // x^4累加
|
||
sumX2 += xi2 // x^2累加
|
||
sumY += y[i] // y累加
|
||
sumX2Y += xi2 * y[i] // x²y累加
|
||
}
|
||
|
||
// 计算行列式
|
||
determinant := sumX4*3 - sumX2*sumX2
|
||
if determinant == 0 {
|
||
return 0, 0, errors.New("无解，行列式为零")
|
||
}
|
||
|
||
// 计算系数 a 和 b
|
||
a := (sumX2Y*3 - sumY*sumX2) / determinant
|
||
b := (sumX4*sumY - sumX2*sumX2Y) / determinant
|
||
|
||
return a, b, nil
|
||
}
|
||
|
||
type TimeRange struct {
|
||
Start int64 // 毫秒时间戳起点
|
||
End int64 // 毫秒时间戳终点
|
||
}
|
||
|
||
func getTimeRanges(startTime int64) map[string]TimeRange {
|
||
// 计算相对于训练开始时间的窗口
|
||
return map[string]TimeRange{
|
||
"2min": {Start: startTime + 120000, End: startTime + 240000}, // 第2分钟（120-240秒）
|
||
"4min": {Start: startTime + 240000, End: startTime + 360000},
|
||
"6min": {Start: startTime + 360000, End: startTime + 480000},
|
||
}
|
||
}
|