eta_api/controllers/data_manage/sci_hq_data.go

package data_manage

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_manage/request"
	"eta/eta_api/models/data_manage/response"
	"eta/eta_api/models/system"
	"eta/eta_api/services/data"
	"eta/eta_api/services/data_stat"
	etaTrialService "eta/eta_api/services/eta_trial"
	"eta/eta_api/utils"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
	"github.com/tealeg/xlsx"
)

type SciHqDataController struct {
	controllers.BaseAuthController
}

// @Title 卓创红期数据分类
// @Description 卓创红期数据分类接口
// @Success 200 {object} data_manage.SciClassify
// @router /sci_hq/classify [get]
func (this *SciHqDataController) Classify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	classifyList, err := data_manage.GetSciHqClassifyAll()
	if err != nil {
		br.Msg = "查询失败"
		br.ErrMsg = "查询失败, Err:" + err.Error()
		return
	}

	initClassify := &data_manage.BaseFromSciHqClassifyItem{
		ClassifyId:     0,
		ClassifyName:   "未分类",
		ClassifyNameEn: "Unclassified",
		UniqueCode:     "0",
		ParentId:       0,
		Level:          1,
		Sort:           0,
		Children:       nil,
	}
	finalList := make([]*data_manage.BaseFromSciHqClassifyItem, 0)
	classifyTree := getSciHqClassifyTree(classifyList, 0)
	finalList = append(finalList, initClassify)
	finalList = append(finalList, classifyTree...)

	br.Msg = "查询成功"
	br.Data = finalList
	br.Success = true
	br.Ret = 200
}

// AddSciClassify
// @Title 新增分类
// @Description 新增分类接口
// @Param	request	body data_manage.AddBaseFromSciClassifyReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /sci_hq/classify/add [post]
func (this *SciHqDataController) AddClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.AddBaseFromSciHqClassifyReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ClassifyName == "" {
		br.Msg = "请输入分类名称"
		return
	}
	if req.ParentId < 0 {
		br.Msg = "操作异常"
		return
	}
	ok, msg, err := data.AddSciHqClassify(req.ClassifyName, this.Lang, req.ParentId)
	if err != nil {
		br.Msg = "添加失败"
		br.ErrMsg = "添加失败，Err:" + err.Error()
		return
	}
	if !ok {
		if msg != "" {
			br.Msg = msg
			return
		}
		br.Msg = "添加失败"
		return
	}
	br.Msg = "添加成功"
	br.Success = true
	br.Ret = 200
}

// DelClassify
// @Title 新增分类
// @Description 新增分类接口
// @Param	request	body data_manage.AddBaseFromSciClassifyReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /sci_hq/classify/del [post]
func (this *SciHqDataController) DelClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.DelBaseFromSciHqClassifyReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ClassifyId < 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}

	err = data.DelSciHqClassify(req.ClassifyId)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除失败，Err:" + err.Error()
		return
	}

	br.Ret = 200
	br.Msg = "删除成功"
	br.Success = true
	br.IsAddLog = true
}

// EditClassify
// @Title 修改分类
// @Description 修改分类接口
// @Param	request	body data_manage.EditBaseFromMysteelChemicalClassifyReq true "type json string"
// @Success 200 Ret=200 修改成功
// @router /sci_hq/classify/edit [post]
func (this *SciHqDataController) EditClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.EditBaseFromSciHqClassifyReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ClassifyId <= 0 {
		br.Msg = "参数错误"
		return
	}
	if req.ClassifyName == "" {
		br.Msg = "请输入分类名称"
		return
	}
	classify, err := data_manage.GetSciHqClassifyById(req.ClassifyId)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "分类不存在"
			return
		}
		br.Msg = "编辑失败"
		br.ErrMsg = "获取分类失败，Err:" + err.Error()
		return
	}
	switch this.Lang {
	case utils.EnLangVersion:
		if classify.ClassifyNameEn != req.ClassifyName {
			count, err := data_manage.GetSciHqClassifyCountByName(req.ClassifyName, this.Lang)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "获取分类失败，Err:" + err.Error()
				return
			}
			if count > 0 {
				br.Msg = "分类名称已存在"
				return
			}
			classify.ClassifyNameEn = req.ClassifyName
			classify.ModifyTime = time.Now()
			err = classify.Update([]string{"classify_name_en", "modify_time"})
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "编辑失败，Err:" + err.Error()
				return
			}
		}
	default:
		if classify.ClassifyName != req.ClassifyName {
			count, err := data_manage.GetSciHqClassifyCountByName(req.ClassifyName, this.Lang)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "获取分类失败，Err:" + err.Error()
				return
			}
			if count > 0 {
				br.Msg = "分类名称已存在"
				return
			}
			classify.ClassifyName = req.ClassifyName
			classify.ModifyTime = time.Now()
			err = classify.Update([]string{"classify_name", "modify_time"})
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "编辑失败，Err:" + err.Error()
				return
			}
		}
	}

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

