herenshan112
/
appPlatform
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

tijiao

v2
herenshan112 4 months ago
parent
882921cf09
commit
5dfcbad029
14 changed files with 4510 additions and 17 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 319
      api/version1/customChartes/analyData.go
  2. 1791
      api/version1/customChartes/bar.go
  3. 267
      api/version1/customChartes/barRace.go
  4. 36
      api/version1/customChartes/chartType.go
  5. 120
      api/version1/customChartes/formTable.go
  6. 555
      api/version1/customChartes/pieChart.go
  7. 661
      api/version1/customChartes/radar.go
  8. 660
      api/version1/customChartes/target.go
  9. 73
      api/version1/customChartes/type.go
  10. 8
      api/version1/customerApp/appControll.go
  11. 4
      api/version1/entry.go
  12. 2
      go.mod
  13. 6
      overall/publicmethod/tableUnit.go
  14. 25
      overall/publicmethod/technique.go

319
api/version1/customChartes/analyData.go
View File

@ -0,0 +1,319 @@
package customChartes
import (
"appPlatform/api/version1/customerform"
"appPlatform/models/modelshr"
"appPlatform/models/modelssystempermission"
"appPlatform/overall"
"appPlatform/overall/publicmethod"
"strconv"
)
// 普通字段
func (c *ChartInfo) DataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string, untis []customerform.MasterStruct) (charData BarDataInfo) {
charData.XAxis.Types = "category"
charData.YAxis.Types = "value"
var timeList []string
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if yVal, isOk := mv[x.Field]; isOk {
pageTime := publicmethod.TypeToInterface(yVal)
if !publicmethod.IsInTrue[string](pageTime, timeList) {
timeList = append(timeList, pageTime)
}
}
}
}
charData.XAxisData(x.Field, timeList, untis)
// charData.XAxis.Data = timeList
for _, v := range y {
var seriesInfo SeriesList
seriesInfo.Name = v.OldTitle
seriesInfo.Types = chartType
if !publicmethod.IsInTrue[string](v.OldTitle, charData.Legend.Data) {
charData.Legend.Data = append(charData.Legend.Data, v.OldTitle)
}
}
charData.AggregateCalculating(x.Field, y, val, timeList, chartType)
return
}
// x轴是否要转换中文
func (b *BarDataInfo) XAxisData(xField string, timeList []string, untis []customerform.MasterStruct) {
for _, v := range untis {
if v.Name == xField {
switch v.Type {
case "pickrole":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_System_Permission.Model(&modelssystempermission.SystemRole{}).Select("`name`").Where("`id` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "pickpost":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_HR.Model(&modelshr.Position{}).Select("`name`").Where("`id` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "deptOrg":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_HR.Model(&modelshr.AdministrativeOrganization{}).Select("`name`").Where("`id` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "orgCentent":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_HR.Model(&modelshr.AdministrativeOrganization{}).Select("`name`").Where("`id` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "owner":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_HR.Model(&modelshr.PersonArchives{}).Select("`name`").Where("`key` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "founder":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_HR.Model(&modelshr.PersonArchives{}).Select("`name`").Where("`key` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "expand-user":
var roleName []string
if len(timeList) > 0 {
overall.CONSTANT_DB_HR.Model(&modelshr.PersonArchives{}).Select("`name`").Where("`key` IN ?", timeList).Find(&roleName)
}
b.XAxis.Data = roleName
case "checkbox":
if len(v.Options) > 0 {
var cbox []string
for _, tv := range timeList {
for _, ov := range v.Options {
if tv == ov.Value {
cbox = append(cbox, ov.Label)
}
}
}
b.XAxis.Data = cbox
} else {
b.XAxis.Data = timeList
}
case "radio":
if len(v.Options) > 0 {
var cbox []string
for _, tv := range timeList {
for _, ov := range v.Options {
if tv == ov.Value {
cbox = append(cbox, ov.Label)
}
}
}
b.XAxis.Data = cbox
} else {
b.XAxis.Data = timeList
}
default:
b.XAxis.Data = timeList
}
}
}
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-18 08:45:24
@ 功能: 聚合计算
# y Y轴设定
# val 查询到的值
#xField X轴字段
#chartType 图标类型
1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (b *BarDataInfo) AggregateCalculating(x string, y []YAxisInfo, val interface{}, timeList []string, chartType string) {
for _, v := range y {
var seriesInfo SeriesList
seriesInfo.Name = v.OldTitle
seriesInfo.Types = chartType
switch v.Method {
case 2:
seriesInfo.AverageValuees(x, v.Field, timeList, val, v.Format)
case 3:
seriesInfo.StatisticalQuantityes(x, v.Field, timeList, val, v.Format)
case 4:
seriesInfo.RemoveDuplicateCountss(x, v.Field, timeList, val, v.Format)
case 5:
seriesInfo.maxDataes(x, v.Field, timeList, val, v.Format)
case 6:
seriesInfo.minDataes(x, v.Field, timeList, val, v.Format)
default:
seriesInfo.sumDataes(x, v.Field, timeList, val, v.Format)
}
if !publicmethod.IsInTrue[string](v.OldTitle, b.Legend.Data) {
b.Legend.Data = append(b.Legend.Data, v.OldTitle)
}
b.Series = append(b.Series, seriesInfo)
}
}
// 求平均值
func (s *SeriesList) AverageValuees(xField, yField string, xAry []string, val interface{}, format int) {
for _, v := range xAry {
var sumVal float64
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
if v == publicmethod.TypeToInterface(xVal) {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
}
}
sumValAvg := sumVal / float64(len(yVal))
jieguo := publicmethod.DataChuli(sumValAvg, format)
s.Data = append(s.Data, jieguo)
}
}
}
// 计数
func (s *SeriesList) StatisticalQuantityes(xField, yField string, xAry []string, val interface{}, format int) {
for _, v := range xAry {
var sumVal []float64
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
if v == publicmethod.TypeToInterface(xVal) {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
}
}
}
// jieguo := publicmethod.DataChuli(sumVal, format)
s.Data = append(s.Data, len(sumVal))
}
}
// 去重计数
func (s *SeriesList) RemoveDuplicateCountss(xField, yField string, xAry []string, val interface{}, format int) {
for _, v := range xAry {
var sumVal []float64
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
if v == publicmethod.TypeToInterface(xVal) {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
}
}
}
// jieguo := publicmethod.DataChuli(sumVal, format)
s.Data = append(s.Data, len(sumVal))
}
}
// 求最大值
func (s *SeriesList) maxDataes(xField, yField string, xAry []string, val interface{}, format int) {
for _, v := range xAry {
var sumVal float64 = 0
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
if v == publicmethod.TypeToInterface(xVal) {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
s.Data = append(s.Data, jieguo)
}
}
// 求最小值
func (s *SeriesList) minDataes(xField, yField string, xAry []string, val interface{}, format int) {
for _, v := range xAry {
var sumVal float64 = 1
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
if v == publicmethod.TypeToInterface(xVal) {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
s.Data = append(s.Data, jieguo)
}
}
// 求和
/*
xField x轴字段
yField y轴字段
xAry x轴值
val 查询出来的所有值
format 取值方式
*/
func (s *SeriesList) sumDataes(xField, yField string, xAry []string, val interface{}, format int) {
for _, v := range xAry {
var sumVal float64
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
if v == publicmethod.TypeToInterface(xVal) {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
s.Data = append(s.Data, jieguo)
}
}

1791
api/version1/customChartes/bar.go
View File

File diff suppressed because it is too large

267
api/version1/customChartes/barRace.go
View File

@ -0,0 +1,267 @@
package customChartes
import (
"appPlatform/api/version1/customerform"
"appPlatform/overall/publicmethod"
"fmt"
"strconv"
)
/*
*
@ 作者: 秦东
@ 时间: 2025-07-22 16:16:33
@ 功能: 排行榜
*/
func (c *ChartInfo) barRaceChart(val interface{}, untis []customerform.MasterStruct, chartType string) (snedMap interface{}) {
for _, v := range c.XAxis {
fmt.Printf("\n\nc.X ===1==> %v =====> %v\n\n", v.Type, v)
switch v.Type {
case 3:
snedMap = c.TimeDataAnaly(v, c.YAxis, val, chartType)
default:
snedMap = c.BarRaceDataAnaly(v, c.YAxis, val, chartType, untis)
}
}
return
}
// 单一维度计算
func (c *ChartInfo) BarRaceDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string, untis []customerform.MasterStruct) (charData BarRace) {
fmt.Printf("人员--->%v\n\n", val)
var timeList []string //根据维度分组
if yVal, isOk := val.([]map[string]interface{}); isOk {
fmt.Printf("人员--1->%v\n\n", yVal)
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
fmt.Printf("人员--->%v\n\n", xVal)
pageTime := publicmethod.TypeToInterface(xVal)
if !publicmethod.IsInTrue[string](pageTime, timeList) {
timeList = append(timeList, pageTime)
}
}
}
}
var weiDu []PicChartInfo
for _, v := range timeList {
pickName := DimensionToChinaName(x.Field, v, untis)
charData.YAxisData = append(charData.YAxisData, pickName)
var weiduInfo PicChartInfo
weiduInfo.Name = v
weiduInfo.Value = pickName
weiDu = append(weiDu, weiduInfo)
}
charData.Max = len(weiDu)
charData.BarRaceAnalyRadarData(x.Field, weiDu, y, val)
return
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-22 11:22:34
@ 功能: 解析雷达数据
#xField x轴设定
w
# y Y轴设定
# val 查询到的值
#chartType 图标类型
1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (b *BarRace) BarRaceAnalyRadarData(xField string, x []PicChartInfo, y []YAxisInfo, val interface{}) {
for _, v := range y {
switch v.Method {
case 2:
b.AverageValuees(v, xField, x, val, v.Format)
case 3:
b.StatisticalQuantityes(v, xField, x, val, v.Format)
case 4:
b.RemoveDuplicateCountss(v, xField, x, val, v.Format)
case 5:
b.maxDataes(v, xField, x, val, v.Format)
case 6:
b.minDataes(v, xField, x, val, v.Format)
default:
b.sumDataes(v, xField, x, val, v.Format)
}
}
}
// 平均值
func (b *BarRace) AverageValuees(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
jibuqi := 1
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
jibuqi++
}
}
}
}
}
if jibuqi > 0 {
sumValAvg := sumVal / float64(jibuqi)
jieguo := publicmethod.DataChuli(sumValAvg, format)
serData.Value = append(serData.Value, jieguo)
} else {
serData.Value = append(serData.Value, 0)
}
}
}
b.SeriesData = append(b.SeriesData, serData)
}
// 计数
func (b *BarRace) StatisticalQuantityes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
}
}
// jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, len(sumVal))
}
}
b.SeriesData = append(b.SeriesData, serData)
}
// 去重计数
func (b *BarRace) RemoveDuplicateCountss(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
}
}
// jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, len(sumVal))
}
}
b.SeriesData = append(b.SeriesData, serData)
}
// 最大值
func (b *BarRace) maxDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64 = 0
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
}
}
b.SeriesData = append(b.SeriesData, serData)
}
// 最小值
func (b *BarRace) minDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64 = 0
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
}
}
b.SeriesData = append(b.SeriesData, serData)
}
// 求和
func (b *BarRace) sumDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
}
}
b.SeriesData = append(b.SeriesData, serData)
}

