Merge remote-tracking branch 'origin/dm' into dm

main.go

@@ -64,7 +64,6 @@ func Recover(ctx *context.Context, conf *web.Config) {
 			logs.Critical(fmt.Sprintf("%s:%d", file, line))
 			stack = stack + fmt.Sprintln(fmt.Sprintf("%s:%d</br>", file, line))
 		}
-		//go utils.SendEmail(utils.APPNAME+"崩了"+time.Now().Format("2006-01-02 15:04:05"), stack, utils.EmailSendToUsers)
 		go alarm_msg.SendAlarmMsg(utils.APPNAME+"崩了"+time.Now().Format("2006-01-02 15:04:05")+"<br/>"+stack, 3)
 	}
 	return

services/aliyun_translate.go

@@ -1,115 +0,0 @@
-package services
-
-import (
-	"errors"
-	"fmt"
-	alimt20181012 "github.com/alibabacloud-go/alimt-20181012/v2/client"
-	openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
-	util "github.com/alibabacloud-go/tea-utils/v2/service"
-	"github.com/alibabacloud-go/tea/tea"
-)
-
-/**
-* 使用STS鉴权方式初始化账号Client，推荐此方式。本示例默认使用AK&SK方式。
-* @param accessKeyId
-* @param accessKeySecret
-* @param securityToken
-* @return Client
-* @throws Exception
- */
-func CreateClientWithSTS (accessKeyId *string, accessKeySecret *string, securityToken *string) (_result *alimt20181012.Client, _err error) {
-	config := &openapi.Config{
-		// 必填，您的 AccessKey ID
-		AccessKeyId: accessKeyId,
-		// 必填，您的 AccessKey Secret
-		AccessKeySecret: accessKeySecret,
-		// 必填，您的 Security Token
-		SecurityToken: securityToken,
-		// 必填，表明使用 STS 方式
-		Type: tea.String("sts"),
-	}
-	// 访问的域名
-	config.Endpoint = tea.String("mt.cn-hangzhou.aliyuncs.com")
-	_result = &alimt20181012.Client{}
-	_result, _err = alimt20181012.NewClient(config)
-	return _result, _err
-}
-
-func handler (accessKeyId, accessKeySecret, stsToken *string, content string) (resp *alimt20181012.TranslateGeneralResponseBody, _err error) {
-	// 初始化 Client，采用 AK&SK 鉴权访问的方式，此方式可能会存在泄漏风险，建议使用 STS 方式。鉴权访问方式请参考：https://help.aliyun.com/document_detail/378661.html
-	//client, _err := CreateClient(accessKeyId, accessKeySecret)
-	client, _err := CreateClientWithSTS(accessKeyId, accessKeySecret, stsToken)
-	if _err != nil {
-		_err = errors.New(fmt.Sprintf("创建翻译客户端失败 err: %v", _err))
-		return
-	}
-
-	translateGeneralRequest := &alimt20181012.TranslateGeneralRequest{
-		FormatType: tea.String("text"),
-		SourceLanguage: tea.String("zh"),
-		TargetLanguage: tea.String("en"),
-		SourceText: tea.String(content),
-		Scene: tea.String("general"),
-	}
-	runtime := &util.RuntimeOptions{}
-	ret, tryErr := func()(ret *alimt20181012.TranslateGeneralResponse, _e error) {
-		defer func() {
-			if r := tea.Recover(recover()); r != nil {
-				_e = r
-				return
-			}
-		}()
-		// 复制代码运行请自行打印 API 的返回值
-		ret, _e = client.TranslateGeneralWithOptions(translateGeneralRequest, runtime)
-		if _e != nil {
-			return
-		}
-		return
-	}()
-
-
-	if tryErr != nil {
-		var e = &tea.SDKError{}
-		if _t, ok := tryErr.(*tea.SDKError); ok {
-			e = _t
-		} else {
-			e.Message = tea.String(tryErr.Error())
-		}
-		// 如有需要，请打印 e
-		_, _err = util.AssertAsString(e.Message)
-		if _err != nil {
-			_err =  errors.New(fmt.Sprintf("翻译失败 err: %v", _err))
-			return
-		}
-		_err =  errors.New(fmt.Sprintf("翻译失败 err: %v", _err))
-		return
-	}
-	if *ret.StatusCode != 200 {
-		_err = errors.New(fmt.Sprintf(" %v", ret.StatusCode))
-		return
-	}
-	resp = ret.Body
-	return
-}
-
-
-func AliTranslate(content string) (contentEn string, err error) {
-	stsToken, err := GetOssSTSToken()
-	if err != nil {
-		err = errors.New(fmt.Sprintf("阿里云机器翻译失败 err %v", err))
-		return
-	}
-	fmt.Println(stsToken)
-	resp, err := handler(&stsToken.AccessKeyId, &stsToken.AccessKeySecret, &stsToken.SecurityToken, content)
-	if err != nil {
-		err = errors.New(fmt.Sprintf("阿里云机器翻译失败 err %v", err))
-		return
-	}
-	if *resp.Code != 200 {
-		err = errors.New(fmt.Sprintf("阿里云机器翻译失败 code: %v; msg: %v",*resp.Code, *resp.Message))
-		return
-	}
-
-	contentEn = *resp.Data.Translated
-	return
-}

services/api.go

