eta_api/services/data/base_from_smm.go

/**
* @Author: jgl
* @Date: 2021/9/14 11:15
 */

package data

import (
	"errors"
	"eta_gn/eta_api/models/data_manage"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/utils"
	"time"
)

type YsIndex struct {
	Code int64 `json:"code"`
	Data struct {
		Apis []struct {
			Aid           int64  `json:"aid"`
			APILabel      string `json:"api_label"`
			APIStartTime  string `json:"api_start_time"`
			APIType       int64  `json:"api_type"`
			APITypeAll    string `json:"api_type_all"`
			APIUpdate     int64  `json:"api_update"`
			APIUpdateTime string `json:"api_update_time"`
			APIUpdateType string `json:"api_update_type"`
			AuthDur       int64  `json:"auth_dur"`
			AuthDurType   string `json:"auth_dur_type"`
			AuthLang      string `json:"auth_lang"`
			AuthModule    string `json:"auth_module"`
			EditPerson    string `json:"edit_person"`
			EditTime      string `json:"edit_time"`
			Enable        string `json:"enable"`
			FinishTime    string `json:"finish_time"`
			Interface     string `json:"interface"`
			Name          string `json:"name"`
			StartTime     string `json:"start_time"`
			Type1         string `json:"type_1"`
			Type2         string `json:"type_2"`
			Type3         string `json:"type_3"`
		} `json:"apis"`
		Types []struct {
			Name string `json:"name"`
			Tid  int64  `json:"tid"`
		} `json:"types"`
	} `json:"data"`
	Msg string `json:"msg"`
}

const (
	dataUrl = "https://dataapi.smm.cn/GetData/" //data url (中文)
	//dataUrl = "https://dataapi.smm.cn/GetDataEn/" //data url (english edition)
	authUrl = "https://platform.smm.cn/usercenter/auth" // auth url (for all)
)

type TokenResp struct {
	Code int       `json:"Code"`
	Msg  string    `json:"Msg"`
	Data TokenData `json:"Data"`
}

type TokenData struct {
	Token string `json:"Token"`
}

// request response
type DataResp struct {
	Code int      `json:"Code"`
	Msg  string   `json:"Msg"`
	Data *ApiData `json:"Data"`
}

// api data response
type ApiData struct {
	Status  int        `json:"Status"` //0 no permission，1 ok
	Field   []ApiField `json:"Field"`
	Content [][]string `json:"Content"`
}

// api title
type ApiField struct {
	Unit       string `json:"Unit"`
	Info       string `json:"Info"`
	Name       string `json:"Name"`
	ColumnType string `json:"ColumnType"`
	ColIndex   uint   `json:"ColIndex"`
	IsDate     string `json:"IsDate"`
}

type YsResult struct {
	Code int64 `json:"Code"`
	Data struct {
		CompanyList []interface{} `json:"CompanyList"`
		Content     [][]string    `json:"Content"`
		Field       []struct {
			ColIndex   int64  `json:"ColIndex"`
			ColumnType string `json:"ColumnType"`
			Info       string `json:"Info"`
			IsDate     string `json:"IsDate"`
			Name       string `json:"Name"`
			Unit       string `json:"Unit"`
			DBColName  string `json:"db_col_name"`
		} `json:"Field"`
		CountPage   int64  `json:"count_page"`
		CurrentPage int64  `json:"current_page"`
		Frequency   string `json:"frequency"`
		Mindate     string `json:"mindate"`
		PageNum     int64  `json:"page_num"`
		Status      int64  `json:"status"`
		TotalNum    int64  `json:"total_num"`
	} `json:"Data"`
	Msg string `json:"Msg"`
}

