dy-admin-temp/internal/pcmserver/bus/cabinet_pkg/service.go

package cabinet_pkg

import (
	"dy-admin/internal/pcmserver/bus/cabinet_pkg/dataProto"
	"dy-admin/internal/pcmserver/bus/model"
	"dy-admin/internal/pcmserver/global"
	"dy-admin/internal/pcmserver/pkg/code"
	"dy-admin/pkg/log"
	"dy-admin/pkg/rescode"
	"encoding/hex"
	"fmt"
	"go.uber.org/zap"
	"strings"
	"time"
)

// AddCabinet 添加柜子
// info 柜子基础信息
// cabinetConnectChan 柜子连接状态
// gridStatusChan 柜子所有格子状态回传通道
func AddCabinet(cabinetInfo model.Cabinet, cabinetConnectChan chan<- *dataProto.CabinetConnect,
	gridStatusChan chan<- *dataProto.GridStatsProto, openStatusChan chan<- *dataProto.GridLockStatusProto) error {
	if cabinets == nil {
		return fmt.Errorf("cabinets is nil")
	}

	cb := newCabinet(cabinetInfo, cabinetConnectChan, gridStatusChan, openStatusChan)
	cabinets.setCabinet(cabinetInfo.ID, cb)

	return nil
}

// DelCabinet 删除柜子
func DelCabinet(cabinetId int) error {
	if cabinets == nil {
		return fmt.Errorf("cabinets is nil")
	}

	cab, exists := cabinets.getCabinet(cabinetId)
	if !exists {
		return nil
	}
	if cab != nil {
		if cab.conn != nil {
			err := cab.conn.Close()
			if err != nil {
				return err
			}
		}
	}
	cabinets.deleteCabinet(cabinetId)

	return nil
}

func cabinetPreCheck(cabinetId int) (*cabinet, error) {
	if cabinets == nil {
		return nil, fmt.Errorf("cabinets is nil")
	}
	cab, ok := cabinets.getCabinet(cabinetId)
	if !ok {
		err := fmt.Errorf("cabinetID %d not found", cabinetId)
		return nil, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetMemNotFoundCode])
	}

	if !cab.memInfo.IsConnect {
		err := fmt.Errorf("cabinetID %d not connected", cabinetId)
		return nil, rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetNotConnectCode])
	}

	return cab, nil
}

func SetCabinetNumber(cabinetId int) error {
	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}
	ccp := &dataProto.CabinetConfigProto{
		PkgLength:        dataProto.PkgLengthCabinetConfig,
		StartSymbol:      dataProto.StartSymbolCabinetConfig,
		Cmd:              dataProto.CmdCabinetConfig,
		CabinetNumber:    cab.memInfo.CabinetNum,
		CabinetGridCount: cab.memInfo.GridCount,
		CRCCode:          0x1DC0,
	}
	encodeBytes, err := dataProto.CabinetConfigProtoEncode(ccp)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}
	tcpServer.WriteData(cab.conn, encodeBytes)

	// 记录下发设置柜子编号指令
	deviceLogChan <- &MsgLog{
		CabinetID: cabinetId,
		MsgType:   model.MsgTypeSend,
		MsgName:   "设置柜子编号指令",
		Message:   encodeBytes,
	}

	err = waitCabinetConfigResponse(cab.responseChannels.cabinetConfigResChannel, cab.memInfo.CabinetNum, 10)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetTimeoutCode])
	}

	return nil
}