// MoveClassify
// @Title 分类移动接口
// @Description 分类移动接口
// @Success 200 {object} data_manage.MoveBaseFromMysteelChemicalClassifyReq
// @router /sci_hq/classify/move [post]
func (this *SciHqDataController) MoveClassify() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	var req request.MoveBaseFromSciHqClassifyReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ClassifyId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "分类id小于等于0"
		br.IsSendEmail = false
		return
	}

	err, errMsg := data.MoveSciHqClassify(req.ClassifyId, req.ParentId, req.PrevClassifyId, req.NextClassifyId)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "移动成功"
}

// IndexList
// @Title 卓创红期指标列表
// @Description 卓创红期数据指标列表接口
// @Param   ClassifyId   query   int  true       "分类id"
// @Success 200 {object} data_manage.BaseFromMysteelChemicalIndexResp
// @router /sci_hq/index/list [get]
func (this *SciHqDataController) IndexList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	classifyId, _ := this.GetInt("ClassifyId", 0)
	indexList, err := data_manage.GetSciHqIndexBaseInfoByClassifyId(classifyId)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取失败"
		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
		return
	}

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

// BatchIndexList
// @Title 卓创红期批量操作指标列表
// @Description 卓创红期批量操作指标列表
// @Param   request	body   request.SciHqDataBatchListReq true "type json string"
// @Success 200 {object} data_manage.BaseFromMysteelChemicalIndexResp
// @router /sci_hq/index/batch_list [post]
func (this *SciHqDataController) BatchIndexList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.SciHqDataBatchListReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	var condition string
	var pars []interface{}
	if req.KeyWord != "" {
		condition += `AND (index_code=? OR index_name=?)`
		pars = utils.GetLikeKeywordPars(pars, req.KeyWord, 2)
	}
	if req.IsSelectAll {
		if len(req.SelectedId) > 0 {
			condition += ` AND base_from_sci_hq_index_id NOT IN (` + utils.GetOrmInReplace(len(req.SelectedId)) + `)`
			pars = append(pars, req.SelectedId)
		}
	} else {
		if len(req.SelectedId) > 0 {
			condition += ` AND base_from_sci_hq_index_id IN (` + utils.GetOrmInReplace(len(req.SelectedId)) + `)`
			pars = append(pars, req.SelectedId)
		}
	}
	if req.ClassifyId >= 0 {
		condition += ` AND classify_id=?`
		pars = append(pars, req.ClassifyId)
	}

	count, err := data_manage.GetSciHqIndexCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
		return
	}
	MaxLen := 30
	if count > MaxLen {
		br.Msg = "批量操作数量不能超过" + strconv.Itoa(MaxLen)
		return
	}
	indexList, err := data_manage.GetSciHqIndexByCondition(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
		return
	}

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

// IndexPageList
// @Title 卓创红期指标列表
// @Description 卓创红期数据指标列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   ClassifyId   query   int  true       "分类id"
// @Param   IsListAll   query   int  true       "是否展示全部"
// @Success 200 {object} data_manage.BaseFromMysteelChemicalIndexResp
// @router /sci_hq/index/page/list [get]
func (this *SciHqDataController) IndexPageList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	classifyId, _ := this.GetInt("ClassifyId", 0)
	pageSize, _ := this.GetInt("PageSize")
	currrentIndex, _ := this.GetInt("CurrentIndex")
	isListAll, _ := this.GetBool("IsListAll")
	var startSize int
	if pageSize <= 0 {
		pageSize = utils.PageSize20
	}
	if currrentIndex <= 0 {
		currrentIndex = 1
	}
	startSize = utils.StartIndex(currrentIndex, pageSize)
	var total int
	var indexList []*data_manage.BaseFromSciHqIndexView
	if isListAll {
		tmpTotal, err := data_manage.GetSciHqIndexCount()
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		total = tmpTotal
		tmpIndexList, err := data_manage.GetSciHqIndexByPage(startSize, pageSize)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		indexList = tmpIndexList
	} else {
		var classifyIds []int
		if classifyId > 0 {
			tmpClassifyIds, err := data_manage.GetSciHqChildClassifyIdsById(classifyId)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
				return
			}
			if len(tmpClassifyIds) > 0 {
				classifyIds = append(classifyIds, tmpClassifyIds...)
			}
		}
		classifyIds = append(classifyIds, classifyId)
		tmpTotal, err := data_manage.GetSciHqIndexCountByClassifyId(classifyIds)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		total = tmpTotal
		tmpIndexList, err := data_manage.GetSciHqIndexByClassifyId(classifyIds, startSize, pageSize)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取指标信息失败，Err:" + err.Error()
			return
		}
		indexList = tmpIndexList
	}

	page := paging.GetPaging(currrentIndex, pageSize, total)
	resp := new(response.SciHqIndexPageListResp)
	resp.List = indexList
	resp.Paging = page

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

