add: 移动图表分类、图表刷新

controller/chart/chart_info.go

@@ -332,41 +332,44 @@ func GetChartInfoDetail(c *gin.Context)  {
 
 // RefreshChartInfo 刷新图表信息
 func RefreshChartInfo(c *gin.Context)  {
-	/*// 参数校验
-	reqChartInfoId := c.DefaultQuery("ChartInfoId", "")
-	if reqChartInfoId == "" {
-		response.Fail("参数有误:图表ID", c)
-		return
-	}
-	chartInfoId, _ := strconv.Atoi(reqChartInfoId)
-
-	// 刷新频率限制
-	userInfo := user.GetInfoByClaims(c)
-	cacheKey := utils.HZ_CHART_LIB_DETAIL + "YB_REFRESH_LIMIT_" + reqChartInfoId + "_" + strconv.Itoa(int(userInfo.UserID))
-	countUserRefresh, _ := global.Redis.Get(context.TODO(), cacheKey).Int()
-	if countUserRefresh > 2 {
-		response.Ok("刷新成功", c)
-		return
-	}
-	countUserRefresh += 1
-
-	_ = global.Redis.SetEX(context.TODO(), cacheKey, 1, 1 *  time.Hour)
-	//cacheKey := utils.HZ_CHART_LIB_DETAIL + chartItem.UniqueCode
-	_ = global.Redis.Del(context.TODO(), cacheKey)
-
-	chartInfo, err := chartInfoModel.GetChartInfoById(chartInfoId)
-	if err != nil {
-		if err == utils.ErrNoRow {
-			response.Fail("图表已被删除，无需刷新", c)
-			return
-		}
-		fmt.Println("获取图表信息失败, Err:" + err.Error())
-		response.Fail("刷新失败", c)
-		return
-	}*/
-
-	// 刷新图表
-
+	//// 参数校验
+	//reqChartInfoId := c.DefaultQuery("ChartInfoId", "")
+	//if reqChartInfoId == "" {
+	//	response.Fail("参数有误:图表ID", c)
+	//	return
+	//}
+	//chartInfoId, _ := strconv.Atoi(reqChartInfoId)
+	//
+	//// 刷新频率限制
+	////userInfo := user.GetInfoByClaims(c)
+	////cacheKey := utils.HZ_CHART_LIB_DETAIL + "YB_REFRESH_LIMIT_" + reqChartInfoId + "_" + strconv.Itoa(int(userInfo.UserID))
+	////countUserRefresh, _ := global.Redis.Get(context.TODO(), cacheKey).Int()
+	////if countUserRefresh > 2 {
+	////	response.Ok("刷新成功", c)
+	////	return
+	////}
+	////countUserRefresh += 1
+	////_ = global.Redis.SetEX(context.TODO(), cacheKey, 1, 1 *  time.Hour)
+	//
+	//// 图表信息校验
+	//chartInfo, err := chartInfoModel.GetChartInfoById(chartInfoId)
+	//if err != nil {
+	//	if err == utils.ErrNoRow {
+	//		response.Fail("图表已被删除，无需刷新", c)
+	//		return
+	//	}
+	//	response.Fail("刷新失败", c)
+	//	return
+	//}
+	//
+	//// 刷新图表
+	//err = chart.RefreshChartInfo(chartInfo.ChartInfoId)
+	//if err != nil {
+	//	response.Fail("刷新图表关联指标信息失败", c)
+	//	return
+	//}
+	//
+	//response.OkData("操作成功", "", c)
 }
 
 // EditChartInfo 编辑图表信息

controller/chart/my_chart.go

@@ -237,9 +237,6 @@ func MoveMyChart(c *gin.Context) {
 			return
 		}
 	}
-	/*else {
-		utils.FileLog.Info("MyChartMove Sort=0:" + requestBodyStr)
-	}*/
 
 	// 新增操作日志
 	{
@@ -258,5 +255,137 @@ func MoveMyChart(c *gin.Context) {
 		go edbLog.Create()
 	}
 
+	response.Ok("操作成功", c)
+}
+
+// MoveMyChart 移动我的图表分类
+// @Tags 图库模块
+// @Summary  移动我的图表分类
+// @Description 移动我的图表分类
+// @Security ApiKeyAuth
+// @Param Authorization	header string true "Bearer 31a165baebe6dec616b1f8f3207b4273"
+// @Accept  json
+// @Product json
+// @Param data body myChartModel.MoveMyChartClassifyReq true "请求参数"
+// @Success 200 {string} string "操作成功"
+// @failure 400 {string} string "操作失败"
+// @Router /my_chart/moveMyChartClassify [post]
+func MoveMyChartClassify(c *gin.Context) {
+	// 参数校验
+	var req myChartModel.MoveMyChartClassifyReq
+	if c.ShouldBind(&req) != nil {
+		response.Fail("参数异常", c)
+		return
+	}
+	if req.MyChartClassifyId == 0 {
+		response.Fail("图表分类ID有误", c)
+		return
+	}
+
+	// 操作权限校验
+	userInfo := user.GetInfoByClaims(c)
+	ok, adminInfo, err := user.GetAdminByUserInfo(userInfo)
+	if err != nil {
+		response.Fail("操作人信息有误", c)
+		return
+	}
+	if !ok {
+		response.Fail("非内部人员无权进行操作", c)
+		return
+	}
+	adminId := int(adminInfo.AdminID)
+	myChassify, err := my_chart_classify.GetClassifyById(req.MyChartClassifyId)
+	if err != nil {
+		if err == utils.ErrNoRow {
+			response.Fail("该图表分类信息有误", c)
+			return
+		}
+		response.Fail("获取图表信息失败", c)
+		return
+	}
+	if myChassify.AdminID != adminId {
+		response.Fail("无权移动该图表", c)
+		return
+	}
+
+	// 移动分类
+	updateCol := make([]string, 0)
+	if req.PrevClassifyId > 0 {
+		prevClassify, err := my_chart_classify.GetClassifyByIdAndAdminId(adminId, req.PrevClassifyId)
+		if err != nil {
+			response.Fail("移动失败, 获取上一个兄弟节点分类信息失败", c)
+			return
+		}
+
+		// 如果是移动在两个兄弟节点之间
+		if req.NextClassifyId > 0 {
+			// 下一个兄弟节点
+			nextClassify, err := my_chart_classify.GetClassifyByIdAndAdminId(adminId, req.NextClassifyId)
+			if err != nil {
+				response.Fail("移动失败, 获取下一个兄弟节点分类信息失败", c)
+				return
+			}
+			// 如果上一个兄弟与下一个兄弟的排序权重是一致的，那么需要将下一个兄弟（以及下个兄弟的同样排序权重）的排序权重+2，自己变成上一个兄弟的排序权重+1
+			if prevClassify.Sort == nextClassify.Sort || prevClassify.Sort == myChassify.Sort {
+				// 变更兄弟节点的排序
+				updateSortStr := `sort + 2`
+				_ = my_chart_classify.UpdateMyChartClassifySortByClassifyId(adminId, prevClassify.MyChartClassifyId, prevClassify.Sort, updateSortStr)
+			} else {
+				// 如果下一个兄弟的排序权重正好是上个兄弟节点的下一层，那么需要再加一层了
+				if nextClassify.Sort-prevClassify.Sort == 1 {
+					// 变更兄弟节点的排序
+					updateSortStr := `sort + 1`
+					_ = my_chart_classify.UpdateMyChartClassifySortByClassifyId(adminId, 0, prevClassify.Sort, updateSortStr)
+				}
+			}
+		}
+
+		myChassify.Sort = prevClassify.Sort + 1
+		myChassify.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	} else {
+		firstClassify, err := my_chart_classify.GetFirstClassifyByAdminId(adminId)
+		if err != nil && err != utils.ErrNoRow {
+			response.Fail("移动失败, 获取获取当前账号下的排序第一条的分类信息失败", c)
+			return
+		}
+
+		//如果该分类下存在其他分类，且第一个其他分类的排序等于0，那么需要调整排序
+		if firstClassify != nil && firstClassify.Sort == 0 {
+			updateSortStr := ` sort + 1 `
+			_ = my_chart_classify.UpdateMyChartClassifySortByClassifyId(adminId, firstClassify.MyChartClassifyId-1, 0, updateSortStr)
+		}
+
+		myChassify.Sort = 0 //那就是排在第一位
+		myChassify.ModifyTime = time.Now()
+		updateCol = append(updateCol, "Sort", "ModifyTime")
+	}
+
+	// 更新
+	if len(updateCol) > 0 {
+		err = my_chart_classify.UpdateClassifySort(adminId, myChassify.MyChartClassifyId, myChassify.Sort, myChassify.ModifyTime)
+		if err != nil {
+			response.Fail("移动失败", c)
+			return
+		}
+	}
+
+	//新增操作日志
+	{
+		bodyBytes, _ := ioutil.ReadAll(c.Request.Body)
+		requestBodyStr := string(bodyBytes)
+
+		edbLog := new(myChartLogModel.MyChartLog)
+		edbLog.MyChartId = 0
+		edbLog.ChartInfoId = 0
+		edbLog.SysUserId = adminId
+		edbLog.SysUserRealName = adminInfo.RealName
+		edbLog.CreateTime = time.Now()
+		edbLog.Content = requestBodyStr
+		edbLog.Status = "移动分类"
+		edbLog.Method = c.Request.URL.String()
+		go edbLog.Create()
+	}
+
 	response.Ok("操作成功", c)
 }