@@ -1,49 +0,0 @@
-package services
-
-import (
-	"eta_gn/eta_api/models"
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-func ApiFix() {
-	//拿到所有的api遍历
-	list, err := models.GetApiUriTest()
-	if err != nil {
-		return
-	}
-
-	apiMap := make(map[int]string, 0)
-
-	for _, v := range list {
-		menuIds := strings.Split(v.MenuId, ",")
-		for _, menuIdStr := range menuIds {
-			if menuIdStr != "" {
-				menuId, err := strconv.Atoi(menuIdStr)
-				if err != nil {
-					fmt.Println("strconv err:" + err.Error())
-					return
-				}
-				if apis, ok := apiMap[menuId]; ok {
-					apiMap[menuId] = apis + "&" + v.ApiUri
-				} else {
-					apiMap[menuId] = v.ApiUri
-				}
-			}
-		}
-	}
-
-	fmt.Println(apiMap)
-
-	//修改每一个按钮的值
-	for menuId, api := range apiMap {
-		fmt.Println(menuId, api)
-		err := models.UpdateApiUriTest(api, menuId)
-		if err != nil {
-			fmt.Println("update err:" + err.Error())
-			return
-		}
-	}
-
-}

services/audio.go

@@ -1,13 +0,0 @@
-package services
-
-import "os/exec"
-
-// 转换音频文件格式
-func ConvertAudioFormat(inputFilePath, outputFilePath string) (err error) {
-	cmd := exec.Command("ffmpeg", "-i", inputFilePath, "-codec:a", "libmp3lame", outputFilePath)
-	err = cmd.Run()
-	if err != nil {
-		return
-	}
-	return nil
-}

services/chart_permission.go

@@ -2,7 +2,6 @@ package services
 
 import (
 	"eta_gn/eta_api/models"
-	"eta_gn/eta_api/models/company"
 	"eta_gn/eta_api/utils"
 	"fmt"
 	"time"
@@ -432,47 +431,3 @@ func moveChartPermission(permissionInfo, prevPermission, nextPermission *models.
 	}()
 	return
 }
-
-// GetChartPermissionEnabledList 查询已启用的FICC权限列表
-func GetChartPermissionEnabledList() (list []*company.PermissionSetList, err error) {
-	dataList, err := GetChartPermissionList(" AND enabled = 1", []interface{}{})
-	if err != nil {
-		return
-	}
-	//enabledList := make([]*models.ChartPermission, 0)
-	parentList := make([]*models.ChartPermission, 0)
-	enabledMap := make(map[int][]*company.PermissionSetItem)
-	listMap := make(map[int]*models.ChartPermission)
-	for _, v := range dataList {
-		listMap[v.ChartPermissionId] = v
-		if v.ParentId == 0 {
-			parentList = append(parentList, v)
-		}
-		if v.Enabled == 1 && v.ParentId > 0 && v.PermissionType == 0 {
-			//enabledList = append(enabledList, v)
-			item := &company.PermissionSetItem{
-				ChartPermissionId: v.ChartPermissionId,
-				PermissionName:    v.PermissionName,
-				PermissionType:    v.PermissionType,
-			}
-
-			enabledMap[v.ParentId] = append(enabledMap[v.ParentId], item)
-		}
-	}
-	for _, v := range parentList {
-		items, ok := enabledMap[v.ChartPermissionId]
-		if !ok {
-			continue
-		}
-		checkList := make([]int, 0)
-		p := new(company.PermissionSetList)
-		p.PermissionName = v.PermissionName
-		p.Child = items
-		if v.PermissionName == "宏观经济" {
-			checkList = append(checkList, 1)
-		}
-		p.CheckList = checkList
-		list = append(list, p)
-	}
-	return
-}

services/classify.go

@@ -274,19 +274,6 @@ func AddReportClassify(classifyName string, parentId int, chartPermissionIdList
 	if err != nil {
 		return
 	}
-	/* 国能补充需求调整
-	//获取报告分类权限列表
-	err = models.EditChartPermissionSearchKeyWordMappingMulti(classifyName, chartPermissionIdList, classify.Id)
-	if err != nil {
-		errMsg = "修改分类权限失败"
-		return
-	}
-
-	// 修改CRM权限
-	go func() {
-		_ = EditClassifyChartPermissionSync(classifyName, classify.Id)
-	}()*/
-
 	// 如果父级分类不为空的话，那么就标记有子级分类，同时
 	if parentClassifyItem != nil {
 		parentClassifyItem.HasChild = 1
@@ -538,10 +525,6 @@ func inheritReportApproveFlow(parentClassifyItem, currClassifyItem *models.Class
 		existCond = fmt.Sprintf(`%s AND %s = ?`, existCond, report_approve.ReportApproveFlowCols.ClassifySecondId)
 		existPars = append(existPars, secondClassify.Id)
 	}
-	//if thirdClassify != nil {
-	//	existCond = fmt.Sprintf(`%s AND %s = ?`, existCond, report_approve.ReportApproveFlowCols.ClassifyThirdId)
-	//	existPars = append(existPars, thirdClassify.Id)
-	//}
 
 	parentFlow, err := flowObj.GetItemByCondition(existCond, existPars, "")
 	if err != nil {
@@ -657,24 +640,6 @@ func EditReportClassify(classifyId int, classifyName string, chartPermissionIdLi
 	if err != nil {
 		return
 	}
-	/* 	国能补充需求调整
-	   	err = models.EditChartPermissionSearchKeyWordMappingMulti(item.ClassifyName, chartPermissionIdList, item.Id)
-	   	if err != nil {
-	   		errMsg = "修改分类权限失败"
-	   		return
-	   	}
-
-	   	// 修改CRM权限
-	   	go func() {
-	   		_ = EditClassifyChartPermissionSync(item.ClassifyName, item.Id)
-	   	}()
-
-	   	// TODO 修改分类的关联品种时，历史报告中关联的品种怎么处理？
-	   	// 更新报告分类名称/父级分类后
-	   	go func() {
-	   		_ = AfterUpdateClassifyNameOrParent(item.Id, item.ParentId, item.ParentId, originName, item.ClassifyName, item.Level)
-	   	}()*/
-
 	return
 }
 

services/crm_eta.go

@@ -47,8 +47,3 @@ type GetCrmTokenData struct {
 	ProductName     string `description:"产品名称：admin,ficc,权益"`
 	Authority       int    `description:"管理权限，0：无，1：部门负责人，2：小组负责人,或者ficc销售主管，4:ficc销售组长"`
 }
-
-// CodeLoginFromMiddleServer 中间服务-编码登录
-func CodeLoginFromMiddleServer(authCode string) (tokenResp GetCrmTokenData, err error) {
-	return
-}

services/data/base_edb_lib.go

@@ -20,62 +20,6 @@ func AddEdbData(source int, edbCode, frequency string) (resp *models.BaseRespons
 	param["Frequency"] = frequency
 	urlStr := ``
 	switch source {
-	//case utils.DATA_SOURCE_THS:
-	//	urlStr = "ths/add"
-	//case utils.DATA_SOURCE_WIND:
-	//	urlStr = "wind/add"
-	//case utils.DATA_SOURCE_PB:
-	//	urlStr = "pb/add"
-	//case utils.DATA_SOURCE_PB_FINANCE:
-	//	urlStr = "pb_finance/add"
-	//case utils.DATA_SOURCE_MANUAL:
-	//	urlStr = "manual/add"
-	//case utils.DATA_SOURCE_LZ:
-	//	urlStr = "lz/add"
-	//case utils.DATA_SOURCE_YS:
-	//	urlStr = "smm/add"
-	//case utils.DATA_SOURCE_GL:
-	//	urlStr = "mysteel/add"
-	//case utils.DATA_SOURCE_ZZ:
-	//	urlStr = "zz/add"
-	//case utils.DATA_SOURCE_DL:
-	//	urlStr = "dl/add"
-	//case utils.DATA_SOURCE_SH:
-	//	urlStr = "sh/add"
-	//case utils.DATA_SOURCE_CFFEX:
-	//	urlStr = "cffex/add"
-	//case utils.DATA_SOURCE_SHFE:
-	//	urlStr = "shfe/add"
-	//case utils.DATA_SOURCE_GIE:
-	//	urlStr = "gie/add"
-	//case utils.DATA_SOURCE_LT:
-	//	urlStr = "lt/add"
-	//case utils.DATA_SOURCE_COAL:
-	//	urlStr = "coal/add"
-	//case utils.DATA_SOURCE_GOOGLE_TRAVEL:
-	//	urlStr = "google_travel/add"
-	//case utils.DATA_SOURCE_MYSTEEL_CHEMICAL:
-	//	urlStr = "mysteel_chemical/add"
-	//case utils.DATA_SOURCE_EIA_STEO:
-	//	urlStr = "eia_steo/add"
-	//case utils.DATA_SOURCE_COM_TRADE:
-	//	urlStr = "com_trade/add"
-	//case utils.DATA_SOURCE_SCI:
-	//	urlStr = "sci/add"
-	//case utils.DATA_SOURCE_BAIINFO:
-	//	urlStr = "baiinfo/add"
-	//case utils.DATA_SOURCE_NATIONAL_STATISTICS:
-	//	urlStr = "national_statistics/add"
-	//case utils.DATA_SOURCE_FUBAO:
-	//	urlStr = "fubao/add"
-	//case utils.DATA_SOURCE_GFEX:
-	//	urlStr = "gz/add"
-	//case utils.DATA_SOURCE_ICPI:
-	//	urlStr = "icpi/add"
-	//case utils.DATA_SOURCE_SCI99:
-	//	urlStr = "sci99/add"
-	//case utils.DATA_SOURCE_SCI_HQ:
-	//	urlStr = "sci_hq/add"
 	default:
 		edbSource := data_manage.GetEdbSourceBySourceId(source)
 		if edbSource != nil {
@@ -202,84 +146,6 @@ func RefreshEdbData(edbInfoId, source, subSource int, edbCode, startDate string)
 	param["StartDate"] = startDate
 	param["Source"] = source
 	urlStr := ``
-	//switch source {
-	//case utils.DATA_SOURCE_THS:
-	//	switch subSource {
-	//	case utils.DATA_SUB_SOURCE_DATE:
-	//		urlStr = "ths/ds/refresh"
-	//	case utils.DATA_SUB_SOURCE_HIGH_FREQUENCY:
-	//		urlStr = "ths/hf/edb/refresh"
-	//	default:
-	//		urlStr = "ths/refresh"
-	//	}
-	//case utils.DATA_SOURCE_WIND:
-	//	if subSource == 0 {
-	//		urlStr = "wind/refresh"
-	//	} else {
-	//		urlStr = "wind/wsd/refresh"
-	//	}
-	//case utils.DATA_SOURCE_PB:
-	//	urlStr = "pb/refresh"
-	//case utils.DATA_SOURCE_PB_FINANCE:
-	//	urlStr = "pb_finance/refresh"
-	//case utils.DATA_SOURCE_MANUAL:
-	//	urlStr = "manual/refresh"
-	//case utils.DATA_SOURCE_LZ:
-	//	urlStr = "lz/refresh"
-	//case utils.DATA_SOURCE_YS:
-	//	urlStr = "smm/refresh"
-	//case utils.DATA_SOURCE_GL:
-	//	urlStr = "mysteel/refresh"
-	//case utils.DATA_SOURCE_ZZ:
-	//	urlStr = "zz/refresh"
-	//case utils.DATA_SOURCE_DL:
-	//	urlStr = "dl/refresh"
-	//case utils.DATA_SOURCE_SH:
-	//	urlStr = "sh/refresh"
-	//case utils.DATA_SOURCE_CFFEX:
-	//	urlStr = "cffex/refresh"
-	//case utils.DATA_SOURCE_SHFE:
-	//	urlStr = "shfe/refresh"
-	//case utils.DATA_SOURCE_GIE:
-	//	urlStr = "gie/refresh"
-	//case utils.DATA_SOURCE_LT:
-	//	urlStr = "lt/refresh"
-	//case utils.DATA_SOURCE_COAL:
-	//	urlStr = "coal/refresh"
-	//case utils.DATA_SOURCE_GOOGLE_TRAVEL:
-	//	urlStr = "google_travel/refresh"
-	//case utils.DATA_SOURCE_MYSTEEL_CHEMICAL:
-	//	urlStr = "mysteel_chemical/refresh"
-	//case utils.DATA_SOURCE_EIA_STEO:
-	//	urlStr = "eia_steo/refresh"
-	//case utils.DATA_SOURCE_PREDICT:
-	//	urlStr = "predict/refresh"
-	//case utils.DATA_SOURCE_COM_TRADE:
-	//	urlStr = "com_trade/refresh"
-	//case utils.DATA_SOURCE_SCI:
-	//	urlStr = "sci/refresh"
-	//case utils.DATA_SOURCE_BAIINFO:
-	//	urlStr = "baiinfo/refresh"
-	//case utils.DATA_SOURCE_STOCK_PLANT:
-	//	urlStr = "stock_plant/refresh"
-	//case utils.DATA_SOURCE_NATIONAL_STATISTICS:
-	//	urlStr = "national_statistics/refresh"
-	//case utils.DATA_SOURCE_FUBAO:
-	//	urlStr = "fubao/refresh"
-	//case utils.DATA_SOURCE_GFEX:
-	//	urlStr = "gz/refresh"
-	//case utils.DATA_SOURCE_ICPI:
-	//	urlStr = "icpi/refresh"
-	//case utils.DATA_SOURCE_SCI99:
-	//	urlStr = "sci99/refresh"
-	//case utils.DATA_SOURCE_SCI_HQ:
-	//	urlStr = "sci_hq/refresh"
-	//default:
-	//	edbSource := data_manage.EdbSourceIdMap[source]
-	//	if edbSource != nil {
-	//		urlStr = edbSource.EdbRefreshMethod
-	//	}
-	//}
 	edbSource := data_manage.GetEdbSourceBySourceId(source)
 	if edbSource != nil {
 		urlStr = edbSource.EdbRefreshMethod
@@ -372,12 +238,6 @@ func BatchEditEdbCalculateMultiData(edbInfoCalculateBatchSaveReqStr, lang string
 	return
 }
 
-//// EditEdbCalculateData 修改计算指标数据请求
-//func EditEdbCalculateData(edbInfoCalculateBatchSaveReqStr string) (resp *models.BaseResponse, err error) {
-//	resp, _, err = postAddEdbData(edbInfoCalculateBatchSaveReqStr, "batch/save")
-//	return
-//}
-
 // ExecPythonCode 执行python代码
 func ExecPythonCode(pythonCode string) (resp *models.BaseResponse, err error) {
 	param := make(map[string]interface{})
@@ -489,10 +349,6 @@ func AddBaseEdbInfo(addBaseEdbInfoReqStr string, source, subSource int, lang str
 	switch source {
 	case utils.DATA_SOURCE_BUSINESS:
 		urlStr = "business_index/add"
-	//case utils.DATA_SOURCE_THS:
-	//	if subSource == utils.DATA_SUB_SOURCE_HIGH_FREQUENCY {
-	//		urlStr = "ths/hf/edb/add"
-	//	}
 	default:
 		edbSource := data_manage.GetEdbSourceBySourceId(source)
 		if edbSource != nil {

services/data/base_from_baiinfo.go

@@ -289,124 +289,6 @@ func DelBaiinfoClassify(classifyId int, sysUser *system.Admin) (err error, errMs
 	return
 }
 
-// MoveBaiinfoData 移动SCI指标
-func MoveBaiinfoData(indexId, classifyId, prevIndexId, nextIndexId int) (err error, errMsg string) {
-	//分类信息
-	baiinfoIndex, err := data_manage.GetBaseFromBaiinfoIndexByIndexId(indexId)
-	if err != nil {
-		errMsg = `获取数据失败`
-		if utils.IsErrNoRow(err) {
-			errMsg = `该指标未入库`
-			err = nil
-		}
-		return
-	}
-
-	//判断分类是否存在
-	if classifyId > 0 {
-		_, err = data_manage.GetBaseFromBaiinfoClassifyById(classifyId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取分类信息失败,Err:" + err.Error())
-			if utils.IsErrNoRow(err) {
-				errMsg = "找不到该分类"
-				err = nil
-			}
-			return
-		}
-	}
-
-	//如果改变了分类，那么移动该图表数据
-	if baiinfoIndex.ClassifyId != classifyId {
-		tmpErr := data_manage.MoveBaseFromBaiinfoIndex(indexId, classifyId)
-		if tmpErr != nil {
-			errMsg = "移动失败"
-			err = errors.New("移动失败,Err:" + tmpErr.Error())
-			return
-		}
-	}
-
-	//移动排序
-	updateCol := make([]string, 0)
-	//如果有传入 上一个兄弟节点分类id
-	if prevIndexId > 0 {
-		prevIndex, tmpErr := data_manage.GetBaseFromBaiinfoIndexByIndexId(prevIndexId)
-		if tmpErr != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取上一个兄弟节点指标信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果是移动在两个兄弟节点之间
-		if nextIndexId > 0 {
-			//下一个兄弟节点
-			nextIndex, tmpErr := data_manage.GetBaseFromBaiinfoIndexByIndexId(nextIndexId)
-			if tmpErr != nil {
-				errMsg = "移动失败"
-				err = errors.New("获取下一个兄弟节点指标信息失败,Err:" + tmpErr.Error())
-				return
-			}
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevIndex.Sort == nextIndex.Sort || prevIndex.Sort == baiinfoIndex.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-				err = data_manage.UpdateBaseFromBaiinfoIndexByClassifyId(prevIndex.ClassifyId, prevIndex.Sort, prevIndex.BaseFromBaiinfoIndexId, updateSortStr)
-				if err != nil {
-					errMsg = "移动失败"
-					err = errors.New("变更兄弟节点排序指标信息失败,Err:" + err.Error())
-					return
-				}
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextIndex.Sort-prevIndex.Sort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-					err = data_manage.UpdateBaseFromBaiinfoIndexByClassifyId(prevIndex.ClassifyId, prevIndex.Sort, prevIndex.BaseFromBaiinfoIndexId, updateSortStr)
-					if err != nil {
-						errMsg = "移动失败"
-						err = errors.New("变更兄弟节点排序指标信息失败,Err:" + err.Error())
-						return
-					}
-				}
-			}
-		}
-
-		baiinfoIndex.Sort = prevIndex.Sort + 1
-		baiinfoIndex.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-
-	} else {
-		firstClassify, tmpErr := data_manage.GetFirstBaseFromBaiinfoIndexByClassifyId(classifyId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "移动失败"
-			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = data_manage.UpdateBaseFromBaiinfoIndexByClassifyId(firstClassify.ClassifyId, 0, firstClassify.BaseFromBaiinfoIndexId-1, updateSortStr)
-		}
-
-		baiinfoIndex.Sort = 0 //那就是排在第一位
-		baiinfoIndex.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
-
-	//更新
-	if len(updateCol) > 0 {
-		err = baiinfoIndex.Update(updateCol)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("修改失败,Err:" + err.Error())
-			return
-		}
-	}
-
-	return
-}
-
 // MoveBaiinfoData2 移动SCI指标
 func MoveBaiinfoData2(indexId, classifyId, prevIndexId, nextIndexId int) (err error, errMsg string) {
 	//分类信息
@@ -560,71 +442,6 @@ func EditBaiinfoIndex(indexId, classifyId int, frequency, unit string, sysUser *
 	return
 }
 
-func InitBaseFromBaiinfoClassify() (err error) {
-	//查询历史数据所有分类
-	typeList, err := data_manage.GetBaseFromBaiinfoIndexType()
-	if err != nil {
-		return
-	}
-	classifyList := make([]*data_manage.BaseFromBaiinfoClassify, 0)
-	classifyMap := make(map[string][]string, 0)
-	parentClassifyMap := make(map[string]struct{}, 0)
-	now := time.Now()
-	for _, v := range typeList {
-		if _, ok := parentClassifyMap[v.Type2]; !ok {
-			parentClassifyMap[v.Type2] = struct{}{}
-			tmp := new(data_manage.BaseFromBaiinfoClassify)
-			tmp.ClassifyName = v.Type2
-			tmp.Level = 1
-			tmp.ModifyTime = now
-			tmp.CreateTime = now
-			classifyList = append(classifyList, tmp)
-		}
-		classifyMap[v.Type2] = append(classifyMap[v.Type2], v.Type3)
-	}
-	//添加一级分类
-	err = data_manage.AddBaiinfoClassifyMulti(classifyList)
-	if err != nil {
-		err = errors.New("新增分类出错:" + err.Error())
-		return
-	}
-	//查询分类表的所有父级
-	rootList, err := data_manage.GetBaseFromBaiinfoClassifyByParentId(0)
-	if err != nil {
-		return
-	}
-	classifyIdMap := make(map[string]int)
-	for _, v := range rootList {
-		classifyIdMap[v.ClassifyName] = v.ClassifyId
-	}
-	classifyList2 := make([]*data_manage.BaseFromBaiinfoClassify, 0)
-	for _, v := range typeList {
-		if parentId, ok := classifyIdMap[v.Type2]; ok {
-			tmp := new(data_manage.BaseFromBaiinfoClassify)
-			tmp.ParentId = parentId
-			tmp.ClassifyName = v.Type3
-			tmp.Level = 2
-			tmp.ModifyTime = now
-			tmp.CreateTime = now
-			classifyList2 = append(classifyList2, tmp)
-		}
-	}
-	//添加二级分类
-	err = data_manage.AddBaiinfoClassifyMulti(classifyList2)
-	if err != nil {
-		err = errors.New("新增二级分类出错:" + err.Error())
-		return
-	}
-	//初始化sort字段
-	err = data_manage.InitBaiinfoClassifySort()
-	if err != nil {
-		return
-	}
-	//更新index表里的分类id
-	err = data_manage.InitBaiinfoIndexClassifyId()
-	return
-}
-
 // DelBaiinfoData 删除SCI指标
 func DelBaiinfoData(indexId int) (err error, errMsg string) {
 	baseFromBaiinfoIndex, err := data_manage.GetBaseFromBaiinfoIndexByIndexId(indexId)

services/data/base_from_sci.go

@@ -286,124 +286,6 @@ func DelSciClassify(classifyId int, sysUser *system.Admin) (err error, errMsg st
 	return
 }
 
-// MoveSciData 移动SCI指标
-func MoveSciData(indexId, classifyId, prevIndexId, nextIndexId int) (err error, errMsg string) {
-	//分类信息
-	sciIndex, err := data_manage.GetBaseFromSciIndexByIndexId(indexId)
-	if err != nil {
-		errMsg = `获取数据失败`
-		if utils.IsErrNoRow(err) {
-			errMsg = `该指标未入库`
-			err = nil
-		}
-		return
-	}
-
-	//判断分类是否存在
-	if classifyId > 0 {
-		_, err = data_manage.GetBaseFromSciClassifyById(classifyId)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取分类信息失败,Err:" + err.Error())
-			if utils.IsErrNoRow(err) {
-				errMsg = "找不到该分类"
-				err = nil
-			}
-			return
-		}
-	}
-
-	//如果改变了分类，那么移动该图表数据
-	if sciIndex.ClassifyId != classifyId {
-		tmpErr := data_manage.MoveBaseFromSciIndex(indexId, classifyId)
-		if tmpErr != nil {
-			errMsg = "移动失败"
-			err = errors.New("移动失败,Err:" + tmpErr.Error())
-			return
-		}
-	}
-
-	//移动排序
-	updateCol := make([]string, 0)
-	//如果有传入 上一个兄弟节点分类id
-	if prevIndexId > 0 {
-		prevIndex, tmpErr := data_manage.GetBaseFromSciIndexByIndexId(prevIndexId)
-		if tmpErr != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取上一个兄弟节点指标信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果是移动在两个兄弟节点之间
-		if nextIndexId > 0 {
-			//下一个兄弟节点
-			nextIndex, tmpErr := data_manage.GetBaseFromSciIndexByIndexId(nextIndexId)
-			if tmpErr != nil {
-				errMsg = "移动失败"
-				err = errors.New("获取下一个兄弟节点指标信息失败,Err:" + tmpErr.Error())
-				return
-			}
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevIndex.Sort == nextIndex.Sort || prevIndex.Sort == sciIndex.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-				err = data_manage.UpdateBaseFromSciIndexByClassifyId(prevIndex.ClassifyId, prevIndex.Sort, prevIndex.BaseFromSciIndexId, updateSortStr)
-				if err != nil {
-					errMsg = "移动失败"
-					err = errors.New("变更兄弟节点排序指标信息失败,Err:" + err.Error())
-					return
-				}
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextIndex.Sort-prevIndex.Sort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-					err = data_manage.UpdateBaseFromSciIndexByClassifyId(prevIndex.ClassifyId, prevIndex.Sort, prevIndex.BaseFromSciIndexId, updateSortStr)
-					if err != nil {
-						errMsg = "移动失败"
-						err = errors.New("变更兄弟节点排序指标信息失败,Err:" + err.Error())
-						return
-					}
-				}
-			}
-		}
-
-		sciIndex.Sort = prevIndex.Sort + 1
-		sciIndex.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-
-	} else {
-		firstClassify, tmpErr := data_manage.GetFirstBaseFromSciIndexByClassifyId(classifyId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "移动失败"
-			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = data_manage.UpdateBaseFromSciIndexByClassifyId(firstClassify.ClassifyId, 0, firstClassify.BaseFromSciIndexId-1, updateSortStr)
-		}
-
-		sciIndex.Sort = 0 //那就是排在第一位
-		sciIndex.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
-
-	//更新
-	if len(updateCol) > 0 {
-		err = sciIndex.Update(updateCol)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("修改失败,Err:" + err.Error())
-			return
-		}
-	}
-
-	return
-}
-
 // MoveSciData2 移动SCI指标
 func MoveSciData2(indexId, classifyId, prevIndexId, nextIndexId int) (err error, errMsg string) {
 	//分类信息
@@ -555,71 +437,6 @@ func EditSciIndex(indexId, classifyId int, sysUser *system.Admin) (baseFromSciIn
 	return
 }
 
-func InitBaseFromSciClassify() (err error) {
-	//查询历史数据所有分类
-	typeList, err := data_manage.GetBaseFromSciIndexType()
-	if err != nil {
-		return
-	}
-	classifyList := make([]*data_manage.BaseFromSciClassify, 0)
-	classifyMap := make(map[string][]string, 0)
-	parentClassifyMap := make(map[string]struct{}, 0)
-	now := time.Now()
-	for _, v := range typeList {
-		if _, ok := parentClassifyMap[v.Type2]; !ok {
-			parentClassifyMap[v.Type2] = struct{}{}
-			tmp := new(data_manage.BaseFromSciClassify)
-			tmp.ClassifyName = v.Type2
-			tmp.Level = 1
-			tmp.ModifyTime = now
-			tmp.CreateTime = now
-			classifyList = append(classifyList, tmp)
-		}
-		classifyMap[v.Type2] = append(classifyMap[v.Type2], v.Type3)
-	}
-	//添加一级分类
-	err = data_manage.AddSciClassifyMulti(classifyList)
-	if err != nil {
-		err = errors.New("新增分类出错:" + err.Error())
-		return
-	}
-	//查询分类表的所有父级
-	rootList, err := data_manage.GetBaseFromSciClassifyByParentId(0)
-	if err != nil {
-		return
-	}
-	classifyIdMap := make(map[string]int)
-	for _, v := range rootList {
-		classifyIdMap[v.ClassifyName] = v.ClassifyId
-	}
-	classifyList2 := make([]*data_manage.BaseFromSciClassify, 0)
-	for _, v := range typeList {
-		if parentId, ok := classifyIdMap[v.Type2]; ok {
-			tmp := new(data_manage.BaseFromSciClassify)
-			tmp.ParentId = parentId
-			tmp.ClassifyName = v.Type3
-			tmp.Level = 2
-			tmp.ModifyTime = now
-			tmp.CreateTime = now
-			classifyList2 = append(classifyList2, tmp)
-		}
-	}
-	//添加二级分类
-	err = data_manage.AddSciClassifyMulti(classifyList2)
-	if err != nil {
-		err = errors.New("新增二级分类出错:" + err.Error())
-		return
-	}
-	//初始化sort字段
-	err = data_manage.InitSciClassifySort()
-	if err != nil {
-		return
-	}
-	//更新index表里的分类id
-	err = data_manage.InitSciIndexClassifyId()
-	return
-}
-
 // DelSciData 删除SCI指标
 func DelSciData(indexId int) (err error, errMsg string) {
 	baseFromSciIndex, err := data_manage.GetBaseFromSciIndexByIndexId(indexId)

services/data/base_from_smm.go

@@ -6,19 +6,10 @@
 package data
 
 import (
-	"crypto/md5"
-	"encoding/hex"
-	"encoding/json"
 	"errors"
 	"eta_gn/eta_api/models/data_manage"
 	"eta_gn/eta_api/models/system"
 	"eta_gn/eta_api/utils"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
 	"time"
 )
 
@@ -57,194 +48,6 @@ type YsIndex struct {
 	Msg string `json:"msg"`
 }
 
-// 已作废,暂时保留
-func GetSmmIndexData() {
-	list, err := data_manage.GetBaseFromSmmList()
-	if err != nil {
-		fmt.Println("GetBaseFromSmmList Err:" + err.Error())
-		return
-	}
-
-	token, err := getToken("pqian@hzinsights.com", "hz123456")
-	if err != nil {
-		fmt.Println(err)
-		return
-	}
-
-	endDate := time.Now().Format(utils.FormatDate)
-	smmIndexAll, err := data_manage.GetBaseFromSmmIndex()
-	if err != nil {
-		fmt.Println("GetBaseFromSmmIndex Err:" + err.Error())
-		return
-	}
-	existIndexMap := make(map[string]*data_manage.BaseFromSmmIndex)
-	for _, item := range smmIndexAll {
-		existIndexMap[item.IndexCode] = item
-	}
-
-	dataAllList, err := data_manage.GetBaseFromSmmDataAll()
-	if err != nil {
-		fmt.Println("GetBaseFromSmmData Err:" + err.Error())
-		return
-	}
-	existDataMap := make(map[string]*data_manage.BaseFromSmmData)
-	for _, item := range dataAllList {
-		key := item.IndexCode + item.DataTime
-		existDataMap[key] = item
-	}
-
-	for _, v := range list {
-		edbCode := v.Interface
-		startDate := v.ApiStartTime
-		ysItem, err := getApiData(token, edbCode, startDate, endDate)
-		if err != nil {
-			fmt.Println(err)
-			return
-		}
-		if ysItem != nil && ysItem.Code == 200 {
-			frequency := ysItem.Data.Frequency
-			var smmIndexIdArr []int64
-			var indexCodeArr []string
-			indexKey := 0
-			containsCount := 0
-			for fk, fv := range ysItem.Data.Field {
-				if fk == 0 {
-					continue
-				}
-				if strings.Contains(fv.Name, "产品名称") ||
-					strings.Contains(fv.Name, "单位") ||
-					strings.Contains(fv.Name, "时间") {
-					containsCount++
-				}
-				if !strings.Contains(fv.Name, "产品名称") &&
-					!strings.Contains(fv.Name, "单位") &&
-					!strings.Contains(fv.Name, "时间") {
-
-					indexKey += 1
-					indexCode := v.Interface + "_" + strconv.Itoa(indexKey)
-					if findItem, ok := existIndexMap[indexCode]; !ok {
-						ssmIndex := new(data_manage.BaseFromSmmIndex)
-						ssmIndex.Interface = v.Interface
-						ssmIndex.Name = v.Name
-						ssmIndex.IndexCode = indexCode
-						ssmIndex.IndexName = v.Name + "_" + fv.Name
-						ssmIndex.Type1 = v.Type1
-						ssmIndex.Type2 = v.Type2
-						ssmIndex.Type3 = v.Type3
-						ssmIndex.Frequency = frequency
-						ssmIndex.Unit = fv.Unit
-						ssmIndex.ApiStartTime = v.ApiStartTime
-						ssmIndex.ApiUpdateTime = v.ApiUpdateTime
-						ssmIndex.StartTime = v.StartTime
-						ssmIndex.FinishTime = v.FinishTime
-						ssmIndex.CreateTime = time.Now()
-						ssmIndex.ModifyTime = time.Now()
-						lastIndexId, err := data_manage.AddBaseFromSmmIndex(ssmIndex)
-						if err != nil {
-							return
-						}
-						smmIndexIdArr = append(smmIndexIdArr, lastIndexId)
-						indexCodeArr = append(indexCodeArr, indexCode)
-					} else {
-						smmIndexIdArr = append(smmIndexIdArr, int64(findItem.BaseFromSmmIndexId))
-						indexCodeArr = append(indexCodeArr, findItem.IndexCode)
-					}
-				}
-			}
-
-			for _, dv := range ysItem.Data.Content {
-				var dataTime string
-				for dataK, dataV := range dv {
-					fmt.Println(dataK, dataV)
-					if dataK == 0 {
-						dataTime = dataV
-
-						if frequency == "月" {
-							monthDate, err := time.Parse("2006-01", dataTime)
-							if err != nil {
-								fmt.Println("time.Parse:" + err.Error())
-							}
-							lastTime := monthDate.AddDate(0, 1, -1)
-							lastYear, lastMonth, lastDay := lastTime.Date()
-							var lastDate string
-							if int(lastMonth) < 10 {
-								lastDate = strconv.Itoa(lastYear) + "-" + "0" + strconv.Itoa(int(lastMonth)) + "-" + strconv.Itoa(lastDay)
-							} else {
-								lastDate = strconv.Itoa(lastYear) + "-" + strconv.Itoa(int(lastMonth)) + "-" + strconv.Itoa(lastDay)
-							}
-							dataTime = lastDate
-						}
-
-					} else {
-						if !strings.Contains(ysItem.Data.Field[dataK].Name, "产品名称") &&
-							!strings.Contains(ysItem.Data.Field[dataK].Name, "单位") &&
-							!strings.Contains(ysItem.Data.Field[dataK].Name, "时间") {
-
-							saveDataTime, err := time.Parse(utils.FormatDate, dataTime)
-							if err != nil {
-
-							}
-							timestamp := saveDataTime.UnixNano() / 1e6
-							var smmIndexId int64
-							var indexCode string
-							smmIndexId = smmIndexIdArr[dataK-(containsCount+1)]
-							indexCode = indexCodeArr[dataK-(containsCount+1)]
-
-							key := indexCode + dataTime
-							val := strings.Replace(dataV, ",", "", -1)
-
-							if findData, dataOk := existDataMap[key]; !dataOk {
-								dataItem := new(data_manage.BaseFromSmmData)
-								dataItem.BaseFromSmmIndexId = int(smmIndexId)
-								dataItem.IndexCode = indexCode
-								dataItem.DataTime = dataTime
-								dataItem.Value = val
-								dataItem.CreateTime = time.Now()
-								dataItem.ModifyTime = time.Now()
-								dataItem.DataTimestamp = timestamp
-								_, err = data_manage.AddBaseFromSmmData(dataItem)
-								if err != nil && !strings.Contains(err.Error(), "idx_index_code_date") {
-									fmt.Println("AddBaseFromSmmData Err:" + err.Error())
-									return
-								}
-							} else {
-								if findData != nil && findData.Value != val { //修改
-									err = data_manage.ModifyBaseFromSmmData(findData.SmmDataId, val)
-									if err != nil {
-										fmt.Println("ModifyBaseFromSmmData Err:" + err.Error())
-										return
-									}
-								}
-							}
-						}
-					}
-				}
-			}
-		}
-
-		//修改数据开始，结束日期
-		{
-			indexList, err := data_manage.GetBaseFromSmmIndexBySmmCode(v.Interface)
-			if err != nil {
-				fmt.Println("GetBaseFromSmmIndexByCode Err:" + err.Error())
-			}
-			for _, sv := range indexList {
-				minDate, maxDate, err := data_manage.GetBaseFromSmmMaxOrMinDate(sv.IndexCode)
-				if err != nil {
-					fmt.Println("GetEdbDataSmmMaxOrMinDate Err:" + err.Error())
-				} else {
-					err = data_manage.ModifyBaseFromSmmMinDateAndMaxDate(sv.BaseFromSmmIndexId, minDate, maxDate)
-					if err != nil {
-						fmt.Println("GetEdbDataSmmMaxOrMinDate Err:" + err.Error())
-					}
-				}
-			}
-		}
-		fmt.Println(v.Interface, v.Name)
-		time.Sleep(3 * time.Second)
-	}
-}
-
 const (
 	dataUrl = "https://dataapi.smm.cn/GetData/" //data url (中文)
 	//dataUrl = "https://dataapi.smm.cn/GetDataEn/" //data url (english edition)
@@ -261,41 +64,6 @@ type TokenData struct {
 	Token string `json:"Token"`
 }
 
-// 获取token
-func getToken(userName string, password string) (string, error) {
-	encryptAuth := md5.New()
-	encryptAuth.Write([]byte(password)) //encrypt password with md5
-	newPassword := hex.EncodeToString(encryptAuth.Sum(nil))
-
-	resp, err := http.PostForm(authUrl, url.Values{"user_name": {userName}, "password": {newPassword}})
-	if err != nil {
-		return "", err
-	}
-
-	defer resp.Body.Close()
-
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Println("reponse error", err)
-		return "", err
-	}
-
-	var bodyJsonContent TokenResp
-
-	if err = json.Unmarshal([]byte(body), &bodyJsonContent); err != nil {
-		fmt.Println(err, "unmarsal failure")
-		return "", err
-	}
-
-	var token string
-	if bodyJsonContent.Code == 0 {
-		token = bodyJsonContent.Data.Token
-	}
-
-	//print(token)
-	return token, nil
-}
-
 // request response
 type DataResp struct {
 	Code int      `json:"Code"`
@@ -345,39 +113,6 @@ type YsResult struct {
 	Msg string `json:"Msg"`
 }
 
-/*
- * request data
- * sdatetime,edatetime ==>format:yyyy-mm-dd,
- * apiName ==> data.metal.com(for english)/data.smm.cn (for chinese)
- */
-func getApiData(token string, apiName string, sdatetime string, edatetime string) (item *YsResult, err error) {
-	reqUrl := dataUrl + apiName
-	resp, err := http.PostForm(reqUrl, url.Values{"token": {token}, "sdatetime": {sdatetime}, "edatetime": {edatetime}})
-	if err != nil {
-		return nil, err
-	}
-
-	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Println("response error")
-		return nil, err
-	}
-	utils.FileLog.Info("ys result:" + string(body))
-	dataJsonContent := new(YsResult)
-	if err = json.Unmarshal([]byte(body), &dataJsonContent); err != nil {
-		fmt.Println(err, "data unmarshal failure")
-		return nil, err
-	}
-
-	if dataJsonContent.Code == 200 && len(dataJsonContent.Data.Content) > 0 {
-		return dataJsonContent, nil
-	} else {
-		err = errors.New("code:" + strconv.Itoa(int(dataJsonContent.Code)) + "msg:" + dataJsonContent.Msg)
-	}
-	return nil, nil
-}
-
 // AddSmmClassify 添加SMM分类
 func AddSmmClassify(classifyName string, parentId, sysUserId int, sysUserName, lang string) (classifyInfo *data_manage.BaseFromSmmClassify, err error, errMsg string) {
 	// 校验分类名称相同的数量
@@ -658,124 +393,6 @@ func DelSmmClassify(classifyId int, sysUser *system.Admin) (err error, errMsg st
 	return
 }
 
-// MoveSmmData 移动SMM指标
-func MoveSmmData(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)
-	//如果有传入 上一个兄弟节点分类id
-	if prevIndexId > 0 {
-		prevIndex, tmpErr := data_manage.GetBaseFromSmmIndexByIndexId(prevIndexId)
-		if tmpErr != nil {
-			errMsg = "移动失败"
-			err = errors.New("获取上一个兄弟节点指标信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果是移动在两个兄弟节点之间
-		if nextIndexId > 0 {
-			//下一个兄弟节点
-			nextIndex, tmpErr := data_manage.GetBaseFromSmmIndexByIndexId(nextIndexId)
-			if tmpErr != nil {
-				errMsg = "移动失败"
-				err = errors.New("获取下一个兄弟节点指标信息失败,Err:" + tmpErr.Error())
-				return
-			}
-			//如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
-			if prevIndex.Sort == nextIndex.Sort || prevIndex.Sort == smmIndex.Sort {
-				//变更兄弟节点的排序
-				updateSortStr := `sort + 2`
-				err = data_manage.UpdateBaseFromSmmIndexByClassifyId(prevIndex.ClassifyId, prevIndex.Sort, prevIndex.BaseFromSmmIndexId, updateSortStr)
-				if err != nil {
-					errMsg = "移动失败"
-					err = errors.New("变更兄弟节点排序指标信息失败,Err:" + err.Error())
-					return
-				}
-			} else {
-				//如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
-				if nextIndex.Sort-prevIndex.Sort == 1 {
-					//变更兄弟节点的排序
-					updateSortStr := `sort + 1`
-					err = data_manage.UpdateBaseFromSmmIndexByClassifyId(prevIndex.ClassifyId, prevIndex.Sort, prevIndex.BaseFromSmmIndexId, updateSortStr)
-					if err != nil {
-						errMsg = "移动失败"
-						err = errors.New("变更兄弟节点排序指标信息失败,Err:" + err.Error())
-						return
-					}
-				}
-			}
-		}
-
-		smmIndex.Sort = prevIndex.Sort + 1
-		smmIndex.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-
-	} else {
-		firstClassify, tmpErr := data_manage.GetFirstBaseFromSmmIndexByClassifyId(classifyId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "移动失败"
-			err = errors.New("获取获取当前父级分类下的排序第一条的分类信息失败,Err:" + tmpErr.Error())
-			return
-		}
-
-		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
-		if firstClassify != nil && firstClassify.Sort == 0 {
-			updateSortStr := ` sort + 1 `
-			_ = data_manage.UpdateBaseFromSmmIndexByClassifyId(firstClassify.ClassifyId, 0, firstClassify.BaseFromSmmIndexId-1, updateSortStr)
-		}
-
-		smmIndex.Sort = 0 //那就是排在第一位
-		smmIndex.ModifyTime = time.Now()
-		updateCol = append(updateCol, "Sort", "ModifyTime")
-	}
-
-	//更新
-	if len(updateCol) > 0 {
-		err = smmIndex.Update(updateCol)
-		if err != nil {
-			errMsg = "移动失败"
-			err = errors.New("修改失败,Err:" + err.Error())
-			return
-		}
-	}
-
-	return
-}
-
 // MoveSmmData2 移动SMM指标
 func MoveSmmData2(indexId, classifyId, prevIndexId, nextIndexId int) (err error, errMsg string) {
 	//分类信息
@@ -927,71 +544,6 @@ func EditSmmIndex(indexId, classifyId int, sysUser *system.Admin) (baseFromSmmIn
 	return
 }
 
-func InitBaseFromSmmClassify() (err error) {
-	//查询历史数据所有分类
-	typeList, err := data_manage.GetBaseFromSmmIndexType()
-	if err != nil {
-		return
-	}
-	classifyList := make([]*data_manage.BaseFromSmmClassify, 0)
-	classifyMap := make(map[string][]string, 0)
-	parentClassifyMap := make(map[string]struct{}, 0)
-	now := time.Now()
-	for _, v := range typeList {
-		if _, ok := parentClassifyMap[v.Type2]; !ok {
-			parentClassifyMap[v.Type2] = struct{}{}
-			tmp := new(data_manage.BaseFromSmmClassify)
-			tmp.ClassifyName = v.Type2
-			tmp.Level = 1
-			tmp.ModifyTime = now
-			tmp.CreateTime = now
-			classifyList = append(classifyList, tmp)
-		}
-		classifyMap[v.Type2] = append(classifyMap[v.Type2], v.Type3)
-	}
-	//添加一级分类
-	err = data_manage.AddSmmClassifyMulti(classifyList)
-	if err != nil {
-		err = errors.New("新增分类出错:" + err.Error())
-		return
-	}
-	//查询分类表的所有父级
-	rootList, err := data_manage.GetBaseFromSmmClassifyByParentId(0)
-	if err != nil {
-		return
-	}
-	classifyIdMap := make(map[string]int)
-	for _, v := range rootList {
-		classifyIdMap[v.ClassifyName] = v.ClassifyId
-	}
-	classifyList2 := make([]*data_manage.BaseFromSmmClassify, 0)
-	for _, v := range typeList {
-		if parentId, ok := classifyIdMap[v.Type2]; ok {
-			tmp := new(data_manage.BaseFromSmmClassify)
-			tmp.ParentId = parentId
-			tmp.ClassifyName = v.Type3
-			tmp.Level = 2
-			tmp.ModifyTime = now
-			tmp.CreateTime = now
-			classifyList2 = append(classifyList2, tmp)
-		}
-	}
-	//添加二级分类
-	err = data_manage.AddSmmClassifyMulti(classifyList2)
-	if err != nil {
-		err = errors.New("新增二级分类出错:" + err.Error())
-		return
-	}
-	//初始化sort字段
-	err = data_manage.InitSmmClassifySort()
-	if err != nil {
-		return
-	}
-	//更新index表里的分类id
-	err = data_manage.InitSmmIndexClassifyId()
-	return
-}
-
 // DelSmmData 删除SMM指标
 func DelSmmData(indexId int) (err error, errMsg string) {
 	baseFromSmmIndex, err := data_manage.GetBaseFromSmmIndexByIndexId(indexId)

services/data/chart_classify.go

@@ -57,61 +57,6 @@ func ChartClassifyItemsMakeTree(sysUser *system.Admin, allNode []*data_manage.Ch
 	}
 }
 
-func FixChartClassify() {
-	//新增三级分类
-	list, err := data_manage.GetChartClassifyByLevel(2, 1)
-	if err != nil {
-		return
-	}
-
-	for _, v := range list {
-		classify := new(data_manage.ChartClassify)
-		classify.ParentId = v.ChartClassifyId
-		classify.ChartClassifyName = v.ChartClassifyName
-		classify.HasData = 0
-		classify.CreateTime = time.Now()
-		classify.ModifyTime = time.Now()
-		if utils.RunMode == "debug" {
-			classify.SysUserId = 11
-		} else {
-			classify.SysUserId = 163
-		}
-		classify.SysUserRealName = "admin"
-		classify.Level = 3
-		timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-		classify.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
-		classify.Sort = v.Sort
-		classify.Source = utils.CHART_SOURCE_DEFAULT
-
-		id, err := data_manage.AddChartClassify(classify)
-		if err != nil {
-			return
-		}
-
-		err = data_manage.FIXChartClassifyId(int(id), v.ChartClassifyId)
-		if err != nil {
-			return
-		}
-	}
-}
-
-func FixChartClassifySysUserId() {
-	//获取所有父级分类信息
-	list, err := data_manage.GetChartClassifyByLevel(2, 1)
-	if err != nil {
-		return
-	}
-
-	for _, v := range list {
-		err := data_manage.EditChartClassifySysUser(v.ChartClassifyId, v.SysUserId, v.SysUserRealName)
-		if err != nil {
-			return
-		}
-		fmt.Println("ChartClassifyId:", v.ChartClassifyId)
-	}
-	fmt.Println("FixChartClassifySysUserId end")
-}
-
 // GetChartClassifyOpButton 获取ETA图库分类的操作权限
 func GetChartClassifyOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.ChartClassifyItemsButton) {
 	// 没有数据权限就直接返回
@@ -130,16 +75,6 @@ func GetChartClassifyOpButton(sysUser *system.Admin, belongUserId int, haveOpera
 	return
 }
 
-// GetCanOpChartClassify 获取是否允许添加图表分类
-func GetCanOpChartClassify(roleTypeCode string) (canOpClassify bool) {
-	// 如果不是 超管 或者 ficc管理员 或者 ficc研究员，那么就没有权限
-	if utils.InArrayByStr([]string{utils.ROLE_TYPE_CODE_ADMIN, utils.ROLE_TYPE_CODE_FICC_ADMIN, utils.ROLE_TYPE_CODE_RESEARCHR, utils.ROLE_TYPE_CODE_FICC_RESEARCHR}, roleTypeCode) {
-		canOpClassify = true
-	}
-
-	return
-}
-
 // GetChartOpButton 获取ETA图库的操作权限
 func GetChartOpButton(sysUser *system.Admin, belongUserId int, haveOperaAuth bool) (button data_manage.ChartClassifyItemsButton) {
 	// 数据权限判断
@@ -970,4 +905,4 @@ func GetChartClassifyChildIds(classifyId int, classifymap map[int]*data_manage.C
 			GetChartClassifyChildIds(item.ChartClassifyId, classifymap, childIds)
 		}
 	}
-}
+}

services/data/chart_edb_config.go

@@ -7,14 +7,6 @@ import (
 
 // BatchAddNoPermissionAdmin 批量添加配置
 func BatchAddNoPermissionAdmin(edbInfoIdList []int, adminIdList []int) (err error) {
-	//_, err = data_manage.GetEdbInfoById(edbInfoId)
-	//if err != nil {
-	//	if utils.IsErrNoRow(err) {
-	//		errMsg = "找不到该指标"
-	//	}
-	//	return
-	//}
-
 	errMsgList := make([]string, 0)
 	for _, edbInfoId := range edbInfoIdList {
 		obj := data_manage.EdbInfoNoPermissionAdmin{}

services/data/chart_info.go

@@ -19,233 +19,6 @@ import (
 	"time"
 )
 
-func ChartInfoRefreshV1(chartInfoId int) (err error) {
-	var errmsg string
-	defer func() {
-		if err != nil {
-			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
-			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
-			fmt.Println("ChartInfoRefresh Err:" + errmsg)
-		}
-	}()
-	baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshData(chartInfoId)
-	if err != nil {
-		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
-		return
-	}
-
-	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
-	baseMap := make(map[int]*data_manage.EdbInfo)
-	for _, bv := range baseEdbInfoArr {
-		// 如果不是普通指标，那么过滤
-		if bv.EdbInfoType != 0 {
-			continue
-		}
-		if _, ok := baseMap[bv.EdbInfoId]; !ok {
-			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
-		}
-		baseMap[bv.EdbInfoId] = bv
-	}
-
-	fmt.Println("calculateInfoArr:", len(calculateInfoArr))
-
-	newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
-	calculateMap := make(map[int]*data_manage.EdbInfo)
-	var calculateArr []int
-	for _, bv := range calculateInfoArr {
-		if _, ok := calculateMap[bv.EdbInfoId]; !ok {
-			newCalculateInfoArr = append(newCalculateInfoArr, bv)
-			calculateArr = append(calculateArr, bv.EdbInfoId)
-		}
-		calculateMap[bv.EdbInfoId] = bv
-	}
-	sort.Ints(calculateArr)
-
-	// 刷新相关基础指标
-	for _, bv := range newBaseEdbInfoArr {
-		err, errmsg = refreshBaseEdbInfo(bv)
-		if err != nil {
-			return
-		}
-	}
-
-	// 刷新相关计算指标
-	for _, v := range calculateArr {
-		edbInfo := calculateMap[v]
-		if edbInfo == nil {
-			return err
-		}
-		err, errmsg = refreshCalculateEdbInfo(edbInfo)
-		if err != nil {
-			return
-		}
-	}
-	return err
-}
-
-// BatchChartInfoRefresh 图表批量刷新
-func BatchChartInfoRefresh(chartInfoList []*data_manage.ChartInfo) (err error) {
-	if len(chartInfoList) <= 0 {
-		return
-	}
-	chartInfoIdSlice := make([]string, 0)
-	for _, chartInfo := range chartInfoList {
-		chartInfoIdSlice = append(chartInfoIdSlice, strconv.Itoa(chartInfo.ChartInfoId))
-	}
-
-	var errmsg string
-	defer func() {
-		if err != nil {
-			go alarm_msg.SendAlarmMsg("ChartInfoRefresh:"+errmsg, 3)
-			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errmsg, utils.EmailSendToUsers)
-			fmt.Println("ChartInfoRefresh Err:" + errmsg)
-		}
-	}()
-	baseEdbInfoArr, calculateInfoArr, err := data_manage.GetChartInfoRefreshDataByChartInfoIdSlice(chartInfoIdSlice)
-	if err != nil {
-		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
-		return
-	}
-
-	//基础指标去重
-	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
-	baseMap := make(map[int]*data_manage.EdbInfo)
-	for _, bv := range baseEdbInfoArr {
-		fmt.Println(bv.UniqueCode)
-		if _, ok := baseMap[bv.EdbInfoId]; !ok {
-			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
-		}
-		baseMap[bv.EdbInfoId] = bv
-	}
-
-	fmt.Println("calculateInfoArr:", len(calculateInfoArr))
-
-	//计算指标去重
-	newCalculateInfoArr := make([]*data_manage.EdbInfo, 0)
-	calculateMap := make(map[int]*data_manage.EdbInfo)
-	var calculateArr []int
-	for _, bv := range calculateInfoArr {
-		if _, ok := calculateMap[bv.EdbInfoId]; !ok {
-			newCalculateInfoArr = append(newCalculateInfoArr, bv)
-			calculateArr = append(calculateArr, bv.EdbInfoId)
-		}
-		calculateMap[bv.EdbInfoId] = bv
-	}
-	sort.Ints(calculateArr)
-
-	// 刷新相关基础指标
-	for _, bv := range newBaseEdbInfoArr {
-		err, errmsg = refreshBaseEdbInfo(bv)
-		if err != nil {
-			return
-		}
-	}
-
-	// 刷新相关计算指标
-	for _, v := range calculateArr {
-		edbInfo := calculateMap[v]
-		if edbInfo == nil {
-			return err
-		}
-		err, errmsg = refreshCalculateEdbInfo(edbInfo)
-		if err != nil {
-			return
-		}
-	}
-
-	return err
-}
-
-// refreshBaseEdbInfo 刷新基础指标
-func refreshBaseEdbInfo(bv *data_manage.EdbInfo) (err error, errMsg string) {
-	source := bv.Source
-	subSource := bv.SubSource
-	edbInfoId := bv.EdbInfoId
-	edbCode := bv.EdbCode
-	//startDate := bv.StartDate
-	frequency := bv.Frequency
-	sTime := bv.EndDate
-
-	// 如果日期是空，那么就采用系统默认的日期
-	if sTime.IsZero() {
-		sTime, _ = time.ParseInLocation(utils.FormatDate, utils.BaseEdbRefreshStartDate, time.Local)
-	}
-
-	var limitDay int
-	startDate := ""
-	switch frequency {
-	case "日度":
-		limitDay = utils.DATA_START_REFRESH_LIMIT
-	case "周度":
-		limitDay = utils.DATA_START_REFRESH_LIMIT * 7
-	case "月度":
-		limitDay = utils.DATA_START_REFRESH_LIMIT * 30
-	case "季度":
-		limitDay = utils.DATA_START_REFRESH_LIMIT * 90
-	case "年度":
-		limitDay = utils.DATA_START_REFRESH_LIMIT * 365
-	default:
-		limitDay = utils.DATA_START_REFRESH_LIMIT
-	}
-	startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
-
-	fmt.Println("source:", source)
-	respItem, err := RefreshEdbData(edbInfoId, source, subSource, edbCode, startDate)
-	if err != nil {
-		errMsg = errors.New("RefreshEdbData Err:" + err.Error()).Error()
-		return
-	}
-	if respItem.Ret != 200 {
-		errMsg = errors.New(respItem.ErrMsg + ";EdbCode:" + edbCode).Error()
-		return
-	}
-
-	maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, subSource, edbCode)
-	if err != nil {
-		return
-	}
-	if maxAndMinItem != nil {
-		err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-// refreshCalculateEdbInfo 刷新计算指标
-func refreshCalculateEdbInfo(edbInfo *data_manage.EdbInfo) (err error, errMsg string) {
-	startDate := utils.TimeToFormatDate(edbInfo.StartDate)
-	source := edbInfo.Source
-
-	if source == utils.DATA_SOURCE_CALCULATE {
-		//startDate = edbInfo.StartDate
-		//sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
-		//if tmpErr != nil {
-		//	err = tmpErr
-		//	return
-		//}
-		if !edbInfo.EndDate.IsZero() {
-			startDate = utils.TimeToFormatDate(edbInfo.EndDate)
-		}
-
-	}
-
-	result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
-	if err != nil {
-		fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
-		errMsg = "RefreshEdbCalculateData Err:" + err.Error()
-		return
-	}
-	if result.Ret != 200 {
-		fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
-		errMsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
-		err = errors.New("刷新失败")
-		return
-	}
-	return
-}
-
 type ChartInfoReq struct {
 	ChartInfoId int `description:"图表id,新增时传0"`
 }
@@ -777,8 +550,6 @@ func getEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate
 				for i, data := range dataList {
 					dataList[i].Value = data.Value / v.ConvertValue
 				}
-				//item.MaxData = item.MaxData / v.ConvertValue
-				//item.MinData = item.MinData / v.ConvertValue
 			case 3:
 				for i, data := range dataList {
 					if data.Value <= 0 {
@@ -787,8 +558,6 @@ func getEdbDataMapList(chartInfoId, chartType int, calendar, startDate, endDate
 					}
 					dataList[i].Value = math.Log(data.Value) / math.Log(v.ConvertValue)
 				}
-				//item.MaxData = math.Log(item.MaxData) / math.Log(v.ConvertValue)
-				//item.MinData = math.Log(item.MinData) / math.Log(v.ConvertValue)
 			}
 		}
 
@@ -1666,32 +1435,6 @@ func BatchChartInfoRefreshV2(chartInfoList []*data_manage.ChartInfo, redisKey st
 	return
 }
 
-// refreshChartEdbInfo
-// @Description: 刷新图表中的质保列表
-// @author: Roc
-// @datetime 2023-12-01 16:05:39
-// @param chartInfoList []*data_manage.ChartInfo
-// @param redisKey string
-// @param newBaseEdbInfoArr []*data_manage.EdbInfo
-// @param newBasePredictEdbInfoArr []*data_manage.EdbInfo
-// @param newCalculateMap map[int]*data_manage.EdbInfo
-// @param newPredictCalculateMap map[int]*data_manage.EdbInfo
-// @param calculateArr []int
-// @param predictCalculateArr []int
-func refreshChartEdbInfo(chartInfoList []*data_manage.ChartInfo, redisKey string, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) {
-	edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
-
-	//清除图表缓存
-	for _, v := range chartInfoList {
-		key := utils.HZ_CHART_LIB_DETAIL + v.UniqueCode
-		_ = utils.Rc.Delete(key)
-	}
-	// 如果是有插入redisKey，那么刷新结束后就清除缓存
-	if redisKey != `` {
-		utils.Rc.Delete(redisKey)
-	}
-}
-
 // GetBatchChartRefreshKey
 // @Description: 获取批量刷新key
 // @author: Roc

services/data/chart_info_elastic.go

@@ -9,94 +9,6 @@ import (
 	"strings"
 )
 
-func CreateChartInfoIndex() {
-	indexName := utils.CHART_INDEX_NAME
-	mappingJson := `{
-  "mappings": {
-    "dynamic": true,
-    "properties": {
-      "ChartInfoId": {
-        "type": "integer"
-      },
-      "ChartName": {
-        "type": "text",
-        "term_vector": "with_positions_offsets",
-        "analyzer": "ik_smart"
-      },
-      "ChartClassifyId": {
-        "type": "integer"
-      },
-      "SysUserId": {
-        "type": "integer"
-      },
-      "SysUserRealName": {
-        "type": "text",
-        "term_vector": "with_positions_offsets",
-        "analyzer": "ik_smart"
-      },
-      "UniqueCode": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      },
-      "Unit": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      },
-      "CreateTime": {
-        "type": "date"
-      },
-      "ModifyTime": {
-        "type": "date"
-      },
-      "DateType": {
-        "type": "integer"
-      },
-      "StartDate": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      },
-      "EndDate": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      },
-      "IsSetName": {
-        "type": "integer"
-      },
-      "EdbInfoIds": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      },
-      "ChartType": {
-        "type": "integer"
-      },
-      "Calendar": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      },
-      "ChartImage": {
-        "type": "text",
-        "term_vector": "with_positions_offsets"
-      }
-    }
-  }
-}`
-	elastic.EsCreateIndex(indexName, mappingJson)
-}
-
-func AddAllChartInfo() {
-	allList, err := data_manage.GetChartInfoAllList()
-	if err != nil {
-		fmt.Println("GetArticleAll Err:", err.Error())
-		return
-	}
-	total := len(allList)
-	for k, v := range allList {
-		EsAddOrEditChartInfo(v.ChartInfoId)
-		//fmt.Println(v.ChartInfoId)
-		fmt.Println("剩余", total-k-1, "条数据，当前图表id：", v.ChartInfoId)
-	}
-}
-
 // EsAddOrEditChartInfo 新增和修改ES中的图表数据
 func EsAddOrEditChartInfo(chartInfoId int) {
 	var err error
@@ -130,32 +42,6 @@ func EsSearchChartInfo(keyword string, showSysId int, sourceList []int, noPermis
 	return
 }
 
-// AddAllMyChartInfo 添加所有的我的图库数据
-func AddAllMyChartInfo() {
-	errMsg := make([]string, 0)
-	defer func() {
-		if len(errMsg) > 0 {
-			fmt.Println("新增和修改ES中的图表数据失败：", strings.Join(errMsg, "\n"))
-		}
-	}()
-	var condition string
-	var pars []interface{}
-
-	allList, err := data_manage.GetMyChartListGroupByCharyInfoIdAndAdminIdByCondition(condition, pars)
-	if err != nil {
-		fmt.Println("AddAllMyChartInfo Err:", err.Error())
-		return
-	}
-
-	for _, v := range allList {
-		//添加es
-		err = elastic.EsAddOrEditDataInterface(utils.MY_CHART_INDEX_NAME, strconv.Itoa(v.MyChartId), v)
-		if err != nil {
-			errMsg = append(errMsg, fmt.Sprintf("myChartId:%d,添加Es失败,err:%s", v.MyChartId, err.Error()))
-		}
-	}
-}
-
 // EsAddOrEditMyChartInfoByChartInfoId 根据图表id 新增和修改ES中的图表数据
 func EsAddOrEditMyChartInfoByChartInfoId(chartInfoId int) {
 	errMsg := make([]string, 0)
@@ -186,35 +72,6 @@ func EsAddOrEditMyChartInfoByChartInfoId(chartInfoId int) {
 	return
 }
 
-// EsDeleteMyChartInfoByChartInfoId 根据图表id 删除ES中的图表数据
-func EsDeleteMyChartInfoByChartInfoId(chartInfoId int) {
-	errMsg := make([]string, 0)
-	defer func() {
-		if len(errMsg) > 0 {
-			fmt.Println("新增和修改ES中的图表数据失败：", strings.Join(errMsg, "\n"))
-		}
-	}()
-
-	var condition string
-	var pars []interface{}
-	condition += " AND a.chart_info_id = ? "
-	pars = append(pars, chartInfoId)
-
-	allList, err := data_manage.GetMyChartListGroupByCharyInfoIdAndAdminIdByCondition(condition, pars)
-	if err != nil {
-		errMsg = append(errMsg, fmt.Sprintf("AddAllMyChartInfo Err:%s", err.Error()))
-		return
-	}
-	for _, v := range allList {
-		//删除es
-		err = elastic.EsDeleteDataV2(utils.MY_CHART_INDEX_NAME, strconv.Itoa(v.MyChartId))
-		if err != nil {
-			errMsg = append(errMsg, fmt.Sprintf("myChartId:%d,删除Es失败,err:%s", v.MyChartId, err.Error()))
-		}
-	}
-	return
-}
-
 // EsAddOrEditMyChartInfoByMyChartId 根据我的图库id 新增和修改ES中的图表数据
 func EsAddOrEditMyChartInfoByMyChartId(myChartId int) {
 	errMsg := make([]string, 0)

services/data/chart_info_excel_balance.go

@@ -21,41 +21,6 @@ import (
 // AddBalanceExcelChart 添加平衡表图表
 func AddBalanceExcelChart(excelInfo *excelModel.ExcelInfo, req request.AddBalanceTableChartReq, sysUser *system.Admin, dataListMap map[int][]*data_manage.EdbDataList) (chartInfo *data_manage.ChartInfo, err error, errMsg string, isSendEmail bool) {
 
-	/*// 操作权限校验, 增加协作人判断
-	{
-		checkExcelInfo := excelInfo
-		checkExcelInfoId := excelInfo.ExcelInfoId
-		if excelInfo.BalanceType == 1 {
-			checkExcelInfoId = excelInfo.RelExcelInfoId
-		} else {
-			if excelInfo.ParentId > 0 {
-				checkExcelInfoId = excelInfo.ParentId
-			}
-		}
-		if checkExcelInfoId != excelInfo.ExcelInfoId {
-			checkExcelInfo, err = excelModel.GetExcelInfoById(checkExcelInfoId)
-			if err != nil {
-				errMsg = "获取平衡表格信息失败"
-				err = fmt.Errorf("获取平衡表格信息失败，Err:" + err.Error())
-				return
-			}
-		}
-		// 数据权限
-		haveOperaAuth, e := data_manage_permission.CheckExcelPermissionByExcelInfoId(checkExcelInfo.ExcelInfoId, checkExcelInfo.ExcelClassifyId, checkExcelInfo.IsJoinPermission, sysUser.AdminId)
-		if e != nil {
-			errMsg = "获取ETA表格权限失败"
-			err = fmt.Errorf("获取表格权限信息失败，Err" + e.Error())
-			return
-		}
-
-		button := excelService.GetBalanceExcelInfoOpButton(sysUser.AdminId, checkExcelInfo.SysUserId, haveOperaAuth, checkExcelInfo.ExcelInfoId)
-		if !button.OpButton {
-			errMsg = "无操作权限"
-			isSendEmail = false
-			return
-		}
-	}*/
-
 	if len(req.ChartEdbInfoList) == 0 {
 		errMsg = "图表数据不能为空！"
 		err = fmt.Errorf("图表数据不能为空！%s", err.Error())
@@ -237,10 +202,6 @@ func addBalanceExcelChart(req request.AddBalanceTableChartReq, sysUserId int, sy
 	}
 
 	chartInfo.Calendar = calendar
-	/*	chartInfo.StartDate = req.StartDate
-		chartInfo.EndDate = req.EndDate
-		chartInfo.SeasonStartDate = req.StartDate
-		chartInfo.SeasonEndDate = req.EndDate*/
 	chartInfo.LeftMin = req.LeftMin
 	chartInfo.LeftMax = req.LeftMax
 	chartInfo.RightMin = req.RightMin
@@ -248,30 +209,11 @@ func addBalanceExcelChart(req request.AddBalanceTableChartReq, sysUserId int, sy
 	chartInfo.Right2Min = req.Right2Min
 	chartInfo.Right2Max = req.Right2Max
 	chartInfo.MinMaxSave = req.MinMaxSave
-	//chartInfo.Disabled = disableVal
-	//chartInfo.BarConfig = barChartConf
 	chartInfo.ExtraConfig = extraConfig
 	chartInfo.SeasonExtraConfig = seasonExtraConfig
-	//chartInfo.StartYear = req.StartYear
 	chartInfo.Source = utils.CHART_SOURCE_BALANCE_EXCEL
 	chartInfo.ChartThemeId = chartThemeId
 	chartInfo.SourcesFrom = req.SourcesFrom
-	/*	chartInfo.Instructions = req.Instructions
-		chartInfo.MarkersLines = req.MarkersLines
-		chartInfo.MarkersAreas = req.MarkersAreas
-		chartInfo.Unit = req.Unit
-		chartInfo.UnitEn = req.UnitEn*/
-	/*newId, err := data_manage.AddChartInfo(chartInfo)
-	if err != nil {
-		errMsg = `保存失败`
-		err = fmt.Errorf("保存失败，Err:" + err.Error())
-		return
-	}
-	chartInfo.ChartInfoId = int(newId)*/
-
-	//添加es数据
-	//go EsAddOrEditChartInfo(chartInfo.ChartInfoId)
-
 	return
 }
 
@@ -282,41 +224,6 @@ func EditBalanceExcelChart(excelInfo *excelModel.ExcelInfo, req request.AddBalan
 		err = fmt.Errorf("图表数据不能为空！%s", err.Error())
 		return
 	}
-	/*// 操作权限校验, 增加协作人判断
-	{
-		checkExcelInfo := excelInfo
-		checkExcelInfoId := excelInfo.ExcelInfoId
-		if excelInfo.BalanceType == 1 {
-			checkExcelInfoId = excelInfo.RelExcelInfoId
-		} else {
-			if excelInfo.ParentId > 0 {
-				checkExcelInfoId = excelInfo.ParentId
-			}
-		}
-		if checkExcelInfoId != excelInfo.ExcelInfoId {
-			checkExcelInfo, err = excelModel.GetExcelInfoById(checkExcelInfoId)
-			if err != nil {
-				errMsg = "获取平衡表格信息失败"
-				err = fmt.Errorf("获取平衡表格信息失败，Err:" + err.Error())
-				return
-			}
-		}
-		// 数据权限
-		haveOperaAuth, e := data_manage_permission.CheckExcelPermissionByExcelInfoId(checkExcelInfo.ExcelInfoId, checkExcelInfo.ExcelClassifyId, checkExcelInfo.IsJoinPermission, sysUser.AdminId)
-		if e != nil {
-			errMsg = "获取ETA表格权限失败"
-			err = fmt.Errorf("获取表格权限信息失败，Err" + e.Error())
-			return
-		}
-
-		button := excelService.GetBalanceExcelInfoOpButton(sysUser.AdminId, checkExcelInfo.SysUserId, haveOperaAuth, checkExcelInfo.ExcelInfoId)
-		if !button.OpButton {
-			errMsg = "无操作权限"
-			isSendEmail = false
-			return
-		}
-	}
-	*/
 	//查询已有的mapping
 	mapping, err := excelModel.GetExcelChartEdbMappingByChartInfoId(req.ChartInfoId)
 	if err != nil {

services/data/cross_variety/chart.go

@@ -469,32 +469,6 @@ func GetChartData(chartInfoId int, config request.ChartConfigReq) (edbList []*da
 	return
 }
 
-// CheckIsEnChart
-// @Description: 检测是否展示英文名称
-// @author: Roc
-// @datetime 2023-11-28 20:54:41
-// @param chartNameEn string
-// @param dataResp ChartInfoResp
-// @return bool
-func CheckIsEnChart(chartNameEn string, dataResp ChartInfoResp) bool {
-	if chartNameEn == "" {
-		return false
-	}
-
-	if dataResp.XNameEn == `` {
-		return false
-	}
-	if dataResp.YNameEn == `` {
-		return false
-	}
-	for _, v := range dataResp.DataList {
-		if v.NameEn == `` {
-			return false
-		}
-	}
-	return true
-}
-
 // GetXYEdbIdList
 // @Description: 根据标签id和品种获取指标列表信息
 // @author: Roc
@@ -710,29 +684,9 @@ func AddChartInfo(req request.AddChartReq, sysUser *system.Admin, lang string) (
 
 	var chartInfoId int
 	// 判断图表是否存在
-	//var condition string
-	//var pars []interface{}
-	//condition += " AND chart_name=? AND source = ? "
-	//pars = append(pars, req.ChartName, source)
-	//count, err := data_manage.GetChartInfoCountByCondition(condition, pars)
-	//if err != nil {
-	//	errMsg = "判断图表名称是否存在失败"
-	//	err = errors.New("判断图表名称是否存在失败,Err:" + err.Error())
-	//	return
-	//}
-
-	//if count > 0 {
-	//	errMsg = "图表已存在，请重新填写"
-	//	err = errors.New(errMsg)
-	//	isSendEmail = false
-	//	return
-	//}
-
 	chartInfo = new(data_manage.ChartInfo)
 	chartInfo.ChartName = req.ChartName
 	chartInfo.ChartNameEn = req.ChartNameEn
-	//chartInfo.EdbInfoIds = edbInfoIdStr
-	//chartInfo.ChartClassifyId = req.ChartClassifyId
 	chartInfo.SysUserId = sysUser.AdminId
 	chartInfo.SysUserRealName = sysUser.RealName
 	chartInfo.ChartImage = req.ChartImage
@@ -744,17 +698,10 @@ func AddChartInfo(req request.AddChartReq, sysUser *system.Admin, lang string) (
 	chartInfo.ChartType = 9 // 相关性图
 	chartInfo.Calendar = "公历"
 	chartInfo.DateType = 6
-	//chartInfo.StartDate = req.StartDate
-	//chartInfo.EndDate = req.EndDate
-	//chartInfo.SeasonStartDate = req.StartDate
-	//chartInfo.SeasonEndDate = req.EndDate
 	chartInfo.LeftMin = req.LeftMin
 	chartInfo.LeftMax = req.LeftMax
 	chartInfo.XMin = req.XMin
 	chartInfo.XMax = req.XMax
-	//chartInfo.RightMin = req.RightMin
-	//chartInfo.RightMax = req.RightMax
-	//chartInfo.Disabled = disableVal
 	chartInfo.Source = source
 	chartInfo.ExtraConfig = string(extraConfigByte)
 	chartInfo.ChartImage = req.ChartImage

services/data/data_manage_permission/data_move.go

@@ -779,258 +779,6 @@ func MoveEdbChart(source, subSource, oldUserId, newUserId int, isSelectAll bool,
 	return
 }
 
-// MoveAllEdbChartOld
-// @Description: 通过原创建人转移指标/图表创建人
-// @author: Roc
-// @datetime 2024-03-26 15:11:12
-// @param sourceList []int 1：手工数据指标 2：钢联化工数据库 3：ETA指标库 4：ETA预测指标 5：图库 6：ETA表格
-// @param oldUserId []int
-// @param userId int
-// @param opUserId int
-// @return err error
-// @return errMsg string
-func MoveAllEdbChartOld(sourceList, oldUserIdList []int, userId, opUserId int) (err error, errMsg string) {
-	adminInfo, err := system.GetSysAdminById(userId)
-	if err != nil {
-		return
-	}
-
-	// 操作记录
-	dataPermissionMoveRecordList := make([]*data_manage_permission.DataPermissionMoveRecord, 0)
-	uniqueCode := uuid.NewUUID().Hex32()
-	title := `资产转移`
-	content := `资产转入`
-	sourceStrList := make([]string, 0)
-
-	for _, source := range sourceList {
-		switch source {
-		case 1: //手工数据指标
-			sourceStrList = append(sourceStrList, "手工指标数据")
-			tmpList, tmpErr := models.GetEdbinfoListByCodeListByUserId(oldUserIdList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			if len(tmpList) > 0 {
-				for _, v := range tmpList {
-					// 操作记录
-					dataPermissionMoveRecordList = append(dataPermissionMoveRecordList, &data_manage_permission.DataPermissionMoveRecord{
-						DataPermissionMoveRecordId: 0,
-						Source:                     int32(source),
-						SubSource:                  0,
-						OpUniqueCode:               uniqueCode,
-						DataId:                     v.TradeCode,
-						DataCode:                   v.TradeCode,
-						DataName:                   v.SecName,
-						OriginalUserId:             int32(v.UserId),
-						OriginalUserName:           v.UserName,
-						NewUserId:                  int32(adminInfo.AdminId),
-						NewUserName:                adminInfo.RealName,
-						CreateTime:                 time.Now(),
-					})
-				}
-				// 修改创建人
-				err = models.ModifyEdbinfoUserIdByOldUserId(oldUserIdList, userId)
-			}
-
-		case 2: //钢联化工数据库
-			sourceStrList = append(sourceStrList, "钢联化工数据库")
-			tmpList, tmpErr := data_manage.GetMysteelChemicalIndexListByUserId(oldUserIdList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			if len(tmpList) > 0 {
-				for _, v := range tmpList {
-					//if v.SysUserId == newUserId {
-					//	errMsg = "新创建人不可和原创建人一致"
-					//	err = errors.New(errMsg)
-					//	return
-					//}
-					// 操作记录
-					dataPermissionMoveRecordList = append(dataPermissionMoveRecordList, &data_manage_permission.DataPermissionMoveRecord{
-						DataPermissionMoveRecordId: 0,
-						Source:                     int32(source),
-						SubSource:                  0,
-						OpUniqueCode:               uniqueCode,
-						DataId:                     fmt.Sprint(v.BaseFromMysteelChemicalIndexId),
-						DataCode:                   v.IndexCode,
-						DataName:                   v.IndexName,
-						OriginalUserId:             int32(v.SysUserId),
-						OriginalUserName:           v.SysUserRealName,
-						NewUserId:                  int32(adminInfo.AdminId),
-						NewUserName:                adminInfo.RealName,
-						CreateTime:                 time.Now(),
-					})
-				}
-				// 修改创建人
-				err = data_manage.ModifyMysteelChemicalIndexUserIdByOldUserId(oldUserIdList, adminInfo.AdminId, adminInfo.RealName)
-			}
-
-		case 3: //ETA指标库
-			sourceStrList = append(sourceStrList, "ETA指标库")
-			edbInfoType := 0
-			tmpList, tmpErr := data_manage.GetEdbInfoListByUserId(oldUserIdList, edbInfoType)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			if len(tmpList) > 0 {
-				for _, v := range tmpList {
-					// 操作记录
-					dataPermissionMoveRecordList = append(dataPermissionMoveRecordList, &data_manage_permission.DataPermissionMoveRecord{
-						DataPermissionMoveRecordId: 0,
-						Source:                     int32(source),
-						SubSource:                  int32(edbInfoType),
-						OpUniqueCode:               uniqueCode,
-						DataId:                     fmt.Sprint(v.EdbInfoId),
-						DataCode:                   v.EdbCode,
-						DataName:                   v.EdbName,
-						OriginalUserId:             int32(v.SysUserId),
-						OriginalUserName:           v.SysUserRealName,
-						NewUserId:                  int32(adminInfo.AdminId),
-						NewUserName:                adminInfo.RealName,
-						CreateTime:                 time.Now(),
-					})
-				}
-				// 修改创建人
-				err = data_manage.ModifyEdbInfoUserIdByOldUserId(oldUserIdList, edbInfoType, adminInfo.AdminId, adminInfo.RealName)
-			}
-
-		case 4: //ETA预测指标
-			sourceStrList = append(sourceStrList, "ETA预测指标")
-
-			edbInfoType := 1
-			tmpList, tmpErr := data_manage.GetEdbInfoListByUserId(oldUserIdList, edbInfoType)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			if len(tmpList) > 0 {
-				for _, v := range tmpList {
-					// 操作记录
-					dataPermissionMoveRecordList = append(dataPermissionMoveRecordList, &data_manage_permission.DataPermissionMoveRecord{
-						DataPermissionMoveRecordId: 0,
-						Source:                     int32(source),
-						SubSource:                  int32(edbInfoType),
-						OpUniqueCode:               uniqueCode,
-						DataId:                     fmt.Sprint(v.EdbInfoId),
-						DataCode:                   v.EdbCode,
-						DataName:                   v.EdbName,
-						OriginalUserId:             int32(v.SysUserId),
-						OriginalUserName:           v.SysUserRealName,
-						NewUserId:                  int32(adminInfo.AdminId),
-						NewUserName:                adminInfo.RealName,
-						CreateTime:                 time.Now(),
-					})
-				}
-				// 修改创建人
-				err = data_manage.ModifyEdbInfoUserIdByOldUserId(oldUserIdList, edbInfoType, adminInfo.AdminId, adminInfo.RealName)
-			}
-		case 5: //ETA图库
-			sourceStrList = append(sourceStrList, "ETA图库")
-			// 只展示eta图库
-			subSource := utils.CHART_SOURCE_DEFAULT
-
-			tmpList, tmpErr := data_manage.GetChartInfoListByUserId(oldUserIdList, subSource)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			if len(tmpList) > 0 {
-				for _, v := range tmpList {
-					// 操作记录
-					dataPermissionMoveRecordList = append(dataPermissionMoveRecordList, &data_manage_permission.DataPermissionMoveRecord{
-						DataPermissionMoveRecordId: 0,
-						Source:                     int32(source),
-						SubSource:                  int32(subSource),
-						OpUniqueCode:               uniqueCode,
-						DataId:                     fmt.Sprint(v.ChartInfoId),
-						DataCode:                   fmt.Sprint(v.ChartInfoId),
-						DataName:                   v.ChartName,
-						OriginalUserId:             int32(v.SysUserId),
-						OriginalUserName:           v.SysUserRealName,
-						NewUserId:                  int32(adminInfo.AdminId),
-						NewUserName:                adminInfo.RealName,
-						CreateTime:                 time.Now(),
-					})
-				}
-				// 修改创建人
-				err = data_manage.ModifyChartInfoUserIdByOldUserId(oldUserIdList, adminInfo.AdminId, adminInfo.RealName)
-			}
-		case 6: // ETA表格
-			sourceStrList = append(sourceStrList, "ETA表格")
-			tmpList, tmpErr := excel.GetNoContentExcelListByUserId(oldUserIdList)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			if len(tmpList) > 0 {
-				for _, v := range tmpList {
-					// 操作记录
-					dataPermissionMoveRecordList = append(dataPermissionMoveRecordList, &data_manage_permission.DataPermissionMoveRecord{
-						DataPermissionMoveRecordId: 0,
-						Source:                     int32(source),
-						SubSource:                  int32(v.Source),
-						OpUniqueCode:               uniqueCode,
-						DataId:                     fmt.Sprint(v.ExcelInfoId),
-						DataCode:                   fmt.Sprint(v.ExcelInfoId),
-						DataName:                   v.ExcelName,
-						OriginalUserId:             int32(v.SysUserId),
-						OriginalUserName:           v.SysUserRealName,
-						NewUserId:                  int32(adminInfo.AdminId),
-						NewUserName:                adminInfo.RealName,
-						CreateTime:                 time.Now(),
-					})
-				}
-				// 修改创建人
-				err = excel.ModifyExcelInfoUserIdByOldUserId(oldUserIdList, adminInfo.AdminId, adminInfo.RealName)
-			}
-		default:
-		}
-
-		// 转移失败了那么就直接返回了
-		if err != nil {
-			return
-		}
-	}
-
-	content += fmt.Sprintf("（%s）", strings.Join(sourceStrList, ","))
-
-	// 添加资产转移的记录
-	dataPermissionMessage := &data_manage_permission.DataPermissionMessage{
-		DataPermissionMessageId: 0,
-		SendUserId:              int32(opUserId),
-		ReceiveUserId:           int32(adminInfo.AdminId),
-		Content:                 title,
-		Remark:                  content,
-		OpType:                  2,
-		OpUniqueCode:            uniqueCode,
-		IsRead:                  0,
-		CreateTime:              time.Now(),
-		ModifyTime:              time.Now(),
-	}
-	tmpErr := data_manage_permission.AddDataPermissionMoveRecord(dataPermissionMoveRecordList, dataPermissionMessage)
-	// 失败的话，日志记录
-	if tmpErr != nil {
-		// 序列化结构体为 JSON 数据
-		recordListJsonBytes, tmpErr2 := json.Marshal(dataPermissionMoveRecordList)
-		if tmpErr2 != nil {
-			utils.FileLog.Error(fmt.Sprintf("添加资产转移的记录失败:%s;list转json失败：;操作记录：%+v;消息记录：%+v", tmpErr.Error(), dataPermissionMoveRecordList, dataPermissionMessage))
-			return
-		}
-		// 序列化结构体为 JSON 数据
-		messageJsonBytes, tmpErr2 := json.Marshal(dataPermissionMessage)
-		if tmpErr2 != nil {
-			utils.FileLog.Error(fmt.Sprintf("添加资产转移的记录失败:%s;message转json失败：;操作记录：%+v;消息记录：%+v", tmpErr.Error(), dataPermissionMoveRecordList, dataPermissionMessage))
-			return
-		}
-		utils.FileLog.Error(fmt.Sprintf("添加资产转移的记录失败:%s;操作记录：%s;消息记录：%s", tmpErr.Error(), string(recordListJsonBytes), string(messageJsonBytes)))
-	}
-
-	return
-}
-
 // MoveAllEdbChart
 // @Description: 通过原创建人转移指标/图表创建人
 // @author: Roc

services/data/data_manage_permission/excel.go

@@ -92,25 +92,6 @@ func GetUserExcelAndClassifyPermissionList(userId, excelInfoId, classifyId int)
 	return
 }
 
-// GetUserExcelClassifyPermissionList
-// @Description: 根据用户获取已经授权指标分类ID列表
-// @author: Roc
-// @datetime 2024-03-28 17:20:36
-// @param userId int
-// @param classifyId int  classifyId，则只返回该classifyId的权限列表（其实也就是为了判断是否存在该指标分类权限了，目的是为了少获取数据）
-// @return classifyIdList []int
-// @return err error
-func GetUserExcelClassifyPermissionList(userId, classifyId int) (classifyIdList []int, err error) {
-	// 获取有权限的指标分类ID列表
-	classifyIdList, err = data_manage_permission.GetPermissionExcelClassifyIdList(userId, classifyId)
-	if err != nil {
-		fmt.Println("获取授权指标分类列表失败， err:", err)
-		return
-	}
-
-	return
-}
-
 // CheckExcelPermissionByExcelInfoId
 // @Description: 根据指标id和指标分类id，检查EDB指标（含预测指标）权限（方法内部自己获取所有的指标和指标分类权限，不用额外传递）
 // @author: Roc
@@ -153,30 +134,3 @@ func CheckExcelPermission(excelIsJoinPermission, excelClassifyIsJoinPermission,
 
 	return
 }
-
-func CheckBalanceExcelPermissionByExcelInfoId(excelInfo *excel.ExcelInfo, excelIsJoinPermission, userId int) (hasAuth bool, err error) {
-	// 查询父级ID
-	if excelInfo.Source != utils.BALANCE_TABLE {
-		return
-	}
-	parentId := excelInfo.ParentId
-	if excelInfo.BalanceType == 1 { //静态表关联的动态表的权限
-		parentId = excelInfo.RelExcelInfoId
-	}
-	parentExcelInfo, err := excel.GetExcelInfoById(parentId)
-	if err != nil {
-		err = fmt.Errorf("查询表格信息出错 err: %v", err)
-		return
-	}
-	excelClassifyId := parentExcelInfo.ExcelClassifyId
-	excelInfoId := parentExcelInfo.ExcelInfoId
-	currClassify, err := excel.GetExcelClassifyById(excelClassifyId)
-	if err != nil {
-		return
-	}
-	if currClassify != nil {
-		return CheckExcelPermission(excelIsJoinPermission, currClassify.IsJoinPermission, userId, excelInfoId, excelClassifyId)
-	}
-
-	return
-}

services/data/edb_classify.go

@@ -15,30 +15,6 @@ import (
 	"time"
 )
 
-func EdbClassifyListMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) {
-	childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回
-	allEdbInfo, _ := GetEdbClassifyEdbInfo()
-	if len(childs) > 0 {
-		node.Children = append(node.Children, childs[0:]...) //添加子节点
-		for _, v := range childs {                           //查询子节点的子节点，并添加到子节点
-			_, has := edbClassifyHaveChild(allNode, v)
-			if has {
-				EdbClassifyListMakeTree(allNode, v) //递归添加节点
-			} else {
-				edbInfoList := allEdbInfo[v.ClassifyId]
-				v.Children = edbInfoList
-				if v.Children == nil {
-					childrenArr := make([]*data_manage.EdbClassifyItems, 0)
-					v.Children = childrenArr
-				}
-			}
-		}
-	} else {
-		childrenArr := make([]*data_manage.EdbClassifyItems, 0)
-		node.Children = childrenArr
-	}
-}
-
 func edbClassifyHaveChild(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) (childs []*data_manage.EdbClassifyItems, yes bool) {
 	for _, v := range allNode {
 		if v.ParentId == node.ClassifyId {
@@ -222,27 +198,6 @@ func GetChildClassifyByClassifyId(targetClassifyId int) (targetList []*data_mana
 
 	return
 }
-func GetEdbClassifyEdbInfo() (result map[int][]*data_manage.EdbClassifyItems, err error) {
-	cMap := make(map[int][]*data_manage.EdbClassifyItems)
-	items, err := data_manage.GetEdbInfoAll(0)
-	if err != nil {
-		return
-	}
-	for _, v := range items {
-		childrenArr := make([]*data_manage.EdbClassifyItems, 0)
-		v.Children = childrenArr
-		if items, ok := cMap[v.ClassifyId]; ok {
-			items = append(items, v)
-			cMap[v.ClassifyId] = items
-		} else {
-			infoList := make([]*data_manage.EdbClassifyItems, 0)
-			infoList = append(infoList, v)
-			cMap[v.ClassifyId] = infoList
-		}
-	}
-	result = cMap
-	return
-}
 
 func EdbClassifyItemsMakeTree(allNode []*data_manage.EdbClassifyItems, node *data_manage.EdbClassifyItems) {
 	childs, _ := edbClassifyHaveChild(allNode, node) //判断节点是否有子节点并返回

services/data/edb_info.go

@@ -33,41 +33,6 @@ func EdbInfoRefreshAllFromBaseV2(edbInfoId int, refreshAll, isRefreshTop bool) (
 	return
 }
 
-// EdbInfoRefreshAllFromBaseV3Bak 全部刷新指标（切换到edb_lib服务）
-// @author Roc
-// @datetime 2022-09-16 11:04:44
-// @description 将原有的单个指标刷新，调整为批量多个指标刷新
-// DeprecatedTime 2023-10-23 09:38:19废弃
-// Deprecated
-func EdbInfoRefreshAllFromBaseV3Bak(edbInfoIdList []int, refreshAll, isSync bool) (err error, isAsync bool) {
-	var errmsg string
-	defer func() {
-		if err != nil {
-			fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
-			go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
-			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
-		}
-	}()
-
-	// 获取关联的基础指标
-	newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
-	if err != nil {
-		return
-	}
-
-	// 需要刷新的指标数量
-	totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)
-
-	if totalEdbInfo <= 20 || isSync {
-		err = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
-	} else {
-		isAsync = true
-		go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
-	}
-
-	return
-}
-
 // EdbInfoRefreshAllFromBaseV3
 //
 //	@Description: 全部刷新指标（切换到edb_lib服务）
@@ -319,19 +284,6 @@ func edbInfoRefreshAll(refreshAll bool, newBaseEdbInfoArr, newBasePredictEdbInfo
 			return fmt.Errorf("刷新失败, err:", errmsg)
 		}
 
-		//maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
-		//if err != nil {
-		//	if utils.IsErrNoRow(err) { //找不到数据，那么就进入到下一条数据做处理
-		//		continue
-		//	}
-		//	return err
-		//}
-		//if maxAndMinItem != nil {
-		//	err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
-		//	if err != nil {
-		//		return err
-		//	}
-		//}
 		fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
 	}
 
@@ -748,427 +700,6 @@ func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId,
 	return
 }
 
-//全部刷新指标
-//func EdbInfoRefreshAllFromBase(edbInfoId int) (err error) {
-//	var errmsg string
-//	defer func() {
-//		if err != nil {
-//			fmt.Println("EdbInfoRefreshAllFromBase Err:" + err.Error() + ";errmsg:" + errmsg)
-//			go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
-//		}
-//	}()
-//
-//	calculateList, err := data_manage.GetEdbInfoAllCalculate(edbInfoId)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		return errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
-//	}
-//	baseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
-//	calculateInfoArr := make([]*data_manage.EdbInfo, 0)
-//	baseEdbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
-//	if err != nil {
-//		return errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
-//	}
-//	baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
-//
-//	for _, v := range calculateList {
-//		getBaseEdbInfoArr, getCalculateInfoArr, err := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
-//		if err != nil {
-//			fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
-//			errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
-//			return err
-//		}
-//		baseEdbInfoArr = append(baseEdbInfoArr, getBaseEdbInfoArr...)
-//		calculateInfoArr = append(calculateInfoArr, getCalculateInfoArr...)
-//		calculateInfoArr = append(calculateInfoArr, v)
-//	}
-//	//取重
-//	newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
-//	baseMap := make(map[int]int)
-//	for _, v := range baseEdbInfoArr {
-//		if _, ok := baseMap[v.EdbInfoId]; !ok {
-//			newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
-//		}
-//		baseMap[v.EdbInfoId] = v.EdbInfoId
-//	}
-//
-//	var calculateArr []int
-//	newCalculateMap := make(map[int]*data_manage.EdbInfo)
-//	for _, v := range calculateInfoArr {
-//		if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
-//			calculateArr = append(calculateArr, v.EdbInfoId)
-//		}
-//		newCalculateMap[v.EdbInfoId] = v
-//	}
-//	sort.Ints(calculateArr)
-//	var startDate string
-//	for _, bv := range newBaseEdbInfoArr {
-//		source := bv.Source
-//		edbInfoId := bv.EdbInfoId
-//		edbCode := bv.EdbCode
-//
-//		sTime, err := time.Parse(utils.FormatDate, bv.StartDate)
-//		if err != nil {
-//			return err
-//		}
-//		startDate = sTime.Format(utils.FormatDate)
-//
-//		if source == utils.DATA_SOURCE_THS {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByThs(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByThs Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_WIND {
-//			endDate := time.Now().Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByWind(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByWind Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_PB {
-//			startDate := sTime.Format(utils.FormatDateUnSpace)
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
-//			err = data_manage.RefreshAllEdbDataByPb(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByPb Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_MANUAL {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByManual(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByManual Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_LZ {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByLz(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByLz Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_YS {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByYs(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByYs Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_GL {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByGl(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByGl Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_ZZ {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByZz(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByZz Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_DL {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByDl(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByDl Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_SH {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataBySh(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataBySh Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_CFFEX {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByCffex(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByCffex Err:" + err.Error()
-//			}
-//		} else if source == utils.DATA_SOURCE_SHFE {
-//			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
-//			err = data_manage.RefreshAllEdbDataByShfe(edbInfoId, source, edbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllEdbDataByShfe Err:" + err.Error()
-//			}
-//		}
-//
-//		maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
-//		if err != nil {
-//			return err
-//		}
-//		if maxAndMinItem != nil {
-//			err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
-//			if err != nil {
-//				return err
-//			}
-//		}
-//		fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
-//	}
-//
-//	endDate := "" //计算指标不限制日期
-//	//刷新相关计算指标
-//	for _, v := range calculateArr {
-//		edbInfo := newCalculateMap[v]
-//		if edbInfo == nil {
-//			return err
-//		}
-//		edbInfoId := edbInfo.EdbInfoId
-//		source := edbInfo.Source
-//		edbCode := edbInfo.EdbCode
-//
-//		if source == utils.DATA_SOURCE_CALCULATE {
-//			startDate = edbInfo.StartDate
-//			sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
-//			if err != nil {
-//				return err
-//			}
-//			startDate = sTime.Format(utils.FormatDate)
-//
-//			var edbInfoIdBytes []string
-//			calculateMap, err := data_manage.GetEdbInfoCalculateDetail(edbInfoId, edbInfo.Source)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateDetail Err:" + err.Error()
-//				return err
-//			}
-//			var formulaStr string
-//			edbInfoList := make([]*data_manage.EdbInfo, 0)
-//
-//			for _, v := range calculateMap {
-//				formulaStr += v.FromTag + ","
-//				edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
-//				edbInfo, _ := data_manage.GetEdbInfoById(v.FromEdbInfoId)
-//				edbInfoList = append(edbInfoList, edbInfo)
-//			}
-//			err = data_manage.RefreshAllCalculate(edbInfoList, int(edbInfoId), source, edbInfo.EdbCode, edbInfo.CalculateFormula, startDate, endDate, edbInfoIdBytes)
-//			if err != nil {
-//				errmsg = "RefreshCalculate Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_LJZZY { //刷新累计值转月值
-//			calculateLjzzy, err := data_manage.GetEdbInfoCalculateLjzzyDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateLjzzyDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateLjzzy.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			err = data_manage.RefreshAllCalculateLjzzy(edbInfoId, source, fromEdbInfo, calculateLjzzy.EdbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateLjzzy Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_TBZ { //刷新同比值
-//			calculateTbz, err := data_manage.GetEdbInfoCalculateTbzDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			err = data_manage.RefreshAllCalculateTbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateTbz Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_TCZ { //同差值
-//			calculateTcz, err := data_manage.GetEdbInfoCalculateTczDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateTczDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTcz.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			err = data_manage.RefreshAllCalculateTcz(edbInfoId, source, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshCalculateTcz Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS { //N数值移动平均计算
-//			calculateNszydpjjs, err := data_manage.GetEdbInfoCalculateNszydpjjsDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateNszydpjjs.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
-//			startDate = edbInfo.StartDate
-//			err = data_manage.RefreshAllCalculateNszydpjjs(edbInfoId, edbInfo.Source, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode, startDate)
-//			if err != nil {
-//				errmsg = "RefreshCalculateNszydpjjs Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_HBZ { //刷新环比值
-//			calculateTbz, err := data_manage.GetEdbInfoCalculateHbzDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateHbzDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
-//			err = data_manage.RefreshAllCalculateHbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateHbz Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_HCZ { //刷新环差值
-//			calculateTbz, err := data_manage.GetEdbInfoCalculateHczDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateHczDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
-//			err = data_manage.RefreshAllCalculateHcz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateHcz Err:" + err.Error()
-//				return err
-//			}
-//		} else if source == utils.DATA_SOURCE_CALCULATE_BP { //刷新变频
-//			calculateTbz, err := data_manage.GetEdbInfoCalculateBpDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			err = data_manage.RefreshAllCalculateBp(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateBp Err:" + err.Error()
-//				return err
-//			}
-//<<<<<<< HEAD
-//		} else if source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT {
-//			calculate, err := data_manage.GetEdbInfoCalculateMappingDetail(edbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
-//				return err
-//			}
-//			fromEdbInfo, err := data_manage.GetEdbInfoById(calculate.FromEdbInfoId)
-//			if err != nil {
-//				errmsg = "GetEdbInfoById Err:" + err.Error()
-//				return err
-//			}
-//			startDate = edbInfo.StartDate
-//			endDate = time.Now().Format(utils.FormatDate)
-//			formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
-//			err = data_manage.RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateTimeShift Err:" + err.Error()
-//=======
-//		} else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //刷新直接拼接
-//			err = data_manage.RefreshAllCalculateZjpj(edbInfo)
-//			if err != nil {
-//				errmsg = "RefreshAllCalculateBp Err:" + err.Error()
-//>>>>>>> 884fd669cc9e91923781680e1890a519c012d38e
-//				return err
-//			}
-//		}
-//
-//		maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
-//		if err != nil {
-//			return err
-//		}
-//
-//		if maxAndMinItem != nil {
-//			err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
-//			if err != nil {
-//				return err
-//			}
-//		}
-//		fmt.Println("end calculateArr:", v, time.Now())
-//	}
-//	return err
-//}
-//
-//// AddEdbInfo 新增手工指标数据
-//func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId, userId int) (err error) {
-//	tradeCode, err := models.GetMaxTradeCode()
-//	if err != nil {
-//		return
-//	}
-//
-//	if tradeCode == "" {
-//		err = errors.New("最大编码为空")
-//		return
-//	}
-//	maxTradeCode, err := utils.GetMaxTradeCode(tradeCode)
-//	if err != nil {
-//		err = errors.New("获取编码信息失败,Err:" + err.Error())
-//		return
-//	}
-//	if maxTradeCode == "" {
-//		err = errors.New("编码为空，请联系技术")
-//		return
-//	}
-//	//判断指标名称是否为空
-//	if secName == "" {
-//		err = errors.New("指标名称不能为空")
-//		return
-//	}
-//	item, err := models.GetEdbinfoBySecName(secName)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		err = errors.New("获取信息失败，Err:" + err.Error())
-//		return
-//	}
-//	if item != nil {
-//		err = errors.New("指标名称已存在")
-//		return
-//	}
-//	err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, noticeTime, classifyId, userId)
-//	if err != nil {
-//		err = errors.New("新增失败，Err:" + err.Error())
-//		return
-//	}
-//	err = models.AddEdbinfoUser(maxTradeCode, mobile)
-//	return
-//}
-//
-//
-//
-//
-
-// AddOrEditAllEdbInfoToEs 修复ES中的指标
-func AddOrEditAllEdbInfoToEs() {
-	//添加es
-	total, itemInfoList, _ := data_manage.GetEdbInfoFilterList("", []interface{}{}, 0, 100000)
-	for k, itemInfo := range itemInfoList {
-		itemInfo.ConvertToResp()
-		elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
-		fmt.Println("剩余", int(total)-k-1, "条数据")
-	}
-}
-
 // AddOrEditEdbInfoToEs 添加/修改ES中的指标
 func AddOrEditEdbInfoToEs(edbInfoId int) {
 	//添加es
@@ -1249,216 +780,6 @@ func GetLeadUnitEn(unit string) (unitEn string) {
 	return
 }
 
-// getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标）
-//func getRefreshEdbInfoList(edbInfoId int) (newBaseEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
-//	calculateList, err := data_manage.GetEdbInfoAllCalculate(edbInfoId)
-//	if err != nil && !utils.IsErrNoRow(err) {
-//		err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
-//		return
-//	}
-//	// 获取指标信息
-//	baseEdbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
-//	if err != nil {
-//		err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
-//		return
-//	}
-//
-//	baseEdbInfoArr := make([]*data_manage.EdbInfo, 0)          // 基础普通指标
-//	calculateInfoArr := make([]*data_manage.EdbInfo, 0)        //基础运算指标
-//	basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0)   // 预测普通指标
-//	predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标
-//
-//	if baseEdbInfo.EdbInfoType == 0 { //普通指标
-//		switch baseEdbInfo.EdbType {
-//		case 1: //基础指标
-//			baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
-//		case 2: //计算指标
-//			calculateList = append(calculateList, baseEdbInfo)
-//		}
-//	} else { //预测指标
-//		switch baseEdbInfo.EdbType {
-//		case 1: //基础指标
-//			basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo)
-//		case 2: //计算指标
-//			predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo)
-//		}
-//	}
-//
-//	// 计算指标
-//	for _, v := range calculateList {
-//		getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
-//		if tmpErr != nil {
-//			err = tmpErr
-//			fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
-//			errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
-//			return
-//		}
-//		for _, tmpEdbInfo := range getBaseEdbInfoArr {
-//			switch tmpEdbInfo.EdbInfoType {
-//			case 0: //普通基础指标
-//				baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
-//			case 1: //预测基础指标
-//				basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
-//			}
-//		}
-//
-//		for _, tmpEdbInfo := range getCalculateInfoArr {
-//			switch tmpEdbInfo.EdbInfoType {
-//			case 0: //普通运算指标
-//				calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
-//			case 1: //预测运算指标
-//				predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
-//			}
-//		}
-//		switch v.EdbInfoType {
-//		case 0: //普通运算指标
-//			calculateInfoArr = append(calculateInfoArr, v)
-//		case 1: //预测运算指标
-//			predictCalculateInfoArr = append(predictCalculateInfoArr, v)
-//		}
-//	}
-//
-//	// 预测计算指标
-//	for _, v := range predictCalculateInfoArr {
-//		getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
-//		if tmpErr != nil {
-//			err = tmpErr
-//			fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
-//			errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
-//			return
-//		}
-//		for _, tmpEdbInfo := range getBaseEdbInfoArr {
-//			switch tmpEdbInfo.EdbInfoType {
-//			case 0: //普通基础指标
-//				baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
-//			case 1: //预测基础指标
-//				basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
-//			}
-//		}
-//
-//		for _, tmpEdbInfo := range getCalculateInfoArr {
-//			switch tmpEdbInfo.EdbInfoType {
-//			case 0: //普通运算指标
-//				calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
-//			case 1: //预测运算指标
-//				predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
-//			}
-//		}
-//		switch v.EdbInfoType {
-//		case 0: //普通运算指标
-//			calculateInfoArr = append(calculateInfoArr, v)
-//		case 1: //预测运算指标
-//			predictCalculateInfoArr = append(predictCalculateInfoArr, v)
-//		}
-//	}
-//
-//	// 第一次的计算指标map
-//	newCalculateMap = make(map[int]*data_manage.EdbInfo)
-//	for _, v := range calculateInfoArr {
-//		if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
-//			calculateArr = append(calculateArr, v.EdbInfoId)
-//		}
-//		newCalculateMap[v.EdbInfoId] = v
-//	}
-//
-//	// 基础预测指标
-//	if len(basePredictEdbInfoArr) > 0 {
-//		basePredictEdbInfoIdList := make([]int, 0)
-//		for _, v := range basePredictEdbInfoArr {
-//			basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId)
-//		}
-//		baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
-//		if tmpErr != nil {
-//			err = tmpErr
-//			return
-//		}
-//
-//		tmpCalculateList := make([]*data_manage.EdbInfo, 0)
-//		for _, v := range baseEdbInfoList {
-//			switch v.EdbType {
-//			case 1:
-//				baseEdbInfoArr = append(baseEdbInfoArr, v)
-//			case 2:
-//				// 如果不在第一次里面，那么在第二次 刷新预测指标的时候 需要加进去
-//				if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
-//					tmpCalculateList = append(tmpCalculateList, v)
-//				}
-//			}
-//		}
-//
-//		// 这里是查询预测指标用到的 普通计算指标
-//		for _, v := range tmpCalculateList {
-//			getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
-//			if tmpErr != nil {
-//				err = tmpErr
-//				fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
-//				errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
-//				return
-//			}
-//
-//			// 基础指标
-//			for _, tmpEdbInfo := range getBaseEdbInfoArr {
-//				switch tmpEdbInfo.EdbInfoType {
-//				case 0: //普通基础指标
-//					baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
-//				case 1: //预测基础指标
-//					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
-//				}
-//			}
-//
-//			// 计算指标
-//			for _, tmpEdbInfo := range getCalculateInfoArr {
-//				switch tmpEdbInfo.EdbInfoType {
-//				case 0: //普通运算指标
-//					calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
-//				case 1: //预测运算指标
-//					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
-//				}
-//			}
-//			switch v.EdbInfoType {
-//			case 0: //普通运算指标
-//				calculateInfoArr = append(calculateInfoArr, v)
-//			case 1: //预测运算指标
-//				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
-//			}
-//		}
-//
-//		// 第二次计算指标的map
-//		for _, v := range calculateInfoArr {
-//			if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
-//				calculateArr = append(calculateArr, v.EdbInfoId)
-//			}
-//			newCalculateMap[v.EdbInfoId] = v
-//		}
-//	}
-//
-//	// 普通基础指标去重
-//	newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
-//	baseMap := make(map[int]int)
-//	for _, v := range baseEdbInfoArr {
-//		if _, ok := baseMap[v.EdbInfoId]; !ok {
-//			newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
-//		}
-//		baseMap[v.EdbInfoId] = v.EdbInfoId
-//	}
-//
-//	// 普通计算指标的id
-//	sort.Ints(calculateArr)
-//
-//	// 预测计算指标去重
-//	newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
-//	for _, v := range predictCalculateInfoArr {
-//		if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok {
-//			predictCalculateArr = append(predictCalculateArr, v.EdbInfoId)
-//		}
-//		newPredictCalculateMap[v.EdbInfoId] = v
-//	}
-//	// 预测计算指标的id
-//	sort.Ints(predictCalculateArr)
-//
-//	return
-//}
-
 // getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标）
 func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
 	calculateList, err := data_manage.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList)
@@ -2572,26 +1893,6 @@ func BatchRefreshEdbByEdbIds(edbIdList []int, redisKey string, refreshKeys []str
 	// 关联指标过多的时候, 异步刷新
 	if totalEdbInfo > 20 {
 		syncing = true
-
-		//go func() {
-		//	defer func() {
-		//		if err != nil {
-		//			alarm_msg.SendAlarmMsg("BatchRefreshEdbByEdbIds, ErrMsg: "+err.Error(), 3)
-		//		}
-		//	}()
-		//
-		//	err = edbInfoRefreshAll(false, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
-		//
-		//	if redisKey != `` {
-		//		_ = utils.Rc.Delete(redisKey)
-		//	}
-		//	if len(refreshKeys) > 0 {
-		//		for _, v := range refreshKeys {
-		//			_ = utils.Rc.Delete(v)
-		//		}
-		//	}
-		//}()
-
 		// 加入队列刷新
 		var refreshItem EdbQueueRefreshReq
 		refreshItem.RefreshKey = redisKey
@@ -2620,113 +1921,6 @@ func BatchRefreshEdbByEdbIds(edbIdList []int, redisKey string, refreshKeys []str
 	return
 }
 
-// EdbInfoSmmApiAdd 添加指标到指标库
-func EdbInfoSmmApiAdd(item *data_manage.EdbInfo) (edbInfo *data_manage.EdbInfo, err error, errMsg string, isSendEmail bool) {
-	isSendEmail = true
-	//判断指标名称是否存在
-	var condition string
-	var pars []interface{}
-
-	condition += " AND edb_name=? "
-	pars = append(pars, item.EdbName)
-
-	count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
-	if err != nil {
-		errMsg = "判断指标名称是否存在失败"
-		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
-		return
-	}
-
-	if count > 0 {
-		errMsg = "指标名称已存在，请重新填写"
-		err = errors.New(errMsg)
-		isSendEmail = false
-		return
-	}
-
-	source := item.Source
-
-	edbInfo = new(data_manage.EdbInfo)
-	edbInfo.Source = source
-
-	var sourceName string
-	edbSource := data_manage.GetEdbSourceBySourceId(source)
-	if edbSource != nil {
-		sourceName = edbSource.SourceName
-	}
-	if sourceName == "" {
-		errMsg = "指标来源异常"
-		err = errors.New(errMsg)
-		return
-	}
-	edbInfo.SourceName = sourceName
-
-	edbType := 1 //基础指标
-	if source == utils.DATA_SOURCE_STOCK_PLANT {
-		edbType = 2 //计算指标
-	}
-	//从缓存中获取
-	serverUrl := ``
-	if edbInfo.Source == utils.DATA_SOURCE_WIND {
-		windCacheKey := utils.CACHE_WIND_URL + ":" + item.EdbCode
-		serverUrl, _ = utils.Rc.RedisString(windCacheKey)
-		if serverUrl == `` {
-			if len(utils.Hz_Data_WIND_Url_List) >= 1 {
-				serverUrl = utils.Hz_Data_WIND_Url_List[len(utils.Hz_Data_WIND_Url_List)-1] //默认是最后一个服务器地址
-			}
-		}
-	}
-	//获取该层级下最大的排序数
-	maxSort, err := GetEdbClassifyMaxSort(item.ClassifyId, 0)
-	if err != nil {
-		errMsg = "获取失败"
-		err = errors.New("查询排序信息失败，Err:" + err.Error())
-		return
-	}
-
-	edbInfo.EdbCode = item.EdbCode
-	edbInfo.EdbName = item.EdbName
-	edbInfo.EdbNameSource = item.EdbName
-	edbInfo.Frequency = item.Frequency
-	edbInfo.Unit = item.Unit
-	edbInfo.ClassifyId = item.ClassifyId
-	edbInfo.SysUserId = item.SysUserId
-	edbInfo.SysUserRealName = item.SysUserRealName
-	edbInfo.CreateTime = time.Now()
-	edbInfo.ModifyTime = time.Now()
-	edbInfo.ServerUrl = serverUrl
-	edbInfo.Sort = maxSort + 1
-	edbInfo.DataDateType = `交易日`
-	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-	edbInfo.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
-	edbInfo.EdbType = edbType
-	edbInfo.SubSource = item.SubSource
-	edbInfo.SubSourceName = ""
-	edbInfo.IndicatorCode = item.IndicatorCode
-	edbInfo.StockCode = item.StockCode
-	edbInfoId, err := data_manage.AddEdbInfo(edbInfo)
-	if err != nil {
-		errMsg = "保存失败"
-		err = errors.New("保存失败，Err:" + err.Error())
-		return
-	}
-	edbInfo.EdbInfoId = int(edbInfoId)
-	//保存数据
-	err = data_manage.ModifyEdbInfoWindWsdDataStatus(source, item.SubSource, edbInfoId, item.EdbCode)
-	if err != nil {
-		errMsg = "保存失败"
-		err = errors.New("修改数据对应指标ID失败，Err:" + err.Error())
-		return
-	}
-	maxAndMinItem, _ := data_manage.GetEdbInfoWsdMaxAndMinInfo(source, item.SubSource, item.EdbCode)
-	if maxAndMinItem != nil {
-		err = data_manage.ModifyEdbInfoMaxAndMinInfo(int(edbInfoId), maxAndMinItem)
-	}
-	//添加es
-	AddOrEditEdbInfoToEs(int(edbInfoId))
-	return
-}
-
 // GetEdbTerminal 获取终端信息
 func GetEdbTerminal(source int, oldTerminalCode string) (edbTerminal *data_manage.EdbTerminal, err error) {
 	if source == utils.DATA_SOURCE_WIND && oldTerminalCode == "" {
@@ -2786,10 +1980,6 @@ func GetEdbTerminal(source int, oldTerminalCode string) (edbTerminal *data_manag
 		err = errors.New("获取配置的终端地址失败")
 		return
 	}
-	/*if edbTerminal != nil {
-		windUrl = edbTerminal.ServerUrl
-		terminalCode = edbTerminal.TerminalCode
-	}*/
 	return
 }
 

services/data/edb_info_calculate.go

@@ -8,7 +8,6 @@ import (
 	"fmt"
 	"github.com/shopspring/decimal"
 	"math"
-	"regexp"
 	"sort"
 	"strings"
 	"time"
@@ -63,399 +62,6 @@ type CalculateItems struct {
 	DataMap   map[string]float64
 }
 
-func ReplaceFormula(edbInfoIdArr []*data_manage.EdbInfo, valArr map[int]float64, formulaMap map[string]string, formulaStr string, edbInfoIdBytes []string) string {
-	// todo 处理min和max
-	funMap := GetFormulaMap()
-	for k, v := range funMap {
-		formulaStr = strings.Replace(formulaStr, k, v, -1)
-	}
-	replaceCount := 0
-	for dk, dv := range edbInfoIdArr {
-		if dk == 0 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				} else {
-					fmt.Println("valArr not found:", valArr, valOk)
-				}
-			} else {
-				fmt.Println("formulaMap not found:", dKey, dk)
-			}
-		}
-		if dk == 1 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				} else {
-					fmt.Println("valArr not found:", valArr, valOk)
-				}
-			} else {
-				fmt.Println("formulaMap not found:", dKey, dk)
-			}
-		}
-		if dk == 2 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 3 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 4 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 5 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 6 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 7 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 8 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 9 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 10 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 11 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 12 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 13 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 14 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 15 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 16 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 17 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 18 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 19 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 20 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 21 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 22 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 23 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 24 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-		if dk == 25 {
-			dKey := edbInfoIdBytes[dk]
-			if _, ok := formulaMap[dKey]; ok { //公式中存在
-				if val, valOk := valArr[dv.EdbInfoId]; valOk { //值存在
-					dvStr := fmt.Sprintf("%v", val)
-					formulaStr = strings.Replace(formulaStr, dKey, dvStr, -1)
-					replaceCount++
-				}
-			}
-		}
-	}
-	for k, v := range funMap {
-		formulaStr = strings.Replace(formulaStr, v, k, -1)
-	}
-	if replaceCount == len(formulaMap) {
-		return formulaStr
-	} else {
-		return ""
-	}
-}
-
-func GetFormulaMap() map[string]string {
-	funMap := make(map[string]string)
-	funMap["MAX"] = "[@@]"
-	funMap["MIN"] = "[@!]"
-	funMap["ABS"] = "[@#]"
-	funMap["CEIL"] = "[@$]"
-	funMap["COS"] = "[@%]"
-	funMap["FLOOR"] = "[@^]"
-	funMap["MOD"] = "[@&]"
-	funMap["POW"] = "[@*]"
-	funMap["ROUND"] = "[@(]"
-	return funMap
-}
-
-// 处理整个数据
-func handleDateSaveDataMap(dateList []string, realSaveDataMap, saveDataMap map[string]map[int]float64, edbInfoIdArr []*data_manage.EdbInfo, emptyType int) {
-	var startDate, endDate string
-	var startDateT, endDateT time.Time
-	if emptyType == 2 || emptyType == 3 {
-		for k, _ := range realSaveDataMap {
-			if k > endDate {
-				endDate = k
-			}
-			if k < startDate || startDate == "" {
-				startDate = k
-			}
-		}
-
-		startDateT, _ = time.ParseInLocation(utils.FormatDate, startDate, time.Local)
-		endDateT, _ = time.ParseInLocation(utils.FormatDate, endDate, time.Local)
-	}
-	for _, date := range dateList {
-		tmpDataMap := realSaveDataMap[date]
-		for _, edbInfo := range edbInfoIdArr {
-			tmpEdbInfoId := edbInfo.EdbInfoId // 当前指标id
-			// 如果该日期不存在该指标数据，那么需要找寻前后日期的数据，进行填补
-			if _, ok := tmpDataMap[tmpEdbInfoId]; !ok {
-				//day := 0
-				//switch edbInfo.Frequency {
-				//case "周度":
-				//	day = 7
-				//case "旬度":
-				//	day = 15
-				//case "月度":
-				//	day = 30
-				//case "季度":
-				//	day = 90
-				//case "年度":
-				//	day = 365
-				//}
-				// 需求池 255 指标运算文案修改，补数据遍历区间修改（2023-3-7 09:37:23修改）
-				switch emptyType {
-				case 0:
-					handleDateDataMap(realSaveDataMap, saveDataMap, date, tmpEdbInfoId, 35)
-				case 2:
-					handleDateDataMapBefore(realSaveDataMap, saveDataMap, date, tmpEdbInfoId, startDateT, endDateT)
-				case 3:
-					handleDateDataMapAfter(realSaveDataMap, saveDataMap, date, tmpEdbInfoId, startDateT, endDateT)
-				case 4:
-					handleDateDataMapZero(saveDataMap, date, tmpEdbInfoId)
-				}
-			}
-		}
-	}
-}
-
-// handleDataMap 处理单个日期的数据
-func handleDateDataMap(realSaveDataMap, saveDataMap map[string]map[int]float64, date string, edbInfoId, day int) {
-	currDate, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
-
-	// 后一天
-	nextDateDayStr := currDate.AddDate(0, 0, 1).Format(utils.FormatDate)
-
-	// 前一天
-	preDateDayStr := currDate.AddDate(0, 0, -1).Format(utils.FormatDate)
-
-	for i := 1; i <= day; i++ {
-
-		// 下个日期的数据
-		{
-			if i >= 1 {
-				nextDateDayStr = currDate.AddDate(0, 0, i).Format(utils.FormatDate)
-			}
-			if findDataMap, hasFindDataMap := realSaveDataMap[nextDateDayStr]; hasFindDataMap { // 下一个日期有数据
-				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
-					saveDataMap[date][edbInfoId] = val
-					return
-				}
-			}
-		}
-
-		// 上个日期的数据
-		{
-			if i >= 1 {
-				preDateDayStr = currDate.AddDate(0, 0, -i).Format(utils.FormatDate)
-			}
-			if findDataMap, hasFindDataMap := realSaveDataMap[preDateDayStr]; hasFindDataMap { // 下一个日期有数据
-				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
-					saveDataMap[date][edbInfoId] = val
-					return
-				}
-			}
-		}
-	}
-}
-
 // handleDataByLinearRegression 插值法补充数据(线性方程式)
 func handleDataByLinearRegression(edbInfoDataList []*data_manage.EdbDataList, handleDataMap map[string]float64) (err error) {
 	if len(edbInfoDataList) < 2 {
@@ -552,115 +158,6 @@ func CallCalculateComputeCorrelation(data *data_manage.EdbInfoCalculateBatchSave
 	return
 }
 
-// handleDateDataMapBefore 前值填充：空值优先以最近的前值填充，没有前值时，用后值填充
-func handleDateDataMapBefore(realSaveDataMap, saveDataMap map[string]map[int]float64, date string, edbInfoId int, startDateT, endDateT time.Time) {
-	currDate, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
-
-	// 后一天
-	nextDateDay := currDate
-
-	// 前一天
-	preDateDay := currDate
-
-	for i := 1; preDateDay.After(startDateT) || preDateDay == startDateT; i++ {
-		// 上个日期的数据
-		{
-			preDateDay = currDate.AddDate(0, 0, -i)
-			preDateDayStr := preDateDay.Format(utils.FormatDate)
-			if findDataMap, hasFindDataMap := realSaveDataMap[preDateDayStr]; hasFindDataMap { // 下一个日期有数据
-				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
-					fmt.Println(fmt.Sprintf("date:%s, 无值，取%s的值%.4f", date, preDateDayStr, val))
-					saveDataMap[date][edbInfoId] = val
-					return
-				}
-			}
-		}
-	}
-
-	for i := 1; nextDateDay.Before(endDateT) || nextDateDay == endDateT; i++ {
-		// 下个日期的数据
-		{
-			nextDateDay = currDate.AddDate(0, 0, i)
-			nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-			if findDataMap, hasFindDataMap := realSaveDataMap[nextDateDayStr]; hasFindDataMap { // 下一个日期有数据
-				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
-					fmt.Println(fmt.Sprintf("date:%s, 无值，取%s的值%.4f", date, nextDateDayStr, val))
-					saveDataMap[date][edbInfoId] = val
-					return
-				}
-			}
-		}
-	}
-	return
-}
-
-// handleDateDataMapAfter 后值填充：空值优先以最近的后值填充，没有后值时，用前值填充
-func handleDateDataMapAfter(realSaveDataMap, saveDataMap map[string]map[int]float64, date string, edbInfoId int, startDateT, endDateT time.Time) {
-	currDate, _ := time.ParseInLocation(utils.FormatDate, date, time.Local)
-
-	// 后一天
-	nextDateDay := currDate
-
-	// 前一天
-	preDateDay := currDate
-
-	for i := 1; nextDateDay.Before(endDateT) || nextDateDay == endDateT; i++ {
-		// 下个日期的数据
-		{
-			nextDateDay = currDate.AddDate(0, 0, i)
-			nextDateDayStr := nextDateDay.Format(utils.FormatDate)
-			if findDataMap, hasFindDataMap := realSaveDataMap[nextDateDayStr]; hasFindDataMap { // 下一个日期有数据
-				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
-					fmt.Println(fmt.Sprintf("date:%s, 无值，取%s的值%.4f", date, nextDateDayStr, val))
-					saveDataMap[date][edbInfoId] = val
-					return
-				}
-			}
-		}
-	}
-
-	for i := 1; preDateDay.After(startDateT) || preDateDay == startDateT; i++ {
-		// 上个日期的数据
-		{
-			preDateDay = currDate.AddDate(0, 0, -i)
-			preDateDayStr := preDateDay.Format(utils.FormatDate)
-			if findDataMap, hasFindDataMap := realSaveDataMap[preDateDayStr]; hasFindDataMap { // 下一个日期有数据
-				if val, hasFindItem := findDataMap[edbInfoId]; hasFindItem {
-					fmt.Println(fmt.Sprintf("date:%s, 无值，取%s的值%.4f", date, preDateDayStr, val))
-					saveDataMap[date][edbInfoId] = val
-					return
-				}
-			}
-		}
-	}
-	return
-}
-
-// handleDateDataMapZero 等于0
-func handleDateDataMapZero(saveDataMap map[string]map[int]float64, date string, edbInfoId int) {
-	saveDataMap[date][edbInfoId] = 0
-	return
-}
-
-func GetMaxMinEdbInfo(formula string) string {
-	//formula := "A+min(A,B,max(A,C))"
-	// todo 无法处理max里嵌套max或者min的情况
-	// 使用正则表达式匹配MAX和MIN函数及其参数
-	regex := regexp.MustCompile(`(?i)(MAX|MIN)\((.*?)\)`)
-	matches := regex.FindAllStringSubmatch(formula, -1)
-	// 遍历匹配结果，输出MAX和MIN函数及其参数
-	for _, match := range matches {
-		if len(match) == 3 {
-			parameter := strings.ToLower(match[0]) // 参数
-			formula = strings.ReplaceAll(formula, match[0], parameter)
-			fmt.Printf("formula: %s\n", formula)
-		}
-	}
-	formula = strings.ReplaceAll(formula, "max", "MAX")
-	formula = strings.ReplaceAll(formula, "min", "MIN")
-	return formula
-}
-
 // HandleDataByLinearRegressionToList 插值法补充数据(线性方程式)
 func HandleDataByLinearRegressionToList(edbInfoDataList []*data_manage.EdbDataList, handleDataMap map[string]float64) (dataTimeList []string, valueList []float64, err error) {
 	if len(edbInfoDataList) < 2 {

services/data/excel/custom_analysis.go

@@ -262,43 +262,6 @@ func SaveCustomAnalysisTable(excelInfo *excel.ExcelInfo, excelName, content, exc
 			return
 		}
 	}
-
-	//// 查找当前excel的sheet列表
-	//currSheetList, err := excel.GetAllSheetList(excelInfo.ExcelInfoId)
-	//if err != nil {
-	//	errMsg = "保存失败"
-	//	err = errors.New("查找当前excel的sheet列表失败，Err:" + err.Error())
-	//	return
-	//}
-	//currSheetMap := make(map[string]string)
-	//for _, currSheet := range currSheetList {
-	//	currSheetMap[currSheet.SheetName] = currSheet.SheetName
-	//}
-	//
-	//for k, sheetOp := range sheetOpList {
-	//	sheetName := utils.TrimLRStr(sheetOp.SheetName)
-	//	switch sheetOp.OpType {
-	//	case "add":
-	//		// 新增
-	//		_, ok := currSheetMap[sheetName]
-	//		if ok {
-	//			errMsg = "存在同名sheet:" + sheetName
-	//			err = errors.New(errMsg)
-	//			isSendEmail = false
-	//			return
-	//		}
-	//	case "replace":
-	//		// 替换
-	//	case "append":
-	//		// 追加
-	//	default:
-	//		errMsg = fmt.Sprint("第", k+1, "个sheet,错误的操作类型")
-	//		err = errors.New(errMsg + "op:" + sheetOp.OpType)
-	//		isSendEmail = false
-	//		return
-	//	}
-	//}
-
 	// 表格
 	excelInfo.ExcelName = excelName
 	// 如果分类不传入的话，那么分类不变更

services/data/excel/excel_classify.go

@@ -146,25 +146,8 @@ func moveExcelClassify(parentExcelClassifyInfo, excelClassifyInfo, prevClassify,
 	// 移动对象为分类， 判断分类是否存在
 	if excelClassifyInfo != nil {
 		oldParentId := excelClassifyInfo.ParentId
-		/*oldLevel := excelClassifyInfo.Level
-		var classifyIds []int*/
 		if oldParentId != parentClassifyId {
 			//todo 更新子分类对应的level
-			/*childList, e, m := GetChildClassifyByClassifyId(excelClassifyInfo.ClassifyId)
-			if e != nil {
-				errMsg = "移动失败"
-				err = errors.New("查询子分类失败,Err:" + e.Error() + m)
-				return
-			}
-
-			if len(childList) > 0 {
-				for _, v := range childList {
-					if v.ClassifyId == excelClassifyInfo.ClassifyId {
-						continue
-					}
-					classifyIds = append(classifyIds, v.ClassifyId)
-				}
-			}*/
 		}
 		//判断上级id是否一致，如果不一致的话，那么需要移动该分类层级
 		if excelClassifyInfo.ParentId != parentClassifyId && parentClassifyId != 0 {

services/data/excel/mixed_table.go

@@ -640,16 +640,6 @@ func handleDate(dataTimeType int, val string) (date string, newVal string, err e
 
 	switch dataTimeType {
 	case request.CustomDateT: //手动输入日期
-		/*if !strings.Contains(val, "{") {
-			newVal, err, errMsg = handleOldCustomerDateT(val)
-			if err != nil {
-				return
-			}
-		}
-		date, err = HandleMixTableDateChange("", newVal)
-		if err != nil {
-			return
-		}*/
 		date = val
 		return
 	case request.SystemDateT: // 系统日期
@@ -807,32 +797,6 @@ func handleOldSystemDateT(confStr string) (newConf string, err error, errMsg str
 	return
 }
 
-// handleSystemCalculateDateT
-// @Description: 处理系统日期计算后的日期
-// @author: Roc
-// @datetime2023-10-27 09:31:22
-// @param num int
-// @param frequency string
-// @return date string
-// @return err error
-// @return errMsg string
-func handleSystemCalculateDateT(num int, frequency string) (date string, err error, errMsg string) {
-	if err != nil {
-		return
-	}
-	currDate := time.Now()
-	switch frequency {
-	case "", "日":
-		date = currDate.AddDate(0, 0, num).Format(utils.FormatDate)
-	default:
-		errMsg = "错误的日期频度：" + frequency
-		err = errors.New(errMsg)
-		return
-	}
-
-	return
-}
-
 // handleSystemAppointDateT
 // @Description: 处理系统日期相关的指定频率（所在周/旬/月/季/半年/年的最后/最早一天）
 // @author: Roc

services/data/future_good/chart_info.go

@@ -331,16 +331,6 @@ func GetChartEdbData(chartInfoId int, startDate, endDate string, baseEdbInfoMapp
 		}
 	}
 
-	//yDataList =make([]data_manage.YData,0)
-	//data_manage.YData{
-	//	Date:           "",
-	//	Color:          "",
-	//	Name:           "",
-	//	NameEn:         "",
-	//	Value:          nil,
-	//	NoDataEdbList:  nil,
-	//	XEdbInfoIdList: nil,
-	//}
 	futureGoodEdbInfoIndexMap := make(map[int]int)
 	for index, v := range futureGoodEdbInfoList {
 		futureGoodEdbInfoIndexMap[v.FutureGoodEdbInfoId] = index
@@ -408,8 +398,6 @@ func GetChartEdbData(chartInfoId int, startDate, endDate string, baseEdbInfoMapp
 		}
 	}
 
-	//xEdbIdValue = xEdbIdValue[0:maxIndex]
-
 	// 找出所有的N值，并进行正序排列
 	nList := make([]int, 0)
 	for _, n := range nMap {
@@ -548,8 +536,6 @@ func BarChartData(baseEdbInfoMapping *data_manage.ChartEdbInfoMapping, edbInfoMa
 			}
 			xEdbInfoIdList = append(xEdbInfoIdList, v.EdbInfoId)
 		}
-		//currMonth := findDateTime.Month() // 当前月份
-		//currYear := findDateTime.Year()   // 当前年份
 
 		// 用实际日期的月份作为基准，往前推12个月（2024-5-13 16:26:43修改）
 		currMonth := realDateTime.Month() // 当前月份
@@ -585,13 +571,7 @@ func BarChartData(baseEdbInfoMapping *data_manage.ChartEdbInfoMapping, edbInfoMa
 
 		for _, i := range indexList {
 			futureGoodMapping := futureGoodMappingList[i] // 当前的期货指标
-			//tmpRealDateTime, tmpFindDataValue, tmpIsFind, tmpErr := GetNeedDateData(findDateTime, edbDataListMap[futureGoodMapping.FutureGoodEdbInfoId], edbDataMap[futureGoodMapping.FutureGoodEdbInfoId])
-			//if tmpErr != nil {
-			//	err = tmpErr
-			//	return
-			//}
-			//tmpRealDateTime := findDateTime	// 按照配置找到的日期
-			tmpRealDateTime := realDateTime // 实际现货的日期
+			tmpRealDateTime := realDateTime               // 实际现货的日期
 			tmpFindDataValue, tmpIsFind := edbDataMap[futureGoodMapping.FutureGoodEdbInfoId][tmpRealDateTime.Format(utils.FormatDate)]
 			yDataMap[futureGoodMapping.FutureGoodEdbInfoId] = tmpFindDataValue
 
@@ -937,13 +917,6 @@ func getFutureGoodEdbInfoList(latestDateTime time.Time, tmpFutureGoodEdbInfoList
 		//海外的连续日期,目前
 		if v.FutureGoodEdbType == 2 {
 			if v.Month <= maxM {
-				//addMonth := int(earliestDateTime.Month()) + v.Month
-				//v.Year = earliestDateTime.Year() + addMonth/12
-				//realMonth := addMonth % 12
-				//if realMonth == 0 {
-				//	realMonth = 12
-				//}
-				//v.Month = realMonth
 				futureGoodEdbInfoList = append(futureGoodEdbInfoList, v)
 			}
 			continue

services/data/jiayue_index.go

@@ -11,7 +11,7 @@ import (
 	"strings"
 )
 
-// 嘉悦桥接服务接口
+// 桥接服务接口
 var (
 	BridgeApiJiaYueIndexUrl         = "/api/index_data/jiayue/index"          // 获取指标信息
 	BridgeApiJiaYueIndexDataUrl     = "/api/index_data/jiayue/index_data"     // 获取指标数据
@@ -43,38 +43,6 @@ func (brg *EdbBridgeJiaYue) GetIndex(req GetIndexFromBridgeReq) (item BridgeInde
 	return
 }
 
-// GetIndexAndData 获取指标和数据
-//func (brg *EdbBridgeJiaYue) GetIndexAndData(req GetIndexAndDataFromBridgeReq) (item BridgeIndexItem, err error) {
-//	var params data_manage.BridgeJiaYueIndexDataParams
-//	params.IndexCode = req.IndexCode
-//	params.SourceExtend = req.SourceExtend
-//	params.StartDate = req.StartDate
-//	params.EndDate = req.EndDate
-//	indexData, e := GetJiaYueIndexDataFromBridge(params)
-//	if e != nil {
-//		err = fmt.Errorf("GetJiaYueIndexDataFromBridge err: %s", e.Error())
-//		return
-//	}
-//	if indexData.Id <= 0 {
-//		return
-//	}
-//	item.Id = indexData.Id
-//	item.IndexCode = indexData.IndexCode
-//	item.IndexName = indexData.IndexName
-//	item.Unit = indexData.Unit
-//	item.Frequency = brg.TransFrequency(indexData.Frequency)
-//	var dataList []BridgeIndexDataItem
-//	for _, v := range indexData.IndexData {
-//		dataList = append(dataList, BridgeIndexDataItem{
-//			Val:        v.Val,
-//			DataTime:   v.DataTime,
-//			UpdateTime: v.UpdateTime,
-//		})
-//	}
-//	item.Data = dataList
-//	return
-//}
-
 // TransFrequency 嘉悦指标频度转换
 func (brg *EdbBridgeJiaYue) TransFrequency(origin string) string {
 	mapping := map[string]string{
@@ -162,71 +130,6 @@ func GetJiaYueIndexFromBridge(param data_manage.BridgeJiaYueIndexParams) (indexD
 	return
 }
 
-// GetJiaYueIndexDataFromBridge 从桥接服务获取指标数据
-//func GetJiaYueIndexDataFromBridge(param data_manage.BridgeJiaYueIndexDataParams) (indexData data_manage.BridgeJiaYueIndexAndData, err error) {
-//	defer func() {
-//		if err != nil {
-//			b, _ := json.Marshal(param)
-//			tips := fmt.Sprintf("桥接服务-获取嘉悦指标数据, err: %s, params: %s", err.Error(), string(b))
-//			go alarm_msg.SendAlarmMsg(tips, 3)
-//		}
-//	}()
-//
-//	url := fmt.Sprint(utils.EtaBridgeUrl, BridgeApiJiaYueIndexDataUrl)
-//	data, e := json.Marshal(param)
-//	if e != nil {
-//		err = fmt.Errorf("data json marshal err: %s", e.Error())
-//		return
-//	}
-//	body := ioutil.NopCloser(strings.NewReader(string(data)))
-//	client := &http.Client{}
-//	req, e := http.NewRequest("POST", url, body)
-//	if e != nil {
-//		err = fmt.Errorf("http create request err: %s", e.Error())
-//		return
-//	}
-//
-//	checkToken := utils.MD5(utils.EtaBridgeAppNameEn + utils.EtaBridgeMd5Key)
-//	contentType := "application/json;charset=utf-8"
-//	req.Header.Set("Content-Type", contentType)
-//	req.Header.Set("Authorization", checkToken)
-//	resp, e := client.Do(req)
-//	if e != nil {
-//		err = fmt.Errorf("http client do err: %s", e.Error())
-//		return
-//	}
-//	defer func() {
-//		_ = resp.Body.Close()
-//	}()
-//	b, e := ioutil.ReadAll(resp.Body)
-//	if e != nil {
-//		err = fmt.Errorf("resp body read err: %s", e.Error())
-//		return
-//	}
-//	if len(b) == 0 {
-//		err = fmt.Errorf("resp body is empty")
-//		return
-//	}
-//	// 生产环境解密
-//	if utils.RunMode == "release" {
-//		str := string(b)
-//		str = strings.Trim(str, `"`)
-//		b = utils.DesBase64Decrypt([]byte(str), utils.EtaBridgeDesKey)
-//	}
-//
-//	result := new(data_manage.BridgeJiaYueResultIndexData)
-//	if e = json.Unmarshal(b, &result); e != nil {
-//		err = fmt.Errorf("result unmarshal err: %s\nresult: %s", e.Error(), string(b))
-//		return
-//	}
-//	if result.Code != 200 {
-//		err = fmt.Errorf("result: %s", string(b))
-//		return
-//	}
-//	indexData = result.Data
-//	return
-//}
-
 // GetJiaYueFrequencyListFromBridge 获取指标频度列表
 func GetJiaYueFrequencyListFromBridge() (frequencies []string, err error) {
 	url := fmt.Sprint(utils.EtaBridgeUrl, BridgeApiJiaYueFrequencyListUrl)

services/data/manual.go

@@ -91,35 +91,6 @@ func GetManualSysUser(keyWord string) (list []*data_manage.ManualSysUser, err er
 	return
 }
 
-// GetManualEdbClassifyListByAdminId
-// @Description: 根据账户类型获取手工指标分类ID集合
-// @author: Roc
-// @datetime 2024-07-16 13:18:39
-// @param adminId int64
-// @return classifyIdList []int
-// @return err error
-func GetManualEdbClassifyListByAdminId(adminId int64) (classifyIdList []int, err error) {
-	var list []*models.EdbdataClassify
-	if adminId <= 0 {
-		list, err = models.GetAllChildManualEdbClassify()
-	} else {
-		userClassifyList, _ := models.GetManualUserClassify(int(adminId))
-		var userClassifyIdList []int
-		for _, v := range userClassifyList {
-			userClassifyIdList = append(userClassifyIdList, v.ClassifyId)
-		}
-		list, err = models.GetChildManualEdbClassifyByIdList(userClassifyIdList)
-	}
-	if err != nil {
-		return
-	}
-	for _, classify := range list {
-		classifyIdList = append(classifyIdList, classify.ClassifyId)
-	}
-
-	return
-}
-
 type ManualIndexSource2EdbReq struct {
 	EdbCode       string
 	EdbName       string
@@ -404,22 +375,6 @@ func ImportManualData(path string, sysUser *system.Admin) (successCount, failCou
 		}
 	}
 
-	//// TODO 成功数量超过20个指标，那就不导入了
-	//if len(targetMap) >= 150 {
-	//	failItem := new(models.EdbdataImportFail)
-	//	failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
-	//	failItem.ClassifyName = classifyName
-	//	failItem.CreateDate = createDate
-	//	failItem.SecName = secName
-	//	failItem.Close = closeVal
-	//	failItem.Remark = "导入指标数量过多"
-	//	failItem.Frequency = frequency
-	//	failItem.Unit = unit
-	//	failDataList = append(failDataList, failItem)
-	//	//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
-	//	continue
-	//}
-
 	addDataList := make([]*models.Edbdata, 0)
 
 	for _, v := range indexDataListMap {
@@ -839,11 +794,6 @@ func getDataByTemplate2(sheet *xlsx.Sheet, sysUserId int) (indexDataList []Impor
 	for i := 1; i <= 4; i++ {
 		row := sheet.Row(i)
 		cells := row.Cells
-		//if len(cells) < 1 {
-		//	errMsg = "模板异常2"
-		//	err = errors.New(errMsg)
-		//	return
-		//}
 
 		switch i {
 		case 1:
@@ -886,11 +836,6 @@ func getDataByTemplate2(sheet *xlsx.Sheet, sysUserId int) (indexDataList []Impor
 	for i := 5; i < maxRow; i++ {
 		row := sheet.Row(i)
 		cells := row.Cells
-		//if len(cells) < 1 {
-		//	errMsg = "模板异常2"
-		//	err = errors.New(errMsg)
-		//	return
-		//}
 		// 当前日期
 		var currDate string
 
@@ -902,18 +847,6 @@ func getDataByTemplate2(sheet *xlsx.Sheet, sysUserId int) (indexDataList []Impor
 			if k == 0 {
 				tmpCurrDate, tmpErr := getExcelDate(v.Value)
 				if tmpErr != nil {
-					// TODO 错误数据记录
-					//failItem := new(models.EdbdataImportFail)
-					//failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
-					//failItem.ClassifyName = classifyName
-					//failItem.CreateDate = createDate
-					//failItem.SecName = secName
-					//failItem.Close = closeVal
-					//failItem.Remark = "日期格式异常"
-					//failItem.Frequency = frequency
-					//failItem.Unit = unit
-					//failDataList = append(failDataList, failItem)
-					//go utils.SendEmail(utils.APPNAME+"失败提醒", "导入数据 获取分类:Err:"+err.Error(), utils.EmailSendToUsers)
 					dateErr = true
 				}
 
@@ -967,17 +900,6 @@ func getDataByTemplate2(sheet *xlsx.Sheet, sysUserId int) (indexDataList []Impor
 
 			closeValFloat, tmpErr := v.Float() //值
 			if tmpErr != nil {
-				// TODO 错误数据记录
-				//failItem := new(models.EdbdataImportFail)
-				//failItem.SysUserId = strconv.Itoa(sysUser.AdminId)
-				//failItem.ClassifyName = classifyName
-				//failItem.CreateDate = createDate
-				//failItem.SecName = secName
-				//failItem.Close = cells[3].Value
-				//failItem.Remark = "值类型异常"
-				//failItem.Frequency = frequency
-				//failItem.Unit = unit
-				//failDataList = append(failDataList, failItem)
 				indexDateValueMap[key][currDate] = ""
 				continue
 			}

services/data/mysteel_chemical.go

@@ -720,11 +720,6 @@ func GetMysteelChemicalOpButton(sysUser *system.Admin, belongUserId int) (button
 // CurlDelMysteelChemicalData 请求钢联服务器删除指标
 func CurlDelMysteelChemicalData(indexCode, updateWeek string) {
 	postUrl := utils.MySteelPostUrl + `/api/index/delete`
-	//type IndexAddReq struct {
-	//	IndexCode  string `json:"IndexCode" binding:"required"`    //指标编码
-	//	UpdateWeek string `json:"UpdateWeek"`                      //更新周期
-	//	RunMode    string `description:"运行环境:debug:测试(默认),release:生产" json:"UpdateWeek"` //更新周期
-	//}
 	paramsMap := make(map[string]interface{})
 
 	updateWeek = WeekMap[updateWeek]
@@ -764,11 +759,6 @@ var WeekMap = map[string]string{
 // CurlRefreshMysteelChemicalData 请求钢联服务器添加指标
 func CurlRefreshMysteelChemicalData(mergeFilePath string) {
 	postUrl := utils.MySteelPostUrl + `/api/index/refresh`
-	//type IndexAddReq struct {
-	//	IndexCode  string `json:"IndexCode" binding:"required"`    //指标编码
-	//	UpdateWeek string `json:"UpdateWeek"`                      //更新周期
-	//	RunMode    string `description:"运行环境:debug:测试(默认),release:生产" json:"UpdateWeek"` //更新周期
-	//}
 	paramsMap := make(map[string]interface{})
 	paramsMap["MergeFilePath"] = mergeFilePath
 	paramJson, err := json.Marshal(paramsMap)

services/data/predict_edb_info.go

@@ -4,419 +4,15 @@ import (
 	"encoding/json"
 	"errors"
 	"eta_gn/eta_api/models/data_manage"
-	"eta_gn/eta_api/models/data_manage/request"
 	"eta_gn/eta_api/models/system"
 	"eta_gn/eta_api/services/data/data_manage_permission"
 	"eta_gn/eta_api/utils"
 	"fmt"
 	"github.com/shopspring/decimal"
 	"strconv"
-	"strings"
 	"time"
 )
 
-// AddPredictEdbInfo 新增预测指标
-func AddPredictEdbInfo(sourceEdbInfoId, classifyId int, edbName string, ruleList []request.RuleConfig, sysUserId int, sysUserName, requestBody, requestUrl string) (edbInfo *data_manage.EdbInfo, err error, errMsg string) {
-	var sourceEdbInfo *data_manage.EdbInfo
-	// 来源指标信息校验
-	{
-		sourceEdbInfo, err = data_manage.GetEdbInfoById(sourceEdbInfoId)
-		if err != nil && !utils.IsErrNoRow(err) {
-			errMsg = "新增失败"
-			err = errors.New("获取来源指标失败，Err:" + err.Error())
-			return
-		}
-		if sourceEdbInfo == nil {
-			errMsg = "找不到该来源指标"
-			err = nil
-			return
-		}
-		//必须是普通的指标
-		if sourceEdbInfo.EdbInfoType != 0 {
-			errMsg = "来源指标异常，不是普通的指标"
-			return
-		}
-		if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, sourceEdbInfo.Frequency) {
-			errMsg = "预测指标只支持选择日度、周度、月度的指标"
-			return
-		}
-	}
-
-	var classifyInfo *data_manage.EdbClassify
-	// 来源分类信息校验
-	{
-		classifyInfo, err = data_manage.GetEdbClassifyById(classifyId)
-		if err != nil && !utils.IsErrNoRow(err) {
-			errMsg = "新增失败"
-			err = errors.New("获取预测指标分类失败，Err:" + err.Error())
-			return
-		}
-		if classifyInfo == nil {
-			errMsg = "找不到该预测指标分类"
-			err = nil
-			return
-		}
-		//必须是预测指标分类
-		if classifyInfo.ClassifyType != 1 {
-			errMsg = "预测指标分类异常，不是预测指标分类"
-			return
-		}
-	}
-
-	edbName = strings.Trim(edbName, " ")
-
-	edbCode := sourceEdbInfo.EdbCode + "_" + time.Now().Format(utils.FormatShortDateTimeUnSpace)
-
-	// 判断该来源指标是否已经被引用了
-	{
-		//predictEdbConf, tmpErr := data_manage.GetPredictEdbConfBySourceEdbInfoId(sourceEdbInfoId)
-		//if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-		//	errMsg = "新增失败"
-		//	err = tmpErr
-		//	return
-		//}
-
-		// 如果该来源指标已经被引用了，那么不允许再次使用
-		//if predictEdbConf != nil {
-		//	//获取预测指标详情
-		//	predictEdbInfo, tmpErr := data_manage.GetEdbInfoById(predictEdbConf.PredictEdbInfoId)
-		//	if tmpErr != nil {
-		//		errMsg = "新增失败"
-		//		err = tmpErr
-		//		return
-		//	}
-		//	//获取预测指标的分类
-		//	edbClassifyInfo, tmpErr := data_manage.GetEdbClassifyById(predictEdbInfo.ClassifyId)
-		//	if tmpErr != nil {
-		//		errMsg = "新增失败"
-		//		err = tmpErr
-		//		return
-		//	}
-		//	errMsg = "该指标已存在数据库，目录为：" + edbClassifyInfo.ClassifyName + "，请重新选择指标"
-		//	err = errors.New(errMsg)
-		//	return
-		//}
-	}
-
-	//判断指标名称是否存在
-	var condition string
-	var pars []interface{}
-	condition += " AND edb_info_type=? "
-	pars = append(pars, 1)
-
-	condition += " AND edb_name=? "
-	pars = append(pars, edbName)
-
-	count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
-	if err != nil {
-		errMsg = "判断指标名称是否存在失败"
-		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
-		return
-	}
-	if count > 0 {
-		errMsg = "指标名称已存在，请重新填写"
-		return
-	}
-
-	timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
-	edbInfo = &data_manage.EdbInfo{
-		//EdbInfoId:   0,
-		EdbInfoType:      1,
-		SourceName:       "预测指标",
-		Source:           utils.DATA_SOURCE_PREDICT,
-		EdbCode:          edbCode,
-		EdbName:          edbName,
-		EdbNameSource:    edbName,
-		Frequency:        sourceEdbInfo.Frequency,
-		Unit:             sourceEdbInfo.Unit,
-		StartDate:        sourceEdbInfo.StartDate,
-		ClassifyId:       classifyId,
-		SysUserId:        sysUserId,
-		SysUserRealName:  sysUserName,
-		UniqueCode:       utils.MD5(utils.DATA_PREFIX + "_" + timestamp),
-		CreateTime:       time.Now(),
-		ModifyTime:       time.Now(),
-		MinValue:         sourceEdbInfo.MinValue,
-		MaxValue:         sourceEdbInfo.MaxValue,
-		CalculateFormula: sourceEdbInfo.CalculateFormula,
-		EdbType:          1,
-		//Sort:             sourceEdbInfo.,
-		LatestDate:    sourceEdbInfo.LatestDate,
-		LatestValue:   sourceEdbInfo.LatestValue,
-		MoveType:      sourceEdbInfo.MoveType,
-		MoveFrequency: sourceEdbInfo.MoveFrequency,
-		NoUpdate:      sourceEdbInfo.NoUpdate,
-		ServerUrl:     "",
-	}
-
-	// 关联关系表
-	calculateMappingList := make([]*data_manage.EdbInfoCalculateMapping, 0)
-	fromEdbMap := make(map[int]int)
-
-	// 源指标关联关系表
-	calculateMappingItem := &data_manage.EdbInfoCalculateMapping{
-		//EdbInfoCalculateMappingId: 0,
-		//EdbInfoId:                 0,
-		Source:         edbInfo.Source,
-		SourceName:     edbInfo.SourceName,
-		EdbCode:        edbInfo.EdbCode,
-		FromEdbInfoId:  sourceEdbInfo.EdbInfoId,
-		FromEdbCode:    sourceEdbInfo.EdbCode,
-		FromEdbName:    sourceEdbInfo.EdbName,
-		FromSource:     sourceEdbInfo.Source,
-		FromSourceName: sourceEdbInfo.SourceName,
-		//FromTag:        "",
-		Sort:       1,
-		CreateTime: time.Now(),
-		ModifyTime: time.Now(),
-	}
-	fromEdbMap[sourceEdbInfoId] = sourceEdbInfoId
-	calculateMappingList = append(calculateMappingList, calculateMappingItem)
-
-	// 预测指标配置
-	predictEdbConfList := make([]*data_manage.PredictEdbConf, 0)
-	for _, v := range ruleList {
-		// 预测指标配置
-		ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
-		if tmpErr != nil {
-			errMsg = "规则配置的截止日期异常，请重新填写"
-			return
-		}
-		// 没有数据，自己瞎测试
-		//switch v.RuleType {
-		//case 3: //3：同比
-		//	v.Value = "0.1"
-		//case 4: //4：同差
-		//	v.Value = "10"
-		//case 5: //5：环比
-		//	v.Value = "0.1"
-		//case 6: //6：环差
-		//	v.Value = "0.1"
-		//case 7: //7：N期移动均值
-		//	v.Value = "5"
-		//case 8: //8：N期段线性外推值
-		//	v.Value = "5"
-		//}
-		switch v.RuleType {
-		case 8: //N期段线性外推值
-			valInt, tmpErr := strconv.Atoi(v.Value)
-			if tmpErr != nil {
-				errMsg = "N期段线性外推值的N值异常"
-				return
-			}
-			if valInt <= 1 {
-				errMsg = "N期段线性外推值的N值必须大于1"
-				return
-			}
-		case 9: //9：动态环差
-			for _, v := range v.EdbInfoIdArr {
-				fromEdbMap[v.EdbInfoId] = v.EdbInfoId
-			}
-		}
-
-		tmpPredictEdbConf := &data_manage.PredictEdbConf{
-			PredictEdbInfoId: 0,
-			SourceEdbInfoId:  sourceEdbInfoId,
-			RuleType:         v.RuleType,
-			//FixedValue:       v.Value,
-			Value:      v.Value,
-			EndDate:    ruleEndDate,
-			ModifyTime: time.Now(),
-			CreateTime: time.Now(),
-		}
-
-		if v.EndDate != `` {
-			endDateTime, tmpErr := utils.FormatDateStrToTime(v.EndDate)
-			if tmpErr != nil {
-				err = tmpErr
-				return
-			}
-			edbInfo.EndDate = endDateTime
-		}
-
-		predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf)
-	}
-	err = data_manage.AddPredictEdb(edbInfo, calculateMappingItem, predictEdbConfList)
-	if err != nil {
-		errMsg = "保存失败"
-		err = errors.New("保存失败，Err:" + err.Error())
-		return
-	}
-
-	//新增操作日志
-	{
-		edbLog := new(data_manage.EdbInfoLog)
-		edbLog.EdbInfoId = edbInfo.EdbInfoId
-		edbLog.SourceName = edbInfo.SourceName
-		edbLog.Source = edbInfo.Source
-		edbLog.EdbCode = edbInfo.EdbCode
-		edbLog.EdbName = edbInfo.EdbName
-		edbLog.ClassifyId = edbInfo.ClassifyId
-		edbLog.SysUserId = sysUserId
-		edbLog.SysUserRealName = sysUserName
-		edbLog.CreateTime = time.Now()
-		edbLog.Content = requestBody
-		edbLog.Status = "新增指标"
-		edbLog.Method = requestUrl
-		go data_manage.AddEdbInfoLog(edbLog)
-	}
-
-	//添加es
-	AddOrEditEdbInfoToEs(edbInfo.EdbInfoId)
-
-	return
-}
-
-// EditPredictEdbInfo 编辑预测指标
-func EditPredictEdbInfo(edbInfoId, classifyId int, edbName string, ruleList []request.RuleConfig, sysUserId int, sysUserName, requestBody, requestUrl string) (edbInfo *data_manage.EdbInfo, err error, errMsg string) {
-	// 指标信息校验
-	{
-		edbInfo, err = data_manage.GetEdbInfoById(edbInfoId)
-		if err != nil && !utils.IsErrNoRow(err) {
-			errMsg = "修改失败"
-			err = errors.New("获取预测指标失败，Err:" + err.Error())
-			return
-		}
-		if edbInfo == nil {
-			errMsg = "找不到该预测指标"
-			err = nil
-			return
-		}
-		//必须是普通的指标
-		if edbInfo.EdbInfoType != 1 {
-			errMsg = "指标异常，不是预测指标"
-			return
-		}
-	}
-
-	var predictEdbConf *data_manage.PredictEdbConf
-	// 指标配置信息校验
-	{
-		// 查找该预测指标配置
-		predictEdbConfList, tmpErr := data_manage.GetPredictEdbConfListById(edbInfo.EdbInfoId)
-		if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
-			errMsg = "修改失败"
-			err = errors.New("获取预测指标配置信息失败，Err:" + tmpErr.Error())
-			return
-		}
-		if len(predictEdbConfList) == 0 {
-			errMsg = "找不到该预测指标配置"
-			err = nil
-			return
-		}
-		predictEdbConf = predictEdbConfList[0]
-	}
-
-	//判断指标名称是否存在
-	var condition string
-	var pars []interface{}
-
-	condition += " AND edb_info_id<>? "
-	pars = append(pars, edbInfoId)
-
-	condition += " AND edb_info_type=? "
-	pars = append(pars, 1)
-
-	condition += " AND edb_name=? "
-	pars = append(pars, edbName)
-
-	count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
-	if err != nil {
-		errMsg = "判断指标名称是否存在失败"
-		err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
-		return
-	}
-
-	if count > 0 {
-		errMsg = "指标名称已存在，请重新填写"
-		return
-	}
-
-	edbInfo.EdbName = edbName
-	edbInfo.EdbNameSource = edbName
-	edbInfo.ClassifyId = classifyId
-	edbInfo.ModifyTime = time.Now()
-	updateEdbInfoCol := []string{"EdbName", "EdbNameSource", "ClassifyId", "EndDate", "ModifyTime"}
-
-	// 预测指标配置
-	predictEdbConfList := make([]*data_manage.PredictEdbConf, 0)
-	for _, v := range ruleList {
-		// 预测指标配置
-		ruleEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, v.EndDate, time.Local)
-		if tmpErr != nil {
-			errMsg = "规则配置的截止日期异常，请重新填写"
-			return
-		}
-		switch v.RuleType {
-		case 8: //N期段线性外推值
-			valInt, tmpErr := strconv.Atoi(v.Value)
-			if tmpErr != nil {
-				errMsg = "N期段线性外推值的N值异常"
-				return
-			}
-			if valInt <= 1 {
-				errMsg = "N期段线性外推值的N值必须大于1"
-				return
-			}
-		case 9: //9：动态环差
-
-		}
-
-		tmpPredictEdbConf := &data_manage.PredictEdbConf{
-			PredictEdbInfoId: edbInfoId,
-			SourceEdbInfoId:  predictEdbConf.SourceEdbInfoId,
-			RuleType:         v.RuleType,
-			//FixedValue:       v.Value,
-			Value:      v.Value,
-			EndDate:    ruleEndDate,
-			ModifyTime: time.Now(),
-			CreateTime: time.Now(),
-		}
-		predictEdbConfList = append(predictEdbConfList, tmpPredictEdbConf)
-
-		if v.EndDate != `` {
-			endDateTime, tmpErr2 := utils.FormatDateStrToTime(v.EndDate)
-			if tmpErr2 != nil {
-				err = tmpErr2
-				return
-			}
-			edbInfo.EndDate = endDateTime
-		}
-	}
-
-	err = data_manage.EditPredictEdb(edbInfo, predictEdbConfList, updateEdbInfoCol)
-	if err != nil {
-		errMsg = "保存失败"
-		err = errors.New("保存失败，Err:" + err.Error())
-		return
-	}
-
-	//新增操作日志
-	{
-		edbLog := new(data_manage.EdbInfoLog)
-		edbLog.EdbInfoId = edbInfo.EdbInfoId
-		edbLog.SourceName = edbInfo.SourceName
-		edbLog.Source = edbInfo.Source
-		edbLog.EdbCode = edbInfo.EdbCode
-		edbLog.EdbName = edbInfo.EdbName
-		edbLog.ClassifyId = edbInfo.ClassifyId
-		edbLog.SysUserId = sysUserId
-		edbLog.SysUserRealName = sysUserName
-		edbLog.CreateTime = time.Now()
-		edbLog.Content = requestBody
-		edbLog.Status = "编辑指标"
-		edbLog.Method = requestUrl
-		go data_manage.AddEdbInfoLog(edbLog)
-	}
-
-	//添加es
-	AddOrEditEdbInfoToEs(edbInfoId)
-
-	// 刷新关联指标
-	go EdbInfoRefreshAllFromBaseV2(edbInfo.EdbInfoId, true, false)
-	return
-}
-
 // RefreshPredictEdbInfo 刷新预测指标
 func RefreshPredictEdbInfo(edbInfoId int, refreshAll bool) (edbInfo *data_manage.EdbInfo, isAsync bool, err error, errMsg string) {
 	// 指标信息校验

services/data/range_analysis/chart_info.go

@@ -1611,296 +1611,6 @@ func CopyChartInfo(classifyId int, chartName string, oldChartInfo *data_manage.C
 	return
 }
 
-/*
-// CalculateCorrelation 计算区间计算-获取x轴和y轴
-func CalculateCorrelation(leadValue int, leadUnit, frequencyA, frequencyB string, dataListA, dataListB []*data_manage.EdbDataList) (xEdbIdValue []int, yDataList []data_manage.YData, err error) {
-	xData := make([]int, 0)
-	yData := make([]float64, 0)
-	if leadValue == 0 {
-		xData = append(xData, 0)
-	}
-	if leadValue > 0 {
-		leadMin := 0 - leadValue
-		xLen := 2*leadValue + 1
-		for i := 0; i < xLen; i++ {
-			n := leadMin + i
-			xData = append(xData, n)
-		}
-	}
-
-	// 计算窗口，不包含第一天
-	//startDateTime, _ := time.ParseInLocation(utils.FormatDate, startDate, time.Local)
-	//startDate = startDateTime.AddDate(0, 0, 1).Format(utils.FormatDate)
-
-	//// 2023-03-02 时间序列始终以指标B为基准, 始终是A进行平移
-	//baseEdbInfo := edbInfoMappingB
-	//changeEdbInfo := edbInfoMappingA
-	// 2023-03-17 时间序列始终以指标A为基准, 始终是B进行平移
-	//baseEdbInfo := edbInfoMappingA
-	//changeEdbInfo := edbInfoMappingB
-
-	// 获取时间基准指标在时间区间内的值
-	//aDataList := make([]*data_manage.EdbDataList, 0)
-	//switch baseEdbInfo.EdbInfoCategoryType {
-	//case 0:
-	//	aDataList, err = data_manage.GetEdbDataList(baseEdbInfo.Source, baseEdbInfo.SubSource, baseEdbInfo.EdbInfoId, startDate, endDate)
-	//case 1:
-	//	_, aDataList, _, _, err, _ = data.GetPredictDataListByPredictEdbInfoId(baseEdbInfo.EdbInfoId, startDate, endDate, false)
-	//default:
-	//	err = errors.New("指标base类型异常")
-	//	return
-	//}
-	//
-	//// 获取变频指标所有日期的值, 插值法完善数据
-	//bDataList := make([]*data_manage.EdbDataList, 0)
-	//switch changeEdbInfo.EdbInfoCategoryType {
-	//case 0:
-	//	bDataList, err = data_manage.GetEdbDataList(changeEdbInfo.Source, changeEdbInfo.SubSource, changeEdbInfo.EdbInfoId, "", "")
-	//case 1:
-	//	_, bDataList, _, _, err, _ = data.GetPredictDataListByPredictEdbInfoId(changeEdbInfo.EdbInfoId, "", "", false)
-	//default:
-	//	err = errors.New("指标change类型异常")
-	//	return
-	//}
-	//changeDataMap := make(map[string]float64)
-	//newChangeDataList, e := HandleDataByLinearRegression(bDataList, changeDataMap)
-	//if e != nil {
-	//	err = fmt.Errorf("获取变频指标插值法Map失败, Err: %s", e.Error())
-	//	return
-	//}
-
-	// 2023-03-17 时间序列始终以指标A为基准, 始终是B进行平移
-	baseDataList := make([]*data_manage.EdbDataList, 0)
-	baseDataMap := make(map[string]float64)
-	changeDataList := make([]*data_manage.EdbDataList, 0)
-	changeDataMap := make(map[string]float64)
-
-	// 先把低频指标升频为高频
-	{
-		frequencyIntMap := map[string]int{
-			"日度": 1,
-			"周度": 2,
-			"旬度": 3,
-			"月度": 4,
-			"季度": 5,
-			"年度": 6,
-		}
-
-		// 如果A指标是高频，那么就需要对B指标进行升频
-		if frequencyIntMap[frequencyA] < frequencyIntMap[frequencyB] {
-			tmpNewChangeDataList, e := HandleDataByLinearRegression(dataListB, changeDataMap)
-			if e != nil {
-				err = fmt.Errorf("获取变频指标插值法Map失败, Err: %s", e.Error())
-				return
-			}
-			changeDataList = tmpNewChangeDataList
-			baseDataList = dataListA
-			for _, v := range baseDataList {
-				baseDataMap[v.DataTime] = v.Value
-			}
-
-		} else if frequencyIntMap[frequencyA] > frequencyIntMap[frequencyB] {
-			// 如果B指标是高频，那么就需要对A指标进行升频
-			tmpNewChangeDataList, e := HandleDataByLinearRegression(dataListA, baseDataMap)
-			if e != nil {
-				err = fmt.Errorf("获取变频指标插值法Map失败, Err: %s", e.Error())
-				return
-			}
-			baseDataList = tmpNewChangeDataList
-
-			changeDataList = dataListB
-			for _, v := range changeDataList {
-				changeDataMap[v.DataTime] = v.Value
-			}
-		} else {
-			baseDataList = dataListA
-			for _, v := range baseDataList {
-				baseDataMap[v.DataTime] = v.Value
-			}
-			changeDataList = dataListB
-			for _, v := range changeDataList {
-				changeDataMap[v.DataTime] = v.Value
-			}
-		}
-
-	}
-
-	// 计算不领先也不滞后时的相关系数
-	baseCalculateData := make([]float64, 0)
-	baseDataTimeArr := make([]string, 0)
-	for i := range baseDataList {
-		baseDataTimeArr = append(baseDataTimeArr, baseDataList[i].DataTime)
-		baseCalculateData = append(baseCalculateData, baseDataList[i].Value)
-	}
-
-	//zeroBaseData := make([]float64, 0)
-	//zeroCalculateData := make([]float64, 0)
-	//for i := range baseDataTimeArr {
-	//	tmpBaseVal, ok1 := baseDataMap[baseDataTimeArr[i]]
-	//	tmpCalculateVal, ok2 := changeDataMap[baseDataTimeArr[i]]
-	//	if ok1 && ok2 {
-	//		zeroBaseData = append(zeroBaseData, tmpBaseVal)
-	//		zeroCalculateData = append(zeroCalculateData, tmpCalculateVal)
-	//	}
-	//}
-	//if len(zeroBaseData) != len(zeroCalculateData) {
-	//	err = fmt.Errorf("相关系数两组序列元素数不一致, %d-%d", len(baseCalculateData), len(zeroCalculateData))
-	//	return
-	//}
-	//zeroRatio := utils.CalculateCorrelationByIntArr(zeroBaseData, zeroCalculateData)
-	//if leadValue == 0 {
-	//	yData = append(yData, zeroRatio)
-	//}
-
-	// 计算领先/滞后N期
-	if leadValue > 0 {
-		// 平移变频指标领先/滞后的日期(单位天)
-		moveUnitDays := utils.FrequencyDaysMap[leadUnit]
-
-		for i := range xData {
-			//if xData[i] == 0 {
-			//	yData = append(yData, zeroRatio)
-			//	continue
-			//}
-			xCalculateData := make([]float64, 0)
-			yCalculateData := make([]float64, 0)
-
-			// 平移指定天数
-			mDays := int(moveUnitDays) * xData[i]
-			_, dMap := MoveDataDaysToNewDataList(changeDataList, mDays)
-
-			// 取出对应的基准日期的值
-			for i2 := range baseDataTimeArr {
-				tmpDate := baseDataTimeArr[i2]
-				if yVal, ok := dMap[tmpDate]; ok {
-					xCalculateData = append(xCalculateData, baseCalculateData[i2])
-					yCalculateData = append(yCalculateData, yVal)
-				}
-			}
-			if len(yCalculateData) <= 0 {
-				//err = fmt.Errorf("领先滞后相关系数两组序列元素数不一致, %d-%d", len(baseCalculateData), len(yCalculateData))
-				//return
-				// 领先滞后后，没有可以计算的数据了
-				continue
-			}
-
-			// 公式计算出领先/滞后频度对应点的区间计算系数
-			ratio := utils.CalculateCorrelationByIntArr(xCalculateData, yCalculateData)
-			yData = append(yData, ratio)
-		}
-	}
-
-	xEdbIdValue = xData
-	yDataList = make([]data_manage.YData, 0)
-	yDate := "0000-00-00"
-	yDataList = append(yDataList, data_manage.YData{
-		Date:  yDate,
-		Value: yData,
-	})
-	return
-}
-
-// GetFactorChartDataByChartId 获取多因子区间计算图表数据
-func GetFactorChartDataByChartId(chartInfoId int, extraConfig string) (xEdbIdValue []int, yDataList []data_manage.YData, err error) {
-	if chartInfoId <= 0 {
-		return
-	}
-	// 指标对应的图例
-	extra := new(data_manage.CorrelationChartInfoExtraConfig)
-	if extraConfig != "" {
-		if e := json.Unmarshal([]byte(extraConfig), extra); e != nil {
-			err = fmt.Errorf("解析图表额外配置失败, err: %v", e)
-			return
-		}
-	}
-	legends := make(map[string]*data_manage.CorrelationChartLegend)
-	if extra != nil {
-		for _, v := range extra.LegendConfig {
-			s := fmt.Sprintf("%d-%d", v.SeriesId, v.EdbInfoId)
-			legends[s] = v
-		}
-	}
-
-	// 获取图表引用到的系列指标
-	chartMappingOb := new(data_manage.FactorEdbSeriesChartMapping)
-	cond := fmt.Sprintf(" AND %s = ? AND %s = 1", chartMappingOb.Cols().ChartInfoId, chartMappingOb.Cols().EdbUsed)
-	pars := make([]interface{}, 0)
-	pars = append(pars, chartInfoId)
-	chartMappings, e := chartMappingOb.GetItemsByCondition(cond, pars, []string{}, "")
-	if e != nil {
-		err = fmt.Errorf("获取图表引用系列指标失败")
-		return
-	}
-
-	// 取出计算结果
-	yDataList = make([]data_manage.YData, 0)
-	yDate := "0000-00-00"
-	for k, m := range chartMappings {
-		var values []data_manage.FactorEdbSeriesCorrelationMatrixValues
-		if m.CalculateData != "" {
-			e = json.Unmarshal([]byte(m.CalculateData), &values)
-			if e != nil {
-				err = fmt.Errorf("系列指标计算数据有误, err: %v", e)
-				return
-			}
-		}
-		var y []float64
-		for _, v := range values {
-			if k == 0 {
-				xEdbIdValue = append(xEdbIdValue, v.XData)
-			}
-			y = append(y, v.YData)
-		}
-		var yData data_manage.YData
-		yData.Date = yDate
-		yData.Value = y
-		yData.SeriesEdb.SeriesId = m.FactorEdbSeriesId
-		yData.SeriesEdb.EdbInfoId = m.EdbInfoId
-
-		// 图例
-		s := fmt.Sprintf("%d-%d", m.FactorEdbSeriesId, m.EdbInfoId)
-		legend := legends[s]
-		if legend != nil {
-			yData.Name = legend.LegendName
-			yData.Color = legend.Color
-		}
-		yDataList = append(yDataList, yData)
-	}
-	return
-}
-
-// FormatChartEdbInfoMappings 补充指标信息
-func FormatChartEdbInfoMappings(chartInfoId int, mappings []*data_manage.ChartEdbInfoMapping) (edbList []*data_manage.ChartEdbInfoMapping, err error) {
-	edbList = make([]*data_manage.ChartEdbInfoMapping, 0)
-	if len(mappings) == 0 {
-		return
-	}
-
-	for _, v := range mappings {
-		if chartInfoId <= 0 {
-			v.IsAxis = 1
-			v.LeadValue = 0
-			v.LeadUnit = ""
-			v.ChartEdbMappingId = 0
-			v.ChartInfoId = 0
-			v.IsOrder = false
-			v.EdbInfoType = 1
-			v.ChartStyle = ""
-			v.ChartColor = ""
-			v.ChartWidth = 0
-		} else {
-			v.LeadUnitEn = data.GetLeadUnitEn(v.LeadUnit)
-			v.LeadUnitEn = data.GetLeadUnitEn(v.LeadUnit)
-		}
-		v.FrequencyEn = data.GetFrequencyEn(v.Frequency)
-		if v.Unit == `无` {
-			v.Unit = ``
-		}
-		edbList = append(edbList, v)
-	}
-	return
-}*/
-
 func GetEdbDateByMoveForward(startDate string, moveForward int, edbDataList []*data_manage.EdbDataList) (date string) {
 	// 根据日期进行排序
 	index := 0
@@ -2111,15 +1821,6 @@ func FactorEdbStepCalculateRange(seriesId int, edbArr []int, extraConf data_mana
 			utils.FileLog.Info(tips)
 			go alarm_msg.SendAlarmMsg(tips, 3)
 		}
-		/*if len(calculateResp.Fail) > 0 {
-			tips := "StepCalculate计算失败, ErrMsg: "
-			for _, f := range calculateResp.Fail {
-				tips += fmt.Sprintf("code: %s, err: %s\n", f.EdbCode, f.ErrMsg)
-			}
-			fmt.Println(tips)
-			utils.FileLog.Info(tips)
-			go alarm_msg.SendAlarmMsg(tips, 2)
-		}*/
 	}()
 
 	edbInfoMappingList, e := data_manage.GetChartEdbMappingListByEdbInfoIdList(edbArr)

services/data/trade_position_analysis.go

@@ -1,522 +1,2 @@
 package data
 
-import (
-	"eta_gn/eta_api/models/data_manage"
-	"eta_gn/eta_api/utils"
-	"fmt"
-	"sort"
-	"strconv"
-	"time"
-)
-
-func InitPositionTask() (err error) {
-	exchanges := []string{"zhengzhou", "dalian", "shanghai", "cffex", "ine"} //郑商所，大商所，上期所，中金所，上期能源
-	startDate := "2023-02-14"
-	endDate := time.Now().Format(utils.FormatDate)
-	for _, v := range exchanges {
-		endDateTmpStr := endDate
-		exchange := v
-		fmt.Println("InitPositionTask:	启动：" + exchange)
-		utils.FileLog.Info("InitPositionTask:	启动：" + exchange)
-		startDateTmpTime, _ := time.ParseInLocation(utils.FormatDate, startDate, time.Local)
-		startDateStr := startDateTmpTime.Format(utils.FormatDate)
-		for {
-			if startDateStr > endDate {
-				break
-			}
-			endDateTmpTime := startDateTmpTime.AddDate(0, 1, 0)
-			endDateTmpStr = endDateTmpTime.Format(utils.FormatDate)
-			if endDateTmpStr > endDate {
-				endDateTmpStr = endDate
-			}
-			fmt.Println("开始" + startDateStr + "结束" + endDateTmpStr)
-			utils.FileLog.Info(fmt.Sprintf("InitTradePosition:开始:%s; 结束:%s", startDateStr, endDateTmpStr))
-			//err :=data.DealYesterdayData(exchange, startDateStr)
-			tErr, errMsg := InitTradePosition(exchange, startDateStr, endDateTmpStr)
-			if tErr != nil {
-				err = tErr
-				fmt.Println("InitTradePosition: 操作失败：" + errMsg + tErr.Error())
-				utils.FileLog.Info(fmt.Sprintf("InitTradePosition: 操作失败：%s:%s", errMsg, tErr.Error()))
-				return
-			}
-			startDateTmpTime = endDateTmpTime.AddDate(0, 0, 1)
-			startDateStr = startDateTmpTime.Format(utils.FormatDate)
-		}
-		fmt.Println("InitTradePosition:" + exchange + "已完成")
-		utils.FileLog.Info("InitTradePosition:" + exchange + "已完成")
-	}
-	return
-}
-
-func InitTradePosition(exchange, startDate, endDate string) (err error, errMsg string) {
-	// 批量插入今日的初始值
-	count, err := data_manage.GetTradePositionTopCountByExchangeDataTime(exchange, startDate, endDate)
-	if err != nil {
-		errMsg = "查询原始数据失败，GetTradePositionTopCountByExchangeDataTime() Err: "
-		return
-	}
-	if count > 0 {
-		err = fmt.Errorf("数据已存在，无需处理")
-		return
-	}
-	err = data_manage.MultiInsertTradeBaseDataToTop(exchange, startDate, endDate)
-	if err != nil {
-		errMsg = "新增原始数据失败，MultiInsertTradeBaseDataToTop() Err: "
-		return
-	}
-	originList, err := data_manage.GetTradePositionTopByExchangeDataTime(exchange, startDate, endDate)
-	if err != nil {
-		errMsg = "查询原始数据失败， GetTradePositionTopByExchangeDataTime() Err: "
-		return
-	}
-	if len(originList) <= 0 {
-		err = fmt.Errorf("原始数据没有值")
-		return
-	}
-
-	now := time.Now()
-	dataTimeMap := make(map[string]*data_manage.TradePositionTop)
-	onlyEmptyMap := make(map[string]bool)
-	onlyEmptyNameMap := make(map[string]*data_manage.TradePositionTop)
-	topLastMap := make(map[string]int)
-	topLastRankMap := make(map[string]int)
-	list := make([]*data_manage.TradePositionTop, 0)
-	for _, v := range originList {
-		tmp0, tmpErr := dealTradeOriginData(dataTimeMap, onlyEmptyMap, onlyEmptyNameMap, v, topLastMap, topLastRankMap, startDate, now)
-		if tmpErr != nil {
-			err = tmpErr
-			errMsg = "处理原始数据失败 dealTradeOriginData() Err: "
-			return
-		}
-		if tmp0 != nil {
-			list = append(list, tmp0)
-		}
-		if len(list) >= 1000 {
-			err = data_manage.InsertMultiTradePositionTop(exchange, list)
-			if err != nil {
-				errMsg = "批量新增昨日数据失败，InsertMultiTradePositionTop() Err: "
-				return
-			}
-			list = make([]*data_manage.TradePositionTop, 0)
-		}
-	}
-	if len(list) > 0 {
-		err = data_manage.InsertMultiTradePositionTop(exchange, list)
-		if err != nil {
-			errMsg = "批量新增昨日数据失败，InsertMultiTradePositionTop() Err: "
-			return
-		}
-		list = make([]*data_manage.TradePositionTop, 0)
-	}
-	// 处理某个期货公司只有买单没有卖单，或者只有卖单没有买单的情况
-	for k, v := range onlyEmptyNameMap {
-		_, ok1 := onlyEmptyMap[k+"_1"]
-		_, ok2 := onlyEmptyMap[k+"_2"]
-		var dealType int
-		if ok1 && !ok2 {
-			dealType = 2 //只有买单没有卖单
-		} else if !ok1 && ok2 {
-			dealType = 1 //只有卖单没有买单的情况
-		} else {
-			continue
-		}
-		if dealType > 0 {
-			str := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DataTime + "_" + strconv.Itoa(dealType)
-			dealValue := 0
-			if lastVal, ok := topLastMap[str]; ok {
-				dealValue = int(float64(lastVal)*0.7 + 0.5)
-			}
-
-			tmp := &data_manage.TradePositionTop{
-				ClassifyName:  v.ClassifyName,
-				ClassifyType:  v.ClassifyType,
-				DealShortName: v.DealShortName,
-				DataTime:      v.DataTime,
-				DealValue:     dealValue,
-				CreateTime:    now,
-				ModifyTime:    now,
-				DealType:      dealType,
-				SourceType:    2,
-			}
-			list = append(list, tmp)
-			if len(list) >= 1000 {
-				err = data_manage.InsertMultiTradePositionTop(exchange, list)
-				if err != nil {
-					errMsg = "批量新增前日数据失败，InsertMultiTradePositionTop() Err: "
-					return
-				}
-				list = make([]*data_manage.TradePositionTop, 0)
-			}
-		}
-	}
-
-	if len(list) > 0 {
-		err = data_manage.InsertMultiTradePositionTop(exchange, list)
-		if err != nil {
-			errMsg = "批量新增前日数据失败，InsertMultiTradePositionTop() Err: "
-			return
-		}
-	}
-
-	//生成净多单，净空单榜单
-	err = createAnalysisCleanTop(exchange, startDate, endDate)
-	if err != nil {
-		errMsg = "创建净多单，净空单数据失败，createAnalysisCleanTop() Err: "
-		return
-	}
-	// 特殊处理起始日期前一天的数据
-	err = DealYesterdayData(exchange, startDate)
-	if err != nil {
-		errMsg = "处理昨日数据失败，DealYesterdayData() Err: "
-		return
-	}
-	return
-}
-
-func dealTradeOriginData(dataTimeMap map[string]*data_manage.TradePositionTop, onlyEmptyMap map[string]bool, onlyEmptyNameMap map[string]*data_manage.TradePositionTop, currentItem *data_manage.TradePositionTop, topLastMap map[string]int, topLastRankMap map[string]int, startDate string, now time.Time) (tmp0 *data_manage.TradePositionTop, err error) {
-	classifyName := currentItem.ClassifyName
-	classifyType := currentItem.ClassifyType
-	dealShortName := currentItem.DealShortName
-	dealValue := currentItem.DealValue
-	dealChange := currentItem.DealChange
-	dataTime := currentItem.DataTime
-	dealType := currentItem.DealType
-	dealTypeStr := strconv.Itoa(dealType)
-	dataTimeMap[classifyName+"_"+classifyType+"_"+dealTypeStr+"_"+dealShortName+"_"+dataTime] = currentItem
-	onlyEmptyMap[classifyName+"_"+classifyType+"_"+dataTime+"_"+dealShortName+"_"+dealTypeStr] = true
-	onlyEmptyNameMap[classifyName+"_"+classifyType+"_"+dataTime+"_"+dealShortName] = currentItem
-	if currentItem.Rank > topLastRankMap[classifyName+"_"+classifyType+"_"+dataTime+"_"+dealTypeStr] {
-		topLastMap[classifyName+"_"+classifyType+"_"+dataTime+"_"+dealTypeStr] = dealValue
-		topLastRankMap[classifyName+"_"+classifyType+"_"+dataTime+"_"+dealTypeStr] = currentItem.Rank
-	}
-	if dataTime > startDate {
-		tmpTimeStr, tErr := getYesterdayDate(dataTime)
-		if tErr != nil {
-			err = tErr
-			return
-		}
-		if tmpTimeStr < startDate {
-			return
-		}
-		// 判断T-1日是否有值, 如果T-1日为空，则根据T日的值计算出T-1的值
-		if _, ok := dataTimeMap[classifyName+"_"+classifyType+"_"+dealTypeStr+"_"+dealShortName+"_"+tmpTimeStr]; !ok {
-			yesterdayVal := dealValue - dealChange
-			yesterdayChange := 0
-			beforeYesterday, _ := getYesterdayDate(tmpTimeStr)
-			beforeYesterdayItem, ok1 := dataTimeMap[classifyName+"_"+classifyType+"_"+dealTypeStr+"_"+dealShortName+"_"+beforeYesterday]
-			if ok1 {
-				yesterdayChange = yesterdayVal - beforeYesterdayItem.DealValue
-			}
-			tmp0 = &data_manage.TradePositionTop{
-				ClassifyName:  classifyName,
-				ClassifyType:  classifyType,
-				DealShortName: dealShortName,
-				DealValue:     yesterdayVal,
-				DealChange:    yesterdayChange,
-				DataTime:      tmpTimeStr,
-				CreateTime:    now,
-				ModifyTime:    now,
-				DealType:      dealType,
-				SourceType:    1,
-			}
-			dataTimeMap[classifyName+"_"+classifyType+"_"+dealTypeStr+"_"+dealShortName+"_"+tmpTimeStr] = tmp0
-			onlyEmptyMap[classifyName+"_"+classifyType+"_"+tmpTimeStr+"_"+dealShortName+"_"+dealTypeStr] = true
-			onlyEmptyNameMap[classifyName+"_"+classifyType+"_"+tmpTimeStr+"_"+dealShortName] = tmp0
-		}
-	}
-	return
-}
-
-// 更新昨日数据
-func DealYesterdayData(exchange, startDate string) (err error) {
-	// 查询最早的日期
-	firstItem, err := data_manage.GetFirstBaseFromTradeIndexByDate(exchange)
-	if err != nil {
-		return
-	}
-	if startDate == firstItem.DataTime { //如果当前是起始日，则无需统计修改前一天的数据
-		return
-	}
-
-	yesterdayStr, err := getYesterdayDate(startDate)
-	if err != nil {
-		return
-	}
-	//查找前日的值，并更新对应的更改
-	beforeYesterdayStr, err := getYesterdayDate(yesterdayStr)
-	if err != nil {
-		return
-	}
-	// 先查出T日最原始的数据
-	originList, err := data_manage.GetTradePositionTopByExchangeDataTime(exchange, startDate, startDate)
-	if err != nil {
-		return
-	}
-	originBuyMap := make(map[string]*data_manage.TradePositionTop)
-	originSoldMap := make(map[string]*data_manage.TradePositionTop)
-	for _, v := range originList {
-		if v.SourceType != 0 {
-			continue
-		}
-		str := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DealShortName
-		if v.DealType == 1 {
-			originBuyMap[str] = v
-		} else if v.DealType == 2 {
-			originSoldMap[str] = v
-		}
-	}
-
-	// 然后查询T-1中数据来源类型是2的数据
-	changeList, err := data_manage.GetTradePositionTopByExchangeSourceType(exchange, yesterdayStr, 2)
-	if err != nil {
-		return
-	}
-	if len(changeList) <= 0 {
-		//err = fmt.Errorf("前天的数据无需修改")
-		return
-	}
-	// 查询出前日的成交量
-	beforeYesterdayList, err := data_manage.GetTradePositionTopByExchangeDataTime(exchange, beforeYesterdayStr, beforeYesterdayStr)
-	if err != nil {
-		return
-	}
-	beforeYesterdayMap1 := make(map[string]int)
-	beforeYesterdayMap2 := make(map[string]int)
-	if len(beforeYesterdayList) > 0 {
-		for _, v := range beforeYesterdayList {
-			if v.SourceType == 2 {
-				continue
-			}
-			str := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DealShortName
-			if v.DealType == 1 {
-				beforeYesterdayMap1[str] = v.DealValue
-			} else if v.DealType == 2 {
-				beforeYesterdayMap2[str] = v.DealValue
-			}
-		}
-	}
-	// 根据原始数据中的值推算出最新的值
-	now := time.Now()
-	// 批量更新到分析表中，
-	var updateAnalysisData []data_manage.UpdateDealValueChange
-	for _, v := range changeList {
-		str := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DealShortName
-		dealValue := 0
-		dealChange := 0
-		if v.DealType == 1 {
-			if n, ok := originBuyMap[str]; ok {
-				dealValue = n.DealValue - n.DealChange
-				if beforeVal, ok1 := beforeYesterdayMap1[str]; ok1 {
-					dealChange = dealValue - beforeVal
-				}
-				tmp := data_manage.UpdateDealValueChange{
-					Id:         v.Id,
-					DealValue:  dealValue,
-					DealChange: dealChange,
-					SourceType: 1,
-					ModifyTime: now,
-				}
-				updateAnalysisData = append(updateAnalysisData, tmp)
-			}
-		} else if v.DealType == 2 {
-			if n, ok := originSoldMap[str]; ok {
-				dealValue = n.DealValue - n.DealChange
-				if beforeVal, ok1 := beforeYesterdayMap2[str]; ok1 {
-					dealChange = dealValue - beforeVal
-				}
-				tmp := data_manage.UpdateDealValueChange{
-					Id:         v.Id,
-					DealValue:  dealValue,
-					DealChange: dealChange,
-					SourceType: 1,
-					ModifyTime: now,
-				}
-				updateAnalysisData = append(updateAnalysisData, tmp)
-			}
-		}
-	}
-	if len(updateAnalysisData) > 0 {
-		err = data_manage.MultiUpdatePositionTop(exchange, updateAnalysisData)
-		if err != nil {
-			return
-		}
-		//删除T-1日净多单和净空单的榜单
-		err = data_manage.DeletePositionTopByDataTime(exchange, yesterdayStr, 3)
-		if err != nil {
-			return
-		}
-
-		err = data_manage.DeletePositionTopByDataTime(exchange, yesterdayStr, 4)
-		if err != nil {
-			return
-		}
-
-		//重新生成净多单和净空单的榜单
-		err = createAnalysisCleanTop(exchange, yesterdayStr, yesterdayStr)
-		if err != nil {
-			return
-		}
-	}
-
-	return
-}
-
-// createAnalysisCleanTop 生成净多单，净空单榜单
-func createAnalysisCleanTop(exchange, startDate, endDate string) (err error) {
-	topList := make([]*data_manage.TradePositionTop, 0)
-	now := time.Now()
-	var subDataList data_manage.TradePositionSubList
-
-	subChangeMap1 := make(map[string]int) //净多单map
-	subChangeMap2 := make(map[string]int) //净空单map
-	//查询所有差值数据，
-	yesterday, err := getYesterdayDate(startDate)
-	if err != nil {
-		return
-	}
-	yesterdayTopList1, tErr := data_manage.GetTradePositionTopByExchangeDataTimeType(exchange, yesterday, 3)
-	if tErr != nil {
-		err = tErr
-		return
-	}
-	if len(yesterdayTopList1) > 0 {
-		for _, v := range yesterdayTopList1 {
-			nameStr := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DataTime + "_" + v.DealShortName
-			subChangeMap1[nameStr] = v.DealValue
-		}
-	}
-
-	yesterdayTopList2, tErr := data_manage.GetTradePositionTopByExchangeDataTimeType(exchange, yesterday, 4)
-	if tErr != nil {
-		err = tErr
-		return
-	}
-	if len(yesterdayTopList2) > 0 {
-		for _, v := range yesterdayTopList2 {
-			nameStr := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DataTime + "_" + v.DealShortName
-			subChangeMap2[nameStr] = v.DealValue
-		}
-	}
-
-	originDataList, err := data_manage.GetTradePositionTopByExchangeDataTime(exchange, startDate, endDate)
-	if err != nil {
-		return
-	}
-	buyDataMap := make(map[string]int)
-	for _, v := range originDataList {
-		str := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DataTime + "_" + v.DealShortName
-		if v.DealType == 1 {
-			buyDataMap[str] = v.DealValue
-		} else if v.DealType == 2 {
-			subValue := 0
-			dealType := 0
-			if buy, ok := buyDataMap[str]; ok {
-				subValue = buy - v.DealValue
-				if subValue >= 0 {
-					dealType = 3
-				} else {
-					subValue = -subValue
-					dealType = 4
-				}
-			}
-			tmp := &data_manage.TradePositionSub{
-				ClassifyName:  v.ClassifyName,
-				ClassifyType:  v.ClassifyType,
-				DataTime:      v.DataTime,
-				DealShortName: v.DealShortName,
-				SubValue:      subValue,
-				DealType:      dealType,
-			}
-			subDataList = append(subDataList, tmp)
-		}
-	}
-	if len(subDataList) > 0 {
-		sort.Sort(subDataList)
-	}
-	var dealType int
-	rankMap := make(map[string]int)
-	for _, v := range subDataList {
-		subValue := v.SubValue
-		nameStr := v.ClassifyName + "_" + v.ClassifyType + "_" + v.DataTime + "_" + v.DealShortName
-		if v.DealType == 3 {
-			subChangeMap1[nameStr] = subValue
-			dealType = 3
-			if _, ok := rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_3"]; !ok {
-				rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_3"] = 1
-			} else {
-				rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_3"]++
-			}
-		} else if v.DealType == 4 {
-			subChangeMap2[nameStr] = subValue
-			dealType = 4
-			if _, ok := rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_4"]; !ok {
-				rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_4"] = 1
-			} else {
-				rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_4"]++
-			}
-		}
-		//和T-1日比较差值
-		var tmpTimeStr string
-		tmpTimeStr, err = getYesterdayDate(v.DataTime)
-		if err != nil {
-			return
-		}
-		yesterdayStr := v.ClassifyName + "_" + v.ClassifyType + "_" + tmpTimeStr + "_" + v.DealShortName
-		dealChange := 0
-		if dealType == 3 {
-			if c, ok := subChangeMap1[yesterdayStr]; ok {
-				dealChange = subValue - c
-			}
-		} else if dealType == 4 {
-			if c, ok := subChangeMap2[yesterdayStr]; ok {
-				dealChange = subValue - c
-			}
-		}
-		tmp := &data_manage.TradePositionTop{
-			ClassifyName:  v.ClassifyName,
-			ClassifyType:  v.ClassifyType,
-			DataTime:      v.DataTime,
-			CreateTime:    now,
-			ModifyTime:    now,
-			DealShortName: v.DealShortName,
-			DealValue:     subValue,
-			DealChange:    dealChange,
-			DealType:      dealType,
-			Rank:          rankMap[v.ClassifyName+"_"+v.ClassifyType+"_"+v.DataTime+"_"+strconv.Itoa(dealType)],
-		}
-		topList = append(topList, tmp)
-		if len(topList) >= 1000 {
-			err = data_manage.InsertMultiTradePositionTop(exchange, topList)
-			if err != nil {
-				return
-			}
-			topList = make([]*data_manage.TradePositionTop, 0)
-		}
-	}
-
-	if len(topList) >= 0 {
-		err = data_manage.InsertMultiTradePositionTop(exchange, topList)
-		if err != nil {
-			return
-		}
-	}
-	return
-}
-
-func getYesterdayDate(today string) (yesterday string, err error) {
-	i := 1
-	tmpTime, err := time.ParseInLocation(utils.FormatDate, today, time.Local)
-	if err != nil {
-		return
-	}
-	tmpTimeDate := tmpTime.AddDate(0, 0, -i)
-	weekStr := tmpTimeDate.Weekday().String()
-	if weekStr == "Sunday" {
-		i += 2
-	} else if weekStr == "Saturday" {
-		i += 1
-	}
-	tmpTimeDate = tmpTime.AddDate(0, 0, -i)
-	yesterday = tmpTimeDate.Format(utils.FormatDate)
-	return
-}

services/day_new.go

@@ -1,12 +1,7 @@
 package services
 
 import (
-	"encoding/json"
-	"errors"
 	"eta_gn/eta_api/utils"
-	"fmt"
-	"github.com/rdlucklib/rdluck_tools/http"
-	"time"
 )
 
 var (
@@ -19,48 +14,3 @@ type DayNewResponse struct {
 	Msg    string `json:"msg"`
 	ErrMsg string `json:"err_msg"`
 }
-
-func DayNewWeworkMsgRefresh() (err error) {
-	cacheKey := utils.CACHE_KEY_DAYNEW_REFRESH
-	//设置redis 防止频繁操作
-	if !utils.Rc.SetNX(cacheKey, 1, 1*time.Minute) {
-		err = errors.New(fmt.Sprintf("系统处理中，请1分钟之后再试"))
-		return
-	}
-	ret, err := http.Get(DayNewWeworkMsgRefreshUrl)
-	if err != nil {
-		return
-	}
-	var resp DayNewResponse
-	err = json.Unmarshal(ret, &resp)
-	if err != nil {
-		return
-	}
-	if resp.Code != 200 {
-		err = errors.New(resp.Msg)
-		return
-	}
-	return
-}
-func DayNewTranslateContent() (err error) {
-	cacheKey := utils.CACHE_KEY_DAYNEW_TRANSLATE
-	//设置redis 防止频繁操作，控制每分钟执行1次
-	if !utils.Rc.SetNX(cacheKey, 1, 1*time.Minute) {
-		err = errors.New(fmt.Sprintf("系统处理中，请1分钟之后再试"))
-		return
-	}
-	ret, err := http.Get(DayNewTranslateContentUrl)
-	if err != nil {
-		return
-	}
-	var resp DayNewResponse
-	err = json.Unmarshal(ret, &resp)
-	if err != nil {
-		return
-	}
-	if resp.Code != 200 {
-		err = errors.New(resp.Msg)
-		return
-	}
-	return
-}

services/edb_info_replace.go

@@ -403,9 +403,6 @@ func ReplaceEdbInRelation(oldEdbInfo, newEdbInfo *data_manage.EdbInfo) {
 // 完成直接引用中的指标替换工程
 func replaceEdbInRelation(oldEdbInfo, newEdbInfo *data_manage.EdbInfo, list []*data_manage.EdbInfoRelation, childEdbMappingIds []int, calculateEdbMappingListMap map[int]*data_manage.EdbInfoCalculateMapping) (replaceTotal int, logMsg string, err error) {
 	replaceEdbIds := make([]int, 0)
-	//calculateEdbMappingListMap := make(map[int]*data_manage.EdbInfoCalculateMapping)
-	//calculateEdbMappingIdsMap := make(map[int][]int)
-	//childEdbMappingIds := make([]int, 0)
 	indexCodeList := make([]string, 0)
 	addList := make([]*data_manage.EdbInfoRelation, 0)
 	refreshIds := make([]int, 0)

services/elastic.go

@@ -65,17 +65,6 @@ func EsDeleteData(indexName, docId string) (err error) {
 	return
 }
 
-func MappingModify(indexName, mappingJson string) {
-	client, err := NewClient()
-	if err != nil {
-		return
-	}
-	result, err := client.PutMapping().Index(indexName).BodyString(mappingJson).Do(context.Background())
-	fmt.Println(err)
-	fmt.Println(result)
-	return
-}
-
 // EsAddOrEditReport 新增编辑es报告
 func EsAddOrEditReport(indexName, docId string, item *models.ElasticReportDetail) (err error) {
 	defer func() {

services/elasticsearch.go

@@ -10,14 +10,3 @@ type tracelog struct{}
 func (tracelog) Printf(format string, v ...interface{}) {
 	fmt.Printf(format, v...)
 }
-
-func RemoveDuplicatesAndEmpty(a []string) (ret []string) {
-	a_len := len(a)
-	for i := 0; i < a_len; i++ {
-		if (i > 0 && a[i-1] == a[i]) || len(a[i]) == 0 {
-			continue
-		}
-		ret = append(ret, a[i])
-	}
-	return
-}

services/email.go

@@ -3,108 +3,11 @@ package services
 import (
 	"crypto/tls"
 	"eta_gn/eta_api/models"
-	"eta_gn/eta_api/utils"
 	"fmt"
 	"gopkg.in/gomail.v2"
 	"strconv"
-	"strings"
 )
 
-func SendEmailToCompany() {
-	// 获取收件人列表
-	emailCond := " AND enabled = 1 AND status in (1,2) "
-	//emailCond := ""
-	emailPars := make([]interface{}, 0)
-	emails, e := models.GetEnglishReportEmailList(emailCond, emailPars, "")
-	if e != nil {
-		fmt.Println("获取收件人列表失败, Err: " + e.Error())
-		return
-	}
-	if len(emails) == 0 {
-		fmt.Println("收件人列表为空")
-		return
-	}
-
-	// TODO:这是HTML模板内容
-	template := `<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Document</title>
-  </head>
-  <body>
-    <div>
-      <p>Hello,</p>
-      <p></p>
-      <p> We are pleased to invite you to the launch of our <span style="font-weight: 700;">Mon. Date with HI</span> , a weekly event where we share timely updates and expert analysis on Global Macro, Base Metal, Ferrous Metal, and Energy markets.</p>
-      <h3 style="font-weight: 700;">Event Details:</h3>
-      <ul>
-        <li>Date: August 26th</li>
-        <li>Time: 5:00 PM (Shanghai/Singapore) | 10:00 AM (London)</li>
-        <li>Platform: Zoom (the same link will be used for all future sessions)</li>
-      </ul>
-      <h3 style="font-weight: 700;">Join Zoom Meeting:</h3>
-      <a href="https://us06web.zoom.us/j/84723517075?pwd=3GHNOCHq6sAgBGXsA7qtX9r1PuA1uK.1" target="_blank">https://us06web.zoom.us/j/84723517075?pwd=3GHNOCHq6sAgBGXsA7qtX9r1PuA1uK.1</a>
-      <p>
-        <span style="font-weight: 700;">Meeting ID:</span>
-        <span>847 2351 7075</span>
-      </p>
-      <p>
-        <span style="font-weight: 700;">Passcode:</span>
-        <span>564439</span>
-      </p>
-      <p style="font-weight: 700;">Theme for Today’s Session: Diverging Expectations between Market and Policymakers</p>
-      <p>Our analysts will discuss the impact of the current macro environment on commodity markets, exploring both short-term challenges and longer-term outlooks.<br>This series will be a recurring event every Monday at the same time. </p>
-      <h3 style="font-weight: 700;">Please note:</h3>
-      <ul>
-        <li>This event will be conducted in listen-only mode. However, participants are encouraged to ask questions via the chat function during the Q&A segments.</li>
-        <li>For privacy concerns, you may change your display name upon joining the event.</li>
-      </ul>
-      <p></p>
-      <p>We look forward to your participation.</p>
-      <p></p>
-      <p>Best regards,<br>Horizon Insights</p>
-      <img style="max-width: 375px;width: 100%;" src="https://hzstatic.hzinsights.com/static/images/202408/20240826/z0qJ4cpM5mIaHrHv0BaMsNXYkLKa.jpg" alt="">
-    </div>
-  </body>
-</html>`
-
-	// 推送信息
-	sendData := make([]*EnglishReportSendEmailRequest, 0)
-	for i := range emails {
-		r := new(EnglishReportSendEmailRequest)
-		r.EmailId = emails[i].Id
-		r.Email = strings.Replace(emails[i].Email, " ", "", -1)
-		r.Subject = "Invitation to Weekly Call with Horizon Insights Analysts: Mon. Date with HI" // TODO:这是主题
-		r.FromAlias = "Horizon FICC"                                                              // TODO:这是推送人(中文)
-
-		r.HtmlBody = template
-		sendData = append(sendData, r)
-	}
-	if len(sendData) == 0 {
-		fmt.Println("无邮件可推送")
-		return
-	}
-
-	// 请求阿里云接口批量推送
-	aliEmail := new(AliyunEmail)
-	resultList, e := aliEmail.BatchSendEmail(sendData)
-	if e != nil {
-		fmt.Println("批量推送失败, Err: " + e.Error())
-		return
-	}
-	for _, r := range resultList {
-		utils.FileLog.Info("email: %s, ok: %v, res: %s", r.Email, r.Ok, r.ResultData)
-		if r.Ok {
-			fmt.Println("发送成功")
-		} else {
-			fmt.Println("发送失败:" + r.ResultData)
-		}
-	}
-}
-
 type SendEmailReq struct {
 	Title   string   `description:"标题"`
 	Content string   `description:"内容"`