From 7cd5225a3835adbdce96a5192d3297c932767218 Mon Sep 17 00:00:00 2001 From: shoopea Date: Wed, 21 Aug 2019 14:37:53 +0800 Subject: [PATCH] improve orderbook ack handling --- def.go | 14 ++++++++++++++ msg.go | 32 ++++++++++++++++++++++++++++++++ workers.go | 44 +++++++++++++++++++++----------------------- 3 files changed, 67 insertions(+), 23 deletions(-) diff --git a/def.go b/def.go index 2236fb1..46ecd5a 100644 --- a/def.go +++ b/def.go @@ -110,6 +110,20 @@ type ChatWarsMessageReportAck struct { ObjID64 int64 `json:"obj_id"` } +type ChatWarsMessageOrderbookAck struct { + Msg *ChatWarsMessage `json:"msg"` + Name string `json:"name"` + Code string `json:"code"` + Qty1 int64 `json:"qty1"` + Price1 int64 `json:"price1"` + Qty2 int64 `json:"qty2"` + Price2 int64 `json:"price2"` + Qty3 int64 `json:"qty3"` + Price3 int64 `json:"price3"` + Qty int64 `json:"qty"` + Gold int64 `json:"gold"` +} + type ChatWarsMessageMeAck struct { Msg *ChatWarsMessage `json:"msg"` CWUserID64 int64 `json:"user_id"` diff --git a/msg.go b/msg.go index b5efb82..2abb9a4 100644 --- a/msg.go +++ b/msg.go @@ -1,6 +1,7 @@ package main import ( + "errors" "fmt" "log" "regexp" @@ -9,6 +10,18 @@ import ( "time" ) +func getMsgParsingRule(m *ChatWarsMessage) (*MessageParsingRule, error) { + var i int + for i = 0; i < len(msgParsingRules) && msgParsingRules[i].re.FindStringSubmatch(m.Text) == nil; i++ { + + } + if i == len(msgParsingRules) { + return nil, errors.New("Can't find message type in rules.") + } else { + return msgParsingRules[i], nil + } +} + func parseSubTypeMessageReportAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageReportAck, error) { cwm := ChatWarsMessageReportAck{} /* @@ -29,6 +42,22 @@ func parseSubTypeMessageReportAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWa return &cwm, nil } +func parseSubTypeMessageOrderbookAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageOrderbookAck, error) { + cwm := ChatWarsMessageOrderbookAck{} + log.Printf("parseSubTypeMessageOrderbookAck : Orderbook identified\n") + log.Printf("parseSubTypeMessageOrderbookAck : Name : %s\n", r.ReplaceAllString(m.Text, "${Name}")) + log.Printf("parseSubTypeMessageOrderbookAck : Code : %s\n", r.ReplaceAllString(m.Text, "${Code}")) + log.Printf("parseSubTypeMessageOrderbookAck : Qty : %s\n", r.ReplaceAllString(m.Text, "${Qty}")) + log.Printf("parseSubTypeMessageOrderbookAck : Gold : %s\n", r.ReplaceAllString(m.Text, "${Gold}")) + log.Printf("parseSubTypeMessageOrderbookAck : Qty1 : %s\n", r.ReplaceAllString(m.Text, "${Qty1}")) + log.Printf("parseSubTypeMessageOrderbookAck : Price1 : %s\n", r.ReplaceAllString(m.Text, "${Price1}")) + log.Printf("parseSubTypeMessageOrderbookAck : Qty2 : %s\n", r.ReplaceAllString(m.Text, "${Qty2}")) + log.Printf("parseSubTypeMessageOrderbookAck : Price2 : %s\n", r.ReplaceAllString(m.Text, "${Price2}")) + log.Printf("parseSubTypeMessageOrderbookAck : Qty3 : %s\n", r.ReplaceAllString(m.Text, "${Qty3}")) + log.Printf("parseSubTypeMessageOrderbookAck : Price3 : %s\n", r.ReplaceAllString(m.Text, "${Price3}")) + return &cwm, nil +} + func parseSubTypeMessageAuctionAnnounce(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMessageAuctionAnnounce, error) { cwm := ChatWarsMessageAuctionAnnounce{} @@ -104,6 +133,7 @@ func parseSubTypeMessageMeAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWarsMe log.Printf("parseSubTypeMessageReport : BagUsed : %s\n", r.ReplaceAllString(m.Text, "${BagUsed}")) log.Printf("parseSubTypeMessageReport : BagDispo : %s\n", r.ReplaceAllString(m.Text, "${BagDispo}")) */ + cwm.Msg = m return &cwm, nil } @@ -148,6 +178,7 @@ func parseSubTypeMessageGRolesAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatWa log.Printf("cwm.SquireID64 : %d\n", cwm.SquireID64) log.Printf("cwm.TreasurerID64 : %d\n", cwm.TreasurerID64) */ + cwm.Msg = m return &cwm, nil } @@ -171,6 +202,7 @@ func parseSubTypeMessageGoQuestAck(m *ChatWarsMessage, r *regexp.Regexp) (*ChatW } else { cwm.Duration = 0 * time.Minute } + cwm.Msg = m return &cwm, nil } diff --git a/workers.go b/workers.go index c4a23f0..2961d82 100644 --- a/workers.go +++ b/workers.go @@ -331,16 +331,13 @@ func SQLIdentifyMsgWorker(id int, objIds <-chan int64) { logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Retrieving message.") if err == nil { //log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Message retrieved (%d)\n%s\n", objId, m.Text) - for i = 0; i < len(msgParsingRules) && msgParsingRules[i].re.FindStringSubmatch(m.Text) == nil; i++ { - - } - if i == len(msgParsingRules) { - log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Can't find message type in rules(%d)\n%s\n", objId, m.Text) + rule, err := getMsgParsingRule(m) + if err != nil { + logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : msgRegex.") } else { - r := msgParsingRules[i].re - err = setObjSubTypeId(objId, msgParsingRules[i].MsgTypeID) + err = setObjSubTypeId(objId, rule.MsgTypeID) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : setObjSubTypeId") - switch msgParsingRules[i].MsgTypeID { + switch rule.MsgTypeID { case objSubTypeMessageGRolesReq: case objSubTypeMessageGo: case objSubTypeMessageReportReq: @@ -377,20 +374,20 @@ func SQLIdentifyMsgWorker(id int, objIds <-chan int64) { case objSubTypeMessageGStockPartReq: case objSubTypeMessageGStockOthReq: case objSubTypeMessageGStockAnyAck: - _, err := parseSubTypeMessageGStockAnyAck(m, r) + _, err := parseSubTypeMessageGStockAnyAck(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGStockAnyAck.") case objSubTypeMessageReportAck: - cwm, err := parseSubTypeMessageReportAck(m, r) + cwm, err := parseSubTypeMessageReportAck(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageReportAck.") cwm.ObjID64 = objId case objSubTypeMessageMiniWar: - cwm, err := parseSubTypeMessageMiniWar(m, r) + cwm, err := parseSubTypeMessageMiniWar(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageMiniWar.") cwm.ObjID64 = objId err = insertMsgMiniWar(cwm) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgMiniWar") case objSubTypeMessagePillageInc: - cwm, err := parseSubTypeMessagePillageInc(m, r) + cwm, err := parseSubTypeMessagePillageInc(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessagePillageInc.") cwm.ObjID64 = objId err = insertMsgPillageInc(cwm) @@ -412,16 +409,14 @@ func SQLIdentifyMsgWorker(id int, objIds <-chan int64) { logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : createJob(JobPillage)") } case objSubTypeMessageMeAck: - cwm, err := parseSubTypeMessageMeAck(m, r) + cwm, err := parseSubTypeMessageMeAck(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageMeAck.") - cwm.Msg = m clientMsgMeAck(cwm) _, err = addObjXP(cwm.CWUserID64, cwm.ExpNow, cwm.ExpLvl, cwm.Level, m.Date) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : addObjXP(MeAck)") case objSubTypeMessageGoQuestAck: - cwm, err := parseSubTypeMessageGoQuestAck(m, r) + cwm, err := parseSubTypeMessageGoQuestAck(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGoQuestAck.") - cwm.Msg = m uid, err := clientGetCWUserID64(m.TGUserID64) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Retrieving UserID64.") if err != nil { @@ -431,21 +426,20 @@ func SQLIdentifyMsgWorker(id int, objIds <-chan int64) { _, err = addObjQuest(uid, cwm.QuestTypeID, cwm.Duration, m.Date.UTC()) } case objSubTypeMessageDuelFight: - cwm, err := parseSubTypeMessageDuelFight(m, r) + cwm, err := parseSubTypeMessageDuelFight(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageDuelFight.") cwm.ObjID64 = objId err = insertMsgDuelFight(cwm) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : insertMsgDuelFight") case objSubTypeMessageUnionWar: - _, err := parseSubTypeMessageUnionWar(m, r) + _, err := parseSubTypeMessageUnionWar(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageUnionWar.") case objSubTypeMessageGRolesAck: - cwm, err := parseSubTypeMessageGRolesAck(m, r) + cwm, err := parseSubTypeMessageGRolesAck(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageGRolesAck.") - cwm.Msg = m clientMsgGRolesAck(cwm) case objSubTypeMessageAuctionAnnounce: - cwm, err := parseSubTypeMessageAuctionAnnounce(m, r) + cwm, err := parseSubTypeMessageAuctionAnnounce(m, rule.re) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageAuctionAnnounce.") cwm.ObjID64 = objId err = insertMsgAuctionAnnounce(cwm) @@ -465,17 +459,21 @@ func SQLIdentifyMsgWorker(id int, objIds <-chan int64) { case objSubTypeMessageTimeAck: _, err := fromChatWarsDate(r.ReplaceAllString(m.Text, "${Day}") + " " + r.ReplaceAllString(m.Text, "${Month}") + " " + r.ReplaceAllString(m.Text, "${Year}") + " " + r.ReplaceAllString(m.Text, "${Hour}") + ":" + r.ReplaceAllString(m.Text, "${Minute}")) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : fromChatWarsDate") + case objSubTypeMessageOrderbookAck: + cwm, err := parseSubTypeMessageOrderbookAck(m, rule.re) + logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Parsing objSubTypeMessageOrderbookAck.") + default: log.Printf("SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : Unknwon message type in rule %d : %d (%d)\n%s\n", msgParsingRules[i].ID, msgParsingRules[i].MsgTypeID, objId, m.Text) } muxCallbacks.Lock() if mc1, mok1 := callbacks[m.TGUserID64]; mok1 { - if mc2, mok2 := mc1[msgParsingRules[i].MsgTypeID]; mok2 { + if mc2, mok2 := mc1[rule.MsgTypeID]; mok2 { for j := range mc2 { err := rescheduleJob(mc2[j], m.ObjID64, time.Now().UTC()) logOnError(err, "SQLIdentifyMsgWorker["+strconv.Itoa(id)+"] : callbacks triggering") } - mc1[msgParsingRules[i].MsgTypeID] = nil + mc1[rule.MsgTypeID] = nil } } muxCallbacks.Unlock()