eta_api/controllers/manual_edb.go

package controllers

import (
	"encoding/json"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/system"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/services/data"
	etaTrialService "eta/eta_api/services/eta_trial"
	"eta/eta_api/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"github.com/shopspring/decimal"
	"github.com/tealeg/xlsx"
	"os"
	"strconv"
	"strings"
	"time"
)

// EdbDetail
// @Title 指标列表
// @Description 指标列表
// @Param   TradeCode   query   string  true       "指标编码"
// @Success 200 {object} models.TargetDetailResp
// @router /target/edb/detail [get]
func (this *TargetController) EdbDetail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	// 指标编码
	tradeCode := this.GetString("TradeCode")
	if tradeCode == `` {
		br.Msg = "请输入指标编码"
		br.IsSendEmail = false
		return
	}

	manualEdbInfo, err := models.GetTargetByTradeCode(tradeCode)
	if err != nil {
		br.Msg = "获取指标失败"
		br.ErrMsg = "获取指标失败,err:" + err.Error()
		return
	}

	// 如果不是超管账号，那么得校验下当前用户是否有该指标的权限
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		//获取账户所拥有权限的分类id集合
		count, err := models.GetCountManualUserClassify(sysUser.AdminId, manualEdbInfo.ClassifyId)
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.ErrMsg = "获取分类数据失败,err:" + err.Error()
			return
		}

		if count <= 0 {
			br.Msg = "无权访问"
			br.ErrMsg = "无权访问"
			br.IsSendEmail = false
			return
		}
	}

	classifyList := make([]*models.EdbdataClassify, 0)
	{
		classify, err := models.GetManualClassifyByClassifyId(manualEdbInfo.ClassifyId)
		if err != nil {
			br.Msg = "获取分类信息失败"
			br.ErrMsg = "获取分类信息失败,err:" + err.Error()
			return
		}
		parentClassify, err := models.GetManualClassifyByClassifyId(classify.ParentId)
		if err != nil {
			br.Msg = "获取分类信息失败"
			br.ErrMsg = "获取父级分类信息失败,err:" + err.Error()
			return
		}
		classifyList = []*models.EdbdataClassify{
			parentClassify, classify,
		}
	}

	// 明细数据
	{
		dataList, err := models.GetEdbDataListByCode(manualEdbInfo.TradeCode)
		if err != nil {
			br.Msg = "获取明细数据失败"
			br.ErrMsg = "获取明细数据失败,err:" + err.Error()
			return
		}

		manualEdbInfo.DataList = dataList
	}

	resp := models.TargetDetailResp{
		Detail:       manualEdbInfo,
		ClassifyList: classifyList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	//br.Data = resp
	br.Data = resp
}

// ClassifyEdbList
// @Title 分类指标列表
// @Description 指标列表
// @Param   ClassifyId   query   string  true       "分类id"
// @Success 200 {object} models.TargetDetailResp
// @router /target/classify/edb/list [get]
func (this *TargetController) ClassifyEdbList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.Ret = 408
		return
	}
	resp := new(models.EdbdataClassifyResp)

	classifyId, _ := this.GetInt("ClassifyId") //分类
	if classifyId <= 0 {
		br.Msg = "请传入分类"
		br.ErrMsg = "请传入分类"
		br.IsSendEmail = false
	}

	var condition string
	var pars []interface{}

	// 如果不是超管账号，那么得校验下当前用户是否有该指标的权限
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		//获取账户所拥有权限的分类id集合
		count, err := models.GetCountManualUserClassify(sysUser.AdminId, classifyId)
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.ErrMsg = "获取分类数据失败,err:" + err.Error()
			return
		}

		if count <= 0 {
			br.Msg = "无权访问"
			br.ErrMsg = "无权访问"
			br.IsSendEmail = false
			return
		}
	}

	list := make([]*models.EdbdataClassifyList, 0)

	condition += ` AND a.classify_id = ? `
	pars = append(pars, classifyId)

	tmpList, err := models.GetEdbInfoList(condition, pars, 0, 0)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}

	for _, v := range tmpList {
		list = append(list, &models.EdbdataClassifyList{
			ClassifyId:   0,
			ClassifyName: v.SecName,
			ParentId:     v.ClassifyId,
			Child:        nil,
			TradeCode:    v.TradeCode,
			UniqueCode:   utils.MD5(v.TradeCode),
		})
	}

	resp.List = list

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