// AddSmmClassify 添加SMM分类
func AddSmmClassify(classifyName string, parentId, sysUserId int, sysUserName, lang string) (classifyInfo *data_manage.BaseFromSmmClassify, err error, errMsg string) {
	// 校验分类名称相同的数量
	{
		var count int
		switch lang {
		case utils.EnLangVersion:
			count, err = data_manage.GetBaseFromSmmClassifyEnCount(classifyName, parentId)
		default:
			count, err = data_manage.GetBaseFromSmmClassifyCount(classifyName, parentId)
		}
		if err != nil {
			errMsg = `判断名称是否已存在失败`
			return
		}
		if count > 0 {
			errMsg = `分类名称已存在，请重新输入`
			err = errors.New(errMsg)
			return
		}
	}

	level := 1
	if parentId > 0 {
		parentClassify, e := data_manage.GetBaseFromSmmClassifyById(parentId)
		if e != nil {
			if utils.IsErrNoRow(e) {
				err = e
				errMsg = `一级分类不存在`
				return
			}
			err = e
			errMsg = `查询一级分类失败`
			return
		}
		level = parentClassify.Level + 1
	}
	classifyInfo = &data_manage.BaseFromSmmClassify{
		ClassifyName:    classifyName,
		ClassifyNameEn:  classifyName,
		ParentId:        parentId,
		SysUserId:       sysUserId,
		SysUserRealName: sysUserName,
		Sort:            0,
		Level:           level,
		ModifyTime:      time.Now(),
		CreateTime:      time.Now(),
	}
	classifyId, err := data_manage.AddBaseFromSmmClassify(classifyInfo)
	if err != nil {
		errMsg = "保存分类失败"
		return
	}
	classifyInfo.ClassifyId = int(classifyId)
	//更新sort为classifyId
	err = data_manage.UpdateBaseFromSmmClassifySort(int(classifyId))
	return
}

// EditSmmClassify 编辑Smm分类
func EditSmmClassify(classifyId int, classifyName, lang string, sysUser *system.Admin) (err error, errMsg string) {
	item, err := data_manage.GetBaseFromSmmClassifyById(classifyId)
	if err != nil {
		errMsg = `保存失败`
		return
	}

	switch lang {
	case utils.EnLangVersion:
		// 名字相同，那么就直接返回
		if item.ClassifyNameEn == classifyName {
			return
		}

		// 判断名称是否已存在
		count, tmpErr := data_manage.GetBaseFromSmmClassifyEnCount(classifyName, item.ParentId)
		if tmpErr != nil {
			err = tmpErr
			errMsg = "判断名称是否已存在失败"
			return
		}
		if count > 0 {
			errMsg = "分类名称已存在，请重新输入"
			err = errors.New(errMsg)
			return
		}

		// 修改数据
		err = data_manage.EditBaseFromSmmClassifyEn(classifyId, classifyName)
		if err != nil {
			errMsg = "保存失败"
		}
	default:
		// 名字相同，那么就直接返回
		if item.ClassifyName == classifyName {
			return
		}

		// 判断名称是否已存在
		count, tmpErr := data_manage.GetBaseFromSmmClassifyCount(classifyName, item.ParentId)
		if tmpErr != nil {
			err = tmpErr
			errMsg = "判断名称是否已存在失败"
			return
		}
		if count > 0 {
			errMsg = "分类名称已存在，请重新输入"
			err = errors.New(errMsg)
			return
		}

		// 修改数据
		err = data_manage.EditBaseFromSmmClassify(classifyId, classifyName)
		if err != nil {
			errMsg = "保存失败"
		}
	}

	return
}

