eta_api/controllers/data_manage/excel/excel_info.go

package excel

import (
	"archive/zip"
	"encoding/json"
	"eta_gn/eta_api/controllers"
	"eta_gn/eta_api/models"
	"eta_gn/eta_api/models/data_manage"
	excel3 "eta_gn/eta_api/models/data_manage/excel"
	"eta_gn/eta_api/models/data_manage/excel/request"
	"eta_gn/eta_api/models/data_manage/excel/response"
	"eta_gn/eta_api/services"
	"eta_gn/eta_api/services/data"
	"eta_gn/eta_api/services/data/data_manage_permission"
	excel2 "eta_gn/eta_api/services/data/excel"
	"eta_gn/eta_api/services/excel"
	"eta_gn/eta_api/utils"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"github.com/rdlucklib/rdluck_tools/paging"
	"github.com/shopspring/decimal"
	"github.com/yidane/formula"
)

type ExcelInfoController struct {
	controllers.BaseAuthController
}

// @router /excel_info/add [post]
func (c *ExcelInfoController) Add() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	cacheKey := "CACHE_EXCEL_TABLE_INFO_ADD_" + strconv.Itoa(sysUser.AdminId)
	defer func() {
		if deleteCache {
			_ = utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！"
		return
	}
	var req request.AddExcelInfoReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.ExcelName = strings.Trim(req.ExcelName, " ")
	if req.ExcelName == "" {
		br.Msg = "请填写表格名称！"
		br.IsSendEmail = false
		return
	}

	if req.ExcelClassifyId <= 0 && req.ParentId == 0 {
		br.Msg = "分类参数错误！"
		br.IsSendEmail = false
		return
	}

	if req.ExcelClassifyId > 0 {
		excelClassify, e := excel3.GetExcelClassifyById(req.ExcelClassifyId)
		if e != nil {
			if utils.IsErrNoRow(e) {
				br.Msg = "分类不存在"
				br.ErrMsg = "分类不存在"
				br.IsSendEmail = false
				return
			}
			br.Msg = "获取分类信息失败"
			br.ErrMsg = "获取分类信息失败，Err:" + e.Error()
			return
		}
		if excelClassify == nil {
			br.Msg = "分类不存在"
			br.ErrMsg = "分类不存在"
			br.IsSendEmail = false
			return
		}
	}

	if req.ParentId > 0 {
		parentExcelInfo, e := excel3.GetExcelInfoById(req.ParentId)
		if e != nil {
			if utils.IsErrNoRow(e) {
				br.Msg = "父级ETA表格被删除，请刷新页面"
				return
			}
			br.Msg = "获取父级ETA表格信息失败"
			br.ErrMsg = "获取父级ETA表格信息失败，Err:" + e.Error()
			return
		}
		req.ExcelClassifyId = parentExcelInfo.ExcelClassifyId
	}

	var condition string
	var pars []interface{}
	condition += " AND excel_classify_id=? AND parent_id=?"
	pars = append(pars, req.ExcelClassifyId, req.ParentId)

	condition += " AND excel_name=? "
	pars = append(pars, req.ExcelName)

	if req.Source == utils.CUSTOM_ANALYSIS_TABLE {
		condition += ` AND sys_user_id = ? `
		pars = append(pars, sysUser.AdminId)
	}

	count, err := excel3.GetExcelInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "判断表格名称是否存在失败"
		br.ErrMsg = "判断表格名称是否存在失败,Err:" + err.Error()
		return
	}
	if count > 0 {
		br.Msg = "表格名称已存在，请重新填写表格名称"
		br.IsSendEmail = false
		return
	}

	if req.Source == 0 {
		req.Source = 1
	}
	content := req.Content

	edbInfoIdList := make([]int, 0)
	if req.Source == utils.TIME_TABLE {
		jsonStrByte, err := json.Marshal(req.TableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		var tableData request.TableDataReq
		err = json.Unmarshal(jsonStrByte, &tableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}

		tableDataConfig, err := excel2.GetTableDataConfig(tableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		edbInfoIdList = tableDataConfig.EdbInfoIdList

		tableDataConfig.DecimalConfig = tableData.DecimalConfig
		contentByte, err := json.Marshal(tableDataConfig)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		content = string(contentByte)
	}

	if req.Source == 3 || req.Source == 5 {
		contentByte, err := json.Marshal(req.TableData)
		if err != nil {
			br.Msg = "自定义表格数据获取失败"
			br.ErrMsg = "自定义表格数据获取后，转json失败,Err:" + err.Error()
			return
		}
		content = string(contentByte)

		var result request.MixedTableReq
		err = json.Unmarshal(contentByte, &result)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "表格json转结构体失败，Err:" + err.Error()
			return
		}
		newResult, err, errMsg := excel2.GetMixedTableCellData(result, c.Lang)
		if err != nil {
			br.Msg = "获取失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取最新的数据失败，Err:" + err.Error()
			return
		}
		edbInfoIdMap := make(map[int]int)
		for _, tmpV := range newResult {
			for _, v := range tmpV {
				if v.EdbInfoId > 0 {
					if _, ok := edbInfoIdMap[v.EdbInfoId]; !ok {
						edbInfoIdMap[v.EdbInfoId] = v.EdbInfoId
						edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
					}
				}
			}
		}
	}

	maxSort, err := excel2.GetExcelClassifyMaxSort(req.ExcelClassifyId, req.Source)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "查询排序信息失败，Err:" + err.Error()
		return
	}

	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
	excelInfo := &excel3.ExcelInfo{
		ExcelName:          req.ExcelName,
		Source:             req.Source,
		ExcelType:          req.ExcelType,
		UniqueCode:         utils.MD5(utils.EXCEL_DATA_PREFIX + "_" + timestamp),
		ExcelClassifyId:    req.ExcelClassifyId,
		SysUserId:          sysUser.AdminId,
		SysUserRealName:    sysUser.RealName,
		Content:            content,
		ExcelImage:         req.ExcelImage,
		Sort:               maxSort + 1,
		IsDelete:           0,
		ModifyTime:         time.Now(),
		CreateTime:         time.Now(),
		ParentId:           req.ParentId,
		UpdateUserId:       sysUser.AdminId,
		UpdateUserRealName: sysUser.RealName,
		SourcesFrom:        req.SourcesFrom,
	}

	excelEdbMappingList := make([]*excel3.ExcelEdbMapping, 0)
	if len(edbInfoIdList) > 0 {
		for _, edbInfoId := range edbInfoIdList {
			excelEdbMappingList = append(excelEdbMappingList, &excel3.ExcelEdbMapping{
				Source:     excelInfo.Source,
				EdbInfoId:  edbInfoId,
				CreateTime: time.Now(),
				ModifyTime: time.Now(),
			})
		}
	}
	var childExcel *excel3.ExcelInfo
	if excelInfo.Source == utils.BALANCE_TABLE && req.ParentId == 0 && excelInfo.BalanceType == 0 { //首次创建平衡表时需要添加一个默认的子表
		timestamp = strconv.FormatInt(time.Now().UnixNano(), 10) + "_" + utils.GetRandString(10)
		childExcel = &excel3.ExcelInfo{
			ExcelName:          "平衡表",
			Source:             excelInfo.Source,
			ExcelType:          excelInfo.ExcelType,
			UniqueCode:         utils.MD5(utils.EXCEL_DATA_PREFIX + "_" + timestamp),
			ExcelClassifyId:    req.ExcelClassifyId,
			SysUserId:          sysUser.AdminId,
			SysUserRealName:    sysUser.RealName,
			Content:            excelInfo.Content,
			Sort:               excelInfo.Sort + 1,
			IsDelete:           0,
			ModifyTime:         time.Now(),
			CreateTime:         time.Now(),
			UpdateUserId:       sysUser.AdminId,
			UpdateUserRealName: sysUser.RealName,
		}
	}
	err = excel3.AddExcelInfo(excelInfo, excelEdbMappingList, childExcel)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败，Err:" + err.Error()
		return
	}

	if req.Source == 1 {
		go excel2.UpdateExcelInfoFileUrl(excelInfo)
	}
	_, err = services.UpdateExcelEditMark(excelInfo.ExcelInfoId, sysUser.AdminId, 1, sysUser.RealName)
	if err != nil {
		br.Msg = "查询标记状态失败"
		br.ErrMsg = "查询标记状态失败，Err:" + err.Error()
		return
	}
	resp := new(response.AddExcelInfoResp)
	resp.ExcelInfoId = excelInfo.ExcelInfoId
	resp.UniqueCode = excelInfo.UniqueCode

	_ = data.SaveExcelEdbInfoRelation(excelInfo.ExcelInfoId, excelInfo.Source, false)

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

