nsinnovations/erpnext
2
0
Fork 0
mirror of https://github.com/frappe/erpnext.git synced 2026-08-04 18:23:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

feat: create sales invoice from pick list (#55594)

Browse Source 
* feat: create sales invoice from pick list

* test: cover sales invoice creation from pick list

* fix: require update stock for pick list invoices

* fix: return SI should not bother with pick list

(cherry picked from commit d6a201ed4a)

# Conflicts:
#	erpnext/selling/doctype/sales_order/mapper.py
#	erpnext/stock/doctype/pick_list/mapper.py
#	erpnext/stock/doctype/pick_list/pick_list.js
#	erpnext/stock/doctype/pick_list/test_pick_list.py
This commit is contained in:
Mihir Kandoi
2026-06-04 21:19:19 +05:30
committed by Mergify
parent 1823fbea37
commit f404b8d48a
10 changed files with 1835 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
erpnext/accounts/doctype/sales_invoice/sales_invoice.py
View File

@@ -370,6 +370,8 @@ class SalesInvoice(SellingController):
if row.billing_amount:
row.billing_amount = -abs(row.billing_amount)
self.validate_update_stock_for_pick_list_reference()
self.set_serial_and_batch_bundle_from_pick_list()
self.update_packing_list()
self.set_billing_hours_and_amount()
self.update_timesheet_billing_for_project()
@@ -389,6 +391,18 @@ class SalesInvoice(SellingController):
self.validate_subcontracted_sales_order()
self.validate_scio_self_rm_qty()
def validate_update_stock_for_pick_list_reference(self):
if self.update_stock or self.is_return:
return
for row in self.items:
if row.get("against_pick_list"):
frappe.throw(
_(
"Row {0}: Update Stock must be checked for item {1} because it is against Pick List {2}."
).format(row.idx, frappe.bold(row.item_code), frappe.bold(row.against_pick_list))
)
def validate_accounts(self):
self.validate_write_off_account()
self.validate_account_for_change_amount()
@@ -491,6 +505,7 @@ class SalesInvoice(SellingController):
if self.update_stock == 1:
self.repost_future_sle_and_gle()
self.update_pick_list_status()
if not self.is_return:
self.update_billing_status_for_zero_amount_refdoc("Delivery Note")
@@ -614,6 +629,7 @@ class SalesInvoice(SellingController):
if self.update_stock == 1:
self.update_stock_reservation_entries()
self.repost_future_sle_and_gle()
self.update_pick_list_status()
self.db_set("status", "Cancelled")
@@ -665,26 +681,41 @@ class SalesInvoice(SellingController):
if not cint(self.update_stock):
return
self.status_updater.append(
{
"source_dt": "Sales Invoice Item",
"target_dt": "Sales Order Item",
"target_parent_dt": "Sales Order",
"target_parent_field": "per_delivered",
"target_field": "delivered_qty",
"target_ref_field": "qty",
"source_field": "qty",
"join_field": "so_detail",
"percent_join_field": "sales_order",
"status_field": "delivery_status",
"keyword": "Delivered",
"second_source_dt": "Delivery Note Item",
"second_source_field": "qty",
"second_join_field": "so_detail",
"overflow_type": "delivery",
"extra_cond": """ and exists(select name from `tabSales Invoice`
where name=`tabSales Invoice Item`.parent and update_stock = 1)""",
}
self.status_updater.extend(
[
{
"source_dt": "Sales Invoice Item",
"target_dt": "Sales Order Item",
"target_parent_dt": "Sales Order",
"target_parent_field": "per_delivered",
"target_field": "delivered_qty",
"target_ref_field": "qty",
"source_field": "qty",
"join_field": "so_detail",
"percent_join_field": "sales_order",
"status_field": "delivery_status",
"keyword": "Delivered",
"second_source_dt": "Delivery Note Item",
"second_source_field": "qty",
"second_join_field": "so_detail",
"overflow_type": "delivery",
"extra_cond": """ and exists(select name from `tabSales Invoice`
where name=`tabSales Invoice Item`.parent and update_stock = 1)""",
},
{
"source_dt": "Sales Invoice Item",
"target_dt": "Pick List Item",
"join_field": "pick_list_item",
"target_field": "delivered_qty",
"target_parent_dt": "Pick List",
"target_parent_field": "per_delivered",
"target_ref_field": "picked_qty",
"source_field": "stock_qty",
"percent_join_field": "against_pick_list",
"status_field": "delivery_status",
"keyword": "Delivered",
},
]
)
if not cint(self.is_return):

23
erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.json
View File

@@ -104,6 +104,7 @@
"sales_order",
"so_detail",
"sales_invoice_item",
"pick_list_item",
"column_break_74",
"delivery_note",
"dn_detail",
@@ -112,6 +113,7 @@
"pos_invoice",
"pos_invoice_item",
"scio_detail",
"against_pick_list",
"internal_transfer_section",
"purchase_order",
"column_break_92",
@@ -855,8 +857,8 @@
"fieldtype": "Currency",
"label": "Rate of Stock UOM",
"no_copy": 1,
"print_hide": 1,
"options": "currency",
"print_hide": 1,
"read_only": 1
},
{
@@ -1011,13 +1013,30 @@
"label": "Consider for Tax Withholding",
"print_hide": 1,
"read_only": 1
},
{
"fieldname": "against_pick_list",
"fieldtype": "Link",
"hidden": 1,
"label": "Against Pick List",
"no_copy": 1,
"options": "Pick List",
"read_only": 1
},
{
"fieldname": "pick_list_item",
"fieldtype": "Data",
"hidden": 1,
"label": "Pick List Item",
"no_copy": 1,
"read_only": 1
}
],
"grid_page_length": 50,
"idx": 1,
"istable": 1,
"links": [],
"modified": "2026-05-29 12:23:28.259905",
"modified": "2026-06-03 13:17:36.145788",
"modified_by": "Administrator",
"module": "Accounts",
"name": "Sales Invoice Item",