// SearchList
// @Title 卓创红期模糊搜索
// @Description 卓创红期模糊搜索
// @Param   Keyword   query   string  true       "关键字搜索"
// @Success 200 {object} models.BaseResponse
// @router /sci_hq/search_list [get]
func (this *SciHqDataController) SearchList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	//关键字
	keyword := this.GetString("Keyword")
	var condition string
	var pars []interface{}
	if keyword != "" {
		condition += ` AND (index_code LIKE ? OR index_name LIKE ?)`
		pars = utils.GetLikeKeywordPars(pars, keyword, 2)
	} else {
		br.Msg = "请输入指标ID/指标名称"
		return
	}

	list, err := data_manage.GetSciHqIndexBaseInfoByCondition(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

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

// SingleData
// @Title 获取卓创红期据
// @Description 获取卓创红期单条数据接口
// @Param   BaseFromSciHqIndexId   query   string  true       "指标唯一编码"
// @Success 200 {object} models.BaseResponse
// @router /sci_hq/single_data [get]
func (this *SciHqDataController) SingleData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	baseFromSciHqIndexId, _ := this.GetInt("BaseFromSciHqIndexId")
	indexInfo, err := data_manage.GetSciHqIndexByIndexId(baseFromSciHqIndexId)
	if err != nil {
		br.Msg = "获取指标信息失败"
		br.ErrMsg = "获取指标信息失败,Err:" + err.Error()
		return
	}
	edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_SCI_HQ, indexInfo.IndexCode)
	if err != nil {
		br.Msg = "获取指标数据失败"
		br.ErrMsg = "获取指标库数据失败,Err:" + err.Error()
		return
	}
	dataList, err := data_manage.GetSciHqDataByIndexId(baseFromSciHqIndexId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取数据失败,Err:" + err.Error()
		return
	}
	var ret response.SciHqSingleDataResp
	ret.ClassifyId = indexInfo.ClassifyId
	ret.BaseFromSciHqIndexId = indexInfo.BaseFromSciHqIndexId
	ret.IndexCode = indexInfo.IndexCode
	ret.EdbInfoId = edbInfo.EdbInfoId
	ret.IndexName = indexInfo.IndexName
	ret.Frequency = indexInfo.Frequency
	ret.CreateTime = indexInfo.CreateTime.Format(utils.FormatDateTime)
	ret.ModifyTime = indexInfo.ModifyTime.Format(utils.FormatDateTime)
	ret.Unit = indexInfo.Unit
	ret.Data = dataList

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

// MoveSciHqData
// @Title 卓创红期指标移动接口
// @Description 卓创红期指标移动接口
// @Success 200 {object} request.MoveBaseFromSciHqReq
// @router /sci_hq/move [post]
func (this *SciHqDataController) MoveSciHqData() {
	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.MoveBaseFromSciHqReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.BaseFromSciHqIndexId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "指标id小于等于0"
		br.IsSendEmail = false
		return
	}

	if req.ClassifyId < 0 {
		br.Msg = "请选择分类"
		br.ErrMsg = "请选择分类"
		br.IsSendEmail = false
		return
	}

	err, errMsg := data.MoveSciHqData(req.BaseFromSciHqIndexId, req.ClassifyId, req.PrevBaseFromSciHqIndexId, req.NextBaseFromSciHqIndexId)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}
	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "移动成功"
}

// ResetSciHqIndex
// @Title 指标数据清除分类
// @Description 指标数据清除分类
// @Param	request	body data_manage.DelBaseFromSciReq true "type json string"
// @Success 200 Ret=200 操作成功
// @router /sci_hq/reset [post]
func (this *SciHqDataController) ResetSciHqIndex() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.ResetBaseFromSciHqReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.BaseFromSciHqIndexId < 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}

	err = data.ResetSciHqIndex(req.BaseFromSciHqIndexId)
	if err != nil {
		br.Msg = "移动失败"
		br.ErrMsg = "移动失败，Err:" + err.Error()
		return
	}

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