// EdbSearch
// @Title 指标搜索
// @Description 指标搜索
// @Param   Keyword   query   string  false       "关键字搜索"
// @Success 200 {object} models.TargetItemListResp
// @router /target/edb/search [get]
func (this *TargetController) EdbSearch() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

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

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

	//关键字
	keyword := this.GetString("Keyword")

	var condition string
	var pars []interface{}

	userId := sysUser.AdminId
	//超管账号可以查看分类下的所有频度数据
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		classifyList, err := models.GetEdbdataClassify(int64(userId))
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.Msg = "获取拥有的分类数据失败，Err:" + err.Error()
			return
		}

		num := len(classifyList)
		if num > 0 {
			classifyIdList := make([]int, 0)
			for _, v := range classifyList {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(num) + `) `
			pars = append(pars, classifyIdList)
		}

	}

	if keyword != "" {
		condition += ` AND (a.SEC_NAME like ?  or a.TRADE_CODE like ? )`
		pars = utils.GetLikeKeywordPars(pars, keyword, 2)
	}

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

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

	for _, v := range list {
		v.UniqueCode = utils.MD5(v.TradeCode)
	}

	resp := models.EdbListResp{
		List:   list,
		Paging: paging.GetPaging(currentIndex, pageSize, total),
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EdbList
// @Title 获取研究员指标
// @Description 获取研究员指标
// @Param   Frequency   query   string  false       "频度；枚举值：日度、周度、月度、季度、半年度、年度"
// @Param   Keyword   query   string  false       "关键字搜索"
// @Param   TradeCode   query   string  false       "指标唯一编码"
// @Param   ClassifyId   query   int  false       "分类id"
// @Param   UserId   query   int  false       "用户id"
// @Param   EdbShowType   query   string  true       "指标展示类型：0,1,2; 0：不管有没有数据，指标都展示出来， 1：只展示有数据的指标， 2：只展示没有数据的指标"
// @Success 200 {object} models.TargetItemListResp
// @router /target/edb/list [get]
func (this *TargetController) EdbList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

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

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

	// 频度
	frequency := this.GetString("Frequency")
	//关键字
	keyword := this.GetString("Keyword")
	//关键字
	classifyId, _ := this.GetInt("ClassifyId", 0)
	//用户ID
	userId, _ := this.GetInt("UserId", 0)

	var condition string
	var pars []interface{}

	//超管账号可以查看分类下的所有频度数据
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		classifyList, err := models.GetEdbdataClassify(int64(sysUser.AdminId))
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.Msg = "获取拥有的分类数据失败，Err:" + err.Error()
			return
		}

		num := len(classifyList)
		if num > 0 {
			classifyIdList := make([]int, 0)
			for _, v := range classifyList {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(num) + `) `
			pars = append(pars, classifyIdList)
		}

	}

	// 关键词
	if keyword != "" {
		condition += ` AND (a.SEC_NAME like ?  or a.TRADE_CODE like ? )`
		pars = utils.GetLikeKeywordPars(pars, keyword, 2)
	}
	if frequency != "" {
		condition += ` AND a.frequency = ?`
		pars = append(pars, frequency)
	}

	// 所属分类
	if classifyId > 0 {
		condition += ` AND a.classify_id = ? `
		pars = append(pars, classifyId)
	}

	// 所属用户
	if userId > 0 {
		condition += ` AND a.user_id = ? `
		pars = append(pars, userId)
	}

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

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

	resp := models.EdbListResp{
		List:   list,
		Paging: paging.GetPaging(currentIndex, pageSize, total),
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// EditExcelData
// @Title 根据excel的样式去编辑指标
// @Description 根据excel的样式去编辑指标
// @Param  request	body models.ManualEdbExcelStyleEditReq true "type json string"
// @Success 200
// @router /target/edb/excel_style/edit [post]
func (this *TargetController) EditExcelData() {
	br := new(models.BaseResponse).Init()
	var err error
	errs := make([]string, 0)
	defer func() {
		if len(errs) > 0 {
			utils.FileLog.Info("编辑EXCEL数据 新增或修改数据失败，Err：" + strings.Join(errs, "\n"))
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

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

	if req.TradeCode == `` {
		br.Msg = "指标编码异常！"
		br.ErrMsg = "指标编码异常！"
		return
	}
	if req.Unit == `` {
		br.Msg = "单位填写异常！"
		br.ErrMsg = "单位填写异常！"
		return
	}
	if req.Frequency == `` {
		br.Msg = "频度填写异常！"
		br.ErrMsg = "频度填写异常！"
		return
	}
	if req.ClassifyId <= 0 {
		br.Msg = "品种填写异常！"
		br.ErrMsg = "品种填写异常！"
		return
	}

	// 获取指标信息
	manualEdbInfo, err := models.GetEdbinfoByTradeCode(req.TradeCode)
	if err != nil {
		br.Msg = `找不到该指标`
		br.Msg = `找不到该指标，ERR:` + err.Error()
		return
	}

	// 如果不是超管账号，那么得校验下当前用户是否有该指标的权限
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		//获取账户所拥有权限的分类id集合
		count, err := models.GetCountManualUserClassify(sysUser.AdminId, manualEdbInfo.ClassifyId)
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.ErrMsg = "获取分类数据失败,err:" + err.Error()
			return
		}

		if count <= 0 {
			br.Msg = "无权访问"
			br.ErrMsg = "无权访问"
			br.IsSendEmail = false
			return
		}
	}

	dateValueMap := make(map[string]string)
	//取到所有数据
	for i := range req.Data {
		// 过滤第一行
		if i == 0 {
			continue
		}
		if req.Data[i] == nil {
			continue
		}
		tmpData := req.Data[i]
		// 少于两列，说明数据是异常的，得过滤
		if len(tmpData) < 2 {
			continue
		}

		var tmpDate string
		//先拿下日期列表
		{
			dateMap := tmpData[0].(map[string]interface{})
			_, ok := dateMap["m"]
			if !ok {
				continue
			}
			tmpDate = dateMap["m"].(string)
		}

		// 数据处理
		{
			if tmpData[1] == nil {
				continue
			}
			valueMap := tmpData[1].(map[string]interface{})
			value, _ := valueMap["m"]
			if value == nil {
				continue
			}
			dateValueMap[tmpDate] = valueMap["m"].(string)

			// 09-27 千位分隔符时用 "m" 取字符串存数据库会把逗号当小数点，现在换用 "v" 直接取数字再转为字符串，看看会不会有问题
			if ct, ok := valueMap["ct"].(map[string]interface{}); ok {
				fa, _ := ct["fa"]
				if fa == "#,##0.000" {
					value = valueMap["v"]
					floatValue := valueMap["v"].(float64)
					dateValueMap[tmpDate] = strconv.FormatFloat(floatValue, 'f', -1, 64)
				}
			}
		}
	}

	//操作指标，新增指标及数据等
	{
		secName := strings.TrimSpace(req.Name)
		frequency := strings.TrimSpace(req.Frequency)
		unit := strings.TrimSpace(req.Unit)

		// 指标基础信息变更
		{
			updateCols := make([]string, 0)

			if manualEdbInfo.SecName != secName {
				updateCols = append(updateCols, "SecName")
				manualEdbInfo.SecName = secName
			}

			if manualEdbInfo.ClassifyId != req.ClassifyId {
				updateCols = append(updateCols, "ClassifyId")
				manualEdbInfo.ClassifyId = req.ClassifyId
			}

			if manualEdbInfo.Frequency != frequency {
				updateCols = append(updateCols, "Frequency")
				manualEdbInfo.Frequency = frequency
			}

			if manualEdbInfo.Unit != unit {
				updateCols = append(updateCols, "Unit")
				manualEdbInfo.Unit = unit
			}

			if len(updateCols) > 0 {
				err = manualEdbInfo.Update(updateCols)
				if err != nil {
					br.Msg = `指标保存失败`
					br.Msg = `指标保存失败，ERR:` + err.Error()
					return
				}
			}
		}

		// 当前已经存在的指标明细数据
		targetDataList, tmpErr := models.GetTargetsDataList(manualEdbInfo.TradeCode)
		if tmpErr != nil {
			err = tmpErr
		}
		existDataMap := make(map[string]string)
		deleteDataMap := make(map[string]string)
		for _, tmpData := range targetDataList {
			existDataMap[tmpData.Dt] = tmpData.Close
			deleteDataMap[tmpData.Dt] = tmpData.Dt
		}

		addDataList := make([]*models.Edbdata, 0)

		for createDate, closeVal := range dateValueMap {
			if createDate == "" || closeVal == "" {
				continue
			}
			//判断数据是否已经存在
			tmpVal, ok3 := existDataMap[createDate]
			// 不存在，那么后面进行插入
			if !ok3 {
				addDataList = append(addDataList, &models.Edbdata{
					TradeCode:  manualEdbInfo.TradeCode,
					Dt:         createDate,
					Close:      closeVal,
					ModifyTime: time.Now(),
				})
				continue
			}

			delete(deleteDataMap, createDate)

			// 库里面的数据
			tmpValDecimal, tmpErr := decimal.NewFromString(tmpVal)
			if tmpErr != nil {
				fmt.Println("tmpVal Parse err:", tmpErr.Error())
				err = tmpErr
				continue
			}
			// 用户填写的数据
			closeValDecimal, tmpErr := decimal.NewFromString(closeVal)
			if tmpErr != nil {
				fmt.Println("closeVal Parse err:", tmpErr.Error())
				err = tmpErr
				continue
			}
			if !tmpValDecimal.Equal(closeValDecimal) {
				fmt.Println("更新数值")
				err = models.ModifyTargetsDataByImport(manualEdbInfo.TradeCode, createDate, closeVal)
				if err != nil {
					fmt.Println("ModifyTargetsDataByImport err:", err.Error())
					errs = append(errs, err.Error())
					//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 修改数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
				}
			}
		}

		// 新增指标
		if len(addDataList) > 0 {
			err = models.OnlyMultiAddEdbdata(addDataList)
			if err != nil {
				fmt.Println("MultiAddEdbdata err:", err.Error())
				errs = append(errs, err.Error())
			}
		}

		// 删除不需要的日期数据
		num := len(deleteDataMap)
		if num > 0 {
			deleteDateList := make([]string, 0)
			for date := range deleteDataMap {
				deleteDateList = append(deleteDateList, date)
			}

			err = models.DelEdbdataByCodeAndDateList(manualEdbInfo.TradeCode, deleteDateList)
			if err != nil {
				fmt.Println("DelEdbdataByCodeAndDateList err:", err.Error())
				errs = append(errs, err.Error())
			}
		}
	}

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

// BatchEdbList
// @Title 获取研究员指标
// @Description 获取研究员指标
// @Param	request	body models.BatchAddEdbReq true "type json string"
// @Success 200 {object} models.TargetItemListResp
// @router /target/edb/batch/list [post]
func (this *TargetController) BatchEdbList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	var req models.BatchManualEdbReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)

	pageSize := req.PageSize
	currentIndex := req.CurrentIndex

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

	req.Keyword = strings.TrimSpace(req.Keyword)

	var condition string
	var pars []interface{}

	// 是否加到指标库
	condition += ` AND a.is_join_edb = ? `
	pars = append(pars, 0)

	//超管账号可以查看分类下的所有频度数据
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		classifyList, err := models.GetEdbdataClassify(int64(sysUser.AdminId))
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.Msg = "获取拥有的分类数据失败，Err:" + err.Error()
			return
		}

		num := len(classifyList)
		if num > 0 {
			classifyIdList := make([]int, 0)
			for _, v := range classifyList {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(num) + `) `
			pars = append(pars, classifyIdList)
		}

	}

	// 关键词
	if req.Keyword != "" {
		condition += ` AND (a.SEC_NAME like ?  or a.TRADE_CODE like ? )`
		pars = utils.GetLikeKeywordPars(pars, req.Keyword, 2)
	}

	// 所属分类
	lenFrequency := len(req.FrequencyList)
	if lenFrequency > 0 {
		condition += ` AND a.frequency in (` + utils.GetOrmInReplace(lenFrequency) + `) `
		pars = append(pars, req.FrequencyList)
	}

	// 所属分类
	lenClassify := len(req.ClassifyIdList)
	if lenClassify > 0 {
		condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(lenClassify) + `) `
		pars = append(pars, req.ClassifyIdList)
	}

	// 所属用户
	lenUser := len(req.UserIdList)
	if lenUser > 0 {
		condition += ` AND a.user_id in (` + utils.GetOrmInReplace(lenUser) + `) `
		pars = append(pars, req.UserIdList)
	}

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

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

	resp := models.EdbListResp{
		List:   list,
		Paging: paging.GetPaging(currentIndex, pageSize, total),
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// BatchAddEdbCheck
// @Title 新增校验
// @Description 新增校验
// @Param	request	body data_manage.BatchManualEdbReq true "type json string"
// @Success 200 string "操作成功"
// @router /target/edb/batch/add/check [post]
func (this *TargetController) BatchAddEdbCheck() {
	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
	}

	// 最大批量添加的数量
	codeMax := 30

	var req models.BatchManualEdbReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)

	req.Keyword = strings.TrimSpace(req.Keyword)

	var condition string
	var pars []interface{}

	//
	condition += ` AND a.is_join_edb = 0 `

	//超管账号可以查看分类下的所有频度数据
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		classifyList, err := models.GetEdbdataClassify(int64(sysUser.AdminId))
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.Msg = "获取拥有的分类数据失败，Err:" + err.Error()
			return
		}

		num := len(classifyList)
		if num > 0 {
			classifyIdList := make([]int, 0)
			for _, v := range classifyList {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(num) + `) `
			pars = append(pars, classifyIdList)
		}

	}

	if req.ListAll {
		// 关键词
		if req.Keyword != "" {
			condition += ` AND (a.SEC_NAME like ?  or a.TRADE_CODE like ? )`
			pars = utils.GetLikeKeywordPars(pars, req.Keyword, 2)
		}

		// 所属分类
		lenFrequency := len(req.FrequencyList)
		if lenFrequency > 0 {
			condition += ` AND a.frequency in (` + utils.GetOrmInReplace(lenFrequency) + `) `
			pars = append(pars, req.FrequencyList)
		}

		// 所属分类
		lenClassify := len(req.ClassifyIdList)
		if lenClassify > 0 {
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(lenClassify) + `) `
			pars = append(pars, req.ClassifyIdList)
		}

		// 所属用户
		lenUser := len(req.UserIdList)
		if lenUser > 0 {
			condition += ` AND a.user_id in (` + utils.GetOrmInReplace(lenUser) + `) `
			pars = append(pars, req.UserIdList)
		}

		lenTradeList := len(req.TradeCodeList)
		// 指标
		if lenTradeList > 0 {
			condition += ` AND a.TRADE_CODE not in (` + utils.GetOrmInReplace(lenTradeList) + `) `
			pars = append(pars, req.TradeCodeList)
		}
	} else {
		lenTradeList := len(req.TradeCodeList)
		if lenTradeList <= 0 {
			br.Msg = "请选择指标"
			br.ErrMsg = "请选择指标"
			return
		}
		// 指标
		if lenTradeList > 0 {
			condition += ` AND a.TRADE_CODE in (` + utils.GetOrmInReplace(lenTradeList) + `) `
			pars = append(pars, req.TradeCodeList)
		}
	}

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

	if len(list) > codeMax {
		br.Msg = fmt.Sprintf("最多只能选择%d个指标", codeMax)
		return
	}

	br.Data = list
	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 /target/edb/batch/add/name_check [post]
