eta_api/controllers/target.go

/*
 * Copyright (c) 2023. Lorem ipsum dolor sit amet, consectetur adipiscing elit.
 * Morbi non lorem porttitor neque feugiat blandit. Ut vitae ipsum eget quam lacinia accumsan.
 * Etiam sed turpis ac ipsum condimentum fringilla. Maecenas magna.
 * Proin dapibus sapien vel ante. Aliquam erat volutpat. Pellentesque sagittis ligula eget metus.
 * Vestibulum commodo. Ut rhoncus gravida arcu.
 */

package controllers

import (
	"encoding/json"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_source"
	"eta/eta_api/models/system"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/services/data"
	"eta/eta_api/utils"
	"fmt"
	"os"
	"path/filepath"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"time"

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

// TargetController 手工指标服务（鉴权）
type TargetController struct {
	BaseAuthController
}

// TargetCommonController 手工指标服务（不鉴权）
type TargetCommonController struct {
	BaseCommonController
}

// DataList
// @Title 获取指标列表
// @Description 获取指标列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   StartDate   query   string  true       "开始日期"
// @Param   EndDate   query   string  true       "结束日期"
// @Param   Frequency   query   string  true       "频度"
// @Param   ClassifyId   query   int  true       "分类"
// @Param   KeyWord   query   string  true       "名称关键词"
// @Param   TradeCode   query   string  true       "指标唯一编码"
// @Success 200 {object} models.DataListResp
// @router /data/list [get]
func (this *TargetController) DataList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyWord := this.GetString("KeyWord")
	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	frequency := this.GetString("Frequency")
	tradeCode := this.GetString("TradeCode")
	classifyId, _ := this.GetInt("ClassifyId") //分类

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

	var condition string
	var pars []interface{}

	if keyWord != "" {
		condition += ` AND a.SEC_NAME LIKE ? `
		pars = utils.GetLikeKeywordPars(pars, keyWord, 1)
	}
	if startDate != "" {
		condition += ` AND c.DT >= ? `
		pars = append(pars, startDate)
	}
	if endDate != "" {
		condition += ` AND c.DT <= ? `
		pars = append(pars, endDate)
	}

	if frequency != "" {
		condition += ` AND a.frequency = ? `
		pars = append(pars, frequency)
	}

	if classifyId > 0 {
		condition += ` AND a.classify_id = ? `

		pars = append(pars, classifyId)
	}

	if tradeCode != "" {
		condition += ` AND c.TRADE_CODE = ? `
		pars = append(pars, tradeCode)
	}

	total, err := models.GetDataListCount(condition, pars)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	list, err := models.GetDataList(condition, pars, startSize, pageSize)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp := new(models.DataListResp)
	resp.Paging = page
	if len(list) <= 0 {
		list = make([]*models.DataList, 0)
	}
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// DataAdd
// @Title 录入数据
// @Description 录入数据接口
// @Param	request	body models.DataAddReq true "type json string"
// @Success 200 Ret=200 录入成功
// @router /data/add [post]
func (this *TargetController) DataAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DataAddReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.TradeCode == "" {
		br.Msg = "指标编码不可为空！"
		return
	}

	if req.CreateDate == "" {
		br.Msg = "请选择日期"
		return
	}
	item, err := models.GetDataInfo(req.TradeCode, req.CreateDate)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	if item != nil {
		br.Msg = "该指标当前日期下，数据已录入"
		return
	}
	edbdata := new(models.Edbdata)
	edbdata.TradeCode = req.TradeCode
	edbdata.Dt = req.CreateDate
	edbdata.Close = req.Close
	edbdata.ModifyTime = time.Now()
	_, err = models.AddEdbdata(edbdata)
	if err != nil {
		br.Msg = "新增失败"
		br.ErrMsg = "新增失败，Err:" + err.Error()
		return
	}
	//将该指标的code加入到 “手工数据导入后刷新” 缓存
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CACHE_IMPORT_MANUAL_DATA, edbdata.TradeCode)
		if err != nil {
			fmt.Println("DataAdd CACHE_IMPORT_MANUAL_DATA LPush Err:" + err.Error())
		}
	}

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

// DataEdit
// @Title 编辑数据
// @Description 编辑数据接口
// @Param	request	body models.DataEditReq true "type json string"
// @Success 200 Ret=200 编辑数据成功
// @router /data/edit [post]
func (this *TargetController) DataEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DataEditReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.TradeCode == "" {
		br.Msg = "指标编码不可为空！"
		return
	}

	if req.CreateDate == "" {
		br.Msg = "请选择日期"
		return
	}

	close := ""
	loc := reflect.ValueOf(req.Close).Kind().String()
	if loc == "string" {
		close = req.Close.(string)
	} else if loc == "int" {
		closeInt := req.Close.(int)
		close = strconv.Itoa(closeInt)
	} else if loc == "float64" {
		close64 := req.Close.(float64)
		close = strconv.FormatFloat(close64, 'g', 30, 64)
	} else {
		close = ""
	}

	edbdata := new(models.Edbdata)
	edbdata.TradeCode = req.TradeCode
	edbdata.Dt = req.CreateDate
	edbdata.Close = close
	edbdata.ModifyTime = time.Now()

	if req.OldCreateDate == "" {
		item, err := models.GetDataInfo(req.TradeCode, req.CreateDate)
		if err != nil && err.Error() != utils.ErrNoRow() {
			br.Msg = "获取信息失败！"
			br.ErrMsg = "获取信息失败，Err:" + err.Error()
			return
		}
		if item == nil { //新增
			_, err = models.AddEdbdata(edbdata)
			if err != nil {
				br.Msg = "新增失败"
				br.ErrMsg = "新增失败，Err:" + err.Error()
				return
			}
		} else { //修改
			err = models.EditEdbdata(edbdata)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "编辑失败，Err:" + err.Error()
				return
			}
		}
	} else {
		if req.CreateDate == req.OldCreateDate { //修改
			err = models.EditEdbdata(edbdata)
			if err != nil {
				br.Msg = "编辑失败"
				br.ErrMsg = "编辑失败，Err:" + err.Error()
				return
			}
		} else {
			item, err := models.GetDataInfo(req.TradeCode, req.CreateDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取信息失败！"
				br.ErrMsg = "获取信息失败，Err:" + err.Error()
				return
			}
			if item == nil {
				_, err = models.AddEdbdata(edbdata)
				if err != nil {
					br.Msg = "新增失败"
					br.ErrMsg = "新增失败，Err:" + err.Error()
					return
				}
			} else {
				err = models.EditEdbdata(edbdata)
				if err != nil {
					br.Msg = "编辑失败"
					br.ErrMsg = "编辑失败，Err:" + err.Error()
					return
				}
			}
			oldItem, err := models.GetDataInfo(req.TradeCode, req.OldCreateDate)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.Msg = "获取信息失败！"
				br.ErrMsg = "获取信息失败，Err:" + err.Error()
				return
			}
			if oldItem != nil {
				record := new(models.EdbdataDeleteRecord)
				record.TradeCode = oldItem.TradeCode
				record.Dt = oldItem.Dt
				record.Close = oldItem.Close
				record.ModifyTime = oldItem.ModifyTime
				record.CreateTime = time.Now()
				record.SysUserId = this.SysUser.AdminId
				_, err = models.AddEdbdataDeleteRecord(record)
				if err != nil {
					br.Msg = "编辑失败"
					br.ErrMsg = "新增删除记录失败，Err:" + err.Error()
					return
				}
				//删除数据
				models.DeleteEdbData(req.TradeCode, req.OldCreateDate)
			}
		}
	}
	//将该指标的code加入到 “手工数据导入后刷新” 缓存
	if utils.Re == nil {
		err := utils.Rc.LPush(utils.CACHE_IMPORT_MANUAL_DATA, edbdata.TradeCode)
		if err != nil {
			fmt.Println("DataEdit CACHE_IMPORT_MANUAL_DATA LPush Err:" + err.Error())
		}
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
}

// BatchDataEdit
// @Title 批量编辑数据
// @Description 批量编辑数据接口
// @Param	request	body models.BatchDataEditReq true "type json string"
// @Success 200 Ret=200 编辑数据成功
// @router /data/batch_edit [post]
func (this *TargetController) BatchDataEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.BatchDataEditReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.CreateDate == req.OldCreateDate { //修改
		br.Msg = "开始日期与结束日期一致！"
		return
	}

	edbDataEditList := make([]data.EdbDataEdit, 0)
	edbCodeMap := make(map[string]string)
	for _, trade := range req.List {
		if trade.TradeCode == "" {
			br.Msg = "指标编码不可为空！"
			return
		}
		edbCodeMap[trade.TradeCode] = trade.TradeCode

		close := ""
		loc := reflect.ValueOf(trade.Close).Kind().String()
		if loc == "string" {
			close = trade.Close.(string)
		} else if loc == "int" {
			closeInt := trade.Close.(int)
			close = strconv.Itoa(closeInt)
		} else if loc == "float64" {
			close64 := trade.Close.(float64)
			close = strconv.FormatFloat(close64, 'g', 30, 64)
		} else {
			close = ""
		}
		edbDataEdit := data.EdbDataEdit{
			OldCreateDate: req.OldCreateDate,
			CreateDate:    req.CreateDate,
			TradeCode:     trade.TradeCode,
			Close:         close,
		}
		edbDataEditList = append(edbDataEditList, edbDataEdit)
	}

	//批量修改
	failEdbDataList, err := data.BatchEdbData(req.OldCreateDate, req.CreateDate, edbDataEditList, this.SysUser.AdminId)
	if err != nil {
		br.Msg = "批量修改失败"
		br.ErrMsg = "批量修改失败：" + err.Error()
		return
	}
	//将该指标的code加入到 “手工数据导入后刷新” 缓存
	if utils.Re == nil {
		for _, edbCode := range edbCodeMap {
			err = utils.Rc.LPush(utils.CACHE_IMPORT_MANUAL_DATA, edbCode)
			if err != nil {
				fmt.Println("BatchDataEdit CACHE_IMPORT_MANUAL_DATA LPush Err:" + err.Error())
			}
		}
	}
	br.Ret = 200
	br.Success = true
	br.Data = failEdbDataList
	br.Msg = "编辑成功"
}

// TargetList
// @Title 指标列表
// @Description 指标列表接口
// @Param   PageSize   query   int  true       "每页数据条数"
// @Param   CurrentIndex   query   int  true       "当前页页码，从1开始"
// @Param   StartDate   query   string  true       "开始日期"
// @Param   EndDate   query   string  true       "结束日期"
// @Param   Frequency   query   string  true       "频度"
// @Param   ClassifyId   query   int  true       "分类"
// @Param   KeyWord   query   string  true       "名称关键词"
// @Success 200 {object} models.TargetListResp
// @router /target/list [get]
func (this *TargetController) TargetList() {
	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.TargetListResp)

	pageSize, _ := this.GetInt("PageSize")
	currentIndex, _ := this.GetInt("CurrentIndex")
	keyWord := this.GetString("KeyWord")
	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	frequency := this.GetString("Frequency")
	classifyId, _ := this.GetInt("ClassifyId") //分类

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

	var condition string
	var pars []interface{}

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

	//有分类数据权限才查询
	if len(classifyIdStrList) > 0 {
		condition += ` AND a.classify_id in (` + strings.Join(classifyIdStrList, ",") + `)  `

		//关键字
		if keyWord != "" {
			condition += ` AND (a.SEC_NAME LIKE '%` + keyWord + `%'  or a.TRADE_CODE LIKE '%` + keyWord + `%' )`
		}

		if startDate != "" {
			startDate = startDate + " 00:00:00"
			condition += ` AND a.create_date >= ? `
			pars = append(pars, startDate)
		}
		if endDate != "" {
			endDate = endDate + " 23:59:59"
			condition += ` AND a.create_date <= ? `
			pars = append(pars, endDate)
		}

		if frequency != "" {
			condition += ` AND a.frequency = ? `
			pars = append(pars, frequency)
		}

		if classifyId > 0 {
			condition += ` AND a.classify_id = ? `

			pars = append(pars, classifyId)
		}
		mobile := sysUser.Mobile
		total, err = models.GetEdbinfoListCount(condition, pars, mobile, sysUser.RoleType)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		tmpList, err := models.GetEdbinfoList(condition, pars, startSize, pageSize, mobile, sysUser.RoleType)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取失败，Err:" + err.Error()
			return
		}
		if len(tmpList) <= 0 {
			list = make([]*models.Edbinfo, 0)
		} else {
			list = tmpList
		}

		systemUserMap := make(map[int]string)
		for k, v := range list {
			userName, ok := systemUserMap[v.UserId]
			if ok == false {
				systemUser, _ := system.GetSysAdminById(v.UserId)
				if systemUser != nil {
					userName = systemUser.RealName
				} else {
					userName = `无`
				}
				systemUserMap[v.UserId] = userName
			}
			list[k].UserName = userName
		}
	}
	page := paging.GetPaging(currentIndex, pageSize, total)
	resp.Paging = page
	resp.List = list

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

