elevator-server/tcpserver/handler.go

package tcpserver

import (
	"DT/repository"
	"DT/ws"
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net"
	"strings"
	"time"
)

type TCPHandler struct {
	Server *Server
	Hub    *ws.Hub
}

func (h *TCPHandler) HandleClient(conn net.Conn) {
	reader := bufio.NewReader(conn)
	clientID := conn.RemoteAddr().String()
	var client *Client
	if value, ok := h.Server.GetClient(clientID); ok {
		client = value
	} else {
		fmt.Println("找不到客户端:", clientID)
		return
	}

	broadcastMessage := func(data []byte) {
		if h.Hub != nil {
			h.Hub.Broadcast <- &ws.WsMessage{IMEI: client.Imei, Data: string(data)}
		}
	}

	for {
		message, err := readUntilDelimiter(reader, []byte("\r\n"))
		if err != nil {
			fmt.Println("Error reading message:", err)
			break
		}

		message = bytes.TrimSpace(message)
		output := strings.ReplaceAll(string(message), "\t", "")
		output = strings.ReplaceAll(output, "\n", "")
		message = []byte(output)
		fmt.Printf("收到消息来自 %s: %s\n", conn.RemoteAddr(), message)
		if !json.Valid(message) {
			fmt.Printf("来自客户端的数据非法 %s\n", conn.RemoteAddr())
			conn.Close()
			return
		}

		var fullMsg map[string]interface{}
		if err := json.Unmarshal(message, &fullMsg); err != nil {
			fmt.Printf("Error parsing message: %v\n", err)
			continue
		}

		msgType, _ := fullMsg["Type"].(string)
		if msgType == "" {
			fmt.Printf("接收到的消息类型为空 %s\n", conn.RemoteAddr())
			conn.Close()
			return
		}

		switch msgType {
		case "reg":
			if err := h.Server.HandleAuth(client, message); err != nil {
				fmt.Printf("客户端授权失败: %v\n", err)
				conn.Close()
				return
			}
			fmt.Printf("客户端已授权: %s\n", client.Imei)
			broadcastMessage(message)

		case "ping":
			if !client.IsAuth {
				fmt.Printf("来自未授权客户端的心跳 %s\n", conn.RemoteAddr())
				conn.Close()
				return
			}
			if err := h.Server.HandleHeartbeat(client, message); err != nil {
				fmt.Printf("心跳错误: %v\n", err)
				continue
			}
			broadcastMessage(message)

		case "ota":
			if !client.IsAuth {
				fmt.Printf("来自未授权客户端的消息 %s\n", conn.RemoteAddr())
				conn.Close()
				return
			}
			if err := h.Server.HandleOta(client, message); err != nil {
				fmt.Printf("OTA 错误: %v\n", err)
				continue
			}
			broadcastMessage(message)

		case "start":
			if !client.IsAuth {
				fmt.Printf("来自未授权客户端的消息 %s\n", conn.RemoteAddr())
				conn.Close()
				return
			}
			if err := h.Server.RealTimeReporting(client, message); err != nil {
				fmt.Printf("OTA 错误: %v\n", err)
				continue
			}
			broadcastMessage(message)

		case "stop":
			if !client.IsAuth {
				fmt.Printf("来自未授权客户端的消息 %s\n", conn.RemoteAddr())
				conn.Close()
				return
			}
			if err := h.Server.StopRealTimeReporting(client, message); err != nil {
				fmt.Printf("客户端停止实时上报数据 错误: %v\n", err)
				continue
			}
			broadcastMessage(message)

		case "up":
			if !client.IsAuth {
				fmt.Printf("来自未授权客户端的消息 %s\n", conn.RemoteAddr())
				conn.Close()
				return
			}
			if err := h.Server.TimingReporting(client, message); err != nil {
				fmt.Printf("客户端定时上报数据 错误: %v\n", err)
				continue
			}
			broadcastMessage(message)

		default:
			if !client.IsAuth {
				fmt.Printf("来自未授权客户端的消息 %s\n", conn.RemoteAddr())
				conn.Close()
				return
			}
			broadcastMessage(message)
		}
	}
}

func (s *Server) HandleHeartbeat(client *Client, message []byte) error {
	if !client.IsAuth {
		return fmt.Errorf("unauthorized")
	}

	var msg Message
	if err := json.Unmarshal(message, &msg); err != nil {
		return err
	}

	if msg.Type == "ping" {
		client.LastPing = time.Now()
		response := Message{
			MessageType: MessageType{Type: "pong"},
		}

		responseData, err := json.Marshal(response)
		if err != nil {
			return err
		}
		_, err = client.Conn.Write(append(responseData, '\r', '\n'))
		return err
	}
	return nil
}

func (s *Server) HandleAuth(client *Client, message []byte) error {
	var msg Message
	if err := json.Unmarshal(message, &msg); err != nil {
		return err
	}
	if msg.Type != "reg" {
		return fmt.Errorf("unauthorized")
	}

	model, err := repository.GroupRepositorys.Device.GetDevice(map[string]interface{}{"imei": msg.Imei})
	if err != nil {
		return fmt.Errorf("设备不存在")
	}
	if msg.Pwd != model.DriverPass {
		return fmt.Errorf("设备密码不正确")
	}

	model.DriverVer = msg.Ver
	err = repository.GroupRepositorys.Device.UpdateDevice(model)
	if err != nil {
		return fmt.Errorf("更新设备版本号失败")
	}

	if client.authTimer != nil {
		client.authTimer.Stop()
		client.authTimer = nil
	}

	client.Imei = msg.Imei
	client.IsAuth = true

	response := Message{
		MessageType: MessageType{Type: "reg"},
		MessageTime: MessageTime{Time: time.Now().Unix()},
	}
	responseData, err := json.Marshal(response)
	if err != nil {
		return err
	}

	_, err = client.Conn.Write(append(responseData, '\r', '\n'))
	return err
}

func (s *Server) HandleOta(client *Client, message []byte) error {
	var msg Message
	if err := json.Unmarshal(message, &msg); err != nil {
		return err
	}
	if msg.Type != "ota" {
		return fmt.Errorf("unauthorized")
	}
	fmt.Printf("设备升级结果：%s\r\n", msg.State)
	return nil
}

func (s *Server) RealTimeReporting(client *Client, message []byte) error {
	var msg Message
	if err := json.Unmarshal(message, &msg); err != nil {
		return err
	}
	if msg.Type != "start" {
		return fmt.Errorf("unauthorized")
	}
	fmt.Printf("设备实时上报数据：%v\r\n", msg)
	return nil
}

func (s *Server) StopRealTimeReporting(client *Client, message []byte) error {
	var msg Message
	if err := json.Unmarshal(message, &msg); err != nil {
		return err
	}
	if msg.Type != "stop" {
		return fmt.Errorf("unauthorized")
	}
	fmt.Printf("设备停止实时上报数据：%s\r\n", msg.State)
	return nil
}

// TimingReporting 定时上报数据
func (s *Server) TimingReporting(client *Client, message []byte) error {
	var msg Message
	if err := json.Unmarshal(message, &msg); err != nil {
		return err
	}
	if msg.Type != "up" {
		return fmt.Errorf("unauthorized")
	}
	fmt.Printf("设备定时上报数据：%v\r\n", msg.MessageData)
	return nil
}