eps/tcp/zz/zzConn.go

package zz

import (
	"encoding/json"
	"eps/models/statusMgr"
	"eps/tcp/mdbs"
	"eps/tcp/tc"
	"eps/tcp/tcpserver"
	"fmt"
	"github.com/astaxie/beego"
	"net"
	"reflect"
	"strings"
	"time"
	"wb/cs"
	"wb/lg"
	"wb/ut"
)

const (
	ZMethod    = "method"
	ZParams    = "params"
	ZHeartBeat = "now"
)
const (
	MLogin   = "login"
	MNowData = "nowdata"
)

type ZZConn struct {
	tc.TConn
	PosX float64
	PosY float64
}

func newZZConn(conn net.Conn) *ZZConn {
	o := ZZConn{}
	o.Typo = "ZZ"
	o.ReadBuf = make([]byte, 4096)
	o.Conn = conn
	o.StatusMgr = statusMgr.GSStatusMgr
	return &o
}
func (this *ZZConn) Read() (bs []byte, err error) {
	i, err := this.Conn.Read(this.ReadBuf)
	if err != nil {
		//this.LogError(this.Typo + " Read error:", err.Error())
		return bs, err
	} else {
		bs := this.ReadBuf[:i]
		this.LogRecv(string(bs))
		return bs, err
	}
}
func (this *ZZConn) Write(req []byte) (n int, err error) {
	n, err = this.Conn.Write(req)
	this.LogSend(string(req))
	return n, err
}
func (this *ZZConn) ParseNowData(recvMap map[string]interface{}) bool {
	//this.LogInfo("ZZConn.ParseNowData data:", recvMap)
	this.parseP(recvMap)
	this.parseBinMap(recvMap, "m_mode")
	this.parseBinMap(recvMap, "a_sd")
	this.parseBinMap(recvMap, "a_et")
	this.parseBinMap(recvMap, "a_trip")
	this.parseBinMap(recvMap, "a_trip")
	this.parseBinMap(recvMap, "a_warn")
	this.parseBinMap(recvMap, "Indica")
	this.parseBinMap(recvMap, "IO_s")
	this.parseBinMap(recvMap, "main_s")
	//this.LogInfo("status",  reflect.TypeOf(iMap)this.StatusMap["rmp"])
	//this.LogInfo("StatusMap", this.StatusMap)
	if rpm, ok := ut.Maps.GetFloat64(this.StatusMap, "rpm"); ok {
		if rpm > 0 {
			this.StatusMap["status"] = "running"
		} else {
			this.StatusMap["status"] = "online"
		}
	} else {
		this.LogError("rpm is not float64!")
	}
	if this.createAlarm() {
		this.StatusMap["status"] = "alarm"
	}
	this.StatusMgr.AddStatus(ut.Maps.Copy(this.StatusMap))
	this.parsePosition(recvMap)
	if this.PosX != 0 && this.PosY != 0 {
		this.LogInfo("[POS]:x = ", this.PosX, " y = ", this.PosY)
		this.StatusMgr.AddPosition(this.TermId, this.PosX, this.PosY)
	}
	return true
}
func (this *ZZConn) createAlarm() bool {
	has := false
	warn := ""
	for _, r := range zzWarnList {
		if v, ok := this.StatusMap[r.Key]; ok {
			if v == 1 {
				warn = warn + " " + r.Name
				has = true
			}
		}
	}
	this.StatusMap["warn"] = warn
	return has
}
func (this *ZZConn) parseP(recvMap map[string]interface{}) bool {
	pList, ok := ut.Maps.GetDeepInMap(recvMap, ZParams, "p")
	if ok {
		//lg.Debug("ZZConn.ParseNowData pList:", pList)
		rPlist, ok := pList.([]interface{})
		if !ok {
			//lg.Debug("ZZConn.ParseNowData pList: not ok", pList)
			return false
		}
		for _, rMap := range rPlist {
			//lg.Debug("ZZConn.ParseNowData rMap:", rMap)
			for k, v := range rMap.(map[string]interface{}) {
				//lg.Debug("ZZConn.ParseNowData rMap k:", k, " v:", v)
				if vStr, ok := v.(string); ok {
					valList := strings.Split(vStr, "|")
					if len(valList) == 0 {
						continue
					}
					valStr := valList[0]
					val, err := ut.StrTo(valStr).Float64()
					// 特殊处理下油压的单位换算
					if err != nil {
						//this.LogError("parse p convert to float64 error", err.Error())
						continue
					}
					if zzReg, ok := zzRegMap[k]; ok {
						this.StatusMap[zzReg.Key] = zzReg.GetValue(val)
					}
				}
			}
		}
		status := strings.TrimSpace(ut.Maps.GetStringDeepInMap(recvMap, ZParams, "status"))
		status = strings.ToLower(status)
		switch status {
		case "online":
			this.StatusMap["status"] = "online"
		default:
			this.StatusMap["status"] = "offline"
		}
		return true
	} else {
		return false
	}
}
func (this *ZZConn) parseBinMap(recvMap map[string]interface{}, mapKey string) bool {
	// 判断是否存在
	iMapList, ok := ut.Maps.GetDeepInMap(recvMap, ZParams, mapKey)
	if !ok {
		//this.LogDebug("parseBinMap mapKey not exist: ", mapKey)
		return false
	}
	// 判断是否为列表
	mapList, lok := iMapList.([]interface{})
	if !lok {
		this.LogError(mapKey, " iMapList type error:", reflect.TypeOf(iMapList))
		return false
	}
	// 循环取列表里的map
	for _, iMap := range mapList {
		// 判断列表中是否是map列表
		rMap, rok := iMap.(map[string]interface{})
		if !rok {
			this.LogError(mapKey, " iMap type error:", reflect.TypeOf(iMap))
			continue
		}
		// 取列表中的map值
		for k, v := range rMap {
			// 判断key是否已经定义
			reg, kok := zzBinMap[k]
			if !kok {
				continue
			}
			// 判断value是否为float
			fv, vok := v.(float64)
			if !vok {
				this.LogError(mapKey, "  type error:", reflect.TypeOf(v))
				continue
			}
			// 根据值设置结果
			if fv == 0 {
				this.StatusMap[reg.Key] = 0
			} else {
				this.StatusMap[reg.Key] = 1
			}
		}
	}
	return true
}
func (this *ZZConn) parsePosition(recvMap map[string]interface{}) bool {
	if longitude, ok := this.getPosition(recvMap, "longitude"); ok {
		//this.LogDebug("[POS]:x = ", this.PosX, " y = ", this.PosY)
		this.PosX = longitude
	} else {
		//this.LogDebug("[POS]: no langitude.")
	}
	if latitude, ok := this.getPosition(recvMap, "latitude"); ok {
		//this.LogDebug("[POS]:x = ", this.PosX, " y = ", this.PosY)
		this.PosY = latitude
	} else {
		//this.LogDebug("[POS]: no latitude.")
		return false
	}
	return true
}
func (this *ZZConn) getPosition(req map[string]interface{}, k string) (float64, bool) {
	pos := ut.Maps.GetStringDeepInMap(req, ZParams, k)
	if pos == "" {
		return 0, false
	}
	if p, err := ut.StrTo(pos).Float64(); err == nil {
		return p, true
	} else {
		this.LogError("getPosition", err.Error())
		return 0, false
	}
}
func (this *ZZConn) SendCmd(cmd string) {
	this.LogInfo("[CMD]:", cmd)
	var cmdStr string
	switch cmd {
	case mdbs.StartCmd:
		cmdStr = `{"deviceid":1,"cmd":4}`
		bb := []byte(cmdStr)
		bb = append(bb, 10)
		this.Write(bb)
		time.Sleep(10 * time.Second)
		cmdStr = `{"deviceid":1,"cmd":0}`
	case mdbs.StopCmd:
		cmdStr = `{"deviceid":1,"cmd":1}`
	case "test":
		cmdStr = `{"deviceid":1,"cmd":2}`
	case "auto":
		cmdStr = `{"deviceid":1,"cmd":3}`
	case "manual":
		cmdStr = `{"deviceid":1,"cmd":4}`
	case "msenable":
		cmdStr = `{"deviceid":1,"cmd":5}`
	case "msdisable":
		cmdStr = `{"deviceid":1,"cmd":5}`
	case "gsenable":
		cmdStr = `{"deviceid":1,"cmd":6}`
	case "gsdisable":
		cmdStr = `{"deviceid":1,"cmd":6}`
	case "faultreset":
		cmdStr = `{"deviceid":1,"cmd":7}`
	default:
		return
	}
	bb := []byte(cmdStr)
	bb = append(bb, 10)
	this.Write(bb)
}
func EchoFunc(conn net.Conn) {
	lg.Info("ZZ CONNECT FROM: ", conn.RemoteAddr())
	defer conn.Close()
	zzConn := newZZConn(conn)
	defer func() {
		if zzConn.TermId != "" {
			tc.DeleteConn(zzConn)
			//statusMgr.Remove(zzConn.TermId)
		}
		if err := recover(); err != nil {
			zzConn.LogError("EchoFunc panic", err)
		}
	}()
	for {
		msg, err := zzConn.Read()
		if err != nil {
			zzConn.LogInfo("ZZ EchoFunc Read error:", err.Error())
			return
		}
		var msgJson cs.MObject
		jsonErr := json.Unmarshal(msg, &msgJson)
		if jsonErr != nil {
			zzConn.LogInfo("zz.EchoFunc read json error:", jsonErr.Error())
			continue
		}
		// 判断是否为心跳包{"now":1}
		if _, ok := msgJson[ZHeartBeat]; ok {
			zzConn.Write([]byte("{\"now\":1}"))
			continue
		}
		method := msgJson.GetString(ZMethod)
		switch msgJson.GetString(ZMethod) {
		case MLogin:
			retBs := createLoginResp()
			zzConn.Write(retBs)
			return
		case MNowData:
			if zzConn.TermId == "" {
				if termId := msgJson.GetTrimStringDeep(ZParams, "hostid"); termId != "" {
					zzConn.Init(termId)
					zzConn.StatusMap = zzConn.StatusMgr.GetDefaultStatusMap(termId)
					tc.AddMConn(zzConn)
				} else {
					continue
				}
			}
			if packetnum, nok := msgJson.GetInt64Deep(ZParams, "packetnum"); nok {
				zzConn.LogDebug("ZZ EchoFunc get packetnum:", packetnum)
				retBs := createSuccessResp(packetnum)
				zzConn.Write(retBs)
				zzConn.ParseNowData(msgJson)
			} else {
				zzConn.LogError("ZZ EchoFunc get packetnum error")
			}
		default:
			zzConn.LogInfo("Recv other msg", method)
		}
	}
}
func createLoginResp() []byte {
	bs := fmt.Sprintf(`{"result":{"register":1,"liveData":"%s","UTC":%v},"retcode":"000000"}`, ZZLivedata, time.Now().Unix())
	bb := []byte(bs)
	bb = append(bb, 10)
	return bb
}
func createSuccessResp(packetnum int64) []byte {
	str := fmt.Sprintf(`{"message":"ok","retcode":"000000","packetnum":%v}`, packetnum)
	bb := []byte(str)
	return append(bb, 10)
}

var (
	ZZPort     string
	ZZLivedata string
)

func init() {
	ZZLivedata = beego.AppConfig.String("zzlivedata")
	ZZPort = beego.AppConfig.String("zzport")
}
func ServerRun() {
	server.Run(ZZPort, EchoFunc)
}