Merge branch 'dev/1.5'

controllers/data_manage/chart_classify.go

@@ -9,6 +9,7 @@ import (
 	"hongze/hongze_ETA_mobile_api/models/system"
 	"hongze/hongze_ETA_mobile_api/services/data"
 	"hongze/hongze_ETA_mobile_api/utils"
+	"strconv"
 	"time"
 )
 
@@ -297,6 +298,204 @@ func (this *ChartClassifyController) ChartClassifyItems() {
 	br.Data = resp
 }
 
+// @Title 新增图表分类
+// @Description 新增图表分类接口
+// @Param	request	body data_manage.AddChartClassifyReq true "type json string"
+// @Success 200 Ret=200 保存成功
+// @router /chart_classify/add [post]
+func (this *ChartClassifyController) AddChartClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req data_manage.AddChartClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.ChartClassifyName == "" {
+		br.Msg = "请输入分类名称"
+		br.IsSendEmail = false
+		return
+	}
+	if req.ParentId < 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+
+	count, err := data_manage.GetChartClassifyCount(req.ChartClassifyName, req.ParentId, utils.CHART_SOURCE_DEFAULT)
+	if err != nil {
+		br.Msg = "判断名称是否已存在失败"
+		br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
+		return
+	}
+	if count > 0 {
+		br.Msg = "分类名称已存在，请重新输入"
+		br.IsSendEmail = false
+		return
+	}
+	//获取该层级下最大的排序数
+	maxSort, err := data_manage.GetChartClassifyMaxSort(req.ParentId, utils.CHART_SOURCE_DEFAULT)
+
+	classify := new(data_manage.ChartClassify)
+	classify.ParentId = req.ParentId
+	classify.ChartClassifyName = req.ChartClassifyName
+	classify.HasData = 0
+	classify.CreateTime = time.Now()
+	classify.ModifyTime = time.Now()
+	classify.SysUserId = this.SysUser.AdminId
+	classify.SysUserRealName = this.SysUser.RealName
+	classify.Level = req.Level + 1
+	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+	classify.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
+	classify.Sort = maxSort + 1
+	classify.Source = utils.CHART_SOURCE_DEFAULT
+
+	_, err = data_manage.AddChartClassify(classify)
+	if err != nil {
+		br.Msg = "保存分类失败"
+		br.ErrMsg = "保存分类失败,Err:" + err.Error()
+		return
+	}
+	br.Ret = 200
+	br.Msg = "保存成功"
+	br.Success = true
+}
+
+// @Title 修改图表分类
+// @Description 修改图表分类接口
+// @Param	request	body data_manage.EditChartClassifyReq true "type json string"
+// @Success 200 Ret=200 修改成功
+// @router /chart_classify/edit [post]
+func (this *ChartClassifyController) EditChartClassify() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req data_manage.EditChartClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	if req.ChartClassifyName == "" {
+		br.Msg = "请输入分类名称"
+		br.IsSendEmail = false
+		return
+	}
+
+	if req.ChartClassifyId <= 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+
+	item, err := data_manage.GetChartClassifyById(req.ChartClassifyId)
+	if err != nil {
+		br.Msg = "保存失败"
+		br.Msg = "获取分类信息失败,Err:" + err.Error()
+		return
+	}
+
+	if item.ChartClassifyName != req.ChartClassifyName {
+		count, err := data_manage.GetChartClassifyCount(req.ChartClassifyName, item.ParentId, utils.CHART_SOURCE_DEFAULT)
+		if err != nil {
+			br.Msg = "判断名称是否已存在失败"
+			br.ErrMsg = "判断名称是否已存在失败，Err:" + err.Error()
+			return
+		}
+		if count > 0 {
+			br.Msg = "分类名称已存在，请重新输入"
+			br.IsSendEmail = false
+			return
+		}
+
+		err = data_manage.EditChartClassify(req.ChartClassifyId, utils.CHART_SOURCE_DEFAULT, req.ChartClassifyName)
+		if err != nil {
+			br.Msg = "保存失败"
+			br.ErrMsg = "保存失败,Err:" + err.Error()
+			return
+		}
+	}
+	br.Ret = 200
+	br.Msg = "保存成功"
+	br.Success = true
+	br.IsAddLog = true
+}
+
+// @Title 删除图表检测接口
+// @Description 删除图表检测接口
+// @Param	request	body data_manage.ChartClassifyDeleteCheckResp true "type json string"
+// @Success 200 Ret=200 检测成功
+// @router /chart_classify/delete/check [post]
+func (this *ChartClassifyController) DeleteChartClassifyCheck() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	var req data_manage.ChartClassifyDeleteCheckReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ChartClassifyId < 0 && req.ChartInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.IsSendEmail = false
+		return
+	}
+	var deleteStatus int
+	var tipsMsg string
+	//删除分类
+	if req.ChartClassifyId > 0 && req.ChartInfoId == 0 {
+		//判断图表分类下，是否含有图表
+		count, err := data_manage.GetChartInfoCountByClassifyId(req.ChartClassifyId)
+		if err != nil {
+			br.Msg = "删除失败"
+			br.ErrMsg = "分类下是否含有指标失败，Err:" + err.Error()
+			return
+		}
+
+		if count > 0 {
+			deleteStatus = 1
+			tipsMsg = "该分类下关联图表不可删除"
+		}
+	}
+
+	if deleteStatus != 1 && req.ChartInfoId == 0 {
+		classifyCount, err := data_manage.GetChartClassifyCountByClassifyId(req.ChartClassifyId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			br.Msg = "删除失败"
+			br.ErrMsg = "分类下是否含有图表失败，Err:" + err.Error()
+			return
+		}
+		if classifyCount > 0 {
+			deleteStatus = 2
+			tipsMsg = "确认删除当前目录及包含的子目录吗"
+		}
+	}
+	if deleteStatus == 0 {
+		tipsMsg = "可删除，进行删除操作"
+	}
+
+	resp := new(data_manage.ChartClassifyDeleteCheckResp)
+	resp.DeleteStatus = deleteStatus
+	resp.TipsMsg = tipsMsg
+	br.Ret = 200
+	br.Msg = "检测成功"
+	br.Success = true
+	br.Data = resp
+}
+
 // DeleteChartClassify
 // @Title 删除图表分类/图表
 // @Description 删除图表分类/图表接口
@@ -483,3 +682,135 @@ func (this *ChartClassifyController) DeleteChartClassify() {
 	br.Data = resp
 	br.IsAddLog = true
 }
+
+// ChartClassifyMove
+// @Title 图表分类移动接口
+// @Description 图表分类移动接口
+// @Success 200 {object} data_manage.MoveChartClassifyReq
+// @router /chart_classify/move [post]
+func (this *ChartClassifyController) ChartClassifyMove() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.MoveChartClassifyReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ClassifyId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "分类id小于等于0"
+		return
+	}
+	//判断分类是否存在
+	chartClassifyInfo, err := data_manage.GetChartClassifyById(req.ClassifyId)
+	if err != nil {
+		br.Msg = "移动失败"
+		br.ErrMsg = "获取分类信息失败,Err:" + err.Error()
+		return
+	}
+	if chartClassifyInfo.Source != utils.CHART_SOURCE_DEFAULT {
+		br.Msg = "分类异常"
+		br.ErrMsg = "分类异常,不是ETA图库的分类"
+		return
+	}
+	updateCol := make([]string, 0)
+
+	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
+	if chartClassifyInfo.ParentId != req.ParentClassifyId && req.ParentClassifyId != 0 {
+		parentChartClassifyInfo, err := data_manage.GetChartClassifyById(req.ParentClassifyId)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "获取上级分类信息失败,Err:" + err.Error()
+			return
+		}
+		chartClassifyInfo.ParentId = parentChartClassifyInfo.ChartClassifyId
+		chartClassifyInfo.Level = parentChartClassifyInfo.Level + 1
+		chartClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "ParentId", "Level", "ModifyTime")
+	}
+
+	//如果有传入 上一个兄弟节点分类id
+	if req.PrevClassifyId > 0 {
+		//上一个兄弟节点
+		prevClassify, err := data_manage.GetChartClassifyById(req.PrevClassifyId)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+			return
+		}
+
+		//如果是移动在两个兄弟节点之间
+		if req.NextClassifyId > 0 {
+			//下一个兄弟节点
+			nextClassify, err := data_manage.GetChartClassifyById(req.NextClassifyId)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+				return
+			}
+			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == chartClassifyInfo.Sort {
+				//变更兄弟节点的排序
+				updateSortStr := `sort + 2`
+				_ = data_manage.UpdateChartClassifySortByParentId(prevClassify.ParentId, prevClassify.ChartClassifyId, prevClassify.Sort, updateSortStr)
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextClassify.Sort-prevClassify.Sort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+					_ = data_manage.UpdateChartClassifySortByParentId(prevClassify.ParentId, 0, prevClassify.Sort, updateSortStr)
+				}
+			}
+		}
+
+		chartClassifyInfo.Sort = prevClassify.Sort + 1
+		chartClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+
+	} else {
+		firstClassify, err := data_manage.GetFirstChartClassifyByParentId(chartClassifyInfo.ParentId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			br.Msg = "移动失败"
+			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = data_manage.UpdateChartClassifySortByParentId(firstClassify.ParentId, firstClassify.ChartClassifyId-1, 0, updateSortStr)
+		}
+
+		chartClassifyInfo.Sort = 0 //那就是排在第一位
+		chartClassifyInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	//更新
+	if len(updateCol) > 0 {
+		err = chartClassifyInfo.Update(updateCol)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "修改失败,Err:" + err.Error()
+			return
+		}
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "移动成功"
+}

controllers/data_manage/chart_common.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"hongze/hongze_ETA_mobile_api/controllers/data_manage/correlation"
 	"hongze/hongze_ETA_mobile_api/controllers/data_manage/future_good"
+	"hongze/hongze_ETA_mobile_api/controllers/data_manage/line_equation"
 	"hongze/hongze_ETA_mobile_api/models"
 	"hongze/hongze_ETA_mobile_api/models/data_manage"
 	"hongze/hongze_ETA_mobile_api/models/data_manage/line_feature/request"
@@ -133,6 +134,17 @@ func (this *ChartInfoController) CommonChartInfoDetailFromUniqueCode() {
 		br.Success = true
 		br.Msg = "获取成功"
 		br.Data = resp
+	case utils.CHART_SOURCE_LINE_EQUATION:
+		resp, isOk, msg, errMsg := line_equation.GetChartInfoDetailFromUniqueCode(chartInfo, isCache, sysUser)
+		if !isOk {
+			br.Msg = msg
+			br.ErrMsg = errMsg
+			return
+		}
+		br.Ret = 200
+		br.Success = true
+		br.Msg = "获取成功"
+		br.Data = resp
 	default:
 		br.Msg = "错误的图表"
 		br.ErrMsg = "错误的图表"

controllers/data_manage/chart_info.go

@@ -245,6 +245,376 @@ func GetChartInfoDetailFromUniqueCode(chartInfo *data_manage.ChartInfoView, isCa
 	return
 }
 
+// @Title 编辑图表英文信息接口
+// @Description 编辑图表英文信息接口
+// @Param	request	body data_manage.EditChartEnInfoReq true "type json string"
+// @Success Ret=200 编辑成功
+// @router /chart_info/en/edit [post]
+func (this *ChartInfoController) ChartEnInfoEdit() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.EditChartEnInfoReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+	req.ChartNameEn = strings.Trim(req.ChartNameEn, " ")
+	if req.ChartInfoId <= 0 {
+		br.Msg = "请选择图表"
+		return
+	}
+
+	//判断指标名称是否存在
+	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			br.Msg = "图表已被删除，请刷新页面"
+			br.ErrMsg = "图表已被删除，请刷新页面"
+			return
+		}
+		br.Msg = "获取图表信息失败"
+		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
+		return
+	}
+
+	// 判断是否有传入对应的指标配置
+	noEdbInfoType := []int{10}
+	if len(req.ChartEdbInfoList) <= 0 && !utils.InArrayByInt(noEdbInfoType, chartItem.ChartType) {
+		br.Msg = "请选择指标！"
+		return
+	}
+
+	var edbCondition string
+	var edbPars []interface{}
+	for _, v := range req.ChartEdbInfoList {
+		edbInfoId := v.EdbInfoId
+		edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
+		if err != nil {
+			if err.Error() == utils.ErrNoRow() {
+				br.Msg = "图表不存在！"
+				br.ErrMsg = "图表指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId)
+				return
+			} else {
+				br.Msg = "获取图表信息失败！"
+				br.ErrMsg = "获取图表的指标信息失败，Err:" + err.Error()
+				return
+			}
+		}
+		if edbInfo == nil {
+			br.Msg = "指标不存在！"
+			br.ErrMsg = "指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId)
+			return
+		}
+
+		//判断指标名称是否重复
+		if v.EdbNameEn != "" {
+			edbCondition = ""
+			edbPars = make([]interface{}, 0)
+
+			edbCondition += " AND edb_info_id<>? "
+			edbPars = append(edbPars, edbInfo.EdbInfoId)
+
+			/*edbCondition += " AND source=? "
+			edbPars = append(edbPars, edbInfo.Source)*/
+
+			edbCondition += " AND edb_name_en=? "
+			edbPars = append(edbPars, v.EdbNameEn)
+
+			edbExist, err := data_manage.GetEdbInfoByCondition(edbCondition, edbPars)
+			if err != nil {
+				if err.Error() != utils.ErrNoRow() {
+					br.Msg = "判断英文指标名称是否存在失败"
+					br.ErrMsg = "判断英文指标名称是否存在失败,Err:" + err.Error()
+					return
+				}
+			}
+
+			if err == nil && edbExist.EdbInfoId > 0 {
+				br.Msg = edbExist.EdbName + "：" + v.EdbNameEn + "指标名称已存在"
+				br.ErrMsg = "英文指标名称已存在，请重新填写"
+				br.IsSendEmail = false
+				return
+			}
+		}
+	}
+	if req.ChartNameEn != "" || req.ExtraConfig != `` {
+		var condition string
+		var pars []interface{}
+		condition += " AND chart_info_id<>? "
+		pars = append(pars, req.ChartInfoId)
+
+		/*condition += " AND chart_classify_id=? "
+		pars = append(pars, chartItem.ChartClassifyId)*/
+
+		condition += " AND chart_name_en=? "
+		pars = append(pars, req.ChartNameEn)
+
+		existItem, err := data_manage.GetChartInfoByCondition(condition, pars)
+		if err != nil {
+			if err.Error() != utils.ErrNoRow() {
+				br.Msg = "判断英文图表名称是否存在失败"
+				br.ErrMsg = "判断英文图表名称是否存在失败,Err:" + err.Error()
+				return
+			}
+		}
+
+		if err == nil && existItem.ChartInfoId > 0 {
+			br.Msg = existItem.ChartName + "：" + req.ChartNameEn + "图表名称已存在"
+			return
+		}
+	}
+
+	err = data_manage.EditChartEnInfoAndEdbEnInfo(&req)
+	if err != nil {
+		br.Msg = "保存失败"
+		br.ErrMsg = "保存失败,Err:" + err.Error()
+		return
+	}
+	//添加es数据
+	go data.EsAddOrEditChartInfo(chartItem.ChartInfoId)
+	//修改my eta es数据
+	go data.EsAddOrEditMyChartInfoByChartInfoId(chartItem.ChartInfoId)
+
+	//edbinfo 修改es信息
+	for _, v := range req.ChartEdbInfoList {
+		edbInfoId := v.EdbInfoId
+		edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
+		if err != nil {
+			if err.Error() == utils.ErrNoRow() {
+				br.Msg = "图表不存在！"
+				br.ErrMsg = "图表指标不存在，ChartInfoId:" + strconv.Itoa(edbInfoId)
+				return
+			} else {
+				br.Msg = "获取图表信息失败！"
+				br.ErrMsg = "获取图表的指标信息失败，Err:" + err.Error()
+				return
+			}
+		}
+		if edbInfo != nil {
+			go data.AddOrEditEdbInfoToEs(edbInfoId)
+		}
+	}
+
+	//新增操作日志
+	{
+		chartLog := new(data_manage.ChartInfoLog)
+		chartLog.ChartName = chartItem.ChartName
+		chartLog.ChartInfoId = req.ChartInfoId
+		chartLog.ChartClassifyId = chartItem.ChartClassifyId
+		chartLog.SysUserId = sysUser.AdminId
+		chartLog.SysUserRealName = sysUser.RealName
+		chartLog.UniqueCode = chartItem.UniqueCode
+		chartLog.CreateTime = time.Now()
+		chartLog.Content = string(this.Ctx.Input.RequestBody)
+		chartLog.Status = "编辑图表英文信息"
+		chartLog.Method = this.Ctx.Input.URL()
+		go data_manage.AddChartInfoLog(chartLog)
+	}
+	//清除缓存
+	if utils.Re == nil && utils.Rc != nil {
+		utils.Rc.Delete(utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode) //图表分享链接缓存
+		utils.Rc.Delete(data.GetChartInfoDataKey(req.ChartInfoId))
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "编辑成功"
+	br.IsAddLog = true
+}
+
+// ChartInfoMove
+// @Title 移动图表接口
+// @Description 移动图表接口
+// @Success 200 {object} data_manage.MoveChartInfoReq
+// @router /chart_info/move [post]
+func (this *ChartInfoController) ChartInfoMove() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req data_manage.MoveChartInfoReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	if req.ChartInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "图表id小于等于0"
+		return
+	}
+
+	if req.ChartClassifyId <= 0 {
+		br.Msg = "请选择分类"
+		return
+	}
+	//判断分类是否存在
+	count, _ := data_manage.GetChartClassifyCountById(req.ChartClassifyId)
+	if count <= 0 {
+		br.Msg = "分类已被删除，不可移动，请刷新页面"
+		return
+	}
+
+	chartInfo, err := data_manage.GetChartInfoById(req.ChartInfoId)
+	if err != nil {
+		br.Msg = "移动失败"
+		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
+		return
+	}
+	if chartInfo.Source != utils.CHART_SOURCE_DEFAULT {
+		br.Msg = "图表异常"
+		br.ErrMsg = "分类异常,不是ETA图库的图表"
+		return
+	}
+
+	//如果改变了分类，那么移动该图表数据
+	if chartInfo.ChartClassifyId != req.ChartClassifyId {
+		//查询需要修改的分类下是否存在同一个图表名称
+		tmpChartInfo, tmpErr := data_manage.GetChartInfoByClassifyIdAndName(req.ChartClassifyId, chartInfo.ChartName)
+		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+			br.Msg = "移动失败"
+			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
+			return
+		}
+		if tmpChartInfo != nil {
+			br.Msg = "移动失败，同一个分类下图表名称不允许重复"
+			br.ErrMsg = "移动失败，同一个分类下图表名称不允许重复"
+			return
+		}
+		err = data_manage.MoveChartInfo(req.ChartInfoId, req.ChartClassifyId)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "移动失败,Err:" + err.Error()
+			return
+		}
+	}
+
+	//移动排序
+	updateCol := make([]string, 0)
+	//如果有传入 上一个兄弟节点分类id
+	if req.PrevChartInfoId > 0 {
+		prevChartInfo, err := data_manage.GetChartInfoById(req.PrevChartInfoId)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+			return
+		}
+
+		//如果是移动在两个兄弟节点之间
+		if req.NextChartInfoId > 0 {
+			//下一个兄弟节点
+			nextChartInfo, err := data_manage.GetChartInfoById(req.NextChartInfoId)
+			if err != nil {
+				br.Msg = "移动失败"
+				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+				return
+			}
+			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevChartInfo.Sort == nextChartInfo.Sort || prevChartInfo.Sort == chartInfo.Sort {
+				//变更兄弟节点的排序
+				updateSortStr := `sort + 2`
+				_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, chartInfo.Source, updateSortStr)
+			} else {
+				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextChartInfo.Sort-prevChartInfo.Sort == 1 {
+					//变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+					_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, chartInfo.Source, updateSortStr)
+				}
+			}
+		}
+
+		chartInfo.Sort = prevChartInfo.Sort + 1
+		chartInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+
+	} else {
+		firstClassify, err := data_manage.GetFirstChartInfoByClassifyId(req.ChartClassifyId)
+		if err != nil && err.Error() != utils.ErrNoRow() {
+			br.Msg = "移动失败"
+			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = data_manage.UpdateChartInfoSortByClassifyId(firstClassify.ChartClassifyId, 0, firstClassify.ChartInfoId-1, chartInfo.Source, updateSortStr)
+		}
+
+		chartInfo.Sort = 0 //那就是排在第一位
+		chartInfo.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	//更新
+	if len(updateCol) > 0 {
+		err = chartInfo.Update(updateCol)
+		if err != nil {
+			br.Msg = "移动失败"
+			br.ErrMsg = "修改失败,Err:" + err.Error()
+			return
+		}
+	}
+
+	if err != nil {
+		br.Msg = "移动失败"
+		br.ErrMsg = "修改失败,Err:" + err.Error()
+		return
+	}
+
+	//添加es数据
+	go data.EsAddOrEditChartInfo(req.ChartInfoId)
+	//修改my eta es数据
+	go data.EsAddOrEditMyChartInfoByChartInfoId(req.ChartInfoId)
+
+	//新增操作日志
+	{
+		chartLog := new(data_manage.ChartInfoLog)
+		chartLog.ChartName = chartInfo.ChartName
+		chartLog.ChartInfoId = req.ChartInfoId
+		chartLog.ChartClassifyId = chartInfo.ChartClassifyId
+		chartLog.SysUserId = sysUser.AdminId
+		chartLog.SysUserRealName = sysUser.RealName
+		chartLog.UniqueCode = chartInfo.UniqueCode
+		chartLog.CreateTime = time.Now()
+		chartLog.Content = string(this.Ctx.Input.RequestBody)
+		chartLog.Status = "移动图表"
+		chartLog.Method = this.Ctx.Input.URL()
+		go data_manage.AddChartInfoLog(chartLog)
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "移动成功"
+}
+
 // ChartInfoDetail
 // @Title 获取图表详情
 // @Description 获取图表详情接口
@@ -1050,6 +1420,76 @@ func (this *ChartInfoController) ChartInfoSearchByEs() {
 	br.Data = resp
 }
 
+// @Title 图表刷新接口
+// @Description 图表刷新接口
+// @Param   ChartInfoId   query   int  true       "图表id"
+// @Param   UniqueCode   query   string  true       "唯一code"
+// @Success Ret=200 刷新成功
+// @router /chart_info/refresh [get]
+func (this *ChartInfoController) ChartInfoRefresh() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	chartInfoId, _ := this.GetInt("ChartInfoId")
+	uniqueCode := this.GetString("UniqueCode")
+	if chartInfoId <= 0 && uniqueCode == `` {
+		br.Msg = "参数错误"
+		br.ErrMsg = "参数错误:chartInfoId:" + strconv.Itoa(chartInfoId) + ",UniqueCode:" + uniqueCode
+		return
+	}
+
+	var chartInfo *data_manage.ChartInfo
+	var err error
+	if chartInfoId > 0 {
+		chartInfo, err = data_manage.GetChartInfoById(chartInfoId)
+	} else {
+		chartInfo, err = data_manage.GetChartInfoByUniqueCode(uniqueCode)
+	}
+	if err != nil {
+		if err.Error() == utils.ErrNoRow() {
+			br.Msg = "图表已被删除，无需刷新"
+			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
+			return
+		}
+		br.Msg = "刷新失败"
+		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+		return
+	}
+	err = data.ChartInfoRefreshV2(chartInfo.ChartInfoId)
+	if err != nil {
+		br.Msg = "刷新失败"
+		br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
+		return
+	}
+	/*
+		//err = data.ChartInfoRefresh(chartInfo.ChartInfoId)
+			//if err != nil {
+			//	br.Msg = "刷新失败"
+			//	br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
+			//	return
+			//}
+	*/
+
+	//清除图表缓存
+	{
+		key := utils.HZ_CHART_LIB_DETAIL + chartInfo.UniqueCode
+		_ = utils.Rc.Delete(key)
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "刷新成功"
+}
+
 // BatchChartInfoRefresh
 // @Title 批量刷新图表接口
 // @Description 批量刷新图表接口

controllers/data_manage/edb_info.go

@@ -0,0 +1,50 @@
+package data_manage
+
+import (
+	"hongze/hongze_ETA_mobile_api/controllers"
+	"hongze/hongze_ETA_mobile_api/models"
+	"hongze/hongze_ETA_mobile_api/services/data"
+)
+
+// 数据管理
+type EdbInfoController struct {
+	controllers.BaseAuthController
+}
+
+// TraceEdbInfo
+// @Title 指标溯源接口
+// @Description 指标溯源接口
+// @Param   EdbInfoId   query   int  true       "指标id"
+// @Success 200 {object} data_manage.ChartListResp
+// @router /edb_info/trace [get]
+func (this *EdbInfoController) TraceEdbInfo() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+	edbInfoId, _ := this.GetInt("EdbInfoId")
+	if edbInfoId <= 0 {
+		br.Msg = "参数错误"
+		br.ErrMsg = "参数错误"
+		return
+	}
+
+	resp, err := data.TraceEdbInfoByEdbInfoId(edbInfoId)
+	if err != nil {
+		br.Msg = "获取失败"
+		br.Msg = "获取失败,Err:" + err.Error()
+		return
+	}
+	br.Ret = 200
+	br.Data = resp
+	br.Success = true
+	br.Msg = "刷新成功"
+}

