data-engine/controller/report/report_controller.go

package report

import (
	"context"

	reportSvc "dataengine/common/report"
	"dataengine/common/report/model"

	"gitea.redpowerfuture.com/red-future/common/beans"
	"github.com/gogf/gf/v2/frame/g"
)

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:"业务列表"`
}

type listBusinessesRes struct {
	List []model.BusinessConfig `json:"list"`
}

func (c *report) ListBusinesses(ctx context.Context, req *listBusinessesReq) (*listBusinessesRes, error) {
	ctx = ctxWithUser(ctx)
	list, err := svc().GetAllBusinesses(ctx)
	if err != nil {
		return nil, err
	}
	return &listBusinessesRes{List: list}, 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 {
		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 {
		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 {
		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"`
}

type listReportsRes struct {
	List []model.ReportConfig `json:"list"`
}

func (c *report) ListReports(ctx context.Context, req *listReportsReq) (*listReportsRes, error) {
	ctx = ctxWithUser(ctx)
	list, err := svc().GetAllReports(ctx, req.BusinessCode)
	if err != nil {
		return nil, err
	}
	return &listReportsRes{List: list}, 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 {
		return nil, err
	}
	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 {
		return nil, err
	}
	return &saveReportRes{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 {
		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"`
}

func (c *report) GetReportFields(ctx context.Context, req *getReportFieldsReq) (*model.GetReportFieldsResp, error) {
	ctx = ctxWithUser(ctx)
	return svc().GetReportFields(ctx, req.BusinessCode, req.ReportCode)
}

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 {
		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 {
		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 {
		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"`
}

type getExtractConfigsRes struct {
	List []model.ExtractConfig `json:"list"`
}

func (c *report) GetExtractConfigs(ctx context.Context, req *getExtractConfigsReq) (*getExtractConfigsRes, error) {
	ctx = ctxWithUser(ctx)
	list, err := svc().GetExtractConfigs(ctx, req.BusinessCode, req.ReportCode)
	if err != nil {
		return nil, err
	}
	return &getExtractConfigsRes{List: list}, 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 {
		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 {
		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 {
		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)
	return svc().ExtractDailyData(ctx, req.BusinessCode, req.ReportCode, req.StatDate, req.Executor)
}

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)
	return svc().AutoCreateStatTable(ctx, req.BusinessCode, req.ReportCode)
}

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)
	return svc().QueryReportByUserSelect(ctx, &req.UserSelectQueryReq)
}

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
}