eta_api/controllers/data_manage/chart_info.go

package data_manage

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_manage/response"
	"eta/eta_api/models/system"
	"eta/eta_api/services"
	"eta/eta_api/services/data"
	etaTrialService "eta/eta_api/services/eta_trial"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"os"
	"os/exec"
	"sort"
	"strconv"
	"strings"
	"time"
)

// 图表管理
type ChartInfoController struct {
	controllers.BaseAuthController
}

// @Title 保存图表接口
// @Description 保存图表接口
// @Param	request	body data_manage.SaveChartInfoReq true "type json string"
// @Success Ret=200 返回图表id
// @router /chart_info/save [post]
func (this *ChartInfoController) ChartInfoSave() {
	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.SaveChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ChartInfoId > 0 && len(req.ChartEdbInfoList) <= 0 {
		br.Msg = "参数错误！"
		return
	}

	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图表已被删除，请刷新页面！"
			br.ErrMsg = "图表已被删除，请刷新页面，ChartInfoId:" + strconv.Itoa(req.ChartInfoId)
			return
		}
		br.Msg = "获取图表信息失败！"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	//图表操作权限
	//ok := data.CheckOpChartPermission(sysUser, chartItem.SysUserId)
	//if !ok {
	//	br.Msg = "没有该图表的操作权限"
	//	br.ErrMsg = "没有该图表的操作权限"
	//	return
	//}

	if chartItem.ChartType == 2 && len(req.ChartEdbInfoList) > 1 {
		br.Msg = "您选择的图表样式为季节性图表，只支持单指标画图！"
		br.ErrMsg = "您选择的图表样式为季节性图表，只支持单指标画图，Data:" + string(this.Ctx.Input.RequestBody)
		return
	}

	if req.Calendar == "" {
		req.Calendar = "公历"
	}

	var edbInfoIdArr []int
	edbList := make([]*data_manage.EdbInfo, 0)

	for _, v := range req.ChartEdbInfoList {
		edbInfo, err := data_manage.GetEdbInfoById(v.EdbInfoId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "图表不存在！"
				br.ErrMsg = "图表不存在，ChartInfoId:" + strconv.Itoa(v.EdbInfoId)
				return
			} else {
				br.Msg = "获取图表信息失败！"
				br.ErrMsg = "获取图表的指标信息失败，Err:" + err.Error()
				return
			}
		}

		if edbInfo == nil {
			br.Msg = "指标不存在！"
			br.ErrMsg = "指标不存在，ChartInfoId:" + strconv.Itoa(v.EdbInfoId)
			return
		}

		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
		edbInfo.EdbNameSource = edbInfo.EdbName
		edbList = append(edbList, edbInfo)
	}
	sort.Ints(edbInfoIdArr)
	var edbInfoIdArrStr []string
	for _, v := range edbInfoIdArr {
		edbInfoIdArrStr = append(edbInfoIdArrStr, strconv.Itoa(v))
	}
	edbInfoIdStr := strings.Join(edbInfoIdArrStr, ",")
	err = data_manage.ModifyChartInfoAndMapping(edbInfoIdStr, &req, chartItem.ChartType)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}

	key := utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode
	if utils.Re == nil && utils.Rc != nil {
		utils.Rc.Delete(key)
	}

	//修改es数据
	go data.EsAddOrEditChartInfo(chartItem.ChartInfoId)
	//修改my eta es数据
	go data.EsAddOrEditMyChartInfoByChartInfoId(chartItem.ChartInfoId)

	//新增操作日志
	{
		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.URI()
		go data_manage.AddChartInfoLog(chartLog)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.IsAddLog = true
}

// ChartInfoAdd
// @Title 新增图表接口
// @Description 新增图表接口
// @Param	request	body data_manage.AddChartInfoReq true "type json string"
// @Success 200 {object} data_manage.AddChartInfoResp
// @router /chart_info/add [post]
func (this *ChartInfoController) ChartInfoAdd() {
	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.AddChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.ChartName = strings.Trim(req.ChartName, " ")
	if req.ChartName == "" {
		br.Msg = "请填写图表名称！"
		return
	}

	if req.ChartClassifyId <= 0 {
		br.Msg = "分类参数错误！"
		return
	}

	chartInfo, err, errMsg, isSendEmail := data.AddChartInfo(req, sysUser.AdminId, sysUser.RealName)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}
	resp := new(data_manage.AddChartInfoResp)
	resp.ChartInfoId = chartInfo.ChartInfoId
	resp.UniqueCode = chartInfo.UniqueCode
	resp.ChartType = req.ChartType

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartInfoId = chartInfo.ChartInfoId
		chartLog.ChartName = req.ChartName
		chartLog.ChartClassifyId = req.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)
	}

	// 试用平台更新用户累计新增图表数
	adminItem, e := system.GetSysAdminById(sysUser.AdminId)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取系统用户数据失败，Err:" + err.Error()
		return
	}
	if utils.BusinessCode == utils.BusinessCodeSandbox && adminItem.DepartmentName == "ETA试用客户" {
		go func() {
			var r etaTrialService.EtaTrialUserReq
			r.Mobile = adminItem.Mobile
			_, _ = etaTrialService.UpdateUserChartNum(r)
		}()
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// @Title 编辑图表接口
// @Description 编辑图表接口
// @Param	request	body data_manage.EditChartInfoReq true "type json string"
// @Success Ret=200 保存成功
// @router /chart_info/edit [post]
func (this *ChartInfoController) ChartInfoEdit() {
	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.EditChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	chartItem, err, errMsg, isSendEmail := data.EditChartInfo(req, sysUser)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	resp := new(data_manage.AddChartInfoResp)
	resp.ChartInfoId = chartItem.ChartInfoId
	resp.UniqueCode = chartItem.UniqueCode
	resp.ChartType = req.ChartType

	//新增操作日志
	{
		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)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// @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
}

// @Title 获取最新图表接口
// @Description 获取最新图表接口
// @Success 200 {object} data_manage.ChartInfoList
// @router /chart_info/newest [get]
func (this *ChartInfoController) ChartInfoNewest() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	item, err := data_manage.GetChartInfoByNewest(1)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取最新图表失败"
		br.ErrMsg = "获取最新图表失败,Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = item
}