36
api/version1/customChartes/chartType.go
View File

@ -0,0 +1,36 @@
package customChartes
/**
@ 作者: 秦东
@ 时间: 2025-07-17 10:53:55
@ 功能: 住壮结构图
*/
type BarDataInfo struct {
XAxis xAxisStruct `json:"xAxis"`
YAxis YAxisStruct `json:"yAxis"`
Legend LegendStruct `json:"legend"`
Series []SeriesList `json:"series"`
}
//x轴设置
type xAxisStruct struct {
Types string `json:"type"`
Data []string `json:"data"`
}
//Y轴设置
type YAxisStruct struct {
Types string `json:"type"`
}
//数据标题
type LegendStruct struct {
Data []string `json:"data"`
}
//渲染图标结构
type SeriesList struct {
Name string `json:"name"`
Data []interface{} `json:"data"`
Types string `json:"type"`
}

120
api/version1/customChart/formTable.go → api/version1/customChartes/formTable.go
View File

@ -1,4 +1,4 @@
package customchart
package customChartes
import (
"appPlatform/api/version1/customerform"
@ -60,6 +60,7 @@ func (a *ApiMethod) DimMeaFormTable(c *gin.Context) {
if publicmethod.IsInTrue[string](v.Type, publicmethod.Dimension) {
var dimInfo ChartFieldInfo
dimInfo.Title = v.Item.Label
fmt.Printf("\n\n组件量化--->%v--->%v\n\n", v.Item.Label, v.Type)
if publicmethod.IsInTrue[string](v.Type, publicmethod.TimeUint) {
dimInfo.Type = 3
} else {
@ -137,13 +138,14 @@ func (a *ApiMethod) DimMeaFormTable(c *gin.Context) {
*/
func (a *ApiMethod) CountChartValue(c *gin.Context) {
var requestData SaveChartSetup
c.ShouldBindJSON(&requestData)
err := c.ShouldBindJSON(&requestData)
fmt.Printf("\n\n========>%v\n\n", err)
if requestData.TableKey == "" {
publicmethod.Result(1, requestData, c, "未知数据源表！")
return
}
var custForm modelAppPlatform.CustomerForm
err := custForm.GetCont(map[string]interface{}{"`tablename`": requestData.TableKey}, "chartView", "`signCode`")
err = custForm.GetCont(map[string]interface{}{"`tablename`": requestData.TableKey}, "chartView", "`signCode`")
if err != nil {
publicmethod.Result(1, requestData, c, "未知数据源表！不可添加!")
return
@ -153,6 +155,7 @@ func (a *ApiMethod) CountChartValue(c *gin.Context) {
publicmethod.Result(1, requestData, c, "图表数据不正确！不可写入!")
return
}
fmt.Printf("\n\n========>%v\n\n", requestData.ChartList)
saveData := publicmethod.MapOut[string]()
saveData["`chartView`"] = string(chartJson)
saveData["`edit_time`"] = time.Now().Unix()
@ -219,7 +222,7 @@ func (a *ApiMethod) AnalyzeChartData(c *gin.Context) {
return
}
var custForm modelAppPlatform.CustomerFormView
err = custForm.GetCont(map[string]interface{}{"`status`": 1, "`signCode`": requestData.TableKey}, "`tablekey`", "`mastesformjson`", "`chartView`")
err = custForm.GetCont(map[string]interface{}{"`status`": 1, "`tablekey`": requestData.TableKey}, "`tablekey`", "`mastesformjson`", "`chartView`")
if err != nil {
publicmethod.Result(1, requestData, c, "未知数据源表！2")
return
@ -238,21 +241,50 @@ func (a *ApiMethod) AnalyzeChartData(c *gin.Context) {
for _, v := range chartList {
if v.Uuid == requestData.ChartId {
isRun = false
sendChartDat = v.AnalyzeBarChart(custForm.TableKey, formJsonCont)
switch v.Type {
case "pie": //饼
sendChartDat = v.pieChart(sendChartDat, formJsonCont.List, "pie")
case "line": //折线
sendChartDat = v.zhuChart(sendChartDat, formJsonCont.List, "line")
case "target": //指标
sendChartDat = v.TargetChart(sendChartDat, formJsonCont.List, "target")
case "barRace": //排行榜
sendChartDat = v.barRaceChart(sendChartDat, formJsonCont.List, "pie")
case "radar": //雷达
sendChartDat = v.radarChart(sendChartDat, formJsonCont.List, "radar")
default: //默认返回柱状图
sendChartDat = v.AnalyzeBarChart(custForm.TableKey, formJsonCont)
sendChartDat = v.zhuChart(sendChartDat, formJsonCont.List, "bar")
}
}
}
if isRun {
publicmethod.Result(200, sendChartDat, c, "没有此表的数据！ ")
return
// for _, v := range requestData.SetConfig {
if requestData.SetConfig.Uuid == requestData.ChartId {
// isRun = false
sendChartDat = requestData.SetConfig.AnalyzeBarChart(custForm.TableKey, formJsonCont)
switch requestData.SetConfig.Type {
case "pie": //饼
sendChartDat = requestData.SetConfig.pieChart(sendChartDat, formJsonCont.List, "pie")
case "line": //折线
sendChartDat = requestData.SetConfig.zhuChart(sendChartDat, formJsonCont.List, "line")
case "target": //指标
sendChartDat = requestData.SetConfig.TargetChart(sendChartDat, formJsonCont.List, "target")
case "barRace": //排行榜
sendChartDat = requestData.SetConfig.barRaceChart(sendChartDat, formJsonCont.List, "pie")
case "radar": //雷达
sendChartDat = requestData.SetConfig.radarChart(sendChartDat, formJsonCont.List, "radar")
default: //默认返回柱状图
sendChartDat = requestData.SetConfig.zhuChart(sendChartDat, formJsonCont.List, "bar")
}
}
// }
// if requestData.ChartId == requestData.SetConfig.
// publicmethod.Result(200, sendChartDat, c, "没有此表的数据！ ")
// return
}
jdfk := publicmethod.GetDaysInMonth(2025, 7)
fmt.Printf("\n\njdfk:%T----2----->%v\n\n", jdfk, jdfk)
publicmethod.Result(0, sendChartDat, c)
}
@ -290,6 +322,9 @@ func (c *ChartInfo) AnalyzeBarChart(tableName string, formJsonCont customerform.
gormDb = v.MakeGormSql(gormDb)
}
}
//判断是否有搜索
gormDb = MakeSearchSql(c.Search, gormDb)
currTime := time.Now().Unix()
//时间约束
switch c.TimeLength {
@ -310,7 +345,76 @@ func (c *ChartInfo) AnalyzeBarChart(tableName string, formJsonCont customerform.
if err != nil && len(formList) < 1 {
return nil
}
return nil
// fmt.Printf("\n\n%v\n\n", formList)
return formList
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-11 09:46:48
@ 功能: 根据搜索条件组装查询条件
*/
func MakeSearchSql(searck interface{}, gormDb *gorm.DB) *gorm.DB {
if searchMap, isOk := searck.(map[string]interface{}); isOk {
if factor, isOk := searchMap["factor"]; isOk {
if factorMap, isOk := factor.([]interface{}); isOk {
for _, v := range factorMap {
if val, isOk := v.(map[string]interface{}); isOk {
if fieldVal, isOk := val["field"]; isOk {
if isTime, isOk := val["isTime"]; isOk {
fmt.Printf("\n\nV:%T----2----->%v\n\n", isTime, isTime)
if isTrue, isOk := isTime.(bool); isOk {
if isTrue {
var startTime int64
var endTime int64
if startTimeVal, isOk := val["startTime"]; isOk {
startTime, _ = publicmethod.StringToInt64(startTimeVal)
}
if endTimeVal, isOk := val["endTime"]; isOk {
endTime, _ = publicmethod.StringToInt64(endTimeVal)
}
if startTime > 0 && endTime > 0 {
sqlStr := fmt.Sprintf("%v BETWEEN %v AND %v", fieldVal, startTime, endTime)
gormDb = gormDb.Where(sqlStr)
} else if startTime > 0 && endTime <= 0 {
sqlStr := fmt.Sprintf("%v = %v", fieldVal, startTime)
gormDb = gormDb.Where(sqlStr)
} else if startTime <= 0 && endTime > 0 {
sqlStr := fmt.Sprintf("%v = %v", fieldVal, endTime)
gormDb = gormDb.Where(sqlStr)
}
} else {
if valInfo, isOk := val["value"]; isOk {
valStr := publicmethod.TypeToInterface(valInfo)
if valStr != "" {
if options, isOk := val["options"]; isOk {
fmt.Printf("\n\nV:%T----1----->%v\n\n", options, options)
if _, isOk := options.([]interface{}); isOk {
sqlStr := fmt.Sprintf("%v = %v", fieldVal, valInfo)
gormDb = gormDb.Where(sqlStr)
} else {
sqlStr := fmt.Sprintf("%v LIKE %v%v%v", fieldVal, "'%", valInfo, "%'")
gormDb = gormDb.Where(sqlStr)
}
} else {
sqlStr := fmt.Sprintf("%v LIKE %v%v%v", fieldVal, "'%", valInfo, "%'")
gormDb = gormDb.Where(sqlStr)
}
}
}
}
}
}
}
}
}
}
}
}
return gormDb
}
/*

555
api/version1/customChartes/pieChart.go
View File

@ -0,0 +1,555 @@
package customChartes
import (
"appPlatform/api/version1/customerform"
"appPlatform/models/modelshr"
"appPlatform/models/modelssystempermission"
"appPlatform/overall"
"appPlatform/overall/publicmethod"
"fmt"
"strconv"
"time"
)
/*
*
@ 作者: 秦东
@ 时间: 2025-07-21 09:50:02
@ 功能: 饼图
*/
func (c *ChartInfo) pieChart(val interface{}, untis []customerform.MasterStruct, chartType string) (snedMap interface{}) {
for _, v := range c.XAxis {
// fmt.Printf("\n\nc.X ===1==> %v =====> %v\n\n", v.Type, v)
switch v.Type {
case 3:
snedMap = c.PieTimeDataAnaly(v, c.YAxis, val, chartType)
default:
snedMap = c.PieDataAnaly(v, c.YAxis, val, chartType, untis)
}
}
return
}
func (c *ChartInfo) PieTimeDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string) (charData SendPicInfo) {
tayTime := time.Now().Unix()
switch x.TimeType {
case "year":
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", yearVal))
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", yearVal))
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
pickName := fmt.Sprintf("%v年", yearVal)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
case "month":
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
yearValInt, _ := strconv.Atoi(yearVal)
var timeList []string
tayTime := int(time.Now().Month())
for i := 1; i <= tayTime; i++ {
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
}
startTime := publicmethod.DateToTimeStampOld(createTime)
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime.AllTime = endTime.AllTime * 1000
}
if startTime <= pageTime && pageTime <= endTime.AllTime {
newVal = append(newVal, mv)
}
}
}
}
pickName := fmt.Sprintf("%v年%v月", yearVal, i)
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
case "day":
yearVal := int(time.Now().Year())
tayTime := int(time.Now().Month())
dayTime := int(time.Now().Day())
var timeList []string
for i := 1; i <= tayTime; i++ {
for j := 1; j <= dayTime; j++ {
pickName := fmt.Sprintf("%v年%v月%v日", yearVal, i, j)
createTime := fmt.Sprintf("%v-%v-%v 00:00:00", yearVal, i, j)
if i < 10 {
if j < 10 {
createTime = fmt.Sprintf("%v-0%v-0%v 00:00:00", yearVal, i, j)
} else {
createTime = fmt.Sprintf("%v-0%v-%v 00:00:00", yearVal, i, j)
}
} else {
if j < 10 {
createTime = fmt.Sprintf("%v-%v-0%v 00:00:00", yearVal, i, j)
} else {
createTime = fmt.Sprintf("%v-%v-%v 00:00:00", yearVal, i, j)
}
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
}
case "hour":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 14)
var timeList []string
for i := 0; i <= 23; i++ {
createTime := fmt.Sprintf("%v %v:00:00", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v:00:00", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
pickName := fmt.Sprintf("%v %v", ymdhVal, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
case "minute":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 13)
var timeList []string
for i := 0; i <= 60; i++ {
createTime := fmt.Sprintf("%v %v:00", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v:00", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
pickName := fmt.Sprintf("%v :%v", ymdhVal, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
case "second":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 12)
var timeList []string
for i := 0; i <= 60; i++ {
createTime := fmt.Sprintf("%v %v", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
pickName := fmt.Sprintf("%v :%v", ymdhVal, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
case "ymdhms":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 12)
var timeList []string
for i := 0; i <= 60; i++ {
createTime := fmt.Sprintf("%v %v", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
pickName := fmt.Sprintf("%v :%v", ymdhVal, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
default:
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
yearValInt, _ := strconv.Atoi(yearVal)
var timeList []string
tayTime := int(time.Now().Month())
for i := 1; i <= tayTime; i++ {
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
}
startTime := publicmethod.DateToTimeStampOld(createTime)
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime.AllTime = endTime.AllTime * 1000
}
if startTime <= pageTime && pageTime <= endTime.AllTime {
newVal = append(newVal, mv)
}
}
}
}
pickName := fmt.Sprintf("%v年%v月", yearVal, i)
timeList = append(timeList, pickName)
charData.picMasterDataAnaly(x.Field, x.Field, pickName, newVal)
charData.AggregateCalculatingPic(pickName, newVal, y)
}
}
return
}
func (c *ChartInfo) PieDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string, untis []customerform.MasterStruct) (charData SendPicInfo) {
var timeList []string //根据维度分组
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
// fmt.Printf("人员--->%v\n\n", xVal)
pageTime := publicmethod.TypeToInterface(xVal)
if !publicmethod.IsInTrue[string](pageTime, timeList) {
timeList = append(timeList, pageTime)
}
}
}
}
// fmt.Printf("人员--2->%v\n\n", timeList)
for _, v := range timeList {
pickName := DimensionToChinaName(x.Field, v, untis)
charData.picMasterDataAnaly(x.Field, v, pickName, val)
charData.AggregateCalculatingPic(pickName, val, y)
// fmt.Printf("人员--pickName->%v\n\n", pickName)
}
return
}
// 处理主数据
func (s *SendPicInfo) picMasterDataAnaly(xField, keyName string, fathreName, val interface{}) {
// fmt.Printf("处理主数据----->%v-----------%v\n\n\n", keyName, fathreName)
if yVal, isOk := val.([]map[string]interface{}); isOk {
jsq := 0
var masterInfo PicChartInfo
masterInfo.Name = publicmethod.TypeToInterface(fathreName)
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == keyName {
jsq++
}
}
}
masterInfo.Value = jsq
s.MasterData = append(s.MasterData, masterInfo)
}
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-18 08:45:24
@ 功能:饼形 聚合计算
#fathreName
# y Y轴设定
# val 查询到的值
#chartType 图标类型
1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (s *SendPicInfo) AggregateCalculatingPic(fathreName, val interface{}, y []YAxisInfo) {
for _, v := range y {
var pickInfo OtherDataInfo
pickInfo.FathreName = publicmethod.TypeToInterface(fathreName)
pickInfo.ToolName = v.OldTitle
switch v.Method {
case 2:
pickInfo.AverageValuees(v.Field, val, v.Format)
case 3:
pickInfo.StatisticalQuantityes(v.Field, val, v.Format)
case 4:
pickInfo.RemoveDuplicateCountss(v.Field, val, v.Format)
case 5:
pickInfo.maxDataes(v.Field, val, v.Format)
case 6:
pickInfo.minDataes(v.Field, val, v.Format)
default:
pickInfo.sumDataes(v.Field, val, v.Format)
}
s.OtherData = append(s.OtherData, pickInfo)
}
}
// 平均值
func (o *OtherDataInfo) AverageValuees(yField string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
jibuqi := 1
for _, mv := range yVal {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = sumVal + minVal
jibuqi++
}
}
}
if jibuqi > 0 {
sumValAvg := sumVal / float64(jibuqi)
jieguo := publicmethod.DataChuli(sumValAvg, format)
o.Toolval = jieguo
} else {
o.Toolval = 0
}
}
}
// 去重计数
func (o *OtherDataInfo) StatisticalQuantityes(yField string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
for _, mv := range yVal {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
// jieguo := publicmethod.DataChuli(sumVal, format)
o.Toolval = len(sumVal)
}
}
// 去重计数
func (o *OtherDataInfo) RemoveDuplicateCountss(yField string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
for _, mv := range yVal {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
// jieguo := publicmethod.DataChuli(sumVal, format)
o.Toolval = len(sumVal)
}
}
// 求最大值
func (o *OtherDataInfo) maxDataes(yField string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64 = 1
for _, mv := range yVal {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
o.Toolval = jieguo
}
}
// 求最小值
func (o *OtherDataInfo) minDataes(yField string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64 = 1
for _, mv := range yVal {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
o.Toolval = jieguo
}
}
// 求和
func (o *OtherDataInfo) sumDataes(yField string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
for _, mv := range yVal {
if vVal, isOk := mv[yField]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
o.Toolval = jieguo
}
}
// 判断维度是否要换成中文
func DimensionToChinaName(xField string, timeList string, untis []customerform.MasterStruct) (names interface{}) {
for _, v := range untis {
if v.Name == xField {
// fmt.Printf("姓名转换---->%v\n\n", v.Type)
switch v.Type {
case "pickrole":
var nameVal string
overall.CONSTANT_DB_System_Permission.Model(&modelssystempermission.SystemRole{}).Select("`name`").Where("`id` = ?", timeList).First(&nameVal)
names = nameVal
case "pickpost":
var nameVal string
overall.CONSTANT_DB_HR.Model(&modelshr.Position{}).Select("`name`").Where("`id` = ?", timeList).First(&nameVal)
names = nameVal
case "deptOrg":
var nameVal string
overall.CONSTANT_DB_HR.Model(&modelshr.AdministrativeOrganization{}).Select("`name`").Where("`id` = ?", timeList).First(&nameVal)
names = nameVal
case "orgCentent":
var nameVal string
overall.CONSTANT_DB_HR.Model(&modelshr.AdministrativeOrganization{}).Select("`name`").Where("`id` = ?", timeList).First(&nameVal)
names = nameVal
case "owner":
var nameVal string
overall.CONSTANT_DB_HR.Model(&modelshr.PersonArchives{}).Select("`name`").Where("`key` = ?", timeList).First(&nameVal)
names = nameVal
case "founder":
var nameVal string
overall.CONSTANT_DB_HR.Model(&modelshr.PersonArchives{}).Select("`name`").Where("`key` = ?", timeList).First(&nameVal)
names = nameVal
case "expand-user":
var nameVal string
overall.CONSTANT_DB_HR.Model(&modelshr.PersonArchives{}).Select("`name`").Where("`key` = ?", timeList).First(&nameVal)
names = nameVal
case "checkbox":
if len(v.Options) > 0 {
for _, ov := range v.Options {
if timeList == ov.Value {
names = ov.Label
}
}
} else {
names = timeList
}
case "radio":
if len(v.Options) > 0 {
for _, ov := range v.Options {
if timeList == ov.Value {
names = ov.Label
}
}
} else {
names = timeList
}
default:
names = timeList
}
}
}
return
}

661
api/version1/customChartes/radar.go
View File

@ -0,0 +1,661 @@
package customChartes
import (
"appPlatform/api/version1/customerform"
"appPlatform/overall/publicmethod"
"fmt"
"strconv"
"time"
)
/*
*
@ 作者: 秦东
@ 时间: 2025-07-21 09:50:02
@ 功能: 雷达图
*/
func (c *ChartInfo) radarChart(val interface{}, untis []customerform.MasterStruct, chartType string) (snedMap interface{}) {
for _, v := range c.XAxis {
fmt.Printf("\n\nc.X ===1==> %v =====> %v\n\n", v.Type, v)
switch v.Type {
case 3:
snedMap = c.RadarTimeDataAnaly(v, c.YAxis, val, chartType)
default:
snedMap = c.RadarDataAnaly(v, c.YAxis, val, chartType, untis)
}
}
return
}
func (c *ChartInfo) RadarTimeDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string) (charData RadarInfo) {
tayTime := time.Now().Unix()
switch x.TimeType {
case "year":
case "day":
case "hour":
case "minute":
case "second":
case "ymdhms":
default:
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
yearValInt, _ := strconv.Atoi(yearVal)
tayTime := int(time.Now().Month())
var jiSuanVal []RadarTimeInfo
for i := 1; i <= tayTime; i++ {
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
}
startTime := publicmethod.DateToTimeStampOld(createTime)
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime.AllTime = endTime.AllTime * 1000
}
if startTime <= pageTime && pageTime <= endTime.AllTime {
newVal = append(newVal, mv)
}
}
}
}
var timeData RadarTimeInfo
timeData.XName = fmt.Sprintf("%v年%v月", yearVal, i)
timeData.DataVal = newVal
jiSuanVal = append(jiSuanVal, timeData)
}
charData.ParsingData(jiSuanVal, y)
}
return
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-23 11:33:29
@ 功能: 解析时间模式下的数据
*/
func (r *RadarInfo) ParsingData(timeVal []RadarTimeInfo, y []YAxisInfo) {
for _, v := range y { //量化指标
if !publicmethod.IsInTrue[string](v.OldTitle, r.Legend) {
r.Legend = append(r.Legend, v.OldTitle)
}
switch v.Method {
case 2:
r.AverageValueesTime(v, timeVal, v.Format)
case 3:
r.StatisticalQuantityesTime(v, timeVal, v.Format)
case 4:
r.RemoveDuplicateCountssTime(v, timeVal, v.Format)
case 5:
r.maxDataesTime(v, timeVal, v.Format)
case 6:
r.minDataesTime(v, timeVal, v.Format)
default:
r.sumDataesTime(v, timeVal, v.Format)
}
}
}
// 平均值
func (r *RadarInfo) AverageValueesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range timeVal {
var sumVal float64
jibuqi := 1
for _, tv := range v.DataVal {
if vVal, isOk := tv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = sumVal + minVal
jibuqi++
}
}
}
var jieguo interface{}
if sumVal > 0 {
sumValAvg := sumVal / float64(jibuqi)
jieguo := publicmethod.DataChuli(sumValAvg, format)
serData.Value = append(serData.Value, jieguo)
} else {
serData.Value = append(serData.Value, 0)
}
isWrite := true
for ri, rv := range r.Indicator {
if rv.Name == v.XName {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
if err == nil {
isWrite = false
if minVal <= sumVal {
r.Indicator[ri].Max = sumVal
}
}
}
}
if isWrite {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(v.XName)
newIndic.Max = jieguo
r.Indicator = append(r.Indicator, newIndic)
}
}
r.DataList = append(r.DataList, serData)
}
// 计数
func (r *RadarInfo) StatisticalQuantityesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range timeVal {
var sumVal []float64
for _, tv := range v.DataVal {
if vVal, isOk := tv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
jieguo := float64(len(sumVal))
serData.Value = append(serData.Value, jieguo)
isWrite := true
for ri, rv := range r.Indicator {
if rv.Name == v.XName {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
if err == nil {
isWrite = false
if minVal <= jieguo {
r.Indicator[ri].Max = sumVal
}
}
}
}
if isWrite {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(v.XName)
newIndic.Max = jieguo
r.Indicator = append(r.Indicator, newIndic)
}
}
r.DataList = append(r.DataList, serData)
}
// 去重计数
func (r *RadarInfo) RemoveDuplicateCountssTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range timeVal {
var sumVal []float64
for _, tv := range v.DataVal {
if vVal, isOk := tv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
jieguo := float64(len(sumVal))
serData.Value = append(serData.Value, jieguo)
isWrite := true
for ri, rv := range r.Indicator {
if rv.Name == v.XName {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
if err == nil {
isWrite = false
if minVal <= jieguo {
r.Indicator[ri].Max = sumVal
}
}
}
}
if isWrite {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(v.XName)
newIndic.Max = jieguo
r.Indicator = append(r.Indicator, newIndic)
}
}
r.DataList = append(r.DataList, serData)
}
// 最大值
func (r *RadarInfo) maxDataesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range timeVal {
var sumVal float64
for _, tv := range v.DataVal {
if vVal, isOk := tv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
isWrite := true
for ri, rv := range r.Indicator {
if rv.Name == v.XName {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
if err == nil {
isWrite = false
if minVal <= sumVal {
r.Indicator[ri].Max = sumVal
}
}
}
}
if isWrite {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(v.XName)
newIndic.Max = jieguo
r.Indicator = append(r.Indicator, newIndic)
}
}
r.DataList = append(r.DataList, serData)
}
// 最小值
func (r *RadarInfo) minDataesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range timeVal {
var sumVal float64
for _, tv := range v.DataVal {
if vVal, isOk := tv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
isWrite := true
for ri, rv := range r.Indicator {
if rv.Name == v.XName {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
if err == nil {
isWrite = false
if minVal <= sumVal {
r.Indicator[ri].Max = sumVal
}
}
}
}
if isWrite {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(v.XName)
newIndic.Max = jieguo
r.Indicator = append(r.Indicator, newIndic)
}
}
r.DataList = append(r.DataList, serData)
}
// 求和
func (r *RadarInfo) sumDataesTime(y YAxisInfo, timeVal []RadarTimeInfo, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range timeVal {
var sumVal float64
for _, tv := range v.DataVal {
if vVal, isOk := tv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(vVal), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
isWrite := true
for ri, rv := range r.Indicator {
if rv.Name == v.XName {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(rv.Max), 64)
if err == nil {
isWrite = false
if minVal <= sumVal {
r.Indicator[ri].Max = sumVal
}
}
}
}
if isWrite {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(v.XName)
newIndic.Max = jieguo
r.Indicator = append(r.Indicator, newIndic)
}
}
r.DataList = append(r.DataList, serData)
}
// 普通字段
func (c *ChartInfo) RadarDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string, untis []customerform.MasterStruct) (charData RadarInfo) {
var timeList []string //根据维度分组
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
// fmt.Printf("人员--->%v\n\n", xVal)
pageTime := publicmethod.TypeToInterface(xVal)
if !publicmethod.IsInTrue[string](pageTime, timeList) {
timeList = append(timeList, pageTime)
}
}
}
}
//纬度信息
var weiDu []PicChartInfo
for _, v := range timeList {
pickName := DimensionToChinaName(x.Field, v, untis)
// charData.AnalyRadarData(x.Field, v, y, pickName, val)
var weiduInfo PicChartInfo
weiduInfo.Name = v
weiduInfo.Value = pickName
weiDu = append(weiDu, weiduInfo)
}
charData.AnalyRadarData(x.Field, weiDu, y, val)
return
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-22 11:22:34
@ 功能: 解析雷达数据
#xField x轴设定
w
# y Y轴设定
# val 查询到的值
#chartType 图标类型
1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (b *RadarInfo) AnalyRadarData(xField string, x []PicChartInfo, y []YAxisInfo, val interface{}) {
for _, v := range y {
b.Legend = append(b.Legend, v.OldTitle)
switch v.Method {
case 2:
b.AverageValuees(v, xField, x, val, v.Format)
case 3:
b.StatisticalQuantityes(v, xField, x, val, v.Format)
case 4:
b.RemoveDuplicateCountss(v, xField, x, val, v.Format)
case 5:
b.maxDataes(v, xField, x, val, v.Format)
case 6:
b.minDataes(v, xField, x, val, v.Format)
default:
b.sumDataes(v, xField, x, val, v.Format)
}
}
}
// 平均值
func (b *RadarInfo) AverageValuees(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
jibuqi := 1
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
jibuqi++
}
}
}
}
}
if jibuqi > 0 {
sumValAvg := sumVal / float64(jibuqi)
jieguo := publicmethod.DataChuli(sumValAvg, format)
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
} else {
jieguo := 0
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
}
} else {
b.WeiDuMaxVal(v.Value, 0)
}
}
b.DataList = append(b.DataList, serData)
}
// 计数
func (b *RadarInfo) StatisticalQuantityes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
}
}
jieguo := len(sumVal)
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
} else {
b.WeiDuMaxVal(v.Value, 0)
}
}
b.DataList = append(b.DataList, serData)
}
// 去重计数
func (b *RadarInfo) RemoveDuplicateCountss(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
}
}
jieguo := len(sumVal)
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
} else {
b.WeiDuMaxVal(v.Value, 0)
}
}
b.DataList = append(b.DataList, serData)
}
// 最大值
func (b *RadarInfo) maxDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64 = 0
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
} else {
b.WeiDuMaxVal(v.Value, 0)
}
}
b.DataList = append(b.DataList, serData)
}
// 最小值
func (b *RadarInfo) minDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64 = 0
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
} else {
b.WeiDuMaxVal(v.Value, 0)
}
}
b.DataList = append(b.DataList, serData)
}
// 求和
func (b *RadarInfo) sumDataes(y YAxisInfo, xField string, x []PicChartInfo, val interface{}, format int) {
var serData DataInfo
serData.Name = y.OldTitle
for _, v := range x {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == v.Name {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
}
}
jieguo := publicmethod.DataChuli(sumVal, format)
serData.Value = append(serData.Value, jieguo)
b.WeiDuMaxVal(v.Value, jieguo)
} else {
b.WeiDuMaxVal(v.Value, 0)
}
}
// if yVal, isOk := val.([]map[string]interface{}); isOk {
// for _, xv := range yVal {
// var sumVal float64
// for _, v := range x {
// if vVal, isOk := xv[xField]; isOk {
// if v.Name == publicmethod.TypeToInterface(vVal) {
// if yVal, isOk := xv[y.Field]; isOk {
// minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yVal), 64)
// if err == nil {
// sumVal = sumVal + minVal
// }
// }
// }
// }
// }
// serData.Value = append(serData.Value, sumVal)
// }
// } else {
// for i := 0; i < len(x); i++ {
// serData.Value = append(serData.Value, 0)
// }
// }
b.DataList = append(b.DataList, serData)
}
// 组装纬度最大值
func (b *RadarInfo) WeiDuMaxVal(name, val interface{}) {
isNew := true
for i, v := range b.Indicator {
if v.Name == name {
isNew = false
valFloat, _ := strconv.ParseFloat(publicmethod.TypeToInterface(val), 64)
indFloat, _ := strconv.ParseFloat(publicmethod.TypeToInterface(v.Max), 64)
if valFloat >= indFloat {
b.Indicator[i].Max = valFloat + 10
}
}
}
if isNew {
var newIndic IndicatorInfo
newIndic.Name = publicmethod.TypeToInterface(name)
newIndic.Max = val
b.Indicator = append(b.Indicator, newIndic)
}
}