// @router /excel_info/list [get]
func (c *ExcelInfoController) List() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	excelClassifyId, _ := c.GetInt("ExcelClassifyId")

	pageSize, _ := c.GetInt("PageSize")
	currentIndex, _ := c.GetInt("CurrentIndex")
	keyword := c.GetString("Keyword")
	adminId, _ := c.GetInt("AdminId")
	source, _ := c.GetInt("Source")

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

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

	var condition string
	var pars []interface{}

	if source <= 0 {
		condition += " AND source in (?,?,?) "
		pars = append(pars, utils.EXCEL_DEFAULT, utils.TIME_TABLE, utils.MIXED_TABLE)
	} else {
		condition += " AND source = ? "
		pars = append(pars, source)
		if source == utils.BALANCE_TABLE { //平衡表的列表只显示动态表的一级表（不显示子表和静态表）
			condition += " AND parent_id = 0 AND balance_type=0 "
		}
	}
	if excelClassifyId > 0 {
		_, err := excel3.GetExcelClassifyById(excelClassifyId)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "获取表格信息失败"
			br.ErrMsg = "获取信息失败,GetExcelClassify,Err:" + err.Error()
			return
		}

		childClassify, e, _ := excel2.GetChildClassifyByClassifyId(excelClassifyId, source)
		if e != nil && !utils.IsErrNoRow(e) {
			br.Msg = "获取失败"
			br.ErrMsg = "获取分类信息失败, GetEdbClassify,Err:" + e.Error()
			return
		}
		if len(childClassify) == 0 {
			condition += " AND excel_classify_id = ? "
			pars = append(pars, excelClassifyId)
		} else {
			classifyIds := []int{excelClassifyId}
			for _, v := range childClassify {
				classifyIds = append(classifyIds, v.ExcelClassifyId)
			}
			condition += fmt.Sprintf(` AND excel_classify_id IN (%s) `, utils.GetOrmInReplace(len(classifyIds)))
			pars = append(pars, classifyIds)
		}
	}
	if keyword != "" {
		condition += ` AND  ( excel_name LIKE ? )`
		pars = utils.GetLikeKeywordPars(pars, keyword, 1)
	}
	if adminId > 0 {
		condition += " AND sys_user_id = ? "
		pars = append(pars, adminId)
	}
	isShowMe, _ := c.GetBool("IsShowMe")
	permissionEdbIdList, permissionClassifyIdList, err := data_manage_permission.GetUserExcelAndClassifyPermissionList(c.SysUser.AdminId, 0, 0)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取所有有权限的指标和分类失败，Err:" + err.Error()
		return
	}
	hasCheck := make(map[int]bool)
	if isShowMe {
		if source == utils.BALANCE_TABLE { //平衡表的，显示同时需要显示协作人相关的图表
			obj := new(excel3.ExcelWorker)
			existList, err := obj.GetBySysUserId(sysUser.AdminId)
			if err != nil {
				br.Msg = "获取表格协作人失败！"
				br.ErrMsg = "获取表格协作人失败，Err:" + err.Error()
				return
			}
			var excelIds []int
			newCondition := condition
			newPars := pars
			if len(existList) > 0 {
				for _, v := range existList {
					excelIds = append(excelIds, v.ExcelInfoId)
				}
				newCondition += fmt.Sprintf(` AND  ( excel_info_id IN (%s)  or sys_user_id = ?)`, utils.GetOrmInReplace(len(excelIds)))
				newPars = append(newPars, excelIds, sysUser.AdminId)
			} else {
				newCondition += ` AND  sys_user_id = ? `
				newPars = append(newPars, sysUser.AdminId)
			}

			tmpList, e := excel3.GetNoContentExcelListByConditionNoPage(newCondition, newPars)
			if e != nil && !utils.IsErrNoRow(e) {
				br.Success = true
				br.Msg = "获取表格信息失败"
				br.ErrMsg = "获取表格信息失败,Err:" + e.Error()
				return
			}
			classifyIdListTmp := make([]int, 0)
			for _, v := range tmpList {
				classifyIdListTmp = append(classifyIdListTmp, v.ExcelClassifyId)
			}
			classifyMap := make(map[int]*excel3.ExcelClassify)

			if len(classifyIdListTmp) > 0 {
				classifyListTmp, e := excel3.GetClassifyByIdList(classifyIdListTmp)
				if e != nil {
					br.Msg = "获取表格分类信息失败"
					br.ErrMsg = "获取表格分类列表数据失败,Err:" + e.Error()
					return
				}
				for _, v := range classifyListTmp {
					classifyMap[v.ExcelClassifyId] = v
				}
			}
			excelIds = make([]int, 0)
			for _, v := range tmpList {
				if classifyInfo, ok := classifyMap[v.ExcelClassifyId]; ok {
					v.HaveOperaAuth = data_manage_permission.CheckExcelPermissionByPermissionIdList(v.IsJoinPermission, classifyInfo.IsJoinPermission, v.ExcelInfoId, v.ExcelClassifyId, permissionEdbIdList, permissionClassifyIdList)
					if v.HaveOperaAuth {
						excelIds = append(excelIds, v.ExcelInfoId)
					}
					hasCheck[v.ExcelInfoId] = v.HaveOperaAuth
				}
			}
			if len(excelIds) > 0 {
				condition += fmt.Sprintf(` AND  excel_info_id IN (%s)`, utils.GetOrmInReplace(len(excelIds)))
				pars = append(pars, excelIds)
			} else {
				list := make([]*excel3.MyExcelInfoList, 0)
				resp := response.ExcelListResp{
					Paging: page,
					List:   list,
				}
				br.Ret = 200
				br.Success = true
				br.Msg = "获取成功"
				br.Data = resp
				return
			}

		} else {
			condition += " AND sys_user_id = ? "
			pars = append(pars, sysUser.AdminId)
		}
	}
	list, err := excel3.GetNoContentExcelListByCondition(condition, pars, startSize, pageSize)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Success = true
		br.Msg = "获取表格信息失败"
		br.ErrMsg = "获取表格信息失败,Err:" + err.Error()
		return
	}

	lenList := len(list)
	if list == nil || lenList <= 0 || (err != nil && utils.IsErrNoRow(err)) {
		list = make([]*excel3.MyExcelInfoList, 0)
	}

	if lenList > 0 {
		classifyIdList := make([]int, 0)
		for _, v := range list {
			classifyIdList = append(classifyIdList, v.ExcelClassifyId)

		}
		classifyMap := make(map[int]*excel3.ExcelClassify)

		{
			classifyList, err := excel3.GetClassifyByIdList(classifyIdList)
			if err != nil {
				br.Msg = "获取表格列表信息失败"
				br.ErrMsg = "获取表格分类列表数据失败,Err:" + err.Error()
				return
			}
			for _, v := range classifyList {
				classifyMap[v.ExcelClassifyId] = v
			}
		}

		for k, v := range list {
			if authCheck, ok1 := hasCheck[v.ExcelInfoId]; ok1 {
				v.HaveOperaAuth = authCheck
			} else {
				if classifyInfo, ok := classifyMap[v.ExcelClassifyId]; ok {
					v.HaveOperaAuth = data_manage_permission.CheckExcelPermissionByPermissionIdList(v.IsJoinPermission, classifyInfo.IsJoinPermission, v.ExcelInfoId, v.ExcelClassifyId, permissionEdbIdList, permissionClassifyIdList)
				}
			}
			if v.Source == utils.BALANCE_TABLE {
				markStatus, err := services.UpdateExcelEditMark(v.ExcelInfoId, sysUser.AdminId, 2, sysUser.RealName)
				if err != nil {
					br.Msg = "查询标记状态失败"
					br.ErrMsg = "查询标记状态失败，Err:" + err.Error()
					return
				}
				if markStatus.Status == 0 {
					list[k].CanEdit = true
				} else {
					list[k].Editor = markStatus.Editor
				}

				list[k].Button = excel2.GetBalanceExcelInfoOpButton(sysUser.AdminId, v.SysUserId, v.HaveOperaAuth, v.ExcelInfoId)
			}
		}

	}

	dataCount, err := excel3.GetExcelListCountByCondition(condition, pars)
	if err != nil && !utils.IsErrNoRow(err) {
		br.Msg = "获取表格列表信息失败"
		br.ErrMsg = "获取表格列表数据总数失败,Err:" + err.Error()
		return
	}
	page = paging.GetPaging(currentIndex, pageSize, dataCount)

	resp := response.ExcelListResp{
		Paging: page,
		List:   list,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @router /excel_info/detail [get]
func (c *ExcelInfoController) Detail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	excelInfoId, _ := c.GetInt("ExcelInfoId")
	if excelInfoId <= 0 {
		br.Msg = "请选择表格"
		br.ErrMsg = "ExcelInfoId未传"
		br.IsSendEmail = false
		return
	}

	excelDetail, errMsg, err := excel2.GetExcelDetailInfoByExcelInfoId(excelInfoId, c.SysUser.AdminId, c.Lang)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}
	checkExcelInfoId := excelInfoId
	if excelDetail.Source == utils.BALANCE_TABLE {
		if excelDetail.BalanceType == 1 { // 平衡表静态表编辑状态以动态表的编辑状态为准
			checkExcelInfoId = excelDetail.RelExcelInfoId
		} else {
			if excelDetail.ParentId > 0 { //  子表编辑状态以父表的编辑状态为准
				checkExcelInfoId = excelDetail.ParentId
			}
		}
	}
	markStatus, err := services.UpdateExcelEditMark(checkExcelInfoId, sysUser.AdminId, 2, sysUser.RealName)
	if err != nil {
		br.Msg = "查询标记状态失败"
		br.ErrMsg = "查询标记状态失败，Err:" + err.Error()
		return
	}
	if markStatus.Status == 0 {
		excelDetail.CanEdit = true
	} else {
		excelDetail.Editor = markStatus.Editor
	}

	if excelDetail.Source == utils.TIME_TABLE {
		jsonStrByte, err := json.Marshal(excelDetail.TableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		var tableData request.TableDataReq
		err = json.Unmarshal(jsonStrByte, &tableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList(tableData.EdbInfoIdList)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		excelDetail.ExcelSource = strings.Join(sourceNameList, ",")
		excelDetail.ExcelSourceEn = strings.Join(sourceNameEnList, ",")

	}

	if excelDetail.Source == utils.MIXED_TABLE {
		jsonByte, e := json.Marshal(excelDetail.TableData)
		if e != nil {
			br.Msg = "刷新失败"
			br.ErrMsg = "JSON格式化混合表格数据失败, Err: " + e.Error()
			return
		}
		var tableData request.MixedTableReq
		if e = json.Unmarshal(jsonByte, &tableData); e != nil {
			br.Msg = "刷新失败"
			br.ErrMsg = "解析混合表格数据失败, Err: " + e.Error()
			return
		}
		edbInfoIds := make([]int, 0)
		edbInfoIdExist := make(map[int]bool)
		if len(tableData.Data) > 0 {
			for _, t := range tableData.Data {
				for _, v := range t {
					if v.EdbInfoId > 0 && !edbInfoIdExist[v.EdbInfoId] {
						edbInfoIdExist[v.EdbInfoId] = true
						edbInfoIds = append(edbInfoIds, v.EdbInfoId)
					}
				}
			}
		}
		sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList(edbInfoIds)
		if err != nil {
			br.Msg = "自定义表格数据获取失败"
			br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
			return
		}
		excelDetail.ExcelSource = strings.Join(sourceNameList, ",")
		excelDetail.ExcelSourceEn = strings.Join(sourceNameEnList, ",")
	}

	if excelDetail.Source != utils.BALANCE_TABLE {
		excelDetail.Button = excel2.GetExcelInfoOpButton(sysUser, excelDetail.SysUserId, excelDetail.Source, excelDetail.HaveOperaAuth)
	}

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

// @router /excel_info/edit [post]
func (c *ExcelInfoController) Edit() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	deleteCache := true
	var req request.EditExcelInfoReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ExcelInfoId <= 0 {
		br.Msg = "请传入ETA表格标识！"
		return
	}

	cacheKey := "CACHE_TABLE_INFO_EDIT_" + strconv.Itoa(req.ExcelInfoId)
	defer func() {
		if deleteCache {
			_ = utils.Rc.Delete(cacheKey)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！"
		return
	}
	req.ExcelName = strings.Trim(req.ExcelName, " ")
	if req.ExcelName == "" {
		br.Msg = "请填写表格名称！"
		br.IsSendEmail = false
		return
	}

	excelInfo, err := excel3.GetExcelInfoById(req.ExcelInfoId)
	if err != nil {
		br.Msg = "获取ETA表格失败"
		br.ErrMsg = "获取ETA表格失败,Err:" + err.Error()
		return
	}

	if req.ExcelClassifyId <= 0 && excelInfo.ParentId == 0 {
		br.Msg = "分类参数错误！"
		br.IsSendEmail = false
		return
	}

	checkExcelInfoId := excelInfo.ExcelInfoId
	checkExcelInfo := excelInfo
	if excelInfo.Source == utils.BALANCE_TABLE {
		checkExcelInfoId = excelInfo.ExcelInfoId
		if excelInfo.BalanceType == 1 {
			checkExcelInfoId = excelInfo.RelExcelInfoId
		} else {
			if excelInfo.ParentId > 0 {
				checkExcelInfoId = excelInfo.ParentId
			}
		}
		if checkExcelInfoId != excelInfo.ExcelInfoId {
			checkExcelInfo, err = excel3.GetExcelInfoById(checkExcelInfoId)
			if err != nil {
				br.Msg = "获取平衡表格信息失败"
				br.ErrMsg = "获取平衡表格信息失败，Err:" + err.Error()
				return
			}
		}
	}

	markRet, err := services.UpdateExcelEditMark(checkExcelInfoId, sysUser.AdminId, 1, sysUser.RealName)
	if err != nil {
		br.Msg = "查询标记状态失败"
		br.ErrMsg = "查询标记状态失败，Err:" + err.Error()
		return
	}
	if markRet.Status == 1 {
		br.Ret = 200
		br.Success = true
		br.Data = markRet
		return
	}
	if req.ExcelClassifyId > 0 {
		excelClassify, e := excel3.GetExcelClassifyById(req.ExcelClassifyId)
		if e != nil {
			if utils.IsErrNoRow(e) {
				br.Msg = "分类不存在"
				br.ErrMsg = "分类不存在"
				br.IsSendEmail = false
				return
			}
			br.Msg = "获取分类信息失败"
			br.ErrMsg = "获取分类信息失败，Err:" + e.Error()
			return
		}
		if excelClassify == nil {
			br.Msg = "分类不存在"
			br.ErrMsg = "分类不存在"
			br.IsSendEmail = false
			return
		}
	}
	if excelInfo.ParentId > 0 {
		parentExcelInfo, e := excel3.GetExcelInfoById(excelInfo.ParentId)
		if e != nil {
			if utils.IsErrNoRow(e) {
				br.Msg = "父级ETA表格被删除，请刷新页面"
				return
			}
			br.Msg = "获取父级ETA表格信息失败"
			br.ErrMsg = "获取父级ETA表格信息失败，Err:" + e.Error()
			return
		}
		req.ExcelClassifyId = parentExcelInfo.ExcelClassifyId
	}
	var condition string
	var pars []interface{}
	condition += " AND excel_info_id != ? "
	pars = append(pars, req.ExcelInfoId)

	condition += " AND excel_classify_id=? AND parent_id=?"
	pars = append(pars, req.ExcelClassifyId, excelInfo.ParentId)

	condition += " AND excel_name=? "
	pars = append(pars, req.ExcelName)

	count, err := excel3.GetExcelInfoCountByCondition(condition, pars)
	if err != nil {
		br.Msg = "ETA判断表格名称是否存在失败"
		br.ErrMsg = "判断ETA表格名称是否存在失败,Err:" + err.Error()
		return
	}
	if count > 0 {
		br.Msg = "ETA表格名称已存在，请重新填写"
		br.IsSendEmail = false
		return
	}

	{
		haveOperaAuth, err := data_manage_permission.CheckExcelPermissionByExcelInfoId(checkExcelInfo.ExcelInfoId, checkExcelInfo.ExcelClassifyId, checkExcelInfo.IsJoinPermission, c.SysUser.AdminId)
		if err != nil {
			br.Msg = "获取ETA表格失败"
			br.ErrMsg = "获取ETA表格权限失败,Err:" + err.Error()
			return
		}
		var button excel3.ExcelInfoDetailButton
		if checkExcelInfo.Source == utils.BALANCE_TABLE {
			button = excel2.GetBalanceExcelInfoOpButton(sysUser.AdminId, checkExcelInfo.SysUserId, haveOperaAuth, checkExcelInfo.ExcelInfoId)
		} else {
			button = excel2.GetExcelInfoOpButton(sysUser, excelInfo.SysUserId, excelInfo.Source, haveOperaAuth)
		}
		if !button.OpButton {
			br.Msg = "无操作权限"
			br.IsSendEmail = false
			return
		}
	}

	edbInfoIdList := make([]int, 0)
	content := req.Content
	contentFlag := false
	if req.Content != excelInfo.Content {
		contentFlag = true
	}
	balanceTableData := make([][]request.MixedTableCellDataReq, 0)
	switch excelInfo.Source {
	case utils.TIME_TABLE: // 自定义表格
		jsonStrByte, err := json.Marshal(req.TableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		var tableData request.TableDataReq
		err = json.Unmarshal(jsonStrByte, &tableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		edbInfoIdList = tableData.EdbInfoIdList
		tableDataConfig, err := excel2.GetTableDataConfig(tableData)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		tableDataConfig.DecimalConfig = tableData.DecimalConfig
		contentByte, err := json.Marshal(tableDataConfig)
		if err != nil {
			br.Msg = "时间序列表格数据获取失败"
			br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
			return
		}
		content = string(contentByte)
	case utils.MIXED_TABLE, utils.BALANCE_TABLE: // 混合表格, 平衡表
		contentByte, err := json.Marshal(req.TableData)
		if err != nil {
			br.Msg = "混合表格数据获取失败"
			br.ErrMsg = "混合表格数据获取后，转json失败,Err:" + err.Error()
			return
		}
		content = string(contentByte)

		var result request.MixedTableReq
		err = json.Unmarshal(contentByte, &result)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "表格json转结构体失败，Err:" + err.Error()
			return
		}
		newResult, err, errMsg := excel2.GetMixedTableCellData(result, c.Lang)
		if err != nil {
			br.Msg = "获取失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取最新的数据失败，Err:" + err.Error()
			return
		}
		balanceTableData = newResult
		edbInfoIdMap := make(map[int]int)
		for _, tmpV := range newResult {
			for _, v := range tmpV {
				if v.EdbInfoId > 0 {
					if _, ok := edbInfoIdMap[v.EdbInfoId]; !ok {
						edbInfoIdMap[v.EdbInfoId] = v.EdbInfoId
						edbInfoIdList = append(edbInfoIdList, v.EdbInfoId)
					}
				}
			}
		}
	}

	excelInfo.ModifyTime = time.Now()
	excelInfo.ExcelName = req.ExcelName
	excelInfo.ExcelType = req.ExcelType
	excelInfo.ExcelClassifyId = req.ExcelClassifyId
	excelInfo.ExcelImage = req.ExcelImage
	excelInfo.UpdateUserId = sysUser.AdminId
	excelInfo.UpdateUserRealName = sysUser.RealName
	excelInfo.Content = content
	excelInfo.SourcesFrom = req.SourcesFrom

	var updateExcelInfoParams []string
	if req.ExcelImage != "" {
		updateExcelInfoParams = []string{"ModifyTime", "ExcelName", "ExcelType", "ExcelClassifyId", "ExcelImage", "Content", "SourcesFrom"}
	} else {
		updateExcelInfoParams = []string{"ModifyTime", "ExcelName", "ExcelType", "ExcelClassifyId", "Content", "SourcesFrom"}
	}

	excelEdbMappingList := make([]*excel3.ExcelEdbMapping, 0)
	if len(edbInfoIdList) > 0 {
		for _, edbInfoId := range edbInfoIdList {
			excelEdbMappingList = append(excelEdbMappingList, &excel3.ExcelEdbMapping{
				ExcelInfoId: excelInfo.ExcelInfoId,
				Source:      excelInfo.Source,
				EdbInfoId:   edbInfoId,
				CreateTime:  time.Now(),
				ModifyTime:  time.Now(),
			})
		}
	}

	err = excel3.EditExcelInfo(excelInfo, updateExcelInfoParams, excelEdbMappingList)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败，Err:" + err.Error()
		return
	}

	if excelInfo.Source == 1 {
		go excel2.UpdateExcelInfoFileUrl(excelInfo)
	}
	if excelInfo.Source == utils.BALANCE_TABLE && excelInfo.BalanceType == 1 && contentFlag == true { //静态表更新表数据
		err = excel2.SyncBalanceEdbData(excelInfo, balanceTableData)
		if err != nil {
			br.Msg = "操作失败"
			br.ErrMsg = err.Error()
			return
		}
	}
	{
		excelDraftInfo := &excel3.ExcelDraft{
			ExcelId:    req.ExcelInfoId,
			Name:       req.ExcelName,
			Content:    content,
			OpUserId:   sysUser.AdminId,
			OpUserName: sysUser.RealName,
			CreateTime: time.Now(),
		}

		err = excel3.AddExcelDraft(excelDraftInfo)
	}

	resp := response.AddExcelInfoResp{
		ExcelInfoId: excelInfo.ExcelInfoId,
		UniqueCode:  excelInfo.UniqueCode,
	}
	_ = data.SaveExcelEdbInfoRelation(excelInfo.ExcelInfoId, excelInfo.Source, false)
	_ = utils.Rc.Delete(utils.HZ_CHART_LIB_EXCEL_TABLE_DETAIL + ":" + excelInfo.UniqueCode)

	br.Ret = 200
	br.Success = true
	br.Msg = "修改成功"
	br.Data = resp
	br.IsAddLog = true
}

// @router /excel_info/move [post]
func (c *ExcelInfoController) Move() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	br.Ret = 200
	br.Success = true
	br.IsAddLog = true
	br.Msg = "移动成功"
}

// @router /excel_info/delete [post]
func (c *ExcelInfoController) Delete() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	resp := response.AddExcelInfoResp{}

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

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

	if req.ExcelInfoId <= 0 {
		br.Msg = "参数错误"
		br.ErrMsg = "表格id小于等于0"
		br.IsSendEmail = false
		return
	}

	// 获取表格信息
	excelInfo, err := excel3.GetExcelInfoById(req.ExcelInfoId)
	if err != nil {
		br.Msg = "删除失败"
		br.ErrMsg = "获取表格信息失败,Err:" + err.Error()
		return
	}

	// 删除excel
	err, errMsg, isSendEmail := excel2.Delete(excelInfo, sysUser)
	if err != nil {
		br.Msg = "删除失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "删除失败,Err:" + err.Error()
		br.IsSendEmail = isSendEmail
		return
	}

	// 返回下一个表格的信息
	{
		var nextItem *excel3.ExcelInfo
		var condition string
		var pars []interface{}
		condition += " AND excel_classify_id=? AND parent_id=0"
		pars = append(pars, excelInfo.ExcelClassifyId)

		condition += " AND sort>=? "
		pars = append(pars, excelInfo.Sort)
		nextItem, err = excel3.GetNextExcelInfoByCondition(condition, pars)
		if err != nil && !utils.IsErrNoRow(err) {
			br.Msg = "删除失败"
			br.ErrMsg = "获取下一级表格信息失败，Err:" + err.Error()
			return
		}

		if nextItem == nil {
			currClassifyInfo, err := excel3.GetExcelClassifyById(excelInfo.ExcelClassifyId)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "删除失败"
				br.ErrMsg = "获取当前表格分类信息失败，Err:" + err.Error()
				return
			}
			nextItem, err = excel3.GetNextExcelInfo(excelInfo.ExcelClassifyId, currClassifyInfo.Sort, currClassifyInfo.Source)
			if err != nil && !utils.IsErrNoRow(err) {
				br.Msg = "删除失败"
				br.ErrMsg = "获取下一级表格信息失败，Err:" + err.Error()
				return
			}
		}

		if nextItem != nil {
			resp = response.AddExcelInfoResp{
				ExcelInfoId: nextItem.ExcelInfoId,
				UniqueCode:  nextItem.UniqueCode,
			}
		}
	}

	_ = utils.Rc.Delete(utils.HZ_CHART_LIB_EXCEL_TABLE_DETAIL)

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