docs/docs.go

@@ -718,6 +718,55 @@ var doc = `{
                 }
             }
         },
+        "/my_chart/moveMyChartClassify": {
+            "post": {
+                "security": [
+                    {
+                        "ApiKeyAuth": []
+                    }
+                ],
+                "description": "移动我的图表分类",
+                "consumes": [
+                    "application/json"
+                ],
+                "tags": [
+                    "图库模块"
+                ],
+                "summary": "移动我的图表分类",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Bearer 31a165baebe6dec616b1f8f3207b4273",
+                        "name": "Authorization",
+                        "in": "header",
+                        "required": true
+                    },
+                    {
+                        "description": "请求参数",
+                        "name": "data",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/my_chart.MoveMyChartClassifyReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "操作成功",
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    "400": {
+                        "description": "操作失败",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                }
+            }
+        },
         "/public/get_apply_variety_list": {
             "get": {
                 "security": [
@@ -1704,6 +1753,20 @@ var doc = `{
                 }
             }
         },
+        "my_chart.MoveMyChartClassifyReq": {
+            "type": "object",
+            "properties": {
+                "myChartClassifyId": {
+                    "type": "integer"
+                },
+                "nextClassifyId": {
+                    "type": "integer"
+                },
+                "prevClassifyId": {
+                    "type": "integer"
+                }
+            }
+        },
         "my_chart.MoveMyChartReq": {
             "type": "object",
             "properties": {

docs/swagger.json

@@ -704,6 +704,55 @@
                 }
             }
         },
+        "/my_chart/moveMyChartClassify": {
+            "post": {
+                "security": [
+                    {
+                        "ApiKeyAuth": []
+                    }
+                ],
+                "description": "移动我的图表分类",
+                "consumes": [
+                    "application/json"
+                ],
+                "tags": [
+                    "图库模块"
+                ],
+                "summary": "移动我的图表分类",
+                "parameters": [
+                    {
+                        "type": "string",
+                        "description": "Bearer 31a165baebe6dec616b1f8f3207b4273",
+                        "name": "Authorization",
+                        "in": "header",
+                        "required": true
+                    },
+                    {
+                        "description": "请求参数",
+                        "name": "data",
+                        "in": "body",
+                        "required": true,
+                        "schema": {
+                            "$ref": "#/definitions/my_chart.MoveMyChartClassifyReq"
+                        }
+                    }
+                ],
+                "responses": {
+                    "200": {
+                        "description": "操作成功",
+                        "schema": {
+                            "type": "string"
+                        }
+                    },
+                    "400": {
+                        "description": "操作失败",
+                        "schema": {
+                            "type": "string"
+                        }
+                    }
+                }
+            }
+        },
         "/public/get_apply_variety_list": {
             "get": {
                 "security": [
@@ -1690,6 +1739,20 @@
                 }
             }
         },