// TargetAdd
// @Title 录入指标
// @Description 录入指标接口
// @Param	request	body models.EdbinfoAddReq true "type json string"
// @Success 200 Ret=200 录入成功
// @router /target/add [post]
func (this *TargetController) TargetAdd() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.EdbinfoAddReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}

	tradeCode, err := models.GetMaxTradeCode()
	if err != nil {
		br.Msg = "获取数据失败"
		br.ErrMsg = "获取最大交易编码失败,Err:" + err.Error()
		return
	}

	maxTradeCode, err := utils.GetMaxTradeCode(tradeCode)
	if err != nil {
		br.Msg = "数据异常"
		br.ErrMsg = "获取编码信息失败,Err:" + err.Error()
		return
	}
	if maxTradeCode == "" {
		br.Msg = "编码为空，请联系技术"
		br.ErrMsg = "编码为空，请联系技术"
		return
	}
	if req.SecName == "" {
		br.Msg = "指标名称不能为空"
		return
	}
	item, err := models.GetEdbinfoBySecName(req.SecName)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	if item != nil {
		br.Msg = "指标名称已存在"
		return
	}
	err = models.AddEdbinfo(maxTradeCode, req.SecName, req.Unit, "手动", req.Frequency, req.NoticeTime, req.ClassifyId, sysUser.AdminId)
	if err != nil {
		br.Msg = "新增失败"
		br.ErrMsg = "新增失败，Err:" + err.Error()
		return
	}
	err = models.AddEdbinfoUser(maxTradeCode, sysUser.Mobile)
	if err != nil {
		br.Msg = "新增失败"
		br.ErrMsg = "新增失败，Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "新增成功"
}

// TargetEdit
// @Title 编辑指标
// @Description 编辑指标
// @Param	request	body models.EdbinfoEditReq true "type json string"
// @Success 200 Ret=200 录入成功
// @router /target/edit [post]
func (this *TargetController) TargetEdit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.EdbinfoEditReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}

	if req.TradeCode == "" {
		br.Msg = "数据异常"
		br.ErrMsg = "最大编码为空"
		return
	}

	if req.SecName == "" {
		br.Msg = "指标名称不能为空"
		return
	}
	item, err := models.GetEdbinfoBySecName(req.SecName)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	if item != nil {
		if req.TradeCode != item.TradeCode {
			br.Msg = "指标名称已存在"
			return
		}
	}
	err = models.EditEdbinfo(req.TradeCode, req.SecName, req.Unit, req.Frequency, req.NoticeTime, req.ClassifyId)
	if err != nil {
		br.Msg = "编辑失败"
		br.ErrMsg = "编辑失败，Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "编辑成功"
}

// TargetSearch
// @Title 搜索指标
// @Description 搜索指标
// @Param   ClassifyId   query   int  true       "分类"
// @Param   KeyWord   query   string  true       "名称关键词"
// @Success 200 {object} models.SearchTargetListResp
// @router /target/search [get]
func (this *TargetController) TargetSearch() {
	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
	}
	classifyId, _ := this.GetInt("ClassifyId")
	keyWord := this.GetString("KeyWord")
	list, err := models.SearchTargetEntry(classifyId, keyWord)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	resp := new(models.SearchTargetListResp)
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ClassifyList
// @Title 获取分类
// @Description 获取分类
// @Success 200 {object} models.EdbdataClassifyResp
// @router /classify [get]
func (this *TargetController) ClassifyList() {
	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
	}
	//mobile := sysUser.Mobile
	//var wxUserId int64
	//if mobile != "" {
	//	wxUser, err := models.GetUserByMobile(mobile)
	//	if err != nil && err.Error() != utils.ErrNoRow() {
	//		br.Msg = "获取用户信息失败"
	//		br.ErrMsg = "获取用户信息失败，err:" + err.Error()
	//		return
	//	}
	//	if wxUser != nil {
	//		wxUserId = wxUser.UserId
	//	}
	//}
	var wxUserId int64
	wxUserId = int64(sysUser.AdminId)
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN {
		wxUserId = 0
	}
	list, err := models.GetEdbdataClassify(wxUserId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败,Err:" + err.Error()
		return
	}

	classifyIdStrList := make([]string, 0)
	for _, classifyList := range list {
		if classifyList.Child != nil {
			for _, classify := range classifyList.Child {
				classifyIdStrList = append(classifyIdStrList, strconv.Itoa(classify.ClassifyId))
			}
		}
	}
	if len(classifyIdStrList) > 0 {
		edbInfoGroupCountList, err := models.GetEdbInfoGroupCountByClassifyIds(strings.Join(classifyIdStrList, ","))
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取分类下有数据的指标数量失败,Err:" + err.Error()
			return
		}

		edbInfoGroupCountMap := make(map[int]int)
		for _, edbInfoGroupCount := range edbInfoGroupCountList {
			edbInfoGroupCountMap[edbInfoGroupCount.ClassifyId] = edbInfoGroupCount.Count
		}
		for _, classifyList := range list {
			if classifyList.Child != nil {
				for _, classify := range classifyList.Child {
					if total, ok := edbInfoGroupCountMap[classify.ClassifyId]; ok {
						classify.EdbInfoTotal = total
					}
				}
			}
		}
	}
	resp := new(models.EdbdataClassifyResp)
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// TemplateDownload
// @Title 下载模板
// @Description 下载模板
// @Success 200 {object} models.EdbdataClassifyResp
// @router /template [get]
func (this *TargetCommonController) TemplateDownload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	this.Ctx.Output.Download("./static/数据导入模板.xlsx", "数据导入模板.xlsx")

	br.Ret = 200
	br.Success = true
	br.Msg = "下载成功"
}

// TemplateDownload
// @Title 下载模板
// @Description 下载模板
// @Success 200 {object} models.EdbdataClassifyResp
// @router /template/en [get]
func (this *TargetCommonController) TemplateDownloadEn() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	this.Ctx.Output.Download("./static/Data Import Template.xlsx", "Data Import Template.xlsx")

	br.Ret = 200
	br.Success = true
	br.Msg = "下载成功"
}

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

// ImportFailListDownload
// @Title 下载失败列表
// @Description 下载失败列表
// @Success 200 {object} models.EdbdataClassifyResp
// @router /import/failList [get]
func (this *TargetController) ImportFailListDownload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}
	item, err := models.GetFailList(sysUser.AdminId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.Msg = "获取数据失败，Err:" + err.Error()
		return
	}
	xlsxFile := xlsx.NewFile()
	SheetName := "导入失败数据"
	if this.Lang == utils.EnLangVersion {
		SheetName = "Import Fail List"
	}
	sheet, err := xlsxFile.AddSheet(SheetName)
	headRow := sheet.AddRow()
	if this.Lang == utils.EnLangVersion {
		headRow.AddCell().SetValue("Species Category")
		headRow.AddCell().SetValue("Input Date")
		headRow.AddCell().SetValue("Indicator Name Indicator Name")
		headRow.AddCell().SetValue("Value")
		headRow.AddCell().SetValue("Frequency")
		headRow.AddCell().SetValue("Unit")
		headRow.AddCell().SetValue("Remark")
	} else {
		headRow.AddCell().SetValue("品种分类")
		headRow.AddCell().SetValue("录入日期")
		headRow.AddCell().SetValue("指标名称")
		headRow.AddCell().SetValue("值")
		headRow.AddCell().SetValue("频度")
		headRow.AddCell().SetValue("单位")
		headRow.AddCell().SetValue("备注")
	}

	for _, v := range item {
		row := sheet.AddRow()
		row.AddCell().SetValue(v.ClassifyName)
		row.AddCell().SetValue(v.CreateDate)
		row.AddCell().SetValue(v.SecName)
		row.AddCell().SetString(v.Close)
		row.AddCell().SetValue(v.Frequency)
		row.AddCell().SetValue(v.Unit)
		row.AddCell().SetValue(v.Remark)
	}
	fileName := time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	savePath := "./static/" + fileName
	err = xlsxFile.Save(savePath)
	if err != nil {
		br.Msg = "文件保存失败"
		br.ErrMsg = "文件保存失败,Err:" + err.Error()
		return
	}
	defer func() {
		os.Remove(savePath)
	}()
	finalFileName := "失败列表.xlsx"

	if this.Lang == utils.EnLangVersion {
		finalFileName = "Failure List.xlsx"
	}
	this.Ctx.Output.Download(savePath, finalFileName)
}

// ExportDataList
// @Title 导出数据
// @Description 导出数据列表
// @Param   StartDate   query   string  true       "开始日期"
// @Param   EndDate   query   string  true       "结束日期"
// @Param   Frequency   query   string  true       "频度"
// @Param   ClassifyId   query   int  true       "分类"
// @Param   KeyWord   query   string  true       "名称关键词"
// @Param   TradeCode   query   string  true       "指标唯一编码"
// @Param   Mobile   query   string  true       "手机号"
// @Success 200  导出成功
// @router /export/dataList [get]
func (this *TargetController) ExportDataList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}

	keyWord := this.GetString("KeyWord")
	startDate := this.GetString("StartDate")
	endDate := this.GetString("EndDate")
	//frequency := this.GetString("Frequency")
	classifyId, _ := this.GetInt("ClassifyId") //分类
	mobile := this.GetString("Mobile")         //分类
	tradeCode := this.GetString("TradeCode")   //指标唯一编码

	var condition string
	var pars []interface{}
	//分类ID
	if keyWord != "" {
		condition += ` AND  a.SEC_NAME LIKE '%` + keyWord + `%'`
	}
	//分类ID
	if tradeCode != "" {
		condition += ` AND  a.TRADE_CODE = ? `
		pars = append(pars, tradeCode)
	}

	if startDate != "" {
		condition += ` AND c.DT >= ? `
		pars = append(pars, startDate)
	}
	if endDate != "" {
		condition += ` AND c.DT <= ? `
		pars = append(pars, endDate)
	}
	//if frequency != "" {
	//	condition += ` AND a.frequency = ? `
	//	pars = append(pars, frequency)
	//}
	if classifyId > 0 {
		condition += ` AND a.classify_id = ? `
		pars = append(pars, classifyId)
	}
	if mobile != "" {
		condition += ` AND d.mobile=? `
		pars = append(pars, mobile)
	}

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

	dir, _ := os.Executable()
	exPath := filepath.Dir(dir)

	downLoadnFilePath := exPath + "/" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	xlsxFile := xlsx.NewFile()
	if err != nil {
		br.Msg = "生成文件失败"
		br.ErrMsg = "生成文件失败"
		return
	}
	var frequencies []*string
	if keyWord == "" {
		frequencies, err = models.GetEdbDataFrequency(classifyId)
		if err != nil {
			br.Msg = "查询频度失败"
			br.ErrMsg = "查询频度失败"
			return
		}
	} else {
		frequencies, err = models.GetEdbDataFrequencyByKeyord(keyWord)
		if err != nil {
			br.Msg = "查询频度失败"
			br.ErrMsg = "查询频度失败"
			return
		}
	}

	fileName := `手工数据`
	if frequencies == 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("")
	}
	for _, frequency := range frequencies {
		secNameList := make([]*models.EdbdataExportList, 0)
		if len(classifyIdStrList) > 0 {
			newCondition := condition
			newCondition += ` AND a.classify_id in (` + strings.Join(classifyIdStrList, ",") + `)  `
			newCondition += ` AND a.frequency = ? `
			pars := append(pars, frequency)
			tmpSecNameList, err := models.GetEdbdataSecName(newCondition, pars)
			if err != nil {
				br.Msg = "获取数据失败"
				br.ErrMsg = "获取数据失败，Err:" + err.Error()
				return
			}
			secNameList = tmpSecNameList
		}
		var sheet *xlsx.Sheet
		if len(secNameList) > 0 {
			sheet, err = xlsxFile.AddSheet(*frequency)
			if err != nil {
				br.Msg = "新增Sheet失败"
				br.ErrMsg = "新增Sheet失败,Err:" + err.Error()
				return
			}
			fileName = secNameList[0].ClassifyName
		} else {
			continue
		}
		//获取指标数据
		rowSecName := sheet.AddRow()
		celSecName := rowSecName.AddCell()
		celSecName.SetValue("指标名称")
		rowFrequency := sheet.AddRow()
		celFrequency := rowFrequency.AddCell()
		celFrequency.SetValue("频率")
		rowUnit := sheet.AddRow()
		celUnit := rowUnit.AddCell()
		celUnit.SetValue("单位")

		rowModifyDate := sheet.AddRow()
		rowModifyCell := rowModifyDate.AddCell()
		rowModifyCell.SetValue("更新时间")

		dataMap := make(map[string]map[string]*models.EdbdataItem)
		var tradeCodeList []string
		for _, v := range secNameList {
			cellSenName := rowSecName.AddCell()
			cellSenName.SetValue(v.SecName)
			celFrequency := rowFrequency.AddCell()
			celFrequency.SetValue(v.Frequency)
			celUnit := rowUnit.AddCell()
			celUnit.SetValue(v.Unit)
			rowModifyCell := rowModifyDate.AddCell()
			rowModifyCell.SetValue(v.Dt)
			tradeCodeList = append(tradeCodeList, v.TradeCode)
			items, err := models.GetEdbdataAllByTradeCode(v.TradeCode)
			if err != nil && err.Error() != utils.ErrNoRow() {
				br.ErrMsg = "GetEdbdataAllByTradeCode,Err:" + err.Error()
				br.Msg = "获取数据失败"
				return
			}
			for _, item := range items {
				if dataMap[item.TradeCode] == nil {
					dataMap[item.TradeCode] = make(map[string]*models.EdbdataItem)
				}
				dataMap[item.TradeCode][item.Dt] = item
				fmt.Println(item.TradeCode, item.Dt)
			}
		}

		tradeCodeStr := strings.Join(tradeCodeList, "','")
		tradeCodeStr = "'" + tradeCodeStr + "'"
		dateList, err := models.GetEdbdataList(tradeCodeStr)
		if err != nil {
			br.Msg = "获取数据失败"
			br.ErrMsg = "获取数据失败,Err:" + err.Error()
			return
		}
		for _, n := range dateList {
			rowData := sheet.AddRow()
			celDate := rowData.AddCell()
			celDate.SetValue(n.Dt)

			for _, m := range secNameList {
				celData := rowData.AddCell()
				fmt.Println(m.TradeCode)
				fmt.Println(n.Dt)
				if dataMap[m.TradeCode][n.Dt] != nil {
					celData.SetValue(dataMap[m.TradeCode][n.Dt].Close)
				}
			}
		}

	}

	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 += time.Now().Format("06.01.02") + `.xlsx` //文件名称
	this.Ctx.Output.Download(downLoadnFilePath, fileName)
	defer func() {
		os.Remove(downLoadnFilePath)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "success"
}

