eta_api/controllers/data_manage/chart_info.go

package data_manage

import (
	"encoding/json"
	"eta_gn/eta_api/controllers"
	"eta_gn/eta_api/models"
	"eta_gn/eta_api/models/data_manage"
	"eta_gn/eta_api/models/data_manage/request"
	"eta_gn/eta_api/models/data_manage/response"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/services"
	"eta_gn/eta_api/services/data"
	"eta_gn/eta_api/services/data/data_manage_permission"
	"eta_gn/eta_api/services/data/excel"
	"eta_gn/eta_api/services/elastic"
	"eta_gn/eta_api/services/eta_forum"
	"eta_gn/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"os"
	"os/exec"
	"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 utils.IsErrNoRow(err) {
			br.Msg = "图表已被删除，请刷新页面！"
			br.ErrMsg = "图表已被删除，请刷新页面，ChartInfoId:" + strconv.Itoa(req.ChartInfoId)
			return
		}
		br.Msg = "获取图表信息失败！"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	//图表操作权限

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

	err = data_manage.ModifyChartInfoAndMapping(chartItem.EdbInfoIds, &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.AddOrEditChartInfoToEs(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
	}

	// 来源字数校验
	type SourcesFrom struct {
		Text string `json:"text"`
	}

	if req.SourcesFrom != "" && len(req.SourcesFrom) > 0 {
		var sourcesFrom SourcesFrom
		err = json.Unmarshal([]byte(req.SourcesFrom), &sourcesFrom)
		if err != nil {
			return
		}
		if len(sourcesFrom.Text) > 50 {
			br.Msg = "字数已达上限！"
			br.ErrMsg = "来源文本字数已达上限，请修改！"
			return
		}
	}

	// 说明字数校验
	if req.Instructions != "" && len(req.Instructions) > 0 {
		var instructions SourcesFrom
		err = json.Unmarshal([]byte(req.Instructions), &instructions)
		if err != nil {
			return
		}
		if len(instructions.Text) > 100 {
			br.Msg = "字数已达上限！"
			br.ErrMsg = "说明文本字数已达上限，请修改！"
			return
		}
	}

	chartInfo, err, errMsg, isSendEmail := data.AddChartInfo(req, sysUser.AdminId, sysUser.RealName, this.Lang)
	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)
	}

	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, this.Lang)
	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
}