// AddEdbInfo
// @Title 新增指标接口
// @Description 新增指标接口
// @Param	request	body data_manage.AddEdbInfoReq true "type json string"
// @Success Ret=200 保存成功
// @router /sci_hq/edb_info/add [post]
func (this *SciHqDataController) AddEdbInfo() {
	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_EDB_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.AddEdbInfoReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	req.EdbName = strings.Trim(req.EdbName, " ")
	req.EdbCode = strings.Trim(req.EdbCode, " ")

	if req.EdbCode == "" {
		br.Msg = "指标ID不能为空"
		return
	}

	if req.EdbName == "" {
		br.Msg = "指标名称不能为空"
		return
	}

	if req.Frequency == "" {
		br.Msg = "频率不能为空"
		return
	}

	if req.Unit == "" {
		br.Msg = "单位不能为空"
		return
	}

	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		return
	}

	_, err = data_manage.GetSciHqIndexByIndexCode(req.EdbCode)
	if err != nil {
		if err.Error() == utils.ErrNoRow() {
			br.Msg = "指标不存在"
			return
		}
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败,Err:" + err.Error()
		return
	}
	source := utils.DATA_SOURCE_SCI_HQ
	// 指标入库
	edbInfo, err, errMsg, isSendEmail := data.EdbInfoAdd(source, utils.DATA_SUB_SOURCE_EDB, req.ClassifyId, req.EdbCode, req.EdbName, req.Frequency, req.Unit, req.StartDate, req.EndDate, sysUser.AdminId, sysUser.RealName, this.Lang)
	if err != nil {
		br.Msg = "保存失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

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

	//新增操作日志
	{
		// 添加钢联指标更新日志
		if edbInfo.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
			go data_stat.AddEdbInfoUpdateLog(edbInfo.EdbInfoId, 1, "", sysUser, 2)
		}

		edbLog := new(data_manage.EdbInfoLog)
		edbLog.EdbInfoId = edbInfo.EdbInfoId
		edbLog.SourceName = edbInfo.SourceName
		edbLog.Source = edbInfo.Source
		edbLog.EdbCode = edbInfo.EdbCode
		edbLog.EdbName = edbInfo.EdbName
		edbLog.ClassifyId = edbInfo.ClassifyId
		edbLog.SysUserId = sysUser.AdminId
		edbLog.SysUserRealName = sysUser.RealName
		edbLog.CreateTime = time.Now()
		edbLog.Content = string(this.Ctx.Input.RequestBody)
		edbLog.Status = "新增指标"
		edbLog.Method = this.Ctx.Input.URI()
		go data_manage.AddEdbInfoLog(edbLog)
	}

	// 更新es
	go data.AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)

	resp := new(data_manage.AddEdbInfoResp)
	resp.EdbInfoId = edbInfo.EdbInfoId
	resp.UniqueCode = edbInfo.UniqueCode
	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}

// AddCheck
// @Title 新增校验
// @Description 新增校验
// @Param	request	body request.BusinessDataBatchAddCheckReq true "type json string"
// @Success 200 string "操作成功"
// @router /sci_hq/edb_info/add_check [post]
func (this *SciHqDataController) AddCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req *request.SciHqDataBatchAddCheckReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	codeMax := 30
	codeLen := len(req.IndexCodes)
	if len(req.IndexCodes) == 0 {
		br.Msg = "请选择指标"
		return
	}

	if codeLen > codeMax {
		br.Msg = fmt.Sprintf("最多只能选择%d个指标", codeMax)
		return
	}
	// 获取指标库已有指标
	existsEdb, e := data_manage.GetEdbCodesBySource(utils.DATA_SOURCE_SCI_HQ)
	if e != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取自有数据已添加的指标失败, Err: " + e.Error()
		return
	}
	existMap := make(map[string]*data_manage.EdbInfo)
	for _, v := range existsEdb {
		existMap[v.EdbCode] = v
	}

	// 查询选中的指标
	cond := fmt.Sprintf(` AND index_code IN (%s)`, utils.GetOrmInReplace(codeLen))
	pars := make([]interface{}, 0)
	pars = append(pars, req.IndexCodes)
	list, err := data_manage.GetSciHqIndexAndEdbInfoByCondition(cond, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取卓创红期原始指标列表失败, Err: " + err.Error()
		return
	}

	resp := make([]*data_manage.BaseFromSciHqIndexView, 0)
	for _, v := range list {
		if v.EdbInfoId > 0 {
			v.EdbExist = 1
		}
		resp = append(resp, v)
	}

	br.Data = resp
	br.Msg = "校验成功"
	br.Ret = 200
	br.Success = true
}

