eta_api/services/eta_forum/eta_forum_hub.go

package eta_forum

import (
	"encoding/json"
	"eta/eta_api/models/data_manage"
	"eta/eta_api/models/data_manage/chart_theme"
	"eta/eta_api/models/system"
	"eta/eta_api/services/alarm_msg"
	"eta/eta_api/utils"
	"fmt"
	"strconv"
	"time"
)

type UploadChartToForumReq struct {
	ChartInfoId int    `description:"图表ID"`
	Description string `description:"逻辑简述"`
}

type UpdateChartToForumReq struct {
	ChartInfoId int `description:"图表ID"`
}

type ChartSaveLibReq struct {
	ChartInfo               *data_manage.ChartInfo
	Description             []*data_manage.ChartDescriptionReq `description:"逻辑简述"`
	EdbInfoList             []*data_manage.EdbInfo
	ChartThemeList          []*chart_theme.ChartTheme
	EdbInfoDataList         []*AddEdbDataReq
	ChartEdbMapping         []*data_manage.ChartEdbMapping
	EdbInfoCalculateMapping []*data_manage.EdbInfoCalculateMapping
	ChartSeries             []*data_manage.ChartSeries
	ChartSeriesEdbMapping   []*data_manage.ChartSeriesEdbMapping
	CreatorInfo             *system.Admin //创建者的账号信息
	UploaderInfo            *system.Admin //上传者的账号信息
}

type ChartSaveLibResp struct {
	Ret         int
	Msg         string
	ErrMsg      string
	ErrCode     string
	Data        *data_manage.AddChartInfoResp
	Success     bool `description:"true 执行成功，false 执行失败"`
	IsSendEmail bool `json:"-" description:"true 发送邮件，false 不发送邮件"`
	IsAddLog    bool `json:"-" description:"true 新增操作日志，false 不新增操作日志" `
}

type AddEdbDataReq struct {
	EdbCode  string
	EdbType  int
	DataList []*data_manage.EdbDataBase
}

type DeleteChartReq struct {
	ChartInfoId int `description:"图表id"`
}