// @router /excel_info/draft/add [post]
func (c *ExcelInfoController) AddDraft() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req request.AddExcelDraftReq

	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	req.ExcelName = strings.Trim(req.ExcelName, " ")
	if req.ExcelName == "" {
		br.Msg = "请填写表格名称！"
		br.IsSendEmail = false
		return
	}

	if req.ExcelClassifyId <= 0 {
		br.Msg = "分类参数错误！"
		br.IsSendEmail = false
		return
	}

	excelClassify, err := excel3.GetExcelClassifyById(req.ExcelClassifyId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			br.Msg = "分类不存在"
			br.ErrMsg = "分类不存在"
			br.IsSendEmail = false
			return
		}
		br.Msg = "获取分类信息失败"
		br.ErrMsg = "获取分类信息失败，Err:" + err.Error()
		return
	}
	if excelClassify == nil {
		br.Msg = "分类不存在"
		br.ErrMsg = "分类不存在"
		br.IsSendEmail = false
		return
	}

	var condition string
	var pars []interface{}
	condition += " AND excel_classify_id=? "
	pars = append(pars, req.ExcelClassifyId)

	condition += " AND excel_name=? "
	pars = append(pars, req.ExcelName)

	_, err = excel3.GetExcelInfoById(req.ExcelInfoId)
	if err != nil {
		br.Msg = "判断表格名称是否存在失败"
		br.ErrMsg = "判断表格名称是否存在失败,Err:" + err.Error()
		return
	}

	excelDraftInfo := &excel3.ExcelDraft{
		ExcelId:    req.ExcelInfoId,
		Name:       req.ExcelName,
		Content:    req.Content,
		OpUserId:   sysUser.AdminId,
		OpUserName: sysUser.RealName,
		CreateTime: time.Now(),
	}

	err = excel3.AddExcelDraft(excelDraftInfo)
	if err != nil {
		br.Msg = "保存失败"
		br.ErrMsg = "保存失败，Err:" + err.Error()
		return
	}

	_, err = services.UpdateExcelEditMark(req.ExcelInfoId, sysUser.AdminId, 1, sysUser.RealName)
	if err != nil {
		br.Msg = "查询标记状态失败"
		br.ErrMsg = "查询标记状态失败，Err:" + err.Error()
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "添加成功"
}

