You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
429 lines
12 KiB
429 lines
12 KiB
package consumers
|
|
|
|
import (
|
|
"bytes"
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"goInOut/dbOperate"
|
|
"goInOut/models"
|
|
"io"
|
|
"log"
|
|
"math/rand"
|
|
"net/http"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/goccy/go-json"
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// 配置结构体
|
|
type DeepExcavationConfig struct {
|
|
Address []string `yaml:"address"`
|
|
Index string `yaml:"index"`
|
|
UserName string `yaml:"userName"`
|
|
Password string `yaml:"password"`
|
|
URL string `yaml:"url"`
|
|
Time int `yaml:"time"`
|
|
Secret string `yaml:"secret"`
|
|
ProjectId string `yaml:"projectId"`
|
|
Appid string `yaml:"appid"`
|
|
ProgramCode string `yaml:"programCode"`
|
|
ProgramName string `yaml:"programName"`
|
|
}
|
|
|
|
// 深层水平位移数据结构
|
|
type DeepHorDisList struct {
|
|
Depth int `json:"depth"`
|
|
DepthValue float64 `json:"depthValue"`
|
|
DepthInitValue float64 `json:"depthInitValue"`
|
|
RateChange float64 `json:"rateChange"`
|
|
}
|
|
|
|
// 输出数据结构
|
|
type DeepExcavationData struct {
|
|
ProjectId string `json:"projectId"`
|
|
ProgramCode string `json:"programCode"`
|
|
ProgramName string `json:"programName"`
|
|
PointName string `json:"pointName"`
|
|
PointId string `json:"pointId"`
|
|
PointType string `json:"pointType"`
|
|
PointTypeName string `json:"pointTypeName"`
|
|
Unit string `json:"unit"`
|
|
AlarmValue float64 `json:"alarmValue"`
|
|
ControlValue float64 `json:"controlValue"`
|
|
DeviceId string `json:"deviceId"`
|
|
Variation float64 `json:"variation"`
|
|
AggregateValue float64 `json:"aggregateValue"`
|
|
RateChange float64 `json:"rateChange"`
|
|
InitValue float64 `json:"initValue"`
|
|
Value float64 `json:"value"`
|
|
AlarmStatus int `json:"alarmStatus"`
|
|
EventTime string `json:"eventTime"`
|
|
DeepHorDisList *DeepHorDisList `json:"deepHorDisList,omitempty"`
|
|
}
|
|
|
|
type consumerESDeepExcavation struct {
|
|
Info DeepExcavationConfig
|
|
EsHelper dbOperate.ESHelper
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) Initial(configStr string) error {
|
|
c.LoadConfigJson(configStr)
|
|
return c.outputInitial()
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) LoadConfigJson(cfgStr string) {
|
|
err := yaml.Unmarshal([]byte(cfgStr), &c.Info)
|
|
if err != nil {
|
|
log.Printf("读取配置文件[%s]异常 err=%v", cfgStr, err.Error())
|
|
panic(err)
|
|
}
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) outputInitial() error {
|
|
c.EsHelper = *dbOperate.NewESHelper(
|
|
c.Info.Address,
|
|
c.Info.UserName,
|
|
c.Info.Password,
|
|
)
|
|
return nil
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) Work() {
|
|
for {
|
|
queryStr := c.getESQueryStr()
|
|
log.Printf("ES查询语句: %s", queryStr)
|
|
|
|
hits := c.EsHelper.SearchLastThemes(c.Info.Index, queryStr)
|
|
log.Printf("查询到 %d 条数据", len(hits))
|
|
|
|
var dataList []DeepExcavationData
|
|
for _, hit := range hits {
|
|
data := c.transformData(hit.Source)
|
|
if data != nil {
|
|
dataList = append(dataList, *data)
|
|
}
|
|
}
|
|
|
|
if len(dataList) > 0 {
|
|
for i, data := range dataList {
|
|
err := c.sendData(data)
|
|
if err != nil {
|
|
log.Printf("发送第 %d 条数据失败: %v", i+1, err)
|
|
} else {
|
|
log.Printf("成功发送第 %d 条数据", i+1)
|
|
}
|
|
}
|
|
}
|
|
|
|
time.Sleep(time.Duration(c.Info.Time) * time.Minute)
|
|
}
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) getESQueryStr() string {
|
|
sensors := []string{
|
|
"71351", "69396", "69397", "69407", "69398", "69400", "69401", "69402", "69420", "69403",
|
|
"69404", "69405", "69408", "69409", "69410", "69411", "69412", "69413", "69425", "69423",
|
|
"69421", "69419", "69418", "69399", "69414", "69406", "69415", "69417", "69533", "69534",
|
|
"69458", "69459", "69460", "69461", "69462", "69463", "69556", "69521", "69522", "69523",
|
|
"69524", "69525", "69526", "69527", "69528", "69529", "69464", "69532", "69520", "69539",
|
|
"69540", "69541", "69542", "69543", "69544", "69545", "69546", "69547", "69538", "69537",
|
|
"69536", "69535", "69457", "69456", "69549", "69647", "69550", "69645", "69646", "69555",
|
|
"69640", "69644", "69643", "69551", "69552", "69553", "69554", "69639", "69671", "69642",
|
|
"69676", "69677", "69678", "69641", "69670", "69638", "69981", "69975", "69969", "69977",
|
|
"69980", "69976", "69978", "69979", "69974", "69973", "69968", "69970", "69971", "69972",
|
|
"70000", "70001", "70002", "70003", "70004", "70013", "70014", "70015", "70016", "70017",
|
|
"69999", "69997", "69998", "69416", "70096", "70097", "70098", "70243", "70244", "70245",
|
|
"70246", "70247", "70403", "70404", "70691", "70692", "71006", "71007", "71008", "73275",
|
|
"73276", "73277", "73278", "73279", "73280", "73281", "73282",
|
|
}
|
|
|
|
sensorStr := "\"" + strings.Join(sensors, "\",\"") + "\""
|
|
|
|
return fmt.Sprintf(`{
|
|
"size": 1000,
|
|
"query": {
|
|
"bool": {
|
|
"must": [
|
|
{
|
|
"terms": {
|
|
"sensor": [%s]
|
|
}
|
|
}
|
|
]
|
|
}
|
|
}
|
|
}`, sensorStr)
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) transformData(theme models.EsTheme) *DeepExcavationData {
|
|
switch theme.Factor {
|
|
case 52:
|
|
return c.transformFactor52(theme)
|
|
case 33:
|
|
return c.transformFactor33(theme)
|
|
case 31:
|
|
return c.transformFactor31(theme)
|
|
default:
|
|
log.Printf("未知的factor值: %d", theme.Factor)
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// factor=52: 深层水平位移
|
|
func (c *consumerESDeepExcavation) transformFactor52(theme models.EsTheme) *DeepExcavationData {
|
|
pointId := strconv.Itoa(theme.Sensor)
|
|
pointName := theme.SensorName
|
|
deviceId := "QDXXGBYY" + pointId
|
|
eventTime := formatEventTime(theme.CollectTime)
|
|
|
|
x := getFloatFromData(theme.Data, "x")
|
|
xTotal := getFloatFromData(theme.Data, "xTotal")
|
|
y := getFloatFromData(theme.Data, "y")
|
|
|
|
// 从sensor_name中提取深度值
|
|
depth := extractDepthFromSensorName(pointName)
|
|
|
|
depthValue := x
|
|
depthInitValue := depthValue + randFloat(-2, 2)
|
|
depthRateChange := depthValue / 1
|
|
|
|
variation := x
|
|
aggregateValue := xTotal
|
|
rateChange := variation / 1
|
|
initValue := variation + randFloat(-2, 2)
|
|
value := y
|
|
|
|
return &DeepExcavationData{
|
|
ProjectId: c.Info.ProjectId,
|
|
ProgramCode: c.Info.ProgramCode,
|
|
ProgramName: c.Info.ProgramName,
|
|
PointName: pointName,
|
|
PointId: pointId,
|
|
PointType: "deepHorDis",
|
|
PointTypeName: "深层水平位移",
|
|
Unit: "mm",
|
|
AlarmValue: 400.0,
|
|
ControlValue: 360.0,
|
|
DeviceId: deviceId,
|
|
Variation: roundFloat(variation, 2),
|
|
AggregateValue: roundFloat(aggregateValue, 2),
|
|
RateChange: roundFloat(rateChange, 2),
|
|
InitValue: roundFloat(initValue, 2),
|
|
Value: roundFloat(value, 2),
|
|
AlarmStatus: 0,
|
|
EventTime: eventTime,
|
|
DeepHorDisList: &DeepHorDisList{
|
|
Depth: depth,
|
|
DepthValue: roundFloat(depthValue, 2),
|
|
DepthInitValue: roundFloat(depthInitValue, 2),
|
|
RateChange: roundFloat(depthRateChange, 2),
|
|
},
|
|
}
|
|
}
|
|
|
|
// factor=33: 锚索轴力
|
|
func (c *consumerESDeepExcavation) transformFactor33(theme models.EsTheme) *DeepExcavationData {
|
|
pointId := strconv.Itoa(theme.Sensor)
|
|
pointName := theme.SensorName
|
|
deviceId := "QDXXGBYY" + pointId
|
|
eventTime := formatEventTime(theme.CollectTime)
|
|
|
|
force := getFloatFromData(theme.Data, "force")
|
|
|
|
variation := force + randFloat(-2, 2)
|
|
aggregateValue := force / 0.98
|
|
rateChange := variation / 1
|
|
initValue := variation + randFloat(-2, 2)
|
|
value := force
|
|
|
|
return &DeepExcavationData{
|
|
ProjectId: c.Info.ProjectId,
|
|
ProgramCode: c.Info.ProgramCode,
|
|
ProgramName: c.Info.ProgramName,
|
|
PointName: pointName,
|
|
PointId: pointId,
|
|
PointType: "axisforceCab",
|
|
PointTypeName: "锚索轴力",
|
|
Unit: "kn",
|
|
AlarmValue: 5250.0,
|
|
ControlValue: 4725.0,
|
|
DeviceId: deviceId,
|
|
Variation: roundFloat(variation, 2),
|
|
AggregateValue: roundFloat(aggregateValue, 2),
|
|
RateChange: roundFloat(rateChange, 2),
|
|
InitValue: roundFloat(initValue, 2),
|
|
Value: roundFloat(value, 2),
|
|
AlarmStatus: 0,
|
|
EventTime: eventTime,
|
|
}
|
|
}
|
|
|
|
// factor=31: 地下水位
|
|
func (c *consumerESDeepExcavation) transformFactor31(theme models.EsTheme) *DeepExcavationData {
|
|
pointId := strconv.Itoa(theme.Sensor)
|
|
pointName := theme.SensorName
|
|
deviceId := "QDXXGBYY" + pointId
|
|
eventTime := formatEventTime(theme.CollectTime)
|
|
|
|
force := getFloatFromData(theme.Data, "force")
|
|
waterLevel := getFloatFromData(theme.Data, "waterLevel")
|
|
|
|
variation := force + randFloat(-1, 1)
|
|
aggregateValue := waterLevel / 0.98
|
|
rateChange := variation / 1
|
|
initValue := variation + randFloat(-1, 1)
|
|
value := waterLevel
|
|
|
|
return &DeepExcavationData{
|
|
ProjectId: c.Info.ProjectId,
|
|
ProgramCode: c.Info.ProgramCode,
|
|
ProgramName: c.Info.ProgramName,
|
|
PointName: pointName,
|
|
PointId: pointId,
|
|
PointType: "froundLev",
|
|
PointTypeName: "地下水位",
|
|
Unit: "mm",
|
|
AlarmValue: 1000.0,
|
|
ControlValue: 900.0,
|
|
DeviceId: deviceId,
|
|
Variation: roundFloat(variation, 2),
|
|
AggregateValue: roundFloat(aggregateValue, 2),
|
|
RateChange: roundFloat(rateChange, 2),
|
|
InitValue: roundFloat(initValue, 2),
|
|
Value: roundFloat(value, 2),
|
|
AlarmStatus: 0,
|
|
EventTime: eventTime,
|
|
}
|
|
}
|
|
|
|
func (c *consumerESDeepExcavation) sendData(data DeepExcavationData) error {
|
|
// 生成签名
|
|
sign := generateSign(c.Info.Secret, c.Info.Appid, c.Info.ProjectId)
|
|
|
|
// 拼接URL
|
|
fullURL := fmt.Sprintf("%s?appid=%s&projectId=%s&sign=%s",
|
|
c.Info.URL, c.Info.Appid, c.Info.ProjectId, sign)
|
|
|
|
// 序列化数据（每个请求只发送一个数据，包装成数组）
|
|
bodyBytes, err := json.Marshal([]DeepExcavationData{data})
|
|
if err != nil {
|
|
return fmt.Errorf("序列化数据失败: %v", err)
|
|
}
|
|
|
|
log.Printf("发送HTTP请求: %s", fullURL)
|
|
log.Printf("请求体: %s", string(bodyBytes))
|
|
|
|
// 创建HTTP请求
|
|
req, err := http.NewRequest("POST", fullURL, bytes.NewReader(bodyBytes))
|
|
if err != nil {
|
|
return fmt.Errorf("创建HTTP请求失败: %v", err)
|
|
}
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{
|
|
Timeout: 2 * time.Minute,
|
|
}
|
|
resp, err := client.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("发送请求失败: %v", err)
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
responseBody, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return fmt.Errorf("读取响应失败: %v", err)
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return fmt.Errorf("请求失败，状态码: %d, 响应: %s", resp.StatusCode, string(responseBody))
|
|
}
|
|
|
|
log.Printf("请求成功! 响应: %s", string(responseBody))
|
|
return nil
|
|
}
|
|
|
|
// 生成签名
|
|
func generateSign(secret, appid, projectId string) string {
|
|
// 连接字符串: secret + "appid" + appid + "projectId" + projectId + secret
|
|
rawStr := secret + "appid" + appid + "projectId" + projectId + secret
|
|
|
|
// MD5加密
|
|
hash := md5.Sum([]byte(rawStr))
|
|
return strings.ToUpper(hex.EncodeToString(hash[:]))
|
|
}
|
|
|
|
// 格式化事件时间（加8小时）
|
|
func formatEventTime(collectTime string) string {
|
|
if collectTime == "" {
|
|
return time.Now().Add(8 * time.Hour).Format("2006-01-02 15:04:00")
|
|
}
|
|
|
|
// 尝试解析多种格式
|
|
formats := []string{
|
|
"2006-01-02T15:04:05",
|
|
"2006-01-02T15:04:05Z",
|
|
"2006-01-02 15:04:05",
|
|
"2006/01/02 15:04:05",
|
|
}
|
|
|
|
for _, format := range formats {
|
|
t, err := time.Parse(format, collectTime)
|
|
if err == nil {
|
|
return t.Add(8 * time.Hour).Format("2006-01-02 15:04:00")
|
|
}
|
|
}
|
|
|
|
// 默认返回当前时间加8小时
|
|
return time.Now().Add(8 * time.Hour).Format("2006-01-02 15:04:00")
|
|
}
|
|
|
|
// 从sensor_name中提取深度值（_后面的数字，取负数）
|
|
func extractDepthFromSensorName(sensorName string) int {
|
|
parts := strings.Split(sensorName, "-")
|
|
if len(parts) >= 2 {
|
|
depth, err := strconv.Atoi(parts[len(parts)-1])
|
|
if err == nil {
|
|
return -depth
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// 从data map中获取float值
|
|
func getFloatFromData(data map[string]any, key string) float64 {
|
|
if val, ok := data[key]; ok && val != nil {
|
|
switch v := val.(type) {
|
|
case float64:
|
|
return v
|
|
case float32:
|
|
return float64(v)
|
|
case int:
|
|
return float64(v)
|
|
case int64:
|
|
return float64(v)
|
|
case string:
|
|
if f, err := strconv.ParseFloat(v, 64); err == nil {
|
|
return f
|
|
}
|
|
}
|
|
}
|
|
return 0.0
|
|
}
|
|
|
|
// 生成随机浮点数
|
|
func randFloat(min, max float64) float64 {
|
|
return min + rand.Float64()*(max-min)
|
|
}
|
|
|
|
// 保留两位小数
|
|
func roundFloat(f float64, places int) float64 {
|
|
shift := float64(1)
|
|
for i := 0; i < places; i++ {
|
|
shift *= 10
|
|
}
|
|
return float64(int(f*shift+0.5)) / shift
|
|
}
|
|
|