// NameCheck
// @Title 重名校验
// @Description 批量新增
// @Param	request	body data_manage.AddEdbInfoReq true "type json string"
// @Success 200 string "操作成功"
// @router /sci_hq/edb_info/name_check [post]
func (c *SciHqDataController) NameCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req []*data_manage.NameCheckEdbInfoReq
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if len(req) == 0 {
		br.Msg = "请选择指标"
		return
	}
	codeMax := 30
	codeLen := len(req)
	if codeLen > codeMax {
		br.Msg = fmt.Sprintf("最多只能选择%d个指标", codeMax)
		return
	}

	type NameCheckResult struct {
		EdbCode string
		EdbName string
		Exist   bool
	}
	indexNames := make([]string, 0)
	resp := make([]*NameCheckResult, 0)
	for _, v := range req {
		v.EdbCode = strings.TrimSpace(v.EdbCode)
		if v.EdbCode == "" {
			br.Msg = "指标ID不可为空"
			return
		}
		v.EdbName = strings.TrimSpace(v.EdbName)
		if v.EdbName == "" {
			br.Msg = "请输入指标名称"
			return
		}
		indexNames = append(indexNames, v.EdbName)
		resp = append(resp, &NameCheckResult{
			EdbCode: v.EdbCode,
			EdbName: v.EdbName,
		})
		dataItems, err := data_manage.GetEdbDataAllByEdbCode(v.EdbCode, utils.DATA_SOURCE_SCI_HQ, 0, utils.EDB_DATA_LIMIT)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取失败"
			br.ErrMsg = "获取卓创红期已存在信息失败,Err:" + err.Error()
			return
		}
		if len(dataItems) <= 0 {
			respItem, err := data.AddEdbData(utils.DATA_SOURCE_SCI_HQ, v.EdbCode, v.Frequency)
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = "获取失败,Err:" + err.Error()
				return
			}
			if respItem.Ret != 200 {
				br.Msg = "未搜索到该指标"
				br.ErrMsg = respItem.ErrMsg + ";EdbCode:" + v.EdbCode
				return
			}
		}
	}

	// 重名校验
	edbList, e := data_manage.GetEdbInfoByNameArr(indexNames, utils.EDB_INFO_TYPE)
	if e != nil {
		br.Msg = "操作失败"
		br.ErrMsg = "获取重名指标失败, Err: " + e.Error()
		return
	}
	nameExists := make(map[string]bool)
	for _, v := range edbList {
		nameExists[v.EdbName] = true
	}
	if len(nameExists) > 0 {
		for _, v := range resp {
			v.Exist = nameExists[v.EdbName]
		}
	}

	br.Data = resp
	br.Msg = "校验成功"
	br.Ret = 200
	br.Success = true
}

// BatchAdd
// @Title 批量新增
// @Description 批量新增
// @Param	request	body data_manage.AddEdbInfoReq true "type json string"
// @Success 200 string "操作成功"
// @router /sci_hq/edb_info/batch_add [post]
func (this *SciHqDataController) BatchAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	deleteCache := true
	cacheKey := "CACHE_EDB_INFO_BATCH_ADD_SCI_HQ_" + 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.AddEdbInfoReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if len(req) == 0 {
		br.Msg = "请选择指标"
		return
	}
	if len(req) > 30 {
		br.Msg = "批量添加指标数量不得超过30个"
		return
	}
	for _, v := range req {
		v.EdbCode = strings.TrimSpace(v.EdbCode)
		if v.EdbCode == "" {
			br.Msg = "指标ID不可为空"
			return
		}
		v.EdbName = strings.TrimSpace(v.EdbName)
		if v.EdbName == "" {
			br.Msg = "请输入指标名称"
			return
		}
		v.Frequency = strings.TrimSpace(v.Frequency)
		if v.Frequency == "" {
			br.Msg = "请选择频度"
			return
		}
		v.Unit = strings.TrimSpace(v.Unit)
		if v.Unit == "" {
			br.Msg = "请输入单位"
			return
		}
		if v.ClassifyId <= 0 {
			br.Msg = "请选择分类"
			return
		}
	}

	// 限定同一时间最多批量新增30个指标
	for _, v := range req {
		var r data.SciHqIndexSource2EdbReq
		r.EdbCode = v.EdbCode
		r.EdbName = v.EdbName
		r.Frequency = v.Frequency
		r.Unit = v.Unit
		r.ClassifyId = v.ClassifyId
		r.AdminId = sysUser.AdminId
		r.AdminRealName = sysUser.RealName

		edbInfo, errMsg, skip, e := data.SciHqIndexSource2Edb(r, this.Lang)
		if e != nil {
			br.Msg = "操作失败"
			if errMsg != "" {
				br.Msg = errMsg
			}
			br.ErrMsg = e.Error()
			return
		}
		if skip {
			continue
		}

		// 试用平台更新用户累计新增指标数
		if utils.BusinessCode == utils.BusinessCodeSandbox {
			go func() {
				adminItem, e := system.GetSysAdminById(sysUser.AdminId)
				if e != nil {
					tips := fmt.Sprintf("试用平台更新用户累计新增指标数-获取用户失败, Err: " + e.Error())
					utils.FileLog.Info(tips)
					return
				}
				if adminItem.DepartmentName != "ETA试用客户" {
					return
				}
				var ur etaTrialService.EtaTrialUserReq
				ur.Mobile = adminItem.Mobile
				_, _ = etaTrialService.UpdateUserIndexNum(ur)
			}()
		}

		// 新增操作日志
		{
			edbLog := new(data_manage.EdbInfoLog)
			edbLog.EdbInfoId = edbInfo.EdbInfoId
			edbLog.SourceName = edbInfo.SourceName
			edbLog.Source = edbInfo.Source
			edbLog.EdbCode = edbInfo.EdbCode
			edbLog.EdbName = edbInfo.EdbName
			edbLog.ClassifyId = edbInfo.ClassifyId
			edbLog.SysUserId = sysUser.AdminId
			edbLog.SysUserRealName = sysUser.RealName
			edbLog.CreateTime = time.Now()
			edbLog.Content = string(this.Ctx.Input.RequestBody)
			edbLog.Status = "新增指标"
			edbLog.Method = this.Ctx.Input.URI()
			go data_manage.AddEdbInfoLog(edbLog)
		}
	}

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

