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 := reader.ReadBytes('\n')
		//if err != nil {
		//	fmt.Println("客户端已断开连接:", err)
		//	break
		//}
		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":
			// 处理 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
			}
			// 广播 OTA 消息
			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
			}
			// 广播 OTA 消息
			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
			}
			// 广播 OTA 消息
			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
			}
			// 广播 OTA 消息
			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)

	//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 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
}