controllers/data_manage/line_equation/line_chart_info.go

@@ -1,11 +1,16 @@
 package line_equation
 
 import (
+	"encoding/json"
+	"fmt"
 	"github.com/rdlucklib/rdluck_tools/paging"
 	"hongze/hongze_ETA_mobile_api/controllers"
 	"hongze/hongze_ETA_mobile_api/models"
 	"hongze/hongze_ETA_mobile_api/models/data_manage"
+	"hongze/hongze_ETA_mobile_api/models/data_manage/line_equation/request"
+	"hongze/hongze_ETA_mobile_api/models/system"
 	"hongze/hongze_ETA_mobile_api/services/data"
+	"hongze/hongze_ETA_mobile_api/services/data/line_equation"
 	"hongze/hongze_ETA_mobile_api/utils"
 	"strconv"
 	"strings"
@@ -17,6 +22,1484 @@ type LineEquationChartInfoController struct {
 	controllers.BaseAuthController
 }
 
+// Preview
+// @Title 拟合方程图表-预览数据
+// @Description 拟合方程图表-获取预览数据
+// // @Param	request	body request.LineChartInfoReq true "type json string"
+// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
+// @router /chart_info/preview [post]
+//func (this *LineEquationChartInfoController) Preview() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	var req request.LineChartInfoReq
+//	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//	lenXdbInfoList := len(req.XEdbInfoIdList)
+//	lenYdbInfoList := len(req.YEdbInfoIdList)
+//	if lenXdbInfoList < 2 {
+//		br.Msg = "X轴指标不能小于两个"
+//		br.IsSendEmail = false
+//		return
+//	}
+//	if lenYdbInfoList < 2 {
+//		br.Msg = "Y轴指标不能小于两个"
+//		br.IsSendEmail = false
+//		return
+//	}
+//	if lenYdbInfoList != lenXdbInfoList {
+//		br.Msg = "X轴与Y轴指标数量不一致"
+//		br.IsSendEmail = false
+//		return
+//	}
+//
+//	chartInfo := new(data_manage.ChartInfoView)
+//	chartInfo.ChartType = 9
+//
+//	// 获取图表x轴y轴
+//	_, dataResp, err, errMsg := line_equation.GetChartEdbData(0, req, true, true, true)
+//	if err != nil {
+//		br.Msg = "获取失败"
+//		if errMsg != `` {
+//			br.Msg = errMsg
+//		}
+//		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	resp := response.ChartInfoResp{List: []response.ChartDataResp{
+//		{
+//			LatestDate:          dataResp.AData.LatestDate,
+//			EdbInfoCategoryType: dataResp.AData.EdbInfoCategoryType,
+//			Name:                dataResp.AData.EdbName,
+//			NameEn:              dataResp.AData.EdbNameEn,
+//			MinData:             dataResp.AData.MinData,
+//			MaxData:             dataResp.AData.MaxData,
+//			DataList:            dataResp.AData.DataList,
+//		},
+//		{
+//			LatestDate:          dataResp.BData.LatestDate,
+//			EdbInfoCategoryType: dataResp.BData.EdbInfoCategoryType,
+//			Name:                dataResp.BData.EdbName,
+//			NameEn:              dataResp.BData.EdbNameEn,
+//			MinData:             dataResp.BData.MinData,
+//			MaxData:             dataResp.BData.MaxData,
+//			DataList:            dataResp.BData.DataList,
+//		},
+//		{
+//			LatestDate:          dataResp.R2Data.LatestDate,
+//			EdbInfoCategoryType: dataResp.R2Data.EdbInfoCategoryType,
+//			Name:                dataResp.R2Data.EdbName,
+//			NameEn:              dataResp.R2Data.EdbNameEn,
+//			MinData:             dataResp.R2Data.MinData,
+//			MaxData:             dataResp.R2Data.MaxData,
+//			DataList:            dataResp.R2Data.DataList,
+//		},
+//	}}
+//
+//	br.Data = resp
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "获取成功"
+//}
+//
+//// Save
+//// @Title 新增图表接口
+//// @Description 新增图表接口
+//// @Param	request	body data_manage.AddChartInfoReq true "type json string"
+//// @Success 200 {object} data_manage.AddChartInfoResp
+//// @router /chart_info/save [post]
+//func (this *LineEquationChartInfoController) Save() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	deleteCache := true
+//	cacheKey := "CACHE_CHART_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
+//	defer func() {
+//		if deleteCache {
+//			_ = utils.Rc.Delete(cacheKey)
+//		}
+//	}()
+//	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
+//		deleteCache = false
+//		br.Msg = "系统处理中，请稍后重试！"
+//		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
+//		return
+//	}
+//	var req request.AddChartInfoReq
+//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+//	if err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	resp := new(data_manage.AddChartInfoResp)
+//	if req.MultipleGraphConfigId <= 0 {
+//		batchAddChartList, err, errMsg, isSendEmail := line_equation.BatchAddChartInfo(req.BatchAddChart, req.ExtraConfig, sysUser)
+//		if err != nil {
+//			br.Msg = "保存失败"
+//			if errMsg != `` {
+//				br.Msg = errMsg
+//			}
+//			br.ErrMsg = err.Error()
+//			br.IsSendEmail = isSendEmail
+//			return
+//		}
+//
+//		resp.ChartInfoId = batchAddChartList[0].ChartInfo.ChartInfoId
+//		resp.UniqueCode = batchAddChartList[0].ChartInfo.UniqueCode
+//		resp.ChartType = batchAddChartList[0].ChartInfo.ChartType
+//
+//		//新增操作日志
+//		{
+//			for _, v := range batchAddChartList {
+//				chartInfo := v.ChartInfo
+//				chartLog := new(data_manage.ChartInfoLog)
+//				chartLog.ChartInfoId = chartInfo.ChartInfoId
+//				chartLog.ChartName = chartInfo.ChartName
+//				chartLog.ChartClassifyId = chartInfo.ChartClassifyId
+//				chartLog.SysUserId = sysUser.AdminId
+//				chartLog.SysUserRealName = sysUser.RealName
+//				chartLog.UniqueCode = chartInfo.UniqueCode
+//				chartLog.CreateTime = time.Now()
+//				chartLog.Content = string(this.Ctx.Input.RequestBody)
+//				chartLog.Status = "新增拟合方程图表"
+//				chartLog.Method = this.Ctx.Input.URI()
+//				go data_manage.AddChartInfoLog(chartLog)
+//			}
+//		}
+//	} else {
+//		batchAddChartList, err, errMsg, isSendEmail := line_equation.BatchSaveChartInfo(req.MultipleGraphConfigId, req.BatchAddChart, req.ExtraConfig, sysUser)
+//		if err != nil {
+//			br.Msg = "保存失败"
+//			if errMsg != `` {
+//				br.Msg = errMsg
+//			}
+//			br.ErrMsg = err.Error()
+//			br.IsSendEmail = isSendEmail
+//			return
+//		}
+//
+//		resp.ChartInfoId = batchAddChartList[0].ChartInfo.ChartInfoId
+//		resp.UniqueCode = batchAddChartList[0].ChartInfo.UniqueCode
+//		resp.ChartType = batchAddChartList[0].ChartInfo.ChartType
+//
+//		//新增操作日志
+//		{
+//			for _, v := range batchAddChartList {
+//				chartInfo := v.ChartInfo
+//				chartLog := new(data_manage.ChartInfoLog)
+//				chartLog.ChartInfoId = chartInfo.ChartInfoId
+//				chartLog.ChartName = chartInfo.ChartName
+//				chartLog.ChartClassifyId = chartInfo.ChartClassifyId
+//				chartLog.SysUserId = sysUser.AdminId
+//				chartLog.SysUserRealName = sysUser.RealName
+//				chartLog.UniqueCode = chartInfo.UniqueCode
+//				chartLog.CreateTime = time.Now()
+//				chartLog.Content = string(this.Ctx.Input.RequestBody)
+//				chartLog.Status = "新增/编辑拟合方程图表"
+//				chartLog.Method = this.Ctx.Input.URI()
+//				go data_manage.AddChartInfoLog(chartLog)
+//			}
+//		}
+//	}
+//
+//	br.Data = resp
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "保存成功"
+//	br.IsAddLog = true
+//}
+//
+//// GetMultipleGraphConfig
+//// @Title 保存配置接口
+//// @Description 保存配置接口
+//// @Param   UniqueCode   query   int  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
+//// @Success Ret=200 返回图表id
+//// @router /multiple_graph/config/detail [get]
+//func (this *LineEquationChartInfoController) GetMultipleGraphConfig() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	uniqueCode := this.GetString("UniqueCode")
+//	if uniqueCode == "" {
+//		br.Msg = "参数错误"
+//		br.ErrMsg = "参数错误,uniqueCode is empty"
+//		return
+//	}
+//
+//	chartInfo, err := data_manage.GetChartInfoViewByUniqueCode(uniqueCode)
+//	if err != nil {
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+//		return
+//	}
+//	if chartInfo == nil {
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+//		return
+//	}
+//	multipleGraphConfigChartMapping, err := data_manage.GetMultipleGraphConfigChartMappingByChartId(chartInfo.ChartInfoId)
+//	if err != nil {
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取统一图表的配置信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	multipleGraphConfig, err := data_manage.GetMultipleGraphConfigById(multipleGraphConfigChartMapping.MultipleGraphConfigId)
+//	if err != nil {
+//		br.Msg = `获取失败`
+//		br.ErrMsg = `获取配置失败，ERR：` + err.Error()
+//		return
+//	}
+//
+//	// 图表的配置
+//	var lineChartInfoConfig request.LineChartInfoReq
+//	if err := json.Unmarshal([]byte(multipleGraphConfig.Curve), &lineChartInfoConfig); err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	// 生成的图表
+//	multipleGraphConfigChartMappingList := make([]response.MultipleGraphConfigChartMapping, 0)
+//	{
+//		chartMappingList, err := data_manage.GetMultipleGraphConfigChartMappingListById(multipleGraphConfigChartMapping.MultipleGraphConfigId)
+//		if err != nil {
+//			br.Msg = `获取失败`
+//			br.ErrMsg = `获取关联图表配置失败，ERR：` + err.Error()
+//			return
+//		}
+//		chartInfoIdList := make([]int, 0)
+//		chartMappingMap := make(map[int]*data_manage.MultipleGraphConfigChartMapping)
+//		for _, v := range chartMappingList {
+//			chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
+//			chartMappingMap[v.ChartInfoId] = v
+//		}
+//		chartList, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
+//		if err != nil {
+//			br.Msg = `获取失败`
+//			br.ErrMsg = `获取关联图表列表失败，ERR：` + err.Error()
+//			return
+//		}
+//		for _, v := range chartList {
+//			if tmpInfo, ok := chartMappingMap[v.ChartInfoId]; ok {
+//				multipleGraphConfigChartMappingList = append(multipleGraphConfigChartMappingList, response.MultipleGraphConfigChartMapping{
+//					ChartInfoId:     tmpInfo.ChartInfoId,
+//					Source:          tmpInfo.Source,
+//					ChartName:       v.ChartName,
+//					ChartClassifyId: v.ChartClassifyId,
+//				})
+//			}
+//		}
+//	}
+//
+//	// 关联指标
+//	mappingList, _, _, err, _ := line_equation.GetConfigData(lineChartInfoConfig)
+//	if err != nil {
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	resp := response.MultipleGraphConfigDetailResp{
+//		MultipleGraphConfigId: multipleGraphConfig.MultipleGraphConfigId,
+//		LineChartInfoConfig:   lineChartInfoConfig,
+//		EdbInfoList:           mappingList,
+//		ChartMappingList:      multipleGraphConfigChartMappingList,
+//	}
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "获取成功"
+//	br.Data = resp
+//	br.IsAddLog = true
+//}
+//
+//// Move
+//// @Title 移动图表接口
+//// @Description 移动图表接口
+//// @Success 200 {object} data_manage.MoveChartInfoReq
+//// @router /chart_info/move [post]
+//func (this *LineEquationChartInfoController) Move() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//
+//	var req data_manage.MoveChartInfoReq
+//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+//	if err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	if req.ChartInfoId <= 0 {
+//		br.Msg = "参数错误"
+//		br.ErrMsg = "图表id小于等于0"
+//		return
+//	}
+//
+//	if req.ChartClassifyId <= 0 {
+//		br.Msg = "请选择分类"
+//		return
+//	}
+//	//判断分类是否存在
+//	count, _ := data_manage.GetChartClassifyCountById(req.ChartClassifyId)
+//	if count <= 0 {
+//		br.Msg = "分类已被删除，不可移动，请刷新页面"
+//		return
+//	}
+//
+//	chartInfo, err := data_manage.GetChartInfoById(req.ChartInfoId)
+//	if err != nil {
+//		br.Msg = "移动失败"
+//		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	if !utils.InArrayByInt([]int{utils.CHART_SOURCE_LINE_EQUATION}, chartInfo.Source) {
+//		br.Msg = "图表异常"
+//		br.ErrMsg = "分类异常,不是拟合方程的图表"
+//		return
+//	}
+//
+//	//如果改变了分类，那么移动该图表数据
+//	if chartInfo.ChartClassifyId != req.ChartClassifyId {
+//		//查询需要修改的分类下是否存在同一个图表名称
+//		tmpChartInfo, tmpErr := data_manage.GetChartInfoByClassifyIdAndName(req.ChartClassifyId, chartInfo.ChartName)
+//		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
+//			return
+//		}
+//		if tmpChartInfo != nil {
+//			br.Msg = "移动失败，同一个分类下图表名称不允许重复"
+//			br.ErrMsg = "移动失败，同一个分类下图表名称不允许重复"
+//			return
+//		}
+//		err = data_manage.MoveChartInfo(req.ChartInfoId, req.ChartClassifyId)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "移动失败,Err:" + err.Error()
+//			return
+//		}
+//	}
+//
+//	//移动排序
+//	updateCol := make([]string, 0)
+//	//如果有传入 上一个兄弟节点分类id
+//	if req.PrevChartInfoId > 0 {
+//		prevChartInfo, err := data_manage.GetChartInfoById(req.PrevChartInfoId)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取上一个兄弟节点分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//
+//		//如果是移动在两个兄弟节点之间
+//		if req.NextChartInfoId > 0 {
+//			//下一个兄弟节点
+//			nextChartInfo, err := data_manage.GetChartInfoById(req.NextChartInfoId)
+//			if err != nil {
+//				br.Msg = "移动失败"
+//				br.ErrMsg = "获取下一个兄弟节点分类信息失败,Err:" + err.Error()
+//				return
+//			}
+//			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+//			if prevChartInfo.Sort == nextChartInfo.Sort || prevChartInfo.Sort == chartInfo.Sort {
+//				//变更兄弟节点的排序
+//				updateSortStr := `sort + 2`
+//				_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, chartInfo.Source, updateSortStr)
+//			} else {
+//				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+//				if nextChartInfo.Sort-prevChartInfo.Sort == 1 {
+//					//变更兄弟节点的排序
+//					updateSortStr := `sort + 1`
+//					_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, chartInfo.Source, updateSortStr)
+//				}
+//			}
+//		}
+//
+//		chartInfo.Sort = prevChartInfo.Sort + 1
+//		chartInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//
+//	} else {
+//		firstClassify, err := data_manage.GetFirstChartInfoByClassifyId(req.ChartClassifyId)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
+//			return
+//		}
+//
+//		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+//		if firstClassify != nil && firstClassify.Sort == 0 {
+//			updateSortStr := ` sort + 1 `
+//			_ = data_manage.UpdateChartInfoSortByClassifyId(firstClassify.ChartClassifyId, 0, firstClassify.ChartInfoId-1, chartInfo.Source, updateSortStr)
+//		}
+//
+//		chartInfo.Sort = 0 //那就是排在第一位
+//		chartInfo.ModifyTime = time.Now()
+//		updateCol = append(updateCol, "Sort", "ModifyTime")
+//	}
+//
+//	//更新
+//	if len(updateCol) > 0 {
+//		err = chartInfo.Update(updateCol)
+//		if err != nil {
+//			br.Msg = "移动失败"
+//			br.ErrMsg = "修改失败,Err:" + err.Error()
+//			return
+//		}
+//	}
+//
+//	if err != nil {
+//		br.Msg = "移动失败"
+//		br.ErrMsg = "修改失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	//添加es数据
+//	go data.EsAddOrEditChartInfo(req.ChartInfoId)
+//	//修改my eta es数据
+//	go data.EsAddOrEditMyChartInfoByChartInfoId(req.ChartInfoId)
+//
+//	//新增操作日志
+//	{
+//		chartLog := new(data_manage.ChartInfoLog)
+//		chartLog.ChartName = chartInfo.ChartName
+//		chartLog.ChartInfoId = req.ChartInfoId
+//		chartLog.ChartClassifyId = chartInfo.ChartClassifyId
+//		chartLog.SysUserId = sysUser.AdminId
+//		chartLog.SysUserRealName = sysUser.RealName
+//		chartLog.UniqueCode = chartInfo.UniqueCode
+//		chartLog.CreateTime = time.Now()
+//		chartLog.Content = string(this.Ctx.Input.RequestBody)
+//		chartLog.Status = "移动拟合方程图表"
+//		chartLog.Method = this.Ctx.Input.URL()
+//		go data_manage.AddChartInfoLog(chartLog)
+//	}
+//
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "移动成功"
+//}
+//
+//// List
+//// @Title 拟合方程图表列表接口
+//// @Description 拟合方程图表列表接口
+//// @Param   PageSize   query   int  true       "每页数据条数"
+//// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
+//// @Param   ChartClassifyId   query   int  true       "分类id"
+//// @Param   Keyword   query   string  true       "搜索关键词"
+//// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
+//// @Param   Source   query   int  true       "图表类型，3：拟合方程，4：滚动拟合方程"
+//// @Success 200 {object} data_manage.ChartListResp
+//// @router /chart_info/list [get]
+//func (this *LineEquationChartInfoController) List() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//
+//	chartClassifyId, _ := this.GetInt("ChartClassifyId")
+//
+//	pageSize, _ := this.GetInt("PageSize")
+//	currentIndex, _ := this.GetInt("CurrentIndex")
+//	keyword := this.GetString("KeyWord")
+//
+//	var total int
+//	page := paging.GetPaging(currentIndex, pageSize, total)
+//
+//	var startSize int
+//	if pageSize <= 0 {
+//		pageSize = utils.PageSize20
+//	}
+//	if currentIndex <= 0 {
+//		currentIndex = 1
+//	}
+//	startSize = paging.StartIndex(currentIndex, pageSize)
+//
+//	source, _ := this.GetInt("Source")
+//	if source <= 0 {
+//		source = utils.CHART_SOURCE_LINE_EQUATION
+//	}
+//
+//	var condition string
+//	var pars []interface{}
+//
+//	// 普通图表
+//	condition += ` AND source = ? `
+//	pars = append(pars, source)
+//
+//	if chartClassifyId > 0 {
+//		chartClassifyId, err := data_manage.GetChartClassify(chartClassifyId)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "获取图表信息失败"
+//			br.ErrMsg = "获取信息失败,GetChartClassify,Err:" + err.Error()
+//			return
+//		}
+//		condition += " AND chart_classify_id IN(" + chartClassifyId + ") "
+//	}
+//	if keyword != "" {
+//		condition += ` AND  ( chart_name LIKE '%` + keyword + `%' )`
+//	}
+//
+//	//只看我的
+//	isShowMe, _ := this.GetBool("IsShowMe")
+//	if isShowMe {
+//		condition += ` AND sys_user_id = ? `
+//		pars = append(pars, sysUser.AdminId)
+//	}
+//
+//	// 获取当前账号的不可见指标
+//	noPermissionChartIdList := make([]int, 0)
+//	{
+//		obj := data_manage.EdbInfoNoPermissionAdmin{}
+//		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "获取失败"
+//			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
+//			return
+//		}
+//		for _, v := range confList {
+//			noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
+//		}
+//	}
+//
+//	lenNoPermissionChartIdList := len(noPermissionChartIdList)
+//	if lenNoPermissionChartIdList > 0 {
+//		condition += ` AND chart_info_id not in (` + utils.GetOrmInReplace(lenNoPermissionChartIdList) + `) `
+//		pars = append(pars, noPermissionChartIdList)
+//	}
+//
+//	//获取图表信息
+//	list, err := data_manage.GetChartListByCondition(condition, pars, startSize, pageSize)
+//	if err != nil && err.Error() != utils.ErrNoRow() {
+//		br.Success = true
+//		br.Msg = "获取图表信息失败"
+//		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	myChartList, err := data_manage.GetMyChartListByAdminId(sysUser.AdminId)
+//	if err != nil && err.Error() != utils.ErrNoRow() {
+//		br.Msg = "获取图表信息失败"
+//		br.ErrMsg = "获取我的图表信息失败,Err:" + err.Error()
+//		return
+//	}
+//	myChartMap := make(map[int]*data_manage.MyChartView)
+//	for _, v := range myChartList {
+//		myChartMap[v.ChartInfoId] = v
+//	}
+//	listLen := len(list)
+//	chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
+//	if listLen > 0 {
+//		chartInfoIds := ""
+//		for _, v := range list {
+//			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
+//		}
+//		if chartInfoIds != "" {
+//			chartInfoIds = strings.Trim(chartInfoIds, ",")
+//			//判断是否需要展示英文标识
+//			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
+//			if e != nil {
+//				br.Msg = "获取失败"
+//				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
+//				return
+//			}
+//			for _, v := range edbList {
+//				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
+//			}
+//		}
+//	}
+//	for i := 0; i < listLen; i++ {
+//		//判断是否需要展示英文标识
+//		if _, ok := chartEdbMap[list[i].ChartInfoId]; ok {
+//			list[i].IsEnChart = data.CheckIsEnChart(list[i].ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, list[i].Source, list[i].ChartType)
+//		}
+//
+//		if existItem, ok := myChartMap[list[i].ChartInfoId]; ok {
+//			list[i].IsAdd = true
+//			list[i].MyChartId = existItem.MyChartId
+//			list[i].MyChartClassifyId = existItem.MyChartClassifyId
+//		}
+//	}
+//
+//	resp := new(data_manage.ChartListResp)
+//	if list == nil || len(list) <= 0 || (err != nil && err.Error() == utils.ErrNoRow()) {
+//		items := make([]*data_manage.ChartInfoView, 0)
+//		resp.Paging = page
+//		resp.List = items
+//		br.Ret = 200
+//		br.Success = true
+//		br.Msg = "获取成功"
+//		return
+//	}
+//
+//	dataCount, err := data_manage.GetChartListCountByCondition(condition, pars)
+//	if err != nil && err.Error() != utils.ErrNoRow() {
+//		br.Msg = "获取指标信息失败"
+//		br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
+//		return
+//	}
+//	page = paging.GetPaging(currentIndex, pageSize, dataCount)
+//	resp.Paging = page
+//	resp.List = list
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "获取成功"
+//	br.Data = resp
+//}
+//
+//// Detail
+//// @Title 获取图表详情
+//// @Description 获取图表详情接口
+//// @Param   ChartInfoId   query   int  true       "图表id"
+//// @Param   DateType   query   int  true       "日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间"
+//// @Param   StartDate   query   string  true       "自定义开始日期"
+//// @Param   EndDate   query   string  true       "自定义结束日期"
+//// @Param   Calendar   query   string  true       "公历/农历"
+//// @Param   SeasonStartDate   query   string  true       "季节性图开始日期"
+//// @Param   SeasonEndDate   query   string  true       "季节性图结束日期"
+//// @Param   EdbInfoId   query   string  true       "指标ID，多个用英文逗号隔开"
+//// @Param   ChartType   query   int  true       "生成样式:1:曲线图,2:季节性图"
+//// @Success 200 {object} data_manage.ChartInfoDetailResp
+//// @router /chart_info/detail [get]
+//func (this *LineEquationChartInfoController) Detail() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	chartInfoId, _ := this.GetInt("ChartInfoId")
+//	if chartInfoId <= 0 {
+//		br.Msg = "参数有误"
+//		return
+//	}
+//
+//	var err error
+//	chartInfo := new(data_manage.ChartInfoView)
+//	chartInfo, err = data_manage.GetChartInfoViewById(chartInfoId)
+//	if err != nil {
+//		if err.Error() == utils.ErrNoRow() {
+//			br.Msg = "图被删除，请刷新页面"
+//			br.ErrMsg = "图被删除，请刷新页面，Err:" + err.Error()
+//			return
+//		}
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	if chartInfo.ExtraConfig == `` {
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取配置信息失败，Err:" + err.Error()
+//		return
+//	}
+//	var lineChartInfoConfig request.LineChartInfoReq
+//	err = json.Unmarshal([]byte(chartInfo.ExtraConfig), &lineChartInfoConfig)
+//	if err != nil {
+//		br.Msg = "获取失败"
+//		br.ErrMsg = "获取图表配置信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	var getAData, getBData, getR2Data bool
+//	switch lineChartInfoConfig.Source {
+//	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
+//		getAData = true
+//	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
+//		getBData = true
+//	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
+//		getR2Data = true
+//	}
+//
+//	edbList, dataResp, err, errMsg := line_equation.GetChartEdbData(chartInfoId, lineChartInfoConfig, getAData, getBData, getR2Data)
+//	if err != nil {
+//		br.Msg = "获取失败"
+//		if errMsg != `` {
+//			br.Msg = errMsg
+//		}
+//		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	var resultResp interface{}
+//	switch lineChartInfoConfig.Source {
+//	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
+//		resultResp = dataResp.AData
+//	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
+//		resultResp = dataResp.BData
+//	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
+//		resultResp = dataResp.R2Data
+//	}
+//
+//	// 判断是否加入我的图库
+//	if chartInfoId > 0 && chartInfo != nil {
+//		{
+//			var myChartCondition string
+//			var myChartPars []interface{}
+//			myChartCondition += ` AND a.admin_id=? `
+//			myChartPars = append(myChartPars, sysUser.AdminId)
+//			myChartCondition += ` AND a.chart_info_id=? `
+//			myChartPars = append(myChartPars, chartInfo.ChartInfoId)
+//
+//			myChartList, err := data_manage.GetMyChartByCondition(myChartCondition, myChartPars)
+//			if err != nil && err.Error() != utils.ErrNoRow() {
+//				br.Msg = "获取失败"
+//				br.ErrMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
+//				return
+//			}
+//			if myChartList != nil && len(myChartList) > 0 {
+//				chartInfo.IsAdd = true
+//				chartInfo.MyChartId = myChartList[0].MyChartId
+//				chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
+//			}
+//		}
+//	}
+//
+//	//图表操作权限
+//	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
+//	//判断是否需要展示英文标识
+//	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, chartInfo.Source, chartInfo.ChartType)
+//	//chartInfo.UnitEn = edbInfoMappingA.UnitEn
+//
+//	// 另存为
+//	isSaveAs := true
+//	chartInfo.Button = data_manage.ChartViewButton{
+//		IsEdit:    chartInfo.IsEdit,
+//		IsEnChart: chartInfo.IsEnChart,
+//		IsAdd:     chartInfo.IsAdd,
+//		IsCopy:    isSaveAs,
+//		IsSetName: chartInfo.IsSetName,
+//	}
+//
+//	resp := new(data_manage.ChartInfoDetailResp)
+//	resp.ChartInfo = chartInfo
+//	resp.EdbInfoList = edbList
+//	resp.DataResp = resultResp
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "获取成功"
+//	br.Data = resp
+//}
+//
+//// DetailFromUniqueCode
+//// @Title 根据编码获取图表详情
+//// @Description 根据编码获取图表详情接口
+//// @Param   UniqueCode   query   int  true       "图表唯一编码,如果是管理后台访问，传固定字符串:7c69b590249049942070ae9dcd5bf6dc"
+//// @Param   IsCache   query   bool  true       "是否走缓存，默认false"
+//// @Success 200 {object} data_manage.ChartInfoDetailFromUniqueCodeResp
+//// @router /chart_info/detail/from_unique_code [get]
+//func (this *LineEquationChartInfoController) DetailFromUniqueCode() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	adminId := sysUser.AdminId
+//
+//	uniqueCode := this.GetString("UniqueCode")
+//	if uniqueCode == "" {
+//		br.Msg = "参数错误"
+//		br.ErrMsg = "参数错误,uniqueCode is empty"
+//		return
+//	}
+//
+//	//是否走缓存
+//	isCache, _ := this.GetBool("IsCache")
+//
+//	resp := new(data_manage.ChartInfoDetailFromUniqueCodeResp)
+//	status := true
+//	chartInfo, err := data_manage.GetChartInfoViewByUniqueCode(uniqueCode)
+//	if err != nil {
+//		if err.Error() == utils.ErrNoRow() {
+//			status = false
+//		} else {
+//			br.Msg = "获取失败"
+//			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+//			return
+//		}
+//	}
+//	if chartInfo == nil {
+//		status = false
+//	}
+//	if !status {
+//		endInfoList := make([]*data_manage.ChartEdbInfoMapping, 0)
+//		resp.EdbInfoList = endInfoList
+//		resp.ChartInfo = chartInfo
+//		resp.Status = false
+//		br.Ret = 200
+//		br.Success = true
+//		br.Msg = "获取成功"
+//		br.Data = resp
+//		return
+//	}
+//
+//	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
+//	key := data.GetChartInfoDataKey(chartInfo.ChartInfoId)
+//	if utils.Re == nil && isCache {
+//		if utils.Re == nil && utils.Rc.IsExist(key) {
+//			if d, e := utils.Rc.RedisBytes(key); e == nil {
+//				err := json.Unmarshal(d, &resp)
+//				if err == nil && resp != nil {
+//					// 这里跟当前用户相关的信息重新查询写入resp, 不使用缓存中的
+//					var myCond string
+//					var myPars []interface{}
+//					myCond += ` AND a.admin_id=? `
+//					myPars = append(myPars, adminId)
+//					myCond += ` AND a.chart_info_id=? `
+//					myPars = append(myPars, chartInfo.ChartInfoId)
+//					myList, err := data_manage.GetMyChartByCondition(myCond, myPars)
+//					if err != nil && err.Error() != utils.ErrNoRow() {
+//						br.Msg = "获取失败"
+//						br.ErrMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
+//						return
+//					}
+//					resp.ChartInfo.IsAdd = false
+//					resp.ChartInfo.MyChartId = 0
+//					resp.ChartInfo.MyChartClassifyId = ""
+//					if myList != nil && len(myList) > 0 {
+//						resp.ChartInfo.IsAdd = true
+//						resp.ChartInfo.MyChartId = myList[0].MyChartId
+//						resp.ChartInfo.MyChartClassifyId = myList[0].MyChartClassifyId
+//					}
+//
+//					br.Ret = 200
+//					br.Success = true
+//					br.Msg = "获取成功"
+//					br.Data = resp
+//					return
+//				}
+//			}
+//		}
+//	}
+//	resp, isOk, msg, errMsg := GetChartInfoDetailFromUniqueCode(chartInfo, isCache, sysUser)
+//	if !isOk {
+//		br.Msg = msg
+//		br.ErrMsg = errMsg
+//		return
+//	}
+//	if !isOk {
+//		br.Msg = msg
+//		br.ErrMsg = errMsg
+//		return
+//	}
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "获取成功"
+//	br.Data = resp
+//}
+//
+//// Refresh
+//// @Title 图表刷新接口
+//// @Description 图表刷新接口
+//// @Param   ChartInfoId   query   int  true       "图表id"
+//// @Param   UniqueCode   query   string  true       "唯一code"
+//// @Success Ret=200 刷新成功
+//// @router /chart_info/refresh [get]
+//func (this *LineEquationChartInfoController) Refresh() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	chartInfoId, _ := this.GetInt("ChartInfoId")
+//	uniqueCode := this.GetString("UniqueCode")
+//	if chartInfoId <= 0 && uniqueCode == `` {
+//		br.Msg = "参数错误"
+//		br.ErrMsg = "参数错误:chartInfoId:" + strconv.Itoa(chartInfoId) + ",UniqueCode:" + uniqueCode
+//		return
+//	}
+//
+//	var chartInfo *data_manage.ChartInfo
+//	var err error
+//	if chartInfoId > 0 {
+//		chartInfo, err = data_manage.GetChartInfoById(chartInfoId)
+//	} else {
+//		chartInfo, err = data_manage.GetChartInfoByUniqueCode(uniqueCode)
+//	}
+//	if err != nil {
+//		if err.Error() == utils.ErrNoRow() {
+//			br.Msg = "图表已被删除，无需刷新"
+//			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
+//			return
+//		}
+//		br.Msg = "刷新失败"
+//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	// 刷新图表的指标信息
+//	err = data.ChartInfoRefreshV2(chartInfo.ChartInfoId)
+//
+//	//清除图表缓存
+//	{
+//		key := utils.HZ_CHART_LIB_DETAIL + chartInfo.UniqueCode
+//		_ = utils.Rc.Delete(key)
+//	}
+//
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "刷新成功"
+//}
+//
+//// Copy
+//// @Title 复制并新增图表接口
+//// @Description 新增图表接口
+//// @Param	request	body data_manage.CopyAddChartInfoReq true "type json string"
+//// @Success 200 {object} data_manage.AddChartInfoResp
+//// @router /chart_info/copy [post]
+//func (this *LineEquationChartInfoController) Copy() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	deleteCache := true
+//	cacheKey := "CACHE_CHART_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
+//	defer func() {
+//		if deleteCache {
+//			utils.Rc.Delete(cacheKey)
+//		}
+//	}()
+//	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
+//		deleteCache = false
+//		br.Msg = "系统处理中，请稍后重试！"
+//		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
+//		return
+//	}
+//	var req data_manage.CopyAddChartInfoReq
+//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+//	if err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//
+//	// 获取原图表信息
+//	oldChartInfo, err := data_manage.GetChartInfoById(req.ChartInfoId)
+//	if err != nil {
+//		br.Msg = "获取原图表信息失败"
+//		br.ErrMsg = "获取原图表信息失败,Err:" + err.Error()
+//		return
+//	}
+//	if oldChartInfo.Source != utils.CHART_SOURCE_LINE_EQUATION {
+//		br.Msg = `错误的图表类型`
+//		br.IsSendEmail = false
+//		return
+//	}
+//
+//	var lineChartInfoConf request.LineChartInfoReq
+//	err = json.Unmarshal([]byte(oldChartInfo.ExtraConfig), &lineChartInfoConf)
+//	addChartList := make([]request.AddChart, 0)
+//	addChartList = append(addChartList, request.AddChart{
+//		Source:          lineChartInfoConf.Source,
+//		ChartClassifyId: req.ChartClassifyId,
+//		ChartName:       req.ChartName,
+//		LeftMin:         oldChartInfo.LeftMin,
+//		LeftMax:         oldChartInfo.LeftMax,
+//		ChartImage:      oldChartInfo.ChartImage,
+//	})
+//
+//	resp := new(data_manage.AddChartInfoResp)
+//	batchAddChartList, err, errMsg, isSendEmail := line_equation.BatchAddChartInfo(addChartList, lineChartInfoConf, sysUser)
+//	if err != nil {
+//		br.Msg = "保存失败"
+//		if errMsg != `` {
+//			br.Msg = errMsg
+//		}
+//		br.ErrMsg = err.Error()
+//		br.IsSendEmail = isSendEmail
+//		return
+//	}
+//
+//	resp.ChartInfoId = batchAddChartList[0].ChartInfo.ChartInfoId
+//	resp.UniqueCode = batchAddChartList[0].ChartInfo.UniqueCode
+//	resp.ChartType = batchAddChartList[0].ChartInfo.ChartType
+//	//新增操作日志
+//	{
+//		for _, v := range batchAddChartList {
+//			chartInfo := v.ChartInfo
+//			chartLog := new(data_manage.ChartInfoLog)
+//			chartLog.ChartInfoId = chartInfo.ChartInfoId
+//			chartLog.ChartName = chartInfo.ChartName
+//			chartLog.ChartClassifyId = chartInfo.ChartClassifyId
+//			chartLog.SysUserId = sysUser.AdminId
+//			chartLog.SysUserRealName = sysUser.RealName
+//			chartLog.UniqueCode = chartInfo.UniqueCode
+//			chartLog.CreateTime = time.Now()
+//			chartLog.Content = string(this.Ctx.Input.RequestBody)
+//			chartLog.Status = "新增拟合方程图表"
+//			chartLog.Method = this.Ctx.Input.URI()
+//			go data_manage.AddChartInfoLog(chartLog)
+//		}
+//	}
+//
+//	br.Ret = 200
+//	br.Data = resp
+//	br.Success = true
+//	br.Msg = "保存成功"
+//	br.IsAddLog = true
+//}
+
+// GetChartInfoDetailFromUniqueCode 根据编码获取图表详情
+func GetChartInfoDetailFromUniqueCode(chartInfo *data_manage.ChartInfoView, isCache bool, sysUser *system.Admin) (resp *data_manage.ChartInfoDetailFromUniqueCodeResp, isOk bool, msg, errMsg string) {
+	resp = new(data_manage.ChartInfoDetailFromUniqueCodeResp)
+
+	adminId := sysUser.AdminId
+
+	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
+	key := data.GetChartInfoDataKey(chartInfo.ChartInfoId)
+	if utils.Re == nil && isCache {
+		if utils.Re == nil && utils.Rc.IsExist(key) {
+			if chartData, err1 := utils.Rc.RedisBytes(key); err1 == nil {
+				err := json.Unmarshal(chartData, &resp)
+				if err == nil && resp != nil {
+					// 这里跟当前用户相关的信息重新查询写入resp, 不使用缓存中的
+					var myCond string
+					var myPars []interface{}
+					myCond += ` AND a.admin_id=? `
+					myPars = append(myPars, adminId)
+					myCond += ` AND a.chart_info_id=? `
+					myPars = append(myPars, chartInfo.ChartInfoId)
+					myList, err := data_manage.GetMyChartByCondition(myCond, myPars)
+					if err != nil && err.Error() != utils.ErrNoRow() {
+						msg = "获取失败"
+						errMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
+						return
+					}
+					resp.ChartInfo.IsAdd = false
+					resp.ChartInfo.MyChartId = 0
+					resp.ChartInfo.MyChartClassifyId = ""
+					if myList != nil && len(myList) > 0 {
+						resp.ChartInfo.IsAdd = true
+						resp.ChartInfo.MyChartId = myList[0].MyChartId
+						resp.ChartInfo.MyChartClassifyId = myList[0].MyChartClassifyId
+					}
+
+					isOk = true
+					fmt.Println("source redis")
+					return
+				}
+			}
+		}
+	}
+
+	if chartInfo.ExtraConfig == `` {
+		msg = "获取失败"
+		errMsg = "获取配置信息失败"
+		return
+	}
+	var lineChartInfoConfig request.LineChartInfoReq
+	err := json.Unmarshal([]byte(chartInfo.ExtraConfig), &lineChartInfoConfig)
+	if err != nil {
+		msg = "获取失败"
+		errMsg = "获取图表配置信息失败, Err:" + err.Error()
+		return
+	}
+
+	var getAData, getBData, getR2Data bool
+	switch lineChartInfoConfig.Source {
+	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
+		getAData = true
+	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
+		getBData = true
+	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
+		getR2Data = true
+	}
+
+	edbList, dataResp, err, errMsg := line_equation.GetChartEdbData(chartInfo.ChartInfoId, lineChartInfoConfig, getAData, getBData, getR2Data)
+	if err != nil {
+		if errMsg == `` {
+			errMsg = "获取失败"
+		}
+		return
+	}
+
+	var resultResp interface{}
+	switch lineChartInfoConfig.Source {
+	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
+		resultResp = dataResp.AData
+	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
+		resultResp = dataResp.BData
+	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
+		resultResp = dataResp.R2Data
+	}
+
+	if chartInfo.ChartInfoId > 0 && chartInfo != nil {
+		//判断是否加入我的图库
+		{
+			var myChartCondition string
+			var myChartPars []interface{}
+			myChartCondition += ` AND a.admin_id=? `
+			myChartPars = append(myChartPars, sysUser.AdminId)
+			myChartCondition += ` AND a.chart_info_id=? `
+			myChartPars = append(myChartPars, chartInfo.ChartInfoId)
+
+			myChartList, err := data_manage.GetMyChartByCondition(myChartCondition, myChartPars)
+			if err != nil && err.Error() != utils.ErrNoRow() {
+				msg = "获取失败"
+				errMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
+				return
+			}
+			if myChartList != nil && len(myChartList) > 0 {
+				chartInfo.IsAdd = true
+				chartInfo.MyChartId = myChartList[0].MyChartId
+				chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
+			}
+		}
+	}
+
+	//图表操作权限
+	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
+	//判断是否需要展示英文标识
+	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, chartInfo.Source, chartInfo.ChartType)
+	//chartInfo.UnitEn = edbInfoMappingA.UnitEn
+
+	isSaveAs := true
+	// 另存为
+	chartInfo.Button = data_manage.ChartViewButton{
+		IsEdit:    chartInfo.IsEdit,
+		IsEnChart: chartInfo.IsEnChart,
+		IsAdd:     chartInfo.IsAdd,
+		IsCopy:    isSaveAs,
+		IsSetName: chartInfo.IsSetName,
+	}
+
+	resp.ChartInfo = chartInfo
+	resp.EdbInfoList = edbList
+	resp.DataResp = resultResp
+	resp.Status = true
+
+	// 将数据加入缓存
+	if utils.Re == nil {
+		d, _ := json.Marshal(resp)
+		_ = utils.Rc.Put(key, d, 2*time.Hour)
+	}
+	isOk = true
+	return
+}
+
+//// EnInfoEdit
+//// @Title 编辑图表英文信息接口
+//// @Description 编辑图表英文信息接口
+//// @Param	request	body data_manage.EditChartEnInfoReq true "type json string"
+//// @Success Ret=200 编辑成功
+//// @router /chart_info/en/edit [post]
+//func (this *LineEquationChartInfoController) EnInfoEdit() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	var req request.EditChartEnInfoReq
+//	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+//	if err != nil {
+//		br.Msg = "参数解析异常！"
+//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+//		return
+//	}
+//	req.ChartNameEn = strings.Trim(req.ChartNameEn, " ")
+//	if req.ChartInfoId <= 0 {
+//		br.Msg = "请选择图表"
+//		return
+//	}
+//	if req.ChartNameEn == "" {
+//		br.Msg = "请输入英文图表名称"
+//		return
+//	}
+//
+//	//判断指标名称是否存在
+//	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
+//	if err != nil {
+//		if err.Error() == utils.ErrNoRow() {
+//			br.Msg = "图表已被删除，请刷新页面"
+//			br.ErrMsg = "图表已被删除，请刷新页面"
+//			return
+//		}
+//		br.Msg = "获取图表信息失败"
+//		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
+//		return
+//	}
+//
+//	// 校验名称是否有重复
+//	{
+//		var condition string
+//		var pars []interface{}
+//		condition += " AND chart_info_id <> ?  AND chart_name_en = ? AND source = ?"
+//		pars = append(pars, req.ChartInfoId, req.ChartNameEn, utils.CHART_SOURCE_LINE_EQUATION)
+//		existItem, err := data_manage.GetChartInfoByCondition(condition, pars)
+//		if err != nil {
+//			if err.Error() != utils.ErrNoRow() {
+//				br.Msg = "判断英文图表名称是否存在失败"
+//				br.ErrMsg = "判断英文图表名称是否存在失败,Err:" + err.Error()
+//				return
+//			}
+//		}
+//		if err == nil && existItem.ChartInfoId > 0 {
+//			br.Msg = existItem.ChartName + "：" + req.ChartNameEn + "图表名称已存在"
+//			return
+//		}
+//	}
+//
+//	chartItem.ChartNameEn = req.ChartNameEn
+//	chartItem.ModifyTime = time.Now().Local()
+//	if e := chartItem.Update([]string{"ChartNameEn", "ModifyTime"}); e != nil {
+//		br.Msg = "操作失败"
+//		br.ErrMsg = "更新图表信息失败, Err: " + e.Error()
+//		return
+//	}
+//
+//	//添加es数据
+//	go data.EsAddOrEditChartInfo(chartItem.ChartInfoId)
+//	//修改my eta es数据
+//	go data.EsAddOrEditMyChartInfoByChartInfoId(chartItem.ChartInfoId)
+//
+//	//指标 修改es信息
+//	//go data.AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)
+//
+//	//新增操作日志
+//	{
+//		chartLog := new(data_manage.ChartInfoLog)
+//		chartLog.ChartName = chartItem.ChartName
+//		chartLog.ChartInfoId = req.ChartInfoId
+//		chartLog.ChartClassifyId = chartItem.ChartClassifyId
+//		chartLog.SysUserId = sysUser.AdminId
+//		chartLog.SysUserRealName = sysUser.RealName
+//		chartLog.UniqueCode = chartItem.UniqueCode
+//		chartLog.CreateTime = time.Now()
+//		chartLog.Content = string(this.Ctx.Input.RequestBody)
+//		chartLog.Status = "编辑拟合方程图表英文信息"
+//		chartLog.Method = this.Ctx.Input.URL()
+//		go data_manage.AddChartInfoLog(chartLog)
+//	}
+//	// 清除缓存
+//	if utils.Re == nil && utils.Rc != nil {
+//		_ = utils.Rc.Delete(utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode) //图表分享链接缓存
+//		_ = utils.Rc.Delete(data.GetChartInfoDataKey(req.ChartInfoId))
+//	}
+//
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "编辑成功"
+//	br.IsAddLog = true
+//}
+//
+//// SearchByEs
+//// @Title 图表模糊搜索（从es获取）
+//// @Description  图表模糊搜索（从es获取）
+//// @Param   Keyword   query   string  true       "图表名称"
+//// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
+//// @Param   Source   query   int  true       "来源，3：拟合方程，4：滚动拟合方程，默认0：全部"
+//// @Success 200 {object} data_manage.ChartInfo
+//// @router /chart_info/search_by_es [get]
+//func (this *LineEquationChartInfoController) SearchByEs() {
+//	br := new(models.BaseResponse).Init()
+//	defer func() {
+//		this.Data["json"] = br
+//		this.ServeJSON()
+//	}()
+//
+//	sysUser := this.SysUser
+//	if sysUser == nil {
+//		br.Msg = "请登录"
+//		br.ErrMsg = "请登录，SysUser Is Empty"
+//		br.Ret = 408
+//		return
+//	}
+//	pageSize, _ := this.GetInt("PageSize")
+//	currentIndex, _ := this.GetInt("CurrentIndex")
+//
+//	var startSize int
+//	if pageSize <= 0 {
+//		pageSize = utils.PageSize20
+//	}
+//	if currentIndex <= 0 {
+//		currentIndex = 1
+//	}
+//	startSize = paging.StartIndex(currentIndex, pageSize)
+//
+//	keyword := this.GetString("Keyword")
+//
+//	//只看我的
+//	isShowMe, _ := this.GetBool("IsShowMe")
+//	showSysId := 0
+//	if isShowMe {
+//		showSysId = sysUser.AdminId
+//	}
+//
+//	sourceList := []int{utils.CHART_SOURCE_LINE_EQUATION}
+//
+//	var searchList []*data_manage.ChartInfo
+//	var total int64
+//	var err error
+//
+//	// 获取当前账号的不可见指标
+//	noPermissionChartIdList := make([]int, 0)
+//	{
+//		obj := data_manage.EdbInfoNoPermissionAdmin{}
+//		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "获取失败"
+//			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
+//			return
+//		}
+//		for _, v := range confList {
+//			noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
+//		}
+//	}
+//
+//	if keyword != "" {
+//		searchList, total, err = data.EsSearchChartInfo(keyword, showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
+//	} else {
+//		total, searchList, err = data_manage.ChartInfoSearchByEmptyKeyWord(showSysId, sourceList, noPermissionChartIdList)
+//		if err != nil && err.Error() != utils.ErrNoRow() {
+//			br.Msg = "获取失败"
+//			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
+//			return
+//		}
+//	}
+//
+//	finalList := make([]*data_manage.ChartInfoMore, 0)
+//	if len(searchList) > 0 {
+//		chartInfoIds := ""
+//		chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
+//		for _, v := range searchList {
+//			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
+//		}
+//		if chartInfoIds != "" {
+//			chartInfoIds = strings.Trim(chartInfoIds, ",")
+//			//判断是否需要展示英文标识
+//			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
+//			if e != nil {
+//				br.Msg = "获取失败"
+//				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
+//				return
+//			}
+//			for _, v := range edbList {
+//				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
+//			}
+//		}
+//
+//		for _, v := range searchList {
+//			tmp := new(data_manage.ChartInfoMore)
+//			tmp.ChartInfo = *v
+//			//判断是否需要展示英文标识
+//			if _, ok := chartEdbMap[v.ChartInfoId]; ok {
+//				tmp.IsEnChart = data.CheckIsEnChart(v.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, v.Source, v.ChartType)
+//			}
+//			finalList = append(finalList, tmp)
+//		}
+//	}
+//	//新增搜索词记录
+//	{
+//		searchKeyword := new(data_manage.SearchKeyword)
+//		searchKeyword.KeyWord = keyword
+//		searchKeyword.CreateTime = time.Now()
+//		go data_manage.AddSearchKeyword(searchKeyword)
+//	}
+//
+//	page := paging.GetPaging(currentIndex, pageSize, int(total))
+//	resp := data_manage.ChartInfoListByEsResp{
+//		Paging: page,
+//		List:   finalList,
+//	}
+//	br.Ret = 200
+//	br.Success = true
+//	br.Msg = "获取成功"
+//	br.Data = resp
+//}
+
 // SearchByEs
 // @Title 图表模糊搜索（从es获取）
 // @Description  图表模糊搜索（从es获取）

controllers/data_manage/my_chart.go

@@ -1810,3 +1810,166 @@ func generateMyChartClassifyName(myChartClassifyName string, count int, chartCla
 	}
 	return
 }
+
+// Locate
+// @Title ETA图表位置
+// @Description ETA图表位置
+// @Param   PageSize   query   int  true       "每页数据条数"
+// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
+// @Param   ChartClassifyId   query   int  true       "分类id"
+// @Param   KeyWord   query   string  true       "搜索关键词"
+// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
+// @Success 200 {object} data_manage.ChartListResp
+// @router /chart/locate [get]
+func (this *MyChartController) Locate() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		if br.ErrMsg == "" {
+			br.IsSendEmail = false
+		}
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	classifyId, _ := this.GetInt("ChartClassifyId")
+	keyword := this.GetString("KeyWord")
+	mine, _ := this.GetBool("IsShowMe") // 只看我的
+
+	condition := ` AND source = ?`
+	pars := make([]interface{}, 0)
+	pars = append(pars, utils.CHART_SOURCE_DEFAULT) // 普通图表
+	orderRule := ``
+	{
+		if keyword != "" {
+			k := fmt.Sprint("%", keyword, "%")
+			condition += ` AND chart_name LIKE ?`
+			pars = append(pars, k)
+		}
+		if mine {
+			condition += ` AND sys_user_id = ?`
+			pars = append(pars, sysUser.AdminId)
+		}
+		if classifyId > 0 {
+			strIds, e := data_manage.GetChartClassify(classifyId)
+			if e != nil {
+				br.Msg = "获取失败"
+				br.ErrMsg = "获取图表分类信息失败, GetChartClassify Err: " + e.Error()
+				return
+			}
+			if strIds == "" {
+				br.Msg = "获取失败"
+				br.ErrMsg = "图表分类为空"
+				return
+			}
+			condition += fmt.Sprintf(` AND chart_classify_id IN (%s)`, strIds)
+		}
+	}
+
+	// 当前账号的不可见指标
+	{
+		ids := make([]int, 0)
+		obj := data_manage.EdbInfoNoPermissionAdmin{}
+		conf, e := obj.GetAllChartListByAdminId(sysUser.AdminId)
+		if e != nil && e.Error() != utils.ErrNoRow() {
+			br.Msg = "获取失败"
+			br.ErrMsg = "获取不可见指标配置失败, Err: " + e.Error()
+			return
+		}
+		for _, v := range conf {
+			ids = append(ids, v.ChartInfoId)
+		}
+		if len(ids) > 0 {
+			condition += fmt.Sprintf(` AND chart_info_id NOT IN (%s)`, utils.GetOrmInReplace(len(ids)))
+			pars = append(pars, ids)
+		}
+	}
+
+	// 获取图表
+	list := make([]*data_manage.ChartInfoLocate, 0)
+	charts, e := data_manage.GetChartItems(condition, pars, orderRule)
+	if e != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取图表列表失败, Err: " + e.Error()
+		return
+	}
+	if len(charts) == 0 {
+		br.Ret = 200
+		br.Success = true
+		br.Msg = "获取成功"
+		br.Data = list
+		return
+	}
+
+	// 二级分类
+	classifies, e := data_manage.GetSecondaryChartClassifyWithSort()
+	if e != nil {
+		br.Msg = "获取失败"
+		br.ErrMsg = "获取图表分类排序失败, Err: " + e.Error()
+		return
+	}
+	classifyIdName := make(map[int]string)
+	for _, c := range classifies {
+		classifyIdName[c.ChartClassifyId] = c.ChartClassifyName
+	}
+
+	// 分类ID大于0时, 优先分类排序, 其次图表排序
+	if classifyId > 0 {
+		for _, cl := range classifies {
+			for _, ch := range charts {
+				if ch.ChartClassifyId != cl.ChartClassifyId {
+					continue
+				}
+				v := new(data_manage.ChartInfoLocate)
+				v.ChartInfoId = ch.ChartInfoId
+				v.ChartName = ch.ChartName
+				v.ChartType = ch.ChartType
+				v.ChartClassifyId = ch.ChartClassifyId
+				v.ChartClassifyName = cl.ChartClassifyName
+				v.UniqueCode = ch.UniqueCode
+				v.Source = ch.Source
+				v.StartDate = ch.StartDate
+				v.EndDate = ch.EndDate
+				v.SeasonStartDate = ch.SeasonStartDate
+				v.SeasonEndDate = ch.SeasonEndDate
+				v.DateType = ch.DateType
+				v.Calendar = ch.Calendar
+				list = append(list, v)
+			}
+		}
+		br.Ret = 200
+		br.Success = true
+		br.Msg = "获取成功"
+		br.Data = list
+		return
+	}
+
+	// 分类ID为0时
+	for _, ch := range charts {
+		v := new(data_manage.ChartInfoLocate)
+		v.ChartInfoId = ch.ChartInfoId
+		v.ChartName = ch.ChartName
+		v.ChartType = ch.ChartType
+		v.ChartClassifyId = ch.ChartClassifyId
+		v.ChartClassifyName = classifyIdName[v.ChartClassifyId]
+		v.UniqueCode = ch.UniqueCode
+		v.Source = ch.Source
+		v.StartDate = ch.StartDate
+		v.EndDate = ch.EndDate
+		v.SeasonStartDate = ch.SeasonStartDate
+		v.SeasonEndDate = ch.SeasonEndDate
+		v.DateType = ch.DateType
+		v.Calendar = ch.Calendar
+		list = append(list, v)
+	}
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "获取成功"
+	br.Data = list
+}