// MoveSmmClassify 移动Smm分类
func MoveSmmClassify(classifyId, parentClassifyId, prevClassifyId, nextClassifyId int) (err error, errMsg string) {
	//判断分类是否存在
	classifyInfo, err := data_manage.GetBaseFromSmmClassifyById(classifyId)
	if err != nil {
		errMsg = "移动失败"
		err = errors.New("获取分类信息失败,Err:" + err.Error())
		return
	}

	updateCol := make([]string, 0)

	//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
	if classifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {
		parentClassifyInfo, tmpErr := data_manage.GetBaseFromSmmClassifyById(parentClassifyId)
		if tmpErr != nil {
			errMsg = "移动失败"
			err = errors.New("获取上级分类信息失败,Err:" + tmpErr.Error())
			return
		}
		classifyInfo.ParentId = parentClassifyInfo.ClassifyId
		classifyInfo.Level = parentClassifyInfo.Level + 1
		updateCol = append(updateCol, "ParentId", "Level")
	}
	var currentSort, prevSort, nextSort int
	currentSort = classifyInfo.Sort

	var prevClassify *data_manage.BaseFromSmmClassify
	var nextClassify *data_manage.BaseFromSmmClassify
	//如果有传入 上一个兄弟节点分类id
	if prevClassifyId > 0 {
		prevClassify, err = data_manage.GetBaseFromSmmClassifyById(prevClassifyId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "移动失败"
				err = errors.New("上一个兄弟节点分类信息不存在" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取上一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		prevSort = prevClassify.Sort
	}
	if nextClassifyId > 0 {
		//下一个兄弟节点
		nextClassify, err = data_manage.GetBaseFromSmmClassifyById(nextClassifyId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "移动失败"
				err = errors.New("下一个兄弟节点分类信息不存在" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + err.Error())
			return
		}
		nextSort = nextClassify.Sort
	}
	// 修改历史数据中的排序为0的情况
	if prevSort == 0 && nextSort == 0 { //目标是让当前分类处于目录的最顶部
		//更新为0排序的数据为当前最小排序
		if nextClassify != nil {
			minSort, e := data_manage.GetSmmIndexClassifyMinSort(parentClassifyId)
			if e != nil {
				errMsg = "移动失败"
				err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + e.Error())
				return
			}
			if minSort > 1 {
				minSort -= 1
			}
			nextClassify.Sort = minSort
			err = nextClassify.Update([]string{"Sort"})
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("更新下一个兄弟节点分类信息失败,Err:" + err.Error())
				return
			}
			nextSort = minSort
		}
	}
	//移到两个排序值中间操作
	if prevSort >= currentSort {
		//往下移动
		err = data_manage.MoveDownSmmIndexClassifyBySort(parentClassifyId, prevSort, currentSort)
		if err != nil {
			err = errors.New("向下移动出错:" + err.Error())
			return
		}
		classifyInfo.Sort = prevSort
	} else if nextSort <= currentSort && nextSort != 0 {
		//往上移动
		err = data_manage.MoveUpSmmIndexClassifyBySort(parentClassifyId, nextSort, currentSort)
		if err != nil {
			err = errors.New("向上移动出错:" + err.Error())
			return
		}
		classifyInfo.Sort = nextSort
	}
	classifyInfo.ModifyTime = time.Now()
	updateCol = append(updateCol, "Sort", "ModifyTime")
	err = classifyInfo.Update(updateCol)
	if err != nil {
		errMsg = "移动失败"
		err = errors.New("修改失败,Err:" + err.Error())
		return
	}
	return
}

// DelSmmClassify 删除SMM分类
func DelSmmClassify(classifyId int, sysUser *system.Admin) (err error, errMsg string) {
	//判断分类是否存在
	classifyInfo, err := data_manage.GetBaseFromSmmClassifyById(classifyId)
	if err != nil {
		errMsg = "删除失败"
		err = errors.New("获取分类信息失败,Err:" + err.Error())
		return
	}

	// 需要删除的分类id集合
	classifyIdList := make([]int, 0)
	classifyIdList = append(classifyIdList, classifyId)
	// 查找所有的子集id
	if classifyInfo.ParentId <= 0 {
		childrenClassifyInfoList, tmpErr := data_manage.GetBaseFromSmmClassifyByParentId(classifyId)
		if tmpErr != nil {
			errMsg = "删除失败"
			err = errors.New("获取分类信息失败,Err:" + tmpErr.Error())
			return
		}
		for _, v := range childrenClassifyInfoList {
			classifyIdList = append(classifyIdList, v.ClassifyId)
		}
	}

	// 获取分类下的所有指标
	count, err := data_manage.GetBaseFromSmmIndexCountByClassifyIds(classifyIdList)
	if err != nil {
		errMsg = "删除失败"
		err = errors.New("获取分类下的指标信息失败,Err:" + err.Error())
		return
	}

	if count > 0 {
		errMsg = "该分类下有指标，不可删除"
		err = errors.New("该分类下有指标，不可删除")
		return
	}

	// 删除对应的分类
	err = data_manage.DeleteSmmClassifyByClassifyId(classifyIdList)
	if err != nil {
		return
	}
	return
}

