eta_api/models/target.go

package models

import (
	"eta_gn/eta_api/global"
	"eta_gn/eta_api/utils"
	"fmt"
	"sort"
	"strconv"
	"strings"
	"time"

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

type DataList struct {
	TradeCode    string  `gorm:"column:TRADE_CODE;type:varchar(255);not null" description:"指标编码"`
	SecName      string  `gorm:"column:SEC_NAME;type:varchar(255);not null" description:"指标名称"`
	Unit         string  `gorm:"column:UNIT;type:varchar(255);not null" description:"单位"`
	Remark       string  `gorm:"column:REMARK;type:varchar(255);not null" description:"备注"`
	Frequency    string  `gorm:"type:varchar(255);not null" description:"频度"`
	ClassifyId   int     `gorm:"type:int;not null" description:"分类id"`
	ClassifyName string  `gorm:"type:varchar(255);not null" description:"分类名称"`
	Dt           string  `gorm:"column:DT;type:varchar(255);not null" description:"录入日期"`
	Close        float64 `gorm:"column:CLOSE;type:float;not null" description:"录入值"`
	ModifyTime   string  `gorm:"type:varchar(255);not null" description:"修改时间"`
}

type DataListResp struct {
	List   []*DataList
	Paging *paging.PagingItem `description:"分页数据"`
}

func GetDataList(condition string, pars []interface{}, startSize, pageSize int) (items []*DataList, err error) {
	sql := `select a.TRADE_CODE,a.SEC_NAME,a.UNIT,a.frequency,a.classify_id,b.classify_name,c.DT,c.CLOSE,c.modify_time FROM edbdata AS c
                inner join edbinfo AS a ON a.TRADE_CODE=c.TRADE_CODE
                left join edbdata_classify AS b ON a.classify_id=b.classify_id
                where a.classify_id>0`
	if condition != "" {
		sql += condition
	}
	sql += ` order by c.DT desc limit ?,? `
	pars = append(pars, startSize)
	pars = append(pars, pageSize)
	err = global.DmSQL["edb"].Raw(sql, pars...).Find(&items).Error
	return
}

func GetDataListCount(condition string, pars []interface{}) (count int, err error) {
	sql := ` select count(1) as count FROM edbdata AS c
                    inner join edbinfo AS a ON a.TRADE_CODE=c.TRADE_CODE    
                    left join edbdata_classify AS b ON a.classify_id=b.classify_id
                    where a.classify_id>0 `
	if condition != "" {
		sql += condition
	}
	err = global.DmSQL["edb"].Raw(sql, pars...).Scan(&count).Error
	return
}

type DataAddReq struct {
	TradeCode  string `description:"指标唯一编码"`
	CreateDate string `description:"创建日期"`
	Close      string `description:"录入值"`
}

type Edbdata struct {
	TradeCode  string    `gorm:"column:TRADE_CODE;primaryKey;type:varchar(255)" orm:"column(TRADE_CODE);pk" gorm:"primaryKey"  description:"指标编码"`
	Dt         string    `gorm:"column:DT;type:varchar(255)" orm:"column(DT)" description:"日期"`
	Close      string    `gorm:"column:CLOSE;type:varchar(255)" orm:"column(CLOSE)" description:"值"`
	ModifyTime time.Time `gorm:"column:modify_time;type:timestamp" orm:"column(modify_time)" description:"修改时间"`
}

func GetDataInfo(tradeCode, creteDate string) (item *Edbdata, err error) {
	sql := " SELECT * FROM edbdata WHERE TRADE_CODE=? AND DT=? "
	err = global.DmSQL["edb"].Raw(sql, tradeCode, creteDate).First(&item).Error
	return
}

func AddEdbdata(item *Edbdata) (lastId int64, err error) {
	err = global.DmSQL["edb"].Create(item).Error
	if err != nil {
		return
	}
	return
}

type DataEditReq struct {
	TradeCode     string      `description:"指标唯一编码"`
	CreateDate    string      `description:"创建日期"`
	Close         interface{} `description:"录入值"`
	OldCreateDate string      `description:"旧的录入日期"`
}

// BatchDataEditReq 批量修改指标
type BatchDataEditReq struct {
	OldCreateDate string        `description:"旧的录入日期"`
	CreateDate    string        `description:"新的录入日期"`
	List          []DataEditReq `description:"需要修改的数据"`
}

// 编辑数据
func EditEdbdata(item *Edbdata) (err error) {
	sql := ` UPDATE edbdata SET CLOSE = ?,modify_time=NOW() WHERE TRADE_CODE = ? AND DT = ? `
	err = global.DmSQL["edb"].Exec(sql, item.Close, item.TradeCode, item.Dt).Error
	return
}

type EdbdataDeleteRecord struct {
	Id         int       `gorm:"primaryKey" `
	TradeCode  string    `orm:"column(TRADE_CODE)" description:"指标编码"`
	Dt         string    `orm:"column(DT)" description:"日期"`
	Close      string    `orm:"column(CLOSE)" description:"值"`
	ModifyTime time.Time `orm:"column(modify_time)" description:"修改时间"`
	CreateTime time.Time
	SysUserId  int
}

func AddEdbdataDeleteRecord(item *EdbdataDeleteRecord) (lastId int64, err error) {
	err = global.DmSQL["edb"].Create(item).Error
	lastId = int64(item.Id)
	return
}

// DeleteEdbData 根据指标code和日期删除数据
func DeleteEdbData(tradeCode, dt string) (err error) {
	sql := ` DELETE FROM edbdata WHERE TRADE_CODE = ? AND DT = ? `
	err = global.DmSQL["edb"].Exec(sql, tradeCode, dt).Error
	return
}

// DeleteAllEdbData 根据指标code删除数据
func DeleteAllEdbData(tradeCode string) (err error) {
	sql := ` DELETE FROM edbdata WHERE TRADE_CODE = ? `
	err = global.DmSQL["edb"].Exec(sql, tradeCode).Error
	return
}

type Edbinfo struct {
	TradeCode    string  `gorm:"column:TRADE_CODE;primaryKey;type:varchar(255)" orm:"column(TRADE_CODE);pk" gorm:"primaryKey"  description:"指标code"`
	SecName      string  `gorm:"column:SEC_NAME;type:varchar(255)" orm:"column(SEC_NAME);" description:"指标名称"`
	Unit         string  `gorm:"column:UNIT;type:varchar(255)" orm:"column(UNIT);" description:"单位"`
	Remark       string  `gorm:"column:REMARK;type:varchar(255)" orm:"column(REMARK);" description:"备注"`
	Frequency    string  `gorm:"column:FREQUENCY;type:varchar(255)" orm:"column(frequency)" description:"频度"`
	ClassifyId   int     `gorm:"column:CLASSIFY_ID;type:int" orm:"column(classify_id)" description:"分类id"`
	ClassifyName string  `gorm:"-" orm:"-" description:"分类名称"`
	CreateDate   string  `gorm:"column:CREATE_DATE;type:varchar(255)" orm:"column(create_date)" description:"创建时间"`
	UserId       int     `gorm:"column:USER_ID;type:int" orm:"column(user_id)" description:"录入用户id"`
	UserName     string  `gorm:"column:USER_NAME;type:varchar(255)" orm:"column(user_name)" description:"录入用户名称"`
	NoticeTime   string  `gorm:"column:NOTICE_TIME;type:varchar(255)" orm:"column(notice_time)" description:"通知时间"`
	Mobile       string  `gorm:"column:MOBILE;type:varchar(255)" orm:"column(mobile)" description:"录入者手机号"`
	Sort         int     `gorm:"column:SORT;type:int" orm:"column(sort)" description:"排序"`
	ModifyTime   string  `gorm:"column:MODIFY_TIME;type:varchar(255)" description:"最近一次更新时间"`
	IsJoinEdb    int8    `gorm:"column:IS_JOIN_EDB;type:tinyint" description:"指标库是否已添加：0-否；1-是"`
	StartDate    string  `gorm:"column:START_DATE;type:varchar(255)" description:"数据开始日期"`
	EndDate      string  `gorm:"column:END_DATE;type:varchar(255)" description:"数据结束日期"`
	LatestValue  float64 `gorm:"column:LATEST_VALUE;type:decimal(10,2)" description:"指标最新值"`
}

func GetEdbinfoListCount(condition string, pars []interface{}, mobile string, roleType int) (count int, err error) {
	sql := ``
	if mobile != "" && roleType == 1 {
		sql = `SELECT COUNT(1) AS count FROM edbinfo AS a 
             INNER JOIN edbinfo_user AS c ON a.TRADE_CODE=c.TRADE_CODE AND c.mobile=?
             WHERE a.classify_id>0`

		if condition != "" {
			sql += condition
		}
		err = global.DmSQL["edb"].Raw(sql, utils.ForwardPars(pars, mobile)...).Scan(&count).Error
	} else {
		sql = `SELECT COUNT(1) AS count FROM edbinfo AS a WHERE a.classify_id>0`

		if condition != "" {
			sql += condition
		}
		err = global.DmSQL["edb"].Raw(sql, pars...).Scan(&count).Error

	}
	return
}

type EdbinfoItem struct {
	TradeCode    string  `gorm:"column:TRADE_CODE;primaryKey;type:varchar(255)"` //`orm:"column(TRADE_CODE);pk" gorm:"primaryKey"  description:"指标code"`
	SecName      string  `gorm:"column:SEC_NAME;type:varchar(255)"`              //`orm:"column(SEC_NAME);" description:"指标名称"`
	Unit         string  `gorm:"column:UNIT;type:varchar(255)"`                  //`orm:"column(UNIT);" description:"单位"`
	Remark       string  `gorm:"column:REMARK;type:varchar(255)"`                //`orm:"column(REMARK);" description:"备注"`
	Frequency    string  `gorm:"column:frequency;"`                              //`description:"频度"`
	ClassifyId   int     `gorm:"column:classify_id;type:int"`                    //`description:"分类id"`
	ClassifyName string  `gorm:"-"`                                              // `description:"分类名称"`
	CreateDate   string  `gorm:"column:create_date;"`                            // `description:"创建时间"`
	UserId       int     `gorm:"column:user_id;"`                                // `description:"录入用户id"`
	UserName     string  `gorm:"column:user_name;"`                              // `description:"录入用户名称"`
	NoticeTime   string  `gorm:"column:notice_time;"`                            //`description:"通知时间"`
	Mobile       string  `gorm:"column:mobile"`                                  // `description:"录入者手机号"`
	ModifyTime   string  `gorm:"column:modify_time;"`                            //`// `description:"最近一次更新时间"`
	StartDate    string  `gorm:"column:start_date;"`                             // `description:"数据开始日期"`
	EndDate      string  `gorm:"column:end_date;"`                               // `description:"数据结束日期"`
	LatestValue  float64 `gorm:"column:latest_value;"`                           // `description:"指标最新值"`
}

func GetEdbinfoItemList(condition string, pars []interface{}, startSize, pageSize int, mobile string, roleType int) (items []*EdbinfoItem, err error) {
	sql := ``
	if mobile != "" && roleType == 1 {
		sql = ` SELECT DISTINCT a.*,b.classify_name FROM edbinfo AS a
                    LEFT JOIN edbdata_classify AS b ON a.classify_id=b.classify_id
                    INNER JOIN edbinfo_user AS c ON a.TRADE_CODE=c.TRADE_CODE AND c.mobile=?
                    WHERE a.classify_id>0`
		if condition != "" {
			sql += condition
		}
		sql += ` ORDER BY a.create_date DESC LIMIT ?,? `
		err = global.DmSQL["edb"].Raw(sql, mobile, pars, startSize, pageSize).Find(&items).Error
	} else {
		sql = `SELECT DISTINCT a.*,b.classify_name FROM edbinfo AS a
                     LEFT JOIN edbdata_classify AS b on a.classify_id=b.classify_id
                     WHERE a.classify_id>0`
		if condition != "" {
			sql += condition
		}
		sql += ` ORDER BY a.create_date DESC LIMIT ?,? `
		pars = append(pars, startSize, pageSize)
		err = global.DmSQL["edb"].Raw(sql, pars...).Find(&items).Error
	}
	return
}

// EdbParamsInfo 指标数据结构体
type EdbParamsInfo struct {
	Unit      string `gorm:"column:UNIT;"`      //`orm:"column(UNIT);" description:"单位"`
	Frequency string `gorm:"column:frequency;"` //`orm:"column(frequency);" description:"单位"`
}

// GetEdbUnitList 获取指标单位
func GetEdbUnitList() (items []*EdbParamsInfo, err error) {
	sql := `SELECT UNIT from edbinfo group by UNIT`
	err = global.DmSQL["edb"].Raw(sql).Find(&items).Error
	return
}

// GetEdbFrequencyList 获取指标频度
func GetEdbFrequencyList(classifyId, userId int) (items []*EdbParamsInfo, err error) {
	sql := `SELECT frequency from edbinfo a 
join edbdata b on a.TRADE_CODE=b.TRADE_CODE
 where classify_id = ? `
	if userId > 0 {
		sql += ` and a.user_id = ` + fmt.Sprint(userId) + ` `
	}
	sql += ` group by a.frequency`
	err = global.DmSQL["edb"].Raw(sql, classifyId).Find(&items).Error
	return
}

type TargetListResp struct {
	List   []*EdbinfoItem
	Paging *paging.PagingItem `description:"分页数据"`
}

type EdbinfoAddReq struct {
	SecName    string `description:"指标名称"`
	Unit       string `description:"单位"`
	Frequency  string `description:"频度"`
	ClassifyId int    `description:"分类id"`
	NoticeTime string `description:"通知时间"`
}

// GetMaxTradeCode 获取指标最大trade_code
func GetMaxTradeCode() (max_trade_code string, err error) {
	sql := " SELECT MAX(TRADE_CODE) AS max_trade_code FROM edbinfo WHERE LEFT(TRADE_CODE,1)='W' "
	err = global.DmSQL["edb"].Raw(sql).Scan(&max_trade_code).Error
	if (err != nil && utils.IsErrNoRow(err)) || max_trade_code == `` {
		max_trade_code = "W00"
	}
	return
}

func GetEdbinfoBySecName(secName string) (item *Edbinfo, err error) {
	sql := `SELECT * FROM edbinfo WHERE SEC_NAME=? `
	err = global.DmSQL["edb"].Raw(sql, secName).First(&item).Error
	return
}

func GetEdbinfoByTradeCode(tradeCode string) (item *Edbinfo, err error) {
	sql := `SELECT * FROM edbinfo WHERE TRADE_CODE=? `
	err = global.DmSQL["edb"].Raw(sql, tradeCode).First(&item).Error
	return
}

func AddEdbinfo(tradeCode, secName, unit, remark, frequency, noticeTime string, classifyId int, userId int, userName string) (err error) {
	currTime := time.Now().Format(utils.FormatDateTime)
	edbInfo := &Edbinfo{
		TradeCode:  tradeCode,
		SecName:    secName,
		Unit:       unit,
		Remark:     remark,
		Frequency:  frequency,
		ClassifyId: classifyId,
		CreateDate: currTime,
		UserId:     userId,
		UserName:   userName,
		NoticeTime: noticeTime,
		Mobile:     "",
		ModifyTime: currTime,
		IsJoinEdb:  0,
	}
	err = global.DmSQL["edb"].Create(edbInfo).Error
	return
}

func AddEdbinfoUser(tradeCode, mobile string) (err error) {
	sql := `INSERT INTO edbinfo_user(TRADE_CODE, mobile) VALUES (?,?)`
	err = global.DmSQL["edb"].Exec(sql, tradeCode, mobile).Error
	return
}

type EdbinfoEditReq struct {
	TradeCode  string `description:"指标code"`
	SecName    string `description:"指标名称"`
	Unit       string `description:"单位"`
	Frequency  string `description:"频度"`
	ClassifyId int    `description:"分类id"`
	NoticeTime string `description:"通知时间"`
}

func EditEdbinfo(tradeCode, secName, unit, frequency, noticeTime string, classifyId int) (err error) {
	sql := `UPDATE edbinfo SET SEC_NAME= ?, UNIT = ?,classify_id=?,frequency=?,notice_time=?,create_date=NOW() WHERE TRADE_CODE=? `
	err = global.DmSQL["edb"].Exec(sql, secName, unit, classifyId, frequency, noticeTime, tradeCode).Error
	return
}

func SearchTargetEntry(classifyId int, keyWord string) (items []*Edbinfo, err error) {
	where := ""
	pars := make([]interface{}, 0)
	sql := `SELECT * FROM edbinfo WHERE classify_id>0 AND classify_id=? `
	pars = append(pars, classifyId)
	if keyWord != "" {
		sql += `AND SEC_NAME LIKE ? `
		pars = utils.GetLikeKeywordPars(pars, keyWord, 1)
	}
	sql += where
	err = global.DmSQL["edb"].Raw(sql, pars...).Find(&items).Error
	return
}

type SearchTargetListResp struct {
	List []*Edbinfo
}

type EdbdataClassify struct {
	ClassifyId   int    `gorm:"column:classify_id;type:int" xorm:"int 'classify_id'"`
	ClassifyName string `gorm:"column:classify_name;type:varchar(255)" xorm:"varchar(255) 'classify_name'"`
	ParentId     int    `gorm:"column:parent_id;type:int" xorm:"int 'parent_id'"`
	EdbInfoTotal int    `gorm:"column:edb_info_total;type:int" xorm:"int 'edb_info_total'"`
	TradeCode    string `gorm:"column:trade_code;type:varchar(255)" xorm:"varchar(255) 'trade_code'"`
	UniqueCode   string `gorm:"column:unique_code;type:varchar(255)" xorm:"varchar(255) 'unique_code'"`
}

type EdbdataClassifyList struct {
	ClassifyId   int
	ClassifyName string
	ParentId     int
	Child        []*EdbdataClassify `gorm:"-"`
	TradeCode    string
	UniqueCode   string
}

func GetEdbdataClassify(userId int64) (items []*EdbdataClassifyList, err error) {
	var newItems []*EdbdataClassifyList
	sql := ` SELECT classify_id,classify_name,parent_id FROM edbdata_classify WHERE parent_id=0 `
	err = global.DmSQL["edb"].Raw(sql).Find(&newItems).Error
	if err != nil {
		return
	}
	classifyLen := len(newItems)

	for i := 0; i < classifyLen; i++ {
		var childItems []*EdbdataClassify
		parentId := newItems[i].ClassifyId
		childSql := ``
		if userId > 0 {
			userClassifyList, _ := GetManualUserClassify(int(userId))
			var userIdArr []string
			for _, v := range userClassifyList {
				userIdArr = append(userIdArr, strconv.Itoa(v.ClassifyId))
			}

			userIdStr := strings.Join(userIdArr, ",")
			if userIdStr != "" {
				childSql = "SELECT a.classify_id,a.classify_name,a.parent_id FROM edbdata_classify AS a WHERE a.is_show=1 and a.classify_id IN(" + userIdStr + ") AND parent_id=? ORDER BY a.create_time ASC "
				//	_, err = o.Raw(childSql, parentId).QueryRows(&childItems)
				err = global.DmSQL["edb"].Raw(childSql, parentId).Find(&childItems).Error
			}
		} else {
			childSql = "SELECT classify_id,classify_name,parent_id FROM edbdata_classify WHERE is_show=1 and parent_id=? ORDER BY create_time ASC "
			//_, err = o.Raw(childSql, parentId).QueryRows(&childItems)
			err = global.DmSQL["edb"].Raw(childSql, parentId).Find(&childItems).Error
		}
		if err != nil {
			return
		}
		newItems[i].Child = childItems
	}
	for _, v := range newItems {
		childLen := len(v.Child)
		if childLen > 0 {
			items = append(items, v)
		}
	}
	return
}

type ManualUserClassify struct {
	ManualUserClassifyId int       `gorm:"column:manual_user_classify_id"` //`orm:"column(manual_user_classify_id);pk" gorm:"primaryKey" `
	AdminId              int       `gorm:"column:admin_id"`
	ClassifyId           int       `gorm:"column:classify_id"`
	CreateTime           time.Time `gorm:"column:create_time"`
}

func GetManualUserClassify(sysUserId int) (list []*ManualUserClassify, err error) {
	sql := `SELECT * FROM manual_user_classify WHERE admin_id=? `
	err = global.DmSQL["data"].Raw(sql, sysUserId).Find(&list).Error
	return
}

type EdbdataClassifyResp struct {
	List []*EdbdataClassifyList
}

func GetTargetBySecName(secName string) (item *Edbinfo, err error) {
	sql := `SELECT * FROM edbinfo WHERE SEC_NAME=? `
	err = global.DmSQL["edb"].Raw(sql, secName).First(&item).Error
	return
}

// 更新指标数据信息
func (edbinfo *Edbinfo) Update(cols []string) (err error) {
	err = global.DmSQL["edb"].Select(cols).Updates(edbinfo).Error
	return
}

// GetTargetsDataList 根据code获取指标数据列表
func GetTargetsDataList(tradeCode string) (items []*Edbdata, err error) {
	sql := `SELECT * FROM edbdata WHERE TRADE_CODE=? ORDER BY DT ASC `
	err = global.DmSQL["edb"].Raw(sql, tradeCode).Find(&items).Error
	return
}

func ModifyTargetsDataByImport(tradeCode, dt, close string) (err error) {
	sql := `UPDATE  edbdata SET CLOSE=?,modify_time=NOW() WHERE  TRADE_CODE=? AND DT=? `
	err = global.DmSQL["edb"].Exec(sql, close, tradeCode, dt).Error
	return
}

func AddTargetsDataByImport(tradeCode, dt, close string) (err error) {
	sql := `INSERT INTO edbdata(TRADE_CODE, DT,CLOSE, modify_time)VALUES(?,?,?,NOW()) `
	err = global.DmSQL["edb"].Exec(sql, tradeCode, dt, close).Error
	return
}

type EdbdataImportResp struct {
	Status       int
	Msg          string
	SuccessCount int
	FailCount    int
}

func GetFailList(sysUserId int) (items []*EdbdataImportFail, err error) {
	sql := ` SELECT * FROM edbdata_import_fail WHERE sys_user_id=? `
	err = global.DmSQL["edb"].Raw(sql, sysUserId).Find(&items).Error
	return
}

type DataListForExport struct {
	TradeCode    string  `gorm:"column:TRADE_CODE"`  //`orm:"column(TRADE_CODE)" description:"指标code"`
	SecName      string  `gorm:"column:SEC_NAME"`    //`orm:"column(SEC_NAME)" description:"指标名称"`
	Unit         string  `gorm:"column:UNIT"`        //`orm:"column(UNIT)" description:"单位"`
	Frequency    string  `gorm:"column:frequency"`   //`description:"频度"`
	ClassifyId   int     `gorm:"column:classify_id"` //`description:"分类id"`
	NoticeTime   string  `gorm:"column:notice_time"` //`description:"通知时间"`
	ClassifyName string  `gorm:"column:classify_name"`
	Dt           string  `gorm:"column:DT"`    //`orm:"column(DT)" description:"日期"`
	Close        float64 `gorm:"column:CLOSE"` //`orm:"column(CLOSE)" description:"值"`
}

type DataDeleteReq struct {
	TradeCode  string `description:"指标唯一编码"`
	CreateDate string `description:"数据录入日期"`
}

func DataDelete(tradeCode, createDate, close string, modifyTime time.Time, sysUserId int) (err error) {
	to := global.DmSQL["edb"].Begin()
	defer func() {
		if err != nil {
			_ = to.Rollback()
		} else {
			_ = to.Commit()
		}
	}()
	recordSql := ` INSERT INTO edbdata_delete_record(TRADE_CODE,DT,CLOSE,modify_time,create_time,sys_user_id) 
                 VALUES(?,?,?,?,?,?)`
	err = to.Exec(recordSql, tradeCode, createDate, close, modifyTime, time.Now(), sysUserId).Error
	sql := ` DELETE FROM edbdata WHERE TRADE_CODE = ? AND DT = ? `
	err = to.Exec(sql, tradeCode, createDate).Error
	return
}

type TargetDeleteReq struct {
	TradeCode string `description:"指标唯一编码"`
}

func TargetDelete(tradeCode string) (err error) {
	to := global.DmSQL["edb"].Begin()
	defer func() {
		if err != nil {
			_ = to.Rollback()
		} else {
			_ = to.Commit()
		}
	}()

	sql := " DELETE FROM edbinfo WHERE TRADE_CODE = ? "
	//_, err = to.Raw(sql, tradeCode).Exec()
	err = to.Exec(sql, tradeCode).Error
	sql = " DELETE FROM edbdata WHERE TRADE_CODE = ? "
	//_, err = to.Raw(sql, tradeCode).Exec()
	err = to.Exec(sql, tradeCode).Error
	return
}

type Researcher struct {
	AdminId     int    `gorm:"column:admin_id"`     //`description:"系统用户id"`
	AdminName   string `gorm:"column:admin_name"`   //`description:"系统用户名称"`
	RealName    string `gorm:"column:real_name"`    //`description:"系统用户姓名"`
	Role        string `gorm:"column:role"`         //`description:"系统用户角色"`
	Mobile      string `gorm:"column:mobile"`       //`description:"手机号"`
	TargetCount int    `gorm:"column:target_count"` //`description:"指标数量"`
}

type ResearcherListResp struct {
	List []*Researcher
}

func GetResearcherEntry() (items []*Researcher, err error) {
	sql := ` SELECT admin_id,admin_name,real_name,mobile,0 as target_count FROM "admin" WHERE role_type=1 `
	err = global.DmSQL["edb"].Raw(sql).Find(&items).Error
	researchLen := len(items)
	for i := 0; i < researchLen; i++ {
		var count int
		mobile := items[i].Mobile
		sqlCount := ` SELECT COUNT(DISTINCT a.TRADE_CODE) AS count FROM  edbinfo_user AS a
            INNER JOIN edbinfo AS b ON a.TRADE_CODE=b.TRADE_CODE
            WHERE a.mobile=? AND b.classify_id>0 `
		err = global.DmSQL["edb"].Raw(sqlCount, mobile).Scan(&count).Error
		items[i].TargetCount = count
	}
	return
}

func GetResearcherEntryByMobile(mobile string) (items []*Researcher, err error) {
	sql := ` SELECT admin_id,admin_name,real_name,mobile,0 as target_count FROM "admin" WHERE  role_type=1 `
	if mobile != "" {
		sql += ` AND mobile IN(` + mobile + `)`
	}
	err = global.DmSQL["edb"].Raw(sql).Find(&items).Error
	researchLen := len(items)
	for i := 0; i < researchLen; i++ {
		var count int
		mobile := items[i].Mobile
		sqlCount := ` SELECT COUNT(DISTINCT a.TRADE_CODE) AS count FROM  edbinfo_user AS a
            INNER JOIN edbinfo AS b ON a.TRADE_CODE=b.TRADE_CODE
            WHERE a.mobile=? AND b.classify_id>0 `
		err = global.DmSQL["edb"].Raw(sqlCount, mobile).Scan(&count).Error
		items[i].TargetCount = count
	}
	return
}

type EdbinfoItems struct {
	TradeCode    string `gorm:"column:TRADE_CODE"`    //`orm:"column(TRADE_CODE);pk" gorm:"primaryKey"  description:"指标code"`
	SecName      string `gorm:"column:SEC_NAME"`      //`orm:"column(SEC_NAME);" description:"指标名称"`
	Unit         string `gorm:"column:UNIT"`          //`orm:"column(UNIT);" description:"单位"`
	Remark       string `gorm:"column:REMARK"`        //`orm:"column(REMARK);" description:"备注"`
	Frequency    string `gorm:"column:frequency"`     //`description:"频度"`
	ClassifyId   int    `gorm:"column:classify_id"`   //`description:"分类id"`
	ClassifyName string `gorm:"column:classify_name"` //`description:"分类名称"`
	CreateDate   string `gorm:"column:create_date"`   //`description:"创建时间"`
	UserId       int    `gorm:"column:user_id"`       //`description:"录入用户id"`
	NoticeTime   string `gorm:"column:notice_time"`   //`description:"通知时间"`
	Mobile       string `gorm:"column:mobile"`        //`description:"录入者手机号"`
	ModifyDate   string `gorm:"column:modify_date"`   //`description:"待更新日期"`
	Status       string `gorm:"column:status"`        // `description:"状态：未完成/完成"`
}

type TargetItemsResp struct {
	List SortEdbInfo
}

type SortEdbInfo []EdbinfoItems

func GetTargetItems(mobile string, classifyId int) (lastItems SortEdbInfo, err error) {
	var items []*EdbinfoItems
	sql := ` SELECT *,'' modify_date,'' STATUS FROM edbinfo AS a 
            WHERE a.classify_id>0
             `
	if classifyId > 0 {
		sql += ` AND a.classify_id=` + strconv.Itoa(classifyId) + ``
	}
	sql += ` GROUP BY a.TRADE_CODE `

	sql = sql + ` ORDER BY CONVERT(a.SEC_NAME USING gbk )  COLLATE gbk_chinese_ci ASC `
	err = global.DmSQL["edb"].Raw(sql).Find(&items).Error
	if err != nil {
		return
	}
	itemsLen := len(items)
	nowWeek := time.Now().Weekday().String()

	fmt.Println(nowWeek)
	finishEdbInfo := SortEdbInfo{}
	unFinishEdbInfo := SortEdbInfo{}

	for i := 0; i < itemsLen; i++ {
		noticeTime := items[i].NoticeTime
		frequency := items[i].Frequency
		tradeCode := items[i].TradeCode
		if noticeTime != "" {
			if frequency == "周度" {
				noticeArr := strings.Split(noticeTime, " ")
				noticeWeek := noticeArr[0]
				fmt.Println(noticeWeek)
				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)
				modifyDateStr := modifyDate.Format(utils.FormatDate)
				items[i].ModifyDate = modifyDateStr

				modifyDateEndStr := modifyDate.AddDate(0, 0, -7).Format(utils.FormatDate)

				fmt.Println("addDay:", addDay)
				fmt.Println("modifyDateEndStr:", modifyDateEndStr)

				count := 0
				sqlCount := ` SELECT COUNT(1) AS num FROM edbdata WHERE TRADE_CODE=? AND DT >= ? AND DT <= ? `
				err = global.DmSQL["edb"].Raw(sqlCount, tradeCode, modifyDateEndStr, modifyDateStr).Scan(&count).Error
				if err != nil {
					return nil, err
				}
				if count > 0 {
					items[i].Status = "完成"
					finishEdbInfo = append(finishEdbInfo, *items[i])
				} else {
					items[i].Status = "未完成"
					unFinishEdbInfo = append(unFinishEdbInfo, *items[i])
				}
			} else if frequency == "日度" {
				items[i].Status = "完成"
				finishEdbInfo = append(finishEdbInfo, *items[i])
			} else if frequency == "月度" {
				myYear := time.Now().Year()
				myMonth := time.Now().Format("01")
				startDate, endDate := utils.GetMonthStartAndEnd(strconv.Itoa(myYear), myMonth)
				count := 0
				sqlCount := ` SELECT COUNT(1) AS num FROM edbdata WHERE TRADE_CODE=? AND DT >= ? AND DT <= ? `
				err = global.DmSQL["edb"].Raw(sqlCount, tradeCode, startDate, endDate).Scan(&count).Error
				if err != nil {
					return nil, err
				}
				if noticeTime != "" {
					var modifyDateStr string
					strArr := strings.Split(noticeTime, "日")
					myYear := time.Now().Year()
					myMonth := time.Now().Format("01")
					modifyDateStr = strconv.Itoa(myYear) + "-" + myMonth + "-" + strArr[0]
					items[i].ModifyDate = modifyDateStr
				}
				if count > 0 {
					items[i].Status = "完成"
					finishEdbInfo = append(finishEdbInfo, *items[i])
				} else {
					items[i].Status = "未完成"
					unFinishEdbInfo = append(unFinishEdbInfo, *items[i])
				}
			} else {
				items[i].Status = "完成"
				finishEdbInfo = append(finishEdbInfo, *items[i])
			}
		} else {
			if frequency == "月度" {
				myYear := time.Now().Year()
				myMonth := time.Now().Format("01")
				startDate, endDate := utils.GetMonthStartAndEnd(strconv.Itoa(myYear), myMonth)
				count := 0
				sqlCount := ` SELECT COUNT(1) AS num FROM edbdata WHERE TRADE_CODE=? AND DT >= ? AND DT <= ? `
				//err = o.Raw(sqlCount, tradeCode, startDate, endDate).QueryRow(&count)
				err = global.DmSQL["edb"].Raw(sqlCount, tradeCode, startDate, endDate).Scan(&count).Error
				if err != nil {
					return nil, err
				}
				if count > 0 {
					items[i].Status = "完成"
					finishEdbInfo = append(finishEdbInfo, *items[i])
				} else {
					items[i].Status = "未完成"
					unFinishEdbInfo = append(unFinishEdbInfo, *items[i])
				}
			} else {
				items[i].Status = "完成"
				finishEdbInfo = append(finishEdbInfo, *items[i])
			}
		}
	}
	sort.Sort(SortByModifyDate{finishEdbInfo})
	sort.Sort(SortByModifyDate{unFinishEdbInfo})
	lastItems = append(lastItems, unFinishEdbInfo...)
	lastItems = append(lastItems, finishEdbInfo...)
	return
}