// BatchDelete
// @Title 批量删除
// @Description 批量删除
// @Param	request	body []*request.DelBaseFromSciHqReq true "type json string"
// @Success 200 string "操作成功"
// @router /sci_hq/edb_info/batch_delete [post]
func (this *SciHqDataController) BatchDelete() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req []*request.DelBaseFromSciHqReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if len(req) == 0 {
		br.Msg = "请选择指标"
		return
	}
	if len(req) > 30 {
		br.Msg = "批量添加指标数量不得超过30个"
		return
	}
	var deleteIds []int
	for _, v := range req {
		if v.BaseFromSciHqIndexId <= 0 {
			continue
		}
		deleteIds = append(deleteIds, v.BaseFromSciHqIndexId)
	}
	existList, err := data.BatchDelSciHqData(deleteIds)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除失败，Err:" + err.Error()
		return
	}

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

// BatchEdit
// @Title 批量编辑
// @Description 批量编辑
// @Param	request	body []*request.DelBaseFromSciHqReq true "type json string"
// @Success 200 string "操作成功"
// @router /sci_hq/edb_info/batch_edit [post]
func (this *SciHqDataController) BatchEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req []*request.EditBaseFromSciHqReq
	if e := json.Unmarshal(this.Ctx.Input.RequestBody, &req); e != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + e.Error()
		return
	}
	if len(req) == 0 {
		br.Msg = "请选择指标"
		return
	}

	indexIds := make([]int, 0)
	classifyIds := make([]int, 0)
	indexIdToclassifyId := make(map[int]int)
	for _, v := range req {
		if v.BaseFromSciHqIndexId <= 0 {
			continue
		}
		if v.ClassifyId <= 0 {
			continue
		}
		indexIds = append(indexIds, v.BaseFromSciHqIndexId)
		classifyIds = append(classifyIds, v.ClassifyId)
		indexIdToclassifyId[v.BaseFromSciHqIndexId] = v.ClassifyId
	}
	if len(indexIds) == 0 {
		br.Msg = "请选择指标或指定正确的分类"
		return
	}
	indexList, err := data_manage.GetSciHqIndexListByIndexIds(indexIds)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "获取指标失败，Err:" + err.Error()
		return
	}
	classifySort, err := data_manage.GetSciHqClassifyMaxSortByClassifyIds(classifyIds)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "获取分类最大排序失败，Err:" + err.Error()
		return
	}
	classifySortMap := make(map[int]int)
	for _, v := range classifySort {
		classifySortMap[v.ClassifyId] = v.MaxSort
	}
	classifyList, err := data_manage.GetSciHqClassifyListByIds(classifyIds)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "获取分类失败，Err:" + err.Error()
		return
	}
	existClassifyList := make(map[int]struct{})
	for _, v := range classifyList {
		existClassifyList[v.ClassifyId] = struct{}{}
	}
	//编辑指标
	updateIndexList := make([]*data_manage.BaseFromSciHqIndex, 0)
	for _, v := range indexList {
		tmpClassifyId := indexIdToclassifyId[v.BaseFromSciHqIndexId]
		if _, ok := existClassifyList[tmpClassifyId]; ok {
			v.ClassifyId = tmpClassifyId
			v.Sort = classifySortMap[tmpClassifyId] + 1
			classifySortMap[tmpClassifyId] += 1
			updateIndexList = append(updateIndexList, v)
		}
	}
	err = data_manage.BatchModifySciHqIndexClassify(updateIndexList)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑指标失败，Err:" + err.Error()
		return
	}

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

}