controllers/sys_admin.go

@@ -0,0 +1,89 @@
+package controllers
+
+import (
+	"encoding/json"
+	"hongze/hongze_ETA_mobile_api/models"
+	"hongze/hongze_ETA_mobile_api/models/system"
+	"hongze/hongze_ETA_mobile_api/utils"
+	"time"
+)
+
+// 系统用户
+type SysAdminController struct {
+	BaseAuthController
+}
+
+// SetConfig
+// @Title 用户信息配置接口
+// @Description 用户信息配置接口
+// @Success 200 {object} system.SetAdminConfigReq
+// @router /sysuser/config/set [post]
+func (this *SysAdminController) SetConfig() {
+	br := new(models.BaseResponse).Init()
+	defer func() {
+		this.Data["json"] = br
+		this.ServeJSON()
+	}()
+
+	sysUser := this.SysUser
+	if sysUser == nil {
+		br.Msg = "请登录"
+		br.ErrMsg = "请登录，SysUser Is Empty"
+		br.Ret = 408
+		return
+	}
+
+	var req system.SetAdminConfigReq
+	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
+	if err != nil {
+		br.Msg = "参数解析异常！"
+		br.ErrMsg = "参数解析失败，Err:" + err.Error()
+		return
+	}
+
+	item, err := system.GetConfigDetailByCode(this.SysUser.AdminId, req.ConfigCode)
+	if err != nil {
+		if err.Error() != utils.ErrNoRow() {
+			br.Msg = "设置失败"
+			br.ErrMsg = "设置失败，Err:" + err.Error()
+			return
+		}
+
+		// 获取默认配置
+		defaultConfig, err := system.GetDefaultConfigDetailByCode(req.ConfigCode)
+		if err != nil {
+			br.Msg = "设置失败"
+			br.ErrMsg = "获取默认配置失败，Err:" + err.Error()
+			return
+		}
+		adminConfigItem := &system.AdminConfig{
+			//ConfigId:    0,
+			AdminId:     this.SysUser.AdminId,
+			ConfigCode:  req.ConfigCode,
+			ConfigValue: req.ConfigValue,
+			Remark:      defaultConfig.Remark,
+			CreateTime:  time.Now(),
+		}
+		err = adminConfigItem.Create()
+
+		if err != nil {
+			br.Msg = "设置失败"
+			br.ErrMsg = "设置失败，Err:" + err.Error()
+			return
+		}
+	} else {
+		// 存在配置，那么就修改
+		item.ConfigValue = req.ConfigValue
+		err = item.Update([]string{"ConfigValue"})
+
+		if err != nil {
+			br.Msg = "设置失败"
+			br.ErrMsg = "设置失败，Err:" + err.Error()
+			return
+		}
+	}
+
+	br.Ret = 200
+	br.Success = true
+	br.Msg = "设置成功"
+}

