def get_messages(self, *,
num_after: int, num_before: int,
anchor: Optional[int]) -> str:
# anchor value may be specific message (int) or next unread (None)
first_anchor = anchor is None
anchor_value = anchor if anchor is not None else 0
request = {
'anchor': anchor_value,
'num_before': num_before,
'num_after': num_after,
'apply_markdown': True,
'use_first_unread_anchor': first_anchor,
'client_gravatar': True,
'narrow': json.dumps(self.narrow),
}
response = self.client.get_messages(message_filters=request)
if response['result'] == 'success':
self.index = index_messages(response['messages'], self, self.index)
narrow_str = repr(self.narrow)
if first_anchor and response['anchor'] != 10000000000000000:
self.index['pointer'][narrow_str] = response['anchor']
if 'found_newest' in response:
self._have_last_message[narrow_str] = response['found_newest']
else:
# Older versions of the server does not contain the
# 'found_newest' flag. Instead, we use this logic:
query_range = num_after + num_before + 1
self._have_last_message[narrow_str] = (
len(response['messages']) < query_range)
return ""
display_error_if_present(response, self.controller)
return response['msg']
def toggle_message_star_status(self, message: Message) -> None:
base_request = dict(flag='starred', messages=[message['id']])
if 'starred' in message['flags']:
request = dict(base_request, op='remove')
else:
request = dict(base_request, op='add')
response = self.client.update_message_flags(request)
display_error_if_present(response, self.controller)
def fetch_custom_emojis(self) -> NamedEmojiData:
response = self.client.get_realm_emoji()
custom_emojis = {emoji['name']: {'code': emoji_code,
'type': 'realm_emoji'}
for emoji_code, emoji in response['emoji'].items()
if not emoji['deactivated']} # type: NamedEmojiData
display_error_if_present(response, self.controller)
return custom_emojis
def update_private_message(self, msg_id: int, content: str) -> bool:
request = {
"message_id": msg_id,
"content": content,
}
response = self.client.update_message(request)
display_error_if_present(response, self.controller)
return response['result'] == 'success'
def toggle_stream_muted_status(self, stream_id: int) -> None:
request = [{
'stream_id': stream_id,
'property': 'is_muted',
'value': not self.is_muted_stream(stream_id)
# True for muting and False for unmuting.
}]
response = self.client.update_subscription_settings(request)
display_error_if_present(response, self.controller)
def mark_message_ids_as_read(self, id_list: List[int]) -> None:
if not id_list:
return
response = self.client.update_message_flags({
'messages': id_list,
'flag': 'read',
'op': 'add',
})
display_error_if_present(response, self.controller)
def send_private_message(self, recipients: str, content: str) -> bool:
request = {
'type': 'private',
'to': recipients,
'content': content,
}
response = self.client.send_message(request)
display_error_if_present(response, self.controller)
return response['result'] == 'success'
def test_display_error_if_present(mocker, response, footer_updated):
controller = mocker.Mock()
set_footer_text = controller.view.set_footer_text
display_error_if_present(response, controller)
if footer_updated:
set_footer_text.assert_called_once_with(response['msg'], 3)
else:
set_footer_text.assert_not_called()
def fetch_message_history(self, message_id: int,
) -> List[Dict[str, Union[int, str]]]:
"""
Fetches message edit history for a message using its ID.
"""
response = self.client.get_message_history(message_id)
if response['result'] == 'success':
return response['message_history']
display_error_if_present(response, self.controller)
return list()
def send_stream_message(self, stream: str, topic: str,
content: str) -> bool:
request = {
'type': 'stream',
'to': stream,
'subject': topic,
'content': content,
}
response = self.client.send_message(request)
display_error_if_present(response, self.controller)
return response['result'] == 'success'
def test_display_error_if_present(
mocker: MockerFixture, response: Dict[str, str], footer_updated: bool
) -> None:
controller = mocker.Mock()
report_error = controller.report_error
display_error_if_present(response, controller)
if footer_updated:
report_error.assert_called_once_with(response["msg"])
else:
report_error.assert_not_called()
def update_stream_message(self, topic: str, msg_id: int,
content: str) -> bool:
request = {
"message_id": msg_id,
"content": content,
# TODO: Add support for "change_later" & "change_all"
"propagate_mode": "change_one",
"subject": topic,
}
response = self.client.update_message(request)
display_error_if_present(response, self.controller)
return response['result'] == 'success'
def update_stream_message(self, topic: str, message_id: int,
propagate_mode: EditPropagateMode,
content: Optional[str]=None) -> bool:
request = {
"message_id": message_id,
"propagate_mode": propagate_mode,
"topic": topic,
}
if content is not None:
request['content'] = content
response = self.client.update_message(request)
display_error_if_present(response, self.controller)
return response['result'] == 'success'
def _fetch_topics_in_streams(self, stream_list: Iterable[int]) -> str:
"""
Fetch all topics with specified stream_id's and
index their names (Version 1)
"""
# FIXME: Version 2: Fetch last 'n' recent topics for each stream.
for stream_id in stream_list:
response = self.client.get_stream_topics(stream_id)
if response['result'] == 'success':
self.index['topics'][stream_id] = [topic['name'] for
topic in response['topics']]
else:
display_error_if_present(response, self.controller)
return response['msg']
return ""
def react_to_message(self, message: Message,
reaction_to_toggle: str) -> None:
# FIXME Only support thumbs_up for now
assert reaction_to_toggle == 'thumbs_up'
reaction_to_toggle_spec = dict(emoji_name='thumbs_up',
emoji_code='1f44d',
reaction_type='unicode_emoji',
message_id=str(message['id']))
existing_reactions = [
reaction['emoji_code'] for reaction in message['reactions']
if (reaction['user'].get('user_id', None) == self.user_id
or reaction['user'].get('id', None) == self.user_id)
]
if reaction_to_toggle_spec['emoji_code'] in existing_reactions:
response = self.client.remove_reaction(reaction_to_toggle_spec)
else:
response = self.client.add_reaction(reaction_to_toggle_spec)
display_error_if_present(response, self.controller)
