1393 lines
46 KiB
Go
1393 lines
46 KiB
Go
package controllers
|
||
|
||
import (
|
||
"errors"
|
||
"hr_receiver/config"
|
||
"hr_receiver/models"
|
||
"math"
|
||
"net/http"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/gin-gonic/gin"
|
||
"gorm.io/gorm"
|
||
)
|
||
|
||
type StatisticsController struct {
|
||
DB *gorm.DB
|
||
}
|
||
|
||
func NewStatisticsController() *StatisticsController {
|
||
return &StatisticsController{DB: config.DB}
|
||
}
|
||
|
||
// --- 请求参数 ---
|
||
|
||
type analysisRecordListParams struct {
|
||
PageNum int `form:"pageNum,default=1"`
|
||
PageSize int `form:"pageSize,default=10"`
|
||
RegionID uint32 `form:"regionId"`
|
||
StartTime int64 `form:"startTime"`
|
||
EndTime int64 `form:"endTime"`
|
||
}
|
||
|
||
type mqttMeasurementHistoryParams struct {
|
||
PageNum int `form:"pageNum,default=1"`
|
||
PageSize int `form:"pageSize,default=50"`
|
||
DataType string `form:"dataType"`
|
||
RegionID uint32 `form:"regionId"`
|
||
Addr string `form:"addr"`
|
||
ValueOperator string `form:"valueOperator"`
|
||
Value *int64 `form:"value"`
|
||
StartTime int64 `form:"startTime"`
|
||
EndTime int64 `form:"endTime"`
|
||
}
|
||
|
||
type mqttMeasurementHistoryItem struct {
|
||
ID uint `json:"id"`
|
||
DataType string `json:"dataType"`
|
||
Identifier string `json:"identifier"`
|
||
Topic string `json:"topic"`
|
||
RegionID uint32 `json:"regionId"`
|
||
Addr string `json:"addr"`
|
||
Value int64 `json:"value"`
|
||
ValueLabel string `json:"valueLabel"`
|
||
PacketNum uint32 `json:"packetNum"`
|
||
GatewayMAC string `json:"gatewayMac"`
|
||
Battery uint32 `json:"battery"`
|
||
IsActive bool `json:"isActive"`
|
||
IsOnSkin bool `json:"isOnSkin"`
|
||
SignalRSSINeg float64 `json:"signalRssiNeg"`
|
||
SNR float64 `json:"snr"`
|
||
ReceivedAt int64 `json:"receivedAt"`
|
||
CreatedAtMilli int64 `json:"createdAt"`
|
||
}
|
||
|
||
type mqttMeasurementHistorySummary struct {
|
||
AvgValue float64 `json:"avgValue"`
|
||
MaxValue int64 `json:"maxValue"`
|
||
MinValue int64 `json:"minValue"`
|
||
RecordCount int64 `json:"recordCount"`
|
||
UniqueAddrs int64 `json:"uniqueAddrs"`
|
||
ValueLabel string `json:"valueLabel"`
|
||
}
|
||
|
||
const (
|
||
mqttChartRawPointLimit int64 = 5000
|
||
mqttChartTargetPointsTotal int64 = 6000
|
||
mqttChartMinPointsPerAddr int64 = 120
|
||
mqttChartMaxPointsPerAddr int64 = 600
|
||
)
|
||
|
||
// --- 查询接口 ---
|
||
|
||
// @Summary 获取AI分析记录列表
|
||
// @Description 分页查询AI分析记录，支持按区域和时间范围筛选
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param pageNum query int false "页码(默认1)"
|
||
// @Param pageSize query int false "每页数量(默认10,最大100)"
|
||
// @Param regionId query int false "区域ID"
|
||
// @Param startTime query int false "开始时间(毫秒时间戳)"
|
||
// @Param endTime query int false "结束时间(毫秒时间戳)"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /admin/statistics/ai-analysis-records [get]
|
||
func (sc *StatisticsController) ListAIAnalysisRecords(c *gin.Context) {
|
||
var params analysisRecordListParams
|
||
if err := c.ShouldBindQuery(¶ms); err != nil {
|
||
writeError(c, http.StatusBadRequest, err.Error())
|
||
return
|
||
}
|
||
if params.PageNum < 1 {
|
||
params.PageNum = 1
|
||
}
|
||
if params.PageSize < 1 || params.PageSize > 100 {
|
||
params.PageSize = 10
|
||
}
|
||
offset := (params.PageNum - 1) * params.PageSize
|
||
|
||
query := sc.DB.Model(&models.AIAnalysisRecord{})
|
||
if params.RegionID > 0 {
|
||
query = query.Where("region_id = ?", params.RegionID)
|
||
}
|
||
if params.StartTime > 0 {
|
||
query = query.Where("upload_time >= ?", params.StartTime)
|
||
}
|
||
if params.EndTime > 0 {
|
||
query = query.Where("upload_time <= ?", params.EndTime)
|
||
}
|
||
|
||
var total int64
|
||
if err := query.Count(&total).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to count records")
|
||
return
|
||
}
|
||
|
||
var records []models.AIAnalysisRecord
|
||
if err := query.Order("upload_time DESC").Offset(offset).Limit(params.PageSize).Find(&records).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query records")
|
||
return
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"list": records,
|
||
"pagination": gin.H{
|
||
"currentPage": params.PageNum,
|
||
"pageSize": params.PageSize,
|
||
"totalList": total,
|
||
"totalPage": int((total + int64(params.PageSize) - 1) / int64(params.PageSize)),
|
||
},
|
||
})
|
||
}
|
||
|
||
// @Summary 获取MQTT测量历史数据
|
||
// @Description 分页查询MQTT测量历史数据，支持按数据类型、区域、地址、数值比较和时间范围筛选
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param pageNum query int false "页码(默认1)"
|
||
// @Param pageSize query int false "每页数量(默认50,最大200)"
|
||
// @Param dataType query string false "数据类型 heart_rate|step_count，默认 heart_rate"
|
||
// @Param regionId query int false "区域ID"
|
||
// @Param addr query string false "地址筛选，模糊匹配 beltAddr"
|
||
// @Param valueOperator query string false "数值比较符 gt|gte|lt|lte|eq"
|
||
// @Param value query int false "数值比较值"
|
||
// @Param startTime query int false "开始时间(毫秒时间戳)"
|
||
// @Param endTime query int false "结束时间(毫秒时间戳)"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /admin/statistics/mqtt-measurements [get]
|
||
func (sc *StatisticsController) ListMqttMeasurementHistory(c *gin.Context) {
|
||
var params mqttMeasurementHistoryParams
|
||
if err := c.ShouldBindQuery(¶ms); err != nil {
|
||
writeError(c, http.StatusBadRequest, err.Error())
|
||
return
|
||
}
|
||
if params.PageNum < 1 {
|
||
params.PageNum = 1
|
||
}
|
||
if params.PageSize < 1 || params.PageSize > 200 {
|
||
params.PageSize = 50
|
||
}
|
||
if strings.TrimSpace(params.DataType) == "" {
|
||
params.DataType = "heart_rate"
|
||
}
|
||
|
||
switch params.DataType {
|
||
case "heart_rate":
|
||
sc.listHeartRateMeasurementHistory(c, params)
|
||
case "step_count":
|
||
sc.listStepCountMeasurementHistory(c, params)
|
||
default:
|
||
writeError(c, http.StatusBadRequest, "unsupported dataType, only heart_rate or step_count is allowed")
|
||
}
|
||
}
|
||
|
||
// @Summary 获取MQTT测量图表数据
|
||
// @Description 查询MQTT测量图表数据，返回同筛选条件下的完整历史序列，不参与分页
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param dataType query string false "数据类型 heart_rate|step_count，默认 heart_rate"
|
||
// @Param regionId query int false "区域ID"
|
||
// @Param addr query string false "地址筛选，模糊匹配 beltAddr"
|
||
// @Param valueOperator query string false "数值比较符 gt|gte|lt|lte|eq"
|
||
// @Param value query int false "数值比较值"
|
||
// @Param startTime query int false "开始时间(毫秒时间戳)"
|
||
// @Param endTime query int false "结束时间(毫秒时间戳)"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /admin/statistics/mqtt-measurements/chart [get]
|
||
func (sc *StatisticsController) MqttMeasurementChartData(c *gin.Context) {
|
||
var params mqttMeasurementHistoryParams
|
||
if err := c.ShouldBindQuery(¶ms); err != nil {
|
||
writeError(c, http.StatusBadRequest, err.Error())
|
||
return
|
||
}
|
||
if strings.TrimSpace(params.DataType) == "" {
|
||
params.DataType = "heart_rate"
|
||
}
|
||
|
||
switch params.DataType {
|
||
case "heart_rate":
|
||
sc.chartHeartRateMeasurementHistory(c, params)
|
||
case "step_count":
|
||
sc.chartStepCountMeasurementHistory(c, params)
|
||
default:
|
||
writeError(c, http.StatusBadRequest, "unsupported dataType, only heart_rate or step_count is allowed")
|
||
}
|
||
}
|
||
|
||
func (sc *StatisticsController) listHeartRateMeasurementHistory(c *gin.Context, params mqttMeasurementHistoryParams) {
|
||
baseQuery := sc.DB.Model(&models.MqttHeartRateRecord{})
|
||
baseQuery = applyMqttMeasurementFilters(baseQuery, params, "belt_addr", "heart_rate", "received_at")
|
||
|
||
var total int64
|
||
if err := baseQuery.Session(&gorm.Session{}).Count(&total).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to count mqtt heart rate records")
|
||
return
|
||
}
|
||
|
||
offset := (params.PageNum - 1) * params.PageSize
|
||
var records []models.MqttHeartRateRecord
|
||
if err := baseQuery.Session(&gorm.Session{}).
|
||
Order("received_at DESC").
|
||
Offset(offset).
|
||
Limit(params.PageSize).
|
||
Find(&records).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt heart rate records")
|
||
return
|
||
}
|
||
|
||
var summary mqttMeasurementHistorySummary
|
||
summary.ValueLabel = "心率"
|
||
if err := buildMqttMeasurementSummary(baseQuery.Session(&gorm.Session{}), "heart_rate", "belt_addr", &summary); err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt heart rate summary")
|
||
return
|
||
}
|
||
|
||
items := make([]mqttMeasurementHistoryItem, 0, len(records))
|
||
for _, record := range records {
|
||
items = append(items, mqttMeasurementHistoryItem{
|
||
ID: record.ID,
|
||
DataType: "heart_rate",
|
||
Identifier: record.Identifier,
|
||
Topic: record.Topic,
|
||
RegionID: record.RegionID,
|
||
Addr: record.BeltAddr,
|
||
Value: int64(record.HeartRate),
|
||
ValueLabel: "心率",
|
||
PacketNum: record.PacketNum,
|
||
GatewayMAC: record.GatewayMAC,
|
||
Battery: record.Battery,
|
||
IsActive: record.IsActive,
|
||
IsOnSkin: record.IsOnSkin,
|
||
SignalRSSINeg: record.SignalRSSINeg,
|
||
SNR: record.SNR,
|
||
ReceivedAt: record.ReceivedAt,
|
||
CreatedAtMilli: record.CreatedAt.UnixMilli(),
|
||
})
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"list": items,
|
||
"pagination": gin.H{
|
||
"currentPage": params.PageNum,
|
||
"pageSize": params.PageSize,
|
||
"totalList": total,
|
||
"totalPage": int((total + int64(params.PageSize) - 1) / int64(params.PageSize)),
|
||
},
|
||
"summary": summary,
|
||
})
|
||
}
|
||
|
||
func (sc *StatisticsController) chartHeartRateMeasurementHistory(c *gin.Context, params mqttMeasurementHistoryParams) {
|
||
baseQuery := sc.DB.Model(&models.MqttHeartRateRecord{})
|
||
baseQuery = applyMqttMeasurementFilters(baseQuery, params, "belt_addr", "heart_rate", "received_at")
|
||
|
||
var summary mqttMeasurementHistorySummary
|
||
summary.ValueLabel = "心率"
|
||
if err := buildMqttMeasurementSummary(baseQuery.Session(&gorm.Session{}), "heart_rate", "belt_addr", &summary); err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt heart rate summary")
|
||
return
|
||
}
|
||
|
||
items, bucketSizeMs, sampled, err := sc.buildHeartRateChartItems(baseQuery, params, summary)
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt heart rate chart records")
|
||
return
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"list": items,
|
||
"summary": summary,
|
||
"sampled": sampled,
|
||
"bucketSizeMs": bucketSizeMs,
|
||
})
|
||
}
|
||
|
||
func (sc *StatisticsController) listStepCountMeasurementHistory(c *gin.Context, params mqttMeasurementHistoryParams) {
|
||
baseQuery := sc.DB.Model(&models.MqttStepCountRecord{})
|
||
baseQuery = applyMqttMeasurementFilters(baseQuery, params, "belt_addr", "step_count", "received_at")
|
||
|
||
var total int64
|
||
if err := baseQuery.Session(&gorm.Session{}).Count(&total).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to count mqtt step count records")
|
||
return
|
||
}
|
||
|
||
offset := (params.PageNum - 1) * params.PageSize
|
||
var records []models.MqttStepCountRecord
|
||
if err := baseQuery.Session(&gorm.Session{}).
|
||
Order("received_at DESC").
|
||
Offset(offset).
|
||
Limit(params.PageSize).
|
||
Find(&records).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt step count records")
|
||
return
|
||
}
|
||
|
||
var summary mqttMeasurementHistorySummary
|
||
summary.ValueLabel = "步数"
|
||
if err := buildMqttMeasurementSummary(baseQuery.Session(&gorm.Session{}), "step_count", "belt_addr", &summary); err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt step count summary")
|
||
return
|
||
}
|
||
|
||
items := make([]mqttMeasurementHistoryItem, 0, len(records))
|
||
for _, record := range records {
|
||
items = append(items, mqttMeasurementHistoryItem{
|
||
ID: record.ID,
|
||
DataType: "step_count",
|
||
Identifier: record.Identifier,
|
||
Topic: record.Topic,
|
||
RegionID: record.RegionID,
|
||
Addr: record.BeltAddr,
|
||
Value: int64(record.StepCount),
|
||
ValueLabel: "步数",
|
||
PacketNum: record.PacketNum,
|
||
GatewayMAC: record.GatewayMAC,
|
||
Battery: 0,
|
||
IsActive: false,
|
||
IsOnSkin: false,
|
||
SignalRSSINeg: record.SignalRSSINeg,
|
||
SNR: record.SNR,
|
||
ReceivedAt: record.ReceivedAt,
|
||
CreatedAtMilli: record.CreatedAt.UnixMilli(),
|
||
})
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"list": items,
|
||
"pagination": gin.H{
|
||
"currentPage": params.PageNum,
|
||
"pageSize": params.PageSize,
|
||
"totalList": total,
|
||
"totalPage": int((total + int64(params.PageSize) - 1) / int64(params.PageSize)),
|
||
},
|
||
"summary": summary,
|
||
})
|
||
}
|
||
|
||
func (sc *StatisticsController) chartStepCountMeasurementHistory(c *gin.Context, params mqttMeasurementHistoryParams) {
|
||
baseQuery := sc.DB.Model(&models.MqttStepCountRecord{})
|
||
baseQuery = applyMqttMeasurementFilters(baseQuery, params, "belt_addr", "step_count", "received_at")
|
||
|
||
var summary mqttMeasurementHistorySummary
|
||
summary.ValueLabel = "步数"
|
||
if err := buildMqttMeasurementSummary(baseQuery.Session(&gorm.Session{}), "step_count", "belt_addr", &summary); err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt step count summary")
|
||
return
|
||
}
|
||
|
||
items, bucketSizeMs, sampled, err := sc.buildStepCountChartItems(baseQuery, params, summary)
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query mqtt step count chart records")
|
||
return
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"list": items,
|
||
"summary": summary,
|
||
"sampled": sampled,
|
||
"bucketSizeMs": bucketSizeMs,
|
||
})
|
||
}
|
||
|
||
func applyMqttMeasurementFilters(query *gorm.DB, params mqttMeasurementHistoryParams, addrField, valueField, timeField string) *gorm.DB {
|
||
if params.RegionID > 0 {
|
||
query = query.Where("region_id = ?", params.RegionID)
|
||
}
|
||
if addr := strings.TrimSpace(params.Addr); addr != "" {
|
||
query = query.Where(addrField+" LIKE ?", "%"+addr+"%")
|
||
}
|
||
if params.StartTime > 0 {
|
||
query = query.Where(timeField+" >= ?", params.StartTime)
|
||
}
|
||
if params.EndTime > 0 {
|
||
query = query.Where(timeField+" <= ?", params.EndTime)
|
||
}
|
||
if params.Value != nil {
|
||
switch strings.TrimSpace(params.ValueOperator) {
|
||
case "", "eq":
|
||
query = query.Where(valueField+" = ?", *params.Value)
|
||
case "gt":
|
||
query = query.Where(valueField+" > ?", *params.Value)
|
||
case "gte":
|
||
query = query.Where(valueField+" >= ?", *params.Value)
|
||
case "lt":
|
||
query = query.Where(valueField+" < ?", *params.Value)
|
||
case "lte":
|
||
query = query.Where(valueField+" <= ?", *params.Value)
|
||
}
|
||
}
|
||
return query
|
||
}
|
||
|
||
func buildMqttMeasurementSummary(query *gorm.DB, valueField, addrField string, summary *mqttMeasurementHistorySummary) error {
|
||
type rawSummary struct {
|
||
RecordCount int64
|
||
UniqueAddrs int64
|
||
MinValue int64
|
||
MaxValue int64
|
||
AvgValue float64
|
||
}
|
||
|
||
var result rawSummary
|
||
if err := query.Session(&gorm.Session{}).Select(
|
||
"COUNT(*) as record_count, COUNT(DISTINCT " + addrField + ") as unique_addrs, COALESCE(MIN(" + valueField + "), 0) as min_value, COALESCE(MAX(" + valueField + "), 0) as max_value, COALESCE(AVG(" + valueField + "), 0) as avg_value",
|
||
).Scan(&result).Error; err != nil {
|
||
return err
|
||
}
|
||
|
||
summary.RecordCount = result.RecordCount
|
||
summary.UniqueAddrs = result.UniqueAddrs
|
||
summary.MinValue = result.MinValue
|
||
summary.MaxValue = result.MaxValue
|
||
summary.AvgValue = result.AvgValue
|
||
return nil
|
||
}
|
||
|
||
func estimateChartBucketSizeMs(params mqttMeasurementHistoryParams, summary mqttMeasurementHistorySummary) int64 {
|
||
if params.StartTime <= 0 || params.EndTime <= params.StartTime {
|
||
return 0
|
||
}
|
||
if summary.RecordCount <= mqttChartRawPointLimit {
|
||
return 0
|
||
}
|
||
|
||
uniqueAddrs := summary.UniqueAddrs
|
||
if uniqueAddrs < 1 {
|
||
uniqueAddrs = 1
|
||
}
|
||
|
||
pointsPerAddr := mqttChartTargetPointsTotal / uniqueAddrs
|
||
if pointsPerAddr < mqttChartMinPointsPerAddr {
|
||
pointsPerAddr = mqttChartMinPointsPerAddr
|
||
}
|
||
if pointsPerAddr > mqttChartMaxPointsPerAddr {
|
||
pointsPerAddr = mqttChartMaxPointsPerAddr
|
||
}
|
||
|
||
rangeMs := params.EndTime - params.StartTime
|
||
if rangeMs <= 0 {
|
||
return 0
|
||
}
|
||
|
||
bucketSizeMs := int64(math.Ceil(float64(rangeMs) / float64(pointsPerAddr)))
|
||
return normalizeBucketSizeMs(bucketSizeMs)
|
||
}
|
||
|
||
func normalizeBucketSizeMs(bucketSizeMs int64) int64 {
|
||
if bucketSizeMs <= 1000 {
|
||
return 1000
|
||
}
|
||
|
||
candidates := []int64{
|
||
1000,
|
||
2000,
|
||
5000,
|
||
10 * 1000,
|
||
15 * 1000,
|
||
30 * 1000,
|
||
60 * 1000,
|
||
2 * 60 * 1000,
|
||
5 * 60 * 1000,
|
||
10 * 60 * 1000,
|
||
15 * 60 * 1000,
|
||
30 * 60 * 1000,
|
||
60 * 60 * 1000,
|
||
2 * 60 * 60 * 1000,
|
||
6 * 60 * 60 * 1000,
|
||
12 * 60 * 60 * 1000,
|
||
24 * 60 * 60 * 1000,
|
||
}
|
||
for _, candidate := range candidates {
|
||
if bucketSizeMs <= candidate {
|
||
return candidate
|
||
}
|
||
}
|
||
return 24 * 60 * 60 * 1000
|
||
}
|
||
|
||
func buildChartBucketExpr(bucketSizeMs int64, timeField string) string {
|
||
return "((" + timeField + " / " + strconv.FormatInt(bucketSizeMs, 10) + ") * " + strconv.FormatInt(bucketSizeMs, 10) + ")"
|
||
}
|
||
|
||
func (sc *StatisticsController) buildHeartRateChartItems(baseQuery *gorm.DB, params mqttMeasurementHistoryParams, summary mqttMeasurementHistorySummary) ([]mqttMeasurementHistoryItem, int64, bool, error) {
|
||
bucketSizeMs := estimateChartBucketSizeMs(params, summary)
|
||
if bucketSizeMs == 0 {
|
||
var records []models.MqttHeartRateRecord
|
||
if err := baseQuery.Session(&gorm.Session{}).
|
||
Order("received_at ASC").
|
||
Find(&records).Error; err != nil {
|
||
return nil, 0, false, err
|
||
}
|
||
items := make([]mqttMeasurementHistoryItem, 0, len(records))
|
||
for _, record := range records {
|
||
items = append(items, mqttMeasurementHistoryItem{
|
||
ID: record.ID,
|
||
DataType: "heart_rate",
|
||
Identifier: record.Identifier,
|
||
Topic: record.Topic,
|
||
RegionID: record.RegionID,
|
||
Addr: record.BeltAddr,
|
||
Value: int64(record.HeartRate),
|
||
ValueLabel: "心率",
|
||
PacketNum: record.PacketNum,
|
||
GatewayMAC: record.GatewayMAC,
|
||
Battery: record.Battery,
|
||
IsActive: record.IsActive,
|
||
IsOnSkin: record.IsOnSkin,
|
||
SignalRSSINeg: record.SignalRSSINeg,
|
||
SNR: record.SNR,
|
||
ReceivedAt: record.ReceivedAt,
|
||
CreatedAtMilli: record.CreatedAt.UnixMilli(),
|
||
})
|
||
}
|
||
return items, 0, false, nil
|
||
}
|
||
|
||
bucketExpr := buildChartBucketExpr(bucketSizeMs, "received_at")
|
||
type rawChartItem struct {
|
||
RegionID uint32
|
||
Addr string
|
||
Value float64
|
||
PacketNum int64
|
||
SignalRSSINeg float64
|
||
SNR float64
|
||
ReceivedAt int64
|
||
CreatedAtMilli int64
|
||
}
|
||
|
||
var rows []rawChartItem
|
||
if err := baseQuery.Session(&gorm.Session{}).
|
||
Select(
|
||
"region_id, belt_addr as addr, ROUND(AVG(heart_rate)) as value, COUNT(*) as packet_num, AVG(signal_rssi_neg) as signal_rssi_neg, AVG(snr) as snr, " + bucketExpr + " as received_at, MIN(EXTRACT(EPOCH FROM created_at) * 1000)::bigint as created_at_milli",
|
||
).
|
||
Group("region_id, belt_addr, " + bucketExpr).
|
||
Order("received_at ASC, addr ASC").
|
||
Scan(&rows).Error; err != nil {
|
||
return nil, bucketSizeMs, true, err
|
||
}
|
||
|
||
items := make([]mqttMeasurementHistoryItem, 0, len(rows))
|
||
for _, row := range rows {
|
||
items = append(items, mqttMeasurementHistoryItem{
|
||
DataType: "heart_rate",
|
||
RegionID: row.RegionID,
|
||
Addr: row.Addr,
|
||
Value: int64(math.Round(row.Value)),
|
||
ValueLabel: "心率",
|
||
PacketNum: uint32(maxInt64(row.PacketNum, 0)),
|
||
SignalRSSINeg: row.SignalRSSINeg,
|
||
SNR: row.SNR,
|
||
ReceivedAt: row.ReceivedAt,
|
||
CreatedAtMilli: row.CreatedAtMilli,
|
||
})
|
||
}
|
||
return items, bucketSizeMs, true, nil
|
||
}
|
||
|
||
func (sc *StatisticsController) buildStepCountChartItems(baseQuery *gorm.DB, params mqttMeasurementHistoryParams, summary mqttMeasurementHistorySummary) ([]mqttMeasurementHistoryItem, int64, bool, error) {
|
||
bucketSizeMs := estimateChartBucketSizeMs(params, summary)
|
||
if bucketSizeMs == 0 {
|
||
var records []models.MqttStepCountRecord
|
||
if err := baseQuery.Session(&gorm.Session{}).
|
||
Order("received_at ASC").
|
||
Find(&records).Error; err != nil {
|
||
return nil, 0, false, err
|
||
}
|
||
items := make([]mqttMeasurementHistoryItem, 0, len(records))
|
||
for _, record := range records {
|
||
items = append(items, mqttMeasurementHistoryItem{
|
||
ID: record.ID,
|
||
DataType: "step_count",
|
||
Identifier: record.Identifier,
|
||
Topic: record.Topic,
|
||
RegionID: record.RegionID,
|
||
Addr: record.BeltAddr,
|
||
Value: int64(record.StepCount),
|
||
ValueLabel: "步数",
|
||
PacketNum: record.PacketNum,
|
||
GatewayMAC: record.GatewayMAC,
|
||
Battery: 0,
|
||
IsActive: false,
|
||
IsOnSkin: false,
|
||
SignalRSSINeg: record.SignalRSSINeg,
|
||
SNR: record.SNR,
|
||
ReceivedAt: record.ReceivedAt,
|
||
CreatedAtMilli: record.CreatedAt.UnixMilli(),
|
||
})
|
||
}
|
||
return items, 0, false, nil
|
||
}
|
||
|
||
bucketExpr := buildChartBucketExpr(bucketSizeMs, "received_at")
|
||
type rawChartItem struct {
|
||
RegionID uint32
|
||
Addr string
|
||
Value float64
|
||
PacketNum int64
|
||
SignalRSSINeg float64
|
||
SNR float64
|
||
ReceivedAt int64
|
||
CreatedAtMilli int64
|
||
}
|
||
|
||
var rows []rawChartItem
|
||
if err := baseQuery.Session(&gorm.Session{}).
|
||
Select(
|
||
"region_id, belt_addr as addr, ROUND(AVG(step_count)) as value, COUNT(*) as packet_num, AVG(signal_rssi_neg) as signal_rssi_neg, AVG(snr) as snr, " + bucketExpr + " as received_at, MIN(EXTRACT(EPOCH FROM created_at) * 1000)::bigint as created_at_milli",
|
||
).
|
||
Group("region_id, belt_addr, " + bucketExpr).
|
||
Order("received_at ASC, addr ASC").
|
||
Scan(&rows).Error; err != nil {
|
||
return nil, bucketSizeMs, true, err
|
||
}
|
||
|
||
items := make([]mqttMeasurementHistoryItem, 0, len(rows))
|
||
for _, row := range rows {
|
||
items = append(items, mqttMeasurementHistoryItem{
|
||
DataType: "step_count",
|
||
RegionID: row.RegionID,
|
||
Addr: row.Addr,
|
||
Value: int64(math.Round(row.Value)),
|
||
ValueLabel: "步数",
|
||
PacketNum: uint32(maxInt64(row.PacketNum, 0)),
|
||
SignalRSSINeg: row.SignalRSSINeg,
|
||
SNR: row.SNR,
|
||
ReceivedAt: row.ReceivedAt,
|
||
CreatedAtMilli: row.CreatedAtMilli,
|
||
})
|
||
}
|
||
return items, bucketSizeMs, true, nil
|
||
}
|
||
|
||
func maxInt64(value, floor int64) int64 {
|
||
if value < floor {
|
||
return floor
|
||
}
|
||
return value
|
||
}
|
||
|
||
// --- 删除接口 ---
|
||
|
||
// @Summary 删除AI分析记录
|
||
// @Description 删除指定的AI分析记录
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param id path int true "记录ID"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "删除成功"
|
||
// @Failure 404 {object} SwagAPIResponse "记录不存在"
|
||
// @Router /admin/statistics/ai-analysis-records/{id} [delete]
|
||
func (sc *StatisticsController) DeleteAIAnalysisRecord(c *gin.Context) {
|
||
id := strings.TrimSpace(c.Param("id"))
|
||
if id == "" {
|
||
writeError(c, http.StatusBadRequest, "id is required")
|
||
return
|
||
}
|
||
|
||
var record models.AIAnalysisRecord
|
||
if err := sc.DB.First(&record, id).Error; err != nil {
|
||
if errors.Is(err, gorm.ErrRecordNotFound) {
|
||
writeError(c, http.StatusNotFound, "record not found")
|
||
return
|
||
}
|
||
writeError(c, http.StatusInternalServerError, "failed to query record")
|
||
return
|
||
}
|
||
|
||
if err := sc.DB.Delete(&record).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to delete record")
|
||
return
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "delete success", nil)
|
||
}
|
||
|
||
// --- 统计接口 ---
|
||
|
||
type regionStatisticsItem struct {
|
||
RegionID uint32 `json:"regionId"`
|
||
KindergartenName string `json:"kindergartenName"`
|
||
Count int64 `json:"count"`
|
||
TotalInputTokens int64 `json:"totalInputTokens"`
|
||
TotalOutputTokens int64 `json:"totalOutputTokens"`
|
||
TotalCacheHitTokens int64 `json:"totalCacheHitTokens"`
|
||
TotalCacheMissTokens int64 `json:"totalCacheMissTokens"`
|
||
TotalInputSizeBytes int64 `json:"totalInputSizeBytes"`
|
||
TotalOutputSizeBytes int64 `json:"totalOutputSizeBytes"`
|
||
TotalDurationMs int64 `json:"totalDurationMs"`
|
||
AvgDurationMs float64 `json:"avgDurationMs"`
|
||
AvgTotalCost float64 `json:"avgTotalCost"`
|
||
TotalOriginalFileSize int64 `json:"totalOriginalFileSize"`
|
||
TotalCompressedSize int64 `json:"totalCompressedSize"`
|
||
TotalCost float64 `json:"totalCost"`
|
||
TotalInputCost float64 `json:"totalInputCost"`
|
||
TotalOutputCost float64 `json:"totalOutputCost"`
|
||
TotalCacheHitCost float64 `json:"totalCacheHitCost"`
|
||
TotalCacheMissCost float64 `json:"totalCacheMissCost"`
|
||
AnalysisTypeCounts map[string]int64 `json:"analysisTypeCounts"`
|
||
SourceTypeCounts map[string]int64 `json:"sourceTypeCounts"`
|
||
FirstUsedAt *time.Time `json:"firstUsedAt"`
|
||
LastUsedAt *time.Time `json:"lastUsedAt"`
|
||
}
|
||
|
||
// @Summary AI分析区域统计
|
||
// @Description 按区域统计AI分析的使用情况，包括调用次数、Token消耗、费用等
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param regionId query int false "区域ID"
|
||
// @Param startTime query int false "开始时间(毫秒时间戳)"
|
||
// @Param endTime query int false "结束时间(毫秒时间戳)"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /admin/statistics/ai-analysis [get]
|
||
func (sc *StatisticsController) StatisticsByRegion(c *gin.Context) {
|
||
regionIDStr := c.Query("regionId")
|
||
startTimeStr := c.Query("startTime")
|
||
endTimeStr := c.Query("endTime")
|
||
|
||
query := sc.DB.Model(&models.AIAnalysisRecord{})
|
||
if regionIDStr != "" {
|
||
if regionID, err := strconv.ParseUint(regionIDStr, 10, 32); err == nil {
|
||
query = query.Where("region_id = ?", uint32(regionID))
|
||
}
|
||
}
|
||
if startTimeStr != "" {
|
||
if startTime, err := strconv.ParseInt(startTimeStr, 10, 64); err == nil {
|
||
query = query.Where("upload_time >= ?", startTime)
|
||
}
|
||
}
|
||
if endTimeStr != "" {
|
||
if endTime, err := strconv.ParseInt(endTimeStr, 10, 64); err == nil {
|
||
query = query.Where("upload_time <= ?", endTime)
|
||
}
|
||
}
|
||
|
||
type rawStats struct {
|
||
RegionID *uint32
|
||
Count int64
|
||
TotalInputTokens int64
|
||
TotalOutputTokens int64
|
||
TotalCacheHitTokens int64
|
||
TotalCacheMissTokens int64
|
||
TotalInputSizeBytes int64
|
||
TotalOutputSizeBytes int64
|
||
TotalDurationMs int64
|
||
TotalOriginalFileSize int64
|
||
TotalCompressedSize int64
|
||
TotalCost float64
|
||
TotalInputCost float64
|
||
TotalOutputCost float64
|
||
TotalCacheHitCost float64
|
||
TotalCacheMissCost float64
|
||
FirstUsedAt *int64
|
||
LastUsedAt *int64
|
||
}
|
||
|
||
var rawResults []rawStats
|
||
err := query.Select(`
|
||
region_id,
|
||
COUNT(*) as count,
|
||
COALESCE(SUM(input_tokens), 0) as total_input_tokens,
|
||
COALESCE(SUM(output_tokens), 0) as total_output_tokens,
|
||
COALESCE(SUM(cache_hit_tokens), 0) as total_cache_hit_tokens,
|
||
COALESCE(SUM(cache_miss_tokens), 0) as total_cache_miss_tokens,
|
||
COALESCE(SUM(input_size_bytes), 0) as total_input_size_bytes,
|
||
COALESCE(SUM(output_size_bytes), 0) as total_output_size_bytes,
|
||
COALESCE(SUM(duration_ms), 0) as total_duration_ms,
|
||
COALESCE(SUM(original_file_size), 0) as total_original_file_size,
|
||
COALESCE(SUM(compressed_content_size), 0) as total_compressed_size,
|
||
COALESCE(SUM(total_cost), 0) as total_cost,
|
||
COALESCE(SUM((cost_json::jsonb->>'cacheHitCost')::float8 + (cost_json::jsonb->>'cacheMissCost')::float8), 0) as total_input_cost,
|
||
COALESCE(SUM((cost_json::jsonb->>'outputCost')::float8), 0) as total_output_cost,
|
||
COALESCE(SUM((cost_json::jsonb->>'cacheHitCost')::float8), 0) as total_cache_hit_cost,
|
||
COALESCE(SUM((cost_json::jsonb->>'cacheMissCost')::float8), 0) as total_cache_miss_cost,
|
||
MIN(upload_time) as first_used_at,
|
||
MAX(upload_time) as last_used_at
|
||
`).Group("region_id").Scan(&rawResults).Error
|
||
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query statistics")
|
||
return
|
||
}
|
||
|
||
type analysisTypeCount struct {
|
||
RegionID *uint32
|
||
AnalysisType string
|
||
Count int64
|
||
}
|
||
var analysisTypeResults []analysisTypeCount
|
||
if err := query.Select("region_id, analysis_type, COUNT(*) as count").Group("region_id, analysis_type").Scan(&analysisTypeResults).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query analysis type statistics")
|
||
return
|
||
}
|
||
|
||
type sourceTypeCount struct {
|
||
RegionID *uint32
|
||
SourceType string
|
||
Count int64
|
||
}
|
||
var sourceTypeResults []sourceTypeCount
|
||
if err := query.Select("region_id, source_type, COUNT(*) as count").Group("region_id, source_type").Scan(&sourceTypeResults).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query source type statistics")
|
||
return
|
||
}
|
||
|
||
analysisTypeMap := make(map[uint32]map[string]int64)
|
||
for _, r := range analysisTypeResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
if analysisTypeMap[regionID] == nil {
|
||
analysisTypeMap[regionID] = make(map[string]int64)
|
||
}
|
||
analysisTypeMap[regionID][r.AnalysisType] = r.Count
|
||
}
|
||
|
||
sourceTypeMap := make(map[uint32]map[string]int64)
|
||
for _, r := range sourceTypeResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
if sourceTypeMap[regionID] == nil {
|
||
sourceTypeMap[regionID] = make(map[string]int64)
|
||
}
|
||
sourceTypeMap[regionID][r.SourceType] = r.Count
|
||
}
|
||
|
||
// 收集所有 regionId 查询幼儿园名称
|
||
regionIDs := make([]uint32, 0, len(rawResults))
|
||
for _, r := range rawResults {
|
||
if r.RegionID != nil && *r.RegionID > 0 {
|
||
regionIDs = append(regionIDs, *r.RegionID)
|
||
}
|
||
}
|
||
kindergartenMap := make(map[uint32]string)
|
||
if len(regionIDs) > 0 {
|
||
var kindergartens []models.Kindergarten
|
||
if err := sc.DB.Where("region_id IN ?", regionIDs).Find(&kindergartens).Error; err == nil {
|
||
for _, k := range kindergartens {
|
||
kindergartenMap[k.RegionID] = k.Name
|
||
}
|
||
}
|
||
}
|
||
|
||
overall := regionStatisticsItem{
|
||
AnalysisTypeCounts: make(map[string]int64),
|
||
SourceTypeCounts: make(map[string]int64),
|
||
}
|
||
regions := make(map[string]regionStatisticsItem, len(rawResults))
|
||
|
||
for _, r := range rawResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
avgDuration := float64(0)
|
||
if r.Count > 0 {
|
||
avgDuration = float64(r.TotalDurationMs) / float64(r.Count)
|
||
}
|
||
avgTotalCost := float64(0)
|
||
if r.Count > 0 {
|
||
avgTotalCost = r.TotalCost / float64(r.Count)
|
||
}
|
||
kgName := ""
|
||
if regionID > 0 {
|
||
kgName = kindergartenMap[regionID]
|
||
}
|
||
|
||
var firstUsedAt, lastUsedAt *time.Time
|
||
if r.FirstUsedAt != nil {
|
||
t := time.UnixMilli(*r.FirstUsedAt)
|
||
firstUsedAt = &t
|
||
}
|
||
if r.LastUsedAt != nil {
|
||
t := time.UnixMilli(*r.LastUsedAt)
|
||
lastUsedAt = &t
|
||
}
|
||
|
||
item := regionStatisticsItem{
|
||
RegionID: regionID,
|
||
KindergartenName: kgName,
|
||
Count: r.Count,
|
||
TotalInputTokens: r.TotalInputTokens,
|
||
TotalOutputTokens: r.TotalOutputTokens,
|
||
TotalCacheHitTokens: r.TotalCacheHitTokens,
|
||
TotalCacheMissTokens: r.TotalCacheMissTokens,
|
||
TotalInputSizeBytes: r.TotalInputSizeBytes,
|
||
TotalOutputSizeBytes: r.TotalOutputSizeBytes,
|
||
TotalDurationMs: r.TotalDurationMs,
|
||
AvgDurationMs: avgDuration,
|
||
AvgTotalCost: avgTotalCost,
|
||
TotalOriginalFileSize: r.TotalOriginalFileSize,
|
||
TotalCompressedSize: r.TotalCompressedSize,
|
||
TotalCost: r.TotalCost,
|
||
TotalInputCost: r.TotalInputCost,
|
||
TotalOutputCost: r.TotalOutputCost,
|
||
TotalCacheHitCost: r.TotalCacheHitCost,
|
||
TotalCacheMissCost: r.TotalCacheMissCost,
|
||
AnalysisTypeCounts: analysisTypeMap[regionID],
|
||
SourceTypeCounts: sourceTypeMap[regionID],
|
||
FirstUsedAt: firstUsedAt,
|
||
LastUsedAt: lastUsedAt,
|
||
}
|
||
|
||
regions[strconv.FormatUint(uint64(regionID), 10)] = item
|
||
|
||
overall.Count += r.Count
|
||
overall.TotalInputTokens += r.TotalInputTokens
|
||
overall.TotalOutputTokens += r.TotalOutputTokens
|
||
overall.TotalCacheHitTokens += r.TotalCacheHitTokens
|
||
overall.TotalCacheMissTokens += r.TotalCacheMissTokens
|
||
overall.TotalInputSizeBytes += r.TotalInputSizeBytes
|
||
overall.TotalOutputSizeBytes += r.TotalOutputSizeBytes
|
||
overall.TotalDurationMs += r.TotalDurationMs
|
||
overall.TotalOriginalFileSize += r.TotalOriginalFileSize
|
||
overall.TotalCompressedSize += r.TotalCompressedSize
|
||
overall.TotalCost += r.TotalCost
|
||
overall.TotalInputCost += r.TotalInputCost
|
||
overall.TotalOutputCost += r.TotalOutputCost
|
||
overall.TotalCacheHitCost += r.TotalCacheHitCost
|
||
overall.TotalCacheMissCost += r.TotalCacheMissCost
|
||
|
||
if firstUsedAt != nil {
|
||
if overall.FirstUsedAt == nil || firstUsedAt.Before(*overall.FirstUsedAt) {
|
||
overall.FirstUsedAt = firstUsedAt
|
||
}
|
||
}
|
||
if lastUsedAt != nil {
|
||
if overall.LastUsedAt == nil || lastUsedAt.After(*overall.LastUsedAt) {
|
||
overall.LastUsedAt = lastUsedAt
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, r := range analysisTypeResults {
|
||
overall.AnalysisTypeCounts[r.AnalysisType] += r.Count
|
||
}
|
||
for _, r := range sourceTypeResults {
|
||
overall.SourceTypeCounts[r.SourceType] += r.Count
|
||
}
|
||
|
||
if overall.Count > 0 {
|
||
overall.AvgDurationMs = float64(overall.TotalDurationMs) / float64(overall.Count)
|
||
overall.AvgTotalCost = overall.TotalCost / float64(overall.Count)
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"overall": overall,
|
||
"regions": regions,
|
||
})
|
||
}
|
||
|
||
type trainingSessionRegionStatisticsItem struct {
|
||
RegionID uint32 `json:"regionId"`
|
||
KindergartenName string `json:"kindergartenName"`
|
||
Count int64 `json:"count"`
|
||
StartedCount int64 `json:"startedCount"`
|
||
EndedCount int64 `json:"endedCount"`
|
||
CompletedCount int64 `json:"completedCount"`
|
||
InProgressCount int64 `json:"inProgressCount"`
|
||
TotalDurationMs int64 `json:"totalDurationMs"`
|
||
AvgDurationMs float64 `json:"avgDurationMs"`
|
||
EventTypeCounts map[string]int64 `json:"eventTypeCounts"`
|
||
AppNameCounts map[string]int64 `json:"appNameCounts"`
|
||
FlavorTypeCounts map[string]int64 `json:"flavorTypeCounts"`
|
||
FirstPublishedAt *time.Time `json:"firstPublishedAt"`
|
||
LastPublishedAt *time.Time `json:"lastPublishedAt"`
|
||
}
|
||
|
||
// @Summary 训练会话区域统计
|
||
// @Description 按区域统计MQTT训练会话情况，包括开始、结束、完成、进行中的会话数
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param regionId query int false "区域ID"
|
||
// @Param flavorType query string false "类型筛选"
|
||
// @Param startTime query int false "开始时间(毫秒时间戳)"
|
||
// @Param endTime query int false "结束时间(毫秒时间戳)"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /admin/statistics/mqtt-training-sessions [get]
|
||
func (sc *StatisticsController) TrainingSessionStatisticsByRegion(c *gin.Context) {
|
||
regionIDStr := c.Query("regionId")
|
||
flavorType := strings.TrimSpace(c.Query("flavorType"))
|
||
startTimeStr := c.Query("startTime")
|
||
endTimeStr := c.Query("endTime")
|
||
|
||
query := sc.DB.Model(&models.MqttTrainingSessionRecord{})
|
||
if regionIDStr != "" {
|
||
if regionID, err := strconv.ParseUint(regionIDStr, 10, 32); err == nil {
|
||
query = query.Where("region_id = ?", uint32(regionID))
|
||
}
|
||
}
|
||
if flavorType != "" {
|
||
query = query.Where("flavor_type = ?", flavorType)
|
||
}
|
||
if startTimeStr != "" {
|
||
if startTime, err := strconv.ParseInt(startTimeStr, 10, 64); err == nil {
|
||
query = query.Where("published_at >= ?", startTime)
|
||
}
|
||
}
|
||
if endTimeStr != "" {
|
||
if endTime, err := strconv.ParseInt(endTimeStr, 10, 64); err == nil {
|
||
query = query.Where("published_at <= ?", endTime)
|
||
}
|
||
}
|
||
|
||
type rawTrainingStats struct {
|
||
RegionID *uint32
|
||
Count int64
|
||
StartedCount int64
|
||
EndedCount int64
|
||
CompletedCount int64
|
||
InProgressCount int64
|
||
TotalDurationMs int64
|
||
FirstPublishedAt *int64
|
||
LastPublishedAt *int64
|
||
}
|
||
|
||
var rawResults []rawTrainingStats
|
||
err := query.Select(`
|
||
region_id,
|
||
COUNT(*) as count,
|
||
COALESCE(SUM(CASE WHEN started_at IS NOT NULL THEN 1 ELSE 0 END), 0) as started_count,
|
||
COALESCE(SUM(CASE WHEN ended_at IS NOT NULL THEN 1 ELSE 0 END), 0) as ended_count,
|
||
COALESCE(SUM(CASE WHEN started_at IS NOT NULL AND ended_at IS NOT NULL THEN 1 ELSE 0 END), 0) as completed_count,
|
||
COALESCE(SUM(CASE WHEN started_at IS NOT NULL AND ended_at IS NULL THEN 1 ELSE 0 END), 0) as in_progress_count,
|
||
COALESCE(SUM(CASE WHEN started_at IS NOT NULL AND ended_at IS NOT NULL AND ended_at >= started_at THEN ended_at - started_at ELSE 0 END), 0) as total_duration_ms,
|
||
MIN(published_at) as first_published_at,
|
||
MAX(published_at) as last_published_at
|
||
`).Group("region_id").Scan(&rawResults).Error
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query training session statistics")
|
||
return
|
||
}
|
||
|
||
type trainingEventTypeCount struct {
|
||
RegionID *uint32
|
||
EventType string
|
||
Count int64
|
||
}
|
||
var eventTypeResults []trainingEventTypeCount
|
||
if err := query.Select("region_id, event_type, COUNT(*) as count").Group("region_id, event_type").Scan(&eventTypeResults).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query training session event type statistics")
|
||
return
|
||
}
|
||
|
||
type trainingAppNameCount struct {
|
||
RegionID *uint32
|
||
AppName string
|
||
Count int64
|
||
}
|
||
var appNameResults []trainingAppNameCount
|
||
if err := query.Select("region_id, app_name, COUNT(*) as count").Group("region_id, app_name").Scan(&appNameResults).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query training session app name statistics")
|
||
return
|
||
}
|
||
|
||
type trainingFlavorTypeCount struct {
|
||
RegionID *uint32
|
||
FlavorType string
|
||
Count int64
|
||
}
|
||
var flavorTypeResults []trainingFlavorTypeCount
|
||
if err := query.Select("region_id, flavor_type, COUNT(*) as count").Group("region_id, flavor_type").Scan(&flavorTypeResults).Error; err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query training session flavor type statistics")
|
||
return
|
||
}
|
||
|
||
eventTypeMap := make(map[uint32]map[string]int64)
|
||
for _, r := range eventTypeResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
if eventTypeMap[regionID] == nil {
|
||
eventTypeMap[regionID] = make(map[string]int64)
|
||
}
|
||
eventTypeMap[regionID][r.EventType] = r.Count
|
||
}
|
||
|
||
appNameMap := make(map[uint32]map[string]int64)
|
||
for _, r := range appNameResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
if appNameMap[regionID] == nil {
|
||
appNameMap[regionID] = make(map[string]int64)
|
||
}
|
||
appNameMap[regionID][r.AppName] = r.Count
|
||
}
|
||
|
||
flavorTypeMap := make(map[uint32]map[string]int64)
|
||
for _, r := range flavorTypeResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
if flavorTypeMap[regionID] == nil {
|
||
flavorTypeMap[regionID] = make(map[string]int64)
|
||
}
|
||
flavorTypeMap[regionID][r.FlavorType] = r.Count
|
||
}
|
||
|
||
regionIDs := make([]uint32, 0, len(rawResults))
|
||
for _, r := range rawResults {
|
||
if r.RegionID != nil && *r.RegionID > 0 {
|
||
regionIDs = append(regionIDs, *r.RegionID)
|
||
}
|
||
}
|
||
kindergartenMap := make(map[uint32]string)
|
||
if len(regionIDs) > 0 {
|
||
var kindergartens []models.Kindergarten
|
||
if err := sc.DB.Where("region_id IN ?", regionIDs).Find(&kindergartens).Error; err == nil {
|
||
for _, k := range kindergartens {
|
||
kindergartenMap[k.RegionID] = k.Name
|
||
}
|
||
}
|
||
}
|
||
|
||
overall := trainingSessionRegionStatisticsItem{
|
||
EventTypeCounts: make(map[string]int64),
|
||
AppNameCounts: make(map[string]int64),
|
||
FlavorTypeCounts: make(map[string]int64),
|
||
}
|
||
regions := make(map[string]trainingSessionRegionStatisticsItem, len(rawResults))
|
||
|
||
for _, r := range rawResults {
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
avgDuration := float64(0)
|
||
if r.CompletedCount > 0 {
|
||
avgDuration = float64(r.TotalDurationMs) / float64(r.CompletedCount)
|
||
}
|
||
kgName := ""
|
||
if regionID > 0 {
|
||
kgName = kindergartenMap[regionID]
|
||
}
|
||
|
||
var firstPublishedAt, lastPublishedAt *time.Time
|
||
if r.FirstPublishedAt != nil {
|
||
t := time.UnixMilli(*r.FirstPublishedAt)
|
||
firstPublishedAt = &t
|
||
}
|
||
if r.LastPublishedAt != nil {
|
||
t := time.UnixMilli(*r.LastPublishedAt)
|
||
lastPublishedAt = &t
|
||
}
|
||
|
||
item := trainingSessionRegionStatisticsItem{
|
||
RegionID: regionID,
|
||
KindergartenName: kgName,
|
||
Count: r.Count,
|
||
StartedCount: r.StartedCount,
|
||
EndedCount: r.EndedCount,
|
||
CompletedCount: r.CompletedCount,
|
||
InProgressCount: r.InProgressCount,
|
||
TotalDurationMs: r.TotalDurationMs,
|
||
AvgDurationMs: avgDuration,
|
||
EventTypeCounts: eventTypeMap[regionID],
|
||
AppNameCounts: appNameMap[regionID],
|
||
FlavorTypeCounts: flavorTypeMap[regionID],
|
||
FirstPublishedAt: firstPublishedAt,
|
||
LastPublishedAt: lastPublishedAt,
|
||
}
|
||
|
||
regions[strconv.FormatUint(uint64(regionID), 10)] = item
|
||
|
||
overall.Count += r.Count
|
||
overall.StartedCount += r.StartedCount
|
||
overall.EndedCount += r.EndedCount
|
||
overall.CompletedCount += r.CompletedCount
|
||
overall.InProgressCount += r.InProgressCount
|
||
overall.TotalDurationMs += r.TotalDurationMs
|
||
|
||
if firstPublishedAt != nil {
|
||
if overall.FirstPublishedAt == nil || firstPublishedAt.Before(*overall.FirstPublishedAt) {
|
||
overall.FirstPublishedAt = firstPublishedAt
|
||
}
|
||
}
|
||
if lastPublishedAt != nil {
|
||
if overall.LastPublishedAt == nil || lastPublishedAt.After(*overall.LastPublishedAt) {
|
||
overall.LastPublishedAt = lastPublishedAt
|
||
}
|
||
}
|
||
}
|
||
|
||
for _, r := range eventTypeResults {
|
||
overall.EventTypeCounts[r.EventType] += r.Count
|
||
}
|
||
for _, r := range appNameResults {
|
||
overall.AppNameCounts[r.AppName] += r.Count
|
||
}
|
||
for _, r := range flavorTypeResults {
|
||
overall.FlavorTypeCounts[r.FlavorType] += r.Count
|
||
}
|
||
|
||
if overall.CompletedCount > 0 {
|
||
overall.AvgDurationMs = float64(overall.TotalDurationMs) / float64(overall.CompletedCount)
|
||
}
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"overall": overall,
|
||
"regions": regions,
|
||
})
|
||
}
|
||
|
||
// @Summary AI分析时间线统计
|
||
// @Description 按日期统计AI分析的使用情况趋势，含总体和分区域数据
|
||
// @Tags 统计管理
|
||
// @Produce json
|
||
// @Param regionId query int false "区域ID"
|
||
// @Param startTime query int false "开始时间(毫秒时间戳)"
|
||
// @Param endTime query int false "结束时间(毫秒时间戳)"
|
||
// @Security BearerAuth
|
||
// @Success 200 {object} SwagAPIResponse "查询成功"
|
||
// @Router /admin/statistics/ai-analysis-timeline [get]
|
||
func (sc *StatisticsController) TimelineStatistics(c *gin.Context) {
|
||
regionIDStr := c.Query("regionId")
|
||
startTimeStr := c.Query("startTime")
|
||
endTimeStr := c.Query("endTime")
|
||
|
||
query := sc.DB.Model(&models.AIAnalysisRecord{})
|
||
if regionIDStr != "" {
|
||
if regionID, err := strconv.ParseUint(regionIDStr, 10, 32); err == nil {
|
||
query = query.Where("region_id = ?", uint32(regionID))
|
||
}
|
||
}
|
||
if startTimeStr != "" {
|
||
if startTime, err := strconv.ParseInt(startTimeStr, 10, 64); err == nil {
|
||
query = query.Where("upload_time >= ?", startTime)
|
||
}
|
||
}
|
||
if endTimeStr != "" {
|
||
if endTime, err := strconv.ParseInt(endTimeStr, 10, 64); err == nil {
|
||
query = query.Where("upload_time <= ?", endTime)
|
||
}
|
||
}
|
||
|
||
type timelineItem struct {
|
||
Date string `json:"date"`
|
||
Count int64 `json:"count"`
|
||
InputTokens int64 `json:"inputTokens"`
|
||
OutputTokens int64 `json:"outputTokens"`
|
||
CacheHitTokens int64 `json:"cacheHitTokens"`
|
||
CacheMissTokens int64 `json:"cacheMissTokens"`
|
||
TotalCost float64 `json:"totalCost"`
|
||
}
|
||
|
||
type rawRegionTimeline struct {
|
||
RegionID *uint32
|
||
Date string
|
||
Count int64
|
||
InputTokens int64
|
||
OutputTokens int64
|
||
CacheHitTokens int64
|
||
CacheMissTokens int64
|
||
TotalCost float64
|
||
}
|
||
|
||
var rawResults []rawRegionTimeline
|
||
err := query.Select(`
|
||
region_id,
|
||
DATE(TO_TIMESTAMP(upload_time / 1000.0)) as date,
|
||
COUNT(*) as count,
|
||
COALESCE(SUM(input_tokens), 0) as input_tokens,
|
||
COALESCE(SUM(output_tokens), 0) as output_tokens,
|
||
COALESCE(SUM(cache_hit_tokens), 0) as cache_hit_tokens,
|
||
COALESCE(SUM(cache_miss_tokens), 0) as cache_miss_tokens,
|
||
COALESCE(SUM(total_cost), 0) as total_cost
|
||
`).Group("region_id, DATE(TO_TIMESTAMP(upload_time / 1000.0))").Order("region_id, date ASC").Scan(&rawResults).Error
|
||
|
||
if err != nil {
|
||
writeError(c, http.StatusInternalServerError, "failed to query timeline statistics")
|
||
return
|
||
}
|
||
|
||
overallMap := make(map[string]*timelineItem)
|
||
regionItemsMap := make(map[string][]timelineItem)
|
||
regionIDs := make([]uint32, 0)
|
||
regionIDSet := make(map[uint32]struct{})
|
||
|
||
for _, r := range rawResults {
|
||
if overallMap[r.Date] == nil {
|
||
overallMap[r.Date] = &timelineItem{Date: r.Date}
|
||
}
|
||
overallMap[r.Date].Count += r.Count
|
||
overallMap[r.Date].InputTokens += r.InputTokens
|
||
overallMap[r.Date].OutputTokens += r.OutputTokens
|
||
overallMap[r.Date].CacheHitTokens += r.CacheHitTokens
|
||
overallMap[r.Date].CacheMissTokens += r.CacheMissTokens
|
||
overallMap[r.Date].TotalCost += r.TotalCost
|
||
|
||
regionID := uint32(0)
|
||
if r.RegionID != nil {
|
||
regionID = *r.RegionID
|
||
}
|
||
regionIDStr := strconv.FormatUint(uint64(regionID), 10)
|
||
regionItemsMap[regionIDStr] = append(regionItemsMap[regionIDStr], timelineItem{
|
||
Date: r.Date,
|
||
Count: r.Count,
|
||
InputTokens: r.InputTokens,
|
||
OutputTokens: r.OutputTokens,
|
||
CacheHitTokens: r.CacheHitTokens,
|
||
CacheMissTokens: r.CacheMissTokens,
|
||
TotalCost: r.TotalCost,
|
||
})
|
||
if _, ok := regionIDSet[regionID]; !ok && regionID > 0 {
|
||
regionIDSet[regionID] = struct{}{}
|
||
regionIDs = append(regionIDs, regionID)
|
||
}
|
||
}
|
||
|
||
// 查询幼儿园名称
|
||
kindergartenMap := make(map[uint32]string)
|
||
if len(regionIDs) > 0 {
|
||
var kindergartens []models.Kindergarten
|
||
if err := sc.DB.Where("region_id IN ?", regionIDs).Find(&kindergartens).Error; err == nil {
|
||
for _, k := range kindergartens {
|
||
kindergartenMap[k.RegionID] = k.Name
|
||
}
|
||
}
|
||
}
|
||
|
||
type regionTimeline struct {
|
||
Name string `json:"name"`
|
||
Items []timelineItem `json:"items"`
|
||
}
|
||
regionsMap := make(map[string]regionTimeline)
|
||
for regionIDStr, items := range regionItemsMap {
|
||
name := ""
|
||
if regionID, err := strconv.ParseUint(regionIDStr, 10, 32); err == nil && regionID > 0 {
|
||
name = kindergartenMap[uint32(regionID)]
|
||
}
|
||
regionsMap[regionIDStr] = regionTimeline{
|
||
Name: name,
|
||
Items: items,
|
||
}
|
||
}
|
||
|
||
var overall []timelineItem
|
||
for _, item := range overallMap {
|
||
overall = append(overall, *item)
|
||
}
|
||
sort.Slice(overall, func(i, j int) bool {
|
||
return overall[i].Date < overall[j].Date
|
||
})
|
||
|
||
writeSuccess(c, http.StatusOK, "query success", gin.H{
|
||
"overall": overall,
|
||
"regions": regionsMap,
|
||
})
|
||
}
|