def send(self): """Send the package to the :attr:`.destination_branch` This will mark the package as sent. Note that it's only possible to call this on the same branch as :attr:`.source_branch`. When calling this, the work orders' :attr:`WorkOrder.current_branch` will be ``None``, since they are on a package and not on any branch. """ assert self.can_send() if self.source_branch != get_current_branch(self.store): raise ValueError( _("This package's source branch is %s and you are in %s. " "It's not possible to send a package outside the " "source branch") % ( self.source_branch, get_current_branch(self.store))) workorders = [item.order for item in self.package_items] if not len(workorders): raise ValueError(_("There're no orders to send")) for order in workorders: assert order.current_branch == self.source_branch # The order is going to leave the current_branch order.current_branch = None self.send_date = localnow() self.status = self.STATUS_SENT
def receive(self): """Receive the package on the :attr:`.destination_branch` This will mark the package as received in the branch to receive it there. Note that it's only possible to call this on the same branch as :attr:`.destination_branch`. When calling this, the work orders' :attr:`WorkOrder.current_branch` will be set to :attr:`.destination_branch`, since receiving means they got to their destination. """ assert self.can_receive() if self.destination_branch != get_current_branch(self.store): raise ValueError( _("This package's destination branch is %s and you are in %s. " "It's not possible to receive a package outside the " "destination branch") % ( self.destination_branch, get_current_branch(self.store))) for order in [item.order for item in self.package_items]: assert order.current_branch is None # The order is in destination branch now order.current_branch = self.destination_branch self.receive_date = localnow() self.status = self.STATUS_RECEIVED
def _create_sale(self, invoice_number, due_date=None): sale = self.create_sale() sale.invoice_number = invoice_number sale.branch = get_current_branch(self.store) tax_types = cycle(['aliq', 'nt', 'outr']) # [0] - Description # [1] - Code # [2] - Price # [3] - Quantity # [4] - Base price for tax_type, data in zip(tax_types, [ (u"Laranja", u"1", Decimal(1), Decimal(10), Decimal('1.5')), (u"Limão", u"2", Decimal('0.5'), Decimal(15), Decimal('0.3')), (u"Abacaxi", u"3", Decimal(3), Decimal(1), Decimal('3.3')), (u"Cenoura", u"4", Decimal('1.5'), Decimal(6), Decimal('1.9')), (u"Pêssego", u"5", Decimal('3.5'), Decimal(3), Decimal('3.0'))]): sellable = self._create_sellable(data[0], data[1], data[2]) storable = Storable(product=sellable.product, store=self.store) storable.increase_stock(data[3], get_current_branch(self.store), StockTransactionHistory.TYPE_INITIAL, sale.id) sale_item = sale.add_sellable(sellable, data[3]) if tax_type == 'aliq': self._add_aliq(sale_item) elif tax_type == 'nt': self._add_nt(sale_item) elif tax_type == 'outr': self._add_outr(sale_item) # Set the base price to test the discount in NF-e. sale_item.base_price = data[4] icms_info = sale_item.icms_info icms_info.csosn = 201 icms_info.p_icms_st = 1 self._update_taxes(sale_item) sale.client = self.create_client() self._create_address(sale.client.person, street=u"Rua dos Tomates", streetnumber=2666, postal_code=u'87654-321') sale.order() method = PaymentMethod.get_by_name(self.store, u'money') method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, sale.get_sale_subtotal(), due_date=due_date) sale.confirm() return sale
def create_for_receiving_order(cls, receiving_order): store = receiving_order.store current_user = get_current_user(store) employee = current_user.person.employee cfop_id = sysparam.get_object_id('DEFAULT_STOCK_DECREASE_CFOP') return_stock_decrease = cls( store=store, receiving_order=receiving_order, branch=get_current_branch(store), responsible=current_user, removed_by=employee, cfop_id=cfop_id) for receiving_item in receiving_order.get_items(with_children=False): if receiving_item.is_totally_returned(): # Exclude items already totally returned continue if receiving_item.children_items.count(): for child in receiving_item.children_items: StockDecreaseItem.create_for_receiving_item( return_stock_decrease, child) else: StockDecreaseItem.create_for_receiving_item(return_stock_decrease, receiving_item) return return_stock_decrease
def print_cheques_for_payment_group(store, group): """ Given a instance that implements the PaymentGroup interface, iterate over all its items printing a cheque for them. """ payments = group.get_valid_payments() printer = get_current_cheque_printer_settings(store) if not printer: return printer_banks = printer.get_banks() current_branch = get_current_branch(store) main_address = current_branch.person.get_main_address() if not main_address: raise ValueError("The cheque can not be printed since there is no " "main address defined for the current branch.") max_len = printer.get_capability("cheque_city").max_len city = main_address.city_location.city[:max_len] for idx, payment in enumerate(payments): if payment.method.method_name == 'check': continue check_data = payment.method.operation.get_check_data_by_payment( payment) bank_id = check_data.bank_data.bank_id try: bank = printer_banks[bank_id] except KeyError: continue thirdparty = group.recipient info(_(u"Insert Cheque %d") % (idx + 1)) max_len = printer.get_capability("cheque_thirdparty").max_len thirdparty = thirdparty and thirdparty.name[:max_len] or "" printer.print_cheque(bank, payment.value, thirdparty, city)
def create_payment_renegotiation(self, group=None): from stoqlib.domain.payment.renegotiation import PaymentRenegotiation return PaymentRenegotiation(responsible=get_current_user(self.store), branch=get_current_branch(self.store), group=group or self.create_payment_group(), client=self.create_client(), store=self.store)
def test_can_remove(self): branch = get_current_branch(self.store) sellable = self.create_sellable() storable = Storable(product=sellable.product, store=self.store) self.failUnless(sellable.can_remove()) storable.increase_stock(1, branch, 0, None) sale = self.create_sale() sale.status = Sale.STATUS_QUOTE sale.branch = branch sale.add_sellable(sellable) self.failIf(sellable.can_remove()) # Can't remove the sellable if it's in a purchase. from stoqlib.domain.purchase import PurchaseItem sellable = self.create_sellable() Storable(product=sellable.product, store=self.store) self.assertTrue(sellable.can_remove()) PurchaseItem(store=self.store, quantity=8, quantity_received=0, cost=125, base_cost=125, sellable=sellable, order=self.create_purchase_order()) self.assertFalse(sellable.can_remove()) # The delivery service cannot be removed. sellable = sysparam(self.store).DELIVERY_SERVICE.sellable self.failIf(sellable.can_remove())
def testTotalReturn(self): sale = self.create_sale(branch=get_current_branch(self.store)) sellable = self.add_product(sale) storable = sellable.product_storable balance_before_confirm = storable.get_balance_for_branch(sale.branch) sale.order() self.add_payments(sale) sale.confirm() self.assertEqual(storable.get_balance_for_branch(sale.branch), balance_before_confirm - 1) balance_before_return = storable.get_balance_for_branch(sale.branch) self.failUnless(sale.can_return()) returned_sale = sale.create_sale_return_adapter() returned_sale.return_() self.failIf(sale.can_return()) self.assertEqual(sale.status, Sale.STATUS_RETURNED) self.assertEqual(sale.return_date.date(), datetime.date.today()) self.assertEqual(storable.get_balance_for_branch(sale.branch), balance_before_return + 1) # Since this is a total return, balance should be # as it wasn't ever confirmed self.assertEqual(storable.get_balance_for_branch(sale.branch), balance_before_confirm)
def test_select_by_branch_data(self): branch = get_current_branch(self.store) sale = self.create_sale() sale.branch = branch sellable = self.add_product(sale) sale.order() self.add_payments(sale, method_type=u"money") sale.confirm() results = SoldItemView.find_by_branch_date(self.store, None, None) self.assertFalse(results.is_empty()) results = SoldItemView.find_by_branch_date(self.store, branch, None) self.assertFalse(results.is_empty()) results = SoldItemView.find_by_branch_date(self.store, branch, None).find(SoldItemView.id == sellable.id) # FIXME: Storm does not support count() with group_by # self.assertEquals(results.count(), 1) self.assertEquals(len(list(results)), 1) today = localtoday() results = SoldItemView.find_by_branch_date(self.store, None, today).find(SoldItemView.id == sellable.id) self.assertEquals(len(list(results)), 1) yesterday = today - datetime.timedelta(days=1) results = SoldItemView.find_by_branch_date(self.store, None, (yesterday, today)) results = results.find(SoldItemView.id == sellable.id) self.assertEquals(len(list(results)), 1) yesterday = today - datetime.timedelta(days=1) results = SoldItemView.find_by_branch_date(self.store, None, (yesterday, today)) self.assertFalse(results.is_empty())
def testIncreaseDecreaseStock(self): branch = get_current_branch(self.store) product = self.create_product() storable = Storable(product=product, store=self.store) stock_item = storable.get_stock_item(branch) self.failIf(stock_item is not None) storable.increase_stock(1, branch, 0, 0) stock_item = storable.get_stock_item(branch) self.assertEquals(stock_item.stock_cost, 0) storable.increase_stock(1, branch, 0, 0, unit_cost=10) stock_item = storable.get_stock_item(branch) self.assertEquals(stock_item.stock_cost, 5) stock_item = storable.decrease_stock(1, branch, 0, 0) self.assertEquals(stock_item.stock_cost, 5) storable.increase_stock(1, branch, 0, 0) stock_item = storable.get_stock_item(branch) self.assertEquals(stock_item.stock_cost, 5) storable.increase_stock(2, branch, 0, 0, unit_cost=15) stock_item = storable.get_stock_item(branch) self.assertEquals(stock_item.stock_cost, 10)
def test_calculate_item_without_icms(self): # SP (São Paulo) as default state. branch = get_current_branch(self.store) address = branch.person.get_main_address() state = address.city_location.state assert state == "SP" # Product with NCM, but without ICMS sale = self.create_sale() item = self.create_sale_item(sale) product = item.sellable.product product.ncm = u'01012100' items = sale.get_items() generator = IBPTGenerator(items) # When there is no icms information, the value defaults to the nacional # tax. tax_values = generator._load_tax_values(item) federal = generator._calculate_federal_tax(item, tax_values) self.assertEquals(federal, Decimal("4.20")) state = generator._calculate_state_tax(item, tax_values) self.assertEquals(state, Decimal("18")) msg = generate_ibpt_message(items) expected_msg = ("Trib aprox R$: 4.20 Federal e 18.00 Estadual\n" "Fonte: IBPT 5oi7eW ") self.assertEquals(msg, expected_msg)
def test_branch_combo_sensitivity(self): branch = get_current_branch(self.store) # Create product with supplier info for all branches supplier = self.create_supplier() product = self.create_product() supplier_info = self.create_product_supplier_info( product=product, supplier=supplier, branch=branch) # We are editing another product supplier info, and since there is NOT # another one for all branches, it's optional to set a branch new_supplier_info = self.create_product_supplier_info( product=product, supplier=supplier) editor = ProductSupplierEditor(self.store, new_supplier_info) self.assertNotSensitive(editor, ['branch_combo']) self.assertSensitive(editor, ['branch_checkbutton']) self.assertFalse(editor.branch_checkbutton.get_active()) # Remove branch from original supplier info. Now it's generic/default supplier_info.branch = None # We are editing another product supplier info, and since there is # already another one for all branches, it's mandatory to set a specific # branch now editor = ProductSupplierEditor(self.store, new_supplier_info) self.assertSensitive(editor, ['branch_combo']) self.assertNotSensitive(editor, ['branch_checkbutton']) self.assertTrue(editor.branch_checkbutton.get_active())
def test_inventory(self): branch = get_current_branch(self.store) product = self.create_product(branch=branch, stock=10) editor = ProductStockQuantityEditor(self.store, product, branch) self.check_editor(editor, 'editor-product-stock-quantity-inventory-show') # Update editor editor.quantity.update(20) editor.reason.update('test case') inventories_before = self.store.find(Inventory).count() # Confirm self.click(editor.main_dialog.ok_button) # Check data inventories_after = self.store.find(Inventory).count() self.assertEqual(inventories_after, inventories_before + 1) stock_item = product.storable.get_stock_item(branch, batch=None) self.assertEqual(stock_item.quantity, 20) # Check Inventory inventory = self.store.find(Inventory).order_by(Inventory.te_id).last() # The inventory should have only one item item = inventory.get_items().one() self.assertEqual(item.recorded_quantity, 10) self.assertEqual(item.counted_quantity, 20) self.assertEqual(item.actual_quantity, 20) self.assertEqual(item.is_adjusted, True) self.assertEqual(inventory.status, Inventory.STATUS_CLOSED)
def _create_domain(self): self.clean_domain([SaleItem]) branch = get_current_branch(self.store) self.today = localtoday() product = self.create_product() storable = Storable(store=self.store, product=product) ProductStockItem(storable=storable, branch=branch, quantity=5, store=self.store) product.sellable.code = u'1' product.sellable.description = u'Luvas' product2 = self.create_product() storable2 = Storable(store=self.store, product=product2) ProductStockItem(storable=storable2, branch=branch, quantity=5, store=self.store) product2.sellable.code = u'2' product2.sellable.description = u'Botas' # Sale sale = self.create_sale(branch=branch) sale.identifier = 123 sale.open_date = self.today sale.add_sellable(product.sellable, 3) sale.add_sellable(product2.sellable, 5) sale.order() self.add_payments(sale, date=self.today) sale.confirm()
def create_sale(self, id_=None, branch=None, client=None): from stoqlib.domain.sale import Sale from stoqlib.domain.till import Till till = Till.get_current(self.store) if till is None: till = self.create_till() till.open_till() salesperson = self.create_sales_person() group = self.create_payment_group() if client: group.payer = client.person sale = Sale( coupon_id=0, open_date=TransactionTimestamp(), salesperson=salesperson, branch=branch or get_current_branch(self.store), cfop=sysparam(self.store).DEFAULT_SALES_CFOP, group=group, client=client, store=self.store, ) if id_: sale.id = id_ sale.identifier = id_ return sale
def test_return_with_credit(self): branch = get_current_branch(self.store) sale_item = self.create_sale_item() sale = sale_item.sale sellable = sale_item.sellable self.create_storable(product=sellable.product, branch=branch, stock=10) payments = self.add_payments(sale, method_type=u'bill', installments=2) payments[0].status = Payment.STATUS_PENDING self.add_payments(sale, method_type=u'money') sale.order() sale.confirm() rsale = ReturnedSale(branch=branch, sale=sale, store=self.store) ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=1) # Create an unused to test the removal of unused items, # should probably be removed. ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=0) rsale.return_(u'credit')
def _return_items(self): # We must have at least one item to return assert self.returned_items.count() branch = get_current_branch(self.store) for item in self.returned_items: item.return_(branch)
def create_loan(self, branch=None, client=None): from stoqlib.domain.loan import Loan user = get_current_user(self.store) return Loan(responsible=user, client=client, branch=branch or get_current_branch(self.store), store=self.store)
def _add_header(self): branch = get_current_branch(self.store) manager = branch.manager.person company = branch.person.company address = branch.person.get_main_address() state_registry = company.get_state_registry_number() state = address.get_state() self.sintegra.add_header(company.get_cnpj_number(), str(state_registry) or 'ISENTO', company.fancy_name, address.get_city(), state, branch.person.get_fax_number_number(), self.start, self.end) self.sintegra.add_complement_header( # If we don't have a street number, use zero for sintegra address.street, address.streetnumber or 0, address.complement, address.district, address.get_postal_code_number(), manager.name, branch.person.get_phone_number_number()) self._add_registers(state)
def testSalesPersonReport(self): sysparam(self.store).SALE_PAY_COMMISSION_WHEN_CONFIRMED = 1 salesperson = self.create_sales_person() product = self.create_product(price=100) sellable = product.sellable sale = self.create_sale() sale.salesperson = salesperson sale.add_sellable(sellable, quantity=1) self.create_storable(product, get_current_branch(self.store), stock=100) CommissionSource(sellable=sellable, direct_value=Decimal(10), installments_value=1, store=self.store) sale.order() method = PaymentMethod.get_by_name(self.store, u'money') till = Till.get_last_opened(self.store) method.create_inpayment(sale.group, sale.branch, sale.get_sale_subtotal(), till=till) sale.confirm() sale.set_paid() salesperson_name = salesperson.person.name commissions = list(self.store.find(CommissionView)) commissions[0].identifier = 1 commissions[1].identifier = 139 self._diff_expected(SalesPersonReport, 'sales-person-report', commissions, salesperson_name)
def test_order_receive_sell(self): product = self.create_product() storable = Storable(product=product, store=self.store) self.failIf(self.store.find(ProductStockItem, storable=storable).one()) purchase_order = self.create_purchase_order() purchase_item = purchase_order.add_item(product.sellable, 1) purchase_order.status = purchase_order.ORDER_PENDING method = PaymentMethod.get_by_name(self.store, u'money') method.create_payment(Payment.TYPE_OUT, purchase_order.group, purchase_order.branch, purchase_order.get_purchase_total()) purchase_order.confirm() receiving_order = self.create_receiving_order(purchase_order) receiving_order.branch = get_current_branch(self.store) self.create_receiving_order_item( receiving_order=receiving_order, sellable=product.sellable, purchase_item=purchase_item, quantity=1) self.failIf(self.store.find(ProductStockItem, storable=storable).one()) receiving_order.confirm() product_stock_item = self.store.find(ProductStockItem, storable=storable).one() self.failUnless(product_stock_item) self.assertEquals(product_stock_item.quantity, 1) sale = self.create_sale() sale.add_sellable(product.sellable) sale.order() method = PaymentMethod.get_by_name(self.store, u'check') method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, Decimal(100)) sale.confirm() self.assertEquals(product_stock_item.quantity, 0)
def _create_sale(self): today = localdate(2010, 12, 1) client = self.create_client() # new sale sale = self.create_sale(branch=get_current_branch(self.store)) sale.identifier = 123 sale.client = client sale.open_date = today sale.discount_value = Decimal('15') sale.surcharge_value = Decimal('8') # Product item_ = self.create_sale_item(sale, product=True) self.create_storable(item_.sellable.product, sale.branch, 1) # Service item = self.create_sale_item(sale, product=False) item.estimated_fix_date = today # Payments payment = self.add_payments(sale, date=today)[0] payment.identifier = 999 payment.group.payer = client.person sale.order() sale.confirm() sale.group.pay() payment.paid_date = today return sale
def test_receive(self, localnow): localnow.return_value = localdate(2013, 1, 1) package = self.create_workorder_package( source_branch=self.create_branch()) package.destination_branch = get_current_branch(self.store) workorder1 = self.create_workorder(current_branch=package.source_branch) workorder2 = self.create_workorder(current_branch=package.source_branch) # Mimic WorkOrderPackage.send for order in [workorder1, workorder2]: package.add_order(order) order.current_branch = None package.status = WorkOrderPackage.STATUS_SENT with mock.patch('stoqlib.domain.workorder.get_current_branch') as gcb: gcb.return_value = self.create_branch() with self.assertRaisesRegexp( ValueError, ("This package's destination branch is <Branch u'[0-9a-f-]+'> " "and you are in <Branch u'[0-9a-f-]+'>. It's not possible " "to receive a package outside the destination branch")): package.receive() self.assertEqual(package.receive_date, None) package.receive() self.assertEqual(package.status, WorkOrderPackage.STATUS_RECEIVED) self.assertEqual(package.receive_date, localdate(2013, 1, 1)) for order in [workorder1, workorder2]: self.assertEqual(order.current_branch, package.destination_branch)
def test_sales_person_report(self): sysparam.set_bool(self.store, "SALE_PAY_COMMISSION_WHEN_CONFIRMED", True) salesperson = self.create_sales_person() product = self.create_product(price=100) sellable = product.sellable sale = self.create_sale() sale.salesperson = salesperson sale.add_sellable(sellable, quantity=1) self.create_storable(product, get_current_branch(self.store), stock=100) CommissionSource(sellable=sellable, direct_value=Decimal(10), installments_value=1, store=self.store) sale.order() method = PaymentMethod.get_by_name(self.store, u"money") method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, sale.get_sale_subtotal()) sale.confirm() sale.group.pay() salesperson = salesperson commissions = list(self.store.find(CommissionView)) commissions[0].identifier = 1 commissions[1].identifier = 139 self._diff_expected(SalesPersonReport, "sales-person-report", commissions, salesperson) # Also test when there is no salesperson selected self._diff_expected(SalesPersonReport, "sales-person-report-without-salesperson", commissions, None)
def create_workorder(self, equipment=u''): from stoqlib.domain.workorder import WorkOrder return WorkOrder( store=self.store, equipment=equipment, branch=get_current_branch(self.store), )
def create_station(self, branch=None): if branch is None: branch = get_current_branch(self.store) from stoqlib.domain.station import BranchStation return BranchStation(name=u"station", branch=branch, store=self.store)
def _update_wizard_model(self): wizard_model = self.wizard.model if wizard_model: # We are replacing the model. Remove old one for item in wizard_model.returned_items: item.delete(item.id, store=item.store) wizard_model.delete(wizard_model.id, store=wizard_model.store) sale_view = self.slave.results.get_selected() # FIXME: Selecting a sale and then clicking on unknown_sale_check # will not really deselect it, not until the results are sensitive # again. This should be as simple as 'if sale_view'. if sale_view and not self.unknown_sale_check.get_active(): sale = self.store.fetch(sale_view.sale) model = sale.create_sale_return_adapter() for item in model.returned_items: _adjust_returned_sale_item(item) else: assert self._allow_unknown_sales() model = ReturnedSale( store=self.store, responsible=get_current_user(self.store), branch=get_current_branch(self.store), ) self.wizard.model = model
def test_get_client_credit_transactions(self): method = self.store.find(PaymentMethod, method_name=u'credit').one() client = self.create_client() sale = self.create_sale(client=client) self.add_product(sale) self.add_payments(sale) sale.order() sale.confirm() returned_sale = ReturnedSale(sale=sale, branch=get_current_branch(self.store), store=self.store) ReturnedSaleItem(sale_item=list(sale.get_items())[0], quantity=1, returned_sale=returned_sale, store=self.store) sale.return_(returned_sale) payment = self.create_payment(payment_type=Payment.TYPE_OUT, value=100, method=method, group=sale.group) payment.set_pending() payment.pay() payment_domain_list = list(client.get_credit_transactions()) self.assertTrue(len(payment_domain_list) == 1) payment_domain = payment_domain_list[0] self.assertEquals(payment.identifier, payment_domain.identifier) self.assertEquals(payment.paid_date, payment_domain.paid_date) self.assertEquals(payment.description, payment_domain.description) self.assertEquals(payment.paid_value, payment_domain.paid_value)
def test_trade_as_discount(self): sale = self.create_sale(branch=get_current_branch(self.store)) self.assertEqual(sale.discount_value, currency(0)) sellable = self.add_product(sale, price=50) storable = sellable.product_storable balance_before_confirm = storable.get_balance_for_branch(sale.branch) sale.order() self.add_payments(sale) sale.confirm() self.assertEqual(storable.get_balance_for_branch(sale.branch), balance_before_confirm - 1) balance_before_trade = storable.get_balance_for_branch(sale.branch) returned_sale = sale.create_sale_return_adapter() new_sale = self.create_sale() returned_sale.new_sale = new_sale with self.sysparam(USE_TRADE_AS_DISCOUNT=True): returned_sale.trade() self.assertEqual(new_sale.discount_value, currency(50)) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(sale.branch), balance_before_trade + 1)
def test_create(self, yesno, print_report): sellable = self.create_sellable(description=u"Product to transfer") self.create_storable(sellable.product, get_current_branch(self.store), stock=10) wizard = StockTransferWizard(self.store) self.assertNotSensitive(wizard, ['next_button']) self.check_wizard(wizard, 'wizard-stock-transfer-create') step = wizard.get_current_step() step.destination_branch.set_active(0) self.assertSensitive(wizard, ['next_button']) self.click(wizard.next_button) step = wizard.get_current_step() # adds sellable to step step.sellable_selected(sellable) step._add_sellable() self.check_wizard(wizard, 'wizard-stock-transfer-products') module = 'stoqlib.gui.events.StockTransferWizardFinishEvent.emit' with mock.patch(module) as emit: with mock.patch.object(self.store, 'commit'): self.click(wizard.next_button) self.assertEquals(emit.call_count, 1) args, kwargs = emit.call_args self.assertTrue(isinstance(args[0], TransferOrder)) yesno.assert_called_once_with( _('Would you like to print a receipt for this transfer?'), gtk.RESPONSE_YES, 'Print receipt', "Don't print") self.assertEquals(print_report.call_count, 1)
def test_sale_return_invoice_step(self): main_branch = get_current_branch(self.store) sale = self.create_sale(branch=main_branch) self.add_product(sale) self.add_product(sale, quantity=2) self.add_payments(sale) sale.order() sale.confirm() returned_sale = sale.create_sale_return_adapter() wizard = SaleReturnWizard(self.store, returned_sale) self.click(wizard.next_button) step = wizard.get_current_step() self.check_wizard(wizard, 'wizard-sale-return-invoice-step') self.assertNotSensitive(wizard, ['next_button']) self.assertInvalid(step, ['reason']) step.reason.update( "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed\n" "do eiusmod tempor incididunt ut labore et dolore magna aliqua.") self.assertValid(step, ['reason']) # XXX: changed because invoice_number is no longer mandatory self.assertSensitive(wizard, ['next_button']) step.invoice_number.update(0) self.assertInvalid(step, ['invoice_number']) step.invoice_number.update(1000000000) self.assertInvalid(step, ['invoice_number']) self.assertNotSensitive(wizard, ['next_button']) # Check if the invoice number already exists in Invoice table invoice = Invoice(invoice_type=Invoice.TYPE_OUT, branch=main_branch) invoice.invoice_number = 123 step.invoice_number.update(123) self.assertInvalid(step, ['invoice_number']) self.assertNotSensitive(wizard, ['next_button']) step.invoice_number.update(1) self.assertValid(step, ['invoice_number']) invoice.branch = self.create_branch() step.invoice_number.update(123) self.assertValid(step, ['invoice_number']) self.assertSensitive(wizard, ['next_button'])
def test_sale_return_report(self): today = datetime.date(2013, 1, 1) client = self.create_client() # new sale sale = self.create_sale(branch=get_current_branch(self.store)) sale.identifier = 123 sale.client = client sale.open_date = today sale.discount_value = Decimal('15') sale.surcharge_value = Decimal('8') # Product item_ = self.create_sale_item(sale, product=True) self.create_storable(item_.sellable.product, sale.branch, 1) # Payments payment = self.add_payments(sale, date=today)[0] payment.identifier = 999 payment.group.payer = client.person sale.order() sale.confirm() sale.group.pay() sale.confirm_date = today payment.paid_date = today date = datetime.date(2013, 2, 2) # return sale returned_sale = sale.create_sale_return_adapter() returned_sale.return_() returned_sale.return_date = date model = self.store.find(SaleView, SaleView.id == returned_sale.sale.id).one() returned_items = list(ReturnedSaleItemsView.find_by_sale(self.store, sale)) self._diff_expected(SaleReturnReport, 'sale-return-report', self.store, client, model, returned_items)
def _create_domain(self): self.clean_domain([ StockTransactionHistory, ProductSupplierInfo, ProductStockItem, Storable, Product ]) branch = get_current_branch(self.store) user = get_current_user(self.store) self.today = localtoday() product = self.create_product() Storable(store=self.store, product=product, minimum_quantity=3, maximum_quantity=20) product.sellable.code = u'1' product.sellable.description = u'Luvas' product2 = self.create_product() Storable(store=self.store, product=product2, minimum_quantity=4, maximum_quantity=20) product2.sellable.code = u'2' product2.sellable.description = u'Botas' # Purchase order = self.create_purchase_order(branch=branch) order.identifier = 111 order.open_date = self.today order.status = PurchaseOrder.ORDER_PENDING p_item = order.add_item(product.sellable, 10) p2_item = order.add_item(product2.sellable, 15) order.confirm() # Receiving receiving = self.create_receiving_order(order, branch, user) receiving.identifier = 222 receiving.receival_date = self.today self.create_receiving_order_item(receiving, product.sellable, p_item, 8) self.create_receiving_order_item(receiving, product2.sellable, p2_item, 12) receiving.confirm()
def load_taxes_csv(): """ Load the fields of IBPT table. - Fields: - ncm: Nomenclatura Comum do Sul. - ex: Exceção fiscal da NCM. - tipo: Código que pertence a uma NCM. - descricao: Nome do produto. - nacionalfederal: Carga tributária para os produtos nacionais. - importadosfederal: Carga tributária para os produtos importados. - estadual: Carga tributária estadual - municipal: Carga tributária municipal - vigenciainicio: Data de início da vigência desta alíquota. - vigenciafim: Data de fim da vigência desta alíquota. - chave: Chave que associa a Tabela IBPT baixada com a empresa. - versao: Versão das alíquotas usadas para cálculo. - Fonte: Fonte """ # Avoid load taxes more than once. if taxes_data: return store = new_store() branch = get_current_branch(store) address = branch.person.get_main_address() state = address.city_location.state # Change the version according to the updates of IBPT tables. version = '16.1.A' filename = environ.get_resource_filename( 'stoq', 'csv', 'ibpt_tables', 'TabelaIBPTax%s%s.csv' % (state, version)) csv_file = (csv.reader(open(filename, "r"), delimiter=';')) for (ncm, ex, tipo, descricao, nacionalfederal, importadosfederal, estadual, municipal, vigenciainicio, vigenciafim, chave, versao, fonte) in csv_file: # Ignore service codes (NBS - Nomenclatura Brasileira de Serviços) if tipo == '1': continue tax_dict = taxes_data.setdefault(ncm, {}) tax_dict[ex] = TaxInfo(nacionalfederal, importadosfederal, estadual, fonte, chave)
def _create_domain(self): self.clean_domain([ProductHistory]) branch = get_current_branch(self.store) user = get_current_user(self.store) self.today = localtoday() product = self.create_product() Storable(store=self.store, product=product) product.sellable.code = u'1' product.sellable.description = u'Luvas' product2 = self.create_product() Storable(store=self.store, product=product2) product2.sellable.code = u'2' product2.sellable.description = u'Botas' # Purchase order = self.create_purchase_order(branch=branch) order.identifier = 111 order.open_date = self.today order.status = PurchaseOrder.ORDER_PENDING p_item = order.add_item(product.sellable, 10) p2_item = order.add_item(product2.sellable, 15) order.confirm(self.current_user) # Receiving receiving = self.create_receiving_order(order, branch, user) receiving.identifier = 222 receiving.receival_date = self.today self.create_receiving_order_item(receiving, product.sellable, p_item, 8) self.create_receiving_order_item(receiving, product2.sellable, p2_item, 12) receiving.confirm(self.current_user) # Sale sale = self.create_sale(branch=branch) sale.identifier = 123 sale.open_date = self.today sale.add_sellable(product.sellable, 3) sale.add_sellable(product2.sellable, 5) sale.order(self.current_user) self.add_payments(sale, date=self.today) sale.confirm(self.current_user)
def test_sync_stock(self): loan = self.create_loan() product = self.create_product() branch = get_current_branch(self.store) storable = self.create_storable(product, branch, 4) loan.branch = branch initial = storable.get_balance_for_branch(branch) sellable = product.sellable # creates a loan with 4 items of the same product quantity = 4 loan_item = loan.add_sellable(sellable, quantity=quantity, price=10) loan_item.sync_stock() self.assertEqual(loan_item.quantity, quantity) self.assertEqual(loan_item.return_quantity, 0) self.assertEqual(loan_item.sale_quantity, 0) # The quantity loaned items should be removed from stock self.assertEqual( storable.get_balance_for_branch(branch), initial - quantity) # Sell one of the loaned items and return one item (leaving 2 in the # loan) loan_item.return_quantity = 1 loan_item.sale_quantity = 1 loan_item.sync_stock() self.assertEqual(loan_item.quantity, quantity) self.assertEqual(loan_item.return_quantity, 1) self.assertEqual(loan_item.sale_quantity, 1) # The return_quantity should be returned to the stock self.assertEqual( storable.get_balance_for_branch(branch), initial - quantity + loan_item.return_quantity) # Return the 2 remaining products in this loan. loan_item.return_quantity += 2 loan_item.sync_stock() self.assertEqual(loan_item.quantity, quantity) self.assertEqual(loan_item.return_quantity, 3) self.assertEqual(loan_item.sale_quantity, 1) # The return_quantity should be returned to the stock self.assertEqual( storable.get_balance_for_branch(branch), initial - quantity + loan_item.return_quantity)
def test_confirm_order(self, new_store, confirm): new_store.return_value = self.store sale = self.create_sale(branch=get_current_branch(self.store)) self.add_product(sale) sale.status = Sale.STATUS_ORDERED app = self.create_app(TillApp, u'till') app.status_filter.select(Sale.STATUS_ORDERED) results = app.results results.select(results[0]) with mock.patch.object(self.store, 'commit'): with mock.patch.object(self.store, 'close'): self.activate(app.Confirm) confirm.assert_called_once_with( sale, self.store, subtotal=decimal.Decimal("10.00"))
def testAddSoldQuantity(self): sale = self.create_sale() sellable = self.create_sellable() product = sellable.product branch = get_current_branch(self.store) self.create_storable(product, branch, 100) sale_item = sale.add_sellable(sellable, quantity=5) method = PaymentMethod.get_by_name(self.store, u'money') method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, sale.get_sale_subtotal()) self.failIf(self.store.find(ProductHistory, sellable=sellable).one()) sale.order() sale.confirm() prod_hist = self.store.find(ProductHistory, sellable=sellable).one() self.failUnless(prod_hist) self.assertEqual(prod_hist.quantity_sold, 5) self.assertEqual(prod_hist.quantity_sold, sale_item.quantity)
def __init__(self, filename, payments_list, salesperson_name, *args, **kwargs): branch = get_current_branch(get_default_store()).get_description() self.payments_list = payments_list if salesperson_name: singular = _("payment for {salesperson} on branch {branch}").format( salesperson=salesperson_name, branch=branch) plural = _("payments for {salesperson} on branch {branch}").format( salesperson=salesperson_name, branch=branch) else: singular = _("payment on branch %s") % branch plural = _("payments on branch %s") % branch self.main_object_name = (singular, plural) self.landscape = (salesperson_name is None) self._sales_person = salesperson_name TableReport.__init__(self, filename, payments_list, self.title, *args, **kwargs)
def test_cancel_inventory(self, new_store, yesno): new_store.return_value = self.store yesno.return_value = True self.create_inventory(branch=get_current_branch(self.store)) app = self.create_app(InventoryApp, u'inventory') results = app.results results.select(results[0]) with mock.patch.object(self.store, 'commit'): with mock.patch.object(self.store, 'close'): self.activate(app.Cancel) yesno.assert_called_once_with( u'Are you sure you want to cancel ' u'this inventory ?', Gtk.ResponseType.NO, u"Cancel inventory", u"Don't cancel") self.assertEqual(results[0].status, Inventory.STATUS_CANCELLED)
def collect_sale_models(self, sale): models = [sale, sale.group, sale.invoice] models.extend(sale.payments) branch = get_current_branch(self.store) def _cmp(a, b): return cmp(a.sellable.description, b.sellable.description) for item in sorted(sale.get_items(), key=functools.cmp_to_key(_cmp)): models.append(item.sellable) stock_item = item.sellable.product_storable.get_stock_item( branch, batch=item.batch) models.append(stock_item) models.append(item) payments = list(sale.payments) if len(payments): p = payments[0] p.description = p.description.rsplit(u' ', 1)[0] return models
def test_installments_commission_amount_when_sale_return(self): if True: raise SkipTest( u"See stoqlib.domain.returnedsale.ReturnedSale.return_ " u"and bug 5215.") self._payComissionWhenConfirmed() sale = self.create_sale() sellable = self.create_sellable() CommissionSource(sellable=sellable, direct_value=12, installments_value=5, store=self.store) sale.add_sellable(sellable, quantity=3, price=300) product = sellable.product branch = get_current_branch(self.store) self.create_storable(product, branch, 100) sale.order() method = PaymentMethod.get_by_name(self.store, u'check') payment1 = method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, Decimal(300)) payment2 = method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, Decimal(450)) payment3 = method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, Decimal(150)) sale.confirm() # the commissions are created after the payment payment1.pay() payment2.pay() payment3.pay() returned_sale = sale.create_sale_return_adapter() returned_sale.return_() self.assertEqual(sale.status, Sale.STATUS_RETURNED) commissions = self.store.find(Commission, sale=sale) value = sum([c.value for c in commissions]) self.assertEqual(value, Decimal(0)) self.assertEqual(commissions.count(), 4) self.assertFalse(commissions[-1].value >= 0)
def test_same_branch(self): branch = get_current_branch(self.store) product = self.create_product(branch=branch, stock=10) editor = ProductStockQuantityEditor(self.store, product, branch) # Using set_text because update() will not show the validation editor.quantity.set_text('-4') editor.reason.update('test') # Do not let the user decrease stock to a negative number self.assertInvalid(editor, ['quantity']) # Let the user decrease stock editor.quantity.update(9) self.assertValid(editor, ['quantity']) # Let the user increase stock editor.quantity.update(11) self.assertValid(editor, ['quantity']) self.click(editor.main_dialog.ok_button)
def test_run_dialogs(self): inventory = self.create_inventory(branch=get_current_branch(self.store)) app = self.create_app(InventoryApp, u'inventory') results = app.results results.select(results[0]) self._check_run_dialog(app.AdjustAction, ProductsAdjustmentDialog, [inventory]) results.select(results[0]) self._check_run_dialog(app.CountingAction, ProductCountingDialog, [inventory]) branches = list(self.store.find(Branch)) branches.remove(inventory.branch) self._check_run_dialog(app.NewInventory, OpenInventoryDialog, [branches])
def test_return_sale(self, new_store, return_sale): new_store.return_value = self.store with self.sysparam(ALLOW_CANCEL_CONFIRMED_SALES=True): sale = self.create_sale(branch=get_current_branch(self.store)) self.add_product(sale) sale.status = Sale.STATUS_ORDERED app = self.create_app(TillApp, u'till') app.status_filter.select(Sale.STATUS_ORDERED) results = app.results results.select(results[0]) with mock.patch.object(self.store, 'commit'): with mock.patch.object(self.store, 'close'): self.activate(app.Return) return_sale.assert_called_once_with( app.get_toplevel(), results[0].sale, self.store)
def test_edit_component(self, run_dialog): run_dialog.return_value = None component = self.create_product_component() component.component.sellable.code = u'4567' branch = get_current_branch(self.store) self.create_storable(component.product, branch=branch, stock=1, unit_cost=10) editor = ProductionProductEditor(self.store, component.product) editor.code.update("12345") compslave = editor.component_slave compslave.component_combo.select_item_by_data(component.component) self.click(compslave.add_button) self.assertEquals(run_dialog.call_count, 1) self.check_editor(editor, 'editor-product-prod-edit')
def test_sale_order_report(self): # Simple sellable product = self.create_product(price=100) sellable = product.sellable sellable.unit = self.create_sellable_unit(description=u'UN') default_date = datetime.date(2007, 1, 1) # Package sellable package = self.create_product(description=u'Package', is_package=True) first_component = self.create_product(description=u'First Component', stock=50) second_component = self.create_product(description=u'Second Component', stock=50, price=20) p_first_component = self.create_product_component(product=package, component=first_component, component_quantity=2, price=15) p_second_component = self.create_product_component(product=package, component=second_component, price=10) # Sale sale = self.create_sale() sale.open_date = default_date # workaround to make the sale order number constant. sale.identifier = 9090 sale.add_sellable(sellable, quantity=1) parent = sale.add_sellable(package.sellable, quantity=2) parent.price = 0 sale.add_sellable(first_component.sellable, quantity=parent.quantity * p_first_component.quantity, price=p_first_component.price, parent=parent) sale.add_sellable(second_component.sellable, quantity=parent.quantity * p_second_component.quantity, price=p_second_component.price, parent=parent) self.create_storable(product, get_current_branch(self.store), stock=100) sale.order(self.current_user) self._diff_expected(SaleOrderReport, 'sale-order-report', sale)
def test_booklet_with_sale_pdf(self): due_dates = [ datetime.datetime(2012, 1, 5), datetime.datetime(2012, 2, 5), datetime.datetime(2012, 3, 5), datetime.datetime(2012, 4, 5), datetime.datetime(2012, 5, 5), ] items = [ (u"Batata", 2, decimal.Decimal('10')), (u"Tomate", 3, decimal.Decimal('15.5')), (u"Banana", 1, decimal.Decimal('5.25')), ] client = self.create_client() client.credit_limit = decimal.Decimal('100000') address = self.create_address() address.person = client.person sale = self.create_sale(client=client, branch=get_current_branch(self.store)) for description, quantity, price in items: sellable = self.add_product(sale, price, quantity) sellable.description = description sale.order(self.current_user) method = PaymentMethod.get_by_name(self.store, u'store_credit') method.max_installments = 12 method.create_payments(sale.branch, sale.station, Payment.TYPE_IN, sale.group, value=sale.get_total_sale_amount(), due_dates=due_dates) sale.confirm(self.current_user) sale.identifier = 123 for i, payment in enumerate(sale.group.payments): payment.identifier = 66 + i self._diff_expected(BookletReport, 'booklet-with-sale', sale.group.payments)
def test_can_close(self): sellable = self.create_sellable() branch = get_current_branch(self.store) storable = self.create_storable(sellable.product, branch, 0) # There's a storable, but we can still close because there's no stock self.assertTrue(sellable.can_close()) storable.increase_stock(1, branch, StockTransactionHistory.TYPE_INITIAL, None) # Now that there's stock we should not be able to close anymore self.assertFalse(sellable.can_close()) storable.decrease_stock(1, branch, StockTransactionHistory.TYPE_INITIAL, None) # But decreasing the stock should make it possible to close again self.assertTrue(sellable.can_close()) # The delivery service cannot be closed. sellable = sysparam.get_object(self.store, 'DELIVERY_SERVICE').sellable self.assertFalse(sellable.can_close())
def _create_domain(self): self.today = datetime.date.today() branch = get_current_branch(self.store) product = self.create_product() storable = Storable(store=self.store, product=product) self.create_product_stock_item( storable=storable, branch=branch, quantity=2) product.sellable.code = u'1' product.sellable.description = u'Luvas' product.sellable.status = Sellable.STATUS_CLOSED product = self.create_product() storable = Storable(store=self.store, product=product) self.create_product_stock_item( storable=storable, branch=branch, quantity=4) product.sellable.code = u'2' product.sellable.description = u'Botas' product.sellable.status = Sellable.STATUS_CLOSED
def _create_fiscal_entry(cls, store, entry_type, group, cfop, invoice_number, iss_value=0, icms_value=0, ipi_value=0): return FiscalBookEntry(entry_type=entry_type, iss_value=iss_value, ipi_value=ipi_value, icms_value=icms_value, invoice_number=invoice_number, cfop=cfop, drawee=group.recipient, branch=get_current_branch(store), date=TransactionTimestamp(), payment_group=group, store=store)
def _create_domain(self): branch = get_current_branch(self.store) product = self.create_product() storable = Storable(store=self.store, product=product) self.create_product_stock_item(storable=storable, branch=branch, quantity=2) product.brand = u'' product.sellable.code = u'1' product.sellable.description = u'Luvas' product2 = self.create_product() storable2 = Storable(store=self.store, product=product2) self.create_product_stock_item(storable=storable2, branch=branch, quantity=4) product2.brand = u'brand' product.sellable.code = u'2' product.sellable.description = u'Botas'
def test_sales_person_report(self): sysparam.set_bool(self.store, 'SALE_PAY_COMMISSION_WHEN_CONFIRMED', True) salesperson = self.create_sales_person() product = self.create_product(price=100) sellable = product.sellable sale = self.create_sale() sale.salesperson = salesperson sale.add_sellable(sellable, quantity=1) self.create_storable(product, get_current_branch(self.store), stock=100) CommissionSource(sellable=sellable, direct_value=Decimal(10), installments_value=1, store=self.store) sale.order(self.current_user) method = PaymentMethod.get_by_name(self.store, u'money') method.create_payment(sale.branch, sale.station, Payment.TYPE_IN, sale.group, sale.get_sale_subtotal()) sale.confirm(self.current_user) sale.group.pay() salesperson = salesperson commissions = list(self.store.find(CommissionView)) commissions[0].identifier = 1 commissions[1].identifier = 139 self._diff_expected(SalesPersonReport, 'sales-person-report', commissions, salesperson) # Also test when there is no salesperson selected self._diff_expected(SalesPersonReport, 'sales-person-report-without-salesperson', commissions, None)
def test_run_dialogs(self): inventory = self.create_inventory( branch=get_current_branch(self.store)) app = self.create_app(InventoryApp, u'inventory') results = app.results results.select(results[0]) self._check_run_dialog(app.AdjustAction, InventoryAdjustmentEditor, [inventory]) with mock.patch.object(results[0], 'all_items_counted', new=lambda: False): results.select(results[0]) self._check_run_dialog(app.CountingAction, InventoryCountWizard, [inventory]) inventory.close() app._update_widgets() self._check_run_dialog(app.NewInventory, InventoryOpenEditor, [])
def get_missing_items(order, store): """ Fetch missing items, the returning object has the following attributes set: - storable: A |storable| for the missing item; - description: A description for the missing item; - ordered: The quantity ordered of the missing item; - stock: The stock available of the missing item. :returns: a list of Settable items with the attributes mentioned above """ # Lets confirm that we can create the sale, before opening the coupon prod_sold = {} prod_desc = {} for item in order.get_items(): # Skip services, since we don't need stock to sell. if isinstance(item, SaleItem) and item.is_service(): continue storable = item.sellable.product_storable # There are some products that we dont control the stock if not storable: continue prod_sold.setdefault(storable, 0) prod_sold[storable] += item.quantity if isinstance(item, SaleItem): prod_sold[storable] -= item.quantity_decreased prod_desc[storable] = item.sellable.get_description() branch = get_current_branch(store) missing = [] for storable in prod_sold.keys(): stock = storable.get_balance_for_branch(branch) if stock < prod_sold[storable]: missing.append( Settable(storable=storable, description=prod_desc[storable], ordered=prod_sold[storable], stock=stock)) return missing
def test_penalty_and_interest(self): sale = self.create_sale() sale_item = self.create_sale_item(sale=sale) self.create_storable(sale_item.sellable.product, get_current_branch(self.store), 10) payment = self.create_payment(payment_type=Payment.TYPE_OUT, value=100, date=localtoday().date() - datetime.timedelta(5)) sale.group = payment.group sale.order() payment.method.daily_interest = 1 payment.method.penalty = 1 slave = PurchasePaymentConfirmSlave(self.store, [payment]) # Penalty and interest enabled self.assertEqual(slave.penalty.read(), currency('1')) self.assertEqual(slave.interest.read(), currency('5.05')) # Penalty disabled and interest enabled self.click(slave.pay_penalty) self.assertEqual(slave.penalty.read(), currency('0')) self.assertEqual(slave.interest.read(), currency('5')) # Penalty enabled and interest disabled self.click(slave.pay_penalty) self.click(slave.pay_interest) self.assertEqual(slave.penalty.read(), currency('1')) self.assertEqual(slave.interest.read(), currency('0')) # Penalty and interest disabled self.click(slave.pay_penalty) self.assertEqual(slave.penalty.read(), currency('0')) self.assertEqual(slave.interest.read(), currency('0'))
def testGetClientCreditTransactions(self): method = self.store.find(PaymentMethod, method_name=u'credit').one() client = self.create_client() sale = self.create_sale(client=client) self.add_product(sale) self.add_payments(sale) sale.order() sale.confirm() returned_sale = ReturnedSale(sale=sale, branch=get_current_branch(self.store), store=self.store) ReturnedSaleItem(sale_item=list(sale.get_items())[0], quantity=1, returned_sale=returned_sale, store=self.store) sale.return_(returned_sale) payment = self.create_payment(payment_type=Payment.TYPE_OUT, value=100, method=method, group=sale.group) payment.set_pending() payment.pay() payment_settable = Settable(identifier=payment.identifier, date=payment.paid_date, description=payment.description, value=Decimal(payment.paid_value)) payment_domain_list = list(client.get_credit_transactions()) self.assertTrue(len(payment_domain_list) == 1) payment_domain = payment_domain_list[0] self.assertEquals(payment_settable.identifier, payment_domain.identifier) self.assertEquals(payment_settable.date, payment_domain.date) self.assertEquals(payment_settable.description, payment_domain.description) self.assertEquals(payment_settable.value, payment_domain.value)
def testSalesPersonReport(self): sysparam(self.store).SALE_PAY_COMMISSION_WHEN_CONFIRMED = 1 salesperson = self.create_sales_person() product = self.create_product(price=100) sellable = product.sellable sale = self.create_sale() sale.salesperson = salesperson sale.add_sellable(sellable, quantity=1) self.create_storable(product, get_current_branch(self.store), stock=100) CommissionSource(sellable=sellable, direct_value=Decimal(10), installments_value=1, store=self.store) sale.order() method = PaymentMethod.get_by_name(self.store, u'money') till = Till.get_last_opened(self.store) method.create_payment(Payment.TYPE_IN, sale.group, sale.branch, sale.get_sale_subtotal(), till=till) sale.confirm() sale.group.pay() salesperson_name = salesperson.person.name commissions = list(self.store.find(CommissionView)) commissions[0].identifier = 1 commissions[1].identifier = 139 self._diff_expected(SalesPersonReport, 'sales-person-report', commissions, salesperson_name)
def test_return_on_another_branch(self, gcb): # Branch where the sale was created sale_branch = get_current_branch(self.store) # Branch where the sale was returned return_branch = self.create_branch() gcb.return_value = return_branch product = self.create_product(branch=sale_branch, stock=2) client = self.create_client() # Creating a sale on sale_branch sale = self.create_sale(branch=sale_branch, client=client) sale_item = sale.add_sellable(sellable=product.sellable) # Adding payments and confirming the sale payments = self.add_payments(sale, method_type=u'bill', installments=2) payments[0].status = Payment.STATUS_PENDING self.add_payments(sale, method_type=u'money') sale.order() sale.confirm() # Creating the returned_sale rsale = ReturnedSale(branch=return_branch, sale=sale, store=self.store) ReturnedSaleItem(store=self.store, returned_sale=rsale, sale_item=sale_item, quantity=1) rsale.return_(u'credit') # Checking the status of sale and returned_sale self.assertEquals(rsale.status, ReturnedSale.STATUS_PENDING) self.assertEquals(sale.status, Sale.STATUS_RETURNED) # Checking the quantity on sale_branch self.assertEquals(product.storable.get_balance_for_branch(sale_branch), 1) # We should not increase the stock of that product on return_branch self.assertEquals(product.storable.get_balance_for_branch(return_branch), 0)
def test_initial_stock(self): branch = get_current_branch(self.store) product = self.create_product(branch=branch, storable=False) product.manage_stock = False editor = ProductStockQuantityEditor(self.store, product, branch) self.check_editor(editor, 'editor-product-stock-quantity-initial-show') # Update editor editor.quantity.update(15) editor.cost.update('3.45') stock_items_before = self.store.find(ProductStockItem).count() # Confirm self.click(editor.main_dialog.ok_button) # Check data stock_items_after = self.store.find(ProductStockItem).count() self.assertEquals(stock_items_after, stock_items_before + 1) stock_item = product.storable.get_stock_item(branch, batch=None) self.assertEquals(stock_item.quantity, 15) self.assertEquals(stock_item.stock_cost, Decimal('3.45'))