self.sentMessage.emit()
self._clear()
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
def _call(self, number):
self.called.emit()
self._clear()
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
def _cancel(self):
)
self.cancelled.emit()
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
def logout(self):
assert self.state != self.LOGGEDOUT_STATE, "Can only logout if logged in (currently %s" % self.state
+ _moduleLogger.info("Logging out")
self._pool.stop()
self._loggedInTime = self._LOGGEDOUT_TIME
self._backend[0].persist()
self._save_to_cache()
+ self.stateChange.emit(self.LOGGEDOUT_STATE)
+ self.loggedOut.emit()
def clear(self):
assert self.state == self.LOGGEDOUT_STATE, "Can only clear when logged out (currently %s" % self.state
def logout_and_clear(self):
assert self.state != self.LOGGEDOUT_STATE, "Can only logout if logged in (currently %s" % self.state
+ _moduleLogger.info("Logging out and clearing the account")
self._pool.stop()
self._loggedInTime = self._LOGGEDOUT_TIME
self.clear()
+ self.stateChange.emit(self.LOGGEDOUT_STATE)
+ self.loggedOut.emit()
def update_contacts(self, force = True):
if not force and self._contacts:
le.start(dnd)
def _set_dnd(self, dnd):
- # I'm paranoid about our state geting out of sync so we set no matter
- # what but act as if we have the cannonical state
- assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in (currently %s" % self.state
oldDnd = self._dnd
try:
+ assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in (currently %s" % self.state
with qui_utils.notify_busy(self._errorLog, "Setting DND Status"):
yield (
self._backend[0].set_dnd,
{},
)
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
return
self._dnd = dnd
return self._dnd
def get_account_number(self):
+ if self.state != self.LOGGEDIN_STATE:
+ return ""
return self._backend[0].get_account_number()
def get_callback_numbers(self):
- # @todo Remove evilness (might call is_authed which can block)
+ if self.state != self.LOGGEDIN_STATE:
+ return {}
return self._backend[0].get_callback_numbers()
def get_callback_number(self):
le.start(callback)
def _set_callback_number(self, callback):
- # I'm paranoid about our state geting out of sync so we set no matter
- # what but act as if we have the cannonical state
- assert self.state == self.LOGGEDIN_STATE, "Callbacks configurable only when logged in (currently %s" % self.state
oldCallback = self._callback
try:
+ assert self.state == self.LOGGEDIN_STATE, "Callbacks configurable only when logged in (currently %s" % self.state
yield (
self._backend[0].set_callback_number,
(callback, ),
{},
)
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
return
self._callback = callback
needOps = True
self.loggedIn.emit()
+ self.stateChange.emit(finalState)
+ finalState = None # Mark it as already set
if needOps:
loginOps = self._loginOps[:]
self.error.emit("Error logging in")
except Exception, e:
self._loggedInTime = self._LOGGEDOUT_TIME
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
finally:
- self.stateChange.emit(finalState)
+ if finalState is not None:
+ self.stateChange.emit(finalState)
if isLoggedIn and self._callback:
self.set_callback_number(self._callback)
def _update_contacts(self):
try:
+ assert self.state == self.LOGGEDIN_STATE, "Contacts requires being logged in (currently %s" % self.state
with qui_utils.notify_busy(self._errorLog, "Updating Contacts"):
self._contacts = yield (
self._backend[0].get_contacts,
{},
)
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
return
self._contactUpdateTime = datetime.datetime.now()
def _update_messages(self):
try:
+ assert self.state == self.LOGGEDIN_STATE, "Messages requires being logged in (currently %s" % self.state
with qui_utils.notify_busy(self._errorLog, "Updating Messages"):
self._messages = yield (
self._backend[0].get_messages,
{},
)
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
return
self._messageUpdateTime = datetime.datetime.now()
def _update_history(self):
try:
+ assert self.state == self.LOGGEDIN_STATE, "History requires being logged in (currently %s" % self.state
with qui_utils.notify_busy(self._errorLog, "Updating History"):
self._history = yield (
self._backend[0].get_recent,
{},
)
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
return
self._historyUpdateTime = datetime.datetime.now()
def _update_dnd(self):
oldDnd = self._dnd
try:
+ assert self.state == self.LOGGEDIN_STATE, "DND requires being logged in (currently %s" % self.state
self._dnd = yield (
self._backend[0].is_dnd,
(),
{},
)
except Exception, e:
+ _moduleLogger.exception("Reporting error to user")
self.error.emit(str(e))
return
if oldDnd != self._dnd: