381 lines
11 KiB
Go
381 lines
11 KiB
Go
package core
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
|
|
"github.com/go-redis/redis/v8"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
"repositories.action2quare.com/ayo/gocommon"
|
|
"repositories.action2quare.com/ayo/gocommon/logger"
|
|
"repositories.action2quare.com/ayo/gocommon/wshandler"
|
|
)
|
|
|
|
type channelID = string
|
|
type channelConfig struct {
|
|
Capacity int64 `json:"capacity"`
|
|
Size int64 `json:"size"`
|
|
Key string `json:"key"`
|
|
emptyJson string
|
|
}
|
|
|
|
type chatConfig struct {
|
|
DefaultCapacity int64 `json:"default_capacity"`
|
|
Channels map[string]*channelConfig `json:"channels"`
|
|
}
|
|
|
|
type groupChat struct {
|
|
chatConfig
|
|
rh *gocommon.RedisonHandler
|
|
enterRoom func(channelID, accountID)
|
|
leaveRoom func(channelID, accountID)
|
|
sendUpstreamMessage func(msg *wshandler.UpstreamMessage)
|
|
}
|
|
|
|
func (gc *groupChat) Initialize(tv *Tavern, cfg configDocument) error {
|
|
rem, _ := json.Marshal(cfg)
|
|
if err := json.Unmarshal(rem, &gc.chatConfig); err != nil {
|
|
return err
|
|
}
|
|
|
|
gc.enterRoom = func(chanid channelID, accid accountID) {
|
|
tv.wsh.EnterRoom(string(chanid), accid)
|
|
}
|
|
gc.leaveRoom = func(chanid channelID, accid accountID) {
|
|
tv.wsh.LeaveRoom(string(chanid), accid)
|
|
}
|
|
gc.sendUpstreamMessage = func(msg *wshandler.UpstreamMessage) {
|
|
tv.wsh.SendUpstreamMessage(msg)
|
|
}
|
|
|
|
gc.rh = tv.redison
|
|
|
|
for name, cfg := range gc.chatConfig.Channels {
|
|
if cfg.Capacity == 0 {
|
|
cfg.Capacity = gc.chatConfig.DefaultCapacity
|
|
}
|
|
cfg.Key = name
|
|
cfg.Size = 0
|
|
|
|
jm, _ := json.Marshal(cfg)
|
|
cfg.emptyJson = fmt.Sprintf("[%s]", string(jm))
|
|
|
|
_, err := gc.rh.JSONSet(name, "$", cfg)
|
|
if *devflag && err != nil {
|
|
gc.rh.JSONDel(name, "$")
|
|
_, err = gc.rh.JSONSet(name, "$", cfg)
|
|
}
|
|
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (gc *groupChat) ClientConnected(ctx wshandler.ApiCallContext) {
|
|
gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel", map[string]any{})
|
|
}
|
|
|
|
func (gc *groupChat) ClientDisconnected(ctx wshandler.ApiCallContext) {
|
|
docs, _ := gc.rh.JSONGetDocuments(ctx.CallBy.Accid.Hex(), "$.channel")
|
|
|
|
if len(docs) > 0 {
|
|
for k, v := range docs[0] {
|
|
typename := k
|
|
chanid := v.(string)
|
|
gc.leaveRoom(chanid, ctx.CallBy.Accid)
|
|
if k == "public" {
|
|
gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
|
|
} else {
|
|
gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + chanid,
|
|
Body: map[string]any{"sender": ctx.CallBy.Alias, "typename": typename},
|
|
Tag: []string{"LeavePrivateChannel"},
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (gc *groupChat) EnterPublicChannel(ctx wshandler.ApiCallContext) {
|
|
chanid := ctx.Arguments[0].(string)
|
|
if cfg, ok := gc.chatConfig.Channels[chanid]; ok {
|
|
size, err := gc.rh.JSONGetInt64(chanid, "$.size")
|
|
if err != nil || len(size) == 0 {
|
|
logger.Println("JSONGetInt64 failed :", chanid, err)
|
|
} else if size[0] < cfg.Capacity {
|
|
// 입장
|
|
newsize, err := gc.rh.JSONNumIncrBy(chanid, "$.size", 1)
|
|
if err == nil {
|
|
gc.enterRoom(chanid, ctx.CallBy.Accid)
|
|
gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel.public", chanid)
|
|
gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + chanid,
|
|
Body: map[string]any{"size": newsize[0]},
|
|
Tag: []string{"ChattingChannelProperties"},
|
|
})
|
|
}
|
|
} else {
|
|
// 풀방
|
|
logger.Println("chatting channel is full :", chanid, size, cfg.Capacity)
|
|
}
|
|
} else {
|
|
logger.Println("chatting channel not valid :", chanid)
|
|
}
|
|
}
|
|
|
|
func (gc *groupChat) LeavePublicChannel(ctx wshandler.ApiCallContext) {
|
|
chanid := ctx.Arguments[0].(string)
|
|
cnt, _ := gc.rh.JSONDel(ctx.CallBy.Accid.Hex(), "$.channel.public")
|
|
if cnt > 0 {
|
|
gc.leaveRoom(chanid, ctx.CallBy.Accid)
|
|
gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
|
|
}
|
|
}
|
|
|
|
func (gc *groupChat) TextMessage(ctx wshandler.ApiCallContext) {
|
|
chanid := ctx.Arguments[0].(string)
|
|
msg := ctx.Arguments[1].(string)
|
|
gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + chanid,
|
|
Body: map[string]any{"sender": ctx.CallBy.Alias, "msg": msg},
|
|
Tag: []string{"TextMessage"},
|
|
})
|
|
}
|
|
|
|
func (gc *groupChat) EnterPrivateChannel(ctx wshandler.ApiCallContext) {
|
|
typename := ctx.Arguments[0].(string)
|
|
channel := ctx.Arguments[1].(string)
|
|
var reason string
|
|
if len(ctx.Arguments) > 2 {
|
|
reason = ctx.Arguments[2].(string)
|
|
}
|
|
|
|
if len(reason) > 0 {
|
|
// 수락
|
|
ok, err := gc.rh.JSONSet(ctx.CallBy.Accid.Hex(), "$.channel."+typename, channel, gocommon.RedisonSetOptionNX)
|
|
if err != nil || !ok {
|
|
// 이미 다른 private channel 참여 중
|
|
logger.Println("EnterPrivateChannel failed. HSetNX return err :", err, ctx.CallBy.Accid.Hex(), typename, channel)
|
|
return
|
|
}
|
|
gc.enterRoom(channel, ctx.CallBy.Accid)
|
|
}
|
|
|
|
gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + channel,
|
|
Body: map[string]any{
|
|
"sender": ctx.CallBy.Alias,
|
|
"msg": reason,
|
|
"typename": typename,
|
|
},
|
|
Tag: []string{"EnterPrivateChannel"},
|
|
})
|
|
}
|
|
|
|
func (gc *groupChat) LeavePrivateChannel(ctx wshandler.ApiCallContext) {
|
|
typename := ctx.Arguments[0].(string)
|
|
chanid := ctx.Arguments[1].(string)
|
|
cnt, _ := gc.rh.JSONDel(ctx.CallBy.Accid.Hex(), "$.channel."+typename)
|
|
if cnt > 0 {
|
|
gc.leaveRoom(chanid, ctx.CallBy.Accid)
|
|
gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
Target: "#" + chanid,
|
|
Body: map[string]any{"sender": ctx.CallBy.Alias, "typename": typename},
|
|
Tag: []string{"LeavePrivateChannel"},
|
|
})
|
|
}
|
|
}
|
|
|
|
// func (gc *groupChat) ClientMessageReceived(sender *wshandler.Sender, mt wshandler.WebSocketMessageType, message any) {
|
|
// if mt == wshandler.Disconnected {
|
|
// if _, err := gc.rh.Del(gc.rh.Context(), accidHex(sender.Accid)).Result(); err != nil {
|
|
// logger.Println(err)
|
|
// }
|
|
// } else if mt == wshandler.BinaryMessage {
|
|
// commandline := message.([]any)
|
|
// cmd := commandline[0].(string)
|
|
// args := commandline[1:]
|
|
// switch cmd {
|
|
// case "EnterPublicChannel":
|
|
// chanid := args[0].(string)
|
|
// if cfg, ok := gc.chatConfig.Channels[chanid]; ok {
|
|
// size, err := gc.rh.JSONGetInt64(chanid, "$.size")
|
|
// if err != nil || len(size) == 0 {
|
|
// logger.Println("JSONGetInt64 failed :", chanid, err)
|
|
// } else if size[0] < cfg.Capacity {
|
|
// // 입장
|
|
// newsize, err := gc.rh.JSONNumIncrBy(chanid, "$.size", 1)
|
|
// if err == nil {
|
|
// gc.enterRoom(chanid, sender.Accid)
|
|
// sender.RegistDisconnectedCallback(chanid, func() {
|
|
// size, err := gc.rh.JSONNumIncrBy(chanid, "$.size", -1)
|
|
// if err == nil {
|
|
// gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
// Target: "#" + chanid,
|
|
// Body: map[string]any{"size": size},
|
|
// Tag: []string{"ChattingChannelProperties"},
|
|
// })
|
|
// }
|
|
// })
|
|
|
|
// gc.rh.HSet(gc.rh.Context(), accidHex(sender.Accid), "cc_pub", chanid)
|
|
// gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
// Target: "#" + chanid,
|
|
// Body: map[string]any{"size": newsize[0]},
|
|
// Tag: []string{"ChattingChannelProperties"},
|
|
// })
|
|
// }
|
|
// } else {
|
|
// // 풀방
|
|
// logger.Println("chatting channel is full :", chanid, size, cfg.Capacity)
|
|
// }
|
|
// } else {
|
|
// logger.Println("chatting channel not valid :", chanid)
|
|
// }
|
|
|
|
// case "LeavePublicChannel":
|
|
// chanid := args[0].(string)
|
|
// gc.rh.HDel(gc.rh.Context(), accidHex(sender.Accid), "cc_pub")
|
|
// gc.leaveRoom(chanid, sender.Accid)
|
|
// if f := sender.PopDisconnectedCallback(chanid); f != nil {
|
|
// f()
|
|
// }
|
|
|
|
// case "TextMessage":
|
|
// chanid := args[0].(string)
|
|
// msg := args[1].(string)
|
|
// gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
// Target: "#" + chanid,
|
|
// Body: map[string]any{"sender": sender.Alias, "msg": msg},
|
|
// Tag: []string{"TextMessage"},
|
|
// })
|
|
|
|
// case "EnterPrivateChannel":
|
|
// typename := args[0].(string)
|
|
// channel := args[1].(string)
|
|
// var reason string
|
|
// if len(args) > 2 {
|
|
// reason = args[2].(string)
|
|
// }
|
|
|
|
// if len(reason) > 0 {
|
|
// // 수락
|
|
// // 이거 HSet 하면 안되겠는데? JSONSet해야할 듯?
|
|
// ok, err := gc.rh.HSetNX(gc.rh.Context(), accidHex(sender.Accid), "cc_"+typename, channel).Result()
|
|
// if err != nil || !ok {
|
|
// // 이미 다른 private channel 참여 중
|
|
// logger.Println("EnterPrivateChannel failed. HSetNX return err :", err, sender.Accid.Hex(), typename, channel)
|
|
// return
|
|
// }
|
|
// gc.enterRoom(channel, sender.Accid)
|
|
|
|
// sender.RegistDisconnectedCallback(channel, func() {
|
|
// gc.rh.JSONDel(channel, "$."+sender.Accid.Hex())
|
|
// // 이거 HDel 하면 안되겠는데? JSONDel해야할 듯?
|
|
// cnt, _ := gc.rh.HDel(gc.rh.Context(), accidHex(sender.Accid), "cc_"+typename).Result()
|
|
// if cnt > 0 {
|
|
// gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
// Target: "#" + channel,
|
|
// Body: map[string]any{"sender": sender.Alias, "typename": typename},
|
|
// Tag: []string{"LeavePrivateChannel"},
|
|
// })
|
|
// }
|
|
// })
|
|
// } else {
|
|
// // 내가 이미 private channel에 있다는 것을 다른 사람들에게 알려주기 위함
|
|
// }
|
|
|
|
// gc.sendUpstreamMessage(&wshandler.UpstreamMessage{
|
|
// Target: "#" + channel,
|
|
// Body: map[string]any{
|
|
// "sender": sender.Alias,
|
|
// "msg": reason,
|
|
// "typename": typename,
|
|
// },
|
|
// Tag: []string{"EnterPrivateChannel"},
|
|
// })
|
|
|
|
// case "LeavePrivateChannel":
|
|
// channel := args[1].(string)
|
|
// gc.leaveRoom(channel, sender.Accid)
|
|
// if f := sender.PopDisconnectedCallback(channel); f != nil {
|
|
// f()
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
func (gc *groupChat) FetchChattingChannels(w http.ResponseWriter, r *http.Request) {
|
|
var prefix string
|
|
if err := gocommon.MakeDecoder(r).Decode(&prefix); err != nil {
|
|
logger.Println("FetchChattingChannels failed. ReadJsonDocumentFromBody returns err :", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if len(prefix) == 0 {
|
|
logger.Println("FetchChattingChannel failed. prefix is missing")
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
var rows []string
|
|
for name, cfg := range gc.chatConfig.Channels {
|
|
if len(prefix) > 0 {
|
|
if !strings.HasPrefix(name, prefix) {
|
|
continue
|
|
}
|
|
}
|
|
|
|
onechan, err := gc.rh.JSONGet(name, "$")
|
|
if err != nil && err != redis.Nil {
|
|
logger.Println("FetchChattingChannel failed. HGetAll return err :", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
if err == redis.Nil || onechan == nil {
|
|
rows = append(rows, cfg.emptyJson)
|
|
} else {
|
|
// json array로 나온다
|
|
rows = append(rows, strings.Trim(onechan.(string), "[]"))
|
|
}
|
|
}
|
|
|
|
gocommon.MakeEncoder(w, r).Encode(rows)
|
|
}
|
|
|
|
func (gc *groupChat) QueryPlayerChattingChannel(w http.ResponseWriter, r *http.Request) {
|
|
var accid primitive.ObjectID
|
|
if err := gocommon.MakeDecoder(r).Decode(&accid); err != nil {
|
|
logger.Println("QueryPlayerChattingChannel failed. ReadJsonDocumentFromBody returns err :", err)
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
sub, err := gc.rh.JSONGetDocuments(accid.Hex(), "$.channel")
|
|
if err != nil {
|
|
w.WriteHeader(http.StatusInternalServerError)
|
|
return
|
|
}
|
|
if len(sub) > 0 {
|
|
gocommon.MakeEncoder(w, r).Encode(sub[0])
|
|
}
|
|
}
|
|
|
|
func (gc *groupChat) SendMessageOnChannel(w http.ResponseWriter, r *http.Request) {
|
|
var msg wshandler.UpstreamMessage
|
|
if err := gocommon.MakeDecoder(r).Decode(&msg); err != nil {
|
|
logger.Println("SendMessageOnChannel failed. ReadJsonDocumentFromBody return err :", err)
|
|
w.WriteHeader(http.StatusBadRequest)
|
|
return
|
|
}
|
|
|
|
gc.sendUpstreamMessage(&msg)
|
|
}
|