def _setup_widgets(self): self.tax_constant.prefill( stoq_api.for_combo(self.store.find(SellableTaxConstant))) categories = set(self.store.find(SellableCategory, SellableCategory.id != self.model.id)) # Remove all children recursively to avoid creating # a circular hierarchy categories -= self.model.get_children_recursively() self.category.prefill( stoq_api.for_combo(categories, attr='full_description')) self.suggested_markup.set_adjustment( Gtk.Adjustment(lower=0, upper=MAX_INT, step_increment=1))
def test_for_combo_attr(self): individual = self.create_individual() individual.father_name = u'Daddy' individual.mother_name = u'Mommy' results = self.store.find(Individual, father_name=u'Daddy') items = stoq_api.for_combo(results, attr=u'mother_name') self.assertEqual(items, [('Mommy', individual)])
def _update_accounts(self): if len(self._payments) != 1: return payment = self._payments[0] create_transaction = payment.method.operation.create_transaction() for combo in [self.destination_account, self.source_account]: combo.set_sensitive(create_transaction) if not create_transaction: return destination_combo = self.get_account_destination_combo() for combo in [self.destination_account, self.source_account]: combo.prefill( stoq_api.for_combo(self.store.find(Account), attr='long_description')) if combo is destination_combo: combo.select(payment.method.destination_account) else: combo.select( sysparam.get_object(self.store, 'IMBALANCE_ACCOUNT')) category_account = payment.category and payment.category.account if category_account: if payment.payment_type == payment.TYPE_IN: self.source_account.select(category_account) else: self.destination_account.select(category_account)
def create_filters(self): # Category categories = self.store.find(SellableCategory) items = stoq_api.for_combo(categories, attr='full_description') items.insert(0, (_('Any'), None)) category_filter = ComboSearchFilter(_('Category'), items) self.add_filter(category_filter, columns=[Sellable.category])
def _setup_widgets(self): self.total.set_bold(True) idents = sorted(p.identifier for p in self.purchases) identifier = ', '.join(str(i) for i in idents) self.identifier.set_text(identifier) # TODO: Testar isso quando compras > 1 if len(self.purchases) == 1 and self.purchases[0].is_paid(): # This widgets would make the value of the installments change. for widget in (self.ipi, self.discount_value, self.icms_total, self.icms_st_total, self.secure_value, self.expense_value): widget.set_sensitive(False) # Only allow to edit the cfop if there is only one receiving for this invoice self.cfop.set_sensitive( bool(not self.visual_mode and self._receiving_order)) self._setup_transporter_entry() self._setup_freight_combo() cfops = CfopData.get_for_receival(self.store) self.cfop.prefill(stoq_api.for_combo(cfops)) self.table.set_focus_chain([ self.invoice_hbox, self.invoice_key, self.cfop, self.transporter, self.freight_combo, self.notes_box, self.freight, self.ipi, self.icms_total, self.icms_st_total, self.discount_value, self.secure_value, self.expense_value ])
def populate(self, gridgroup): from stoqlib.domain.product import GridGroup store = get_store_for_field(self) self.prefill(stoq_api.for_combo(store.find(GridGroup)), gridgroup) self.add_button.set_tooltip_text(_("Add a new grid group")) self.edit_button.set_tooltip_text(_("Edit the grid group"))
def _setup_widgets(self): # Salesperson combo salespersons = SalesPerson.get_active_salespersons( self.store, api.get_current_branch(self.store)) self.salesperson.prefill(salespersons) change_salesperson = sysparam.get_int('ACCEPT_CHANGE_SALESPERSON') if change_salesperson == ChangeSalespersonPolicy.ALLOW: self.salesperson.grab_focus() elif change_salesperson == ChangeSalespersonPolicy.DISALLOW: self.salesperson.set_sensitive(False) elif change_salesperson == ChangeSalespersonPolicy.FORCE_CHOOSE: self.model.salesperson = None self.salesperson.grab_focus() else: raise AssertionError # CFOP combo if sysparam.get_bool('ASK_SALES_CFOP'): cfops = CfopData.get_for_sale(self.store) self.cfop.prefill(stoq_api.for_combo(cfops)) else: self.cfop_lbl.hide() self.cfop.hide() self.create_cfop.hide() self._fill_clients_category_combo() self._setup_clients_widget() self._client_credit_set_visible(bool(self.client.read()))
def fields(self): device_values = stoq_api.for_combo( CardPaymentDevice.get_devices(self.store)) provider_values = stoq_api.for_combo( CreditProvider.get_card_providers(self.store)) return collections.OrderedDict( device=ChoiceField(_('Device'), proxy=True, mandatory=True, values=device_values), provider=ChoiceField(_('Provider'), proxy=True, mandatory=True, values=provider_values), auth=TextField(_('Authorization'), proxy=True, mandatory=True))
def _fill_clients_category_combo(self): categories = self.store.find(ClientCategory).order_by( ClientCategory.name) self.client_category.prefill(stoq_api.for_combo(categories, empty='')) if categories.is_empty(): self.client_category.hide() self.client_category_lbl.hide()
def setup_sellable_combos(self): self._fill_categories() self.edit_category.set_sensitive(False) cfops = CfopData.get_for_sale(self.store) self.default_sale_cfop.prefill(stoq_api.for_combo(cfops, empty='')) self.setup_unit_combo()
def _setup_widgets(self): """Populate device widgets and set some properties""" # Let the user edit provider_id when creating a new one self.provider_id.set_property('sensitive', not self.edit_mode) self.provider_id.set_property('editable', not self.edit_mode) devices = CardPaymentDevice.get_devices(self.store) self.default_device.prefill( stoq_api.for_combo(devices, empty=_(u"No device")))
def populate(self, cfop): from stoqlib.domain.fiscal import CfopData store = get_store_for_field(self) cfops = store.find(CfopData) self.prefill(stoq_api.for_combo(cfops), cfop) self.add_button.set_tooltip_text(_("Add a new C.F.O.P")) self.edit_button.set_tooltip_text(_("View C.F.O.P details"))
def setup_entry(self, entry): entry.set_mode(ENTRY_MODE_DATA) entry.set_exact_completion() completion = entry.get_completion() completion.set_minimum_key_length = 1 items = self.model.get_available_batches( api.get_current_branch(self.store)) entry.prefill(stoq_api.for_combo(items))
def test_for_combo_all(self): client = self.create_client() client.credit_limit = 99 clients = self.store.find( Client, credit_limit=99, ) items = stoq_api.for_combo(clients) self.assertEqual(items, [('Client', client)])
def setup_proxies(self): categories = self.store.find(ClientCategory) self.category_combo.prefill(stoq_api.for_combo(categories, empty='')) table = self.model_type items = [(value, constant) for constant, value in table.statuses.items()] self.statuses_combo.prefill(items) self.proxy = self.add_proxy(self.model, ClientStatusSlave.proxy_widgets)
def setup_proxies(self): groups = list(GridGroup.get_active_groups(self.store)) # If the current group is no longer active, we must add it to the list # of groups: if not self.model.group.is_active: groups.append(self.model.group) self.fields['group'].prefill( stoq_api.for_combo(groups, attr='description'), self.model.group) self.proxy = self.add_proxy(self.model, self.proxy_widgets)
def _fill_categories_combo(self): if self.categories_for_combo is not None: categories = self.store.find( WorkOrderCategory, In(WorkOrderCategory.name, self.categories_for_combo)) else: categories = self.store.find(WorkOrderCategory) self.category.color_attribute = 'color' self.category.prefill( stoq_api.for_combo(categories, empty=_(u"No category")))
def setup_proxies(self): if api.sysparam.get_bool('SYNCHRONIZED_MODE'): current = api.get_current_branch(self.store) branches = [(current.get_description(), current)] else: branches = stoq_api.for_combo( Branch.get_active_branches(self.store)) self.branch.prefill(branches) self.add_proxy(self.model, self.proxy_widgets)
def _fill_person_combo(self): if self.model.person: self.person_combo.prefill([(self.model.person.name, self.model.person)]) self.person_combo.set_sensitive(False) else: # Get only persons of person_type by joining with the table query = (self.person_type.person_id == Person.id) persons = self.store.find(Person, query) self.person_combo.prefill(stoq_api.for_combo(persons, attr='name'))
def create_filters(self): self.search.set_query(self.executer_query) # Category categories = self.store.find(SellableCategory) items = stoq_api.for_combo(categories, attr='full_description') items.insert(0, (_('Any'), None)) category_filter = ComboSearchFilter(_('Category'), items) self.add_filter(category_filter, position=SearchFilterPosition.TOP) self.category_filter = category_filter
def fields(self): user = stoq_api.for_combo(self.store.find(Employee), empty='') return collections.OrderedDict( responsible=ChoiceField(_("Responsible"), mandatory=True, use_entry=True, proxy=True, values=user), notes=TextField(_('Notes'), proxy=True), )
def populate(self, address): from stoqlib.domain.address import Address self.person = address.person if address else None store = get_store_for_field(self) addresses = store.find(Address, person=self.person).order_by(Address.street) self.prefill(stoq_api.for_combo(addresses), address) self.add_button.set_tooltip_text(_("Add a new address")) self.edit_button.set_tooltip_text(_("Edit the selected address"))
def create_filters(self): self.search.set_query(self._query) self.set_text_field_columns([ 'description', 'code', 'barcode', 'category_description', 'manufacturer' ]) branches = Branch.get_active_branches(self.store) self.branch_filter = ComboSearchFilter( _('Show by:'), stoq_api.for_combo(branches, empty=_("All branches"))) self.branch_filter.select(api.get_current_branch(self.store)) self.add_filter(self.branch_filter, position=SearchFilterPosition.TOP)
def populate(self, value): from stoqlib.domain.payment.category import PaymentCategory store = get_store_for_field(self) categories = PaymentCategory.get_by_type(store, self.category_type) values = stoq_api.for_combo(categories, empty=_('No category'), attr='name') self.prefill(values, value) # FIXME: Move to noun self.add_button.set_tooltip_text(_("Add a new payment category")) self.edit_button.set_tooltip_text( _("Edit the selected payment category"))
def _fill_wo_categories_combo(self): wo_categories = list(self.store.find(WorkOrderCategory)) self.wo_categories.color_attribute = 'color' self.wo_categories.prefill( stoq_api.for_combo(wo_categories, empty=_("No category"))) self.wo_categories.set_sensitive(len(wo_categories)) # We can use any work order, since all workorders in the same sale are # sharing the same category. workorder = WorkOrder.find_by_sale(self.store, self.model).any() if workorder and workorder.category: self.wo_categories.select(workorder.category)
def populate(self, value): from stoqlib.domain.payment.method import PaymentMethod assert self.payment_type is not None store = get_store_for_field(self) methods = set( PaymentMethod.get_creatable_methods(store, self.payment_type, separate=self.separate)) # Add the current value, just in case the payment method is not # currently creatable methods.add(value) self.widget.prefill(stoq_api.for_combo(methods)) if value is not None: self.widget.select(value)
def _fill_cost_center_combo(self): cost_centers = CostCenter.get_active(self.store) # we keep this value because each call to is_empty() is a new sql query # to the database cost_centers_exists = not cost_centers.is_empty() if cost_centers_exists: self.cost_center.prefill( stoq_api.for_combo(cost_centers, attr='name', empty=_('No cost center.'))) self.cost_center.set_visible(cost_centers_exists) self.cost_center_lbl.set_visible(cost_centers_exists)
def _setup_widgets(self): # Set a default provider, otherwise, if the user does not change the # combo, the provider may not be set (bug in kiwi) providers = CreditProvider.get_card_providers(self.store).order_by( CreditProvider.short_name) self.provider.prefill(stoq_api.for_combo(providers)) types = [(value, key) for key, value in CreditCardData.types.items()] self.card_type.prefill(types) # Set values to the ones of the model self.installment_start.set_value(self.model.installment_start) self.installment_end.set_value(self.model.installment_end) self.set_installment_limits()
def fields(self): suppliers = stoq_api.for_combo(self.store.find(Supplier), empty='') return collections.OrderedDict( item=ChoiceField(_('Item'), mandatory=True, use_entry=True, proxy=True, values=self.items), # FIXME change to an appropiate name supplier=ChoiceField(_('Supplier'), mandatory=True, use_entry=True, proxy=True, values=suppliers), supplier_order=TextField(_('Supplier Order'), mandatory=True, proxy=True), is_freebie=BoolField(_('Freebie'), proxy=True), )
def setup_proxies(self): repeat_types = get_interval_type_items(with_multiples=True, adverb=True) repeat_types.insert(0, (_('Once'), _ONCE)) self.repeat.prefill(repeat_types) is_paid = self.model.is_paid() # Show account information only after the payment is paid if is_paid: accounts = Account.get_accounts(self.store) self.account.prefill( stoq_api.for_combo(accounts, attr='long_description')) if self.payment_type == Payment.TYPE_OUT: account = self.model.transaction.source_account else: account = self.model.transaction.account self.account.select(account) self.account.set_property('sensitive', False) else: self.account.hide() self.account_lbl.hide() self.add_proxy(self.model, _PaymentEditor.proxy_widgets)