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()
