# Copyright (c) 2013, Web Notes Technologies Pvt. Ltd. and Contributors # License: GNU General Public License v3. See license.txt from __future__ import unicode_literals import frappe from frappe import _, throw from frappe.utils import flt, cint, add_days from frappe.model.meta import has_field import json @frappe.whitelist() def get_item_details(args): """ args = { "item_code": "", "warehouse": None, "customer": "", "conversion_rate": 1.0, "selling_price_list": None, "price_list_currency": None, "plc_conversion_rate": 1.0, "doctype": "", "docname": "", "supplier": None, "transaction_date": None, "conversion_rate": 1.0, "buying_price_list": None, "is_subcontracted": "Yes" / "No", "transaction_type": "selling" } """ if isinstance(args, basestring): args = json.loads(args) args = frappe._dict(args) if not args.get("transaction_type"): args.transaction_type = "buying" if has_field(args.get("doctype"), "supplier") \ else "selling" if not args.get("price_list"): args.price_list = args.get("selling_price_list") or args.get("buying_price_list") if args.barcode: args.item_code = get_item_code(barcode=args.barcode) elif not args.item_code and args.serial_no: args.item_code = get_item_code(serial_no=args.serial_no) item_bean = frappe.bean("Item", args.item_code) item = item_bean.doc validate_item_details(args, item) out = get_basic_details(args, item_bean) get_party_item_code(args, item_bean, out) if out.get("warehouse"): out.update(get_available_qty(args.item_code, out.warehouse)) out.update(get_projected_qty(item.name, out.warehouse)) get_price_list_rate(args, item_bean, out) if args.transaction_type == "selling" and cint(args.is_pos): out.update(get_pos_settings_item_details(args.company, args)) apply_pricing_rule(out, args) if args.get("doctype") in ("Sales Invoice", "Delivery Note"): if item_bean.doc.has_serial_no == "Yes" and not args.serial_no: out.serial_no = get_serial_nos_by_fifo(args, item_bean) if args.transaction_date and item.lead_time_days: out.schedule_date = out.lead_time_date = add_days(args.transaction_date, item.lead_time_days) return out def get_item_code(barcode=None, serial_no=None): if barcode: item_code = frappe.db.get_value("Item", {"barcode": barcode}) elif serial_no: item_code = frappe.db.get_value("Serial No", serial_no, "item_code") if not item_code: throw(_("No Item found with ") + _("Barcode") if barcode else _("Serial No") + ": %s" % (barcode or serial_no)) return item_code def validate_item_details(args, item): if not args.company: throw(_("Please specify Company")) from erpnext.stock.doctype.item.item import validate_end_of_life validate_end_of_life(item.name, item.end_of_life) if args.transaction_type == "selling": # validate if sales item or service item if args.get("order_type") == "Maintenance": if item.is_service_item != "Yes": throw(_("Item") + (" %s: " % item.name) + _("not a service item.") + _("Please select a service item or change the order type to Sales.")) elif item.is_sales_item != "Yes": throw(_("Item") + (" %s: " % item.name) + _("not a sales item")) elif args.transaction_type == "buying": # validate if purchase item or subcontracted item if item.is_purchase_item != "Yes": throw(_("Item") + (" %s: " % item.name) + _("not a purchase item")) if args.get("is_subcontracted") == "Yes" and item.is_sub_contracted_item != "Yes": throw(_("Item") + (" %s: " % item.name) + _("not a sub-contracted item.") + _("Please select a sub-contracted item or do not sub-contract the transaction.")) def get_basic_details(args, item_bean): item = item_bean.doc from frappe.defaults import get_user_default_as_list user_default_warehouse_list = get_user_default_as_list('warehouse') user_default_warehouse = user_default_warehouse_list[0] \ if len(user_default_warehouse_list)==1 else "" out = frappe._dict({ "item_code": item.name, "item_name": item.item_name, "description": item.description_html or item.description, "warehouse": user_default_warehouse or args.warehouse or item.default_warehouse, "income_account": item.income_account or args.income_account \ or frappe.db.get_value("Company", args.company, "default_income_account"), "expense_account": item.expense_account or args.expense_account \ or frappe.db.get_value("Company", args.company, "default_expense_account"), "cost_center": item.selling_cost_center \ if args.transaction_type == "selling" else item.buying_cost_center, "batch_no": None, "item_tax_rate": json.dumps(dict(([d.tax_type, d.tax_rate] for d in item_bean.doclist.get({"parentfield": "item_tax"})))), "uom": item.stock_uom, "min_order_qty": flt(item.min_order_qty) if args.doctype == "Material Request" else "", "conversion_factor": 1.0, "qty": 1.0, "price_list_rate": 0.0, "base_price_list_rate": 0.0, "rate": 0.0, "base_rate": 0.0, "amount": 0.0, "base_amount": 0.0, "discount_percentage": 0.0 }) for fieldname in ("item_name", "item_group", "barcode", "brand", "stock_uom"): out[fieldname] = item.fields.get(fieldname) return out def get_price_list_rate(args, item_bean, out): meta = frappe.get_doctype(args.doctype) if meta.get_field("currency"): validate_price_list(args) validate_conversion_rate(args, meta) price_list_rate = frappe.db.get_value("Item Price", {"price_list": args.price_list, "item_code": args.item_code}, "price_list_rate") if not price_list_rate: return {} out.price_list_rate = flt(price_list_rate) * flt(args.plc_conversion_rate) \ / flt(args.conversion_rate) if not out.price_list_rate and args.transaction_type == "buying": from erpnext.stock.doctype.item.item import get_last_purchase_details out.update(get_last_purchase_details(item_bean.doc.name, args.docname, args.conversion_rate)) def validate_price_list(args): if args.get("price_list"): if not frappe.db.get_value("Price List", {"name": args.price_list, args.transaction_type: 1, "enabled": 1}): throw(_("Price List is either disabled or for not ") + _(args.transaction_type)) else: throw(_("Price List not selected")) def validate_conversion_rate(args, meta): from erpnext.setup.doctype.currency.currency import validate_conversion_rate from frappe.model.meta import get_field_precision # validate currency conversion rate validate_conversion_rate(args.currency, args.conversion_rate, meta.get_label("conversion_rate"), args.company) args.conversion_rate = flt(args.conversion_rate, get_field_precision(meta.get_field("conversion_rate"), frappe._dict({"fields": args}))) # validate price list currency conversion rate if not args.get("price_list_currency"): throw(_("Price List Currency not selected")) else: validate_conversion_rate(args.price_list_currency, args.plc_conversion_rate, meta.get_label("plc_conversion_rate"), args.company) args.plc_conversion_rate = flt(args.plc_conversion_rate, get_field_precision(meta.get_field("plc_conversion_rate"), frappe._dict({"fields": args}))) def get_item_discount(item_group, customer): parent_item_groups = [x[0] for x in frappe.db.sql("""SELECT parent.name FROM `tabItem Group` AS node, `tabItem Group` AS parent WHERE parent.lft <= node.lft and parent.rgt >= node.rgt and node.name = %s GROUP BY parent.name ORDER BY parent.lft desc""", (item_group,))] discount = 0 for d in parent_item_groups: res = frappe.db.sql("""select discount, name from `tabCustomer Discount` where parent = %s and item_group = %s""", (customer, d)) if res: discount = flt(res[0][0]) break return {"discount_percentage": discount} def get_party_item_code(args, item_bean, out): if args.transaction_type == "selling": customer_item_code = item_bean.doclist.get({"parentfield": "item_customer_details", "customer_name": args.customer}) out.customer_item_code = customer_item_code[0].ref_code if customer_item_code else None else: item_supplier = item_bean.doclist.get({"parentfield": "item_supplier_details", "supplier": args.supplier}) out.supplier_part_no = item_supplier[0].supplier_part_no if item_supplier else None def get_pos_settings_item_details(company, args, pos_settings=None): res = frappe._dict() if not pos_settings: pos_settings = get_pos_settings(company) if pos_settings: for fieldname in ("income_account", "cost_center", "warehouse", "expense_account"): if not args.get(fieldname): res[fieldname] = pos_settings.get(fieldname) if res.get("warehouse"): res.actual_qty = get_available_qty(args.item_code, res.warehouse).get("actual_qty") return res def get_pos_settings(company): pos_settings = frappe.db.sql("""select * from `tabPOS Setting` where user = %s and company = %s""", (frappe.session['user'], company), as_dict=1) if not pos_settings: pos_settings = frappe.db.sql("""select * from `tabPOS Setting` where ifnull(user,'') = '' and company = %s""", company, as_dict=1) return pos_settings and pos_settings[0] or None def apply_pricing_rule(out, args): args_dict = frappe._dict().update(args) args_dict.update(out) for rule_for in ["price", "discount"]: pricing_rules = get_pricing_rules(args_dict, rule_for) if pricing_rules: if rule_for == "discount": out["discount_percentage"] = pricing_rules[-1]["discount"] else: out["base_price_list_rate"] = pricing_rules[0]["price"] out["price_list_rate"] = pricing_rules[0]["price"] * \ flt(args_dict.plc_conversion_rate) / flt(args_dict.conversion_rate) def get_pricing_rules(args_dict, price_or_discount): def _filter_pricing_rule(pricing_rules, field_set): p_rules = [] for field in field_set: if not p_rules: for p_rule in pricing_rules: if p_rule[field] == args_dict.get(field): p_rules.append(p_rule) else: break return p_rules or pricing_rules pricing_rules = get_all_pricing_rules(args_dict, price_or_discount) for field_set in [["item_code", "item_group", "brand"], ["customer", "customer_group", "territory", "supplier", "supplier_type", "campaign", "sales_partner"]]: if pricing_rules: pricing_rules = _filter_pricing_rule(pricing_rules, field_set) # filter for price list if pricing_rules: pricing_rules = filter(lambda x: (not x.for_price_list or x.for_price_list==args_dict.price_list), pricing_rules) # filter for qty if pricing_rules and args_dict.get("qty"): pricing_rules = filter(lambda x: (args_dict.qty>=flt(x.min_qty) and (args_dict.qty<=x.max_qty if x.max_qty else True)), pricing_rules) # find pricing rule with highest priority if pricing_rules: max_priority = min([cint(p.priority) for p in pricing_rules]) if max_priority: pricing_rules = filter(lambda x: x.priority==max_priority, pricing_rules) if len(pricing_rules) > 1: pricing_rules = sorted(pricing_rules, key=lambda x: x[price_or_discount]) return pricing_rules def get_all_pricing_rules(args_dict, price_or_discount): conditions = " and ifnull(%s, 0) > 0" % price_or_discount for field in ["customer", "customer_group", "territory", "supplier", "supplier_type", "campaign", "sales_partner"]: if args_dict.get(field): conditions += " and ifnull("+field+", '') in (%("+field+")s, '')" if args_dict.get("transaction_date"): conditions += """ and %(transaction_date)s between ifnull(valid_from, '2000-01-01') and ifnull(valid_upto, '2500-12-31')""" return frappe.conn.sql("""select * from `tabPricing Rule` where (item_code=%(item_code)s or item_group=%(item_group)s or brand=%(brand)s) and docstatus < 2 and ifnull(disable, 0) = 0 {0} order by priority desc, name desc""".format(conditions), args_dict, as_dict=1) def get_serial_nos_by_fifo(args, item_bean): return "\n".join(frappe.db.sql_list("""select name from `tabSerial No` where item_code=%(item_code)s and warehouse=%(warehouse)s and status='Available' order by timestamp(purchase_date, purchase_time) asc limit %(qty)s""", { "item_code": args.item_code, "warehouse": args.warehouse, "qty": cint(args.qty) })) @frappe.whitelist() def get_conversion_factor(item_code, uom): return {"conversion_factor": frappe.db.get_value("UOM Conversion Detail", {"parent": item_code, "uom": uom}, "conversion_factor")} @frappe.whitelist() def get_projected_qty(item_code, warehouse): return {"projected_qty": frappe.db.get_value("Bin", {"item_code": item_code, "warehouse": warehouse}, "projected_qty")} @frappe.whitelist() def get_available_qty(item_code, warehouse): return frappe.db.get_value("Bin", {"item_code": item_code, "warehouse": warehouse}, ["projected_qty", "actual_qty"], as_dict=True) or {}