// EditSciHq
// @Title 编辑卓创红期指标
// @Description 编辑卓创红期指标接口
// @Param	request	body data_manage.AddEdbClassifyReq true "type json string"
// @Success 200 Ret=200 保存成功
// @router /sci_hq/edit [post]
func (this *SciHqDataController) EditSciHq() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.EditBaseFromSciHqReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.BaseFromSciHqIndexId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	if req.ClassifyId <= 0 {
		br.Msg = "请选择分类"
		br.IsSendEmail = false
		return
	}

	//编辑指标
	sciIndexInfo, errMsg, err := data.EditSciHqIndex(req.BaseFromSciHqIndexId, req.ClassifyId)
	if errMsg != `` {
		br.Msg = errMsg
		return
	}
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑指标失败，Err:" + err.Error()
		return
	}

	resp := response.EditSciHqIndexInfoResp{
		BaseFromSciHqIndexId: sciIndexInfo.BaseFromSciHqIndexId,
		IndexCode:            sciIndexInfo.IndexCode,
	}
	br.Data = resp
	br.Ret = 200
	br.Msg = "保存成功"
	br.Success = true
	br.IsAddLog = true
}

// DeleteSciHqData
// @Title 删除指标
// @Description 删除指标接口
// @Param	request	body data_manage.DelBaseFromSciReq true "type json string"
// @Success 200 Ret=200 删除成功
// @router /sci_hq/del [post]
func (this *SciHqDataController) DeleteSciHqData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req request.DelBaseFromSciHqReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.BaseFromSciHqIndexId < 0 {
		br.Msg = "参数错误"
		br.IsSendEmail = false
		return
	}

	err, errMsg := data.DelSciHqData(req.BaseFromSciHqIndexId)
	if errMsg != `` {
		br.Msg = errMsg
		br.ErrMsg = errMsg
		if err != nil {
			br.ErrMsg = errMsg + ";Err:" + err.Error()
		} else {
			br.IsSendEmail = false
		}
		return
	}

	br.Ret = 200
	br.Msg = "删除成功"
	br.Success = true
	br.IsAddLog = true
}