// DataList
// @Title 导出数据
// @Description 导出数据列表
// @Param   StartDate   query   string  true       "开始日期"
// @Param   EndDate   query   string  true       "结束日期"
// @Param   Frequency   query   string  true       "频度"
// @Param   ClassifyId   query   int  true       "分类"
// @Param   KeyWord   query   string  true       "名称关键词"
// @Param   Mobile   query   string  true       "手机号"
// @Success 200  导出成功
// @router /dataList [get]
func (this *TargetCommonController) DataList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	br.Msg = "成功"
	br.Ret = 200
}

// DataDelete
// @Title 数据删除
// @Description 数据删除
// @Param	request	body models.DataDeleteReq true "type json string"
// @Success 200 Ret=200 录入成功
// @router /data/delete [post]
func (this *TargetController) DataDelete() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.DataDeleteReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}

	if req.TradeCode == "" {
		br.Msg = "指标编码不可为空"
		br.ErrMsg = "指标编码不可为空"
		return
	}

	if req.CreateDate == "" {
		br.Msg = "数据录入日期不可为空"
		return
	}
	item, err := models.GetDataInfo(req.TradeCode, req.CreateDate)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取信息失败！"
		br.ErrMsg = "获取信息失败，Err:" + err.Error()
		return
	}
	if item == nil {
		br.Msg = "数据不存在"
		return
	}

	err = models.DataDelete(req.TradeCode, req.CreateDate, item.Close, item.ModifyTime, sysUser.AdminId)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "删除失败，Err:" + err.Error()
		return
	}

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

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

// DataCheck
// @Title 数据删除校验
// @Description 数据删除校验
// @Param   TradeCode   query   string  true       "指标唯一编码"
// @Param   CreateDate   query   string  true       "数据录入日期"
// @Success Ret=200 可删除
// @router /data/check [get]
func (this *TargetController) DataCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	tradeCode := this.GetString("TradeCode")
	createDate := this.GetString("CreateDate")
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}
	if tradeCode == "" {
		br.Msg = "指标编码不可为空"
		return
	}
	if createDate == "" {
		br.Msg = "请选择日期"
		return
	}
	resp := new(models.DataCheckResp)
	item, err := models.GetDataInfo(tradeCode, createDate)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取数据失败"
		br.Msg = "获取数据失败，Err:" + err.Error()
		return
	}
	if item != nil {
		resp.Status = 1
		resp.Close = item.Close
	} else {
		resp.Status = 0
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "检测成功"
	br.Data = resp
}

// TargetCheck
// @Title 指标删除校验
// @Description 指标删除校验
// @Param   TradeCode   query   string  true       "指标唯一编码"
// @Success Ret=200 可删除
// @router /target/check [get]
func (this *TargetController) TargetCheck() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	tradeCode := this.GetString("TradeCode")

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}
	if tradeCode == "" {
		br.Msg = "指标编码不可为空"
		return
	}
	resp := new(models.DataCheckResp)
	count, err := data_manage.GetEdbInfoCount(utils.DATA_SOURCE_MANUAL, tradeCode)
	if err != nil && err.Error() != utils.ErrNoRow() {
		br.Msg = "获取数据失败"
		br.Msg = "获取数据失败，Err:" + err.Error()
		return
	}
	if count > 0 {
		resp.Status = 1
	} else {
		resp.Status = 0
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "指标不存在关联数据，可直接删除"
	br.Data = resp
}

// TargetDelete
// @Title 指标删除
// @Description 指标删除
// @Param	request	body models.TargetDeleteReq true "type json string"
// @Success Ret=200 删除成功
// @router /target/delete [post]
func (this *TargetController) TargetDelete() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	if req.TradeCode == "" {
		br.Msg = "指标编码不可为空"
		return
	}

	//判断是否在指标数据导入的过程，如果是在该过程，那么就不允许用户操作
	key := "import:edbinfo:data:" + req.TradeCode
	if utils.Rc.IsExist(key) {
		br.Msg = "该指标正在导入数据中，请稍后操作"
		return
	}
	err = models.TargetDelete(req.TradeCode)
	if err != nil {
		br.Msg = "删除失败"
		br.Msg = "删除失败，Err:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "删除成功"
}

