summary refs log tree commit diff
path: root/synapse/util/room_name.py
blob: 7e49b92bb41642e9886346313bc2954ac66bfbc0 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
# -*- coding: utf-8 -*-
# Copyright 2016 OpenMarket Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import re

# intentionally looser than what aliases we allow to be registered since
# other HSes may allow aliases that we would not
ALIAS_RE = re.compile(r"^#.*:.+$")

ALL_ALONE = "Empty Room"


def calculate_room_name(room_state, user_id):
    # does it have a name?
    if ("m.room.name", "") in room_state:
        m_room_name = room_state[("m.room.name", "")]
        if m_room_name.content and m_room_name.content["name"]:
            return m_room_name.content["name"]

    # does it have a caononical alias?
    if ("m.room.canonical_alias", "") in room_state:
        canon_alias = room_state[("m.room.canonical_alias", "")]
        if (
            canon_alias.content and canon_alias.content["alias"] and
            looks_like_an_alias(canon_alias.content["alias"])
        ):
            return canon_alias.content["alias"]

    # at this point we're going to need to search the state by all state keys
    # for an event type, so rearrange the data structure
    room_state_bytype = state_as_two_level_dict(room_state)

    # right then, any aliases at all?
    if "m.room.aliases" in room_state_bytype:
        m_room_aliases = room_state_bytype["m.room.aliases"]
        if len(m_room_aliases.values()) > 0:
            first_alias_event = m_room_aliases.values()[0]
            if first_alias_event.content and first_alias_event.content["aliases"]:
                the_aliases = first_alias_event.content["aliases"]
                if len(the_aliases) > 0 and looks_like_an_alias(the_aliases[0]):
                    return the_aliases[0]

    my_member_event = None
    if ("m.room.member", user_id) in room_state:
        my_member_event = room_state[("m.room.member", user_id)]

    if (
        my_member_event is not None and
        my_member_event.content['membership'] == "invite"
    ):
        if ("m.room.member", my_member_event.sender) in room_state:
            inviter_member_event = room_state[("m.room.member", my_member_event.sender)]
            return "Invite from %s" % (name_from_member_event(inviter_member_event),)
        else:
            return "Room Invite"

    # we're going to have to generate a name based on who's in the room,
    # so find out who is in the room that isn't the user.
    if "m.room.member" in room_state_bytype:
        all_members = [
            ev for ev in room_state_bytype["m.room.member"].values()
            if ev.membership == "join" or ev.membership == "invite"
        ]
        other_members = [m for m in all_members if m.sender != user_id]
    else:
        other_members = []
        all_members = []

    if len(other_members) == 0:
        if len(all_members) == 1:
            # self-chat, peeked room with 1 participant,
            # or inbound invite, or outbound 3PID invite.
            if all_members[0].sender == user_id:
                if "m.room.third_party_invite" in room_state_bytype:
                    third_party_invites = room_state_bytype["m.room.third_party_invite"]
                    if len(third_party_invites) > 0:
                        # technically third party invite events are not member
                        # events, but they are close enough
                        return "Inviting %s" (
                            descriptor_from_member_events(third_party_invites)
                        )
                    else:
                        return ALL_ALONE
            else:
                return name_from_member_event(all_members[0])
        else:
            return ALL_ALONE
    else:
        return descriptor_from_member_events(other_members)


def state_as_two_level_dict(state):
    ret = {}
    for k, v in state.items():
        ret.setdefault(k[0], {})[k[1]] = v
    return ret


def looks_like_an_alias(string):
    return ALIAS_RE.match(string) is not None


def descriptor_from_member_events(member_events):
    #     else if (otherMembers.length === 1) {
    #     return otherMembers[0].name;
    # }
    # else if (otherMembers.length === 2) {
    #     return (
    #         otherMembers[0].name + " and " + otherMembers[1].name
    #     );
    # }
    # else {
    #     return (
    #         otherMembers[0].name + " and " + (otherMembers.length - 1) + " others"
    #     );
    # }
    if len(member_events) == 0:
        return "nobody"
    elif len(member_events) == 1:
        return name_from_member_event(member_events[0])
    return "all the people, so many people. They all go hand in hand, hand in hand in their park life."


def name_from_member_event(member_event):
    if (
        member_event.content and "displayname" in member_event.content and
        member_event.content["displayname"]
    ):
        return member_event.content["displayname"]
    return member_event.sender