// 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, []int{chartInfo.Source}, updateSortStr)
			} else {
				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
				if nextChartInfo.Sort-prevChartInfo.Sort == 1 {
					//变更兄弟节点的排序
					updateSortStr := `sort + 1`
					_ = data_manage.UpdateChartInfoSortByClassifyId(prevChartInfo.ChartClassifyId, prevChartInfo.Sort, prevChartInfo.ChartInfoId, []int{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, []int{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 获取图表详情接口
// @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 *ChartInfoController) ChartInfoDetail() {
	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")

	dateType, _ := this.GetInt("DateType")
	fmt.Println("dateType:", dateType)
	if dateType <= 0 {
		dateType = 3
	}

	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	startYear, _ := this.GetInt("StartYear")

	edbInfoId := this.GetString("EdbInfoId")
	chartType, _ := this.GetInt("ChartType")

	calendar := this.GetString("Calendar")
	if calendar == "" {
		calendar = "公历"
	}

	var err error
	chartInfo := new(data_manage.ChartInfoView)
	if chartInfoId > 0 {
		chartInfo, err = data_manage.GetChartInfoViewById(chartInfoId)
		if err != nil {
			if err.Error() == utils.ErrNoRow() {
				br.Msg = "该图表已删除，自动查看下一图表"
				br.ErrMsg = "该图表已删除，自动查看下一图表，Err:" + err.Error()
				br.Ret = 406
				return
			}
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
		chartType = chartInfo.ChartType

		// 获取主题样式
		chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, chartInfo.Source, chartInfo.ChartType)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取主题信息失败，Err:" + err.Error()
			return
		}
		chartInfo.ChartThemeStyle = chartTheme.Config
	}

	mappingList := make([]*data_manage.ChartEdbInfoMapping, 0)
	if chartInfoId > 0 {
		mappingList, err = data_manage.GetChartEdbMappingList(chartInfoId)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
			return
		}
	} else {
		if edbInfoId != "" {
			mappingList, err = data_manage.GetChartEdbMappingListByEdbInfoId(edbInfoId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
				return
			}
		}
	}

	// 图表额外数据参数
	extraConfigStr := chartInfo.ExtraConfig
	// 柱方图的一些配置
	var barConfig data_manage.BarChartInfoReq
	if chartInfo != nil && chartInfo.ChartType == 7 {
		if chartInfo.BarConfig == `` {
			br.Msg = "柱方图未配置"
			br.ErrMsg = "柱方图未配置"
			return
		}
		err := json.Unmarshal([]byte(chartInfo.BarConfig), &barConfig)
		if err != nil {
			br.Msg = "柱方图配置异常"
			br.ErrMsg = "柱方图配置异常"
			return
		}
		extraConfigStr = chartInfo.BarConfig
	}
	yearMax := 0
	if dateType == utils.DateTypeNYears {
		for _, v := range mappingList {
			if v.LatestDate != "" {
				lastDateT, tErr := time.Parse(utils.FormatDate, v.LatestDate)
				if tErr != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取图表日期信息失败，Err:" + tErr.Error()
					return
				}
				if lastDateT.Year() > yearMax {
					yearMax = lastDateT.Year()
				}
			}
		}
	}
	// 开始/结束日期
	startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, yearMax)

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(chartInfoId, chartType, calendar, startDate, endDate, mappingList, extraConfigStr, chartInfo.SeasonExtraConfig)
	if err != nil {
		br.Msg = "获取失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	// 单位
	if chartType == utils.CHART_TYPE_BAR && len(yDataList) > 0 {
		chartInfo.Unit = yDataList[0].Unit
		chartInfo.UnitEn = yDataList[0].UnitEn
	}
	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}
	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
			}
		}
		if chartInfo.ChartType == 2 {
			if chartInfo.SeasonStartDate != "" {
				chartInfo.StartDate = chartInfo.SeasonStartDate
				chartInfo.EndDate = chartInfo.SeasonEndDate
				if chartInfo.DateType == 3 {
					chartInfo.DateType = 5
				}
			}
		}
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.BarChartInfo = barConfig
	resp.DataResp = dataResp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// PreviewChartInfoDetail
// @Title 获取图表详情（预览）
// @Description 获取图表详情接口（预览）
// @Param	request	body data_manage.PreviewChartInfoReq true "type json string"
// @Success 200 {object} data_manage.ChartInfoDetailResp
// @router /chart_info/detail/preview [post]
func (this *ChartInfoController) PreviewChartInfoDetail() {
	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.PreviewChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.DateType <= 0 {
		req.DateType = 3
	}

	// edbInfoId 指标id
	if len(req.ChartEdbInfoList) <= 0 {
		br.Msg = "请选择指标"
		br.ErrMsg = "指标为空"
		br.IsSendEmail = false
		return
	}

	calendar := req.Calendar
	if calendar == "" {
		calendar = "公历"
	}

	chartInfo := new(data_manage.ChartInfoView)
	chartInfo.ChartType = req.ChartType

	edbInfoIdList := make([]int, 0)
	edbInfoIdMapping := make(map[int]*data_manage.ChartSaveItem)
	for _, v := range req.ChartEdbInfoList {
		edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
		edbInfoIdMapping[v.EdbInfoId] = v
	}
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIdList)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	yearMax := 0
	for k, v := range mappingList {
		if tmpV, ok := edbInfoIdMapping[v.EdbInfoId]; ok {
			v.EdbInfoType = tmpV.EdbInfoType
			v.MaxData = tmpV.MaxData
			v.MinData = tmpV.MinData
			v.IsOrder = tmpV.IsOrder
			v.IsAxis = tmpV.IsAxis
			v.EdbInfoType = tmpV.EdbInfoType
			v.LeadValue = tmpV.LeadValue
			v.LeadUnit = tmpV.LeadUnit
			v.ChartStyle = tmpV.ChartStyle
			v.ChartColor = tmpV.ChartColor
			v.PredictChartColor = tmpV.PredictChartColor
			v.ChartWidth = tmpV.ChartWidth
			//v.Source = tmpV.Source
			// 得到指标更新的最新的年份
			if req.DateType == utils.DateTypeNYears && v.LatestDate != "" {
				lastDateT, tErr := time.Parse(utils.FormatDate, v.LatestDate)
				if tErr != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取图表日期信息失败，Err:" + tErr.Error()
					return
				}
				if lastDateT.Year() > yearMax {
					yearMax = lastDateT.Year()
				}
			}
		}
		mappingList[k] = v
	}

	// 开始/结束日期
	startDate, endDate := utils.GetDateByDateTypeV2(req.DateType, req.StartDate, req.EndDate, req.StartYear, yearMax)
	if startDate == "" {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败 时间格式错误"
		return
	}

	var seasonExtraConfig string
	if req.ChartType == 2 {
		seasonExtra, tErr := json.Marshal(req.SeasonExtraConfig)
		if tErr != nil {
			br.Msg = "季节性图表配置信息异常"
			br.ErrMsg = "季节性图表配置信息异常,Err:" + tErr.Error()
			return
		}

		seasonExtraConfig = string(seasonExtra)
	}
	// 图表额外数据参数
	extraConfigStr := chartInfo.ExtraConfig
	// 柱方图的一些配置
	var barConfig data_manage.BarChartInfoReq
	if chartInfo != nil && chartInfo.ChartType == 7 {
		if chartInfo.BarConfig == `` {
			br.Msg = "柱方图未配置"
			br.ErrMsg = "柱方图未配置"
			return
		}
		err := json.Unmarshal([]byte(chartInfo.BarConfig), &barConfig)
		if err != nil {
			br.Msg = "柱方图配置异常"
			br.ErrMsg = "柱方图配置异常"
			return
		}
		extraConfigStr = chartInfo.BarConfig
	}

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(0, req.ChartType, calendar, startDate, endDate, mappingList, extraConfigStr, seasonExtraConfig)
	if err != nil {
		br.Msg = "获取失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	// 单位
	if req.ChartType == utils.CHART_TYPE_BAR && len(yDataList) > 0 {
		chartInfo.Unit = yDataList[0].Unit
		chartInfo.UnitEn = yDataList[0].UnitEn
	}
	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.BarChartInfo = barConfig
	resp.DataResp = dataResp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ChartInfoDetailV2
// @Title 获取图表详情
// @Description 获取图表详情接口
// @Param   ChartInfoId   query   int  true       "图表id"
// @Success 200 {object} data_manage.ChartInfoDetailResp
// @router /chart_info/detail/v2 [get]
func (this *ChartInfoController) ChartInfoDetailV2() {
	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")
	//startDate = strconv.Itoa(time.Now().Year()) + "-01-01"
	if chartInfoId <= 0 {
		br.Msg = "请选择图表"
		br.IsSendEmail = false
		return
	}
	chartInfo, err := data_manage.GetChartInfoViewById(chartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "该图表已删除，自动查看下一图表"
			br.ErrMsg = "该图表已删除，自动查看下一图表，Err:" + err.Error()
			br.Ret = 406
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	dateType := chartInfo.DateType
	fmt.Println("dateType:", dateType)

	chartType := chartInfo.ChartType
	startDate := chartInfo.StartDate
	endDate := chartInfo.EndDate
	seasonStartDate := chartInfo.SeasonStartDate
	seasonEndDate := chartInfo.SeasonEndDate
	startYear := chartInfo.StartYear

	calendar := chartInfo.Calendar

	if calendar == "" {
		calendar = "公历"
	}

	// 相关联指标
	mappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}

	if chartType == 2 {
		startDate = seasonStartDate
		endDate = seasonEndDate
		if dateType <= 0 {
			if startDate != "" {
				dateType = 5
			} else {
				dateType = utils.DateTypeNYears
			}
		}
	} else {
		if dateType <= 0 {
			dateType = 3
		}
	}
	yearMax := 0
	if dateType == utils.DateTypeNYears {
		for _, v := range mappingList {
			if v.LatestDate != "" {
				lastDateT, tErr := time.Parse(utils.FormatDate, v.LatestDate)
				if tErr != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取图表日期信息失败，Err:" + tErr.Error()
					return
				}
				if lastDateT.Year() > yearMax {
					yearMax = lastDateT.Year()
				}
			}
		}
	}
	startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, yearMax)

	if chartInfo.ChartType == 2 {
		chartInfo.StartDate = startDate
		chartInfo.EndDate = endDate
	}
	// 图表额外数据参数
	extraConfigStr := chartInfo.ExtraConfig
	// 柱方图的一些配置
	var barConfig data_manage.BarChartInfoReq
	if chartInfo != nil && chartInfo.ChartType == 7 {
		if chartInfo.BarConfig == `` {
			br.Msg = "柱方图未配置"
			br.ErrMsg = "柱方图未配置"
			return
		}
		err := json.Unmarshal([]byte(chartInfo.BarConfig), &barConfig)
		if err != nil {
			br.Msg = "柱方图配置异常"
			br.ErrMsg = "柱方图配置异常"
			return
		}
		extraConfigStr = chartInfo.BarConfig
	}

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(chartInfoId, chartType, calendar, startDate, endDate, mappingList, extraConfigStr, chartInfo.SeasonExtraConfig)
	if err != nil {
		br.Msg = "获取失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	// 单位
	if chartType == utils.CHART_TYPE_BAR && len(yDataList) > 0 {
		chartInfo.Unit = yDataList[0].Unit
		chartInfo.UnitEn = yDataList[0].UnitEn
	}
	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}
	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, edbList, chartInfo.Source, chartInfo.ChartType)
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.BarChartInfo = barConfig
	resp.DataResp = dataResp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @Title 图表指标模糊搜索