// @router /excel_info/table_data [get]
func (c *ExcelInfoController) GetExcelTableData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	uniqueCode := c.GetString("UniqueCode")
	fromScene, _ := c.GetInt("FromScene", 0)

	var err error
	if uniqueCode == `` {
		br.Msg = "请选择表格"
		br.ErrMsg = "UniqueCode未传"
		br.IsSendEmail = false
		return
	}
	excelInfo, err := excel3.GetExcelInfoByUniqueCode(uniqueCode)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取ETA表格信息失败，Err:" + err.Error()
		if utils.IsErrNoRow(err) {
			br.Msg = "ETA表格被删除，请刷新页面"
			br.ErrMsg = "ETA表格被删除，请刷新页面，Err:" + err.Error()
			br.IsSendEmail = false
		}
		return
	}

	var tableData excel.TableData
	var excelSource, excelSourceEn string
	switch excelInfo.Source {
	case utils.EXCEL_DEFAULT:
		luckySheetData, err := excel.GetLuckySheetData(excelInfo.Content)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取excel数据失败，Err:" + err.Error()
			return
		}
		tableData, err = luckySheetData.GetTableDataByLuckySheetDataStr(true)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "转换成table失败，Err:" + err.Error()
			return
		}
	case utils.TIME_TABLE:
		var tableDataConfig excel2.TableDataConfig
		err = json.Unmarshal([]byte(excelInfo.Content), &tableDataConfig)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "表格json转结构体失败，Err:" + err.Error()
			return
		}
		result, err := excel2.GetDataByTableDataConfig(tableDataConfig)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取最新的表格数据失败，Err:" + err.Error()
			return
		}
		tableData, err = excel.GetTableDataByCustomData(excelInfo.ExcelType, result, c.Lang)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "转换成table失败，Err:" + err.Error()
			return
		}
		sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList(result.EdbInfoIdList)
		if err != nil {
			br.Msg = "自定义表格数据获取失败"
			br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
			return
		}
		excelSource = strings.Join(sourceNameList, ",")
		excelSourceEn = strings.Join(sourceNameEnList, ",")
	case utils.MIXED_TABLE:
		var result request.MixedTableReq
		err = json.Unmarshal([]byte(excelInfo.Content), &result)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "表格json转结构体失败，Err:" + err.Error()
			return
		}
		newResult, err, errMsg := excel2.GetMixedTableCellData(result, c.Lang)
		if err != nil {
			br.Msg = "获取失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取最新的数据失败，Err:" + err.Error()
			return
		}
		tableData, err = excel.GetTableDataByMixedTableData(newResult, true)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "转换成table失败，Err:" + err.Error()
			return
		}
		edbInfoIds := make([]int, 0)
		edbInfoIdExist := make(map[int]bool)
		if len(newResult) > 0 {
			for _, t := range newResult {
				for _, v := range t {
					if v.EdbInfoId > 0 && !edbInfoIdExist[v.EdbInfoId] {
						edbInfoIdExist[v.EdbInfoId] = true
						edbInfoIds = append(edbInfoIds, v.EdbInfoId)
					}
				}
			}
		}
		sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList(edbInfoIds)
		if err != nil {
			br.Msg = "自定义表格数据获取失败"
			br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
			return
		}
		excelSource = strings.Join(sourceNameList, ",")
		excelSourceEn = strings.Join(sourceNameEnList, ",")
	}

	tableData = excel.HandleTableCell(tableData)
	tableData, err = excel.HandleRuleToTableCell(excelInfo.ExcelInfoId, tableData)
	if err != nil {
		utils.FileLog.Info("表格管理规则处理失败，HandleRuleToTableCell err:", err.Error())
	}
	config := response.ExcelTableDetailConfigResp{
		FontSize: 9,
	}

	// 获取配置的字体大小
	confName := models.FromSceneMap[fromScene]
	if confName != `` {
		busConf, err := models.GetBusinessConfByKey(confName)
		if err == nil {
			sizeDeci, err := decimal.NewFromString(busConf.ConfVal)
			if err == nil {
				config.FontSize = int(sizeDeci.IntPart())
			}
		}
	}

	resp := response.ExcelTableDetailResp{
		UniqueCode:    excelInfo.UniqueCode,
		ExcelImage:    excelInfo.ExcelImage,
		ExcelName:     excelInfo.ExcelName,
		TableInfo:     tableData,
		Config:        config,
		SourcesFrom:   excelInfo.SourcesFrom,
		ExcelSource:   excelSource,
		ExcelSourceEn: excelSourceEn,
		ExcelInfoId:   excelInfo.ExcelInfoId,
		Source:        excelInfo.Source,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// @router /excel_info/table/calculate [post]
func (c *ExcelInfoController) Calculate() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

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

	if req.CalculateFormula == "" {
		br.Msg = "请填写公式"
		return
	}
	calculateFormula := req.CalculateFormula
	calculateFormula = strings.TrimPrefix(calculateFormula, "=")
	calculateFormula = strings.Replace(calculateFormula, "（", "(", -1)
	calculateFormula = strings.Replace(calculateFormula, "）", ")", -1)
	calculateFormula = strings.Replace(calculateFormula, "，", ",", -1)
	calculateFormula = strings.Replace(calculateFormula, "。", ".", -1)
	calculateFormula = strings.Replace(calculateFormula, "%", "*0.01", -1)

	formulaFormStr := utils.ReplaceFormula(req.TagMap, calculateFormula)
	if formulaFormStr == `` {
		br.Msg = "公式异常"
		br.ErrMsg = "公式异常"
		return
	}

	expression := formula.NewExpression(formulaFormStr)
	calResult, err := expression.Evaluate()
	if err != nil {
		br.Msg = "计算失败"
		br.ErrMsg = "计算失败：Err:" + err.Error() + ";formulaStr:" + formulaFormStr
		if strings.Contains(err.Error(), "divide by zero") {
			br.Msg = "分母不能为0"
			br.ErrMsg = "分母不能为空，计算公式：" + formulaFormStr
			br.IsSendEmail = false
		}
		return
	}
	if calResult.IsNan() {
		br.Msg = "计算失败"
		br.ErrMsg = "计算失败：计算结果是:NAN;formulaStr:" + formulaFormStr
		return
	}
	calFloat, e := calResult.Float64()
	if e != nil {
		br.Msg = "计算失败"
		br.ErrMsg = "计算失败, Err: " + e.Error()
		return
	}
	calVal := utils.FormatTableDataShowValue(calFloat)

	br.Ret = 200
	br.Success = true
	br.Msg = "计算成功"
	br.Data = calVal
}

