narayana.im/telegabber
1
0
Fork 1
mirror of https://dev.narayana.im/narayana/telegabber.git synced 2026-08-05 04:07:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Terminology clarification (member -> occupant wherever applicable)

Browse source
This commit is contained in:
Bohdan Horbeshko 2025-06-15 23:21:42 -04:00
parent b1ecfc29cd
commit 67c960da25
4 changed files with 49 additions and 48 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
telegram/client.go
View file

@ -24,11 +24,11 @@ type DelayedStatus struct {
// MUCState holds MUC metadata // MUCState holds MUC metadata
type MUCState struct { type MUCState struct {
Resources map[string]bool Resources map[string]bool
Members map[int64]*MUCMember Occupants map[int64]*MUCOccupant
} }
// MUCMember represents a MUC member // MUCOccupant represents a MUC occupant
type MUCMember struct { type MUCOccupant struct {
Nickname string Nickname string
Affiliation string Affiliation string
Role string Role string
@ -37,7 +37,7 @@ type MUCMember struct {
func NewMUCState() *MUCState { func NewMUCState() *MUCState {
return &MUCState{ return &MUCState{
Resources: make(map[string]bool), Resources: make(map[string]bool),
Members: make(map[int64]*MUCMember), Occupants: make(map[int64]*MUCOccupant),
} }
} }

4
telegram/handlers.go
View file

@ -489,8 +489,8 @@ func (c *Client) updateBasicGroupFullInfo(update *client.UpdateBasicGroupFullInf
mucState, ok := c.mucCache[chatID] mucState, ok := c.mucCache[chatID]
if ok && mucState != nil { if ok && mucState != nil {
mucState.Members = make(map[int64]*MUCMember) mucState.Occupants = make(map[int64]*MUCOccupant)
c.updateMUCMembers(mucState, chatID, update.BasicGroupFullInfo.Members) c.updateMUCOccupants(mucState, chatID, update.BasicGroupFullInfo.Members)
} }
c.locks.mucCacheLock.Unlock() c.locks.mucCacheLock.Unlock()

81
telegram/utils.go
View file

@ -518,14 +518,14 @@ func (c *Client) ProcessStatusUpdate(chatID int64, status string, show string, o
c.locks.mucCacheLock.Lock() c.locks.mucCacheLock.Lock()
chatJid := gateway.CHATJID(chatID, true) chatJid := gateway.CHATJID(chatID, true)
for mucId, state := range c.mucCache { for mucId, state := range c.mucCache {
member, ok := state.Members[chatID] occupant, ok := state.Occupants[chatID]
if ok { if ok {
newMucArgs := append( newMucArgs := append(
newArgs, newArgs,
gateway.SPFrom(gateway.MUCNODE(mucId)), gateway.SPFrom(gateway.MUCNODE(mucId)),
gateway.SPResource(member.Nickname), gateway.SPResource(occupant.Nickname),
gateway.SPMUCAffiliation(member.Affiliation), gateway.SPMUCAffiliation(occupant.Affiliation),
gateway.SPMUCRole(member.Role), gateway.SPMUCRole(occupant.Role),
gateway.SPMUCJid(chatJid), gateway.SPMUCJid(chatJid),
) )
err := c.sendPresence(newMucArgs...) err := c.sendPresence(newMucArgs...)
@ -610,10 +610,10 @@ func (c *Client) sendMUCStatuses(chatID int64) {
Limit: 200, Limit: 200,
Filter: &client.ChatMembersFilterMembers{}, Filter: &client.ChatMembersFilterMembers{},
}) })
c.updateMUCMembers(mucState, chatID, members.Members) c.updateMUCOccupants(mucState, chatID, members.Members)
} }
func (c *Client) updateMUCMembers(mucState *MUCState, chatID int64, members []*client.ChatMember) { func (c *Client) updateMUCOccupants(mucState *MUCState, chatID int64, members []*client.ChatMember) {
sChatId := gateway.MUCNODE(chatID) sChatId := gateway.MUCNODE(chatID)
myNickname := "me" myNickname := "me"
if c.me != nil { if c.me != nil {
@ -623,8 +623,8 @@ func (c *Client) updateMUCMembers(mucState *MUCState, chatID int64, members []*c
myRole := "participant" myRole := "participant"
for _, member := range members { for _, member := range members {
senderId, nickname, affiliation, role := c.TgMemberToMUCMember(member) senderId, nickname, affiliation, role := c.TgMemberToMUCOccupant(member)
mucState.Members[senderId] = &MUCMember{ mucState.Occupants[senderId] = &MUCOccupant{
Nickname: nickname, Nickname: nickname,
Affiliation: affiliation, Affiliation: affiliation,
Role: role, Role: role,
@ -647,7 +647,7 @@ func (c *Client) updateMUCMembers(mucState *MUCState, chatID int64, members []*c
) )
} }
// according to the spec, own member entry should be sent the last // according to the spec, own occupant entry should be sent the last
c.sendPresence( c.sendPresence(
gateway.SPFrom(sChatId), gateway.SPFrom(sChatId),
gateway.SPResource(myNickname), gateway.SPResource(myNickname),
@ -658,7 +658,7 @@ func (c *Client) updateMUCMembers(mucState *MUCState, chatID int64, members []*c
) )
} }
func (c *Client) mucCacheHasMember(mucID int64, memberID int64) bool { func (c *Client) mucCacheHasOccupant(mucID int64, memberID int64) bool {
c.locks.mucCacheLock.Lock() c.locks.mucCacheLock.Lock()
defer c.locks.mucCacheLock.Unlock() defer c.locks.mucCacheLock.Unlock()
mucState, ok := c.mucCache[mucID] mucState, ok := c.mucCache[mucID]
@ -666,11 +666,11 @@ func (c *Client) mucCacheHasMember(mucID int64, memberID int64) bool {
return false // no MUC to be added to return false // no MUC to be added to
} }
_, ok = mucState.Members[memberID] _, ok = mucState.Occupants[memberID]
return ok return ok
} }
func (c *Client) addMUCMember(mucID int64, memberID int64, affiliation, role string) bool { func (c *Client) addMUCOccupant(mucID int64, memberID int64, affiliation, role string) bool {
c.locks.mucCacheLock.Lock() c.locks.mucCacheLock.Lock()
defer c.locks.mucCacheLock.Unlock() defer c.locks.mucCacheLock.Unlock()
mucState, ok := c.mucCache[mucID] mucState, ok := c.mucCache[mucID]
@ -690,7 +690,7 @@ func (c *Client) addMUCMember(mucID int64, memberID int64, affiliation, role str
) )
if err == nil { if err == nil {
mucState.Members[memberID] = &MUCMember{ mucState.Occupants[memberID] = &MUCOccupant{
Nickname: nickname, Nickname: nickname,
Affiliation: affiliation, Affiliation: affiliation,
Role: role, Role: role,
@ -721,7 +721,7 @@ func (c *Client) sendMUCSubject(chatID int64, resource string) {
} }
} }
// GetMUCNickname generates a unique nickname for a MUC member // GetMUCNickname generates a unique nickname for a MUC occupant
func (c *Client) GetMUCNickname(chatID int64) string { func (c *Client) GetMUCNickname(chatID int64) string {
if chatID == 0 { if chatID == 0 {
if c.me != nil { if c.me != nil {
@ -739,11 +739,12 @@ func (c *Client) updateMUCsNickname(memberID int64, newNickname string) {
realJid := gateway.CHATJID(memberID, true) realJid := gateway.CHATJID(memberID, true)
for mucId, state := range c.mucCache { for mucId, state := range c.mucCache {
oldMember, ok := state.Members[memberID] oldOccupant, ok := state.Occupants[memberID]
if ok { if ok {
state.Members[memberID] = &MUCMember{ state.Occupants[memberID] = &MUCOccupant{
Nickname: newNickname, Nickname: newNickname,
Affiliation: oldMember.Affiliation, Affiliation: oldOccupant.Affiliation,
Role: oldOccupant.Role,
} }
sMucId := gateway.MUCNODE(mucId) sMucId := gateway.MUCNODE(mucId)
@ -756,10 +757,10 @@ func (c *Client) updateMUCsNickname(memberID int64, newNickname string) {
c.sendPresence( c.sendPresence(
gateway.SPType("unavailable"), gateway.SPType("unavailable"),
gateway.SPFrom(sMucId), gateway.SPFrom(sMucId),
gateway.SPResource(oldMember.Nickname), gateway.SPResource(oldOccupant.Nickname),
gateway.SPImmed(true), gateway.SPImmed(true),
gateway.SPMUCAffiliation(oldMember.Affiliation), gateway.SPMUCAffiliation(oldOccupant.Affiliation),
gateway.SPMUCRole(oldMember.Role), gateway.SPMUCRole(oldOccupant.Role),
gateway.SPMUCNick(newNickname), gateway.SPMUCNick(newNickname),
gateway.SPMUCStatusCodes(unavailableStatusCodes), gateway.SPMUCStatusCodes(unavailableStatusCodes),
gateway.SPMUCJid(realJid), gateway.SPMUCJid(realJid),
@ -768,8 +769,8 @@ func (c *Client) updateMUCsNickname(memberID int64, newNickname string) {
gateway.SPFrom(sMucId), gateway.SPFrom(sMucId),
gateway.SPResource(newNickname), gateway.SPResource(newNickname),
gateway.SPImmed(true), gateway.SPImmed(true),
gateway.SPMUCAffiliation(oldMember.Affiliation), gateway.SPMUCAffiliation(oldOccupant.Affiliation),
gateway.SPMUCRole(oldMember.Role), gateway.SPMUCRole(oldOccupant.Role),
gateway.SPMUCStatusCodes(availableStatusCodes), gateway.SPMUCStatusCodes(availableStatusCodes),
gateway.SPMUCJid(realJid), gateway.SPMUCJid(realJid),
) )
@ -821,14 +822,14 @@ func (c *Client) GetMyMUCNickname(chatID int64) (string, bool) {
if !ok || mucState == nil { if !ok || mucState == nil {
return "", false return "", false
} }
member, ok := mucState.Members[c.me.Id] occupant, ok := mucState.Occupants[c.me.Id]
if !ok { if !ok {
return "", false return "", false
} }
return member.Nickname, true return occupant.Nickname, true
} }
// GetMUCMemberIdByNickname looks up the telegram ID by the MUC nickname (slow yet!) // GetMUCMemberIdByNickname looks up the telegram ID by the MUC nickname (slow yet! (TODO))
func (c *Client) GetMUCMemberIdByNickname(chatID int64, nickname string) int64 { func (c *Client) GetMUCMemberIdByNickname(chatID int64, nickname string) int64 {
c.locks.mucCacheLock.Lock() c.locks.mucCacheLock.Lock()
defer c.locks.mucCacheLock.Unlock() defer c.locks.mucCacheLock.Unlock()
@ -838,8 +839,8 @@ func (c *Client) GetMUCMemberIdByNickname(chatID int64, nickname string) int64 {
return 0 return 0
} }
for memberId, member := range mucState.Members { for memberId, occupant := range mucState.Occupants {
if member.Nickname == nickname { if occupant.Nickname == nickname {
return memberId return memberId
} }
} }
@ -1638,18 +1639,18 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
switch message.Content.MessageContentType() { switch message.Content.MessageContentType() {
case client.TypeMessageChatJoinByLink: case client.TypeMessageChatJoinByLink:
c.mucMemberRolePresence(chatId, senderId, ChatMemberStatusUnmuted, c.GetMUCNickname(senderId)) c.mucOccupantRolePresence(chatId, senderId, ChatMemberStatusUnmuted, c.GetMUCNickname(senderId))
case client.TypeMessageChatAddMembers: case client.TypeMessageChatAddMembers:
addMembers, _ := message.Content.(*client.MessageChatAddMembers) addMembers, _ := message.Content.(*client.MessageChatAddMembers)
for _, memberId := range addMembers.MemberUserIds { for _, memberId := range addMembers.MemberUserIds {
c.mucMemberRolePresence(chatId, memberId, ChatMemberStatusUnmuted, c.GetMUCNickname(memberId)) c.mucOccupantRolePresence(chatId, memberId, ChatMemberStatusUnmuted, c.GetMUCNickname(memberId))
} }
case client.TypeMessageChatDeleteMember: case client.TypeMessageChatDeleteMember:
deleteMember, _ := message.Content.(*client.MessageChatDeleteMember) deleteMember, _ := message.Content.(*client.MessageChatDeleteMember)
c.mucMemberRolePresence(chatId, deleteMember.UserId, ChatMemberStatusKicked, c.GetMUCNickname(deleteMember.UserId)) c.mucOccupantRolePresence(chatId, deleteMember.UserId, ChatMemberStatusKicked, c.GetMUCNickname(deleteMember.UserId))
} }
if !c.mucCacheHasMember(chatId, senderId) { if !c.mucCacheHasOccupant(chatId, senderId) {
chatMember, err := c.client.GetChatMember(&client.GetChatMemberRequest{ chatMember, err := c.client.GetChatMember(&client.GetChatMemberRequest{
ChatId: chatId, ChatId: chatId,
MemberId: message.SenderId, MemberId: message.SenderId,
@ -1659,7 +1660,7 @@ func (c *Client) ProcessIncomingMessage(chatId int64, message *client.Message) {
status = chatMember.Status status = chatMember.Status
} }
affiliation, role := c.memberStatusToAffiliationAndRole(status) affiliation, role := c.memberStatusToAffiliationAndRole(status)
safeToSend = c.addMUCMember(chatId, senderId, affiliation, role) safeToSend = c.addMUCOccupant(chatId, senderId, affiliation, role)
} }
groupChatFrom = gateway.MUCJID(chatId) + "/" + c.GetMUCNickname(senderId) groupChatFrom = gateway.MUCJID(chatId) + "/" + c.GetMUCNickname(senderId)
@ -2485,8 +2486,8 @@ func (c *Client) memberStatusToAffiliationAndRole(memberStatus client.ChatMember
return "member", "participant" return "member", "participant"
} }
// TgMemberToMUCMember resolves useful data to generate a MUC member // TgMemberToMUCMember resolves useful data to generate a MUC occupant
func (c *Client) TgMemberToMUCMember(member *client.ChatMember) (senderId int64, nickname, affiliation, role string) { func (c *Client) TgMemberToMUCOccupant(member *client.ChatMember) (senderId int64, nickname, affiliation, role string) {
senderId = c.GetSenderId(member.MemberId) senderId = c.GetSenderId(member.MemberId)
nickname = c.GetMUCNickname(senderId) nickname = c.GetMUCNickname(senderId)
affiliation, role = c.memberStatusToAffiliationAndRole(member.Status) affiliation, role = c.memberStatusToAffiliationAndRole(member.Status)
@ -2669,12 +2670,12 @@ func (c *Client) SetChatMemberStatus(chatID, userID int64, status ChatMemberStat
Status: chatMemberStatus, Status: chatMemberStatus,
}) })
if err == nil && nickname != "" { if err == nil && nickname != "" {
c.mucMemberRolePresence(chatID, userID, status, nickname) c.mucOccupantRolePresence(chatID, userID, status, nickname)
} }
return err return err
} }
func (c *Client) mucMemberRolePresence(chatID, userID int64, status ChatMemberStatus, nickname string) { func (c *Client) mucOccupantRolePresence(chatID, userID int64, status ChatMemberStatus, nickname string) {
args := []args.V{ args := []args.V{
gateway.SPFrom(gateway.MUCNODE(chatID)), gateway.SPFrom(gateway.MUCNODE(chatID)),
gateway.SPResource(nickname), gateway.SPResource(nickname),
@ -2723,12 +2724,12 @@ func (c *Client) mucMemberRolePresence(chatID, userID int64, status ChatMemberSt
mucState, ok := c.mucCache[chatID] mucState, ok := c.mucCache[chatID]
if ok && mucState != nil { if ok && mucState != nil {
if status == ChatMemberStatusKicked || status == ChatMemberStatusBanned { if status == ChatMemberStatusKicked || status == ChatMemberStatusBanned {
delete(mucState.Members, userID) delete(mucState.Occupants, userID)
} else { } else {
member, ok := mucState.Members[userID] occupant, ok := mucState.Occupants[userID]
if ok { if ok {
member.Affiliation = newAffiliation occupant.Affiliation = newAffiliation
member.Role = newRole occupant.Role = newRole
} }
} }
} }

4
xmpp/handlers.go
View file

@ -161,7 +161,7 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
if isGroupchat { if isGroupchat {
gateway.SendErrorMessageWithBody(msg.From, msg.To, msg.Body, "", msg.Id, 400, true, component) gateway.SendErrorMessageWithBody(msg.From, msg.To, msg.Body, "", msg.Id, 400, true, component)
} else { } else {
gateway.SendErrorMessage(msg.From, msg.To, "PMing room members is not supported, use the real JID", 406, true, component) gateway.SendErrorMessage(msg.From, msg.To, "PMing room occupants is not supported, use the real JID", 406, true, component)
} }
return return
} }
@ -1213,7 +1213,7 @@ func handleGetQueryMucAdmin(s xmpp.Sender, iq *stanza.IQ, query *extensions.Quer
members, err := session.GetChatMembers(toID, false, "", membersList) members, err := session.GetChatMembers(toID, false, "", membersList)
if err == nil { if err == nil {
for _, member := range members { for _, member := range members {
senderId, nickname, affiliation, role := session.TgMemberToMUCMember(member) senderId, nickname, affiliation, role := session.TgMemberToMUCOccupant(member)
if item.Role != "" && role != item.Role { if item.Role != "" && role != item.Role {
continue continue
} }