// @Description 图表指标模糊搜索接口
// @Param   KeyWord   query   string  true       "指标名称/ID"
// @Success 200 {object} data_manage.ChartEdbInfo
// @router /chart_info/edb_info/search [get]
func (this *ChartInfoController) ChartInfoEdbInfoSearch() {
	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
	}
	KeyWord := this.GetString("KeyWord")
	//if KeyWord == "" {
	//	br.Msg = "请输入指标名称/指标ID"
	//	return
	//}
	var err error
	searchList := make([]*data_manage.ChartEdbInfo, 0)
	searchList, err = data_manage.EdbInfoSearchByKeyWord(KeyWord)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}
	if searchList == nil {
		searchList = make([]*data_manage.ChartEdbInfo, 0)
	}

	lenSearchList := len(searchList)
	for i := 0; i < lenSearchList; i++ {
		searchList[i].EdbNameAlias = searchList[i].EdbName
	}

	for i := 0; i < lenSearchList; i++ {
		for j := 0; j < lenSearchList; j++ {
			if (searchList[i].EdbNameAlias == searchList[j].EdbNameAlias) &&
				(searchList[i].EdbInfoId != searchList[j].EdbInfoId) &&
				!(strings.Contains(searchList[i].EdbName, searchList[i].SourceName)) {
				searchList[i].EdbName = searchList[i].EdbName + "(" + searchList[i].SourceName + ")"
			}
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = searchList
}

// @Title 图表-获取指标详情
// @Description 图表-获取指标详情接口
// @Param   EdbInfoId   query   int  true       "指标ID"
// @Param   DateType   query   int  true       "日期类型:1:00年至今,2:10年至今,3:15年至今，4：年初至今，5:自定义时间,6:自定义起始时间至今，7：18年至今,8:19年至今,9:20年至今"
// @Param   StartDate   query   string  true       "自定义开始日期"
// @Param   EndDate   query   string  true       "自定义结束日期"
// @Param   EdbInfoType  query int  true     "1:标准指标,0:领先指标，默认为标准指标"
// @Param   LeadValue    query   int  true       "领先值"
// @Param   LeadUnit     query   string  true        "领先单位:天，月，季，周"
// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
// @router /chart_info/edb_info/detail [get]
func (this *ChartInfoController) ChartInfoEdbInfoDetail() {
	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 = "参数错误"
		return
	}
	dateType, _ := this.GetInt("DateType")
	if dateType <= 0 {
		dateType = 3
	}

	edbInfoType, _ := this.GetInt("EdbInfoType")
	if edbInfoType < 0 {
		edbInfoType = 1
	}

	leadValue, _ := this.GetInt("LeadValue")
	if leadValue < 0 {
		leadValue = 0
	}

	leadUnit := this.GetString("LeadUnit")

	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	startYear, _ := this.GetInt("StartYear")

	isTimeBetween := false //是否是时间区间
	if dateType == 5 {
		isTimeBetween = true
	}

	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.Msg = "获取失败,Err:" + err.Error()
		return
	}
	maxYear := 0
	if edbInfo.LatestDate != "" {
		latestDateT, _ := time.Parse(utils.FormatDate, edbInfo.LatestDate)
		maxYear = latestDateT.Year()
	}

	startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, maxYear)
	if startDate == "" {
		br.Msg = "参数错误"
		br.Msg = "参数错误,无效的查询日期"
		return
	}

	var startDateReal string
	var diffSeconds int64
	if leadValue > 0 && leadUnit != "" {
		var startTimeRealTemp time.Time
		startDateParse, err := time.Parse(utils.FormatDate, startDate)
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "获取数据失败,日期格式错误：startDate:" + startDate
			return
		}
		switch leadUnit {
		case "天":
			startTimeRealTemp = startDateParse.AddDate(0, 0, -leadValue)
		case "月":
			startTimeRealTemp = startDateParse.AddDate(0, -leadValue, 0)
		case "季":
			startTimeRealTemp = startDateParse.AddDate(0, -3*leadValue, 0)
		case "周":
			startTimeRealTemp = startDateParse.AddDate(0, 0, -7*leadValue)
		case "年":
			startTimeRealTemp = startDateParse.AddDate(-leadValue, 0, 0)
		}

		if startTimeRealTemp.Before(startDateParse) {
			startDateReal = startTimeRealTemp.Format(utils.FormatDate)
			diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
		} else {
			startDateReal = startDate
			diffSeconds = 0
		}
	} else {
		startDateReal = startDate
	}

	var dataList []*data_manage.EdbDataList
	var minData, maxData float64

	switch edbInfo.EdbInfoType {
	case 0: //普通源指标
		dataList, err = data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfoId, startDateReal, endDate)
		if err != nil {
			br.Msg = "获取失败"
			br.Msg = "获取失败,Err:" + err.Error()
			return
		}
		//查询区间内最大最小值
		minData, maxData, err = data_manage.GetEdbDataListMinAndMax(edbInfo.Source, edbInfo.SubSource, edbInfoId, startDateReal, endDate)
		if err != nil {
			br.Msg = "获取失败"
			br.Msg = "获取指标最新的最大最小值失败,Err:" + err.Error()
			return
		}
	case 1: //预测指标
		tmpDataList, sourceEdbInfoItem, _, err, _ := data.GetPredictDataListByPredictEdbInfo(edbInfo, startDateReal, endDate, isTimeBetween)
		if err != nil {
			br.Msg = "获取失败"
			br.Msg = "获取失败,Err:" + err.Error()
			return
		}
		dataList = tmpDataList
		// 有预测数据，且为普通的预测指标
		if len(dataList) > 0 && edbInfo.EdbInfoType == 0 {
			//查询区间内最大最小值
			minData, maxData, err = data_manage.GetEdbDataListMinAndMax(sourceEdbInfoItem.Source, sourceEdbInfoItem.SubSource, sourceEdbInfoItem.EdbInfoId, startDateReal, endDate)
			if err != nil {
				br.Msg = "获取失败"
				br.Msg = "获取指标最新的最大最小值失败,Err:" + err.Error()
				return
			}

			tmpValue := dataList[len(dataList)-1]

			// 如果最大值 小于 预测值，那么将预测值作为最大值数据返回
			if edbInfo.MaxValue < tmpValue.Value {
				maxData = tmpValue.Value
			}

			// 如果最小值 大于 预测值，那么将预测值作为最小值数据返回
			if edbInfo.MinValue > tmpValue.Value {
				minData = tmpValue.Value
			}
		}
	}

	moveLatestDate := edbInfo.LatestDate
	if diffSeconds != 0 {
		dataListLen := len(dataList)
		for i := 0; i < dataListLen; i++ {
			dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
		}

		day, err := utils.GetDaysBetween2Date(utils.FormatDate, startDate, startDateReal)
		if err != nil {
			br.Msg = "获取失败"
			br.Msg = "获取领先滞后的的日期间隔失败,Err:" + err.Error()
			return
		}
		moveLatestDateTime, err := time.ParseInLocation(utils.FormatDate, moveLatestDate, time.Local)
		if err != nil {
			br.Msg = "获取失败"
			br.Msg = "指标日期转换失败,Err:" + err.Error()
			return
		}
		moveLatestDate = moveLatestDateTime.AddDate(0, 0, day).Format(utils.FormatDate)
	}
	mapping := new(data_manage.ChartEdbInfoMapping)
	mapping.EdbInfoId = edbInfo.EdbInfoId
	mapping.EdbInfoCategoryType = edbInfo.EdbInfoType
	mapping.SourceName = edbInfo.SourceName
	mapping.Source = edbInfo.Source
	mapping.EdbCode = edbInfo.EdbCode
	mapping.EdbName = edbInfo.EdbName
	mapping.EdbType = edbInfo.EdbType
	mapping.Frequency = edbInfo.Frequency
	mapping.Unit = edbInfo.Unit
	mapping.StartDate = edbInfo.StartDate
	mapping.EndDate = edbInfo.EndDate
	mapping.ChartEdbMappingId = 0
	mapping.ChartInfoId = 0
	mapping.MaxData = maxData
	mapping.MinData = minData
	mapping.IsOrder = false
	mapping.IsAxis = 1
	mapping.EdbInfoType = 1
	mapping.LeadValue = 0
	mapping.LeadUnit = ""
	mapping.LeadUnitEn = ""
	mapping.ChartStyle = ""
	mapping.ChartColor = ""
	mapping.PredictChartColor = ""
	mapping.ChartWidth = 0
	mapping.LatestDate = edbInfo.LatestDate
	mapping.MoveLatestDate = moveLatestDate
	mapping.DataList = dataList

	resp := new(data_manage.ChartEdbInfoDetailResp)
	resp.EdbInfo = mapping
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ChartInfoSearch
// @Title 图表模糊搜索
// @Description 图表模糊搜索接口
// @Param   KeyWord   query   string  true       "图表名称"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartInfo
// @router /chart_info/search [get]
func (this *ChartInfoController) ChartInfoSearch() {
	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
	}
	keyWord := this.GetString("KeyWord")
	searchList := make([]*data_manage.ChartInfo, 0)
	//var err error
	//if KeyWord == "" {
	//	searchList, err = data_manage.ChartInfoSearchByKeyWord(KeyWord)
	//	if err != nil && err.Error() != utils.ErrNoRow() {
	//		br.Msg = "获取失败"
	//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
	//		return
	//	}
	//} else {
	//	searchList, err = data.EsSearchChartInfo(KeyWord)
	//	if err != nil && err.Error() != utils.ErrNoRow() {
	//		br.Msg = "获取失败"
	//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
	//		return
	//	}
	//}
	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	showSysId := 0
	if isShowMe {
		showSysId = sysUser.AdminId
	}

	var keyWordArr []string
	keyWordArr = append(keyWordArr, keyWord)
	if keyWord != "" {
		newKeyWord := strings.Split(keyWord, " ")
		keyWordArr = append(keyWordArr, newKeyWord...)
	}
	existMap := make(map[int]string)
	for _, v := range keyWordArr {
		v = strings.Replace(v, " ", "%", -1)
		newSearchList, err := data_manage.ChartInfoSearchByKeyWord(v, showSysId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
		for _, nv := range newSearchList {
			if _, ok := existMap[nv.ChartInfoId]; !ok {
				searchList = append(searchList, nv)
			}
			existMap[nv.ChartInfoId] = nv.ChartName
		}
	}

	if searchList == nil {
		searchList = make([]*data_manage.ChartInfo, 0)
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyWord
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = searchList
}

// ChartInfoSearchByEs
// @Title 图表模糊搜索（从es获取）
// @Description  图表模糊搜索（从es获取）
// @Param   Keyword   query   string  true       "图表名称"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Success 200 {object} data_manage.ChartInfo
// @router /chart_info/search_by_es [get]
func (this *ChartInfoController) ChartInfoSearchByEs() {
	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
	}

	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, []int{utils.CHART_SOURCE_DEFAULT}, noPermissionChartIdList, startSize, pageSize)
	} else {
		total, searchList, err = data_manage.ChartInfoSearchByEmptyKeyWord(showSysId, []int{utils.CHART_SOURCE_DEFAULT}, noPermissionChartIdList, startSize, pageSize)
		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 edbTmpList, ok := chartEdbMap[v.ChartInfoId]; ok {
				tmp.IsEnChart = data.CheckIsEnChart(v.ChartNameEn, edbTmpList, 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
}

// @Title 图表刷新接口
// @Description 图表刷新接口
// @Param   ChartInfoId   query   int  true       "图表id"
// @Param   UniqueCode   query   string  true       "唯一code"
// @Success Ret=200 刷新成功
// @router /chart_info/refresh [get]
func (this *EdbInfoController) 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, isAsync := 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 = "刷新成功"
	if isAsync {
		br.Msg = "图表关联指标较多，请10分钟后刷新页面查看最新数据"
	}
}

// @Title 设置图表图片
// @Description 设置图表图片接口
// @Param	request	body data_manage.SetChartInfoImageReq true "type json string"
// @Success Ret=200 保存成功
// @router /chart_info/image/set [post]
func (this *ChartInfoController) ChartInfoImageSet() {
	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.SetChartInfoImageReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ChartInfoId > 0 && req.ImageUrl != "" {
		err = data_manage.EditChartInfoImage(&req)
		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)
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
}

// ChartInfoDetailFromUniqueCode
// @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 *ChartInfoController) ChartInfoDetailFromUniqueCode() {
	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
	}

	//是否走缓存
	isCache, _ := this.GetBool("IsCache")

	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 {
		resp := new(data_manage.ChartInfoDetailFromUniqueCodeResp)
		endInfoList := make([]*data_manage.ChartEdbInfoMapping, 0)
		resp.EdbInfoList = endInfoList
		resp.ChartInfo = chartInfo
		resp.Status = false
		return
	}

	resp, isOk, msg, errMsg := GetChartInfoDetailFromUniqueCode(chartInfo, isCache, sysUser)
	if !isOk {
		br.Msg = msg
		br.ErrMsg = errMsg
		return
	}

	br.Ret = 200
	br.Success = true
	msg = "获取成功"
	br.Data = resp
}

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 data, err1 := utils.Rc.RedisBytes(key); err1 == nil {
				err := json.Unmarshal(data, &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
				}
			}
		}
	}

	// 获取主题样式
	chartTheme, err := data.GetChartThemeConfig(chartInfo.ChartThemeId, chartInfo.Source, chartInfo.ChartType)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取主题信息失败，Err:" + err.Error()
		return
	}
	
	chartInfo.ChartThemeStyle = chartTheme.Config

	chartInfoId := chartInfo.ChartInfoId

	dateType := chartInfo.DateType

	startDate := chartInfo.StartDate
	endDate := chartInfo.EndDate
	startYear := chartInfo.StartYear
	calendar := chartInfo.Calendar
	chartType := chartInfo.ChartType

	if calendar == "" {
		calendar = "公历"
	}

	fmt.Println("a dateType:", dateType)

	mappingList, err := data_manage.GetChartEdbMappingList(chartInfoId)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}

	yearMax := 0
	if dateType == utils.DateTypeNYears {
		for _, v := range mappingList {
			if v.LatestDate != "" {
				lastDateT, tErr := time.Parse(utils.FormatDate, v.LatestDate)
				if tErr != nil {
					msg = "获取失败"
					errMsg = "获取图表日期信息失败，Err:" + tErr.Error()
					return
				}
				if lastDateT.Year() > yearMax {
					yearMax = lastDateT.Year()
				}
			}
		}
	}
	startDate, endDate = utils.GetDateByDateTypeV2(dateType, startDate, endDate, startYear, yearMax)

	extraConfigStr := chartInfo.ExtraConfig //图表额外数据参数
	var barConfig data_manage.BarChartInfoReq
	// 柱方图的一些配置
	if chartInfo != nil && chartInfo.ChartType == 7 {
		if chartInfo.BarConfig == `` {
			msg = "柱方图未配置"
			errMsg = "柱方图未配置"
			return
		}

		err := json.Unmarshal([]byte(chartInfo.BarConfig), &barConfig)
		if err != nil {
			msg = "柱方图配置异常"
			errMsg = "柱方图配置异常"
			return
		}

		extraConfigStr = chartInfo.BarConfig
	}

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(chartInfoId, chartType, calendar, startDate, endDate, mappingList, extraConfigStr, chartInfo.SeasonExtraConfig)
	if err != nil {
		msg = "获取失败"
		if errMsg != `` {
			msg = errMsg
		}
		errMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	// 单位
	if chartType == utils.CHART_TYPE_BAR && len(yDataList) > 0 {
		chartInfo.Unit = yDataList[0].Unit
		chartInfo.UnitEn = yDataList[0].UnitEn
	}
	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}
	/*
		ChartClassify     []*ChartClassifyView
	*/

	chartClassify, _ := data_manage.GetChartClassifyViewById(chartInfo.ChartClassifyId)
	if chartClassify != nil {
		chartClassifyParent, _ := data_manage.GetChartClassifyViewById(chartClassify.ParentId)
		chartInfo.ChartClassify = append(chartInfo.ChartClassify, chartClassifyParent)
	}
	chartInfo.ChartClassify = append(chartInfo.ChartClassify, chartClassify)
	resp.EdbInfoList = edbList
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)
	//判断是否加入我的图库
	{
		var myChartCondition string
		var myChartPars []interface{}
		myChartCondition += ` AND a.admin_id=? `
		myChartPars = append(myChartPars, 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.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp.ChartInfo = chartInfo
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.Status = true
	resp.BarChartInfo = barConfig
	resp.DataResp = dataResp

	// 将数据加入缓存
	if utils.Re == nil {
		data, _ := json.Marshal(resp)
		utils.Rc.Put(key, data, 2*time.Hour)
	}
	isOk = true

	return
}

// @Param   Img   query   string  true       "图片"
// @Success 200 {object} models.ResourceResp
// @router /chart_info/base64Upload [post]
func (this *ChartInfoController) ChartInfoBase64Upload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	imgData := this.GetString("Img")
	if imgData == "" {
		br.Msg = "图片参数错误"
		br.ErrMsg = "图片参数错误,Img Is Empty"
		return
	}
	resp := new(models.ResourceResp)

	uploadDir := "static/images/"
	if !utils.FileIsExist(uploadDir) {
		err := os.MkdirAll(uploadDir, utils.DIR_MOD)
		if err != nil {
			br.Msg = "图表保存失败"
			br.ErrMsg = "存储目录创建失败,Err:" + err.Error()
			return
		}
	}

	var saveToOssPath string
	randStr := utils.GetRandStringNoSpecialChar(28)
	var fileName, outFileName string
	fileName = randStr + ".txt"
	fileName = uploadDir + fileName
	err := utils.SaveToFile(imgData, fileName)
	if err != nil {
		br.Msg = "图片保存失败"
		br.ErrMsg = "图片保存失败,Err:" + err.Error()
		return
	}
	outFileName = randStr + ".png"

	doneChannel := make(chan bool, 1)
	errorChannel := make(chan error, 1)

	cmd := exec.Command("highcharts-export-server", "--infile", fileName, "--constr", "Chart", "--scale", "2", "--workers", "10", "--workLimit", "3", "--outfile", outFileName)

	go func() {
		output, err := cmd.CombinedOutput()
		if err != nil {
			utils.FileLog.Info("execute command failed, output: , error: \n" + string(output) + err.Error())
			errorChannel <- err
			return
		}
		doneChannel <- true
	}()

	select {
	case <-time.After(30 * time.Second):
		utils.FileLog.Info("执行超过30秒 杀死超时进程")
		cmd.Process.Kill()
		fmt.Println("timeout kill process")
	case <-doneChannel:
		fmt.Println("done")
	case err := <-errorChannel:
		br.Msg = "文件上传失败"
		br.ErrMsg = fmt.Sprintf("execute command failure err: %s", err.Error())
		fmt.Println("execute command failure err:" + err.Error())
		return
	}

	defer func() {
		os.Remove(fileName)
	}()

	saveToOssPath = uploadDir + time.Now().Format("200601/20060102/")
	saveToOssPath += outFileName

	//上传到阿里云 和 minio
	resourceUrl := ``
	if utils.ObjectStorageClient == "minio" {
		err = services.UploadFileToMinIo("", outFileName, saveToOssPath)
		if err != nil {
			br.Msg = "文件上传失败"
			br.ErrMsg = "文件上传失败，Err:" + err.Error()
			return
		}
		resourceUrl = utils.MinIoImghost + saveToOssPath
	} else {
		err = services.UploadFileToAliyun("", outFileName, saveToOssPath)
		if err != nil {
			br.Msg = "文件上传失败"
			br.ErrMsg = "文件上传失败，Err:" + err.Error()
			return
		}
		resourceUrl = utils.Imghost + saveToOssPath
	}

	resp.ResourceUrl = resourceUrl
	resp.Source = "convert"
	//resp.CacheKey = imgDataKey
	br.Msg = "上传成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
	return
}

