480 lines
15 KiB
Go
480 lines
15 KiB
Go
package report
|
|
|
|
import (
|
|
"context"
|
|
"strconv"
|
|
"strings"
|
|
|
|
reportSvc "dataengine/common/report"
|
|
"dataengine/common/report/model"
|
|
|
|
"gitea.redpowerfuture.com/red-future/common/beans"
|
|
"github.com/gogf/gf/v2/frame/g"
|
|
"github.com/sirupsen/logrus"
|
|
)
|
|
|
|
type report struct{}
|
|
|
|
var ReportController = new(report)
|
|
|
|
func svc() *reportSvc.ReportService {
|
|
return reportSvc.GetService()
|
|
}
|
|
|
|
func ctxWithUser(ctx context.Context) context.Context {
|
|
return context.WithValue(ctx, "user", &beans.User{UserName: "admin", TenantId: 1})
|
|
}
|
|
|
|
// ============================================================
|
|
// 业务 CRUD
|
|
// ============================================================
|
|
|
|
type listBusinessesReq struct {
|
|
g.Meta `path:"/businesses" method:"get" tags:"报表引擎" summary:"业务列表"`
|
|
model.PageReq
|
|
}
|
|
|
|
type listBusinessesRes struct {
|
|
List []model.BusinessConfig `json:"list"`
|
|
model.PageRes
|
|
}
|
|
|
|
func (c *report) ListBusinesses(ctx context.Context, req *listBusinessesReq) (*listBusinessesRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
list, total, err := svc().ListBusinesses(ctx, req.PageNum, req.PageSize)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取业务列表失败: %v", err)
|
|
return nil, err
|
|
}
|
|
totalPages := (total + req.PageSize - 1) / req.PageSize
|
|
return &listBusinessesRes{List: list, PageRes: model.PageRes{Total: total, Page: req.PageNum, PageSize: req.PageSize, TotalPages: totalPages}}, nil
|
|
}
|
|
|
|
type getBusinessReq struct {
|
|
g.Meta `path:"/business" method:"get" tags:"报表引擎" summary:"获取业务"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type getBusinessRes struct {
|
|
Data *model.BusinessConfig `json:"data"`
|
|
}
|
|
|
|
func (c *report) GetBusiness(ctx context.Context, req *getBusinessReq) (*getBusinessRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
data, err := svc().GetBusiness(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取业务失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &getBusinessRes{Data: data}, nil
|
|
}
|
|
|
|
type saveBusinessReq struct {
|
|
g.Meta `path:"/business/save" method:"post" tags:"报表引擎" summary:"保存业务"`
|
|
model.SaveBusinessReq
|
|
}
|
|
|
|
type saveBusinessRes struct {
|
|
*model.SaveResult
|
|
}
|
|
|
|
func (c *report) SaveBusiness(ctx context.Context, req *saveBusinessReq) (*saveBusinessRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().SaveBusiness(ctx, &req.SaveBusinessReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 保存业务失败: %v", err)
|
|
return nil, err
|
|
}
|
|
return &saveBusinessRes{SaveResult: result}, nil
|
|
}
|
|
|
|
type deleteBusinessReq struct {
|
|
g.Meta `path:"/business" method:"delete" tags:"报表引擎" summary:"删除业务"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type deleteBusinessRes struct {
|
|
*model.DeleteResult
|
|
}
|
|
|
|
func (c *report) DeleteBusiness(ctx context.Context, req *deleteBusinessReq) (*deleteBusinessRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().DeleteBusiness(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 删除业务失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &deleteBusinessRes{DeleteResult: result}, nil
|
|
}
|
|
|
|
// ============================================================
|
|
// 报表 CRUD
|
|
// ============================================================
|
|
|
|
type listReportsReq struct {
|
|
g.Meta `path:"/reports" method:"get" tags:"报表引擎" summary:"报表列表"`
|
|
BusinessCode string `json:"businessCode" v:"required"`
|
|
ReportName string `json:"reportName" dc:"报表名称（模糊搜索）"`
|
|
model.PageReq
|
|
}
|
|
|
|
type listReportsRes struct {
|
|
List []model.ReportConfig `json:"list"`
|
|
model.PageRes
|
|
}
|
|
|
|
func (c *report) ListReports(ctx context.Context, req *listReportsReq) (*listReportsRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
list, total, err := svc().ListReports(ctx, req.BusinessCode, req.ReportName, req.PageNum, req.PageSize)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取报表列表失败 %s: %v", req.BusinessCode, err)
|
|
return nil, err
|
|
}
|
|
|
|
// 填充抽取配置ID（逗号分隔，不限 status）
|
|
for i := range list {
|
|
configs, err := svc().GetExtractConfigsAll(ctx, list[i].BusinessCode, list[i].ReportCode)
|
|
if err == nil {
|
|
ids := make([]string, 0, len(configs))
|
|
for _, ec := range configs {
|
|
ids = append(ids, strconv.FormatInt(ec.Id, 10))
|
|
}
|
|
list[i].ExtractConfigIDs = strings.Join(ids, ",")
|
|
}
|
|
}
|
|
|
|
totalPages := (total + req.PageSize - 1) / req.PageSize
|
|
return &listReportsRes{List: list, PageRes: model.PageRes{Total: total, Page: req.PageNum, PageSize: req.PageSize, TotalPages: totalPages}}, nil
|
|
}
|
|
|
|
type getReportReq struct {
|
|
g.Meta `path:"/report" method:"get" tags:"报表引擎" summary:"获取报表"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type getReportRes struct {
|
|
Data *model.ReportConfig `json:"data"`
|
|
}
|
|
|
|
func (c *report) GetReport(ctx context.Context, req *getReportReq) (*getReportRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
data, err := svc().GetReport(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取报表失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
|
|
// 填充抽取配置ID（逗号分隔，不限 status）
|
|
configs, err := svc().GetExtractConfigsAll(ctx, data.BusinessCode, data.ReportCode)
|
|
if err == nil {
|
|
ids := make([]string, 0, len(configs))
|
|
for _, ec := range configs {
|
|
ids = append(ids, strconv.FormatInt(ec.Id, 10))
|
|
}
|
|
data.ExtractConfigIDs = strings.Join(ids, ",")
|
|
}
|
|
|
|
return &getReportRes{Data: data}, nil
|
|
}
|
|
|
|
type saveReportReq struct {
|
|
g.Meta `path:"/report/save" method:"post" tags:"报表引擎" summary:"保存报表"`
|
|
model.SaveReportReq
|
|
}
|
|
|
|
type saveReportRes struct {
|
|
*model.SaveResult
|
|
}
|
|
|
|
func (c *report) SaveReport(ctx context.Context, req *saveReportReq) (*saveReportRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().SaveReport(ctx, &req.SaveReportReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 保存报表失败: %v", err)
|
|
return nil, err
|
|
}
|
|
return &saveReportRes{SaveResult: result}, nil
|
|
}
|
|
|
|
type saveReportWithFieldsReq struct {
|
|
g.Meta `path:"/report/saveWithFields" method:"post" tags:"报表引擎" summary:"保存报表及字段配置（全量替换）"`
|
|
model.SaveReportWithFieldsReq
|
|
}
|
|
|
|
type saveReportWithFieldsRes struct {
|
|
*model.SaveResult
|
|
}
|
|
|
|
func (c *report) SaveReportWithFields(ctx context.Context, req *saveReportWithFieldsReq) (*saveReportWithFieldsRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().SaveReportWithFields(ctx, &req.SaveReportWithFieldsReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 保存报表及字段失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
|
|
return nil, err
|
|
}
|
|
logrus.Infof("[报表引擎] 保存报表及字段成功 %s/%s id=%d", req.BusinessCode, req.ReportCode, result.ID)
|
|
return &saveReportWithFieldsRes{SaveResult: result}, nil
|
|
}
|
|
|
|
type deleteReportReq struct {
|
|
g.Meta `path:"/report" method:"delete" tags:"报表引擎" summary:"删除报表"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type deleteReportRes struct {
|
|
*model.DeleteResult
|
|
}
|
|
|
|
func (c *report) DeleteReport(ctx context.Context, req *deleteReportReq) (*deleteReportRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().DeleteReport(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 删除报表失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &deleteReportRes{DeleteResult: result}, nil
|
|
}
|
|
|
|
// ============================================================
|
|
// 字段 CRUD
|
|
// ============================================================
|
|
|
|
type getReportFieldsReq struct {
|
|
g.Meta `path:"/fields" method:"get" tags:"报表引擎" summary:"报表字段列表（按角色分组）"`
|
|
BusinessCode string `json:"businessCode" v:"required"`
|
|
ReportCode string `json:"reportCode" v:"required"`
|
|
model.PageReq
|
|
}
|
|
|
|
func (c *report) GetReportFields(ctx context.Context, req *getReportFieldsReq) (*model.GetReportFieldsResp, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
resp, err := svc().GetReportFields(ctx, req.BusinessCode, req.ReportCode)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取报表字段失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
|
|
return nil, err
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
type getFieldReq struct {
|
|
g.Meta `path:"/field" method:"get" tags:"报表引擎" summary:"获取字段"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type getFieldRes struct {
|
|
Data *model.FieldConfig `json:"data"`
|
|
}
|
|
|
|
func (c *report) GetField(ctx context.Context, req *getFieldReq) (*getFieldRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
data, err := svc().GetField(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取字段失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &getFieldRes{Data: data}, nil
|
|
}
|
|
|
|
type saveFieldReq struct {
|
|
g.Meta `path:"/field/save" method:"post" tags:"报表引擎" summary:"保存字段"`
|
|
model.SaveFieldReq
|
|
}
|
|
|
|
type saveFieldRes struct {
|
|
*model.SaveResult
|
|
}
|
|
|
|
func (c *report) SaveField(ctx context.Context, req *saveFieldReq) (*saveFieldRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().SaveField(ctx, &req.SaveFieldReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 保存字段失败: %v", err)
|
|
return nil, err
|
|
}
|
|
return &saveFieldRes{SaveResult: result}, nil
|
|
}
|
|
|
|
type deleteFieldReq struct {
|
|
g.Meta `path:"/field" method:"delete" tags:"报表引擎" summary:"删除字段"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type deleteFieldRes struct {
|
|
*model.DeleteResult
|
|
}
|
|
|
|
func (c *report) DeleteField(ctx context.Context, req *deleteFieldReq) (*deleteFieldRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().DeleteField(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 删除字段失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &deleteFieldRes{DeleteResult: result}, nil
|
|
}
|
|
|
|
// ============================================================
|
|
// 抽取配置 CRUD
|
|
// ============================================================
|
|
|
|
type getExtractConfigsReq struct {
|
|
g.Meta `path:"/extractConfigs" method:"get" tags:"报表引擎" summary:"抽取配置列表"`
|
|
BusinessCode string `json:"businessCode" v:"required"`
|
|
ReportCode string `json:"reportCode" v:"required"`
|
|
model.PageReq
|
|
}
|
|
|
|
type getExtractConfigsRes struct {
|
|
List []model.ExtractConfig `json:"list"`
|
|
model.PageRes
|
|
}
|
|
|
|
func (c *report) GetExtractConfigs(ctx context.Context, req *getExtractConfigsReq) (*getExtractConfigsRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
list, total, err := svc().ListExtractConfigs(ctx, req.BusinessCode, req.ReportCode, req.PageNum, req.PageSize)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取抽取配置列表失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
|
|
return nil, err
|
|
}
|
|
totalPages := (total + req.PageSize - 1) / req.PageSize
|
|
return &getExtractConfigsRes{List: list, PageRes: model.PageRes{Total: total, Page: req.PageNum, PageSize: req.PageSize, TotalPages: totalPages}}, nil
|
|
}
|
|
|
|
type getExtractConfigReq struct {
|
|
g.Meta `path:"/extractConfig" method:"get" tags:"报表引擎" summary:"获取抽取配置"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type getExtractConfigRes struct {
|
|
Data *model.ExtractConfig `json:"data"`
|
|
}
|
|
|
|
func (c *report) GetExtractConfig(ctx context.Context, req *getExtractConfigReq) (*getExtractConfigRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
data, err := svc().GetExtractConfig(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 获取抽取配置失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &getExtractConfigRes{Data: data}, nil
|
|
}
|
|
|
|
type saveExtractConfigReq struct {
|
|
g.Meta `path:"/extractConfig/save" method:"post" tags:"报表引擎" summary:"保存抽取配置"`
|
|
model.SaveExtractConfigReq
|
|
}
|
|
|
|
type saveExtractConfigRes struct {
|
|
*model.SaveResult
|
|
}
|
|
|
|
func (c *report) SaveExtractConfig(ctx context.Context, req *saveExtractConfigReq) (*saveExtractConfigRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().SaveExtractConfig(ctx, &req.SaveExtractConfigReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 保存抽取配置失败: %v", err)
|
|
return nil, err
|
|
}
|
|
return &saveExtractConfigRes{SaveResult: result}, nil
|
|
}
|
|
|
|
type deleteExtractConfigReq struct {
|
|
g.Meta `path:"/extractConfig" method:"delete" tags:"报表引擎" summary:"删除抽取配置"`
|
|
ID int64 `json:"id" v:"required"`
|
|
}
|
|
|
|
type deleteExtractConfigRes struct {
|
|
*model.DeleteResult
|
|
}
|
|
|
|
func (c *report) DeleteExtractConfig(ctx context.Context, req *deleteExtractConfigReq) (*deleteExtractConfigRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
result, err := svc().DeleteExtractConfig(ctx, req.ID)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 删除抽取配置失败 id=%d: %v", req.ID, err)
|
|
return nil, err
|
|
}
|
|
return &deleteExtractConfigRes{DeleteResult: result}, nil
|
|
}
|
|
|
|
// ============================================================
|
|
// 数据操作
|
|
// ============================================================
|
|
|
|
type extractDataReq struct {
|
|
g.Meta `path:"/extract" method:"post" tags:"报表引擎" summary:"执行按天数据抽取"`
|
|
model.ExtractDailyDataReq
|
|
}
|
|
|
|
func (c *report) ExtractData(ctx context.Context, req *extractDataReq) (*model.ExtractDailyDataResp, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
resp, err := svc().ExtractDailyData(ctx, req.BusinessCode, req.ReportCode, req.StatDate, req.Executor)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 按天抽取失败 %s/%s %s: %v", req.BusinessCode, req.ReportCode, req.StatDate, err)
|
|
return nil, err
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
type backfillReq struct {
|
|
g.Meta `path:"/backfill" method:"post" tags:"报表引擎" summary:"批量回填数据"`
|
|
model.BackfillReq
|
|
}
|
|
|
|
func (c *report) Backfill(ctx context.Context, req *backfillReq) (*model.BackfillResp, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
resp, err := svc().Backfill(ctx, &req.BackfillReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 批量回填失败 %s/%s %s~%s: %v", req.BusinessCode, req.ReportCode, req.StartDate, req.EndDate, err)
|
|
return nil, err
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
type autoCreateTableReq struct {
|
|
g.Meta `path:"/autoCreateTable" method:"post" tags:"报表引擎" summary:"自动创建统计宽表"`
|
|
model.AutoCreateStatTableReq
|
|
}
|
|
|
|
func (c *report) AutoCreateTable(ctx context.Context, req *autoCreateTableReq) (*model.AutoCreateStatTableResp, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
resp, err := svc().AutoCreateStatTable(ctx, req.BusinessCode, req.ReportCode)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 自动建表失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
|
|
return nil, err
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
type queryReportReq struct {
|
|
g.Meta `path:"/query" method:"post" tags:"报表引擎" summary:"用户选择查询"`
|
|
model.UserSelectQueryReq
|
|
}
|
|
|
|
func (c *report) QueryReport(ctx context.Context, req *queryReportReq) (*model.UserSelectQueryResp, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
resp, err := svc().QueryReportByUserSelect(ctx, &req.UserSelectQueryReq)
|
|
if err != nil {
|
|
logrus.Errorf("[报表引擎] 查询报表失败 %s/%s: %v", req.BusinessCode, req.ReportCode, err)
|
|
return nil, err
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
type initTablesReq struct {
|
|
g.Meta `path:"/initTables" method:"post" tags:"报表引擎" summary:"初始化系统表"`
|
|
}
|
|
|
|
type initTablesRes struct {
|
|
Success bool `json:"success"`
|
|
Message string `json:"message"`
|
|
}
|
|
|
|
func (c *report) InitTables(ctx context.Context, req *initTablesReq) (*initTablesRes, error) {
|
|
ctx = ctxWithUser(ctx)
|
|
if err := svc().InitSystemTables(ctx); err != nil {
|
|
return nil, err
|
|
}
|
|
return &initTablesRes{Success: true, Message: "系统表初始化完成"}, nil
|
|
}
|