eta_api/controllers/data_stat/edb_terminal.go

package data_stat

import (
	"encoding/json"
	"eta/eta_api/controllers"
	"eta/eta_api/models"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/services/data_stat"
	"eta/eta_api/utils"
	"fmt"
	"strconv"

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

// EdbTerminalController 数据源终端管理
type EdbTerminalController struct {
	controllers.BaseAuthController
}

// Save
// @Title 保存数据源终端
// @Description 保存数据源终端接口
// @Param	request  body  true data_manage.AddEdbTerminalListReq  "type json string"
// @Success 200 string "操作成功"
// @router /terminal/save [post]
func (this *EdbTerminalController) Save() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req *data_manage.AddEdbTerminalListReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.Name == "" {
		br.Msg = "请输入终端名称"
		return
	}
	/*if req.ServerUrl == "" && req.Value == "" {
		br.Msg = "请输入终端地址或者token"
		return
	}*/
	// if req.Num <= 0 {
	// 	br.Msg = "请输入指标数据量"
	// 	return
	// }
	if req.Source == 0 {
		br.Msg = "请输入终端类型"
		return
	}

	// todo 校验终端数据

	errMsg, err := data_stat.SaveEdbTerminal(req)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = "SaveEnglishVideoCover ErrMsg:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	return
}

// SetStatus
// @Title 启用/禁用数据源终端
// @Description 启用/禁用数据源终端
// @Param	request  body  true data_manage.SetEdbTerminalStatusReq  "type json string"
// @Success 200 string "操作成功"
// @router /terminal/status/set [post]
func (this *EdbTerminalController) SetStatus() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	var req *data_manage.SetEdbTerminalStatusReq
	if err := json.Unmarshal(this.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}
	if req.TerminalId <= 0 {
		br.Msg = "请选择要操作的终端"
		return
	}

	if req.Status != 1 && req.Status != 2 {
		br.Msg = "请选择正确的终端状态"
		return
	}

	errMsg, err := data_stat.SetEdbTerminalStatus(req.TerminalId, req.Status)
	if err != nil {
		br.Msg = errMsg
		br.ErrMsg = "SetEdbTerminalStatus ErrMsg:" + err.Error()
		return
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "操作成功"
	return
}