// ChartEnInfoEdit
// @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 utils.IsErrNoRow(err) {
			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 utils.IsErrNoRow(err) {
				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 !utils.IsErrNoRow(err) {
					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 !utils.IsErrNoRow(err) {
				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.AddOrEditChartInfoToEs(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 utils.IsErrNoRow(err) {
				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
}

// ChartInfoBaseEdit
// @Title 编辑图表基础信息接口
// @Description 编辑图表基础信息接口
// @Param	request	body data_manage.EditChartEnInfoBaseReq true "type json string"
// @Success Ret=200 编辑成功
// @router /chart_info/base/edit [post]
func (this *ChartInfoController) ChartInfoBaseEdit() {
	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.EditChartInfoBaseReq
	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.ChartInfoId <= 0 {
		br.Msg = "请选择图表"
		return
	}

	//判断指标名称是否存在
	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			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
	}

	for _, v := range req.ChartEdbInfoList {
		edbInfoId := v.EdbInfoId
		edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				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
		}

		// 根据指标名称和指标ID校验库中是否还存在其他同名指标
		if v.EdbName != "" {
			existEdbName, err := data.CheckExistByEdbNameAndEdbInfoId(utils.EDB_INFO_TYPE, edbInfo.EdbInfoId, this.SysUser.AdminId, v.EdbName, this.Lang)
			if err != nil {
				br.Msg = "判断指标名称是否存在失败"
				br.ErrMsg = "判断指标名称是否存在失败,Err:" + err.Error()
				return
			}
			if existEdbName {
				br.Msg = v.EdbName + "：" + v.EdbName + "指标名称已存在"
				br.ErrMsg = "指标名称已存在，请重新填写"
				br.IsSendEmail = false
				return
			}
		}
	}
	if req.ChartName != "" || req.ExtraConfig != `` {
		var condition string
		var pars []interface{}
		condition += " AND chart_info_id<>? "
		pars = append(pars, req.ChartInfoId)

		switch this.Lang {
		case utils.EnLangVersion:
			condition += " AND chart_name_en = ? "
		default:
			condition += " AND chart_name = ? "
		}

		pars = append(pars, req.ChartName)

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

		if err == nil && existItem.ChartInfoId > 0 {
			br.Msg = existItem.ChartName + "：" + req.ChartName + "图表名称已存在"
			return
		}
	}

	err = data_manage.EditChartBaseInfoAndEdbEnInfo(&req, chartItem, this.Lang)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败,Err:" + err.Error()
		return
	}
	//添加es数据
	go data.AddOrEditChartInfoToEs(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 utils.IsErrNoRow(err) {
				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 && !utils.IsErrNoRow(err) {
		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
	}

	// 数据权限校验
	{
		haveOperaAuth, err := data_manage_permission.CheckChartPermissionByChartInfoId(chartInfo.ChartInfoId, chartInfo.ChartClassifyId, chartInfo.IsJoinPermission, sysUser.AdminId)
		if err != nil {
			br.Msg = "移动失败"
			br.ErrMsg = "获取图表权限失败,Err:" + err.Error()
			return
		}
		if !haveOperaAuth {
			br.Msg = "无操作权限"
			br.ErrMsg = "无操作权限"
			br.IsSendEmail = false
			return
		}
	}

	//如果改变了分类，那么移动该图表数据
	if chartInfo.ChartClassifyId != req.ChartClassifyId {
		//查询需要修改的分类下是否存在同一个图表名称
		tmpChartInfo, tmpErr := data_manage.GetChartInfoByClassifyIdAndName(req.ChartClassifyId, chartInfo.ChartName)
		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
			br.Msg = "移动失败"
			br.ErrMsg = "移动失败,Err:" + tmpErr.Error()
			return
		}
		if tmpErr == nil && tmpChartInfo.ChartInfoId > 0 {
			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 && !utils.IsErrNoRow(err) {
			br.Msg = "移动失败"
			br.ErrMsg = "获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + err.Error()
			return
		}

		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
		if firstClassify != nil && firstClassify.ChartClassifyId > 0 && 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.AddOrEditChartInfoToEs(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)
	chartInfo.HaveOperaAuth = true

	if chartInfoId > 0 {
		chartInfo, err = data_manage.GetChartInfoViewById(chartInfoId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				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
		chartInfo.ChartThemeId = chartTheme.ChartThemeId

		// 图表数据权限
		{
			// 图表分类
			chartClassify, err := data_manage.GetChartClassifyById(chartInfo.ChartClassifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表分类信息失败，Err:" + err.Error()
				return
			}

			// 已授权分类id
			permissionChartIdList, permissionClassifyIdList, err := data_manage_permission.GetUserChartAndClassifyPermissionList(this.SysUser.AdminId, chartInfo.ChartInfoId, chartInfo.ChartClassifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取已授权分类id数据失败，Err:" + err.Error()
				return
			}
			chartInfo.HaveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(chartInfo.IsJoinPermission, chartClassify.IsJoinPermission, chartInfo.ChartInfoId, chartInfo.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
		}
	}

	resp := new(data_manage.ChartInfoDetailResp)

	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
			}
		}
	}
	for _, v := range mappingList {
		v.ConvertToResp()
	}

	// 图表额外数据参数
	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)

	if chartInfo.HaveOperaAuth {
		// 获取图表中的指标数据
		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
		}

		// 指标权限
		{

			classifyMap := make(map[int]*data_manage.EdbClassify)

			// 分类
			{
				classifyIdList := make([]int, 0)
				for _, v := range edbList {
					classifyIdList = append(classifyIdList, v.ClassifyId)
				}
				classifyList, tmpErr := data_manage.GetEdbClassifyByIdList(classifyIdList)
				if tmpErr != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取分类列表失败，Err:" + tmpErr.Error()
					return
				}
				for _, v := range classifyList {
					classifyMap[v.ClassifyId] = v
				}
			}
			// 获取所有有权限的指标和分类
			permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(sysUser.AdminId, 0, 0)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
				return
			}

			for _, item := range edbList {
				// 数据权限
				if currClassify, ok := classifyMap[item.ClassifyId]; ok {
					item.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(item.IsJoinPermission, currClassify.IsJoinPermission, item.EdbInfoId, item.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
				}
			}
		}

		// 单位
		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 && !utils.IsErrNoRow(err) {
					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
					}
				}
			}
		}

		// 图表的指标来源
		sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
		chartInfo.ChartSource = strings.Join(sourceNameList, ",")
		chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")
		//判断是否需要展示英文标识
		chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)

		resp.EdbInfoList = edbList
		resp.XEdbIdValue = xEdbIdValue
		resp.YDataList = yDataList
		resp.DataResp = dataResp
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, chartInfo.HaveOperaAuth)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}

	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp.ChartInfo = chartInfo
	resp.BarChartInfo = barConfig
	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
	}

	// 区分是否是来自平衡表图表的数据
	var chartInfoDataShow data.ChartInfoDataShow

	if req.ChartSource == utils.CHART_SOURCE_BALANCE_EXCEL { //来自平衡表图表的数据
		excelChartInfoDataShow := new(data.ExcelChartInfoDataShow)
		// 相关联指标
		mappingListTmp, dataListMap, err, errMsg := excel.GetBalanceExcelChartSingle(chartInfo.ChartInfoId, req.ChartEdbInfoList[0].EdbInfoId, "")
		if err != nil {
			br.Msg = errMsg
			br.ErrMsg = err.Error()
			return
		}
		excelChartInfoDataShow.DataListMap = dataListMap
		excelChartInfoDataShow.MappingListTmp = mappingListTmp
		chartInfoDataShow = excelChartInfoDataShow
	} else {
		chartInfoDataShow = &data.BaseChartInfoDataShow{}
	}

	mappingList, err := chartInfoDataShow.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()
				}
			}
		}
		if req.ChartEdbInfoList[k].IsConvert == 1 {
			v.IsConvert = 1
			v.ConvertType = req.ChartEdbInfoList[k].ConvertType
			v.ConvertValue = req.ChartEdbInfoList[k].ConvertValue
			v.ConvertUnit = req.ChartEdbInfoList[k].ConvertUnit
			v.ConvertEnUnit = req.ChartEdbInfoList[k].ConvertEnUnit
		}
		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
	} else if chartInfo != nil && chartInfo.ChartType == utils.CHART_TYPE_SECTION_COMBINE {
		extraConfigStr = req.ExtraConfig
	}

	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbDataV2(0, req.ChartType, calendar, startDate, endDate, mappingList, extraConfigStr, seasonExtraConfig, chartInfoDataShow)
	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, true)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}
	//判断是否需要展示英文标识
	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,
	}

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	// 标识线计算
	if req.MarkersLines != "" {
		markerLines := make([]data_manage.MarkersLine, 0)
		err = json.Unmarshal([]byte(req.MarkersLines), &markerLines)
		if err != nil {
			br.Msg = "标识线配置异常"
			br.ErrMsg = "标识线配置异常" + err.Error()
			return
		}
		for i := range markerLines {
			if markerLines[i].EdbType == 0 && markerLines[i].TimeIntervalType == 0 && markerLines[i].Axis != 3 {
				// 图上第一个指标且时间区间跟随图表
				if markerLines[i].MarkLineType == 2 {
					if edbList[0].IsAxis == 1 {
						value, err := data.MarkerLineCalculate(markerLines[i], edbList[0].DataList, chartInfo)
						if err != nil {
							br.Msg = "标识线配置异常"
							br.ErrMsg = "标识线配置异常" + err.Error()
							return
						}
						markerLines[i].Value = value
					} else {
						// 其他的都走指标计算
						edbInfo, err := data_manage.GetEdbInfoById(markerLines[i].EdbInfoId)
						if err != nil {
							br.Msg = "指标计算标识线获取指标信息异常"
							br.ErrMsg = "指标计算标识线获取指标信息异常" + err.Error()
							return
						}
						// 判断时间区间不为跟随图表的情况
						if markerLines[i].TimeIntervalType != 0 {
							startDate = markerLines[i].StartDate.Date
							endDate = markerLines[i].EndDate.Date
						}
						dataList, err := data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfo.EdbInfoId, startDate, endDate)
						if err != nil {
							br.Msg = "指标计算标识线获取指标数据异常"
							br.ErrMsg = "指标计算标识线获取指标数据异常" + err.Error()
							return
						}
						value, err := data.MarkerLineCalculate(markerLines[i], dataList, chartInfo)
						if err != nil {
							br.Msg = "标识线配置异常"
							br.ErrMsg = "标识线配置异常" + err.Error()
							return
						}
						markerLines[i].Value = value
					}
				}
			}
		}

		markerLineStr, err := json.Marshal(markerLines)
		if err != nil {
			br.Msg = "标识线配置异常"
			br.ErrMsg = "标识线配置异常" + err.Error()
			return
		}

		chartInfo.MarkersLines = string(markerLineStr)
	}

	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 utils.IsErrNoRow(err) {
			br.Msg = "该图表已删除，自动查看下一图表"
			br.ErrMsg = "该图表已删除，自动查看下一图表，Err:" + err.Error()
			br.Ret = 406
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	resp := new(data_manage.ChartInfoDetailResp)

	// 图表数据权限
	{
		// 图表分类
		chartClassify, err := data_manage.GetChartClassifyById(chartInfo.ChartClassifyId)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表分类信息失败，Err:" + err.Error()
			return
		}

		// 已授权分类id
		permissionChartIdList, permissionClassifyIdList, err := data_manage_permission.GetUserChartAndClassifyPermissionList(this.SysUser.AdminId, chartInfo.ChartInfoId, chartInfo.ChartClassifyId)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取已授权分类id数据失败，Err:" + err.Error()
			return
		}
		chartInfo.HaveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(chartInfo.IsJoinPermission, chartClassify.IsJoinPermission, chartInfo.ChartInfoId, chartInfo.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
	}

	// 获取主题样式
	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
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	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
	}

	if chartInfo.HaveOperaAuth {
		// 获取图表中的指标数据
		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 && !utils.IsErrNoRow(err) {
					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.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)

		// 图表的指标来源
		sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)

		chartInfo.ChartSource = strings.Join(sourceNameList, ",")
		chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

		// 指标权限
		{

			classifyMap := make(map[int]*data_manage.EdbClassify)

			// 分类
			{
				classifyIdList := make([]int, 0)
				for _, v := range edbList {
					classifyIdList = append(classifyIdList, v.ClassifyId)
				}
				classifyList, tmpErr := data_manage.GetEdbClassifyByIdList(classifyIdList)
				if tmpErr != nil {
					br.Msg = "获取失败"
					br.ErrMsg = "获取分类列表失败，Err:" + tmpErr.Error()
					return
				}
				for _, v := range classifyList {
					classifyMap[v.ClassifyId] = v
				}
			}
			// 获取所有有权限的指标和分类
			permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(sysUser.AdminId, 0, 0)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
				return
			}

			for _, item := range edbList {
				// 数据权限
				if currClassify, ok := classifyMap[item.ClassifyId]; ok {
					item.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(item.IsJoinPermission, currClassify.IsJoinPermission, item.EdbInfoId, item.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
				}
			}
		}

		// 没有就返回空数组
		if len(edbList) <= 0 {
			edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
		}

		resp.EdbInfoList = edbList
		resp.XEdbIdValue = xEdbIdValue
		resp.YDataList = yDataList
		resp.DataResp = dataResp
	} else {
		resp.EdbInfoList = mappingList
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, chartInfo.HaveOperaAuth)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}

	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    true,
		IsSetName: chartInfo.IsSetName,
	}

	resp.ChartInfo = chartInfo
	resp.BarChartInfo = barConfig
	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 = utils.TimeToFormatDate(edbInfo.StartDate)
	mapping.EndDate = utils.TimeToFormatDate(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       "图表名称"
// @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.ChartInfoMore, 0)
	//var err error
	//if KeyWord == "" {
	//	searchList, err = data_manage.ChartInfoSearchByKeyWord(KeyWord)
	//	if err != nil && !utils.IsErrNoRow(err) {
	//		br.Msg = "获取失败"
	//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
	//		return
	//	}
	//} else {
	//	searchList, err = data.EsSearchChartInfo(KeyWord)
	//	if err != nil && !utils.IsErrNoRow(err) {
	//		br.Msg = "获取失败"
	//		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
	//		return
	//	}
	//}
	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 && !utils.IsErrNoRow(err) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
		for _, nv := range newSearchList {
			if _, ok := existMap[nv.ChartInfoId]; !ok {
				searchList = append(searchList, data_manage.ChartInfoMore{
					ChartInfo: *nv,
				})
			}
			existMap[nv.ChartInfoId] = nv.ChartName
		}
	}

	if searchList == nil {
		searchList = make([]data_manage.ChartInfoMore, 0)
	}

	// 数据权限
	if len(searchList) > 0 {
		// 涉及分类id
		classifyIdList := make([]int, 0)
		for _, v := range searchList {
			classifyIdList = append(classifyIdList, v.ChartClassifyId)
		}

		// 图表分类
		chartClassifyList, err := data_manage.GetChartClassifyByIdList(classifyIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表分类失败，Err:" + err.Error()
			return
		}

		chartClassifyMap := make(map[int]*data_manage.ChartClassify)
		for _, v := range chartClassifyList {
			chartClassifyMap[v.ChartClassifyId] = v
		}

		// 已授权图表和分类id
		permissionChartIdList, permissionClassifyIdList, err := data_manage_permission.GetUserChartAndClassifyPermissionList(sysUser.AdminId, 0, 0)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "已授权图表和分类id失败，Err:" + err.Error()
			return
		}

		// 权限判断
		for k, v := range searchList {
			if currClassify, ok := chartClassifyMap[v.ChartClassifyId]; ok {
				searchList[k].HaveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(v.IsJoinPermission, currClassify.IsJoinPermission, v.ChartInfoId, v.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
			}
		}
	}

	//新增搜索词记录
	{
		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   ChartAuth   query   int  false       "图表权限：0-全部；1-我的；2-公共"
// @Param   ChartCollect   query   int  false       "图表收藏状态：0-全部；1-已收藏"
// @Param   ClassifyId   query   int  false       "父级分类id"
// @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()
	}()
	resp := data_manage.ChartInfoListByEsRespV2{}

	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")
	if keyword == `` {
		keyword = this.GetString("KeyWord")
	}

	showSysId := sysUser.AdminId

	var searchList []*data_manage.ChartInfoView
	var total int64
	var err error

	chartAuth, _ := this.GetInt("ChartAuth", 0) // 图表权限范围，0-全部；1-我的；2-公共

	chartCollect, _ := this.GetInt("ChartCollect", 0) // 图表收藏状态：0-全部；1-已收藏

	// 筛选分类id列表
	searchClassifyIdList := make([]int, 0)
	searchPublicClassifyIdList := make([]int, 0)
	// 父级分类id
	classifyId, _ := this.GetInt("ClassifyId")
	if classifyId > 0 {
		switch chartAuth {
		case 1: // 1-我的；2-公共
			allChildClassifyItemList, err, _ := data.GetAllChartChildClassifyByParentId(classifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表分类信息失败，Err:" + err.Error()
				return
			}
			searchClassifyIdList = append(searchClassifyIdList, classifyId)
			for _, v := range allChildClassifyItemList {
				searchClassifyIdList = append(searchClassifyIdList, v.ChartClassifyId)
			}
		case 2: // 1-我的；2-公共
			obj := data_manage.ChartPublicClassify{}
			allChildClassifyItemList, err, _ := obj.GetAllChildClassifyByParentId(classifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表分类信息失败，Err:" + err.Error()
				return
			}
			searchPublicClassifyIdList = append(searchPublicClassifyIdList, classifyId)
			for _, v := range allChildClassifyItemList {
				searchPublicClassifyIdList = append(searchPublicClassifyIdList, v.ChartPublicClassifyId)
			}

		}
	}

	// 收藏的指标id
	collectChartInfoIdList := make([]int, 0)
	if chartCollect == 1 {
		collectChartInfoIdList, err = data_manage.GetUserAllCollectChartInfoIdList(this.SysUser.AdminId)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取收藏指标配置数据失败，Err:" + err.Error()
			return
		}
	}

	sortMap := make(map[string]string)
	// 如果没有搜索关键词，则默认根据图表创建时间倒序排序
	if keyword == `` {
		sortMap["ChartInfoId"] = `desc`
	}

	// 是否走ES
	total, searchList, err = elastic.SearchChartInfoDataV2(keyword, showSysId, chartAuth, []int{utils.CHART_SOURCE_DEFAULT}, collectChartInfoIdList, searchClassifyIdList, searchPublicClassifyIdList, sortMap, startSize, pageSize)

	if len(searchList) <= 0 {
		searchList = make([]*data_manage.ChartInfoView, 0)
		page := paging.GetPaging(currentIndex, pageSize, int(total))
		resp.Paging = page
		resp.List = searchList

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

	// 涉及分类id
	classifyIdList := make([]int, 0)
	// 图表id
	chartInfoIdList := make([]int, 0)

	for _, v := range searchList {
		classifyIdList = append(classifyIdList, v.ChartClassifyId)
		chartInfoIdList = append(chartInfoIdList, v.ChartInfoId)
	}

	// 当前列表中的分类map
	chartClassifyMap := make(map[int]*data_manage.ChartClassify)

	// 图表分类
	{
		chartClassifyList, err := data_manage.GetChartClassifyByIdList(classifyIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表分类失败，Err:" + err.Error()
			return
		}
		for _, v := range chartClassifyList {
			chartClassifyMap[v.ChartClassifyId] = v
		}
	}

	// 查询收藏
	collectEdbMap := make(map[int][]int)
	collectNameEdbMap := make(map[int][]string)
	{
		obj := data_manage.ChartCollect{}
		collectList, err := obj.GetItemsByUserIdAndChartInfoIdList(this.SysUser.AdminId, chartInfoIdList)
		if err != nil {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标数据失败,Err:" + err.Error()
			return
		}
		for _, v := range collectList {
			collectIdList, ok := collectEdbMap[v.ChartInfoId]
			if !ok {
				collectIdList = make([]int, 0)
			}
			collectEdbMap[v.ChartInfoId] = append(collectIdList, v.ChartCollectClassifyId)

			collectNameList, ok := collectNameEdbMap[v.ChartInfoId]
			if !ok {
				collectNameList = make([]string, 0)
			}
			collectNameEdbMap[v.ChartInfoId] = append(collectNameList, v.ClassifyName)
		}

	}

	// 图表
	{
		// 当前列表中的图表map
		chartInfoMap := make(map[int]*data_manage.ChartInfo)
		tmpChartList, err := data_manage.GetChartInfoByIdList(chartInfoIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有权限的图表失败，Err:" + err.Error()
			return
		}
		for _, tmpChartInfo := range tmpChartList {
			chartInfoMap[tmpChartInfo.ChartInfoId] = tmpChartInfo
		}
		for _, v := range searchList {
			if collectIdList, ok := collectEdbMap[v.ChartInfoId]; ok {
				v.CollectClassifyIdList = collectIdList
			} else {
				v.CollectClassifyIdList = []int{}
			}

			if collectNameList, ok := collectNameEdbMap[v.ChartInfoId]; ok {
				v.CollectClassifyNameList = collectNameList
			} else {
				v.CollectClassifyNameList = []string{}
			}

			// 图表权限
			if chartViewInfo, ok := chartInfoMap[v.ChartInfoId]; ok {
				v.IsJoinPermission = chartViewInfo.IsJoinPermission
			}
			v.HaveOperaAuth = true
		}
	}

	page := paging.GetPaging(currentIndex, pageSize, int(total))
	resp = data_manage.ChartInfoListByEsRespV2{
		Paging: page,
		List:   searchList,
	}
	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 utils.IsErrNoRow(err) {
			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.AddOrEditChartInfoToEs(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 utils.IsErrNoRow(err) {
			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)
	msg = `获取失败`
	adminId := sysUser.AdminId

	// 图表数据权限
	// 图表分类
	chartClassify, err := data_manage.GetChartClassifyById(chartInfo.ChartClassifyId)
	if err != nil {
		errMsg = "获取图表分类信息失败，Err:" + err.Error()
		return
	}

	// 已授权分类id
	//permissionChartIdList, permissionClassifyIdList, err := data_manage_permission.GetUserChartAndClassifyPermissionList(adminId, chartInfo.ChartInfoId, chartInfo.ChartClassifyId)
	//if err != nil {
	//	errMsg = "获取已授权分类id数据失败，Err:" + err.Error()
	//	return
	//}

	// 指标数据map
	edbClassifyPermissionMap := make(map[int]data_manage_permission.EdbClassifyPermission)
	defer func() {
		if isOk {
			// 这里跟当前用户相关的信息重新查询写入resp, 不使用缓存中的
			{
				//判断是否加入我的图库
				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 && !utils.IsErrNoRow(err) {
					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
				}
			}

			// 图表权限校验
			{
				shareObj := new(data_manage.ChartInfoShare)
				shareUserIdList, err := shareObj.GetAllUserIdListByChartInfoId(chartInfo.ChartInfoId)
				if err != nil && err.Error() != utils.ErrNoRow() {
					msg = "获取失败"
					errMsg = "获取我的图表信息失败，GetAllUserIdListByChartInfoId，Err:" + err.Error()
					return
				}
				//utils.InArrayByInt(permissionChartInfoIdList, chartInfoId) {
				//resp.ChartInfo.HaveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(chartInfo.IsJoinPermission, chartClassify.IsJoinPermission, chartInfo.ChartInfoId, chartInfo.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
				if sysUser.AdminId == chartInfo.SysUserId || chartInfo.PublicStatus == 3 || utils.InArrayByInt(shareUserIdList, chartInfo.SysUserId) {
					resp.ChartInfo.HaveOperaAuth = true
				}
				//图表操作权限
				chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, resp.ChartInfo.HaveOperaAuth)
				// 如果没有操作权限，那么去获取共享用户的编辑权限
				if !chartInfo.IsEdit {
					chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
					if err != nil {
						msg = "获取失败"
						errMsg = "获取图表分享情况信息失败，GetAllUserIdListByChartInfoId，Err:" + err.Error()
						return
					}
				}

				chartInfo.Button = data_manage.ChartViewButton{
					IsEdit:    chartInfo.IsEdit,
					IsEnChart: chartInfo.IsEnChart,
					IsAdd:     chartInfo.IsAdd,
					IsCopy:    true,
					IsSetName: chartInfo.IsSetName,
				}

				//if !resp.ChartInfo.HaveOperaAuth {
				//	for _, v := range resp.EdbInfoList {
				//		v.DataList = nil
				//	}
				//	resp.DataResp = nil
				//	resp.XEdbIdValue = []int{}
				//	resp.YDataList = []data_manage.YData{}
				//}
			}

			// 指标权限
			{
				classifyMap := make(map[int]*data_manage.EdbClassify)
				// 分类
				{
					classifyIdList := make([]int, 0)
					for _, v := range resp.EdbInfoList {
						classifyIdList = append(classifyIdList, v.ClassifyId)
					}
					classifyList, tmpErr := data_manage.GetEdbClassifyByIdList(classifyIdList)
					if tmpErr != nil {
						errMsg = "获取分类列表失败，Err:" + tmpErr.Error()
						return
					}
					for _, v := range classifyList {
						classifyMap[v.ClassifyId] = v
					}
				}

				// 指标
				if len(edbClassifyPermissionMap) < 0 {
					edbInfoIdList := make([]int, 0)
					for _, v := range resp.EdbInfoList {
						edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
					}
					edbInfoList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdList)
					if tmpErr != nil {
						errMsg = "获取指标列表失败，Err:" + tmpErr.Error()
						return
					}
					for _, v := range edbInfoList {
						edbClassifyPermissionMap[v.EdbInfoId] = data_manage_permission.EdbClassifyPermission{
							ClassifyId:       v.ClassifyId,
							IsJoinPermission: v.IsJoinPermission,
							EdbInfoId:        v.EdbInfoId,
						}
					}
				}

				// 获取所有有权限的指标和分类
				permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserEdbAndClassifyPermissionList(sysUser.AdminId, 0, 0)
				if err != nil {
					errMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
					return
				}

				for _, v := range resp.EdbInfoList {
					// 数据权限
					edbItem, ok := edbClassifyPermissionMap[v.EdbInfoId]
					if !ok {
						continue
					}

					if currClassify, ok := classifyMap[edbItem.ClassifyId]; ok {
						v.HaveOperaAuth = data_manage_permission.CheckEdbPermissionByPermissionIdList(edbItem.IsJoinPermission, currClassify.IsJoinPermission, edbItem.EdbInfoId, edbItem.ClassifyId, permissionEdbIdList, permissionClassifyIdList)
					}
				}
			}
		}
	}()

	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
	key := data.GetChartInfoDataKey(chartInfo.ChartInfoId)
	if utils.Re == nil && isCache {
		if utils.Re == nil && utils.Rc.IsExist(key) {
			if redisData, err1 := utils.Rc.RedisBytes(key); err1 == nil {
				err := json.Unmarshal(redisData, &resp)
				if err != nil || resp == nil {
					return
				}
				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
	chartInfo.ChartThemeId = chartTheme.ChartThemeId

	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
	*/

	chartViewClassify, _ := data_manage.GetChartClassifyViewById(chartInfo.ChartClassifyId)
	if chartViewClassify != nil {
		chartClassifyParent, _ := data_manage.GetChartClassifyViewById(chartClassify.ParentId)
		chartInfo.ChartClassify = append(chartInfo.ChartClassify, chartClassifyParent)
	}
	chartInfo.ChartClassify = append(chartInfo.ChartClassify, chartViewClassify)

	// 没有就返回空数组
	if len(edbList) <= 0 {
		edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
	}
	resp.EdbInfoList = edbList
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	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

	// 遍历到校验map
	for _, v := range edbList {
		edbClassifyPermissionMap[v.EdbInfoId] = data_manage_permission.EdbClassifyPermission{
			ClassifyId:       v.ClassifyId,
			IsJoinPermission: v.IsJoinPermission,
			EdbInfoId:        v.EdbInfoId,
		}
	}

	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秒 杀死超时进程")
		e := cmd.Process.Kill()
		if e != nil {
			fmt.Println("cmd kill err: ", e.Error())
			utils.FileLog.Info(fmt.Sprintf("cmd kill err: %s", e.Error()))
			br.Msg = "图片生成失败"
			br.ErrMsg = "图片生成失败, 执行超时" + e.Error()
			return
		}
		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)
		os.Remove(outFileName)
	}()

	//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
	//}
	ossClient := services.NewOssClient()
	if ossClient == nil {
		br.Msg = "上传失败"
		br.ErrMsg = "初始化OSS服务失败"
		return
	}
	resourceUrl, err = ossClient.UploadFile(outFileName, outFileName, "")
	if err != nil {
		br.Msg = "文件上传失败"
		br.ErrMsg = "文件上传失败，Err:" + err.Error()
		return
	}

	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
	}
	if req.Source == "" {
		br.Msg = "刷新来源有误"
		return
	}
	if req.PrimaryId <= 0 {
		br.Msg = "刷新对象有误"
		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.PrimaryId, req.SubId)

	// 图表中的指标刷新
	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 utils.IsErrNoRow(err) {
			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 && !utils.IsErrNoRow(err) {
	//	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,
		Right2Min:         oldChartInfo.Right2Min,
		Right2Max:         oldChartInfo.Right2Max,
		Disabled:          oldChartInfo.Disabled,
		Source:            oldChartInfo.Source,
		ExtraConfig:       oldChartInfo.ExtraConfig,
		SeasonExtraConfig: oldChartInfo.SeasonExtraConfig,
		StartYear:         oldChartInfo.StartYear,
		Unit:              oldChartInfo.Unit,
		UnitEn:            oldChartInfo.UnitEn,
		ChartThemeId:      oldChartInfo.ChartThemeId,
		SourcesFrom:       oldChartInfo.SourcesFrom,
		Instructions:      oldChartInfo.Instructions,
		MarkersLines:      oldChartInfo.MarkersLines,
		MarkersAreas:      oldChartInfo.MarkersAreas,
	}
	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,
				EdbAliasName:  v.EdbAliasName,
				IsConvert:     v.IsConvert,
				ConvertType:   v.ConvertType,
				ConvertValue:  v.ConvertValue,
				ConvertUnit:   v.ConvertEnUnit,
				ConvertEnUnit: v.ConvertEnUnit,
			}
			mapList = append(mapList, mapItem)
		}
		err = data_manage.AddChartEdbMapping(mapList)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "保存失败，Err:" + err.Error()
			return
		}
	}
	if chartInfo.ChartType == utils.CHART_TYPE_SECTION_COMBINE {
		// 查询系列信息并复制
		chartSeriesList, e := data_manage.GetChartSeriesByChartInfoId(oldChartInfo.ChartInfoId)
		if e != nil {
			br.Msg = "获取图表关联的系列信息失败"
			br.ErrMsg = "获取图表关联的系列信息失败,Err:" + e.Error()
			return
		}

		chartSeriesEdbList, e := data_manage.GetChartSeriesEdbByChartInfoId(oldChartInfo.ChartInfoId)
		if err != nil {
			br.Msg = "获取图表关联的系列指标信息失败"
			br.ErrMsg = "获取图表关联的系列指标信息失败,Err:" + err.Error()
			return
		}
		err = data_manage.CopyChartSeriesAndEdbMapping(chartSeriesList, chartSeriesEdbList, chartInfo.ChartInfoId)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "保存图表系列失败，Err:" + err.Error()
			return
		}
	}

	//添加es数据
	go data.AddOrEditChartInfoToEs(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)
	}

	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)
	convertMap := make(map[int]*data_manage.ChartEdbInfoMapping, 0)
	for _, v := range req.EdbInfoIdList {
		edbInfoIdsList = append(edbInfoIdsList, strconv.Itoa(v.EdbInfoId))
		convertMap[v.EdbInfoId] = &data_manage.ChartEdbInfoMapping{
			IsConvert:     v.IsConvert,
			ConvertType:   v.ConvertType,
			ConvertValue:  v.ConvertValue,
			ConvertUnit:   v.ConvertUnit,
			ConvertEnUnit: v.ConvertEnUnit,
		}
	}
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoId(strings.Join(edbInfoIdsList, ","))
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取图表，指标信息失败，Err:" + err.Error()
		return
	}
	for i, item := range mappingList {
		if _, ok := convertMap[item.EdbInfoId]; ok {
			mappingList[i].ConvertValue = convertMap[item.EdbInfoId].ConvertValue
			mappingList[i].ConvertUnit = convertMap[item.EdbInfoId].ConvertUnit
			mappingList[i].ConvertEnUnit = convertMap[item.EdbInfoId].ConvertEnUnit
			mappingList[i].ConvertType = convertMap[item.EdbInfoId].ConvertType
			mappingList[i].IsConvert = convertMap[item.EdbInfoId].IsConvert
		}
	}

	// 获取图表中的指标数据
	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, "，")
	}
	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, true)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}
	//判断是否需要展示英文标识
	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,
	}

	// 标识线计算
	if req.MarkersLines != "" {
		markerLines := make([]data_manage.MarkersLine, 0)
		err = json.Unmarshal([]byte(req.MarkersLines), &markerLines)
		if err != nil {
			br.Msg = "标识线配置异常"
			br.ErrMsg = "标识线配置异常" + err.Error()
			return
		}
		for i := range markerLines {
			if markerLines[i].EdbType == 0 && markerLines[i].TimeIntervalType == 0 && markerLines[i].Axis != 3 {
				// 图上第一个指标且时间区间跟随图表
				if markerLines[i].MarkLineType == 2 {
					// 图上第一个指标且时间区间跟随图表
					if edbList[0].IsAxis == 1 {
						value, err := data.MarkerLineCalculate(markerLines[i], edbList[0].DataList, chartInfo)
						if err != nil {
							br.Msg = "标识线配置异常"
							br.ErrMsg = "标识线配置异常" + err.Error()
							return
						}
						markerLines[i].Value = value
					} else {
						// 其他的都走指标计算
						edbInfo, err := data_manage.GetEdbInfoById(markerLines[i].EdbInfoId)
						if err != nil {
							br.Msg = "指标计算标识线获取指标信息异常"
							br.ErrMsg = "指标计算标识线获取指标信息异常" + err.Error()
							return
						}
						dataList, err := data_manage.GetEdbDataList(edbInfo.Source, edbInfo.SubSource, edbInfo.EdbInfoId, "", "")
						if err != nil {
							br.Msg = "指标计算标识线获取指标数据异常"
							br.ErrMsg = "指标计算标识线获取指标数据异常" + err.Error()
							return
						}
						value, err := data.MarkerLineCalculate(markerLines[i], dataList, chartInfo)
						if err != nil {
							br.Msg = "标识线配置异常"
							br.ErrMsg = "标识线配置异常" + err.Error()
							return
						}
						markerLines[i].Value = value
					}
				}
			}
		}

		markerLineStr, err := json.Marshal(markerLines)
		if err != nil {
			br.Msg = "标识线配置异常"
			br.ErrMsg = "标识线配置异常" + err.Error()
			return
		}

		chartInfo.MarkersLines = string(markerLineStr)
	}

	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, "，")
	}

	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, true)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}
	//判断是否需要展示英文标识
	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
	}
	if req.Source == "" {
		br.Msg = "刷新来源有误"
		return
	}
	if req.PrimaryId <= 0 {
		br.Msg = "刷新对象有误"
		return
	}

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

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

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

}