func (this *TargetController) NameCheck() {
	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 []*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
	}

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

	// 重名校验
	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 /target/edb/batch/add [post]
func (this *TargetController) 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
	}

	// 最大批量添加的数量
	codeMax := 30

	deleteCache := true
	cacheKey := "CACHE_EDB_INFO_BATCH_ADD_MANUAL_" + 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) > codeMax {
		br.Msg = "批量添加指标数量不得超过30个"
		return
	}
	indexNames := make([]string, 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)
		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.ManualIndexSource2EdbReq
		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, e, errMsg, skip := data.ManualIndexSource2Edb(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
}

// BatchDelEdbCheck
// @Title 新增校验
// @Description 新增校验
// @Param	request	body data_manage.BatchManualEdbReq true "type json string"
// @Success 200 string "操作成功"
// @router /target/edb/batch/del/check [post]
func (this *TargetController) BatchDelEdbCheck() {
	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 models.BatchManualEdbReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)

	req.Keyword = strings.TrimSpace(req.Keyword)

	var condition string
	var pars []interface{}

	// 就是为了找出已经加入指标库的指标
	condition += ` AND a.is_join_edb = ? `
	pars = append(pars, 1)

	//超管账号可以查看分类下的所有频度数据
	if sysUser.RoleTypeCode != utils.ROLE_TYPE_CODE_ADMIN {
		classifyList, err := models.GetEdbdataClassify(int64(sysUser.AdminId))
		if err != nil {
			br.Msg = "获取分类数据失败"
			br.Msg = "获取拥有的分类数据失败，Err:" + err.Error()
			return
		}

		num := len(classifyList)
		if num > 0 {
			classifyIdList := make([]int, 0)
			for _, v := range classifyList {
				classifyIdList = append(classifyIdList, v.ClassifyId)
			}
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(num) + `) `
			pars = append(pars, classifyIdList)
		}

	}

	if req.ListAll {
		// 关键词
		if req.Keyword != "" {
			condition += ` AND (a.SEC_NAME like ?  or a.TRADE_CODE like ? )`
			pars = utils.GetLikeKeywordPars(pars, req.Keyword, 2)
		}

		// 所属分类
		lenFrequency := len(req.FrequencyList)
		if lenFrequency > 0 {
			condition += ` AND a.frequency in (` + utils.GetOrmInReplace(lenFrequency) + `) `
			pars = append(pars, req.FrequencyList)
		}

		// 所属分类
		lenClassify := len(req.ClassifyIdList)
		if lenClassify > 0 {
			condition += ` AND a.classify_id in (` + utils.GetOrmInReplace(lenClassify) + `) `
			pars = append(pars, req.ClassifyIdList)
		}

		// 所属用户
		lenUser := len(req.UserIdList)
		if lenUser > 0 {
			condition += ` AND a.user_id in (` + utils.GetOrmInReplace(lenUser) + `) `
			pars = append(pars, req.UserIdList)
		}

		lenTradeList := len(req.TradeCodeList)
		// 指标
		if lenTradeList > 0 {
			condition += ` AND a.TRADE_CODE not in (` + utils.GetOrmInReplace(lenTradeList) + `) `
			pars = append(pars, req.TradeCodeList)
		}
	} else {
		lenTradeList := len(req.TradeCodeList)
		if lenTradeList <= 0 {
			br.Msg = "请选择指标"
			br.ErrMsg = "请选择指标"
			return
		}
		// 指标
		if lenTradeList > 0 {
			condition += ` AND a.TRADE_CODE in (` + utils.GetOrmInReplace(lenTradeList) + `) `
			pars = append(pars, req.TradeCodeList)
		}
	}

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

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