// List
// @Title 数据源终端列表
// @Description 数据源终端列表接口
// @Success 200 {object} data_manage.EdbTerminalLisResp
// @router /terminal/list [get]
func (this *EdbTerminalController) List() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()   
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	source, _ := this.GetInt("Source")

	list, err := data_manage.GetEdbTerminalList(source)
	if err != nil {
		br.Msg = "获取终端列表失败"
		br.ErrMsg = "获取终端列表失败 ErrMsg:" + err.Error()
		return
	}

	// 计算已使用额度
	// 根据source查找对应的终端信息，比如source为34，则查询对应的数据源里的指标
	// 获取数据源详细信息
	for _, v := range list {
		num, subNumList, err := data_manage.GetIndexNumBySource(v.Source, v.TerminalCode)
		if err != nil {
			br.Msg = "获取终端列表失败"
			br.ErrMsg = "获取终端列表失败 ErrMsg:" + err.Error()
			return
		}
		v.UsedQuota = strconv.Itoa(num)
		if v.Source == utils.DATA_SOURCE_THS {
			edbNum := 0
			dateNum := 0
			hfNum := 0
			for _, subNum := range subNumList {
				if subNum.SubSource == utils.DATA_SUB_SOURCE_HIGH_FREQUENCY {
					hfNum = subNum.Num
				} else if subNum.SubSource == utils.DATA_SUB_SOURCE_EDB {
					edbNum = subNum.Num
				} else if subNum.SubSource == utils.DATA_SUB_SOURCE_DATE {
					dateNum = subNum.Num
				}
			}
			v.UsedQuota = fmt.Sprintf("EDB:%d\n日期序列:%d\n高频序列:%d", edbNum, dateNum, hfNum)
		}else if v.Source == utils.DATA_SOURCE_WIND {
			edbNum := 0
			dateNum := 0
			for _, subNum := range subNumList {
				if subNum.SubSource == utils.DATA_SUB_SOURCE_EDB {
					edbNum = subNum.Num
				} else if subNum.SubSource == utils.DATA_SUB_SOURCE_DATE {
					dateNum = subNum.Num
				}
			}
			v.UsedQuota = fmt.Sprintf("EDB:%d\n日期序列:%d", edbNum, dateNum)
		}else if len(subNumList) == 1 {
			v.UsedQuota = strconv.Itoa(subNumList[0].Num)
		}
	}

	resp := &data_manage.EdbTerminalListResp{
		List: list,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// TerminalCodeList
// @Title 数据源终端列表
// @Description 数据源终端列表接口
// @Success 200 {object} data_manage.EdbTerminalCodeResp
// @router /terminal/code [get]
func (this *EdbTerminalController) TerminalCodeList() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	source, _ := this.GetInt("Source", utils.DATA_SOURCE_MYSTEEL_CHEMICAL)
	isApi, _ := this.GetInt("IsApi", 0)
	list, err := data_manage.GetEdbTerminalBySourceAndIsApi(source, isApi)
	if err != nil {
		br.Msg = "获取终端列表失败"
		br.ErrMsg = "获取终端列表失败 ErrMsg:" + err.Error()
		return
	}
	codeList := make([]*data_manage.EdbTerminalCode, 0)
	if len(list) > 0 {
		for _, v := range list {
			tmp := new(data_manage.EdbTerminalCode)
			tmp.TerminalCode = v.TerminalCode
			tmp.Source = v.Source
			tmp.Name = v.Name
			codeList = append(codeList, tmp)
		}
	}
	resp := &data_manage.EdbTerminalCodeResp{
		List: codeList,
	}
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = resp
}

// TerminalIndexDirInfo
// @Title 获取指标终端文件夹信息
// @Description 获取指标终端文件夹信息
// @Success 200 {object} data_manage.EdbTerminalDirInfo
// @router /terminal/index_dir [get]
func (this *EdbTerminalController) TerminalIndexDirInfo() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	defer func() {
		this.Data["json"] = br
		this.ServeJSON()
	}()
	sysUser := this.SysUser
	if sysUser == nil {
		br.Msg = "请登录"
		br.ErrMsg = "请登录，SysUser Is Empty"
		br.Ret = 408
		return
	}
	source, _ := this.GetInt("Source")
	indexId, _ := this.GetInt("IndexId")
	if source <= 0 || indexId <= 0 {
		br.Msg = "请选择数据源和指标ID"
		return
	}
	info := new(data_manage.EdbTerminalDirInfo)
	var err error
	info, err = data_stat.GetEdbTerminalDirInfo(indexId, source)
	if err != nil {
		utils.FileLog.Info(fmt.Sprintf("获取终端文件夹信息失败indexId:%d,source:%d,Err:%s", indexId, source, err.Error()))
		//br.Msg = "获取终端文件夹信息失败"
		//br.ErrMsg = "获取终端文件夹信息失败 ErrMsg:" + err.Error()
		//return
	}

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

// 查询指标列表
// @Title 查询指标列表接口
// @Description 查询指标列表接口
// @Success Ret=200 获取成功
// @router /terminal/edb_info/list [get]
func (c *EdbTerminalController) GetEdbInfoList() {
	br := new(models.BaseResponse).Init()

	defer func() {
		c.Data["json"] = br
		c.ServeJSON()
	}()

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

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

	if source <= 0 {
		br.Msg = "来源不能为空"
		br.ErrMsg = "来源不能为空"
		br.IsSendEmail = false
		return
	}
	

	condition := ``
	var pars []interface{}

	
	condition += " AND e.source = ?"
	pars = append(pars, source)
	if terminalCode != "" {
		condition += " AND e.terminal_code = ?"
		pars = append(pars, terminalCode)
	}
	if keyword != "" {
		condition += " AND (e.edb_name like ? or e.edb_code like ?)"
		pars = append(pars, "%"+keyword+"%")
		pars = append(pars, "%"+keyword+"%")
	}

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

	page := paging.GetPaging(currentIndex, pageSize, int(count))	
	br.Ret = 200
	br.Success = true
	br.Msg = "获取成功"
	br.Data = map[string]interface{}{
		"List": list,
		"Paging": page,
	}
	return
}