// EnableOpenDoor 允许开门
func EnableOpenDoor(cabinetId int, uptMem bool) error {

	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}

	if !IsHumanization() {
		// 强制管理 下发允许开门指令
		controlProto := &dataProto.DoorControlProto{
			PkgLength:     dataProto.PkgLengthDoorControl,
			StartSymbol:   dataProto.StartSymbolDoorControl,
			CabinetNumber: cab.memInfo.CabinetNum,
			Cmd:           dataProto.CmdDoorControlEnable,
		}
		controlProtoBytes, err := dataProto.DoorControlProtoEncode(controlProto)
		if err != nil {
			tips := fmt.Sprintf("cabinetId:%d", cabinetId)
			return rescode.RegisterErrorWithMessage(err, tips, code.ErrCodeMap[code.ErrCabinetDeviceCode])
		}

		//发送
		tcpServer.WriteData(cab.conn, controlProtoBytes)

		// 记录下发允许开门指令
		deviceLogChan <- &MsgLog{
			CabinetID: cabinetId,
			MsgType:   model.MsgTypeSend,
			MsgName:   "允许开门指令",
			Message:   controlProtoBytes,
		}

		err = waitDoorControlResponse(cab.responseChannels.doorControlResChannel, dataProto.CmdDoorControlEnable, 10)
		if err != nil {
			tips := fmt.Sprintf("cabinetId:%d", cabinetId)
			return rescode.RegisterErrorWithMessage(err, tips, code.ErrCodeMap[code.ErrCabinetTimeoutCode])
		}
	}

	//更新内存柜子信息未允许开启状态
	if uptMem {
		cab.memInfo.IsAllowOpen = true
	}

	// 发送获取柜子所有消息的指令
	go func() {
		// 柜子要求.发送禁止柜门后1分钟后再获取状态。
		time.Sleep(time.Second * 60)
		err = GetCabinetStatus(cabinetId)
		if err != nil {
			log.Error("获取柜门信息失败", zap.Error(err))
		}
	}()

	return nil
}

// DisableOpenDoor  禁止打开所有柜门
func DisableOpenDoor(cabinetId int) error {

	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}

	if !IsHumanization() {
		// 强制管理

		controlProto := &dataProto.DoorControlProto{
			PkgLength:     dataProto.PkgLengthDoorControl,
			StartSymbol:   dataProto.StartSymbolDoorControl,
			CabinetNumber: cab.memInfo.CabinetNum,
			Cmd:           dataProto.CmdDoorControlDisable,
		}
		controlProtoBytes, err := dataProto.DoorControlProtoEncode(controlProto)
		if err != nil {
			tips := fmt.Sprintf("cabinetId:%d", cabinetId)
			return rescode.RegisterErrorWithMessage(err, tips, code.ErrCodeMap[code.ErrCabinetDeviceCode])
		}

		//发送
		tcpServer.WriteData(cab.conn, controlProtoBytes)

		// 记录下发禁止开门指令
		deviceLogChan <- &MsgLog{
			CabinetID: cabinetId,
			MsgType:   model.MsgTypeSend,
			MsgName:   "禁止开门指令",
			Message:   controlProtoBytes,
		}

		err = waitDoorControlResponse(cab.responseChannels.doorControlResChannel, dataProto.CmdDoorControlDisable, 10)
		if err != nil {
			tips := fmt.Sprintf("cabinetId:%d", cabinetId)
			return rescode.RegisterErrorWithMessage(err, tips, code.ErrCodeMap[code.ErrCabinetTimeoutCode])
		}
	}

	//更新内存柜子信息未允许开启状态
	cab.memInfo.IsAllowOpen = false

	// 发送获取柜子所有消息的指令
	go func() {
		// 柜子要求.发送禁止柜门后1分钟后再获取状态。
		time.Sleep(time.Second * 60)
		err = GetCabinetStatus(cabinetId)
		if err != nil {
			log.Error("获取柜门信息失败", zap.Error(err))
		}
	}()
	return nil
}

func EnableGrid(cabinetId int, gridNum uint16) error {
	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}
	controlProto := &dataProto.GridControlProto{
		PkgLength:     dataProto.PkgLengthGridControl,
		StartSymbol:   dataProto.StartSymbolGridControl,
		CabinetNumber: cab.memInfo.CabinetNum,
		GridNumber:    gridNum,
		Cmd:           dataProto.CmdGridControlEnable,
	}
	controlProtoBytes, err := dataProto.GridControlProtoEncode(controlProto)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}

	// 记录下发允许打开格子指令
	deviceLogChan <- &MsgLog{
		CabinetID: cabinetId,
		MsgType:   model.MsgTypeSend,
		MsgName:   fmt.Sprintf("允许打开%d号格子指令", gridNum),
		Message:   controlProtoBytes,
	}

	//发送
	tcpServer.WriteData(cab.conn, controlProtoBytes)

	err = waitGridControlResponse(cab.responseChannels.gridControlResChannel, dataProto.CmdGridControlEnable, 10)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetTimeoutCode])
	}
	return nil
}