models/data_manage/chart_classify.go

@@ -254,4 +254,17 @@ func GetChartClassifyAllFromETA() (items []*ChartClassifyItems, err error) {
 	sql := ` SELECT * FROM chart_classify WHERE parent_id<>0 AND source = 1 order by sort asc,chart_classify_id asc`
 	_, err = o.Raw(sql).QueryRows(&items)
 	return
-}
+}
+
+// GetSecondaryChartClassifyWithSort 获取二级分类-根据父级分类排序
+func GetSecondaryChartClassifyWithSort() (items []*ChartClassify, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := `SELECT * FROM chart_classify AS a
+			LEFT JOIN (
+				SELECT chart_classify_id AS parent_classify_id, sort AS parent_sort FROM chart_classify WHERE parent_id = 0 AND source = 1
+			) AS b ON a.parent_id = b.parent_classify_id
+			WHERE parent_id > 0 AND source = 1
+			ORDER BY b.parent_sort, a.sort`
+	_, err = o.Raw(sql).QueryRows(&items)
+	return
+}

models/data_manage/chart_edb_mapping.go

@@ -36,7 +36,7 @@ func AddChartEdbMapping(items []*ChartEdbMapping) (err error) {
 
 func GetChartEdbMappingList(chartInfoId int) (list []*ChartEdbInfoMapping, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT a.*,b.source_name,b.source,b.classify_id,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type
+	sql := ` SELECT a.*,b.source_name,b.source,b.classify_id,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type,b.edb_type
              FROM chart_edb_mapping AS a
 			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
 			 WHERE chart_info_id=? 
@@ -47,7 +47,7 @@ func GetChartEdbMappingList(chartInfoId int) (list []*ChartEdbInfoMapping, err e
 
 func GetChartEdbMappingListByChartInfoIds(chartInfoIds string) (list []*ChartEdbInfoMapping, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type
+	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type,b.edb_type
              FROM chart_edb_mapping AS a
 			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
 			 WHERE chart_info_id in (` + chartInfoIds + `) 
@@ -58,7 +58,7 @@ func GetChartEdbMappingListByChartInfoIds(chartInfoIds string) (list []*ChartEdb
 
 func GetChartEdbMappingListByEdbInfoId(edbInfoStr string) (list []*ChartEdbInfoMapping, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT edb_info_id,source_name,source,edb_code,edb_name,edb_name_en,frequency,unit,unit_en,start_date,end_date,modify_time,latest_date,latest_value,unique_code,edb_info_type AS edb_info_category_type,max_value,min_value
+	sql := ` SELECT edb_info_id,source_name,source,edb_code,edb_name,edb_name_en,frequency,unit,unit_en,start_date,end_date,modify_time,latest_date,latest_value,unique_code,edb_info_type AS edb_info_category_type,max_value,min_value,edb_type
              FROM edb_info
 			 WHERE edb_info_id IN(` + edbInfoStr + `)
 			ORDER BY FIELD(edb_info_id,` + edbInfoStr + `)
@@ -74,7 +74,7 @@ func GetChartEdbMappingListByEdbInfoIdList(edbIdList []int) (list []*ChartEdbInf
 		return
 	}
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT edb_info_id,source_name,source,edb_code,edb_name,edb_name_en,frequency,unit,unit_en,start_date,end_date,modify_time,latest_date,latest_value,unique_code,edb_info_type AS edb_info_category_type,max_value,min_value
+	sql := ` SELECT edb_info_id,source_name,source,edb_code,edb_name,edb_name_en,frequency,unit,unit_en,start_date,end_date,modify_time,latest_date,latest_value,unique_code,edb_info_type AS edb_info_category_type,max_value,min_value,edb_type
              FROM edb_info
 			 WHERE edb_info_id IN(` + utils.GetOrmInReplace(num) + `)
 			ORDER BY FIELD(edb_info_id,` + utils.GetOrmInReplace(num) + `)
@@ -90,7 +90,7 @@ func GetChartEdbMappingListByIdList(chartInfoIdList []int) (list []*ChartEdbInfo
 		return
 	}
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type
+	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type,b.edb_type AS edb_info_category_type
              FROM chart_edb_mapping AS a
 			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
 			 WHERE chart_info_id in (` + utils.GetOrmInReplace(num) + `) 
@@ -192,7 +192,7 @@ func GetChartEdbMappingByEdbInfoId(edbInfoId int) (item *ChartEdbInfoMapping, er
 // GetChartEdbMappingByFutureGoodEdbInfoId 根据指标id获取edb_mapping
 func GetChartEdbMappingByFutureGoodEdbInfoId(edbInfoId int) (item *ChartEdbInfoMapping, err error) {
 	o := orm.NewOrmUsingDB("data")
-	sql := ` SELECT future_good_edb_info_id as edb_info_id,future_good_edb_code as edb_code,b.future_good_edb_name as edb_name,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value
+	sql := ` SELECT future_good_edb_info_id as edb_info_id,future_good_edb_code as edb_code,b.future_good_edb_name as edb_name,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.region_type
              FROM future_good_edb_info b
 			 WHERE future_good_edb_info_id = ?  limit 1 `
 	err = o.Raw(sql, edbInfoId).QueryRow(&item)

models/data_manage/chart_info.go

@@ -1689,3 +1689,20 @@ type RollingCorrelationChartDataResp struct {
 	XDateTimeValue []string `description:"滚动相关性图的x轴数据，日期数据"`
 	YDataList      []YData  `description:"滚动相关性图的y轴数据"`
 }
+
+// ChartInfoLocate 图表位置响应体
+type ChartInfoLocate struct {
+	ChartInfoId       int    `description:"图表ID"`
+	ChartName         string `description:"图表名称"`
+	ChartType         int    `description:"图表类型"`
+	ChartClassifyId   int    `description:"图表分类id"`
+	ChartClassifyName string `description:"图表分类名称"`
+	UniqueCode        string `description:"图表唯一编码"`
+	Source            int    `description:"1：ETA图库；2：商品价格曲线；3：相关性图表"`
+	StartDate         string `description:""`
+	EndDate           string `description:""`
+	SeasonStartDate   string `description:""`
+	SeasonEndDate     string `description:""`
+	DateType          int    `description:""`
+	Calendar          string `description:""`
+}

models/data_manage/edb_info.go

@@ -1146,3 +1146,12 @@ func GetEdbInfoAndClassifyListByEdbIdList(edbIdList []int) (items []*EdbAndClass
 
 	return
 }
+
+// TraceEdbInfoResp 指标追溯数据返回
+type TraceEdbInfoResp struct {
+	//EdbInfo   *EdbInfo
+	EdbInfoId int                `description:"指标id"`
+	EdbName   string             `description:"指标名称"`
+	RuleTitle string             `description:"指标规则"`
+	Child     []TraceEdbInfoResp `description:"下级来源"`
+}

models/data_manage/edb_info_calculate_mapping.go

@@ -5,7 +5,7 @@ import (
 	"time"
 )
 
-//Seal 计算指标于基础指标，关系表
+// Seal 计算指标于基础指标，关系表
 type EdbInfoCalculateMapping struct {
 	EdbInfoCalculateMappingId int       `orm:"column(edb_info_calculate_mapping_id);pk"`
 	EdbInfoId                 int       `description:"计算指标id"`
@@ -66,3 +66,33 @@ func GetEdbInfoCalculateMappingDetail(edbInfoId int) (item *EdbInfoCalculateMapp
 	err = o.Raw(sql, edbInfoId).QueryRow(&item)
 	return
 }
+
+// EdbInfoCalculateMappingInfo
+type EdbInfoCalculateMappingInfo struct {
+	EdbInfoCalculateMappingId int       `orm:"column(edb_info_calculate_mapping_id);pk"`
+	EdbInfoId                 int       `description:"计算指标id"`
+	Source                    int       `description:"计算指标来源"`
+	SourceName                string    `description:"计算指标来源名称"`
+	EdbCode                   string    `description:"计算指标编码"`
+	FromEdbInfoId             int       `description:"基础指标id"`
+	FromEdbCode               string    `description:"基础指标编码"`
+	FromEdbName               string    `description:"基础指标名称"`
+	FromSource                int       `description:"基础指标来源"`
+	FromSourceName            string    `description:"基础指标来源名称"`
+	MoveValue                 int       `description:"领先值"`
+	FromTag                   string    `description:"来源指标标签"`
+	Sort                      int       `description:"计算指标名称排序"`
+	CreateTime                time.Time `description:"创建时间"`
+	ModifyTime                time.Time `description:"修改时间"`
+	EdbType                   int       `description:"指标类型:1:基础指标,2:计算指标"`
+}
+
+// GetEdbInfoCalculateMappingListByEdbInfoId 根据生成的指标id获取来源的指标id列表
+func GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId int) (items []*EdbInfoCalculateMappingInfo, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := ` SELECT a.*,b.edb_type FROM edb_info_calculate_mapping AS a
+			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
+			WHERE a.edb_info_id=? `
+	_, err = o.Raw(sql, edbInfoId).QueryRows(&items)
+	return
+}

models/data_manage/handle_data.go

@@ -0,0 +1,48 @@
+package data_manage
+
+import (
+	"hongze/hongze_ETA_mobile_api/utils"
+	"time"
+)
+
+// HandleDataByPreviousData 当前日期无值时,用上一个日期的数据补充当前日期的数据
+func HandleDataByPreviousData(edbInfoDataList []*EdbDataList, handleDataMap map[string]float64) (err error) {
+	if len(edbInfoDataList) < 2 {
+		return
+	}
+
+	var startEdbInfoData *EdbDataList
+	for _, v := range edbInfoDataList {
+		handleDataMap[v.DataTime] = v.Value
+
+		// 第一个数据就给过滤了,给后面的试用
+		if startEdbInfoData == nil {
+			startEdbInfoData = v
+			continue
+		}
+
+		// 获取两条数据之间相差的天数
+		startDataTime, _ := time.ParseInLocation(utils.FormatDate, startEdbInfoData.DataTime, time.Local)
+		currDataTime, _ := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
+		betweenHour := int(currDataTime.Sub(startDataTime).Hours())
+		betweenDay := betweenHour / 24
+
+		// 如果相差一天,那么过滤
+		if betweenDay <= 1 {
+			startEdbInfoData = v
+			continue
+		}
+
+		// 生成对应的值
+		{
+			for i := 1; i < betweenDay; i++ {
+				tmpDataTime := startDataTime.AddDate(0, 0, i)
+				handleDataMap[tmpDataTime.Format(utils.FormatDate)] = startEdbInfoData.Value
+			}
+		}
+
+		startEdbInfoData = v
+	}
+
+	return
+}

models/data_manage/line_equation/line_equation.go

@@ -0,0 +1,167 @@
+package line_equation
+
+import (
+	"github.com/beego/beego/v2/client/orm"
+	"hongze/hongze_ETA_mobile_api/models/data_manage"
+)
+
+type BatchAddChart struct {
+	ChartInfo                       *data_manage.ChartInfo
+	EdbMappingList                  []*data_manage.ChartEdbMapping
+	MultipleGraphConfigChartMapping *data_manage.MultipleGraphConfigChartMapping
+}
+
+// CreateLineEquationChartAndEdb 批量新增拟合方程图表
+func CreateLineEquationChartAndEdb(multipleGraphConfig *data_manage.MultipleGraphConfig, batchAddChartList []BatchAddChart) (err error) {
+	o := orm.NewOrmUsingDB("data")
+	tx, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = tx.Rollback()
+		} else {
+			_ = tx.Commit()
+		}
+	}()
+	// 新增批量配置
+	newMultipleGraphConfigId, err := tx.Insert(multipleGraphConfig)
+	if err != nil {
+		return
+	}
+	multipleGraphConfig.MultipleGraphConfigId = int(newMultipleGraphConfigId)
+
+	for k, v := range batchAddChartList {
+		// 新增图表信息
+		chartInfo := v.ChartInfo
+		newId, tmpErr := tx.Insert(chartInfo)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		chartInfo.ChartInfoId = int(newId)
+		batchAddChartList[k].ChartInfo = chartInfo
+
+		// 指标mapping
+		edbMappingList := v.EdbMappingList
+		if len(edbMappingList) > 0 {
+			for i := range edbMappingList {
+				edbMappingList[i].ChartInfoId = chartInfo.ChartInfoId
+			}
+			_, err = tx.InsertMulti(len(edbMappingList), edbMappingList)
+			if err != nil {
+				return
+			}
+		}
+		batchAddChartList[k].EdbMappingList = edbMappingList
+
+		// 批量配置的关系表
+		multipleGraphConfigChartMapping := v.MultipleGraphConfigChartMapping
+		multipleGraphConfigChartMapping.ChartInfoId = chartInfo.ChartInfoId
+		multipleGraphConfigChartMapping.MultipleGraphConfigId = multipleGraphConfig.MultipleGraphConfigId
+		newMultipleGraphConfigChartMappingId, tmpErr := tx.Insert(v.MultipleGraphConfigChartMapping)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		multipleGraphConfigChartMapping.Id = int(newMultipleGraphConfigChartMappingId)
+	}
+
+	return
+}
+
+// CreateAndEditLineEquationChartAndEdb 批量新增/编辑拟合方程图表
+func CreateAndEditLineEquationChartAndEdb(multipleGraphConfig *data_manage.MultipleGraphConfig, batchAddChartList []BatchAddChart, updateMultipleGraphConfigCols, updateChartCols []string) (err error) {
+	o := orm.NewOrmUsingDB("data")
+	tx, err := o.Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = tx.Rollback()
+		} else {
+			_ = tx.Commit()
+		}
+	}()
+	// 编辑批量配置
+	_, err = tx.Update(multipleGraphConfig, updateMultipleGraphConfigCols...)
+	if err != nil {
+		return
+	}
+
+	for k, v := range batchAddChartList {
+		// 新增图表信息
+		chartInfo := v.ChartInfo
+		var isDelMapping bool
+		{
+			if chartInfo.ChartInfoId <= 0 {
+				newId, tmpErr := tx.Insert(chartInfo)
+				if tmpErr != nil {
+					err = tmpErr
+					return
+				}
+				chartInfo.ChartInfoId = int(newId)
+				batchAddChartList[k].ChartInfo = chartInfo
+			} else {
+				// 更改图表信息
+				_, err = tx.Update(chartInfo, updateChartCols...)
+				if err != nil {
+					return
+				}
+				isDelMapping = true
+			}
+		}
+
+		// 图表与指标的关系表
+		{
+			// 先删除图表关联的指标关系，然后再新增
+			if isDelMapping {
+				sql := ` DELETE FROM  chart_edb_mapping WHERE chart_info_id=? `
+				_, err = tx.Raw(sql, chartInfo.ChartInfoId).Exec()
+				if err != nil {
+					return
+				}
+			}
+			// 指标mapping
+			edbMappingList := v.EdbMappingList
+			if len(edbMappingList) > 0 {
+				for i := range edbMappingList {
+					edbMappingList[i].ChartInfoId = chartInfo.ChartInfoId
+				}
+				_, err = tx.InsertMulti(len(edbMappingList), edbMappingList)
+				if err != nil {
+					return
+				}
+			}
+			batchAddChartList[k].EdbMappingList = edbMappingList
+		}
+
+		// 批量配置的关系表
+		{
+			multipleGraphConfigChartMapping := v.MultipleGraphConfigChartMapping
+			if multipleGraphConfigChartMapping.Id <= 0 {
+				multipleGraphConfigChartMapping.ChartInfoId = chartInfo.ChartInfoId
+				multipleGraphConfigChartMapping.MultipleGraphConfigId = multipleGraphConfig.MultipleGraphConfigId
+				newMultipleGraphConfigChartMappingId, tmpErr := tx.Insert(v.MultipleGraphConfigChartMapping)
+				if tmpErr != nil {
+					err = tmpErr
+					return
+				}
+				multipleGraphConfigChartMapping.Id = int(newMultipleGraphConfigChartMappingId)
+			} else {
+				if multipleGraphConfigChartMapping.ChartInfoId != chartInfo.ChartInfoId {
+					multipleGraphConfigChartMapping.ChartInfoId = chartInfo.ChartInfoId
+					_, err = tx.Update(multipleGraphConfigChartMapping, "ChartInfoId")
+					if err != nil {
+						return
+					}
+				}
+			}
+			batchAddChartList[k].MultipleGraphConfigChartMapping = multipleGraphConfigChartMapping
+		}
+	}
+
+	return
+}