// BatchDel
// @Title 批量删除
// @Description 批量新增
// @Param	request	body data_manage.AddEdbInfoReq true "type json string"
// @Success 200 string "操作成功"
// @router /target/edb/batch/del [post]
func (this *TargetController) BatchDel() {
	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
	}

	// 最大批量添加的数量
	codeMax := 30

	deleteCache := true
	cacheKey := "CACHE_EDB_INFO_BATCH_ADD_MANUAL_" + 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) > codeMax {
		br.Msg = "批量添加指标数量不得超过30个"
		return
	}
	indexNames := make([]string, 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)
		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.ManualIndexSource2EdbReq
		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, e, errMsg, skip := data.ManualIndexSource2Edb(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
}

// ImportData
// @Title 导入数据
// @Description 导入数据
// @Param   EntryFile   query   file  true       "文件"
// @Success 200 Ret=200 录入成功
// @router /import/data [post]
func (this *TargetController) ImportData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}
	file, _, err := this.GetFile("EntryFile")
	if err != nil {
		br.Msg = "获取文件失败"
		br.ErrMsg = "获取文件失败，Err:" + err.Error()
		return
	}
	path := "./static/数据导入_" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	defer file.Close()
	err = this.SaveToFile("EntryFile", path)
	if err != nil {
		br.Msg = "文件保存失败"
		br.ErrMsg = "文件保存失败，Err:" + err.Error()
		return
	}
	if utils.RunMode == "debug" {
		defer os.Remove(path)
	}
	xlFile, err := xlsx.OpenFile(path)
	if err != nil {
		fmt.Println(err.Error())
		return
	}

	//超管账号可以查看分类下的所有频度数据
	userId := sysUser.AdminId
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN {
		userId = 0
	}
	//获取账户所拥有权限的分类id集合
	classifyNameStrList, edbDataClassifyMap, err := data.GetEdbClassifyNameListByAdminId(int64(userId))
	if err != nil {
		br.Msg = "获取分类数据失败"
		return
	}

	//导入成功数量
	successCount := 0
	//导入失败数据
	failDatas := make([]*models.EdbdataImportFail, 0)

	//指标map
	targetMap := make(map[string]*models.Edbinfo)
	defer func() {
		for _, target := range targetMap {
			//结束后，清除掉对应的缓存
			key := "import:edbinfo:data:" + target.TradeCode
			utils.Rc.Delete(key)

			//将该指标的code加入到 “手工数据导入后刷新” 缓存
			if utils.Re == nil {
				err := utils.Rc.LPush(utils.CACHE_IMPORT_MANUAL_DATA, target.TradeCode)
				if err != nil {
					fmt.Println("CACHE_IMPORT_MANUAL_DATA LPush Err:" + err.Error())
				}
			}
		}
	}()

	// 所有的指标数据map
	edbCodeDataMap := make(map[string]map[string]string)

	// 遍历sheet页读取
	for _, sheet := range xlFile.Sheets {
		fmt.Println("sheet name: ", sheet.Name)
		//遍历行读取
		maxRow := sheet.MaxRow
		fmt.Println("maxRow:", maxRow)
		fmt.Println("maxRow")
		for i := 0; i < maxRow; i++ {
			if i == 1 {
				row := sheet.Row(i)
				cells := row.Cells
				if len(cells) < 6 {
					br.ErrMsg = "导入文件异常，请下载最新导入模板文件"
					br.Msg = "导入文件异常，请下载最新导入模板文件"
					return
				}
				templateFail := false
				if cells[0].Value != "品种分类" && cells[0].Value != "Species Category" {
					templateFail = true
				}
				if cells[1].Value != "录入日期" && cells[1].Value != "Input Date" {
					templateFail = true
				}
				if cells[2].Value != "指标名称" && cells[2].Value != "Indicator Name Indicator Name" {
					templateFail = true
				}
				if cells[3].Value != "值" && cells[3].Value != "Value" {
					templateFail = true
				}
				if cells[4].Value != "频度" && cells[4].Value != "Frequency" {
					templateFail = true
				}
				if cells[5].Value != "单位" && cells[5].Value != "Unit" {
					templateFail = true
				}
				if templateFail {
					br.ErrMsg = "导入文件异常，请下载最新导入模板文件"
					br.Msg = "导入文件异常，请下载最新导入模板文件"
					return
				}
			}
			if i > 1 {
				row := sheet.Row(i)
				cells := row.Cells
				if len(cells) >= 6 {
					classifyName := cells[0].Value //分类
					if classifyName == "" {        //过滤空白行
						continue
					}
					cell1 := cells[1].Value
					//createDate := utils.ConvertToFormatDay(cell1) //录入日期
					createDate := cell1
					cell2 := cells[2].Value //指标名称
					secName := utils.TrimStr(cell2)
					frequency := cells[4].Value //频度
					unit := cells[5].Value      //单位

					closeVal := cells[3].Value //值
					if strings.Contains(closeVal, "#N/A") {
						continue
					}

					//校验表格中的日期格式
					if strings.Contains(createDate, "-") {
						//如果是带有 - 的普通日期格式文本
						_, timeErr := time.Parse("2006-1-2", createDate)
						if timeErr != nil {
							failItem := new(models.EdbdataImportFail)
							failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
							failItem.ClassifyName = classifyName
							failItem.CreateDate = createDate
							failItem.SecName = secName
							failItem.Close = closeVal
							failItem.Remark = "日期格式异常"
							failItem.Frequency = frequency
							failItem.Unit = unit
							failDatas = append(failDatas, failItem)
							//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
							continue
						}
					} else if strings.Contains(createDate, "/") {
						//如果是带有 / 的普通日期格式文本
						createDateTime, timeErr := time.Parse("2006/1/2", createDate)
						if timeErr != nil {
							failItem := new(models.EdbdataImportFail)
							failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
							failItem.ClassifyName = classifyName
							failItem.CreateDate = createDate
							failItem.SecName = secName
							failItem.Close = closeVal
							failItem.Remark = "日期格式异常"
							failItem.Frequency = frequency
							failItem.Unit = unit
							failDatas = append(failDatas, failItem)
							//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
							continue
						}
						createDate = createDateTime.Format("2006-01-02")
					} else {
						//可能是excel的日期格式
						_, tmpErr := strconv.Atoi(createDate)
						if tmpErr != nil {
							failItem := new(models.EdbdataImportFail)
							failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
							failItem.ClassifyName = classifyName
							failItem.CreateDate = createDate
							failItem.SecName = secName
							failItem.Close = closeVal
							failItem.Remark = "日期格式异常"
							failItem.Frequency = frequency
							failItem.Unit = unit
							failDatas = append(failDatas, failItem)
							//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
							continue
						}
						createDate = utils.ConvertToFormatDay(createDate) //录入日期
					}

					closeValFloat, err := cells[3].Float() //值

					if err != nil {
						failItem := new(models.EdbdataImportFail)
						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
						failItem.ClassifyName = classifyName
						failItem.CreateDate = createDate
						failItem.SecName = secName
						failItem.Close = cells[3].Value
						failItem.Remark = "值类型异常"
						failItem.Frequency = frequency
						failItem.Unit = unit
						failDatas = append(failDatas, failItem)
						continue
					}
					newDecimal := decimal.NewFromFloat(closeValFloat)
					newDecimal.Round(4)
					closeVal = newDecimal.String()
					if strings.Contains(closeVal, "#N/A") {
						continue
					}
					//closeVal := closeValFloat.

					//判断指标，类型，等数据是否正常
					classifyName = strings.Trim(classifyName, " ")
					frequency = utils.TrimStr(frequency)
					unit = utils.TrimStr(unit)

					// 成功数量超过20个指标，那就不导入了
					if len(targetMap) >= 150 {
						failItem := new(models.EdbdataImportFail)
						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
						failItem.ClassifyName = classifyName
						failItem.CreateDate = createDate
						failItem.SecName = secName
						failItem.Close = closeVal
						failItem.Remark = "导入指标数量过多"
						failItem.Frequency = frequency
						failItem.Unit = unit
						failDatas = append(failDatas, failItem)
						//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
						continue
					}

					if !strings.Contains(strings.Join(classifyNameStrList, ","), classifyName) {
						failItem := new(models.EdbdataImportFail)
						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
						failItem.ClassifyName = classifyName
						failItem.CreateDate = createDate
						failItem.SecName = secName
						failItem.Close = closeVal
						failItem.Remark = "没有该品种分类权限"
						failItem.Frequency = frequency
						failItem.Unit = unit
						failDatas = append(failDatas, failItem)
						continue
					}
					//fmt.Println(classifyName, createDate, secName, closeVal)

					//获取指标分类信息
					classify, ok := edbDataClassifyMap[classifyName]
					if !ok {
						failItem := new(models.EdbdataImportFail)
						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
						failItem.ClassifyName = classifyName
						failItem.CreateDate = createDate
						failItem.SecName = secName
						failItem.Close = closeVal
						failItem.Remark = "指标分类不存在"
						failItem.Frequency = frequency
						failItem.Unit = unit
						failDatas = append(failDatas, failItem)
						//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
						continue
					}

					//判断指标是否存在
					target, ok := targetMap[secName]
					if !ok {
						tmpTarget, err := models.GetTargetBySecName(secName)
						if err != nil {
							//如果是找不到该指标，那么新增指标
							if err.Error() == utils.ErrNoRow() {
								if frequency == "" {
									failItem := new(models.EdbdataImportFail)
									failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
									failItem.ClassifyName = classifyName
									failItem.CreateDate = createDate
									failItem.SecName = secName
									failItem.Close = closeVal
									failItem.Remark = "新增指标失败，频度字段为空"
									failItem.Frequency = frequency
									failItem.Unit = unit
									failDatas = append(failDatas, failItem)
									continue
								}
								if unit == "" {
									failItem := new(models.EdbdataImportFail)
									failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
									failItem.ClassifyName = classifyName
									failItem.CreateDate = createDate
									failItem.SecName = secName
									failItem.Close = closeVal
									failItem.Remark = "新增指标失败，单位字段为空"
									failItem.Frequency = frequency
									failItem.Unit = unit
									failDatas = append(failDatas, failItem)
									continue
								}
								tmpErr := data.AddEdbInfo(secName, unit, frequency, "", sysUser.Mobile, classify.ClassifyId, sysUser.AdminId)
								if tmpErr != nil {
									fmt.Println("line 158")
									failItem := new(models.EdbdataImportFail)
									failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
									failItem.ClassifyName = classifyName
									failItem.CreateDate = createDate
									failItem.SecName = secName
									failItem.Close = closeVal
									failItem.Remark = "新增指标失败"
									failItem.Frequency = frequency
									failItem.Unit = unit
									failDatas = append(failDatas, failItem)
									continue
								}
								tmpTarget, tmpErr := models.GetTargetBySecName(secName)
								target = tmpTarget
								targetMap[secName] = target
							} else {
								fmt.Println("导入数据 获取指标:Err:" + err.Error())
							}
						} else {
							target = tmpTarget
							targetMap[secName] = target
						}

						//设置10分钟缓存，不允许其他地方删除
						key := "import:edbinfo:data:" + target.TradeCode
						utils.Rc.SetNX(key, 1, time.Second*600)
					}

					if target == nil {
						fmt.Println("指标不存在")
						failItem := new(models.EdbdataImportFail)
						failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
						failItem.ClassifyName = classifyName
						failItem.CreateDate = createDate
						failItem.SecName = secName
						failItem.Close = closeVal
						failItem.Remark = "指标不存在"
						failItem.Frequency = frequency
						failItem.Unit = unit
						failDatas = append(failDatas, failItem)
						continue
					}

					//更新指标信息
					updateCols := make([]string, 0)
					//更新指标分类
					if target.ClassifyId <= 0 && classify.ClassifyId > 0 {
						target.ClassifyId = classify.ClassifyId
						updateCols = append(updateCols, "ClassifyId")
					}
					if target.Frequency != frequency {
						target.Frequency = frequency
						target.NoticeTime = ""
						updateCols = append(updateCols, "Frequency", "NoticeTime")
					}
					if target.Unit != unit {
						target.Unit = unit
						updateCols = append(updateCols, "Unit")
					}
					if len(updateCols) > 0 {
						_ = target.Update(updateCols)
					}

					// 判断指标数据列表是否已经存在
					tmpDataMap, ok := edbCodeDataMap[target.TradeCode]
					if !ok {
						tmpDataMap = make(map[string]string)
						dataList, tmpErr := models.GetTargetsDataList(target.TradeCode)
						if tmpErr != nil {
							go alarm_msg.SendAlarmMsg("导入数据"+target.TradeCode+" 获取指标的数据失败，Err："+err.Error(), 3)
						}
						for _, tmpData := range dataList {
							tmpDataMap[tmpData.Dt] = tmpData.Close
						}
						edbCodeDataMap[target.TradeCode] = tmpDataMap
					}

					//判断数据是否已经存在
					tmpVal, ok := tmpDataMap[createDate]
					//数据已存在，进行更新操作
					if ok {
						if tmpVal != closeVal {
							err = models.ModifyTargetsDataByImport(target.TradeCode, createDate, closeVal)
							if err != nil {
								go alarm_msg.SendAlarmMsg("导入数据 修改数据失败，Err："+err.Error(), 3)
								//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 修改数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
							}
						}
					} else { //数据不存在，进行新增操作
						if target.TradeCode != "" && createDate != "" && closeVal != "" {
							models.AddTargetsDataByImport(target.TradeCode, createDate, closeVal)
							if err != nil {
								go alarm_msg.SendAlarmMsg("导入数据 新增数据失败，Err："+err.Error(), 3)
								//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 新增数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
							}
							tmpDataMap[createDate] = closeVal
							edbCodeDataMap[target.TradeCode] = tmpDataMap
						}
					}
					successCount++
				} else {
					//br.ErrMsg = "请填写导入内容"
					//br.Msg = "请填写导入内容"
					//return
				}
			}
		}
	}
	resp := models.EdbdataImportResp{
		SuccessCount: successCount,
		FailCount:    len(failDatas),
	}
	fmt.Println("failDatas:", len(failDatas))
	if len(failDatas) > 0 {
		//先删除导入失败记录
		_ = models.DelEdbDataImportFail(sysUser.AdminId)
		//错误信息字符串切片，最后作为发送邮件通知使用
		failContents := make([]string, 0)
		for _, v := range failDatas {
			failContents = append(failContents, fmt.Sprint(v.SecName, "导入失败：", v.Remark))
			err = models.AddEdbdataImportFail(v)
			if err != nil {
				go alarm_msg.SendAlarmMsg("导入数据 新增失败记录失败，Err："+err.Error(), 3)
				//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 新增失败记录失败:Err:"+err.Error(), utils.EmailSendToUsers)
			}
		}
		//导入失败的话，最后统一邮件提醒就好啦，不需要每次都去提醒
		go alarm_msg.SendAlarmMsg("导入数据 存在部分数据导入失败:"+strings.Join(failContents, "；"), 3)
		//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 存在部分数据导入失败:"+strings.Join(failContents, "；"), utils.EmailSendToUsers)

		if successCount == 0 {
			resp.Status = -1
			resp.Msg = "导入失败"
		} else {
			resp.Status = 1
			resp.Msg = "存在部分导入失败"
		}
	} else {
		resp.Status = 0
	}
	br.Msg = "导入成功"
	br.Ret = 200
	br.Success = true
	br.Data = resp
}