penguin/golifehk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Refactoring codes for more tg message types

Browse Source
This commit is contained in:
斟酌 鵬兄
2026-03-07 22:16:14 +08:00
parent a396a381b5
commit 912f9fd0ad
26 changed files with 771 additions and 472 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
adaptors/tg/botsend.go Normal file
View File

@@ -0,0 +1,56 @@
package tg
import (
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
query "github.com/tgckpg/golifehk/query"
)
func BotSendText(bot *tgbotapi.BotAPI, update *tgbotapi.Update, mesg *string) {
var msg tgbotapi.MessageConfig
msg = tgbotapi.NewMessage(update.Message.Chat.ID, *mesg)
msg.ParseMode = "MarkdownV2"
msg.ReplyToMessageID = update.Message.MessageID
bot.Send(msg)
}
func BotSend(bot *tgbotapi.BotAPI, update *tgbotapi.Update, qResult query.IQueryResult) (bool, error) {
var msg tgbotapi.MessageConfig
mesg, err := qResult.Message()
if err != nil {
// not sent, error
return false, err
}
mesgType := qResult.DataType()
switch mesgType {
case "IGNORE":
// not sent with no error tells the parent to look for other processors
return false, nil
}
msg = tgbotapi.NewMessage(update.Message.Chat.ID, mesg)
msg.ParseMode = "MarkdownV2"
switch mesgType {
case "PlainText":
case "Table":
button := tgbotapi.NewInlineKeyboardButtonData(
"Show Status", // what user sees
"status_cmd", // what bot receives
)
msg.ReplyMarkup = tgbotapi.NewInlineKeyboardMarkup(
tgbotapi.NewInlineKeyboardRow(button, button),
)
}
msg.ReplyToMessageID = update.Message.MessageID
bot.Send(msg)
return true, nil
}

6
datasources/cjlookup/CChar.go
View File

