Fixing some errors seen when account is cleared

[gc-dialer] / src / session.py

diff --git a/src/session.py b/src/session.py
index c002945..a50245a 100644 (file)
--- a/src/session.py
+++ b/src/session.py
@@ -78,8 +78,6 @@ class Draft(QtCore.QObject):
                return self._message
 
        def _set_message(self, message):
-               if self._busyReason is not None:
-                       raise RuntimeError("Please wait for %r" % self._busyReason)
                self._message = message
 
        message = property(_get_message, _set_message)
@@ -162,6 +160,7 @@ class Draft(QtCore.QObject):
                                self.sentMessage.emit()
                                self._clear()
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
 
        def _call(self, number):
@@ -177,6 +176,7 @@ class Draft(QtCore.QObject):
                                self.called.emit()
                                self._clear()
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
 
        def _cancel(self):
@@ -190,6 +190,7 @@ class Draft(QtCore.QObject):
                                )
                        self.cancelled.emit()
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
 
 
@@ -268,10 +269,13 @@ class Session(QtCore.QObject):
 
        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
@@ -282,9 +286,12 @@ class Session(QtCore.QObject):
 
        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:
@@ -331,11 +338,9 @@ class Session(QtCore.QObject):
                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,
@@ -343,6 +348,7 @@ class Session(QtCore.QObject):
                                        {},
                                )
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
                        return
                self._dnd = dnd
@@ -353,10 +359,13 @@ class Session(QtCore.QObject):
                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):
@@ -367,17 +376,16 @@ class Session(QtCore.QObject):
                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
@@ -427,6 +435,8 @@ class Session(QtCore.QObject):
                                                needOps = True
 
                                        self.loggedIn.emit()
+                                       self.stateChange.emit(finalState)
+                                       finalState = None # Mark it as already set
 
                                        if needOps:
                                                loginOps = self._loginOps[:]
@@ -440,9 +450,11 @@ class Session(QtCore.QObject):
                                        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)
 
@@ -551,11 +563,11 @@ class Session(QtCore.QObject):
                oldCallback = self._callback
 
                self._contacts = {}
-               self._contactUpdateTime = datetime.datetime(1, 1, 1)
+               self._contactUpdateTime = datetime.datetime(1971, 1, 1)
                self._messages = []
-               self._messageUpdateTime = datetime.datetime(1, 1, 1)
+               self._messageUpdateTime = datetime.datetime(1971, 1, 1)
                self._history = []
-               self._historyUpdateTime = datetime.datetime(1, 1, 1)
+               self._historyUpdateTime = datetime.datetime(1971, 1, 1)
                self._dnd = False
                self._callback = ""
 
@@ -574,6 +586,7 @@ class Session(QtCore.QObject):
 
        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,
@@ -581,6 +594,7 @@ class Session(QtCore.QObject):
                                        {},
                                )
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
                        return
                self._contactUpdateTime = datetime.datetime.now()
@@ -588,6 +602,7 @@ class Session(QtCore.QObject):
 
        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,
@@ -595,6 +610,7 @@ class Session(QtCore.QObject):
                                        {},
                                )
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
                        return
                self._messageUpdateTime = datetime.datetime.now()
@@ -602,6 +618,7 @@ class Session(QtCore.QObject):
 
        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,
@@ -609,6 +626,7 @@ class Session(QtCore.QObject):
                                        {},
                                )
                except Exception, e:
+                       _moduleLogger.exception("Reporting error to user")
                        self.error.emit(str(e))
                        return
                self._historyUpdateTime = datetime.datetime.now()
@@ -617,12 +635,14 @@ class Session(QtCore.QObject):
        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: