def cookie_login(self):
        if api.sysparam(api.get_default_store()).DISABLE_COOKIES:
            log.info("Cookies disable by parameter")
            return

        cookie_file = get_utility(ICookieFile)
        try:
            username, password = cookie_file.get()
        except CookieError:
            log.info("Not using cookie based login")
            return

        def is_md5(password):
            # This breaks for passwords that are 32 characters long,
            # uses only digits and lowercase a-f, pretty unlikely as
            # real-world password
            if len(password) != 32:
                return False
            for c in '1234567890abcdef':
                password = password.replace(c, '')
            return password == ''

        # Migrate old passwords to md5 hashes.
        if not is_md5(password):
            password = _encrypt_password(password)
            cookie_file.store(username, password)

        try:
            user = self._check_user(username, password)
        except (LoginError, UserProfileError, DatabaseError) as e:
            log.info("Cookie login failed: %r" % e)
            return

        log.info("Logging in using cookie credentials")
        return user

    def _check_user(self, username, password):
        username = unicode(username)
        password = unicode(password)
        # This function is really just a post-validation item.
        default_store = api.get_default_store()
        user = default_store.find(LoginUser, username=username).one()
        if not user:
            raise LoginError(_("Invalid user or password"))

        if not user.is_active:
            raise LoginError(_('This user is inactive'))

        branch = api.get_current_branch(default_store)
        # current_branch may not be set if we are registering a new station
        if branch and not user.has_access_to(branch):
            raise LoginError(_('This user does not have access to this branch'))

        if user.pw_hash != password:
            raise LoginError(_("Invalid user or password"))

        # Dont know why, but some users have this empty. Prevent user from
        # login in, since it will break later
        if not user.profile:
            msg = (_("User '%s' has no profile set, "
                     "but this should not happen.") % user.username + '\n\n' +
                   _("Please contact your system administrator or Stoq team."))
            warning(msg)
            raise LoginError(_("User does not have a profile"))

        user.login()

        # ICurrentUser might already be provided which is the case when
        # creating a new database, thus we need to replace it.
        provide_utility(ICurrentUser, user, replace=True)
        return user

def sentry_report(exctype, value, tb, **tags):
    tags.update({
        'version': stoqserver.version_str,
        'stoq_version': stoq.version,
        'architecture': platform.architecture(),
        'distribution': platform.dist(),
        'python_version': tuple(sys.version_info),
        'system': platform.system(),
        'uname': platform.uname(),
    })
    # Those are inside a try/except because thy require database access.
    # If the database access is not working, we won't be able to get them
    try:
        default_store = api.get_default_store()
        tags['user_hash'] = api.sysparam.get_string('USER_HASH')
        tags['demo'] = api.sysparam.get_bool('DEMO_MODE')
        tags['postgresql_version'] = get_database_version(default_store)
        tags['plugins'] = InstalledPlugin.get_plugin_names(default_store)
        tags['cnpj'] = get_main_cnpj(default_store)
    except Exception:
        pass

    # Disable send sentry log if we are on developer mode.
    developer_mode = stoqserver.library.uninstalled
    if raven_client is not None and not developer_mode:
        if hasattr(raven_client, 'user_context'):
            raven_client.user_context({'id': tags.get('hash', None),
                                       'username': tags.get('cnpj', None)})
        raven_client.captureException((exctype, value, tb), tags=tags)

    def _check_user(self, username, pw_hash):
        username = unicode(username)
        pw_hash = unicode(pw_hash)
        # This function is really just a post-validation item.
        default_store = api.get_default_store()
        current_branch = api.get_current_branch(default_store)

        user = LoginUser.authenticate(default_store, username, pw_hash,
                                      current_branch)

        # Dont know why, but some users have this empty. Prevent user from
        # login in, since it will break later
        if not user.profile:
            msg = (_("User '%s' has no profile set, "
                     "but this should not happen.") % user.username + '\n\n' +
                   _("Please contact your system administrator or Stoq team."))
            warning(msg)
            raise LoginError(_("User does not have a profile"))

        user.login()

        # ICurrentUser might already be provided which is the case when
        # creating a new database, thus we need to replace it.
        provide_utility(ICurrentUser, user, replace=True)
        return user

    def run_embedded(self, appdesc, app_window, params=None):
        app = self._load_app(appdesc, app_window)
        app.launcher = app_window

        self._current_app = app
        self._appname = appdesc.name

        if appdesc.name in self._blocked_apps:
            app_window.show()
            return

        app.run(params)

        # Possibly correct window position (livecd workaround for small
        # screens)
        from stoqlib.lib.pluginmanager import get_plugin_manager
        manager = get_plugin_manager()
        from stoqlib.api import api
        if (api.sysparam(api.get_default_store()).DEMO_MODE
            and manager.is_active(u'ecf')):
            pos = app.main_window.toplevel.get_position()
            if pos[0] < 220:
                app.main_window.toplevel.move(220, pos[1])

        return app

    def __init__(self, resource, manager, compact=False):
        self._resource = resource
        self._compact = compact
        self._manager = manager
        user = api.get_current_user(api.get_default_store())
        self._is_admin = user.profile.check_app_permission(u'admin')

        super(ResourceStatusBox, self).__init__(spacing=6)
        if compact:
            self.props.margin = 6
        else:
            self.props.margin = 12

        self.img = Gtk.Image()
        self.pack_start(self.img, False, True, 0)
        self.lbl = Gtk.Label()
        self.lbl.set_xalign(0)
        self.lbl.set_line_wrap(True)
        self.pack_start(self.lbl, False, True, 0)

        self.buttonbox = Gtk.Box()
        self.buttonbox.set_valign(Gtk.Align.CENTER)
        self.buttonbox.get_style_context().add_class('linked')
        if not compact:
            self.pack_end(self.buttonbox, False, True, 0)

 def get_uri(self):
     if locale.getlocale()[0] == 'pt_BR' or platform.system() == 'Windows':
         content = environ.find_resource('html', 'welcome-pt_BR.html')
     else:
         content = environ.find_resource('html', 'welcome.html')
     if api.sysparam(api.get_default_store()).DEMO_MODE:
         content += '?demo-mode'
     return 'file:///' + content

    def on_RemoveSettingsCache__activate(self, action):
        keys = ["app-ui", "launcher-geometry"]
        keys.append("search-columns-%s" % (api.get_current_user(api.get_default_store()).username,))

        for key in keys:
            try:
                api.user_settings.remove(key)
            except KeyError:
                pass

    def __init__(self, columns, tree=False, restore_name=None):
        self._restore_name = restore_name
        self._settings_key = 'search-columns-%s' % (
            api.get_current_user(api.get_default_store()).username, )
        self._columns = self.restore_columns(columns)

        SearchSlaveDelegate.__init__(self, self._columns, tree=tree)
        self.search.connect("search-completed",
                            self._on_search__search_completed)

