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 test_add_item(self, branch=None): sale_item = self.create_sale_item() branch = branch or self.create_branch() item = ReturnedSaleItem(store=self.store, sale_item=sale_item) rsale = ReturnedSale(store=self.store, branch=branch) rsale.add_item(item)
def test_client(self): branch = self.create_branch() client = self.create_client() sale = self.create_sale(branch=branch) sale.client = client rsale = ReturnedSale(store=self.store) self.assertIsNone(rsale.client) rsale.sale = sale self.assertEquals(rsale.client, client)
def test_group(self): branch = self.create_branch() client = self.create_client() sale = self.create_sale(branch=branch) sale.client = client rsale = ReturnedSale(branch=branch, store=self.store) self.assertIsNone(rsale.group) rsale.sale = sale self.assertEquals(rsale.group, sale.group) rsale.sale = None rsale.new_sale = sale self.assertEquals(rsale.group, sale.group)
def create_trade(self, trade_value=100): from stoqlib.domain.returnedsale import ReturnedSale, ReturnedSaleItem branch = get_current_branch(self.store) returned_sale = ReturnedSale(store=self.store, responsible=get_current_user(self.store), branch=branch) ReturnedSaleItem(store=self.store, quantity=1, price=trade_value, sellable=self.create_sellable(), returned_sale=returned_sale) new_sale = self.create_sale() product_price = trade_value * 2 self.add_product(new_sale, price=product_price) new_sale.discount_value = trade_value returned_sale.new_sale = new_sale return returned_sale
def test_trade_without_sale(self): # With discount branch = get_current_branch(self.store) returned_sale = ReturnedSale(store=self.store, responsible=get_current_user(self.store), branch=branch) storable = self.create_storable(branch=branch, stock=10) ReturnedSaleItem(store=self.store, quantity=1, price=10, sellable=storable.product.sellable, returned_sale=returned_sale) new_sale = self.create_sale() returned_sale.new_sale = new_sale balance_before_trade = storable.get_balance_for_branch(branch) with self.sysparam(USE_TRADE_AS_DISCOUNT=True): returned_sale.trade() self.assertEqual(new_sale.discount_value, currency(10)) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(branch), balance_before_trade + 1) # Without discount returned_sale2 = ReturnedSale(store=self.store, responsible=get_current_user(self.store), branch=branch) storable = self.create_storable(branch=branch, stock=10) ReturnedSaleItem(store=self.store, quantity=1, price=10, sellable=storable.product.sellable, returned_sale=returned_sale2) new_sale = self.create_sale() returned_sale2.new_sale = new_sale balance_before_trade = storable.get_balance_for_branch(branch) returned_sale2.trade() self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(new_sale.discount_value, currency(0)) group = new_sale.group payment = group.payments[0] self.assertEqual(group.payments.count(), 1) self.assertEqual(payment.value, returned_sale2.returned_total) self.assertEqual(storable.get_balance_for_branch(branch), balance_before_trade + 1)
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 _create_pending_returned_sale_message(self): branch = api.get_current_branch(self.store) n_returned = ReturnedSale.get_pending_returned_sales(self.store, branch).count() if not n_returned: return None msg = stoqlib_ngettext(_(u"You have %s returned sale to receive"), _(u"You have %s returned sales to receive"), n_returned) % n_returned info_returned_bar = self.window.add_info_bar(gtk.MESSAGE_QUESTION, msg) button = info_returned_bar.add_button(_(u"Returned sale"), gtk.RESPONSE_OK) button.connect('clicked', self._on_info_returned_sales__clicked) return info_returned_bar
def test_return_unpaid_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) self.add_payments(sale, method_type=u'bill', installments=1) 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) # Before the return there is not out payment self.assertIsNone( sale.group.payments.find(payment_type=Payment.TYPE_OUT).one()) rsale.return_(u'credit') # There should be one payment with a credit for the returned value self.assertIsNotNone( sale.group.payments.find(payment_type=Payment.TYPE_OUT).one())
def test_return_unpaid_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) self.add_payments(sale, method_type=u'bill', installments=1) 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) # Before the return there is not out payment self.assertIsNone(sale.group.payments.find(payment_type=Payment.TYPE_OUT).one()) rsale.return_(u'credit') # There should be one payment with a credit for the returned value self.assertIsNotNone(sale.group.payments.find(payment_type=Payment.TYPE_OUT).one())
def test_sale_total_with_rounding(self): branch = self.create_branch() sale = self.create_sale(branch=branch) self.add_product(sale, price=2, quantity=Decimal('0.527')) self.add_product(sale, price=2, quantity=Decimal('0.527')) self.add_payments(sale) sale.order(self.current_user) sale.confirm(self.current_user) rsale = ReturnedSale(branch=branch, station=self.current_station, sale=sale, store=self.store) # Here, if the rounding was made before adding both products, we would actually # end up with a sale_total of 2.11 instead of 2.10, which is the expected value. self.assertEqual(rsale.sale_total, currency(Decimal('2.10')))
def test_returned_sale_totals(self): # Verificar esse funcionamento no Stoq sale = self.create_sale() product = self.create_product(price=100) sale_item = sale.add_sellable(product.sellable) self.add_payments(sale) sale.order() sale.confirm() returned_sale = ReturnedSale(branch=sale.branch, sale=sale, store=self.store) ReturnedSaleItem(returned_sale=returned_sale, sale_item=sale_item, quantity=1) self.assertEquals(returned_sale.invoice_subtotal, 100) self.assertEquals(returned_sale.invoice_total, 100)
def _search_pending_returned_sales(self): with api.new_store() as store: self.run_dialog(PendingReturnedSaleSearch, store) branch = api.get_current_branch(self.store) # After the search is closed we may want to update , or even hide the # message, if there is no pending returned sale to receive if self.returned_bar: n_returned = ReturnedSale.get_pending_returned_sales(self.store, branch).count() if n_returned > 0: msg = stoqlib_ngettext(_(u"You have %s returned sale to receive"), _(u"You have %s returned sales to receive"), n_returned) % n_returned self.returned_bar.set_message(msg) else: self.returned_bar.hide() self.refresh()
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 _update_wizard_model(self): wizard_model = self.wizard.model if wizard_model: # We are replacing the model. Remove old one wizard_model.remove() 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_trade_on_another_branch(self): sale_branch = self.current_branch return_branch = self.create_branch() product = self.create_product(branch=sale_branch, stock=5) sale = self.create_sale(branch=sale_branch) sale_item = sale.add_sellable(sellable=product.sellable) storable = product.storable sale.order(self.current_user) self.add_payments(sale) sale.confirm(self.current_user) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) returned_sale = ReturnedSale(store=self.store, station=self.current_station, responsible=self.current_user, sale=sale, branch=return_branch) ReturnedSaleItem(store=self.store, quantity=1, price=10, sale_item=sale_item, returned_sale=returned_sale) new_sale = self.create_sale(branch=return_branch) returned_sale.new_sale = new_sale returned_sale.trade(self.current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_PENDING) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) self.assertEqual(storable.get_balance_for_branch(return_branch), 0) # This sale is returned in the return_branch, so the stock for the original sale branch is # the same, but the return branch has a new stock item returned_sale.confirm(self.current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) self.assertEqual(storable.get_balance_for_branch(return_branch), 1)
def test_trade_on_another_branch(self): sale_branch = get_current_branch(self.store) return_branch = self.create_branch() current_user = get_current_user(self.store) product = self.create_product(branch=sale_branch, stock=5) sale = self.create_sale(branch=sale_branch) sale_item = sale.add_sellable(sellable=product.sellable) storable = product.storable sale.order() self.add_payments(sale) sale.confirm() self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) returned_sale = ReturnedSale(store=self.store, responsible=current_user, sale=sale, branch=return_branch) ReturnedSaleItem(store=self.store, quantity=1, price=10, sale_item=sale_item, returned_sale=returned_sale) new_sale = self.create_sale(branch=return_branch) returned_sale.new_sale = new_sale returned_sale.trade() self.assertEqual(returned_sale.status, ReturnedSale.STATUS_PENDING) self.assertEqual(storable.get_balance_for_branch(sale_branch), 4) self.assertEqual(storable.get_balance_for_branch(return_branch), 0) returned_sale.confirm(current_user) self.assertEqual(returned_sale.status, ReturnedSale.STATUS_CONFIRMED) self.assertEqual(storable.get_balance_for_branch(sale_branch), 5) self.assertEqual(storable.get_balance_for_branch(return_branch), 0)
def test_total_amount_abs(self): branch = self.create_branch() sale = self.create_sale(branch=branch) self.add_product(sale) rsale = ReturnedSale(branch=branch, sale=sale, store=self.store) self.assertEqual(rsale.total_amount_abs, currency(0))
def test_add_item(self): sale_item = self.create_sale_item() item = ReturnedSaleItem(store=self.store, sale_item=sale_item) rsale = ReturnedSale(store=self.store) rsale.add_item(item)