650 lines
18 KiB
Go
650 lines
18 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"strconv"
|
||
"time"
|
||
|
||
"cid/dao"
|
||
"cid/model/dto"
|
||
"cid/model/entity"
|
||
|
||
"github.com/gogf/gf/v2/frame/g"
|
||
"github.com/gogf/gf/v2/util/gconv"
|
||
)
|
||
|
||
type StatReportService struct{}
|
||
|
||
var StatReport = &StatReportService{}
|
||
|
||
// GenerateDailyReport 生成日报表（现在只用于手动触发，定时任务会自动生成）
|
||
func (s *StatReportService) GenerateDailyReport(ctx context.Context, req *dto.ReportGenerateReq) (*dto.ReportGenerateResp, error) {
|
||
// 获取统计日期
|
||
reportDate := time.Now()
|
||
if req.Date != "" {
|
||
parsedDate, err := time.Parse("2006-01-02", req.Date)
|
||
if err == nil {
|
||
reportDate = parsedDate
|
||
}
|
||
}
|
||
|
||
// 检查是否已存在报表
|
||
existingReport, err := dao.StatReport.GetByTenantAndDate(ctx, strconv.FormatInt(req.TenantID, 10), "daily", reportDate.Format("2006-01-02"))
|
||
if err == nil && existingReport != nil {
|
||
// 返回已存在的报表
|
||
var reportData map[string]interface{}
|
||
if err := gconv.Struct(existingReport.ReportData, &reportData); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: existingReport.Id,
|
||
ReportType: "daily",
|
||
ReportDate: reportDate.Format("2006-01-02"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
// 生成日报表数据
|
||
reportData, err := s.generateReportData(ctx, req.TenantID, req.AppID, "daily", reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 保存报表
|
||
report := &entity.StatReport{
|
||
TenantId: req.TenantID,
|
||
AppID: strconv.FormatInt(req.AppID, 10),
|
||
ReportType: "daily",
|
||
ReportDate: reportDate,
|
||
ReportData: gconv.String(reportData),
|
||
GeneratedAt: time.Now(),
|
||
Status: "completed",
|
||
}
|
||
|
||
err = dao.StatReport.Create(ctx, report)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: report.Id,
|
||
ReportType: "daily",
|
||
ReportDate: reportDate.Format("2006-01-02"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
// GenerateMonthlyReport 生成月报表（现在优先使用预生成的报表）
|
||
func (s *StatReportService) GenerateMonthlyReport(ctx context.Context, req *dto.ReportGenerateReq) (*dto.ReportGenerateResp, error) {
|
||
reportDate := time.Now()
|
||
if req.Date != "" {
|
||
parsedDate, err := time.Parse("2006-01", req.Date)
|
||
if err == nil {
|
||
reportDate = parsedDate
|
||
}
|
||
}
|
||
|
||
// 检查是否已存在报表
|
||
existingReport, err := dao.StatReport.GetByTenantAndDate(ctx, strconv.FormatInt(req.TenantID, 10), "monthly", reportDate.Format("2006-01"))
|
||
if err == nil && existingReport != nil {
|
||
var reportData map[string]interface{}
|
||
if err := gconv.Struct(existingReport.ReportData, &reportData); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: existingReport.Id,
|
||
ReportType: "monthly",
|
||
ReportDate: reportDate.Format("2006-01"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
reportData, err := s.generateReportData(ctx, req.TenantID, req.AppID, "monthly", reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
report := &entity.StatReport{
|
||
TenantId: req.TenantID,
|
||
AppID: strconv.FormatInt(req.AppID, 10),
|
||
ReportType: "monthly",
|
||
ReportDate: reportDate,
|
||
ReportData: gconv.String(reportData),
|
||
GeneratedAt: time.Now(),
|
||
Status: "completed",
|
||
}
|
||
|
||
err = dao.StatReport.Create(ctx, report)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: report.Id,
|
||
ReportType: "monthly",
|
||
ReportDate: reportDate.Format("2006-01"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
// GenerateWeeklyReport 生成周报表（新增周报表支持）
|
||
func (s *StatReportService) GenerateWeeklyReport(ctx context.Context, req *dto.ReportGenerateReq) (*dto.ReportGenerateResp, error) {
|
||
reportDate := time.Now()
|
||
if req.Date != "" {
|
||
// 周报表格式：2024-W01
|
||
parsedDate, err := time.Parse("2006-W01", req.Date)
|
||
if err == nil {
|
||
reportDate = parsedDate
|
||
}
|
||
}
|
||
|
||
// 检查是否已存在报表
|
||
existingReport, err := dao.StatReport.GetByTenantAndDate(ctx, strconv.FormatInt(req.TenantID, 10), "weekly", reportDate.Format("2006-W01"))
|
||
if err == nil && existingReport != nil {
|
||
var reportData map[string]interface{}
|
||
if err := gconv.Struct(existingReport.ReportData, &reportData); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: existingReport.Id,
|
||
ReportType: "weekly",
|
||
ReportDate: reportDate.Format("2006-W01"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
reportData, err := s.generateReportData(ctx, req.TenantID, req.AppID, "weekly", reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
report := &entity.StatReport{
|
||
TenantId: req.TenantID,
|
||
AppID: strconv.FormatInt(req.AppID, 10),
|
||
ReportType: "weekly",
|
||
ReportDate: reportDate,
|
||
ReportData: gconv.String(reportData),
|
||
GeneratedAt: time.Now(),
|
||
Status: "completed",
|
||
}
|
||
|
||
err = dao.StatReport.Create(ctx, report)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: report.Id,
|
||
ReportType: "weekly",
|
||
ReportDate: reportDate.Format("2006-W01"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
// 生成季度报表
|
||
func (s *StatReportService) GenerateQuarterlyReport(ctx context.Context, req *dto.ReportGenerateReq) (*dto.ReportGenerateResp, error) {
|
||
reportDate := time.Now()
|
||
if req.Date != "" {
|
||
parsedDate, err := time.Parse("2006-Q1", req.Date)
|
||
if err == nil {
|
||
reportDate = parsedDate
|
||
}
|
||
}
|
||
|
||
// 检查是否已存在报表
|
||
existingReport, err := dao.StatReport.GetByTenantAndDate(ctx, strconv.FormatInt(req.TenantID, 10), "quarterly", reportDate.Format("2006-Q1"))
|
||
if err == nil && existingReport != nil {
|
||
var reportData map[string]interface{}
|
||
if err := gconv.Struct(existingReport.ReportData, &reportData); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: existingReport.Id,
|
||
ReportType: "quarterly",
|
||
ReportDate: reportDate.Format("2006-Q1"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
reportData, err := s.generateReportData(ctx, req.TenantID, req.AppID, "quarterly", reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
report := &entity.StatReport{
|
||
TenantId: req.TenantID,
|
||
AppID: strconv.FormatInt(req.AppID, 10),
|
||
ReportType: "quarterly",
|
||
ReportDate: reportDate,
|
||
ReportData: gconv.String(reportData),
|
||
GeneratedAt: time.Now(),
|
||
Status: "completed",
|
||
}
|
||
|
||
err = dao.StatReport.Create(ctx, report)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: report.Id,
|
||
ReportType: "quarterly",
|
||
ReportDate: reportDate.Format("2006-Q1"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
// 生成年报表
|
||
func (s *StatReportService) GenerateYearlyReport(ctx context.Context, req *dto.ReportGenerateReq) (*dto.ReportGenerateResp, error) {
|
||
reportDate := time.Now()
|
||
if req.Date != "" {
|
||
parsedDate, err := time.Parse("2006", req.Date)
|
||
if err == nil {
|
||
reportDate = parsedDate
|
||
}
|
||
}
|
||
|
||
// 检查是否已存在报表
|
||
existingReport, err := dao.StatReport.GetByTenantAndDate(ctx, strconv.FormatInt(req.TenantID, 10), "yearly", reportDate.Format("2006"))
|
||
if err == nil && existingReport != nil {
|
||
var reportData map[string]interface{}
|
||
if err := gconv.Struct(existingReport.ReportData, &reportData); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: existingReport.Id,
|
||
ReportType: "yearly",
|
||
ReportDate: reportDate.Format("2006"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
reportData, err := s.generateReportData(ctx, req.TenantID, req.AppID, "yearly", reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
report := &entity.StatReport{
|
||
TenantId: req.TenantID,
|
||
AppID: strconv.FormatInt(req.AppID, 10),
|
||
ReportType: "yearly",
|
||
ReportDate: reportDate,
|
||
ReportData: gconv.String(reportData),
|
||
GeneratedAt: time.Now(),
|
||
Status: "completed",
|
||
}
|
||
|
||
err = dao.StatReport.Create(ctx, report)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return &dto.ReportGenerateResp{
|
||
ReportID: report.Id,
|
||
ReportType: "yearly",
|
||
ReportDate: reportDate.Format("2006"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|
||
|
||
// 生成报表数据
|
||
func (s *StatReportService) generateReportData(ctx context.Context, tenantID, appID int64, reportType string, reportDate time.Time) (map[string]interface{}, error) {
|
||
// 构建查询条件
|
||
where := g.Map{"tenant_id": tenantID}
|
||
if appID > 0 {
|
||
where["app_id"] = appID
|
||
}
|
||
|
||
// 根据报表类型确定时间范围
|
||
startTime, endTime := s.getReportTimeRange(reportType, reportDate)
|
||
where["created_at between ? and ?"] = g.Slice{startTime, endTime}
|
||
|
||
// 查询基础统计数据
|
||
// 这里简化实现，实际应该使用mongo查询ad_statistics集合
|
||
// 由于ad_statistics可能不存在或需要重构，这里返回模拟数据
|
||
stats := []map[string]interface{}{
|
||
{
|
||
"impressions": 1200,
|
||
"clicks": 60,
|
||
"revenue": 600.0,
|
||
"ad_type": "banner",
|
||
"region": "北京",
|
||
"platform": "web",
|
||
"play_duration": 30.5,
|
||
},
|
||
}
|
||
|
||
// 计算环比数据
|
||
yoyData, err := s.calculateYearOverYear(ctx, tenantID, appID, reportType, reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 计算同比数据
|
||
momData, err := s.calculateMonthOverMonth(ctx, tenantID, appID, reportType, reportDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 按广告类型分组统计
|
||
adTypeStats, err := s.groupByAdType(stats)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 按地区分组统计
|
||
regionStats := s.groupByRegion(stats)
|
||
|
||
// 按终端类型分组统计
|
||
platformStats := s.groupByPlatform(stats)
|
||
|
||
return map[string]interface{}{
|
||
"basic_stats": map[string]interface{}{
|
||
"total_impressions": s.sumField(stats, "impressions"),
|
||
"total_clicks": s.sumField(stats, "clicks"),
|
||
"total_revenue": s.sumField(stats, "revenue"),
|
||
"avg_ctr": s.calculateCTR(stats),
|
||
"avg_play_duration": s.avgField(stats, "play_duration"),
|
||
},
|
||
"ad_type_stats": adTypeStats,
|
||
"region_stats": regionStats,
|
||
"platform_stats": platformStats,
|
||
"year_over_year": yoyData,
|
||
"month_over_month": momData,
|
||
"time_range": map[string]string{
|
||
"start": startTime.Format("2006-01-02 15:04:05"),
|
||
"end": endTime.Format("2006-01-02 15:04:05"),
|
||
},
|
||
}, nil
|
||
}
|
||
|
||
// 获取报表时间范围
|
||
func (s *StatReportService) getReportTimeRange(reportType string, reportDate time.Time) (time.Time, time.Time) {
|
||
switch reportType {
|
||
case "daily":
|
||
start := time.Date(reportDate.Year(), reportDate.Month(), reportDate.Day(), 0, 0, 0, 0, time.Local)
|
||
end := start.AddDate(0, 0, 1).Add(-time.Second)
|
||
return start, end
|
||
case "monthly":
|
||
start := time.Date(reportDate.Year(), reportDate.Month(), 1, 0, 0, 0, 0, time.Local)
|
||
end := start.AddDate(0, 1, 0).Add(-time.Second)
|
||
return start, end
|
||
case "quarterly":
|
||
quarter := (reportDate.Month()-1)/3 + 1
|
||
startMonth := time.Month((quarter-1)*3 + 1)
|
||
start := time.Date(reportDate.Year(), startMonth, 1, 0, 0, 0, 0, time.Local)
|
||
end := start.AddDate(0, 3, 0).Add(-time.Second)
|
||
return start, end
|
||
case "yearly":
|
||
start := time.Date(reportDate.Year(), 1, 1, 0, 0, 0, 0, time.Local)
|
||
end := start.AddDate(1, 0, 0).Add(-time.Second)
|
||
return start, end
|
||
default:
|
||
return reportDate, reportDate
|
||
}
|
||
}
|
||
|
||
// 计算同比数据
|
||
func (s *StatReportService) calculateYearOverYear(ctx context.Context, tenantID, appID int64, reportType string, reportDate time.Time) (map[string]interface{}, error) {
|
||
lastYearDate := reportDate.AddDate(-1, 0, 0)
|
||
lastYearData, err := s.getComparisonData(ctx, tenantID, appID, reportType, lastYearDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"last_year": lastYearData,
|
||
"growth_rate": s.calculateGrowthRate(lastYearData, s.getCurrentPeriodData(ctx, tenantID, appID, reportType, reportDate)),
|
||
}, nil
|
||
}
|
||
|
||
// 计算环比数据
|
||
func (s *StatReportService) calculateMonthOverMonth(ctx context.Context, tenantID, appID int64, reportType string, reportDate time.Time) (map[string]interface{}, error) {
|
||
var lastPeriodDate time.Time
|
||
switch reportType {
|
||
case "daily":
|
||
lastPeriodDate = reportDate.AddDate(0, 0, -1)
|
||
case "monthly":
|
||
lastPeriodDate = reportDate.AddDate(0, -1, 0)
|
||
case "quarterly":
|
||
lastPeriodDate = reportDate.AddDate(0, -3, 0)
|
||
case "yearly":
|
||
lastPeriodDate = reportDate.AddDate(-1, 0, 0)
|
||
}
|
||
|
||
lastPeriodData, err := s.getComparisonData(ctx, tenantID, appID, reportType, lastPeriodDate)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
return map[string]interface{}{
|
||
"last_period": lastPeriodData,
|
||
"growth_rate": s.calculateGrowthRate(lastPeriodData, s.getCurrentPeriodData(ctx, tenantID, appID, reportType, reportDate)),
|
||
}, nil
|
||
}
|
||
|
||
// 获取对比数据
|
||
func (s *StatReportService) getComparisonData(ctx context.Context, tenantID, appID int64, reportType string, date time.Time) (map[string]float64, error) {
|
||
// 这里简化实现，实际应该查询数据库
|
||
return map[string]float64{
|
||
"impressions": 1000,
|
||
"clicks": 50,
|
||
"revenue": 500.0,
|
||
"ctr": 0.05,
|
||
}, nil
|
||
}
|
||
|
||
// 获取当前周期数据
|
||
func (s *StatReportService) getCurrentPeriodData(ctx context.Context, tenantID, appID int64, reportType string, date time.Time) map[string]float64 {
|
||
// 这里简化实现，实际应该查询数据库
|
||
return map[string]float64{
|
||
"impressions": 1200,
|
||
"clicks": 60,
|
||
"revenue": 600.0,
|
||
"ctr": 0.05,
|
||
}
|
||
}
|
||
|
||
// 计算增长率
|
||
func (s *StatReportService) calculateGrowthRate(lastData, currentData map[string]float64) map[string]float64 {
|
||
growthRate := make(map[string]float64)
|
||
for key, lastValue := range lastData {
|
||
currentValue := currentData[key]
|
||
if lastValue == 0 {
|
||
growthRate[key] = 0
|
||
} else {
|
||
growthRate[key] = (currentValue - lastValue) / lastValue * 100
|
||
}
|
||
}
|
||
return growthRate
|
||
}
|
||
|
||
// 按广告类型分组统计
|
||
func (s *StatReportService) groupByAdType(stats []map[string]interface{}) (map[string]interface{}, error) {
|
||
result := make(map[string]interface{})
|
||
for _, stat := range stats {
|
||
adType := gconv.String(stat["ad_type"])
|
||
if adType == "" {
|
||
adType = "unknown"
|
||
}
|
||
|
||
if _, exists := result[adType]; !exists {
|
||
result[adType] = map[string]float64{
|
||
"impressions": 0,
|
||
"clicks": 0,
|
||
"revenue": 0,
|
||
}
|
||
}
|
||
|
||
adTypeStat, ok := result[adType].(map[string]float64)
|
||
if !ok {
|
||
return nil, fmt.Errorf("invalid adTypeStat type")
|
||
}
|
||
adTypeStat["impressions"] += gconv.Float64(stat["impressions"])
|
||
adTypeStat["clicks"] += gconv.Float64(stat["clicks"])
|
||
adTypeStat["revenue"] += gconv.Float64(stat["revenue"])
|
||
}
|
||
|
||
// 计算每个广告类型的CTR
|
||
for adType, stat := range result {
|
||
adTypeStat, ok := stat.(map[string]float64)
|
||
if !ok {
|
||
return nil, fmt.Errorf("invalid adTypeStat type for adType: %s", adType)
|
||
}
|
||
if adTypeStat["impressions"] > 0 {
|
||
adTypeStat["ctr"] = adTypeStat["clicks"] / adTypeStat["impressions"] * 100
|
||
} else {
|
||
adTypeStat["ctr"] = 0
|
||
}
|
||
}
|
||
|
||
return result, nil
|
||
}
|
||
|
||
// 按地区分组统计
|
||
func (s *StatReportService) groupByRegion(stats []map[string]interface{}) map[string]interface{} {
|
||
result := make(map[string]interface{})
|
||
for _, stat := range stats {
|
||
region := gconv.String(stat["region"])
|
||
if region == "" {
|
||
region = "unknown"
|
||
}
|
||
|
||
if _, exists := result[region]; !exists {
|
||
result[region] = map[string]float64{
|
||
"impressions": 0,
|
||
"clicks": 0,
|
||
"revenue": 0,
|
||
}
|
||
}
|
||
|
||
regionStat := result[region].(map[string]float64)
|
||
regionStat["impressions"] += gconv.Float64(stat["impressions"])
|
||
regionStat["clicks"] += gconv.Float64(stat["clicks"])
|
||
regionStat["revenue"] += gconv.Float64(stat["revenue"])
|
||
}
|
||
return result
|
||
}
|
||
|
||
// 按终端类型分组统计
|
||
func (s *StatReportService) groupByPlatform(stats []map[string]interface{}) map[string]interface{} {
|
||
result := make(map[string]interface{})
|
||
for _, stat := range stats {
|
||
platform := gconv.String(stat["platform"])
|
||
if platform == "" {
|
||
platform = "unknown"
|
||
}
|
||
|
||
if _, exists := result[platform]; !exists {
|
||
result[platform] = map[string]float64{
|
||
"impressions": 0,
|
||
"clicks": 0,
|
||
"revenue": 0,
|
||
}
|
||
}
|
||
|
||
platformStat := result[platform].(map[string]float64)
|
||
platformStat["impressions"] += gconv.Float64(stat["impressions"])
|
||
platformStat["clicks"] += gconv.Float64(stat["clicks"])
|
||
platformStat["revenue"] += gconv.Float64(stat["revenue"])
|
||
}
|
||
return result
|
||
}
|
||
|
||
// 计算字段总和
|
||
func (s *StatReportService) sumField(stats []map[string]interface{}, field string) float64 {
|
||
total := 0.0
|
||
for _, stat := range stats {
|
||
total += gconv.Float64(stat[field])
|
||
}
|
||
return total
|
||
}
|
||
|
||
// 计算字段平均值
|
||
func (s *StatReportService) avgField(stats []map[string]interface{}, field string) float64 {
|
||
if len(stats) == 0 {
|
||
return 0
|
||
}
|
||
return s.sumField(stats, field) / float64(len(stats))
|
||
}
|
||
|
||
// 计算平均CTR
|
||
func (s *StatReportService) calculateCTR(stats []map[string]interface{}) float64 {
|
||
totalImpressions := s.sumField(stats, "impressions")
|
||
totalClicks := s.sumField(stats, "clicks")
|
||
if totalImpressions == 0 {
|
||
return 0
|
||
}
|
||
return totalClicks / totalImpressions * 100
|
||
}
|
||
|
||
// 查询报表列表
|
||
func (s *StatReportService) GetReportList(ctx context.Context, req *dto.ReportListReq) (*dto.ReportListResp, error) {
|
||
// 使用DAO的List方法
|
||
reports, count, err := dao.StatReport.List(ctx, strconv.FormatInt(req.TenantID, 10), strconv.FormatInt(req.AppID, 10), req.ReportType, req.StartDate, req.EndDate, req.Page, req.PageSize)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
// 转换为DTO
|
||
var reportDTOs []*dto.ReportDTO
|
||
for _, report := range reports {
|
||
appID, _ := strconv.ParseInt(report.AppID, 10, 64)
|
||
id, _ := strconv.ParseInt(report.Id, 10, 64)
|
||
|
||
reportDTOs = append(reportDTOs, &dto.ReportDTO{
|
||
ID: id,
|
||
TenantID: report.TenantId,
|
||
AppID: appID,
|
||
ReportType: report.ReportType,
|
||
ReportDate: report.ReportDate.Format("2006-01-02"),
|
||
GeneratedAt: report.GeneratedAt.Format("2006-01-02 15:04:05"),
|
||
})
|
||
}
|
||
|
||
return &dto.ReportListResp{
|
||
Reports: reportDTOs,
|
||
Total: count,
|
||
Page: req.Page,
|
||
PageSize: req.PageSize,
|
||
}, nil
|
||
}
|
||
|
||
// 获取报表详情
|
||
func (s *StatReportService) GetReportDetail(ctx context.Context, reportID int64) (*dto.ReportDetailResp, error) {
|
||
var report *entity.StatReport
|
||
report, err := dao.StatReport.GetByID(ctx, strconv.FormatInt(reportID, 10))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
if report == nil {
|
||
return nil, fmt.Errorf("报表不存在")
|
||
}
|
||
|
||
// 解析报表数据
|
||
var reportData map[string]interface{}
|
||
if err := gconv.Struct(report.ReportData, &reportData); err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
appID, _ := strconv.ParseInt(report.AppID, 10, 64)
|
||
id, _ := strconv.ParseInt(report.Id, 10, 64)
|
||
|
||
return &dto.ReportDetailResp{
|
||
ID: id,
|
||
TenantID: report.TenantId,
|
||
AppID: appID,
|
||
ReportType: report.ReportType,
|
||
ReportDate: report.ReportDate.Format("2006-01-02"),
|
||
GeneratedAt: report.GeneratedAt.Format("2006-01-02 15:04:05"),
|
||
Data: reportData,
|
||
}, nil
|
||
}
|