// PreviewRadarChartInfo
// @Title 图表-获取预览的雷达图
// @Description 图表-获取预览的雷达图
// @Param	ExtraConfig	body data_manage.PreviewRadarChartReq true "type json string"
// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
// @router /chart_info/preview/radar [post]
func (this *ChartInfoController) PreviewRadarChartInfo() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req data_manage.PreviewRadarChartReq
	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_RADAR
	if len(req.ChartEdbInfoList) <= 0 {
		br.Msg = "请选择指标"
		return
	}

	edbInfoIdArr := make([]int, 0)
	edbInfoNameMap := make(map[int]string)
	for _, v := range req.ChartEdbInfoList {
		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
		edbInfoNameMap[v.EdbInfoId] = v.EdbAliasName
	}
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIdArr)
	for _, v := range mappingList {
		if name, ok := edbInfoNameMap[v.EdbInfoId]; ok {
			v.EdbAliasName = name
		}
	}
	// 获取图表中的指标数据
	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, true)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}

	//判断是否需要展示英文标识
	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,
	}
	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	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
}

// 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/convert/detail [get]
func (this *ChartInfoController) ChartInfoConvertDetail() {
	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")
	isAxis, _ := this.GetInt("IsAxis")

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

	isConvert, _ := this.GetInt("IsConvert")
	convertType, _ := this.GetInt("ConvertType")
	convertValue, _ := this.GetFloat("ConvertValue")
	convertUnit := this.GetString("ConvertUnit")
	convertEnUnit := this.GetString("ConvertEnUnit")

	resp := new(data_manage.ChartInfoDetailResp)
	var err error
	chartInfo := new(data_manage.ChartInfoView)
	chartInfo.HaveOperaAuth = true

	// 通过id获取详情
	if chartInfoId > 0 {
		chartInfo, err = data_manage.GetChartInfoViewById(chartInfoId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				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
		chartInfo.ChartThemeId = chartTheme.ChartThemeId

		// 图表数据权限
		{
			// 图表分类
			chartClassify, err := data_manage.GetChartClassifyById(chartInfo.ChartClassifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表分类信息失败，Err:" + err.Error()
				return
			}

			// 已授权分类id
			permissionChartIdList, permissionClassifyIdList, err := data_manage_permission.GetUserChartAndClassifyPermissionList(this.SysUser.AdminId, chartInfo.ChartInfoId, chartInfo.ChartClassifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取已授权分类id数据失败，Err:" + err.Error()
				return
			}
			chartInfo.HaveOperaAuth = data_manage_permission.CheckChartPermissionByPermissionIdList(chartInfo.IsJoinPermission, chartClassify.IsJoinPermission, chartInfo.ChartInfoId, chartInfo.ChartClassifyId, permissionChartIdList, permissionClassifyIdList)
		}

		//图表操作权限
		chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId, chartInfo.HaveOperaAuth)
		// 如果没有操作权限，那么去获取共享用户的编辑权限
		if !chartInfo.IsEdit {
			chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
			if err != nil {
				br.Msg = `获取失败`
				br.ErrMsg = `获取失败：` + err.Error()
				return
			}
		}

		chartInfo.Button = data_manage.ChartViewButton{
			IsEdit:    chartInfo.IsEdit,
			IsEnChart: chartInfo.IsEnChart,
			IsAdd:     chartInfo.IsAdd,
			IsCopy:    true,
			IsSetName: chartInfo.IsSetName,
		}
	}

	// 有数据权限的话，获取图表的数据
	if chartInfo.HaveOperaAuth {
		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
				}
				if isConvert == 1 && len(mappingList) > 0 {
					for i, _ := range mappingList {
						mappingList[i].IsConvert = 1
						mappingList[i].ConvertType = convertType
						mappingList[i].ConvertValue = convertValue
						mappingList[i].ConvertUnit = convertUnit
						mappingList[i].ConvertEnUnit = convertEnUnit
					}
				}
			}
		}

		// 图表额外数据参数
		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.GetChartConvertEdbData(chartInfoId, chartType, calendar, startDate, endDate, mappingList, extraConfigStr, chartInfo.SeasonExtraConfig, isAxis)
		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 && !utils.IsErrNoRow(err) {
					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
					}
				}
			}
		}

		// 图表的指标来源
		sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
		chartInfo.ChartSource = strings.Join(sourceNameList, ",")
		chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")
		//判断是否需要展示英文标识
		chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, edbList, chartInfo.Source, chartInfo.ChartType)

		resp.EdbInfoList = edbList
		resp.XEdbIdValue = xEdbIdValue
		resp.YDataList = yDataList
		resp.DataResp = dataResp
		resp.BarChartInfo = barConfig
	}

	resp.ChartInfo = chartInfo
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// UploadToForum
// @Title 上传至社区
// @Description 上传至社区
// @Param	request	body data_manage.SetChartInfoImageReq true "type json string"
// @Success Ret=200 保存成功
// @router /chart_info/forum/upload [post]
func (this *ChartInfoController) UploadToForum() {
	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 eta_forum.UploadChartToForumReq
	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 = "请选择图表"
		return
	}

	err, errMsg := eta_forum.UploadChart(req.ChartInfoId, req.Description, sysUser)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

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