func DisableGrid(cabinetId int, gridNum uint16) error {
	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}
	controlProto := &dataProto.GridControlProto{
		PkgLength:     dataProto.PkgLengthGridControl,
		StartSymbol:   dataProto.StartSymbolGridControl,
		CabinetNumber: cab.memInfo.CabinetNum,
		GridNumber:    gridNum,
		Cmd:           dataProto.CmdGridControlDisable,
	}
	controlProtoBytes, err := dataProto.GridControlProtoEncode(controlProto)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}

	//发送
	tcpServer.WriteData(cab.conn, controlProtoBytes)

	// 记录下发禁止打开格子指令
	deviceLogChan <- &MsgLog{
		CabinetID: cabinetId,
		MsgType:   model.MsgTypeSend,
		MsgName:   fmt.Sprintf("禁止打开%d号格子指令", gridNum),
		Message:   controlProtoBytes,
	}

	err = waitGridControlResponse(cab.responseChannels.gridControlResChannel, dataProto.CmdGridControlDisable, 10)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetTimeoutCode])
	}
	return nil
}

// OpenDoor 打开指定柜门
func OpenDoor(cabinetId int, gridID uint16) error {
	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}

	// 平台可以在禁止时开门
	//if !cab.cabinetInfo.IsAllowOpen {
	//	return fmt.Errorf("此时禁止打开箱门")
	//}

	openDoor := &dataProto.OpenGridProto{
		PkgLength:     dataProto.PkgLengthOpenGrid,
		StartSymbol:   dataProto.StartSymbolOpenGrid,
		Cmd:           dataProto.CmdOpenGrid,
		CabinetNumber: cab.memInfo.CabinetNum,
		GridNumber:    gridID,
	}

	//编码
	openDoorBytes, err := dataProto.OpenGridProtoEncode(openDoor)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}

	//发送
	tcpServer.WriteData(cab.conn, openDoorBytes)

	// 记录下发打开格子指令
	deviceLogChan <- &MsgLog{
		CabinetID: cabinetId,
		MsgType:   model.MsgTypeSend,
		MsgName:   fmt.Sprintf("打开%d号格子指令", gridID),
		Message:   openDoorBytes,
	}

	// 开箱门操作不等待开门结果。 统一由开门状态通道获取箱门的状态。
	log.Info("开门命令下发成功", zap.String("cabinetIP", cab.memInfo.CabinetIP), zap.Uint16("number", cab.memInfo.CabinetNum))
	return nil
}

// GetCabinetStatus 手动获取柜门所有箱门的状态
func GetCabinetStatus(cabinetId int) error {
	cab, err := cabinetPreCheck(cabinetId)
	if err != nil {
		return err
	}

	getReq := &dataProto.GetCabinetReq{
		PkgLength:     dataProto.PkgLengthGetCabinetReq,
		StartSymbol:   dataProto.StartSymbolGetCabinetReq,
		Cmd:           dataProto.CmdGetCabinetReq,
		CabinetNumber: cab.memInfo.CabinetNum,
	}

	//编码
	openDoorBytes, err := dataProto.GetCabinetReqEncode(getReq)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}

	//发送
	tcpServer.WriteData(cab.conn, openDoorBytes)

	// 记录下发获取所有柜门状态指令
	deviceLogChan <- &MsgLog{
		CabinetID: cabinetId,
		MsgType:   model.MsgTypeSend,
		MsgName:   "获取指定柜子所有格子状态指令",
		Message:   openDoorBytes,
	}

	//手动获取箱门状态响应全部由服务层管道读取后统一处理
	log.Info("获取柜子信息命令下发成功", zap.String("cabinetIP", cab.memInfo.CabinetIP), zap.Uint16("number", cab.memInfo.CabinetNum))
	return nil
}