// BatchChartInfoRefresh
// @Title 批量刷新图表接口
// @Description 批量刷新图表接口
// @Param	request	body data_manage.BatchChartRefreshReq true "type json string"
// @Success Ret=200 刷新成功
// @router /chart_info/batch_refresh [post]
func (this *EdbInfoController) BatchChartInfoRefresh() {
	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.BatchChartRefreshReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	//获取所有的图表列表
	_, chartInfoList, err := data_manage.GetChartInfoListByUniqueCodeSlice(req.ChartInfoCode)
	if len(chartInfoList) <= 0 {
		br.Ret = 200
		br.Success = true
		br.Msg = "刷新成功"
		return
	}

	redisKey := data.GetBatchChartRefreshKey(req.Source, req.ReportId, req.ReportChapterId)

	// 图表中的指标刷新
	err, isAsync := data.BatchChartInfoRefreshV2(chartInfoList, redisKey)
	if err != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新图表关联指标信息失败，Err:" + err.Error()
		return
	}
	br.Msg = "刷新成功"
	if isAsync {
		br.Msg = "研报中图表关联指标较多，请10分钟后刷新页面查看最新数据"
	}
	br.Ret = 200
	br.Success = true

}

// CopyChartInfo
// @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 *ChartInfoController) CopyChartInfo() {
	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
	}

	//校验图表名称是否重复
	req.ChartName = strings.Trim(req.ChartName, " ")
	if req.ChartName == "" {
		br.Msg = "请填写图表名称！"
		return
	}
	if req.ChartClassifyId <= 0 {
		br.Msg = "分类参数错误！"
		return
	}
	chartClassify, err := data_manage.GetChartClassifyById(req.ChartClassifyId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "分类不存在"
			br.ErrMsg = "分类不存在"
			return
		}
		br.Msg = "获取分类信息失败"
		br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
		return
	}
	if chartClassify == nil {
		br.Msg = "分类不存在"
		br.ErrMsg = "分类不存在"
		return
	}
	//count, err := data_manage.ChartInfoExist("", edbInfoIdStr)
	//if err != nil && err.Error() != utils.ErrNoRow() {
	//	br.Msg = "保存失败"
	//	br.ErrMsg = "判断图表名称是否存在失败,Err:" + err.Error()
	//	return
	//}
	//if count > 0 {
	//	br.Msg = "所选指标已存在相同指标"
	//	return
	//}
	//判断图表是否存在
	var condition string
	var pars []interface{}
	condition += " AND chart_classify_id=? "
	pars = append(pars, req.ChartClassifyId)

	condition += " AND chart_name=? AND source = ? "
	pars = append(pars, req.ChartName, utils.CHART_SOURCE_DEFAULT)

	count, err := data_manage.GetChartInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断图表名称是否存在失败"
		br.ErrMsg = "判断图表名称是否存在失败,Err:" + err.Error()
		return
	}

	if count > 0 {
		br.Msg = "图表已存在，请重新填写"
		br.IsSendEmail = false
		return
	}

	//获取原图表关联的指标信息列表
	edbMappingList, err := data_manage.GetChartEdbMappingList(req.ChartInfoId)
	if err != nil {
		br.Msg = "获取图表关联的指标信息失败！"
		return
	}

	//添加图表
	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	chartInfo := &data_manage.ChartInfo{
		ChartInfoId:     0,
		ChartName:       req.ChartName,
		ChartClassifyId: req.ChartClassifyId,
		SysUserId:       sysUser.AdminId,
		SysUserRealName: sysUser.RealName,
		UniqueCode:      utils.MD5(utils.CHART_PREFIX + "_" + timestamp),
		CreateTime:      time.Now(),
		ModifyTime:      time.Now(),
		DateType:        oldChartInfo.DateType,
		StartDate:       oldChartInfo.StartDate,
		EndDate:         oldChartInfo.EndDate,
		IsSetName:       oldChartInfo.IsSetName,
		EdbInfoIds:      oldChartInfo.EdbInfoIds,
		ChartType:       oldChartInfo.ChartType,
		Calendar:        oldChartInfo.Calendar,
		SeasonStartDate: oldChartInfo.SeasonStartDate,
		SeasonEndDate:   oldChartInfo.SeasonEndDate,
		ChartImage:      oldChartInfo.ChartImage,
		BarConfig:       oldChartInfo.BarConfig,
		//Sort:     sort,
		LeftMin:           oldChartInfo.LeftMin,
		LeftMax:           oldChartInfo.LeftMax,
		RightMin:          oldChartInfo.RightMin,
		RightMax:          oldChartInfo.RightMax,
		Disabled:          oldChartInfo.Disabled,
		Source:            oldChartInfo.Source,
		ExtraConfig:       oldChartInfo.ExtraConfig,
		SeasonExtraConfig: oldChartInfo.SeasonExtraConfig,
		StartYear:         oldChartInfo.StartYear,
	}
	newId, err := data_manage.AddChartInfo(chartInfo)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败，Err:" + err.Error()
		return
	}
	chartInfo.ChartInfoId = int(newId)

	// 添加图表与指标的关联关系
	{
		mapList := make([]*data_manage.ChartEdbMapping, 0)
		for _, v := range edbMappingList {
			timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
			mapItem := &data_manage.ChartEdbMapping{
				//ChartEdbMappingId: 0,
				ChartInfoId: chartInfo.ChartInfoId,
				EdbInfoId:   v.EdbInfoId,
				CreateTime:  time.Now(),
				ModifyTime:  time.Now(),
				UniqueCode:  utils.MD5(utils.CHART_PREFIX + "_" + timestamp),
				MaxData:     v.MaxData,
				MinData:     v.MinData,
				IsOrder:     v.IsOrder,
				IsAxis:      v.IsAxis,
				EdbInfoType: v.EdbInfoType,
				LeadValue:   v.LeadValue,
				LeadUnit:    v.LeadUnit,
				ChartStyle:  v.ChartStyle,
				ChartColor:  v.ChartColor,
				ChartWidth:  v.ChartWidth,
				Source:      v.Source,
			}
			mapList = append(mapList, mapItem)
		}
		err = data_manage.AddChartEdbMapping(mapList)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "保存失败，Err:" + err.Error()
			return
		}
	}

	//添加es数据
	go data.EsAddOrEditChartInfo(chartInfo.ChartInfoId)
	//修改my eta es数据
	go data.EsAddOrEditMyChartInfoByChartInfoId(chartInfo.ChartInfoId)

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartInfoId = chartInfo.ChartInfoId
		chartLog.ChartName = req.ChartName
		chartLog.ChartClassifyId = req.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)
	}

	// 试用平台更新用户累计新增图表数
	adminItem, e := system.GetSysAdminById(sysUser.AdminId)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取系统用户数据失败，Err:" + err.Error()
		return
	}
	if utils.BusinessCode == utils.BusinessCodeSandbox && adminItem.DepartmentName == "ETA试用客户" {
		go func() {
			var r etaTrialService.EtaTrialUserReq
			r.Mobile = adminItem.Mobile
			_, _ = etaTrialService.UpdateUserChartNum(r)
		}()
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = data_manage.AddChartInfoResp{
		ChartInfoId: chartInfo.ChartInfoId,
		UniqueCode:  chartInfo.UniqueCode,
		ChartType:   chartInfo.ChartType,
	}
	br.IsAddLog = true
}