// 设置指标终端
// @Title 设置指标终端
// @Description 设置指标终端
// @Success 200 string "操作成功"
// @router /terminal/edb_info/set [post]
func (c *EdbTerminalController) SetEdbInfoTerminal() {
	br := new(models.BaseResponse).Init()
	br.IsSendEmail = false
	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 *data_manage.SetEdbInfoTerminalReq
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		br.Msg = "参数解析异常！"
		br.ErrMsg = "参数解析失败，Err:" + err.Error()
		return
	}

	if req.Source <= 0 {
		br.Msg = "来源不能为空"
		br.ErrMsg = "来源不能为空"
		return
	}

	if req.TerminalCode == "" {
		br.Msg = "终端编码不能为空"
		br.ErrMsg = "终端编码不能为空"
		return
	}

	if len(req.EdbInfoIds) <= 0 {
		br.Msg = "指标ID不能为空"
		br.ErrMsg = "指标ID不能为空"
		return
	}
	
	// 校验终端编码是否存在
	terminal, err := data_manage.GetEdbTerminalByTerminalCode(req.TerminalCode)
	if err != nil {
		br.Msg = "终端编码不存在"
		br.ErrMsg = "终端编码不存在"
		return
	}

	if req.Source != terminal.Source {
		br.Msg = "终端来源不匹配"
		br.ErrMsg = "终端来源不匹配"
		return
	}

	var count int64
	edbCodeList := make([]string, 0)
	if req.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
		// 查询对应的指标编码
		edbIds := make([]string, 0)
		for _, v := range req.EdbInfoIds {
			edbIds = append(edbIds, strconv.Itoa(v))
		}
		edbInfoList, err := data_manage.GetEdbInfoListByEdbInfoId(edbIds)
		if err != nil {
			br.Msg = "设置失败"
			br.ErrMsg = "设置失败，Err:" + err.Error()
			return
		}
		count = int64(len(edbInfoList))
		for _, v := range edbInfoList {
			edbCodeList = append(edbCodeList, v.EdbCode)
		}
	}else {
		// 更新指标的终端编码
		condition := " and e.edb_info_id in (?) and e.source = ?"
		pars := []interface{}{req.EdbInfoIds, req.Source}
		count, err := data_manage.GetSimpleEdbListCountByCondition(condition, pars)
		if err != nil {
			br.Msg = "设置失败"
			br.ErrMsg = "设置失败，Err:" + err.Error()
			return
		}

		if count <= 0 {
			br.Msg = "指标ID不存在"
			br.ErrMsg = "指标ID不存在"
			return
		}
	}
	
	if len(req.EdbInfoIds) != int(count) {
		br.Msg = "指标和数据源不匹配"
		br.ErrMsg = "指标和数据源不匹配"
		return
	}

	// 如果是钢联指标，则还需要变更数据源里的终端编码
	if req.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
		// 更新数据源里的终端编码
		err = data_manage.UpdateMysteelChemicalTerminalCode(edbCodeList, req.TerminalCode)
		if err != nil {
			br.Msg = "设置失败"
			br.ErrMsg = "设置失败，Err:" + err.Error()
			return
		}
	}else{
		// 更新指标的终端编码
		err = data_manage.UpdateEdbInfoTerminal(req.EdbInfoIds, req.TerminalCode, req.Source)
		if err != nil {
			br.Msg = "设置失败"
			br.ErrMsg = "设置失败，Err:" + err.Error()
			return
		}
	}

	br.Ret = 200
	br.Success = true
	br.Msg = "设置成功"
	return
}