// @router /excel_info/table/first_edb_data_list [get]
func (c *ExcelInfoController) GetFirstEdbData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	edbInfoId, _ := c.GetInt("EdbInfoId")
	num, _ := c.GetInt("Num")
	sortType := c.GetString("SortType")

	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	if num <= 0 {
		br.Msg = "期数必须大于0"
		br.IsSendEmail = false
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取指标信息失败,Err:", err.Error())
		return
	}

	dataList, err := excel2.GetFirstEdbDataList(edbInfo, num, []string{}, -1)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
		return
	}

	if sortType == "asc" {
		for i, j := 0, len(dataList)-1; i < j; i, j = i+1, j-1 {
			dataList[i], dataList[j] = dataList[j], dataList[i]
		}
	}

	sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList([]int{edbInfoId})
	if err != nil {
		br.Msg = "自定义表格数据获取失败"
		br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
		return
	}
	excelSource := strings.Join(sourceNameList, ",")
	excelSourceEn := strings.Join(sourceNameEnList, ",")
	if len(dataList) == 0 {
		br.Msg = "指标数据异常，请检查"
		return
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = response.TableDataItem{
		EdbInfoId:     edbInfoId,
		Data:          dataList,
		Decimal:       -1,
		ExcelSource:   excelSource,
		ExcelSourceEn: excelSourceEn,
	}
}

// @router /excel_info/table/other_edb_data_list [post]
func (c *ExcelInfoController) GetOtherEdbData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

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

	if req.EdbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	if len(req.DateList) <= 0 {
		br.Msg = "请选择日期"
		br.IsSendEmail = false
		return
	}

	edbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoId)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取指标信息失败,Err:", err.Error())
		return
	}
	dataList, err := excel2.GetOtherEdbDataListFollowDate(edbInfo, req.DateList, req.DateDecimal)
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
		return
	}

	if req.SortType == "asc" {
		for i, j := 0, len(dataList)-1; i < j; i, j = i+1, j-1 {
			dataList[i], dataList[j] = dataList[j], dataList[i]
		}
	}

	sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList([]int{req.EdbInfoId})
	if err != nil {
		br.Msg = "自定义表格数据获取失败"
		br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
		return
	}
	excelSource := strings.Join(sourceNameList, ",")
	excelSourceEn := strings.Join(sourceNameEnList, ",")

	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = response.TableDataItem{
		EdbInfoId:     req.EdbInfoId,
		Data:          dataList,
		Decimal:       -1,
		ExcelSource:   excelSource,
		ExcelSourceEn: excelSourceEn,
	}
}

