diff --git a/synapse/push/httppusher.py b/synapse/push/httppusher.py
index feedb075e2..c0f8176e3d 100644
--- a/synapse/push/httppusher.py
+++ b/synapse/push/httppusher.py
@@ -245,7 +245,7 @@ class HttpPusher(object):
@defer.inlineCallbacks
def _build_notification_dict(self, event, tweaks, badge):
ctx = yield push_tools.get_context_for_event(
- self.state_handler, event, self.user_id
+ self.store, self.state_handler, event, self.user_id
)
d = {
diff --git a/synapse/push/mailer.py b/synapse/push/mailer.py
index 1028731bc9..845ddd43da 100644
--- a/synapse/push/mailer.py
+++ b/synapse/push/mailer.py
@@ -22,7 +22,7 @@ from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from synapse.util.async import concurrently_execute
-from synapse.util.presentable_names import (
+from synapse.push.presentable_names import (
calculate_room_name, name_from_member_event, descriptor_from_member_events
)
from synapse.types import UserID
@@ -139,7 +139,7 @@ class Mailer(object):
@defer.inlineCallbacks
def _fetch_room_state(room_id):
- room_state = yield self.state_handler.get_current_state(room_id)
+ room_state = yield self.state_handler.get_current_state_ids(room_id)
state_by_room[room_id] = room_state
# Run at most 3 of these at once: sync does 10 at a time but email
@@ -160,7 +160,8 @@ class Mailer(object):
rooms.append(roomvars)
reason['room_name'] = calculate_room_name(
- state_by_room[reason['room_id']], user_id, fallback_to_members=True
+ self.store, state_by_room[reason['room_id']], user_id,
+ fallback_to_members=True
)
summary_text = self.make_summary_text(
@@ -203,12 +204,15 @@ class Mailer(object):
)
@defer.inlineCallbacks
- def get_room_vars(self, room_id, user_id, notifs, notif_events, room_state):
- my_member_event = room_state[("m.room.member", user_id)]
+ def get_room_vars(self, room_id, user_id, notifs, notif_events, room_state_ids):
+ my_member_event_id = room_state_ids[("m.room.member", user_id)]
+ my_member_event = yield self.store.get_event(my_member_event_id)
is_invite = my_member_event.content["membership"] == "invite"
+ room_name = yield calculate_room_name(self.store, room_state_ids, user_id)
+
room_vars = {
- "title": calculate_room_name(room_state, user_id),
+ "title": room_name,
"hash": string_ordinal_total(room_id), # See sender avatar hash
"notifs": [],
"invite": is_invite,
@@ -218,7 +222,7 @@ class Mailer(object):
if not is_invite:
for n in notifs:
notifvars = yield self.get_notif_vars(
- n, user_id, notif_events[n['event_id']], room_state
+ n, user_id, notif_events[n['event_id']], room_state_ids
)
# merge overlapping notifs together.
@@ -243,7 +247,7 @@ class Mailer(object):
defer.returnValue(room_vars)
@defer.inlineCallbacks
- def get_notif_vars(self, notif, user_id, notif_event, room_state):
+ def get_notif_vars(self, notif, user_id, notif_event, room_state_ids):
results = yield self.store.get_events_around(
notif['room_id'], notif['event_id'],
before_limit=CONTEXT_BEFORE, after_limit=CONTEXT_AFTER
@@ -261,17 +265,19 @@ class Mailer(object):
the_events.append(notif_event)
for event in the_events:
- messagevars = self.get_message_vars(notif, event, room_state)
+ messagevars = yield self.get_message_vars(notif, event, room_state_ids)
if messagevars is not None:
ret['messages'].append(messagevars)
defer.returnValue(ret)
- def get_message_vars(self, notif, event, room_state):
+ @defer.inlineCallbacks
+ def get_message_vars(self, notif, event, room_state_ids):
if event.type != EventTypes.Message:
- return None
+ return
- sender_state_event = room_state[("m.room.member", event.sender)]
+ sender_state_event_id = room_state_ids[("m.room.member", event.sender)]
+ sender_state_event = yield self.store.get_event(sender_state_event_id)
sender_name = name_from_member_event(sender_state_event)
sender_avatar_url = sender_state_event.content.get("avatar_url")
@@ -299,7 +305,7 @@ class Mailer(object):
if "body" in event.content:
ret["body_text_plain"] = event.content["body"]
- return ret
+ defer.returnValue(ret)
def add_text_message_vars(self, messagevars, event):
msgformat = event.content.get("format")
diff --git a/synapse/push/presentable_names.py b/synapse/push/presentable_names.py
new file mode 100644
index 0000000000..80c9f21a6c
--- /dev/null
+++ b/synapse/push/presentable_names.py
@@ -0,0 +1,199 @@
+# -*- 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.
+
+from twisted.internet import defer
+
+import re
+import logging
+
+logger = logging.getLogger(__name__)
+
+# 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"
+
+
+@defer.inlineCallbacks
+def calculate_room_name(store, room_state_ids, user_id, fallback_to_members=True,
+ fallback_to_single_member=True):
+ """
+ Works out a user-facing name for the given room as per Matrix
+ spec recommendations.
+ Does not yet support internationalisation.
+ Args:
+ room_state: Dictionary of the room's state
+ user_id: The ID of the user to whom the room name is being presented
+ fallback_to_members: If False, return None instead of generating a name
+ based on the room's members if the room has no
+ title or aliases.
+
+ Returns:
+ (string or None) A human readable name for the room.
+ """
+ # does it have a name?
+ if ("m.room.name", "") in room_state_ids:
+ m_room_name = yield store.get_event(
+ room_state_ids[("m.room.name", "")], allow_none=True
+ )
+ if m_room_name and m_room_name.content and m_room_name.content["name"]:
+ defer.returnValue(m_room_name.content["name"])
+
+ # does it have a canonical alias?
+ if ("m.room.canonical_alias", "") in room_state_ids:
+ canon_alias = yield store.get_event(
+ room_state_ids[("m.room.canonical_alias", "")], allow_none=True
+ )
+ canon_alias = room_state_ids[("m.room.canonical_alias", "")]
+ if (
+ canon_alias and canon_alias.content and canon_alias.content["alias"] and
+ _looks_like_an_alias(canon_alias.content["alias"])
+ ):
+ defer.returnValue(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_ids = _state_as_two_level_dict(room_state_ids)
+
+ # right then, any aliases at all?
+ if "m.room.aliases" in room_state_bytype_ids:
+ m_room_aliases = room_state_bytype_ids["m.room.aliases"]
+ for alias_id in m_room_aliases.values():
+ alias_event = yield store.get_event(
+ alias_id, allow_none=True
+ )
+ if alias_event and alias_event.content and alias_event.get("aliases"):
+ the_aliases = alias_event.content["aliases"]
+ if len(the_aliases) > 0 and _looks_like_an_alias(the_aliases[0]):
+ defer.returnValue(the_aliases[0])
+
+ if not fallback_to_members:
+ defer.returnValue(None)
+
+ my_member_event = None
+ if ("m.room.member", user_id) in room_state_ids:
+ my_member_event = yield store.get_event(
+ room_state_ids[("m.room.member", user_id)], allow_none=True
+ )
+
+ 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_ids:
+ inviter_member_event = yield store.get_event(
+ room_state_ids[("m.room.member", my_member_event.sender)],
+ allow_none=True,
+ )
+ if inviter_member_event:
+ if fallback_to_single_member:
+ defer.returnValue(
+ "Invite from %s" % (
+ name_from_member_event(inviter_member_event),
+ )
+ )
+ else:
+ return
+ else:
+ defer.returnValue("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_ids:
+ member_events = yield store.get_events(
+ room_state_bytype_ids["m.room.member"].values()
+ )
+ all_members = [
+ ev for ev in member_events.values()
+ if ev.content['membership'] == "join" or ev.content['membership'] == "invite"
+ ]
+ # Sort the member events oldest-first so the we name people in the
+ # order the joined (it should at least be deterministic rather than
+ # dictionary iteration order)
+ all_members.sort(key=lambda e: e.origin_server_ts)
+ other_members = [m for m in all_members if m.state_key != 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_ids:
+ third_party_invites = (
+ room_state_bytype_ids["m.room.third_party_invite"].values()
+ )
+
+ if len(third_party_invites) > 0:
+ # technically third party invite events are not member
+ # events, but they are close enough
+
+ # FIXME: no they're not - they look nothing like a member;
+ # they have a great big encrypted thing as their name to
+ # prevent leaking the 3PID name...
+ # return "Inviting %s" % (
+ # descriptor_from_member_events(third_party_invites)
+ # )
+ defer.returnValue("Inviting email address")
+ else:
+ defer.returnValue(ALL_ALONE)
+ else:
+ defer.returnValue(name_from_member_event(all_members[0]))
+ else:
+ defer.returnValue(ALL_ALONE)
+ elif len(other_members) == 1 and not fallback_to_single_member:
+ return
+ else:
+ defer.returnValue(descriptor_from_member_events(other_members))
+
+
+def descriptor_from_member_events(member_events):
+ if len(member_events) == 0:
+ return "nobody"
+ elif len(member_events) == 1:
+ return name_from_member_event(member_events[0])
+ elif len(member_events) == 2:
+ return "%s and %s" % (
+ name_from_member_event(member_events[0]),
+ name_from_member_event(member_events[1]),
+ )
+ else:
+ return "%s and %d others" % (
+ name_from_member_event(member_events[0]),
+ len(member_events) - 1,
+ )
+
+
+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.state_key
+
+
+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
diff --git a/synapse/push/push_tools.py b/synapse/push/push_tools.py
index becb8ef1ae..b47bf1f92b 100644
--- a/synapse/push/push_tools.py
+++ b/synapse/push/push_tools.py
@@ -14,7 +14,7 @@
# limitations under the License.
from twisted.internet import defer
-from synapse.util.presentable_names import (
+from synapse.push.presentable_names import (
calculate_room_name, name_from_member_event
)
from synapse.util.logcontext import preserve_fn, preserve_context_over_deferred
@@ -49,21 +49,22 @@ def get_badge_count(store, user_id):
@defer.inlineCallbacks
-def get_context_for_event(state_handler, ev, user_id):
+def get_context_for_event(store, state_handler, ev, user_id):
ctx = {}
- room_state = yield state_handler.get_current_state(ev.room_id)
+ room_state_ids = yield state_handler.get_current_state_ids(ev.room_id)
# we no longer bother setting room_alias, and make room_name the
# human-readable name instead, be that m.room.name, an alias or
# a list of people in the room
- name = calculate_room_name(
- room_state, user_id, fallback_to_single_member=False
+ name = yield calculate_room_name(
+ store, room_state_ids, user_id, fallback_to_single_member=False
)
if name:
ctx['name'] = name
- sender_state_event = room_state[("m.room.member", ev.sender)]
+ sender_state_event_id = room_state_ids[("m.room.member", ev.sender)]
+ sender_state_event = yield store.get_event(sender_state_event_id)
ctx['sender_display_name'] = name_from_member_event(sender_state_event)
defer.returnValue(ctx)
|
