eta_mobile/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_mobile/models"
	"eta/eta_mobile/models/data_manage"
	"eta/eta_mobile/models/data_source"
	"eta/eta_mobile/models/system"
	"eta/eta_mobile/services/alarm_msg"
	"eta/eta_mobile/services/data"
	"eta/eta_mobile/utils"
	"fmt"
	"github.com/rdlucklib/rdluck_tools/paging"
	"github.com/shopspring/decimal"
	"github.com/tealeg/xlsx"
	"os"
	"path/filepath"
	"reflect"
	"sort"
	"strconv"
	"strings"
	"time"
)

// 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
	}
	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)
			}
		}
	}
	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)
	for _, trade := range req.List {
		if trade.TradeCode == "" {
			br.Msg = "指标编码不可为空！"
			return
		}

		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
	}
	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 = "下载成功"
}

// 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 != "品种分类" {
					templateFail = true
				}
				if cells[1].Value != "录入日期" {
					templateFail = true
				}
				if cells[2].Value != "指标名称" {
					templateFail = true
				}
				if cells[3].Value != "值" {
					templateFail = true
				}
				if cells[4].Value != "频度" {
					templateFail = true
				}
				if cells[5].Value != "单位" {
					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
					}
					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)

					//校验表格中的日期格式
					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) //录入日期
					}

					//获取指标分类信息
					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()
	sheet, err := xlsxFile.AddSheet("导入失败数据")
	headRow := sheet.AddRow()
	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().SetValue(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)
	}()
	this.Ctx.Output.Download(savePath, "失败列表.xlsx")
}

// 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
	}
	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.GetTargetItemList(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
						}
					}

					//判断指标数据是否已经存在
					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
					//		}
					//	}
					//}
				}
			}
		}
	}

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

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