// PreviewBarChartInfo
// @Title 图表-获取预览的柱方图数据
// @Description 图表-获取指标详情接口
// @Param	request	body data_manage.BarChartInfoReq true "type json string"
// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
// @router /chart_info/preview_bar [post]
func (this *ChartInfoController) PreviewBarChartInfo() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req data_manage.BarChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	if len(req.EdbInfoIdList) <= 0 {
		br.Msg = "请选择指标"
		return
	}
	if len(req.DateList) <= 0 {
		br.Msg = "请选择日期"
		return
	}
	chartInfo := new(data_manage.ChartInfoView)
	chartType := utils.CHART_TYPE_BAR

	//edbInfoIdList := make([]int, 0)
	edbInfoIdsList := make([]string, 0)
	for _, v := range req.EdbInfoIdList {
		edbInfoIdsList = append(edbInfoIdsList, strconv.Itoa(v.EdbInfoId))
	}
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoId(strings.Join(edbInfoIdsList, ","))
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(0, chartType, "", "", "", mappingList, string(this.Ctx.Input.RequestBody), "")
	if err != nil {
		br.Msg = "获取失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	// 单位
	if len(yDataList) > 0 {
		chartInfo.Unit = yDataList[0].Unit
		chartInfo.UnitEn = yDataList[0].UnitEn
	}
	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
		for _, reqEdb := range req.EdbInfoIdList {
			if v.EdbInfoId == reqEdb.EdbInfoId {
				v.EdbAliasName = reqEdb.Name
			}
		}
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.DataResp = dataResp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// PreviewSectionScatterChartInfo
// @Title 图表-获取预览的截面散点图数据
// @Description 图表-获取指标详情接口
// @Param	request	body data_manage.SectionScatter true "type json string"
// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
// @router /chart_info/preview/time_section [post]
func (this *ChartInfoController) PreviewSectionScatterChartInfo() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req data_manage.PreviewSectionScatterChartReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	chartInfo := new(data_manage.ChartInfoView)

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	chartType := utils.CHART_TYPE_SECTION_SCATTER
	edbInfoIdArr, err, errMsg := data.CheckChartExtraConfig(chartType, req.ExtraConfig)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = "添加失败:" + err.Error()
		return
	}

	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIdArr)

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(0, chartType, "", "", "", mappingList, req.ExtraConfig, "")
	if err != nil {
		br.Msg = "获取失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	warnEdbList := make([]string, 0)
	for _, v := range edbList {
		if v.IsNullData {
			warnEdbList = append(warnEdbList, v.EdbName+"("+v.EdbCode+")")
		}
	}
	if len(warnEdbList) > 0 {
		chartInfo.WarnMsg = `图表引用指标异常，异常指标：` + strings.Join(warnEdbList, "，")
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, utils.CHART_SOURCE_DEFAULT, chartType)
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp := new(data_manage.ChartInfoDetailResp)
	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.XEdbIdValue = xEdbIdValue
	resp.YDataList = yDataList
	resp.DataResp = dataResp
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// GetBatchChartRefreshResult
// @Title 获取批量刷新图表结果的接口
// @Description 获取批量刷新图表结果的接口
// @Param	request	body data_manage.BatchChartRefreshReq true "type json string"
// @Success Ret=200 刷新成功
// @router /chart_info/batch_refresh/result [post]
func (this *EdbInfoController) GetBatchChartRefreshResult() {
	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.BatchChartRefreshReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	// 刷新结果，默认是刷新完成了
	refreshResult := data.CheckBatchChartRefreshResult(req.Source, req.ReportId, req.ReportChapterId)

	resp := response.ChartRefreshResp{
		RefreshResult: refreshResult,
	}

	br.Data = resp
	br.Ret = 200
	br.Success = true

}

//
//修复数据时间戳

//func init() {
//	fmt.Println("start")
//	edbInfoList,err:=data_manage.GetEdbInfo()
//	if err!=nil {
//		fmt.Println("Err:",err.Error())
//		return
//	}
//	startDate:=time.Now().AddDate(-40,0,0).Format(utils.FormatDate)
//	endDate:=time.Now().Format(utils.FormatDate)
//	for _,v:=range edbInfoList{
//		dataList,err:=data_manage.GetEdbDataList(v.Source,v.EdbInfoId,startDate,endDate)
//		if err!=nil {
//			fmt.Println("GetEdbDataList Err:",err.Error())
//			return
//		}
//		for _,dv:=range dataList{
//			dataTime,err:=time.Parse(utils.FormatDate,dv.DataTime)
//			if err!=nil {
//				fmt.Println("time.Parse Err:"+err.Error())
//				return
//			}
//			timestamp:=dataTime.UnixNano()/1e6
//			err=data_manage.ModifyEdbDatadTimestamp(v.Source,dv.EdbDataId,timestamp)
//			if err!=nil{
//				fmt.Println("ModifyEdbDatadTimestamp Err:"+err.Error())
//				return
//			}
//			fmt.Println(v.Source,dv.EdbDataId,timestamp)
//		}
//	}
//	//time.Sleep(2*time.Minute)
//
//	//startDate:=time.Now().AddDate(-30,0,0).Format(utils.FormatDate)
//	//endDate:=time.Now().Format(utils.FormatDate)
//	//dataList,err:=data_manage.GetEdbDataList(1,100099,startDate,endDate)
//	//if err!=nil {
//	//	fmt.Println("GetEdbDataList Err:",err.Error())
//	//	return
//	//}
//	//for _,dv:=range dataList{
//	//	dataTime,err:=time.Parse(utils.FormatDate,dv.DataTime)
//	//	if err!=nil {
//	//		fmt.Println("time.Parse Err:"+err.Error())
//	//		return
//	//	}
//	//	timestamp:=dataTime.UnixNano()/1e6
//	//	err=data_manage.ModifyEdbDatadTimestamp(2,dv.EdbDataId,timestamp)
//	//	if err!=nil{
//	//		fmt.Println("ModifyEdbDatadTimestamp Err:"+err.Error())
//	//		return
//	//	}
//	//	fmt.Println(2,dv.EdbDataId,timestamp)
//	//}
//
//	fmt.Println("end")
//}

//修复指标配置数据
//func init() {
//	fmt.Println("start")
//	edbInfo, err := data_manage.GetEdbInfoAll()
//	fmt.Println(err)
//	for k, v := range edbInfoAll {
//		fmt.Println(k, v.EdbInfoId)
//		item, err := data_manage.GetEdbInfoMaxAndMinInfo(v.Source, v.EdbCode)
//		fmt.Println(item, err)
//		err = data_manage.ModifyEdbInfoMaxAndMinInfo(v.EdbInfoId, item)
//		if err != nil {
//			fmt.Println("ModifyEdbInfoMaxAndMinInfo Err:" + err.Error())
//		}
//	}
//	fmt.Println("end")
//}

//func init() {
//	fmt.Println("start")
//	var yearArr []int
//	yearArr = append(yearArr, 2021)
//	yearArr = append(yearArr, 2010)
//	yearArr = append(yearArr, 2020)
//	yearArr = append(yearArr, 2017)
//	yearArr = append(yearArr, 2019)
//	sort.Sort(sort.Reverse(sort.IntSlice(yearArr)))
//	fmt.Println(yearArr)
//	fmt.Println("end")
//}

//季度指标数据计算(公历转农历)
//func init() {
//	fmt.Println("start AddCalculateQuarter")
//	list:=make([]*data_manage.EdbDataList,0)
//	data_manage.AddCalculateQuarterV4(list)
//	fmt.Println("end AddCalculateQuarter")
//	//return
//}

/*
{
  "ChartClassifyId": 58,
  "ChartName": "公历转农历6",
  "ChartType": 2,
  "ChartEdbInfoList": [
    {
      "ChartColor": "#00f",
      "ChartStyle": "spline",
      "ChartWidth": 3,
      "EdbInfoId": 100466,
      "EdbInfoType": 1,
      "IsAxis": 1,
      "IsOrder": false,
      "LeadUnit": "",
      "LeadValue": 0,
      "MaxData": 0.2943,
      "MinData": -0.2448
    }
  ]
}
*/
//func init() {
//	fmt.Println("start")
//	data_manage.AddCalculateQuarter(100466,6,"C2108252836")
//	fmt.Println("end")
//}

//func init() {
//	data.AddAllChartInfo()
//}

// 截面散点示例数据
//func init() {
//
//	seriesList := []data_manage.SectionScatterSeriesItemReq{
//		{
//			Name:  "系列1名称",
//			Color: "红红火火色",
//			EdbList: []data_manage.SectionScatterEdbItemReq{
//				{
//					XEdbInfoId: 1,
//					YEdbInfoId: 2,
//					Name:       "破铜",
//					NameEn:     "Po Tong",
//					XDateType:  1,
//					XDate:      "",
//					XDateValue: 0,
//					YDateType:  2,
//					YDate:      "",
//					YDateValue: 30,
//					IsShow:     false,
//				},
//				{
//					XEdbInfoId: 3,
//					YEdbInfoId: 4,
//					Name:       "烂铁",
//					NameEn:     "Lan Tie",
//					XDateType:  2,
//					XDate:      "",
//					XDateValue: 30,
//					YDateType:  3,
//					YDate:      "2023-02-17",
//					YDateValue: 0,
//					IsShow:     false,
//				},
//			},
//			ShowLine:     false,
//			ShowEquation: false,
//			ShowR:        false,
//		},
//		{
//			Name:  "系列2名称",
//			Color: "恍恍惚惚色",
//			EdbList: []data_manage.SectionScatterEdbItemReq{
//				{
//					XEdbInfoId: 1,
//					YEdbInfoId: 2,
//					Name:       "破铜",
//					NameEn:     "Po Tong",
//					XDateType:  3,
//					XDate:      "2023-02-17",
//					XDateValue: 0,
//					YDateType:  2,
//					YDate:      "",
//					YDateValue: 60,
//					IsShow:     true,
//				},
//				{
//					XEdbInfoId: 3,
//					YEdbInfoId: 4,
//					Name:       "烂铁",
//					NameEn:     "Lan Tie",
//					XDateType:  3,
//					XDate:      "2023-02-17",
//					XDateValue: 0,
//					YDateType:  2,
//					YDate:      "",
//					YDateValue: 60,
//					IsShow:     false,
//				},
//			},
//			ShowLine:     false,
//			ShowEquation: false,
//			ShowR:        false,
//		},
//	}
//	rel := data_manage.SectionScatter{
//		XName:       "X轴名称",
//		XNameEn:     "X english name",
//		XUnitName:   "X轴单位",
//		XUnitNameEn: "X unit english name",
//		YName:       "Y轴名称",
//		YNameEn:     "Y english name",
//		YUnitName:   "Y轴单位",
//		YUnitNameEn: "Y unit english name",
//		SeriesList:  seriesList,
//	}
//	jsonByte, _ := json.Marshal(rel)
//	utils.FileLog.Info(string(jsonByte))
//}

//	func init() {
//		var a, b float64
//
//		testX := []float64{1, 3, 8, 7, 9}
//		testY := []float64{10, 12, 24, 21, 34}
//		{
//			coordinateData := make([]utils.Coordinate, 0)
//			for k, x := range testX {
//				tmpCoordinate1 := utils.Coordinate{
//					X: x,
//					Y: testY[k],
//				}
//				coordinateData = append(coordinateData, tmpCoordinate1)
//			}
//			a, b = utils.GetLinearResult(coordinateData)
//			trendLine := fmt.Sprintf("y=%sx+%s", utils.SubFloatToString(a, 4), utils.SubFloatToString(b, 4))
//
//			fmt.Println(trendLine)
//		}
//
//		{
//			r2 := utils.CalculationDecisive(testX, testY)
//			fmt.Println(r2)
//		}
//	}

// FixChart 修复季节性图的日期数据
//func FixChart() {
//	var condition string
//	var pars []interface{}
//
//	// 普通图表
//	condition += ` AND chart_type = ? AND season_start_date != "" `
//	pars = append(pars, 2)
//
//	//获取图表信息
//	list, err := data_manage.GetChartInfoListByCondition(condition, pars, 0, 10000)
//	if err != nil {
//		fmt.Println("err:", err)
//		return
//	}
//
//	for _, v := range list {
//		fmt.Println(v)
//		v.SeasonStartDate = v.SeasonStartDate + "-01"
//		v.SeasonEndDate = v.SeasonEndDate + "-12"
//		err = v.Update([]string{"SeasonStartDate", "SeasonEndDate"})
//		if err != nil {
//			fmt.Println(v.ChartInfoId, ";", v.ChartName, "修改失敗")
//		}
//		data.EsAddOrEditChartInfo(v.ChartInfoId)
//		data.EsAddOrEditMyChartInfoByChartInfoId(v.ChartInfoId)
//	}
//}