def restore(restore_dir, user_hash, time=None):
    global _user_hash
    _user_hash = user_hash

    with _mock_environ():
        config = get_config()

        backup_key = config.get('Backup', 'key')
        if not backup_key:
            raise ValueError("No backup key set on configuration file")
        os.environ.setdefault('PASSPHRASE', backup_key)

        # Close the main store so the database can be dropped after this
        api.get_default_store().rollback(close=True)
        sys.argv.extend([_duplicity_bin, 'restore',
                         _webservice_url, restore_dir])
        if time is not None:
            sys.argv.extend(['--time', time])

        _duplicity_main.main()

 def _migrate_from_pickle(self):
     username = api.get_current_user(api.get_default_store()).username
     filename = os.path.join(get_application_dir(), 'columns-%s' % username,
                             self._restore_name + '.pickle')
     log.info("Migrating columns from pickle: %s" % (filename, ))
     try:
         with open(filename) as fd:
             import cPickle
             return cPickle.load(fd)
     except Exception, e:
         log.info("Exception while migrating: %r" % (e, ))
         return {}

 def validate_confirm(self):
     if not self.edit_mode:
         settings = DeviceSettings.get_by_station_and_type(
             store=api.get_default_store(), station=self.model.station.id, type=self.model.type
         )
         if settings:
             self.station.set_invalid(
                 _(u'A %s already exists for station "%s"')
                 % (self.model.get_device_type_name(), self.model.station.name)
             )
             return False
     return True

    def validate_confirm(self):
        settings = DeviceSettings.get_by_station_and_type(
            store=api.get_default_store(),
            station=self.model.station.id,
            type=self.model.type,
            exclude=self.model)
        if settings and self.is_active_button.get_active():
            warning(_(u"An active %s already exists for station \"%s\"") % (
                    self.model.device_type_name,
                    self.model.station_name))
            return False

        return True

    def setup_widgets(self):
        self.get_toplevel().set_size_request(*self.size)
        self.notification_label.set_text('')
        self.notification_label.set_color('black')

        if api.sysparam(api.get_default_store()).DISABLE_COOKIES:
            self.remember.hide()
            self.remember.set_active(False)

        gtkimage = gtk.Image()
        gtkimage.set_from_pixbuf(render_logo_pixbuf('login'))
        self.logo_container.add(gtkimage)
        self.logo_container.show_all()

    def _get_proxy(self):
        if self._proxy is None:
            config = get_config()
            if not config:
                raise ServerError(_('Configuration not found'))

            address = config.get('General', 'serveraddress')
            if not address:
                query = ("SELECT client_addr FROM pg_stat_activity "
                         "WHERE application_name LIKE ? AND "
                         "      datname = ? "
                         "LIMIT 1")
                params = [u'stoqserver%', str(db_settings.dbname)]
                res = api.get_default_store().execute(query, params=params).get_one()

                if res:
                    # When stoqserver is located in another machine
                    if res[0] not in ['127.0.0.1', '::1', '', None]:
                        address = res[0]
                    else:
                        # XXX: For now we only support ipv4
                        # XXX: If the client_addr is NULL, then stoqserver is
                        # connected using the unix socket, which means that he
                        # is in the same ip as the postgresql
                        address = db_settings.address
                        if not address:
                            address = 'localhost'
                else:
                    address = None

            if not address:
                raise ServerError(_("Stoq server not found"))

            port = config.get('General', 'serverport') or 6970
            url = 'http://%s:%s/XMLRPC' % (address, port)

            default_timeout = socket.getdefaulttimeout()
            socket.setdefaulttimeout(self._timeout)
            self._proxy = xmlrpc.client.ServerProxy(url, allow_none=True)
            socket.setdefaulttimeout(default_timeout)

        try:
            retval = self._proxy.ping()
        except (Exception, AttributeError):
            self._proxy = None
            raise

        if not retval:
            raise ServerError(_("Server not responding to pings"))

        return self._proxy

