Merge branch 'master' into feature/migrate_wechat_msg

controller/activity/activity.go

@@ -5,8 +5,10 @@ import (
 	"github.com/gin-gonic/gin"
 	"hongze/hongze_yb/controller/response"
 	"hongze/hongze_yb/models/tables/yb_activity"
+	"hongze/hongze_yb/models/tables/yb_view_log"
 	"hongze/hongze_yb/services/activity"
 	"hongze/hongze_yb/services/user"
+	"hongze/hongze_yb/services/view_log"
 	"hongze/hongze_yb/utils"
 	"io/ioutil"
 	"os"
@@ -291,4 +293,61 @@ func calcuDrawXandY(drawText string, fontSize, canvasLength, canvasWidth int) (x
 	}
 
 	return
+}
+
+// AddStatistics
+// @Description 新增语音点击记录
+// @Success 200 {string} string "新增成功"
+// @Router /activity/voice_log/add [post]
+func AddActivityAudioLog(c *gin.Context) {
+	var req yb_view_log.ActivityAudioLogAddReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误:"+err.Error(), c)
+		return
+	}
+	if req.PrimaryId == 0 {
+		response.Fail("请输入音频ID", c)
+		return
+	}
+	if req.ExtendId == 0 {
+		response.Fail("请输入活动ID", c)
+		return
+	}
+
+	if req.Source == 0 {
+		response.Fail("请输入操作来源", c)
+		return
+	}
+	userinfo := user.GetInfoByClaims(c)
+
+	data, err := view_log.AddActivityAudioLog(userinfo, req)
+	if err != nil {
+		response.FailMsg("添加日志失败", err.Error(), c)
+		return
+	}
+	response.OkData("新增记录成功", data, c)
+}
+
+// AddStatistics
+// @Description 新增语音点击记录
+// @Success 200 {string} string "新增成功"
+// @Router /activity/voice_log/update [post]
+func UpdateActivityAudioLog(c *gin.Context) {
+	var req yb_view_log.ActivityAudioLogStopReq
+	if err := c.Bind(&req); err != nil {
+		response.Fail("参数有误:"+err.Error(), c)
+		return
+	}
+	if req.Id == 0 {
+		response.Fail("请输入日志ID", c)
+		return
+	}
+	userinfo := user.GetInfoByClaims(c)
+
+	err := view_log.UpdateActivityAudioLog(userinfo, req)
+	if err != nil {
+		response.FailMsg("更新日志失败", err.Error(), c)
+		return
+	}
+	response.Ok("更新日志成功", c)
 }

controller/chart/chart_info.go