660
api/version1/customChartes/target.go
View File

@ -0,0 +1,660 @@
package customChartes
import (
"appPlatform/api/version1/customerform"
"appPlatform/overall/publicmethod"
"fmt"
"strconv"
"time"
)
/*
*
@ 作者: 秦东
@ 时间: 2025-07-23 09:39:25
@ 功能: 指标数据处理
*/
func (c *ChartInfo) TargetChart(val interface{}, untis []customerform.MasterStruct, chartType string) (snedMap interface{}) {
for _, v := range c.XAxis {
// fmt.Printf("\n\nc.X ===1==> %v =====> %v\n\n", v.Type, v)
switch v.Type {
case 3:
snedMap = c.TargetTimeDataAnaly(v, c.YAxis, val, chartType)
default:
snedMap = c.TargetDataAnaly(v, c.YAxis, val, chartType, untis)
}
}
return
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-23 10:19:15
@ 功能: 指标时间维度计算
*/
func (c *ChartInfo) TargetTimeDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string) (charData []TargetInfo) {
tayTime := time.Now().Unix()
switch x.TimeType {
case "year":
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
startTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-01-01 00:00:00", yearVal))
endTime := publicmethod.DateToTimeStampOld(fmt.Sprintf("%v-12-31 23:59:59", yearVal))
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
var charInfo TargetInfo
charInfo.Title = fmt.Sprintf("%v年", yearVal)
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
case "day":
yearVal := int(time.Now().Year())
tayTime := int(time.Now().Month())
dayTime := int(time.Now().Day())
for i := 1; i <= tayTime; i++ {
for j := 1; j <= dayTime; j++ {
var charInfo TargetInfo
charInfo.Title = fmt.Sprintf("%v年%v月%v日", yearVal, i, j)
createTime := fmt.Sprintf("%v-%v-%v 00:00:00", yearVal, i, j)
if i < 10 {
if j < 10 {
createTime = fmt.Sprintf("%v-0%v-0%v 00:00:00", yearVal, i, j)
} else {
createTime = fmt.Sprintf("%v-0%v-%v 00:00:00", yearVal, i, j)
}
} else {
if j < 10 {
createTime = fmt.Sprintf("%v-%v-0%v 00:00:00", yearVal, i, j)
} else {
createTime = fmt.Sprintf("%v-%v-%v 00:00:00", yearVal, i, j)
}
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
}
}
case "hour":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 14)
for i := 0; i <= 23; i++ {
createTime := fmt.Sprintf("%v %v:00:00", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v:00:00", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
var charInfo TargetInfo
charInfo.Title = fmt.Sprintf("%v %v", ymdhVal, i)
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
}
case "minute":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 13)
for i := 0; i <= 60; i++ {
createTime := fmt.Sprintf("%v %v:00", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v:00", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
var charInfo TargetInfo
charInfo.Title = fmt.Sprintf("%v :%v", ymdhVal, i)
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
}
case "second":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 12)
for i := 0; i <= 60; i++ {
createTime := fmt.Sprintf("%v %v", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
var charInfo TargetInfo
charInfo.Title = fmt.Sprintf("%v :%v", ymdhVal, i)
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
}
case "ymdhms":
tayTime := time.Now().Unix()
ymdhVal := publicmethod.UnixTimeToDay(tayTime, 12)
for i := 0; i <= 60; i++ {
createTime := fmt.Sprintf("%v %v", ymdhVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v 0%v", ymdhVal, i)
}
tayTime := publicmethod.DateToTimeStampOld(createTime)
startTime, endTime := publicmethod.TimeUnixDayStartAndEnd(tayTime)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime = endTime * 1000
}
if startTime <= pageTime && pageTime <= endTime {
newVal = append(newVal, mv)
}
}
}
}
var charInfo TargetInfo
charInfo.Title = fmt.Sprintf("%v :%v", ymdhVal, i)
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
}
default:
yearVal := publicmethod.UnixTimeToDay(tayTime, 16)
yearValInt, _ := strconv.Atoi(yearVal)
tayMonthTime := int(time.Now().Month())
for i := 1; i <= tayMonthTime; i++ {
var charInfo TargetInfo
createTime := fmt.Sprintf("%v-%v-01 00:00:00", yearVal, i)
if i < 10 {
createTime = fmt.Sprintf("%v-0%v-01 00:00:00", yearVal, i)
}
charInfo.Title = fmt.Sprintf("%v年%v月", yearVal, i)
startTime := publicmethod.DateToTimeStampOld(createTime)
endTime := publicmethod.GetDaysInMonth(yearValInt, i)
var newVal []map[string]interface{}
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
pageTime, _ := publicmethod.StringToInt64(xVal)
if publicmethod.GetIntLength(pageTime) >= 13 {
startTime = startTime * 1000
endTime.AllTime = endTime.AllTime * 1000
}
if startTime <= pageTime && pageTime <= endTime.AllTime {
newVal = append(newVal, mv)
}
}
}
}
charInfo.AnalyRadarDataTime(y, newVal)
charData = append(charData, charInfo)
}
}
return
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-22 11:22:34
@ 功能: 解析雷达数据
#xField x轴设定
w
# y Y轴设定
# val 查询到的值
#chartType 图标类型
1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (t *TargetInfo) AnalyRadarDataTime(y []YAxisInfo, val interface{}) {
for _, v := range y {
switch v.Method {
case 2:
t.TimeAverageValuees(v, val, v.Format)
case 3:
t.TimeStatisticalQuantityes(v, val, v.Format)
case 4:
t.TimeRemoveDuplicateCountss(v, val, v.Format)
case 5:
t.TimemaxDataes(v, val, v.Format)
case 6:
t.TimeminDataes(v, val, v.Format)
default:
t.TimesumDataes(v, val, v.Format)
}
}
}
// 平均值
func (t *TargetInfo) TimeAverageValuees(y YAxisInfo, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
jibuqi := 1
for _, mv := range yVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
jibuqi++
}
}
}
if jibuqi > 0 {
sumValAvg := sumVal / float64(jibuqi)
lianHua.Value = publicmethod.DataChuli(sumValAvg, format)
t.List = append(t.List, lianHua)
} else {
lianHua.Value = 0
t.List = append(t.List, lianHua)
}
}
}
// 计数
func (t *TargetInfo) TimeStatisticalQuantityes(y YAxisInfo, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
lianHua.Value = len(sumVal)
t.List = append(t.List, lianHua)
}
}
// 去重计数
func (t *TargetInfo) TimeRemoveDuplicateCountss(y YAxisInfo, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
lianHua.Value = len(sumVal)
t.List = append(t.List, lianHua)
}
}
// 最大值
func (t *TargetInfo) TimemaxDataes(y YAxisInfo, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
lianHua.Value = publicmethod.DataChuli(sumVal, format)
t.List = append(t.List, lianHua)
}
}
// 最小值
func (t *TargetInfo) TimeminDataes(y YAxisInfo, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
lianHua.Value = publicmethod.DataChuli(sumVal, format)
t.List = append(t.List, lianHua)
}
}
// 求和
func (t *TargetInfo) TimesumDataes(y YAxisInfo, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
lianHua.Value = publicmethod.DataChuli(sumVal, format)
t.List = append(t.List, lianHua)
}
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-23 09:41:50
@ 功能: 指标普通维度计算
*/
func (c *ChartInfo) TargetDataAnaly(x XAxisInfo, y []YAxisInfo, val interface{}, chartType string, untis []customerform.MasterStruct) (charData []TargetInfo) {
var timeList []string //根据维度分组
if yVal, isOk := val.([]map[string]interface{}); isOk {
for _, mv := range yVal {
if xVal, isOk := mv[x.Field]; isOk {
// fmt.Printf("人员--->%v\n\n", xVal)
pageTime := publicmethod.TypeToInterface(xVal)
if !publicmethod.IsInTrue[string](pageTime, timeList) {
timeList = append(timeList, pageTime)
}
}
}
}
for _, v := range timeList {
var charInfo TargetInfo
pickName := DimensionToChinaName(x.Field, v, untis)
charInfo.Title = pickName
charInfo.AnalyRadarData(x.Field, v, y, val)
charData = append(charData, charInfo)
}
return
}
/*
*
@ 作者: 秦东
@ 时间: 2025-07-22 11:22:34
@ 功能: 解析雷达数据
#xField x轴设定
w
# y Y轴设定
# val 查询到的值
#chartType 图标类型
1:求和；2:平均值；3:计数；4:去重计数；5:最大值；6:最小值
当字段为时间类型时. 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
*/
func (t *TargetInfo) AnalyRadarData(xField, xVal string, y []YAxisInfo, val interface{}) {
for _, v := range y {
switch v.Method {
case 2:
t.AverageValuees(v, xField, xVal, val, v.Format)
case 3:
t.StatisticalQuantityes(v, xField, xVal, val, v.Format)
case 4:
t.RemoveDuplicateCountss(v, xField, xVal, val, v.Format)
case 5:
t.maxDataes(v, xField, xVal, val, v.Format)
case 6:
t.minDataes(v, xField, xVal, val, v.Format)
default:
t.sumDataes(v, xField, xVal, val, v.Format)
}
}
}
// 平均值
func (t *TargetInfo) AverageValuees(y YAxisInfo, xField, xVal string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
jibuqi := 1
for _, mv := range yVal {
if xVal, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xVal)
if xValStr == xVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
jibuqi++
}
}
}
}
}
sumValAvg := sumVal / float64(jibuqi)
lianHua.Value = publicmethod.DataChuli(sumValAvg, format)
t.List = append(t.List, lianHua)
}
}
// 计数
func (t *TargetInfo) StatisticalQuantityes(y YAxisInfo, xField, xVal string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if xValx, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xValx)
if xValStr == xVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = append(sumVal, minVal)
}
}
}
}
}
lianHua.Value = len(sumVal)
t.List = append(t.List, lianHua)
}
}
// 去重计数
func (t *TargetInfo) RemoveDuplicateCountss(y YAxisInfo, xField, xVal string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal []float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if xValx, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xValx)
if xValStr == xVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if !publicmethod.IsInTrue[float64](minVal, sumVal) {
sumVal = append(sumVal, minVal)
}
}
}
}
}
}
lianHua.Value = len(sumVal)
t.List = append(t.List, lianHua)
}
}
// 最大值
func (t *TargetInfo) maxDataes(y YAxisInfo, xField, xVal string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if xValx, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xValx)
if xValStr == xVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal <= minVal {
sumVal = minVal
}
}
}
}
}
}
lianHua.Value = publicmethod.DataChuli(sumVal, format)
t.List = append(t.List, lianHua)
}
}
// 最小值
func (t *TargetInfo) minDataes(y YAxisInfo, xField, xVal string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if xValx, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xValx)
if xValStr == xVal {
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
if sumVal >= minVal {
sumVal = minVal
}
}
}
}
}
}
lianHua.Value = publicmethod.DataChuli(sumVal, format)
t.List = append(t.List, lianHua)
}
}
// 求和
func (t *TargetInfo) sumDataes(y YAxisInfo, xField, xVal string, val interface{}, format int) {
if yVal, isOk := val.([]map[string]interface{}); isOk {
var sumVal float64
var lianHua PicChartInfo
lianHua.Name = y.OldTitle
for _, mv := range yVal {
if xValx, isOk := mv[xField]; isOk {
xValStr := publicmethod.TypeToInterface(xValx)
if xValStr == xVal {
// fmt.Printf("指标秋毫---->%v---->%v\n\n\n", xValStr, y.Field)
if yval, isOk := mv[y.Field]; isOk {
minVal, err := strconv.ParseFloat(publicmethod.TypeToInterface(yval), 64)
if err == nil {
sumVal = sumVal + minVal
}
}
}
}
}
lianHua.Value = publicmethod.DataChuli(sumVal, format)
t.List = append(t.List, lianHua)
}
}

