947 lines
30 KiB
Go
947 lines
30 KiB
Go
package event
|
||
|
||
import (
|
||
"encoding/hex"
|
||
"fmt"
|
||
"git.rosy.net.cn/baseapi/utils"
|
||
"git.rosy.net.cn/jx-callback/business/jxutils"
|
||
"git.rosy.net.cn/jx-callback/business/model"
|
||
"git.rosy.net.cn/jx-callback/business/model/dao"
|
||
"git.rosy.net.cn/jx-callback/globals"
|
||
"log"
|
||
"net"
|
||
"regexp"
|
||
"strconv"
|
||
"strings"
|
||
"sync"
|
||
"time"
|
||
"unicode/utf8"
|
||
)
|
||
|
||
var TcpClientList = new(sync.Map)
|
||
|
||
const (
|
||
heartText = "1e000f02000151" // 老版心跳
|
||
heartTextNew = "1e001a02000151" // 新版心跳
|
||
printText = "1e00180200" // 老版打印回调
|
||
printTextNew = "1e00190200" // 新版打印回调
|
||
printSuccessText = "1e001802000150" // 老版消息打印
|
||
printSuccessTextNew = "1e001902000150" // 新版消息打印
|
||
|
||
printErrWithoutPaper = "05"
|
||
|
||
printMsgAlreadySend = 2 //已经发出打印消息
|
||
printMsgSuccess = 1 //打印成功
|
||
PrintMsgWait = 0 //待打印
|
||
printMsgFail = -1 //打印失败（打印机报出）
|
||
printMsgErr = -2 //京西报出
|
||
PrintMsgAlreadyLoad = 3 //已放入队列
|
||
|
||
heartErrNormal = "00" //正常
|
||
heartErrWithoutPaper = "04" //心跳错，缺纸
|
||
heartErrHot = "08" //过热
|
||
|
||
printerStatusOnlineWithoutPaper = 2 //在线缺纸
|
||
printerStatusOnline = 1 //在线
|
||
printerStatusOffline = -1 //离线
|
||
printerStatusOfflineAll = -9 //其他异常状态
|
||
|
||
PrintSoundMaxNumber = 16 // 十六进制最大补位
|
||
PlaceFillingParam = "0" // 补位参数
|
||
)
|
||
|
||
//标签
|
||
const (
|
||
signBR = "<br>" //换行
|
||
signCenter = "<center>" //居中
|
||
signLeft = "<left>" //居左
|
||
signRight = "<right>" //居右
|
||
signBig = "<b>" //字体放大
|
||
signHighBig = "<hb>" //字体纵向放大
|
||
signWideBig = "<wb>" //字体横向放大
|
||
signQrCenter = "<qrc>" //二维码居中
|
||
signQrLeft = "<qrl>" //二维码居左
|
||
signQrRight = "<qrr>" //二维码居右
|
||
signSound, signSoundEnd = "<sound>", "</sound>" // 声音结束标签
|
||
|
||
// GPRS通讯说明，打印机识别二进制码
|
||
hexSignBROrEXE = "0a" // 换行
|
||
hexSignCenter = "1b6101" // 居中打印
|
||
hexSignLeft = "1b6100" // 恢复居左打印
|
||
hexSignRight = "1b6102" // 居右打印
|
||
hexSignNormal = "1b2100"
|
||
hexSignBig = "1b2130" // 横向及纵向都放大
|
||
hexSignHighBig = "1b2110" // 倍高
|
||
hexSignWideBig = "1b2120" // 倍宽
|
||
hexSignQrCenter = "1d5802" // 二维码居中
|
||
hexSignQrLeft = "1d5800" // 二维码居左
|
||
hexSignQrRight = "1d5804" // 二维码居右
|
||
hexSignQr = "1b5a000106" // "1b5a000106" 0600 : 后面二维码的字节数
|
||
hexSignQrEnd = "000a1b40" // 000a0a0a1b40
|
||
hexSignSound = "1d6b40" // 音频指令(自定义语音指令)
|
||
hexSignSoundSolidification = "1B594155" // 音频指令(固化指令)
|
||
|
||
//起始标签 -- 自定义标签utf8转码为gbk字符集
|
||
byteSignBR = "3c62723e" // 换行
|
||
byteSignCenter = "3c63656e7465723e" // 居中
|
||
byteSignLeft = "3c6c6566743e" // 居左
|
||
byteSignRight = "3c72696768743e" // 居右
|
||
byteSignBig = "3c623e" // 字体放大
|
||
byteSignHighBig = "3c68623e" // 字体纵向放大
|
||
byteSignWideBig = "3c77623e" // 字体横向放大
|
||
byteSignQrCenter = "3c7172633e" // 二维码居中
|
||
byteSignQrLeft = "3c71726c3e" // 二维码居左
|
||
byteSignQrRight = "3c7172723e" // 二维码居右
|
||
byteSignSound = "3c736f756e643e" // 声音
|
||
|
||
//结束标签
|
||
byteSignCenterE = "3c2f63656e7465723e" // 居中
|
||
byteSignLeftE = "3c2f6c6566743e" // 居左
|
||
byteSignRightE = "3c2f72696768743e" // 居右
|
||
byteSignBigE = "3c2f623e" // 字体放大
|
||
byteSignHighBigE = "3c2f68623e" // 字体纵向放大
|
||
byteSignWideBigE = "3c2f77623e" // 字体横向放大
|
||
byteSignQrCenterE = "3c2f7172633e" // 二维码居中
|
||
byteSignQrLeftE = "3c2f71726c3e" // 二维码居左
|
||
byteSignQrRightE = "3c2f7172723e" // 二维码居右
|
||
byteSignSoundE = "3c2f736f756e643e" // 声音
|
||
)
|
||
|
||
var (
|
||
printErrMap = map[string]string{
|
||
printErrWithoutPaper: "打印机缺纸！",
|
||
}
|
||
|
||
signMap = map[string]string{
|
||
byteSignBR: hexSignBROrEXE,
|
||
}
|
||
|
||
regexpQrc = regexp.MustCompile(byteSignQrCenter + "(.*?)" + byteSignQrCenterE)
|
||
regexpQrl = regexp.MustCompile(byteSignQrLeft + "(.*?)" + byteSignQrLeftE)
|
||
regexpQrr = regexp.MustCompile(byteSignQrRight + "(.*?)" + byteSignQrRightE)
|
||
regexpSound = regexp.MustCompile(byteSignSound + "(.*?)" + byteSignSoundE)
|
||
regexpSoundSpan = regexp.MustCompile(signSound + "(.*?)" + signSoundEnd)
|
||
)
|
||
|
||
type PrintInfo struct {
|
||
C net.Conn
|
||
Status int // 2 //在线缺纸 1 //在线 -1 //离线
|
||
StatusTime time.Time
|
||
}
|
||
|
||
//type PrintPoolMap struct {
|
||
// *sync.RWMutex
|
||
// PrintObj *TcpClient
|
||
//}
|
||
|
||
//连接的客户端,吧每个客户端都放进来
|
||
type TcpClient struct {
|
||
Clients map[string]*PrintInfo //放tcp连接的，printNo 为key
|
||
MsgMap map[string]chan *model.PrintMsg //放打印信息的，printNo为key
|
||
CallBackMap map[string]chan string //放打印信息回调信息的，printNo为key
|
||
TimeoutMap map[string]bool //退出channel
|
||
*sync.RWMutex
|
||
}
|
||
|
||
type GetPrintStatus struct {
|
||
PrintNo string //打印机编号
|
||
AppID int
|
||
}
|
||
|
||
//从连接池删除，并关闭连接
|
||
func (t *TcpClient) delConn(key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
if t.Clients[key].C != nil {
|
||
t.Clients[key].C.Close()
|
||
}
|
||
delete(t.Clients, key)
|
||
}
|
||
|
||
func (t *TcpClient) clear(key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
t.Clients[key].C.Close()
|
||
delete(t.Clients, key)
|
||
close(t.MsgMap[key])
|
||
delete(t.MsgMap, key)
|
||
close(t.CallBackMap[key])
|
||
delete(t.CallBackMap, key)
|
||
delete(t.TimeoutMap, key)
|
||
}
|
||
|
||
//添加到连接池中
|
||
func addConn(c net.Conn, t *TcpClient, key string, status int) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
t.Clients[key] = &PrintInfo{
|
||
C: c,
|
||
Status: status,
|
||
StatusTime: time.Now(),
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) buildMsgMap(key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
dataChan := make(chan *model.PrintMsg, 1024)
|
||
t.MsgMap[key] = dataChan
|
||
}
|
||
|
||
func (t *TcpClient) buildCallBackMap(key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
dataChan := make(chan string, 1024)
|
||
t.CallBackMap[key] = dataChan
|
||
}
|
||
|
||
func (t *TcpClient) buildTimeoutMap(key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
//dataChan := make(chan bool)
|
||
//t.TimeoutMap[key] = dataChan
|
||
t.TimeoutMap[key] = true
|
||
}
|
||
|
||
func (t *TcpClient) getTimeOut(key string) bool {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
//return <-t.TimeoutMap[key]
|
||
return t.TimeoutMap[key]
|
||
}
|
||
|
||
func buildAllMap(t *TcpClient, key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
t.MsgMap[key] = make(chan *model.PrintMsg, 1024)
|
||
t.CallBackMap[key] = make(chan string, 1024)
|
||
t.TimeoutMap[key] = true
|
||
}
|
||
|
||
func BuildAllMap(t *TcpClient, key string) {
|
||
buildAllMap(t, key)
|
||
}
|
||
|
||
func (t *TcpClient) getPrintStatus(key string) int {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.Clients[key] != nil {
|
||
return t.Clients[key].Status
|
||
} else {
|
||
return printerStatusOfflineAll
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) getPrintConn(key string) net.Conn {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.Clients[key] != nil {
|
||
return t.Clients[key].C
|
||
} else {
|
||
return nil
|
||
}
|
||
}
|
||
func (t *TcpClient) setPrintConn(key string, c net.Conn) {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
t.Clients[key].C = c
|
||
}
|
||
|
||
func (t *TcpClient) getPrintStatusTime(key string) time.Time {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.Clients[key] != nil {
|
||
return t.Clients[key].StatusTime
|
||
} else {
|
||
return utils.ZeroTimeValue
|
||
}
|
||
}
|
||
|
||
// 获取连接对象
|
||
func (t *TcpClient) getClients(key string) *PrintInfo {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
return t.Clients[key]
|
||
}
|
||
|
||
func (t *TcpClient) isExistMsg(key string) bool {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.MsgMap[key] == nil {
|
||
return false
|
||
} else {
|
||
return true
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) isExistCallback(key string) bool {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.CallBackMap[key] == nil {
|
||
return false
|
||
} else {
|
||
return true
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) isExist(key string) bool {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.Clients[key] == nil {
|
||
return false
|
||
} else {
|
||
return true
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) setPrintStatus(key string, status int) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
if t.Clients[key] != nil {
|
||
t.Clients[key].Status = status
|
||
//t.Clients[key].StatusTime = time.Now()
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) setPrintStatusTime(key string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
if t.Clients[key] != nil {
|
||
//t.Clients[key].Status = status
|
||
t.Clients[key].StatusTime = time.Now()
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) addMsgChan(printMsg *model.PrintMsg) (err error) {
|
||
t.Lock()
|
||
defer func() {
|
||
t.Unlock()
|
||
if r := recover(); r != nil && r.(error).Error() == "send on closed channel" {
|
||
err = fmt.Errorf("send on closed channel")
|
||
}
|
||
}()
|
||
if t.MsgMap[printMsg.PrintNo] == nil {
|
||
dataChan := make(chan *model.PrintMsg, 1024)
|
||
t.MsgMap[printMsg.PrintNo] = dataChan
|
||
}
|
||
t.MsgMap[printMsg.PrintNo] <- printMsg
|
||
return err
|
||
}
|
||
|
||
func (t *TcpClient) addCallbackChan(key, data string) {
|
||
t.Lock()
|
||
defer t.Unlock()
|
||
if t.CallBackMap[key] == nil {
|
||
dataChan := make(chan string, 1024)
|
||
t.CallBackMap[key] = dataChan
|
||
}
|
||
t.CallBackMap[key] <- data
|
||
}
|
||
|
||
func (t *TcpClient) GetCallbackChan(key string) string {
|
||
t.RLock()
|
||
defer t.RUnlock()
|
||
if t.CallBackMap[key] == nil {
|
||
return ""
|
||
}
|
||
return <-t.CallBackMap[key]
|
||
}
|
||
|
||
func NewTcpClient() *TcpClient {
|
||
t := &TcpClient{
|
||
Clients: make(map[string]*PrintInfo),
|
||
CallBackMap: make(map[string]chan string),
|
||
MsgMap: make(map[string]chan *model.PrintMsg),
|
||
TimeoutMap: make(map[string]bool, 0),
|
||
}
|
||
t.RWMutex = new(sync.RWMutex)
|
||
return t
|
||
}
|
||
|
||
func printStatus2JxStatus(printStatus string) (status int) {
|
||
if printStatus == heartErrWithoutPaper {
|
||
return printerStatusOnlineWithoutPaper
|
||
} else if printStatus == heartErrNormal {
|
||
return printerStatusOnline
|
||
}
|
||
return status
|
||
}
|
||
|
||
func getCallbackMsgInfo(data string) (orderNo int64, printNo string) {
|
||
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)
|
||
return orderNo, printNo
|
||
}
|
||
|
||
func changePrinterStatus(printNo string, status int) {
|
||
var (
|
||
db = dao.GetDB()
|
||
)
|
||
if printer, err := dao.GetPrinter(db, printNo); err == nil && printer != nil {
|
||
var feilds []string
|
||
if printer.Status != status {
|
||
printer.Status = status
|
||
feilds = append(feilds, "Status")
|
||
}
|
||
isOnline := 0
|
||
if status == printerStatusOnline || status == printerStatusOnlineWithoutPaper {
|
||
isOnline = model.YES
|
||
} else {
|
||
isOnline = model.NO
|
||
printer.OfflineCount++
|
||
feilds = append(feilds, "OfflineCount")
|
||
}
|
||
if isOnline != printer.IsOnline {
|
||
printer.IsOnline = isOnline
|
||
feilds = append(feilds, "IsOnline")
|
||
}
|
||
if len(feilds) > 0 {
|
||
dao.UpdateEntity(db, printer, feilds...)
|
||
}
|
||
}
|
||
}
|
||
|
||
func getCheckSum(str string) (check string) {
|
||
var sum int64
|
||
for i := 0; i < len(str); i = i + 2 {
|
||
b := string(str[i]) + string(str[i+1])
|
||
bt, _ := strconv.ParseInt(b, 16, 32)
|
||
sum += bt
|
||
}
|
||
_, check = int2h8l8(sum)
|
||
return check
|
||
}
|
||
|
||
//内容中的标签替换成指令
|
||
func replaceContent(content string, printMsg *model.PrintMsg) (result string) {
|
||
var (
|
||
lenqr int
|
||
hexLenqr string
|
||
)
|
||
result = content
|
||
for k, v := range signMap {
|
||
if strings.Contains(result, k) {
|
||
result = strings.ReplaceAll(result, k, v)
|
||
}
|
||
}
|
||
// 居中标签
|
||
if strings.Contains(result, byteSignCenter) && strings.Contains(result, byteSignCenterE) {
|
||
result = strings.ReplaceAll(result, byteSignCenter, hexSignCenter)
|
||
result = strings.ReplaceAll(result, byteSignCenterE, hexSignBROrEXE+hexSignLeft)
|
||
}
|
||
// 居左标签
|
||
if strings.Contains(result, byteSignLeft) && strings.Contains(result, byteSignLeftE) {
|
||
result = strings.ReplaceAll(result, byteSignLeft, hexSignLeft)
|
||
result = strings.ReplaceAll(result, byteSignLeftE, hexSignBROrEXE+hexSignLeft)
|
||
}
|
||
// 居右标签
|
||
if strings.Contains(result, byteSignRight) && strings.Contains(result, byteSignRightE) {
|
||
result = strings.ReplaceAll(result, byteSignRight, hexSignRight)
|
||
result = strings.ReplaceAll(result, byteSignRightE, hexSignBROrEXE+hexSignLeft)
|
||
}
|
||
// 字体放大
|
||
if strings.Contains(result, byteSignBig) && strings.Contains(result, byteSignBigE) {
|
||
result = strings.ReplaceAll(result, byteSignBig, hexSignBig)
|
||
result = strings.ReplaceAll(result, byteSignBigE, hexSignBROrEXE+hexSignNormal)
|
||
}
|
||
// 字体高大
|
||
if strings.Contains(result, byteSignHighBig) && strings.Contains(result, byteSignHighBigE) {
|
||
result = strings.ReplaceAll(result, byteSignHighBig, hexSignHighBig)
|
||
result = strings.ReplaceAll(result, byteSignHighBigE, hexSignBROrEXE+hexSignNormal)
|
||
}
|
||
// 字体宽大
|
||
if strings.Contains(result, byteSignWideBig) && strings.Contains(result, byteSignWideBigE) {
|
||
result = strings.ReplaceAll(result, byteSignWideBig, hexSignWideBig)
|
||
result = strings.ReplaceAll(result, byteSignWideBigE, hexSignBROrEXE+hexSignNormal)
|
||
}
|
||
// 二维码居中
|
||
if strings.Contains(result, byteSignQrCenter) && strings.Contains(result, byteSignQrCenterE) {
|
||
if qrs := regexpQrc.FindStringSubmatch(result); len(qrs) > 0 {
|
||
lenqr = len(qrs[1]) / 2
|
||
hexLenqr = fmt.Sprintf("%x", lenqr)
|
||
if len(hexLenqr) < 2 {
|
||
hexLenqr = "0" + hexLenqr
|
||
}
|
||
}
|
||
result = strings.ReplaceAll(result, byteSignQrCenter, hexSignQrCenter+hexSignQr+hexLenqr+"00")
|
||
result = strings.ReplaceAll(result, byteSignQrCenterE, hexSignQrEnd)
|
||
}
|
||
// 二维码局左
|
||
if strings.Contains(result, byteSignQrLeft) && strings.Contains(result, byteSignQrLeftE) {
|
||
if qrs := regexpQrl.FindStringSubmatch(result); len(qrs) > 0 {
|
||
lenqr = len(qrs[1]) / 2
|
||
hexLenqr = fmt.Sprintf("%x", lenqr)
|
||
if len(hexLenqr) < 2 {
|
||
hexLenqr = "0" + hexLenqr
|
||
}
|
||
}
|
||
result = strings.ReplaceAll(result, byteSignQrLeft, hexSignQrLeft+hexSignQr+hexLenqr+"00")
|
||
result = strings.ReplaceAll(result, byteSignQrLeftE, hexSignQrEnd)
|
||
}
|
||
// 二维码居右
|
||
if strings.Contains(result, byteSignQrRight) && strings.Contains(result, byteSignQrRightE) {
|
||
if qrs := regexpQrr.FindStringSubmatch(result); len(qrs) > 0 {
|
||
lenqr = len(qrs[1])
|
||
hexLenqr = fmt.Sprintf("%x", lenqr)
|
||
if len(hexLenqr) < 2 {
|
||
hexLenqr = "0" + hexLenqr
|
||
}
|
||
}
|
||
result = strings.ReplaceAll(result, byteSignQrRight, hexSignQrRight+hexSignQr+hexLenqr+"00")
|
||
result = strings.ReplaceAll(result, byteSignQrRightE, hexSignQrEnd)
|
||
}
|
||
// 固定模板输出语音
|
||
if strings.Contains(result, byteSignSound) && strings.Contains(result, byteSignSoundE) {
|
||
var soundStr []string
|
||
for _, v1 := range strings.Split(result, byteSignSoundE) {
|
||
v1 += byteSignSoundE
|
||
if sounds := regexpSound.FindStringSubmatch(v1); len(sounds) > 0 {
|
||
sound := sounds[1]
|
||
// 将语音包转换为十六进制
|
||
voice := ""
|
||
for _, v := range strings.Split(sound, "2c") {
|
||
voice += hexSignSoundSolidification
|
||
soundNum, _ := hex.DecodeString(v) // 十六进制转字符串
|
||
intSound, _ := strconv.ParseInt(string(soundNum), 10, 64)
|
||
int16Sound := strconv.FormatInt(intSound, 16)
|
||
if intSound < PrintSoundMaxNumber { // 小于十六补位
|
||
voice += PlaceFillingParam + int16Sound
|
||
} else {
|
||
voice += int16Sound
|
||
}
|
||
}
|
||
soundStr = append(soundStr, voice)
|
||
}
|
||
}
|
||
|
||
result = strings.ReplaceAll(result, byteSignSound, "*")
|
||
result = strings.ReplaceAll(result, byteSignSoundE, "&")
|
||
for i := 0; i < len(soundStr); i++ {
|
||
start := strings.Index(result, "*")
|
||
end := strings.Index(result, "&")
|
||
result = strings.Replace(result, result[start:end+1], soundStr[i], 1)
|
||
}
|
||
}
|
||
// 自动合成语音功能
|
||
//if strings.Contains(result, byteSignSound) && strings.Contains(result, byteSignSoundE) {
|
||
// if sounds := regexpSound.FindStringSubmatch(result); len(sounds) > 0 {
|
||
// sound := sounds[1]
|
||
// if printer, _ := dao.GetPrinter(dao.GetDB(), printMsg.PrintNo); printer != nil {
|
||
// //先把结束标签消了
|
||
// result = strings.ReplaceAll(result, byteSignSoundE, "")
|
||
// soundPrefix := ""
|
||
// if printer.Sound != "" {
|
||
// soundPrefix = "[v" + utils.Int2Str(printer.Volume*2) + "]" + printer.Sound
|
||
// } else {
|
||
// soundPrefix = "[v" + utils.Int2Str(printer.Volume*2) + "]"
|
||
// }
|
||
// hexPrefix, _ := jxutils.Utf8ToGbk([]byte(soundPrefix))
|
||
// hexPrefixStr := hex.EncodeToString(hexPrefix)
|
||
// realSound := hexPrefixStr + sound
|
||
// allLen := fmt.Sprintf("%x", (len("fd001a0101")+len(realSound))/2)
|
||
// if len(allLen) < 2 {
|
||
// allLen = "0" + allLen
|
||
// }
|
||
// soundLenH, soundLenX := int2h8l8(int64((len(realSound) + len("0101")) / 2))
|
||
// result = strings.ReplaceAll(result, byteSignSound, hexSignSound+allLen+"fd"+soundLenH+soundLenX+"0100"+hexPrefixStr)
|
||
// }
|
||
// }
|
||
//}
|
||
return result
|
||
}
|
||
|
||
func checkPrintMsg(db *dao.DaoDB, printMsg *model.PrintMsg) (err error) {
|
||
if printMsg.Content == "" {
|
||
return fmt.Errorf("此打印信息内容为空！printMsg printNo:[%v], orderNo :[%v] 1", printMsg.PrintNo, printMsg.OrderNo)
|
||
}
|
||
if printMsg.PrintNo == "" {
|
||
return fmt.Errorf("此打印信息打印机编号为空！printMsg printNo:[%v], orderNo :[%v] 2", printMsg.PrintNo, printMsg.OrderNo)
|
||
}
|
||
if printMsg.OrderNo == "" {
|
||
return fmt.Errorf("此打印信息订单序号为空！printMsg printNo:[%v], orderNo :[%v] 3", printMsg.PrintNo, printMsg.OrderNo)
|
||
}
|
||
//if printer, err := dao.GetPrinter(db, printMsg.PrintNo); err == nil {
|
||
// if printer != nil {
|
||
// if printer.FlowFlag == 1 {
|
||
// return fmt.Errorf("此打印机当月流量已用完，请及时充值！printNo:[%v]", printMsg.PrintNo)
|
||
// }
|
||
// }
|
||
//}
|
||
return err
|
||
}
|
||
|
||
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 != 0 {
|
||
h = "0" + h
|
||
}
|
||
if len(l)%2 != 0 {
|
||
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, 32)
|
||
return i
|
||
}
|
||
|
||
func xtob(x string) string {
|
||
base, _ := strconv.ParseInt(x, 16, 10)
|
||
return strconv.FormatInt(base, 2)
|
||
}
|
||
|
||
// Heartbeat 心跳回调
|
||
func Heartbeat(c net.Conn, t *TcpClient, data string, printNo string, printRemoteAddr string) {
|
||
//printNoData, _ := hex.DecodeString(data[len(heartText) : len(data)-8])
|
||
//printNo = string(printNoData)
|
||
status := printStatus2JxStatus(data[len(data)-8 : len(data)-6])
|
||
//如果没在连接池里
|
||
//1、加到连接池中，不同的打印机no开不同的goroutine
|
||
//2、初始化channel，每个打印机一个，放打印消息和打印回调消息
|
||
//3、读数据库里的待打印信息，放到打印channel中
|
||
//4、读打印channel并打印，并切等待回调channel中的消息
|
||
//5、修改数据库中打印机状态（没在连接池中说明是重新连接的）
|
||
//6、监听心跳时间，超过1分多钟就clear掉
|
||
if t.getClients(printNo) == nil || t.getPrintStatusTime(printNo).IsZero() || time.Now().Sub(t.Clients[printNo].StatusTime).Seconds() >= 120 {
|
||
addConn(c, t, printNo, status)
|
||
buildAllMap(t, printNo)
|
||
//t.TimeoutMap[printNo] <- true
|
||
HandleTcpMessages(t, printNo)
|
||
doPrint(t, printNo)
|
||
if status == printerStatusOnline {
|
||
//t.printFail()
|
||
}
|
||
//changePrinterStatus(printNo, status)
|
||
// todo 暂时关闭心跳检测
|
||
HandleCheckTcpHeart(t, printNo)
|
||
// todo 证明打印机已经被激活,将激活打印机存入数据库,保证用户不能无限制绑定打印机
|
||
if err := dao.NotExistsCreate(printNo); err != nil {
|
||
globals.SugarLogger.Debugf("监听打印机心跳,不存在则创建 :[%v],printNo[%s]", err, printNo)
|
||
}
|
||
} else {
|
||
//在加到连接池中已经更新了时间，所以放在else里
|
||
t.setPrintStatusTime(printNo)
|
||
}
|
||
//状态不一致再更新状态（可能缺纸了，过热了等）
|
||
t.setPrintStatus(printNo, status)
|
||
changePrinterStatus(printNo, status)
|
||
}
|
||
|
||
// Callback 打印成功回调
|
||
func Callback(c net.Conn, t *TcpClient, data string, printNo string) {
|
||
//打印消息发送后，打印机会回调该条打印消息的状态（打印成功or失败，失败原因..）
|
||
//将回调的信息放到回调channel中，打印成功后再打印下一条消息
|
||
//_, printNo = getCallbackMsgInfo(data)
|
||
//更新打印机心跳时间（打印机本身不会在打印的同时，或回调的同时发心跳消息，会导致心跳判断超时，这里更新一下）
|
||
t.setPrintStatusTime(printNo)
|
||
t.addCallbackChan(printNo, data)
|
||
}
|
||
|
||
func HandleTcpMessages(t *TcpClient, printNo string) {
|
||
var (
|
||
db = dao.GetDB()
|
||
offset, pageSize = 0, 10
|
||
)
|
||
if !t.isExistMsg(printNo) {
|
||
return
|
||
}
|
||
|
||
fn := func() {
|
||
//for {
|
||
// time.Sleep(2 * time.Second)
|
||
if t.TimeoutMap[printNo] == true {
|
||
timeNow := time.Now()
|
||
timeStart := time.Date(timeNow.Year(), timeNow.Month(), timeNow.Day(), 0, 0, 0, 0, timeNow.Location())
|
||
timeEnd := time.Date(timeNow.Year(), timeNow.Month(), timeNow.Day(), 23, 59, 59, 0, timeNow.Location())
|
||
prints, _ := dao.GetPrintMsgs(db, printNo, []int{PrintMsgWait}, timeStart.AddDate(0, 0, -1), timeEnd, offset, pageSize)
|
||
for _, printMsg := range prints {
|
||
printMsg.Status = PrintMsgAlreadyLoad
|
||
//先避免重复读再插到channel？
|
||
if _, err := dao.UpdateEntity(db, printMsg, "Status"); err == nil {
|
||
if err = t.addMsgChan(printMsg); err != nil {
|
||
globals.SugarLogger.Debugf("HandleTcpMessages addMsgChan Err: %v", err)
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
globals.SugarLogger.Debugf("HandleTcpMessages timeout")
|
||
return
|
||
}
|
||
}
|
||
Pool.AddJob(fn)
|
||
}
|
||
func doPrint(t *TcpClient, key string) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
)
|
||
|
||
if !t.isExistMsg(key) {
|
||
return err
|
||
}
|
||
|
||
fn := func() {
|
||
for {
|
||
if t.TimeoutMap[key] == true {
|
||
select {
|
||
case printMsg, ok := <-t.MsgMap[key]:
|
||
if !ok {
|
||
globals.SugarLogger.Debugf("doPrint err !ok ...")
|
||
return
|
||
}
|
||
var (
|
||
data []byte
|
||
c net.Conn
|
||
)
|
||
if printMsg == nil {
|
||
globals.SugarLogger.Debugf("print msg is nil")
|
||
continue
|
||
}
|
||
|
||
if err = checkPrintMsg(db, printMsg); err == nil {
|
||
status := t.getPrintStatus(printMsg.PrintNo)
|
||
switch status {
|
||
//只有在线才打印内容
|
||
case printerStatusOnline:
|
||
if c = t.getPrintConn(printMsg.PrintNo); c != nil {
|
||
data, err = buildMsg(printMsg)
|
||
}
|
||
case printerStatusOffline:
|
||
err = fmt.Errorf("打印机离线！")
|
||
case printerStatusOnlineWithoutPaper:
|
||
err = fmt.Errorf("打印机缺纸！")
|
||
default:
|
||
err = fmt.Errorf("打印机状态未知！")
|
||
}
|
||
}
|
||
|
||
if c == nil {
|
||
return
|
||
}
|
||
|
||
if err != nil {
|
||
printMsg.Status = printMsgErr
|
||
printMsg.Comment = err.Error()
|
||
dao.UpdateEntity(db, printMsg, "Status", "Comment")
|
||
return
|
||
}
|
||
|
||
// 链接已经关闭了
|
||
//if isClosed(c) {
|
||
// remoteAddr := c.RemoteAddr().(*net.TCPAddr)
|
||
// remoteIP := remoteAddr.IP.String() // 打印机IP
|
||
// remotePort := remoteAddr.Port // 打印机端口
|
||
// globals.SugarLogger.Debugf("remoteIP3: %s", remoteIP)
|
||
// globals.SugarLogger.Debugf("remotePort3: %d", remotePort)
|
||
//
|
||
// printRemoteAddr := c.RemoteAddr().String()
|
||
// printRemoteAddr = strings.Split(printRemoteAddr, ":")[0]
|
||
// globals.SugarLogger.Debugf("printRemoteAddr3: %s", printRemoteAddr)
|
||
//
|
||
// c = reconnectPrinter(c)
|
||
// if c != nil {
|
||
// t.setPrintConn(printMsg.PrintNo, c)
|
||
// }
|
||
//}
|
||
if _, err = c.Write(data); err != nil {
|
||
globals.SugarLogger.Debugf("handleTcpMessages err [%v]", err)
|
||
} else {
|
||
//等待回调
|
||
dataStr := <-t.CallBackMap[key]
|
||
if dataStr != "" {
|
||
a, b := getCallbackMsgInfo(dataStr)
|
||
t.changePrintMsg(dataStr, a, b)
|
||
// 查询打印机是否扣费,未扣费就扣费,已经扣费不做处理
|
||
have, err2 := dao.QueryOrderDeductionRecord(db, b, utils.Int64ToStr(a))
|
||
if err2 == nil && !have {
|
||
// 扣除打印机账号金额
|
||
if err = dao.DeductionPrintBalance(db, b); err != nil {
|
||
globals.SugarLogger.Debugf("扣除用户打印机金额错误 %s", err)
|
||
} else {
|
||
// 添加打印记录(支出记录)
|
||
if err = dao.AddPrintRecord(db, &model.PrintBillRecord{
|
||
CreatedAt: time.Now(),
|
||
UpdatedAt: time.Now(),
|
||
PrintNo: b,
|
||
PayType: 2,
|
||
PayMoney: 1, // 固定支出一分钱
|
||
OrderId: utils.Int64ToStr(a),
|
||
UserId: "",
|
||
}); err != nil {
|
||
globals.SugarLogger.Debugf("添加打印机订单支付记录错误 %s", err)
|
||
}
|
||
}
|
||
} else {
|
||
globals.SugarLogger.Debugf("今天已经扣除过了! %v %d %s", err2, a, b)
|
||
}
|
||
// 回调重置打印机状态时间
|
||
t.Clients[b].StatusTime = time.Now()
|
||
//判断音频暂停？
|
||
//收到打印成功回调后，如果消息中有音频，需要等待一下,等上一个音频播完
|
||
//暂停时间就暂时取的sound标签内内容长度/2
|
||
if sounds := regexpSoundSpan.FindStringSubmatch(printMsg.Content); len(sounds) > 0 {
|
||
sound := sounds[1]
|
||
lenTime := time.Duration(utf8.RuneCountInString(sound)) * time.Second
|
||
time.Sleep(lenTime / 2)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
globals.SugarLogger.Debugf("doPrint timeout")
|
||
return
|
||
}
|
||
}
|
||
}
|
||
Pool.AddJob(fn)
|
||
return err
|
||
}
|
||
|
||
//按打印机方提供的文档来的
|
||
func buildMsg(printMsg *model.PrintMsg) (data []byte, err error) {
|
||
var (
|
||
content = printMsg.Content
|
||
orderNo = printMsg.OrderNo
|
||
str = "1e"
|
||
const1 = "0200ff50"
|
||
printInit = "1b40" //打印机初始化
|
||
//voice = "1d6b401dfd001a01015b7631365d736f756e64622cc4fad3d0d0c2b6a9b5a5c0b1" //语音，中国
|
||
//qr = "1d58021b5a0001061600747470733a2f2f7777772e62616964752e636f6d2f1b000A0A0A1B40"
|
||
orderNoHexH, orderNoHexL, printData string
|
||
)
|
||
//写入数据
|
||
no, err := strconv.ParseInt(orderNo, 10, 64)
|
||
if err != nil {
|
||
globals.SugarLogger.Debug("order_msg Order_no 转换异常")
|
||
}
|
||
orderNoHexH, orderNoHexL = int2h8l8(no)
|
||
// 将数据与模板组装
|
||
if strings.Contains(content, "•") {
|
||
content = strings.ReplaceAll(content, "•", "-")
|
||
}
|
||
printDataGBK, _ := jxutils.Utf8ToGbk([]byte(utils.FilterEmoji(content)))
|
||
printData = hex.EncodeToString(printDataGBK)
|
||
printData = replaceContent(printData, printMsg)
|
||
lenData := int64(len(str) + len(const1) + len(orderNoHexH) + len(orderNoHexL) + len(printInit) + 2 + 4 + len(printData))
|
||
x1, x2 := int2h8l8(lenData / 2)
|
||
dataStr := str + x1 + x2 + const1 + orderNoHexH + orderNoHexL + printInit + printData
|
||
check := getCheckSum(dataStr)
|
||
return jxutils.Hextob(dataStr + check), err
|
||
}
|
||
|
||
// HandleCheckTcpHeart 检测心跳
|
||
func HandleCheckTcpHeart(t *TcpClient, key string) {
|
||
if t.TimeoutMap[key] == true {
|
||
statusTime := t.getPrintStatusTime(key)
|
||
if !utils.IsTimeZero(statusTime) {
|
||
//1分钟内没心跳判断打印机掉线了
|
||
if time.Now().Sub(statusTime) > time.Second*75 {
|
||
globals.SugarLogger.Debugf("超过一分十秒没有心跳的打印机[%s],当前心跳时间: %s ,上一次心跳时间 : %s", key, utils.Time2TimeStr(time.Now()), utils.Time2TimeStr(statusTime))
|
||
changePrinterStatus(key, printerStatusOffline)
|
||
}
|
||
}
|
||
} else {
|
||
t.getClients(key).C.Close()
|
||
close(t.MsgMap[key])
|
||
close(t.CallBackMap[key])
|
||
//t.delConn(key)
|
||
t.clear(key)
|
||
TcpClientList.Delete(key)
|
||
return
|
||
}
|
||
}
|
||
|
||
func (t *TcpClient) changePrintMsg(data string, orderNo int64, printNo string) (err error) {
|
||
var (
|
||
db = dao.GetDB()
|
||
comment string
|
||
status int
|
||
)
|
||
//1、先找出打印机编号和订单序列号，这两个确定唯一一条消息?
|
||
//通过参数传进来
|
||
//2、打印成功改变打印表的状态
|
||
if strings.Contains(data, printSuccessText) || strings.Contains(data, printSuccessTextNew) {
|
||
status = printMsgSuccess
|
||
comment = "回调成功,修改打印状态"
|
||
} else {
|
||
//打印失败也改变状态并更新失败原因
|
||
status = printMsgFail
|
||
comment = printErrMap[data[12:14]]
|
||
}
|
||
//这里序号重复会有问题
|
||
if printMsgs, err := dao.GetPrintMsgNoPage(db, printNo, orderNo); err != nil {
|
||
globals.SugarLogger.Debugf("changePrintMsg err :[%v]", err)
|
||
return err
|
||
} else if len(printMsgs) == 0 {
|
||
globals.SugarLogger.Debugf("changePrintMsg err ,not found printMsg printNo:[%v], orderNo :[%v]", printNo, orderNo)
|
||
} else if len(printMsgs) > 0 {
|
||
for _, v := range printMsgs {
|
||
v.Comment = comment
|
||
v.Status = status
|
||
dao.UpdateEntity(db, v, "Comment", "Status")
|
||
}
|
||
}
|
||
return err
|
||
}
|
||
|
||
// 工具函数：判断连接是否关闭
|
||
func isClosed(conn net.Conn) bool {
|
||
buffer := make([]byte, 0)
|
||
// 设置读取超时=极短时间，不阻塞
|
||
conn.SetReadDeadline(time.Now().Add(1 * time.Millisecond))
|
||
_, err := conn.Read(buffer)
|
||
conn.SetReadDeadline(time.Time{}) // 重置超时
|
||
|
||
if err != nil {
|
||
if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
|
||
return false // 只是超时，连接正常
|
||
}
|
||
}
|
||
return true // 连接已关闭
|
||
}
|
||
|
||
var mu sync.Mutex
|
||
|
||
// 自动重连
|
||
func reconnectPrinter(printerConn net.Conn) net.Conn {
|
||
mu.Lock()
|
||
defer mu.Unlock()
|
||
|
||
if printerConn != nil {
|
||
printerConn.Close()
|
||
}
|
||
|
||
// 重试 5 次
|
||
for i := 0; i < 5; i++ {
|
||
conn, err := net.DialTimeout("tcp", "打印机IP:端口", 3*time.Second)
|
||
if err == nil {
|
||
printerConn = conn
|
||
log.Println("打印机重连成功")
|
||
return printerConn
|
||
}
|
||
time.Sleep(2 * time.Second)
|
||
}
|
||
log.Println("打印机重连失败")
|
||
return nil
|
||
}
|