appPlatform/api/version1/customChartes/analyData.go

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)
	}
}