All/Go/Wine-Server/handlers/seller/worker.go

package seller

import (
	"Wine-Server/utils"
	"Wine-Server/utils/tables"
	"encoding/json"
	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	"github.com/skip2/go-qrcode"
)

func versionHandler(ctx *gin.Context) {
	version := tables.VersionTable{}
	err := version.GetLatest()
	if err != nil {
		ctx.JSON(utils.HttpError, utils.Fail("Get latest version failed"))
		return
	}
	ctx.JSON(utils.HttpOk, utils.Success(version))
}

func infoOfDevice(device *tables.DeviceTable, conn *websocket.Conn) {
	var err error
	for i := 0; i < 4; i++ {
		err = device.Wines[i].Get()
		if err != nil {
			utils.Logger.Println("Query wine info failed:", err)
			_ = conn.WriteJSON(utils.WsError("Query wine info failed"))
			return
		}
	}
	_ = conn.WriteJSON(utils.WsEvent("wineResult", device.Wines))

	var advList []tables.AdvertiseTable
	advList, err = tables.AdvertiseListAll()
	if err != nil {
		utils.Logger.Println("Query advertise failed:", err)
		_ = conn.WriteJSON(utils.WsError("Query advertise failed"))
		return
	}
	_ = conn.WriteJSON(utils.WsEvent("advResult", advList))

	var runParams []tables.ParamsTable
	runParams, err = tables.ParamsListAll()
	if err != nil {
		utils.Logger.Println("Query running params failed:", err)
		_ = conn.WriteJSON(utils.WsError("Query running params failed"))
		return
	}
	_ = conn.WriteJSON(utils.WsEvent("runParamResult", runParams))

	url := utils.Format("%s?device=%s&callback=%s", utils.VipScanApi, device.Id, utils.VipCallback)
	img, err := qrcode.Encode(url, qrcode.Medium, 512)
	if err != nil {
		utils.Logger.Println(err)
		_ = conn.WriteJSON(utils.WsError("Can't Access to Vip Qrcode"))
		return
	}
	_ = conn.WriteJSON(utils.WsEvent("vipQrcodeResult", img))

	_ = conn.WriteJSON(utils.WsEvent("initFinish", nil))
}

func keepAlive(conn *websocket.Conn, data any) {
	_ = conn.WriteJSON(utils.WsEvent("pon", data))
}

func getQrcode(device *tables.DeviceTable, conn *websocket.Conn, data any) {
	var param qrcodeParam
	err := utils.AnyTrans(data, &param)
	if err != nil {
		_ = conn.WriteJSON(utils.WsError("param error"))
		return
	}
	wine := tables.WineTable{Id: param.Id}
	err = wine.Get()
	if err != nil {
		utils.Logger.Printf("Query wine[%d] failed: %s\n", param.Id, err)
		_ = conn.WriteJSON(utils.WsError(utils.Format("no such wine: %d", param.Id)))
		return
	}
	cash := int(param.Weight) * int(wine.Price)
	if cash != param.Cash {
		utils.Logger.Printf("got a wrong cash[user: %d, need: %d]\n", param.Cash, cash)
		_ = conn.WriteJSON(utils.WsError(utils.Format("got a wrong cash[you: %d, real: %d]", param.Cash, cash)))
		return
	}
	_ = device.Get()
	trade := device.Id + utils.TimeString()
	store := tradeRedis{Device: device.Id, Cell: param.Cell, Wine: wine.Id, Weight: param.Weight, Cash: uint32(cash)}
	marshal, err := json.Marshal(store)
	if err != nil {
		utils.Logger.Println("marshal trade failed:", err)
		_ = conn.WriteJSON(utils.WsError("marshal trade failed"))
		return
	}
	err = utils.Redis.Set(utils.WxPayCli, utils.Format("WxPay_%s", trade), marshal, utils.Duration(1800)).Err()
	if err != nil {
		utils.Logger.Println("store trade failed:", err)
		_ = conn.WriteJSON(utils.WsError("store trade failed"))
		return
	}

	var img []byte
	img, err = utils.TryWxPay(trade, wine.Name, cash)
	if err != nil {
		utils.Logger.Println("access to wxpay failed:", err)
		_ = conn.WriteJSON(utils.WsError("access to Wechat Pay failed"))
		return
	}
	_ = conn.WriteJSON(utils.WsEvent("qrcodeOkayed", img))
}

