def test_lead_time(self):
product = self.create_product()
Storable(product=product, store=self.store)
branch = get_current_branch(self.store)
supplier1 = self.create_supplier()
ProductSupplierInfo(store=self.store,
product=product,
supplier=supplier1,
lead_time=10)
self.assertEqual(product.get_max_lead_time(1, branch), 10)
supplier2 = self.create_supplier()
ProductSupplierInfo(store=self.store,
product=product,
supplier=supplier2,
lead_time=20)
self.assertEqual(product.get_max_lead_time(1, branch), 20)
# Now for composed products
product = self.create_product(create_supplier=False)
product.is_composed = True
product.production_time = 5
Storable(product=product, store=self.store)
component = self.create_product(create_supplier=False)
Storable(product=component, store=self.store)
ProductSupplierInfo(store=self.store,
product=component,
supplier=supplier1,
lead_time=7)
self.assertEqual(component.get_max_lead_time(1, branch), 7)
pc = ProductComponent(product=product,
component=component,
quantity=1,
store=self.store)
self.assertEqual(product.get_max_lead_time(1, branch), 12)
# Increase the component stock
component.storable.increase_stock(1, branch, 0, 0)
self.assertEqual(product.get_max_lead_time(1, branch), 5)
# Increase the quantity required:
pc.quantity = 2
self.assertEqual(product.get_max_lead_time(1, branch), 12)
def testHasComponents(self):
self.assertFalse(self.product.has_components())
component = self.create_product()
ProductComponent(product=self.product,
component=component,
store=self.store)
self.assertTrue(self.product.has_components())
def testGetComponents(self):
self.assertEqual(list(self.product.get_components()), [])
components = []
for i in range(3):
component = self.create_product()
product_component = ProductComponent(product=self.product,
component=component,
store=self.store)
components.append(product_component)
self.assertEqual(list(self.product.get_components()), components)
def test_lead_time(self):
product = self.create_product()
Storable(product=product, store=self.store)
branch = get_current_branch(self.store)
supplier1 = self.create_supplier()
ProductSupplierInfo(store=self.store, product=product,
supplier=supplier1, lead_time=10)
self.assertEqual(product.get_max_lead_time(1, branch), 10)
supplier2 = self.create_supplier()
ProductSupplierInfo(store=self.store, product=product,
supplier=supplier2, lead_time=20)
self.assertEqual(product.get_max_lead_time(1, branch), 20)
# Now for composed products
product = self.create_product(create_supplier=False)
product.is_composed = True
product.production_time = 5
Storable(product=product, store=self.store)
component = self.create_product(create_supplier=False)
Storable(product=component, store=self.store)
ProductSupplierInfo(store=self.store, product=component,
supplier=supplier1, lead_time=7)
self.assertEqual(component.get_max_lead_time(1, branch), 7)
pc = ProductComponent(product=product, component=component, quantity=1,
store=self.store)
self.assertEqual(product.get_max_lead_time(1, branch), 12)
# Increase the component stock
component.storable.increase_stock(1, branch, 0, 0)
self.assertEqual(product.get_max_lead_time(1, branch), 5)
# Increase the quantity required:
pc.quantity = 2
self.assertEqual(product.get_max_lead_time(1, branch), 12)
def add_or_update_product_component(self, store):
component = self._get_product_component(store)
if component is not None:
# updating
component.quantity = self.quantity
component.design_reference = self.design_reference
else:
# adding
ProductComponent(product=self.product,
component=self.component,
quantity=self.quantity,
design_reference=self.design_reference,
store=store)
def testIsComposedBy(self):
component = self.create_product()
self.assertEqual(self.product.is_composed_by(component), False)
ProductComponent(product=self.product,
component=component,
store=self.store)
self.assertEqual(self.product.is_composed_by(component), True)
component2 = self.create_product()
ProductComponent(product=component,
component=component2,
store=self.store)
self.assertEqual(self.product.is_composed_by(component2), True)
self.assertEqual(component.is_composed_by(component2), True)
component3 = self.create_product()
ProductComponent(product=self.product,
component=component3,
store=self.store)
self.assertEqual(self.product.is_composed_by(component3), True)
self.assertEqual(component.is_composed_by(component3), False)
self.assertEqual(component2.is_composed_by(component3), False)
def testCanRemove(self):
product = self.create_product()
storable = Storable(product=product, store=self.store)
self.assertTrue(product.can_remove())
storable.increase_stock(1, get_current_branch(self.store), 0, 0)
self.assertFalse(product.can_remove())
# Product was sold.
sale = self.create_sale()
sale.add_sellable(product.sellable, quantity=1, price=10)
method = PaymentMethod.get_by_name(self.store, u'money')
method.create_payment(Payment.TYPE_IN, sale.group, sale.branch,
sale.get_sale_subtotal())
sale.order()
sale.confirm()
self.assertFalse(product.can_remove())
# Product is a component.
from stoqlib.domain.product import ProductComponent
product = self.create_product(10)
component = self.create_product(5)
Storable(product=component, store=self.store)
self.assertTrue(component.can_remove())
ProductComponent(product=product,
component=component,
store=self.store)
self.assertFalse(component.can_remove())
# Product is used in a production.
from stoqlib.domain.production import ProductionItem
product = self.create_product()
Storable(product=product, store=self.store)
self.assertTrue(product.can_remove())
order = self.create_production_order()
ProductionItem(product=product,
order=order,
quantity=1,
store=self.store)
self.assertFalse(product.can_remove())
def create_sellable(self, product_info, responsible):
if product_info.get('is_package') != 'true':
raise SellableError(
"""A criação de produtos somente é permitida para produtos do tipo pacote.
Verifique o cache do seu navegador.""")
sellable = None
if product_info["code"]:
sellable = self.store.find(Sellable,
Sellable.code == product_info["code"])
if sellable:
return
sellable = Sellable(store=self.store,
description=product_info["description"],
cost=Decimal(product_info["cost"]),
price=Decimal(product_info["price"]))
sellable.code = product_info["code"]
sellable.barcode = product_info["barcode"]
sellable.notes = "Created via API" + product_info["notes"]
sellable.unit_id = product_info["unit_id"] or None
sellable.tax_constant_id = product_info["tax_constant"] or None
sellable.default_sale_cfop_id = product_info[
"default_sale_cfop_id"] or None
sellable.category_id = product_info["category_id"] or None
# FIXME Need to get more info from NFe to fill both Product and Storable
product = Product(store=self.store, sellable=sellable)
product.manage_stock = product_info.get('manage_stock') == 'true'
product.is_package = product_info.get('is_package') == 'true'
package_quantity = product_info.get('package_quantity')
item_ean = product_info.get('item_ean')
item = self.store.find(Sellable, barcode=item_ean).one()
ProductComponent(product=product,
component=item.product,
price=sellable.get_price(),
quantity=Decimal(package_quantity))
return sellable
def create_production_item(self, quantity=1, order=None):
from stoqlib.domain.product import ProductComponent, Storable
from stoqlib.domain.production import (ProductionItem,
ProductionMaterial)
product = self.create_product(10)
Storable(product=product, store=self.store)
component = self.create_product(5)
Storable(product=component, store=self.store)
ProductComponent(product=product,
component=component,
store=self.store)
if not order:
order = self.create_production_order()
component = list(product.get_components())[0]
ProductionMaterial(product=component.component,
order=order,
needed=quantity,
store=self.store)
return ProductionItem(product=product,
order=order,
quantity=quantity,
store=self.store)
def create_product_component(self, product=None, component=None):
from stoqlib.domain.product import ProductComponent
return ProductComponent(product=product or self.create_product(),
component=component or self.create_product(),
store=self.store)
def delete_product_component(self, store):
component = self._get_product_component(store)
if component is not None:
ProductComponent.delete(component.id,
store=store)
def delete_product_component(self, store):
component = self._get_product_component(store)
if component is not None:
ProductComponent.delete(component.id, store=store)
