1142 lines
35 KiB
Go
1142 lines
35 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"encoding/xml"
|
|
"fmt"
|
|
skype "github.com/kelaresg/go-skypeapi"
|
|
skypeExt "github.com/kelaresg/matrix-skype/skype-ext"
|
|
"sort"
|
|
//"strconv"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
//"github.com/pkg/errors"
|
|
"github.com/skip2/go-qrcode"
|
|
log "maunium.net/go/maulogger/v2"
|
|
"maunium.net/go/mautrix"
|
|
|
|
//"github.com/Rhymen/go-whatsapp"
|
|
//waProto "github.com/Rhymen/go-whatsapp/binary/proto"
|
|
|
|
"maunium.net/go/mautrix/event"
|
|
"maunium.net/go/mautrix/id"
|
|
|
|
"github.com/kelaresg/matrix-skype/database"
|
|
"github.com/kelaresg/matrix-skype/types"
|
|
//"github.com/kelaresg/matrix-skype/whatsapp-ext"
|
|
)
|
|
|
|
type User struct {
|
|
*database.User
|
|
Conn *skypeExt.ExtendedConn
|
|
|
|
bridge *Bridge
|
|
log log.Logger
|
|
|
|
Admin bool
|
|
Whitelisted bool
|
|
RelaybotWhitelisted bool
|
|
|
|
IsRelaybot bool
|
|
|
|
ConnectionErrors int
|
|
CommunityID string
|
|
|
|
cleanDisconnection bool
|
|
|
|
chatListReceived chan struct{}
|
|
syncPortalsDone chan struct{}
|
|
|
|
messages chan PortalMessage
|
|
syncLock sync.Mutex
|
|
|
|
mgmtCreateLock sync.Mutex
|
|
|
|
contactsPresence map[string]*skypeExt.Presence
|
|
}
|
|
|
|
func (bridge *Bridge) GetUserByMXID(userID id.UserID) *User {
|
|
_, isPuppet := bridge.ParsePuppetMXID(userID)
|
|
fmt.Println("GetUserByMXID0", userID)
|
|
fmt.Println("GetUserByMXID1", bridge.Bot.UserID)
|
|
if isPuppet || userID == bridge.Bot.UserID {
|
|
fmt.Println("GetUserByMXID2", userID)
|
|
fmt.Println("GetUserByMXID3", bridge.Bot.UserID)
|
|
return nil
|
|
}
|
|
bridge.usersLock.Lock()
|
|
defer bridge.usersLock.Unlock()
|
|
user, ok := bridge.usersByMXID[userID]
|
|
if !ok {
|
|
return bridge.loadDBUser(bridge.DB.User.GetByMXID(userID), &userID)
|
|
}
|
|
return user
|
|
}
|
|
|
|
func (bridge *Bridge) GetUserByJID(userID types.SkypeID) *User {
|
|
bridge.usersLock.Lock()
|
|
defer bridge.usersLock.Unlock()
|
|
user, ok := bridge.usersByJID[userID]
|
|
if !ok {
|
|
return bridge.loadDBUser(bridge.DB.User.GetByJID(userID), nil)
|
|
}
|
|
return user
|
|
}
|
|
|
|
func (user *User) getSkypeIdByMixId() (skypeId string){
|
|
mixIdArr := strings.Split(string(user.MXID), "&")
|
|
idArr := strings.Split(mixIdArr[1], ":"+user.bridge.Config.Homeserver.Domain)
|
|
skypeId = strings.Replace(idArr[0], "-",":",2)
|
|
return skypeId
|
|
}
|
|
|
|
func (user *User) addToJIDMap() {
|
|
user.bridge.usersLock.Lock()
|
|
user.bridge.usersByJID[user.JID] = user
|
|
user.bridge.usersLock.Unlock()
|
|
}
|
|
|
|
func (user *User) removeFromJIDMap() {
|
|
user.bridge.usersLock.Lock()
|
|
delete(user.bridge.usersByJID, user.JID)
|
|
user.bridge.usersLock.Unlock()
|
|
}
|
|
|
|
func (bridge *Bridge) GetAllUsers() []*User {
|
|
bridge.usersLock.Lock()
|
|
defer bridge.usersLock.Unlock()
|
|
dbUsers := bridge.DB.User.GetAll()
|
|
output := make([]*User, len(dbUsers))
|
|
for index, dbUser := range dbUsers {
|
|
user, ok := bridge.usersByMXID[dbUser.MXID]
|
|
if !ok {
|
|
user = bridge.loadDBUser(dbUser, nil)
|
|
}
|
|
user.contactsPresence = make(map[string]*skypeExt.Presence)
|
|
output[index] = user
|
|
}
|
|
return output
|
|
}
|
|
|
|
func (bridge *Bridge) loadDBUser(dbUser *database.User, mxid *id.UserID) *User {
|
|
if dbUser == nil {
|
|
if mxid == nil {
|
|
return nil
|
|
}
|
|
dbUser = bridge.DB.User.New()
|
|
dbUser.MXID = *mxid
|
|
dbUser.Insert()
|
|
}
|
|
user := bridge.NewUser(dbUser)
|
|
bridge.usersByMXID[user.MXID] = user
|
|
if len(user.JID) > 0 {
|
|
bridge.usersByJID[user.JID] = user
|
|
}
|
|
if len(user.ManagementRoom) > 0 {
|
|
bridge.managementRooms[user.ManagementRoom] = user
|
|
}
|
|
return user
|
|
}
|
|
|
|
func (user *User) GetPortals() []*Portal {
|
|
keys := user.User.GetPortalKeys()
|
|
portals := make([]*Portal, len(keys))
|
|
|
|
user.bridge.portalsLock.Lock()
|
|
for i, key := range keys {
|
|
portal, ok := user.bridge.portalsByJID[key]
|
|
if !ok {
|
|
portal = user.bridge.loadDBPortal(user.bridge.DB.Portal.GetByJID(key), &key)
|
|
}
|
|
portals[i] = portal
|
|
}
|
|
user.bridge.portalsLock.Unlock()
|
|
return portals
|
|
}
|
|
|
|
func (bridge *Bridge) NewUser(dbUser *database.User) *User {
|
|
user := &User{
|
|
User: dbUser,
|
|
bridge: bridge,
|
|
log: bridge.Log.Sub("User").Sub(string(dbUser.MXID)),
|
|
|
|
IsRelaybot: false,
|
|
|
|
chatListReceived: make(chan struct{}, 1),
|
|
syncPortalsDone: make(chan struct{}, 1),
|
|
messages: make(chan PortalMessage, 256),
|
|
}
|
|
user.RelaybotWhitelisted = user.bridge.Config.Bridge.Permissions.IsRelaybotWhitelisted(user.MXID)
|
|
user.Whitelisted = user.bridge.Config.Bridge.Permissions.IsWhitelisted(user.MXID)
|
|
user.Admin = user.bridge.Config.Bridge.Permissions.IsAdmin(user.MXID)
|
|
go user.handleMessageLoop()
|
|
return user
|
|
}
|
|
|
|
func (user *User) GetManagementRoom() id.RoomID {
|
|
if len(user.ManagementRoom) == 0 {
|
|
user.mgmtCreateLock.Lock()
|
|
defer user.mgmtCreateLock.Unlock()
|
|
if len(user.ManagementRoom) > 0 {
|
|
return user.ManagementRoom
|
|
}
|
|
resp, err := user.bridge.Bot.CreateRoom(&mautrix.ReqCreateRoom{
|
|
Topic: "Skype bridge notices",
|
|
IsDirect: true,
|
|
})
|
|
if err != nil {
|
|
user.log.Errorln("Failed to auto-create management room:", err)
|
|
} else {
|
|
user.SetManagementRoom(resp.RoomID)
|
|
}
|
|
}
|
|
return user.ManagementRoom
|
|
}
|
|
|
|
func (user *User) SetManagementRoom(roomID id.RoomID) {
|
|
existingUser, ok := user.bridge.managementRooms[roomID]
|
|
if ok {
|
|
existingUser.ManagementRoom = ""
|
|
existingUser.Update()
|
|
}
|
|
|
|
user.ManagementRoom = roomID
|
|
user.bridge.managementRooms[user.ManagementRoom] = user
|
|
user.Update()
|
|
}
|
|
|
|
func (user *User) SetSession(session *skype.Session) {
|
|
user.Session = session
|
|
if session == nil {
|
|
user.LastConnection = 0
|
|
}
|
|
user.Update()
|
|
}
|
|
|
|
//func (user *User) Connect(evenIfNoSession bool) bool {
|
|
// if user.Conn != nil {
|
|
// return true
|
|
// } else if !evenIfNoSession && user.Session == nil {
|
|
// return false
|
|
// }
|
|
// user.log.Debugln("Connecting to WhatsApp")
|
|
// timeout := time.Duration(user.bridge.Config.Bridge.ConnectionTimeout)
|
|
// if timeout == 0 {
|
|
// timeout = 20
|
|
// }
|
|
// conn, err := whatsapp.NewConn(timeout * time.Second)
|
|
// if err != nil {
|
|
// user.log.Errorln("Failed to connect to WhatsApp:", err)
|
|
// msg := format.RenderMarkdown("\u26a0 Failed to connect to WhatsApp server. "+
|
|
// "This indicates a network problem on the bridge server. See bridge logs for more info.", true, false)
|
|
// _, _ = user.bridge.Bot.SendMessageEvent(user.GetManagementRoom(), event.EventMessage, msg)
|
|
// return false
|
|
// }
|
|
// user.Conn = whatsappExt.ExtendConn(conn)
|
|
// _ = user.Conn.SetClientName("matrix-skype bridge", "mx-wa", SkypeVersion)
|
|
// user.log.Debugln("WhatsApp connection successful")
|
|
// user.Conn.AddHandler(user)
|
|
// return user.RestoreSession()
|
|
//}
|
|
|
|
func (user *User) Connect(evenIfNoSession bool) bool {
|
|
if user.Conn != nil {
|
|
return true
|
|
} else if !evenIfNoSession && user.Session == nil {
|
|
return false
|
|
}
|
|
user.log.Debugln("Connecting to skype")
|
|
timeout := time.Duration(user.bridge.Config.Bridge.ConnectionTimeout)
|
|
if timeout == 0 {
|
|
timeout = 20
|
|
}
|
|
conn, err := skype.NewConn()
|
|
if err != nil {
|
|
user.log.Errorln("Failed to connect to skype:", err)
|
|
//msg := format.RenderMarkdown("\u26a0 Failed to connect to WhatsApp server. "+
|
|
// "This indicates a network problem on the bridge server. See bridge logs for more info.", true, false)
|
|
//_, _ = user.bridge.Bot.SendMessageEvent(user.GetManagementRoom(), event.EventMessage, msg)
|
|
return false
|
|
}
|
|
user.Conn = skypeExt.ExtendConn(conn)
|
|
//_ = user.Conn.SetClientName("matrix-skype bridge", "mx-wa", SkypeVersion)
|
|
user.log.Debugln("skype connection successful")
|
|
user.Conn.AddHandler(user)
|
|
return user.RestoreSession()
|
|
}
|
|
|
|
func (user *User) RestoreSession() bool {
|
|
if user.Session != nil {
|
|
//sess, err := user.Conn.RestoreWithSession(*user.Session)
|
|
//if err == whatsapp.ErrAlreadyLoggedIn {
|
|
// return true
|
|
//} else if err != nil {
|
|
// user.log.Errorln("Failed to restore session:", err)
|
|
// msg := format.RenderMarkdown("\u26a0 Failed to connect to WhatsApp. Make sure WhatsApp "+
|
|
// "on your phone is reachable and use `reconnect` to try connecting again.", true, false)
|
|
// _, _ = user.bridge.Bot.SendMessageEvent(user.GetManagementRoom(), event.EventMessage, msg)
|
|
// user.log.Debugln("Disconnecting due to failed session restore...")
|
|
// _, err := user.Conn.Disconnect()
|
|
// if err != nil {
|
|
// user.log.Errorln("Failed to disconnect after failed session restore:", err)
|
|
// }
|
|
// return false
|
|
//}
|
|
//user.ConnectionErrors = 0
|
|
//user.SetSession(&sess)
|
|
//user.log.Debugln("Session restored successfully")
|
|
//user.PostLogin()
|
|
}
|
|
return true
|
|
}
|
|
|
|
func (user *User) HasSession() bool {
|
|
//return user.Session != nil
|
|
return true
|
|
}
|
|
|
|
func (user *User) IsConnected() bool {
|
|
//return user.Conn != nil && user.Conn.IsConnected() && user.Conn.IsLoggedIn()
|
|
return true
|
|
}
|
|
|
|
func (user *User) IsLoginInProgress() bool {
|
|
return user.Conn != nil && user.Conn.IsLoginInProgress()
|
|
}
|
|
|
|
func (user *User) loginQrChannel(ce *CommandEvent, qrChan <-chan string, eventIDChan chan<- id.EventID) {
|
|
var qrEventID id.EventID
|
|
for code := range qrChan {
|
|
if code == "stop" {
|
|
return
|
|
}
|
|
qrCode, err := qrcode.Encode(code, qrcode.Low, 256)
|
|
if err != nil {
|
|
user.log.Errorln("Failed to encode QR code:", err)
|
|
ce.Reply("Failed to encode QR code: %v", err)
|
|
return
|
|
}
|
|
|
|
bot := user.bridge.AS.BotClient()
|
|
|
|
resp, err := bot.UploadBytes(qrCode, "image/png")
|
|
if err != nil {
|
|
user.log.Errorln("Failed to upload QR code:", err)
|
|
ce.Reply("Failed to upload QR code: %v", err)
|
|
return
|
|
}
|
|
|
|
if qrEventID == "" {
|
|
sendResp, err := bot.SendImage(ce.RoomID, code, resp.ContentURI)
|
|
if err != nil {
|
|
user.log.Errorln("Failed to send QR code to user:", err)
|
|
return
|
|
}
|
|
qrEventID = sendResp.EventID
|
|
eventIDChan <- qrEventID
|
|
} else {
|
|
_, err = bot.SendMessageEvent(ce.RoomID, event.EventMessage, &event.MessageEventContent{
|
|
MsgType: event.MsgImage,
|
|
Body: code,
|
|
URL: resp.ContentURI.CUString(),
|
|
NewContent: &event.MessageEventContent{
|
|
MsgType: event.MsgImage,
|
|
Body: code,
|
|
URL: resp.ContentURI.CUString(),
|
|
},
|
|
RelatesTo: &event.RelatesTo{
|
|
Type: event.RelReplace,
|
|
EventID: qrEventID,
|
|
},
|
|
})
|
|
if err != nil {
|
|
user.log.Errorln("Failed to send edited QR code to user:", err)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func (user *User) Login(ce *CommandEvent, name string, password string) (err error) {
|
|
if user.contactsPresence == nil {
|
|
user.contactsPresence = make(map[string]*skypeExt.Presence)
|
|
}
|
|
err = user.Conn.Login(name, password)
|
|
if err != nil {
|
|
user.log.Errorln("Failed to login:", err)
|
|
ce.Reply(err.Error())
|
|
return err
|
|
}
|
|
username := user.Conn.UserProfile.FirstName
|
|
if len(user.Conn.UserProfile.LastName) > 0 {
|
|
username = username + user.Conn.UserProfile.LastName
|
|
}
|
|
ce.Reply("Successfully logged in as @" + username)
|
|
|
|
user.Conn.Subscribes() // subscribe basic event
|
|
err = user.Conn.Conn.ContactList(user.Conn.UserProfile.Username)
|
|
if err == nil{
|
|
var userIds []string
|
|
for _, contact := range user.Conn.Store.Contacts {
|
|
if strings.Index(contact.PersonId, "28:") > -1 {
|
|
continue
|
|
}
|
|
userId := strings.Replace(contact.PersonId, skypeExt.NewUserSuffix, "", 1)
|
|
userIds = append(userIds, userId)
|
|
}
|
|
ce.User.Conn.SubscribeUsers(userIds)
|
|
go loopPresence(ce, user)
|
|
}
|
|
go user.Conn.Poll()
|
|
|
|
user.ConnectionErrors = 0
|
|
user.SetSession(user.Conn.LoginInfo)
|
|
user.JID = "8:" + user.Conn.UserProfile.Username + skypeExt.NewUserSuffix
|
|
user.addToJIDMap()
|
|
_ = ce.User.Conn.GetConversations("", user.bridge.Config.Bridge.InitialChatSync)
|
|
return
|
|
}
|
|
|
|
func loopPresence(ce *CommandEvent, user *User) {
|
|
for {
|
|
if user.Conn.LoggedIn == false {
|
|
ce.Reply("Session expired")
|
|
break
|
|
}
|
|
for cid, contact := range user.contactsPresence {
|
|
puppet := user.bridge.GetPuppetByJID(cid)
|
|
_ = puppet.DefaultIntent().SetPresence(event.Presence(strings.ToLower(contact.Availability)))
|
|
}
|
|
time.Sleep(39 * time.Second)
|
|
}
|
|
}
|
|
|
|
type Chat struct {
|
|
Portal *Portal
|
|
LastMessageTime uint64
|
|
Contact skype.Conversation
|
|
}
|
|
|
|
type ChatList []Chat
|
|
|
|
func (cl ChatList) Len() int {
|
|
return len(cl)
|
|
}
|
|
|
|
func (cl ChatList) Less(i, j int) bool {
|
|
return cl[i].LastMessageTime > cl[j].LastMessageTime
|
|
}
|
|
|
|
func (cl ChatList) Swap(i, j int) {
|
|
cl[i], cl[j] = cl[j], cl[i]
|
|
}
|
|
|
|
func (user *User) PostLogin() {
|
|
user.log.Debugln("Locking processing of incoming messages and starting post-login sync")
|
|
user.syncLock.Lock()
|
|
go user.intPostLogin()
|
|
}
|
|
|
|
func (user *User) tryAutomaticDoublePuppeting() {
|
|
fmt.Println("tryAutomaticDoublePuppeting")
|
|
if len(user.bridge.Config.Bridge.LoginSharedSecret) == 0 {
|
|
fmt.Println("tryAutomaticDoublePuppeting-1", user.bridge.Config.Bridge.LoginSharedSecret)
|
|
// Automatic login not enabled
|
|
return
|
|
} else if _, homeserver, _ := user.MXID.Parse(); homeserver != user.bridge.Config.Homeserver.Domain {
|
|
fmt.Println("tryAutomaticDoublePuppeting-2", user.MXID)
|
|
fmt.Println("tryAutomaticDoublePuppeting-21", homeserver)
|
|
fmt.Println("tryAutomaticDoublePuppeting--3", user.bridge.Config.Homeserver.Domain)
|
|
// user is on another homeserver
|
|
return
|
|
}
|
|
fmt.Println("tryAutomaticDoublePuppeting1")
|
|
puppet := user.bridge.GetPuppetByJID(user.JID)
|
|
if len(puppet.CustomMXID) > 0 {
|
|
// Custom puppet already enabled
|
|
return
|
|
}
|
|
fmt.Println("tryAutomaticDoublePuppeting2", user.MXID)
|
|
accessToken, err := puppet.loginWithSharedSecret(user.MXID)
|
|
if err != nil {
|
|
user.log.Warnln("Failed to login with shared secret:", err)
|
|
return
|
|
}
|
|
err = puppet.SwitchCustomMXID(accessToken, user.MXID)
|
|
if err != nil {
|
|
puppet.log.Warnln("Failed to switch to auto-logined custom puppet:", err)
|
|
return
|
|
}
|
|
user.log.Infoln("Successfully automatically enabled custom puppet")
|
|
}
|
|
|
|
func (user *User) intPostLogin() {
|
|
defer user.syncLock.Unlock()
|
|
user.createCommunity()
|
|
user.tryAutomaticDoublePuppeting()
|
|
|
|
select {
|
|
case <-user.chatListReceived:
|
|
user.log.Debugln("Chat list receive confirmation received in PostLogin")
|
|
case <-time.After(time.Duration(user.bridge.Config.Bridge.ChatListWait) * time.Second):
|
|
user.log.Warnln("Timed out waiting for chat list to arrive! Unlocking processing of incoming messages.")
|
|
return
|
|
}
|
|
select {
|
|
case <-user.syncPortalsDone:
|
|
user.log.Debugln("Post-login portal sync complete, unlocking processing of incoming messages.")
|
|
case <-time.After(time.Duration(user.bridge.Config.Bridge.PortalSyncWait) * time.Second):
|
|
user.log.Warnln("Timed out waiting for chat list to arrive! Unlocking processing of incoming messages.")
|
|
}
|
|
}
|
|
|
|
func (user *User) HandleChatList(chats []skype.Conversation) {
|
|
user.log.Infoln("Chat list received")
|
|
chatMap := make(map[string]skype.Conversation)
|
|
//for _, chat := range user.Conn.Store.Chats {
|
|
// chatMap[chat.Jid] = chat
|
|
//}
|
|
for _, chat := range chats {
|
|
cid, _ := chat.Id.(string)
|
|
chatMap[cid] = chat
|
|
}
|
|
select {
|
|
case user.chatListReceived <- struct{}{}:
|
|
default:
|
|
}
|
|
go user.syncPortals(chatMap, false)
|
|
}
|
|
|
|
func (user *User) syncPortals(chatMap map[string]skype.Conversation, createAll bool) {
|
|
if chatMap == nil {
|
|
chatMap = user.Conn.Store.Chats
|
|
}
|
|
user.log.Infoln("Reading chat list")
|
|
chats := make(ChatList, 0, len(chatMap))
|
|
existingKeys := user.GetInCommunityMap()
|
|
portalKeys := make([]database.PortalKeyWithMeta, 0, len(chatMap))
|
|
for _, chat := range chatMap {
|
|
t, err := time.Parse(time.RFC3339,chat.LastMessage.ComposeTime)
|
|
if err != nil {
|
|
t = time.Now()
|
|
if chat.Properties.ConversationStatus != "Accepted" && len(chat.ThreadProperties.Lastjoinat) < 1 {
|
|
continue
|
|
}
|
|
}
|
|
// Filter calllogs conversation
|
|
if chat.Id == "48:calllogs" {
|
|
continue
|
|
}
|
|
// Filter conversations that have not sent messages
|
|
if chat.LastMessage.Id == "" {
|
|
continue
|
|
}
|
|
// 'Lastleaveat' value means that you have left the current conversation
|
|
if len(chat.ThreadProperties.Lastleaveat) > 0 {
|
|
continue
|
|
}
|
|
ts := uint64(t.UnixNano())
|
|
cid, _ := chat.Id.(string)
|
|
portal := user.GetPortalByJID(cid)
|
|
|
|
chats = append(chats, Chat{
|
|
Portal: portal,
|
|
Contact: user.Conn.Store.Chats[cid],
|
|
LastMessageTime: ts,
|
|
})
|
|
var inCommunity, ok bool
|
|
if inCommunity, ok = existingKeys[portal.Key]; !ok || !inCommunity {
|
|
inCommunity = user.addPortalToCommunity(portal)
|
|
if portal.IsPrivateChat() {
|
|
puppet := user.bridge.GetPuppetByJID(portal.Key.JID + skypeExt.NewUserSuffix)
|
|
user.addPuppetToCommunity(puppet)
|
|
}
|
|
}
|
|
portalKeys = append(portalKeys, database.PortalKeyWithMeta{PortalKey: portal.Key, InCommunity: inCommunity})
|
|
}
|
|
user.log.Infoln("Read chat list, updating user-portal mapping")
|
|
err := user.SetPortalKeys(portalKeys)
|
|
if err != nil {
|
|
user.log.Warnln("Failed to update user-portal mapping:", err)
|
|
}
|
|
sort.Sort(chats)
|
|
limit := user.bridge.Config.Bridge.InitialChatSync
|
|
if limit < 0 {
|
|
limit = len(chats)
|
|
}
|
|
now := uint64(time.Now().Unix())
|
|
user.log.Infoln("Syncing portals")
|
|
for i, chat := range chats {
|
|
if chat.LastMessageTime+user.bridge.Config.Bridge.SyncChatMaxAge < now {
|
|
break
|
|
}
|
|
create := (chat.LastMessageTime >= user.LastConnection && user.LastConnection > 0) || i < limit
|
|
if len(chat.Portal.MXID) > 0 || create || createAll {
|
|
chat.Portal.SyncSkype(user, chat.Contact)
|
|
//err := chat.Portal.BackfillHistory(user, chat.LastMessageTime)
|
|
if err != nil {
|
|
chat.Portal.log.Errorln("Error backfilling history:", err)
|
|
}
|
|
}
|
|
}
|
|
user.log.Infoln("Finished syncing portals")
|
|
select {
|
|
case user.syncPortalsDone <- struct{}{}:
|
|
default:
|
|
}
|
|
}
|
|
|
|
//func (user *User) HandleContactList(contacts []whatsapp.Contact) {
|
|
// contactMap := make(map[string]whatsapp.Contact)
|
|
// for _, contact := range contacts {
|
|
// contactMap[contact.Jid] = contact
|
|
// }
|
|
// // go user.syncPuppets(contactMap)
|
|
//}
|
|
|
|
func (user *User) syncPuppets(contacts map[string]skype.Contact) {
|
|
if contacts == nil {
|
|
contacts = user.Conn.Store.Contacts
|
|
}
|
|
if len(contacts) < 1 {
|
|
user.log.Infoln("No contacts to sync")
|
|
return
|
|
}
|
|
user.log.Infoln("Syncing puppet info from contacts")
|
|
//for jid, contact := range contacts {
|
|
username := user.Conn.UserProfile.FirstName
|
|
if user.Conn.UserProfile.LastName != "" {
|
|
username = user.Conn.UserProfile.FirstName + " " + user.Conn.UserProfile.LastName
|
|
}
|
|
contacts["8:" + user.Conn.UserProfile.Username + skypeExt.NewUserSuffix] = skype.Contact{
|
|
Profile: skype.UserInfoProfile{
|
|
AvatarUrl: user.Conn.UserProfile.AvatarUrl,
|
|
},
|
|
DisplayName: username,
|
|
PersonId: user.Conn.UserProfile.Username,
|
|
}
|
|
for personId, contact := range contacts {
|
|
fmt.Println("Syncing puppet info from contacts", personId)
|
|
user.log.Infoln("Syncing puppet info from contacts", strings.HasSuffix(personId, skypeExt.NewUserSuffix))
|
|
fmt.Println("Syncing puppet info from contacts", skypeExt.NewUserSuffix)
|
|
if strings.HasSuffix(personId, skypeExt.NewUserSuffix) {
|
|
fmt.Println("Syncing puppet info from contacts i am coming")
|
|
puppet := user.bridge.GetPuppetByJID(personId)
|
|
puppet.Sync(user, contact)
|
|
}
|
|
}
|
|
user.log.Infoln("Finished syncing puppet info from contacts")
|
|
}
|
|
|
|
func (user *User) updateLastConnectionIfNecessary() {
|
|
if user.LastConnection+60 < uint64(time.Now().Unix()) {
|
|
user.UpdateLastConnection()
|
|
}
|
|
}
|
|
|
|
func (user *User) HandleError(err error) {
|
|
// Otherwise unknown error, probably mostly harmless
|
|
}
|
|
|
|
func (user *User) tryReconnect(msg string) {
|
|
//if user.ConnectionErrors > user.bridge.Config.Bridge.MaxConnectionAttempts {
|
|
// content := format.RenderMarkdown(fmt.Sprintf("%s. Use the `reconnect` command to reconnect.", msg), true, false)
|
|
// _, _ = user.bridge.Bot.SendMessageEvent(user.GetManagementRoom(), event.EventMessage, content)
|
|
// return
|
|
//}
|
|
//if user.bridge.Config.Bridge.ReportConnectionRetry {
|
|
// _, _ = user.bridge.Bot.SendNotice(user.GetManagementRoom(), fmt.Sprintf("%s. Reconnecting...", msg))
|
|
// // Don't want the same error to be repeated
|
|
// msg = ""
|
|
//}
|
|
//var tries uint
|
|
//var exponentialBackoff bool
|
|
//baseDelay := time.Duration(user.bridge.Config.Bridge.ConnectionRetryDelay)
|
|
//if baseDelay < 0 {
|
|
// exponentialBackoff = true
|
|
// baseDelay = -baseDelay + 1
|
|
//}
|
|
//delay := baseDelay
|
|
//for user.ConnectionErrors <= user.bridge.Config.Bridge.MaxConnectionAttempts {
|
|
// err := user.Conn.Restore()
|
|
// if err == nil {
|
|
// user.ConnectionErrors = 0
|
|
// if user.bridge.Config.Bridge.ReportConnectionRetry {
|
|
// _, _ = user.bridge.Bot.SendNotice(user.GetManagementRoom(), "Reconnected successfully")
|
|
// }
|
|
// user.PostLogin()
|
|
// return
|
|
// } else if err.Error() == "init responded with 400" {
|
|
// user.log.Infoln("Got init 400 error when trying to reconnect, resetting connection...")
|
|
// sess, err := user.Conn.Disconnect()
|
|
// if err != nil {
|
|
// user.log.Debugln("Error while disconnecting for connection reset:", err)
|
|
// }
|
|
// if len(sess.Wid) > 0 {
|
|
// user.SetSession(&sess)
|
|
// }
|
|
// }
|
|
// user.log.Errorln("Error while trying to reconnect after disconnection:", err)
|
|
// tries++
|
|
// user.ConnectionErrors++
|
|
// if user.ConnectionErrors <= user.bridge.Config.Bridge.MaxConnectionAttempts {
|
|
// if exponentialBackoff {
|
|
// delay = (1 << tries) + baseDelay
|
|
// }
|
|
// if user.bridge.Config.Bridge.ReportConnectionRetry {
|
|
// _, _ = user.bridge.Bot.SendNotice(user.GetManagementRoom(),
|
|
// fmt.Sprintf("Reconnection attempt failed: %v. Retrying in %d seconds...", err, delay))
|
|
// }
|
|
// time.Sleep(delay * time.Second)
|
|
// }
|
|
//}
|
|
//
|
|
//if user.bridge.Config.Bridge.ReportConnectionRetry {
|
|
// msg = fmt.Sprintf("%d reconnection attempts failed. Use the `reconnect` command to try to reconnect manually.", tries)
|
|
//} else {
|
|
// msg = fmt.Sprintf("\u26a0 %sAdditionally, %d reconnection attempts failed. "+
|
|
// "Use the `reconnect` command to try to reconnect.", msg, tries)
|
|
//}
|
|
//
|
|
//content := format.RenderMarkdown(msg, true, false)
|
|
//_, _ = user.bridge.Bot.SendMessageEvent(user.GetManagementRoom(), event.EventMessage, content)
|
|
}
|
|
|
|
func (user *User) ShouldCallSynchronously() bool {
|
|
return true
|
|
}
|
|
|
|
func (user *User) HandleJSONParseError(err error) {
|
|
user.log.Errorln("WhatsApp JSON parse error:", err)
|
|
}
|
|
|
|
func (user *User) PortalKey(jid types.SkypeID) database.PortalKey {
|
|
fmt.Println("User PortalKey jid: ", jid)
|
|
fmt.Println("User PortalKey user.JID: ", user.JID)
|
|
return database.NewPortalKey(jid, user.JID)
|
|
}
|
|
|
|
func (user *User) GetPortalByJID(jid types.SkypeID) *Portal {
|
|
return user.bridge.GetPortalByJID(user.PortalKey(jid))
|
|
}
|
|
|
|
func (user *User) handleMessageLoop() {
|
|
for msg := range user.messages {
|
|
user.syncLock.Lock()
|
|
fmt.Println("User handleMessageLoop msg.chat: ", msg.chat)
|
|
user.GetPortalByJID(msg.chat).messages <- msg
|
|
user.syncLock.Unlock()
|
|
}
|
|
}
|
|
|
|
func (user *User) putMessage(message PortalMessage) {
|
|
select {
|
|
case user.messages <- message:
|
|
default:
|
|
user.log.Warnln("Buffer is full, dropping message in", message.chat)
|
|
}
|
|
}
|
|
|
|
func (user *User) HandleTextMessage(message skype.Resource) {
|
|
user.log.Debugf("HandleTextMessage: ", message)
|
|
user.putMessage(PortalMessage{message.Jid, user, message, uint64(message.Timestamp)})
|
|
}
|
|
|
|
func (user *User) HandleImageMessage(message skype.Resource) {
|
|
user.log.Debugf("HandleImageMessage: ", message)
|
|
user.putMessage(PortalMessage{message.Jid, user, message, uint64(message.Timestamp)})
|
|
}
|
|
|
|
//func (user *User) HandleStickerMessage(message whatsapp.StickerMessage) {
|
|
// user.putMessage(PortalMessage{message.Info.RemoteJid, user, message, message.Info.Timestamp})
|
|
//}
|
|
//
|
|
//func (user *User) HandleVideoMessage(message whatsapp.VideoMessage) {
|
|
// user.putMessage(PortalMessage{message.Info.RemoteJid, user, message, message.Info.Timestamp})
|
|
//}
|
|
//
|
|
//func (user *User) HandleAudioMessage(message whatsapp.AudioMessage) {
|
|
// user.putMessage(PortalMessage{message.Info.RemoteJid, user, message, message.Info.Timestamp})
|
|
//}
|
|
//
|
|
//func (user *User) HandleDocumentMessage(message whatsapp.DocumentMessage) {
|
|
// user.putMessage(PortalMessage{message.Info.RemoteJid, user, message, message.Info.Timestamp})
|
|
//}
|
|
|
|
func (user *User) HandleContactMessage(message skype.Resource) {
|
|
user.log.Debugf("HandleContactMessage: ", message)
|
|
user.putMessage(PortalMessage{message.Jid, user, message, uint64(message.Timestamp)})
|
|
}
|
|
|
|
func (user *User) HandleLocationMessage(message skype.Resource) {
|
|
user.log.Debugf("HandleLocationMessage: ", message)
|
|
user.putMessage(PortalMessage{message.Jid, user, message, uint64(message.Timestamp)})
|
|
}
|
|
|
|
func (user *User) HandleMessageRevoke(message skype.Resource) {
|
|
user.putMessage(PortalMessage{message.Jid, user, message, uint64(message.Timestamp)})
|
|
}
|
|
|
|
type FakeMessage struct {
|
|
Text string
|
|
ID string
|
|
Alert bool
|
|
}
|
|
|
|
//func (user *User) HandleCallInfo(info whatsappExt.CallInfo) {
|
|
// if info.Data != nil {
|
|
// return
|
|
// }
|
|
// data := FakeMessage{
|
|
// ID: info.ID,
|
|
// }
|
|
// switch info.Type {
|
|
// case whatsappExt.CallOffer:
|
|
// if !user.bridge.Config.Bridge.CallNotices.Start {
|
|
// return
|
|
// }
|
|
// data.Text = "Incoming call"
|
|
// data.Alert = true
|
|
// case whatsappExt.CallOfferVideo:
|
|
// if !user.bridge.Config.Bridge.CallNotices.Start {
|
|
// return
|
|
// }
|
|
// data.Text = "Incoming video call"
|
|
// data.Alert = true
|
|
// case whatsappExt.CallTerminate:
|
|
// if !user.bridge.Config.Bridge.CallNotices.End {
|
|
// return
|
|
// }
|
|
// data.Text = "Call ended"
|
|
// data.ID += "E"
|
|
// default:
|
|
// return
|
|
// }
|
|
// portal := user.GetPortalByJID(info.From)
|
|
// if portal != nil {
|
|
// portal.messages <- PortalMessage{info.From, user, data, 0}
|
|
// }
|
|
//}
|
|
|
|
func (user *User) HandleTypingStatus(info skype.Resource) {
|
|
sendId := info.SendId + skypeExt.NewUserSuffix
|
|
puppet := user.bridge.GetPuppetByJID(sendId)
|
|
|
|
switch info.MessageType {
|
|
case "Control/ClearTyping":
|
|
if len(puppet.typingIn) > 0 && puppet.typingAt+15 > time.Now().Unix() {
|
|
portal := user.bridge.GetPortalByMXID(puppet.typingIn)
|
|
_, _ = puppet.IntentFor(portal).UserTyping(puppet.typingIn, false, 0)
|
|
puppet.typingIn = ""
|
|
puppet.typingAt = 0
|
|
}
|
|
case "Control/Typing":
|
|
portal := user.GetPortalByJID(info.Jid)
|
|
if len(puppet.typingIn) > 0 && puppet.typingAt+15 > time.Now().Unix() {
|
|
if puppet.typingIn == portal.MXID {
|
|
return
|
|
}
|
|
_, _ = puppet.IntentFor(portal).UserTyping(puppet.typingIn, false, 0)
|
|
}
|
|
puppet.typingIn = portal.MXID
|
|
puppet.typingAt = time.Now().Unix()
|
|
_, _ = puppet.IntentFor(portal).UserTyping(portal.MXID, true, 10*1000)
|
|
time.Sleep(10 * time.Second)
|
|
_, _ = puppet.IntentFor(portal).UserTyping(portal.MXID, false, 0)
|
|
//_ = puppet.DefaultIntent().SetPresence("online")
|
|
}
|
|
}
|
|
|
|
func (user *User) HandlePresence(info skype.Resource) {
|
|
sendId := info.SendId + skypeExt.NewUserSuffix
|
|
puppet := user.bridge.GetPuppetByJID(sendId)
|
|
|
|
if _,ok := user.contactsPresence[sendId]; ok {
|
|
user.contactsPresence[sendId].Availability = info.Availability
|
|
user.contactsPresence[sendId].Status = info.Status
|
|
} else {
|
|
user.contactsPresence[sendId] = &skypeExt.Presence {
|
|
Id: sendId,
|
|
Availability: info.Availability,
|
|
Status: info.Status,
|
|
}
|
|
}
|
|
|
|
switch skype.Presence(info.Availability) {
|
|
case skype.PresenceOffline:
|
|
_ = puppet.DefaultIntent().SetPresence("offline")
|
|
case skype.PresenceOnline:
|
|
if len(puppet.typingIn) > 0 && puppet.typingAt+15 > time.Now().Unix() {
|
|
portal := user.bridge.GetPortalByMXID(puppet.typingIn)
|
|
_, _ = puppet.IntentFor(portal).UserTyping(puppet.typingIn, false, 0)
|
|
puppet.typingIn = ""
|
|
puppet.typingAt = 0
|
|
} else {
|
|
_ = puppet.DefaultIntent().SetPresence("online")
|
|
}
|
|
//case whatsapp.PresenceComposing:
|
|
// portal := user.GetPortalByJID(info.Jid)
|
|
// if len(puppet.typingIn) > 0 && puppet.typingAt+15 > time.Now().Unix() {
|
|
// if puppet.typingIn == portal.MXID {
|
|
// return
|
|
// }
|
|
// _, _ = puppet.IntentFor(portal).UserTyping(puppet.typingIn, false, 0)
|
|
// }
|
|
// puppet.typingIn = portal.MXID
|
|
// puppet.typingAt = time.Now().Unix()
|
|
// _, _ = puppet.IntentFor(portal).UserTyping(portal.MXID, true, 15*1000)
|
|
// _ = puppet.DefaultIntent().SetPresence("online")
|
|
}
|
|
}
|
|
|
|
//func (user *User) HandlePresenceWA(info whatsappExt.Presence) {
|
|
// puppet := user.bridge.GetPuppetByJID(info.SenderJID)
|
|
// switch info.Status {
|
|
// case whatsapp.PresenceUnavailable:
|
|
// _ = puppet.DefaultIntent().SetPresence("offline")
|
|
// case whatsapp.PresenceAvailable:
|
|
// if len(puppet.typingIn) > 0 && puppet.typingAt+15 > time.Now().Unix() {
|
|
// portal := user.bridge.GetPortalByMXID(puppet.typingIn)
|
|
// _, _ = puppet.IntentFor(portal).UserTyping(puppet.typingIn, false, 0)
|
|
// puppet.typingIn = ""
|
|
// puppet.typingAt = 0
|
|
// }
|
|
// _ = puppet.DefaultIntent().SetPresence("online")
|
|
// case whatsapp.PresenceComposing:
|
|
// portal := user.GetPortalByJID(info.JID)
|
|
// if len(puppet.typingIn) > 0 && puppet.typingAt+15 > time.Now().Unix() {
|
|
// if puppet.typingIn == portal.MXID {
|
|
// return
|
|
// }
|
|
// _, _ = puppet.IntentFor(portal).UserTyping(puppet.typingIn, false, 0)
|
|
// }
|
|
// puppet.typingIn = portal.MXID
|
|
// puppet.typingAt = time.Now().Unix()
|
|
// _, _ = puppet.IntentFor(portal).UserTyping(portal.MXID, true, 15*1000)
|
|
// _ = puppet.DefaultIntent().SetPresence("online")
|
|
// }
|
|
//}
|
|
|
|
//func (user *User) HandleMsgInfo(info whatsappExt.MsgInfo) {
|
|
// if (info.Command == whatsappExt.MsgInfoCommandAck || info.Command == whatsappExt.MsgInfoCommandAcks) && info.Acknowledgement == whatsappExt.AckMessageRead {
|
|
// portal := user.GetPortalByJID(info.ToJID)
|
|
// if len(portal.MXID) == 0 {
|
|
// return
|
|
// }
|
|
//
|
|
// go func() {
|
|
// intent := user.bridge.GetPuppetByJID(info.SenderJID).IntentFor(portal)
|
|
// for _, id := range info.IDs {
|
|
// msg := user.bridge.DB.Message.GetByJID(portal.Key, id)
|
|
// if msg == nil {
|
|
// continue
|
|
// }
|
|
//
|
|
// err := intent.MarkRead(portal.MXID, msg.MXID)
|
|
// if err != nil {
|
|
// user.log.Warnln("Failed to mark message %s as read by %s: %v", msg.MXID, info.SenderJID, err)
|
|
// }
|
|
// }
|
|
// }()
|
|
// }
|
|
//}
|
|
|
|
func (user *User) HandleCommand(cmd skypeExt.Command) {
|
|
switch cmd.Type {
|
|
case skypeExt.CommandPicture:
|
|
if strings.HasSuffix(cmd.JID, skypeExt.NewUserSuffix) {
|
|
puppet := user.bridge.GetPuppetByJID(cmd.JID)
|
|
go puppet.UpdateAvatar(user, cmd.ProfilePicInfo)
|
|
} else {
|
|
portal := user.GetPortalByJID(cmd.JID)
|
|
go portal.UpdateAvatar(user, cmd.ProfilePicInfo)
|
|
}
|
|
case skypeExt.CommandDisconnect:
|
|
//var msg string
|
|
//if cmd.Kind == "replaced" {
|
|
// msg = "\u26a0 Your Skype connection was closed by the server because you opened another Skype Web client.\n\n" +
|
|
// "Use the `reconnect` command to disconnect the other client and resume bridging."
|
|
//} else {
|
|
// user.log.Warnln("Unknown kind of disconnect:", string(cmd.Raw))
|
|
// msg = fmt.Sprintf("\u26a0 Your Skype connection was closed by the server (reason code: %s).\n\n"+
|
|
// "Use the `reconnect` command to reconnect.", cmd.Kind)
|
|
//}
|
|
//msg = "can not disconnect"
|
|
//user.cleanDisconnection = true
|
|
//go user.bridge.Bot.SendMessageEvent(user.GetManagementRoom(), event.EventMessage, format.RenderMarkdown(msg, true, false))
|
|
}
|
|
}
|
|
|
|
func (user *User) HandleChatUpdate(cmd skype.Resource) {
|
|
fmt.Println()
|
|
fmt.Println("HandleChatUpdate :")
|
|
fmt.Println()
|
|
//if cmd.Command != skypeExt.ChatUpdateCommandAction {
|
|
// return
|
|
//}
|
|
|
|
portal := user.GetPortalByJID(cmd.Jid)
|
|
//if len(portal.MXID) == 0 {
|
|
// if cmd.Data.Action == skypeExt.ChatActionCreate {
|
|
// go portal.membershipCreate(user, cmd)
|
|
// }
|
|
// return
|
|
//}
|
|
|
|
fmt.Println("portl:", portal)
|
|
fmt.Println("cmd.MessageType:", cmd.MessageType)
|
|
messageType := skypeExt.ChatActionType(cmd.MessageType)
|
|
|
|
switch messageType {
|
|
case skypeExt.ChatTopicUpdate:
|
|
topicContent := skype.ChatTopicContent{}
|
|
//把xml数据解析成bs对象
|
|
xml.Unmarshal([]byte(cmd.Content), &topicContent)
|
|
portalName := ""
|
|
noRoomTopic := false
|
|
names := strings.Split(cmd.ThreadTopic, ", ")
|
|
for _, name := range names {
|
|
key := "8:" + name + skypeExt.NewUserSuffix
|
|
if key == user.JID {
|
|
noRoomTopic = true
|
|
}
|
|
}
|
|
if noRoomTopic {
|
|
participants, _ := portal.GetPuppets()
|
|
for index, participant := range participants {
|
|
if *participant.DisplayName != user.Conn.LoginInfo.Username {
|
|
if len(portalName) == 0 {
|
|
portalName = *participant.DisplayName
|
|
} else {
|
|
if index > 5 {
|
|
portalName = portalName + ", ..."
|
|
break
|
|
} else {
|
|
portalName = *participant.DisplayName + ", " + portalName
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
portalName = cmd.ThreadTopic
|
|
}
|
|
cmd.SendId = topicContent.Initiator + skypeExt.NewUserSuffix
|
|
go portal.UpdateName(portalName, cmd.SendId)
|
|
case skypeExt.ChatPictureUpdate:
|
|
topicContent := skype.ChatPictureContent{}
|
|
//把xml数据解析成bs对象
|
|
xml.Unmarshal([]byte(cmd.Content), &topicContent)
|
|
cmd.SendId = topicContent.Initiator + skypeExt.NewUserSuffix
|
|
url := strings.TrimPrefix(topicContent.Value, "URL@")
|
|
if strings.Index(url, "/views/") > 0 {
|
|
url = strings.Replace(url, "avatar_fullsize", "swx_avatar", 1)
|
|
} else {
|
|
url = url + "/views/swx_avatar"
|
|
}
|
|
fmt.Println()
|
|
fmt.Println("HandleChatUpdateL picture:", url )
|
|
fmt.Println()
|
|
avatar := &skypeExt.ProfilePicInfo{
|
|
URL: url,
|
|
Tag: url,
|
|
Status: 0,
|
|
}
|
|
go portal.UpdateAvatar(user, avatar)
|
|
case skypeExt.ChatMemberAdd:
|
|
user.log.Debugfln("chat member add")
|
|
if len(portal.MXID) == 0 {
|
|
err := portal.CreateMatrixRoom(user)
|
|
if err != nil {
|
|
fmt.Println("create room failed")
|
|
}
|
|
}
|
|
go portal.membershipAdd(cmd.Content)
|
|
case skypeExt.ChatMemberDelete:
|
|
go portal.membershipRemove(cmd.Content)
|
|
case "":
|
|
if skypeExt.ChatActionType(cmd.Type) == skypeExt.ChatActionThread {
|
|
if len(cmd.ETag) > 0 && len(cmd.Properties.Capabilities) < 1{
|
|
portal.Delete()
|
|
portal.Cleanup(false)
|
|
}
|
|
}
|
|
|
|
//case skypeExt.ChatActionAddTopic:
|
|
// go portal.UpdateTopic(cmd.Data.AddTopic.Topic, cmd.Data.SenderJID)
|
|
//case skypeExt.ChatActionRemoveTopic:
|
|
// go portal.UpdateTopic("", cmd.Data.SenderJID)
|
|
//case skypeExt.ChatActionPromote:
|
|
// go portal.ChangeAdminStatus(cmd.Data.PermissionChange.JIDs, true)
|
|
//case skypeExt.ChatActionDemote:
|
|
// go portal.ChangeAdminStatus(cmd.Data.PermissionChange.JIDs, false)
|
|
//case skypeExt.ChatActionAnnounce:
|
|
// go portal.RestrictMessageSending(cmd.Data.Announce)
|
|
//case skypeExt.ChatActionRestrict:
|
|
// go portal.RestrictMetadataChanges(cmd.Data.Restrict)
|
|
//case skypeExt.ChatActionAdd:
|
|
// go portal.membershipAdd(user, cmd.Jid)
|
|
//case skypeExt.ChatActionRemove:
|
|
// go portal.membershipRemove(cmd.Data.MemberAction.JIDs, cmd.Data.Action)
|
|
//case skypeExt.ChatActionIntroduce:
|
|
// go portal.membershipAdd(user, cmd.JID)
|
|
}
|
|
}
|
|
|
|
|
|
//func (user *User) HandleChatUpdate(cmd whatsappExt.ChatUpdate) {
|
|
// if cmd.Command != whatsappExt.ChatUpdateCommandAction {
|
|
// return
|
|
// }
|
|
//
|
|
// portal := user.GetPortalByJID(cmd.JID)
|
|
// if len(portal.MXID) == 0 {
|
|
// if cmd.Data.Action == whatsappExt.ChatActionCreate {
|
|
// go portal.membershipCreate(user, cmd)
|
|
// }
|
|
// return
|
|
// }
|
|
//
|
|
// switch cmd.Data.Action {
|
|
// case whatsappExt.ChatActionNameChange:
|
|
// go portal.UpdateName(cmd.Data.NameChange.Name, cmd.Data.SenderJID)
|
|
// case whatsappExt.ChatActionAddTopic:
|
|
// go portal.UpdateTopic(cmd.Data.AddTopic.Topic, cmd.Data.SenderJID)
|
|
// case whatsappExt.ChatActionRemoveTopic:
|
|
// go portal.UpdateTopic("", cmd.Data.SenderJID)
|
|
// case whatsappExt.ChatActionPromote:
|
|
// go portal.ChangeAdminStatus(cmd.Data.PermissionChange.JIDs, true)
|
|
// case whatsappExt.ChatActionDemote:
|
|
// go portal.ChangeAdminStatus(cmd.Data.PermissionChange.JIDs, false)
|
|
// case whatsappExt.ChatActionAnnounce:
|
|
// go portal.RestrictMessageSending(cmd.Data.Announce)
|
|
// case whatsappExt.ChatActionRestrict:
|
|
// go portal.RestrictMetadataChanges(cmd.Data.Restrict)
|
|
// case whatsappExt.ChatActionAdd:
|
|
// go portal.membershipAdd(user, cmd.JID)
|
|
// case whatsappExt.ChatActionRemove:
|
|
// go portal.membershipRemove(cmd.Data.MemberAction.JIDs, cmd.Data.Action)
|
|
// case whatsappExt.ChatActionIntroduce:
|
|
// go portal.membershipAdd(user, cmd.JID)
|
|
// }
|
|
//}
|
|
|
|
func (user *User) HandleJsonMessage(message string) {
|
|
var msg json.RawMessage
|
|
err := json.Unmarshal([]byte(message), &msg)
|
|
if err != nil {
|
|
return
|
|
}
|
|
user.log.Debugln("JSON message:", message)
|
|
user.updateLastConnectionIfNecessary()
|
|
}
|
|
|
|
//func (user *User) HandleRawMessage(message *waProto.WebMessageInfo) {
|
|
// user.updateLastConnectionIfNecessary()
|
|
//}
|
|
|
|
func (user *User) NeedsRelaybot(portal *Portal) bool {
|
|
return false
|
|
//return !user.HasSession() || !user.IsInPortal(portal.Key)
|
|
}
|