func checkAuthCode(did string, conn *websocket.Conn, data any) {
	var param authParam
	err := utils.AnyTrans(data, &param)
	if err != nil {
		_ = conn.WriteJSON(utils.WsError("params error"))
		return
	}

	utils.Logger.Println(param)
	if param.UserType == "debugger" && param.Type == "Changing" {
		key := utils.Format("Change_%s_%s", did, param.UserId)
		code, err := utils.Redis.Get(utils.WxPayCli,key).Result()
		utils.Logger.Println(key, code)
		if err != nil {
			_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
				"type": param.Type, "ok": false,
			}))
			return
		}
		if code == param.Code {
			_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
				"type": param.Type, "ok": true, "work": []utils.JsonType{
					{
						"cell": 1,
						"old":  utils.JsonType{"id": 13026, "name": "某一款酒名-1", "remain": 300},
						"new":  utils.JsonType{"id": 13026, "name": "某一款酒名-1", "remain": 15000},
					},
					{
						"cell": 2,
						"old":  utils.JsonType{"id": 13027, "name": "某一款酒名-2", "remain": 286},
						"new":  utils.JsonType{"id": 13029, "name": "某一款酒名-3", "remain": 15000},
					},
					{
						"cell": 3,
						"old":  utils.JsonType{"id": 13027, "name": "某一款酒名-2", "remain": 286},
						"new":  utils.JsonType{"id": 13029, "name": "某一款酒名-3", "remain": 15000},
					},
					{
						"cell": 4,
						"old":  utils.JsonType{"id": 13027, "name": "某一款酒名-2", "remain": 286},
						"new":  utils.JsonType{"id": 13029, "name": "某一款酒名-3", "remain": 15000},
					},
				},
			}))
		} else {
			_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
				"type": param.Type, "ok": false,
			}))
		}
		return
	}

	switch param.Type {
	case "Changing":
		cid, err := utils.Redis.Get(utils.WxPayCli, utils.Format("Change_%s_%s", did, param.UserId)).Int()
		if err != nil {
			_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
				"type": param.Type, "ok": false,
			}))
			return
		}
		change := tables.ChangeTable{Id: uint32(cid)}
		err = change.Get()
		if err != nil || change.Code != param.Code {
			_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
				"type": param.Type, "ok": false,
			}))
			return
		}
		_ = change.Update(utils.JsonType{"status": 1})
		works := make([]utils.JsonType, 0)
		for i := 0; i < 4; i++ {
			ow := tables.WineTable{Id: change.Old[0].Id}
			nw := tables.WineTable{Id: change.New[0].Id}
			_, _ = ow.Get(), nw.Get()
			works = append(works, utils.JsonType{
				"cell": i + 1,
				"old":  utils.JsonType{"id": ow.Id, "name": ow.Name, "remain": change.Old[0].Remain},
				"new":  utils.JsonType{"id": nw.Id, "name": nw.Name, "remain": change.New[0].Remain},
			})
		}
		_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
			"type": param.Type, "ok": true, "work": works,
		}))
		break
	case "Fixing":
		code, err := utils.Redis.Get(utils.WxPayCli, utils.Format("Fix_%s_%s", did, param.UserId)).Result()
		if err != nil {
			_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
				"type": param.Type, "ok": false,
			}))
			return
		}
		_ = conn.WriteJSON(utils.WsEvent("authCodeResult", utils.JsonType{
			"type": param.Type, "ok": code == param.Code,
		}))
		break
	default:
		_ = conn.WriteJSON(utils.WsError("unrecognized open type"))
	}
}

func openResult(conn *websocket.Conn, data any) {
	var param resultParam
	err := utils.AnyTrans(data, &param)
	if err != nil {
		_ = conn.WriteJSON(utils.WsError("params error"))
		return
	}
	switch param.UserType {
	case "worker":
		if worker, win := utils.WorkerWss[param.UserId]; win {
			_ = worker.WriteJSON(utils.WsEvent("openResult", utils.JsonType{
				"type": param.Type, "result": param.Result,
			}))
		}
		break
	case "debugger":
		if debugger, din := utils.DebugWss[param.UserId]; din {
			_ = debugger.WriteJSON(utils.WsEvent("openResult", utils.JsonType{
				"type": param.Type, "result": param.Result,
			}))
		}
		break
	case "manager":
		if manager, min := utils.ManagerWss[param.UserId]; min {
			_ = manager.WriteJSON(utils.WsEvent("openResult", utils.JsonType{
				"type": param.Type, "result": param.Result,
			}))
		}
		break
	default:
		utils.Logger.Printf("unrecognized user type: %s\n", param.UserType)
		break
	}
}

func workFinished(conn *websocket.Conn, data any) {
	var param finishParam
	err := utils.AnyTrans(data, &param)
	if err != nil {
		_ = conn.WriteJSON(utils.WsError("params error"))
		return
	}
	switch param.UserType {
	case "worker":
		if worker, win := utils.WorkerWss[param.UserId]; win {
			_ = worker.WriteJSON(utils.WsEvent("workFinished", param.Type))
		}
		break
	case "debugger":
		if debugger, din := utils.DebugWss[param.UserId]; din {
			_ = debugger.WriteJSON(utils.WsEvent("workFinished", param.Type))
		}
		break
	case "manager":
		if manager, min := utils.ManagerWss[param.UserId]; min {
			_ = manager.WriteJSON(utils.WsEvent("workFinished", param.Type))
		}
		break
	default:
		utils.Logger.Printf("unrecognized user type: %s\n", param.UserType)
		break
	}
}