// UpdateToForum
// @Title 更新社区图表
// @Description 更新社区图表
// @Param	request	body data_manage.SetChartInfoImageReq true "type json string"
// @Success Ret=200 保存成功
// @router /chart_info/forum/update [post]
func (this *ChartInfoController) UpdateToForum() {
	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 eta_forum.UpdateChartToForumReq
	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 = "请选择图表"
		return
	}

	err, errMsg := eta_forum.UpdateChart(req.ChartInfoId)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

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

// ForumDelete
// @Title 从社区撤回
// @Description 从社区撤回
// @Param	request	body data_manage.SetChartInfoImageReq true "type json string"
// @Success Ret=200 保存成功
// @router /chart_info/forum/delete [post]
func (this *ChartInfoController) ForumDelete() {
	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 eta_forum.DeleteChartReq
	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 = "请选择图表"
		return
	}

	err, errMsg := eta_forum.DeleteChart(req.ChartInfoId)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
}

// PreviewSeasonChartInfo
// @Title 图表-获取预览的季节性图
// @Description 图表-获取预览的季节性图
// @Param	ExtraConfig	body data_manage.PreviewRadarChartReq true "type json string"
// @Success 200 {object} data_manage.ChartEdbInfoDetailResp
// @router /chart_info/preview/season [post]
func (this *ChartInfoController) PreviewSeasonChartInfo() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req data_manage.PreviewSeasonChartReq
	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_SEASON
	if len(req.ChartEdbInfoList) <= 0 {
		br.Msg = "请选择指标"
		return
	}

	edbInfoIdArr := make([]int, 0)
	edbInfoNameMap := make(map[int]string)
	for _, v := range req.ChartEdbInfoList {
		edbInfoIdArr = append(edbInfoIdArr, v.EdbInfoId)
		edbInfoNameMap[v.EdbInfoId] = v.EdbAliasName
	}
	mappingList, err := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbInfoIdArr)
	for _, v := range mappingList {
		if name, ok := edbInfoNameMap[v.EdbInfoId]; ok {
			v.EdbAliasName = name
		}
	}

	var seasonExtraConfig string
	seasonExtra, tErr := json.Marshal(req.SeasonExtraConfig)
	if tErr != nil {
		br.Msg = "季节性图表配置信息异常"
		br.ErrMsg = "季节性图表配置信息异常,Err:" + tErr.Error()
		return
	}
	seasonExtraConfig = string(seasonExtra)
	// 获取图表中的指标数据
	edbList, xEdbIdValue, yDataList, dataResp, err, errMsg := data.GetChartEdbData(0, chartType, "", "", "", mappingList, "", seasonExtraConfig)
	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, true)
	// 如果没有操作权限，那么去获取共享用户的编辑权限
	if !chartInfo.IsEdit {
		chartInfo.IsEdit, err = data.CheckChartInfoEditPermission(chartInfo.ChartInfoId, sysUser.AdminId)
		if err != nil {
			br.Msg = `获取失败`
			br.ErrMsg = `获取失败：` + err.Error()
			return
		}
	}

	//判断是否需要展示英文标识
	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,
	}
	// 图表的指标来源
	sourceNameList, sourceNameEnList := data.GetEdbSourceByEdbInfoIdList(edbList)
	chartInfo.ChartSource = strings.Join(sourceNameList, ",")
	chartInfo.ChartSourceEn = strings.Join(sourceNameEnList, ",")

	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
}