// @router /excel_info/table/batch_edb_data_list [post]
func (c *ExcelInfoController) GetBatchEdbData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req request.GetBatchEdbDateDataReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if len(req.EdbInfoId) == 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	tableList := make([]*response.TableDataItem, 0)
	var firstDataList []string
	for i, v := range req.EdbInfoId {
		if req.Num <= 0 {
			br.Msg = "期数必须大于0"
			br.IsSendEmail = false
			return
		}
		edbInfo, err := data_manage.GetEdbInfoById(v)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprint("获取指标信息失败,Err:", err.Error())
			return
		}
		if len(req.DateList) == 0 {
			req.Num = 12
		}
		if len(firstDataList) == 0 {
			firstDataList = req.DateList
		}
		if len(firstDataList) != 0 && len(firstDataList) != req.Num {
			req.Num = len(firstDataList)
		}
		if i == 0 {
			dataList, err := excel2.GetFirstEdbDataList(edbInfo, req.Num, firstDataList, req.Decimal[i])
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
				return
			}

			if req.SortType == "asc" {
				for i, j := 0, len(dataList)-1; i < j; i, j = i+1, j-1 {
					dataList[i], dataList[j] = dataList[j], dataList[i]
				}
			}
			dataList = excel2.PadFirstEdbDataList(dataList, req.DateList, req.SortType, req.Decimal[i])

			sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList([]int{v})
			if err != nil {
				br.Msg = "时间序列表格数据获取失败"
				br.ErrMsg = "时间序列表格数据获取失败,Err:" + err.Error()
				return
			}
			excelSource := strings.Join(sourceNameList, ",")
			excelSourceEn := strings.Join(sourceNameEnList, ",")
			if len(dataList) == 0 {
				br.Msg = "指标数据异常，请检查"
				return
			}
			tableList = append(tableList, &response.TableDataItem{
				EdbInfoId:     v,
				Data:          dataList,
				Decimal:       req.Decimal[i],
				ExcelSource:   excelSource,
				ExcelSourceEn: excelSourceEn,
			})
			if len(firstDataList) == 0 {
				tmpDataList := make([]string, 0)
				for _, v := range dataList {
					tmpDataList = append(tmpDataList, v.DataTime)
				}
				firstDataList = tmpDataList
			}
		} else {
			dataList, err := excel2.GetOtherEdbDataList(edbInfo, firstDataList, req.Decimal[i])
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
				return
			}

			if req.SortType == "asc" {
				for i, j := 0, len(dataList)-1; i < j; i, j = i+1, j-1 {
					dataList[i], dataList[j] = dataList[j], dataList[i]
				}
			}

			sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList([]int{v})
			if err != nil {
				br.Msg = "自定义表格数据获取失败"
				br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
				return
			}
			excelSource := strings.Join(sourceNameList, ",")
			excelSourceEn := strings.Join(sourceNameEnList, ",")
			tableList = append(tableList, &response.TableDataItem{
				EdbInfoId:     v,
				Decimal:       req.Decimal[i],
				Data:          dataList,
				ExcelSource:   excelSource,
				ExcelSourceEn: excelSourceEn,
			})
		}
	}

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

// @router /excel_info/table/future_date_list [post]
func (c *ExcelInfoController) GetFutureDateData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

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

	if req.StartDate == `` {
		br.Msg = "开始日期未传"
		br.IsSendEmail = false
		return
	}
	startDate, err := time.ParseInLocation(utils.FormatDate, req.StartDate, time.Local)
	if err != nil {
		br.Msg = "开始日期异常"
		br.ErrMsg = fmt.Sprint("开始日期异常,startDate:", req.StartDate, ";err:", err.Error())
		return
	}
	if len(req.EdbInfoIdList) <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	baseEdbInfo, err := data_manage.GetEdbInfoById(req.EdbInfoIdList[0])
	if err != nil {
		br.Msg = "查找指标失败"
		br.Msg = "查找指标失败,err:" + err.Error()
		return
	}

	var firstEdbDataList []*data_manage.EdbDataList
	{
		switch baseEdbInfo.EdbInfoType {
		case 0:
			firstEdbDataList, err = data_manage.GetEdbDataList(baseEdbInfo.Source, baseEdbInfo.SubSource, baseEdbInfo.EdbInfoId, req.StartDate, ``)
		case 1:
			_, firstEdbDataList, _, _, err, _ = data.GetPredictDataListByPredictEdbInfoId(baseEdbInfo.EdbInfoId, req.StartDate, ``, false)
		default:
			br.Msg = "指标类型异常"
			br.ErrMsg = fmt.Sprint("获取失败,指标类型异常", baseEdbInfo.EdbInfoType)
			br.IsSendEmail = false
			return
		}
	}
	dateList := make([]time.Time, 0)
	if req.DateType == 1 {
		num := req.Num

		i := 0 // 数据中有的日期数
		for _, v := range firstEdbDataList {
			tmpDate, err := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
			if err != nil {
				br.Msg = "结束日期异常"
				br.ErrMsg = fmt.Sprint("结束日期异常,startDate:", req.EndDate, ";err:", err.Error())
				return
			}
			if tmpDate.After(startDate) {
				dateList = append(dateList, tmpDate)
				startDate = tmpDate
				i++
			}
			if i >= num {
				break
			}
		}
		num = num - i
		if num > 0 {
			tmpDateList := utils.GetPredictEdbDayListByNum(startDate, num, baseEdbInfo.Frequency)
			dateList = append(dateList, tmpDateList...)
		}
	} else {
		if req.EndDate == `` {
			br.Msg = "结束日期未传"
			br.IsSendEmail = false
			return
		}
		endDate, err := time.ParseInLocation(utils.FormatDate, req.EndDate, time.Local)
		if err != nil {
			br.Msg = "结束日期异常"
			br.ErrMsg = fmt.Sprint("结束日期异常,startDate:", req.EndDate, ";err:", err.Error())
			return
		}
		for _, v := range firstEdbDataList {
			tmpDate, err := time.ParseInLocation(utils.FormatDate, v.DataTime, time.Local)
			if err != nil {
				br.Msg = "结束日期异常"
				br.ErrMsg = fmt.Sprint("结束日期异常,startDate:", req.EndDate, ";err:", err.Error())
				return
			}
			if tmpDate.Equal(endDate) || (tmpDate.Before(endDate) && tmpDate.After(startDate)) {
				dateList = append(dateList, tmpDate)
				startDate = tmpDate
			}
		}
		if startDate.Before(endDate) {
			tmpDateList := utils.GetPredictEdbDayListByEndDate(startDate, endDate, baseEdbInfo.Frequency)
			dateList = append(dateList, tmpDateList...)
		}
	}

	edbInfoMap := make(map[int]*data_manage.EdbInfo)
	{
		edbInfoList, err := data_manage.GetEdbInfoByIdList(req.EdbInfoIdList)
		if err != nil {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标信息失败,err:" + err.Error()
			return
		}
		for _, v := range edbInfoList {
			edbInfoMap[v.EdbInfoId] = v
		}
	}

	result := make([]response.TableDataItem, 0)
	dateStrList := make([]string, 0)
	lenDate := len(dateList)
	if lenDate > 0 {
		for i := lenDate - 1; i >= 0; i-- {
			dateStrList = append(dateStrList, dateList[i].Format(utils.FormatDate))
		}
		for j, v := range req.EdbInfoIdList {
			tmpEdbInfo, ok := edbInfoMap[v]
			if !ok {
				br.Msg = "获取指标信息失败"
				br.ErrMsg = "获取指标信息失败,err:" + err.Error()
				return
			}

			dataList, err := excel2.GetOtherEdbDataList(tmpEdbInfo, dateStrList, req.Decimal[j])
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
				return
			}
			result = append(result, response.TableDataItem{
				EdbInfoId: v,
				Decimal:   req.Decimal[j],
				Data:      dataList,
			})
		}
	}

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

// @router /excel_info/table/history_date_list [post]
func (c *ExcelInfoController) GetHistoryDateData() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

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

	if req.EndDate == `` {
		br.Msg = "结束日期未传"
		br.IsSendEmail = false
		return
	}
	if len(req.EdbInfoIdList) <= 0 {
		br.Msg = "请选择指标"
		br.IsSendEmail = false
		return
	}

	edbInfoMap := make(map[int]*data_manage.EdbInfo)
	{
		edbInfoList, err := data_manage.GetEdbInfoByIdList(req.EdbInfoIdList)
		if err != nil {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标信息失败,err:" + err.Error()
			return
		}
		for _, v := range edbInfoList {
			edbInfoMap[v.EdbInfoId] = v
		}
	}

	result := make([]response.TableDataItem, 0)
	dateStrList := make([]string, 0)

	{
		tmpEdbInfo, ok := edbInfoMap[req.EdbInfoIdList[0]]
		if !ok {
			br.Msg = "获取指标信息失败"
			br.ErrMsg = "获取指标信息失败,err:" + err.Error()
			return
		}
		firstDataList, err := excel2.GetFirstHistoryEdbDataList(tmpEdbInfo, req.Num, req.EndDate, req.Decimal[0])
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
			return
		}

		result = append(result, response.TableDataItem{
			EdbInfoId: req.EdbInfoIdList[0],
			Decimal:   req.Decimal[0],
			Data:      firstDataList,
		})

		for _, v := range firstDataList {
			dateStrList = append(dateStrList, v.DataTime)
		}
	}

	if len(dateStrList) > 0 {
		for k, v := range req.EdbInfoIdList {
			if k == 0 {
				continue
			}
			tmpEdbInfo, ok := edbInfoMap[v]
			if !ok {
				br.Msg = "获取指标信息失败"
				br.ErrMsg = "获取指标信息失败,err:" + err.Error()
				return
			}

			dataList, err := excel2.GetOtherEdbDataList(tmpEdbInfo, dateStrList, req.Decimal[k])
			if err != nil {
				br.Msg = "获取失败"
				br.ErrMsg = fmt.Sprint("获取失败,Err:", err.Error())
				return
			}
			result = append(result, response.TableDataItem{
				EdbInfoId: v,
				Decimal:   req.Decimal[k],
				Data:      dataList,
			})
		}
	}

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