+        "my_chart.MoveMyChartClassifyReq": {
+            "type": "object",
+            "properties": {
+                "myChartClassifyId": {
+                    "type": "integer"
+                },
+                "nextClassifyId": {
+                    "type": "integer"
+                },
+                "prevClassifyId": {
+                    "type": "integer"
+                }
+            }
+        },
         "my_chart.MoveMyChartReq": {
             "type": "object",
             "properties": {

docs/swagger.yaml

@@ -323,6 +323,15 @@ definitions:
       pic_url:
         type: string
     type: object
+  my_chart.MoveMyChartClassifyReq:
+    properties:
+      myChartClassifyId:
+        type: integer
+      nextClassifyId:
+        type: integer
+      prevClassifyId:
+        type: integer
+    type: object
   my_chart.MoveMyChartReq:
     properties:
       myChartClassifyId:
@@ -1092,6 +1101,37 @@ paths:
       summary: 移动我的图表
       tags:
       - 图库模块
+  /my_chart/moveMyChartClassify:
+    post:
+      consumes:
+      - application/json
+      description: 移动我的图表分类
+      parameters:
+      - description: Bearer 31a165baebe6dec616b1f8f3207b4273
+        in: header
+        name: Authorization
+        required: true
+        type: string
+      - description: 请求参数
+        in: body
+        name: data
+        required: true
+        schema:
+          $ref: '#/definitions/my_chart.MoveMyChartClassifyReq'
+      responses:
+        "200":
+          description: 操作成功
+          schema:
+            type: string
+        "400":
+          description: 操作失败
+          schema:
+            type: string
+      security:
+      - ApiKeyAuth: []
+      summary: 移动我的图表分类
+      tags:
+      - 图库模块
   /public/get_apply_variety_list:
     get:
       consumes:

models/tables/edb_data/create.go

@@ -0,0 +1,23 @@
+package edb_data
+
+import (
+	"hongze/hongze_yb/global"
+)
+
+func AddEdbDataThsBySql(sqlStr string) (err error) {
+	err = global.MYSQL["data"].Exec(sqlStr).Error
+
+	return
+}
+
+func AddEdbDataWindBySql(sqlStr string) (err error) {
+	err = global.MYSQL["data"].Exec(sqlStr).Error
+
+	return
+}
+
+func AddEdbDataPb(items []*EdbDataPb) (err error) {
+	err = global.MYSQL["data"].Model(EdbDataPb{}).Create(items).Error
+
+	return
+}

models/tables/edb_data/query.go

@@ -6,6 +6,7 @@ import (
 	"hongze/hongze_yb/global"
 	"hongze/hongze_yb/utils"
 	"strconv"
+	"time"
 )
 
 // 指标数据->存储表
@@ -112,4 +113,95 @@ func GetEdbDataList(source, endInfoId int, startDate, endDate string) (list []*E
 	err = global.MYSQL["data"].Raw(sql, endInfoId, pars).Scan(&list).Error
 
 	return
+}
+
+
+func GetEdbDataThsByCodeAndDate(edbCode string, startDate string) (count int, err error) {
+	sql := ` SELECT COUNT(1) AS count FROM edb_data_ths WHERE edb_code = ? AND data_time = ? `
+	err = global.MYSQL["data"].Raw(sql, edbCode, startDate).Scan(&count).Error
+
+	return
+}
+
+func GetEdbDataWindByCodeAndDate(edbCode string, startDate string) (count int, err error) {
+	sql := ` SELECT COUNT(1) AS count FROM edb_data_wind WHERE edb_code=? AND data_time=? `
+	err = global.MYSQL["data"].Raw(sql, edbCode, startDate).Scan(&count).Error
+
+	return
+}
+
+func GetEdbDataPbByCodeAndDate(edbCode string, startDate string) (count int, err error) {
+	sql := ` SELECT COUNT(1) AS count FROM edb_data_pb WHERE edb_code=? AND data_time>=? `
+	err = global.MYSQL["data"].Raw(sql, edbCode, startDate).Scan(&count).Error
+
+	return
+}
+
+type ManualEdbdata struct {
+	TradeCode  string    `orm:"column(TRADE_CODE);pk" description:"指标编码"`
+	Dt         string    `orm:"column(DT)" description:"日期"`
+	Close      string    `orm:"column(CLOSE)" description:"值"`
+	ModifyTime time.Time `orm:"column(modify_time)" description:"修改时间"`
+}
+
+func GetEdbdataManualByTradeCode(condition string, pars []interface{}) (item []*ManualEdbdata, err error) {
+	sql := ` SELECT  * FROM edbdata WHERE 1=1 `
+	if condition != "" {
+		sql += condition
+	}
+	sql += ` ORDER BY DT DESC `
+	err = global.MYSQL["edb"].Raw(sql, pars).Scan(&item).Error
+
+	return
+}
+
+type EdbDataBase struct {
+	EdbDataId     int `orm:"column(edb_data_id);pk"`
+	EdbInfoId     int
+	EdbCode       string
+	DataTime      string
+	Value         string
+	Status        int
+	CreateTime    time.Time
+	ModifyTime    time.Time
+	DataTimestamp int64
+}
+
+type lzSurveyData struct {
+	DataTime   string `orm:"column(data_time)" description:"日期"`
+	InputValue string `orm:"column(input_value)" description:"值"`
+}
+
+func GetLzSurveyDataByTradeCode(condition string, pars []interface{}) (item []*lzSurveyData, err error) {
+	sql := ` SELECT  a.* FROM longzhong_survey_data AS a
+				INNER JOIN longzhong_survey_product AS b ON a.survey_product_id=b.survey_product_id
+				WHERE 1=1 `
+	if condition != "" {
+		sql += condition
+	}
+	sql += ` ORDER BY a.data_time DESC `
+	err = global.MYSQL["edb"].Raw(sql, pars).Scan(&item).Error
+
+	return
+}
+
+func GetEdbDataLzByCodeAndDate(edbCode string, startDate string) (count int, err error) {
+	sql := ` SELECT COUNT(1) AS count FROM edb_data_lz WHERE edb_code=? AND data_time=? `
+	err = global.MYSQL["data"].Raw(sql, edbCode, startDate).Scan(&count).Error
+
+	return
+}
+
+type EdbDataPb struct {
+	EdbDataId     int `orm:"column(edb_data_id);pk"`
+	EdbInfoId     int
+	EdbCode       string
+	DataTime      string
+	Value         float64
+	Status        int
+	CreateTime    time.Time
+	ModifyTime    time.Time
+	Ticker        string
+	Field         string
+	DataTimestamp int64
 }

models/tables/edb_data/update.go

@@ -0,0 +1,24 @@
+package edb_data
+
+import "hongze/hongze_yb/global"
+
+func ModifyEdbDataThs(edbInfoId int64, dataTime string, value float64) (err error) {
+	sql := ` UPDATE edb_data_ths SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+	err = global.MYSQL["data"].Exec(sql, value, edbInfoId, dataTime).Error
+
+	return
+}
+
+func ModifyEdbDataWind(edbInfoId int64, dataTime string, value float64) (err error) {
+	sql := ` UPDATE edb_data_wind SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+	err = global.MYSQL["data"].Exec(sql, value, edbInfoId, dataTime).Error
+
+	return
+}
+
+func ModifyEdbDataPb(edbInfoId int, dataTime string, value float64) (err error) {
+	sql := ` UPDATE edb_data_pb SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+	err = global.MYSQL["data"].Exec(sql, value, edbInfoId, dataTime).Error
+
+	return
+}

models/tables/edb_info/edb_info.go

@@ -4,9 +4,9 @@ import "time"
 
 // EdbInfo 指标信息表
 type EdbInfo struct {
-	EdbInfoID        int       `gorm:"primaryKey;column:edb_info_id;type:int(11);not null" json:"edbInfoId"`							 // 指标id
+	EdbInfoId        int       `gorm:"primaryKey;column:edb_info_id;type:int(11);not null" json:"edbInfoId"`							 // 指标id
 	SourceName       string    `gorm:"column:source_name;type:varchar(100)" json:"sourceName"`                                           // 来源名称
-	Source           int8      `gorm:"uniqueIndex:idx_code_source;uniqueIndex:idx_edb_name;column:source;type:tinyint(4)" json:"source"` // 来源:1:同花顺,2:wind,3:彭博,4:指标运算,5:累计值转月,6:同比值,7:同差值,8:N数值移动平均计算,9:手工指标,10:隆众,11:有色,12:环比值,13:环差值,14:变频,15:钢联
+	Source           int       `gorm:"uniqueIndex:idx_code_source;uniqueIndex:idx_edb_name;column:source;type:tinyint(4)" json:"source"` // 来源:1:同花顺,2:wind,3:彭博,4:指标运算,5:累计值转月,6:同比值,7:同差值,8:N数值移动平均计算,9:手工指标,10:隆众,11:有色,12:环比值,13:环差值,14:变频,15:钢联
 	EdbCode          string    `gorm:"uniqueIndex:idx_code_source;unique;column:edb_code;type:varchar(255);default:''" json:"edbCode"`   // 指标编码
 	EdbName          string    `gorm:"uniqueIndex:idx_edb_name;column:edb_name;type:varchar(255);default:''" json:"edbName"`             // 指标名称
 	EdbNameSource    string    `gorm:"column:edb_name_source;type:varchar(255);default:''" json:"edbNameSource"`                         // 指标名称_来源
@@ -14,8 +14,8 @@ type EdbInfo struct {
 	Unit             string    `gorm:"column:unit;type:varchar(20);default:''" json:"unit"`                                              // 单位
 	StartDate        time.Time `gorm:"column:start_date;type:date" json:"startDate"`                                                     // 更新开始日期
 	EndDate          time.Time `gorm:"column:end_date;type:date" json:"endDate"`                                                         // 更新结束日期
-	ClassifyID       int       `gorm:"index:idx_classify_id;column:classify_id;type:int(11)" json:"classifyId"`                          // 分类id
-	SysUserID        int       `gorm:"column:sys_user_id;type:int(11)" json:"sysUserId"`                                                 // 创建人
+	ClassifyId       int       `gorm:"index:idx_classify_id;column:classify_id;type:int(11)" json:"classifyId"`                          // 分类id
+	SysUserId        int       `gorm:"column:sys_user_id;type:int(11)" json:"sysUserId"`                                                 // 创建人
 	SysUserRealName  string    `gorm:"column:sys_user_real_name;type:varchar(100)" json:"sysUserRealName"`                               // 创建人姓名
 	CreateTime       time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                               // 创建时间
 	ModifyTime       time.Time `gorm:"column:modify_time;type:datetime" json:"modifyTime"`                                               // 修改时间
@@ -23,12 +23,12 @@ type EdbInfo struct {
 	MinValue         float64   `gorm:"column:min_value;type:double;default:0" json:"minValue"`                                           // 最小值
 	MaxValue         float64   `gorm:"column:max_value;type:double;default:0" json:"maxValue"`                                           // 最大值
 	CalculateFormula string    `gorm:"column:calculate_formula;type:varchar(255);default:''" json:"calculateFormula"`                    // 计算公式,N数值移动
-	EdbType          int8      `gorm:"column:edb_type;type:tinyint(4);default:1" json:"edbType"`                                         // 指标类型:1:基础指标,2:计算指标
-	IsUpdate         int8      `gorm:"column:is_update;type:tinyint(4);default:1" json:"isUpdate"`                                       // 当天是否已更新，1:未更新,2:已更新
+	EdbType          int       `gorm:"column:edb_type;type:tinyint(4);default:1" json:"edbType"`                                         // 指标类型:1:基础指标,2:计算指标
+	IsUpdate         int       `gorm:"column:is_update;type:tinyint(4);default:1" json:"isUpdate"`                                       // 当天是否已更新，1:未更新,2:已更新
 	Sort             int       `gorm:"column:sort;type:int(9);default:0" json:"sort"`                                                    // 排序字段
 	LatestDate       time.Time `gorm:"column:latest_date;type:date" json:"latestDate"`                                                   // 数据最新日期
 	LatestValue      float64   `gorm:"column:latest_value;type:double" json:"latestValue"`                                               // 数据最新值
-	MoveType         int8      `gorm:"column:move_type;type:tinyint(4);default:1" json:"moveType"`                                       // 移动方式:1:领先(默认),2:滞后
+	MoveType         int       `gorm:"column:move_type;type:tinyint(4);default:1" json:"moveType"`                                       // 移动方式:1:领先(默认),2:滞后
 	MoveFrequency    string    `gorm:"column:move_frequency;type:varchar(20);default:''" json:"moveFrequency"`                           // 移动频度
 }
 

models/tables/my_chart/query.go

@@ -48,6 +48,12 @@ type MoveMyChartReq struct {
 	MyChartClassifyId int `description:"当前分类id"`
 }
 
+type MoveMyChartClassifyReq struct {
+	MyChartClassifyId int `description:"分类id"`
+	PrevClassifyId    int `description:"上一个兄弟节点分类id"`
+	NextClassifyId    int `description:"下一个兄弟节点分类id"`
+}
+
 // GetMyChartListByCondition 条件获取我的图表列表
 func GetMyChartListByCondition(condition string, pars []interface{}, page, limit int) (list []*MyChartList, err error) {
 	sql := ` SELECT a.my_chart_id,c.sort,b.* FROM my_chart AS a

models/tables/my_chart_classify/query.go

@@ -18,9 +18,24 @@ func GetClassifyListByCondition(condition map[string]interface{}) (list []*MyCha
 	return
 }
 
-// GetClassifyById 根据主键获取图表分类信息
+// GetClassifyById 根据主键获取分类信息
 func GetClassifyById(chartClassifyId int) (item *MyChartClassify, err error) {
 	err = global.MYSQL["data"].Model(MyChartClassify{}).Where("my_chart_classify_id = ?", chartClassifyId).First(&item).Error
 
 	return
 }
+
+// GetClassifyByIdAndAdminId 根据ID及adminId获取分类信息
+func GetClassifyByIdAndAdminId(adminId, myChartClassifyId int) (item *MyChartClassify, err error) {
+	err = global.MYSQL["data"].Model(MyChartClassify{}).Where("my_chart_classify_id = ? AND admin_id = ?", myChartClassifyId, adminId).First(&item).Error
+
+	return
+}
+
+// GetFirstClassifyByAdminId 获取账号排序第一条的分类数据
+func GetFirstClassifyByAdminId(adminId int) (item *MyChartClassify, err error) {
+	sql := ` SELECT * FROM my_chart_classify WHERE admin_id=? order by sort asc,my_chart_classify_id asc limit 1`
+	err = global.MYSQL["data"].Raw(sql, adminId).Scan(&item).Error
+
+	return
+}

models/tables/my_chart_classify/update.go

@@ -0,0 +1,27 @@
+package my_chart_classify
+
+import (
+	"fmt"
+	"hongze/hongze_yb/global"
+	"time"
+)
+
+// UpdateMyChartClassifySortByClassifyId 根据分类ID更新排序
+func UpdateMyChartClassifySortByClassifyId(adminId, classifyId, nowSort int, updateSort string) (err error) {
+	sql := ` update my_chart_classify set sort = ` + updateSort + ` WHERE admin_id = ? and sort > ? `
+	if classifyId > 0 {
+		sql += ` or ( my_chart_classify_id > ` + fmt.Sprint(classifyId) + ` and sort = ` + fmt.Sprint(nowSort) + `)`
+	}
+	err = global.MYSQL["data"].Exec(sql, adminId, nowSort).Error
+
+	return
+}
+
+// UpdateClassifySort 更新分类排序
+func UpdateClassifySort(adminId, classifyId, nowSort int, modifyTime time.Time) (err error) {
+	err = global.MYSQL["data"].Model(MyChartClassify{}).Select("Sort", "ModifyTime").Where("admin_id = ? AND my_chart_classify_id = ?", adminId, classifyId).Updates(MyChartClassify{
+		Sort: nowSort,
+		ModifyTime: modifyTime,
+	}).Error
+	return
+}

routers/chart.go

@@ -12,7 +12,9 @@ func InitChart(r *gin.Engine) {
 		rGroup.GET("/getChartChassify", chart.GetMyChartChassify)
 		rGroup.GET("/getChartList", chart.GetMyChartList)
 		rGroup.POST("/moveMyChart", chart.MoveMyChart)
+		rGroup.POST("/moveMyChartClassify", chart.MoveMyChartClassify)
 		rGroup.GET("/getChartDetail", chart.GetChartInfoDetail)
 		rGroup.GET("/editChartInfo", chart.EditChartInfo)
+		rGroup.POST("/refreshChartInfo", chart.RefreshChartInfo)
 	}
 }

services/chart/chart_info.go

@@ -5,7 +5,9 @@ import (
 	"hongze/hongze_yb/global"
 	chartEdbMappingModel "hongze/hongze_yb/models/tables/chart_edb_mapping"
 	chartInfoModel "hongze/hongze_yb/models/tables/chart_info"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
 	"hongze/hongze_yb/utils"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -140,3 +142,376 @@ func ModifyChartInfoAndMapping(edbInfoIdStr string, req *chartInfoModel.SaveChar
 
 	return
 }
+
+// RefreshChartInfo 刷新图表
+func RefreshChartInfo(chartInfoId int) (err error) {
+	var errMsg string
+	defer func() {
+		if err != nil {
+			//go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "ChartInfoRefresh:"+errMsg, utils.EmailSendToUsers)
+			fmt.Println("ChartInfoRefresh Err:" + errMsg)
+		}
+	}()
+
+	// 获取需要刷新的指标
+	baseEdbInfoArr, calculateInfoArr, err := GetChartInfoRefreshData(chartInfoId)
+	if err != nil {
+		errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
+		return
+	}
+
+	newBaseEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)
+	baseMap := make(map[int]*edbInfoModel.EdbInfo)
+	for _, bv := range baseEdbInfoArr {
+		if _, ok := baseMap[bv.EdbInfoId]; !ok {
+			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
+		}
+		baseMap[bv.EdbInfoId] = bv
+	}
+
+	fmt.Println("calculateInfoArr:", len(calculateInfoArr))
+
+	newCalculateInfoArr := make([]*edbInfoModel.EdbInfo, 0)
+	calculateMap := make(map[int]*edbInfoModel.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)
+
+	var startDate string
+	for _, bv := range newBaseEdbInfoArr {
+		source := bv.Source
+		edbInfoId := bv.EdbInfoId
+		edbCode := bv.EdbCode
+		startDate = bv.StartDate.Format(utils.FormatDate)
+		sTime, err := time.Parse(utils.FormatDate, bv.EndDate.Format(utils.FormatDate))
+		if err != nil {
+			return err
+		}
+		startDate = sTime.Format(utils.FormatDate)
+
+		fmt.Println("source:", source)
+
+		if source == utils.DATA_SOURCE_THS {
+			endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
+			err = RefreshEdbDataByThs(edbInfoId, edbCode, startDate, endDate)
+			if err != nil {
+				errMsg = "RefreshEdbDataByThs Err:" + err.Error()
+			}
+		} else if source == utils.DATA_SOURCE_WIND {
+			endDate := time.Now().Format(utils.FormatDate)
+			err = RefreshEdbDataByWind(edbInfoId, edbCode, startDate, endDate)
+			if err != nil {
+				errMsg = "RefreshEdbDataByWind 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 = RefreshEdbDataByPb(edbInfoId, edbCode, startDate, endDate)
+			if err != nil {
+				errMsg = "RefreshEdbDataByPb Err:" + err.Error()
+			}
+		} else if source == utils.DATA_SOURCE_MANUAL {
+			fmt.Println("RefreshAllEdbDataByManual:" + edbCode)
+			err = RefreshAllEdbDataByManual(edbInfoId, bv.Source, edbCode)
+			if err != nil {
+				errMsg = "RefreshEdbDataByManual 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 = RefreshEdbDataByLz(edbInfoId, edbCode, startDate, endDate)
+			if err != nil {
+				errMsg = "RefreshEdbDataByLz 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 = RefreshAllEdbDataByYs(edbInfoId, source, edbCode, startDate, endDate)
+			if err != nil {
+				errMsg = "RefreshEdbDataByYs 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 = RefreshEdbDataByGl(edbInfoId, edbCode, startDate, endDate)
+			if err != nil {
+				errMsg = "RefreshEdbDataByGl 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
+			}
+		}*/
+	}
+
+	//endDate := "" //计算指标不限制日期
+	//刷新相关计算指标
+	//for _, v := range calculateArr {
+	//	edbInfo := calculateMap[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([]*edbInfoModel.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
+	//		}
+	//	} else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //刷新直接拼接数据
+	//		err = data_manage.RefreshAllCalculateZjpj(edbInfo)
+	//		if err != nil {
+	//			errMsg = "RefreshAllCalculateZjpj Err:" + err.Error()
+	//			return err
+	//		}
+	//	} else if source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //刷新累计值同比拼接数据
+	//		err = data_manage.RefreshAllCalculateLjztbpj(edbInfo)
+	//		if err != nil {
+	//			errMsg = "RefreshAllCalculateLjztbpj Err:" + err.Error()
+	//			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
+}
+
+// GetChartInfoRefreshData 获取需要刷新的指标
+func GetChartInfoRefreshData(chartInfoId int) (baseEdbInfoArr, calculateInfoArr []*edbInfoModel.EdbInfo, err error) {
+	sql := ` SELECT b.* FROM chart_edb_mapping AS a
+		   INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id 
+		   WHERE a.chart_info_id=? `
+	edbInfoList := make([]*edbInfoModel.EdbInfo, 0)
+	err = global.MYSQL["data"].Exec(sql, chartInfoId).Error
+	if err != nil {
+		return
+	}
+
+	for _, v := range edbInfoList {
+		fmt.Println(v.EdbInfoId, v.EdbType)
+		if v.EdbType == 1 {
+			baseEdbInfoArr = append(baseEdbInfoArr, v)
+		} else {
+			calculateInfoArr = append(calculateInfoArr, v)
+			newBaseEdbInfoArr, newCalculateInfoArr, err := GetChartRefreshEdbInfo(v.EdbInfoId, v.Source, 0)
+			if err != nil {
+				return baseEdbInfoArr, calculateInfoArr, err
+			}
+			baseEdbInfoArr = append(baseEdbInfoArr, newBaseEdbInfoArr...)
+			calculateInfoArr = append(calculateInfoArr, newCalculateInfoArr...)
+		}
+	}
+
+	return
+}
+
+// GetChartRefreshEdbInfo
+func GetChartRefreshEdbInfo(edbInfoId, source, n int) (baseEdbInfoArr, calculateInfoArr []*edbInfoModel.EdbInfo, err error) {
+	calculateList, err := GetEdbInfoCalculateMap(edbInfoId, source)
+	if err != nil && err != utils.ErrNoRow {
+		return
+	}
+	n++
+	for _, item := range calculateList {
+		fmt.Println(item.EdbInfoId)
+		if item.EdbType == 1 {
+			baseEdbInfoArr = append(baseEdbInfoArr, item)
+		} else {
+			calculateInfoArr = append(calculateInfoArr, item)
+			if n > 10 {
+				return
+			}
+			newBaseEdbInfoArr, newCalculateInfoArr, _ := GetChartRefreshEdbInfo(item.EdbInfoId, item.Source, n)
+			baseEdbInfoArr = append(baseEdbInfoArr, newBaseEdbInfoArr...)
+			calculateInfoArr = append(calculateInfoArr, newCalculateInfoArr...)
+		}
+	}
+
+	return
+}
+
+func GetEdbInfoCalculateMap(edbInfoId, source int) (list []*edbInfoModel.EdbInfo, err error) {
+	sql := ` SELECT b.* FROM edb_info_calculate_mapping AS a
+			INNER JOIN edb_info AS b ON a.from_edb_info_id=b.edb_info_id
+			WHERE a.edb_info_id=? ORDER BY sort ASC `
+	err = global.MYSQL["data"].Exec(sql, edbInfoId).Error
+
+	return
+}

services/chart/edb_data.go

@@ -0,0 +1,823 @@
+package chart
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"hongze/hongze_yb/global"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
+	"hongze/hongze_yb/utils"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type EdbDataFromThs struct {
+	DataVol   int64       	`json:"dataVol"`
+	Errmsg    string      	`json:"errmsg"`
+	Errorcode int64       	`json:"errorcode"`
+	Perf      interface{} 	`json:"perf"`
+	Tables    []struct {
+		ID    []string  	`json:"id"`
+		Time  []string  	`json:"time"`
+		Value []float64 	`json:"value"`
+	}						`json:"tables"`
+}
+
+func RefreshEdbDataByThs(edbInfoId int, edbCode, startDate, endDate string) (err error) {
+	HzServerDataUrl := ""
+	if global.CONFIG.Serve.RunMode == "release" {
+		HzServerDataUrl = "http://172.19.173.231:7000/"
+	} else {
+		HzServerDataUrl = "http://139.196.136.213:7000/"
+	}
+
+	thsUrl := HzServerDataUrl + `edbInfo/ths?EdbCode=%s&StartDate=%s&EndDate=%s`
+	thsUrl = fmt.Sprintf(thsUrl, edbCode, startDate, endDate)
+	//utils.FileLog.Info("thsUrl:%s", thsUrl)
+
+	reqRes, err := http.Get(thsUrl)
+	if err != nil {
+		return
+	}
+	defer reqRes.Body.Close()
+	body, err := ioutil.ReadAll(reqRes.Body)
+	if err != nil {
+		return
+	}
+
+	fmt.Println("GetEdbDataByThs body:")
+	fmt.Println(string(body))
+
+	item := new(EdbDataFromThs)
+	err = json.Unmarshal(body, &item)
+	if err != nil {
+		return
+	}
+	if item.Errorcode != 0 {
+		err = errors.New(string(body))
+		return
+	}
+	if len(item.Tables) > 0 {
+		table := item.Tables[0]
+		dataLen := len(table.Time)
+		addSql := ` INSERT INTO edb_data_ths(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+		nowStr := time.Now().Format(utils.FormatDateTime)
+		var isAdd bool
+		for i := 0; i < dataLen; i++ {
+			eDate := table.Time[i]
+			sValue := table.Value[i]
+
+			count, err := edbDataModel.GetEdbDataThsByCodeAndDate(edbCode, eDate)
+			if err != nil && err != utils.ErrNoRow {
+				return err
+			}
+			if count <= 0 {
+				dataTime, err := time.Parse(utils.FormatDate, eDate)
+				if err != nil {
+
+				}
+				timestamp := dataTime.UnixNano() / 1e6
+				timeStr := fmt.Sprintf("%d", timestamp)
+
+				addSql += "("
+				addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + eDate + "'" + "," + utils.SubFloatToString(sValue, 30) + "," + "'" + nowStr + "'" +
+					"," + "'" + nowStr + "'" + "," + "1"
+				addSql += "," + "'" + timeStr + "'"
+				addSql += "),"
+				isAdd = true
+			} else {
+				err = edbDataModel.ModifyEdbDataThs(int64(edbInfoId), eDate, sValue)
+				if err != nil {
+					return err
+				}
+			}
+		}
+
+		if isAdd {
+			addSql = strings.TrimRight(addSql, ",")
+			err = edbDataModel.AddEdbDataThsBySql(addSql)
+			if err != nil {
+				fmt.Println("AddEdbDataThs Err", err.Error())
+				return
+			}
+		}
+	}
+
+	return
+}
+
+type EdbDataFromWind struct {
+	Close  map[string]float64 `json:"CLOSE"`
+	Dt     map[string]int64   `json:"DT"`
+	ErrMsg string
+}
+
+func RefreshEdbDataByWind(edbInfoId int, edbCode, startDate, endDate string) (err error) {
+	defer func() {
+		if err != nil {
+			fmt.Println("GetEdbDataByWind Err:" + err.Error())
+		}
+	}()
+
+	fmt.Println("startDate,endDate:",startDate,endDate)
+
+	thsUrl := utils.Hz_Data_Url + `edbInfo/wind?EdbCode=%s&StartDate=%s&EndDate=%s`
+	thsUrl = fmt.Sprintf(thsUrl, edbCode, startDate, endDate)
+	//utils.FileLog.Info("thsUrl:%s", thsUrl)
+
+	reqRes, err := http.Get(thsUrl)
+	if err != nil {
+		return
+	}
+	defer reqRes.Body.Close()
+	body, err := ioutil.ReadAll(reqRes.Body)
+	if err != nil {
+		return
+	}
+	
+	fmt.Println("GetEdbDataByThs body:")
+	fmt.Println(string(body))
+	//utils.FileLog.Info("wind result:"+string(body))
+
+	item := new(EdbDataFromWind)
+	err = json.Unmarshal(body, &item)
+	if err != nil {
+		return
+	}
+	addSql := ` INSERT INTO edb_data_wind(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+	nowStr := time.Now().Format(utils.FormatDateTime)
+	var isAdd bool
+	for k, v := range item.Dt {
+		timeStr := fmt.Sprintf("%d", v)
+
+		v = v / 1000
+		t := time.Unix(v, 0)
+		dateTime := t.Format(utils.FormatDate)
+		val := item.Close[k]
+
+		count, err := edbDataModel.GetEdbDataWindByCodeAndDate(edbCode, dateTime)
+		if err != nil && err != utils.ErrNoRow {
+			return err
+		}
+		if count <= 0 {
+			isAdd = true
+			fmt.Println(dateTime)
+			addSql += "("
+			addSql += strconv.Itoa(edbInfoId) + "," + "'" + edbCode + "'" + "," + "'" + dateTime + "'" + "," + utils.SubFloatToString(val, 30) + "," + "'" + nowStr + "'" +
+				"," + "'" + nowStr + "'" + "," + "1"
+			addSql += "," + "'" + timeStr + "'"
+			addSql += "),"
+		} else {
+			err = edbDataModel.ModifyEdbDataWind(int64(edbInfoId), dateTime, val)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		err = edbDataModel.AddEdbDataWindBySql(addSql)
+		if err != nil {
+			fmt.Println("AddEdbDataWind Err", err.Error())
+			return
+		}
+	}
+	return
+}
+
+type EdbDataFromPb struct {
+	Date   map[string]int64   `json:"date"`
+	Ticker map[string]string  `json:"ticker"`
+	Field  map[string]string  `json:"field"`
+	Value  map[string]float64 `json:"value"`
+}
+
+func RefreshEdbDataByPb(edbInfoId int, edbCode, startDate, endDate string) (err error) {
+	refreshEdbCode := edbCode
+	edbCode = url.QueryEscape(edbCode)
+	bpUrl := utils.Hz_Data_PB_Url + `edbInfo/pb?EdbCode=%s&StartDate=%s&EndDate=%s`
+	bpUrl = fmt.Sprintf(bpUrl, edbCode, startDate, endDate)
+	//utils.FileLog.Info("bpUrl+" + bpUrl)
+
+	reqRes, err := http.Get(bpUrl)
+	if err != nil {
+		return
+	}
+	defer reqRes.Body.Close()
+	body, err := ioutil.ReadAll(reqRes.Body)
+	if err != nil {
+		return
+	}
+	fmt.Println("RefreshEdbDataByPb body:")
+	fmt.Println(string(body))
+	//utils.FileLog.Info("RefreshEdbDataByPb:" + string(body))
+
+	item := new(EdbDataFromPb)
+	err = json.Unmarshal(body, &item)
+	if err != nil {
+		return
+	}
+	if len(item.Date) > 0 {
+		dateMap := item.Date
+		pbList := make([]*edbDataModel.EdbDataPb, 0)
+		for k, v := range dateMap {
+			timestamp := v
+			v = v / 1000
+			t := time.Unix(v, 0)
+			dateTime := t.Format(utils.FormatDate)
+
+			val := item.Value[k]
+			field := item.Field[k]
+			ticker := item.Ticker[k]
+			if field == "PX_LAST" {
+				//判断数据是否已经存在
+				count, err := edbDataModel.GetEdbDataPbByCodeAndDate(refreshEdbCode, dateTime)
+				if err != nil && err != utils.ErrNoRow {
+					return err
+				}
+				fmt.Println("field:", field)
+				if count <= 0 {
+					item := new(edbDataModel.EdbDataPb)
+					item.EdbCode, _ = url.QueryUnescape(edbCode)
+					item.EdbInfoId = edbInfoId
+					item.CreateTime = time.Now()
+					item.ModifyTime = time.Now()
+					item.DataTime = dateTime
+					item.Value = val
+					item.Status = 1
+					item.Field = field
+					item.Ticker = ticker
+					item.DataTimestamp = timestamp
+					pbList = append(pbList, item)
+				} else {
+					err = edbDataModel.ModifyEdbDataPb(edbInfoId, dateTime, val)
+					if err != nil {
+						return err
+					}
+				}
+			}
+		}
+
+		if len(pbList) > 0 {
+			err = edbDataModel.AddEdbDataPb(pbList)
+			if err != nil {
+				fmt.Println("AddEdbDataPb Err", err.Error())
+				return
+			}
+		}
+	}
+
+	return
+}
+
+//刷新手工指标数据
+func RefreshAllEdbDataByManual(edbInfoId, source int, edbCode string) (err error) {
+	tx := global.MYSQL["data"].Begin()
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			tx.Commit()
+		}
+	}()
+
+	if err != nil {
+		return
+	}
+	edbInfoIdStr := strconv.Itoa(edbInfoId)
+	//计算数据
+	var condition string
+	var pars []interface{}
+
+	if edbCode != "" {
+		condition += " AND TRADE_CODE=? "
+		pars = append(pars, edbCode)
+	}
+
+	manualDataList, err := edbDataModel.GetEdbdataManualByTradeCode(condition, pars)
+	//获取指标所有数据
+	existDataList := make([]*edbDataModel.EdbDataBase, 0)
+	dataTableName := edbDataModel.GetEdbDataTableName(source)
+	sql := `SELECT * FROM %s WHERE edb_info_id=? `
+	sql = fmt.Sprintf(sql, dataTableName)
+	err = global.MYSQL["data"].Raw(sql, edbInfoId).Scan(&existDataList).Error
+	//_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+	if err != nil {
+		return err
+	}
+
+	existDataMap := make(map[string]*edbDataModel.EdbDataBase)
+	for _, v := range existDataList {
+		existDataMap[v.DataTime] = v
+	}
+
+	addSql := ` INSERT INTO edb_data_manual(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+	var isAdd bool
+	manualMap := make(map[string]*edbDataModel.ManualEdbdata)
+	for _, v := range manualDataList {
+		item := v
+		if findItem, ok := existDataMap[v.Dt]; !ok {
+			eDate := item.Dt
+			sValue := item.Close
+
+			dataTime, err := time.Parse(utils.FormatDate, eDate)
+			if err != nil {
+				return err
+			}
+			timestamp := dataTime.UnixNano() / 1e6
+			timeStr := fmt.Sprintf("%d", timestamp)
+
+			addSql += GetAddSql(edbInfoIdStr, edbCode, eDate, timeStr, sValue)
+			isAdd = true
+		} else {
+			if findItem.Value != item.Close {
+				sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+				sql = fmt.Sprintf(sql, dataTableName)
+				err = tx.Exec(sql, item.Close, edbInfoId, item.Dt).Error
+				//err = global.MYSQL["data"].Exec(sql, item.Close, edbInfoId, item.Dt).Error
+				//_, err = o.Raw(sql, item.Close, edbInfoId, item.Dt).Exec()
+				if err != nil {
+					return err
+				}
+			}
+		}
+		manualMap[v.Dt] = v
+	}
+	for _, v := range existDataList {
+		if _, ok := manualMap[v.DataTime]; !ok {
+			go func() {
+				sql := ` DELETE FROM %s WHERE edb_data_id=? `
+				tableName := edbDataModel.GetEdbDataTableName(utils.DATA_SOURCE_MANUAL)
+				sql = fmt.Sprintf(sql, tableName)
+				err = tx.Exec(sql, v.EdbInfoId).Error
+				//err = global.MYSQL["data"].Exec(sql, edbDataId).Error
+			}()
+			//go DeleteEdbDataByIdAndSource(v.EdbDataId, utils.DATA_SOURCE_MANUAL)
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		err = tx.Exec(addSql).Error
+		//_, err = o.Raw(addSql).Exec()
+		if err != nil {
+			fmt.Println("RefreshAllEdbDataByManual add Err", err.Error())
+			return
+		}
+	}
+	return
+}
+
+func DeleteEdbDataByIdAndSource(edbDataId, source int) (err error) {
+	sql := ` DELETE FROM %s WHERE edb_data_id=? `
+	tableName := edbDataModel.GetEdbDataTableName(source)
+	sql = fmt.Sprintf(sql, tableName)
+	err = global.MYSQL["data"].Exec(sql, edbDataId).Error
+
+	return
+}
+
+func GetAddSql(edbInfoId, edbCode, dataTime, timestampStr string, value string) (addSql string) {
+	nowStr := time.Now().Format(utils.FormatDateTime)
+	addSql += "("
+	addSql += edbInfoId + "," + "'" + edbCode + "'" + "," + "'" + dataTime + "'" + "," + value + "," + "'" + nowStr + "'" +
+		"," + "'" + nowStr + "'" + "," + "1"
+	addSql += "," + "'" + timestampStr + "'"
+	addSql += "),"
+	return
+}
+
+//刷新隆众指标数据
+func RefreshEdbDataByLz(edbInfoId int, edbCode, startDate, endDate string) (err error) {
+
+	tx := global.MYSQL["data"].Begin()
+	defer func() {
+		if err != nil {
+			tx.Rollback()
+		} else {
+			tx.Commit()
+		}
+	}()
+
+	if err != nil {
+		return
+	}
+	edbInfoIdStr := strconv.Itoa(edbInfoId)
+	//计算数据
+	var condition string
+	var pars []interface{}
+
+	if edbCode != "" {
+		condition += " AND b.lz_code=? "
+		pars = append(pars, edbCode)
+	}
+
+	if startDate != "" {
+		condition += " AND a.data_time>=? "
+		pars = append(pars, startDate)
+	}
+
+	if endDate != "" {
+		condition += " AND a.data_time<=? "
+		pars = append(pars, endDate)
+	}
+
+	lzDataList, err := edbDataModel.GetLzSurveyDataByTradeCode(condition, pars)
+
+	addSql := ` INSERT INTO edb_data_lz(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+	var isAdd bool
+	for _, v := range lzDataList {
+		item := v
+		count, err := edbDataModel.GetEdbDataLzByCodeAndDate(edbCode, v.DataTime)
+		if err != nil && err != utils.ErrNoRow {
+			return err
+		}
+		if count <= 0 {
+			nowStr := time.Now().Format(utils.FormatDateTime)
+			eDate := item.DataTime
+			sValue := item.InputValue
+			dataTime, err := time.Parse(utils.FormatDate, eDate)
+			if err != nil {
+				return err
+			}
+			timestamp := dataTime.UnixNano() / 1e6
+			timeStr := fmt.Sprintf("%d", timestamp)
+			addSql += "("
+			addSql += edbInfoIdStr + "," + "'" + edbCode + "'" + "," + "'" + eDate + "'" + "," + sValue + "," + "'" + nowStr + "'" +
+				"," + "'" + nowStr + "'" + "," + "1" + "," + "'" + timeStr + "'"
+			addSql += "),"
+			isAdd = true
+		} else {
+			//edbInfoId int64, dataTime, value string
+			//o := orm.NewOrm()
+			//o.Using("data")
+			sql := ` UPDATE edb_data_lz SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+			err = tx.Exec(sql, v.InputValue, int64(edbInfoId), v.DataTime).Error
+			//_, err = o.Raw(sql, value, edbInfoId, dataTime).Exec()
+
+			//err = ModifyEdbDataLz(int64(edbInfoId), v.DataTime, v.InputValue)
+			if err != nil {
+				return err
+			}
+		}
+	}
+	if isAdd {
+		addSql = strings.TrimRight(addSql, ",")
+		err = tx.Exec(addSql).Error
+		//_, err = o.Raw(addSql).Exec()
+		if err != nil {
+			return err
+		}
+	}
+
+	return
+}
+
+//全部刷新有色数据
+//func RefreshAllEdbDataByYs(edbInfoId, source int, edbCode, startDate, endDate string) (err error) {
+//
+//	tx := global.MYSQL["data"].Begin()
+//	defer func() {
+//		if err != nil {
+//			tx.Rollback()
+//		} else {
+//			tx.Commit()
+//		}
+//	}()
+//
+//	if err != nil {
+//		return
+//	}
+//	edbInfoIdStr := strconv.Itoa(edbInfoId)
+//	//获取数据
+//	err = SyncSmmIndexDataBase(edbCode, startDate, endDate)
+//	if err != nil {
+//		err = errors.New("SyncSmmIndexDataBase Err:" + err.Error())
+//		return err
+//	}
+//	//获取已存在指标所有数据
+//	existDataList := make([]*EdbDataBase, 0)
+//	dataTableName := GetEdbDataTableName(source)
+//	sql := `SELECT * FROM %s WHERE edb_info_id=? `
+//	sql = fmt.Sprintf(sql, dataTableName)
+//	_, err = o.Raw(sql, edbInfoId).QueryRows(&existDataList)
+//	if err != nil {
+//		return err
+//	}
+//	existDataMap := make(map[string]string)
+//	for _, v := range existDataList {
+//		existDataMap[v.DataTime] = v.Value
+//	}
+//
+//	smmDateList := make([]*BaseFromSmmDataSimple, 0)
+//	smmSql := ` SELECT * FROM base_from_smm_data WHERE index_code=? AND data_time>=? `
+//	_, err = o.Raw(smmSql, edbCode, startDate).QueryRows(&smmDateList)
+//	if err != nil {
+//		return err
+//	}
+//
+//	addSql := ` INSERT INTO edb_data_ys(edb_info_id,edb_code,data_time,value,create_time,modify_time,status,data_timestamp) values `
+//	var isAdd bool
+//	for _, sv := range smmDateList {
+//		if existVal, ok := existDataMap[sv.DataTime]; !ok {
+//			dataTime, err := time.Parse(utils.FormatDate, sv.DataTime)
+//			if err != nil {
+//				return err
+//			}
+//			timestamp := dataTime.UnixNano() / 1e6
+//			timeStr := fmt.Sprintf("%d", timestamp)
+//			addSql += GetAddSql(edbInfoIdStr, edbCode, sv.DataTime, timeStr, sv.Value)
+//			isAdd = true
+//		} else {
+//			if existVal != sv.Value {
+//				sql := ` UPDATE %s SET value=?,modify_time=NOW() WHERE edb_info_id=? AND data_time=? `
+//				sql = fmt.Sprintf(sql, dataTableName)
+//				_, err = o.Raw(sql, sv.Value, edbInfoId, sv.DataTime).Exec()
+//				if err != nil {
+//					return err
+//				}
+//			}
+//		}
+//	}
+//	if isAdd {
+//		addSql = strings.TrimRight(addSql, ",")
+//		_, err = o.Raw(addSql).Exec()
+//		if err != nil {
+//			return err
+//		}
+//	}
+//	return
+//}
+
+//获取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
+//}
+
+//func SyncSmmIndexDataBase(edbCode, startDate, endDate string) (err error) {
+//	//utils.FileLog.Info("start:" + time.Now().Format(utils.FormatDateTime))
+//
+//	var smmCode string
+//	if strings.Contains(edbCode, "#") {
+//		smmCode = strings.Split(edbCode, "#")[0]
+//	} else {
+//		smmCode = edbCode
+//	}
+//	token, err := getToken("pqian@hzinsights.com", "hz123456")
+//	if err != nil {
+//		fmt.Println(err)
+//		return
+//	}
+//	baseSmmItem, err := GetBaseFromSmmBySmmCode(smmCode)
+//	if err != nil {
+//		fmt.Println(err)
+//		return
+//	}
+//
+//	if baseSmmItem == nil {
+//		err = errors.New("GetBaseFromSmmBySmmCode Err:" + err.Error())
+//		return
+//	}
+//
+//	smmIndexAll, err := GetBaseFromSmmIndexBySmmCode(smmCode)
+//	if err != nil {
+//		fmt.Println("GetBaseFromSmmIndex Err:" + err.Error())
+//		return
+//	}
+//	existIndexMap := make(map[string]*BaseFromSmmIndex)
+//	for _, item := range smmIndexAll {
+//		existIndexMap[item.IndexCode] = item
+//	}
+//
+//	ysItem, err := getApiData(token, edbCode, startDate, endDate)
+//	if err != nil {
+//		fmt.Println(err)
+//		return
+//	}
+//	if ysItem != nil && ysItem.Code == 200 {
+//
+//		frequency := ysItem.Data.Frequency
+//
+//		indexMap := make(map[string]int)
+//		smmIndexIdMap := make(map[int]int)
+//		indexCodeMap := make(map[int]string)
+//
+//		indexKey := 0
+//		var isDateIndex int
+//		for fk, fv := range ysItem.Data.Field {
+//			if fv.IsDate == "1" {
+//				isDateIndex = fk
+//			} else {
+//				if !strings.Contains(fv.Name, "产品名称") &&
+//					!strings.Contains(fv.Name, "单位") &&
+//					!strings.Contains(fv.Name, "时间") &&
+//					!strings.Contains(fv.Name, "备注") {
+//
+//					indexMap[fv.DBColName] = fk
+//
+//					indexKey += 1
+//					indexCode := smmCode + "#" + strconv.Itoa(indexKey)
+//
+//					if findItem, ok := existIndexMap[indexCode]; !ok {
+//						ssmIndex := new(BaseFromSmmIndex)
+//						ssmIndex.Interface = smmCode
+//						ssmIndex.Name = baseSmmItem.Name
+//						ssmIndex.IndexCode = indexCode
+//						ssmIndex.IndexName = baseSmmItem.Name + "_" + fv.Name
+//						ssmIndex.Type1 = baseSmmItem.Type1
+//						ssmIndex.Type2 = baseSmmItem.Type2
+//						ssmIndex.Type3 = baseSmmItem.Type3
+//						ssmIndex.Frequency = frequency
+//						ssmIndex.Unit = fv.Unit
+//						ssmIndex.ApiStartTime = baseSmmItem.ApiStartTime
+//						ssmIndex.ApiUpdateTime = baseSmmItem.ApiUpdateTime
+//						ssmIndex.StartTime = baseSmmItem.StartTime
+//						ssmIndex.FinishTime = baseSmmItem.FinishTime
+//						ssmIndex.CreateTime = time.Now()
+//						ssmIndex.ModifyTime = time.Now()
+//						lastIndexId, err := AddBaseFromSmmIndex(ssmIndex)
+//						if err != nil {
+//							err = errors.New("AddBaseFromSmmIndex Err:" + err.Error())
+//							return err
+//						}
+//						smmIndexIdMap[fk] = int(lastIndexId)
+//						indexCodeMap[fk] = indexCode
+//					} else {
+//						smmIndexIdMap[fk] = findItem.BaseFromSmmIndexId
+//						indexCodeMap[fk] = findItem.IndexCode
+//					}
+//				}
+//			}
+//		}
+//
+//		existDataMap := make(map[string]*BaseFromSmmData)
+//		for _, mv := range indexCodeMap {
+//			indexCode := mv
+//			dataAllList, err := GetBaseFromSmmDataAllByIndexCode(indexCode)
+//			if err != nil {
+//				err = errors.New("GetBaseFromSmmData Err:" + err.Error())
+//				return err
+//			}
+//			for _, item := range dataAllList {
+//				key := item.IndexCode + item.DataTime
+//				existDataMap[key] = item
+//			}
+//		}
+//
+//		addExistDataMap := make(map[string]string)
+//
+//		for _, dv := range ysItem.Data.Content {
+//			var dataTime string
+//			dataTime = dv[isDateIndex]
+//			if strings.Contains(dataTime, "Q1") {
+//				dataTime = strings.Replace(dataTime, "Q1", "-01", -1)
+//				dataTime += "-31"
+//			}
+//			if strings.Contains(dataTime, "Q2") {
+//				dataTime = strings.Replace(dataTime, "Q2", "-06", -1)
+//				dataTime += "-30"
+//			}
+//			if strings.Contains(dataTime, "Q3") {
+//				dataTime = strings.Replace(dataTime, "Q3", "-09", -1)
+//				dataTime += "-30"
+//			}
+//			if strings.Contains(dataTime, "Q4") {
+//				dataTime = strings.Replace(dataTime, "Q4", "-12", -1)
+//				dataTime += "-31"
+//			}
+//
+//			if strings.Contains(dataTime, "H1") {
+//				dataTime = strings.Replace(dataTime, "H1", "-06", -1)
+//				dataTime += "-30"
+//			}
+//
+//			if strings.Contains(dataTime, "H2") {
+//				dataTime = strings.Replace(dataTime, "H2", "-12", -1)
+//				dataTime += "-31"
+//			}
+//
+//			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 frequency == "年" {
+//				dataTime = dataTime + "-12-31"
+//			}
+//			saveDataTime, err := time.Parse(utils.FormatDate, dataTime)
+//			if err != nil {
+//				err = errors.New("time.Parse Err:" + err.Error())
+//				return err
+//			}
+//			timestamp := saveDataTime.UnixNano() / 1e6
+//			//循环指标
+//			for _, v := range indexMap {
+//
+//				indexCode := indexCodeMap[v]
+//				smmIndexId := smmIndexIdMap[v]
+//				dataVal := dv[v]
+//
+//				if indexCode != "" {
+//
+//					key := indexCode + dataTime
+//					val := strings.Replace(dataVal, ",", "", -1)
+//					if findData, dataOk := existDataMap[key]; !dataOk {
+//						if _, addOK := addExistDataMap[key]; !addOK {
+//							if val != "" && val != "-" {
+//								dataItem := new(BaseFromSmmData)
+//								dataItem.BaseFromSmmIndexId = smmIndexId
+//								dataItem.IndexCode = indexCode
+//								dataItem.DataTime = dataTime
+//								dataItem.Value = val
+//								dataItem.CreateTime = time.Now()
+//								dataItem.ModifyTime = time.Now()
+//								dataItem.DataTimestamp = timestamp
+//								_, err = AddBaseFromSmmData(dataItem)
+//								if err != nil && !strings.Contains(err.Error(), "idx_index_code_date") {
+//									fmt.Println("AddBaseFromSmmData Err:" + err.Error())
+//									err = errors.New("AddBaseFromSmmData Err:" + err.Error())
+//									return err
+//								}
+//							}
+//						}
+//					} else {
+//						if findData != nil && findData.Value != val { //修改
+//							if _, addOK := addExistDataMap[key]; !addOK {
+//								if val != "" && val != "-" {
+//									err = ModifyBaseFromSmmData(findData.SmmDataId, val)
+//									if err != nil {
+//										err = errors.New("ModifyBaseFromSmmData Err:" + err.Error())
+//										return err
+//									}
+//								}
+//							}
+//						}
+//					}
+//					addExistDataMap[key] = key
+//				}
+//			}
+//		}
+//
+//		//修改数据开始，结束日期
+//		{
+//			indexList, err := GetBaseFromSmmIndexBySmmCode(smmCode)
+//			if err != nil {
+//				fmt.Println("GetBaseFromSmmIndexBySmmCode Err:" + err.Error())
+//			}
+//			for _, sv := range indexList {
+//				minDate, maxDate, err := GetBaseFromSmmMaxOrMinDate(sv.IndexCode)
+//				if err != nil {
+//					fmt.Println("GetEdbDataSmmMaxOrMinDate Err:" + err.Error())
+//				} else {
+//					err = ModifyBaseFromSmmMinDateAndMaxDate(sv.BaseFromSmmIndexId, minDate, maxDate)
+//					if err != nil {
+//						fmt.Println("ModifyBaseFromSmmMinDateAndMaxDate Err:" + err.Error())
+//					}
+//				}
+//			}
+//		}
+//	}
+//	return
+//}

services/edb_data/edb_data.go

@@ -3,14 +3,14 @@ package edb_data
 import (
 	"fmt"
 	"github.com/nosixtools/solarlunar"
-	"hongze/hongze_yb/models/tables/edb_data"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
 	"hongze/hongze_yb/utils"
 	"strconv"
 	"time"
 )
 
 // AddCalculateQuarter 指标季度数据计算(公历转农历)
-func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.EdbDataResult, err error) {
+func AddCalculateQuarter(dataList []*edbDataModel.EdbDataList) (result *edbDataModel.EdbDataResult, err error) {
 	var errMsg string
 	defer func() {
 		if errMsg != "" {
@@ -25,7 +25,7 @@ func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.Edb
 	}
 	thisMonth := int(endDateForm.Month())
 
-	result = new(edb_data.EdbDataResult)
+	result = new(edbDataModel.EdbDataResult)
 	var yearArr []int
 	yearMap := make(map[int]int)
 	var cureentDate time.Time
@@ -89,7 +89,7 @@ func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.Edb
 			}
 			day := currentYearCjglDate.Sub(preYearCjglDate).Hours() / float64(24)
 
-			items := new(edb_data.EdbDataItems)
+			items := new(edbDataModel.EdbDataItems)
 			items.Year = preYear
 			for _, v := range dataList {
 				dateTime, err := time.Parse(utils.FormatDate, v.DataTime)
@@ -102,7 +102,7 @@ func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.Edb
 				selectDate, _ := time.Parse(utils.FormatDate, selectDateStr)
 				if newDate.Before(selectDate) || newDate == selectDate {
 					timestamp := newDate.UnixNano() / 1e6
-					item := new(edb_data.EdbDataList)
+					item := new(edbDataModel.EdbDataList)
 					item.DataTime = newDate.Format(utils.FormatDate)
 					item.EdbInfoId = v.EdbInfoId
 					item.Value = v.Value
@@ -134,7 +134,7 @@ func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.Edb
 
 			//fmt.Println("day:", day, nextYearCjglDate, preYearCjglDate)
 
-			items := new(edb_data.EdbDataItems)
+			items := new(edbDataModel.EdbDataItems)
 			items.Year = preYear - 1
 			//fmt.Println("preYear:", preYear, "ky:", ky, "yearArrLen:", len(yearArr))
 			if ky+1 < len(yearArr) {
@@ -150,7 +150,7 @@ func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.Edb
 
 					if newDate.Before(selectDate) || newDate == selectDate {
 						timestamp := newDate.UnixNano() / 1e6
-						item := new(edb_data.EdbDataList)
+						item := new(edbDataModel.EdbDataList)
 						item.DataTime = newDate.Format(utils.FormatDate)
 						item.EdbInfoId = v.EdbInfoId
 						item.Value = v.Value
@@ -168,7 +168,7 @@ func AddCalculateQuarter(dataList []*edb_data.EdbDataList) (result *edb_data.Edb
 						return result, err
 					}
 					timestamp := dateTime.UnixNano() / 1e6
-					item := new(edb_data.EdbDataList)
+					item := new(edbDataModel.EdbDataList)
 					item.DataTime = dateTime.Format(utils.FormatDate)
 					item.EdbInfoId = v.EdbInfoId
 					item.Value = v.Value

utils/constants.go

@@ -75,7 +75,23 @@ const (
 	HZ_CHART_LIB_DETAIL = "HZ_CHART_LIB_DETAIL_"
 )
 
+//var (
+//	Hz_Server_Data_Url string //同花顺，万得接口服务地址（阿里云windows服务器地址）
+//)
+
 const (
 	DATA_PREFIX  = "hz_data"
 	CHART_PREFIX = "hz_chart"
+)
+
+//数据刷新频率
+const (
+	DATA_REFRESH        = 7 //7个单位，日/周/月/季度/年
+	DATA_END_DATE_LIMIT = 4 //数据结束日期为，当前日期，加上4年时间
+)
+
+const (
+	Hz_Data_Url    = "http://datawind.hzinsights.com:8040/" //同花顺，万得接口服务地址
+	Hz_Data_PB_Url = "http://datapb.hzinsights.com:8040/"   //彭博接口地址
+	EDB_DATA_LIMIT = 10
 )