// ChartInfoImgSetBySvg
// @Title 图表图片上传
// @Param   Img   query   string  true       "图片"
// @Param   ChartInfoId   query   int  true       "图表ID"
// @Success 200 {object} models.ResourceResp
// @router /chart_info/image/set_by_svg [post]
func (this *ChartInfoController) ChartInfoImgSetBySvg() {
	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
	}
	chartInfoId, _ := this.GetInt("ChartInfoId", 0)
	if chartInfoId <= 0 {
		br.Msg = "图片参数错误"
		br.ErrMsg = "图片参数错误,ChartInfoId Is Empty"
		return
	}
	resp := new(models.ResourceResp)

	// 通过svg图片生成图片资源地址
	resourceUrl, err, errMsg := services.GetResourceUrlBySvgImg(imgData)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	// 修改图表的缩略图信息
	if chartInfoId > 0 && resourceUrl != "" {
		err = data_manage.EditChartInfoImageV2(chartInfoId, resourceUrl)
		if err != nil {
			br.Msg = "保存失败"
			br.ErrMsg = "保存失败,Err:" + err.Error()
			return
		}

		//修改es数据
		go data.AddOrEditChartInfoToEs(chartInfoId)
		//修改my eta es数据
		go data.EsAddOrEditMyChartInfoByChartInfoId(chartInfoId)
	}

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