2
erpnext/accounts/doctype/sales_invoice_item/sales_invoice_item.py
View File

@@ -22,6 +22,7 @@ class SalesInvoiceItem(Document):
actual_batch_qty: DF.Float
actual_qty: DF.Float
against_pick_list: DF.Link | None
allow_zero_valuation_rate: DF.Check
amount: DF.Currency
apply_tds: DF.Check
@@ -72,6 +73,7 @@ class SalesInvoiceItem(Document):
parent: DF.Data
parentfield: DF.Data
parenttype: DF.Data
pick_list_item: DF.Data | None
pos_invoice: DF.Link | None
pos_invoice_item: DF.Data | None
price_list_rate: DF.Currency

38
erpnext/controllers/selling_controller.py
View File

@@ -1039,6 +1039,44 @@ class SellingController(StockController):
qty_to_undelivered -= qty_can_be_undelivered
def set_serial_and_batch_bundle_from_pick_list(self):
from erpnext.stock.serial_batch_bundle import SerialBatchCreation
for item in self.items:
if item.use_serial_batch_fields or not item.against_pick_list or not self.get("update_stock", 1):
continue
if item.pick_list_item and not item.serial_and_batch_bundle:
filters = {
"item_code": item.item_code,
"voucher_type": "Pick List",
"voucher_no": item.against_pick_list,
"voucher_detail_no": item.pick_list_item,
}
bundle_id = frappe.db.get_value("Serial and Batch Bundle", filters, "name")
if bundle_id:
cls_obj = SerialBatchCreation(
{
"type_of_transaction": "Outward",
"serial_and_batch_bundle": bundle_id,
"item_code": item.get("item_code"),
"warehouse": item.get("warehouse"),
}
)
cls_obj.duplicate_package()
item.serial_and_batch_bundle = cls_obj.serial_and_batch_bundle
def update_pick_list_status(self):
from erpnext.stock.doctype.pick_list.pick_list import update_pick_list_status
pick_lists = {row.against_pick_list for row in self.items if row.against_pick_list}
for pick_list in pick_lists:
update_pick_list_status(pick_list)
def set_default_income_account_for_item(obj):
"""Set income account as default for items in the transaction.

1092
erpnext/selling/doctype/sales_order/mapper.py Normal file
View File

File diff suppressed because it is too large Load Diff

38
erpnext/stock/doctype/delivery_note/delivery_note.py
View File

@@ -356,37 +356,6 @@ class DeliveryNote(SellingController):
]
)
def set_serial_and_batch_bundle_from_pick_list(self):
from erpnext.stock.serial_batch_bundle import SerialBatchCreation
for item in self.items:
if item.use_serial_batch_fields or not item.against_pick_list:
continue
if item.pick_list_item and not item.serial_and_batch_bundle:
filters = {
"item_code": item.item_code,
"voucher_type": "Pick List",
"voucher_no": item.against_pick_list,
"voucher_detail_no": item.pick_list_item,
}
bundle_id = frappe.db.get_value("Serial and Batch Bundle", filters, "name")
if bundle_id:
cls_obj = SerialBatchCreation(
{
"type_of_transaction": "Outward",
"serial_and_batch_bundle": bundle_id,
"item_code": item.get("item_code"),
"warehouse": item.get("warehouse"),
}
)
cls_obj.duplicate_package()
item.serial_and_batch_bundle = cls_obj.serial_and_batch_bundle
def validate_references(self):
self.validate_sales_order_references()
self.validate_sales_invoice_references()
@@ -617,13 +586,6 @@ class DeliveryNote(SellingController):
)
)
def update_pick_list_status(self):
from erpnext.stock.doctype.pick_list.pick_list import update_pick_list_status
pick_lists = {row.against_pick_list for row in self.items if row.against_pick_list}
for pick_list in pick_lists:
update_pick_list_status(pick_list)
def check_next_docstatus(self):
submit_rv = frappe.db.sql(
"""select t1.name