@@ -12,7 +12,8 @@ type CChar struct {
JyutPing *CJyutPing
DukJam *[]*DukJam
_JiDukJam *[]*CJyutPing
query.Searchable
query.Words
query.NoGeoLocation
}
type DukJam struct {
@@ -25,7 +26,8 @@ type CJyutPing struct {
SearchKey string // Searchable key
TungJamZi *[]*CChar
tSorted bool
query.Searchable
query.Words
query.NoGeoLocation
}
func (this *CJyutPing) Test(val string) bool {

11
datasources/cjlookup/QueryResult.go
View File

@@ -13,6 +13,9 @@ type QueryResult struct {
Lang string
Error error
Query *query.QueryObject
ResultType string
isConsumed bool
}
func writeCCharInfo(sb *strings.Builder, cc *CChar) {
@@ -37,14 +40,20 @@ func writeCCharInfo(sb *strings.Builder, cc *CChar) {
}
}
func (this QueryResult) DataType() string { return this.ResultType }
func (this QueryResult) Consumed() bool { return this.isConsumed }
func (this QueryResult) GetTableData() [][]map[string]string { return nil }
func (this QueryResult) Message() (string, error) {
this.ResultType = "PlainText"
if this.Error != nil {
return "", this.Error
}
if this.Query == nil {
panic("Query is nil")
return "", nil
}
sb := strings.Builder{}

14
datasources/cjlookup/query.go
View File

@@ -1,13 +1,16 @@
package cjlookup
import (
"fmt"
"strings"
"github.com/tgckpg/golifehk/query"
)
func Query(lang string, message string) query.IQueryResult {
func Query(q query.QueryMessage) query.IQueryResult {
lang := q.Lang
message := q.Text
var qResults *query.QueryObject
var err error
var searchables *[]query.ISearchable
@@ -17,9 +20,12 @@ func Query(lang string, message string) query.IQueryResult {
// Only look up jyut ping
if !strings.HasPrefix(messageU, "JP ") {
err = fmt.Errorf("Invalid query")
qr.ResultType = "IGNORE"
goto qrReturn
}
qr.isConsumed = true
if err != nil {
qr.Error = err
goto qrReturn
@@ -28,7 +34,7 @@ func Query(lang string, message string) query.IQueryResult {
messageU = messageU[3:]
searchables, err = getSearchables()
qResults, err = query.Parse(messageU, searchables)
qResults, err = query.MatchKeys(messageU, searchables)
qr.Query = qResults

265
datasources/kmb/QueryResult.go
View File

@@ -1,176 +1,181 @@
package kmb
import (
"fmt"
"sort"
"strings"
"time"
"fmt"
"sort"
"strings"
"time"
query "github.com/tgckpg/golifehk/query"
utils "github.com/tgckpg/golifehk/utils"
query "github.com/tgckpg/golifehk/query"
utils "github.com/tgckpg/golifehk/utils"
)
type QueryResult struct {
Schedules *map[*RouteStop] *[] *Schedule
Lang string
Error error
Query *query.QueryObject
Schedules *map[*RouteStop]*[]*Schedule
Lang string
Error error
Query *query.QueryObject
isConsumed bool
}
func writeRouteHead( sb *strings.Builder, r *RouteStop ) {
utils.WriteMDv2Text( sb, r.RouteId )
if r.Direction == "O" {
sb.WriteString( "↑" )
} else if r.Direction == "I" {
sb.WriteString( "↓" )
}
if r.ServiceType != "1" {
utils.WriteMDv2Text( sb, utils.ToPower( r.ServiceType ) )
}
func writeRouteHead(sb *strings.Builder, r *RouteStop) {
utils.WriteMDv2Text(sb, r.RouteId)
if r.Direction == "O" {
sb.WriteString("↑")
} else if r.Direction == "I" {
sb.WriteString("↓")
}
if r.ServiceType != "1" {
utils.WriteMDv2Text(sb, utils.ToPower(r.ServiceType))
}
}
func writeShortRoute( lang *string, sb *strings.Builder, r *RouteStop ) {
func writeShortRoute(lang *string, sb *strings.Builder, r *RouteStop) {
if r.PrevStop() != nil {
utils.WriteMDv2Text( sb, (*(r.PrevStop().BusStop).Name)[ *lang ] )
sb.WriteString( " \\> " )
}
if r.PrevStop() != nil {
utils.WriteMDv2Text(sb, (*(r.PrevStop().BusStop).Name)[*lang])
sb.WriteString(" \\> ")
}
sb.WriteString( "*" )
utils.WriteMDv2Text( sb, (*(r.BusStop).Name)[ *lang ] )
sb.WriteString( "*" )
sb.WriteString("*")
utils.WriteMDv2Text(sb, (*(r.BusStop).Name)[*lang])
sb.WriteString("*")
if r.NextStop() != nil {
sb.WriteString( " \\> " )
utils.WriteMDv2Text( sb, (*(r.NextStop().BusStop).Name)[ *lang ] )
}
if r.NextStop() != nil {
sb.WriteString(" \\> ")
utils.WriteMDv2Text(sb, (*(r.NextStop().BusStop).Name)[*lang])
}
sb.WriteString( "\n" )
sb.WriteString("\n")
}
func ( this *QueryResult ) Message() ( string, error ) {
func (this QueryResult) DataType() string { return "MarkdownV2" }
func (this QueryResult) Consumed() bool { return this.isConsumed }
func (this QueryResult) GetTableData() [][]map[string]string { return nil }
if this.Error != nil {
return "", this.Error
}
func (this *QueryResult) Message() (string, error) {
sb := strings.Builder{}
if this.Error != nil {
return "", this.Error
}
if 0 < len( *this.Query.Results ) {
sb := strings.Builder{}
// Print Stop Names, then print the list of routes
if this.Query.Key == "" {
busStops := map[string] *BusStop{}
for _, item := range *this.Query.Results {
var r *RouteStop
r = any( item ).( *RouteStop )
if 0 < len(*this.Query.Results) {
b := r.BusStop
if b.Routes == nil {
continue
}
// Print Stop Names, then print the list of routes
if this.Query.Key == "" {
busStops := map[string]*BusStop{}
for _, item := range *this.Query.Results {
var r *RouteStop
r = any(item).(*RouteStop)
busStops[ b.BusStopId ] = b
}
b := r.BusStop
if b.Routes == nil {
continue
}
for _, b := range busStops {
utils.WriteMDv2Text( &sb, (*b.Name)[ this.Lang ] )
sb.WriteString( "\n " )
for _, route := range *b.Routes {
writeRouteHead( &sb, route )
sb.WriteString( " " )
}
sb.WriteString( "\n" )
}
busStops[b.BusStopId] = b
}
// We got a route key
} else {
for _, b := range busStops {
utils.WriteMDv2Text(&sb, (*b.Name)[this.Lang])
sb.WriteString("\n ")
for _, route := range *b.Routes {
writeRouteHead(&sb, route)
sb.WriteString(" ")
}
sb.WriteString("\n")
}
// We also got other search keys with 1 < Results
// Get the ETA for this stop
if 1 < len( *this.Query.SearchTerms ) {
// We got a route key
} else {
now := time.Now()
for _, item := range *this.Query.Results {
var r *RouteStop
r = any( item ).( *RouteStop )
writeRouteHead( &sb, r )
sb.WriteString( "\n" )
writeShortRoute( &this.Lang, &sb, r )
// We also got other search keys with 1 < Results
// Get the ETA for this stop
if 1 < len(*this.Query.SearchTerms) {
for _, schedule := range *(*this.Schedules)[ r ] {
now := time.Now()
for _, item := range *this.Query.Results {
var r *RouteStop
r = any(item).(*RouteStop)
writeRouteHead(&sb, r)
sb.WriteString("\n")
writeShortRoute(&this.Lang, &sb, r)
if !schedule.ETA.IsZero() {
for _, schedule := range *(*this.Schedules)[r] {
_m := schedule.ETA.Sub( now ).Minutes()
if !schedule.ETA.IsZero() {
sb.WriteString( " \\* " )
txt := "%.0f min(s)"
_m := schedule.ETA.Sub(now).Minutes()
if this.Lang == "zh-Hant" {
txt = "%.0f 分鐘"
}
sb.WriteString(" \\* ")
txt := "%.0f min(s)"
utils.WriteMDv2Text( &sb, fmt.Sprintf( txt, _m ) )
if this.Lang == "zh-Hant" {
txt = "%.0f 分鐘"
}
if _m < 0 {
sb.WriteString( " 走左了？" )
}
}
utils.WriteMDv2Text(&sb, fmt.Sprintf(txt, _m))
if schedule.Remarks_en != "" {
sb.WriteString( " \\*\\* " )
switch this.Lang {
case "en":
utils.WriteMDv2Text( &sb, schedule.Remarks_en )
case "zh-Hant":
utils.WriteMDv2Text( &sb, schedule.Remarks_tc )
}
}
if _m < 0 {
sb.WriteString(" 走左了？")
}
}
sb.WriteString( "\n" )
}
if schedule.Remarks_en != "" {
sb.WriteString(" \\*\\* ")
switch this.Lang {
case "en":
utils.WriteMDv2Text(&sb, schedule.Remarks_en)
case "zh-Hant":
utils.WriteMDv2Text(&sb, schedule.Remarks_tc)
}
}
sb.WriteString( "\n" )
}
sb.WriteString("\n")
}
// We got only the route key, proceed to list the route stops
} else {
// Result contains all route stops, we only need the starting one
routes := [] *RouteStop{}
sb.WriteString("\n")
}
for _, item := range *this.Query.Results {
var r *RouteStop
r = any( item ).( *RouteStop )
if r.PrevStop() == nil {
routes = append( routes, r )
}
}
// We got only the route key, proceed to list the route stops
} else {
// Result contains all route stops, we only need the starting one
routes := []*RouteStop{}
sort.Sort( ByRoute( routes ) )
for _, item := range *this.Query.Results {
var r *RouteStop
r = any(item).(*RouteStop)
if r.PrevStop() == nil {
routes = append(routes, r)
}
}
for _, r := range routes {
writeRouteHead( &sb, r )
sb.WriteString( "\n" )
for {
b := *r.BusStop
utils.WriteMDv2Text( &sb, (*b.Name)[ this.Lang ] )
r = r.NextStop()
if r == nil {
break
}
sort.Sort(ByRoute(routes))
sb.WriteString( " \\> " )
}
sb.WriteString( "\n" )
}
for _, r := range routes {
writeRouteHead(&sb, r)
sb.WriteString("\n")
for {
b := *r.BusStop
utils.WriteMDv2Text(&sb, (*b.Name)[this.Lang])
r = r.NextStop()
if r == nil {
break
}
sb.WriteString(" \\> ")
}
sb.WriteString("\n")
}
}
}
} else {
return "", fmt.Errorf( "No Results" )
}
}
}
} else {
return "", fmt.Errorf("No Results")
}
return sb.String(), nil
return sb.String(), nil
}

85
datasources/kmb/RouteStop.go
View File

@@ -1,65 +1,66 @@
package kmb
import (
query "github.com/tgckpg/golifehk/query"
query "github.com/tgckpg/golifehk/query"
)
type RouteStop struct {
BusStop *BusStop
RouteId string `json:"route"`
ServiceType string `json:"service_type"`
Direction string `json:"bound"`
StationSeq int `json:"seq,string"`
StationId string `json:"stop"`
BusStop *BusStop
RouteId string `json:"route"`
ServiceType string `json:"service_type"`
Direction string `json:"bound"`
StationSeq int `json:"seq,string"`
StationId string `json:"stop"`
RouteStops *map[int] *RouteStop
query.Searchable
RouteStops *map[int]*RouteStop
query.Words
query.NoGeoLocation
}
type RouteStops struct {
Type string `json:"type"`
Version string `json:"version"`
DateCreated string `json:"generated_timestamp"`
RouteStops [] *RouteStop `json:"data"`
Type string `json:"type"`
Version string `json:"version"`
DateCreated string `json:"generated_timestamp"`
RouteStops []*RouteStop `json:"data"`
}
func ( routeStop RouteStop ) PrevStop() *RouteStop {
if v, hasKey := (*routeStop.RouteStops)[ routeStop.StationSeq - 1 ]; hasKey {
return v
}
return nil
func (routeStop RouteStop) PrevStop() *RouteStop {
if v, hasKey := (*routeStop.RouteStops)[routeStop.StationSeq-1]; hasKey {
return v
}
return nil
}
func ( routeStop RouteStop ) NextStop() *RouteStop {
if v, hasKey := (*routeStop.RouteStops)[ routeStop.StationSeq + 1 ]; hasKey {
return v
}
return nil
func (routeStop RouteStop) NextStop() *RouteStop {
if v, hasKey := (*routeStop.RouteStops)[routeStop.StationSeq+1]; hasKey {
return v
}
return nil
}
func ( this *RouteStop ) Reload() {
func (this *RouteStop) Reload() {
searchData := [] *string{}
busStop := *this.BusStop
searchData = append( searchData, &busStop.Name_en )
searchData = append( searchData, &busStop.Name_tc )
searchData := []*string{}
busStop := *this.BusStop
searchData = append(searchData, &busStop.Name_en)
searchData = append(searchData, &busStop.Name_tc)
this.Key = &this.RouteId
this.SearchData = &searchData
this.Key = &this.RouteId
this.SearchData = &searchData
}
type ByRoute [] *RouteStop
type ByRoute []*RouteStop
func (a ByRoute) Len() int { return len(a) }
func (a ByRoute) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByRoute) Len() int { return len(a) }
func (a ByRoute) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByRoute) Less(i, j int) bool {
_a := *a[i]
_b := *a[j]
if _a.RouteId == _b.RouteId {
if _a.Direction == _b.Direction {
return _a.ServiceType < _b.ServiceType
}
return _a.Direction < _b.Direction
}
return _a.RouteId < _b.RouteId
_a := *a[i]
_b := *a[j]
if _a.RouteId == _b.RouteId {
if _a.Direction == _b.Direction {
return _a.ServiceType < _b.ServiceType
}
return _a.Direction < _b.Direction
}
return _a.RouteId < _b.RouteId
}

7
datasources/kmb/query.go
View File

@@ -6,7 +6,10 @@ import (
"strings"
)
func Query(lang string, message string) query.IQueryResult {
func Query(q query.QueryMessage) query.IQueryResult {
lang := q.Lang
message := q.Text
var qo *query.QueryObject
var err error
@@ -18,7 +21,7 @@ func Query(lang string, message string) query.IQueryResult {
goto qrReturn
}
qo, err = query.Parse(strings.ToUpper(message), routeStops)
qo, err = query.MatchKeys(strings.ToUpper(message), routeStops)
if err != nil {
qr.Error = err
goto qrReturn

12
datasources/mtr/bus/BusStop.go
View File

@@ -2,6 +2,7 @@ package bus
import (
i18n "github.com/tgckpg/golifehk/i18n"
query "github.com/tgckpg/golifehk/query"
)
type BusStop struct {
@@ -10,8 +11,6 @@ type BusStop struct {
Direction string
StationSeq int
StationId string
Latitude float64
Longtitude float64
Name_zh string
Name_en string
@@ -22,6 +21,7 @@ type BusStop struct {
AltRoutes *map[string]*BusStop
i18n.Generics
query.GeoLocation
}
func (this *BusStop) PrevStop() *BusStop {
@@ -52,6 +52,14 @@ func (this *BusStop) Reload() {
this.SearchData = &searchData
}
func (this BusStop) Register(registers map[string]struct{}) bool {
if _, ok := registers[this.StationId]; ok {
return false
}
registers[this.StationId] = struct{}{}
return true
}
type ByRoute []*BusStop
func (a ByRoute) Len() int { return len(a) }

48
datasources/mtr/bus/QueryResult.go
View File

@@ -14,7 +14,10 @@ type QueryResult struct {
Schedules *map[*BusStop]*BusStopBuses
Lang string
Error error
Source *query.QueryMessage
Query *query.QueryObject
isConsumed bool
}
func writeShortRoute(lang *string, sb *strings.Builder, b *BusStop) {
@@ -35,6 +38,10 @@ func writeShortRoute(lang *string, sb *strings.Builder, b *BusStop) {
sb.WriteString("\n")
}
func (this QueryResult) DataType() string { return "MarkdownV2" }
func (this QueryResult) Consumed() bool { return this.isConsumed }
func (this QueryResult) GetTableData() [][]map[string]string { return nil }
func (this QueryResult) Message() (string, error) {
if this.Error != nil {
@@ -56,12 +63,41 @@ func (this QueryResult) Message() (string, error) {
}
if q.Key == "" {
sort.Sort(query.ByKey(*q.Results))
for _, entry := range *q.Results {
busStop := any(entry).(*BusStop)
utils.WriteMDv2Text(&sb, busStop.RouteId)
sb.WriteString(" ")
writeShortRoute(&this.Lang, &sb, busStop)
loc := q.Message.Location
if loc != nil {
// Print nearest bus stops
for _, entry := range *q.Results {
busStop := any(entry).(*BusStop)
utils.WriteMDv2Text(&sb, fmt.Sprintf("%.2fm", busStop.Dist(loc.Lat(), loc.Lon())))
sb.WriteString(" ")
sb.WriteString(" [")
utils.WriteMDv2Text(&sb, busStop.RouteId)
d := busStop.Direction
if d == "O" {
sb.WriteString("↑")
} else if d == "I" {
sb.WriteString("↓")
} else {
sb.WriteString("\\?")
}
utils.WriteMDv2Text(&sb, (*busStop.Name)[this.Lang])
utils.WriteMDv2Text(&sb, busStop.RouteId)
utils.WriteMDv2Text(&sb, (*busStop.Name)[this.Lang])
sb.WriteString(")")
sb.WriteString("\n")
}
} else {
sort.Sort(query.ByKey(*q.Results))
for _, entry := range *q.Results {
busStop := any(entry).(*BusStop)
utils.WriteMDv2Text(&sb, busStop.RouteId)
sb.WriteString(" ")
writeShortRoute(&this.Lang, &sb, busStop)
}
}
} else if 1 == len(*q.SearchTerms) {

2
datasources/mtr/bus/busstops.go
View File

@@ -50,7 +50,7 @@ func readBusStopData(r io.Reader) (*map[string]*BusStop, error) {
entry.Latitude = v
case "STATION_LONGITUDE":
v, _ := strconv.ParseFloat(value, 64)
entry.Longtitude = v
entry.Longitude = v
case "STATION_NAME_CHI":
entry.Name_zh = value
case "STATION_NAME_ENG":

13
datasources/mtr/bus/query.go
View File

@@ -6,7 +6,9 @@ import (
query "github.com/tgckpg/golifehk/query"
)
func Query(lang string, message string) query.IQueryResult {
func Query(q query.QueryMessage) query.IQueryResult {
lang := q.Lang
var qBusStops *query.QueryObject
var err error
@@ -18,7 +20,14 @@ func Query(lang string, message string) query.IQueryResult {
goto qrReturn
}
qBusStops, err = query.Parse(strings.ToUpper(message), busStops)
if q.Text != "" {
qBusStops, err = query.MatchKeys(strings.ToUpper(q.Text), busStops)
} else if q.Location != nil {
qBusStops, err = query.MatchNearest(*q.Location, busStops, 100, 3)
}
qBusStops.Message = &q
if err != nil {
qr.Error = err
goto qrReturn

2
go.mod
View File

@@ -7,3 +7,5 @@ require (
golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa
golang.org/x/text v0.34.0
)
require github.com/tidwall/geodesic v1.52.4 // indirect

2
go.sum
View File

@@ -1,5 +1,7 @@
github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1 h1:wG8n/XJQ07TmjbITcGiUaOtXxdrINDz1b0J1w0SzqDc=
github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1/go.mod h1:A2S0CWkNylc2phvKXWBBdD3K0iGnDBGbzRpISP2zBl8=
github.com/tidwall/geodesic v1.52.4 h1:nT9cvYziVbmqFMDuvJzCJKvBJ9wFx0gRwvVrt86fpXg=
github.com/tidwall/geodesic v1.52.4/go.mod h1:SNL5vSG4X+o0ExTya69PX7/ZQ2SAvmjAxI+o5ZGJsxs=
golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0=
golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA=
golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk=

6
i18n/Generics.go
View File

@@ -1,10 +1,10 @@
package i18n
import (
query "github.com/tgckpg/golifehk/query"
query "github.com/tgckpg/golifehk/query"
)
type Generics struct {
Name *map[string] string
query.Searchable
Name *map[string]string
query.Words
}

42
main.go
View File

@@ -6,6 +6,7 @@ import (
"os"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
tgadaptor "github.com/tgckpg/golifehk/adaptors/tg"
cjlookup "github.com/tgckpg/golifehk/datasources/cjlookup"
kmb "github.com/tgckpg/golifehk/datasources/kmb"
mtrbus "github.com/tgckpg/golifehk/datasources/mtr/bus"
@@ -13,15 +14,6 @@ import (
utils "github.com/tgckpg/golifehk/utils"
)
func botsend(bot *tgbotapi.BotAPI, update *tgbotapi.Update, mesg *string) {
var msg tgbotapi.MessageConfig
msg = tgbotapi.NewMessage(update.Message.Chat.ID, *mesg)
msg.ParseMode = "MarkdownV2"
msg.ReplyToMessageID = update.Message.MessageID
bot.Send(msg)
}
func main() {
bot, err := tgbotapi.NewBotAPI(os.Getenv("TELEGRAM_API_TOKEN"))
if err != nil {
@@ -48,12 +40,12 @@ func main() {
mesg, processed := utils.SystemControl(update.Message)
if processed {
if mesg != "" {
botsend(bot, &update, &mesg)
tgadaptor.BotSendText(bot, &update, &mesg)
}
continue
}
f_queries := []func(string, string) query.IQueryResult{
f_queries := []func(query.QueryMessage) query.IQueryResult{
cjlookup.Query,
mtrbus.Query,
kmb.Query,
@@ -61,21 +53,35 @@ func main() {
var f_sent bool = false
var f_err error = nil
for _, Query := range f_queries {
var err error
mesg, err = Query("zh-Hant", update.Message.Text).Message()
if err == nil {
tgMesg := update.Message
q := query.QueryMessage{Lang: "zh-Hant", Text: tgMesg.Text}
if tgMesg.Location != nil {
q.Location = &query.GeoLocation{tgMesg.Location.Latitude, tgMesg.Location.Longitude}
}
for _, Query := range f_queries {
qResult := Query(q)
sent, err := tgadaptor.BotSend(bot, &update, qResult)
if sent {
f_sent = true
botsend(bot, &update, &mesg)
} else if f_err == nil {
}
if err != nil {
f_err = err
}
if qResult.Consumed() {
break
}
}
if !isGroup && !f_sent && f_err != nil {
mesg := utils.MDv2Text(fmt.Sprintf("%s", f_err))
botsend(bot, &update, &mesg)
tgadaptor.BotSendText(bot, &update, &mesg)
}
}
}

59
query/GeoLocation.go Normal file
View File

@@ -0,0 +1,59 @@
package query
import (
"github.com/tidwall/geodesic"
"sort"
)
type GeoLocation struct {
Latitude float64
Longitude float64
}
func (b GeoLocation) HasGeoLocation() bool { return true }
func (b GeoLocation) Lat() float64 { return b.Latitude }
func (b GeoLocation) Lon() float64 { return b.Longitude }
func (b GeoLocation) Dist(lat float64, lon float64) float64 {
var dist float64
geodesic.WGS84.Inverse(
lat, lon,
b.Latitude, b.Longitude,
&dist, nil, nil,
)
return dist
}
type NoGeoLocation struct{}
func (b NoGeoLocation) HasGeoLocation() bool { return false }
func (b NoGeoLocation) Lat() float64 { return 0 }
func (b NoGeoLocation) Lon() float64 { return 0 }
func (b NoGeoLocation) Dist(lat, lon float64) float64 { return 0 }
func (b NoGeoLocation) Register(map[string]struct{}) bool {
return false
}
type GeoLocations []ISearchable
func (m GeoLocations) SortByNearest(p GeoLocation) {
sort.Slice(m, func(i, j int) bool {
return m[i].Dist(p.Lat(), p.Lon()) < m[j].Dist(p.Lat(), p.Lon())
})
}
func (b GeoLocation) Register(map[string]struct{}) bool {
return false
}
func (m GeoLocations) Clean() *GeoLocations {
registers := map[string]struct{}{}
items := &GeoLocations{}
for _, item := range m {
if item.HasGeoLocation() && item.Register(registers) {
*items = append(*items, item)
}
}
return items
}

5
query/IQueryResult.go
View File

@@ -1,5 +0,0 @@
package query
type IQueryResult interface {
Message() ( string, error )
}

47
query/Searchable.go
View File

@@ -1,40 +1,15 @@
package query
import (
"strings"
)
type ISearchable interface {
Test( string ) bool
GetKey() *string
HasWords() bool
Test(string) bool
GetKey() *string
HasGeoLocation() bool
Lat() float64
Lon() float64
Dist(lat float64, lon float64) float64
// Clean() filtering
Register(map[string]struct{}) bool
}
type Searchable struct {
Key *string
SearchData *[] *string
}
func ( this *Searchable ) Test( val string ) bool {
data := this.SearchData
if data == nil {
return false
}
for _, v := range *data {
if strings.Contains( *v, val ) {
return true
}
}
return false
}
func ( this *Searchable ) GetKey() *string {
return this.Key
}
type ByKey [] ISearchable
func (a ByKey) Len() int { return len(a) }
func (a ByKey) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByKey) Less(i, j int) bool { return *a[i].GetKey() < *a[j].GetKey() }

43
query/Words.go Normal file
View File

@@ -0,0 +1,43 @@
package query
import (
"strings"
)
type Words struct {
Key *string
SearchData *[]*string
}
func (this *Words) HasWords() bool { return true }
func (this *Words) Test(val string) bool {
data := this.SearchData
if data == nil {
return false
}
for _, v := range *data {
if strings.Contains(*v, val) {
return true
}
}
return false
}
func (this *Words) GetKey() *string {
return this.Key
}
type ByKey []ISearchable
func (a ByKey) Len() int { return len(a) }
func (a ByKey) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
func (a ByKey) Less(i, j int) bool { return *a[i].GetKey() < *a[j].GetKey() }
type NoWords struct{}
func (this NoWords) HasWords() bool { return false }
func (this NoWords) Test(val string) bool { return false }
func (this NoWords) GetKey() *string { return nil }

33
query/geo_test.go Normal file
View File

@@ -0,0 +1,33 @@
package query
import (
"fmt"
"testing"
)
type City struct {
Name string
NoWords
GeoLocation
}
func TestGeo(t *testing.T) {
B := GeoLocations{
City{Name: "Osaka", GeoLocation: GeoLocation{34.6937, 135.5023}},
City{Name: "Nagoya", GeoLocation: GeoLocation{35.1815, 136.9066}},
City{Name: "Sapporo", GeoLocation: GeoLocation{43.0618, 141.3545}},
City{Name: "Yokohama", GeoLocation: GeoLocation{35.4437, 139.6380}},
}
// Reference point A (Tokyo)
A := GeoLocation{35.6895, 139.6917}
// Sort by distance
B.SortByNearest(A)
// Print result
for _, loc := range B {
fmt.Printf("%s: %.2f km\n", loc.(City).Name, loc.Dist(A.Lat(), A.Lon())/1000)
}
}

69
query/match_keys.go Normal file
View File

@@ -0,0 +1,69 @@
package query
import (
"fmt"
"strings"
)
func MatchKeys(line string, entries *[]ISearchable) (*QueryObject, error) {
var Key string = ""
// Sanitize and assume properties for each of the keywords
terms := []*QTerm{}
for _, val := range strings.Split(line, " ") {
if val == "" {
continue
}
term := QTerm{
Org: val,
Value: strings.Trim(val, " "),
}
terms = append(terms, &term)
}
lookForKey:
for _, term := range terms {
for _, entry := range *entries {
if term.Value == *entry.GetKey() {
Key = term.Value
term.IsKey = true
break lookForKey
}
}
}
matches := []ISearchable{}
if Key != "" && len(terms) == 1 {
for _, entry := range *entries {
if Key == *entry.GetKey() {
matches = append(matches, entry)
}
}
return &QueryObject{Key: Key, Results: &matches, SearchTerms: &terms}, nil
} else if 0 < len(terms) {
for _, entry := range *entries {
anyFailed := false
for _, term := range terms {
if term.IsKey {
continue
}
if !((Key == "" || Key == *entry.GetKey()) && entry.Test(term.Value)) {
anyFailed = true
break
}
}
if !anyFailed {
matches = append(matches, entry)
}
}
return &QueryObject{Key: Key, Results: &matches, SearchTerms: &terms}, nil
}
return nil, fmt.Errorf("Cannot parse: %s", line)
}

29
query/match_locations.go Normal file
View File

@@ -0,0 +1,29 @@
package query
import (
"fmt"
)
func MatchNearest(p GeoLocation, entries *[]ISearchable, dist float64, limit int) (*QueryObject, error) {
terms := []*QTerm{
{
Org: fmt.Sprintf("%f, %f", p.Lat(), p.Lon()),
Value: "",
},
}
var locs *GeoLocations
locs = GeoLocations(*entries).Clean()
locs.SortByNearest(p)
matches := []ISearchable{}
for i, loc := range *locs {
if i < limit {
matches = append(matches, loc)
}
}
return &QueryObject{Key: "", Results: &matches, SearchTerms: &terms}, nil
}

27
query/objects.go Normal file
View File

@@ -0,0 +1,27 @@
package query
type QTerm struct {
Org string
Value string
IsKey bool
}
type QueryMessage struct {
Lang string
Text string
Location *GeoLocation
}
type QueryObject struct {
Key string
Message *QueryMessage
SearchTerms *[]*QTerm
Results *[]ISearchable
}
type IQueryResult interface {
Message() (string, error)
DataType() string
GetTableData() [][]map[string]string
Consumed() bool
}

81
query/query.go
View File

@@ -1,81 +0,0 @@
package query
import (
"fmt"
"strings"
)
type QTerm struct {
Org string
Value string
IsKey bool
}
type QueryObject struct {
Key string
SearchTerms *[] *QTerm
Results *[] ISearchable
}
func Parse( line string, entries *[] ISearchable ) ( *QueryObject, error ) {
var Key string = ""
// Sanitize and assume properties for each of the keywords
terms := [] *QTerm{}
for _, val := range strings.Split( line, " " ) {
if val == "" {
continue
}
term := QTerm{
Org: val,
Value: strings.Trim( val, " " ),
}
terms = append( terms, &term )
}
lookForKey:
for _, term := range terms {
for _, entry := range *entries {
if term.Value == *entry.GetKey() {
Key = term.Value
term.IsKey = true
break lookForKey
}
}
}
matches := [] ISearchable{}
if Key != "" && len( terms ) == 1 {
for _, entry := range *entries {
if Key == *entry.GetKey() {
matches = append( matches, entry )
}
}
return &QueryObject{ Key: Key, Results: &matches, SearchTerms: &terms }, nil
} else if 0 < len( terms ) {
for _, entry := range *entries {
anyFailed := false
for _, term := range terms {
if term.IsKey {
continue
}
if !( ( Key == "" || Key == *entry.GetKey() ) && entry.Test( term.Value ) ) {
anyFailed = true
break
}
}
if !anyFailed {
matches = append( matches, entry )
}
}
return &QueryObject{ Key: Key, Results: &matches, SearchTerms: &terms }, nil
}
return nil, fmt.Errorf( "Cannot parse: %s", line )
}

115
query/query_test.go
View File

@@ -5,75 +5,76 @@ import (
)
type TestItem struct {
Searchable
Words
NoGeoLocation
}
func TestQuery( t *testing.T ) {
testItems := [] ISearchable{}
func TestQuery(t *testing.T) {
testItems := []ISearchable{}
s1234 := "1234"
sApple := "Apple"
s0000 := "0000"
s1234 := "1234"
sApple := "Apple"
s0000 := "0000"
sDat0 := "Dat0"
data0 := [] *string{}
data0 = append( data0, &s1234 )
data0 = append( data0, &sApple )
t0 := TestItem{}
t0.Key = &sDat0
t0.SearchData = &data0
testItems = append( testItems, &t0 )
sDat0 := "Dat0"
data0 := []*string{}
data0 = append(data0, &s1234)
data0 = append(data0, &sApple)
t0 := TestItem{}
t0.Key = &sDat0
t0.SearchData = &data0
testItems = append(testItems, &t0)
sDat1 := "Dat1"
data1 := [] *string{}
data1 = append( data1, &s0000 )
data1 = append( data1, &sApple )
t1 := TestItem{}
t1.Key = &sDat1
t1.SearchData = &data1
testItems = append( testItems, &t1 )
sDat1 := "Dat1"
data1 := []*string{}
data1 = append(data1, &s0000)
data1 = append(data1, &sApple)
t1 := TestItem{}
t1.Key = &sDat1
t1.SearchData = &data1
testItems = append(testItems, &t1)
sDat2 := "Dat2"
data2 := [] *string{}
data2 = append( data2, &sDat0 )
t2 := TestItem{}
t2.Key = &sDat2
t2.SearchData = &data2
testItems = append( testItems, &t2 )
sDat2 := "Dat2"
data2 := []*string{}
data2 = append(data2, &sDat0)
t2 := TestItem{}
t2.Key = &sDat2
t2.SearchData = &data2
testItems = append(testItems, &t2)
qo, err := Parse( "Apple", &testItems )
if err != nil {
t.Error( err )
}
qo, err := MatchKeys("Apple", &testItems)
if err != nil {
t.Error(err)
}
if len(*qo.Results) != 2 {
t.Error( "Expected 2 results when searching for \"Apple\"" )
}
if len(*qo.Results) != 2 {
t.Error("Expected 2 results when searching for \"Apple\"")
}
qo, err = Parse( "0000", &testItems )
if err != nil {
t.Error( err )
}
qo, err = MatchKeys("0000", &testItems)
if err != nil {
t.Error(err)
}
if len(*qo.Results) != 1 {
t.Error( "Expected 1 results when searching for \"0000\"" )
}
if len(*qo.Results) != 1 {
t.Error("Expected 1 results when searching for \"0000\"")
}
qo, err = Parse( "Dat0", &testItems )
if err != nil {
t.Error( err )
}
qo, err = MatchKeys("Dat0", &testItems)
if err != nil {
t.Error(err)
}
if len(*qo.Results) != 1 {
t.Error( "Expected 1 results when searching for \"Dat0\"" )
}
if len(*qo.Results) != 1 {
t.Error("Expected 1 results when searching for \"Dat0\"")
}
qo, err = Parse( "Dat2 Dat0", &testItems )
if err != nil {
t.Error( err )
}
qo, err = MatchKeys("Dat2 Dat0", &testItems)
if err != nil {
t.Error(err)
}
if len(*qo.Results) != 1 {
t.Error( "Expected 1 results when searching for \"Dat2 Dat0\"" )
}
if len(*qo.Results) != 1 {
t.Error("Expected 1 results when searching for \"Dat2 Dat0\"")
}
}

164
utils/system.go
View File

@@ -1,96 +1,100 @@
package utils
import (
"bytes"
"encoding/json"
"fmt"
"io"
"log"
"path/filepath"
"strings"
"time"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
"bytes"
"encoding/json"
"fmt"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
"io"
"log"
"path/filepath"
"strings"
"time"
)
var JSON_SETTINGS string = filepath.Join( WORKDIR, "settings.json" )
var JSON_SETTINGS string = filepath.Join(WORKDIR, "settings.json")
var settingsTime = time.Unix( 0, 0 )
var settingsTime = time.Unix(0, 0)
type SysSettings struct {
IgnoredChats map[int64] bool `json:"IgnoredChats"`
IgnoredChats map[int64]bool `json:"IgnoredChats"`
}
var Settings = SysSettings{ IgnoredChats: map[int64] bool{} }
var Settings = SysSettings{IgnoredChats: map[int64]bool{}}
func rwSettings() {
buff, err := ChangedStream( JSON_SETTINGS, writeSettings, settingsTime )
if err != nil {
log.Panic( err )
return
}
conf := SysSettings{}
err = json.Unmarshal( buff.Bytes(), &conf )
if err != nil {
log.Panic( err )
return
}
Settings = conf
}
func writeSettings() ( io.Reader, error ) {
b, err := json.Marshal( Settings )
if err != nil {
return nil, err
}
return bytes.NewBuffer( b ), nil
}
func SystemControl( tgMesg *tgbotapi.Message ) ( string, bool ) {
rwSettings()
processed := false
mesg := ""
if tgMesg.Text[0] == '/' {
processed = true
}
chatId := tgMesg.Chat.ID
if Settings.IgnoredChats == nil {
Settings.IgnoredChats = map[int64] bool{}
}
if strings.Contains( tgMesg.Text, "/golifehk disable" ) {
mesg = fmt.Sprintf( "OK" )
Settings.IgnoredChats[ chatId ] = true
processed = true
}
if strings.Contains( tgMesg.Text, "/golifehk enable" ) {
mesg = fmt.Sprintf( "OK" )
Settings.IgnoredChats[ chatId ] = false
processed = true
}
if processed {
settingsTime = time.Now()
rwSettings()
}
//// Begin processing settings
// ignore chats if enabled
if ignore, ok := Settings.IgnoredChats[ chatId ]; ok {
processed = processed || ignore;
} else {
// default ignore
processed = true;
buff, err := ChangedStream(JSON_SETTINGS, writeSettings, settingsTime)
if err != nil {
log.Panic(err)
return
}
return mesg, processed
conf := SysSettings{}
err = json.Unmarshal(buff.Bytes(), &conf)
if err != nil {
log.Panic(err)
return
}
Settings = conf
}
func writeSettings() (io.Reader, error) {
b, err := json.Marshal(Settings)
if err != nil {
return nil, err
}
return bytes.NewBuffer(b), nil
}
func SystemControl(tgMesg *tgbotapi.Message) (string, bool) {
rwSettings()
processed := false
mesg := ""
if tgMesg.Text == "" {
return "", false
}
if tgMesg.Text[0] == '/' {
processed = true
}
chatId := tgMesg.Chat.ID
if Settings.IgnoredChats == nil {
Settings.IgnoredChats = map[int64]bool{}
}
if strings.Contains(tgMesg.Text, "/golifehk disable") {
mesg = fmt.Sprintf("OK")
Settings.IgnoredChats[chatId] = true
processed = true
}
if strings.Contains(tgMesg.Text, "/golifehk enable") {
mesg = fmt.Sprintf("OK")
Settings.IgnoredChats[chatId] = false
processed = true
}
if processed {
settingsTime = time.Now()
rwSettings()
}
//// Begin processing settings
// ignore chats if enabled
if ignore, ok := Settings.IgnoredChats[chatId]; ok {
processed = processed || ignore
} else {
// default ignore
processed = true
}
return mesg, processed
}