// UploadChart 上传图表接口
func UploadChart(chartInfoId int, description string, uploaderInfo *system.Admin) (err error, errMsg string) {
	// 设置缓存 防止重复上传
	cacheKey := "eta_forum_task:UploadChart:" + strconv.Itoa(chartInfoId)
	if utils.Rc.Get(cacheKey) != nil {
		err = fmt.Errorf("系统处理中，请稍后重试！")
		return
	}
	utils.Rc.SetNX(cacheKey, 1, 10*time.Minute)
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg(fmt.Sprintf("上传图表至社区失败：Err:%v,ErrMsg:%s", err, errMsg), 3)
		}
		utils.Rc.Delete(cacheKey)
	}()
	// 查询图表信息
	chartInfo, err := data_manage.GetChartInfoById(chartInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			errMsg = "图表不存在"
			err = fmt.Errorf(errMsg)
			return
		}
		errMsg = "获取图表信息失败"
		err = fmt.Errorf("获取图表信息失败,Err:" + err.Error())
		return
	}
	if chartInfo.ForumChartInfoId > 0 {
		errMsg = "该图表已上传至社区，无法再次上传"
		err = fmt.Errorf(errMsg)
		return
	}
	//查询图表主题

	//查询图表指标
	//获取原图表关联的指标信息列表
	chartMappingList, err := data_manage.GetChartMappingListOrderByEdbInfoId(chartInfoId)
	if err != nil {
		errMsg = "获取图表关联的指标信息失败"
		err = fmt.Errorf("获取图表关联的指标信息失败,Err:" + err.Error())
		return
	}
	edbIds := make([]int, 0)
	edbInfoStr := ""
	for _, v := range chartMappingList {
		edbIds = append(edbIds, v.EdbInfoId)
		edbInfoStr += strconv.Itoa(v.EdbInfoId) + ","
	}
	chartSeriesList := make([]*data_manage.ChartSeries, 0)
	chartSeriesEdbList := make([]*data_manage.ChartSeriesEdbMapping, 0)
	if chartInfo.ChartType == utils.CHART_TYPE_SECTION_COMBINE {
		chartSeriesList, err = data_manage.GetChartSeriesByChartInfoId(chartInfoId)
		if err != nil {
			errMsg = "获取图表关联的系列信息失败"
			err = fmt.Errorf("获取图表关联的系列信息失败,Err:" + err.Error())
			return
		}

		chartSeriesEdbList, err = data_manage.GetChartSeriesEdbByChartInfoId(chartInfoId)
		if err != nil {
			errMsg = "获取图表关联的系列指标信息失败"
			err = fmt.Errorf("获取图表关联的系列指标信息失败,Err:" + err.Error())
			return
		}
	}

	var (
		edbInfoList     []*data_manage.EdbInfo
		edbMappingList  []*data_manage.EdbInfoCalculateMapping
		edbInfoDataList []*AddEdbDataReq
	)
	//查询指标详情
	edbInfoList, edbMappingList, edbInfoDataList, err = GetEdbListByEdbInfoId(edbIds, true)
	if err != nil {
		errMsg = "获取指标详情失败"
		err = fmt.Errorf("获取指标详情失败,Err:" + err.Error())
		return
	}

	descriptionList, err, errMsg := getChartDescriptionWithAdminNameByChartInfoId(chartInfoId)
	if err != nil {
		errMsg = "获取图表简介失败"
		err = fmt.Errorf("获取图表简介失败,Err:" + err.Error())
		return
	}

	req := new(ChartSaveLibReq)
	req.ChartInfo = chartInfo
	req.ChartEdbMapping = chartMappingList
	req.EdbInfoList = edbInfoList
	req.EdbInfoDataList = edbInfoDataList
	req.EdbInfoCalculateMapping = edbMappingList
	req.Description = descriptionList
	req.ChartSeries = chartSeriesList
	req.ChartSeriesEdbMapping = chartSeriesEdbList

	// 查询创建者信息
	creatorInfo, _ := system.GetSysAdminById(chartInfo.SysUserId)
	if creatorInfo != nil {
		req.CreatorInfo = creatorInfo
	}

	req.UploaderInfo = uploaderInfo
	// 添加计算指标
	reqJson, err := json.Marshal(req)
	if err != nil {
		errMsg = "参数解析异常"
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := ChartSaveLib(string(reqJson))
	if err != nil {
		errMsg = "上传失败"
		err = fmt.Errorf("上传失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		errMsg = "上传失败"
		err = fmt.Errorf(respItem.ErrMsg)
		return
	}

	if respItem.Data != nil && respItem.Data.ChartInfoId != 0 {
		// 更新社区返回的图表ID
		err = data_manage.SetForumChartInfoId(chartInfoId, respItem.Data.ChartInfoId, utils.ChartClassifyResourceStatusUp)
		if err != nil {
			errMsg = "更新图表ID失败"
			err = fmt.Errorf("更新图表ID失败,Err:" + err.Error())
			return
		}
		// 新增投研资源库里的图表和指标绑定关系
		err = data_manage.AddForumChartEdbMapping(chartInfoId, edbInfoStr)
		if err != nil {
			errMsg = "新增投研资源库里的图表和指标绑定关系失败"
			err = fmt.Errorf("新增投研资源库里的图表和指标绑定关系失败,Err:" + err.Error())
			return
		}
	}

	return
}

// UpdateChart 更新社区里的图表接口
func UpdateChart(chartInfoId int) (err error, errMsg string) {
	// 设置缓存 防止重复更新
	cacheKey := "eta_forum_task:UpdateChart:" + strconv.Itoa(chartInfoId)
	if utils.Rc.Get(cacheKey) != nil {
		err = fmt.Errorf("系统处理中，请稍后重试！")
		return
	}
	utils.Rc.SetNX(cacheKey, 1, 10*time.Minute)
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg(fmt.Sprintf("同步图表信息至社区失败：Err:%v,ErrMsg:%s", err, errMsg), 3)
		}
		utils.Rc.Delete(cacheKey)
	}()
	// 查询图表信息
	chartInfo, err := data_manage.GetChartInfoById(chartInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			errMsg = "图表不存在"
			err = fmt.Errorf(errMsg)
			return
		}
		errMsg = "获取图表信息失败"
		err = fmt.Errorf("获取图表信息失败,Err:" + err.Error())
		return
	}

	if chartInfo.ForumChartInfoId <= 0 {
		errMsg = "该图表未上传至社区"
		err = fmt.Errorf(errMsg)
		return
	}
	//查询图表主题

	//查询图表指标
	//获取原图表关联的指标信息列表
	chartMappingList, err := data_manage.GetChartMappingListOrderByEdbInfoId(chartInfoId)
	if err != nil {
		errMsg = "获取图表关联的指标信息失败"
		err = fmt.Errorf("获取图表关联的指标信息失败,Err:" + err.Error())
		return
	}
	edbIds := make([]int, 0)
	edbInfoStr := ""
	for _, v := range chartMappingList {
		edbIds = append(edbIds, v.EdbInfoId)
		edbInfoStr += strconv.Itoa(v.EdbInfoId) + ","
	}
	chartSeriesList := make([]*data_manage.ChartSeries, 0)
	chartSeriesEdbList := make([]*data_manage.ChartSeriesEdbMapping, 0)
	if chartInfo.ChartType == utils.CHART_TYPE_SECTION_COMBINE {
		chartSeriesList, err = data_manage.GetChartSeriesByChartInfoId(chartInfoId)
		if err != nil {
			errMsg = "获取图表关联的系列信息失败"
			err = fmt.Errorf("获取图表关联的系列信息失败,Err:" + err.Error())
			return
		}

		chartSeriesEdbList, err = data_manage.GetChartSeriesEdbByChartInfoId(chartInfoId)
		if err != nil {
			errMsg = "获取图表关联的系列指标信息失败"
			err = fmt.Errorf("获取图表关联的系列指标信息失败,Err:" + err.Error())
			return
		}
	}
	var (
		edbInfoList     []*data_manage.EdbInfo
		edbMappingList  []*data_manage.EdbInfoCalculateMapping
		edbInfoDataList []*AddEdbDataReq
	)
	//查询指标详情
	isGetEdbData := false
	// 查询投研资源库里的图表和指标绑定关系
	oldEdbInfoStr, err := data_manage.GetForumEdbInfoIdsByChartInfoId(chartInfoId)
	if err != nil {
		errMsg = "获取投研资源库里的图表和指标绑定关系失败"
		err = fmt.Errorf("获取投研资源库里的图表和指标绑定关系失败,Err:" + err.Error())
		return
	}
	if oldEdbInfoStr != edbInfoStr { // 图表更换过指标需要重新获取指标数据
		isGetEdbData = true
	}
	//查询指标详情
	edbInfoList, edbMappingList, edbInfoDataList, err = GetEdbListByEdbInfoId(edbIds, isGetEdbData)
	if err != nil {
		errMsg = "获取指标详情失败"
		err = fmt.Errorf("获取指标详情失败,Err:" + err.Error())
		return
	}
	descriptionList, err, errMsg := getChartDescriptionWithAdminNameByChartInfoId(chartInfoId)
	if err != nil {
		errMsg = "获取图表简介失败"
		err = fmt.Errorf("获取图表简介失败,Err:" + err.Error())
		return
	}
	req := new(ChartSaveLibReq)
	req.ChartInfo = chartInfo
	req.ChartInfo.ChartInfoId = chartInfo.ForumChartInfoId
	req.ChartEdbMapping = chartMappingList
	req.EdbInfoList = edbInfoList
	req.EdbInfoDataList = edbInfoDataList
	req.EdbInfoCalculateMapping = edbMappingList
	req.ChartSeries = chartSeriesList
	req.ChartSeriesEdbMapping = chartSeriesEdbList
	req.Description = descriptionList
	// 查询创建者信息
	creatorInfo, _ := system.GetSysAdminById(chartInfo.SysUserId)
	if creatorInfo != nil {
		req.CreatorInfo = creatorInfo
	}

	// 添加计算指标
	reqJson, err := json.Marshal(req)
	if err != nil {
		errMsg = "参数解析异常"
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := ChartUpdateLib(string(reqJson))
	if err != nil {
		errMsg = "更新失败"
		err = fmt.Errorf("上传失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		errMsg = "更新失败"
		err = fmt.Errorf(respItem.ErrMsg)
		return
	}

	// 更新投研资源库里的图表和指标绑定关系
	err = data_manage.UpdateForumChartEdbMapping(chartInfoId, edbInfoStr)
	if err != nil {
		errMsg = "更新投研资源库里的图表和指标绑定关系失败"
		err = fmt.Errorf("更新投研资源库里的图表和指标绑定关系失败,Err:" + err.Error())
		return
	}
	return
}

func GetEdbListByEdbInfoId(edbInfoIds []int, isGetEdbData bool) (edbInfoList []*data_manage.EdbInfo, edbMappingList []*data_manage.EdbInfoCalculateMapping, edbInfoDataList []*AddEdbDataReq, err error) {
	//查询指标信息
	//查询指标映射
	//查询所有指标数据
	//查询这个指标相关的mapping信息放到数组里，
	//将得到的指标ID信息放到数组里
	chartEdbInfoIdMap := make(map[int]struct{}) //只查询图表上直接相关的指标数据
	hasFindMap := make(map[int]struct{})
	edbInfoIdMap := make(map[int]struct{})
	edbMappingList = make([]*data_manage.EdbInfoCalculateMapping, 0)
	edbMappingMap := make(map[int]struct{})
	for _, edbInfoId := range edbInfoIds {
		chartEdbInfoIdMap[edbInfoId] = struct{}{}
		edbMappingList, err = traceEdbInfoByEdbInfoId(edbInfoId, hasFindMap, edbInfoIdMap, edbMappingList, edbMappingMap)
		if err != nil {
			err = fmt.Errorf(" traceEdbInfoByEdbInfoId err: %s", err.Error())
			return
		}
	}

	// 指标信息map
	edbInfoIdList := make([]int, 0)
	for k, _ := range edbInfoIdMap {
		edbInfoIdList = append(edbInfoIdList, k)
	}
	edbInfoList, err = data_manage.GetEdbInfoByIdList(edbInfoIdList)
	if err != nil {
		err = fmt.Errorf(" GetEdbInfoByIdList err: %s", err.Error())
		return
	}
	if isGetEdbData {
		for _, v := range edbInfoList {
			if _, ok := chartEdbInfoIdMap[v.EdbInfoId]; !ok {
				continue
			}
			var dataList []*data_manage.EdbDataBase
			if v.Source == utils.DATA_SOURCE_BUSINESS && utils.UseMongo {
				dataList, err = data_manage.GetEdbDataBaseMongoByEdbInfoId(v.EdbInfoId, v.Source, v.SubSource)
			} else if v.Source == utils.DATA_SOURCE_THS && v.SubSource == utils.DATA_SUB_SOURCE_HIGH_FREQUENCY && utils.UseMongo {
				dataList, err = data_manage.GetThsHfEdbDataBaseMongoByEdbInfoId(v.EdbInfoId, v.Source, v.SubSource)
			} else {
				dataList, err = data_manage.GetEdbDataBaseByEdbInfoId(v.EdbInfoId, v.Source, v.SubSource)
			}

			if err != nil {
				err = fmt.Errorf("查询指标数据失败 Err: %s", err.Error())
				return
			}

			tmp := new(AddEdbDataReq)
			tmp.EdbCode = v.EdbCode
			tmp.EdbType = v.EdbType
			tmp.DataList = dataList
			edbInfoDataList = append(edbInfoDataList, tmp)
		}
	}
	return
}

// traceEdbInfoByEdbInfoId 指标追溯
func traceEdbInfoByEdbInfoId(edbInfoId int, hasFindMap map[int]struct{}, edbInfoIdMap map[int]struct{}, edbMappingList []*data_manage.EdbInfoCalculateMapping, edbMappingMap map[int]struct{}) (newEdbMappingList []*data_manage.EdbInfoCalculateMapping, err error) {
	newEdbMappingList = edbMappingList

	_, ok := hasFindMap[edbInfoId]
	if ok {
		return
	}

	if _, ok1 := edbInfoIdMap[edbInfoId]; !ok1 {
		edbInfoIdMap[edbInfoId] = struct{}{}
	}

	edbInfoMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
	if e != nil {
		err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error())
		return
	}

	if len(edbInfoMappingList) > 0 {
		fromEdbInfoIdList := make([]int, 0)
		for _, v := range edbInfoMappingList {
			fromEdbInfoIdList = append(fromEdbInfoIdList, v.FromEdbInfoId)
			if _, ok1 := edbInfoIdMap[v.FromEdbInfoId]; !ok1 {
				edbInfoIdMap[v.FromEdbInfoId] = struct{}{}
			}
			if _, ok2 := edbMappingMap[v.EdbInfoCalculateMappingId]; !ok2 {
				edbMappingMap[v.EdbInfoCalculateMappingId] = struct{}{}
				tmp := &data_manage.EdbInfoCalculateMapping{
					EdbInfoCalculateMappingId: v.EdbInfoCalculateMappingId,
					EdbInfoId:                 v.EdbInfoId,
					Source:                    v.Source,
					SourceName:                v.SourceName,
					EdbCode:                   v.EdbCode,
					FromEdbInfoId:             v.FromEdbInfoId,
					FromEdbCode:               v.FromEdbCode,
					FromEdbName:               v.FromEdbName,
					FromSource:                v.FromSource,
					FromSourceName:            v.FromSourceName,
					FromTag:                   v.FromTag,
					Sort:                      v.Sort,
					CreateTime:                v.CreateTime,
					ModifyTime:                v.ModifyTime,
				}
				newEdbMappingList = append(newEdbMappingList, tmp)
			}

			if edbInfoId != v.FromEdbInfoId && (v.FromEdbType == 2 || v.FromEdbInfoType == 1) {
				// 查过了就不查了
				if _, ok2 := hasFindMap[v.FromEdbInfoId]; !ok2 {
					newEdbMappingList, e = traceEdbInfoByEdbInfoId(v.FromEdbInfoId, hasFindMap, edbInfoIdMap, newEdbMappingList, edbMappingMap)
					if e != nil {
						err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", e.Error())
						return
					}
				}
			}
			hasFindMap[v.FromEdbInfoId] = struct{}{}
		}
	}

	hasFindMap[edbInfoId] = struct{}{}
	return
}