415
erpnext/stock/doctype/pick_list/mapper.py Normal file
View File

@@ -0,0 +1,415 @@
# Copyright (c) 2019, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
import json
from itertools import groupby
import frappe
from frappe import _
from frappe.model.document import Document
from frappe.model.mapper import map_child_doc
from frappe.utils import flt, get_link_to_form
from erpnext.selling.doctype.sales_order.mapper import (
make_delivery_note as create_delivery_note_from_sales_order,
)
from erpnext.selling.doctype.sales_order.mapper import (
make_sales_invoice as create_sales_invoice_from_sales_order,
)
def validate_item_locations(pick_list):
if not pick_list.locations:
frappe.throw(_("Add items in the Item Locations table"))
@frappe.whitelist()
def create_delivery_note(source_name: str, target_doc: str | Document | None = None):
return create_delivery(source_name, target_doc, "Delivery Note")
@frappe.whitelist()
def create_delivery(source_name: str, target_doc: str | Document | None = None, target: str | None = None):
pick_list = frappe.get_doc("Pick List", source_name)
target = target or (frappe.flags.args or {}).get("target") or "Delivery Note"
validate_item_locations(pick_list)
sales_dict = dict()
sales_orders = []
documents = []
for location in pick_list.locations:
if location.sales_order:
sales_orders.append(
frappe.db.get_value(
"Sales Order",
location.sales_order,
[
"customer",
"name as sales_order",
"company_address",
"dispatch_address_name",
"shipping_address_name",
"customer_address",
],
as_dict=True,
)
)
group_key = lambda so: ( # noqa
so["customer"],
so["company_address"] or "",
so["dispatch_address_name"] or "",
so["shipping_address_name"] or "",
so["customer_address"] or "",
)
for key, rows in groupby(sorted(sales_orders, key=group_key), key=group_key):
sales_dict[key] = {row.sales_order for row in rows}
if sales_dict:
documents.extend(create_delivery_with_so(sales_dict, pick_list, target))
if not all(item.sales_order for item in pick_list.locations):
documents.append(create_delivery_wo_so(pick_list, target, target_doc))
if len(documents) == 1:
return documents[0]
else:
from frappe.utils import comma_and
doc_list = [get_link_to_form(target, p.name) for p in documents]
frappe.msgprint(_("{0} created").format(comma_and(doc_list)))
def create_dn_wo_so(pick_list, delivery_note=None):
return create_delivery_wo_so(pick_list, "Delivery Note", delivery_note)
def create_delivery_wo_so(pick_list, target, target_doc=None):
if not target_doc:
target_doc = frappe.new_doc(target)
target_doc.company = pick_list.company
item_table_mapper_without_so = {
"doctype": f"{target} Item",
"field_map": {
"rate": "rate",
"name": "name",
"parent": "",
},
}
map_pl_locations(pick_list, item_table_mapper_without_so, target_doc)
target_doc.flags.ignore_mandatory = True
if target == "Sales Invoice":
target_doc.update_stock = 1
target_doc.save()
return target_doc
@frappe.whitelist()
def create_dn_for_pick_lists(
source_name: str, target_doc: str | Document | None = None, kwargs: dict | str | None = None
):
"""Get Items from Multiple Pick Lists and create a Delivery Note for filtered customer"""
if kwargs is None:
kwargs = {}
if isinstance(kwargs, str):
kwargs = json.loads(kwargs)
pick_list = frappe.get_doc("Pick List", source_name)
validate_item_locations(pick_list)
sales_order_arg = kwargs.get("sales_order")
customer_arg = kwargs.get("customer")
if sales_order_arg:
sales_orders = {sales_order_arg}
else:
sales_orders = {row.sales_order for row in pick_list.locations if row.sales_order}
if customer_arg:
sales_orders = frappe.get_all(
"Sales Order",
filters={"customer": customer_arg, "name": ["in", list(sales_orders)]},
pluck="name",
)
delivery_note = create_delivery_from_so(
pick_list, sales_orders, "Delivery Note", target_doc=target_doc, kwargs=kwargs
)
if not sales_order_arg and not all(item.sales_order for item in pick_list.locations):
if isinstance(delivery_note, str):
delivery_note = frappe.get_doc(frappe.parse_json(delivery_note))
delivery_note = create_delivery_wo_so(pick_list, "Delivery Note", delivery_note)
return delivery_note
def create_dn_with_so(sales_dict, pick_list):
return create_delivery_with_so(sales_dict, pick_list, "Delivery Note")
def create_delivery_with_so(sales_dict, pick_list, target):
"""Create target document for each customer (based on SO) in a Pick List."""
documents = []
for key in sales_dict:
document = create_delivery_from_so(pick_list, sales_dict[key], target)
if document:
document.flags.ignore_mandatory = True
# updates packed_items on save
# save as multiple customers are possible
if target == "Sales Invoice":
document.update_stock = 1
document.save()
documents.append(document)
return documents
def create_dn_from_so(pick_list, sales_order_list, delivery_note=None, kwargs=None):
return create_delivery_from_so(
pick_list, sales_order_list, "Delivery Note", target_doc=delivery_note, kwargs=kwargs
)
def create_delivery_from_so(pick_list, sales_order_list, target, target_doc=None, kwargs=None):
if not sales_order_list:
return target_doc
if kwargs is None:
kwargs = {}
def select_item(d):
filtered_items = kwargs.get("filtered_children", [])
child_filter = d.name in filtered_items if filtered_items else True
return child_filter
item_table_mapper = {
"doctype": f"{target} Item",
"field_map": {
"rate": "rate",
"name": "so_detail",
"parent": "against_sales_order" if target == "Delivery Note" else "sales_order",
},
"condition": lambda doc: abs(doc.delivered_qty) < abs(doc.qty)
and doc.delivered_by_supplier != 1
and select_item(doc),
}
kwargs = {"skip_item_mapping": True, "ignore_pricing_rule": pick_list.ignore_pricing_rule}
target_doc = (
create_delivery_note_from_sales_order(next(iter(sales_order_list)), target_doc, kwargs=kwargs)
if target == "Delivery Note"
else create_sales_invoice_from_sales_order(next(iter(sales_order_list)), target_doc, args=kwargs)
)
if not target_doc:
return
for so in sales_order_list:
map_pl_locations(pick_list, item_table_mapper, target_doc, so)
return target_doc
def map_pl_locations(pick_list, item_mapper, target_doc, sales_order=None):
for location in pick_list.locations:
if location.sales_order != sales_order or location.product_bundle_item:
continue
if location.sales_order_item:
sales_order_item = frappe.get_doc("Sales Order Item", location.sales_order_item)
else:
sales_order_item = None
source_doc = sales_order_item or location
child_item = map_child_doc(source_doc, target_doc, item_mapper)
if child_item:
child_item.against_pick_list = pick_list.name
child_item.pick_list_item = location.name
child_item.warehouse = location.warehouse
child_item.qty = flt(location.picked_qty - location.delivered_qty) / (
flt(child_item.conversion_factor) or 1
)
child_item.batch_no = location.batch_no
child_item.serial_no = location.serial_no
child_item.use_serial_batch_fields = location.use_serial_batch_fields
if not child_item.qty:
target_doc.items.remove(child_item)
continue
update_child_item(source_doc, child_item, target_doc)
add_product_bundles_to_target(pick_list, target_doc, item_mapper, sales_order)
set_target_missing_values(target_doc)
target_doc.company = pick_list.company
if sales_order:
target_doc.customer = frappe.get_value("Sales Order", sales_order, "customer")
def add_product_bundles_to_delivery_note(pick_list, delivery_note, item_mapper, sales_order=None) -> None:
return add_product_bundles_to_target(pick_list, delivery_note, item_mapper, sales_order)
def add_product_bundles_to_target(pick_list, target_doc, item_mapper, sales_order=None) -> None:
"""Add product bundles found in pick list to target document.
When mapping pick list items, the bundle item itself isn't part of the
locations. Dynamically fetch and add parent bundle item into target document."""
product_bundles = pick_list._get_product_bundles()
product_bundle_qty_map = pick_list._get_product_bundle_qty_map(product_bundles.values())
for so_row, value in product_bundles.items():
sales_order_item = frappe.get_doc("Sales Order Item", so_row)
if sales_order and sales_order_item.parent != sales_order:
continue
target_bundle_item = map_child_doc(sales_order_item, target_doc, item_mapper)
target_bundle_item.qty = pick_list._compute_picked_qty_for_bundle(
so_row, product_bundle_qty_map[value.item_code]
)
target_bundle_item.pick_list_item = value.pick_list_item
target_bundle_item.against_pick_list = pick_list.name
update_child_item(sales_order_item, target_bundle_item, target_doc)
@frappe.whitelist()
def create_stock_entry(pick_list: str):
pick_list = frappe.get_doc(json.loads(pick_list))
validate_item_locations(pick_list)
if stock_entry_exists(pick_list.get("name")):
return frappe.msgprint(_("Stock Entry has been already created against this Pick List"))
stock_entry = frappe.new_doc("Stock Entry")
stock_entry.pick_list = pick_list.get("name")
stock_entry.purpose = pick_list.get("purpose")
stock_entry.company = pick_list.get("company")
stock_entry.set_stock_entry_type()
if pick_list.get("work_order"):
stock_entry = update_stock_entry_based_on_work_order(pick_list, stock_entry)
elif pick_list.get("material_request"):
stock_entry = update_stock_entry_based_on_material_request(pick_list, stock_entry)
else:
stock_entry = update_stock_entry_items_with_no_reference(pick_list, stock_entry)
stock_entry.set_missing_values()
return stock_entry.as_dict()
def update_delivery_note_item(source, target, delivery_note):
return update_child_item(source, target, delivery_note)
def update_child_item(source, target, target_doc):
cost_center = frappe.db.get_value("Project", target_doc.project, "cost_center")
if not cost_center:
cost_center = get_cost_center(source.item_code, "Item", target_doc.company)
if not cost_center:
cost_center = get_cost_center(source.item_group, "Item Group", target_doc.company)
target.cost_center = cost_center
def get_cost_center(for_item, from_doctype, company):
"""Returns Cost Center for Item or Item Group"""
return frappe.db.get_value(
"Item Default",
fieldname=["buying_cost_center"],
filters={"parent": for_item, "parenttype": from_doctype, "company": company},
)
def set_delivery_note_missing_values(target):
return set_target_missing_values(target)
def set_target_missing_values(target):
target.run_method("set_missing_values")
target.run_method("set_po_nos")
target.run_method("calculate_taxes_and_totals")
def stock_entry_exists(pick_list_name):
return frappe.db.exists("Stock Entry", {"pick_list": pick_list_name})
def update_stock_entry_based_on_work_order(pick_list, stock_entry):
work_order = frappe.get_doc("Work Order", pick_list.get("work_order"))
stock_entry.work_order = work_order.name
stock_entry.company = work_order.company
stock_entry.from_bom = 1
stock_entry.bom_no = work_order.bom_no
stock_entry.use_multi_level_bom = work_order.use_multi_level_bom
stock_entry.fg_completed_qty = pick_list.for_qty
if work_order.bom_no:
stock_entry.inspection_required = frappe.db.get_value("BOM", work_order.bom_no, "inspection_required")
is_wip_warehouse_group = frappe.db.get_value("Warehouse", work_order.wip_warehouse, "is_group")
if not (is_wip_warehouse_group and work_order.skip_transfer):
wip_warehouse = work_order.wip_warehouse
else:
wip_warehouse = None
stock_entry.to_warehouse = wip_warehouse
stock_entry.project = work_order.project
for location in pick_list.locations:
item = frappe._dict()
update_common_item_properties(item, location)
item.t_warehouse = wip_warehouse
stock_entry.append("items", item)
return stock_entry
def update_stock_entry_based_on_material_request(pick_list, stock_entry):
for location in pick_list.locations:
target_warehouse = None
if location.material_request_item:
target_warehouse = frappe.get_value(
"Material Request Item", location.material_request_item, "warehouse"
)
item = frappe._dict()
update_common_item_properties(item, location)
item.t_warehouse = target_warehouse
stock_entry.append("items", item)
return stock_entry
def update_stock_entry_items_with_no_reference(pick_list, stock_entry):
for location in pick_list.locations:
item = frappe._dict()
update_common_item_properties(item, location)
stock_entry.append("items", item)
return stock_entry
def update_common_item_properties(item, location):
item.item_code = location.item_code
item.s_warehouse = location.warehouse
item.transfer_qty = location.picked_qty
item.qty = flt(location.picked_qty / (location.conversion_factor or 1), location.precision("qty"))
item.uom = location.uom
item.conversion_factor = location.conversion_factor
item.stock_uom = location.stock_uom
item.material_request = location.material_request
item.serial_no = location.serial_no
item.batch_no = location.batch_no
item.material_request_item = location.material_request_item

