eta_mobile/controllers/data_manage/line_equation/line_chart_info.go

package line_equation

import (
	"encoding/json"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"eta/eta_mobile/controllers"
	"eta/eta_mobile/models"
	"eta/eta_mobile/models/data_manage"
	"eta/eta_mobile/models/data_manage/line_equation/request"
	"eta/eta_mobile/models/system"
	"eta/eta_mobile/services/data"
	"eta/eta_mobile/services/data/line_equation"
	"eta/eta_mobile/utils"
	"strconv"
	"strings"
	"time"
)

// LineEquationChartInfoController 拟合方程图表管理
type LineEquationChartInfoController struct {
	controllers.BaseAuthController
}

// List
// @Title 拟合方程图表列表接口
// @Description 拟合方程图表列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ChartClassifyId   query   int  true       "分类id"
// @Param   Keyword   query   string  true       "搜索关键词"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Param   Source   query   int  true       "图表类型，3：拟合方程，4：滚动拟合方程"
// @Success 200 {object} data_manage.ChartListResp
// @router /chart_info/list [get]
func (this *LineEquationChartInfoController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	chartClassifyId, _ := this.GetInt("ChartClassifyId")

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyword := this.GetString("KeyWord")

	var total int
	page := paging.GetPaging(currentIndex, pageSize, total)

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	source, _ := this.GetInt("Source")
	if source <= 0 {
		source = utils.CHART_SOURCE_LINE_EQUATION
	}

	var condition string
	var pars []interface{}

	// 普通图表
	condition += ` AND source = ? `
	pars = append(pars, source)

	if chartClassifyId > 0 {
		chartClassifyId, err := data_manage.GetChartClassify(chartClassifyId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取图表信息失败"
			br.ErrMsg = "获取信息失败,GetChartClassify,Err:" + err.Error()
			return
		}
		condition += " AND chart_classify_id IN(" + chartClassifyId + ") "
	}
	if keyword != "" {
		condition += ` AND  ( chart_name LIKE '%` + keyword + `%' )`
	}

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	if isShowMe {
		condition += ` AND sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	// 获取当前账号的不可见指标
	noPermissionChartIdList := make([]int, 0)
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
		}
	}

	lenNoPermissionChartIdList := len(noPermissionChartIdList)
	if lenNoPermissionChartIdList > 0 {
		condition += ` AND chart_info_id not in (` + utils.GetOrmInReplace(lenNoPermissionChartIdList) + `) `
		pars = append(pars, noPermissionChartIdList)
	}

	//获取图表信息
	list, err := data_manage.GetChartListByCondition(condition, pars, startSize, pageSize)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Success = true
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	myChartList, err := data_manage.GetMyChartListByAdminId(sysUser.AdminId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取我的图表信息失败,Err:" + err.Error()
		return
	}
	myChartMap := make(map[int]*data_manage.MyChartView)
	for _, v := range myChartList {
		myChartMap[v.ChartInfoId] = v
	}
	listLen := len(list)
	chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
	if listLen > 0 {
		chartInfoIds := ""
		for _, v := range list {
			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
		}
		if chartInfoIds != "" {
			chartInfoIds = strings.Trim(chartInfoIds, ",")
			//判断是否需要展示英文标识
			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
				return
			}
			for _, v := range edbList {
				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
			}
		}
	}
	for i := 0; i < listLen; i++ {
		//判断是否需要展示英文标识
		if _, ok := chartEdbMap[list[i].ChartInfoId]; ok {
			list[i].IsEnChart = data.CheckIsEnChart(list[i].ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, list[i].Source, list[i].ChartType)
		}

		if existItem, ok := myChartMap[list[i].ChartInfoId]; ok {
			list[i].IsAdd = true
			list[i].MyChartId = existItem.MyChartId
			list[i].MyChartClassifyId = existItem.MyChartClassifyId
		}
	}

	resp := new(data_manage.ChartListResp)
	if list == nil || len(list) <= 0 || (err != nil && err.Error() == utils.ErrNoRow()) {
		items := make([]*data_manage.ChartInfoView, 0)
		resp.Paging = page
		resp.List = items
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		return
	}

	dataCount, err := data_manage.GetChartListCountByCondition(condition, pars)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标数据总数失败,Err:" + err.Error()
		return
	}
	page = paging.GetPaging(currentIndex, pageSize, dataCount)
	resp.Paging = page
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// SearchByEs
// @Title 图表模糊搜索（从es获取）
// @Description  图表模糊搜索（从es获取）
// @Param   Keyword   query   string  true       "图表名称"
// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
// @Param   Source   query   int  true       "来源，3：拟合方程，4：滚动拟合方程，默认0：全部"
// @Success 200 {object} data_manage.ChartInfo
// @router /chart_info/search_by_es [get]
func (this *LineEquationChartInfoController) SearchByEs() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")

	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currentIndex <= 0 {
		currentIndex = 1
	}
	startSize = paging.StartIndex(currentIndex, pageSize)

	keyword := this.GetString("Keyword")

	//只看我的
	isShowMe, _ := this.GetBool("IsShowMe")
	showSysId := 0
	if isShowMe {
		showSysId = sysUser.AdminId
	}

	sourceList := []int{utils.CHART_SOURCE_LINE_EQUATION}

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

	// 获取当前账号的不可见指标
	noPermissionChartIdList := make([]int, 0)
	{
		obj := data_manage.EdbInfoNoPermissionAdmin{}
		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
			return
		}
		for _, v := range confList {
			noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
		}
	}

	if keyword != "" {
		searchList, total, err = data.EsSearchChartInfo(keyword, showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
	} else {
		total, searchList, err = data_manage.ChartInfoSearchByEmptyKeyWord(showSysId, sourceList, noPermissionChartIdList)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
			return
		}
	}

	finalList := make([]*data_manage.ChartInfoMore, 0)
	if len(searchList) > 0 {
		chartInfoIds := ""
		chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
		for _, v := range searchList {
			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
		}
		if chartInfoIds != "" {
			chartInfoIds = strings.Trim(chartInfoIds, ",")
			//判断是否需要展示英文标识
			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
			if e != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
				return
			}
			for _, v := range edbList {
				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
			}
		}

		for _, v := range searchList {
			tmp := new(data_manage.ChartInfoMore)
			tmp.ChartInfo = *v
			//判断是否需要展示英文标识
			if _, ok := chartEdbMap[v.ChartInfoId]; ok {
				tmp.IsEnChart = data.CheckIsEnChart(v.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, v.Source, v.ChartType)
			}
			finalList = append(finalList, tmp)
		}
	}
	//新增搜索词记录
	{
		searchKeyword := new(data_manage.SearchKeyword)
		searchKeyword.KeyWord = keyword
		searchKeyword.CreateTime = time.Now()
		go data_manage.AddSearchKeyword(searchKeyword)
	}

	page := paging.GetPaging(currentIndex, pageSize, int(total))
	resp := data_manage.ChartInfoListByEsResp{
		Paging: page,
		List:   finalList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

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

// Refresh
// @Title 图表刷新接口
// @Description 图表刷新接口
// @Param   ChartInfoId   query   int  true       "图表id"
// @Param   UniqueCode   query   string  true       "唯一code"
// @Success Ret=200 刷新成功
// @router /chart_info/refresh [get]
func (this *LineEquationChartInfoController) Refresh() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	chartInfoId, _ := this.GetInt("ChartInfoId")
	uniqueCode := this.GetString("UniqueCode")
	if chartInfoId <= 0 && uniqueCode == `` {
		br.Msg = "参数错误"
		br.ErrMsg = "参数错误:chartInfoId:" + strconv.Itoa(chartInfoId) + ",UniqueCode:" + uniqueCode
		return
	}

	var chartInfo *data_manage.ChartInfo
	var err error
	if chartInfoId > 0 {
		chartInfo, err = data_manage.GetChartInfoById(chartInfoId)
	} else {
		chartInfo, err = data_manage.GetChartInfoByUniqueCode(uniqueCode)
	}
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图表已被删除，无需刷新"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		br.Msg = "刷新失败"
		br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
		return
	}

	// 刷新图表的指标信息
	err = data.ChartInfoRefreshV2(chartInfo.ChartInfoId)

	//清除图表缓存
	{
		key := utils.HZ_CHART_LIB_DETAIL + chartInfo.UniqueCode
		_ = utils.Rc.Delete(key)
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "刷新成功"
}

// Copy
// @Title 复制并新增图表接口
// @Description 新增图表接口
// @Param	request	body data_manage.CopyAddChartInfoReq true "type json string"
// @Success 200 {object} data_manage.AddChartInfoResp
// @router /chart_info/copy [post]
func (this *LineEquationChartInfoController) Copy() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	cacheKey := "CACHE_CHART_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！" + sysUser.RealName + ";data:" + string(this.Ctx.Input.RequestBody)
		return
	}
	var req data_manage.CopyAddChartInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	// 获取原图表信息
	oldChartInfo, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		br.Msg = "获取原图表信息失败"
		br.ErrMsg = "获取原图表信息失败,Err:" + err.Error()
		return
	}
	if oldChartInfo.Source != utils.CHART_SOURCE_LINE_EQUATION {
		br.Msg = `错误的图表类型`
		br.IsSendEmail = false
		return
	}

	var lineChartInfoConf request.LineChartInfoReq
	err = json.Unmarshal([]byte(oldChartInfo.ExtraConfig), &lineChartInfoConf)
	addChartList := make([]request.AddChart, 0)
	addChartList = append(addChartList, request.AddChart{
		Source:          lineChartInfoConf.Source,
		ChartClassifyId: req.ChartClassifyId,
		ChartName:       req.ChartName,
		LeftMin:         oldChartInfo.LeftMin,
		LeftMax:         oldChartInfo.LeftMax,
		ChartImage:      oldChartInfo.ChartImage,
	})

	resp := new(data_manage.AddChartInfoResp)
	batchAddChartList, err, errMsg, isSendEmail := line_equation.BatchAddChartInfo(addChartList, lineChartInfoConf, sysUser)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	resp.ChartInfoId = batchAddChartList[0].ChartInfo.ChartInfoId
	resp.UniqueCode = batchAddChartList[0].ChartInfo.UniqueCode
	resp.ChartType = batchAddChartList[0].ChartInfo.ChartType
	//新增操作日志
	{
		for _, v := range batchAddChartList {
			chartInfo := v.ChartInfo
			chartLog := new(data_manage.ChartInfoLog)
			chartLog.ChartInfoId = chartInfo.ChartInfoId
			chartLog.ChartName = chartInfo.ChartName
			chartLog.ChartClassifyId = chartInfo.ChartClassifyId
			chartLog.SysUserId = sysUser.AdminId
			chartLog.SysUserRealName = sysUser.RealName
			chartLog.UniqueCode = chartInfo.UniqueCode
			chartLog.CreateTime = time.Now()
			chartLog.Content = string(this.Ctx.Input.RequestBody)
			chartLog.Status = "新增拟合方程图表"
			chartLog.Method = this.Ctx.Input.URI()
			go data_manage.AddChartInfoLog(chartLog)
		}
	}

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

// GetChartInfoDetailFromUniqueCode 根据编码获取图表详情
func GetChartInfoDetailFromUniqueCode(chartInfo *data_manage.ChartInfoView, isCache bool, sysUser *system.Admin) (resp *data_manage.ChartInfoDetailFromUniqueCodeResp, isOk bool, msg, errMsg string) {
	resp = new(data_manage.ChartInfoDetailFromUniqueCodeResp)

	adminId := sysUser.AdminId

	//判断是否存在缓存，如果存在缓存，那么直接从缓存中获取
	key := data.GetChartInfoDataKey(chartInfo.ChartInfoId)
	if utils.Re == nil && isCache {
		if utils.Re == nil && utils.Rc.IsExist(key) {
			if chartData, err1 := utils.Rc.RedisBytes(key); err1 == nil {
				err := json.Unmarshal(chartData, &resp)
				if err == nil && resp != nil {
					// 这里跟当前用户相关的信息重新查询写入resp, 不使用缓存中的
					var myCond string
					var myPars []interface{}
					myCond += ` AND a.admin_id=? `
					myPars = append(myPars, adminId)
					myCond += ` AND a.chart_info_id=? `
					myPars = append(myPars, chartInfo.ChartInfoId)
					myList, err := data_manage.GetMyChartByCondition(myCond, myPars)
					if err != nil && err.Error() != utils.ErrNoRow() {
						msg = "获取失败"
						errMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
						return
					}
					resp.ChartInfo.IsAdd = false
					resp.ChartInfo.MyChartId = 0
					resp.ChartInfo.MyChartClassifyId = ""
					if myList != nil && len(myList) > 0 {
						resp.ChartInfo.IsAdd = true
						resp.ChartInfo.MyChartId = myList[0].MyChartId
						resp.ChartInfo.MyChartClassifyId = myList[0].MyChartClassifyId
					}

					isOk = true
					fmt.Println("source redis")
					return
				}
			}
		}
	}

	if chartInfo.ExtraConfig == `` {
		msg = "获取失败"
		errMsg = "获取配置信息失败"
		return
	}
	var lineChartInfoConfig request.LineChartInfoReq
	err := json.Unmarshal([]byte(chartInfo.ExtraConfig), &lineChartInfoConfig)
	if err != nil {
		msg = "获取失败"
		errMsg = "获取图表配置信息失败, Err:" + err.Error()
		return
	}

	var getAData, getBData, getR2Data bool
	switch lineChartInfoConfig.Source {
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
		getAData = true
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
		getBData = true
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
		getR2Data = true
	}

	edbList, dataResp, err, errMsg := line_equation.GetChartEdbData(chartInfo.ChartInfoId, lineChartInfoConfig, getAData, getBData, getR2Data)
	if err != nil {
		if errMsg == `` {
			errMsg = "获取失败"
		}
		return
	}

	var resultResp interface{}
	switch lineChartInfoConfig.Source {
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_ONE:
		resultResp = dataResp.AData
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_TWO:
		resultResp = dataResp.BData
	case utils.CHART_MULTIPLE_GRAPH_LINE_EQUATION_THREE:
		resultResp = dataResp.R2Data
	}

	if chartInfo.ChartInfoId > 0 && chartInfo != nil {
		//判断是否加入我的图库
		{
			var myChartCondition string
			var myChartPars []interface{}
			myChartCondition += ` AND a.admin_id=? `
			myChartPars = append(myChartPars, sysUser.AdminId)
			myChartCondition += ` AND a.chart_info_id=? `
			myChartPars = append(myChartPars, chartInfo.ChartInfoId)

			myChartList, err := data_manage.GetMyChartByCondition(myChartCondition, myChartPars)
			if err != nil && err.Error() != utils.ErrNoRow() {
				msg = "获取失败"
				errMsg = "获取我的图表信息失败，GetMyChartByCondition，Err:" + err.Error()
				return
			}
			if myChartList != nil && len(myChartList) > 0 {
				chartInfo.IsAdd = true
				chartInfo.MyChartId = myChartList[0].MyChartId
				chartInfo.MyChartClassifyId = myChartList[0].MyChartClassifyId
			}
		}
	}

	//图表操作权限
	chartInfo.IsEdit = data.CheckOpChartPermission(sysUser, chartInfo.SysUserId)
	//判断是否需要展示英文标识
	chartInfo.IsEnChart = data.CheckIsEnChart(chartInfo.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, chartInfo.Source, chartInfo.ChartType)
	//chartInfo.UnitEn = edbInfoMappingA.UnitEn

	isSaveAs := true
	// 另存为
	chartInfo.Button = data_manage.ChartViewButton{
		IsEdit:    chartInfo.IsEdit,
		IsEnChart: chartInfo.IsEnChart,
		IsAdd:     chartInfo.IsAdd,
		IsCopy:    isSaveAs,
		IsSetName: chartInfo.IsSetName,
	}

	resp.ChartInfo = chartInfo
	resp.EdbInfoList = edbList
	resp.DataResp = resultResp
	resp.Status = true

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

// EnInfoEdit
// @Title 编辑图表英文信息接口
// @Description 编辑图表英文信息接口
// @Param	request	body data_manage.EditChartEnInfoReq true "type json string"
// @Success Ret=200 编辑成功
// @router /chart_info/en/edit [post]
func (this *LineEquationChartInfoController) EnInfoEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.EditChartEnInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.ChartNameEn = strings.Trim(req.ChartNameEn, " ")
	if req.ChartInfoId <= 0 {
		br.Msg = "请选择图表"
		return
	}
	if req.ChartNameEn == "" {
		br.Msg = "请输入英文图表名称"
		return
	}

	//判断指标名称是否存在
	chartItem, err := data_manage.GetChartInfoById(req.ChartInfoId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "图表已被删除，请刷新页面"
			br.ErrMsg = "图表已被删除，请刷新页面"
			return
		}
		br.Msg = "获取图表信息失败"
		br.ErrMsg = "获取图表信息失败,Err:" + err.Error()
		return
	}

	// 校验名称是否有重复
	{
		var condition string
		var pars []interface{}
		condition += " AND chart_info_id <> ?  AND chart_name_en = ? AND source = ?"
		pars = append(pars, req.ChartInfoId, req.ChartNameEn, utils.CHART_SOURCE_LINE_EQUATION)
		existItem, err := data_manage.GetChartInfoByCondition(condition, pars)
		if err != nil {
			if err.Error() != utils.ErrNoRow() {
				br.Msg = "判断英文图表名称是否存在失败"
				br.ErrMsg = "判断英文图表名称是否存在失败,Err:" + err.Error()
				return
			}
		}
		if err == nil && existItem.ChartInfoId > 0 {
			br.Msg = existItem.ChartName + "：" + req.ChartNameEn + "图表名称已存在"
			return
		}
	}

	chartItem.ChartNameEn = req.ChartNameEn
	chartItem.ModifyTime = time.Now().Local()
	if e := chartItem.Update([]string{"ChartNameEn", "ModifyTime"}); e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "更新图表信息失败, Err: " + e.Error()
		return
	}

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

	//指标 修改es信息
	//go data.AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)

	//新增操作日志
	{
		chartLog := new(data_manage.ChartInfoLog)
		chartLog.ChartName = chartItem.ChartName
		chartLog.ChartInfoId = req.ChartInfoId
		chartLog.ChartClassifyId = chartItem.ChartClassifyId
		chartLog.SysUserId = sysUser.AdminId
		chartLog.SysUserRealName = sysUser.RealName
		chartLog.UniqueCode = chartItem.UniqueCode
		chartLog.CreateTime = time.Now()
		chartLog.Content = string(this.Ctx.Input.RequestBody)
		chartLog.Status = "编辑拟合方程图表英文信息"
		chartLog.Method = this.Ctx.Input.URL()
		go data_manage.AddChartInfoLog(chartLog)
	}
	// 清除缓存
	if utils.Re == nil && utils.Rc != nil {
		_ = utils.Rc.Delete(utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode) //图表分享链接缓存
		_ = utils.Rc.Delete(data.GetChartInfoDataKey(req.ChartInfoId))
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
	br.IsAddLog = true
}

//// SearchByEs
//// @Title 图表模糊搜索（从es获取）
//// @Description  图表模糊搜索（从es获取）
//// @Param   Keyword   query   string  true       "图表名称"
//// @Param   IsShowMe   query   bool  true       "是否只看我的，true、false"
//// @Param   Source   query   int  true       "来源，3：拟合方程，4：滚动拟合方程，默认0：全部"
//// @Success 200 {object} data_manage.ChartInfo
//// @router /chart_info/search_by_es [get]
//func (this *LineEquationChartInfoController) SearchByEs() {
//	br := new(models.BaseResponse).Init()
//	defer func() {
//		this.Data["json"] = br
//		this.ServeJSON()
//	}()
//
//	sysUser := this.SysUser
//	if sysUser == nil {
//		br.Msg = "请登录"
//		br.ErrMsg = "请登录，SysUser Is Empty"
//		br.Ret = 408
//		return
//	}
//	pageSize, _ := this.GetInt("PageSize")
//	currentIndex, _ := this.GetInt("CurrentIndex")
//
//	var startSize int
//	if pageSize <= 0 {
//		pageSize = utils.PageSize20
//	}
//	if currentIndex <= 0 {
//		currentIndex = 1
//	}
//	startSize = paging.StartIndex(currentIndex, pageSize)
//
//	keyword := this.GetString("Keyword")
//
//	//只看我的
//	isShowMe, _ := this.GetBool("IsShowMe")
//	showSysId := 0
//	if isShowMe {
//		showSysId = sysUser.AdminId
//	}
//
//	sourceList := []int{utils.CHART_SOURCE_LINE_EQUATION}
//
//	var searchList []*data_manage.ChartInfo
//	var total int64
//	var err error
//
//	// 获取当前账号的不可见指标
//	noPermissionChartIdList := make([]int, 0)
//	{
//		obj := data_manage.EdbInfoNoPermissionAdmin{}
//		confList, err := obj.GetAllChartListByAdminId(this.SysUser.AdminId)
//		if err != nil && err.Error() != utils.ErrNoRow() {
//			br.Msg = "获取失败"
//			br.ErrMsg = "获取不可见指标配置数据失败，Err:" + err.Error()
//			return
//		}
//		for _, v := range confList {
//			noPermissionChartIdList = append(noPermissionChartIdList, v.ChartInfoId)
//		}
//	}
//
//	if keyword != "" {
//		searchList, total, err = data.EsSearchChartInfo(keyword, showSysId, sourceList, noPermissionChartIdList, startSize, pageSize)
//	} else {
//		total, searchList, err = data_manage.ChartInfoSearchByEmptyKeyWord(showSysId, sourceList, noPermissionChartIdList)
//		if err != nil && err.Error() != utils.ErrNoRow() {
//			br.Msg = "获取失败"
//			br.ErrMsg = "获取图表信息失败，Err:" + err.Error()
//			return
//		}
//	}
//
//	finalList := make([]*data_manage.ChartInfoMore, 0)
//	if len(searchList) > 0 {
//		chartInfoIds := ""
//		chartEdbMap := make(map[int][]*data_manage.ChartEdbInfoMapping)
//		for _, v := range searchList {
//			chartInfoIds += strconv.Itoa(v.ChartInfoId) + ","
//		}
//		if chartInfoIds != "" {
//			chartInfoIds = strings.Trim(chartInfoIds, ",")
//			//判断是否需要展示英文标识
//			edbList, e := data_manage.GetChartEdbMappingListByChartInfoIds(chartInfoIds)
//			if e != nil {
//				br.Msg = "获取失败"
//				br.ErrMsg = "获取图表，指标信息失败，Err:" + e.Error()
//				return
//			}
//			for _, v := range edbList {
//				chartEdbMap[v.ChartInfoId] = append(chartEdbMap[v.ChartInfoId], v)
//			}
//		}
//
//		for _, v := range searchList {
//			tmp := new(data_manage.ChartInfoMore)
//			tmp.ChartInfo = *v
//			//判断是否需要展示英文标识
//			if _, ok := chartEdbMap[v.ChartInfoId]; ok {
//				tmp.IsEnChart = data.CheckIsEnChart(v.ChartNameEn, []*data_manage.ChartEdbInfoMapping{}, v.Source, v.ChartType)
//			}
//			finalList = append(finalList, tmp)
//		}
//	}
//	//新增搜索词记录
//	{
//		searchKeyword := new(data_manage.SearchKeyword)
//		searchKeyword.KeyWord = keyword
//		searchKeyword.CreateTime = time.Now()
//		go data_manage.AddSearchKeyword(searchKeyword)
//	}
//
//	page := paging.GetPaging(currentIndex, pageSize, int(total))
//	resp := data_manage.ChartInfoListByEsResp{
//		Paging: page,
//		List:   finalList,
//	}
//	br.Ret = 200
//	br.Success = true
//	br.Msg = "获取成功"
//	br.Data = resp
//}