def fields(self): # Only users with admin or purchase permission can modify transporters user = api.get_current_user(self.store) can_modify_transporter = any(( user.profile.check_app_permission(u'admin'), user.profile.check_app_permission(u'purchase'), )) freight_types = [(v, k) for k, v in Delivery.freights.items()] states = [(v, v) for v in api.get_l10n_field('state').state_list] return collections.OrderedDict( recipient=PersonQueryField(_("Recipient"), proxy=True, mandatory=True, person_type=self.person_type), transporter_id=PersonField(_("Transporter"), proxy=True, person_type=Transporter, can_add=can_modify_transporter, can_edit=can_modify_transporter), address=AddressField(_("Address"), proxy=True, mandatory=True), freight_type=ChoiceField(_("Freight type"), proxy=True, values=freight_types), price=PriceField(_("Delivery cost"), proxy=True), estimated_fix_date=DateField(_("Estimated delivery date"), proxy=True), volumes_kind=TextField(_("Volumes kind"), proxy=True), volumes_quantity=IntegerField(_("Volumes quantity"), proxy=True), volumes_net_weight=NumericField(_("Volumes net weight"), proxy=True, digits=3), volumes_gross_weight=NumericField(_("Volumes gross weight"), proxy=True, digits=3), vehicle_license_plate=TextField(_("Vehicle license plate"), proxy=True), vehicle_state=ChoiceField(_("Vehicle state"), proxy=True, use_entry=True, values=states), vehicle_registration=TextField(_("Vehicle registration"), proxy=True), )
def fields(self): return collections.OrderedDict( branch_id=PersonField(_('Branch'), proxy=True, person_type=Branch, can_add=False, can_edit=False, mandatory=True), method=PaymentMethodField(_('Method'), payment_type=self.payment_type, proxy=True, mandatory=True, separate=True), account=ChoiceField(self.account_label), description=TextField(_('Description'), proxy=True, mandatory=True), person=PersonQueryField(person_type=self.person_type, proxy=True), value=PriceField(_('Value'), proxy=True, mandatory=True), due_date=DateField(_('Due date'), proxy=True, mandatory=True), category=PaymentCategoryField(_('Category'), category_type=self.category_type, proxy=True), repeat=ChoiceField(_('Repeat')), end_date=DateField(_('End date')), attachment=AttachmentField(_('Attachment')))
def fields(self): return collections.OrderedDict( name=TextField(_('Name'), proxy=True), color=ColorField(_('Color'), proxy=True), category_type=ChoiceField(_('Type'), data_type=int, values=self._category_type_values, proxy=True), account=ChoiceField(_('Account'), values=self._get_account_options(), proxy=True), )
class CreditCheckHistoryEditor(BaseEditor): model_type = CreditCheckHistory model_name = _("Client Credit Check History") size = (400, -1) fields = dict( client=PersonField(_('Client'), proxy=True, person_type=Client, mandatory=True), identifier=TextField(_('Identifier'), proxy=True, mandatory=True), status=ChoiceField('Status', mandatory=True), check_date=DateField(_('Date'), proxy=True), user=ChoiceField(_('User')), notes=MultiLineField(_('Notes'), proxy=True), ) def __init__(self, store, model, client, visual_mode=None): self._client = client self.fields['status'].values = self.get_status_options() BaseEditor.__init__(self, store, model, visual_mode) if visual_mode or client: self.client_add_button.hide() self.client_edit_button.hide() if self.model.client: self.set_description(_('client credit check history for %s') % self.model.client.person.name) self.client.set_sensitive(False) else: self.set_description(_('client credit check history')) def create_model(self, store): return CreditCheckHistory(check_date=localtoday().date(), identifier=u'', status=CreditCheckHistory.STATUS_NOT_INCLUDED, client=self._client, notes=u'', user=api.get_current_user(self.store), store=store) def setup_proxies(self): self._fill_user_field() def _fill_user_field(self): self.user.prefill([(self.model.user.person.name, self.model.user)]) self.user.set_sensitive(False) @classmethod def get_status_options(cls): return [(value, key) for key, value in CreditCheckHistory.statuses.items()]
def fields(self): device_values = api.for_combo( CardPaymentDevice.get_devices(self.store)) provider_values = 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=IntegerField(_('Authorization'), proxy=True, mandatory=True) )
def fields(self): return collections.OrderedDict( client_id=PersonField(_('Client'), proxy=True, person_type=Client, mandatory=True), identifier=TextField(_('Identifier'), proxy=True, mandatory=True), status=ChoiceField('Status', values=self.get_status_options(), mandatory=True), check_date=DateField(_('Date'), proxy=True), user=ChoiceField(_('User')), notes=MultiLineField(_('Notes'), proxy=True), )
def fields(self): # Only users with admin or purchase permission can modify transporters user = api.get_current_user(self.store) can_modify_transporter = any(( user.profile.check_app_permission(u'admin'), user.profile.check_app_permission(u'purchase'), )) freight_types = [(v, k) for k, v in Delivery.freights.items()] return collections.OrderedDict( client_str=TextField(_("Client"), proxy=True, editable=False), transporter_id=PersonField(_("Transporter"), proxy=True, person_type=Transporter, can_add=can_modify_transporter, can_edit=can_modify_transporter), address=AddressField(_("Address"), proxy=True, mandatory=True), is_sent_check=BoolField(_("Was sent to deliver?")), send_date=DateField(_("Send date"), mandatory=True, proxy=True), tracking_code=TextField(_("Tracking code"), proxy=True), freight_type=ChoiceField(_("Freight type"), proxy=True, values=freight_types), volumes_kind=TextField(_("Volumes kind"), proxy=True), volumes_quantity=IntegerField(_("Volumes quantity"), proxy=True), is_received_check=BoolField(_("Was received by client?")), receive_date=DateField(_("Receive date"), mandatory=True, proxy=True), empty=EmptyField(), )
def fields(self): # Only users with admin or purchase permission can modify transporters user = api.get_current_user(self.store) can_modify_transporter = any(( user.profile.check_app_permission(u'admin'), user.profile.check_app_permission(u'purchase'), )) freight_types = [(v, k) for k, v in Delivery.freights.items()] return collections.OrderedDict( client=PersonQueryField(_("Client"), proxy=True, mandatory=True, person_type=Client), transporter_id=PersonField(_("Transporter"), proxy=True, person_type=Transporter, can_add=can_modify_transporter, can_edit=can_modify_transporter), address=AddressField(_("Address"), proxy=True, mandatory=True), freight_type=ChoiceField(_("Freight type"), proxy=True, values=freight_types), price=PriceField(_("Delivery cost"), proxy=True), estimated_fix_date=DateField(_("Estimated delivery date"), proxy=True), volumes_kind=TextField(_("Volumes kind"), proxy=True), volumes_quantity=IntegerField(_("Volumes quantity"), proxy=True), )
def fields(self): # Only users with admin or purchase permission can modify transporters user = api.get_current_user(self.store) can_modify_transporter = any(( user.profile.check_app_permission(u'admin'), user.profile.check_app_permission(u'purchase'), )) freight_types = [(v, k) for k, v in Delivery.freights.items()] states = [(v, v) for v in api.get_l10n_field('state').state_list] return collections.OrderedDict( recipient_str=TextField(_("Recipient"), proxy=True, editable=False), transporter_id=PersonField(_("Transporter"), proxy=True, person_type=Transporter, can_add=can_modify_transporter, can_edit=can_modify_transporter), address=AddressField(_("Address"), proxy=True, mandatory=True), is_sent_check=BoolField(_("Was sent to deliver?")), send_date=DateField(_("Send date"), mandatory=True, proxy=True), tracking_code=TextField(_("Tracking code"), proxy=True), freight_type=ChoiceField(_("Freight type"), proxy=True, values=freight_types), volumes_kind=TextField(_("Volumes kind"), proxy=True), volumes_quantity=IntegerField(_("Volumes quantity"), proxy=True), volumes_net_weight=NumericField(_("Volumes net weight"), proxy=True, digits=3), volumes_gross_weight=NumericField(_("Volumes gross weight"), proxy=True, digits=3), vehicle_license_plate=TextField(_("Vehicle license plate"), proxy=True), vehicle_state=ChoiceField(_("Vehicle state"), proxy=True, use_entry=True, values=states), vehicle_registration=TextField(_("Vehicle registration"), proxy=True), is_received_check=BoolField(_("Was received by recipient?")), receive_date=DateField(_("Receive date"), mandatory=True, proxy=True), empty=EmptyField(), )
def fields(self): user = 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 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), )
class CardPaymentDetailsEditor(BaseEditor): """Editor for :obj: `stoqlib.domain.payment.CreditCardData` """ model_type = CreditCardData fields = dict( device=ChoiceField(_('Device'), proxy=True, mandatory=True), provider=ChoiceField(_('Provider'), proxy=True, mandatory=True), auth=IntegerField(_('Authorization'), proxy=True, mandatory=True) ) def __init__(self, store, model, visual_mode=None): self.fields['device'].values = api.for_combo( CardPaymentDevice.get_devices(store)) self.fields['provider'].values = api.for_combo( CreditProvider.get_card_providers(store)) BaseEditor.__init__(self, store, model) def on_confirm(self): self.model.update_card_data(device=self.model.device, provider=self.model.provider, card_type=self.model.card_type, installments=self.model.installments)
class PaymentCategoryEditor(BaseEditor): model_name = _('Payment Category') model_type = PaymentCategory confirm_widgets = ['name'] proxy_widgets = ['category_type'] fields = dict( name=TextField(_('Name'), proxy=True), color=ColorField(_('Color'), proxy=True), category_type=ChoiceField(_('Type'), data_type=int), ) def __init__(self, store, model=None, category_type=None, visual_mode=False): self._category_type = category_type or PaymentCategory.TYPE_PAYABLE BaseEditor.__init__(self, store, model, visual_mode=visual_mode) if category_type is not None: self.category_type.set_sensitive(False) # # BaseEditor # def validate_confirm(self): category_type = self.model.category_type if (not self.edit_mode or self._original_category_type == category_type): return True payments = self.store.find(Payment, category=self.model) payments_count = payments.count() if (payments_count > 0 and not yesno( _("Changing the payment type will remove this category " "from %s payments. Are you sure?") % payments_count, gtk.RESPONSE_NO, _("Change"), _("Don't change"))): return False for p in payments: p.category = None return True def create_model(self, store): used_colors = set([pc.color for pc in store.find(PaymentCategory)]) color = get_random_color(ignore=used_colors) return PaymentCategory(name=u'', color=color, category_type=int(self._category_type), store=store) def setup_proxies(self): self.name.grab_focus() self.category_type.prefill([ (_('Payable'), PaymentCategory.TYPE_PAYABLE), (_('Receivable'), PaymentCategory.TYPE_RECEIVABLE) ]) self.add_proxy(self.model, self.proxy_widgets) self._original_category_type = self.model.category_type # # Kiwi Callbacks # def on_name__validate(self, widget, new_name): if not new_name: return ValidationError( _(u"The payment category should have name.")) if self.model.check_unique_value_exists(PaymentCategory.name, new_name): return ValidationError( _(u"The payment category '%s' already exists.") % new_name)
class _PaymentEditor(BaseEditor): confirm_widgets = ['due_date'] model_type = Payment model_name = _('payment') # Override in subclass person_type = None category_type = None payment_type = None fields = dict(branch=PersonField(_('Branch'), proxy=True, person_type=Branch, can_add=False, can_edit=False, mandatory=True), method=PaymentMethodField(_('Method'), proxy=True, mandatory=True, separate=True), description=TextField(_('Description'), proxy=True, mandatory=True), person=PersonField(proxy=True), value=PriceField(_('Value'), proxy=True, mandatory=True), due_date=DateField(_('Due date'), proxy=True, mandatory=True), category=PaymentCategoryField(_('Category'), proxy=True), repeat=ChoiceField(_('Repeat')), end_date=DateField(_('End date')), attachment=AttachmentField(_('Attachment'))) def __init__(self, store, model=None, category=None): """ A base class for additional payments :param store: a store :param model: a :class:`stoqlib.domain.payment.payment.Payment` object or None """ self.fields['person'].person_type = self.person_type self.fields['category'].category_type = self.category_type self.fields['method'].payment_type = self.payment_type BaseEditor.__init__(self, store, model) self._setup_widgets() if category: self.category.select_item_by_label(category) self.description.grab_focus() # # BaseEditor hooks # def create_model(self, store): group = PaymentGroup() money = PaymentMethod.get_by_name(store, u'money') branch = api.get_current_branch(store) # Set status to PENDING now, to avoid calling set_pending on # on_confirm for payments that shoud not have its status changed. return Payment(open_date=localtoday().date(), branch=branch, status=Payment.STATUS_PENDING, description=u'', value=currency(0), base_value=currency(0), due_date=None, method=money, group=group, till=None, category=None, payment_type=self.payment_type, bill_received=False) 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) self.add_proxy(self.model, _PaymentEditor.proxy_widgets) def validate_confirm(self): if (self.repeat.get_selected() != _ONCE and not self._validate_date()): return False # FIXME: the kiwi view should export it's state and it should # be used by default return bool(self.model.description and self.model.due_date and self.model.value) def on_confirm(self): self.model.base_value = self.model.value person = self.person.get_selected_data() if (person is not None and person is not ValueUnset and # FIXME: PersonField should never let get_selected_data() # return anything different from None and the model. person != ""): setattr(self.model.group, self.person_attribute, self.store.fetch(person.person)) self.model.attachment = self.fields['attachment'].attachment self.store.add(self.model.group) self.store.add(self.model) if self.repeat.get_selected() != _ONCE: Payment.create_repeated(self.store, self.model, self.repeat.get_selected(), self.model.due_date.date(), self.end_date.get_date()) # Private def _setup_widgets(self): self.person_lbl.set_label(self._person_label) if self.model.group.sale: label = _("Sale details") elif self.model.group.purchase: label = _("Purchase details") elif self.model.group._renegotiation: label = _("Details") else: label = _("Details") self.details_button = self.add_button(label) self.details_button.connect('clicked', self._on_details_button__clicked) self.end_date.set_sensitive(False) if self.edit_mode: for field_name in [ 'value', 'due_date', 'person', 'repeat', 'end_date', 'branch', 'method' ]: field = self.fields[field_name] field.can_add = False field.can_edit = False field.set_sensitive(False) person = getattr(self.model.group, self.person_attribute) if person: store = person.store facet = store.find(self.person_type, person=person).one() self.person.select(facet) def _show_order_dialog(self): group = self.model.group if group.sale: sale_view = self.store.find(SaleView, id=group.sale.id).one() run_dialog(SaleDetailsDialog, self, self.store, sale_view) elif group.purchase: run_dialog(PurchaseDetailsDialog, self, self.store, group.purchase) elif group._renegotiation: run_dialog(RenegotiationDetailsDialog, self, self.store, group._renegotiation) elif group.stock_decrease: run_dialog(StockDecreaseDetailsDialog, self, self.store, group.stock_decrease) else: run_dialog(LonelyPaymentDetailsDialog, self, self.store, self.model) def _get_min_date_for_interval(self, due_date, interval_type): if not due_date or interval_type is None: return None return due_date + interval_type_as_relativedelta(interval_type) def _validate_date(self): if not self.end_date.props.sensitive: return True end_date = self.end_date.get_date() due_date = self.due_date.get_date() min_date = self._get_min_date_for_interval(due_date, self.repeat.read()) if end_date and due_date: if end_date < due_date: self.end_date.set_invalid( _("End date cannot be before start date")) elif min_date and end_date < min_date: self.end_date.set_invalid( _("End date must be after %s for this " "repeat interval") % min_date.strftime('%x')) else: self.end_date.set_valid() self.refresh_ok(self.is_valid) return True elif not end_date: self.end_date.set_invalid(_("Date cannot be empty")) elif not due_date: self.due_date.set_invalid(_("Date cannot be empty")) self.refresh_ok(False) return False def _validate_person(self): payment_type = self.payment_type method = self.method.get_selected() if method.operation.require_person(payment_type): self.person.set_property('mandatory', True) else: self.person.set_property('mandatory', False) # # Kiwi Callbacks # def on_value__validate(self, widget, newvalue): if newvalue is None or newvalue <= 0: return ValidationError(_("The value must be greater than zero.")) def on_repeat__content_changed(self, repeat): if repeat.get_selected() == _ONCE: self.end_date.set_sensitive(False) # FIXME: need this check so tests won't crash if hasattr(self, 'main_dialog'): self.refresh_ok(True) return self.end_date.set_sensitive(True) self._validate_date() def on_due_date__content_changed(self, due_date): self._validate_date() def on_end_date__content_changed(self, end_date): self._validate_date() def _on_details_button__clicked(self, widget): self._show_order_dialog() def on_method__content_changed(self, method): self.person.validate(force=True) self._validate_person()