// BatchMove
// @Title 图表批量移动接口
// @Description 图表批量移动接口
// @Param	request	body request.MoveChartClassifyReq true "type json string"
// @Success Ret=200 移动成功
// @router /chart_info/batch_move [post]
func (this *ChartInfoController) BatchMove() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	if req.NewClassifyId <= 0 {
		br.Msg = `请选择要转移的新分类`
		br.IsSendEmail = false
		return
	}

	classifyItem, err := data_manage.GetChartClassifyById(req.NewClassifyId)
	if err != nil {
		br.Msg = "获取指标分类失败！"
		br.ErrMsg = "获取指标分类失败！" + err.Error()
		return
	}
	if classifyItem.SysUserId != this.SysUser.AdminId {
		br.Msg = `您没有权限移动指标到该分类！`
		br.IsSendEmail = false
		return
	}

	chartInfoIdList := make([]int, 0)
	if req.IsSelectAll {
		// 获取指标
		chartInfoList, err := data.GetAllChartInfoListBySearchPublicChartReq(req.SearchPublicChartReq, this.SysUser.AdminId)
		if err != nil {
			br.Msg = "获取指标列表失败！"
			br.ErrMsg = "获取指标列表失败，Err:" + err.Error()
			return
		}
		// 如果有过滤指标，那么就过滤吧
		if len(req.NoChartIdList) > 0 {
			noChartIdMap := make(map[int]bool)
			for _, v := range req.NoChartIdList {
				noChartIdMap[v] = true
			}

			for _, chartInfo := range chartInfoList {
				if _, ok := noChartIdMap[chartInfo.ChartInfoId]; !ok {

					if chartInfo.SysUserId != this.SysUser.AdminId {
						br.Msg = `您没有权限移动该指标！`
						br.IsSendEmail = false
						return
					}

					// 如果不在未选中的指标id列表中，那么就加入到选中的指标id列表
					chartInfoIdList = append(chartInfoIdList, chartInfo.ChartInfoId)
				}
			}
		} else {
			for _, chartInfo := range chartInfoList {
				chartInfoIdList = append(chartInfoIdList, chartInfo.ChartInfoId)
				for _, v := range chartInfoList {
					if v.SysUserId != this.SysUser.AdminId {
						br.Msg = `您没有权限移动该指标！`
						br.IsSendEmail = false
						return
					}
				}
			}
		}
	} else {
		chartInfoList, err := data_manage.GetChartInfoViewByIdList(req.ChartIdList)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取所有有权限的指标失败，Err:" + err.Error()
			return
		}
		for _, v := range chartInfoList {
			if v.SysUserId != this.SysUser.AdminId {
				br.Msg = `您没有权限移动该指标！`
				br.IsSendEmail = false
				return
			}
		}
		chartInfoIdList = req.ChartIdList
	}

	num := len(chartInfoIdList)
	if num <= 0 {
		br.Msg = `请选择要移动的指标！`
		br.IsSendEmail = false
		return
	}
	if num > 100 {
		br.Msg = `最多只能选择100条指标！`
		br.IsSendEmail = false
		return
	}

	// 开始批量修改指标分类
	if len(chartInfoIdList) > 0 {
		err = data_manage.UpdateClassifyIdByChartInfoIdList(chartInfoIdList, req.NewClassifyId)
		if err != nil {
			br.Msg = `指标移动失败！`
			br.ErrMsg = `指标移动失败，ERR：` + err.Error()
			return
		}

		// 还得修改ES呢
		for _, v := range chartInfoIdList {
			data.AddOrEditChartInfoToEs(v)
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
}