// SendCabinetDoorStatus 发送柜门此时是否允许开
func SendCabinetDoorStatus(cabinetId int) error {
	if cabinets == nil {
		return fmt.Errorf("cabinets is nil")
	}
	cab, ok := cabinets.getCabinet(cabinetId)
	if !ok {
		return fmt.Errorf("cabinetId %d not found", cabinetId)
	}

	var doorControlCmd uint8
	if cab.memInfo.IsAllowOpen {
		doorControlCmd = dataProto.CmdDoorControlEnable
	} else {
		doorControlCmd = dataProto.CmdDoorControlDisable
	}
	dcp := &dataProto.DoorControlProto{
		PkgLength:     dataProto.PkgLengthDoorControl,
		StartSymbol:   dataProto.StartSymbolDoorControl,
		CabinetNumber: cab.memInfo.CabinetNum,
		Cmd:           doorControlCmd,
	}
	protoBytes, err := dataProto.DoorControlProtoEncode(dcp)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}
	tcpServer.WriteData(cab.conn, protoBytes)

	if cab.memInfo.IsAllowOpen {
		// 记录下发允许开门指令
		deviceLogChan <- &MsgLog{
			CabinetID: cabinetId,
			MsgType:   model.MsgTypeSend,
			MsgName:   "允许开门指令",
			Message:   protoBytes,
		}
	} else {
		// 记录下发禁止开门指令
		deviceLogChan <- &MsgLog{
			CabinetID: cabinetId,
			MsgType:   model.MsgTypeSend,
			MsgName:   "禁止开门指令",
			Message:   protoBytes,
		}
	}

	// 不是页面发起的 不能在这里同步等待
	go func() {
		err = waitDoorControlResponse(cab.responseChannels.doorControlResChannel, doorControlCmd, 10)
		if err != nil {
			log.Error("waitDoorControlResponse err", zap.Error(err))
		}
	}()
	return nil
}

func SendPing(cabinetId int) error {
	if cabinets == nil {
		return fmt.Errorf("cabinets is nil")
	}
	cab, ok := cabinets.getCabinet(cabinetId)
	if !ok {
		return fmt.Errorf("cabinetId %d not found", cabinetId)
	}
	pingBytes, err := hex.DecodeString(dataProto.PingHex)
	if err != nil {
		return rescode.RegisterErrorWithCause(err, code.ErrCodeMap[code.ErrCabinetDeviceCode])
	}
	tcpServer.WriteData(cab.conn, pingBytes)

	//deviceLogChan <- &MsgLog{
	//	CabinetID: cabinetId,
	//	MsgType:   model.MsgTypeSend,
	//	MsgName:   "ping",
	//	Message:   pingBytes,
	//}

	// 等待响应
	if err := waitPongResponse(cab.responseChannels.pongResChannel, 10); err != nil {
		return err
	}

	return nil
}

func waitPongResponse(resChan chan []byte, waitSecond int) error {
	ticker := time.NewTicker(time.Second * time.Duration(waitSecond))
	for {
		select {
		case <-ticker.C:
			return fmt.Errorf("wait pong time out")
		case pongBytes := <-resChan:
			if strings.ToUpper(hex.EncodeToString(pongBytes)) == dataProto.PongHex {
				return nil
			}
		}
	}
}

func waitCabinetConfigResponse(resChan chan *dataProto.CabinetConfigProto, number uint16, waitSecond int) error {
	ticker := time.NewTicker(time.Second * time.Duration(waitSecond))
	for {
		select {
		case <-ticker.C:
			return fmt.Errorf("wait CabinetConfig response time out")
		case resProto := <-resChan:
			log.Info("waitResponse", zap.Any("resProto", resProto))
			if resProto.CabinetNumber == number {
				return nil
			} else {
				log.Warnf("set number is %d,but response number is %d,not matched", number, resProto.CabinetNumber)
				continue
			}
		}
	}
}