// MoveSmmData2 移动SMM指标
func MoveSmmData2(indexId, classifyId, prevIndexId, nextIndexId int) (err error, errMsg string) {
	//分类信息
	smmIndex, err := data_manage.GetBaseFromSmmIndexByIndexId(indexId)
	if err != nil {
		errMsg = `获取数据失败`
		if utils.IsErrNoRow(err) {
			errMsg = `该指标未入库`
			err = nil
		}
		return
	}

	//判断分类是否存在
	if classifyId > 0 {
		_, err = data_manage.GetBaseFromSmmClassifyById(classifyId)
		if err != nil {
			errMsg = "移动失败"
			err = errors.New("获取分类信息失败,Err:" + err.Error())
			if utils.IsErrNoRow(err) {
				errMsg = "找不到该分类"
				err = nil
			}
			return
		}
	}

	//如果改变了分类，那么移动该图表数据
	if smmIndex.ClassifyId != classifyId {
		tmpErr := data_manage.MoveBaseFromSmmIndex(indexId, classifyId)
		if tmpErr != nil {
			errMsg = "移动失败"
			err = errors.New("移动失败,Err:" + tmpErr.Error())
			return
		}
	}

	//移动排序
	updateCol := make([]string, 0)
	var currentSort, prevSort, nextSort int
	currentSort = smmIndex.Sort
	//如果有传入 上一个兄弟节点分类id
	var prevIndex *data_manage.BaseFromSmmIndex
	var nextIndex *data_manage.BaseFromSmmIndex
	if prevIndexId > 0 {
		prevIndex, err = data_manage.GetBaseFromSmmIndexByIndexId(prevIndexId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "移动失败"
				err = errors.New("上一个兄弟节点指标信息不存在" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取上一个兄弟节点指标信息失败,Err:" + err.Error())
			return
		}
		prevSort = prevIndex.Sort
	}

	if nextIndexId > 0 {
		//下一个兄弟节点
		nextIndex, err = data_manage.GetBaseFromSmmIndexByIndexId(nextIndexId)
		if err != nil {
			if utils.IsErrNoRow(err) {
				errMsg = "移动失败"
				err = errors.New("下一个兄弟节点指标信息不存在" + err.Error())
				return
			}
			errMsg = "移动失败"
			err = errors.New("获取下一个兄弟节点指标信息失败,Err:" + err.Error())
			return
		}
		nextSort = nextIndex.Sort
	}

	// 修改历史数据中的排序为0的情况
	if prevSort == 0 && nextSort == 0 { //目标是让当前分类处于目录的最顶部, 但是历史数据里下个节点的sort为0的情况
		//更新为0排序的数据为当前最小排序
		if nextIndex != nil {
			minSort, e := data_manage.GetBaseFromSmmIndexMinSortByClassifyId(classifyId)
			if e != nil {
				errMsg = "移动失败"
				err = errors.New("获取下一个兄弟节点分类信息失败,Err:" + e.Error())
				return
			}
			if minSort > 1 {
				minSort -= 1
			}
			nextIndex.Sort = minSort
			err = nextIndex.Update([]string{"Sort"})
			if err != nil {
				errMsg = "移动失败"
				err = errors.New("更新下一个兄弟节点分类信息失败,Err:" + err.Error())
				return
			}
			nextSort = minSort
		}
	}
	//移到两个排序值中间操作
	if prevSort >= currentSort {
		//往下移动
		err = data_manage.MoveDownSmmIndexBySort(classifyId, prevSort, currentSort)
		if err != nil {
			err = errors.New("向下移动出错:" + err.Error())
			return
		}
		smmIndex.Sort = prevSort
	} else if nextSort <= currentSort && nextSort != 0 {
		//往上移动
		err = data_manage.MoveUpSmmIndexBySort(classifyId, nextSort, currentSort)
		if err != nil {
			err = errors.New("向上移动出错:" + err.Error())
			return
		}
		smmIndex.Sort = nextSort
	}

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

// EditSmmIndex 编辑SMM指标
func EditSmmIndex(indexId, classifyId int, sysUser *system.Admin) (baseFromSmmIndex *data_manage.BaseFromSmmIndex, err error, errMsg string) {
	baseFromSmmIndex, err = data_manage.GetBaseFromSmmIndexByIndexId(indexId)
	if err != nil {
		errMsg = `获取数据失败`
		if utils.IsErrNoRow(err) {
			errMsg = `该指标未入库`
			err = nil
		}
		return
	}

	baseFromSmmIndex.ClassifyId = classifyId
	baseFromSmmIndex.ModifyTime = time.Now()
	err = baseFromSmmIndex.Update([]string{"ClassifyId", "ModifyTime"})
	if err != nil {
		errMsg = "保存分类失败"
	}

	return
}

// DelSmmData 删除SMM指标
func DelSmmData(indexId int) (err error, errMsg string) {
	baseFromSmmIndex, err := data_manage.GetBaseFromSmmIndexByIndexId(indexId)
	if err != nil {
		errMsg = `获取数据失败`
		if utils.IsErrNoRow(err) {
			errMsg = `该指标未入库`
			err = nil
		}
		return
	}

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

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

	return
}

// ResetSmmData 指标数据清除分类接口
func ResetSmmData(indexId int) (err error, errMsg string) {
	smmIndex, err := data_manage.GetBaseFromSmmIndexByIndexId(indexId)
	if err != nil {
		errMsg = `获取数据失败`
		if utils.IsErrNoRow(err) {
			errMsg = `该指标未入库`
			err = nil
		}
		return
	}

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

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

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