// ExportSciHqList
// @Title 导出Sci数据
// @Description 导出Sci数据
// @Param   ClassifyId   query   int  true       "关键字搜索"
// @Success 200  导出成功
// @router /export/sciHqList [get]
func (this *SciHqDataController) ExportSciHqList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}

	classifyId, _ := this.GetInt("ClassifyId")
	if classifyId < 0 {
		br.Msg = "请选择分类"
		return
	}
	secNameList := make([]*models.EdbdataExportList, 0)
	dir, _ := os.Executable()
	exPath := filepath.Dir(dir)
	downLoadnFilePath := exPath + "/" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	xlsxFile := xlsx.NewFile()

	var condition string
	var pars []interface{}
	if classifyId > 0 {
		childClassify, err := data_manage.GetChildSciHqClassifyListById(classifyId)
		if err != nil {
			br.Msg = "下载失败"
			br.ErrMsg = "获取分类失败,Err:" + err.Error()
			return
		}
		if len(childClassify) > 0 {
			condition += `AND classify_id IN (` + utils.GetOrmInReplace(len(childClassify)) + `)`
			for _, child := range childClassify {
				pars = append(pars, child.ClassifyId)
			}
		} else {
			condition += ` AND classify_id=?`
			pars = append(pars, classifyId)
		}
	} else {
		condition += ` AND classify_id=?`
		pars = append(pars, classifyId)
	}
	frequencies, err := data_manage.GetSciHqFrequencyByCondition(condition, pars)
	if err != nil {
		fmt.Println("GetSciFrequency err:", err.Error())
		utils.FileLog.Info("GetSciFrequency err:" + err.Error())
		return
	}
	for _, frequency := range frequencies {

		//获取指标
		secNameList, err := data_manage.GetSciHqIndexByConditionAndFrequency(condition, *frequency, pars)
		if err != nil {
			fmt.Println("获取数据失败，Err:" + err.Error())
			return
		}
		if len(secNameList) <= 0 {
			fmt.Println("secNameList长度为0")
			return
		}
		sheetNew, err := xlsxFile.AddSheet(*frequency)

		if err != nil {
			fmt.Println("新增Sheet失败", err.Error())
			return
		}
		//sheetNew.SetColWidth()
		//获取指标数据
		windRow := sheetNew.AddRow()
		secNameRow := sheetNew.AddRow()
		indexCodeRow := sheetNew.AddRow()
		frequencyRow := sheetNew.AddRow()
		unitRow := sheetNew.AddRow()
		lastModifyDateRow := sheetNew.AddRow()
		//获取分类下指标最大数据量
		dataMax, err := data_manage.GetSciHqDataMaxCount(condition, pars)
		if err != nil {
			fmt.Println("获取指标最大数据量失败", err.Error())
			return
		}
		fmt.Println("dataMax:", dataMax)
		setRowIndex := 6
		for k, sv := range secNameList {
			//获取数据
			dataList, err := data_manage.GetSciHqIndexDataByCode(sv.IndexCode)
			if err != nil {
				br.Msg = "获取数据失败"
				br.ErrMsg = "获取数据失败,Err:" + err.Error()
				return
			}
			if len(dataList) > 0 {
				windRow.AddCell().SetValue("Sci_Hq")
				secNameRow.AddCell().SetValue("指标名称")
				indexCodeRow.AddCell().SetValue("指标ID")
				frequencyRow.AddCell().SetValue("频率")
				unitRow.AddCell().SetValue("单位")
				lastModifyDateRow.AddCell().SetValue("更新时间")

				secNameRow.AddCell().SetValue(sv.IndexName)
				indexCodeRow.AddCell().SetValue(sv.IndexCode)
				frequencyRow.AddCell().SetValue(sv.Frequency)

				unitRow.AddCell().SetValue(sv.Unit)
				lastModifyDateRow.AddCell().SetValue(sv.ModifyTime)

				windRow.AddCell()
				windRow.AddCell()
				secNameRow.AddCell()
				indexCodeRow.AddCell()
				frequencyRow.AddCell()
				unitRow.AddCell()
				lastModifyDateRow.AddCell()
				min := k * 3
				sheetNew.SetColWidth(min, min, 15)

				if len(dataList) <= 0 {
					for n := 0; n < dataMax; n++ {
						rowIndex := setRowIndex + n
						row := sheetNew.Row(rowIndex)
						row.AddCell()
						row.AddCell()
						row.AddCell()
					}
				} else {
					endRowIndex := 0
					for rk, dv := range dataList {
						rowIndex := setRowIndex + rk
						row := sheetNew.Row(rowIndex)
						displayDate, _ := time.Parse(utils.FormatDate, dv.DataTime)
						displayDateCell := row.AddCell()
						style := new(xlsx.Style)
						style.ApplyAlignment = true
						style.Alignment.WrapText = true
						displayDateCell.SetStyle(style)
						displayDateCell.SetDate(displayDate)

						row.AddCell().SetValue(dv.Value)
						row.AddCell()
						endRowIndex = rowIndex
					}
					if len(dataList) < dataMax {
						dataLen := dataMax - len(dataList)
						for n := 0; n < dataLen; n++ {
							rowIndex := (endRowIndex + 1) + n
							row := sheetNew.Row(rowIndex)
							row.AddCell()
							row.AddCell()
							row.AddCell()
						}
					}
				}
			}
		}
	}

	err = xlsxFile.Save(downLoadnFilePath)
	if err != nil {
		//有指标无数据时先导出一遍空表
		sheet, err := xlsxFile.AddSheet("无数据")
		if err != nil {
			br.Msg = "新增Sheet失败"
			br.ErrMsg = "新增Sheet失败,Err:" + err.Error()
			return
		}
		rowSecName := sheet.AddRow()
		celSecName := rowSecName.AddCell()
		celSecName.SetValue("")
		err = xlsxFile.Save(downLoadnFilePath)
		if err != nil {
			br.Msg = "保存文件失败"
			br.ErrMsg = "保存文件失败"
			return
		}
	}
	fileName := `卓创红期`
	if len(secNameList) > 0 {
		fileName = secNameList[0].ClassifyName
	}
	fileName += time.Now().Format("2006.01.02") + `.xlsx` //文件名称
	this.Ctx.Output.Download(downLoadnFilePath, fileName)
	defer func() {
		os.Remove(downLoadnFilePath)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "success"
}

// getSciHqClassifyTree 返回卓创红旗的树形结构
func getSciHqClassifyTree(items []*data_manage.BaseFromSciHqClassifyItem, parentId int) []*data_manage.BaseFromSciHqClassifyItem {
	res := make([]*data_manage.BaseFromSciHqClassifyItem, 0)
	for _, item := range items {
		if item.ParentId == parentId {
			t := new(data_manage.BaseFromSciHqClassifyItem)
			t.ClassifyId = item.ClassifyId
			t.ClassifyName = item.ClassifyName
			t.ParentId = item.ParentId
			t.Level = item.Level
			t.Sort = item.Sort
			t.ModifyTime = item.ModifyTime
			t.CreateTime = item.CreateTime
			t.ClassifyNameEn = item.ClassifyNameEn
			if item.UniqueCode == "" {
				t.UniqueCode = strconv.Itoa(item.ClassifyId)
			}
			t.Children = getSciHqClassifyTree(items, item.ClassifyId)
			res = append(res, t)
		}
	}
	return res
}