def test_make_item_variant_with_numeric_values(self):
# cleanup
for d in frappe.db.get_all('Item', filters={'variant_of':
'_Test Numeric Template Item'}):
frappe.delete_doc_if_exists("Item", d.name)
frappe.delete_doc_if_exists("Item", "_Test Numeric Template Item")
frappe.delete_doc_if_exists("Item Attribute", "Test Item Length")
frappe.db.sql('''delete from `tabItem Variant Attribute`
where attribute="Test Item Length"''')
frappe.flags.attribute_values = None
# make item attribute
frappe.get_doc({
"doctype": "Item Attribute",
"attribute_name": "Test Item Length",
"numeric_values": 1,
"from_range": 0.0,
"to_range": 100.0,
"increment": 0.5
}).insert()
# make template item
make_item("_Test Numeric Template Item", {
"attributes": [
{
"attribute": "Test Size"
},
{
"attribute": "Test Item Length",
"numeric_values": 1,
"from_range": 0.0,
"to_range": 100.0,
"increment": 0.5
}
],
"item_defaults": [
{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}
],
"has_variants": 1
})
variant = create_variant("_Test Numeric Template Item",
{"Test Size": "Large", "Test Item Length": 1.1})
self.assertEqual(variant.item_code, "_Test Numeric Template Item-L-1.1")
variant.item_code = "_Test Numeric Variant-L-1.1"
variant.item_name = "_Test Numeric Variant Large 1.1m"
self.assertRaises(InvalidItemAttributeValueError, variant.save)
variant = create_variant("_Test Numeric Template Item",
{"Test Size": "Large", "Test Item Length": 1.5})
self.assertEqual(variant.item_code, "_Test Numeric Template Item-L-1.5")
variant.item_code = "_Test Numeric Variant-L-1.5"
variant.item_name = "_Test Numeric Variant Large 1.5m"
variant.save()
def test_make_item_variant(self):
frappe.delete_doc_if_exists("Item", "_Test Variant Item-L")
variant = create_variant("_Test Variant Item", {"Test Size": "Large"})
variant.save()
# doing it again should raise error
variant = create_variant("_Test Variant Item", {"Test Size": "Large"})
self.assertRaises(ItemVariantExistsError, variant.save)
def test_copy_fields_from_template_to_variants(self):
frappe.delete_doc_if_exists("Item", "_Test Variant Item-XL", force=1)
fields = [{'field_name': 'item_group'}, {'field_name': 'is_stock_item'}]
allow_fields = [d.get('field_name') for d in fields]
set_item_variant_settings(fields)
if not frappe.db.get_value('Item Attribute Value',
{'parent': 'Test Size', 'attribute_value': 'Extra Large'}, 'name'):
item_attribute = frappe.get_doc('Item Attribute', 'Test Size')
item_attribute.append('item_attribute_values', {
'attribute_value' : 'Extra Large',
'abbr': 'XL'
})
item_attribute.save()
template = frappe.get_doc('Item', '_Test Variant Item')
template.item_group = "_Test Item Group D"
template.save()
variant = create_variant("_Test Variant Item", {"Test Size": "Extra Large"})
variant.item_code = "_Test Variant Item-XL"
variant.item_name = "_Test Variant Item-XL"
variant.save()
variant = frappe.get_doc('Item', '_Test Variant Item-XL')
for fieldname in allow_fields:
self.assertEqual(template.get(fieldname), variant.get(fieldname))
template = frappe.get_doc('Item', '_Test Variant Item')
template.item_group = "_Test Item Group Desktops"
template.save()
def test_make_item_variant_with_numeric_values(self):
# cleanup
frappe.delete_doc_if_exists("Item", "_Test Numeric Template Item")
frappe.delete_doc_if_exists("Item", "_Test Numeric Variant-L-1.5")
frappe.delete_doc_if_exists("Item Attribute", "Test Item Length")
# make item attribute
frappe.get_doc({
"doctype": "Item Attribute",
"attribute_name": "Test Item Length",
"numeric_values": 1,
"from_range": 0.0,
"to_range": 100.0,
"increment": 0.5
}).insert()
# make template item
make_item("_Test Numeric Template Item", {
"attributes": [
{
"attribute": "Test Size"
},
{
"attribute": "Test Item Length",
"numeric_values": 1,
"from_range": 0.0,
"to_range": 100.0,
"increment": 0.5
}
],
"default_warehouse": "_Test Warehouse - _TC"
})
variant = create_variant("_Test Numeric Template Item", {"Test Size": "Large", "Test Item Length": 1.1})
self.assertEquals(variant.item_code, None)
variant.item_code = "_Test Numeric Variant-L-1.1"
variant.item_name = "_Test Numeric Variant Large 1.1m"
self.assertRaises(InvalidItemAttributeValueError, variant.save)
variant = create_variant("_Test Numeric Template Item", {"Test Size": "Large", "Test Item Length": 1.5})
self.assertEquals(variant.item_code, None)
variant.item_code = "_Test Numeric Variant-L-1.5"
variant.item_name = "_Test Numeric Variant Large 1.5m"
variant.save()
def test_item_attribute_change_after_variant(self):
frappe.delete_doc_if_exists("Item", "_Test Variant Item-L", force=1)
variant = create_variant("_Test Variant Item", {"Test Size": "Large"})
variant.save()
attribute = frappe.get_doc('Item Attribute', 'Test Size')
attribute.item_attribute_values = []
# reset flags
frappe.flags.attribute_values = None
self.assertRaises(InvalidItemAttributeValueError, attribute.save)
frappe.db.rollback()
def test_item_attribute_change_after_variant(self):
frappe.delete_doc_if_exists("Item", "_Test Variant Item-L", force=1)
variant = create_variant("_Test Variant Item", {"Test Size": "Large"})
variant.save()
attribute = frappe.get_doc('Item Attribute', 'Test Size')
attribute.item_attribute_values = []
# reset flags
frappe.flags.attribute_values = None
self.assertRaises(InvalidItemAttributeValueError, attribute.save)
frappe.db.rollback()
def test_show_item_attr(self):
from erpnext.controllers.item_variant import create_variant
self.item.has_variants = True
self.item.append("attributes", {"attribute": "Test Size"})
self.item.save()
attributes = {"Test Size": "Large"}
variant = create_variant(self.item.name, attributes)
variant.save()
self.generate_stock_ledger(variant.name, [_dict(qty=5, rate=10)])
rows = stock_balance(
self.filters.update({"show_variant_attributes": 1, "item_code": variant.name})
)
self.assertPartialDictEq(attributes, rows[0])
self.assertInvariants(rows)
def test_generated_variant_bom(self):
from erpnext.controllers.item_variant import create_variant
template_item = make_item(
"_TestTemplateItem",
{
"has_variants": 1,
"attributes": [
{
"attribute": "Test Size"
},
],
},
)
variant = create_variant(template_item.item_code,
{"Test Size": "Large"})
variant.insert(ignore_if_duplicate=True)
bom_tree = {
template_item.item_code: {
"SubAssembly1": {
"ChildPart1": {},
"ChildPart2": {},
},
"ChildPart5": {},
}
}
template_bom = create_nested_bom(bom_tree, prefix="")
variant_bom = make_variant_bom(template_bom.name,
template_bom.name,
variant.item_code,
variant_items=[])
variant_bom.save()
reqd_order = template_bom.get_tree_representation(
).level_order_traversal()
created_order = variant_bom.get_tree_representation(
).level_order_traversal()
self.assertEqual(len(reqd_order), len(created_order))
for reqd_item, created_item in zip(reqd_order, created_order):
self.assertEqual(reqd_item.item_code, created_item.item_code)
self.assertEqual(reqd_item.qty, created_item.qty)
self.assertEqual(reqd_item.exploded_qty, created_item.exploded_qty)
def create_new_paper(bf_gsm_deck, color):
attributes = bf_gsm_deck.strip().split("-")
if (len(attributes) != 3):
frappe.throw("Argument isn't in the right format(BF-GSM-Deck)")
args = {
"Colour": color,
"BF": attributes[0],
"GSM": attributes[1],
"Deck": attributes[2]
}
if (get_variant("PPR", args) != None):
frappe.throw("Paper {0} is already present".format(bf_gsm_deck))
print("Creating the new paper {0}".format(args))
paper = create_variant("PPR", args)
paper.save()
paper_mgmnt = frappe.get_doc("CM Paper Management", "Paper Management")
paper_mgmnt.update_paper_rate()
return paper.name
def create_variant_web_item():
"Create Variant and Template Website Items."
from erpnext.controllers.item_variant import create_variant
from erpnext.e_commerce.doctype.website_item.website_item import make_website_item
from erpnext.stock.doctype.item.test_item import make_item
make_item(
"Test Web Item", {
"has_variant": 1,
"variant_based_on": "Item Attribute",
"attributes": [{
"attribute": "Test Size"
}]
})
if not frappe.db.exists("Item", "Test Web Item-L"):
variant = create_variant("Test Web Item", {"Test Size": "Large"})
variant.save()
if not frappe.db.exists("Website Item", {"variant_of": "Test Web Item"}):
make_website_item(variant, save=True)
def execute():
i = 1
for item in frappe.get_all('Item', fields=["name"], filters=[]):
item_doc = frappe.get_doc('Item',item.name)
print "\nLooping for: " + item_doc.name
if item_doc.has_variants != 1:
item_doc.has_variants = 1
if not item_doc.attributes:
item_doc.append('attributes',get_attribute(item_doc.name, item_doc.revision))
item_doc.save()
args = {"Revision": cstr(item_doc.revision)}
new_variant = create_variant(item_doc.name, args)
new_variant.item_code = item_doc.name + "_" + cstr(item_doc.revision)
new_variant.item_name = item_doc.item_name
print new_variant.item_name
new_variant.insert()
i = i + 1
def import_rolls(self):
for roll in self.roll_items:
bf_gsm_vals = roll.paper_bf_gsm.split("-")
if (len(bf_gsm_vals) != 2):
frappe.throw(
"BF-GSM value {0} is not in the prescribed format".format(
roll.paper_bf_gsm))
variant_args = {
"Colour": roll.paper_color,
"BF": int(bf_gsm_vals[0]),
"GSM": int(bf_gsm_vals[1]),
"Deck": roll.paper_deck
}
paper = find_variant("PPR", variant_args)
if (paper == None):
print("Creating Paper for args {0} weight: {1}".format(
variant_args, roll.roll_weight))
paper_doc = create_variant("PPR", variant_args)
if (paper_doc != None):
paper_doc.valuation_rate = roll.paper_val_rate
paper_doc.standard_rate = roll.paper_std_rate
paper_doc.save(ignore_permissions=True)
paper = paper_doc.name
else:
frappe.throw("Failed to create the paper variant")
continue
paper_item = frappe.get_doc("Item", paper)
paper_item.opening_stock = roll.roll_weight
print("Updating paper {0} stock to {1}".format(
paper, paper_item.opening_stock))
paper_item.set_opening_stock()
paper_item.save(ignore_permissions=True)
paper_roll = frappe.new_doc("CM Paper Roll")
paper_roll.paper = paper
paper_roll.number = roll.roll_no
paper_roll.weight = roll.roll_weight
paper_roll.status = "Ready"
paper_roll.insert()
def execute():
i = 1
for item in frappe.get_all('Item', fields=["name"], filters=[]):
item_doc = frappe.get_doc('Item', item.name)
print "\nLooping for: " + item_doc.name
if item_doc.has_variants != 1:
item_doc.has_variants = 1
if not item_doc.attributes:
item_doc.append(
'attributes',
get_attribute(item_doc.name, item_doc.revision))
item_doc.save()
args = {"Revision": cstr(item_doc.revision)}
new_variant = create_variant(item_doc.name, args)
new_variant.item_code = item_doc.name + "_" + cstr(item_doc.revision)
new_variant.item_name = item_doc.item_name
print new_variant.item_name
new_variant.insert()
i = i + 1
def test_copy_fields_from_template_to_variants(self):
frappe.delete_doc_if_exists("Item", "_Test Variant Item-XL", force=1)
fields = [{
'field_name': 'item_group'
}, {
'field_name': 'is_stock_item'
}]
allow_fields = [d.get('field_name') for d in fields]
set_item_variant_settings(fields)
if not frappe.db.get_value('Item Attribute Value', {
'parent': 'Test Size',
'attribute_value': 'Extra Large'
}, 'name'):
item_attribute = frappe.get_doc('Item Attribute', 'Test Size')
item_attribute.append('item_attribute_values', {
'attribute_value': 'Extra Large',
'abbr': 'XL'
})
item_attribute.save()
variant = create_variant("_Test Variant Item",
{"Test Size": "Extra Large"})
variant.item_code = "_Test Variant Item-XL"
variant.item_name = "_Test Variant Item-XL"
variant.save()
template = frappe.get_doc('Item', '_Test Variant Item')
template.item_group = "_Test Item Group D"
template.save()
variant = frappe.get_doc('Item', '_Test Variant Item-XL')
for fieldname in allow_fields:
self.assertEquals(template.get(fieldname), variant.get(fieldname))
template = frappe.get_doc('Item', '_Test Variant Item')
template.item_group = "_Test Item Group Desktops"
template.save()
def test_copy_fields_from_template_to_variants(self):
frappe.delete_doc_if_exists("Item", "_Test Variant Item-XL", force=1)
fields = [{
"field_name": "item_group"
}, {
"field_name": "is_stock_item"
}]
allow_fields = [d.get("field_name") for d in fields]
set_item_variant_settings(fields)
if not frappe.db.get_value("Item Attribute Value", {
"parent": "Test Size",
"attribute_value": "Extra Large"
}, "name"):
item_attribute = frappe.get_doc("Item Attribute", "Test Size")
item_attribute.append("item_attribute_values", {
"attribute_value": "Extra Large",
"abbr": "XL"
})
item_attribute.save()
template = frappe.get_doc("Item", "_Test Variant Item")
template.item_group = "_Test Item Group D"
template.save()
variant = create_variant("_Test Variant Item",
{"Test Size": "Extra Large"})
variant.item_code = "_Test Variant Item-XL"
variant.item_name = "_Test Variant Item-XL"
variant.save()
variant = frappe.get_doc("Item", "_Test Variant Item-XL")
for fieldname in allow_fields:
self.assertEqual(template.get(fieldname), variant.get(fieldname))
template = frappe.get_doc("Item", "_Test Variant Item")
template.item_group = "_Test Item Group Desktops"
template.save()
def test_publish_variant_and_template(self):
"Check if template is published on publishing variant."
# template "Test Web Item" created on setUp
variant = create_variant("Test Web Item", {"Test Size": "Large"})
variant.save()
# check if template is not published
self.assertIsNone(frappe.db.exists("Website Item", {"item_code": variant.variant_of}))
variant_web_item = make_website_item(variant, save=False)
variant_web_item.save()
# check if template is published
try:
template_web_item = frappe.get_doc("Website Item", {"item_code": variant.variant_of})
except frappe.DoesNotExistError:
self.fail(f"Template of {variant.item_code}, {variant.variant_of} not published")
# teardown
variant_web_item.delete()
template_web_item.delete()
variant.delete()
def create_variants(attribute, template, product, setting):
attr_name = attribute[0].get("attribute") if len(attribute) >= 1 else None
if not attr_name:
return
options = frappe.db.get_values("Item Attribute Value",
filters={"parent": attr_name},
fieldname=["attribute_value", "abbr"],
as_dict=True)
for opt in options:
args = {}
item_code = "{0}-{1}".format(template.item_code, opt.get("abbr"))
if not frappe.db.get_value("Item", item_code):
args[attr_name] = opt.get("attribute_value")
doc = create_variant(template.item_code, args)
doc.save(ignore_permissions=True)
create_item_price(product, doc, setting)
else:
doc = frappe.get_doc("Item", item_code)
item_name = "{0}-{1}".format(product.name, opt.get("abbr"))
doc.update({"item_name": item_name})
doc.save(ignore_permissions=True)
create_item_price(product, doc, setting)
def test_add_item_variant_without_web_item_to_cart(self):
"Test adding Variants having no Website Items in cart via Template Web Item."
from erpnext.controllers.item_variant import create_variant
from erpnext.e_commerce.doctype.website_item.website_item import make_website_item
from erpnext.stock.doctype.item.test_item import make_item
template_item = make_item(
"Test-Tshirt-Temp",
{
"has_variant":
1,
"variant_based_on":
"Item Attribute",
"attributes": [{
"attribute": "Test Size"
}, {
"attribute": "Test Colour"
}],
},
)
variant = create_variant("Test-Tshirt-Temp", {
"Test Size": "Small",
"Test Colour": "Red"
})
variant.save()
make_website_item(template_item) # publish template not variant
update_cart("Test-Tshirt-Temp-S-R", 1)
cart = get_cart_quotation(
) # test if cart page gets data without errors
doc = cart.get("doc")
self.assertEqual(doc.get("items")[0].item_name, "Test-Tshirt-Temp-S-R")
# test if items are rendered without error
frappe.render_template("templates/includes/cart/cart_items.html", cart)
def make_item_variant():
if not frappe.db.exists("Item", "_Test Variant Item-S"):
variant = create_variant("_Test Variant Item", """{"Test Size": "Small"}""")
variant.item_code = "_Test Variant Item-S"
variant.item_name = "_Test Variant Item-S"
variant.save()
def test_make_item_variant_with_numeric_values(self):
# cleanup
for d in frappe.db.get_all(
'Item', filters={'variant_of': '_Test Numeric Template Item'}):
frappe.delete_doc_if_exists("Item", d.name)
frappe.delete_doc_if_exists("Item", "_Test Numeric Template Item")
frappe.delete_doc_if_exists("Item Attribute", "Test Item Length")
frappe.db.sql('''delete from `tabItem Variant Attribute`
where attribute="Test Item Length"''')
frappe.flags.attribute_values = None
# make item attribute
frappe.get_doc({
"doctype": "Item Attribute",
"attribute_name": "Test Item Length",
"numeric_values": 1,
"from_range": 0.0,
"to_range": 100.0,
"increment": 0.5
}).insert()
# make template item
make_item(
"_Test Numeric Template Item", {
"attributes": [{
"attribute": "Test Size"
}, {
"attribute": "Test Item Length",
"numeric_values": 1,
"from_range": 0.0,
"to_range": 100.0,
"increment": 0.5
}],
"default_warehouse":
"_Test Warehouse - _TC",
"has_variants":
1
})
variant = create_variant("_Test Numeric Template Item", {
"Test Size": "Large",
"Test Item Length": 1.1
})
self.assertEquals(variant.item_code,
"_Test Numeric Template Item-L-1.1")
variant.item_code = "_Test Numeric Variant-L-1.1"
variant.item_name = "_Test Numeric Variant Large 1.1m"
self.assertRaises(InvalidItemAttributeValueError, variant.save)
variant = create_variant("_Test Numeric Template Item", {
"Test Size": "Large",
"Test Item Length": 1.5
})
self.assertEquals(variant.item_code,
"_Test Numeric Template Item-L-1.5")
variant.item_code = "_Test Numeric Variant-L-1.5"
variant.item_name = "_Test Numeric Variant Large 1.5m"
variant.save()
def make_item_variant():
if not frappe.db.exists("Item", "_Test Variant Item-S"):
variant = create_variant("_Test Variant Item", """{"Test Size": "Small"}""")
variant.item_code = "_Test Variant Item-S"
variant.item_name = "_Test Variant Item-S"
variant.save()