// 获取此 slice 的长度
func (p SortEdbInfo) Len() int { return len(p) }

// 根据元素的状态降序排序
func (p SortEdbInfo) Less(i, j int) bool {
	return p[i].Status > p[j].Status
}

// 交换数据
func (p SortEdbInfo) Swap(i, j int) { p[i], p[j] = p[j], p[i] }

// 嵌套结构体  将继承 SortEdbInfo 的所有属性和方法
// 所以相当于SortByName 也实现了 Len() 和 Swap() 方法
type SortByStatus struct{ SortEdbInfo }

// 根据元素的姓名长度降序排序 （此处按照自己的业务逻辑写）
func (p SortByStatus) Less(i, j int) bool {
	return len(p.SortEdbInfo[i].Status) > len(p.SortEdbInfo[j].Status)
}

type SortByModifyDate struct{ SortEdbInfo }

// 根据元素的年龄降序排序 （此处按照自己的业务逻辑写）
func (p SortByModifyDate) Less(i, j int) bool {
	return p.SortEdbInfo[i].ModifyDate > p.SortEdbInfo[j].ModifyDate
}

type DataCheckResp struct {
	Status int    `description:"状态：1：该日期已存在数据，是否确认修改？,0:数据不存在"`
	Close  string `description:"值"`
}

type TargetCheckResp struct {
	Status int `description:"状态：1：该指标有关联数据，请先删除数据,0:指标不存在关联数据，可直接删除"`
}

type EdbdataExportList struct {
	TradeCode    string `gorm:"column:TRADE_CODE;primaryKey;not null" description:"指标code"`
	SecName      string `gorm:"column:SEC_NAME" description:"指标名称"`
	Unit         string `gorm:"column:UNIT" description:"单位"`
	Remark       string `gorm:"column:REMARK" description:"备注"`
	Frequency    string `gorm:"column:frequency" description:"频度"`       //`description:"频度"`
	ClassifyId   int    `gorm:"column:classify_id" description:"分类id"`   //`description:"分类id"`
	ClassifyName string `gorm:"column:classify_name" description:"分类名称"` //`description:"分类名称"`
	CreateDate   string `gorm:"column:create_date" description:"创建时间"`   //`description:"创建时间"`
	Dt           string `gorm:"column:DT" description:"最新一次录入时间"`
}

func GetEdbdataSecName(condition string, pars []interface{}) (items []*EdbdataExportList, err error) {
	sql := `SELECT a.TRADE_CODE,a.SEC_NAME,a.frequency,a.UNIT,MAX(c.DT) AS Dt,b.classify_name
		        FROM edbdata AS c
		        INNER JOIN edbinfo AS a ON a.TRADE_CODE=c.TRADE_CODE
		        LEFT JOIN edbdata_classify AS b ON a.classify_id=b.classify_id
		        WHERE a.classify_id>0`
	if condition != "" {
		sql += condition
	}
	sql += " GROUP BY a.TRADE_CODE ORDER BY a.TRADE_CODE ASC "
	err = global.DmSQL["edb"].Raw(sql, pars...).Find(&items).Error
	return
}