@@ -10,11 +10,9 @@ import (
 	chartEdbMappingModel "hongze/hongze_yb/models/tables/chart_edb_mapping"
 	chartInfoModel "hongze/hongze_yb/models/tables/chart_info"
 	"hongze/hongze_yb/models/tables/chart_info_log"
-	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
 	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
 	"hongze/hongze_yb/services/alarm_msg"
 	"hongze/hongze_yb/services/chart"
-	edbDataService "hongze/hongze_yb/services/edb_data"
 	"hongze/hongze_yb/services/user"
 	"hongze/hongze_yb/utils"
 	"io/ioutil"
@@ -169,183 +167,191 @@ func GetChartInfoDetail(c *gin.Context) {
 	}
 
 	// 指标列表
-	sourceArr := make([]string, 0)
-	edbList := make([]*chartEdbMappingModel.ChartEdbInfoMappingList, 0)
-	for _, v := range mappingList {
-		item := new(chartEdbMappingModel.ChartEdbInfoMappingList)
-		item.EdbInfoId = v.EdbInfoId
-		item.SourceName = v.SourceName
-		item.Source = v.Source
-		item.EdbCode = v.EdbCode
-		item.EdbName = v.EdbName
-		item.Frequency = v.Frequency
-		if v.Unit != "无" {
-			item.Unit = v.Unit
-		}
-		item.StartDate = v.StartDate
-		item.EndDate = v.EndDate
-		item.ModifyTime = v.ModifyTime
-
-		if !utils.InArray(v.Source, utils.SystemSourceList) { //来源于系统的指标，都展示为弘则研究
-			if !utils.InArray(v.SourceName, sourceArr) {
-				sourceArr = append(sourceArr, v.SourceName)
-			}
-		}
-		if chartInfoId <= 0 {
-			item.IsAxis = 1
-			item.LeadValue = 0
-			item.LeadUnit = ""
-			item.ChartEdbMappingId = 0
-			item.ChartInfoId = 0
-			item.IsOrder = false
-			item.EdbInfoType = 1
-			item.ChartStyle = ""
-			item.ChartColor = ""
-			item.ChartWidth = 0
-			item.MaxData = v.MaxValue
-			item.MinData = v.MinValue
-		} else {
-			item.IsAxis = v.IsAxis
-			item.EdbInfoType = v.EdbInfoType
-			item.LeadValue = v.LeadValue
-			item.LeadUnit = v.LeadUnit
-			item.ChartEdbMappingId = v.ChartEdbMappingId
-			item.ChartInfoId = v.ChartInfoId
-			item.ChartStyle = v.ChartStyle
-			item.ChartColor = v.ChartColor
-			item.ChartWidth = v.ChartWidth
-			item.IsOrder = v.IsOrder
-			item.MaxData = v.MaxData
-			item.MinData = v.MinData
-		}
-		item.LatestValue = v.LatestValue
-		item.LatestDate = v.LatestDate
-		item.UniqueCode = v.UniqueCode
-		item.ChartStyle = v.ChartStyle
-
-		var startDateReal string
-		var diffSeconds int64
-		if chartType == 2 { //季节性图表
-			startDateReal = startDate
-		} else {
-			if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 {
-				// 领先指标
-				var startTimeRealTemp time.Time
-				startDateParse, _ := time.Parse(utils.FormatDate, startDate)
-				switch v.LeadUnit {
-				case "天":
-					startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
-				case "月":
-					startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
-				case "季":
-					startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
-				case "周":
-					startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
-				case "年":
-					startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
-				}
-				if startTimeRealTemp.Before(startDateParse) {
-					startDateReal = startTimeRealTemp.Format(utils.FormatDate)
-					diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
-				} else {
-					startDateReal = startDate
-					diffSeconds = 0
-				}
-			} else {
-				startDateReal = startDate
-			}
-		}
-		//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
-		calendarPreYear := 0
-		if calendar == "农历" {
-			newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
-			if err != nil {
-				response.FailMsg("获取失败", "农历时间转换有误4001, Err:"+err.Error(), c)
-				//fmt.Println("time.Parse:" + err.Error())
-				return
-			}
-			calendarPreYear = newStartDateReal.Year() - 1
-			newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
-			startDateReal = newStartDateReal.Format(utils.FormatDate)
-		}
-		dataList := make([]*edbDataModel.EdbDataList, 0)
-		fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
-		dataList, err = edbDataModel.GetEdbDataList(v.Source, v.EdbInfoId, startDateReal, endDate)
-		if err != nil {
-			response.FailMsg("获取失败", "获取图表指标信息失败4003, Err:"+err.Error(), c)
-			return
-		}
-		if diffSeconds != 0 && v.EdbInfoType == 0 {
-			dataListLen := len(dataList)
-			for i := 0; i < dataListLen; i++ {
-				dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
-			}
-		}
-
-		if chartType == 2 {
-			if calendar == "农历" {
-				if len(dataList) <= 0 {
-					result := new(edbDataModel.EdbDataResult)
-					item.DataList = result
-				} else {
-					result, err := edbDataService.AddCalculateQuarter(dataList)
-					if err != nil {
-						response.FailMsg("获取失败", "获取农历数据失败4002, Err:"+err.Error(), c)
-						return
-					}
-					if result.List[0].Year != calendarPreYear {
-						itemList := make([]*edbDataModel.EdbDataList, 0)
-						items := new(edbDataModel.EdbDataItems)
-						//items.Year = calendarPreYear
-						items.Items = itemList
-
-						newResult := new(edbDataModel.EdbDataResult)
-						newResult.List = append(newResult.List, items)
-						newResult.List = append(newResult.List, result.List...)
-						item.DataList = newResult
-					} else {
-						item.DataList = result
-					}
-				}
-
-			} else {
-				currentYear := time.Now().Year()
-				quarterDataList := make([]*edbDataModel.QuarterData, 0)
-				quarterMap := make(map[int][]*edbDataModel.EdbDataList)
-				var quarterArr []int
-				for _, v := range dataList {
-					itemDate, err := time.Parse(utils.FormatDate, v.DataTime)
-					if err != nil {
-						response.FailMsg("获取失败", "季度指标日期转换失败, Err:"+err.Error()+";DataTime:"+v.DataTime, c)
-						return
-					}
-					year := itemDate.Year()
-					newItemDate := itemDate.AddDate(currentYear-year, 0, 0)
-					timestamp := newItemDate.UnixNano() / 1e6
-					v.DataTimestamp = timestamp
-					if findVal, ok := quarterMap[year]; !ok {
-						quarterArr = append(quarterArr, year)
-						findVal = append(findVal, v)
-						quarterMap[year] = findVal
-					} else {
-						findVal = append(findVal, v)
-						quarterMap[year] = findVal
-					}
-				}
-				for _, v := range quarterArr {
-					itemList := quarterMap[v]
-					quarterItem := new(edbDataModel.QuarterData)
-					quarterItem.Year = v
-					quarterItem.DataList = itemList
-					quarterDataList = append(quarterDataList, quarterItem)
-				}
-				item.DataList = quarterDataList
-			}
-		} else {
-			item.DataList = dataList
-		}
-		edbList = append(edbList, item)
+	//sourceArr := make([]string, 0)
+	//edbList := make([]*chartEdbMappingModel.ChartEdbInfoMappingList, 0)
+	//for _, v := range mappingList {
+	//	item := new(chartEdbMappingModel.ChartEdbInfoMappingList)
+	//	item.EdbInfoId = v.EdbInfoId
+	//	item.SourceName = v.SourceName
+	//	item.Source = v.Source
+	//	item.EdbCode = v.EdbCode
+	//	item.EdbName = v.EdbName
+	//	item.Frequency = v.Frequency
+	//	if v.Unit != "无" {
+	//		item.Unit = v.Unit
+	//	}
+	//	item.StartDate = v.StartDate
+	//	item.EndDate = v.EndDate
+	//	item.ModifyTime = v.ModifyTime
+	//
+	//	if !utils.InArray(v.Source, utils.SystemSourceList) { //来源于系统的指标，都展示为弘则研究
+	//		if !utils.InArray(v.SourceName, sourceArr) {
+	//			sourceArr = append(sourceArr, v.SourceName)
+	//		}
+	//	}
+	//	if chartInfoId <= 0 {
+	//		item.IsAxis = 1
+	//		item.LeadValue = 0
+	//		item.LeadUnit = ""
+	//		item.ChartEdbMappingId = 0
+	//		item.ChartInfoId = 0
+	//		item.IsOrder = false
+	//		item.EdbInfoType = 1
+	//		item.ChartStyle = ""
+	//		item.ChartColor = ""
+	//		item.ChartWidth = 0
+	//		item.MaxData = v.MaxValue
+	//		item.MinData = v.MinValue
+	//	} else {
+	//		item.IsAxis = v.IsAxis
+	//		item.EdbInfoType = v.EdbInfoType
+	//		item.LeadValue = v.LeadValue
+	//		item.LeadUnit = v.LeadUnit
+	//		item.ChartEdbMappingId = v.ChartEdbMappingId
+	//		item.ChartInfoId = v.ChartInfoId
+	//		item.ChartStyle = v.ChartStyle
+	//		item.ChartColor = v.ChartColor
+	//		item.ChartWidth = v.ChartWidth
+	//		item.IsOrder = v.IsOrder
+	//		item.MaxData = v.MaxData
+	//		item.MinData = v.MinData
+	//	}
+	//	item.LatestValue = v.LatestValue
+	//	item.LatestDate = v.LatestDate
+	//	item.UniqueCode = v.UniqueCode
+	//	item.ChartStyle = v.ChartStyle
+	//
+	//	var startDateReal string
+	//	var diffSeconds int64
+	//	if chartType == 2 { //季节性图表
+	//		startDateReal = startDate
+	//	} else {
+	//		if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 {
+	//			// 领先指标
+	//			var startTimeRealTemp time.Time
+	//			startDateParse, _ := time.Parse(utils.FormatDate, startDate)
+	//			switch v.LeadUnit {
+	//			case "天":
+	//				startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
+	//			case "月":
+	//				startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
+	//			case "季":
+	//				startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
+	//			case "周":
+	//				startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
+	//			case "年":
+	//				startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
+	//			}
+	//			if startTimeRealTemp.Before(startDateParse) {
+	//				startDateReal = startTimeRealTemp.Format(utils.FormatDate)
+	//				diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
+	//			} else {
+	//				startDateReal = startDate
+	//				diffSeconds = 0
+	//			}
+	//		} else {
+	//			startDateReal = startDate
+	//		}
+	//	}
+	//	//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
+	//	calendarPreYear := 0
+	//	if calendar == "农历" {
+	//		newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
+	//		if err != nil {
+	//			response.FailMsg("获取失败", "农历时间转换有误4001, Err:"+err.Error(), c)
+	//			//fmt.Println("time.Parse:" + err.Error())
+	//			return
+	//		}
+	//		calendarPreYear = newStartDateReal.Year() - 1
+	//		newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
+	//		startDateReal = newStartDateReal.Format(utils.FormatDate)
+	//	}
+	//	dataList := make([]*edbDataModel.EdbDataList, 0)
+	//	fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
+	//	dataList, err = edbDataModel.GetEdbDataList(v.Source, v.EdbInfoId, startDateReal, endDate)
+	//	if err != nil {
+	//		response.FailMsg("获取失败", "获取图表指标信息失败4003, Err:"+err.Error(), c)
+	//		return
+	//	}
+	//	if diffSeconds != 0 && v.EdbInfoType == 0 {
+	//		dataListLen := len(dataList)
+	//		for i := 0; i < dataListLen; i++ {
+	//			dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
+	//		}
+	//	}
+	//
+	//	if chartType == 2 {
+	//		if calendar == "农历" {
+	//			if len(dataList) <= 0 {
+	//				result := new(edbDataModel.EdbDataResult)
+	//				item.DataList = result
+	//			} else {
+	//				result, err := edbDataService.AddCalculateQuarter(dataList)
+	//				if err != nil {
+	//					response.FailMsg("获取失败", "获取农历数据失败4002, Err:"+err.Error(), c)
+	//					return
+	//				}
+	//				if result.List[0].Year != calendarPreYear {
+	//					itemList := make([]*edbDataModel.EdbDataList, 0)
+	//					items := new(edbDataModel.EdbDataItems)
+	//					//items.Year = calendarPreYear
+	//					items.Items = itemList
+	//
+	//					newResult := new(edbDataModel.EdbDataResult)
+	//					newResult.List = append(newResult.List, items)
+	//					newResult.List = append(newResult.List, result.List...)
+	//					item.DataList = newResult
+	//				} else {
+	//					item.DataList = result
+	//				}
+	//			}
+	//
+	//		} else {
+	//			currentYear := time.Now().Year()
+	//			quarterDataList := make([]*edbDataModel.QuarterData, 0)
+	//			quarterMap := make(map[int][]*edbDataModel.EdbDataList)
+	//			var quarterArr []int
+	//			for _, v := range dataList {
+	//				itemDate, err := time.Parse(utils.FormatDate, v.DataTime)
+	//				if err != nil {
+	//					response.FailMsg("获取失败", "季度指标日期转换失败, Err:"+err.Error()+";DataTime:"+v.DataTime, c)
+	//					return
+	//				}
+	//				year := itemDate.Year()
+	//				newItemDate := itemDate.AddDate(currentYear-year, 0, 0)
+	//				timestamp := newItemDate.UnixNano() / 1e6
+	//				v.DataTimestamp = timestamp
+	//				if findVal, ok := quarterMap[year]; !ok {
+	//					quarterArr = append(quarterArr, year)
+	//					findVal = append(findVal, v)
+	//					quarterMap[year] = findVal
+	//				} else {
+	//					findVal = append(findVal, v)
+	//					quarterMap[year] = findVal
+	//				}
+	//			}
+	//			for _, v := range quarterArr {
+	//				itemList := quarterMap[v]
+	//				quarterItem := new(edbDataModel.QuarterData)
+	//				quarterItem.Year = v
+	//				quarterItem.DataList = itemList
+	//				quarterDataList = append(quarterDataList, quarterItem)
+	//			}
+	//			item.DataList = quarterDataList
+	//		}
+	//	} else {
+	//		item.DataList = dataList
+	//	}
+	//	edbList = append(edbList, item)
+	//}
+
+	// 获取图表中的指标数据
+	edbList, sourceArr, err := chart.GetChartEdbData(chartInfoId, chartType, calendar, startDate, endDate, mappingList)
+	if err != nil {
+		response.FailMsg("获取失败", "获取图表，指标信息失败, Err:"+err.Error(), c)
+		return
 	}
+
 	sourceArr = append(sourceArr, "弘则研究")
 	chartInfo.ChartSource = strings.Join(sourceArr, ",")
 
@@ -423,7 +429,7 @@ func RefreshChartInfo(c *gin.Context) {
 	}
 
 	// 刷新图表
-	if err = chart.RefreshChart(chartInfo.ChartInfoId); err != nil {
+	if err = chart.ChartInfoRefreshV2(chartInfo.ChartInfoId); err != nil {
 		errContent := fmt.Sprint("ErrMsg: 刷新图表关联指标信息失败, " + err.Error())
 		if global.CONFIG.Serve.RunMode == "release" {
 			go alarm_msg.SendAlarmMsg("刷新图表报错"+time.Now().Format("2006-01-02 15:04:05")+";Err:"+errContent, 3)

controller/community/comment.go

@@ -6,7 +6,6 @@ import (
 	"hongze/hongze_yb/logic/yb_community_question"
 	"hongze/hongze_yb/models/request"
 	responseModel "hongze/hongze_yb/models/response"
-	"hongze/hongze_yb/models/tables/wx_user"
 	"hongze/hongze_yb/models/tables/yb_community_question_comment"
 	"hongze/hongze_yb/services"
 	userService "hongze/hongze_yb/services/user"
@@ -23,27 +22,35 @@ func Comment(c *gin.Context) {
 	userInfo := userService.GetInfoByClaims(c)
 
 	var qaAvatarUrl string
-	if userInfo.QaAvatarUrl == "" {
-		avatar, err := yb_community_question_comment.GetUserAvatarRandom()
-		if err != nil {
-			response.FailMsg("发布失败", err.Error(), c)
-			return
-		}
-		qaAvatarUrl = avatar.AvatarUrl
-		err = wx_user.ModifyQaAvatarUrl(qaAvatarUrl, userInfo.UserID)
-		if err != nil {
-			response.FailMsg("发布失败", err.Error(), c)
-			return
-		}
-	} else {
-		qaAvatarUrl = userInfo.QaAvatarUrl
+	//if userInfo.QaAvatarUrl == "" {
+	//	avatar, err := yb_community_question_comment.GetUserAvatarRandom()
+	//	if err != nil {
+	//		response.FailMsg("发布失败", err.Error(), c)
+	//		return
+	//	}
+	//	qaAvatarUrl = avatar.AvatarUrl
+	//	err = wx_user.ModifyQaAvatarUrl(qaAvatarUrl, userInfo.UserID)
+	//	if err != nil {
+	//		response.FailMsg("发布失败", err.Error(), c)
+	//		return
+	//	}
+	//} else {
+	//	qaAvatarUrl = userInfo.QaAvatarUrl
+	//}
+
+	// 2022-0914修改为全随机
+	avatar, e := yb_community_question_comment.GetUserAvatarRandom()
+	if e != nil {
+		response.FailMsg("发布失败", e.Error(), c)
+		return
 	}
+	qaAvatarUrl = avatar.AvatarUrl
 
 	req.IsShowName = 0
 	if userInfo.NickName != `` { //非空串时为实名
 		req.IsShowName = 1
 	}
-	ybCommunityQuestionComment, err, errMsg := yb_community_question.Comment(userInfo, req.CommunityQuestionID, req.Content, req.SourceAgent, req.IsShowName,qaAvatarUrl)
+	ybCommunityQuestionComment, err, errMsg := yb_community_question.Comment(userInfo, req.CommunityQuestionID, req.Content, req.SourceAgent, req.IsShowName, qaAvatarUrl)
 	if err != nil {
 		response.FailMsg(errMsg, err.Error(), c)
 		return

controller/pc/pc.go

@@ -324,6 +324,7 @@ func ClassifyDetailBanner(c *gin.Context) {
 		"弘则有色团队": utils.ALIYUN_YBIMG_HOST + "qp.png",
 		"弘则黑色团队": utils.ALIYUN_YBIMG_HOST + "wxy.png",
 		"弘则宏观团队": utils.ALIYUN_YBIMG_HOST + "zzh.png",
+		"张立舟": utils.ALIYUN_YBIMG_HOST + "zlz.png",
 	}
 
 	if url, ok := firstNameMap[bannerResp.ClassifyNameFirst]; ok {

logic/user/user.go

@@ -119,6 +119,7 @@ type Detail struct {
 	NickName       string              `json:"nick_name" description:"用户昵称"`
 	HeadImgUrl     string              `json:"head_img_url" description:"用户头像，最后一个数值代表正方形头像大小（有0、46、64、96、132数值可选，0代表640*640正方形头像），用户没有头像时该项为空"`
 	UserId         uint64              `json:"user_id" description:"用户ID"`
+	IsBind         int                 `json:"is_bind" description:"是否绑定了微信"`
 }
 
 // GetUserInfo 获取用户我的页面详情数据
@@ -210,9 +211,15 @@ func GetUserInfo(userInfo user.UserInfo) (userDetail Detail, err error, errMsg s
 		errMsg = "查询消息未读数失败"
 		return
 	}
+
+	// 用户头像
 	headimgurl := userInfo.Headimgurl
 	if headimgurl == "" {
-		headimgurl = utils.DEFAULT_HONGZE_USER_LOGO
+		// 未绑定-灰色头像
+		headimgurl = utils.DEFAULT_HONGZE_USER_LOGO_GRAY
+		if userInfo.UserID > 0 {
+			headimgurl = utils.DEFAULT_HONGZE_USER_LOGO
+		}
 	}
 
 	// 查询是否为内部员工、研究员、语音管理员
@@ -221,6 +228,11 @@ func GetUserInfo(userInfo user.UserInfo) (userDetail Detail, err error, errMsg s
 		return
 	}
 
+	isBind := 0
+	if userInfo.UserID > 0 {
+		isBind = 1
+	}
+
 	userDetail = Detail{
 		CompanyName:    companyName, //客户名称（公司名称）
 		Status:         status,      //产品状态
@@ -239,6 +251,7 @@ func GetUserInfo(userInfo user.UserInfo) (userDetail Detail, err error, errMsg s
 		NickName:       userInfo.NickName,
 		HeadImgUrl:     headimgurl,
 		UserId:         userInfo.UserID,
+		IsBind:         isBind,
 	}
 
 	return

middleware/token.go

@@ -63,13 +63,13 @@ func Token() gin.HandlerFunc {
 			}
 		}
 
-		if err != nil {
+		if err != nil && err != services.ERR_USER_NOT_BIND {
 			//用户openid查询出来发现没有绑定用户
-			if err == services.ERR_USER_NOT_BIND {
-				response.TokenError(nil, "信息已变更,请重新登陆1058!", err.Error(), c)
-				c.Abort()
-				return
-			}
+			//if err == services.ERR_USER_NOT_BIND {
+			//	response.TokenError(nil, "信息已变更,请重新登陆1058!", err.Error(), c)
+			//	c.Abort()
+			//	return
+			//}
 			//没有找到记录
 			if err == utils.ErrNoRow {
 				response.TokenError(nil, "信息已变更,请重新登陆2064!", err.Error(), c)

models/tables/chart_edb_mapping/query.go

@@ -1,46 +1,57 @@
 package chart_edb_mapping
 
-import "hongze/hongze_yb/global"
+import (
+	"hongze/hongze_yb/global"
+	"time"
+)
 
 type ChartEdbInfoMapping struct {
-	EdbInfoId         int     `description:"指标id"`
-	SourceName        string  `description:"来源名称"`
-	Source            int     `description:"来源id"`
-	EdbCode           string  `description:"指标编码"`
-	EdbName           string  `description:"指标名称"`
-	EdbType           int     `description:"指标类型:1:基础指标,2:计算指标"`
-	Frequency         string  `description:"频率"`
-	Unit              string  `description:"单位"`
-	StartDate         string  `description:"起始日期"`
-	EndDate           string  `description:"终止日期"`
-	ModifyTime        string  `description:"指标最后更新时间"`
-	ChartEdbMappingId int     `description:"图表指标id"`
-	ChartInfoId       int     `description:"图表id"`
-	MaxData           float64 `description:"上限"`
-	MinData           float64 `description:"下限"`
-	IsOrder           bool    `description:"true:正序,false:逆序"`
-	IsAxis            int     `description:"1:左轴,0:右轴"`
-	EdbInfoType       int     `description:"1:标准指标,0:领先指标"`
-	LeadValue         int     `description:"领先值"`
-	LeadUnit          string  `description:"领先单位"`
-	ChartStyle        string  `description:"图表类型"`
-	ChartColor        string  `description:"颜色"`
-	ChartWidth        float64 `description:"线条大小"`
-	LatestDate        string  `description:"数据最新日期"`
-	LatestValue       float64 `description:"数据最新值"`
-	UniqueCode        string  `description:"指标唯一编码"`
-	MinValue          float64 `json:"-" description:"最小值"`
-	MaxValue          float64 `json:"-" description:"最大值"`
+	EdbInfoId         int       `description:"指标id"`
+	SourceName        string    `description:"来源名称"`
+	Source            int       `description:"来源id"`
+	EdbCode           string    `description:"指标编码"`
+	EdbName           string    `description:"指标名称"`
+	EdbType           int       `description:"指标类型:1:基础指标,2:计算指标"`
+	Frequency         string    `description:"频率"`
+	Unit              string    `description:"单位"`
+	StartDate         string    `description:"起始日期"`
+	EndDate           string    `description:"终止日期"`
+	ModifyTime        string    `description:"指标最后更新时间"`
+	ChartEdbMappingId int       `description:"图表指标id"`
+	ChartInfoId       int       `description:"图表id"`
+	MaxData           float64   `description:"上限"`
+	MinData           float64   `description:"下限"`
+	IsOrder           bool      `description:"true:正序,false:逆序"`
+	IsAxis            int       `description:"1:左轴,0:右轴"`
+	EdbInfoType       int       `description:"1:标准指标,0:领先指标"`
+	LeadValue         int       `description:"领先值"`
+	LeadUnit          string    `description:"领先单位"`
+	ChartStyle        string    `description:"图表类型"`
+	ChartColor        string    `description:"颜色"`
+	ChartWidth        float64   `description:"线条大小"`
+	LatestDate        time.Time `description:"数据最新日期"`
+	LatestValue       float64   `description:"数据最新值"`
+	UniqueCode        string    `description:"指标唯一编码"`
+	MinValue          float64   `json:"-" description:"最小值"`
+	MaxValue          float64   `json:"-" description:"最大值"`
+
+	EdbNameEn           string `description:"英文指标名称"`
+	FrequencyEn         string `description:"英文频率"`
+	UnitEn              string `description:"英文单位"`
+	EdbInfoCategoryType int    `description:"0:普通指标,1:预测指标"`
+	LeadUnitEn          string `description:"领先英文单位"`
+	PredictChartColor   string `description:"预测数据的颜色"`
+	ChartType           int    `description:"生成样式:1:曲线图,2:季节性图,3:面积图，4：柱状图，5：散点图，6：组合图"`
 }
 
 type ChartEdbInfoMappingList struct {
 	ChartEdbInfoMapping
-	DataList	interface{}
+	DataList interface{}
 }
 
 // GetMappingListByChartInfoId 根据图表ID获取指标映射列表
 func GetMappingListByChartInfoId(chartInfoId int) (list []*ChartEdbInfoMapping, err error) {
-	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.frequency,b.unit,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code
+	sql := ` SELECT a.*,b.source_name,b.source,b.edb_code,b.edb_name,b.edb_name_en,b.frequency,b.unit,b.unit_en,b.start_date,b.end_date,b.modify_time,b.latest_date,b.latest_value,b.unique_code,b.edb_info_type AS edb_info_category_type
              FROM chart_edb_mapping AS a
 			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
 			 WHERE chart_info_id=? 
@@ -52,7 +63,7 @@ func GetMappingListByChartInfoId(chartInfoId int) (list []*ChartEdbInfoMapping,
 
 // GetMappingListByEdbInfoId 根据指标ID获取指标映射列表
 func GetMappingListByEdbInfoId(edbInfoStr string) (list []*ChartEdbInfoMapping, err error) {
-	sql := ` SELECT * FROM edb_info WHERE edb_info_id IN(` + edbInfoStr + `) ORDER BY FIELD(edb_info_id,` + edbInfoStr + `) `
+	sql := ` SELECT edb_info_id,source_name,source,edb_code,edb_name,edb_name_en,frequency,unit,unit_en,start_date,end_date,modify_time,latest_date,latest_value,unique_code,edb_info_type AS edb_info_category_type,max_value,min_value FROM edb_info WHERE edb_info_id IN(` + edbInfoStr + `) ORDER BY FIELD(edb_info_id,` + edbInfoStr + `) `
 	err = global.MYSQL["data"].Raw(sql).Scan(&list).Error
 	return
-}
+}

models/tables/edb_data/query.go

@@ -67,6 +67,14 @@ func GetEdbDataTableName(source int) (tableName string) {
 		tableName = "edb_data_python"
 	case utils.DATA_SOURCE_GOOGLE_TRAVEL:
 		tableName = "edb_data_google_travel"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE:
+		tableName = "edb_data_predict_calculate"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
+		tableName = "edb_data_predict_calculate_tbz"
+	case utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
+		tableName = "edb_data_predict_calculate_tcz"
+	case utils.DATA_SOURCE_MYSTEEL_CHEMICAL:
+		tableName = "edb_data_mysteel_chemical"
 	default:
 		tableName = ""
 	}
@@ -82,8 +90,10 @@ type EdbDataList struct {
 }
 
 type EdbDataItems struct {
-	Items []*EdbDataList
-	Year  int
+	Items                []*EdbDataList
+	Year                 int
+	BetweenDay           int   `json:"-" description:"公历与农历之间相差的天数"`
+	CuttingDataTimestamp int64 `description:"切割的时间戳"`
 }
 
 type EdbDataResult struct {
@@ -91,8 +101,9 @@ type EdbDataResult struct {
 }
 
 type QuarterData struct {
-	Year     int
-	DataList []*EdbDataList
+	Year                 int
+	DataList             []*EdbDataList
+	CuttingDataTimestamp int64 `description:"切割的时间戳"`
 }
 
 // GetEdbDataList 获取指标数据

models/tables/edb_info/edb_info.go

@@ -4,7 +4,8 @@ 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
+	EdbInfoType      uint8     `gorm:"column:edb_info_type;type:tinyint(9) unsigned;default:0" json:"edbInfoType"`                       // 指标类型，0：普通指标，1：预测指标
 	SourceName       string    `gorm:"column:source_name;type:varchar(100)" json:"sourceName"`                                           // 来源名称
 	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"`   // 指标编码
@@ -30,6 +31,11 @@ type EdbInfo struct {
 	LatestValue      float64   `gorm:"column:latest_value;type:double" json:"latestValue"`                                               // 数据最新值
 	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"`                           // 移动频度
+	NoUpdate         int8      `gorm:"column:no_update;type:tinyint(4);default:0" json:"noUpdate"`                                       // 是否停止更新，0：继续更新；1：停止更新
+	ServerURL        string    `gorm:"column:server_url;type:varchar(255);default:''" json:"serverUrl"`                                  // 服务器地址
+	EdbNameEn        string    `gorm:"column:edb_name_en;type:varchar(255);default:''" json:"edbNameEn"`                                 // 英文指标名称
+	UnitEn           string    `gorm:"column:unit_en;type:varchar(20);default:''" json:"unitEn"`                                         // 英文单位
+	ChartImage       string    `gorm:"column:chart_image;type:varchar(255);default:''" json:"chartImage"`                                // 图表图片
 }
 
 // TableName get sql table name.获取数据库表名
@@ -40,6 +46,7 @@ func (m *EdbInfo) TableName() string {
 // EdbInfoColumns get sql column name.获取数据库列名
 var EdbInfoColumns = struct {
 	EdbInfoID        string
+	EdbInfoType      string
 	SourceName       string
 	Source           string
 	EdbCode          string
@@ -65,8 +72,14 @@ var EdbInfoColumns = struct {
 	LatestValue      string
 	MoveType         string
 	MoveFrequency    string
+	NoUpdate         string
+	ServerURL        string
+	EdbNameEn        string
+	UnitEn           string
+	ChartImage       string
 }{
 	EdbInfoID:        "edb_info_id",
+	EdbInfoType:      "edb_info_type",
 	SourceName:       "source_name",
 	Source:           "source",
 	EdbCode:          "edb_code",
@@ -92,4 +105,9 @@ var EdbInfoColumns = struct {
 	LatestValue:      "latest_value",
 	MoveType:         "move_type",
 	MoveFrequency:    "move_frequency",
-}
+	NoUpdate:         "no_update",
+	ServerURL:        "server_url",
+	EdbNameEn:        "edb_name_en",
+	UnitEn:           "unit_en",
+	ChartImage:       "chart_image",
+}

models/tables/edb_info/query.go

@@ -1,10 +1,83 @@
 package edb_info
 
-import "hongze/hongze_yb/global"
+import (
+	"hongze/hongze_yb/global"
+	"hongze/hongze_yb/utils"
+)
 
 // GetEdbInfoById 主键获取指标信息
 func GetEdbInfoById(edbInfoId int) (item *EdbInfo, err error) {
 	err = global.MYSQL["data"].Where("edb_info_id = ? ", edbInfoId).First(&item).Error
 
 	return
-}
+}
+
+// GetEdbInfoAllCalculateByEdbInfoIdList 根据指标id集合 获取基础指标对应的所有计算指标
+func GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	sql := ` SELECT b.* FROM edb_info_calculate_mapping AS a
+			 INNER JOIN edb_info AS b ON a.edb_info_id=b.edb_info_id
+             WHERE a.from_edb_info_id IN (?)
+			 GROUP BY a.edb_info_id
+			 ORDER BY a.edb_info_id ASC `
+	err = global.MYSQL["data"].Raw(sql, edbInfoIdList).Scan(&list).Error
+	return
+}
+
+// GetEdbInfoByIdList 根据指标id集合 获取 指标列表
+func GetEdbInfoByIdList(edbInfoIdList []int) (items []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	sql := ` SELECT * FROM edb_info WHERE edb_info_id IN (?) `
+	err = global.MYSQL["data"].Raw(sql, edbInfoIdList).Scan(&items).Error
+	return
+}
+
+// GetRefreshEdbInfoFromBase 查询基础指标
+func GetRefreshEdbInfoFromBase(edbInfoId, source int) (baseEdbInfoArr, calculateInfoArr []*EdbInfo, err error) {
+	calculateList, err := GetEdbInfoCalculateMap(edbInfoId)
+	if err != nil && err != utils.ErrNoRow {
+		return
+	}
+	for _, item := range calculateList {
+		if item.EdbType == 1 {
+			baseEdbInfoArr = append(baseEdbInfoArr, item)
+		} else {
+			calculateInfoArr = append(calculateInfoArr, item)
+			newBaseEdbInfoArr, newCalculateInfoArr, _ := GetRefreshEdbInfoFromBase(item.EdbInfoId, item.Source)
+			baseEdbInfoArr = append(baseEdbInfoArr, newBaseEdbInfoArr...)
+			calculateInfoArr = append(calculateInfoArr, newCalculateInfoArr...)
+		}
+	}
+	return
+}
+
+// GetEdbInfoCalculateMap 获取计算指标关联信息
+func GetEdbInfoCalculateMap(edbInfoId int) (list []*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"].Raw(sql, edbInfoId).Scan(&list).Error
+	return
+}
+
+// GetPredictEdbInfoAllCalculate 根据基础预测指标id集合 获取 所有的普通指标列表数据
+func GetPredictEdbInfoAllCalculate(edbInfoIdList []int) (list []*EdbInfo, err error) {
+	num := len(edbInfoIdList)
+	if num <= 0 {
+		return
+	}
+	sql := ` SELECT b.* FROM predict_edb_conf AS a
+			 INNER JOIN edb_info AS b ON a.source_edb_info_id=b.edb_info_id
+             WHERE a.predict_edb_info_id IN (?)
+			 GROUP BY a.source_edb_info_id
+			 ORDER BY a.source_edb_info_id ASC `
+	err = global.MYSQL["data"].Raw(sql, edbInfoIdList).Scan(&list).Error
+
+	return
+}

models/tables/predict_edb_conf/predict_edb_info.go

@@ -0,0 +1,37 @@
+package predict_edb_conf
+
+import (
+	"time"
+)
+
+// PredictEdbConf 预测指标规则配置表
+type PredictEdbConf struct {
+	PredictEdbInfoID uint64    `gorm:"primaryKey;column:predict_edb_info_id;type:bigint(9) unsigned;not null;default:0" json:"-"` // 预测指标id
+	SourceEdbInfoID  uint64    `gorm:"column:source_edb_info_id;type:bigint(9) unsigned;default:0" json:"sourceEdbInfoId"`        // 来源指标id
+	RuleType         uint8     `gorm:"column:rule_type;type:tinyint(9) unsigned;default:1" json:"ruleType"`                       // 预测规则，1：最新，2：固定值
+	FixedValue       float64   `gorm:"column:fixed_value;type:decimal(38,4)" json:"fixedValue"`                                   // 固定值
+	ModifyTime       time.Time `gorm:"column:modify_time;type:datetime;default:CURRENT_TIMESTAMP" json:"modifyTime"`              // 修改时间
+	CreateTime       time.Time `gorm:"column:create_time;type:datetime" json:"createTime"`                                        // 添加时间
+}
+
+// TableName get sql table name.获取数据库表名
+func (m *PredictEdbConf) TableName() string {
+	return "predict_edb_conf"
+}
+
+// PredictEdbConfColumns get sql column name.获取数据库列名
+var PredictEdbConfColumns = struct {
+	PredictEdbInfoID string
+	SourceEdbInfoID  string
+	RuleType         string
+	FixedValue       string
+	ModifyTime       string
+	CreateTime       string
+}{
+	PredictEdbInfoID: "predict_edb_info_id",
+	SourceEdbInfoID:  "source_edb_info_id",
+	RuleType:         "rule_type",
+	FixedValue:       "fixed_value",
+	ModifyTime:       "modify_time",
+	CreateTime:       "create_time",
+}

models/tables/predict_edb_conf/query.go

@@ -0,0 +1,9 @@
+package predict_edb_conf
+
+import "hongze/hongze_yb/global"
+
+// GetPredictEdbConfById 根据预测指标获取配置信息
+func GetPredictEdbConfById(edbInfoId int) (item *PredictEdbConf, err error) {
+	err = global.MYSQL["data"].Where("predict_edb_info_id = ? ", edbInfoId).First(&item).Error
+	return
+}

models/tables/yb_activity_voice/yb_activity_voice.go

@@ -4,7 +4,7 @@ import "time"
 
 // YbActivityVoice [...]
 type YbActivityVoice struct {
-	ActivityVoiceID  int       `gorm:"primaryKey;column:activity_voice_id;type:int(11);not null" json:"-"`
+	ActivityVoiceID  int       `gorm:"primaryKey;column:activity_voice_id;type:int(11);not null" json:"activity_voice_id"`
 	ActivityID       uint32    `gorm:"index:idx_activity_id;column:activity_id;type:int(11) unsigned;not null;default:0" json:"activityId"` // 活动id
 	VoiceURL         string    `gorm:"unique;column:voice_url;type:varchar(500);not null;default:''" json:"voiceUrl"`                       // 音频地址
 	VoiceName        string    `gorm:"column:voice_name;type:varchar(255);not null;default:''" json:"voiceName"`                            // 音频名称

models/tables/yb_comment/update.go

@@ -8,7 +8,7 @@ import "hongze/hongze_yb/global"
 	return
 }*/
 
-// Delete 软删除，隐藏评论
+// Delete 直接删除留言
 func Delete(userId uint64, commentId uint64)(err error) {
 	tx := global.DEFAULT_MYSQL.Begin()
 	defer func() {
@@ -18,23 +18,13 @@ func Delete(userId uint64, commentId uint64)(err error) {
 			tx.Commit()
 		}
 	}()
-	sql1 := ` UPDATE yb_comment
-			SET
-            	enabled = 0,
-				modify_time = NOW(),
-				is_hot = 0,
-				is_top = 0
-			WHERE type = 1 and user_id = ? and comment_id = ?`
+	sql1 := ` Delete from yb_comment WHERE type = 1 and user_id = ? and comment_id = ?`
 	err = tx.Exec(sql1, userId, commentId).Error
 	if err != nil {
 		return
 	}
 	// 删除相关联的回复
-	sql2 := ` UPDATE yb_comment
-			SET
-            	enabled = 0,
-				modify_time = NOW()
-			WHERE reply_comment_id = ? and type = 2`
+	sql2 := `Delete from yb_comment WHERE reply_comment_id = ? and type = 2`
 	err = tx.Exec(sql2, commentId).Error
 	return
 }

models/tables/yb_comment/yb_comment.go

@@ -4,27 +4,28 @@ import "time"
 
 // 研报 用户留言表
 type YbComment struct {
-	CommentId                 uint64 `gorm:"primaryKey;column:comment_id;type:bigint(20) unsigned;not null" ` //留言ID
-	UserId                    uint64 `gorm:"column:user_id"` //用户id
-	AdminId                   uint64 `gorm:"column:admin_id"` //发布留言回复的管理员ID
-	ReportId                  int `gorm:"column:report_id"` //报告ID
-	ReportChapterId           int `gorm:"column:report_chapter_id"` //报告章节ID
-	Content                   string `gorm:"column:content"` //留言内容
-	SysIsRead                 int8 `gorm:"column:sys_is_read"` //管理员是否已读 0-未读，1-已读
-	SysReadTime               time.Time `gorm:"column:sys_read_time"` //管理员已读时间
-	SysReadAdminId            int64 `gorm:"column:sys_read_admin_id"` //已读的管理员id
-	ReplyCommentId            uint64 `gorm:"column:reply_comment_id"` //回复的留言ID
-	IsTop                     int8 `gorm:"column:is_top"` //是否置顶（0-未置顶，1-置顶）
-	IsHot                     int8 `gorm:"column:is_hot"` //是否设置精选（0-未设置，1-已设置）
-	HotTopTime                time.Time `gorm:"column:hot_top_time"` //设置精选或者设置置顶的时间
-	Type                      int8 `gorm:"column:type"` //留言类型 1-评论 2-回复
-	Enabled                   int8 `gorm:"column:enabled"` //是否有效, 0-无效留言 1-有效留言
-	IsShowName                int8 `gorm:"column:is_show_name"` //是否匿名 0-匿名，1-不匿名
-	SourceAgent               int `gorm:"column:source_agent"` //留言入口来源，1：小程序，2：pc
-	CreateTime                time.Time `gorm:"column:create_time"` //创建时间
-	ModifyTime                time.Time `gorm:"column:modify_time"` //修改时间
-	OldReportId               int `gorm:"column:old_report_id"  json:"old_report_id" ` //老报告ID
-	OldReportChapterId        int `gorm:"column:old_report_chapter_id" json:"old_report_chapter_id" ` //老报告章节ID
+	CommentId          uint64    `gorm:"primaryKey;column:comment_id;type:bigint(20) unsigned;not null" ` //留言ID
+	UserId             uint64    `gorm:"column:user_id"`                                                  //用户id
+	AdminId            uint64    `gorm:"column:admin_id"`                                                 //发布留言回复的管理员ID
+	ReportId           int       `gorm:"column:report_id"`                                                //报告ID
+	ReportChapterId    int       `gorm:"column:report_chapter_id"`                                        //报告章节ID
+	Content            string    `gorm:"column:content"`                                                  //留言内容
+	SysIsRead          int8      `gorm:"column:sys_is_read"`                                              //管理员是否已读 0-未读，1-已读
+	SysReadTime        time.Time `gorm:"column:sys_read_time"`                                            //管理员已读时间
+	SysReadAdminId     int64     `gorm:"column:sys_read_admin_id"`                                        //已读的管理员id
+	ReplyCommentId     uint64    `gorm:"column:reply_comment_id"`                                         //回复的留言ID
+	IsTop              int8      `gorm:"column:is_top"`                                                   //是否置顶（0-未置顶，1-置顶）
+	IsHot              int8      `gorm:"column:is_hot"`                                                   //是否设置精选（0-未设置，1-已设置）
+	HotTopTime         time.Time `gorm:"column:hot_top_time"`                                             //设置精选或者设置置顶的时间
+	Type               int8      `gorm:"column:type"`                                                     //留言类型 1-评论 2-回复
+	Enabled            int8      `gorm:"column:enabled"`                                                  //是否有效, 0-无效留言 1-有效留言
+	IsShowName         int8      `gorm:"column:is_show_name"`                                             //是否匿名 0-匿名，1-不匿名
+	SourceAgent        int       `gorm:"column:source_agent"`                                             //留言入口来源，1：小程序，2：pc
+	CreateTime         time.Time `gorm:"column:create_time"`                                              //创建时间
+	ModifyTime         time.Time `gorm:"column:modify_time"`                                              //修改时间
+	OldReportId        int       `gorm:"column:old_report_id"  json:"old_report_id" `                     //老报告ID
+	OldReportChapterId int       `gorm:"column:old_report_chapter_id" json:"old_report_chapter_id" `      //老报告章节ID
+	RealName           string    `gorm:"column:real_name"`                                                //留言内容
 }
 
 func (yc *YbComment) TableName() string {

models/tables/yb_community_audio_listen_log/entity.go

@@ -14,6 +14,7 @@ type YbCommunityAudioListenLog struct {
 	SellerID                 int       `gorm:"column:seller_id;type:int(11)" json:"sellerId"`
 	SourceAgent              int       `gorm:"column:source_agent;type:tinyint(4);default:1" json:"source_agent"`             // 操作来源，1：小程序，2：小程序 pc 3:弘则研究公众号，4:web pc
 	CreateTime               time.Time `gorm:"column:create_time;type:datetime;default:CURRENT_TIMESTAMP" json:"create_time"` // 创建日志时间
+	RealName                 string    `gorm:"column:real_name;type:varchar(100);not null;default:''" json:"real_name"`                //用户姓名
 }
 
 // TableName get sql table name.获取数据库表名

models/tables/yb_view_log/entity.go

@@ -0,0 +1,31 @@
+package yb_view_log
+
+import "time"
+
+// 研报访问记录表-综合各模块
+type YbViewLog struct {
+	Id            uint64    `gorm:"primaryKey;column:id" json:"id"`
+	UserId        uint64       `gorm:"column:user_id" json:"user_id"`               //用户ID
+	PrimaryId     int       `gorm:"column:primary_id" json:"primary_id"`         //访问类型对应主键ID(如：活动音频记录音频ID)
+	ExtendId      int       `gorm:"column:extend_id" json:"extend_id"`           //扩展ID(如：活动音频记录活动ID)
+	ViewType      uint8     `gorm:"column:view_type" json:"view_type"`           //访问类型：1-活动详情；2-活动音频；3-报告详情；4-报告音频；5-ETA图库；6-问答社区音频；7-价格驱动；8-语音播报详情；9-语音播报音频；10-沙盘推演；
+	Source        uint8     `gorm:"column:source" json:"source"`                 //来源：1-小程序；2-小程序PC端；3-公众号；4-Web PC端
+	FromPage      string    `gorm:"column:from_page" json:"from_page"`           //来源页面
+	ViewSeconds   uint      `gorm:"column:view_seconds" json:"view_seconds"`     //访问时长(秒)
+	QuitType      uint8     `gorm:"column:quit_type" json:"quit_type"`           //退出类型：1-正常退出；2-强制退出；
+	CreateTime    time.Time `gorm:"column:create_time" json:"create_time"`       //创建时间
+	SellerId      int       `gorm:"column:seller_id" json:"seller_id"`           //客户对应的销售ID
+	CompanyId     int64      `gorm:"column:company_id" json:"company_id"`         //客户ID
+	CompanyName   string    `gorm:"column:company_name" json:"company_name"`     //客户名称
+	CompanyStatus string    `gorm:"column:company_status" json:"company_status"` //客户状态
+	ReportId      int       `gorm:"column:report_id" json:"report_id"`           //报告ID
+	OldReportId   int       `gorm:"column:old_report_id" json:"old_report_id"`   //老报告ID
+	StopSeconds   int       `gorm:"column:stop_seconds" json:"stop_seconds"`     //停止时的秒数
+	ModifyTime    time.Time `gorm:"column:modify_time" json:"modify_time"`       //修改时间
+}
+
+// TableName get sql table name.获取数据库表名
+func (i *YbViewLog) TableName() string {
+	return "yb_view_log"
+}
+

models/tables/yb_view_log/model.go

@@ -0,0 +1,34 @@
+package yb_view_log
+
+import (
+	"hongze/hongze_yb/global"
+)
+
+func (i *YbViewLog) Create() (err error) {
+	err = global.DEFAULT_MYSQL.Create(i).Error
+	return
+}
+// Update 更新对应字段数据
+func (i *YbViewLog) Update(updateCols []string) (err error) {
+	err = global.DEFAULT_MYSQL.Model(i).Select(updateCols).Updates(*i).Error
+	return
+}
+
+type ActivityAudioLogAddReq struct {
+	PrimaryId int    `json:"primary_id" ` //访问类型对应主键ID(如：活动音频记录音频ID)
+	ExtendId  int    `json:"extend_id" `  //扩展ID(如：活动音频记录活动ID)
+	Source    uint8  `json:"source" `     //来源：1-小程序；2-小程序PC端；3-公众号；4-Web PC端
+	FromPage  string `json:"from_page"`  //来源页面
+}
+type ActivityAudioLogAddResp struct {
+	Id          uint64 `json:"id"`           //日志ID
+}
+type ActivityAudioLogStopReq struct {
+	Id          uint64 `json:"id"`           //日志ID
+	StopSeconds int    `json:"stop_seconds"` //停止时的秒数
+}
+
+func (i *YbViewLog) GetById() (item *YbViewLog, err error) {
+	err = global.DEFAULT_MYSQL.Model(i).Where("id = ?", i.Id).First(&item).Error
+	return
+}

routers/activity.go

@@ -17,6 +17,8 @@ func InitActivity(r *gin.Engine) {
 		rGroup.POST("/cancelRemind", activity.CancelRemind)
 		rGroup.POST("/registerActivity", activity.RegisterActivity)
 		rGroup.POST("/cancelRegister", activity.CancelRegister)
+		rGroup.POST("/voice_log/add", activity.AddActivityAudioLog)
+		rGroup.POST("/voice_log/update", activity.UpdateActivityAudioLog)
 	}
 	// 不需要Token
 	rGroup2 := r.Group("activity")
@@ -38,6 +40,8 @@ func initActivity(r *gin.Engine) {
 		rGroup.POST("/cancelRemind", activity.CancelRemind)
 		rGroup.POST("/registerActivity", activity.RegisterActivity)
 		rGroup.POST("/cancelRegister", activity.CancelRegister)
+		rGroup.POST("/voice_log/add", activity.AddActivityAudioLog)
+		rGroup.POST("/voice_log/update", activity.UpdateActivityAudioLog)
 	}
 	// 不需要Token
 	rGroup2 := r.Group("api/activity")

services/chart/chart_info.go

@@ -7,11 +7,13 @@ import (
 	chartEdbMappingModel "hongze/hongze_yb/models/tables/chart_edb_mapping"
 	chartInfoModel "hongze/hongze_yb/models/tables/chart_info"
 	company2 "hongze/hongze_yb/models/tables/company"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
 	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
 	"hongze/hongze_yb/models/tables/my_chart_classify"
 	"hongze/hongze_yb/models/tables/yb_chart_daily_visit_log"
 	"hongze/hongze_yb/models/tables/yb_chart_visit_log"
 	"hongze/hongze_yb/services/alarm_msg"
+	edbDataService "hongze/hongze_yb/services/edb_data"
 	"hongze/hongze_yb/services/user"
 	"hongze/hongze_yb/utils"
 	"sort"
@@ -292,6 +294,10 @@ func RefreshChart(chartInfoId int) (err error) {
 	newBaseEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)
 	baseMap := make(map[int]*edbInfoModel.EdbInfo)
 	for _, bv := range baseEdbInfoArr {
+		// 如果不是普通指标，那么过滤
+		if bv.EdbInfoType != 0 {
+			continue
+		}
 		if _, ok := baseMap[bv.EdbInfoId]; !ok {
 			newBaseEdbInfoArr = append(newBaseEdbInfoArr, bv)
 		}
@@ -392,3 +398,324 @@ func RefreshChart(chartInfoId int) (err error) {
 
 	return
 }
+
+// GetChartEdbData 获取图表的指标数据
+func GetChartEdbData(chartInfoId, chartType int, calendar, startDate, endDate string, mappingList []*chartEdbMappingModel.ChartEdbInfoMapping) (edbList []*chartEdbMappingModel.ChartEdbInfoMappingList, sourceArr []string, err error) {
+	edbList = make([]*chartEdbMappingModel.ChartEdbInfoMappingList, 0)
+	sourceArr = make([]string, 0)
+
+	for _, v := range mappingList {
+		//fmt.Println("v:", v.EdbInfoId)
+		item := new(chartEdbMappingModel.ChartEdbInfoMappingList)
+		item.EdbInfoId = v.EdbInfoId
+		item.SourceName = v.SourceName
+		item.Source = v.Source
+		item.EdbCode = v.EdbCode
+		item.EdbName = v.EdbName
+		item.EdbNameEn = v.EdbNameEn
+		item.Frequency = v.Frequency
+		item.FrequencyEn = GetFrequencyEn(v.Frequency)
+		if v.Unit != `无` {
+			item.Unit = v.Unit
+		}
+		item.UnitEn = v.UnitEn
+		item.StartDate = v.StartDate
+		item.EndDate = v.EndDate
+		item.ModifyTime = v.ModifyTime
+		item.EdbInfoCategoryType = v.EdbInfoCategoryType
+		item.PredictChartColor = v.PredictChartColor
+
+		if !utils.InArray(v.Source, utils.SystemSourceList) { //来源于系统的指标，都展示为弘则研究
+			if !utils.InArray(v.SourceName, sourceArr) {
+				sourceArr = append(sourceArr, v.SourceName)
+			}
+		}
+		if chartInfoId <= 0 {
+			item.IsAxis = 1
+			item.LeadValue = 0
+			item.LeadUnit = ""
+			item.ChartEdbMappingId = 0
+			item.ChartInfoId = 0
+			item.IsOrder = false
+			item.EdbInfoType = 1
+			item.ChartStyle = ""
+			item.ChartColor = ""
+			item.ChartWidth = 0
+			item.MaxData = v.MaxValue
+			item.MinData = v.MinValue
+		} else {
+			item.IsAxis = v.IsAxis
+			item.EdbInfoType = v.EdbInfoType
+			item.LeadValue = v.LeadValue
+			item.LeadUnit = v.LeadUnit
+			item.LeadUnitEn = GetLeadUnitEn(v.LeadUnit)
+			item.ChartEdbMappingId = v.ChartEdbMappingId
+			item.ChartInfoId = v.ChartInfoId
+			item.ChartStyle = v.ChartStyle
+			item.ChartColor = v.ChartColor
+			item.ChartWidth = v.ChartWidth
+			item.IsOrder = v.IsOrder
+			item.MaxData = v.MaxData
+			item.MinData = v.MinData
+		}
+		item.LatestValue = v.LatestValue
+		item.LatestDate = v.LatestDate
+		item.UniqueCode = v.UniqueCode
+
+		var startDateReal string
+		var diffSeconds int64
+		if chartType == 2 { //季节性图
+			startDateReal = startDate
+		} else {
+			if v.EdbInfoType == 0 && v.LeadUnit != "" && v.LeadValue > 0 { //领先指标
+				var startTimeRealTemp time.Time
+				startDateParse, _ := time.Parse(utils.FormatDate, startDate)
+				switch v.LeadUnit {
+				case "天":
+					startTimeRealTemp = startDateParse.AddDate(0, 0, -v.LeadValue)
+				case "月":
+					startTimeRealTemp = startDateParse.AddDate(0, -v.LeadValue, 0)
+				case "季":
+					startTimeRealTemp = startDateParse.AddDate(0, -3*v.LeadValue, 0)
+				case "周":
+					startTimeRealTemp = startDateParse.AddDate(0, 0, -7*v.LeadValue)
+				case "年":
+					startTimeRealTemp = startDateParse.AddDate(-v.LeadValue, 0, 0)
+				}
+				if startTimeRealTemp.Before(startDateParse) {
+					startDateReal = startTimeRealTemp.Format(utils.FormatDate)
+					diffSeconds = (int64(startTimeRealTemp.UnixNano()) - int64(startDateParse.UnixNano())) / 1e6
+				} else {
+					startDateReal = startDate
+					diffSeconds = 0
+				}
+			} else {
+				startDateReal = startDate
+			}
+		}
+		//fmt.Println("line 1011 chart:", v.Source, v.EdbInfoId, startDateReal, endDate)
+		calendarPreYear := 0
+		if calendar == "农历" {
+			newStartDateReal, err := time.Parse(utils.FormatDate, startDateReal)
+			if err != nil {
+				fmt.Println("time.Parse:" + err.Error())
+			}
+			calendarPreYear = newStartDateReal.Year() - 1
+			newStartDateReal = newStartDateReal.AddDate(-1, 0, 0)
+			startDateReal = newStartDateReal.Format(utils.FormatDate)
+		}
+		dataList := make([]*edbDataModel.EdbDataList, 0)
+		//fmt.Println("chart:", v.Source, v.EdbInfoId, startDateReal, endDate, ";EdbInfoCategoryType:", v.EdbInfoCategoryType)
+
+		switch v.EdbInfoCategoryType {
+		case 0:
+			dataList, err = edbDataModel.GetEdbDataList(v.Source, v.EdbInfoId, startDateReal, endDate)
+		case 1:
+			dataList, _, _, err, _ = GetPredictDataListByPredictEdbInfoId(v.EdbInfoId, startDateReal, endDate, false)
+		default:
+			err = errors.New(fmt.Sprint("获取失败,指标类型异常", v.EdbInfoCategoryType))
+		}
+		if err != nil {
+			return
+		}
+		if diffSeconds != 0 && v.EdbInfoType == 0 {
+			dataListLen := len(dataList)
+			for i := 0; i < dataListLen; i++ {
+				dataList[i].DataTimestamp = dataList[i].DataTimestamp - diffSeconds
+			}
+		}
+
+		if chartType == 2 {
+			latestDateStr := v.LatestDate.Format(utils.FormatDate) //实际数据的截止日期
+			latestDate := v.LatestDate
+			//latestDate, tmpErr := time.Parse(utils.FormatDate, v.LatestDate)
+			//if tmpErr != nil {
+			//	err = errors.New(fmt.Sprint("获取最后实际数据的日期失败,Err:" + tmpErr.Error() + ";LatestDate:" + v.LatestDate))
+			//	return
+			//}
+			latestDateYear := latestDate.Year() //实际数据截止年份
+
+			if calendar == "农历" {
+				if len(dataList) <= 0 {
+					result := new(edbDataModel.EdbDataResult)
+					item.DataList = result
+				} else {
+					result, tmpErr := edbDataService.AddCalculateQuarter(dataList)
+					if tmpErr != nil {
+						err = errors.New("获取农历数据失败,Err:" + tmpErr.Error())
+						return
+					}
+
+					// 处理季节图的截止日期
+					for k, edbDataItems := range result.List {
+						var cuttingDataTimestamp int64
+
+						// 切割的日期时间字符串
+						cuttingDataTimeStr := latestDate.AddDate(0, 0, edbDataItems.BetweenDay).Format(utils.FormatDate)
+						//如果等于最后的实际日期，那么遍历找到该日期对应的时间戳，并将其赋值为 切割时间戳
+						if edbDataItems.Year >= latestDateYear {
+							for _, tmpData := range edbDataItems.Items {
+								if tmpData.DataTime == cuttingDataTimeStr {
+									cuttingDataTimestamp = tmpData.DataTimestamp
+									break
+								}
+							}
+						}
+						edbDataItems.CuttingDataTimestamp = cuttingDataTimestamp
+						result.List[k] = edbDataItems
+					}
+
+					if result.List[0].Year != calendarPreYear {
+						itemList := make([]*edbDataModel.EdbDataList, 0)
+						items := new(edbDataModel.EdbDataItems)
+						//items.Year = calendarPreYear
+						items.Items = itemList
+
+						newResult := new(edbDataModel.EdbDataResult)
+						newResult.List = append(newResult.List, items)
+						newResult.List = append(newResult.List, result.List...)
+						item.DataList = newResult
+					} else {
+						item.DataList = result
+					}
+				}
+
+			} else {
+				currentYear := time.Now().Year()
+
+				quarterDataList := make([]*edbDataModel.QuarterData, 0)
+				quarterMap := make(map[int][]*edbDataModel.EdbDataList)
+				var quarterArr []int
+
+				for _, v := range dataList {
+					itemDate, tmpErr := time.Parse(utils.FormatDate, v.DataTime)
+					if tmpErr != nil {
+						err = errors.New("季度指标日期转换,Err:" + tmpErr.Error() + ";DataTime:" + v.DataTime)
+						return
+					}
+					year := itemDate.Year()
+					newItemDate := itemDate.AddDate(currentYear-year, 0, 0)
+					timestamp := newItemDate.UnixNano() / 1e6
+					v.DataTimestamp = timestamp
+					if findVal, ok := quarterMap[year]; !ok {
+						quarterArr = append(quarterArr, year)
+						findVal = append(findVal, v)
+						quarterMap[year] = findVal
+					} else {
+						findVal = append(findVal, v)
+						quarterMap[year] = findVal
+					}
+				}
+				for _, v := range quarterArr {
+					itemList := quarterMap[v]
+					quarterItem := new(edbDataModel.QuarterData)
+					quarterItem.Year = v
+					quarterItem.DataList = itemList
+
+					//如果等于最后的实际日期，那么将切割时间戳记录
+					if v == latestDateYear {
+						var cuttingDataTimestamp int64
+						for _, tmpData := range itemList {
+							if tmpData.DataTime == latestDateStr {
+								cuttingDataTimestamp = tmpData.DataTimestamp
+								break
+							}
+						}
+						quarterItem.CuttingDataTimestamp = cuttingDataTimestamp
+					} else if v > latestDateYear {
+						//如果大于最后的实际日期，那么第一个点就是切割的时间戳
+						if len(itemList) > 0 {
+							quarterItem.CuttingDataTimestamp = itemList[0].DataTimestamp - 100
+						}
+					}
+					quarterDataList = append(quarterDataList, quarterItem)
+				}
+				item.DataList = quarterDataList
+			}
+		} else {
+			item.DataList = dataList
+		}
+		edbList = append(edbList, item)
+	}
+	return
+}
+
+// 获取频度的英文版
+func GetFrequencyEn(frequency string) (frequencyEn string) {
+	switch frequency {
+	case "日度":
+		frequencyEn = "day"
+		return
+	case "周度":
+		frequencyEn = "week"
+		return
+	case "旬度":
+		frequencyEn = "ten days"
+		return
+	case "月度":
+		frequencyEn = "month"
+		return
+	case "季度":
+		frequencyEn = "quarter"
+		return
+	case "年度":
+		frequencyEn = "year"
+		return
+	}
+	return
+}
+
+func GetLeadUnitEn(unit string) (unitEn string) {
+	switch unit {
+	case "天":
+		unitEn = "day"
+		return
+	case "周":
+		unitEn = "week"
+		return
+	case "月":
+		unitEn = "month"
+		return
+	case "季":
+		unitEn = "quarter"
+		return
+	case "年":
+		unitEn = "year"
+		return
+	}
+	return
+}
+
+// ChartInfoRefreshV2 图表刷新
+// @author Roc
+// @datetime 2022-09-16 10:15:38
+// @description 将原来自己写的一套获取所有关联指标，然后刷新指标逻辑 改成  只获取使用的指标id，然后遍历去调用“指标刷新服务”
+func ChartInfoRefreshV2(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)
+		}
+	}()
+
+	edbMappingList, err := chartEdbMappingModel.GetMappingListByChartInfoId(chartInfoId)
+	if err != nil {
+		errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
+		return
+	}
+
+	edbIdList := make([]int, 0)
+	for _, v := range edbMappingList {
+		edbIdList = append(edbIdList, v.EdbInfoId)
+	}
+
+	// 批量刷新
+	err = EdbInfoRefreshAllFromBase(edbIdList, false)
+	if err != nil {
+		return
+	}
+
+	return
+}

services/chart/edb_data.go

@@ -61,6 +61,10 @@ func RefreshEdbData(edbInfoId, source int, edbCode, startDate string) (resp *Ref
 		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"
 	}
 	if urlStr == "" {
 		err = fmt.Errorf(fmt.Sprint("source:", source, ";未实现该指标的刷新接口，请联系管理员"))
@@ -124,3 +128,13 @@ func RefreshEdbCalculateData(edbInfoId int, edbCode, startDate string) (resp *Re
 	resp, err = postRefreshEdbData(param, "/calculate/refresh")
 	return
 }
+
+// RefreshPredictEdbCalculateData 刷新 预测计算指标 数据请求
+func RefreshPredictEdbCalculateData(edbInfoId int, edbCode, startDate string) (resp *RefreshResponse, err error) {
+	param := make(map[string]interface{})
+	param["EdbCode"] = edbCode
+	param["EdbInfoId"] = edbInfoId
+	param["StartDate"] = startDate
+	resp, err = postRefreshEdbData(param, "predict_calculate/refresh")
+	return
+}

services/chart/edb_info.go

@@ -0,0 +1,442 @@
+package chart
+
+import (
+	"errors"
+	"fmt"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	"hongze/hongze_yb/services/alarm_msg"
+	"hongze/hongze_yb/utils"
+	"sort"
+	"time"
+)
+
+// EdbInfoRefreshAllFromBase 全部刷新指标（切换到edb_lib服务）
+// @author Roc
+// @datetime 2022-09-16 11:04:44
+// @description 将原有的单个指标刷新，调整为批量多个指标刷新
+func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error) {
+	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, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
+	if err != nil {
+		return
+	}
+
+	var startDate string
+	for _, bv := range newBaseEdbInfoArr {
+		//source := bv.Source
+		//edbInfoId := bv.EdbInfoId
+		//edbCode := bv.EdbCode
+		if bv.StartDate.IsZero() {
+			continue
+		}
+		//开始时间
+		startDate = ``
+		if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+			startDate = bv.StartDate.Format(utils.FormatDate)
+		} else {
+			sTime := bv.EndDate
+			frequency := bv.Frequency
+			var limitDay int
+			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)
+		}
+		result, err := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now())
+			errmsg = "RefreshBaseEdbData Err:" + err.Error()
+			return err
+		}
+		if result.Ret != 200 {
+			fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			return fmt.Errorf("刷新失败, err:", errmsg)
+		}
+
+		//maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
+		//if err != nil {
+		//	if err.Error() == utils.ErrNoRow() { //找不到数据，那么就进入到下一条数据做处理
+		//		continue
+		//	}
+		//	return err
+		//}
+		//if maxAndMinItem != nil {
+		//	err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
+		//	if err != nil {
+		//		return err
+		//	}
+		//}
+		fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
+	}
+
+	//刷新相关普通计算指标
+	for _, v := range calculateArr {
+		edbInfo := newCalculateMap[v]
+		if edbInfo == nil {
+			return err
+		}
+		startDate = edbInfo.StartDate.Format(utils.FormatDate)
+		source := edbInfo.Source
+		if edbInfo.StartDate.IsZero() { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了）
+			startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
+		} else {
+			if source == utils.DATA_SOURCE_CALCULATE {
+				startDate = ``
+				if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+					startDate = edbInfo.StartDate.Format(utils.FormatDate)
+				} else {
+					sTime := edbInfo.EndDate
+					frequency := edbInfo.Frequency
+					var limitDay int
+					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)
+				}
+			}
+		}
+
+		result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
+			errmsg = "RefreshEdbCalculateData Err:" + err.Error()
+			return err
+		}
+		if result.Ret != 200 {
+			fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			return fmt.Errorf("刷新失败")
+		}
+	}
+
+	//刷新相关预测计算指标
+	for _, v := range predictCalculateArr {
+		edbInfo := newPredictCalculateMap[v]
+		if edbInfo == nil {
+			return err
+		}
+		startDate = edbInfo.StartDate.Format(utils.FormatDate)
+		source := edbInfo.Source
+		if edbInfo.StartDate.IsZero() { //如果没有开始日期，说明还没有计算出来数据，那么就往前面推40年吧（也意味着重新计算了）
+			startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
+		} else {
+			if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
+				startDate = ``
+				if refreshAll { //刷新所有数据，用开始时间作为起始日期去刷新
+					startDate = edbInfo.StartDate.Format(utils.FormatDate)
+				} else {
+					sTime := edbInfo.EndDate
+					frequency := edbInfo.Frequency
+					var limitDay int
+					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)
+				}
+			}
+		}
+
+		result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
+		if err != nil {
+			fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
+			errmsg = "RefreshPredictEdbCalculateData Err:" + err.Error()
+			return err
+		}
+		if result.Ret != 200 {
+			fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
+			return fmt.Errorf("刷新失败")
+		}
+	}
+	return err
+}
+
+// getRefreshEdbInfoList 获取待更新的指标（普通基础指标、普通运算指标，预测运算指标）
+func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr []*edbInfoModel.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*edbInfoModel.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
+	calculateList, err := edbInfoModel.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList)
+	if err != nil && err != utils.ErrNoRow {
+		err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
+		return
+	}
+	// 获取指标信息
+	edbInfoList, err := edbInfoModel.GetEdbInfoByIdList(edbInfoIdList)
+	if err != nil {
+		err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
+		return
+	}
+
+	baseEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)          // 基础普通指标
+	calculateInfoArr := make([]*edbInfoModel.EdbInfo, 0)        //基础运算指标
+	basePredictEdbInfoArr := make([]*edbInfoModel.EdbInfo, 0)   // 预测普通指标
+	predictCalculateInfoArr := make([]*edbInfoModel.EdbInfo, 0) //预测运算指标
+
+	for _, baseEdbInfo := range edbInfoList {
+		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 := edbInfoModel.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)
+				if tmpEdbInfo.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				} else {
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+		}
+		switch v.EdbInfoType {
+		case 0: //普通运算指标
+			calculateInfoArr = append(calculateInfoArr, v)
+		case 1: //预测运算指标
+			//predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			if v.EdbType == 1 { //预测普通指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
+			} else {
+				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			}
+		}
+	}
+
+	// 预测计算指标
+	for _, v := range predictCalculateInfoArr {
+		getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := edbInfoModel.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)
+				if tmpEdbInfo.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				} else {
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+		}
+
+		for _, tmpEdbInfo := range getCalculateInfoArr {
+			switch tmpEdbInfo.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
+			case 1: //预测运算指标
+				//predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				if tmpEdbInfo.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+				} else {
+					predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+				}
+			}
+		}
+		switch v.EdbInfoType {
+		case 0: //普通运算指标
+			calculateInfoArr = append(calculateInfoArr, v)
+		case 1: //预测运算指标
+			//predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			if v.EdbType == 1 { //预测普通指标
+				basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
+			} else {
+				predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+			}
+		}
+	}
+
+	// 第一次的计算指标map
+	newCalculateMap = make(map[int]*edbInfoModel.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 := edbInfoModel.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+
+		tmpCalculateList := make([]*edbInfoModel.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 := edbInfoModel.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)
+					if v.EdbType == 1 { //预测普通指标
+						basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
+					} else {
+						predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
+					}
+				}
+			}
+			switch v.EdbInfoType {
+			case 0: //普通运算指标
+				calculateInfoArr = append(calculateInfoArr, v)
+			case 1: //预测运算指标
+				//predictCalculateInfoArr = append(predictCalculateInfoArr, v)
+				if v.EdbType == 1 { //预测普通指标
+					basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
+				} else { //预测运算指标
+					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([]*edbInfoModel.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]*edbInfoModel.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
+}

services/chart/predict_edb_info.go

@@ -0,0 +1,171 @@
+package chart
+
+import (
+	"errors"
+	edbDataModel "hongze/hongze_yb/models/tables/edb_data"
+	edbInfoModel "hongze/hongze_yb/models/tables/edb_info"
+	predictEdbConfModel "hongze/hongze_yb/models/tables/predict_edb_conf"
+	"hongze/hongze_yb/utils"
+	"time"
+)
+
+// GetChartPredictEdbInfoDataList 获取图表的预测指标的未来数据
+func GetChartPredictEdbInfoDataList(predictEdbConf predictEdbConfModel.PredictEdbConf, filtrateStartDateStr, latestDateStr string, lastDataValue float64, endDateStr, frequency string) (predictEdbInfoData []*edbDataModel.EdbDataList, err error) {
+	endDate, err := time.ParseInLocation(utils.FormatDate, endDateStr, time.Local)
+	if err != nil {
+		return
+	}
+
+	latestDate, err := time.ParseInLocation(utils.FormatDate, latestDateStr, time.Local)
+	if err != nil {
+		return
+	}
+
+	// 开始预测数据的时间
+	startDate := latestDate
+
+	// 如果有筛选时间的话
+	if filtrateStartDateStr != `` {
+		filtrateStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, filtrateStartDateStr, time.Local)
+		if tmpErr != nil {
+			err = tmpErr
+			return
+		}
+		//如果筛选时间晚于实际数据时间，那么就以筛选时间作为获取预测数据的时间
+		if filtrateStartDate.After(latestDate) {
+			startDate = filtrateStartDate.AddDate(0, 0, -1)
+		}
+	}
+
+	dataValue := lastDataValue
+	if predictEdbConf.RuleType == 2 {
+		dataValue = predictEdbConf.FixedValue
+	}
+	//获取后面的预测数据
+	dayList := getPredictEdbDayList(startDate, endDate, frequency)
+	predictEdbInfoData = make([]*edbDataModel.EdbDataList, 0)
+	for k, v := range dayList {
+		predictEdbInfoData = append(predictEdbInfoData, &edbDataModel.EdbDataList{
+			EdbDataId:     int(predictEdbConf.PredictEdbInfoID) + 10000000000 + k,
+			EdbInfoId:     int(predictEdbConf.PredictEdbInfoID),
+			DataTime:      v.Format(utils.FormatDate),
+			Value:         dataValue,
+			DataTimestamp: (v.UnixNano() / 1e6) + 1000, //前端需要让加1s，说是2022-09-01 00:00:00 这样的整点不合适
+		})
+	}
+	return
+}
+
+// GetPredictEdbDayList 获取预测指标日期列表
+func getPredictEdbDayList(startDate, endDate time.Time, frequency string) (dayList []time.Time) {
+	//if !utils.InArrayByStr([]string{"日度", "周度", "月度"}, frequency)
+	switch frequency {
+	case "日度":
+		for currDate := startDate.AddDate(0, 0, 1); currDate.Before(endDate) || currDate.Equal(endDate); currDate = currDate.AddDate(0, 0, 1) {
+			//周六、日排除
+			if currDate.Weekday() == time.Sunday || currDate.Weekday() == time.Saturday {
+				continue
+			}
+			dayList = append(dayList, currDate)
+		}
+	case "周度":
+		//nextDate := startDate.AddDate(0, 0, 7)
+		for currDate := startDate.AddDate(0, 0, 7); currDate.Before(endDate) || currDate.Equal(endDate); currDate = currDate.AddDate(0, 0, 7) {
+			dayList = append(dayList, currDate)
+		}
+	case "月度":
+		for currDate := startDate; currDate.Before(endDate) || currDate.Equal(endDate); {
+			currDate = time.Date(currDate.Year(), currDate.Month(), 1, 0, 0, 0, 0, time.Now().Location()).AddDate(0, 2, -1)
+			if !currDate.After(endDate) {
+				dayList = append(dayList, currDate)
+			}
+		}
+	}
+	return
+}
+
+// GetPredictDataListByPredictEdbInfoId 根据预测指标id获取预测指标的数据
+func GetPredictDataListByPredictEdbInfoId(edbInfoId int, startDate, endDate string, isTimeBetween bool) (dataList []*edbDataModel.EdbDataList, sourceEdbInfoItem *edbInfoModel.EdbInfo, predictEdbConf *predictEdbConfModel.PredictEdbConf, err error, errMsg string) {
+	edbInfo, err := edbInfoModel.GetEdbInfoById(edbInfoId)
+	if err != nil {
+		errMsg = `获取预测指标信息失败`
+		return
+	}
+	return GetPredictDataListByPredictEdbInfo(edbInfo, startDate, endDate, isTimeBetween)
+}
+
+// GetPredictDataListByPredictEdbInfo 根据预测指标信息获取预测指标的数据
+func GetPredictDataListByPredictEdbInfo(edbInfo *edbInfoModel.EdbInfo, startDate, endDate string, isTimeBetween bool) (dataList []*edbDataModel.EdbDataList, sourceEdbInfoItem *edbInfoModel.EdbInfo, predictEdbConf *predictEdbConfModel.PredictEdbConf, err error, errMsg string) {
+	// 非计算指标，直接从表里获取数据
+	if edbInfo.EdbType != 1 {
+		if !isTimeBetween {
+			endDate = ``
+		}
+		return GetPredictCalculateDataListByPredictEdbInfo(edbInfo, startDate, endDate)
+	}
+	// 查找该预测指标配置
+	predictEdbConf, err = predictEdbConfModel.GetPredictEdbConfById(edbInfo.EdbInfoId)
+	if err != nil && err != utils.ErrNoRow {
+		errMsg = "获取预测指标配置信息失败"
+		return
+	}
+	if predictEdbConf == nil {
+		errMsg = "获取预测指标配置信息失败"
+		err = errors.New(errMsg)
+		return
+	}
+
+	// 来源指标
+	sourceEdbInfoItem, err = edbInfoModel.GetEdbInfoById(int(predictEdbConf.SourceEdbInfoID))
+	if err != nil {
+		if err == utils.ErrNoRow {
+			errMsg = "找不到来源指标信息"
+			err = errors.New(errMsg)
+		}
+		return
+	}
+
+	//获取指标数据（实际已生成）
+	dataList, err = edbDataModel.GetEdbDataList(sourceEdbInfoItem.Source, sourceEdbInfoItem.EdbInfoId, startDate, endDate)
+	if err != nil {
+		return
+	}
+
+	// 获取预测指标未来的数据
+	predictDataList := make([]*edbDataModel.EdbDataList, 0)
+
+	endDateStr := edbInfo.EndDate.Format(utils.FormatDate) //预测指标的结束日期
+
+	if isTimeBetween { //如果是时间区间，那么
+		reqEndDateTime, _ := time.ParseInLocation(utils.FormatDate, endDate, time.Local)
+		// 如果选择的时间区间结束日期 晚于 当天，那么预测数据截止到当天
+		if reqEndDateTime.Before(edbInfo.EndDate) {
+			endDateStr = endDate
+		}
+	}
+	predictDataList, err = GetChartPredictEdbInfoDataList(*predictEdbConf, startDate, sourceEdbInfoItem.LatestDate.Format(utils.FormatDate), sourceEdbInfoItem.LatestValue, endDateStr, edbInfo.Frequency)
+	if err != nil {
+		return
+	}
+	dataList = append(dataList, predictDataList...)
+	if len(predictDataList) > 0 {
+		tmpValue := predictDataList[0]
+
+		// 如果最大值 小于 预测值，那么将预测值作为最大值数据返回
+		if edbInfo.MaxValue < tmpValue.Value {
+			edbInfo.MaxValue = tmpValue.Value
+		}
+
+		// 如果最小值 大于 预测值，那么将预测值作为最小值数据返回
+		if edbInfo.MinValue > tmpValue.Value {
+			edbInfo.MinValue = tmpValue.Value
+		}
+	}
+	return
+}
+
+// GetPredictCalculateDataListByPredictEdbInfo 根据预测运算指标信息获取预测指标的数据
+func GetPredictCalculateDataListByPredictEdbInfo(edbInfo *edbInfoModel.EdbInfo, startDate, endDate string) (dataList []*edbDataModel.EdbDataList, sourceEdbInfoItem *edbInfoModel.EdbInfo, predictEdbConf *predictEdbConfModel.PredictEdbConf, err error, errMsg string) {
+	dataList, err = edbDataModel.GetEdbDataList(edbInfo.Source, edbInfo.EdbInfoId, startDate, endDate)
+	return
+}

