def create_model(self, store):
     return DeviceSettings(device_name=None,
                           station=api.get_current_station(store),
                           brand=None,
                           model=None,
                           type=None,
                           store=store)

    def test_print_invoice(self, info, print_sale_invoice, run_dialog, new_store):
        new_store.return_value = self.store

        app = self.create_app(SalesApp, u"sales")
        results = app.main_window.results
        results.select(results[0])

        self.activate(app.main_window.SalesPrintInvoice)
        info.assert_called_once_with(u"There are no invoice printer configured " u"for this station")

        layout = InvoiceLayout(description=u"layout", width=10, height=20, store=self.store)
        printer = InvoicePrinter(
            store=self.store,
            description=u"test invoice",
            layout=layout,
            device_name=u"/dev/lp0",
            station=api.get_current_station(self.store),
        )
        self.activate(app.main_window.SalesPrintInvoice)
        self.assertEquals(print_sale_invoice.call_count, 1)
        args, kwargs = print_sale_invoice.call_args
        invoice, called_printer = args
        self.assertTrue(isinstance(invoice, SaleInvoice))
        self.assertEquals(printer, called_printer)

        results[0].sale.invoice_number = None
        InvoiceField(layout=layout, x=0, y=0, width=1, height=1, field_name=u"INVOICE_NUMBER", store=self.store)
        with mock.patch.object(self.store, "commit"):
            with mock.patch.object(self.store, "close"):
                self.activate(app.main_window.SalesPrintInvoice)
                run_dialog.assert_called_once_with(SaleInvoicePrinterDialog, self.store, results[0].sale, printer)

    def _open_till(self, store):
        till = Till(store=store, station=api.get_current_station(store))
        till.open_till()

        TillOpenEvent.emit(till=till)
        self.assertEquals(till, Till.get_current(store))
        return till

    def _create_statusbar(self):
        statusbar = ShellStatusbar(self)

        # Set the initial text, the currently logged in user and the actual
        # branch and station.
        user = api.get_current_user(self.store)
        station = api.get_current_station(self.store)
        status_str = "   |   ".join([_("User: %s") % (user.get_description(),), _("Computer: %s") % (station.name,)])
        statusbar.push(0, status_str)
        return statusbar

    def populate_namespace(self, bare):
        for table in get_table_types():
            self.ns[table.__name__] = table

        self.ns["store"] = self.store
        self.ns["sysparam"] = api.sysparam
        self.ns["api"] = api

        if not bare:
            self.ns["branch"] = api.get_current_branch(self.store)
            self.ns["station"] = api.get_current_station(self.store)
            self.ns["now"] = datetime.datetime.now
            self.ns["today"] = datetime.date.today

            for name in ("stoqlib.database.runtime", "stoqlib.lib.interfaces", "stoqlib.domain.interfaces"):
                mod = __import__(name, {}, {}, " ")
                self.ns.update(mod.__dict__)

    def populate_namespace(self, bare):
        for table in get_table_types():
            self.ns[table.__name__] = table

        self.ns['store'] = self.store
        self.ns['sysparam'] = api.sysparam
        self.ns['api'] = api

        if not bare:
            self.ns['branch'] = api.get_current_branch(self.store)
            self.ns['station'] = api.get_current_station(self.store)
            self.ns['now'] = datetime.datetime.now
            self.ns['today'] = datetime.date.today

            for name in ('stoqlib.database.runtime',
                         'stoqlib.lib.interfaces',
                         'stoqlib.domain.interfaces'):
                mod = __import__(name, {}, {}, ' ')
                self.ns.update(mod.__dict__)

    def process_one(self, data, fields, store):
        if data.parent_account:
            name = _(data.parent_account)
            parent = store.find(Account, description=name).one()
        else:
            parent = None
        account = Account(description=data.description,
                          parent=parent,
                          code=None,
                          station=api.get_current_station(store),
                          account_type=int(data.account_type),
                          store=store)

        if data.bank_number:
            BankAccount(account=account,
                        bank_account=data.bank_account,
                        bank_number=int(data.bank_number),
                        bank_branch=data.bank_branch,
                        store=store)

    def _print_invoice(self):
        sale_view = self.results.get_selected()
        assert sale_view
        sale = sale_view.sale
        station = api.get_current_station(self.store)
        printer = InvoicePrinter.get_by_station(station, self.store)
        if printer is None:
            info(_("There are no invoice printer configured for this station"))
            return
        assert printer.layout

        invoice = SaleInvoice(sale, printer.layout)
        if not invoice.has_invoice_number() or sale.invoice.invoice_number:
            print_sale_invoice(invoice, printer)
        else:
            store = api.new_store()
            retval = self.run_dialog(SaleInvoicePrinterDialog, store, store.fetch(sale), printer)
            store.confirm(retval)
            store.close()

    def create_model(self, store):
        till = Till(store=store, station=api.get_current_station(store))
        till.open_till()

        return _TillOpeningModel(till=till, value=currency(0))