// DeleteChart 上传图表接口
func DeleteChart(chartInfoId int) (err error, errMsg string) {
	// 设置缓存 防止重复撤回
	cacheKey := "eta_forum_task:DeleteChart:" + strconv.Itoa(chartInfoId)
	if utils.Rc.Get(cacheKey) != nil {
		err = fmt.Errorf("系统处理中，请稍后重试！")
		return
	}
	utils.Rc.SetNX(cacheKey, 1, 30*time.Second)
	defer func() {
		if err != nil {
			go alarm_msg.SendAlarmMsg(fmt.Sprintf("撤回图表失败:%v,ErrMsg:%s", err, errMsg), 3)
		}
		utils.Rc.Delete(cacheKey)
	}()
	// 查询图表信息
	chartInfo, err := data_manage.GetChartInfoById(chartInfoId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			errMsg = "图表不存在"
			err = fmt.Errorf(errMsg)
			return
		}
		errMsg = "获取图表信息失败"
		err = fmt.Errorf("获取图表信息失败,Err:" + err.Error())
		return
	}
	if chartInfo.ForumChartInfoId <= 0 {
		errMsg = "该图表未上传至社区，无需撤回"
		err = fmt.Errorf(errMsg)
		return
	}

	req := new(DeleteChartReq)
	req.ChartInfoId = chartInfo.ForumChartInfoId

	// 添加计算指标
	reqJson, err := json.Marshal(req)
	if err != nil {
		errMsg = "参数解析异常"
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := ChartDeleteLib(string(reqJson))
	if err != nil {
		errMsg = "撤回失败"
		err = fmt.Errorf("撤回失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		errMsg = "撤回失败"
		err = fmt.Errorf(respItem.ErrMsg)
		return
	}

	// 更新社区返回的图表ID
	err = data_manage.SetForumChartInfoId(chartInfoId, 0, utils.ChartClassifyResourceStatusDown)
	if err != nil {
		errMsg = "撤回失败"
		err = fmt.Errorf("更新图表ID失败,Err:" + err.Error())
		return
	}
	// 删除投研资源库里的图表和指标绑定关系
	err = data_manage.DeleteForumChartEdbMapping(chartInfoId)
	if err != nil {
		errMsg = "删除投研资源库里的图表和指标绑定关系失败"
		err = fmt.Errorf("删除投研资源库里的图表和指标绑定关系失败,Err:" + err.Error())
		return
	}
	return
}

// DeleteChart 上传图表接口
func DeleteChartByForumChartInfoId(forumChartInfoId int) (err error, errMsg string) {
	// 查询图表信息
	req := new(DeleteChartReq)
	req.ChartInfoId = forumChartInfoId

	// 添加计算指标
	reqJson, err := json.Marshal(req)
	if err != nil {
		errMsg = "参数解析异常"
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := ChartDeleteLib(string(reqJson))
	if err != nil {
		errMsg = "撤回失败"
		err = fmt.Errorf("撤回失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		errMsg = "撤回失败"
		err = fmt.Errorf(respItem.ErrMsg)
		return
	}

	return
}

type AdminSaveReq struct {
	*system.Admin
	BusinessCode string `description:"商家编码"`
}

// 上传管理员信息
func AdminSave(adminId int) (err error) {
	if utils.BusinessCode == "" || (utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeDebug && utils.BusinessCode != utils.BusinessCodeSandbox) {
		return
	}
	//查询用户信息
	adminInfo, err := system.GetSysAdminById(adminId)
	if err != nil {
		if utils.IsErrNoRow(err) {
			err = fmt.Errorf("用户不存在")
			return
		}
		err = fmt.Errorf("获取用户信息失败,Err:" + err.Error())
		return
	}
	var req AdminSaveReq
	req.Admin = adminInfo
	req.BusinessCode = utils.BusinessCode
	reqJson, err := json.Marshal(req)
	if err != nil {
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := AdminSaveLib(string(reqJson))
	if err != nil {
		err = fmt.Errorf("上传管理员信息失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		err = fmt.Errorf("上传管理员信息失败,Err:%v,errMsg:%v", respItem.Msg, respItem.ErrMsg)
		return
	}
	return
}

type AdminDeleteReq struct {
	AdminName    string
	BusinessCode string `description:"商家编码"`
}

// 上传管理员信息
func AdminDelete(adminName string) (err error) {
	if utils.BusinessCode == "" || (utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeDebug && utils.BusinessCode != utils.BusinessCodeSandbox) {
		return
	}
	var req AdminDeleteReq
	req.AdminName = adminName
	req.BusinessCode = utils.BusinessCode
	reqJson, err := json.Marshal(req)
	if err != nil {
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := AdminDeleteLib(string(reqJson))
	if err != nil {
		err = fmt.Errorf("删除管理员信息失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		err = fmt.Errorf("删除管理员信息失败,Err:%v,errMsg:%v", respItem.Msg, respItem.ErrMsg)
		return
	}
	return
}

type ChartThemeReq struct {
	*chart_theme.ChartTheme
	BusinessCode string `description:"商家编码"`
}

// 上传主题信息
func ChartThemeSave(theme *chart_theme.ChartTheme) (err error) {
	if utils.BusinessCode == "" || (utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeDebug && utils.BusinessCode != utils.BusinessCodeSandbox) {
		return
	}
	var req ChartThemeReq
	req.ChartTheme = theme
	req.BusinessCode = utils.BusinessCode
	reqJson, err := json.Marshal(req)
	if err != nil {
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := ChartThemeSaveLib(string(reqJson))
	if err != nil {
		err = fmt.Errorf("上传图表主题信息失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		err = fmt.Errorf("上传图表主题信息失败,Err:%v,errMsg:%v", respItem.Msg, respItem.ErrMsg)
		return
	}
	return
}

// ChartThemeTypeSave  上传主题类型信息
func ChartThemeTypeSave(theme *chart_theme.ChartThemeType) (err error) {
	if utils.BusinessCode == "" || (utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeDebug && utils.BusinessCode != utils.BusinessCodeSandbox) {
		return
	}
	//req.BusinessCode = utils.BusinessCode
	reqJson, err := json.Marshal(theme)
	if err != nil {
		err = fmt.Errorf("参数解析异常,Err:" + err.Error())
		return
	}
	respItem, err := ChartThemeTypeSaveLib(string(reqJson))
	if err != nil {
		err = fmt.Errorf("上传图表主题信息失败,Err:" + err.Error())
		return
	}
	if respItem.Ret != 200 {
		err = fmt.Errorf("上传图表主题信息失败,Err:%v,errMsg:%v", respItem.Msg, respItem.ErrMsg)
		return
	}
	return
}

// ChartBatchUpdate 批量上传和更新图表信息
func ChartBatchUpdateAndUpload(chartClassifyInfo *data_manage.ChartClassify, sysUser *system.Admin) (err error) {
	if utils.BusinessCode == "" || (utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeDebug && utils.BusinessCode != utils.BusinessCodeSandbox) {
		return
	}
	var tmpErr []error
	deleteCache := true
	cacheKey := "eta_forum_task:EtaForumChartUpdateByClassifyId:" + strconv.Itoa(chartClassifyInfo.ChartClassifyId)
	defer func() {
		if deleteCache {
			_ = utils.Rc.Delete(cacheKey)
		}
		stack := ""
		if err != nil {
			stack = fmt.Sprintln(stack + err.Error())
		}
		if len(tmpErr) > 0 {
			for _, v := range tmpErr {
				stack = fmt.Sprintln(stack + v.Error())
			}
		}
		if stack != "" {
			utils.FileLog.Error("批量更新资源库图表信息失败"+"<br/>"+stack)
			go alarm_msg.SendAlarmMsg("批量更新资源库图表信息失败"+"<br/>"+stack, 3)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		err = fmt.Errorf("系统处理中，请稍后重试！")
		return
	}
	chartClassifyInfoList, err := data_manage.GetChartClassifyByLevelPath(chartClassifyInfo.LevelPath, chartClassifyInfo.Source)
	if err != nil {
		return
	}
	chartClassifyIdList := make([]string, 0)
	upChartClassifyIdList := make([]string, 0)
	for _, v := range chartClassifyInfoList {
		chartClassifyIdList = append(chartClassifyIdList, strconv.Itoa(v.ChartClassifyId))
		if v.ResourceStatus == utils.ChartClassifyResourceStatusUp {
			upChartClassifyIdList = append(upChartClassifyIdList, strconv.Itoa(v.ChartClassifyId))
		}
	}
	condition := " and forum_chart_info_id > 0 and source=1 and chart_classify_id in ?"
	// 查询需要更新的图表信息总数
	total, err := data_manage.GetChartInfoCountByCondition(condition, []interface{}{chartClassifyIdList})
	if err != nil {
		return
	}
	if total > 0 {
		// 更新图表数据
		offset := 0
		pageSize := 100
		success := 0

		// 循环更新100个图表数据
		for i := 0; offset <= total; i++ {
			// 查询需要更新的图表信息
			chartInfos, e := data_manage.GetChartInfoListByCondition(condition, []interface{}{chartClassifyIdList}, offset, pageSize)
			if e != nil {
				err = fmt.Errorf("查询需要更新的图表信息失败: %v", e)
				return
			}
			if len(chartInfos) == 0 {
				break
			}
			// 循环更新图表数据
			for _, chartInfo := range chartInfos {
				// 更新图表数据
				er, msg := UpdateChart(chartInfo.ChartInfoId)
				if er != nil {
					er = fmt.Errorf("图表ID %d, 更新图表数据失败: %s, %v", chartInfo.ChartInfoId, msg, er)
					tmpErr = append(tmpErr, er)
					continue
				}
				success += 1
			}

			offset += pageSize
		}
		utils.FileLog.Info("更新图表数据完成, 更新图表数据总数:", success)
	}
	// 更新指标数据
	utils.Rc.LPush(utils.CACHE_KEY_EDB_DATA_UPDATE_LOG, []byte("1"))

	// 批量上传已经上架的分类下的图表到资源库中
	// 查询需要新增的图表ID
	condition = " and source=1 and forum_chart_info_id=0 and resource_status !=2 and chart_classify_id in ?"
	total, err = data_manage.GetChartInfoCountByCondition(condition, []interface{}{upChartClassifyIdList})
	if err != nil {
		return
	}
	if total == 0 {
		return
	}
	offset := 0
	pageSize := 100
	success := 0
	for i := 0; offset <= total; i++ {
		chartInfos, e := data_manage.GetChartInfoListByCondition(condition, []interface{}{upChartClassifyIdList}, offset, pageSize)
		if e != nil {
			err = fmt.Errorf("查询需要新增的图表信息失败: %v", e)
			return
		}
		if len(chartInfos) == 0 {
			break
		}
		// 循环更新图表数据
		for _, chartInfo := range chartInfos {
			// 更新图表数据
			er, msg := UploadChart(chartInfo.ChartInfoId, "", sysUser)
			if er != nil {
				er = fmt.Errorf("图表ID %d, 上传图表数据失败: %s, %v", chartInfo.ChartInfoId, msg, er)
				tmpErr = append(tmpErr, er)
				continue
			}
			success += 1
		}

		offset += pageSize
	}
	utils.FileLog.Info("批量上传已经上架的分类下的图表到资源库中完成, 新增图表数据总数:", success)
	
	return
}

// 批量删除资源库图表信息
func ChartInfoDeleteBatch(chartClassifyInfo *data_manage.ChartClassify, sysUser *system.Admin) (err error) {
	if utils.BusinessCode == "" || (utils.BusinessCode != utils.BusinessCodeRelease && utils.BusinessCode != utils.BusinessCodeDebug && utils.BusinessCode != utils.BusinessCodeSandbox) {
		return
	}
	var tmpErr []error
	deleteCache := true
	cacheKey := "eta_forum_task:ChartInfoDeleteBatch:" + strconv.Itoa(chartClassifyInfo.ChartClassifyId)
	defer func() {
		if deleteCache {
			_ = utils.Rc.Delete(cacheKey)
		}
		stack := ""
		if err != nil {
			stack = fmt.Sprintln(stack + err.Error())
		}
		if len(tmpErr) > 0 {
			for _, v := range tmpErr {
				stack = fmt.Sprintln(stack + v.Error())
			}
		}
		if stack != "" {
			utils.FileLog.Error("批量删除资源库图表信息失败"+"<br/>"+stack)
			go alarm_msg.SendAlarmMsg("批量删除资源库图表信息失败"+"<br/>"+stack, 3)
		}
	}()
	if !utils.Rc.SetNX(cacheKey, 1, 30*time.Second) {
		deleteCache = false
		err = fmt.Errorf("系统处理中，请稍后重试！")
		return
	}
	// 查询所有子分类
	chartClassifyInfoList, err := data_manage.GetChartClassifyByLevelPath(chartClassifyInfo.LevelPath, chartClassifyInfo.Source)
	if err != nil {
		return
	}
	if len(chartClassifyInfoList) == 0 {
		return
	}
	chartClassifyIdList := make([]string, 0)
	for _, v := range chartClassifyInfoList {
		chartClassifyIdList = append(chartClassifyIdList, strconv.Itoa(v.ChartClassifyId))
	}
	// 批量删除图表信息
	condition := " AND source=? AND chart_classify_id in ? AND forum_chart_info_id > 0"
	total, err := data_manage.GetChartInfoCountByCondition(condition, []interface{}{chartClassifyInfo.Source, chartClassifyIdList})
	if err != nil {
		return
	}	
	if total == 0 {
		return
	}
	
	offset := 0
	pageSize := 100
	success := 0

	// 循环更新100个图表数据
	for i := 0; offset <= total; i++ {
		// 查询需要更新的图表信息
		chartInfos, e := data_manage.GetChartInfoListByCondition(condition, []interface{}{chartClassifyInfo.Source, chartClassifyIdList}, offset, pageSize)
		if e != nil {
			err = fmt.Errorf("查询需要更新的图表信息失败: %v", e)
			return
		}
		if len(chartInfos) == 0 {
			break
		}
		// 循环更新图表数据
		for _, chartInfo := range chartInfos {
			// 删除图表数据
			er, msg := DeleteChart(chartInfo.ChartInfoId)
			if er != nil {
				er = fmt.Errorf("图表ID %d, 删除图表数据失败: %s, %v", chartInfo.ChartInfoId, msg, er)
				tmpErr = append(tmpErr, er)
				continue
			}
			success += 1
		}

		offset += pageSize
	}
	fmt.Println("删除图表数据完成, 删除图表数据总数:", success)
	return	
}

// 修改分类状态，一键上架至资源库
func SetChartClassifyResourceStatusUp(chartClassifyInfo *data_manage.ChartClassify, sysUser *system.Admin) (errMsg string, err error) {
	if chartClassifyInfo.ResourceStatus == utils.ChartClassifyResourceStatusUp {
		errMsg = "分类状态已为已上架, 无需重复操作"
		err = fmt.Errorf("%s", errMsg)
		return
	}
	// 判断是否是精选资源
	if chartClassifyInfo.IsSelected != utils.ChartClassifyIsSelected {
		errMsg = "分类状态已为已上架, 无需重复操作"
		err = fmt.Errorf("%s", errMsg)
		return
	}
	// 查询分类下的所有图表信息
	err = data_manage.UpdateChartClassifyResourceStatus(chartClassifyInfo.Source, utils.ChartClassifyResourceStatusUp, chartClassifyInfo.LevelPath)
	if err != nil {
		errMsg = "更新分类状态失败"
		err = fmt.Errorf("更新分类状态失败,Err:%w", err)
		return
	}

	go ChartBatchUpdateAndUpload(chartClassifyInfo, sysUser)
	
	return
}

// 修改分类，一键从资源库下架
func SetChartClassifyResourceStatusDown(chartClassifyInfo *data_manage.ChartClassify, sysUser *system.Admin) (errMsg string, err error) {
	if chartClassifyInfo.ResourceStatus == utils.ChartClassifyResourceStatusDown {
		errMsg = "分类状态已为已下架, 无需重复操作"
		err = fmt.Errorf("%s", errMsg)
		return
	}
	// 查询分类下的所有图表信息
	err = data_manage.UpdateChartClassifyResourceStatus(chartClassifyInfo.Source, utils.ChartClassifyResourceStatusDown, chartClassifyInfo.LevelPath)
	if err != nil {
		errMsg = "更新分类状态失败"
		err = fmt.Errorf("更新分类状态失败,Err:%w", err)
		return
	}

	go ChartInfoDeleteBatch(chartClassifyInfo, sysUser)
	
	return
}

func getChartDescriptionWithAdminNameByChartInfoId(chartInfoId int) (list []*data_manage.ChartDescriptionReq, err error, errMsg string) {
	descriptionList, err := data_manage.GetChartDescriptionByChartInfoId(chartInfoId)
	if err != nil {
		errMsg = "获取图表简介失败"
		err = fmt.Errorf("获取图表简介失败,Err:" + err.Error())
		return
	}
	// 查询创建者信息
	adminIdList := make([]int, 0)
	for _, v := range descriptionList {
		adminIdList = append(adminIdList, v.SysUserId)
	}
	adminList, err := system.GetAdminListByIdList(adminIdList)
	if err != nil {
		errMsg = "获取创建者信息失败"
		err = fmt.Errorf("获取创建者信息失败,Err:" + err.Error())
		return
	}
	adminMap := make(map[int]string)
	for _, v := range adminList {
		adminMap[v.AdminId] = v.AdminName
	}
	for _, v := range descriptionList {
		adminName, ok := adminMap[v.SysUserId]
		if !ok {
			adminName = ""
		}
		list = append(list, &data_manage.ChartDescriptionReq{
			ChartInfoId: v.ChartInfoId,
			Description: v.Description,
			AdminName:   adminName,
			SysUserId:   v.SysUserId,
			SysUserRealName: v.SysUserRealName,
			ModifyTime: v.ModifyTime,
			CreateTime: v.CreateTime,
		})
	}
	return
}