def validate_production_qty(self):
if flt(self.production_qty):
return True
errmsg = translate("Missing Fields")
field = translate("Production Qty")
frappe.throw("{}: {}".format(errmsg, field))
def _validate_item_set_uom():
doctype = "Item Set"
filters = {
"parenttype": "List of Material Detail",
"parentfield": "item_set",
"parent": self.name,
}
fields = "item"
doclist = frappe \
.get_all(doctype,
filters,
fields,
as_list=True)
for name, in doclist:
doctype = "Item"
doc = frappe.get_doc(doctype, name)
if self.uom in [d.uom for d in doc.uoms]:
continue
errmsg = \
translate("Conversion Factor not specified "
"in UOMs table in {0}: {1} for UOM: {2}")
frappe.throw(
errmsg
.format(doc.item_code,
doc.item_name, self.uom)
)
def validate_planning_document(self):
if self.planning_document:
return True
errmsg = translate("Missing Value for Planning Document field")
frappe.throw(errmsg)
def generate_hash_and_validate(self):
# don't validate for compound products
unique_hash = self.generate_hash()
doctype = self.doctype
filters = {
"unique_hash": unique_hash,
}
if not self.is_new():
filters.update({
"name": ["!=", self.name]
})
exists = cstr(database.exists(doctype, filters))
url_to_form = frappe.utils.get_url_to_form(doctype, exists)
err_msg = """
Ya existe un Producto con las mismas especificaciones
<br>
<strong>{doctype}</strong>
<a href="{url_to_form}">{name}</a>
"""
if exists and not self.is_compound_product:
frappe.throw(
err_msg
.format(doctype=translate(doctype),
url_to_form=url_to_form,
name=exists)
)
self.unique_hash = unique_hash
def get_filename(filename, attachment_type, doctype, docname):
attachment_opts = get_attachment_opts(attachment_type)
prefix = attachment_opts.prefix
extension = get_extension(filename)
common_name_part = "{prefix}-{name}" \
.format(prefix=prefix, name=docname)
current_count = get_current_count(common_name_part, doctype, docname)
if cint(attachment_opts.limit):
# validate attachment limits
errmsg = translate("Attachment limit exceeded "
"for Attachment Type of: {0}")
if current_count >= attachment_opts.limit:
frappe.throw(errmsg.format(attachment_type))
if cint(attachment_opts.limit) == 1:
return "{prefix}-{name}.{extension}" \
.format(prefix=prefix, name=docname, extension=extension)
version = "{next_version}" \
.format(next_version=cint(current_count) + 1)
return "{prefix}-{name}-{version}.{extension}" \
.format(prefix=prefix, name=docname,
extension=extension, version=version)
def get_item(source_doc):
ref_doctype = "Product Assembly"
ref_docname = source_doc.product_assembly
doctype = "Item"
filters = {
"ref_doctype": ref_doctype,
"ref_docname": ref_docname,
}
errmsg = translate("Item not found for Product Assembly: {}")
if not database.exists(doctype, filters):
frappe.throw(errmsg.format(ref_docname))
item_doc = frappe.get_doc(doctype, filters)
args = {
"item_code": item_doc.name,
"item_name": item_doc.item_name,
"parent": target_doc.name,
"parentfield": "items",
"parenttype": "Quotation",
"description": source_doc.product_assembly_specification,
"company": defaults.company,
"doctype": "Quotation",
"currency": source_doc.currency,
"qty": source_doc.qty_to_produce,
"rate": source_doc.rate_per_unit,
}
return get_item_details(args)
def validate_colors(self):
validvalues = ("0", "1", "2", "3", "4")
fields = (
"front_colors",
"pantone_colors",
"back_colors",
"pantone_back_colors",
)
err_msg = """
Valor para el campo {0}
debe estar en el rango (0-4)
"""
for fieldname in fields:
value = cstr(self.get(fieldname, 0))
if value in validvalues:
continue
if fieldname.startswith("pantone") \
and cint(value) > 0:
continue
label = self.meta.get_field(fieldname) \
.label
translated_label = translate(label)
frappe.throw(err_msg
.format(
bold(translated_label)
)
)
def _validate_item_group_uom():
doctype = "Item"
filters = {
"disabled": 0,
"is_stock_item": 1,
"item_group": self.item_group,
}
doclist = frappe \
.get_all(doctype,
filters,
as_list=True)
for name, in doclist:
doc = frappe.get_doc(doctype, name)
if self.uom in [d.uom for d in doc.uoms]:
continue
errmsg = \
translate("Conversion Factor not specified "
"in UOMs table in {0}: {1} for UOM: {2}")
frappe.throw(
errmsg
.format(doc.item_code,
doc.item_name, self.uom)
)
def update_task(name, status):
def update_project(task):
doctype = "Project"
name = task.get("project")
doc = frappe.get_doc(doctype, name)
doc.run_method("update_percent_complete")
doc.db_update()
return doc.as_dict()
doctype = "Task"
doc = frappe.get_doc(doctype, name)
if status not in ("Open", "Completed"):
return False
doc.status = status
if status == "Completed":
doc.completed_by = frappe.session.user
comment_type = "Edit"
text = translate("Completed By")
doc.add_comment(comment_type, "{}: {}".format(text, doc.completed_by))
else:
doc.completed_by = None
doc.db_update()
return update_project(doc)
def validate_cost_center(self):
doctype = "Cost Center"
name = self.cost_center
fieldname = "company"
if not name:
return True
cost_center_company = database \
.get_value(doctype, name, fieldname)
if cost_center_company == self.company:
return True
errmsg = \
translate("Cost Center should belong to "
"<strong>{company}</strong> company and it belongs "
"to <strong>{cost_center_company}</strong> company")
opts = {
"company": self.company,
"cost_center_company": cost_center_company,
}
frappe.throw(errmsg.format(opts))
def validate_planning_template(self):
if self.planning_template:
return True
errmsg = translate("Missing Value for Planning Template field")
frappe.throw(errmsg)
def validate_qty_to_produce(self):
qty_to_produce = flt(self.qty_to_produce)
errmsg = translate("Qty to produce must be greater than zero!")
if qty_to_produce <= 0:
frappe.throw(errmsg)
def validate_paperboard_items(self):
doctype = "Paperboard"
fieldname = "backboard"
err_msg = translate(
"Material {paperboard} ({material_name}) cannot be in the"
" {tablename} table at Row #{idx} as it is backboard.")
for d in self.paperboards:
docname = d.paperboard
backboard = frappe.get_value(doctype, docname, fieldname)
if backboard:
opts = d.as_dict()
opts.update({"tablename": translate("Paperboard")})
frappe.throw(err_msg.format(**opts))
def on_fetch_materials_prevalidate(self):
project_centers = self.project_centers
errmsg = translate("There should be at least one Project Center "
"in the Production Project Centers' table")
if not project_centers:
frappe.throw(errmsg)
def validate_packing_features_items(self):
doctype = "Product Feature"
fieldname = "product_feature_type"
err_msg = translate("{product_feature} Feature cannot be in the"
" {tablename} table at Row #{idx}. Please check!")
for d in self.packing_features:
docname = d.product_feature
product_feature_type = frappe.get_value(doctype, docname,
fieldname)
if product_feature_type != "Packing":
opts = d.as_dict()
opts.update({"tablename": translate("Packing")})
frappe.throw(err_msg.format(**opts))
def get_template():
doctype = "Project Center Template"
name = self.project_center_template
errmsg = translate("Missing Fields")
if not name:
frappe.throw("{}: {}".format(errmsg, doctype))
return frappe.get_doc(doctype, name)
def set_printing_sides(self):
doctype = "Product Assembly"
name = self.product_assembly
fields = ("front_colors", "pantone_colors", "back_colors",
"pantone_back_colors")
front_colors, pantone_colors, back_colors, pantone_back_colors \
= database.get_value(doctype, name, fields)
self.printing_sides = "Sin Impresión"
if cint(front_colors) > 0 \
or cint(pantone_colors) > 0:
self.printing_sides = translate("One Side")
if cint(back_colors) > 0 \
or cint(pantone_back_colors) > 0:
self.printing_sides = translate("Two Sides")
def validate_if_doc_exists(self):
item_doc = self.get_item_doc()
doctype = item_doc.ref_doctype
name = item_doc.ref_docname
errmsg = translate("This Item cannot be used as it does "
"not have a Product Profile")
if not doctype or not name:
frappe.throw(errmsg)
errmsg = translate(
"This Item cannot be used as its "
"references to a Product Profile does not exist anymore")
if not database.exists(doctype, name):
frappe.throw(errmsg)
def get_docfield(cls, label, fieldtype="Data", options="", length=100):
kwargs = {
"label": translate(label),
"fieldtype": fieldtype,
"options": options,
"length": length,
}
return "{label}:{fieldtype}/{options}:{length}" \
.format(**kwargs)
def make_sales_quotation(source_name, target_doc=None):
cost_estimation = database.get_value("Cost Estimation",
source_name,
["generated_on", "valid_until"],
as_dict=1)
if cost_estimation.valid_until and (
cost_estimation.valid_until < cost_estimation.generated_on
or cost_estimation.valid_until < getdate(nowdate())):
frappe.throw(translate("Validity period of this quotation has ended."))
return _make_sales_quotation(source_name, target_doc)
def get_item_doc(self):
doctype = "Item"
name = self.item_code
errmsg = translate("Item Code is missing")
if not name:
frappe.throw(errmsg)
return frappe.get_doc(doctype, name)
def get_formatted_field(label, fieldtype="Data", options=str(), length=120):
kwargs = {
"label": translate(label),
"fieldtype": fieldtype,
"options": options,
"length": length,
}
return "{label}:{fieldtype}/{options}:{length}" \
.format(**kwargs)
def get_planning_mission_template(self):
errmsg = translate("Missing value for Planning Template")
if not self.planning_mission_template:
frappe.throw(errmsg)
doctype = self.meta.get_field("planning_mission_template") \
.options
name = self.planning_mission_template
return frappe.get_doc(doctype, name)
def get_product_assembly(self):
item_doc = self.get_item_doc()
doctype = item_doc.ref_doctype
name = item_doc.ref_docname
errmsg = translate("Product Assembly not found for Item: {}")
if not database \
.exists(doctype, name):
frappe.throw(errmsg.format(item_doc.name))
return frappe.get_doc(doctype, name)
def validate_field_value(self, fieldname, datasource,
childfieldname, istable=False):
value = self.get(fieldname)
if not value:
return True
items = self.product_profile_doc \
.get(datasource, list())
item_list = (d.get(childfieldname) for d in items)
if istable:
for d in self.get(fieldname):
value = d.get(childfieldname)
if value in item_list:
continue
break
else:
return True
else:
if value in item_list:
return True
label = self.meta.get_field(fieldname) \
.label
translated_label = translate(label)
err_msg = translate(
"The selected {} {} is not defined in the "
"Product Profile. Please check!")
frappe.throw(err_msg
.format(translated_label,
bold(value)
)
)
def update_item_group(doc):
item_group = doc.item_group_5 \
or doc.item_group_4 \
or doc.item_group_3 \
or doc.item_group_2 \
or doc.item_group_1
errmsg = translate("Missing Item Group on Item {}: {}")
if not item_group:
frappe.throw(errmsg.format(doc.name, doc.item_name))
doc.item_group = item_group
doc.db_update()
def get_paperboard_name(self):
if not self.paperboard:
return translate("No Material")
doctype = self.meta \
.get_field("paperboard") \
.options
name = self.paperboard
doc = frappe.get_doc(doctype, name)
return doc \
.get_full_name(ignore_trademark=True)
def update_projects(self, autocommit=True, force=False):
if not force:
return False
status_list = list()
def update_child_project(project):
doctype = "Project"
name = project.project
fieldname = "status"
value = frappe.get_value(doctype, name, fieldname)
if value != project.status:
project.set(fieldname, value)
project.db_update()
return project.status
# remember project center status
prev_status = self.status
for project in self.projects:
status = update_child_project(project=project)
status_list.append(status)
# just a bit of config
status_change_comment = translate("Set to {}")
if all(status == "Completed" for status in status_list):
self.status = "Completed"
else:
if "Delayed" in status_list:
self.status = "Delayed"
else:
self.status = "Open"
if prev_status != self.status:
comment = status_change_comment \
.format(self.status)
self.add_comment("Edit", comment)
self.db_update()
if autocommit:
frappe.db.commit()
def validate_item_agaist_product_assembly(self):
fields = ("ref_doctype", "ref_docname")
doctype = "Item"
name = self.item
ref_doctype, ref_docname = database \
.get_value(doctype, name, fields)
field = self.meta.get_field("product_assembly")
errmsg = translate("Item: {} is not a type of Product Assembly: {}")
if field.options != ref_doctype \
or self.product_assembly != ref_docname:
frappe.throw(errmsg.format(name, self.product_assembly))
def get_compound_product(self, throw_error=True):
if not self.is_compound_product:
if throw_error:
err_msg = translate(
"Product Assembly must be a marked as Compound Product")
frappe.throw(err_msg)
return False
doctype = "Compound Product"
filters = {
"product_profile": self.product_profile,
"product_assembly": self.name,
}
if not database.exists(doctype, filters):
err_msg = translate(
"A Compound Product linked to this "
"Product Assembly does not exist")
frappe.throw(err_msg)
return frappe.get_doc(doctype, filters)