73
api/version1/customChart/type.go → api/version1/customChartes/type.go
View File

@ -1,4 +1,4 @@
package customchart
package customChartes
import (
"appPlatform/api/version1/customerform"
@ -78,6 +78,18 @@ type ChartInfo struct {
TimeLength int `json:"timelength"`
Search interface{} `json:"search"`
}
type ChartInfoTest struct {
Uuid string `json:"uuid"`
Icon string `json:"icon"`
Type string `json:"type"`
Title string `json:"title"`
WidthBox int `json:"widthBox"`
YAxis interface{} `json:"y"`
XAxis interface{} `json:"x"`
Filter interface{} `json:"filter"`
TimeLength int `json:"timelength"`
Search interface{} `json:"search"`
}
/*
*
@ -200,6 +212,61 @@ type FactorInfo struct {
@ 功能: 单一图表设定
*/
type OneChartViews struct {
TableKey string `json:"tableKey"`
ChartId string `json:"chartId"`
TableKey string `json:"tableKey"`
ChartId string `json:"chartId"`
SetConfig ChartInfo `json:"setConfig"`
}
// 饼形图数据输出
type PicChartInfo struct {
Name string `json:"name"`
Value interface{} `json:"value"`
}
// 输出饼形结构数据
type SendPicInfo struct {
MasterData []PicChartInfo `json:"mastrerData"`
OtherData []OtherDataInfo `json:"otherData"`
}
type OtherDataInfo struct {
FathreName string `json:"fathreName"`
ToolName string `json:"toolName"`
Toolval interface{} `json:"toolval"`
}
// 输出雷达数据
type RadarInfo struct {
Legend []string `json:"legend"`
Indicator []IndicatorInfo `json:"indicator"`
DataList []DataInfo `json:"dataList"`
}
type IndicatorInfo struct {
Name string `json:"name"`
Max interface{} `json:"max"`
}
type DataInfo struct {
Name string `json:"name"`
Value []interface{} `json:"value"`
}
// 输出排行榜
type BarRace struct {
Max int `json:"max"`
YAxisData []interface{} `json:"yAxisData"`
SeriesData []DataInfo `json:"seriesData"`
}
// 输出指标刊本结构体
type TargetInfo struct {
Title interface{} `json:"title"`
List []PicChartInfo `json:"list"`
}
// 雷达按时间统计
type RadarTimeInfo struct {
XName string
DataVal []map[string]interface{}
}

8
api/version1/customerApp/appControll.go
View File

@ -1522,6 +1522,14 @@ func (a *ApiMethod) GainAppPageInfo(c *gin.Context) {
} else {
sendData["pageList"] = true
}
if appFormPage.ChartView == "" {
sendData["chart"] = false
} else {
sendData["chart"] = true
}
var chartList interface{}
json.Unmarshal([]byte(appFormPage.ChartView), &chartList)
sendData["chartList"] = chartList
sendData["appFlow"] = false
if appFormPage.FlowIsOpen == 1 {

4
api/version1/entry.go
View File

@ -1,7 +1,7 @@
package version1
import (
customchart "appPlatform/api/version1/customChart"
"appPlatform/api/version1/customChartes"
"appPlatform/api/version1/customerApp"
"appPlatform/api/version1/customerform"
datacenter "appPlatform/api/version1/dataCenter"
@ -39,7 +39,7 @@ type ApiEntry struct {
CustomerAppApi customerApp.ApiMethod //自定App
WebSocketApi webstocetmsg.ApiMethod //webSocket通讯相关
WorkFlowApi workflowRun.ApiMethod //工作流相关
ChartApi customchart.ApiMethod
ChartApi customChartes.ApiMethod
}
var AppApiEntry = new(ApiEntry)

2
go.mod
View File

@ -1,7 +1,7 @@
module appPlatform
//go 1.19
go 1.21
go 1.24
require (
github.com/dengsgo/math-engine v0.0.0-20230823154425-78f211b48149

6
overall/publicmethod/tableUnit.go
View File

@ -1,6 +1,6 @@
package publicmethod
//自定义表单量化类型
var Dimension = []string{"input", "textarea", "datePicker", "timePicker", "organization", "tinymce", "colorPicker", "treeSelect", "serialNumber", "expand-user", "orgCentent", "founder", "founderTime", "editTime", "owner", "deptOrg", "pickpost", "pickrole"} //维度字段
var Quantization = []string{"digitpage", "radio", "checkbox", "select", "cascader", "switch", "inputNumber", "slider", "rate"} //可量化字段
var TimeUint = []string{"founderTime", "editTime", "timePicker"}
var Dimension = []string{"input", "textarea", "datePicker", "timePicker", "organization", "tinymce", "colorPicker", "treeSelect", "serialNumber", "expand-user", "orgCentent", "founder", "founderTime", "editTime", "owner", "deptOrg", "pickpost", "pickrole", "radio", "checkbox"} //维度字段
var Quantization = []string{"digitpage", "select", "cascader", "switch", "inputNumber", "slider", "rate"} //可量化字段
var TimeUint = []string{"founderTime", "editTime", "timePicker", "datePicker"} //时间

25
overall/publicmethod/technique.go
View File

@ -1898,6 +1898,8 @@ func (d *DateTimeTotimes) BaisStrToTime(dateTime string) {
case 2:
if len(timeStrAry[1]) < 2 {
dateTime = fmt.Sprintf("%v-0%v-01 12:00:00", timeStrAry[0], timeStrAry[1])
} else {
dateTime = fmt.Sprintf("%v-%v-01 12:00:00", timeStrAry[0], timeStrAry[1])
}
case 3:
monthStr := timeStrAry[1]
@ -3049,3 +3051,26 @@ func GetIntLength(n int64) int {
}
return count
}
// 值处理
// 1:自动（原始值）；2:整数；3:保留1位小数；4:保留2位小数；5:百分比；6:百分比1位小数；7:百分比2位小数；
func DataChuli(val float64, types int) interface{} {
var guodu interface{}
switch types {
case 2:
guodu = int64(val)
case 3:
guodu = fmt.Sprintf("%.1f", val)
case 4:
guodu = fmt.Sprintf("%.2f", val)
case 5:
guodu = fmt.Sprintf("%v%", val)
case 6:
guodu = fmt.Sprintf("%.1f%", val)
case 7:
guodu = fmt.Sprintf("%.2f%", val)
default:
guodu = val
}
return guodu
}

Write Preview
Loading…
Cancel
Save