def __on_auth_ok(self, username, password):
self.__username = username
self.__password = password
keyring.get_keyring().store_login('google', self.__username, self.__password)
for ui in self.__auth_uis:
ui.hide()
if self.__auth_dialog:
self.__auth_dialog.hide()
hooks = self.__post_auth_hooks
self.__post_auth_hooks = []
for h in hooks:
h()
self.__consider_checking_mail()
def __init__(self):
self.__logger = logging.getLogger("bigboard.Google")
self.__username = None
self.__password = None
self.__fetcher = AsyncHTTPLib2Fetcher()
self.__auth_dialog = None
self.__auth_uis = []
self.__post_auth_hooks = []
k = keyring.get_keyring()
try:
username, password = k.get_login("google")
self.__username = username
self.__password = password
except TypeError:
self.__username = None
self.__password = None
self.__mail_checker = None
self.__consider_checking_mail()
def save_account_changes(self, account, new_properties):
_logger.debug("Saving new props for account %s: %s" % (str(account), str(new_properties.keys())))
set_password = False
## special-case handling of password since it goes in the keyring
if 'password' in new_properties:
if 'username' in new_properties:
username = new_properties['username']
else:
username = account.get_username()
if 'url' in new_properties:
url = new_properties['url']
else:
url = account.get_url()
k = keyring.get_keyring()
k.store_login(kind=account.get_kind().get_id(),
username=username,
url=url,
password=new_properties['password'])
set_password = True
## now do everything else by stuffing it in gconf
gconf_dir = account._get_gconf_dir()
if not gconf_dir:
gconf_dir = self.__find_unused_gconf_dir(account.get_kind())
## associate the Account with this new gconf dir.
## basically this means if a weblogindriver account
## is modified, it becomes a gconf account also.
## We would also do this on seeing a new gconf
## dir appear in gconf spontaneously, but doing
## it here ensures that we definitely attach
## to the proper previous Account
account._set_gconf_dir(gconf_dir)
self.__gconf_accounts.add(account)
base_key = '/apps/bigboard/accounts/' + gconf_dir
def set_account_prop(gconf, base_key, prop, value):
_logger.debug("prop %s value %s" % (prop, str(value)))
if isinstance(value, AccountKind):
value = value.get_id()
gconf.set_value(base_key + '/' + prop, value)
set_account_prop(self.__gconf, base_key, 'kind', account.get_kind())
if 'username' in new_properties:
set_account_prop(self.__gconf, base_key, 'username', new_properties['username'])
if 'url' in new_properties:
set_account_prop(self.__gconf, base_key, 'url', new_properties['url'])
## enable it last, so we ignore the other settings until we do this
if 'enabled' in new_properties:
set_account_prop(self.__gconf, base_key, 'enabled', new_properties['enabled'])
## keyring doesn't have change notification so we have to do the work for it
if set_password:
## this should notice a new password
self.__update_account(account)
import gtk, gtk.gdk
import bigboard.libbig
try:
import bigboard.bignative as bignative
except:
import bignative
gtk.gdk.threads_init()
libbig.logutil.init('DEBUG', ['AsyncHTTP2LibFetcher'])
bignative.set_application_name("BigBoard")
keyring.get_keyring().store_login('google', 'havoc.pennington', 'wrong')
#AuthDialog().present('foo', 'bar')
#gtk.main()
sys.exit(0)
g = get_google()
def display(x):
print x
#g.fetch_documents(display, display)
g.fetch_calendar(display, display)
#g.fetch_new_mail(display, display)
gtk.main()
def __update_account(self, account):
_logger.debug("Updating account %s" % (str(account)))
## note that "kind" is never updated (not allowed to change without
## making a new Account object)
was_enabled = account in self.__enabled_accounts
if was_enabled != account.get_enabled():
raise Exception("account enabled state messed up")
fields = { }
## first, look for the info from our local gconf storage
gconf_base = '/apps/bigboard/accounts'
gconf_dir = account._get_gconf_dir()
if gconf_dir and gconf_dir in self.__gconf_info:
gconf_info = self.__gconf_info[gconf_dir]
if 'username' in gconf_info:
fields['username'] = gconf_info['username']
if 'enabled' in gconf_info:
fields['enabled'] = gconf_info['enabled']
if 'url' in gconf_info:
fields['url'] = gconf_info['url']
elif gconf_dir and gconf_dir not in self.__gconf_info:
## Account object originating with a gconf item
## apparently now deleted, so disable. This
## does mean if you create a gconf item corresponding
## to something from weblogin driver, then delete the
## gconf item, the weblogin account doesn't come back
## until you restart the process. Clunky.
## deleting a gconf dir isn't what we'd normally do though,
## we'd normally set enabled=False in gconf, which would
## persist across restarts.
fields['enabled'] = False
self.__gconf_accounts.remove(account)
## second, look at weblogin driver, though we don't want to prefer
## its password over keyring, so there's some trickiness
weblogin_password = None
if account.get_kind() in self.__weblogin_info:
(username, weblogin_password) = self.__weblogin_info[account.get_kind()]
if 'username' not in fields:
fields['username'] = username
## if account was not disabled explicitly by gconf, we enable it
if 'enabled' not in fields:
fields['enabled'] = True
else:
if account in self.__weblogin_accounts:
self.__weblogin_accounts.remove(account)
## after compositing all this information, update our account object
account._update_from_origin(fields)
## use updated information to find password
fields = {}
## third, look for password in keyring
k = keyring.get_keyring()
password = k.get_password(kind=account.get_kind().get_id(),
username=account.get_username(),
url=account.get_url())
if password and 'password' not in fields:
_logger.debug("using password from keyring")
fields['password'] = password
## fourth, if no password in keyring, use the weblogin one
if weblogin_password and 'password' not in fields:
_logger.debug("using password from weblogin")
fields['password'] = weblogin_password
## if no password found, the password has to be set to empty
if 'password' not in fields:
fields['password'] = ''
## update account object again if we might have the password
if 'password' in fields:
account._update_from_origin(fields)
## now add or remove the account from the set of enabled accounts
if was_enabled and not account.get_enabled():
self.__enabled_accounts.remove(account)
self.emit('account-removed', account)
elif not was_enabled and account.get_enabled():
self.__enabled_accounts.add(account)
self.emit('account-added', account)