// @router /excel_info/table/refresh [get]
func (c *ExcelInfoController) Refresh() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		c.Data["json"] = br
		c.ServeJSON()
	}()

	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	excelInfoId, _ := c.GetInt("ExcelInfoId")
	chartInfoId, _ := c.GetInt("ChartInfoId")
	if excelInfoId <= 0 && chartInfoId <= 0 {
		br.Msg = "请选择表格"
		br.ErrMsg = "ExcelInfoId未传"
		br.IsSendEmail = false
		return
	}

	if chartInfoId > 0 && excelInfoId == 0 {
		excelInfo, err := excel3.GetExcelInfoByChartInfoId(chartInfoId)
		if err != nil {
			br.Msg = "请选择表格"
			br.ErrMsg = "未找到对应的表格"
			br.IsSendEmail = false
			return
		}
		excelInfoId = excelInfo.ExcelInfoId
	}
	excelDetail, errMsg, err := excel2.GetExcelDetailInfoByExcelInfoId(excelInfoId, c.SysUser.AdminId, c.Lang)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = err.Error()
		return
	}

	{
		button := excelDetail.Button
		if excelDetail.Source != utils.BALANCE_TABLE {
			button = excel2.GetExcelInfoOpButton(sysUser, excelDetail.SysUserId, excelDetail.Source, excelDetail.HaveOperaAuth)
		}
		if !button.RefreshButton {
			br.Msg = "无操作权限"
			br.IsSendEmail = false
			return
		}
	}

	if excelDetail.Source == utils.TIME_TABLE {
		jsonStrByte, err := json.Marshal(excelDetail.TableData)
		if err != nil {
			br.Msg = "自定义表格数据获取失败"
			br.ErrMsg = "自定义表格数据获取失败,转json失败，Err:" + err.Error()
			return
		}
		var tableData request.TableDataReq
		err = json.Unmarshal(jsonStrByte, &tableData)
		if err != nil {
			br.Msg = "自定义表格数据获取失败"
			br.ErrMsg = "自定义表格数据获取失败,json转结构体失败，Err:" + err.Error()
			return
		}

		if len(tableData.EdbInfoIdList) > 0 {
			err, _ = data.EdbInfoRefreshAllFromBaseV3(tableData.EdbInfoIdList, false, true, false)
			if err != nil {
				br.Msg = "刷新失败"
				br.ErrMsg = "刷新失败,Err:" + err.Error()
				return
			}
		}
	}

	if excelDetail.Source == utils.MIXED_TABLE {
		jsonByte, e := json.Marshal(excelDetail.TableData)
		if e != nil {
			br.Msg = "刷新失败"
			br.ErrMsg = "JSON格式化混合表格数据失败, Err: " + e.Error()
			return
		}
		var tableData request.MixedTableReq
		if e = json.Unmarshal(jsonByte, &tableData); e != nil {
			br.Msg = "刷新失败"
			br.ErrMsg = "解析混合表格数据失败, Err: " + e.Error()
			return
		}
		edbInfoIds := make([]int, 0)
		edbInfoIdExist := make(map[int]bool)
		if len(tableData.Data) > 0 {
			for _, t := range tableData.Data {
				for _, v := range t {
					if v.EdbInfoId > 0 && !edbInfoIdExist[v.EdbInfoId] {
						edbInfoIdExist[v.EdbInfoId] = true
						edbInfoIds = append(edbInfoIds, v.EdbInfoId)
					}
				}
			}
		}
		if len(edbInfoIds) > 0 {
			e, _ = data.EdbInfoRefreshAllFromBaseV3(edbInfoIds, false, true, false)
			if e != nil {
				br.Msg = "刷新失败"
				br.ErrMsg = "刷新混合表格数据失败, Err: " + err.Error()
				return
			}
		}
	}

	if excelDetail.Source == utils.BALANCE_TABLE {
		err = refreshBalanceTable(excelDetail, c.Lang)
		if err != nil {
			br.Msg = "刷新失败"
			br.ErrMsg = "刷新失败,Err:" + err.Error()
			return
		}
	}
	key := utils.HZ_CHART_LIB_EXCEL_TABLE_DETAIL + ":" + excelDetail.UniqueCode
	if utils.Re == nil {
		_ = utils.Rc.Delete(key)
	}

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

// @router /excel_info/table/download [get]
func (c *ExcelInfoController) Download() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	excelInfoId, _ := c.GetInt("ExcelInfoId")
	uniqueCode := c.GetString("UniqueCode")
	if excelInfoId <= 0 && uniqueCode == `` {
		br.Msg = "请选择表格"
		br.ErrMsg = "ExcelInfoId和UniqueCode都未传"
		br.IsSendEmail = false
		return
	}
	var excelInfo *excel3.ExcelInfo
	var err error
	if excelInfoId > 0 {
		excelInfo, err = excel3.GetExcelInfoById(excelInfoId)
	} else {
		excelInfo, err = excel3.GetExcelInfoByUniqueCode(uniqueCode)
	}
	if err != nil {
		br.Msg = "获取失败"
		br.ErrMsg = "获取ETA表格信息失败，Err:" + err.Error()
		if utils.IsErrNoRow(err) {
			br.Msg = "ETA表格被删除，请刷新页面"
			br.ErrMsg = "ETA表格被删除，请刷新页面，Err:" + err.Error()
			br.IsSendEmail = false
		}
		return
	}

	if excelInfo.Source == 1 {
		br.Msg = "不是自定义表格"
		br.IsSendEmail = false
		return
	}

	var tableData excel.TableData
	switch excelInfo.Source {
	case utils.EXCEL_DEFAULT:
		br.Msg = "表格类型异常"
	case utils.TIME_TABLE: // 自定义表格
		var tableDataConfig excel2.TableDataConfig
		err = json.Unmarshal([]byte(excelInfo.Content), &tableDataConfig)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "表格json转结构体失败，Err:" + err.Error()
			return
		}
		result, err := excel2.GetDataByTableDataConfig(tableDataConfig)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "获取最新的表格数据失败，Err:" + err.Error()
			return
		}
		tableData, err = excel.GetTableDataByCustomData(excelInfo.ExcelType, result, c.Lang)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "转换成table失败，Err:" + err.Error()
			return
		}
	case utils.MIXED_TABLE: // 混合表格
		var result request.MixedTableReq
		err = json.Unmarshal([]byte(excelInfo.Content), &result)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "表格json转结构体失败，Err:" + err.Error()
			return
		}
		newResult, err, errMsg := excel2.GetMixedTableCellData(result, c.Lang)
		if err != nil {
			br.Msg = "获取失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取最新的数据失败，Err:" + err.Error()
			return
		}
		tableData, err = excel.GetTableDataByMixedTableData(newResult, false)
		if err != nil {
			br.Msg = "获取失败"
			br.ErrMsg = "转换成table失败，Err:" + err.Error()
			return
		}
	case utils.BALANCE_TABLE: // 混合表格
		savePath, fileName, uploadDir, err, errMsg := downloadBalanceTable(excelInfo, c.Lang)
		if err != nil {
			br.Msg = "下载失败"
			if errMsg != `` {
				br.Msg = errMsg
			}
			br.ErrMsg = "获取最新的数据失败，Err:" + err.Error()
			return
		}
		defer func() {
			_ = os.RemoveAll(uploadDir)
		}()
		c.Ctx.Output.Download(savePath, fileName)
		br.Ret = 200
		br.Success = true
		br.Msg = "获取成功"
		br.Data = excelInfo
		return
	}

	downloadFilePath, err := tableData.ToExcel()
	if err != nil {
		fmt.Println("err:", err)
		return
	}
	defer func() {
		_ = os.Remove(downloadFilePath)
	}()

	downloadFileName := excelInfo.ExcelName + ".xlsx"
	c.Ctx.Output.Download(downloadFilePath, downloadFileName)

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

// @router /excel_info/copy [post]
func (c *ExcelInfoController) Copy() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}

	var req request.CopyExcelInfoReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ExcelInfoId <= 0 {
		br.Msg = "请传入ETA表格标识！"
		return
	}

	cacheKey := "CACHE_TABLE_INFO_EDIT_" + strconv.Itoa(req.ExcelInfoId)
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		br.Msg = "系统处理中，请稍后重试！"
		br.ErrMsg = "系统处理中，请稍后重试！"
		return
	}
	defer func() {
		_ = utils.Rc.Delete(cacheKey)
	}()

	req.ExcelName = strings.Trim(req.ExcelName, " ")
	if req.ExcelName == "" {
		br.Msg = "请填写表格名称！"
		br.IsSendEmail = false
		return
	}

	if req.ExcelClassifyId <= 0 {
		br.Msg = "分类参数错误！"
		br.IsSendEmail = false
		return
	}
	oldExcelInfo, err := excel3.GetExcelInfoById(req.ExcelInfoId)
	if err != nil {
		br.Msg = "获取ETA表格失败"
		return
	}
	var (
		excelInfo   *excel3.ExcelInfo
		errMsg      string
		isSendEmail bool
	)
	if oldExcelInfo.Source == utils.BALANCE_TABLE {
		excelInfo, err, errMsg, isSendEmail = data.CopyBalanceExcel(oldExcelInfo, req.ExcelClassifyId, req.ExcelName, sysUser)
	} else {
		excelInfo, err, errMsg, isSendEmail = excel2.Copy(oldExcelInfo, req.ExcelClassifyId, req.ExcelName, sysUser)
	}
	if err != nil {
		br.Msg = "复制失败"
		if errMsg != `` {
			br.Msg = errMsg
		}
		br.ErrMsg = "复制失败,Err:" + err.Error()
		br.IsSendEmail = isSendEmail
		return
	}
	_ = data.SaveExcelEdbInfoRelation(excelInfo.ExcelInfoId, excelInfo.Source, true)

	resp := new(response.AddExcelInfoResp)
	resp.ExcelInfoId = excelInfo.ExcelInfoId
	resp.UniqueCode = excelInfo.UniqueCode

	br.Ret = 200
	br.Success = true
	br.Msg = "保存成功"
	br.Data = resp
	br.IsAddLog = true
}
func decompressZip(src string) error {
	archive, err := zip.OpenReader(src)
	if err != nil {
		return err
	}
	dir := filepath.Dir(src) + "/zip"
	defer archive.Close()
	for _, f := range archive.File {
		filePath := filepath.Join(dir, f.Name)
		if f.FileInfo().IsDir() {
			os.MkdirAll(filePath, os.ModePerm)
			continue
		}
		if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
			return fmt.Errorf("failed to make directory (%v)", err)
		}
		dstFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
		if err != nil {
			return fmt.Errorf("failed to create file (%v)", err)
		}
		fileInArchive, err := f.Open()
		if err != nil {
			return fmt.Errorf("failed to open file in zip (%v)", err)
		}
		if _, err := io.Copy(dstFile, fileInArchive); err != nil {
			return fmt.Errorf("failed to copy file in zip (%v)", err)
		}
		dstFile.Close()
		fileInArchive.Close()
	}
	return nil
}

// @router /excel_info/mark [post]
func (c *ExcelInfoController) MarkEditStatus() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.MarkEditExcel
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.ExcelInfoId <= 0 {
		br.Msg = "缺少表格编号"
		return
	}
	if req.Status <= 0 {
		br.Msg = "标记状态异常"
		return
	}

	status := 1
	if req.Status == 2 {
		status = 0
	}
	data, err := services.UpdateExcelEditMark(req.ExcelInfoId, sysUser.AdminId, status, sysUser.RealName)
	if err != nil {
		br.Msg = err.Error()
		return
	}

	msg := "标记成功"
	br.Ret = 200
	br.Success = true
	br.Msg = msg
	br.Data = data
}

// @router /excel_info/table/batch_refresh [post]
func (c *ExcelInfoController) BatchRefresh() {
	br := new(models.BaseResponse).Init()
	defer func() {
		if br.ErrMsg == "" {
			br.IsSendEmail = false
		}
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req excel3.BatchRefreshExcelReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if len(req.ExcelCodes) == 0 {
		br.Ret = 200
		br.Success = true
		br.Msg = "刷新成功"
		return
	}
	if req.Source == "" {
		br.Msg = "刷新来源有误"
		return
	}
	if req.PrimaryId <= 0 {
		br.Msg = "刷新对象有误"
		return
	}

	edbIds, e := excel2.GetEdbIdsFromExcelCodes(req.ExcelCodes, sysUser.AdminId, c.Lang)
	if e != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "获取表格关联的指标IDs失败, Err: " + e.Error()
		return
	}

	redisKey := data.GetBatchChartRefreshKey(req.Source, req.PrimaryId, req.SubId)
	refreshKeys := make([]string, 0)
	for _, v := range req.ExcelCodes {
		refreshKeys = append(refreshKeys, fmt.Sprint(utils.HZ_CHART_LIB_EXCEL_TABLE_DETAIL, v))
	}

	syncing, e := data.BatchRefreshEdbByEdbIds(edbIds, redisKey, refreshKeys)
	if e != nil {
		br.Msg = "刷新失败"
		br.ErrMsg = "刷新表格关联指标信息失败，Err:" + err.Error()
		return
	}

	br.Msg = "刷新成功"
	if syncing {
		br.Msg = "表格关联指标较多，请10分钟后刷新页面查看最新数据"
	}
	br.Ret = 200
	br.Success = true
}

// @router /excel_info/table/batch_refresh/result [post]
func (c *ExcelInfoController) GetBatchChartRefreshResult() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req excel3.BatchRefreshExcelReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.Source == "" {
		br.Msg = "刷新来源有误"
		return
	}
	if req.PrimaryId <= 0 {
		br.Msg = "刷新对象有误"
		return
	}

	result := true
	redisKey := excel2.GetExcelEdbBatchRefreshKey(req.Source, req.PrimaryId, req.SubId)
	if redisKey != `` {
		ok := utils.Rc.IsExist(redisKey)
		if ok {
			result = false
		}
	}

	resp := struct {
		RefreshResult bool `description:"刷新结果"`
	}{
		RefreshResult: result,
	}
	br.Data = resp
	br.Ret = 200
	br.Success = true
}

// @router /excel_info/get_edb_source [get]
func (c *ExcelInfoController) GetEdbSource() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	edbInfoId, _ := c.GetInt("EdbInfoId")
	if edbInfoId <= 0 {
		br.Msg = "请选择指标"
		br.ErrMsg = "请选择指标"
		br.IsSendEmail = false
		return
	}
	sourceNameList, sourceNameEnList, err := excel2.GetEdbSourceByEdbInfoIdList([]int{edbInfoId})
	if err != nil {
		br.Msg = "自定义表格数据获取失败"
		br.ErrMsg = "自定义表格数据获取失败,Err:" + err.Error()
		return
	}
	excelSource := strings.Join(sourceNameList, ",")
	excelSourceEn := strings.Join(sourceNameEnList, ",")

	var resp struct {
		ExcelSource   string `description:"表格来源"`
		ExcelSourceEn string `description:"表格来源（英文）"`
	}

	resp.ExcelSource = excelSource
	resp.ExcelSourceEn = excelSourceEn

	br.Data = resp
	br.Ret = 200
	br.Success = true
}

// @router /excel_info/rule/add [post]
func (c *ExcelInfoController) AddExcelRule() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req *request.ExcelRuleMappingReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.LeftValue == "" {
		br.Msg = "条件值不能为空"
		return
	}
	if req.Scope == "" {
		br.Msg = "应用选区不能为空"
		return
	}
	if req.FontColor == "" && req.BackgroundColor == "" {
		br.Msg = "字体颜色和背景颜色不能同时为空"
		return
	}
	if req.RuleType == 3 && req.RightValue == "" {
		br.Msg = "条件值不能为空"
		return
	}
	err = excel2.AddExcelRule(req, c.Lang)
	if err != nil {
		br.Msg = "规则添加失败"
		br.ErrMsg = "规则添加失败，Err:" + err.Error()
		return
	}
	br.Msg = "添加成功"
	br.Ret = 200
	br.Success = true
}

// @router /excel_info/rule/edit [post]
func (c *ExcelInfoController) EditExcelRule() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req *request.ExcelRuleMappingReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.LeftValue == "" {
		br.Msg = "条件值不能为空"
		return
	}
	if req.Scope == "" {
		br.Msg = "应用选区不能为空"
		return
	}
	if req.FontColor == "" {
		br.Msg = "字体颜色不能为空"
		return
	}
	if req.BackgroundColor == "" {
		br.Msg = "背景颜色不能为空"
		return
	}
	if req.RuleType == 3 && req.RightValue == "" {
		br.Msg = "条件值不能为空"
		return
	}
	if req.ExcelRuleMappingId <= 0 {
		br.Msg = "非法的管理规则ID"
		return
	}
	err = excel2.ModifyExcelRule(req, c.Lang)
	if err != nil {
		br.Msg = "规则编辑失败"
		br.ErrMsg = "规则编辑失败，Err:" + err.Error()
		return
	}
	br.Msg = "编辑成功"
	br.Ret = 200
	br.Success = true
}

// @router /excel_info/rule/delete [post]
func (c *ExcelInfoController) DeleteExcelRule() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req request.DeleteExcelRuleMappingReq
	err := json.Unmarshal(c.Ctx.Input.RequestBody, &req)
	if err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.ExcelRuleMappingId <= 0 {
		br.Msg = "非法的管理规则ID"
		return
	}
	err = excel3.DeleteExcelRuleMappingById(req.ExcelRuleMappingId)
	if err != nil {
		br.Msg = "规则删除失败"
		br.ErrMsg = "规则删除失败，Err:" + err.Error()
		return
	}
	br.Msg = "删除成功"
	br.Ret = 200
	br.Success = true
}

// @router /excel_info/rule/list [get]
func (c *ExcelInfoController) GetExcelRuleList() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	ExcelInfoId, _ := c.GetInt("ExcelInfoId")

	if ExcelInfoId <= 0 {
		br.Msg = "请选择表格"
		return
	}

	items, err := excel2.GetExcelRuleList(ExcelInfoId)
	if err != nil {
		br.Msg = "管理规则编辑失败"
		br.ErrMsg = "管理规则添加失败，Err:" + err.Error()
		return
	}
	if items.List == nil {
		items.List = []*excel3.ExcelInfoRuleMappingView{}
	}

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

// @router /excel_info/rule/detail [get]
func (c *ExcelInfoController) GetExcelRuleDetail() {
	br := new(models.BaseResponse).Init()
	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()
	sysUser := c.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	excelInfoRuleMappingId, _ := c.GetInt("ExcelInfoRuleMappingId")

	items, err := excel2.GetExcelRuleDetail(excelInfoRuleMappingId)
	if err != nil {
		br.Msg = "管理规则编辑失败"
		br.ErrMsg = "管理规则添加失败，Err:" + err.Error()
		return
	}

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