func waitDoorControlResponse(resChan chan *dataProto.DoorControlProto, cmd uint8, waitSecond int) error {
	ticker := time.NewTicker(time.Second * time.Duration(waitSecond))
	for {
		select {
		case <-ticker.C:
			return fmt.Errorf("wait DoorControl response time out")
		case resProto := <-resChan:

			log.Info("doorControlResChannel out")
			if resProto.Cmd == cmd {
				return nil
			} else {
				log.Warnf("set cmd %d,but response cmd is %d,not matched", cmd, resProto.Cmd)
				continue
			}
		}
	}
}

func waitGridControlResponse(resChan chan *dataProto.GridControlProto, cmd uint8, waitSecond int) error {
	ticker := time.NewTicker(time.Second * time.Duration(waitSecond))
	for {
		select {
		case <-ticker.C:
			return fmt.Errorf("waitGridControlResponse wait response time out")
		case resProto := <-resChan:
			if resProto == nil {
				return fmt.Errorf("res proto is nil")
			}
			log.Info("gridControlResChannel out")
			if resProto.Cmd == cmd {
				return nil
			} else {
				log.Warnf("set cmd %d,but response cmd is %d,not matched", cmd, resProto.Cmd)
				continue
			}
		}
	}
}

func waitOpenDoorResponse(resChan chan *dataProto.GridLockStatusProto, cabinetNum uint16, gridNum uint16, waitSecond int) error {
	ticker := time.NewTicker(time.Second * time.Duration(waitSecond))
	for {
		select {
		case <-ticker.C:
			return fmt.Errorf("wait response time out")
		case resProto := <-resChan:
			log.Info("waitResponse", zap.Any("resProto", resProto))
			if resProto.CabinetNumber != cabinetNum {
				return fmt.Errorf("set cabinet number is %d,but response number is %d,not matched", cabinetNum, resProto.CabinetNumber)
			}

			if resProto.GridNumber != gridNum {
				return fmt.Errorf("set gird number is %d,but response number is %d,not matched", gridNum, resProto.GridNumber)
			}

			if resProto.LockStatus == dataProto.OpenGridLockBroken {
				return fmt.Errorf("开启失败,锁故障")
			}

			if resProto.LockStatus == dataProto.OpenGridLockOpen {
				return nil
			}
		}
	}
}

func sendCabinetNum(cabinetId int) error {

	err := SetCabinetNumber(cabinetId)
	if err != nil {
		return err
	}
	return nil
}

func sendCabinetDoorControl(cabinetId int) error {
	cab, ok := cabinets.getCabinet(cabinetId)
	if !ok {
		return fmt.Errorf("sendCabinetNum err,remoteId %d not found", cabinetId)
	}
	if cab.memInfo.IsAllowOpen {
		if err := EnableOpenDoor(cabinetId, true); err != nil {
			return err
		}
	} else {
		if err := DisableOpenDoor(cabinetId); err != nil {
			return err
		}
	}
	return nil
}

func sendGetCabinetStatus(cabinetId int) error {
	return GetCabinetStatus(cabinetId)
}

func sendVacation(cabinetId int) error {

	cab, ok := cabinets.getCabinet(cabinetId)
	if !ok {
		return fmt.Errorf("sendCabinetNum err,remoteId %d not found", cabinetId)
	}

	// 获取当前柜子的所有请假人员
	var staffs []model.Staff
	err := global.DB.Model(&model.Staff{}).Where("cabinet_id = ?", cab.memInfo.CabinetID).Where("vacation_state = ?", 2).Find(&staffs).Error
	if err != nil {
		return err
	}

	for _, staff := range staffs {

		// 下发请假指令
		err = EnableGrid(cabinetId, uint16(staff.GridDeviceID))
		if err != nil {
			return err
		}

		// 每个人间隔1毫秒 张总要求
		time.Sleep(time.Microsecond)
	}

	return nil
}