jx-callback/business/jxstore/event/event_tcp.go

package event

import (
	"encoding/hex"
	"fmt"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"git.rosy.net.cn/jx-callback/globals"
	"github.com/astaxie/beego/client/orm"
	"io"
	"net"
	"strconv"
	"strings"
	"sync"
)

const (
	heartText        = "1e000f02000151"
	printText        = "1e00180200"
	printSuccessText = "1e001802000150"

	printErrWithoutPaper = "05"

	printMsgSuccess = 1  //打印成功
	printMsgWait    = 0  //待打印
	printMsgFail    = -1 //打印失败
)

var (
	tcpClient = &TcpClient{}

	printErrMap = map[string]string{
		printErrWithoutPaper: "打印机缺纸！",
	}
)

//连接的客户端,吧每个客户端都放进来
type TcpClient struct {
	Clients map[string]net.Conn
	s       *sync.RWMutex
}

func Init() {
	listenTcp()
	go handleTcpMessages()
}

func listenTcp() {
	tcpClient.Clients = make(map[string]net.Conn)
	l, err := net.Listen("tcp", ":8000")
	if err != nil {
		fmt.Println("listen error:", err)
		return
	}
	for {
		c, err := l.Accept()
		if err != nil {
			fmt.Println("accept error:", err)
			break
		}
		go handleConn(c)
	}
}

func handleConn(c net.Conn) {
	var (
		printNo string //打印机编号
		db      = dao.GetDB()
	)
	db.Db = orm.NewOrmUsingDB("api") //读写这个库
	if c == nil {
		globals.SugarLogger.Debugf("conn is nil")
		return
	}
	defer c.Close()
	buffer := make([]byte, 1024)
	for {
		n, err := c.Read(buffer)
		if err != nil {
			if err == io.EOF {
				fmt.Println("connection close")
			} else {
				fmt.Println("ReadString err", err)
			}
			return
		}
		//看是心跳还是打印返回
		data := hex.EncodeToString(buffer[:n])
		//证明是心跳
		if strings.Contains(data, heartText) {
			printNoData, _ := hex.DecodeString(data[len(heartText) : len(data)-8])
			printNo = string(printNoData)
			if tcpClient.Clients[printNo] == nil {
				tcpClient.Clients[printNo] = c
			} else {
				//改变打印机状态
			}
		} else if strings.Contains(data, printText) {
			changePrintMsg(db, data)
		}
	}
}

func changePrintMsg(db *dao.DaoDB, data string) (err error) {
	var (
		printNo, comment string
		orderNo          int64
		status           int
		printMsg         = &model.PrintMsg{}
	)
	//1、先找出打印机编号和订单序列号，这两个确定唯一一条消息
	orderNo = h8l82int(data[len(data)-6:len(data)-4], data[len(data)-4:len(data)-2])
	printNoData, _ := hex.DecodeString(data[len(printSuccessText) : len(data)-6])
	printNo = string(printNoData)
	//2、打印成功改变打印表的状态
	if strings.Contains(data, printSuccessText) {
		//1e001802000150323032313036313530303030313000013c
		status = printMsgSuccess
	} else {
		//打印失败也改变状态并更新失败原因
		status = printMsgFail
		comment = printErrMap[data[12:14]]
	}
	if printMsg, err = dao.GetPrintMsg(db, printNo, orderNo); err != nil {
		globals.SugarLogger.Debugf("changePrintMsg err :[%v]", err)
		return
	} else if printMsg == nil {
		globals.SugarLogger.Debugf("changePrintMsg err ,not found printMsg printNo:[%v], orderNo :[%v]", printNo, orderNo)
	} else {
		printMsg.Comment = comment
		printMsg.Status = status
		dao.UpdateEntity(db, printMsg, "Comment", "Status")
	}
	return err
}

func handleTcpMessages() {
	var (
		db               = dao.GetDB()
		offset, pageSize = 0, 10
	)
	db.Db = orm.NewOrmUsingDB("api") //读写这个库
	for {
		//一直读？
		var err error
		prints, _ := dao.GetPrintMsgs(db, printMsgWait, offset, pageSize)
		for _, printMsg := range prints {
			if printMsg != nil {
				if err = checkPrintMsg(printMsg); err == nil {

				}
			} else {
				err = fmt.Errorf("未查询到此printMsg")
			}
		}
	}
}

func checkPrintMsg(printMsg *model.PrintMsg) (err error) {
	if printMsg.Content == "" {
		return fmt.Errorf("此打印信息内容为空！printMsg printNo:[%v], orderNo :[%v]", printMsg.PrintNo, printMsg.OrderNo)
	}
	if printMsg.PrintNo == "" {
		return fmt.Errorf("此打印信息打印机编号为空！printMsg printNo:[%v], orderNo :[%v]", printMsg.PrintNo, printMsg.OrderNo)
	}
	if printMsg.OrderNo == 0 {
		return fmt.Errorf("此打印信息订单序号为空！printMsg printNo:[%v], orderNo :[%v]", printMsg.PrintNo, printMsg.OrderNo)
	}
	return err
}

func Hextob(str string) []byte {
	slen := len(str)
	bHex := make([]byte, len(str)/2)
	ii := 0
	for i := 0; i < len(str); i = i + 2 {
		if slen != 1 {
			ss := string(str[i]) + string(str[i+1])
			bt, _ := strconv.ParseInt(ss, 16, 32)
			bHex[ii] = byte(bt)
			ii = ii + 1
			slen = slen - 2
		}
	}
	return bHex
}

func int2h8l8(i int64) (h, l string) {
	origin2 := fmt.Sprintf("%b", i)
	flag := 16 - len(origin2)
	for i := 0; i < flag; i++ {
		origin2 = "0" + origin2
	}
	begin8 := origin2[:8]
	end8 := origin2[8:]
	r1, _ := strconv.ParseInt(begin8, 2, 32)
	r2, _ := strconv.ParseInt(end8, 2, 32)
	h = fmt.Sprintf("%x", r1)
	l = fmt.Sprintf("%x", r2)
	if len(h) < 2 {
		h = "0" + h
	}
	if len(l) < 2 {
		l = "0" + l
	}
	return h, l
}

func h8l82int(h, l string) (i int64) {
	s1, s2 := xtob(h), xtob(l)
	flag1 := 8 - len(s1)
	flag2 := 8 - len(s2)
	for m := 0; m < flag1; m++ {
		s1 = "0" + s1
	}
	for j := 0; j < flag2; j++ {
		s2 = "0" + s2
	}
	i, _ = strconv.ParseInt(s1+s2, 2, 10)
	return i
}

func xtob(x string) string {
	base, _ := strconv.ParseInt(x, 16, 10)
	return strconv.FormatInt(base, 2)
}