models/data_manage/line_equation/request/line_equation.go

@@ -0,0 +1,32 @@
+package request
+
+// LineChartInfoReq 线性拟合图表预览请求数据
+type LineChartInfoReq struct {
+	DateType       int    `description:"日期类型"`
+	StartDate      string `description:"开始日期"`
+	EndDate        string `description:"结束日期"`
+	XEdbInfoIdList []int  `description:"X轴的指标id列表"`
+	YEdbInfoIdList []int  `description:"Y轴的指标id列表"`
+	Source         int    `description:"来源，5：斜率图；6：截距图；7：相关性图"`
+}
+
+type AddChartInfoReq struct {
+	MultipleGraphConfigId int              `description:"统一配置id,有的话就是编辑，没有则是新增"`
+	BatchAddChart         []AddChart       `description:"批量创建图的信息"`
+	ExtraConfig           LineChartInfoReq `description:"图表额外配置信息"`
+}
+
+type AddChart struct {
+	Source          int    `description:"来源，5：斜率图；6：截距图；7：相关性图"`
+	ChartClassifyId int    `description:"分类id"`
+	ChartName       string `description:"图表名称"`
+	LeftMin         string `description:"图表左侧最小值"`
+	LeftMax         string `description:"图表左侧最大值"`
+	ChartImage      string `description:"图表截图，复制的时候才用到" json:"-"`
+}
+
+// EditChartEnInfoReq 编辑图表英文信息
+type EditChartEnInfoReq struct {
+	ChartInfoId int    `description:"图表ID"`
+	ChartNameEn string `description:"英文图表名称"`
+}