services/comment/comment.go

@@ -48,24 +48,6 @@ func Comment(user user.UserInfo, req reqComment.ReqComment) (ret response.RespCo
 		err = errors.New("请输入报告ID")
 		return
 	}
-	// 判断是否有留言权限
-	err, errMsg = services.CheckSimpleCompanyProduct(user)
-	if err != nil {
-		return
-	}
-	//处理老报告, 转化成新报告ID
-	if req.ReportChapterId <=0 && req.ReportId <=0 && (req.OldReportId >0 || req.OldReportChapterId > 0) {
-		reportId, reportChapterId, err, errMsg = services.GetReportIdReportChapterIdByOldReportId(uint64(req.OldReportId), uint64(req.OldReportChapterId))
-		if err != nil {
-			return
-		}
-	} else {
-		// 判断报告ID是否正确
-		err, errMsg = services.CheckReportExistByReportIdReportChapterId(reportId, reportChapterId)
-		if err != nil {
-			return
-		}
-	}
 	// 敏感词过滤
 	if user.RecordInfo.OpenID != "" && user.RecordInfo.CreatePlatform == 6 {   //只有小程序的用户才能走敏感词过滤接口
 		checkResult, tErr := wx_app.MsgSecCheck(user.RecordInfo.OpenID, req.Content)
@@ -84,23 +66,43 @@ func Comment(user user.UserInfo, req reqComment.ReqComment) (ret response.RespCo
 			}
 		}
 	}