16
erpnext/stock/doctype/pick_list/pick_list.js
View File

@@ -135,7 +135,12 @@ frappe.ui.form.on("Pick List", {
if (frm.doc.purpose === "Delivery") {
frm.add_custom_button(
__("Delivery Note"),
() => frm.trigger("create_delivery_note"),
() => frm.events.create_delivery(frm, "Delivery Note"),
__("Create")
);
frm.add_custom_button(
__("Sales Invoice"),
() => frm.events.create_delivery(frm, "Sales Invoice"),
__("Create")
);
} else {
@@ -232,9 +237,16 @@ frappe.ui.form.on("Pick List", {
frm.clear_table("locations");
frm.trigger("add_get_items_button");
},
create_delivery_note: (frm) => {
create_delivery(frm, doctype) {
frappe.model.open_mapped_doc({
<<<<<<< HEAD
method: "erpnext.stock.doctype.pick_list.pick_list.create_delivery_note",
=======
method: "erpnext.stock.doctype.pick_list.mapper.create_delivery",
args: {
target: doctype,
},
>>>>>>> d6a201ed4a (feat: create sales invoice from pick list (#55594))
frm: frm,
});
},

3
erpnext/stock/doctype/pick_list/pick_list_dashboard.py
View File

@@ -7,6 +7,7 @@ def get_data():
"non_standard_fieldnames": {
"Stock Reservation Entry": "from_voucher_no",
"Delivery Note": "against_pick_list",
"Sales Invoice": "against_pick_list",
},
"internal_links": {
"Sales Order": ["locations", "sales_order"],
@@ -14,7 +15,7 @@ def get_data():
"transactions": [
{
"label": _("Sales"),
"items": ["Sales Order", "Delivery Note"],
"items": ["Sales Order", "Delivery Note", "Sales Invoice"],
},
{
"label": _("Manufacturing"),

200
erpnext/stock/doctype/pick_list/test_pick_list.py
View File

@@ -9,7 +9,15 @@ from erpnext.selling.doctype.sales_order.sales_order import create_pick_list
from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order
from erpnext.stock.doctype.item.test_item import create_item, make_item
from erpnext.stock.doctype.packed_item.test_packed_item import create_product_bundle
<<<<<<< HEAD
from erpnext.stock.doctype.pick_list.pick_list import create_delivery_note, create_dn_for_pick_lists
=======
from erpnext.stock.doctype.pick_list.mapper import (
create_delivery,
create_delivery_note,
create_dn_for_pick_lists,
)
>>>>>>> d6a201ed4a (feat: create sales invoice from pick list (#55594))
from erpnext.stock.doctype.purchase_receipt.test_purchase_receipt import make_purchase_receipt
from erpnext.stock.doctype.serial_and_batch_bundle.test_serial_and_batch_bundle import (
get_batch_from_bundle,
@@ -768,6 +776,198 @@ class TestPickList(ERPNextTestSuite):
if dn_item.item_code == "_Test Item 2":
self.assertEqual(dn_item.qty, 2)
@ERPNextTestSuite.change_settings("Stock Settings", {"use_serial_batch_fields": 1})
def test_sales_invoice_from_pick_list_copies_old_batch_serial_fields(self):
warehouse = "_Test Warehouse - _TC"
item = make_item(
f"_Test PLSI Old Fields {frappe.generate_hash(length=8)}",
properties={
"is_stock_item": 1,
"has_batch_no": 1,
"create_new_batch": 1,
"has_serial_no": 1,
"batch_number_series": f"PLSI-OLD-B-{frappe.generate_hash(length=6)}-.#####",
"serial_no_series": f"PLSI-OLD-S-{frappe.generate_hash(length=6)}-.#####",
},
).name
make_stock_entry(item=item, to_warehouse=warehouse, qty=2, basic_rate=100)
sales_order = make_sales_order(item_code=item, warehouse=warehouse, qty=2, rate=100)
pick_list = create_pick_list(sales_order.name)
pick_list.submit()
pick_list_item = pick_list.locations[0]
self.assertTrue(pick_list_item.use_serial_batch_fields)
self.assertTrue(pick_list_item.batch_no)
self.assertTrue(pick_list_item.serial_no)
sales_invoice = create_delivery(pick_list.name, target="Sales Invoice")
sales_invoice_item = sales_invoice.items[0]
self.assertEqual(sales_invoice.update_stock, 1)
self.assertEqual(sales_invoice_item.against_pick_list, pick_list.name)
self.assertEqual(sales_invoice_item.pick_list_item, pick_list_item.name)
self.assertEqual(sales_invoice_item.use_serial_batch_fields, 1)
self.assertEqual(sales_invoice_item.batch_no, pick_list_item.batch_no)
self.assertEqual(
set(sales_invoice_item.serial_no.split("\n")), set(pick_list_item.serial_no.split("\n"))
)
@ERPNextTestSuite.change_settings("Stock Settings", {"use_serial_batch_fields": 0})
def test_sales_invoice_from_pick_list_copies_serial_and_batch_bundle(self):
frappe.db.set_single_value("Stock Settings", "use_serial_batch_fields", 0)
warehouse = "_Test Warehouse - _TC"
item = make_item(
f"_Test PLSI Bundle {frappe.generate_hash(length=8)}",
properties={
"is_stock_item": 1,
"has_batch_no": 1,
"create_new_batch": 1,
"has_serial_no": 1,
"batch_number_series": f"PLSI-BND-B-{frappe.generate_hash(length=6)}-.#####",
"serial_no_series": f"PLSI-BND-S-{frappe.generate_hash(length=6)}-.#####",
},
).name
stock_entry = make_stock_entry(item=item, to_warehouse=warehouse, qty=2, basic_rate=100)
batch_no = get_batch_from_bundle(stock_entry.items[0].serial_and_batch_bundle)
serial_nos = get_serial_nos_from_bundle(stock_entry.items[0].serial_and_batch_bundle)
sales_order = make_sales_order(item_code=item, warehouse=warehouse, qty=2, rate=100)
pick_list = frappe.get_doc(
{
"doctype": "Pick List",
"company": "_Test Company",
"customer": "_Test Customer",
"items_based_on": "Sales Order",
"purpose": "Delivery",
"pick_manually": 1,
"locations": [
{
"item_code": item,
"warehouse": warehouse,
"qty": 2,
"stock_qty": 2,
"picked_qty": 2,
"conversion_factor": 1,
"sales_order": sales_order.name,
"sales_order_item": sales_order.items[0].name,
"use_serial_batch_fields": 0,
}
],
}
).insert()
from erpnext.stock.serial_batch_bundle import SerialBatchCreation
pick_list.locations[0].serial_and_batch_bundle = (
SerialBatchCreation(
{
"item_code": item,
"warehouse": warehouse,
"voucher_type": "Pick List",
"voucher_no": pick_list.name,
"voucher_detail_no": pick_list.locations[0].name,
"qty": -2,
"batches": frappe._dict({batch_no: 2}),
"serial_nos": serial_nos,
"type_of_transaction": "Outward",
"company": "_Test Company",
"do_not_submit": True,
}
)
.make_serial_and_batch_bundle()
.name
)
pick_list.locations[0].db_set(
{
"use_serial_batch_fields": 0,
"batch_no": None,
"serial_no": None,
"serial_and_batch_bundle": pick_list.locations[0].serial_and_batch_bundle,
}
)
pick_list.reload()
pick_list_item = pick_list.locations[0]
self.assertFalse(pick_list_item.use_serial_batch_fields)
self.assertTrue(pick_list_item.serial_and_batch_bundle)
sales_invoice = create_delivery(pick_list.name, target="Sales Invoice")
sales_invoice_item = sales_invoice.items[0]
self.assertEqual(sales_invoice_item.against_pick_list, pick_list.name)
self.assertEqual(sales_invoice_item.pick_list_item, pick_list_item.name)
self.assertFalse(sales_invoice_item.use_serial_batch_fields)
self.assertTrue(sales_invoice_item.serial_and_batch_bundle)
self.assertNotEqual(
sales_invoice_item.serial_and_batch_bundle, pick_list_item.serial_and_batch_bundle
)
self.assertEqual(
get_batch_from_bundle(sales_invoice_item.serial_and_batch_bundle),
get_batch_from_bundle(pick_list_item.serial_and_batch_bundle),
)
self.assertEqual(
set(get_serial_nos_from_bundle(sales_invoice_item.serial_and_batch_bundle)),
set(get_serial_nos_from_bundle(pick_list_item.serial_and_batch_bundle)),
)
def test_sales_invoice_from_sales_order_pick_list_updates_sales_order(self):
warehouse = "_Test Warehouse - _TC"
item = make_item().name
make_stock_entry(item=item, to_warehouse=warehouse, qty=5, basic_rate=100)
sales_order = make_sales_order(item_code=item, warehouse=warehouse, qty=5, rate=100)
pick_list = create_pick_list(sales_order.name)
pick_list.submit()
sales_invoice = create_delivery(pick_list.name, target="Sales Invoice")
sales_invoice_item = sales_invoice.items[0]
self.assertEqual(sales_invoice_item.sales_order, sales_order.name)
self.assertEqual(sales_invoice_item.so_detail, sales_order.items[0].name)
self.assertEqual(sales_invoice_item.against_pick_list, pick_list.name)
self.assertEqual(sales_invoice_item.pick_list_item, pick_list.locations[0].name)
sales_invoice.submit()
pick_list.reload()
sales_order.reload()
self.assertEqual(pick_list.locations[0].delivered_qty, pick_list.locations[0].picked_qty)
self.assertEqual(pick_list.per_delivered, 100)
self.assertEqual(pick_list.delivery_status, "Fully Delivered")
self.assertEqual(pick_list.status, "Completed")
self.assertEqual(sales_order.items[0].picked_qty, 5)
self.assertEqual(sales_order.items[0].delivered_qty, 5)
self.assertEqual(sales_order.per_delivered, 100)
self.assertEqual(sales_order.delivery_status, "Fully Delivered")
self.assertEqual(sales_order.per_billed, 100)
self.assertEqual(sales_order.billing_status, "Fully Billed")
self.assertEqual(sales_order.status, "Completed")
def test_sales_invoice_against_pick_list_requires_update_stock(self):
warehouse = "_Test Warehouse - _TC"
item = make_item().name
make_stock_entry(item=item, to_warehouse=warehouse, qty=5, basic_rate=100)
sales_order = make_sales_order(item_code=item, warehouse=warehouse, qty=5, rate=100)
pick_list = create_pick_list(sales_order.name)
pick_list.submit()
sales_invoice = create_delivery(pick_list.name, target="Sales Invoice")
sales_invoice.update_stock = 0
self.assertRaisesRegex(
frappe.ValidationError,
"Update Stock.*Pick List",
sales_invoice.save,
)
def test_picklist_reserved_qty_validation(self):
from erpnext.selling.doctype.sales_order.test_sales_order import make_sales_order