models/data_manage/line_equation/response/line_equation.go

@@ -0,0 +1,39 @@
+package response
+
+import (
+	"hongze/hongze_ETA_mobile_api/models/data_manage"
+	"hongze/hongze_ETA_mobile_api/models/data_manage/line_equation/request"
+)
+
+type ChartInfoResp struct {
+	List []ChartDataResp `description:"数据列表"`
+}
+
+// ChartDataResp 图表数据
+type ChartDataResp struct {
+	LatestDate          string  `description:"真实数据的日期"`
+	Name                string  `description:"名称"`
+	NameEn              string  `description:"英文名称"`
+	EdbInfoCategoryType int     `description:"普通数据还是预测数据，0：普通，1：预测"`
+	MaxData             float64 `description:"最大值"`
+	MinData             float64 `description:"最小值"`
+	DataList            []data_manage.EdbDataList
+}
+
+// MultipleGraphConfigDetailResp 配置详情接口返回
+type MultipleGraphConfigDetailResp struct {
+	MultipleGraphConfigId int
+	LineChartInfoConfig   request.LineChartInfoReq
+	EdbInfoList           []*data_manage.ChartEdbInfoMapping
+	ChartMappingList      []MultipleGraphConfigChartMapping `description:"关联图表"`
+}
+type MultipleGraphConfigChartMapping struct {
+	ChartInfoId     int    `description:"图表id"`
+	Source          int    `description:"来源,5:斜率图，6：截距图；7：相关性图；"`
+	ChartName       string `description:"图表名称"`
+	ChartClassifyId int    `description:"图表分类id"`
+}
+type MultipleGraphConfigEdbMapping struct {
+	EdbInfoId int `description:"图表id"`
+	Source    int `description:"来源,5:斜率图，6：截距图；7：相关性图；"`
+}

models/data_manage/my_chart.go

@@ -845,3 +845,18 @@ func GetRelationChartListCountByCondition(condition string, pars []interface{})
 	err = o.Raw(sql, pars).QueryRow(&count)
 	return
 }
+
+func GetChartItems(cond string, pars []interface{}, orderRule string) (item []*ChartInfoView, err error) {
+	o := orm.NewOrmUsingDB("data")
+	sql := `SELECT * FROM chart_info WHERE 1=1 `
+	if cond != "" {
+		sql += cond
+	}
+	order := ` ORDER BY create_time DESC`
+	if orderRule != "" {
+		order = fmt.Sprintf(` ORDER BY %s`, orderRule)
+	}
+	sql += order
+	_, err = o.Raw(sql, pars).QueryRows(&item)
+	return
+}

routers/commentsRouter.go