-
+	// 判断是否有留言权限
+	err, errMsg = services.CheckSimpleCompanyProduct(user)
+	if err != nil {
+		return
+	}
+	//处理老报告, 转化成新报告ID
+	if req.ReportChapterId <=0 && req.ReportId <=0 && (req.OldReportId >0 || req.OldReportChapterId > 0) {
+		reportId, reportChapterId, err, errMsg = services.GetReportIdReportChapterIdByOldReportId(uint64(req.OldReportId), uint64(req.OldReportChapterId))
+		if err != nil {
+			return
+		}
+	} else {
+		// 判断报告ID是否正确
+		err, errMsg = services.CheckReportExistByReportIdReportChapterId(reportId, reportChapterId)
+		if err != nil {
+			return
+		}
+	}
 
 	//新增留言
 	now := time.Now()
 	commentInfo := &yb_comment.YbComment{
-		UserId: user.UserID,
-		Content: req.Content,
-		ReportId: reportId,
-		ReportChapterId: reportChapterId,
-		IsShowName: req.IsShowName,
-		SourceAgent: req.SourceAgent,
-		Type: 1,
-		Enabled: 1,
-		CreateTime: now,
-		ModifyTime: now,
-		OldReportId:    req.OldReportId,
+		UserId:             user.UserID,
+		RealName:           user.RealName,
+		Content:            req.Content,
+		ReportId:           reportId,
+		ReportChapterId:    reportChapterId,
+		IsShowName:         req.IsShowName,
+		SourceAgent:        req.SourceAgent,
+		Type:               1,
+		Enabled:            1,
+		CreateTime:         now,
+		ModifyTime:         now,
+		OldReportId:        req.OldReportId,
 		OldReportChapterId: req.OldReportChapterId,
+		IsHot: 1,
+		HotTopTime: time.Now(),
 	}
 	err = commentInfo.Create()
 	if err != nil {
@@ -143,9 +145,7 @@ func Delete(user user.UserInfo, req *reqComment.ReqDel) (err error) {
 		err = errors.New("不允许删除回复")
 		return
 	}
-	if commentInfo.Enabled == 0 {
-		return
-	}
+
 	err = yb_comment.Delete(user.UserID, commentInfo.CommentId)
 	if err != nil {
 		errMsg = err.Error()

services/community/question.go

@@ -483,19 +483,22 @@ func AddAudioListenLog(userInfo user.UserInfo, audioId int, sourceAgent int) (er
 	}
 	companyName := "潜在客户"
 	companyStatus := "潜在"
+	sellerId := 0
 	if companyInfo != nil && companyInfo.CompanyID > 0 {
 		companyName = companyInfo.CompanyName
 		companyStatus = companyInfo.Status
+		sellerId = companyInfo.SellerID
 	}
 	//3. 添加点击日志
 	item := &yb_community_audio_listen_log.YbCommunityAudioListenLog{
 		CommunityQuestionAudioID: audio.CommunityQuestionAudioID,
 		CommunityQuestionID:      audio.CommunityQuestionID,
 		UserID:                   int(userInfo.UserID),
+		RealName:                 userInfo.RealName,
 		CompanyID:                int(userInfo.CompanyID),
 		CompanyName:              companyName,
 		CompanyStatus:            companyStatus,
-		SellerID:                 companyInfo.SellerID,
+		SellerID:                 sellerId,
 		SourceAgent:              sourceAgent,
 	}
 	if err = item.Create(); err != nil {

services/view_log/view_log.go

@@ -0,0 +1,91 @@
+package view_log
+
+import (
+	"errors"
+	"gorm.io/gorm"
+	"hongze/hongze_yb/models/tables/company_product"
+	"hongze/hongze_yb/models/tables/yb_activity"
+	"hongze/hongze_yb/models/tables/yb_view_log"
+	"hongze/hongze_yb/services/user"
+	"time"
+)
+
+func AddViewLog(item *yb_view_log.YbViewLog) (id uint64, err error) {
+	//查询对应的客户信息
+	companyProduct, err := company_product.GetByCompany2ProductId(item.CompanyId, 1)
+	if err != nil {
+		return
+	}
+	//增加记录
+	item.CompanyName = companyProduct.CompanyName
+	item.CompanyStatus = companyProduct.Status
+	item.SellerId = companyProduct.SellerID
+	err = item.Create()
+	if err != nil {
+		return
+	}
+	return item.Id, nil
+}
+
+func UpdateActivityAudioLog(userinfo user.UserInfo, req yb_view_log.ActivityAudioLogStopReq) (err error)  {
+	viewLog := new(yb_view_log.YbViewLog)
+	viewLog.Id = req.Id
+	item, err := viewLog.GetById()
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return
+		}
+		return
+	}
+	if item.UserId != userinfo.UserID {
+		err = errors.New("用户不一致， 更新日志失败")
+		return
+	}
+	//更新音频停止的时间
+	item.StopSeconds = req.StopSeconds
+	item.ModifyTime = time.Now()
+	err = item.Update([]string{"stop_seconds", "modify_time"})
+	return
+}
+
+func AddActivityAudioLog(userinfo user.UserInfo, req yb_view_log.ActivityAudioLogAddReq)(resp yb_view_log.ActivityAudioLogAddResp, err error)  {
+	//查询报告相关
+	var activityDetail *yb_activity.ActivityDetail
+	ybViewLog := new(yb_view_log.YbViewLog)
+	if req.ExtendId <= 0 {
+		err = errors.New("请输入活动ID")
+		return
+	}
+	//根据活动ID查询报告信息
+	activityDetail, err = yb_activity.GetDetailById(req.ExtendId)
+	if err != nil {
+		if err == gorm.ErrRecordNotFound {
+			return
+		}
+		return
+	}
+	if activityDetail.ActivityID == 0 {
+		err = errors.New("活动不存在")
+		return
+	}
+	ybViewLog.PrimaryId = req.PrimaryId
+	ybViewLog.ExtendId = activityDetail.ActivityID
+	ybViewLog.UserId = userinfo.UserID
+	ybViewLog.Source = req.Source
+	ybViewLog.FromPage = req.FromPage
+	ybViewLog.ViewType = 2
+	if activityDetail.IsNewReport == 1 {
+		ybViewLog.ReportId = activityDetail.ReportId
+	}else{
+		ybViewLog.OldReportId = activityDetail.ReportId
+	}
+	ybViewLog.CreateTime = time.Now()
+	ybViewLog.ModifyTime = time.Now()
+	ybViewLog.CompanyId = userinfo.CompanyID
+	id, err := AddViewLog(ybViewLog)
+	if err != nil {
+		return
+	}
+	resp.Id = id
+	return
+}

utils/constants.go

@@ -42,36 +42,40 @@ const (
 
 //数据来源渠道
 const (
-	DATA_SOURCE_THS                  = iota + 1 //同花顺
-	DATA_SOURCE_WIND                            //wind
-	DATA_SOURCE_PB                              //彭博
-	DATA_SOURCE_CALCULATE                       //指标运算
-	DATA_SOURCE_CALCULATE_LJZZY                 //累计值转月
-	DATA_SOURCE_CALCULATE_TBZ                   //同比值
-	DATA_SOURCE_CALCULATE_TCZ                   //同差值
-	DATA_SOURCE_CALCULATE_NSZYDPJJS             //N数值移动平均计算
-	DATA_SOURCE_MANUAL                          //手工指标
-	DATA_SOURCE_LZ                              //隆众
-	DATA_SOURCE_YS                              //有色
-	DATA_SOURCE_CALCULATE_HBZ                   //环比值->12
-	DATA_SOURCE_CALCULATE_HCZ                   //环差值->13
-	DATA_SOURCE_CALCULATE_BP                    //变频->14
-	DATA_SOURCE_GL                              //钢联->15
-	DATA_SOURCE_ZZ                              //郑商所->16
-	DATA_SOURCE_DL                              //大商所->17
-	DATA_SOURCE_SH                              //上期所->18
-	DATA_SOURCE_CFFEX                           //中金所->19
-	DATA_SOURCE_SHFE                            //上期能源->20
-	DATA_SOURCE_GIE                             //欧洲天然气->21
-	DATA_SOURCE_CALCULATE_TIME_SHIFT            //时间移位->22
-	DATA_SOURCE_CALCULATE_ZJPJ                  //直接拼接->23
-	DATA_SOURCE_CALCULATE_LJZTBPJ               //累计值同比拼接->24
-	DATA_SOURCE_LT                              //路透->25
-	DATA_SOURCE_COAL                            //中国煤炭网->26
-	DATA_SOURCE_PYTHON                          //python代码->27
-	DATA_SOURCE_PB_FINANCE                      //彭博财务数据->28
-	DATA_SOURCE_GOOGLE_TRAVEL                   //谷歌出行->29
-	DATA_SOURCE_PREDICT                         //普通预测指标->30
+	DATA_SOURCE_THS                   = iota + 1 //同花顺
+	DATA_SOURCE_WIND                             //wind
+	DATA_SOURCE_PB                               //彭博
+	DATA_SOURCE_CALCULATE                        //指标运算
+	DATA_SOURCE_CALCULATE_LJZZY                  //累计值转月
+	DATA_SOURCE_CALCULATE_TBZ                    //同比值
+	DATA_SOURCE_CALCULATE_TCZ                    //同差值
+	DATA_SOURCE_CALCULATE_NSZYDPJJS              //N数值移动平均计算
+	DATA_SOURCE_MANUAL                           //手工指标
+	DATA_SOURCE_LZ                               //隆众
+	DATA_SOURCE_YS                               //有色
+	DATA_SOURCE_CALCULATE_HBZ                    //环比值->12
+	DATA_SOURCE_CALCULATE_HCZ                    //环差值->13
+	DATA_SOURCE_CALCULATE_BP                     //变频->14
+	DATA_SOURCE_GL                               //钢联->15
+	DATA_SOURCE_ZZ                               //郑商所->16
+	DATA_SOURCE_DL                               //大商所->17
+	DATA_SOURCE_SH                               //上期所->18
+	DATA_SOURCE_CFFEX                            //中金所->19
+	DATA_SOURCE_SHFE                             //上期能源->20
+	DATA_SOURCE_GIE                              //欧洲天然气->21
+	DATA_SOURCE_CALCULATE_TIME_SHIFT             //时间移位->22
+	DATA_SOURCE_CALCULATE_ZJPJ                   //直接拼接->23
+	DATA_SOURCE_CALCULATE_LJZTBPJ                //累计值同比拼接->24
+	DATA_SOURCE_LT                               //路透->25
+	DATA_SOURCE_COAL                             //中国煤炭网->26
+	DATA_SOURCE_PYTHON                           //python代码->27
+	DATA_SOURCE_PB_FINANCE                       //彭博财务数据->28
+	DATA_SOURCE_GOOGLE_TRAVEL                    //谷歌出行->29
+	DATA_SOURCE_PREDICT                          //普通预测指标->30
+	DATA_SOURCE_PREDICT_CALCULATE                //预测指标运算->31
+	DATA_SOURCE_PREDICT_CALCULATE_TBZ            //预测指标同比值->32
+	DATA_SOURCE_PREDICT_CALCULATE_TCZ            //预测指标同差值->33
+	DATA_SOURCE_MYSTEEL_CHEMICAL                 //钢联化工->34
 )
 
 const (
@@ -158,8 +162,9 @@ const (
 )
 
 const (
-	DEFAULT_HONGZE_USER_LOGO = "https://hzstatic.hzinsights.com/static/icon/hzyb/default_avatar.png"      //个人中心默认头像、匿名用户留言默认头像
-	DEFAULT_HONGZE_SYS_LOGO  = "https://hzstatic.hzinsights.com/static/yb_wx/hongze_sys_default_head.png" //弘则官方默认头像
+	DEFAULT_HONGZE_USER_LOGO      = "https://hzstatic.hzinsights.com/static/icon/hzyb/default_avatar.png"      //个人中心默认头像、匿名用户留言默认头像
+	DEFAULT_HONGZE_USER_LOGO_GRAY = "https://hzstatic.hzinsights.com/static/icon/hzyb/default_avatar_gray.png" //默认头像-未登录状态
+	DEFAULT_HONGZE_SYS_LOGO       = "https://hzstatic.hzinsights.com/static/yb_wx/hongze_sys_default_head.png" //弘则官方默认头像
 )
 
 const (
@@ -175,20 +180,24 @@ const (
 
 // SystemSourceList 系统来源
 var SystemSourceList = []int{
-	DATA_SOURCE_CALCULATE,            //指标运算
-	DATA_SOURCE_CALCULATE_LJZZY,      //累计值转月
-	DATA_SOURCE_CALCULATE_TBZ,        //同比值
-	DATA_SOURCE_CALCULATE_TCZ,        //同差值
-	DATA_SOURCE_CALCULATE_NSZYDPJJS,  //N数值移动平均计算
-	DATA_SOURCE_MANUAL,               //手工指标
-	DATA_SOURCE_CALCULATE_HBZ,        //环比值->12
-	DATA_SOURCE_CALCULATE_HCZ,        //环差值->13
-	DATA_SOURCE_CALCULATE_BP,         //变频->14
-	DATA_SOURCE_CALCULATE_TIME_SHIFT, //时间移位->22
-	DATA_SOURCE_CALCULATE_ZJPJ,       //直接拼接->23
-	DATA_SOURCE_CALCULATE_LJZTBPJ,    //累计值同比拼接->24
-	DATA_SOURCE_PYTHON,               //python代码->27
-	DATA_SOURCE_PREDICT,              //预测指标->30
+	DATA_SOURCE_CALCULATE,             //指标运算
+	DATA_SOURCE_CALCULATE_LJZZY,       //累计值转月
+	DATA_SOURCE_CALCULATE_TBZ,         //同比值
+	DATA_SOURCE_CALCULATE_TCZ,         //同差值
+	DATA_SOURCE_CALCULATE_NSZYDPJJS,   //N数值移动平均计算
+	DATA_SOURCE_MANUAL,                //手工指标
+	DATA_SOURCE_CALCULATE_HBZ,         //环比值->12
+	DATA_SOURCE_CALCULATE_HCZ,         //环差值->13
+	DATA_SOURCE_CALCULATE_BP,          //变频->14
+	DATA_SOURCE_CALCULATE_TIME_SHIFT,  //时间移位->22
+	DATA_SOURCE_CALCULATE_ZJPJ,        //直接拼接->23
+	DATA_SOURCE_CALCULATE_LJZTBPJ,     //累计值同比拼接->24
+	DATA_SOURCE_PYTHON,                //python代码->27
+	DATA_SOURCE_PREDICT,               //预测指标->30
+	DATA_SOURCE_PREDICT_CALCULATE,     //预测指标运算->31
+	DATA_SOURCE_PREDICT_CALCULATE_TBZ, //预测指标同比值->32
+	DATA_SOURCE_PREDICT_CALCULATE_TCZ, //预测指标同差值->33
+	DATA_SOURCE_MYSTEEL_CHEMICAL,      //钢联化工->34
 }
 
 const (