// GetResearcher
// @Title 获取研究员
// @Description 获取研究员
// @Success 200 {object} models.ResearcherListResp
// @router /getResearcher [get]
func (this *TargetController) GetResearcher() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}
	var err error
	list := make([]*models.Researcher, 0)
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN ||
		sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_FICC_ADMIN ||
		sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_RAI_ADMIN {
		list, err = models.GetResearcherEntry()
		if err != nil {
			br.Msg = "获取数据失败"
			br.Msg = "获取数据失败，Err:" + err.Error()
			return
		}
	} else if sysUser.Role == "hggroup" {
		mobileStr := "'15888577277','15888856487','15158848535','13651627324' "
		list, err = models.GetResearcherEntryByMobile(mobileStr)
		if err != nil {
			br.Msg = "获取数据失败"
			br.Msg = "获取数据失败，Err:" + err.Error()
			return
		}
	} else if sysUser.AdminName == "dfma" {
		list, err = models.GetResearcherEntry()
		if err != nil {
			br.Msg = "获取数据失败"
			br.Msg = "获取数据失败，Err:" + err.Error()
			return
		}

	}
	resp := new(models.ResearcherListResp)
	resp.List = list
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// GetTargetItems
// @Title 获取研究员指标
// @Description 获取研究员指标
// @Param   Mobile   query   string  true       "手机号"
// @Param   ClassifyId   query   int  true       "分类id"
// @Success 200 {object} models.ResearcherListResp
// @router /getTargetItems [get]
func (this *TargetController) GetTargetItems() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	mobile := this.GetString("Mobile")

	if mobile == "" {
		mobile = sysUser.Mobile
	}
	classifyId, _ := this.GetInt("ClassifyId")
	items, err := models.GetTargetItems(mobile, classifyId)
	if err != nil {
		br.ErrMsg = "获取失败，Err:" + err.Error()
		br.Msg = "获取失败"
		return
	}
	resp := new(models.TargetItemsResp)
	resp.List = items
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// ExportLongzhong
// @Title 隆众数据下载
// @Description 隆众数据下载接口
// @Success 200 {object} models.ResearcherListResp
// @router /export/longzhong [get]
func (this *TargetCommonController) ExportLongzhong() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	parentId := 4
	classifyList, err := models.GetEdbdataClassifyByParentId(parentId)
	if err != nil {
		return
	}
	xlsxFile := xlsx.NewFile()
	if err != nil {
		fmt.Println("生成文件失败" + err.Error())
		return
	}
	dir, _ := os.Executable()
	exPath := filepath.Dir(dir)
	downLoadnFilePath := exPath + "/static/" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	for _, v := range classifyList {
		fmt.Println(v.ClassifyId, v.ClassifyName)
		//获取指标
		secNameList, err := data_source.GetLongzhonginfoByClassifyId(v.ClassifyId)
		if err != nil {
			fmt.Println("获取数据失败，Err:" + err.Error())
			return
		}
		if len(secNameList) <= 0 {
			continue
		}
		sheetNew, err := xlsxFile.AddSheet(v.ClassifyName)

		if err != nil {
			fmt.Println("新增Sheet失败", err.Error())
			return
		}
		//sheetNew.SetColWidth()
		//获取指标数据
		windRow := sheetNew.AddRow()
		secNameRow := sheetNew.AddRow()
		frequencyRow := sheetNew.AddRow()
		unitRow := sheetNew.AddRow()
		lastModifyDateRow := sheetNew.AddRow()
		//获取分类下指标最大数据量
		dataMax, err := data_source.GetLongzhongDataMaxCount(v.ClassifyId)
		if err != nil {
			fmt.Println("获取指标最大数据量失败", err.Error())
			return
		}
		for k, sv := range secNameList {
			fmt.Println("line 399:", v.ClassifyId, v.ClassifyName, sv.SecName, sv.Frequency)

			windRow.AddCell().SetValue("Wind")
			secNameRow.AddCell().SetValue("指标名称")
			frequencyRow.AddCell().SetValue("频率")
			unitRow.AddCell().SetValue("单位")
			lastModifyDateRow.AddCell().SetValue("更新时间")

			secNameRow.AddCell().SetValue(sv.SecName)
			frequencyRow.AddCell().SetValue(sv.Frequency)
			unitRow.AddCell().SetValue(sv.Unit)
			lastModifyDateRow.AddCell().SetValue(sv.LastModifyDate)

			windRow.AddCell()
			windRow.AddCell()
			secNameRow.AddCell()
			frequencyRow.AddCell()
			unitRow.AddCell()
			lastModifyDateRow.AddCell()
			min := k * 3
			sheetNew.SetColWidth(min, min, 15)
			//获取数据
			dataList, err := data_source.GetLongzhongDataById(sv.LongzhonginfoId)
			if err != nil {
				br.Msg = "获取数据失败"
				br.ErrMsg = "获取数据失败,Err:" + err.Error()
				return
			}
			if len(dataList) <= 0 {
				for n := 0; n < dataMax; n++ {
					rowIndex := 5 + n
					row := sheetNew.Row(rowIndex)
					row.AddCell()
					row.AddCell()
					row.AddCell()
				}
			} else {
				endRowIndex := 0
				for rk, dv := range dataList {
					rowIndex := 5 + rk
					row := sheetNew.Row(rowIndex)
					displayDate, _ := time.Parse(utils.FormatDate, dv.DisplayTime)
					displayDateCell := row.AddCell()
					style := new(xlsx.Style)
					style.ApplyAlignment = true
					style.Alignment.WrapText = true
					displayDateCell.SetStyle(style)
					displayDateCell.SetDate(displayDate)

					row.AddCell().SetFloat(dv.Close)
					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 {
		br.Msg = "保存文件失败"
		br.ErrMsg = "保存文件失败"
		return
	}
	fileName := "隆众石化数据" + time.Now().Format("200601021504") + ".xlsx"
	this.Ctx.Output.Download(downLoadnFilePath, fileName)
	defer func() {
		os.Remove(downLoadnFilePath)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "success"
}

// ExportLongzhongPrice
// @Title 隆众价格数据下载
// @Description 隆众价格数据下载接口
// @Success 200 {object} models.ResearcherListResp
// @router /export/longzhong/price [get]
func (this *TargetCommonController) ExportLongzhongPrice() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	classifyList, err := models.GetLzPriceClassify()
	if err != nil {
		return
	}
	xlsxFile := xlsx.NewFile()
	if err != nil {
		fmt.Println("生成文件失败" + err.Error())
		return
	}
	dir, _ := os.Executable()
	exPath := filepath.Dir(dir)
	downLoadnFilePath := exPath + "/static/" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	for _, v := range classifyList {
		//获取指标
		secNameList, err := models.GetLongzhongpriceinfoByClassifyName(v.ProductName)
		if err != nil {
			fmt.Println("获取数据失败，Err:" + err.Error())
			return
		}
		if len(secNameList) <= 0 {
			continue
		}
		sheetNew, err := xlsxFile.AddSheet(v.ProductName)
		if err != nil {
			fmt.Println("新增Sheet失败", err.Error())
			return
		}
		//获取指标数据
		windRow := sheetNew.AddRow()
		secNameRow := sheetNew.AddRow()
		frequencyRow := sheetNew.AddRow()
		unitRow := sheetNew.AddRow()
		lastModifyDateRow := sheetNew.AddRow()
		marketRow := sheetNew.AddRow()
		manufactureRow := sheetNew.AddRow()
		standardRow := sheetNew.AddRow()  //规格
		modelNameRow := sheetNew.AddRow() //规格型号

		titleRow := sheetNew.AddRow()
		//获取分类下指标最大数据量
		dataMax, err := models.GetLongzhongPriceDataMaxCount(v.ProductName)
		if err != nil {
			fmt.Println("获取指标最大数据量失败", err.Error())
			return
		}

		for k, sv := range secNameList {
			fmt.Println("line 399:", v.ProductName, sv.InfoTypeRemark, sv.AreaName)

			windRow.AddCell().SetString("Wind")
			secNameRow.AddCell().SetValue("分类")
			frequencyRow.AddCell().SetValue("价格类型")
			unitRow.AddCell().SetValue("单位")
			lastModifyDateRow.AddCell().SetValue("地区")
			marketRow.AddCell().SetValue("市场名称")
			manufactureRow.AddCell().SetValue("厂家名称")
			standardRow.AddCell().SetValue("规格")
			modelNameRow.AddCell().SetValue("规格型号")

			secNameRow.AddCell().SetValue(sv.InfoTypeRemark)
			frequencyRow.AddCell().SetValue(sv.PriceType)
			unitRow.AddCell().SetValue(sv.Unit)
			lastModifyDateRow.AddCell().SetValue(sv.AreaName)
			marketRow.AddCell().SetValue(sv.MarketName)
			manufactureRow.AddCell().SetValue(sv.ManufactureName)
			standardRow.AddCell().SetValue(sv.Standard)
			modelNameRow.AddCell().SetValue(sv.ModelName)

			windRow.AddCell()
			windRow.AddCell()
			windRow.AddCell()
			windRow.AddCell()

			secNameRow.AddCell()
			frequencyRow.AddCell()
			unitRow.AddCell()
			lastModifyDateRow.AddCell()
			marketRow.AddCell()
			manufactureRow.AddCell()
			standardRow.AddCell()
			modelNameRow.AddCell()

			secNameRow.AddCell()
			frequencyRow.AddCell()
			unitRow.AddCell()
			lastModifyDateRow.AddCell()
			marketRow.AddCell()
			manufactureRow.AddCell()
			standardRow.AddCell()
			modelNameRow.AddCell()

			secNameRow.AddCell()
			frequencyRow.AddCell()
			unitRow.AddCell()
			lastModifyDateRow.AddCell()
			marketRow.AddCell()
			manufactureRow.AddCell()
			standardRow.AddCell()
			modelNameRow.AddCell()

			titleRow.AddCell().SetValue("价格日期")
			titleRow.AddCell().SetValue("价格")
			titleRow.AddCell().SetValue("低端价格")
			titleRow.AddCell().SetValue("高端价格")
			titleRow.AddCell()

			min := k * 5
			sheetNew.SetColWidth(min, min, 15)

			//获取数据
			dataList, err := models.GetLongzhongPriceDataById(sv.LongzhongpriceinfoId)
			if err != nil {
				fmt.Println("GetLongzhongDataById Err:" + err.Error())
				return
			}
			rowStart := 10
			if len(dataList) <= 0 {
				for n := 0; n < dataMax; n++ {
					rowIndex := rowStart + n
					row := sheetNew.Row(rowIndex)
					row.AddCell()
					row.AddCell()
					row.AddCell()
					row.AddCell()
					row.AddCell()
				}
			} else {
				endRowIndex := 0
				for rk, dv := range dataList {
					rowIndex := rowStart + rk
					row := sheetNew.Row(rowIndex)
					priceDate, _ := time.Parse(utils.FormatDate, dv.PriceDate)
					row.AddCell().SetDate(priceDate)
					row.AddCell().SetFloat(dv.Price)
					row.AddCell().SetFloat(dv.LowPrice)
					row.AddCell().SetFloat(dv.HighPrice)

					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()
						row.AddCell()
						row.AddCell()
					}
				}
			}
		}
	}

	err = xlsxFile.Save(downLoadnFilePath)
	if err != nil {
		br.Msg = "保存文件失败"
		br.ErrMsg = "保存文件失败"
		return
	}
	fileName := "隆众价格数据" + time.Now().Format("200601021504") + ".xlsx"
	this.Ctx.Output.Download(downLoadnFilePath, fileName)
	defer func() {
		os.Remove(downLoadnFilePath)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "success"
}

// ExportLongzhongSurvey
// @Title 隆众调研数据下载
// @Description 隆众调研数据下载接口
// @Success 200 {object} models.ResearcherListResp
// @router /export/longzhong/survey [get]
func (this *TargetCommonController) ExportLongzhongSurvey() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	classifyList, err := models.GetLzSurveyClassify()
	if err != nil {
		return
	}
	xlsxFile := xlsx.NewFile()
	if err != nil {
		fmt.Println("生成文件失败" + err.Error())
		return
	}
	dir, _ := os.Executable()
	exPath := filepath.Dir(dir)
	downLoadnFilePath := exPath + "/static/" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	for _, v := range classifyList {
		//获取指标
		secNameList, err := models.GetLongzhongSurveyProductByClassifyName(v.ProductName)
		if err != nil {
			fmt.Println("获取数据失败，Err:" + err.Error())
			return
		}
		if len(secNameList) <= 0 {
			continue
		}
		sheetNew, err := xlsxFile.AddSheet(v.ProductName)

		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_source.GetLongzhongSurveyDataMaxCount(v.ProductName)
		if err != nil {
			fmt.Println("获取指标最大数据量失败", err.Error())
			return
		}
		setRowIndex := 6
		for k, sv := range secNameList {

			windRow.AddCell().SetValue("隆众")
			secNameRow.AddCell().SetValue("指标名称")
			indexCodeRow.AddCell().SetValue("指标ID")
			frequencyRow.AddCell().SetValue("频率")
			unitRow.AddCell().SetValue("单位")
			lastModifyDateRow.AddCell().SetValue("更新时间")

			secNameRow.AddCell().SetValue(sv.SampleName + sv.BreedName + sv.Custom + sv.QuotaName)
			indexCodeRow.AddCell().SetValue(sv.LzCode)
			if sv.Frequency == 1 {
				frequencyRow.AddCell().SetValue("日度")
			} else if sv.Frequency == 2 {
				frequencyRow.AddCell().SetValue("周度")
			} else if sv.Frequency == 3 {
				frequencyRow.AddCell().SetValue("月度")
			} else if sv.Frequency == 4 {
				frequencyRow.AddCell().SetValue("季度")
			} else if sv.Frequency == 5 {
				frequencyRow.AddCell().SetValue("年度")
			} else if sv.Frequency == 99 {
				frequencyRow.AddCell().SetValue("无固定频率")
			}

			unitRow.AddCell().SetValue(sv.UnitName)
			lastModifyDateRow.AddCell().SetValue(sv.EndDate)

			windRow.AddCell()
			windRow.AddCell()
			secNameRow.AddCell()
			indexCodeRow.AddCell()
			frequencyRow.AddCell()
			unitRow.AddCell()
			lastModifyDateRow.AddCell()
			min := k * 3
			sheetNew.SetColWidth(min, min, 15)
			//获取数据
			dataList, err := data_source.GetLongzhongSurveyDataById(sv.SurveyProductId)
			if err != nil {
				br.Msg = "获取数据失败"
				br.ErrMsg = "获取数据失败,Err:" + err.Error()
				return
			}
			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().SetFloat(dv.InputValue)
					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 {
		br.Msg = "保存文件失败"
		br.ErrMsg = "保存文件失败"
		return
	}
	fileName := "隆众调研数据" + time.Now().Format("200601021504") + ".xlsx"
	this.Ctx.Output.Download(downLoadnFilePath, fileName)
	defer func() {
		os.Remove(downLoadnFilePath)
	}()
	br.Ret = 200
	br.Success = true
	br.Msg = "success"
}

// TargetUnitList
// @Title 指标列表
// @Description 指标列表接口
// @Success 200 {object} []string
// @router /target/unit_list [get]
func (this *TargetController) TargetUnitList() {
	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
	}

	list, err := models.GetEdbUnitList()
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	edbUnitList := make([]string, 0)
	for _, unit := range list {
		edbUnitList = append(edbUnitList, unit.Unit)
	}

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

// TargetFrequencyList
// @Title 指标频度列表
// @Description 指标频度列表接口
// @Param   ClassifyId   query   int  true       "分类"
// @Success 200 {object} []string
// @router /target/frequency_list [get]
func (this *TargetController) TargetFrequencyList() {
	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
	}

	classifyId, _ := this.GetInt("ClassifyId") //分类
	if classifyId <= 0 {
		br.Msg = "分类ID必传"
		return
	}
	userId := sysUser.AdminId
	//超管账号可以查看分类下的所有频度数据
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN {
		userId = 0
	}
	list, err := models.GetEdbFrequencyList(classifyId, userId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取失败，Err:" + err.Error()
		return
	}
	edbFrequencyList := make([]string, 0)
	for _, unit := range list {
		edbFrequencyList = append(edbFrequencyList, unit.Frequency)
	}
	edbFrequencyList = sortEdbFrequency(edbFrequencyList)

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

func sortEdbFrequency(frequencyList []string) (newFrequencyList []string) {
	var frequencyMap1 = map[string]int{
		"日度":   1,
		"周度":   2,
		"旬度":   3,
		"月度":   4,
		"季度":   5,
		"半年度": 6,
		"年度":   7,
	}

	var frequencyMap2 = map[int]string{
		1: "日度",
		2: "周度",
		3: "旬度",
		4: "月度",
		5: "季度",
		6: "半年度",
		7: "年度",
	}

	idList := make([]int, 0)
	for _, frequency := range frequencyList {
		idList = append(idList, frequencyMap1[frequency])
	}
	sort.Ints(idList)

	for _, id := range idList {
		newFrequencyList = append(newFrequencyList, frequencyMap2[id])
	}
	return
}

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

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

	//频度
	frequency := this.GetString("Frequency")

	//关键字
	keyword := this.GetString("Keyword")
	//指标编码
	tradeCode := this.GetString("TradeCode")

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

	classifyId, _ := this.GetInt("ClassifyId")
	edbShowType, _ := this.GetInt("EdbShowType")

	list, err := models.GetTargetItemListSort(classifyId, edbShowType, frequency, keyword, tradeCode, classifyIdStrList)
	if err != nil {
		br.ErrMsg = "获取失败，Err:" + err.Error()
		br.Msg = "获取失败"
		return
	}
	edbTradeCodeList := make([]string, 0)
	//频度数据
	frequencyMap := make(map[string]int)
	for _, edb := range list {
		edbTradeCodeList = append(edbTradeCodeList, edb.TradeCode)
		frequencyMap[edb.Frequency] = 0
	}
	frequencyList := make([]string, 0)
	for k := range frequencyMap {
		frequencyList = append(frequencyList, k)
	}
	frequencyList = sortEdbFrequency(frequencyList)

	if len(edbTradeCodeList) > 0 {
		edbTradeCodeStr := `"` + strings.Join(edbTradeCodeList, `","`) + `"`
		edbDataList, err := models.GetEdbDataListByCodes(edbTradeCodeStr)
		if err != nil {
			br.ErrMsg = "获取指标数据失败，Err:" + err.Error()
			br.Msg = "获取失败"
			return
		}
		edbDataMap := make(map[string][]*models.Edbdata, 0)
		for _, edbData := range edbDataList {
			if _, ok := edbDataMap[edbData.TradeCode]; ok {
				edbDataMap[edbData.TradeCode] = append(edbDataMap[edbData.TradeCode], edbData)
			} else {
				tmpEdbDataList := make([]*models.Edbdata, 0)
				tmpEdbDataList = append(tmpEdbDataList, edbData)
				edbDataMap[edbData.TradeCode] = tmpEdbDataList
			}
		}

		//nowWeek := time.Now().Weekday().String() //当前周几
		myYear := time.Now().Year()        //当前年份
		myMonth := time.Now().Format("01") //当前月份

		//当前周的周一与周日
		nowWeekFirstDay := utils.GetNowWeekMonday()
		nowWeekLastDay := utils.GetNowWeekLastDay()

		//当前月的一号与最后一天
		nowMonthFirstDay := utils.GetNowMonthFirstDay()
		nowMonthLastDay := utils.GetNowMonthLastDay()

		//当前季度的第一天与最后一天
		nowQuarterFirstDay := utils.GetNowQuarterFirstDay()
		nowQuarterLastDay := utils.GetNowQuarterLastDay()

		//当前半年的第一天与最后一天
		nowHalfYearFirstDay := utils.GetNowHalfYearFirstDay()
		nowHalfYearLastDay := utils.GetNowHalfYearLastDay()

		// 当前年的第一天与最后一天
		nowYearFirstDay := utils.GetNowYearFirstDay()
		nowYearLastDay := utils.GetNowYearLastDay()

		for _, edb := range list {
			edb.Status = "未完成"
			if dataList, ok := edbDataMap[edb.TradeCode]; ok {
				edb.DataList = dataList
				dataDtTime, _ := time.ParseInLocation(utils.FormatDate, dataList[0].Dt, time.Now().Location()) //最近的一条数据时间

				switch edb.Frequency {
				case "日度":
					if time.Now().After(dataDtTime.AddDate(0, 0, 1)) {
						edb.ModifyDate = time.Now().Format(utils.FormatDate)
					} else {
						edb.ModifyDate = dataDtTime.AddDate(0, 0, 1).Format(utils.FormatDate)
						edb.Status = "完成"
					}
				case "周度":
					//if edb.NoticeTime != "" {
					//	noticeArr := strings.Split(edb.NoticeTime, " ")
					//	noticeWeek := noticeArr[0]
					//	addDay := 0
					//
					//	if nowWeek == "Sunday" {
					//		if noticeWeek == "周日" {
					//			addDay = 0
					//		} else if noticeWeek == "周一" {
					//			addDay = 1
					//		} else if noticeWeek == "周二" {
					//			addDay = 2
					//		} else if noticeWeek == "周三" {
					//			addDay = 3
					//		} else if noticeWeek == "周四" {
					//			addDay = 4
					//		} else if noticeWeek == "周五" {
					//			addDay = 5
					//		} else if noticeWeek == "周六" {
					//			addDay = 6
					//		} else {
					//			addDay = 0
					//		}
					//	} else if nowWeek == "Monday" {
					//		if noticeWeek == "周日" {
					//			addDay = 6
					//		} else if noticeWeek == "周一" {
					//			addDay = 0
					//		} else if noticeWeek == "周二" {
					//			addDay = 1
					//		} else if noticeWeek == "周三" {
					//			addDay = 2
					//		} else if noticeWeek == "周四" {
					//			addDay = 3
					//		} else if noticeWeek == "周五" {
					//			addDay = 4
					//		} else if noticeWeek == "周六" {
					//			addDay = 5
					//		} else {
					//			addDay = 0
					//		}
					//	} else if nowWeek == "Tuesday" {
					//		if noticeWeek == "周日" {
					//			addDay = 5
					//		} else if noticeWeek == "周一" {
					//			addDay = 6
					//		} else if noticeWeek == "周二" {
					//			addDay = 0
					//		} else if noticeWeek == "周三" {
					//			addDay = 1
					//		} else if noticeWeek == "周四" {
					//			addDay = 2
					//		} else if noticeWeek == "周五" {
					//			addDay = 3
					//		} else if noticeWeek == "周六" {
					//			addDay = 4
					//		} else {
					//			addDay = 0
					//		}
					//	} else if nowWeek == "Wednesday" {
					//		if noticeWeek == "周日" {
					//			addDay = 4
					//		} else if noticeWeek == "周一" {
					//			addDay = 5
					//		} else if noticeWeek == "周二" {
					//			addDay = 6
					//		} else if noticeWeek == "周三" {
					//			addDay = 0
					//		} else if noticeWeek == "周四" {
					//			addDay = 1
					//		} else if noticeWeek == "周五" {
					//			addDay = 2
					//		} else if noticeWeek == "周六" {
					//			addDay = 3
					//		} else {
					//			addDay = 0
					//		}
					//	} else if nowWeek == "Thursday" {
					//		if noticeWeek == "周日" {
					//			addDay = 3
					//		} else if noticeWeek == "周一" {
					//			addDay = 4
					//		} else if noticeWeek == "周二" {
					//			addDay = 5
					//		} else if noticeWeek == "周三" {
					//			addDay = 6
					//		} else if noticeWeek == "周四" {
					//			addDay = 0
					//		} else if noticeWeek == "周五" {
					//			addDay = 1
					//		} else if noticeWeek == "周六" {
					//			addDay = 2
					//		} else {
					//			addDay = 0
					//		}
					//	} else if nowWeek == "Friday" {
					//		if noticeWeek == "周日" {
					//			addDay = 2
					//		} else if noticeWeek == "周一" {
					//			addDay = 3
					//		} else if noticeWeek == "周二" {
					//			addDay = 4
					//		} else if noticeWeek == "周三" {
					//			addDay = 5
					//		} else if noticeWeek == "周四" {
					//			addDay = 6
					//		} else if noticeWeek == "周五" {
					//			addDay = 0
					//		} else if noticeWeek == "周六" {
					//			addDay = 1
					//		} else {
					//			addDay = 0
					//		}
					//	} else if nowWeek == "Saturday" {
					//		if noticeWeek == "周日" {
					//			addDay = 1
					//		} else if noticeWeek == "周一" {
					//			addDay = 2
					//		} else if noticeWeek == "周二" {
					//			addDay = 3
					//		} else if noticeWeek == "周三" {
					//			addDay = 4
					//		} else if noticeWeek == "周四" {
					//			addDay = 5
					//		} else if noticeWeek == "周五" {
					//			addDay = 6
					//		} else if noticeWeek == "周六" {
					//			addDay = 0
					//		} else {
					//			addDay = 0
					//		}
					//	}
					//
					//	modifyDate := time.Now().AddDate(0, 0, addDay)
					//	if modifyDate.After(dataDtTime.AddDate(0, 0, 1)) {
					//		edb.ModifyDate = modifyDate.Format(utils.FormatDate)
					//	} else {
					//		edb.ModifyDate = modifyDate.AddDate(0, 0, 7).Format(utils.FormatDate)
					//		edb.Status = "完成"
					//	}
					//} else {
					//	if startWeekDay.Unix() <= dataDtTime.Unix() {
					//		edb.ModifyDate = endWeekDay.AddDate(0, 0, 7).Format(utils.FormatDate)
					//		edb.Status = "完成"
					//	} else {
					//		edb.ModifyDate = endWeekDay.Format(utils.FormatDate)
					//	}
					//}

					modifyDate := nowWeekLastDay //下次更新日期
					if edb.NoticeTime != "" {
						addDay := 7
						noticeArr := strings.Split(edb.NoticeTime, " ")
						noticeWeek := noticeArr[0]
						switch noticeWeek {
						case "周一":
							addDay = 1
						case "周二":
							addDay = 2
						case "周三":
							addDay = 3
						case "周四":
							addDay = 4
						case "周五":
							addDay = 5
						case "周六":
							addDay = 6
						case "周日":
							addDay = 7
						}
						modifyDate = modifyDate.AddDate(0, 0, addDay-7)
					}
					if nowWeekFirstDay.Before(dataDtTime) {
						edb.ModifyDate = modifyDate.AddDate(0, 0, 7).Format(utils.FormatDate)
						edb.Status = "完成"
					} else {
						edb.ModifyDate = modifyDate.Format(utils.FormatDate)
					}
				case "月度":
					addDay := 0
					modifyDate := nowMonthLastDay //下次更新日期
					if edb.NoticeTime != "" {
						strArr := strings.Split(edb.NoticeTime, "日")
						tmpAddDay, tmpErr := strconv.Atoi(strArr[0])
						if tmpErr != nil {
							continue
						}
						addDay = tmpAddDay - 1
						modifyDate = nowMonthFirstDay.AddDate(0, 0, addDay)
					}

					if nowMonthFirstDay.Before(dataDtTime) {
						if int(time.Now().Month()) != int(nowMonthFirstDay.Month()) {
							edb.ModifyDate = nowMonthLastDay.Format(utils.FormatDate)
						} else {
							month := nowMonthLastDay.Month() + 1
							edb.ModifyDate = time.Date(nowMonthLastDay.Year(), month, 1, 0, 0, 0, 0, modifyDate.Location()).AddDate(0, 1, -1).Format(utils.FormatDate)
						}
						edb.Status = "完成"
					} else {
						edb.ModifyDate = modifyDate.Format(utils.FormatDate)
					}
				case "季度":
					//每季度更新数据时间
					if nowQuarterFirstDay.After(dataDtTime) {
						edb.ModifyDate = nowQuarterLastDay.Format(utils.FormatDate)
					} else {
						edb.ModifyDate = nowQuarterLastDay.AddDate(0, 3, 0).Format(utils.FormatDate)
						edb.Status = "完成"
					}
				case "半年度":
					//每半年度更新数据时间
					if nowHalfYearFirstDay.After(dataDtTime) {
						edb.ModifyDate = nowHalfYearLastDay.Format(utils.FormatDate)
					} else {
						month := nowHalfYearLastDay.Month() + 1
						edb.ModifyDate = time.Date(nowMonthLastDay.Year(), month, 1, 0, 0, 0, 0, nowHalfYearLastDay.Location()).AddDate(0, 6, -1).Format(utils.FormatDate)
						edb.Status = "完成"
					}
				case "年度":
					//每年度更新数据时间
					if nowYearFirstDay.After(dataDtTime) {
						edb.ModifyDate = nowYearLastDay.Format(utils.FormatDate)
					} else {
						edb.ModifyDate = nowYearLastDay.AddDate(1, 0, 0).Format(utils.FormatDate)
						edb.Status = "完成"
					}
				}
			} else {
				edb.DataList = make([]*models.Edbdata, 0)
				switch edb.Frequency {
				case "日度":
					edb.ModifyDate = time.Now().Format(utils.FormatDate)
				case "周度":
					modifyDate := nowWeekLastDay //下次更新日期
					if edb.NoticeTime != "" {
						addDay := 7
						noticeArr := strings.Split(edb.NoticeTime, " ")
						noticeWeek := noticeArr[0]
						switch noticeWeek {
						case "周一":
							addDay = 1
						case "周二":
							addDay = 2
						case "周三":
							addDay = 3
						case "周四":
							addDay = 4
						case "周五":
							addDay = 5
						case "周六":
							addDay = 6
						case "周日":
							addDay = 7
						}
						modifyDate = modifyDate.AddDate(0, 0, addDay-7)
					}
					edb.ModifyDate = modifyDate.Format(utils.FormatDate)
				case "月度":
					if edb.NoticeTime != "" {
						var modifyDateStr string
						strArr := strings.Split(edb.NoticeTime, "日")
						modifyDateStr = strconv.Itoa(myYear) + "-" + myMonth + "-" + strArr[0]
						edb.ModifyDate = modifyDateStr
					} else {
						edb.ModifyDate = nowMonthFirstDay.AddDate(0, 1, -1).Format(utils.FormatDate)
					}
				case "季度":
					edb.ModifyDate = utils.GetNowQuarterLastDay().Format(utils.FormatDate)
				case "半年度":
					edb.ModifyDate = utils.GetNowHalfYearLastDay().Format(utils.FormatDate)
				case "年度":
					edb.ModifyDate = utils.GetNowYearLastDay().Format(utils.FormatDate)
				}
			}
		}
	}

	resp := models.TargetItemListResp{
		List:          list,
		FrequencyList: frequencyList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	//br.Data = resp
	br.Data = resp
}

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

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

	//频度
	frequency := this.GetString("Frequency")

	//关键字
	keyword := this.GetString("Keyword")
	//指标编码
	tradeCode := this.GetString("TradeCode")

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

	list, err := models.GetTargetItemList(classifyId, edbShowType, frequency, keyword, tradeCode, classifyIdStrList)
	if err != nil {
		br.ErrMsg = "获取失败，Err:" + err.Error()
		br.Msg = "获取失败"
		return
	}

	resp := models.TargetItemListResp{
		List: list,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	//br.Data = resp
	br.Data = resp
}

// BatchDataDeleteByDate
// @Title 根据日期批量删除指标的数据
// @Description 根据日期批量删除指标的数据接口
// @Param	request	body models.BatchDataDeleteReq true "type json string"
// @Success 200 Ret=200 删除数据成功
// @router /data/batch_delete_by_date [post]
func (this *TargetController) BatchDataDeleteByDate() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	var req models.BatchDataDeleteReq
	err := json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if len(req.TradeCodeList) <= 0 {
		br.Msg = "至少传入一个指标编码！"
		return
	}

	if req.CreateDate == "" {
		br.Msg = "请选择日期"
		return
	}

	TradeCodeStr := `"` + strings.Join(req.TradeCodeList, `","`) + `"`

	//删除数据
	err = models.BatchDeleteEdbDataByDate(TradeCodeStr, req.CreateDate, this.SysUser.AdminId)
	if err != nil {
		br.Msg = "删除失败！"
		br.ErrMsg = "删除失败，Err:" + err.Error()
		return
	}

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

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

	if req.TradeCode == "" {
		br.Msg = "指标编码不可为空"
		return
	}

	//删除数据
	err = models.BatchDeleteEdbData(req.TradeCode, this.SysUser.AdminId)
	if err != nil {
		br.Msg = "删除失败！"
		br.ErrMsg = "删除失败，Err:" + err.Error()
		return
	}

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

// EdbTemplateDownload
// @Title 下载指标导入模板
// @Description 下载指标导入模板
// @router /target/template [get]
func (this *TargetCommonController) EdbTemplateDownload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	this.Ctx.Output.Download("./static/指标导入模板.xlsx", "指标导入模板.xlsx")
	br.Ret = 200
	br.Success = true
	br.Msg = "下载成功"
}

// ImportTarget
// @Title 导入指标
// @Description 导入指标接口
// @Success 200 Ret=200 导入成功
// @router /target/import [post]
func (this *TargetController) ImportTarget() {
	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("ImportTargetFile")
	if err != nil {
		br.Msg = "获取文件失败"
		br.ErrMsg = "获取文件失败，Err:" + err.Error()
		return
	}
	path := "./static/手工指标数据导入_" + time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	defer func() {
		file.Close()
		os.Remove(path)
	}()
	err = this.SaveToFile("ImportTargetFile", path)
	if err != nil {
		br.Msg = "文件保存失败"
		br.ErrMsg = "文件保存失败，Err:" + err.Error()
		return
	}
	xlFile, err := xlsx.OpenFile(path)
	if err != nil {
		fmt.Println(err.Error())
		br.Msg = "excel打开失败"
		br.ErrMsg = "excel打开失败，Err:" + err.Error()
		return
	}

	//分类map
	classifyMap := make(map[string]*models.EdbdataClassify)
	//获取当前账号拥有的所有分类权限
	userId := sysUser.AdminId
	if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN {
		userId = 0
	}
	classifyList, err := models.GetEdbdataClassify(int64(userId))
	for _, classify := range classifyList {
		if classify.Child != nil {
			for _, child := range classify.Child {
				classifyMap[child.ClassifyName] = child
			}
		}
	}

	failDatas := make([]*models.EdbImportFail, 0)
	// 遍历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) >= 4 {
					cell1 := cells[0].Value //指标名称
					secName := strings.Trim(cell1, " ")
					if secName == "" { //过滤空白行
						continue
					}

					cell2 := cells[1].Value
					frequency := strings.Trim(cell2, " ") //频度

					classifyName := cells[2].Value //分类
					classifyName = strings.Trim(classifyName, " ")

					unit := cells[3].Value //单位
					unit = strings.Trim(unit, " ")

					//获取分类
					classify, ok := classifyMap[classifyName]
					if !ok {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "分类不存在",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
					}

					tradeCode, err := models.GetMaxTradeCode()
					if err != nil {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "获取数据失败",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
						//br.Msg = "获取数据失败"
						//br.ErrMsg = "获取最大交易编码失败,Err:" + err.Error()
						//return
					}

					if tradeCode == "" {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "数据异常",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
					}
					maxTradeCode, err := utils.GetMaxTradeCode(tradeCode)
					if err != nil {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "数据异常",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
						//br.Msg = "数据异常"
						//br.ErrMsg = "获取编码信息失败,Err:" + err.Error()
						//return
					}
					if maxTradeCode == "" {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "编码为空，请联系技术",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
						//br.Msg = "编码为空，请联系技术"
						//br.ErrMsg = "编码为空，请联系技术"
						//return
					}
					if secName == "" {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "指标名称不能为空",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
						//br.Msg = "指标名称不能为空"
						//return
					}
					item, err := models.GetEdbinfoBySecName(secName)
					if err != nil && err.Error() != utils.ErrNoRow() {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "获取信息失败",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
						//br.Msg = "获取信息失败！"
						//br.ErrMsg = "获取信息失败，Err:" + err.Error()
						//return
					}
					//存在该指标，那么退出当前循环，进入下一循环
					if item != nil {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "指标已存在",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
					}
					err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, "", classify.ClassifyId, sysUser.AdminId)
					if err != nil {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "导入失败",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue

						//br.Msg = "导入失败"
						//br.ErrMsg = "导入失败，Err:" + err.Error()
						//return
					}
					err = models.AddEdbinfoUser(maxTradeCode, sysUser.Mobile)
					if err != nil {
						failItem := &models.EdbImportFail{
							ClassifyName: classifyName,
							Frequency:    frequency,
							SecName:      secName,
							Unit:         unit,
							Remark:       "创建账号关系失败",
							SysUserId:    strconv.Itoa(sysUser.AdminId),
						}
						failDatas = append(failDatas, failItem)
						continue
						//br.Msg = "导入失败"
						//br.ErrMsg = "导入失败，Err:" + err.Error()
						//return
					}
				}
			}
		}
	}

	resp := new(models.EdbdataImportResp)
	if len(failDatas) > 0 {
		//先删除导入失败记录
		_ = models.DelEdbImportFail(sysUser.AdminId)
		//错误信息字符串切片，最后作为发送邮件通知使用
		failContents := make([]string, 0)
		for _, v := range failDatas {
			failContents = append(failContents, fmt.Sprint(v.SecName, "导入失败：", v.Remark))
			err = models.AddEdbImportFail(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("导入数据 存在部分数据导入失败，Err："+err.Error(), 3)
		//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入指标 存在部分数据导入失败:"+strings.Join(failContents, "；"), utils.EmailSendToUsers)

		resp.Status = 1
		resp.Msg = "存在部分导入失败"
	} else {
		resp.Status = 0
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "导入成功"
	br.Data = resp
}

// ImportTargetFailListDownload
// @Title 下载指标数据导入失败列表
// @Description 下载指标数据导入失败列表
// @router /import_target/failList [get]
func (this *TargetController) ImportTargetFailListDownload() {
	br := new(models.BaseResponse).Init()
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请重新登录"
		return
	}
	item, err := models.GetEdbImportFailList(sysUser.AdminId)
	if err != nil {
		br.Msg = "获取数据失败"
		br.Msg = "获取数据失败，Err:" + err.Error()
		return
	}
	xlsxFile := xlsx.NewFile()
	sheet, err := xlsxFile.AddSheet("导入失败数据")
	headRow := sheet.AddRow()
	headRow.AddCell().SetValue("指标名称")
	headRow.AddCell().SetValue("频度")
	headRow.AddCell().SetValue("品种分类")
	headRow.AddCell().SetValue("单位")
	headRow.AddCell().SetValue("备注")
	for _, v := range item {
		row := sheet.AddRow()
		row.AddCell().SetValue(v.SecName)
		row.AddCell().SetValue(v.Frequency)
		row.AddCell().SetValue(v.ClassifyName)
		row.AddCell().SetValue(v.Unit)
		row.AddCell().SetValue(v.Remark)
	}
	fileName := time.Now().Format(utils.FormatDateTimeUnSpace) + ".xlsx"
	savePath := "./static/" + fileName
	err = xlsxFile.Save(savePath)
	if err != nil {
		br.Msg = "文件保存失败"
		br.ErrMsg = "文件保存失败,Err:" + err.Error()
		return
	}
	defer func() {
		os.Remove(savePath)
	}()
	this.Ctx.Output.Download(savePath, "失败列表.xlsx")
}

// ExcelDataAdd
// @Title 复制EXCEL数据保存
// @Description 复制EXCEL数据保存
// @Param  request	body models.ExcelStyleReq true "type json string"
// @Success 200
//// @router /target/excel_style/add [post]
// func (this *TargetController) ExcelDataAdd() {
// 	br := new(models.BaseResponse).Init()
// 	var err error
// 	errs := make([]string, 0)
// 	defer func() {
// 		if len(errs) > 0 {
// 			go alarm_msg.SendAlarmMsg("新增复制EXCEL数据 新增或修改数据失败，Err："+strings.Join(errs, ","), 3)
// 		}
// 		this.Data["json"] = br
// 		this.ServeJSON()
// 	}()

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

// 	//频度
// 	//frequency := this.GetString("Frequency")
// 	//
// 	//关键字
// 	//keyword := this.GetString("Keyword")
// 	//指标编码
// 	//tradeCode := this.GetString("TradeCode")
// 	//
// 	//userId := sysUser.AdminId
// 	//超管账号可以查看分类下的所有频度数据
// 	//if sysUser.RoleTypeCode == utils.ROLE_TYPE_CODE_ADMIN {
// 	//	userId = 0
// 	//}
// 	//
// 	//list, err := models.GetExcelData()
// 	//if err != nil {
// 	//	br.ErrMsg = "获取失败，Err:" + err.Error()
// 	//	br.Msg = "获取失败"
// 	//	return
// 	//}

// 	var req data_manage.ExcelStyleReq
// 	err = json.Unmarshal(this.Ctx.Input.RequestBody, &req)
// 	if err != nil {
// 		br.Msg = "参数解析异常！"
// 		br.ErrMsg = "参数解析失败，Err:" + err.Error()
// 		return
// 	}
// 	//指标map
// 	targetMap := make(map[string]*models.Edbinfo)
// 	var cellDataList []map[string]interface{}
// 	var dataList [][]map[string]interface{}
// 	//var configList []map[string]interface{}
// 	for _, item := range req.CellData {
// 		v := item.(map[string]interface{})
// 		cellDataList = append(cellDataList, v)
// 	}

// 	valueIndex := 0

// 	var secNameList []string
// 	var frequencyList []string
// 	var unitList []string

// 	var dateList []string
// 	dateValueMap := make(map[string]map[int]string)
// 	//取到所有数据
// 	for i := range req.Data {
// 		//取到一行
// 		if i > 4 {
// 			//先拿下日期列表
// 			if req.Data[i] == nil || req.Data[i][0] == nil {
// 				continue
// 			}
// 			//fmt.Println("i:", i)
// 			//fmt.Println(req.Data[i])
// 			//fmt.Println(req.Data[i][0])
// 			dateMap := req.Data[i][0].(map[string]interface{})
// 			_, ok := dateMap["m"]
// 			if ok {
// 				dateList = append(dateList, dateMap["m"].(string))
// 				//fmt.Println("dateList:", dateList)
// 			} else {
// 				continue
// 			}
// 		}
// 		for j, dataArr := range req.Data[i] {
// 			//每一列
// 			if dataArr == nil {
// 				continue
// 			}
// 			dataMap := dataArr.(map[string]interface{})
// 			if dataList == nil {
// 				dataList = make([][]map[string]interface{}, len(req.Data))
// 			}
// 			if dataList[i] == nil {
// 				dataList[i] = make([]map[string]interface{}, len(req.Data[i]))
// 			}
// 			dataList[i][j] = dataMap
// 			//fmt.Println("dataMap", dataMap["m"])
// 			v, _ := dataMap["m"]
// 			//指标名称列表
// 			if v == "指标名称" {
// 				for nameIndex := 1; nameIndex < len(req.Data[i]); nameIndex++ {
// 					if req.Data[i][nameIndex] == nil {
// 						break
// 					}
// 					secNameMap := req.Data[i][nameIndex].(map[string]interface{})
// 					secName, _ := secNameMap["m"]
// 					if secName == nil {
// 						continue
// 					}
// 					secNameList = append(secNameList, secNameMap["m"].(string))
// 					//fmt.Println("secName:", secNameList)
// 				}
// 			}
// 			//频度列表
// 			if v == "频度" {
// 				for nameIndex := 1; nameIndex < len(req.Data[i]); nameIndex++ {
// 					if req.Data[i][nameIndex] == nil {
// 						break
// 					}
// 					frequencyMap := req.Data[i][nameIndex].(map[string]interface{})
// 					frequency, _ := frequencyMap["m"]
// 					if frequency == nil {
// 						continue
// 					}
// 					frequencyList = append(frequencyList, frequencyMap["m"].(string))
// 					//fmt.Println("frequencyList:", frequencyList)
// 				}
// 			}
// 			//单位列表
// 			if v == "单位" {
// 				for nameIndex := 1; nameIndex < len(req.Data[i]); nameIndex++ {
// 					if req.Data[i][nameIndex] == nil {
// 						break
// 					}
// 					unitMap := req.Data[i][nameIndex].(map[string]interface{})
// 					unit, _ := unitMap["m"]
// 					if unit == nil {
// 						continue
// 					}
// 					unitList = append(unitList, unitMap["m"].(string))
// 					//fmt.Println("unitList:", unitList)
// 				}
// 			}
// 			//数据列表
// 			//var valueList []string
// 			valueListMap := make(map[int]string)
// 			if i > 4 {
// 				for index := 1; index < len(req.Data[i]); index++ {
// 					if req.Data[i][index] == nil {
// 						continue
// 					}
// 					valueMap := req.Data[i][index].(map[string]interface{})
// 					value, _ := valueMap["m"]
// 					if value == nil {
// 						continue
// 					}
// 					valueListMap[index] = 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)
// 							valueListMap[index] = strconv.FormatFloat(floatValue, 'f', -1, 64)
// 						}
// 					}

// 					//valueList = append(valueList, valueMap["m"].(string))
// 					//fmt.Println("valueList:", valueList)
// 				}
// 				dateMap := req.Data[i][0].(map[string]interface{})
// 				date := dateMap["m"].(string)
// 				dateValueMap[date] = valueListMap
// 			}
// 		}

// 		//firstCell := req.Data[i][0]
// 		//if firstCell == nil {
// 		//	continue
// 		//}
// 		//dataMap := firstCell.(map[string]interface{})
// 		//if dataList == nil {
// 		//	dataList = make([][]map[string]interface{}, len(req.Data[i]))
// 		//}
// 		//if dataList[i] == nil {
// 		//	dataList[i] = make([]map[string]interface{}, len(req.Data[i]))
// 		//}
// 		//dataList[i][0] = dataMap
// 		//fmt.Println("dataMap", dataMap["m"])
// 		//v, _ := dataMap["m"]
// 		////指标名称
// 		//if v == "指标名称" {
// 		//	secNameMap := req.Data[i][1].(map[string]interface{})
// 		//	secName = secNameMap["m"].(string)
// 		//	fmt.Println("secName:", secName)
// 		//}
// 		////频度
// 		//if v == "频度" {
// 		//	frequencyMap := req.Data[i][1].(map[string]interface{})
// 		//	frequency = frequencyMap["m"].(string)
// 		//	fmt.Println("frequency:", frequency)
// 		//}
// 		////单位
// 		//if v == "单位" {
// 		//	unitMap := req.Data[i][1].(map[string]interface{})
// 		//	unit = unitMap["m"].(string)
// 		//	fmt.Println("unit:", unit)
// 		//}
// 		//
// 		////日期
// 		//dateMap := req.Data[i][1].(map[string]interface{})
// 		//createDate = dateMap["m"].(string)
// 		//
// 		////值
// 		//valueMap := req.Data[i][valueIndex].(map[string]interface{})
// 		//closeVal = valueMap["m"].(string)

// 		//新增指标
// 		//errMsg := services.AddEdbItem(secName, unit, frequency, req.ClassifyId, sysUser)
// 		//if errMsg == "" {
// 		//	br.Msg = "新增指标异常！"
// 		//	br.ErrMsg = errMsg
// 		//	return
// 		//}

// 		valueIndex++
// 	}

// 	//var excelId int64
// 	//保存EXCEL样式
// 	//{
// 	//	cellData, err := json.Marshal(cellDataList)
// 	//	if err != nil {
// 	//		br.Msg = "参数解析异常！"
// 	//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
// 	//		return
// 	//	}
// 	//	config, err := json.Marshal(req.Config)
// 	//	if err != nil {
// 	//		br.Msg = "参数解析异常！"
// 	//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
// 	//		return
// 	//	}
// 	//	datas, err := json.Marshal(dataList)
// 	//	if err != nil {
// 	//		br.Msg = "参数解析异常！"
// 	//		br.ErrMsg = "参数解析失败，Err:" + err.Error()
// 	//		return
// 	//	}
// 	//	excelItem := data_manage.ExcelStyle{
// 	//		CellData: string(cellData),
// 	//		Config:   string(config),
// 	//		Data:     string(datas),
// 	//	}
// 	//	excelId, err = models.AddExcelData(&excelItem)
// 	//	if err != nil {
// 	//		br.ErrMsg = "获取失败，Err:" + err.Error()
// 	//		br.Msg = "获取失败"
// 	//		return
// 	//	}
// 	//
// 	//	//判断映射表是否已经存在
// 	//	count, err := data_manage.GetExcelEdbdataMappingCount(req.ClassifyId, target.TradeCode, frequency)
// 	//	if err != nil {
// 	//		br.ErrMsg = "GetExcelEdbdataMappingCount，Err:" + err.Error()
// 	//		br.Msg = "新增映射表失败"
// 	//		return
// 	//	}
// 	//	mappingItem := data_manage.ExcelEdbdataMapping{
// 	//		ExcelId:    excelId,
// 	//		ClassifyId: req.ClassifyId,
// 	//		Frequency:  frequency,
// 	//		TradeCode:  target.TradeCode,
// 	//		CreateTime: time.Now(),
// 	//	}
// 	//	if count == 0{
// 	//		//新增
// 	//		err := data_manage.AddExcelEdbdataMapping(&mappingItem)
// 	//		if err != nil {
// 	//			br.ErrMsg = "AddExcelEdbdataMapping，Err:" + err.Error()
// 	//			br.Msg = "新增映射表失败"
// 	//			return
// 	//		}
// 	//	}
// 	//}

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

// 	//操作指标，新增指标及数据等
// 	{
// 		for i := 0; i < len(secNameList); i++ {
// 			//fmt.Println("len(secNameList):", len(secNameList))
// 			secName := secNameList[i]
// 			frequency := frequencyList[i]

// 			//防止填了指标名称后没填单位报错
// 			if len(unitList) < len(secNameList) {
// 				br.Msg = "单位填写异常！"
// 				br.ErrMsg = "单位填写异常！"
// 				return
// 			}
// 			unit := unitList[i]

// 			for j, s := range dateList {
// 				var closeVal string
// 				//valueList, ok := dateValueMap[s]
// 				valueMap, ok := dateValueMap[s]
// 				//fmt.Println("valueMap:", valueMap)
// 				if ok {
// 					createDate := dateList[j]
// 					//if i < len(valueList) {
// 					//	closeVal = valueList[i]
// 					//} else {
// 					//	continue
// 					//}
// 					closeVal, ok = valueMap[i+1]
// 					target, ok2 := targetMap[secName]
// 					if !ok2 {
// 						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, req.ClassifyId, sysUser.AdminId)
// 								if tmpErr != nil {
// 									//fmt.Println("AddEdbInfo err:", err.Error())
// 									utils.FileLogData.Error("AddEdbInfo err :%s", tmpErr.Error())
// 									continue
// 								}
// 								tmpTarget, tmpErr := models.GetTargetBySecName(secName)
// 								target = tmpTarget
// 								targetMap[secName] = target
// 							} else {
// 								fmt.Println("导入数据 获取指标:Err:" + err.Error())
// 							}
// 						} else {
// 							target = tmpTarget
// 							targetMap[secName] = target
// 						}
// 					}
// 					// 判断指标的顺序是否发生改变
// 					if targetMap[secName].Sort != i {
// 						edbinfo := models.Edbinfo{TradeCode: target.TradeCode, Sort: i}
// 						er := edbinfo.Update([]string{"sort"})
// 						if er != nil {
// 							fmt.Println("sort update err:", er.Error())
// 						}
// 					}

// 					//判断指标数据是否已经存在
// 					tmpDataMap, ok2 := edbCodeDataMap[target.TradeCode]
// 					if !ok2 {
// 						tmpDataMap = make(map[string]string)
// 						targetDataList, tmpErr := models.GetTargetsDataList(target.TradeCode)
// 						if tmpErr != nil {
// 							err = tmpErr
// 						}
// 						for _, tmpData := range targetDataList {
// 							tmpDataMap[tmpData.Dt] = tmpData.Close
// 						}
// 						edbCodeDataMap[target.TradeCode] = tmpDataMap
// 					}

// 					//判断数据是否已经存在
// 					tmpVal, ok3 := tmpDataMap[createDate]
// 					//数据已存在，进行更新操作
// 					if ok3 {
// 						if closeVal != "" {
// 							// 库里面的数据
// 							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(target.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)
// 								}
// 							}
// 						} else {
// 							fmt.Println("删除数值")
// 							err = models.DeleteTargetsDataByImport(target.TradeCode, createDate)
// 							if err != nil {
// 								fmt.Println("DeleteTargetsDataByImport err:", err.Error())
// 								errs = append(errs, err.Error())
// 								//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 修改数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
// 							}
// 						}

// 						if frequency != target.Frequency || unit != target.Unit || req.ClassifyId != target.ClassifyId {
// 							fmt.Println("更新指标频度或单位")
// 							err = models.ModifyEdbinfo(target.TradeCode, unit, frequency, req.ClassifyId)
// 							if err != nil {
// 								fmt.Println("EditEdbinfo err:", err.Error())
// 								return
// 							}
// 						}
// 					} else { //数据不存在，进行新增操作
// 						if target.TradeCode != "" && createDate != "" && closeVal != "" {
// 							fmt.Println("新增")
// 							models.AddTargetsDataByImport(target.TradeCode, createDate, closeVal)
// 							if err != nil {
// 								fmt.Println("AddTargetsDataByImport err:", err.Error())
// 								errs = append(errs, err.Error())
// 								//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 新增数据失败:Err:"+err.Error(), utils.EmailSendToUsers)
// 							}

// 							tmpDataMap[createDate] = closeVal
// 							edbCodeDataMap[target.TradeCode] = tmpDataMap
// 						}
// 					}

// 					//保存关联表
// 					//{
// 					//	//判断映射表是否已经存在
// 					//	count, err := data_manage.GetExcelEdbdataMappingCount(req.ClassifyId, target.TradeCode, frequency)
// 					//	if err != nil {
// 					//		br.ErrMsg = "GetExcelEdbdataMappingCount，Err:" + err.Error()
// 					//		br.Msg = "新增映射表失败"
// 					//		return
// 					//	}
// 					//	mappingItem := data_manage.ExcelEdbdataMapping{
// 					//		ExcelId:    excelId,
// 					//		ClassifyId: req.ClassifyId,
// 					//		Frequency:  frequency,
// 					//		TradeCode:  target.TradeCode,
// 					//		CreateTime: time.Now(),
// 					//	}
// 					//	if count == 0{
// 					//		//新增
// 					//		err := data_manage.AddExcelEdbdataMapping(&mappingItem)
// 					//		if err != nil {
// 					//			br.ErrMsg = "AddExcelEdbdataMapping，Err:" + err.Error()
// 					//			br.Msg = "新增映射表失败"
// 					//			return
// 					//		}
// 					//	}
// 					//}
// 				}
// 			}
// 		}

// 		list, err := models.GetTargetItemList(req.ClassifyId, 1, req.Frequency, "", "", []string{})
// 		if err != nil {
// 			br.ErrMsg = "获取失败，Err:" + err.Error()
// 			br.Msg = "获取失败"
// 			return
// 		}
// 		fmt.Println(list)
// 	}

// 	//resp := models.TargetItemListResp{
// 	//	List: list,
// 	//}
// 	br.Ret = 200
// 	br.Success = true
// 	br.Msg = "获取成功"
// 	//br.Data = resp
// 	//br.Data = list
// }

// ExcelDataAdd
// @Title 复制EXCEL数据保存
// @Description 复制EXCEL数据保存
// @Param  request	body models.ExcelStyleReq true "type json string"
// @Success 200
// @router /target/excel_style/add [post]
func (this *TargetController) ExcelDataAdd() {
	br := new(models.BaseResponse).Init()
	var err error
	errs := make([]string, 0)
	defer func() {
		if len(errs) > 0 {
			go alarm_msg.SendAlarmMsg("新增复制EXCEL数据 新增或修改数据失败，Err："+strings.Join(errs, ","), 3)
		}
		this.Data["json"] = br
		this.ServeJSON()
	}()

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

	var req data_manage.ExcelStyleReq
	err = json.Unmarshal(this.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	//指标map
	var dataList [][]map[string]interface{}

	var secNameList []string
	var frequencyList []string
	var unitList []string

	secNameToDateMap := make(map[string]map[string]string)
	//取到所有数据
	for i := range req.Data {
		//取到一行
		if i > 4 {
			//先拿下日期列表
			if req.Data[i] == nil || req.Data[i][0] == nil {
				continue
			}
			dateMap := req.Data[i][0].(map[string]interface{})
			_, ok := dateMap["m"]
			date := dateMap["m"].(string)
			if !ok {
				continue
			}
			// 存储数据
			for j := 1; j < len(req.Data[i]); j++ {
				closeVal := req.Data[i][j].(map[string]interface{})
				if item, ok := secNameToDateMap[secNameList[j-1]]; ok {
					item[date] = closeVal["m"].(string)
				} else {
					// secNameToDateMap[secNameList[j]] = make(map[string]string)
					secNameToDateMap[secNameList[j-1]] = map[string]string{
						date: closeVal["m"].(string),
					}
				}
			}

		} else {
			for j, dataArr := range req.Data[i] {
				//每一列
				if dataArr == nil {
					continue
				}
				dataMap := dataArr.(map[string]interface{})
				if dataList == nil {
					dataList = make([][]map[string]interface{}, len(req.Data))
				}
				if dataList[i] == nil {
					dataList[i] = make([]map[string]interface{}, len(req.Data[i]))
				}
				dataList[i][j] = dataMap
				//fmt.Println("dataMap", dataMap["m"])
				v, _ := dataMap["m"]
				//指标名称列表
				if v == "指标名称" {
					for nameIndex := 1; nameIndex < len(req.Data[i]); nameIndex++ {
						if req.Data[i][nameIndex] == nil {
							break
						}
						secNameMap := req.Data[i][nameIndex].(map[string]interface{})
						secName, _ := secNameMap["m"]
						if secName == nil {
							continue
						}
						secNameList = append(secNameList, secNameMap["m"].(string))
						//fmt.Println("secName:", secNameList)
					}
				}
				//频度列表
				if v == "频度" {
					for nameIndex := 1; nameIndex < len(req.Data[i]); nameIndex++ {
						if req.Data[i][nameIndex] == nil {
							break
						}
						frequencyMap := req.Data[i][nameIndex].(map[string]interface{})
						frequency, _ := frequencyMap["m"]
						if frequency == nil {
							continue
						}
						frequencyList = append(frequencyList, frequencyMap["m"].(string))
					}
				}
				//单位列表
				if v == "单位" {
					for nameIndex := 1; nameIndex < len(req.Data[i]); nameIndex++ {
						if req.Data[i][nameIndex] == nil {
							break
						}
						unitMap := req.Data[i][nameIndex].(map[string]interface{})
						unit, _ := unitMap["m"]
						if unit == nil {
							continue
						}
						unitList = append(unitList, unitMap["m"].(string))
					}
				}
			}
		}
	}

	// 所有的指标数据map
	edbCodeInfoMap := make(map[string]*models.EdbInfoItem)

	if len(frequencyList) == 0 {
		br.Ret = 200
		br.Success = true
		br.Msg = "保存成功"
		return
	}

	//获取账户所拥有权限的分类id集合
	classifyIdStrList, err := data.GetEdbClassifyListByAdminId(int64(sysUser.AdminId))
	if err != nil {
		br.Msg = "获取分类数据失败"
		return
	}
	IsVaild := 0
	for _, classifyId := range classifyIdStrList {
		if strconv.Itoa(req.ClassifyId) == classifyId {
			IsVaild += 1
		}
		if strconv.Itoa(req.OldClassifyId) == classifyId {
			IsVaild += 1
		}
	}
	if IsVaild != 2 {
		br.Msg = "操作权限不足，请检查分类操作权限"
		br.ErrMsg = "操作权限不足"
		return
	}

	// 获取当前类所有的有效指标
	list, err := models.GetTargetItemListSort(req.ClassifyId, 1, req.Frequence, "", "", classifyIdStrList)
	if err != nil {
		br.Msg = "获取指标失败"
		br.ErrMsg = "获取有效指标失败，系统错误，Err:" + err.Error()
		return
	}

	for _, item := range list {
		edbCodeInfoMap[item.SecName] = item
	}
	//历史的类别下的指标
	oldEdbCodeInfoMap := make(map[string]*models.EdbInfoItem)
	if req.ClassifyId != req.OldClassifyId || req.Frequence != req.OldFrequence {
		// 获取历史类所有的有效指标
		oldList, err := models.GetTargetItemListSort(req.OldClassifyId, 1, req.OldFrequence, "", "", classifyIdStrList)
		if err != nil {
			br.Msg = "获取指标失败"
			br.ErrMsg = "获取有效指标失败，系统错误，Err:" + err.Error()
			return
		}
		for _, item := range oldList {
			edbCodeInfoMap[item.SecName] = item
			oldEdbCodeInfoMap[item.SecName] = item
		}
	}

	// 删除历史类别下的指标及数据
	if req.TradeCode == "" {
		// TradeCode == "" 表示当前数据不是经过搜索的数据，可以进行删除指标操作
		deleteTraceCodeList := make([]string, 0)
		for k, v := range oldEdbCodeInfoMap {
			if _, ok := secNameToDateMap[k]; !ok {
				deleteTraceCodeList = append(deleteTraceCodeList, v.TradeCode)
			}
		}
		// 删除指标
		err = models.DeleteEdbinfoByTraceCodeList(deleteTraceCodeList)
		if err != nil {
			br.Msg = "excel保存失败"
			br.ErrMsg = "指标及指标数据删除失败，Err:" + err.Error()
			return
		}
	}

	// 获得需要新增的指标
	addEdbInfoList := make([]*models.Edbinfo, 0)
	sortEdbInfoList := make([]*models.Edbinfo, 0)
	for i, v := range secNameList {
		if item, ok := edbCodeInfoMap[v]; !ok {
			t := new(models.Edbinfo)
			t.SecName = v
			t.Unit = unitList[i]
			t.Remark = "手动"
			t.Frequency = frequencyList[i]
			t.ClassifyId = req.ClassifyId
			t.UserId = sysUser.AdminId
			t.Sort = len(list) + i
			addEdbInfoList = append(addEdbInfoList, t)
			edbCodeInfoMap[t.SecName] = &models.EdbInfoItem{
				TradeCode: t.TradeCode,
				SecName:   t.SecName,
				Unit:      t.Unit,
				Frequency: t.Frequency,
				UserId:    t.UserId,
			}
		} else {
			t := new(models.Edbinfo)
			t.TradeCode = item.TradeCode
			if req.Frequence != req.OldFrequence || req.ClassifyId != req.OldClassifyId {
				t.Sort = len(list) + i
			} else {
				if req.TradeCode != "" {
					// 如果是搜索的指标，那就保存原来的排序
					t.Sort = item.Sort
				} else {
					t.Sort = i
				}
			}
			t.Frequency = req.Frequence
			t.ClassifyId = req.ClassifyId
			sortEdbInfoList = append(sortEdbInfoList, t)
		}
	}
	// 更新指标频度,分类,顺序
	for _, v := range sortEdbInfoList {
		err = v.Update([]string{"frequency", "classify_id", "sort"})
		if err != nil {
			br.Msg = "excel保存失败"
			br.ErrMsg = "excel更新顺序失败，Err:" + err.Error()
			return
		}
	}
	// 新增指标
	msg, err := data.MultiAddEdbInfo(addEdbInfoList, sysUser.Mobile)
	if err != nil {
		if msg != "" {
			br.Msg = msg
		} else {
			br.Msg = "指标保存失败"
		}
		br.ErrMsg = "新增指标失败，系统错误，Err:" + err.Error()
		return
	}
	for _, v := range addEdbInfoList {
		edbCodeInfoMap[v.SecName].TradeCode = v.TradeCode
	}
	// 新增指标数据
	addEdbDataList := make([]*models.Edbdata, 0)
	for _, v := range secNameList {
		// 指标数据
		for date, closeVal := range secNameToDateMap[v] {
			t := new(models.Edbdata)
			// 理论上这里面不应该出现空值
			t.TradeCode = edbCodeInfoMap[v].TradeCode
			t.Dt = date
			t.Close = closeVal
			t.ModifyTime = time.Now()
			addEdbDataList = append(addEdbDataList, t)
		}
	}
	err = models.MultiAddEdbdata(addEdbDataList)
	if err != nil {
		br.Msg = "excel保存失败"
		br.ErrMsg = "新增指标数据失败，系统错误，Err:" + err.Error()
		return
	}

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

// ExcelDataEdit
// @Title 在线Excel编辑
// @Description 在线Excel编辑
// @Param   ClassifyId   query   string  false       "指标唯一编码"
// @Param   TradeCode   query   string  false       "指标唯一编码"
// @Param   Frequency   query   string  true       "频度"
// @Success 200
// @router /target/excel_style/edit [get]
func (this *TargetController) ExcelDataEdit() {
	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")
	classifyId, _ := this.GetInt("ClassifyId")
	frequency := this.GetString("Frequency")

	excelId, err := data_manage.GetExcelEdbdataMappingByTradeCode(classifyId, frequency)
	if err != nil {
		br.Msg = "查找关联表失败"
		br.ErrMsg = "GetExcelEdbdataMappingByTradeCode，Err:" + err.Error()
		return
	}

	item, err := data_manage.GetExcelStyleById(*excelId)
	if err != nil {
		br.Msg = "查找样式失败"
		br.ErrMsg = "GetExcelStyleById，Err:" + err.Error()
		return
	}

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