def register_payment_slaves():
    dsm = get_utility(IDomainSlaveMapper)
    default_store = api.get_default_store()
    for method_name, slave_class in [
        (u'money', MoneyMethodSlave),
        (u'bill', BillMethodSlave),
        (u'check', CheckMethodSlave),
        (u'card', CardMethodSlave),
        (u'store_credit', StoreCreditMethodSlave),
        (u'multiple', MultipleMethodSlave),
        (u'deposit', DepositMethodSlave)]:

        method = PaymentMethod.get_by_name(default_store, method_name)
        dsm.register(method, slave_class)

 def get_pixbuf(self, model):
     kind = model.kind
     if kind == 'payable':
         pixbuf = self._pixbuf_payable
     elif kind == 'receivable':
         pixbuf = self._pixbuf_receivable
     elif kind == 'account':
         till_account_id = sysparam(api.get_default_store()).TILLS_ACCOUNT.id
         if model.matches(till_account_id):
             pixbuf = self._pixbuf_till
         else:
             pixbuf = self._pixbuf_money
     else:
         return None
     return pixbuf

def setup_stoq(register_station=False, name='stoqserver', version=stoqserver.version_str):
    info = AppInfo()
    info.set('name', name)
    info.set('version', version)
    info.set('ver', version)
    provide_utility(IAppInfo, info, replace=True)

    # FIXME: Maybe we should check_schema and load plugins here?
    setup(config=get_config(), options=None, register_station=register_station,
          check_schema=False, load_plugins=True)

    # This is needed for api calls that requires the current branch set,
    # e.g. Sale.confirm
    main_company = api.sysparam.get_object(
        api.get_default_store(), 'MAIN_COMPANY')
    provide_utility(ICurrentBranch, main_company, replace=True)

    def on_confirm(self):
        till = self.model.till
        # Using api.get_default_store instead of self.store
        # or it will return self.model.till
        last_opened = Till.get_last_opened(api.get_default_store())
        if (last_opened and
            last_opened.opening_date.date() == till.opening_date.date()):
            warning(_("A till was opened earlier this day."))
            self.retval = False
            return

        try:
            TillOpenEvent.emit(till=till)
        except (TillError, DeviceError), e:
            warning(str(e))
            self.retval = False
            return

    def __init__(self, window, store=None):
        if store is None:
            store = api.get_default_store()
        self.store = store
        self.window = window

        self._sensitive_group = dict()
        self.help_ui = None
        self.uimanager = self.window.uimanager

        # FIXME: These two should probably post-__init__, but
        #        that breaks date_label in the calender app
        self._create_search()
        self.create_actions()
        GladeDelegate.__init__(self, gladefile=self.gladefile, toplevel_name=self.toplevel_name)
        self._attach_search()
        self.create_ui()