eta_api/services/data/base_from_sci_hq.go

package data

import (
	"errors"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/utils"
	"fmt"
	"time"
)

func AddSciHqClassify(classifyName, lang string, parentId int) (ok bool, err error) {
	var count int
	switch lang {
	case utils.EnLangVersion:
		count, err = data_manage.GetBaseFromSciHqClassifyEnCount(classifyName, parentId)
	default:
		count, err = data_manage.GetBaseFromSciHqClassifyCount(classifyName, parentId)
	}
	if err != nil {
		return
	}
	if count > 0 {
		return false, errors.New("分类已存在")
	}

	sort, err := data_manage.GetChildSciHqClassifyMaxSortById(parentId)
	if err != nil {
		return false, err
	}
	if parentId > 0 {
		count, err = data_manage.GetSciHqClassifyCountById(parentId)
		if err != nil {
			return false, err
		}
		if count == 0 {
			return false, errors.New("父分类不存在")
		}
		sciHqClassify := &data_manage.BaseFromSciHqClassify{
			ClassifyName:   classifyName,
			ClassifyNameEn: classifyName,
			ParentId:       parentId,
			Level:          2,
			Sort:           sort + 1,
			ModifyTime:     time.Now(),
			CreateTime:     time.Now(),
		}
		_, err = sciHqClassify.Add()
		if err != nil {
			return
		}
	} else {
		sciHqClassify := &data_manage.BaseFromSciHqClassify{
			ClassifyName:   classifyName,
			ClassifyNameEn: classifyName,
			ParentId:       0,
			Level:          1,
			Sort:           sort + 1,
			ModifyTime:     time.Now(),
			CreateTime:     time.Now(),
		}
		insertId, er := sciHqClassify.Add()
		if er != nil {
			return false, er
		}
		sciHqClassifyList := []*data_manage.BaseFromSciHqClassify{
			{
				ClassifyName:   "价格",
				ClassifyNameEn: "价格",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           1,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
			{
				ClassifyName:   "供应",
				ClassifyNameEn: "供应",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           2,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
			{
				ClassifyName:   "需求",
				ClassifyNameEn: "需求",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           3,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
			{
				ClassifyName:   "库存",
				ClassifyNameEn: "库存",
				ParentId:       int(insertId),
				Level:          2,
				Sort:           4,
				ModifyTime:     time.Now(),
				CreateTime:     time.Now(),
			},
		}
		err = data_manage.BatchAddSciHqClassify(sciHqClassifyList)
		if err != nil {
			return
		}
	}
	return true, nil
}

func DelSciHqClassify(classifyId int) (err error) {
	classify, err := data_manage.GetSciHqClassifyById(classifyId)
	if err != nil {
		return
	}
	var classifyIds []int
	if classify.ParentId == 0 {
		classifyIds, err = data_manage.GetChildSciHqClassifyIdsById(classify.ClassifyId)
		if err != nil {
			return
		}
	} else {
		classifyIds = append(classifyIds, classify.ClassifyId)
	}
	// 获取分类下的所有指标
	count, err := data_manage.GetBaseFromSciIndexCountByClassifyIds(classifyIds)
	if err != nil {
		err = errors.New("获取分类下的指标信息失败,Err:" + err.Error())
		return
	}
	if count > 0 {
		err = errors.New("该分类下有指标，不可删除")
		return
	}
	// 删除对应的分类
	err = data_manage.DeleteSciHqClassifyByClassifyId(classifyIds)
	if err != nil {
		return
	}
	return
}

// ResetSciHqIndex 指标数据清除分类接口
func ResetSciHqIndex(indexId int) (err error) {
	sciHqIndex, err := data_manage.GetSciHqIndexByIndexId(indexId)
	if err != nil {
		return
	}

	// 更新指标在未分类下的排序，永远排在未分类的最后一个
	//移动排序
	classifyId := 0
	updateCol := make([]string, 0)
	var currentSort, prevSort int
	currentSort = sciHqIndex.Sort
	//未分类的最大的sort值
	prevSort, err = data_manage.GetSciHqIndexMaxSortByClassifyId(classifyId)
	if err != nil {
		err = errors.New("获取上一个兄弟节点指标信息失败,Err:" + err.Error())
		return
	}

	//如果前面一个节点的sort值比当前大，则当前节点往下移动
	if prevSort >= currentSort {
		//往下移动
		err = data_manage.MoveDownSciIndexBySort(classifyId, prevSort, currentSort)
		if err != nil {
			err = errors.New("向下移动出错:" + err.Error())
			return
		}
		sciHqIndex.Sort = prevSort
	}

	//更新
	sciHqIndex.ModifyTime = time.Now()
	sciHqIndex.ClassifyId = classifyId
	updateCol = append(updateCol, "Sort", "ModifyTime", "ClassifyId")
	err = sciHqIndex.Update(updateCol)
	if err != nil {
		err = errors.New("移动失败,Err:" + err.Error())
		return
	}
	return
}

// 批量删除卓创红期指标
func BatchDelSciHqData(indexIds []int) (existIndex []*data_manage.BaseFromSciHqIndex, err error) {
	sciHqIndexList, err := data_manage.GetSciHqIndexListByIndexIds(indexIds)
	if err != nil {
		return
	}

	indexCodes := make([]string, 0)
	codeToIndex := make(map[string]*data_manage.BaseFromSciHqIndex)
	for _, v := range sciHqIndexList {
		indexCodes = append(indexCodes, v.IndexCode)
		codeToIndex[v.IndexCode] = v
	}

	edbInfoList, err := data_manage.GetEdbInfoListByEdbCodes(utils.DATA_SOURCE_SCI_HQ, indexCodes)
	if err != nil {
		return
	}
	for _, v := range edbInfoList {
		if index, ok := codeToIndex[v.EdbCode]; ok {
			existIndex = append(existIndex, index)
			delete(codeToIndex, v.EdbCode)
		}
	}

	// 删除对应的指标
	err = data_manage.DeleteSciHqIndexByIds(indexIds)
	if err != nil {
		return
	}
	return
}

// DelSciHqData 删除卓创红期指标
func DelSciHqData(indexId int) (err error, errMsg string) {
	baseFromSciHqIndex, err := data_manage.GetSciHqIndexByIndexId(indexId)
	if err != nil {
		errMsg = `获取数据失败`
		if err.Error() == utils.ErrNoRow() {
			errMsg = `该指标未入库`
			err = nil
		}
		return
	}

	// 获取已经加入到EDB指标库的Sci指标
	edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_SCI_HQ, baseFromSciHqIndex.IndexCode)
	if err != nil && err.Error() != utils.ErrNoRow() {
		errMsg = "删除失败"
		err = errors.New("获取分类下的指标信息失败,Err:" + err.Error())
		return
	}
	if edbInfo != nil {
		errMsg = "当前指标已被引用，不可删除"
		err = nil
		return
	}

	// 删除对应的指标
	err = data_manage.DeleteSciHqIndexById(indexId)
	if err != nil {
		return
	}

	return
}

// EditSciHqIndex 编辑卓创红期指标
func EditSciHqIndex(indexId, classifyId int) (baseFromSciHqIndex *data_manage.BaseFromSciHqIndex, err error) {
	baseFromSciHqIndex, err = data_manage.GetSciHqIndexByIndexId(indexId)
	if err != nil {
		return
	}

	baseFromSciHqIndex.ClassifyId = classifyId
	baseFromSciHqIndex.ModifyTime = time.Now()
	err = baseFromSciHqIndex.Update([]string{"ClassifyId", "ModifyTime"})
	return
}

type SciIndexSource2EdbReq struct {
	EdbCode       string
	EdbName       string
	Frequency     string
	Unit          string
	ClassifyId    int
	AdminId       int
	AdminRealName string
}

// SciHqIndexSource2Edb 新增卓创红期数据从数据源到指标库
func SciHqIndexSource2Edb(req SciIndexSource2EdbReq, lang string) (edb *data_manage.EdbInfo, errMsg string, skip bool, err error) {
	if req.EdbCode == "" {
		err = fmt.Errorf("指标ID为空")
		return
	}
	defer func() {
		if err != nil {
			tips := fmt.Sprintf("SciHqIndexSource2Edb新增失败, Err: %s", err.Error())
			fmt.Println(tips)
			utils.FileLog.Info(tips)
		}
	}()
	source := utils.DATA_SOURCE_SCI_HQ

	// 是否新增过指标
	exist, e := data_manage.GetEdbInfoByEdbCode(source, req.EdbCode)
	if e != nil && e.Error() != utils.ErrNoRow() {
		err = fmt.Errorf("获取指标是否存在失败, err: %s", e.Error())
		return
	}
	if exist != nil {
		skip = true
		return
	}

	// 开始结束时间
	var startDate, endDate string

	// 新增指标库
	edbInfo, e, msg, _ := EdbInfoAdd(source, utils.DATA_SUB_SOURCE_EDB, req.ClassifyId, req.EdbCode, req.EdbName, req.Frequency, req.Unit, startDate, endDate, req.AdminId, req.AdminRealName, lang)
	if e != nil {
		errMsg = msg
		err = fmt.Errorf("EdbInfo: 新增指标失败, err: %s", e.Error())
		return
	}

	edb = edbInfo

	return
}