// GetEdbDataFrequencyByClassifyIdList
// @Description: 根据分类列表获取所有的频度
// @author: Roc
// @datetime 2024-08-15 17:51:13
// @param classifyIdList []int
// @return items []*string
// @return err error
func GetEdbDataFrequencyByClassifyIdList(classifyIdList []int) (items []string, err error) {
	num := len(classifyIdList)
	if num <= 0 {
		return
	}
	sql := `SELECT DISTINCT frequency FROM edbinfo where classify_id in (` + utils.GetOrmInReplace(num) + `) AND frequency IS NOT NULL ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年度','年度') `
	err = global.DmSQL["edb"].Raw(sql, classifyIdList).Find(&items).Error
	return
}

func GetEdbDataFrequencyByKeyord(keyword string) (items []string, err error) {
	sql := `SELECT DISTINCT frequency FROM edbinfo where SEC_NAME=? ORDER BY FIELD(frequency,'日度','周度','月度','季度','半年度','年度') `
	err = global.DmSQL["edb"].Raw(sql, keyword).Find(&items).Error
	return
}

type EdbdataList struct {
	Dt string `gorm:"column:DT" description:"录入时间"` //`orm:"column(DT);" description:"录入时间"`
}

func GetEdbdataList(tradeCode string) (items []*EdbdataList, err error) {
	sql := ` SELECT  DT FROM edbdata WHERE TRADE_CODE IN(` + tradeCode + `)  GROUP BY DT ORDER BY DT DESC `
	err = global.DmSQL["edb"].Raw(sql).Find(&items).Error
	return
}

type EdbdataItem struct {
	TradeCode string  `gorm:"column:TRADE_CODE" description:"指标code"` //`orm:"column(TRADE_CODE);" description:"指标code"`
	Dt        string  `gorm:"column:DT" description:"最新一次录入时间"`       // `orm:"column(DT);" description:"最新一次录入时间"`
	Close     float64 `gorm:"column:CLOSE" description:"值"`           //`orm:"column(CLOSE);" description:"值"`
}

func GetEdbdataAllByTradeCode(tradeCode string) (items []*EdbdataItem, err error) {
	sql := ` SELECT * FROM edbdata WHERE TRADE_CODE=? `
	err = global.DmSQL["edb"].Raw(sql, tradeCode).Find(&items).Error
	return
}

// EdbInfoItem
type EdbInfoItem struct {
	TradeCode    string     `gorm:"column:TRADE_CODE;primaryKey;type:varchar(255)" orm:"column(TRADE_CODE);pk" gorm:"primaryKey"  description:"指标code"`
	SecName      string     `gorm:"column:SEC_NAME;type:varchar(255)" orm:"column(SEC_NAME);" description:"指标名称"`
	Unit         string     `gorm:"column:UNIT;type:varchar(255)" orm:"column(UNIT);" description:"单位"`
	Remark       string     `gorm:"column:REMARK;type:varchar(255)" orm:"column(REMARK);" description:"备注"`
	Frequency    string     `gorm:"column:FREQUENCY;type:varchar(255)" description:"频度"`
	ClassifyId   int        `gorm:"column:CLASSIFY_ID;type:int" description:"分类id"`
	ClassifyName string     `gorm:"column:CLASSIFY_NAME;type:varchar(255)" description:"分类名称"`
	CreateDate   string     `gorm:"column:CREATE_DATE;type:varchar(255)" description:"创建时间"`
	UserId       int        `gorm:"column:USER_ID;type:int" description:"录入用户id"`
	UserName     string     `gorm:"column:USER_NAME;type:varchar(255)" description:"录入用户名称"`
	NoticeTime   string     `gorm:"column:NOTICE_TIME;type:varchar(255)" description:"通知时间"`
	Mobile       string     `gorm:"column:MOBILE;type:varchar(255)" description:"录入者手机号"`
	ModifyDate   string     `gorm:"column:MODIFY_DATE;type:varchar(255)" description:"待更新日期"`
	ModifyTime   string     `gorm:"column:MODIFY_TIME;type:varchar(255)" description:"最近一次更新时间"`
	Status       string     `gorm:"column:STATUS;type:varchar(255)" description:"状态：未完成/完成"`
	IsJoinEdb    int8       `gorm:"column:IS_JOIN_EDB;type:tinyint" description:"指标库是否已添加：0-否；1-是"`
	StartDate    string     `gorm:"column:START_DATE;type:varchar(255)" description:"数据开始日期"`
	EndDate      string     `gorm:"column:END_DATE;type:varchar(255)" description:"数据结束日期"`
	LatestValue  float64    `gorm:"column:LATEST_VALUE;type:decimal(10,2)" description:"指标最新值"`
	DataList     []*Edbdata `gorm:"-" description:"指标数据列表"`
}

// GetTargetItemList 获取指标列表数据
func GetTargetItemList(classifyId, edbShowType int, frequency, keyword, tradeCode string, classifyIdStrList []string) (items []*EdbInfoItem, err error) {

	pars := make([]interface{}, 0)

	sql := ` SELECT a.*,'' modify_date,'' STATUS FROM edbinfo AS a `
	if edbShowType != 0 {
		sql = ` SELECT a.*,b.DT,'' modify_date,'' STATUS FROM edbinfo AS a 
left join edbdata b on a.TRADE_CODE=b.TRADE_CODE `
	}
	sql += ` WHERE a.classify_id>0 `

	//如果没有分类id集合列表，那么就没有数据了，不用往下执行了，直接返回好了
	if len(classifyIdStrList) <= 0 {
		return
	}
	if len(classifyIdStrList) > 0 {
		sql += ` AND a.classify_id in (` + strings.Join(classifyIdStrList, ",") + `)  `
	}
	if classifyId > 0 {
		sql += ` AND a.classify_id=` + strconv.Itoa(classifyId) + ` `
	}
	//频度
	if frequency != "" {
		sql += ` AND a.frequency="` + frequency + `" `
	}
	//关键字
	if keyword != "" {
		sql += ` AND (a.SEC_NAME like ?  or a.TRADE_CODE like ? )`
		pars = utils.GetLikeKeywordPars(pars, keyword, 2)
	}
	//指定指标
	if tradeCode != "" {
		sql += ` AND a.TRADE_CODE = "` + tradeCode + `" `
	}
	//指标里面是否有数据
	switch edbShowType {
	case 1:
		sql += ` AND b.CLOSE is not null `
	case 2:
		sql += ` AND b.CLOSE is null `
	}
	sql += ` GROUP BY a.TRADE_CODE `

	sql = sql + ` ORDER BY CONVERT(a.SEC_NAME USING gbk )  COLLATE gbk_chinese_ci ASC `
	err = global.DmSQL["edb"].Raw(sql, pars...).Find(&items).Error
	return

}

// GetEdbDataListByCodes 通过指标ID获取所有数据
func GetEdbDataListByCodes(tradeCode string) (items []*Edbdata, err error) {
	sql := ` SELECT  TRADE_CODE,DT,round(CLOSE,4) CLOSE,modify_time  FROM edbdata WHERE TRADE_CODE IN(` + tradeCode + `)  GROUP BY TRADE_CODE,DT ORDER BY DT DESC `
	err = global.DmSQL["edb"].Raw(sql).Find(&items).Error
	return
}

// TargetItemListResp 指标数据结构体
type TargetItemListResp struct {
	List          []*EdbInfoItem
	FrequencyList []string
}

// BatchDataDeleteReq 批量删除某日的指标数据请求结构体
type BatchDataDeleteReq struct {
	CreateDate    string   `description:"创建日期"`
	TradeCodeList []string `description:"指标唯一编码列表"`
}

// BatchDeleteEdbDataByDate 批量删除某日的指标数据
func BatchDeleteEdbDataByDate(tradeCodes, dt string, opUserId int) (err error) {
	var list []*Edbdata
	sql := ` select * FROM edbdata WHERE TRADE_CODE in  (` + tradeCodes + `) AND DT = ? `
	err = global.DmSQL["edb"].Raw(sql, dt).Find(&list).Error
	if err != nil {
		return
	}
	deleteRecordList := make([]*EdbdataDeleteRecord, 0)
	for _, edbDataInfo := range list {
		deleteRecord := &EdbdataDeleteRecord{
			TradeCode:  edbDataInfo.TradeCode,
			Dt:         edbDataInfo.Dt,
			Close:      edbDataInfo.Close,
			ModifyTime: time.Now(),
			CreateTime: time.Now(),
			SysUserId:  opUserId,
		}
		deleteRecordList = append(deleteRecordList, deleteRecord)
	}
	if len(deleteRecordList) > 0 {
		tmpErr := global.DmSQL["edb"].CreateInBatches(deleteRecordList, utils.MultiAddNum).Error
		if tmpErr != nil {
			err = tmpErr
			return
		}
	}
	sql = ` DELETE FROM edbdata WHERE TRADE_CODE in  (` + tradeCodes + `) AND DT = ? `
	//_, err = o.Raw(sql, dt).Exec()
	err = global.DmSQL["edb"].Exec(sql, dt).Error
	return
}

// BatchDeleteEdbData 批量删除指标数据
func BatchDeleteEdbData(tradeCode string, opUserId int) (err error) {
	var list []*Edbdata
	sql := ` select * FROM edbdata WHERE TRADE_CODE =  ? `
	err = global.DmSQL["edb"].Raw(sql, tradeCode).Find(&list).Error
	if err != nil {
		return
	}
	deleteRecordList := make([]*EdbdataDeleteRecord, 0)
	for _, edbDataInfo := range list {
		deleteRecord := &EdbdataDeleteRecord{
			TradeCode:  edbDataInfo.TradeCode,
			Dt:         edbDataInfo.Dt,
			Close:      edbDataInfo.Close,
			ModifyTime: time.Now(),
			CreateTime: time.Now(),
			SysUserId:  opUserId,
		}
		deleteRecordList = append(deleteRecordList, deleteRecord)
	}
	err = global.DmSQL["edb"].CreateInBatches(deleteRecordList, utils.MultiAddNum).Error
	if err != nil {
		return
	}
	sql = ` DELETE FROM edbdata WHERE TRADE_CODE  = ? `
	err = global.DmSQL["edb"].Exec(sql, tradeCode).Error
	return
}

// EdbInfoGroupCount 指标分类id获取当前分类下的指标数量
type EdbInfoGroupCount struct {
	Count      int `gorm:"column:count"`
	ClassifyId int `gorm:"column:classify_id"`
}

// GetEdbInfoGroupCountByClassifyIds 根据指标分类id获取当前分类下的指标数量
func GetEdbInfoGroupCountByClassifyIds(classifyIds string) (list []*EdbInfoGroupCount, err error) {
	sql := `SELECT COUNT(1) AS count,classify_id FROM ( SELECT a.*,b.CLOSE FROM edbinfo AS a 
             INNER JOIN edbdata AS b ON a.TRADE_CODE=b.TRADE_CODE
             WHERE a.classify_id in (` + classifyIds + `) group by a.TRADE_CODE) d 
						 GROUP BY classify_id `
	err = global.DmSQL["edb"].Raw(sql).Find(&list).Error
	return
}

type EdbdataFloat struct {
	TradeCode  string    `gorm:"column:TRADE_CODE"`  //`orm:"column(TRADE_CODE);pk" gorm:"primaryKey"  description:"指标编码"`
	Dt         string    `gorm:"column:DT"`          //`orm:"column(DT)" description:"日期"`
	Close      float64   `gorm:"column:CLOSE"`       //`orm:"column(CLOSE)" description:"值"`
	ModifyTime time.Time `gorm:"column:modify_time"` //`orm:"column(modify_time)" description:"修改时间"`
}

func ModifyEdbinfo(tradeCode, unit, frequency string, classifyId int) (err error) {
	sql := `UPDATE edbinfo SET UNIT = ?,frequency=?, classify_id=?, create_date=NOW() WHERE TRADE_CODE=? `
	err = global.DmSQL["edb"].Exec(sql, unit, frequency, classifyId, tradeCode).Error
	return
}

func DeleteTargetsDataByImport(tradeCode, dt string) (err error) {
	sql := `DELETE FROM edbdata WHERE TRADE_CODE=? AND DT=? `
	err = global.DmSQL["edb"].Exec(sql, tradeCode, dt).Error
	return
}

// GetEdbinfoListByCodeListByCodeIdList
// @Description: 根据指标code列表获取列表信息
// @param edbCodeList
// @return items
// @return err
func GetEdbinfoListByCodeListByCodeIdList(edbCodeList []string) (items []*Edbinfo, err error) {
	num := len(edbCodeList)
	if num <= 0 {
		return
	}
	sql := `SELECT * FROM edbinfo WHERE TRADE_CODE in (` + utils.GetOrmInReplace(num) + `) `
	err = global.DmSQL["edb"].Raw(sql, edbCodeList).Find(&items).Error
	return
}

// GetEdbinfoListByCodeListByUserId
// @Description: 根据用户id列表获取指标列表信息
// @param userIdList
// @return items
// @return err
func GetEdbinfoListByCodeListByUserId(userIdList []int) (items []*Edbinfo, err error) {
	num := len(userIdList)
	if num <= 0 {
		return
	}
	sql := `SELECT * FROM edbinfo WHERE user_id in (` + utils.GetOrmInReplace(num) + `) `
	err = global.DmSQL["edb"].Raw(sql, userIdList).Find(&items).Error
	return
}

// ModifyEdbinfoUserIdByCodeList 根据指标code列表修改创建人
func ModifyEdbinfoUserIdByCodeList(edbCodeList []string, userId int, userName string) (err error) {
	num := len(edbCodeList)
	if num <= 0 {
		return
	}
	sql := `UPDATE edbinfo SET user_id = ?,user_name = ? WHERE TRADE_CODE in (` + utils.GetOrmInReplace(num) + `) `
	err = global.DmSQL["edb"].Exec(sql, userId, userName, edbCodeList).Error
	return
}

func GetEdbInfoAdminList() (list []int, err error) {
	sql := `SELECT user_id FROM edbinfo GROUP BY user_id `
	err = global.DmSQL["edb"].Raw(sql).Find(&list).Error
	return
}

// EdbinfoMaxMinDate
// @Description: 手工指标的最小最大日期
type EdbinfoMaxMinDate struct {
	MinDate string `gorm:"column:min_date"`
	MaxDate string `gorm:"column:max_date"`
}

// GetEdbdataMaxMinDate
// @Description: 获取手工指标的最小最大日期
// @author: Roc
// @datetime 2024-08-01 14:27:20
// @param tradeCode string
// @return item EdbinfoMaxMinDate
// @return err error
func GetEdbdataMaxMinDate(tradeCode string) (item EdbinfoMaxMinDate, err error) {
	sql := ` SELECT MIN(DT) min_date,MAX(DT) max_date FROM edbdata WHERE TRADE_CODE = ? `
	err = global.DmSQL["edb"].Raw(sql, tradeCode).Find(&item).Error
	return
}

// GetEdbdataLatestValue
// @Description: 获取手工数据的最新值
// @author: Roc
// @datetime 2024-08-02 10:33:22
// @param tradeCode string
// @return latestValue float64
// @return err error
func GetEdbdataLatestValue(tradeCode string) (latestValue float64, err error) {
	sql := ` SELECT CLOSE FROM edbdata WHERE TRADE_CODE = ? ORDER BY DT DESC LIMIT 1`
	err = global.DmSQL["edb"].Raw(sql, tradeCode).Scan(&latestValue).Error
	return
}

// ModifyEdbinfoMaxMinDate
// @Description: 修改手工指标的最小最大日期
// @author: Roc
// @datetime 2024-08-01 15:33:45
// @param startDate string
// @param endDate string
// @param tradeCode string
// @return err error
func ModifyEdbinfoMaxMinDate(tradeCode, startDate, endDate string, latestValue float64) (err error) {

	sql := ` UPDATE edbinfo SET start_date = ?, end_date = ?, latest_value = ? , modify_time = now() WHERE TRADE_CODE = ? `
	err = global.DmSQL["edb"].Exec(sql, startDate, endDate, latestValue, tradeCode).Error
	return
}