diff --git a/synapse/server_notices/server_notices_manager.py b/synapse/server_notices/server_notices_manager.py
index f7432c8d2f..999c621b92 100644
--- a/synapse/server_notices/server_notices_manager.py
+++ b/synapse/server_notices/server_notices_manager.py
@@ -14,11 +14,9 @@
# limitations under the License.
import logging
-from twisted.internet import defer
-
from synapse.api.constants import EventTypes, Membership, RoomCreationPreset
-from synapse.types import create_requester
-from synapse.util.caches.descriptors import cachedInlineCallbacks
+from synapse.types import UserID, create_requester
+from synapse.util.caches.descriptors import cached
logger = logging.getLogger(__name__)
@@ -36,10 +34,12 @@ class ServerNoticesManager(object):
self._store = hs.get_datastore()
self._config = hs.config
self._room_creation_handler = hs.get_room_creation_handler()
+ self._room_member_handler = hs.get_room_member_handler()
self._event_creation_handler = hs.get_event_creation_handler()
self._is_mine_id = hs.is_mine_id
self._notifier = hs.get_notifier()
+ self.server_notices_mxid = self._config.server_notices_mxid
def is_enabled(self):
"""Checks if server notices are enabled on this server.
@@ -49,8 +49,7 @@ class ServerNoticesManager(object):
"""
return self._config.server_notices_mxid is not None
- @defer.inlineCallbacks
- def send_notice(
+ async def send_notice(
self, user_id, event_content, type=EventTypes.Message, state_key=None
):
"""Send a notice to the given user
@@ -66,7 +65,8 @@ class ServerNoticesManager(object):
Returns:
Deferred[FrozenEvent]
"""
- room_id = yield self.get_notice_room_for_user(user_id)
+ room_id = await self.get_or_create_notice_room_for_user(user_id)
+ await self.maybe_invite_user_to_room(user_id, room_id)
system_mxid = self._config.server_notices_mxid
requester = create_requester(system_mxid)
@@ -83,16 +83,17 @@ class ServerNoticesManager(object):
if state_key is not None:
event_dict["state_key"] = state_key
- res = yield self._event_creation_handler.create_and_send_nonmember_event(
+ res = await self._event_creation_handler.create_and_send_nonmember_event(
requester, event_dict, ratelimit=False
)
return res
- @cachedInlineCallbacks()
- def get_notice_room_for_user(self, user_id):
+ @cached()
+ async def get_or_create_notice_room_for_user(self, user_id):
"""Get the room for notices for a given user
- If we have not yet created a notice room for this user, create it
+ If we have not yet created a notice room for this user, create it, but don't
+ invite the user to it.
Args:
user_id (str): complete user id for the user we want a room for
@@ -105,21 +106,24 @@ class ServerNoticesManager(object):
assert self._is_mine_id(user_id), "Cannot send server notices to remote users"
- rooms = yield self._store.get_rooms_for_local_user_where_membership_is(
+ rooms = await self._store.get_rooms_for_local_user_where_membership_is(
user_id, [Membership.INVITE, Membership.JOIN]
)
- system_mxid = self._config.server_notices_mxid
for room in rooms:
# it's worth noting that there is an asymmetry here in that we
# expect the user to be invited or joined, but the system user must
# be joined. This is kinda deliberate, in that if somebody somehow
# manages to invite the system user to a room, that doesn't make it
# the server notices room.
- user_ids = yield self._store.get_users_in_room(room.room_id)
- if system_mxid in user_ids:
+ user_ids = await self._store.get_users_in_room(room.room_id)
+ if self.server_notices_mxid in user_ids:
# we found a room which our user shares with the system notice
# user
- logger.info("Using room %s", room.room_id)
+ logger.info(
+ "Using existing server notices room %s for user %s",
+ room.room_id,
+ user_id,
+ )
return room.room_id
# apparently no existing notice room: create a new one
@@ -138,24 +142,49 @@ class ServerNoticesManager(object):
"avatar_url": self._config.server_notices_mxid_avatar_url,
}
- requester = create_requester(system_mxid)
- info = yield self._room_creation_handler.create_room(
+ requester = create_requester(self.server_notices_mxid)
+ info = await self._room_creation_handler.create_room(
requester,
config={
"preset": RoomCreationPreset.PRIVATE_CHAT,
"name": self._config.server_notices_room_name,
"power_level_content_override": {"users_default": -10},
- "invite": (user_id,),
},
ratelimit=False,
creator_join_profile=join_profile,
)
room_id = info["room_id"]
- max_id = yield self._store.add_tag_to_room(
+ max_id = await self._store.add_tag_to_room(
user_id, room_id, SERVER_NOTICE_ROOM_TAG, {}
)
self._notifier.on_new_event("account_data_key", max_id, users=[user_id])
logger.info("Created server notices room %s for %s", room_id, user_id)
return room_id
+
+ async def maybe_invite_user_to_room(self, user_id: str, room_id: str):
+ """Invite the given user to the given server room, unless the user has already
+ joined or been invited to it.
+
+ Args:
+ user_id: The ID of the user to invite.
+ room_id: The ID of the room to invite the user to.
+ """
+ requester = create_requester(self.server_notices_mxid)
+
+ # Check whether the user has already joined or been invited to this room. If
+ # that's the case, there is no need to re-invite them.
+ joined_rooms = await self._store.get_rooms_for_local_user_where_membership_is(
+ user_id, [Membership.INVITE, Membership.JOIN]
+ )
+ for room in joined_rooms:
+ if room.room_id == room_id:
+ return
+
+ await self._room_member_handler.update_membership(
+ requester=requester,
+ target=UserID.from_string(user_id),
+ room_id=room_id,
+ action="invite",
+ )
|
