def test_getactive_branches(self):
person = self.create_person()
Company(person=person, store=self.store)
count = Branch.get_active_branches(self.store).count()
manager = self.create_employee()
branch = Branch(person=person, store=self.store,
manager=manager, is_active=True)
assert branch.get_active_branches(self.store).count() == count + 1
def test_getactive_branches(self):
person = self.create_person()
Company(person=person, store=self.store)
count = Branch.get_active_branches(self.store).count()
manager = self.create_employee()
branch = Branch(person=person,
store=self.store,
manager=manager,
is_active=True)
assert branch.get_active_branches(self.store).count() == count + 1
def _setup_widgets(self):
branches = Branch.get_active_remote_branches(self.store)
self.destination_branch.prefill(api.for_person_combo(branches))
self.source_branch.set_text(self.branch.get_description())
employees = self.store.find(Employee)
self.source_responsible.prefill(api.for_person_combo(employees))
def test_receive_order(self, print_report, yesno):
yesno.retval = True
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
# Created and sent the order.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.click(dialog.print_button)
print_report.assert_called_once_with(dialog.report_class, dialog.model)
self.assertSensitive(dialog, ['receive_button'])
with mock.patch.object(self.store, 'commit'):
self.click(dialog.receive_button)
yesno.assert_called_once_with(u'Receive the order?', gtk.RESPONSE_YES,
u'Receive', u"Don't receive")
self.assertEquals(order.status, order.STATUS_RECEIVED)
self.assertEquals(order.cancel_date, None)
def _setup_widgets(self):
branches = Branch.get_active_remote_branches(self.store)
self.destination_branch.prefill(api.for_person_combo(branches))
self.source_branch.set_text(self.branch.get_description())
employees = self.store.find(Employee)
self.source_responsible.prefill(api.for_person_combo(employees))
def test_cancel_order_nfce_plugin_active(self, get_plugin_manager,
run_dialog):
dest_branch = Branch.get_active_remote_branches(
self.store, api.get_current_branch(self.store))[0]
source_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send(self.current_user)
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
get_plugin_manager.is_active.return_value = True
run_dialog.return_value = Note()
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
msg_text = u"This will cancel the transfer. Are you sure?"
run_dialog.assert_called_once_with(
NoteEditor,
dialog,
order.store,
model=None,
message_text=msg_text,
label_text=u"Reason",
mandatory=True,
ok_button_label=u"Cancel transfer",
cancel_button_label=u"Don't cancel",
min_length=15)
self.assertEqual(order.status, TransferOrder.STATUS_CANCELLED)
self.assertEqual(order.receival_date, None)
def _setup_widgets(self):
quote_group = "%05d" % self.wizard.quote_group.id
self.quote_group.set_text(quote_group)
branches = Branch.get_active_branches(self.store)
self.branch_combo.prefill(api.for_person_combo(branches))
self.notes.set_accepts_tab(False)
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:"), 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 _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
# Created order, did not send it yet.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
# Created and sent the order.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
order.send()
# Order arrived at the destination.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20486
order.open_date = localdatetime(2012, 3, 3)
order.send()
order.receive(self.create_employee())
order.receival_date = localdatetime(2012, 3, 4)
def _setup_widgets(self):
quote_group = str(self.wizard.quote_group.identifier)
self.quote_group.set_text(quote_group)
branches = Branch.get_active_branches(self.store)
self.branch_combo.prefill(api.for_person_combo(branches))
self.notes.set_accepts_tab(False)
def populate(self, person):
from stoqlib.domain.person import (Client, Supplier, Transporter,
SalesPerson, Branch)
store = get_store_for_field(self)
person_type = self.person_type
if person_type == Supplier:
objects = Supplier.get_active_suppliers(store)
self.add_button.set_tooltip_text(_("Add a new supplier"))
self.edit_button.set_tooltip_text(_("Edit the selected supplier"))
elif person_type == Client:
objects = Client.get_active_clients(store)
self.add_button.set_tooltip_text(_("Add a new client"))
self.edit_button.set_tooltip_text(_("Edit the selected client"))
elif person_type == Transporter:
objects = Transporter.get_active_transporters(store)
self.add_button.set_tooltip_text(_("Add a new transporter"))
self.edit_button.set_tooltip_text(
_("Edit the selected transporter"))
elif person_type == SalesPerson:
objects = SalesPerson.get_active_salespersons(store)
self.add_button.set_tooltip_text(_("Add a new sales person"))
self.edit_button.set_tooltip_text(
_("Edit the selected sales person"))
elif person_type == Branch:
objects = Branch.get_active_branches(store)
self.add_button.set_tooltip_text(_("Add a new branch"))
self.edit_button.set_tooltip_text(_("Edit the selected branch"))
else:
raise AssertionError(self.person_type)
self.widget.prefill(api.for_person_combo(objects))
if person:
assert isinstance(person, person_type)
self.widget.select(person)
def test_cancel_order_nfce_plugin_active(self, get_plugin_manager,
run_dialog):
dest_branch = Branch.get_active_remote_branches(self.store)[0]
source_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
get_plugin_manager.is_active.return_value = True
run_dialog.return_value = Note()
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
msg_text = u"This will cancel the transfer. Are you sure?"
run_dialog.assert_called_once_with(
NoteEditor, dialog, order.store, model=None,
message_text=msg_text, label_text=u"Reason", mandatory=True,
ok_button_label=u"Cancel transfer",
cancel_button_label=u"Don't cancel",
min_length=15)
self.assertEqual(order.status, TransferOrder.STATUS_CANCELLED)
self.assertEqual(order.receival_date, None)
def process_one(self, data, fields, store):
person = Person(store=store,
name=data.name,
phone_number=data.phone_number,
fax_number=data.fax_number)
Company(person=person,
cnpj=data.cnpj,
state_registry=data.state_registry,
fancy_name=data.fancy_name,
store=store)
ctloc = CityLocation.get_or_create(store=store,
city=data.city,
state=data.state,
country=data.country)
streetnumber = data.streetnumber and int(data.streetnumber) or None
Address(is_main_address=True,
person=person,
city_location=ctloc,
store=store,
street=data.street,
streetnumber=streetnumber,
district=data.district,
postal_code=data.postal_code)
branch = Branch(person=person, store=store)
for user in store.find(LoginUser):
user.add_access_to(branch)
self.branches.append(branch)
def test_receive_order(self, print_report, yesno):
yesno.retval = True
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
# Created and sent the order.
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.click(dialog.print_button)
print_report.assert_called_once_with(dialog.report_class, dialog.model)
self.assertSensitive(dialog, ['receive_button'])
with mock.patch.object(self.store, 'commit'):
self.click(dialog.receive_button)
yesno.assert_called_once_with(u'Receive the order?', Gtk.ResponseType.YES,
u'Receive', u"Don't receive")
self.assertEqual(order.status, order.STATUS_RECEIVED)
self.assertEqual(order.cancel_date, None)
def populate(self, person):
from stoqlib.domain.person import (Client, Supplier, Transporter,
SalesPerson, Branch)
store = get_store_for_field(self)
person_type = self.person_type
if person_type == Supplier:
objects = Supplier.get_active_suppliers(store)
self.add_button.set_tooltip_text(_("Add a new supplier"))
self.edit_button.set_tooltip_text(_("Edit the selected supplier"))
elif person_type == Client:
objects = Client.get_active_clients(store)
self.add_button.set_tooltip_text(_("Add a new client"))
self.edit_button.set_tooltip_text(_("Edit the selected client"))
elif person_type == Transporter:
objects = Transporter.get_active_transporters(store)
self.add_button.set_tooltip_text(_("Add a new transporter"))
self.edit_button.set_tooltip_text(_("Edit the selected transporter"))
elif person_type == SalesPerson:
objects = SalesPerson.get_active_salespersons(store)
self.add_button.set_tooltip_text(_("Add a new sales person"))
self.edit_button.set_tooltip_text(_("Edit the selected sales person"))
elif person_type == Branch:
objects = Branch.get_active_branches(store)
self.add_button.set_tooltip_text(_("Add a new branch"))
self.edit_button.set_tooltip_text(_("Edit the selected branch"))
else:
raise AssertionError(self.person_type)
self.widget.prefill(api.for_person_combo(objects))
if person:
assert isinstance(person, person_type)
self.widget.select(person)
def create_model(self, store):
person = BasePersonRoleEditor.create_model(self, store)
branch = person.branch
if branch is None:
branch = Branch(person=person, store=store)
return branch
def _provide_current_station(station_name=None, branch_name=None):
if not station_name:
station_name = get_hostname()
store = new_store()
if branch_name:
branch = store.find(
Person,
And(Person.name == branch_name,
Branch.person_id == Person.id)).one()
else:
branches = store.find(Branch)
if branches.count() == 0:
person = Person(name=u"test", store=store)
branch = Branch(person=person, store=store)
else:
branch = branches[0]
provide_utility(ICurrentBranch, branch)
station = BranchStation.get_station(store, branch, station_name)
if not station:
station = BranchStation.create(store, branch, station_name)
assert station
assert station.is_active
provide_utility(ICurrentBranchStation, station)
store.commit(close=True)
def _create_model(self, store):
user = api.get_current_user(store)
source_responsible = store.find(Employee, person=user.person).one()
return TransferOrder(
source_branch=api.get_current_branch(store),
source_responsible=source_responsible,
destination_branch=Branch.get_active_remote_branches(store)[0],
store=store)
def create_filters(self):
self.search.set_query(self._query)
self.set_text_field_columns(['description'])
branches = Branch.get_active_branches(self.store)
self.branch_filter = ComboSearchFilter(
_('Show by:'), 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 _create_model(self, store):
user = api.get_current_user(store)
source_responsible = store.find(Employee, person=user.person).one()
return TransferOrder(
source_branch=api.get_current_branch(store),
source_responsible=source_responsible,
destination_branch=Branch.get_active_remote_branches(store)[0],
store=store)
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
responsible = self.create_employee()
other_branch = Branch.get_active_remote_branches(
self.store, self.current_branch)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send(self.current_user)
# One that we have already received
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
order.send(self.current_user)
order.receive(self.current_user, responsible)
order.receival_date = localdatetime(2012, 2, 2)
# One that we have sent but is not received yet
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20486
order.open_date = localdatetime(2012, 3, 3)
order.send(self.current_user)
# One that we have sent and is recived
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20489
order.open_date = localdatetime(2012, 3, 4)
order.send(self.current_user)
order.receive(self.current_user, responsible)
order.receival_date = localdatetime(2012, 3, 5)
# And another one that is cancelled
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20491
order.open_date = localdatetime(2012, 4, 5)
order.send(self.current_user)
order.cancel(self.current_user,
responsible,
'Cancelled due something',
self.current_branch,
cancel_date=localdatetime(2012, 4, 6))
def _get_branch_values(self):
if api.sysparam.get_bool('SYNCHRONIZED_MODE'):
current = api.get_current_branch(self.store)
items = [(current.get_description(), current.id)]
else:
items = [(b.get_description(), b.id) for b
in Branch.get_active_branches(self.store)]
items.insert(0, (_('Any'), None))
return items
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 = api.for_combo(Branch.get_active_branches(self.store))
self.branch.prefill(branches)
self.add_proxy(self.model, self.proxy_widgets)
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 = api.for_combo(Branch.get_active_branches(self.store))
self.branch.prefill(branches)
self.add_proxy(self.model, self.proxy_widgets)
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:'), 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 create_branch(self, name=u'Dummy', phone_number=u'12345678',
fax_number=u'87564321'):
from stoqlib.domain.person import Branch, Company, Person
person = Person(name=name, phone_number=phone_number,
fax_number=fax_number, store=self.store)
self.create_address(person=person)
fancy_name = name + u' shop'
Company(person=person, fancy_name=fancy_name,
store=self.store)
return Branch(person=person, store=self.store)
def _prefill_branches(self):
branches = Branch.get_active_remote_branches(self.store)
current_branch = api.get_current_branch(self.store)
# Branches not allowed to execute foreign work orders can only send
# orders for those who can
if not current_branch.can_execute_foreign_work_orders:
branches = branches.find(can_execute_foreign_work_orders=True)
self.destination_branch.prefill(api.for_person_combo(branches))
def _prefill_branches(self):
branches = Branch.get_active_remote_branches(self.store)
current_branch = api.get_current_branch(self.store)
# Branches not allowed to execute foreign work orders can only send
# orders for those who can
if not current_branch.can_execute_foreign_work_orders:
branches = branches.find(can_execute_foreign_work_orders=True)
self.destination_branch.prefill(api.for_person_combo(branches))
def _setup_widgets(self):
quote_group = str(self.wizard.quote_group.identifier)
self.quote_group.set_text(quote_group)
branches = Branch.get_active_branches(self.store)
self.branch_combo.prefill(api.for_person_combo(branches))
sync_mode = api.sysparam.get_bool('SYNCHRONIZED_MODE')
self.branch_combo.set_sensitive(not sync_mode)
self.notes.set_accepts_tab(False)
def _setup_widgets(self):
quote_group = str(self.wizard.quote_group.identifier)
self.quote_group.set_text(quote_group)
branches = Branch.get_active_branches(self.store)
self.branch_combo.prefill(api.for_person_combo(branches))
sync_mode = api.sysparam.get_bool('SYNCHRONIZED_MODE')
self.branch_combo.set_sensitive(not sync_mode)
self.notes.set_accepts_tab(False)
def test_company_find_by_cnpj_with_extra_query(store, example_creator):
branch = example_creator.create_branch(cnpj='71.225.183/0001-34')
branch.name = 'teste'
branch2 = example_creator.create_branch(cnpj='71.225.183/0001-34')
branch2.name = 'should not be found'
extra_query = Branch.name == 'teste'
branches = Branch.find_by_cnpj(store,
'71.225.183/0001-34',
extra_query=extra_query)
assert set(branches) == {branch}
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
responsible = self.create_employee()
other_branch = Branch.get_active_remote_branches(self.store)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send()
# One that we have already received
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 56832
order.open_date = localdatetime(2012, 2, 2)
order.send()
order.receive(responsible)
order.receival_date = localdatetime(2012, 2, 2)
# One that we have sent but is not received yet
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20486
order.open_date = localdatetime(2012, 3, 3)
order.send()
# One that we have sent and is recived
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20489
order.open_date = localdatetime(2012, 3, 4)
order.send()
order.receive(responsible)
order.receival_date = localdatetime(2012, 3, 5)
# And another one that is cancelled
order = self.create_transfer_order(source_branch=current_branch,
dest_branch=other_branch)
self.create_transfer_order_item(order=order)
order.identifier = 20491
order.open_date = localdatetime(2012, 4, 5)
order.send()
order.cancel(responsible, 'Cancelled due something',
cancel_date=localdatetime(2012, 4, 6))
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
other_branch = Branch.get_active_remote_branches(self.store)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch, dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send()
def _create_domain(self):
self.clean_domain([TransferOrderItem, TransferOrder])
other_branch = Branch.get_active_remote_branches(self.store)[0]
current_branch = api.get_current_branch(self.store)
# One transfer that we did not receive yet
order = self.create_transfer_order(source_branch=other_branch,
dest_branch=current_branch)
self.create_transfer_order_item(order=order)
order.identifier = 75168
order.open_date = localdatetime(2012, 1, 1)
order.send()
def test_cancel_order_on_dest_branch(self):
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
# Destination branch should not cancel the transfer
self.assertFalse(dialog.cancel_button.get_visible())
def _setup_widgets(self):
branches = Branch.get_active_remote_branches(self.store)
self.destination_branch.prefill(api.for_person_combo(branches))
self.source_branch.set_text(self.branch.get_description())
employees = self.store.find(Employee)
self.source_responsible.prefill(api.for_person_combo(employees))
self.invoice_number.set_property('mandatory', self._nfe_is_active)
# Set an initial invoice number to TransferOrder and Invoice
if not self.model.invoice_number:
new_invoice_number = Invoice.get_next_invoice_number(self.store)
self.model.invoice_number = new_invoice_number
def test_cancel_order_on_dest_branch(self):
source_branch = Branch.get_active_remote_branches(self.store)[0]
dest_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
# Destination branch should not cancel the transfer
self.assertFalse(dialog.cancel_button.get_visible())
def _setup_widgets(self):
branches = Branch.get_active_remote_branches(self.store)
self.destination_branch.prefill(api.for_person_combo(branches))
self.source_branch.set_text(self.branch.get_description())
employees = self.store.find(Employee)
self.source_responsible.prefill(api.for_person_combo(employees))
self.invoice_number.set_property('mandatory', self._nfe_is_active)
# Set an initial invoice number to TransferOrder and Invoice
if not self.model.invoice_number:
new_invoice_number = Invoice.get_next_invoice_number(self.store)
self.model.invoice_number = new_invoice_number
def create_branch_filter(self, label=None):
from stoqlib.domain.person import Branch
branches = Branch.get_active_branches(self.store)
items = [(b.get_description(), b.id) for b in branches]
items.insert(0, (_("Any"), None))
if not label:
label = _("Branch:")
branch_filter = ComboSearchFilter(label, items)
current = api.get_current_branch(self.store)
if current:
branch_filter.select(current.id)
return branch_filter
def create_main_branch(store, name):
"""Creates a new branch and sets it as the main branch for the system
:param store: a store
:param name: name of the new branch
"""
person = Person(name=name, store=store)
Company(person=person, store=store)
branch = Branch(person=person, store=store)
sysparam.set_object(store, 'MAIN_COMPANY', branch)
provide_utility(ICurrentBranch, branch)
admin = get_admin_user(store)
admin.add_access_to(branch)
return branch
def create_branch_filter(self, label=None):
from stoqlib.domain.person import Branch
branches = Branch.get_active_branches(self.store)
items = [(b.person.name, b.id) for b in branches]
# if not items:
# raise ValueError('You should have at least one branch at '
# 'this point')
items.insert(0, (_("Any"), None))
if not label:
label = _('Branch:')
branch_filter = ComboSearchFilter(label, items)
current = api.get_current_branch(self.store)
if current:
branch_filter.select(current.id)
return branch_filter
def create_branch_filter(self, label=None):
from stoqlib.domain.person import Branch
branches = Branch.get_active_branches(self.store)
items = [(b.person.name, b.id) for b in branches]
# if not items:
# raise ValueError('You should have at least one branch at '
# 'this point')
items.insert(0, (_("Any"), None))
if not label:
label = _('Branch:')
branch_filter = ComboSearchFilter(label, items)
current = api.get_current_branch(self.store)
if current:
branch_filter.select(current.id)
return branch_filter
def create_branch_filter(self, label=None):
from stoqlib.domain.person import Branch
current = api.get_current_branch(self.store)
if api.sysparam.get_bool('SYNCHRONIZED_MODE'):
items = [(current.get_description(), current.id)]
else:
branches = Branch.get_active_branches(self.store)
items = [(b.get_description(), b.id) for b in branches]
items.insert(0, (_("Any"), None))
if not label:
label = _('Branch:')
branch_filter = ComboSearchFilter(label, items)
if current:
branch_filter.select(current.id)
return branch_filter
def _create_examples(self):
person = Person(name=u'Jonas', store=self.store)
Individual(person=person, store=self.store)
role = EmployeeRole(store=self.store, name=u'desenvolvedor')
Employee(person=person, store=self.store,
role=role)
self.salesperson = SalesPerson(person=person,
store=self.store)
Company(person=person, store=self.store)
client = Client(person=person, store=self.store)
self.branch = Branch(person=person, store=self.store)
group = self.create_payment_group()
self.sale = Sale(coupon_id=123, client=client,
cfop_id=self.sparam.get_object_id('DEFAULT_SALES_CFOP'),
group=group, branch=self.branch,
salesperson=self.salesperson,
store=self.store)
self.storable = self.create_storable()
def test_cancel_order(self, yesno):
dest_branch = Branch.get_active_remote_branches(self.store)[0]
source_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
yesno.retval = True
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
yesno.assert_called_once_with(u'Cancel the order?', gtk.RESPONSE_YES,
u'Cancel transfer', u"Don't cancel")
self.assertEquals(order.status, TransferOrder.STATUS_CANCELLED)
self.assertEquals(order.receival_date, None)
def test_cancel_order(self, yesno):
dest_branch = Branch.get_active_remote_branches(self.store)[0]
source_branch = api.get_current_branch(self.store)
order = self.create_transfer_order(source_branch=source_branch,
dest_branch=dest_branch)
self.create_transfer_order_item(order=order)
order.identifier = 28474
order.open_date = localdatetime(2012, 2, 2)
order.send()
dialog = TransferOrderDetailsDialog(self.store, order)
self.assertSensitive(dialog, ['cancel_button'])
yesno.retval = True
with mock.patch.object(self.store, 'commit'):
self.click(dialog.cancel_button)
yesno.assert_called_once_with(u'Cancel the order?',
gtk.RESPONSE_YES, u'Cancel transfer',
u"Don't cancel")
self.assertEquals(order.status, TransferOrder.STATUS_CANCELLED)
self.assertEquals(order.receival_date, None)
def get_branches_for_filter(self, store, use_id=False):
"""Returns a list of branches to be used in a combo.
:param use_id: If True, we will return the options using the object id
instead of the real object.
"""
if not api.can_see_all_branches():
current = self.get_current_branch(store)
if use_id:
value = current.id
else:
value = current
items = [(current.get_description(), value)]
else:
branches = Branch.get_active_branches(store)
if use_id:
items = [(b.get_description(), b.id) for b in branches]
else:
items = [(b.get_description(), b) for b in branches]
items.insert(0, (_("Any"), None))
return items
def get_branches_for_filter(self, store, use_id=False):
"""Returns a list of branches to be used in a combo.
:param use_id: If True, we will return the options using the object id
instead of the real object.
"""
if not api.can_see_all_branches():
current = self.get_current_branch(store)
if use_id:
value = current.id
else:
value = current
items = [(current.get_description(), value)]
else:
branches = Branch.get_active_branches(store)
if use_id:
items = [(b.get_description(), b.id) for b in branches]
else:
items = [(b.get_description(), b) for b in branches]
items.insert(0, (_("Any"), None))
return items
def _setup_branch_combo(self):
current_branch = api.get_current_branch(self.store)
branches = [current_branch]
user = api.get_current_user(self.store)
if user.profile.check_app_permission(u'admin'):
branches.extend(
list(
Branch.get_active_remote_branches(self.store,
current_branch)))
options = [(branch.get_description(), branch) for branch in branches]
self.branch_combo.prefill(options)
self.branch_combo.set_sensitive(False)
has_generic_active = self.model.product.is_supplied_by(
self.model.supplier, exclude=self.model, branch=None)
if self.model.branch is not None or has_generic_active:
self.branch_checkbutton.set_active(True)
self.branch_combo.set_sensitive(True)
if has_generic_active:
# There is already a generical supplier info, so this must have a
# specific branch
self.branch_checkbutton.set_sensitive(False)
def _get_branch_values(self):
items = [(b.person.name, b.id) for b
in Branch.get_active_branches(self.store)]
items.insert(0, (_('Any'), None))
return items
def _fill_branch_combo(self):
branches = Branch.get_active_branches(self.store)
self.branch.prefill(api.for_person_combo(branches))
def _fill_branch_combo(self):
branches = Branch.get_active_branches(self.store)
self.branch.prefill(api.for_person_combo(branches))
self.branch.set_sensitive(api.can_see_all_branches())
def _get_branch_values(self):
items = [(b.person.name, b.id)
for b in Branch.get_active_branches(self.store)]
items.insert(0, (_('Any'), None))
return items
def _fill_branch_combo(self):
branches = Branch.get_active_branches(self.store)
self.branch.prefill(api.for_person_combo(branches))
sync_mode = api.sysparam.get_bool('SYNCHRONIZED_MODE')
self.branch.set_sensitive(not sync_mode)
def _prefill_branches(self):
branches = Branch.get_active_remote_branches(self.store)
self.destination_branch.prefill(api.for_person_combo(branches))
def test_get_active_remote_branches(self):
current_branch = get_current_branch(self.store)
self.assertIn(current_branch, Branch.get_active_branches(self.store))
self.assertNotIn(current_branch,
Branch.get_active_remote_branches(self.store))
def get_targets(self):
branches = Branch.get_active_branches(self._store)
return api.for_person_combo(branches)
