def _on_close_result(self, task):
try:
task.finish()
except StanzaError as error:
app.socks5queue.error_cb('Error', to_user_string(error))
self._log.warning(error)
return
def _set_error(self, error):
text = MUC_DISCO_ERRORS.get(error.condition, to_user_string(error))
if error.condition == 'gone':
reason = error.get_text(get_rfc5646_lang())
if reason:
text = '%s:\n%s' % (text, reason)
self._show_error_page(text)
def _items_received(self, result):
if is_error_result(result):
ErrorDialog('Error', to_user_string(result))
return
jid = result.jid.getBare()
for item in result.items:
if item.jid == jid and item.node is not None:
self.treestore.append([item.node])
def _on_remove_response(self, result):
if is_error_result(result):
self._con.removing_account = False
error_text = to_user_string(result)
self.get_page('error').set_text(error_text)
self.show_page('error')
else:
app.interface.remove_account(self.account)
self.show_page('success')
def _on_change_password(self, result):
if is_error_result(result):
error_text = to_user_string(result)
self.get_page('error').set_text(error_text)
self.show_page('error', Gtk.StackTransitionType.SLIDE_LEFT)
elif result.successful:
self.show_page('success')
else:
self.get_page('next_stage').set_form(result.form)
self.show_page('next_stage', Gtk.StackTransitionType.SLIDE_LEFT)
def _on_data_result(self, task):
try:
task.finish()
except StanzaError as error:
app.socks5queue.error_cb('Error', to_user_string(error))
self._log.warning(error)
return
file_props = task.get_user_data()
self.send_data(file_props)
def _parameters_received(self, result, user_data):
if is_error_result(result):
self._global_search_listbox.remove_progress()
self._show_error_page(to_user_string(result))
return
con, text = user_data
self._parameter_form = result
self._parameter_form.type_ = 'submit'
self._start_iq_search(con, text)
def _on_save_result(self, result):
self._await_results -= 1
if is_error_result(result) and not self._received_errors:
self._show_error(to_user_string(result))
self._received_errors = True
if not self._await_results:
if self._received_errors:
self._reset_after_error()
else:
self.destroy()
def _items_received(self, task):
try:
result = task.finish()
except StanzaError as error:
ErrorDialog('Error', to_user_string(error))
return
jid = result.jid.bare
for item in result.items:
if item.jid == jid and item.node is not None:
self.treestore.append([item.node])
def _on_remove_response(self, task):
try:
task.finish()
except StanzaError as error:
self._con.set_remove_account(False)
error_text = to_user_string(error)
self.get_page('error').set_text(error_text)
self.show_page('error')
return
self._account_removed = True
def _received_command_list(self, task):
try:
commands = task.finish()
except (StanzaError, MalformedStanzaError) as error:
self._set_error(to_user_string(error), False)
return
if not commands:
self._set_error(_('No commands available'), False)
return
self.get_page('commands').add_commands(commands)
self.show_page('commands')
def _on_captcha_result(self, result):
if not is_error_result(result):
return
muc_data = self._manager.get(result.jid)
if muc_data is None:
return
self._manager.set_state(result.jid, MUCJoinedState.CAPTCHA_FAILED)
app.nec.push_incoming_event(
NetworkEvent('muc-captcha-error',
account=self._account,
room_jid=str(result.jid),
error_text=to_user_string(result)))
def _on_captcha_result(self, task):
try:
task.finish()
except StanzaError as error:
muc_data = self._manager.get(error.jid)
if muc_data is None:
return
self._manager.set_state(error.jid, MUCJoinedState.CAPTCHA_FAILED)
app.nec.push_incoming_event(
NetworkEvent('muc-captcha-error',
account=self._account,
room_jid=str(error.jid),
error_text=to_user_string(error)))
def _on_blocking_list_received(self, result):
is_error = is_error_result(result)
self._disable_spinner()
self._set_grid_state(not is_error)
if is_error:
self._show_error(to_user_string(result))
else:
self._prev_blocked_jids = set(result.blocking_list)
self._ui.blocking_store.clear()
for item in result.blocking_list:
self._ui.blocking_store.append((item, ))
def _on_change_password(self, task):
try:
task.finish()
except ChangePasswordStanzaError as error:
self.get_page('next_stage').set_form(error.get_form())
self.show_page('next_stage', Gtk.StackTransitionType.SLIDE_LEFT)
except StanzaError as error:
error_text = to_user_string(error)
self.get_page('error').set_text(error_text)
self.show_page('error', Gtk.StackTransitionType.SLIDE_LEFT)
else:
self.show_page('success')
def _received_stage(self, task):
try:
stage = task.finish()
except (StanzaError, MalformedStanzaError) as error:
self._set_error(to_user_string(error), True)
return
page_name = 'stage'
if stage.is_completed:
page_name = 'completed'
page = self.get_page(page_name)
page.process_stage(stage)
self.show_page(page_name)
def _process_search_result(self, result, parameters=False):
if self._search_stopped:
raise CancelledError()
if is_error(result):
self._global_search_listbox.remove_progress()
self._show_error_page(to_user_string(result))
raise result
if parameters:
return
for item in result.items:
self._global_search_listbox.add(ResultRow(item))
def _received_stage(self, stage):
if is_error_result(stage):
self.get_nth_page(Page.ERROR).set_text(to_user_string(stage))
self.get_nth_page(Page.ERROR).show_command_button = True
self.set_current_page(Page.ERROR)
return
page = Page.STAGE
if stage.is_completed:
page = Page.COMPLETED
stage_page = self.get_nth_page(page)
stage_page.process_stage(stage)
self.set_current_page(page)
def _received_stage(self, task):
try:
stage = task.finish()
except (StanzaError, MalformedStanzaError) as error:
self._set_error(to_user_string(error), True)
return
page = Page.STAGE
if stage.is_completed:
page = Page.COMPLETED
stage_page = self.get_nth_page(page)
stage_page.process_stage(stage)
self.set_current_page(page)
def _on_error_presence(self, _con, _stanza, properties):
room_jid = properties.jid.getBare()
muc_data = self._manager.get(room_jid)
if muc_data is None:
return
if muc_data.state == MUCJoinedState.JOINING:
if properties.error.condition == 'conflict':
self._remove_rejoin_timeout(room_jid)
muc_data.nick += '_'
self._log.info('Nickname conflict: %s change to %s',
muc_data.jid, muc_data.nick)
self._join(muc_data)
elif properties.error.condition == 'not-authorized':
self._remove_rejoin_timeout(room_jid)
self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
self._raise_muc_event('muc-password-required', properties)
else:
self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
if room_jid not in self._rejoin_muc:
app.nec.push_incoming_event(
NetworkEvent('muc-join-failed',
account=self._account,
room_jid=room_jid,
error=properties.error))
elif muc_data.state == MUCJoinedState.CREATING:
self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
app.nec.push_incoming_event(
NetworkEvent('muc-creation-failed',
account=self._account,
room_jid=room_jid,
error=properties.error))
elif muc_data.state == MUCJoinedState.CAPTCHA_REQUEST:
app.nec.push_incoming_event(
NetworkEvent('muc-captcha-error',
account=self._account,
room_jid=room_jid,
error_text=to_user_string(properties.error)))
self._manager.set_state(room_jid, MUCJoinedState.CAPTCHA_FAILED)
self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
elif muc_data.state == MUCJoinedState.CAPTCHA_FAILED:
self._manager.set_state(room_jid, MUCJoinedState.NOT_JOINED)
else:
self._raise_muc_event('muc-presence-error', properties)
def _received_command_list(self, commands):
error_text = None
if is_error_result(commands):
error_text = to_user_string(commands)
elif not commands:
error_text = _('No commands available')
if error_text is not None:
self.get_nth_page(Page.ERROR).set_text(error_text)
self.get_nth_page(Page.ERROR).show_command_button = False
self.set_current_page(Page.ERROR)
return
self.get_nth_page(Page.COMMANDS).add_commands(commands)
self.set_current_page(Page.COMMANDS)
def _on_search_result(self, result, user_data):
if self._search_stopped:
return
if is_error_result(result):
self._global_search_listbox.remove_progress()
self._show_error_page(to_user_string(result))
return
for item in result.items:
self._global_search_listbox.add(ResultRow(item))
if result.end:
self._global_search_listbox.end_search()
return
con, http = user_data
if http:
self._continue_http_search(result, con)
else:
self._continue_iq_search(result, con)
def _iq_error_received(self, _con, _stanza, properties):
self._log.info('Error: %s', properties.error)
if properties.error.condition in ('jid-malformed', 'forbidden',
'not-acceptable'):
sid = self._get_sid(properties.id)
file_props = FilesProp.getFileProp(self._account, sid)
if file_props:
if properties.error.condition == 'jid-malformed':
file_props.error = -3
else:
file_props.error = -4
app.nec.push_incoming_event(
NetworkEvent('file-request-error',
conn=self._con,
jid=properties.jid.getBare(),
file_props=file_props,
error_msg=to_user_string(properties.error)))
self._con.get_module('Bytestream').disconnect_transfer(
file_props)
raise nbxmpp.NodeProcessed
if properties.error.condition == 'item-not-found':
sid = self._get_sid(properties.id)
file_props = FilesProp.getFileProp(self._account, sid)
if file_props:
app.nec.push_incoming_event(
NetworkEvent('file-send-error',
account=self._account,
jid=str(properties.jid),
file_props=file_props))
self._con.get_module('Bytestream').disconnect_transfer(
file_props)
raise nbxmpp.NodeProcessed
app.nec.push_incoming_event(
NetworkEvent('iq-error-received',
account=self._account,
properties=properties))
raise nbxmpp.NodeProcessed
def _on_close_result(self, result):
if is_error_result(result):
app.socks5queue.error_cb('Error', to_user_string(result))
self._log.warning(result)
return
def _on_data_result(self, result, file_props):
if is_error_result(result):
app.socks5queue.error_cb('Error', to_user_string(result))
self._log.warning(result)
return
self.send_data(file_props)
def _set_warning_from_error(self, error):
condition = error.condition
if condition == 'gone':
condition = 'already-exists'
text = MUC_DISCO_ERRORS.get(condition, to_user_string(error))
self._set_warning(text)