@@ -79,6 +79,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"],
+        beego.ControllerComments{
+            Method: "AddChartClassify",
+            Router: `/chart_classify/add`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"],
         beego.ControllerComments{
             Method: "DeleteChartClassify",
@@ -88,6 +97,24 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"],
+        beego.ControllerComments{
+            Method: "DeleteChartClassifyCheck",
+            Router: `/chart_classify/delete/check`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"],
+        beego.ControllerComments{
+            Method: "EditChartClassify",
+            Router: `/chart_classify/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"],
         beego.ControllerComments{
             Method: "ChartClassifyItems",
@@ -106,6 +133,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartClassifyController"],
+        beego.ControllerComments{
+            Method: "ChartClassifyMove",
+            Router: `/chart_classify/move`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"],
         beego.ControllerComments{
             Method: "BatchChartInfoRefresh",
@@ -151,6 +187,33 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "ChartEnInfoEdit",
+            Router: `/chart_info/en/edit`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "ChartInfoMove",
+            Router: `/chart_info/move`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"],
+        beego.ControllerComments{
+            Method: "ChartInfoRefresh",
+            Router: `/chart_info/refresh`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ChartInfoController"],
         beego.ControllerComments{
             Method: "ChartInfoSearchByEs",
@@ -160,6 +223,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:EdbInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:EdbInfoController"],
+        beego.ControllerComments{
+            Method: "TraceEdbInfo",
+            Router: `/edb_info/trace`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ExcelInfoController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:ExcelInfoController"],
         beego.ControllerComments{
             Method: "List",
@@ -205,6 +277,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:MyChartController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:MyChartController"],
+        beego.ControllerComments{
+            Method: "Locate",
+            Router: `/chart/locate`,
+            AllowHTTPMethods: []string{"get"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:MyChartController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers/data_manage:MyChartController"],
         beego.ControllerComments{
             Method: "ChartRecommendList",
@@ -1456,6 +1537,15 @@ func init() {
             Filters: nil,
             Params: nil})
 
+    beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers:SysAdminController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers:SysAdminController"],
+        beego.ControllerComments{
+            Method: "SetConfig",
+            Router: `/sysuser/config/set`,
+            AllowHTTPMethods: []string{"post"},
+            MethodParams: param.Make(),
+            Filters: nil,
+            Params: nil})
+
     beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers:SysMenuController"] = append(beego.GlobalControllerRouter["hongze/hongze_ETA_mobile_api/controllers:SysMenuController"],
         beego.ControllerComments{
             Method: "SysMenuList",

routers/router.go

@@ -66,6 +66,7 @@ func init() {
 		),
 		web.NSNamespace("/datamanage",
 			web.NSInclude(
+				&data_manage.EdbInfoController{},
 				&data_manage.ChartInfoController{},
 				&data_manage.ExcelInfoController{},
 				&data_manage.ChartClassifyController{},
@@ -129,6 +130,9 @@ func init() {
 			web.NSInclude(
 				&controllers.SysMenuController{},
 			),
+			web.NSInclude(
+				&controllers.SysAdminController{},
+			),
 		),
 	)
 	web.AddNamespace(ns)

services/data/chart_info.go

@@ -230,6 +230,21 @@ func getEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate
 					startDateReal = startDate
 					diffSeconds = 0
 				}
+
+				// 预测指标的开始日期也要偏移
+				{
+					day, tmpErr := utils.GetDaysBetween2Date(utils.FormatDate, startDate, startDateReal)
+					if tmpErr != nil {
+						err = tmpErr
+						return
+					}
+					latestDateTime, tmpErr := time.ParseInLocation(utils.FormatDate, item.LatestDate, time.Local)
+					if tmpErr != nil {
+						err = tmpErr
+						return
+					}
+					item.LatestDate = latestDateTime.AddDate(0, 0, day).Format(utils.FormatDate)
+				}
 			} else {
 				startDateReal = startDate
 			}
@@ -577,6 +592,7 @@ func BarChartData(mappingList []*data_manage.ChartEdbInfoMapping, edbDataListMap
 				}
 			}
 			if tmpValue, ok := edbDataMap[edbInfoId][findDate]; ok {
+				tmpValue, _ = decimal.NewFromFloat(tmpValue).Round(4).Float64()
 				findDataList = append(findDataList, tmpValue)
 			} else {
 				findDataList = append(findDataList, 0)
@@ -994,6 +1010,39 @@ func GetSectionScatterChartData(mappingList []*data_manage.ChartEdbInfoMapping,
 	return
 }
 
+// ChartInfoRefreshV2 图表刷新
+// @author Roc
+// @datetime 2022-09-16 10:15:38
+// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成  只获取使用的指标id，然后遍历去调用“指标刷新服务”
+func ChartInfoRefreshV2(chartInfoId int) (err error) {
+	var errmsg string
+	defer func() {
+		if err != nil {
+			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
+			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
+			fmt.Println("ChartInfoRefresh Err:" + errmsg)
+		}
+	}()
+	edbMappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
+	if err != nil {
+		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
+		return
+	}
+
+	edbIdList := make([]int, 0)
+	for _, v := range edbMappingList {
+		edbIdList = append(edbIdList, v.EdbInfoId)
+	}
+
+	// 批量刷新
+	err = EdbInfoRefreshAllFromBaseV3(edbIdList, false)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
 // BatchChartInfoRefreshV2 图表批量刷新
 // @author Roc
 // @datetime 2022-09-16 10:15:38
@@ -1031,6 +1080,5 @@ func BatchChartInfoRefreshV2(chartInfoList []*data_manage.ChartInfo) (err error)
 	if err != nil {
 		return
 	}
-
 	return
 }

services/data/edb_info.go

@@ -1,12 +1,16 @@
 package data
 
 import (
+	"encoding/json"
 	"errors"
 	"fmt"
 	"hongze/hongze_ETA_mobile_api/models/data_manage"
 	"hongze/hongze_ETA_mobile_api/services/alarm_msg"
+	"hongze/hongze_ETA_mobile_api/services/elastic"
 	"hongze/hongze_ETA_mobile_api/utils"
 	"sort"
+	"strconv"
+	"strings"
 	"time"
 )
 
@@ -588,3 +592,309 @@ func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBase
 
 	return
 }
+
+// AddOrEditEdbInfoToEs 添加/修改ES中的指标
+func AddOrEditEdbInfoToEs(edbInfoId int) {
+	//添加es
+	itemInfo, _ := data_manage.GetEdbInfoByCondition("AND edb_info_id=?", []interface{}{edbInfoId})
+	go elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
+}
+
+// TraceEdbInfoByEdbInfoId 指标追溯
+func TraceEdbInfoByEdbInfoId(edbInfoId int) (traceEdbInfo data_manage.TraceEdbInfoResp, err error) {
+	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
+	if err != nil {
+		return
+	}
+	edbInfoRuleMap := make(map[int]string, 0)
+	edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
+	//edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
+	traceEdbInfo = data_manage.TraceEdbInfoResp{
+		//EdbInfoId: edbInfo.EdbInfoId,
+		EdbInfoId: edbInfoId,
+		EdbName:   edbInfo.EdbName,
+	}
+	findIdMap := make(map[int]int)
+	findIdMap[edbInfoId] = edbInfoId
+	existMap := make(map[int]data_manage.TraceEdbInfoResp)
+	traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
+
+	edbInfoIdList := make([]int, 0)
+	for _, v := range findIdMap {
+		edbInfoIdList = append(edbInfoIdList, v)
+	}
+	edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
+	if err != nil {
+		return
+	}
+	edbInfoMap := make(map[int]*data_manage.EdbInfo)
+	for _, tmpEdbInfo := range edbInfoList {
+		edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
+	}
+	traceEdbInfo, err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
+	return
+}
+
+// traceEdbInfoByEdbInfoId 指标追溯
+func traceEdbInfoByEdbInfoId(edbInfoId int, traceEdbInfo data_manage.TraceEdbInfoResp, edbInfoRuleMap map[int]string, findIdMap map[int]int, existMap map[int]data_manage.TraceEdbInfoResp, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (child []data_manage.TraceEdbInfoResp, err error) {
+	traceEdbInfo, ok := existMap[edbInfoId]
+	if ok {
+		return
+	}
+	child = make([]data_manage.TraceEdbInfoResp, 0)
+
+	edbInfoMappingList, err := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
+	edbMappingMap[edbInfoId] = edbInfoMappingList
+
+	for _, v := range edbInfoMappingList {
+		tmpEdbInfoId := v.FromEdbInfoId
+		tmpTraceEdbInfo := data_manage.TraceEdbInfoResp{
+			EdbInfoId: tmpEdbInfoId,
+			//EdbName:   v.EdbName,
+			//RuleTitle: edbInfoRuleMap[v.EdbInfoId],
+			//Child:     make([]data_manage.TraceEdbInfoResp, 0),
+		}
+		if v.EdbType == 2 { // 计算指标
+			// 查过了就不查了
+			if _, ok2 := findIdMap[tmpEdbInfoId]; !ok2 {
+				tmpTraceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(tmpEdbInfoId, tmpTraceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
+			}
+			//else {
+			//	tmpTraceEdbInfo = existMap[v.EdbInfoId]
+			//}
+		}
+		child = append(child, tmpTraceEdbInfo)
+		findIdMap[tmpEdbInfoId] = tmpEdbInfoId
+		//existMap[v.EdbInfoId] = tmpTraceEdbInfo
+	}
+	existMap[edbInfoId] = traceEdbInfo
+
+	return
+}
+
+func handleTraceEdbInfo(traceEdbInfoResp data_manage.TraceEdbInfoResp, parentEdbInfoId int, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (newTraceEdbInfoResp data_manage.TraceEdbInfoResp, err error) {
+	edbInfo, ok := edbInfoMap[traceEdbInfoResp.EdbInfoId]
+	if !ok {
+		err = errors.New("指标异常")
+		return
+	}
+
+	var parentEdbInfo *data_manage.EdbInfo
+	if parentEdbInfoId > 0 {
+		parentEdbInfo, ok = edbInfoMap[parentEdbInfoId]
+		if !ok {
+			err = errors.New("指标异常")
+			return
+		}
+	}
+
+	//traceEdbInfoResp.EdbName = edbInfo.EdbName
+	traceEdbInfoResp.EdbName, traceEdbInfoResp.RuleTitle = getEdbRuleTitle(edbInfo, parentEdbInfo, traceEdbInfoResp.Child, edbInfoMap, edbMappingMap)
+
+	if traceEdbInfoResp.Child != nil && len(traceEdbInfoResp.Child) > 0 {
+		for k, v := range traceEdbInfoResp.Child {
+			traceEdbInfoResp.Child[k], err = handleTraceEdbInfo(v, traceEdbInfoResp.EdbInfoId, edbInfoMap, edbMappingMap)
+			if err != nil {
+				return
+			}
+		}
+	}
+	newTraceEdbInfoResp = traceEdbInfoResp
+
+	return
+}
+
+// getEdbRule 获取规则名称
+func getEdbRuleTitle(edbInfo, parentEdbInfo *data_manage.EdbInfo, childList []data_manage.TraceEdbInfoResp, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (edbName, ruleTitle string) {
+	edbName = edbInfo.EdbName
+	ruleTitle = `来源于` + edbInfo.SourceName
+	if edbInfo.EdbType == 1 {
+		// 基础指标的话，直接返回来源名称
+		//ruleTitle = `来源于`+edbInfo.SourceName
+
+		return
+	}
+	if parentEdbInfo != nil {
+		edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
+		if !ok {
+			edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{}
+		}
+		// 指标名称
+		switch parentEdbInfo.Source {
+		case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
+			for _, v := range edbMappingList {
+				if v.FromEdbInfoId == edbInfo.EdbInfoId {
+					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag)
+				}
+			}
+
+		case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ, utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 直接拼接 ,累计值同比拼接
+			for _, v := range edbMappingList {
+				if v.FromEdbInfoId == edbInfo.EdbInfoId {
+					tmpName := ``
+					if v.FromTag == `A` {
+						tmpName = `拼接日期前`
+					} else if v.FromTag == `B` {
+						tmpName = `拼接日期后`
+					}
+					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName)
+				}
+			}
+		case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差）
+			for _, v := range edbMappingList {
+				//（需对上游指标+自变量，领先10天/因变量）
+				if v.FromEdbInfoId == edbInfo.EdbInfoId {
+					tmpName := ``
+					if v.FromTag == `A` {
+						tmpName = fmt.Sprintf(`自变量，领先%d天`, v.MoveValue)
+					} else if v.FromTag == `B` {
+						tmpName = `因变量`
+					}
+					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, tmpName)
+				}
+			}
+		case utils.DATA_SOURCE_CALCULATE_CORRELATION: // 滚动相关性
+			for _, v := range edbMappingList {
+				if v.FromEdbInfoId == edbInfo.EdbInfoId {
+					edbName = fmt.Sprintf("%s（%s）", edbInfo.EdbName, v.FromTag)
+				}
+			}
+
+		}
+
+	}
+
+	// 规则
+	switch edbInfo.Source {
+	case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
+		ruleTitle = "=" + edbInfo.CalculateFormula
+	case utils.DATA_SOURCE_CALCULATE_LJZZY, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZZY:
+		ruleTitle = `累计转月值计算`
+	case utils.DATA_SOURCE_CALCULATE_TBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
+		ruleTitle = `同比值计算`
+	case utils.DATA_SOURCE_CALCULATE_TCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
+		ruleTitle = `同差值计算`
+	case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_PREDICT_CALCULATE_NSZYDPJJS:
+		ruleTitle = fmt.Sprintf("N数值移动均值计算（N=%s）", edbInfo.CalculateFormula)
+	case utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ:
+		ruleTitle = fmt.Sprintf("N数值环比值计算（N=%s）", edbInfo.CalculateFormula)
+	case utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HCZ:
+		ruleTitle = fmt.Sprintf("N数值环差值计算（N=%s）", edbInfo.CalculateFormula)
+	case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_PREDICT_CALCULATE_TIME_SHIFT:
+		moveType := `领先`
+		if edbInfo.MoveType == 2 {
+			moveType = "滞后"
+		}
+		ruleTitle = fmt.Sprintf("时间移位计算（%s%s%s）", moveType, edbInfo.CalculateFormula, edbInfo.MoveFrequency)
+	case utils.DATA_SOURCE_CALCULATE_BP, utils.DATA_SOURCE_PREDICT_CALCULATE_BP: // 变频
+		childFrequency := ``
+		if len(childList) > 0 {
+			if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok {
+				childFrequency = childEdbInfo.Frequency
+			}
+
+		}
+		ruleTitle = fmt.Sprintf("升频计算（%s转%s）", childFrequency, edbInfo.Frequency)
+	case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ: // 直接拼接
+		ruleTitle = fmt.Sprintf("直接拼接计算（%s）", edbInfo.CalculateFormula)
+	case utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 累计值同比拼
+		ruleTitle = fmt.Sprintf("累计值同比值拼接计算（%s）", edbInfo.CalculateFormula)
+	case utils.DATA_SOURCE_PYTHON:
+		ruleTitle = `代码运算`
+	case utils.DATA_SOURCE_CALCULATE_CJJX, utils.DATA_SOURCE_PREDICT_CALCULATE_CJJX:
+		ruleTitle = fmt.Sprintf("超季节性计算（N=%s，%s）", edbInfo.CalculateFormula, edbInfo.Calendar)
+	case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标（拟合残差）
+		var startDate, endDate string
+		dateList := strings.Split(edbInfo.CalculateFormula, ",")
+		if len(dateList) == 2 {
+			startDate = dateList[0]
+			endDate = dateList[1]
+		}
+		ruleTitle = fmt.Sprintf("拟合残差计算（%s至%s）", startDate, endDate)
+	case utils.DATA_SOURCE_CALCULATE_ADJUST:
+		ruleTitle = `数据调整`
+	case utils.DATA_SOURCE_CALCULATE_NH, utils.DATA_SOURCE_PREDICT_CALCULATE_NH:
+		ruleTitle = `年化计算`
+	case utils.DATA_SOURCE_CALCULATE_KSZS, utils.DATA_SOURCE_PREDICT_CALCULATE_KSZS: // 扩散指数->53
+		type KszsConfig struct {
+			DateType  int      `description:"扩散指标日期；1：全部指标日期并集;2:部分指标日期并集"`
+			CheckList []string `description:"选中的数据,A,B,C"`
+		}
+		var config KszsConfig
+		err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &config)
+		if err != nil {
+			return
+		}
+		var startDate, endDate time.Time
+
+		childEdbInfoIdList := make([]int, 0)
+		if config.DateType == 1 {
+			for _, v := range childList {
+				childEdbInfoIdList = append(childEdbInfoIdList, v.EdbInfoId)
+			}
+
+		} else {
+			edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
+			if !ok {
+				edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{}
+			}
+			tagMap := make(map[string]int)
+			for _, v := range edbMappingList {
+				tagMap[v.FromTag] = v.FromEdbInfoId
+			}
+			for _, v := range config.CheckList {
+				if tmpEdbInfoId, ok := tagMap[v]; ok {
+					childEdbInfoIdList = append(childEdbInfoIdList, tmpEdbInfoId)
+				}
+			}
+		}
+		for _, v := range childEdbInfoIdList {
+			if childEdbInfo, ok := edbInfoMap[v]; ok {
+				tmpStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.StartDate, time.Local)
+				if tmpErr != nil {
+					return
+				}
+				if startDate.IsZero() || startDate.After(tmpStartDate) {
+					startDate = tmpStartDate
+				}
+
+				tmpEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.EndDate, time.Local)
+				if tmpErr != nil {
+					return
+				}
+				if endDate.IsZero() || endDate.Before(tmpEndDate) {
+					endDate = tmpEndDate
+				}
+			}
+		}
+		ruleTitle = fmt.Sprintf("扩散指数计算（%s至%s）", startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
+	case utils.DATA_SOURCE_STOCK_PLANT:
+		ruleTitle = `来源于装置分析`
+	case utils.DATA_SOURCE_CALCULATE_CORRELATION:
+		type EdbCalculateFormula struct {
+			BaseCalculateValue int    `description:"基础计算窗口"`
+			BaseCalculateUnit  string `description:"基础计算频度"`
+			LeadValue          int    `description:"领先期数"`
+			LeadUnit           string `description:"频度"`
+			CalculateValue     int    `description:"计算窗口"`
+			CalculateUnit      string `description:"计算频度"`
+		}
+		var correlationConf EdbCalculateFormula
+		err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &correlationConf)
+		if err != nil {
+			return
+		}
+		ruleTitle = fmt.Sprintf("滚动相关性（计算窗口%d%s，B领先A%d%s）", correlationConf.CalculateValue, correlationConf.CalculateUnit, correlationConf.LeadValue, correlationConf.LeadUnit)
+	case utils.DATA_SOURCE_CALCULATE_JP, utils.DATA_SOURCE_PREDICT_CALCULATE_JP:
+		childFrequency := ``
+		if len(childList) > 0 {
+			if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok {
+				childFrequency = childEdbInfo.Frequency
+			}
+
+		}
+		ruleTitle = fmt.Sprintf("降频计算（%s转%s，%s）", childFrequency, edbInfo.Frequency, edbInfo.CalculateFormula)
+	}
+
+	return
+}

services/data/line_equation/chart_info.go

@@ -0,0 +1,774 @@
+package line_equation
+
+import (
+	"errors"
+	"github.com/shopspring/decimal"
+	"hongze/hongze_ETA_mobile_api/models/data_manage"
+	"hongze/hongze_ETA_mobile_api/models/data_manage/line_equation/request"
+	"hongze/hongze_ETA_mobile_api/services/data"
+	"hongze/hongze_ETA_mobile_api/utils"
+	"math"
+	"time"
+)
+
+type LineEquationResp struct {
+	AData  LineEquationDataResp
+	BData  LineEquationDataResp
+	R2Data LineEquationDataResp
+}
+
+type LineEquationDataResp struct {
+	MaxData             float64
+	MinData             float64
+	LatestDate          string `description:"真实数据的最后日期"`
+	EdbInfoCategoryType int
+	ChartColor          string
+	ChartStyle          string
+	PredictChartColor   string
+	ChartType           int
+	ChartWidth          int
+	EdbName             string
+	EdbNameEn           string
+	Unit                string
+	UnitEn              string
+	IsAxis              int
+	DataList            []data_manage.EdbDataList
+}
+
+// GetChartEdbData 获取图表数据
+func GetChartEdbData(chartInfoId int, lineChartInfoConfig request.LineChartInfoReq, getAData, getBData, getR2Data bool) (edbList []*data_manage.ChartEdbInfoMapping, dataResp LineEquationResp, err error, errMsg string) {
+	// 获取基本信息
+	mappingList, startDate, endDate, err, errMsg := getConfigData(lineChartInfoConfig)
+	if err != nil {
+		return
+	}
+	xEdbInfoIdList := lineChartInfoConfig.XEdbInfoIdList
+	yEdbInfoIdList := lineChartInfoConfig.YEdbInfoIdList
+
+	aLineEquationDataResp := LineEquationDataResp{
+		DataList:          make([]data_manage.EdbDataList, 0),
+		MaxData:           0,
+		MinData:           0,
+		ChartColor:        "#00f",
+		ChartStyle:        `spline`,
+		PredictChartColor: `#00f`,
+		ChartType:         0,
+		ChartWidth:        3,
+		EdbName:           `弹性系数`,
+		EdbNameEn:         `elastic coefficient`,
+		IsAxis:            1,
+	}
+	bLineEquationDataResp := LineEquationDataResp{
+		DataList:          make([]data_manage.EdbDataList, 0),
+		MaxData:           0,
+		MinData:           0,
+		ChartColor:        "#00f",
+		ChartStyle:        `spline`,
+		PredictChartColor: `#00f`,
+		ChartType:         0,
+		ChartWidth:        3,
+		EdbName:           `截距`,
+		EdbNameEn:         `intercept`,
+		IsAxis:            1,
+	}
+	r2LineEquationDataResp := LineEquationDataResp{
+		DataList:          make([]data_manage.EdbDataList, 0),
+		MaxData:           0,
+		MinData:           0,
+		ChartColor:        "#00f",
+		ChartStyle:        `spline`,
+		PredictChartColor: `#00f`,
+		ChartType:         0,
+		ChartWidth:        3,
+		EdbName:           `相关系数`,
+		EdbNameEn:         `coefficient of association`,
+		IsAxis:            1,
+	}
+	edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
+	dataResp = LineEquationResp{
+		AData:  aLineEquationDataResp,
+		BData:  bLineEquationDataResp,
+		R2Data: r2LineEquationDataResp,
+	}
+
+	var baseEdbInfo *data_manage.ChartEdbInfoMapping
+	// 获取确定以哪个指标的日期作为基准日期
+	{
+		var xEdbInfo, yEdbInfo *data_manage.ChartEdbInfoMapping
+		for _, v := range mappingList {
+			if v.EdbInfoId == xEdbInfoIdList[0] {
+				xEdbInfo = v
+			}
+			if v.EdbInfoId == yEdbInfoIdList[0] {
+				yEdbInfo = v
+			}
+		}
+		if xEdbInfo == nil {
+			errMsg = `X轴第一个指标异常`
+			err = errors.New(errMsg)
+			return
+		}
+		if yEdbInfo == nil {
+			errMsg = `Y轴第一个指标异常`
+			err = errors.New(errMsg)
+			return
+		}
+
+		// 时间截面规则：按照什么频率来取不同的截面的问题。原则是：按照X轴和Y轴所选择的第一个指标（X和Y分别有一个第一个指标），两个指标中，以低频的那个作为基准。如果X轴和Y轴是同频的，那以Y轴第一个指标的为准。
+		frequencyIntMap := map[string]int{
+			"日度": 1,
+			"周度": 2,
+			"旬度": 3,
+			"月度": 4,
+			"季度": 5,
+			"年度": 6,
+		}
+		// 如果x是高频 或者 x与y是同频的，那么就是Y轴的第一个指标为主
+		if frequencyIntMap[xEdbInfo.Frequency] <= frequencyIntMap[yEdbInfo.Frequency] {
+			baseEdbInfo = yEdbInfo
+		} else {
+			// 否则是X轴的第一个指标是低频
+			baseEdbInfo = xEdbInfo
+		}
+	}
+
+	// 指标对应的所有数据
+	chartType := 1 //1：普通图，2：季节性图
+	calendar := "公历"
+	edbDataListMap, edbList, err := data.GetEdbDataMapList(chartInfoId, chartType, calendar, startDate, endDate, mappingList)
+	if err != nil {
+		return
+	}
+
+	// 获取所有的日期
+	dateList := make([]string, 0)
+	for _, v := range edbDataListMap[baseEdbInfo.EdbInfoId] {
+		dateList = append(dateList, v.DataTime)
+	}
+
+	// 数据整理
+	// [日期][A指标id:值，B指标id:值]
+	dateEdbMap, err := handleData(baseEdbInfo.EdbInfoId, edbDataListMap)
+	if err != nil {
+		return
+	}
+
+	lenX := len(xEdbInfoIdList)
+
+	var isNotAFirst, isNotBFirst, isNotR2First bool
+	for i, date := range dateList {
+		coordinateData := make([]utils.Coordinate, 0)
+		for k := 0; k < lenX; k++ {
+			xVal, ok1 := dateEdbMap[date][xEdbInfoIdList[k]]
+			yVal, ok2 := dateEdbMap[date][yEdbInfoIdList[k]]
+			if !ok1 || !ok2 {
+				continue
+			}
+			tmpCoordinate1 := utils.Coordinate{
+				X: xVal,
+				Y: yVal,
+			}
+			coordinateData = append(coordinateData, tmpCoordinate1)
+		}
+		dataTime, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
+		timestamp := dataTime.UnixNano() / 1e6
+
+		// 只有存在两个坐标点的时候,才能去计算线性方程和R平方
+		if len(coordinateData) >= 2 {
+			a, b := utils.GetLinearResult(coordinateData)
+			if !math.IsNaN(a) && !math.IsNaN(b) && !math.IsInf(a, 0) && !math.IsInf(b, 0) {
+				if getAData {
+					a, _ = decimal.NewFromFloat(a).Round(4).Float64()
+					dataResp.AData.DataList = append(dataResp.AData.DataList, data_manage.EdbDataList{
+						EdbDataId:     i,
+						EdbInfoId:     0,
+						DataTime:      date,
+						DataTimestamp: timestamp,
+						Value:         a,
+					})
+					if !isNotAFirst {
+						dataResp.AData.MinData = a
+						dataResp.AData.MaxData = a
+						isNotAFirst = true
+					}
+					if dataResp.AData.MinData > a {
+						dataResp.AData.MinData = a
+					}
+					if dataResp.AData.MaxData < a {
+						dataResp.AData.MaxData = a
+					}
+				}
+				if getBData {
+					b, _ = decimal.NewFromFloat(b).Round(4).Float64()
+					dataResp.BData.DataList = append(dataResp.BData.DataList, data_manage.EdbDataList{
+						EdbDataId:     i,
+						EdbInfoId:     0,
+						DataTime:      date,
+						DataTimestamp: timestamp,
+						Value:         b,
+					})
+					if !isNotBFirst {
+						dataResp.BData.MinData = b
+						dataResp.BData.MaxData = b
+						isNotBFirst = true
+					}
+					if dataResp.BData.MinData > b {
+						dataResp.BData.MinData = b
+					}
+					if dataResp.BData.MaxData < b {
+						dataResp.BData.MaxData = b
+					}
+				}
+			}
+
+			// 计算R平方
+			if getR2Data {
+				tmpVal := utils.CalculationDecisive(coordinateData)
+				if math.IsNaN(tmpVal) || math.IsInf(tmpVal, 0) {
+					continue
+				}
+
+				tmpVal, _ = decimal.NewFromFloat(tmpVal).Round(4).Float64()
+				dataResp.R2Data.DataList = append(dataResp.R2Data.DataList, data_manage.EdbDataList{
+					EdbDataId:     i,
+					EdbInfoId:     0,
+					DataTime:      date,
+					DataTimestamp: timestamp,
+					Value:         tmpVal,
+				})
+				if !isNotR2First {
+					dataResp.R2Data.MinData = tmpVal
+					dataResp.R2Data.MaxData = tmpVal
+					isNotR2First = true
+				}
+				if dataResp.R2Data.MinData > tmpVal {
+					dataResp.R2Data.MinData = tmpVal
+				}
+				if dataResp.R2Data.MaxData < tmpVal {
+					dataResp.R2Data.MaxData = tmpVal
+				}
+			}
+		}
+	}
+	dataResp.AData.LatestDate = baseEdbInfo.LatestDate
+	dataResp.AData.EdbInfoCategoryType = baseEdbInfo.EdbInfoCategoryType
+	dataResp.BData.LatestDate = baseEdbInfo.LatestDate
+	dataResp.BData.EdbInfoCategoryType = baseEdbInfo.EdbInfoCategoryType
+	dataResp.R2Data.LatestDate = baseEdbInfo.LatestDate
+	dataResp.R2Data.EdbInfoCategoryType = baseEdbInfo.EdbInfoCategoryType
+
+	return
+}
+
+// GetConfigData 获取配置数据
+//func GetConfigData(lineChartInfoConfig request.LineChartInfoReq) (mappingList []*data_manage.ChartEdbInfoMapping, startDate, endDate string, err error, errMsg string) {
+//	return getConfigData(lineChartInfoConfig)
+//}
+
+// getConfigData 获取配置数据
+func getConfigData(lineChartInfoConfig request.LineChartInfoReq) (mappingList []*data_manage.ChartEdbInfoMapping, startDate, endDate string, err error, errMsg string) {
+	dateType := lineChartInfoConfig.DateType
+	switch dateType {
+	case 1:
+		startDate = "2000-01-01"
+	case 2:
+		startDate = "2010-01-01"
+	case 3:
+		startDate = "2015-01-01"
+	case 4:
+		//startDate = strconv.Itoa(time.Now().Year()) + "-01-01"
+		startDate = "2021-01-01"
+	case 5:
+		startDate = lineChartInfoConfig.StartDate + "-01"
+		endDate = lineChartInfoConfig.EndDate + "-01"
+	case 6:
+		startDate = lineChartInfoConfig.StartDate + "-01"
+	case 7:
+		startDate = "2018-01-01"
+	case 8:
+		startDate = "2019-01-01"
+	case 9:
+		startDate = "2020-01-01"
+	case 11:
+		startDate = "2022-01-01"
+	}
+
+	//指标数据
+	edbInfoIdList := make([]int, 0)
+	{
+		edbInfoIdMap := make(map[int]int, 0)
+		for _, edbInfoId := range lineChartInfoConfig.XEdbInfoIdList {
+			edbInfoIdMap[edbInfoId] = edbInfoId
+		}
+		for _, edbInfoId := range lineChartInfoConfig.YEdbInfoIdList {
+			edbInfoIdMap[edbInfoId] = edbInfoId
+		}
+		for _, edbInfoId := range edbInfoIdMap {
+			edbInfoIdList = append(edbInfoIdList, edbInfoId)
+		}
+	}
+	mappingList, err = data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIdList)
+	if err != nil {
+		errMsg = `获取失败`
+		err = errors.New("获取图表，指标信息失败，Err:" + err.Error())
+		return
+	}
+
+	return
+}
+
+// handleData 数据处理
+func handleData(baseEdbInfoId int, edbDataListMap map[int][]*data_manage.EdbDataList) (dateEdbMap map[string]map[int]float64, err error) {
+	dateEdbMap = make(map[string]map[int]float64) // [日期][A指标id:值，B指标id:值]
+	for edbInfoId, edbDataList := range edbDataListMap {
+		if edbInfoId != baseEdbInfoId {
+			// 用上期的数据补充当期的数据处理
+			handleDataMap := make(map[string]float64)
+			err = data_manage.HandleDataByPreviousData(edbDataList, handleDataMap)
+			if err != nil {
+				return
+			}
+
+			for date, val := range handleDataMap {
+				item, ok := dateEdbMap[date]
+				if ok {
+					item[edbInfoId] = val
+				} else {
+					item = map[int]float64{
+						edbInfoId: val,
+					}
+				}
+				dateEdbMap[date] = item
+			}
+		} else {
+			for _, edbData := range edbDataList {
+				item, ok := dateEdbMap[edbData.DataTime]
+				if ok {
+					item[edbInfoId] = edbData.Value
+				} else {
+					item = map[int]float64{
+						edbInfoId: edbData.Value,
+					}
+				}
+				dateEdbMap[edbData.DataTime] = item
+			}
+		}
+	}
+
+	return
+}
+
+// BatchAddChartInfo 批量添加图表
+//func BatchAddChartInfo(batchAddChartReq []request.AddChart, lineChartInfoConfig request.LineChartInfoReq, sysUser *system.Admin) (batchAddChartList []line_equation.BatchAddChart, err error, errMsg string, isSendEmail bool) {
+//	source := utils.CHART_SOURCE_LINE_EQUATION
+//	// 获取需要
+//	for k, v := range batchAddChartReq {
+//		v.ChartName = strings.Trim(v.ChartName, " ")
+//		batchAddChartReq[k] = v
+//
+//		if v.ChartName == "" {
+//			errMsg = "请填写图表名称！"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//		if v.ChartClassifyId <= 0 {
+//			errMsg = "请填写图表名称！"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//
+//		chartClassify, tmpErr := data_manage.GetChartClassifyById(v.ChartClassifyId)
+//		if tmpErr != nil {
+//			if tmpErr.Error() == utils.ErrNoRow() {
+//				errMsg = "分类不存在"
+//				err = errors.New(errMsg)
+//				isSendEmail = false
+//				return
+//			}
+//			errMsg = "获取分类信息失败"
+//			err = errors.New("获取分类信息失败，Err:" + tmpErr.Error())
+//			return
+//		}
+//		if chartClassify == nil {
+//			errMsg = "分类不存在"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//
+//		// 判断图表是否存在
+//		var condition string
+//		var pars []interface{}
+//		condition += " AND chart_name=? AND source = ? "
+//		pars = append(pars, v.ChartName, source)
+//		count, tmpErr := data_manage.GetChartInfoCountByCondition(condition, pars)
+//		if tmpErr != nil {
+//			errMsg = "判断图表名称是否存在失败"
+//			err = errors.New("判断图表名称是否存在失败,Err:" + tmpErr.Error())
+//			return
+//		}
+//
+//		if count > 0 {
+//			errMsg = "图表已存在，请重新填写"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//	}
+//
+//	edbList, _, _, err, errMsg := getConfigData(lineChartInfoConfig)
+//
+//	var edbInfoIdArr []int
+//	for _, v := range edbList {
+//		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
+//	}
+//	disableVal := data.CheckIsDisableChart(edbInfoIdArr)
+//
+//	sort.Ints(edbInfoIdArr)
+//	var edbInfoIdArrStr []string
+//	for _, v := range edbInfoIdArr {
+//		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
+//	}
+//	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
+//
+//	// 批量配置
+//	lineChartInfoConfigByte, err := json.Marshal(lineChartInfoConfig)
+//	if err != nil {
+//		return
+//	}
+//	multipleGraphConfig := &data_manage.MultipleGraphConfig{
+//		Curve:           string(lineChartInfoConfigByte),
+//		SysUserId:       sysUser.AdminId,
+//		SysUserRealName: sysUser.RealName,
+//		ModifyTime:      time.Now(),
+//		CreateTime:      time.Now(),
+//	}
+//
+//	// 多图
+//	batchAddChartList = make([]line_equation.BatchAddChart, 0)
+//	for _, v := range batchAddChartReq {
+//		tmpLineChartInfoConfig := lineChartInfoConfig
+//		tmpLineChartInfoConfig.Source = v.Source
+//		tmpLineChartInfoConfigByte, tmpErr := json.Marshal(tmpLineChartInfoConfig)
+//		if tmpErr != nil {
+//			err = tmpErr
+//			return
+//		}
+//
+//		chartInfo := &data_manage.ChartInfo{
+//			ChartInfoId: 0,
+//			ChartName:   v.ChartName,
+//			//ChartNameEn:     v.ChartName,
+//			ChartClassifyId: v.ChartClassifyId,
+//			SysUserId:       sysUser.AdminId,
+//			SysUserRealName: sysUser.RealName,
+//			UniqueCode:      utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + strconv.FormatInt(time.Now().UnixNano(), 10)),
+//			CreateTime:      time.Now(),
+//			ModifyTime:      time.Now(),
+//			DateType:        lineChartInfoConfig.DateType,
+//			StartDate:       lineChartInfoConfig.StartDate,
+//			EndDate:         lineChartInfoConfig.EndDate,
+//			IsSetName:       0,
+//			EdbInfoIds:      edbInfoIdStr,
+//			ChartType:       1,
+//			Calendar:        "公历",
+//			SeasonStartDate: "",
+//			SeasonEndDate:   "",
+//			ChartImage:      v.ChartImage,
+//			Sort:            0,
+//			LeftMin:         v.LeftMin,
+//			LeftMax:         v.LeftMax,
+//			RightMin:        "",
+//			RightMax:        "",
+//			Disabled:        disableVal,
+//			BarConfig:       "",
+//			Source:          source,
+//			ExtraConfig:     string(tmpLineChartInfoConfigByte),
+//		}
+//
+//		// 指标信息
+//		mapList := make([]*data_manage.ChartEdbMapping, 0)
+//		for _, edbInfo := range edbList {
+//			mapItem := new(data_manage.ChartEdbMapping)
+//			mapItem.EdbInfoId = edbInfo.EdbInfoId
+//			mapItem.CreateTime = time.Now()
+//			mapItem.ModifyTime = time.Now()
+//			timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+//
+//			mapItem.UniqueCode = utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + timestamp + "_" + strconv.Itoa(edbInfo.EdbInfoId))
+//			mapItem.IsOrder = true
+//			mapItem.IsAxis = 1
+//			mapItem.EdbInfoType = 1
+//			mapItem.Source = source
+//			mapList = append(mapList, mapItem)
+//		}
+//
+//		// 批量的关系图
+//		multipleGraphConfigChartMapping := &data_manage.MultipleGraphConfigChartMapping{
+//			//Id:                    0,
+//			//MultipleGraphConfigId: 0,
+//			//ChartInfoId:           0,
+//			Source:     v.Source,
+//			ModifyTime: time.Now(),
+//			CreateTime: time.Now(),
+//		}
+//
+//		batchAddChartList = append(batchAddChartList, line_equation.BatchAddChart{
+//			ChartInfo:                       chartInfo,
+//			EdbMappingList:                  mapList,
+//			MultipleGraphConfigChartMapping: multipleGraphConfigChartMapping,
+//		})
+//	}
+//
+//	// 批量创建
+//	err = line_equation.CreateLineEquationChartAndEdb(multipleGraphConfig, batchAddChartList)
+//
+//	// 更改es
+//	for _, v := range batchAddChartList {
+//		//添加es数据
+//		go data.EsAddOrEditChartInfo(v.ChartInfo.ChartInfoId)
+//	}
+//
+//	return
+//}
+
+// BatchSaveChartInfo 批量添加编辑图表
+//func BatchSaveChartInfo(multipleGraphConfigId int, batchAddChartReq []request.AddChart, lineChartInfoConfig request.LineChartInfoReq, sysUser *system.Admin) (batchAddChartList []line_equation.BatchAddChart, err error, errMsg string, isSendEmail bool) {
+//	// 获取统一配置
+//	multipleGraphConfig, err := data_manage.GetMultipleGraphConfigById(multipleGraphConfigId)
+//	if err != nil {
+//		errMsg = `获取失败`
+//		err = errors.New(`获取配置失败，ERR：` + err.Error())
+//		return
+//	}
+//	// 获取已经关联的图表
+//	chartMappingList, err := data_manage.GetMultipleGraphConfigChartMappingListById(multipleGraphConfig.MultipleGraphConfigId)
+//	if err != nil {
+//		errMsg = `获取失败`
+//		err = errors.New(`获取关联图表配置失败，ERR：` + err.Error())
+//		return
+//	}
+//
+//	// 已经存在关联的图表map
+//	existSourceChartMap := make(map[int]*data_manage.MultipleGraphConfigChartMapping)
+//	// 已经存在的图表map
+//	existChartInfoMap := make(map[int]*data_manage.ChartInfo)
+//	for _, v := range chartMappingList {
+//		existSourceChartMap[v.Source] = v
+//
+//		chartInfo, tmpErr := data_manage.GetChartInfoById(v.ChartInfoId)
+//		if tmpErr != nil && tmpErr.Error() != utils.ErrNoRow() {
+//			err = tmpErr
+//			return
+//		}
+//		if chartInfo != nil {
+//			existChartInfoMap[v.Source] = chartInfo
+//		}
+//	}
+//
+//	source := utils.CHART_SOURCE_LINE_EQUATION
+//	// 获取需要
+//	for k, v := range batchAddChartReq {
+//		v.ChartName = strings.Trim(v.ChartName, " ")
+//		batchAddChartReq[k] = v
+//
+//		if v.ChartName == "" {
+//			errMsg = "请填写图表名称！"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//		if v.ChartClassifyId <= 0 {
+//			errMsg = "请填写图表名称！"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//
+//		chartClassify, tmpErr := data_manage.GetChartClassifyById(v.ChartClassifyId)
+//		if tmpErr != nil {
+//			if tmpErr.Error() == utils.ErrNoRow() {
+//				errMsg = "分类不存在"
+//				err = errors.New(errMsg)
+//				isSendEmail = false
+//				return
+//			}
+//			errMsg = "获取分类信息失败"
+//			err = errors.New("获取分类信息失败，Err:" + tmpErr.Error())
+//			return
+//		}
+//		if chartClassify == nil {
+//			errMsg = "分类不存在"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//
+//		// 判断图表是否存在
+//		var condition string
+//		var pars []interface{}
+//		condition += " AND chart_name=? AND source = ? "
+//		pars = append(pars, v.ChartName, source)
+//
+//		// 已经创建了图表的类型
+//		if sourceChart, ok := existChartInfoMap[v.Source]; ok {
+//			condition += " AND chart_info_id != ?  "
+//			pars = append(pars, sourceChart.ChartInfoId)
+//		}
+//
+//		count, tmpErr := data_manage.GetChartInfoCountByCondition(condition, pars)
+//		if tmpErr != nil {
+//			errMsg = "判断图表名称是否存在失败"
+//			err = errors.New("判断图表名称是否存在失败,Err:" + tmpErr.Error())
+//			return
+//		}
+//
+//		if count > 0 {
+//			errMsg = "图表已存在，请重新填写"
+//			err = errors.New(errMsg)
+//			isSendEmail = false
+//			return
+//		}
+//	}
+//
+//	edbList, _, _, err, errMsg := getConfigData(lineChartInfoConfig)
+//
+//	var edbInfoIdArr []int
+//	for _, v := range edbList {
+//		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
+//	}
+//	disableVal := data.CheckIsDisableChart(edbInfoIdArr)
+//
+//	sort.Ints(edbInfoIdArr)
+//	var edbInfoIdArrStr []string
+//	for _, v := range edbInfoIdArr {
+//		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
+//	}
+//	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
+//
+//	// 批量配置
+//	lineChartInfoConfigByte, err := json.Marshal(lineChartInfoConfig)
+//	if err != nil {
+//		return
+//	}
+//	multipleGraphConfig.Curve = string(lineChartInfoConfigByte)
+//	multipleGraphConfig.ModifyTime = time.Now()
+//	updateMultipleGraphConfigCols := []string{"Curve", "ModifyTime"}
+//	updateChartCols := []string{"ChartName", "DateType", "StartDate", "EndDate", "EdbInfoIds", "LeftMin", "LeftMax", "Disabled", "ExtraConfig"}
+//
+//	// 多图
+//	batchAddChartList = make([]line_equation.BatchAddChart, 0)
+//	for _, v := range batchAddChartReq {
+//		tmpLineChartInfoConfig := lineChartInfoConfig
+//		tmpLineChartInfoConfig.Source = v.Source
+//		tmpLineChartInfoConfigByte, tmpErr := json.Marshal(tmpLineChartInfoConfig)
+//		if tmpErr != nil {
+//			err = tmpErr
+//			return
+//		}
+//
+//		var multipleGraphConfigChartMapping *data_manage.MultipleGraphConfigChartMapping
+//		// 已经创建了图表的类型
+//		chartInfo, ok := existChartInfoMap[v.Source]
+//		if ok {
+//			chartInfo.ChartName = v.ChartName
+//			chartInfo.DateType = lineChartInfoConfig.DateType
+//			chartInfo.StartDate = lineChartInfoConfig.StartDate
+//			chartInfo.EndDate = lineChartInfoConfig.EndDate
+//			chartInfo.EdbInfoIds = edbInfoIdStr
+//			chartInfo.LeftMin = v.LeftMin
+//			chartInfo.LeftMax = v.LeftMax
+//			chartInfo.Disabled = disableVal
+//			chartInfo.ExtraConfig = string(tmpLineChartInfoConfigByte)
+//			//updateChartInfoList
+//
+//			tmpMultipleGraphConfigChartMapping, ok2 := existSourceChartMap[v.Source]
+//			if !ok2 {
+//				err = errors.New("找不到对应的统一配置关系")
+//				return
+//			}
+//			multipleGraphConfigChartMapping = tmpMultipleGraphConfigChartMapping
+//		} else {
+//			chartInfo = &data_manage.ChartInfo{
+//				ChartInfoId: 0,
+//				ChartName:   v.ChartName,
+//				//ChartNameEn:     v.ChartName,
+//				ChartClassifyId: v.ChartClassifyId,
+//				SysUserId:       sysUser.AdminId,
+//				SysUserRealName: sysUser.RealName,
+//				UniqueCode:      utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + strconv.FormatInt(time.Now().UnixNano(), 10)),
+//				CreateTime:      time.Now(),
+//				ModifyTime:      time.Now(),
+//				DateType:        lineChartInfoConfig.DateType,
+//				StartDate:       lineChartInfoConfig.StartDate,
+//				EndDate:         lineChartInfoConfig.EndDate,
+//				IsSetName:       0,
+//				EdbInfoIds:      edbInfoIdStr,
+//				ChartType:       1,
+//				Calendar:        "公历",
+//				SeasonStartDate: "",
+//				SeasonEndDate:   "",
+//				ChartImage:      "",
+//				Sort:            0,
+//				LeftMin:         v.LeftMin,
+//				LeftMax:         v.LeftMax,
+//				RightMin:        "",
+//				RightMax:        "",
+//				Disabled:        disableVal,
+//				BarConfig:       "",
+//				Source:          source,
+//				ExtraConfig:     string(tmpLineChartInfoConfigByte),
+//			}
+//
+//			// 批量配置的关系图
+//			if tmpMultipleGraphConfigChartMapping, ok2 := existSourceChartMap[v.Source]; ok2 {
+//				multipleGraphConfigChartMapping = tmpMultipleGraphConfigChartMapping
+//			} else {
+//				multipleGraphConfigChartMapping = &data_manage.MultipleGraphConfigChartMapping{
+//					//Id:                    0,
+//					//MultipleGraphConfigId: 0,
+//					//ChartInfoId:           0,
+//					Source:     v.Source,
+//					ModifyTime: time.Now(),
+//					CreateTime: time.Now(),
+//				}
+//			}
+//
+//		}
+//
+//		// 指标信息
+//		mapList := make([]*data_manage.ChartEdbMapping, 0)
+//		for _, edbInfo := range edbList {
+//			mapItem := new(data_manage.ChartEdbMapping)
+//			mapItem.EdbInfoId = edbInfo.EdbInfoId
+//			mapItem.CreateTime = time.Now()
+//			mapItem.ModifyTime = time.Now()
+//			timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
+//
+//			mapItem.UniqueCode = utils.MD5(utils.CHART_PREFIX + "_" + fmt.Sprint(v.Source) + "_" + timestamp + "_" + strconv.Itoa(edbInfo.EdbInfoId))
+//			mapItem.IsOrder = true
+//			mapItem.IsAxis = 1
+//			mapItem.EdbInfoType = 1
+//			mapItem.Source = source
+//			mapList = append(mapList, mapItem)
+//		}
+//
+//		batchAddChartList = append(batchAddChartList, line_equation.BatchAddChart{
+//			ChartInfo:                       chartInfo,
+//			EdbMappingList:                  mapList,
+//			MultipleGraphConfigChartMapping: multipleGraphConfigChartMapping,
+//		})
+//	}
+//
+//	// 批量创建
+//	err = line_equation.CreateAndEditLineEquationChartAndEdb(multipleGraphConfig, batchAddChartList, updateMultipleGraphConfigCols, updateChartCols)
+//
+//	// 更改es
+//	for _, v := range batchAddChartList {
+//		//添加es数据
+//		go data.EsAddOrEditChartInfo(v.ChartInfo.ChartInfoId)
+//	}
+//	return
+//}

utils/constants.go

@@ -412,12 +412,12 @@ const (
 
 // 图表类型
 const (
-	CHART_SOURCE_DEFAULT             = 1
-	CHART_SOURCE_FUTURE_GOOD         = 2
-	CHART_SOURCE_CORRELATION         = 3 // 相关性图表
-	CHART_SOURCE_ROLLING_CORRELATION = 4 // 滚动相关性图表
-	CHART_SOURCE_FUTURE_GOOD_PROFIT  = 5 // 商品利润曲线
-	CHART_SOURCE_LINE_EQUATION       = 6 // 拟合方程图表
+	CHART_SOURCE_DEFAULT                         = 1
+	CHART_SOURCE_FUTURE_GOOD                     = 2
+	CHART_SOURCE_CORRELATION                     = 3 // 相关性图表
+	CHART_SOURCE_ROLLING_CORRELATION             = 4 // 滚动相关性图表
+	CHART_SOURCE_FUTURE_GOOD_PROFIT              = 5 // 商品利润曲线
+	CHART_SOURCE_LINE_EQUATION                   = 6 // 拟合方程图表
 	CHART_SOURCE_LINE_FEATURE_STANDARD_DEVIATION = 7 // 统计特征-标准差图表
 	CHART_SOURCE_LINE_FEATURE_PERCENTILE         = 8 // 统计特征-百分位图表
 	CHART_SOURCE_LINE_FEATURE_FREQUENCY          = 9 // 统计特征-频率分布图表