def work():
frappe.set_user(frappe.db.get_global('demo_manufacturing_user'))
make_purchase_receipt()
make_delivery_note()
make_stock_reconciliation()
submit_draft_stock_entries()
def test_dn_billing_status_case2(self):
# SO -> SI and SO -> DN1, DN2
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note, make_sales_invoice
so = make_sales_order()
si = make_sales_invoice(so.name)
si.get("items")[0].qty = 5
si.insert()
si.submit()
frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1)
dn1 = make_delivery_note(so.name)
dn1.posting_time = "10:00"
dn1.get("items")[0].qty = 2
dn1.submit()
self.assertEqual(dn1.get("items")[0].billed_amt, 200)
self.assertEqual(dn1.per_billed, 100)
self.assertEqual(dn1.status, "Completed")
dn2 = make_delivery_note(so.name)
dn2.posting_time = "08:00"
dn2.get("items")[0].qty = 4
dn2.submit()
dn1.load_from_db()
self.assertEqual(dn1.get("items")[0].billed_amt, 100)
self.assertEqual(dn1.per_billed, 50)
self.assertEqual(dn1.status, "To Bill")
self.assertEqual(dn2.get("items")[0].billed_amt, 400)
self.assertEqual(dn2.per_billed, 100)
self.assertEqual(dn2.status, "Completed")
def test_create_quotation_with_margin(self):
from erpnext.selling.doctype.quotation.quotation import make_sales_order
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note, make_sales_invoice
total_margin = flt((1500 * 18.75) / 100 + 1500)
test_records[0]["items"][0]["price_list_rate"] = 1500
test_records[0]["items"][0]["margin_type"] = "Percentage"
test_records[0]["items"][0]["margin_rate_or_amount"] = 18.75
quotation = frappe.copy_doc(test_records[0])
quotation.insert()
self.assertEquals(quotation.get("items")[0].rate, total_margin)
self.assertRaises(frappe.ValidationError, make_sales_order, quotation.name)
quotation.submit()
sales_order = make_sales_order(quotation.name)
sales_order.delivery_date = "2016-01-02"
sales_order.naming_series = "_T-Quotation-"
sales_order.transaction_date = "2016-01-01"
sales_order.insert()
self.assertEquals(quotation.get("items")[0].rate, total_margin)
sales_order.submit()
dn = make_delivery_note(sales_order.name)
self.assertEquals(quotation.get("items")[0].rate, total_margin)
dn.save()
si = make_sales_invoice(sales_order.name)
self.assertEquals(quotation.get("items")[0].rate, total_margin)
si.save()
def create_delivery_note(order, shopify_settings, so):
for fulfillment in order.get("fulfillments"):
if not frappe.db.get_value("Delivery Note", {"shopify_id": fulfillment.get("id")}, "name") and so.docstatus==1:
dn = make_delivery_note(so.name)
dn.shopify_id = fulfillment.get("id")
dn.naming_series = shopify_settings.delivery_note_series or "DN-Shopify-"
dn.items = update_items_qty(dn.items, fulfillment.get("line_items"), shopify_settings)
dn.save()
def create_dn_against_so(so, delivered_qty=0):
frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1)
dn = make_delivery_note(so)
dn.get("items")[0].qty = delivered_qty or 5
dn.insert()
dn.submit()
return dn
def test_block_delivery_note_against_cancelled_sales_order(self): so = make_sales_order() dn = make_delivery_note(so.name) dn.insert() so.cancel() self.assertRaises(frappe.CancelledLinkError, dn.submit)
def create_dn_for_so(wbtname, so):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
dn = make_delivery_note(so.name)
dn.weighbridge_ticket = wbtname
dn.save()
frappe.db.commit()
frappe.msgprint(_("Delivery Note %s created successfully." % (dn.name)))
return dn
def test_make_delivery_note(self):
so = make_sales_order(do_not_submit=True)
self.assertRaises(frappe.ValidationError, make_delivery_note, so.name)
so.submit()
dn = make_delivery_note(so.name)
self.assertEquals(dn.doctype, "Delivery Note")
self.assertEquals(len(dn.get("items")), len(so.get("items")))
def create_delivery_note(shopify_order, shopify_settings, so):
for fulfillment in shopify_order.get("fulfillments"):
if not frappe.db.get_value("Delivery Note", {"shopify_order_id": fulfillment.get("id")}, "name") and so.docstatus==1:
dn = make_delivery_note(so.name)
dn.shopify_order_id = fulfillment.get("order_id")
dn.shopify_fulfillment_id = fulfillment.get("id")
dn.naming_series = shopify_settings.delivery_note_series or "DN-Shopify-"
dn.items = get_fulfillment_items(dn.items, fulfillment.get("line_items"), shopify_settings)
dn.flags.ignore_mandatory = True
dn.save()
frappe.db.commit()
def test_dn_billing_status_case2(self):
# SO -> SI and SO -> DN1, DN2
from erpnext.selling.doctype.sales_order.sales_order import (
make_delivery_note,
make_sales_invoice,
)
so = make_sales_order()
si = make_sales_invoice(so.name)
si.get("items")[0].qty = 5
si.insert()
si.submit()
# Testing if Customer's Purchase Order No was rightly copied
self.assertEqual(so.po_no, si.po_no)
frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1)
dn1 = make_delivery_note(so.name)
dn1.get("items")[0].qty = 2
dn1.submit()
# Testing if Customer's Purchase Order No was rightly copied
self.assertEqual(so.po_no, dn1.po_no)
dn2 = make_delivery_note(so.name)
dn2.get("items")[0].qty = 3
dn2.submit()
# Testing if Customer's Purchase Order No was rightly copied
self.assertEqual(so.po_no, dn2.po_no)
dn1.load_from_db()
self.assertEqual(dn1.get("items")[0].billed_amt, 200)
self.assertEqual(dn1.per_billed, 100)
self.assertEqual(dn1.status, "Completed")
self.assertEqual(dn2.get("items")[0].billed_amt, 300)
self.assertEqual(dn2.per_billed, 100)
self.assertEqual(dn2.status, "Completed")
def create_delivery_note(order, shopify_settings, so):
for fulfillment in order.get("fulfillments"):
if not frappe.db.get_value("Delivery Note",
{"shopify_id": fulfillment.get("id")},
"name") and so.docstatus == 1:
dn = make_delivery_note(so.name)
dn.shopify_id = fulfillment.get("id")
dn.naming_series = shopify_settings.delivery_note_series or "DN-Shopify-"
dn.items = update_items_qty(dn.items,
fulfillment.get("line_items"),
shopify_settings)
dn.save()
def create_delivery_note(shopify_order, shopify_settings, so):
for fulfillment in shopify_order.get("fulfillments"):
if not frappe.db.get_value("Delivery Note", {"shopify_fulfillment_id": fulfillment.get("id")}, "name")\
and so.docstatus==1:
dn = make_delivery_note(so.name)
dn.shopify_order_id = fulfillment.get("order_id")
dn.shopify_fulfillment_id = fulfillment.get("id")
dn.naming_series = shopify_settings.delivery_note_series or "DN-Shopify-"
dn.items = get_fulfillment_items(dn.items, fulfillment.get("line_items"), shopify_settings)
dn.flags.ignore_mandatory = True
dn.save()
frappe.db.commit()
def make_delivery(fulfilled_items,current_order,SI_dict):
dn = make_delivery_note(current_order)
dn.set_posting_time = 1
dn.inflow_file = SI_dict["inflow_file"]
datepaid = SI_dict['DatePaid']
if not datepaid:
datepaid = SI_dict["OrderDate"]
else:
datepaid = parser.parse(datepaid)
dn.posting_date = datepaid.date()
dn.posting_time = str(datepaid.time())
dn.save()
dn.submit()
def test_make_delivery_note(self):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
so = frappe.bean(copy=test_records[0]).insert()
self.assertRaises(frappe.ValidationError, make_delivery_note,
so.doc.name)
sales_order = frappe.bean("Sales Order", so.doc.name)
sales_order.submit()
dn = make_delivery_note(so.doc.name)
self.assertEquals(dn[0]["doctype"], "Delivery Note")
self.assertEquals(len(dn), len(sales_order.doclist))
def test_make_delivery_note(self):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
so = frappe.copy_doc(test_records[0]).insert()
self.assertRaises(frappe.ValidationError, make_delivery_note, so.name)
sales_order = frappe.get_doc("Sales Order", so.name)
sales_order.submit()
dn = make_delivery_note(so.name)
self.assertEquals(dn.doctype, "Delivery Note")
self.assertEquals(len(dn.get("delivery_note_details")),
len(sales_order.get("sales_order_details")))
def create_delivery_note(so, setting):
if not frappe.db.get_value("Delivery Note", filters={"bcommerce_order_id": so.bcommerce_order_id})\
and so.docstatus == 1:
doc = make_delivery_note(so.name)
doc.naming_series = setting.bcommerce_naming
doc.flags.ignore_mandatory = 1
doc.bcommerce_delivery_id = 1
try:
doc.save(ignore_permissions=True)
except:
print "Error while saving Delivery note, Traceback: {0}".format(
frappe.get_traceback())
def test_make_delivery_note(self):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
so = frappe.copy_doc(test_records[0]).insert()
self.assertRaises(frappe.ValidationError, make_delivery_note,
so.name)
sales_order = frappe.get_doc("Sales Order", so.name)
sales_order.submit()
dn = make_delivery_note(so.name)
self.assertEquals(dn.doctype, "Delivery Note")
self.assertEquals(len(dn.get("delivery_note_details")), len(sales_order.get("sales_order_details")))
def make_next_doc_testcase(self, so, next_doc=None):
if so.docstatus < 1:
so.submit()
if next_doc == "Delivery Note":
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
next_doc = make_delivery_note(so.name)
if next_doc == "Sales Invoice":
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
next_doc = make_sales_invoice(so.name)
return next_doc
def _test_delivery_note_return_against_sales_order(self, item_code,
delivered_qty,
returned_qty):
self._insert_material_receipt()
from erpnext.selling.doctype.sales_order.test_sales_order import test_records as sales_order_test_records
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice, make_delivery_note
actual_qty_0 = self._get_actual_qty()
so = frappe.copy_doc(sales_order_test_records[0])
so.get("sales_order_details")[0].item_code = item_code
so.get("sales_order_details")[0].qty = 5.0
so.insert()
so.submit()
dn = make_delivery_note(so.name)
dn.status = "Draft"
dn.posting_date = so.delivery_date
dn.insert()
dn.submit()
actual_qty_1 = self._get_actual_qty()
self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1)
si = make_sales_invoice(so.name)
si.posting_date = dn.posting_date
si.debit_to = "_Test Customer - _TC"
for d in si.get("entries"):
d.income_account = "Sales - _TC"
d.cost_center = "_Test Cost Center - _TC"
si.insert()
si.submit()
# insert and submit stock entry for sales return
se = frappe.copy_doc(test_records[0])
se.purpose = "Sales Return"
se.delivery_note_no = dn.name
se.posting_date = "2013-03-10"
se.fiscal_year = "_Test Fiscal Year 2013"
se.get("mtn_details")[0].qty = se.get(
"mtn_details")[0].transfer_qty = returned_qty
se.insert()
se.submit()
actual_qty_2 = self._get_actual_qty()
self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2)
return se
def test_dn_billing_status_case2(self):
# SO -> SI and SO -> DN1, DN2
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note, make_sales_invoice
so = make_sales_order()
si = make_sales_invoice(so.name)
si.get("items")[0].qty = 5
si.insert()
si.submit()
frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1)
dn1 = make_delivery_note(so.name)
dn1.set_posting_time = 1
dn1.posting_time = "10:00"
dn1.get("items")[0].qty = 2
dn1.submit()
self.assertEqual(dn1.get("items")[0].billed_amt, 200)
self.assertEqual(dn1.per_billed, 100)
self.assertEqual(dn1.status, "To Deliver")
dn2 = make_delivery_note(so.name)
dn2.set_posting_time = 1
dn2.posting_time = "08:00"
dn2.get("items")[0].qty = 4
dn2.submit()
dn1.load_from_db()
self.assertEqual(dn1.get("items")[0].billed_amt, 100)
self.assertEqual(dn1.per_billed, 50)
self.assertEqual(dn1.status, "To Bill")
self.assertEqual(dn2.get("items")[0].billed_amt, 400)
self.assertEqual(dn2.per_billed, 100)
self.assertEqual(dn2.status, "To Deliver")
def test_dn_billing_status_case3(self):
# SO -> DN1 -> SI and SO -> SI and SO -> DN2
from erpnext.selling.doctype.sales_order.sales_order \
import make_delivery_note, make_sales_invoice as make_sales_invoice_from_so
frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1)
so = make_sales_order()
dn1 = make_delivery_note(so.name)
dn1.set_posting_time = 1
dn1.posting_time = "10:00"
dn1.get("items")[0].qty = 2
dn1.submit()
si1 = make_sales_invoice(dn1.name)
si1.submit()
dn1.load_from_db()
self.assertEqual(dn1.per_billed, 100)
si2 = make_sales_invoice_from_so(so.name)
si2.get("items")[0].qty = 4
si2.submit()
dn2 = make_delivery_note(so.name)
dn2.posting_time = "08:00"
dn2.get("items")[0].qty = 5
dn2.submit()
dn1.load_from_db()
self.assertEqual(dn1.get("items")[0].billed_amt, 200)
self.assertEqual(dn1.per_billed, 100)
self.assertEqual(dn1.status, "Completed")
self.assertEqual(dn2.get("items")[0].billed_amt, 400)
self.assertEqual(dn2.per_billed, 80)
self.assertEqual(dn2.status, "To Bill")
def sync_magento_shipments(magento_order, magento_settings):
erpnext_sales_order_name = frappe.db.get_value("Sales Order", {"magento_order_id": magento_order.get("entity_id")}, "name")
erpnext_sales_order = frappe.get_doc("Sales Order", erpnext_sales_order_name)
for shipment in get_magento_order_shipments(magento_order.get("entity_id")):
if not frappe.db.get_value("Delivery Note", {"magento_shipment_id": shipment.get("entity_id")}, "name") and erpnext_sales_order.docstatus == 1:
delivery_note = make_delivery_note(erpnext_sales_order.name)
delivery_note.magento_order_id = shipment.get("order_id")
delivery_note.magento_shipment_id = shipment.get("entity_id")
delivery_note.naming_series = magento_settings.delivery_note_series or "delivery_note-Magento-"
delivery_note.items = get_magento_shipment_items(delivery_note.items, shipment.get("items"), magento_settings)
delivery_note.flags.ignore_mandatory = True
delivery_note.save()
delivery_note.submit()
frappe.db.commit()
def make_delivery(fulfilled_items, current_order, datepaid):
#against_sales_order
# print current_order
exists_si = frappe.db.sql(
"""SELECT Count(*) FROM `tabDelivery Note` INNER JOIN
`tabDelivery Note Item`
ON `tabDelivery Note`.name=`tabDelivery Note Item`.parent
WHERE `tabDelivery Note`.docstatus =1
AND `tabDelivery Note Item`.against_sales_order=%s""",
(current_order))
# print "exists dn", exists_si, current_order
if exists_si[0][0] > 0:
return None
# print("making delivery note.")
dn = make_delivery_note(current_order)
dn.set_posting_time = 1
dn.inflow_file = current_order
# datepaid = SI_dict['DatePaid']
# if not datepaid:
# datepaid = SI_dict["OrderDate"]
# else:
# datepaid = parser.parse(datepaid)
# print " ========================== SALES RETURN ============================"
# print fulfilled_items
# remove_rows = []
# for dnr_item in dn.items:
# found = 0
# for i, item in enumerate(fulfilled_items):
# # print " ", dnr_item.item_code, item['item_code']
# if dnr_item.item_code == item['item_code']:
# found = 1
# del fulfilled_items[i]
# dnr_item.qty = item['quantity']
# if found == 0:
# remove_rows.append(dnr_item)
#
# # print remove_rows
# for i, r in enumerate(remove_rows):
# # print "removing,", r.item_code
# dn.remove(r)
dn.posting_date = datepaid.date()
dn.posting_time = str(datepaid.time())
dn.save()
dn.submit()
def create_dn(key):
dn = make_delivery_note(doc_name, skip_item_mapping=True)
dn.sales_partner = key[0]
dn.commission_rate = frappe.get_cached_value("Sales Partner", key[0],
"commission_rate")
dn.le_scheduled_datetime = key[1]
dn.le_auto_invoice = 1
for item in items_by_sales_partner[key]:
so_item = frappe.get_cached_doc("Sales Order Item",
item.get("so_detail"))
frappe.model.mapper.map_child_doc(so_item, dn, item_table_mapper)
dn.run_method("set_missing_values")
dn.run_method("set_po_nos")
dn.run_method("calculate_taxes_and_totals")
dn.insert()
return dn.name
def test_dn_billing_status_case4(self):
# SO -> SI -> DN
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note
so = make_sales_order()
si = make_sales_invoice(so.name)
si.submit()
dn = make_delivery_note(si.name)
dn.submit()
self.assertEqual(dn.get("items")[0].billed_amt, 1000)
self.assertEqual(dn.per_billed, 100)
self.assertEqual(dn.status, "Completed")
def test_dn_billing_status_case4(self):
# SO -> SI -> DN
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note
so = make_sales_order()
si = make_sales_invoice(so.name)
si.submit()
dn = make_delivery_note(si.name)
dn.submit()
self.assertEqual(dn.get("items")[0].billed_amt, 1000)
self.assertEqual(dn.per_billed, 100)
self.assertEqual(dn.status, "Completed")
def _test_delivery_note_return_against_sales_order(self, item_code, delivered_qty, returned_qty):
self._insert_material_receipt()
from erpnext.selling.doctype.sales_order.test_sales_order import test_records as sales_order_test_records
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice, make_delivery_note
actual_qty_0 = self._get_actual_qty()
so = frappe.copy_doc(sales_order_test_records[0])
so.get("sales_order_details")[0].item_code = item_code
so.get("sales_order_details")[0].qty = 5.0
so.insert()
so.submit()
dn = make_delivery_note(so.name)
dn.status = "Draft"
dn.posting_date = so.delivery_date
dn.insert()
dn.submit()
actual_qty_1 = self._get_actual_qty()
self.assertEquals(actual_qty_0 - delivered_qty, actual_qty_1)
si = make_sales_invoice(so.name)
si.posting_date = dn.posting_date
si.debit_to = "_Test Customer - _TC"
for d in si.get("entries"):
d.income_account = "Sales - _TC"
d.cost_center = "_Test Cost Center - _TC"
si.insert()
si.submit()
# insert and submit stock entry for sales return
se = frappe.copy_doc(test_records[0])
se.purpose = "Sales Return"
se.delivery_note_no = dn.name
se.posting_date = "2013-03-10"
se.fiscal_year = "_Test Fiscal Year 2013"
se.get("mtn_details")[0].qty = se.get("mtn_details")[0].transfer_qty = returned_qty
se.insert()
se.submit()
actual_qty_2 = self._get_actual_qty()
self.assertEquals(actual_qty_1 + returned_qty, actual_qty_2)
return se
def test_make_sales_invoice_from_dn_for_returned_qty(self): from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice so = make_sales_order(qty=2) so.submit() dn = make_delivery_note(so.name) dn.submit() dn1 = create_delivery_note(is_return=1, return_against=dn.name, qty=-1, do_not_submit=True) dn1.items[0].against_sales_order = so.name dn1.items[0].so_detail = so.items[0].name dn1.submit() si = make_sales_invoice(dn.name) self.assertEquals(si.items[0].qty, 1)
def test_make_sales_invoice_from_dn_for_returned_qty(self): from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice so = make_sales_order(qty=2) so.submit() dn = make_delivery_note(so.name) dn.submit() dn1 = create_delivery_note(is_return=1, return_against=dn.name, qty=-1, do_not_submit=True) dn1.items[0].against_sales_order = so.name dn1.items[0].so_detail = so.items[0].name dn1.submit() si = make_sales_invoice(dn.name) self.assertEquals(si.items[0].qty, 1)
def create_delivery_note(woocommerce_order, woocommerce_settings, so):
for fulfillment in woocommerce_order.get("fulfillments"):
if (not frappe.db.get_value(
"Delivery Note",
{"woocommerce_fulfillment_id": fulfillment.get("id")},
"name",
) and so.docstatus == 1):
dn = make_delivery_note(so.name)
dn.woocommerce_order_id = fulfillment.get("order_id")
dn.woocommerce_fulfillment_id = fulfillment.get("id")
dn.naming_series = (woocommerce_settings.delivery_note_series
or "DN-woocommerce-")
dn.items = get_fulfillment_items(dn.items,
fulfillment.get("line_items"),
woocommerce_settings)
dn.flags.ignore_mandatory = True
dn.save()
frappe.db.commit()
def test_block_delivery_note_against_cancelled_sales_order(self):
from erpnext.stock.doctype.delivery_note.test_delivery_note import _insert_purchase_receipt
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
sales_order = frappe.copy_doc(test_records[0])
sales_order.items[0].qty = 5
sales_order.insert()
sales_order.submit()
_insert_purchase_receipt(sales_order.get("items")[0].item_code)
delivery_note = make_delivery_note(sales_order.name)
delivery_note.posting_date = sales_order.transaction_date
delivery_note.insert()
sales_order.cancel()
self.assertRaises(frappe.CancelledLinkError, delivery_note.submit)
def test_block_delivery_note_against_cancelled_sales_order(self):
from erpnext.stock.doctype.delivery_note.test_delivery_note import _insert_purchase_receipt
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
sales_order = frappe.copy_doc(test_records[0])
sales_order.sales_order_details[0].qty = 5
sales_order.insert()
sales_order.submit()
_insert_purchase_receipt(sales_order.get("sales_order_details")[0].item_code)
delivery_note = make_delivery_note(sales_order.name)
delivery_note.posting_date = sales_order.transaction_date
delivery_note.insert()
sales_order.cancel()
self.assertRaises(frappe.CancelledLinkError, delivery_note.submit)
def deliver(so_item_names, receiver, signature, comments):
data = json.loads(so_item_names) if (so_item_names) else {}
parent_sales_orders = []
to_be_removed = []
actual_data_ids = []
print('dkdaskkkkk')
for s_item_name in data:
for so in frappe.db.sql(
"""Select parent from `tabSales Order Item` where name=%s""",
(s_item_name['id'])):
parent_sales_orders.append(so[0])
actual_data_ids.append(s_item_name['id'])
delivery_note_names = []
for so in list(set(parent_sales_orders)):
print(so)
print('ssssssoooooooooo')
dn = make_delivery_note(so)
print(dn.items)
for item in dn.items:
print(item.so_detail)
# print(item.so_detail not in actual_data_ids)
# print(actual_data_ids)
if item.so_detail not in actual_data_ids:
to_be_removed.append(item)
for i in to_be_removed:
dn.items.remove(i)
for item in dn.items:
for qty in data:
if qty['id'] in item.so_detail:
item.qty = qty['qty']
dn.it_receiver_name = receiver
dn.docstatus = 1
dn.it_signature = signature
dn.it_comments = comments
dn.save()
delivery_note_names.append(dn.name)
print(delivery_note_names)
print('dddddddd')
return delivery_note_names
def make_delivery_note(current_date):
# make purchase requests
# make delivery notes (if possible)
if can_make("Delivery Note"):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="'Total'"]))[:how_many("Delivery Note")]:
dn = frappe.get_doc(make_delivery_note(so))
dn.posting_date = current_date
for d in dn.get("items"):
if not d.expense_account:
d.expense_account = "Cost of Goods Sold - {}".format(settings.company_abbr)
dn.insert()
try:
dn.submit()
frappe.db.commit()
except (NegativeStockError, SerialNoRequiredError, SerialNoQtyError):
frappe.db.rollback()
def run_stock(current_date):
# make purchase requests
if can_make("Purchase Receipt"):
from erpnext.buying.doctype.purchase_order.purchase_order import make_purchase_receipt
from erpnext.stock.stock_ledger import NegativeStockError
report = "Purchase Order Items To Be Received"
for po in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Purchase Receipt")]:
pr = frappe.get_doc(make_purchase_receipt(po))
pr.posting_date = current_date
pr.fiscal_year = cstr(current_date.year)
pr.insert()
try:
pr.submit()
frappe.db.commit()
except NegativeStockError: pass
# make delivery notes (if possible)
if can_make("Delivery Note"):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
from erpnext.stock.stock_ledger import NegativeStockError
from erpnext.stock.doctype.serial_no.serial_no import SerialNoRequiredError, SerialNoQtyError
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Delivery Note")]:
dn = frappe.get_doc(make_delivery_note(so))
dn.posting_date = current_date
dn.fiscal_year = cstr(current_date.year)
for d in dn.get("delivery_note_details"):
if not d.expense_account:
d.expense_account = "Cost of Goods Sold - {}".format(company_abbr)
dn.insert()
try:
dn.submit()
frappe.db.commit()
except NegativeStockError: pass
except SerialNoRequiredError: pass
except SerialNoQtyError: pass
# try submitting existing
for dn in frappe.db.get_values("Delivery Note", {"docstatus": 0}, "name"):
b = frappe.get_doc("Delivery Note", dn[0])
b.submit()
frappe.db.commit()
def make_delivery_note(current_date):
# make purchase requests
# make delivery notes (if possible)
if can_make("Delivery Note"):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="'Total'"]))[:how_many("Delivery Note")]:
dn = frappe.get_doc(make_delivery_note(so))
dn.posting_date = current_date
dn.fiscal_year = cstr(current_date.year)
for d in dn.get("items"):
if not d.expense_account:
d.expense_account = "Cost of Goods Sold - {}".format(settings.company_abbr)
dn.insert()
try:
dn.submit()
frappe.db.commit()
except (NegativeStockError, SerialNoRequiredError, SerialNoQtyError):
frappe.db.rollback()
def create_delivery_note(shopify_order, shopify_settings, so):
if not cint(shopify_settings.sync_delivery_note):
return
for fulfillment in shopify_order.get("fulfillments"):
if not frappe.db.get_value("Delivery Note", {"shopify_fulfillment_id": fulfillment.get("id")}, "name")\
and so.docstatus==1:
dn = make_delivery_note(so.name)
dn.shopify_order_id = fulfillment.get("order_id")
dn.shopify_order_number = shopify_order.get("name")
dn.set_posting_time = 1
dn.posting_date = getdate(fulfillment.get("created_at"))
dn.shopify_fulfillment_id = fulfillment.get("id")
dn.naming_series = shopify_settings.delivery_note_series or "DN-Shopify-"
dn.items = get_fulfillment_items(dn.items, fulfillment.get("line_items"), shopify_settings)
dn.flags.ignore_mandatory = True
dn.save()
dn.submit()
frappe.db.commit()
def test_newly_mapped_doc_packed_items(self):
"Test impact on packed items in newly mapped DN from SO."
so_items = []
for qty in [2, 4]:
so_items.append({
"item_code": self.bundle,
"qty": qty,
"rate": 400,
"warehouse": "_Test Warehouse - _TC"
})
# create SO with recurring bundle item
so = make_sales_order(item_list=so_items)
dn = make_delivery_note(so.name)
dn.items[1].qty = 3 # change second row qty for inserting doc
dn.save()
self.assertEqual(len(dn.packed_items), 4)
self.assertEqual(dn.packed_items[2].qty, 6)
self.assertEqual(dn.packed_items[3].qty, 6)
def make_delivery_note():
# make purchase requests
# make delivery notes (if possible)
if random.random() < 0.3:
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="'Total'"]))[:random.randint(1, 3)]:
dn = frappe.get_doc(make_delivery_note(so))
dn.posting_date = frappe.flags.current_date
for d in dn.get("items"):
if not d.expense_account:
d.expense_account = ("Cost of Goods Sold - {0}".format(
frappe.db.get_value('Company', dn.company, 'abbr')))
dn.insert()
try:
dn.submit()
frappe.db.commit()
except (NegativeStockError, SerialNoRequiredError, SerialNoQtyError):
frappe.db.rollback()
def make_delivery_note():
# make purchase requests
# make delivery notes (if possible)
if random.random() < 0.3:
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="'Total'"]))[:random.randint(1, 3)]:
dn = frappe.get_doc(make_delivery_note(so))
dn.posting_date = frappe.flags.current_date
for d in dn.get("items"):
if not d.expense_account:
d.expense_account = ("Cost of Goods Sold - {0}".format(
frappe.db.get_value('Company', dn.company, 'abbr')))
dn.insert()
try:
dn.submit()
frappe.db.commit()
except (NegativeStockError, SerialNoRequiredError, SerialNoQtyError):
frappe.db.rollback()
def test_create_quotation_with_margin(self):
from erpnext.selling.doctype.quotation.quotation import make_sales_order
from erpnext.selling.doctype.sales_order.sales_order import (
make_delivery_note,
make_sales_invoice,
)
rate_with_margin = flt((1500*18.75)/100 + 1500)
test_records[0]['items'][0]['price_list_rate'] = 1500
test_records[0]['items'][0]['margin_type'] = 'Percentage'
test_records[0]['items'][0]['margin_rate_or_amount'] = 18.75
quotation = frappe.copy_doc(test_records[0])
quotation.transaction_date = nowdate()
quotation.valid_till = add_months(quotation.transaction_date, 1)
quotation.insert()
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
self.assertRaises(frappe.ValidationError, make_sales_order, quotation.name)
quotation.submit()
sales_order = make_sales_order(quotation.name)
sales_order.naming_series = "_T-Quotation-"
sales_order.transaction_date = "2016-01-01"
sales_order.delivery_date = "2016-01-02"
sales_order.insert()
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
sales_order.submit()
dn = make_delivery_note(sales_order.name)
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
dn.save()
si = make_sales_invoice(sales_order.name)
self.assertEqual(quotation.get("items")[0].rate, rate_with_margin)
si.save()
def test_reposting_packed_items(self):
warehouse = "Stores - TCP1"
company = "_Test Company with perpetual inventory"
today = nowdate()
yesterday = add_to_date(today, days=-1, as_string=True)
for item in self.bundle_items:
make_stock_entry(item_code=item,
to_warehouse=warehouse,
qty=10,
rate=100,
posting_date=today)
so = make_sales_order(item_code=self.bundle,
qty=1,
company=company,
warehouse=warehouse)
dn = make_delivery_note(so.name)
dn.save()
dn.submit()
gles = get_gl_entries(dn.doctype, dn.name)
credit_before_repost = sum(gle.credit for gle in gles)
# backdated stock entry
for item in self.bundle_items:
make_stock_entry(item_code=item,
to_warehouse=warehouse,
qty=10,
rate=200,
posting_date=yesterday)
# assert correct reposting
gles = get_gl_entries(dn.doctype, dn.name)
credit_after_reposting = sum(gle.credit for gle in gles)
self.assertNotEqual(credit_before_repost, credit_after_reposting)
self.assertAlmostEqual(credit_after_reposting,
2 * credit_before_repost)
def run_stock(current_date):
# make purchase requests
if can_make("Purchase Receipt"):
from erpnext.buying.doctype.purchase_order.purchase_order import make_purchase_receipt
from erpnext.stock.stock_ledger import NegativeStockError
report = "Purchase Order Items To Be Received"
for po in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Purchase Receipt")]:
pr = webnotes.bean(make_purchase_receipt(po))
pr.doc.posting_date = current_date
pr.doc.fiscal_year = cstr(current_date.year)
pr.insert()
try:
pr.submit()
webnotes.conn.commit()
except NegativeStockError: pass
# make delivery notes (if possible)
if can_make("Delivery Note"):
from erpnext.selling.doctype.sales_order.sales_order import make_delivery_note
from erpnext.stock.stock_ledger import NegativeStockError
from erpnext.stock.doctype.serial_no.serial_no import SerialNoRequiredError, SerialNoQtyError
report = "Ordered Items To Be Delivered"
for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:how_many("Delivery Note")]:
dn = webnotes.bean(make_delivery_note(so))
dn.doc.posting_date = current_date
dn.doc.fiscal_year = cstr(current_date.year)
dn.insert()
try:
dn.submit()
webnotes.conn.commit()
except NegativeStockError: pass
except SerialNoRequiredError: pass
except SerialNoQtyError: pass
# try submitting existing
for dn in webnotes.conn.get_values("Delivery Note", {"docstatus": 0}, "name"):
b = webnotes.bean("Delivery Note", dn[0])
b.submit()
webnotes.conn.commit()
def test_returning_partial_bundles(self):
from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_return
item_list = [
{
"item_code": self.bundle,
"warehouse": self.warehouse,
"qty": 1,
"rate": 100,
},
{
"item_code": self.bundle2,
"warehouse": self.warehouse,
"qty": 1,
"rate": 100,
},
]
so = make_sales_order(item_list=item_list, warehouse=self.warehouse)
dn = make_delivery_note(so.name)
dn.save()
dn.submit()
# create return
dn_ret = make_sales_return(dn.name)
# remove bundle 2
dn_ret.items.pop()
dn_ret.save()
dn_ret.submit()
dn_ret.reload()
self.assertTrue(
all(d.parent_item == self.bundle for d in dn_ret.packed_items))
expected_returns = [
d for d in dn.packed_items if d.parent_item == self.bundle
]
self.assertReturns(expected_returns, dn_ret.packed_items)
def test_returning_partial_bundle_qty(self):
from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_return
so = make_sales_order(item_code=self.bundle,
warehouse=self.warehouse,
qty=2)
dn = make_delivery_note(so.name)
dn.save()
dn.submit()
# create return
dn_ret = make_sales_return(dn.name)
# halve the qty
dn_ret.items[0].qty = -1
dn_ret.save()
dn_ret.submit()
expected_returns = dn.packed_items
for d in expected_returns:
d.qty /= 2
self.assertReturns(expected_returns, dn_ret.packed_items)
def test_dn_billing_status_case4(self):
# SO -> SI -> DN
from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
so = make_sales_order()
si = make_sales_invoice(so.name)
si.submit()
# Testing if Customer's Purchase Order No was rightly copied
self.assertEqual(so.po_no, si.po_no)
dn = make_delivery_note(si.name)
dn.submit()
# Testing if Customer's Purchase Order No was rightly copied
self.assertEqual(dn.po_no, si.po_no)
self.assertEqual(dn.get("items")[0].billed_amt, 1000)
self.assertEqual(dn.per_billed, 100)
self.assertEqual(dn.status, "Completed")
def create_muliple_delivery_notes(orders):
orders = json.loads(orders)
created_orders = []
for order in orders:
created = False
customer = frappe.db.get_value("Sales Order", order, "customer")
# check if a Delivery Note already exists against the order
delivery_notes = frappe.get_all("Delivery Note",
filters=[
["Delivery Note", "docstatus", "<", 2],
["Delivery Note Item", "against_sales_order", "=", order]
],
distinct=True)
delivery_notes = [item.name for item in delivery_notes if item.name]
# if none are found, then create a new Pick List
if not delivery_notes:
order_doc = make_delivery_note(order)
# if no items can be picked, do not create an empty Pick List
if order_doc.get("items"):
order_doc.save()
delivery_notes = [order_doc.name]
created = True
else:
delivery_notes = []
created_orders.append({
"sales_order": order,
"customer": customer,
"delivery_notes": delivery_notes,
"created": created
})
return created_orders
def test_returned_qty_in_return_dn(self):
# SO ---> SI ---> DN
# |
# |---> DN(Partial Sales Return) ---> SI(Credit Note)
# |
# |---> DN(Partial Sales Return) ---> SI(Credit Note)
from erpnext.accounts.doctype.sales_invoice.sales_invoice import make_delivery_note
from erpnext.selling.doctype.sales_order.sales_order import make_sales_invoice
so = make_sales_order(qty=10)
si = make_sales_invoice(so.name)
si.insert()
si.submit()
dn = make_delivery_note(si.name)
dn.insert()
dn.submit()
self.assertEqual(dn.items[0].returned_qty, 0)
self.assertEqual(dn.per_billed, 100)
from erpnext.stock.doctype.delivery_note.delivery_note import make_sales_invoice
dn1 = create_delivery_note(is_return=1, return_against=dn.name, qty=-3)
si1 = make_sales_invoice(dn1.name)
si1.insert()
si1.submit()
dn1.reload()
self.assertEqual(dn1.items[0].returned_qty, 0)
self.assertEqual(dn1.per_billed, 100)
dn2 = create_delivery_note(is_return=1, return_against=dn.name, qty=-4)
si2 = make_sales_invoice(dn2.name)
si2.insert()
si2.submit()
dn2.reload()
self.assertEqual(dn2.items[0].returned_qty, 0)
self.assertEqual(dn2.per_billed, 100)
def test_serial_no_based_delivery(self):
frappe.set_value("Stock Settings", None, "automatically_set_serial_nos_based_on_fifo", 1)
from erpnext.stock.doctype.item.test_item import make_item
item = make_item("_Reserved_Serialized_Item", {"is_stock_item": 1,
"maintain_stock": 1,
"has_serial_no": 1,
"serial_no_series": "SI.####",
"valuation_rate": 500,
"item_defaults": [
{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
frappe.db.sql("""delete from `tabSerial No` where item_code=%s""", (item.item_code))
make_item("_Test Item A", {"maintain_stock": 1,
"valuation_rate": 100,
"item_defaults": [
{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
make_item("_Test Item B", {"maintain_stock": 1,
"valuation_rate": 200,
"item_defaults": [
{
"default_warehouse": "_Test Warehouse - _TC",
"company": "_Test Company"
}]
})
from erpnext.manufacturing.doctype.production_plan.test_production_plan import make_bom
make_bom(item=item.item_code, rate=1000,
raw_materials = ['_Test Item A', '_Test Item B'])
so = make_sales_order(**{
"item_list": [{
"item_code": item.item_code,
"ensure_delivery_based_on_produced_serial_no": 1,
"qty": 1,
"rate":1000
}]
})
so.submit()
from erpnext.manufacturing.doctype.work_order.test_work_order import \
make_wo_order_test_record
work_order = make_wo_order_test_record(item=item.item_code,
qty=1, do_not_save=True)
work_order.fg_warehouse = "_Test Warehouse - _TC"
work_order.sales_order = so.name
work_order.submit()
make_stock_entry(item_code=item.item_code, target="_Test Warehouse - _TC", qty=1)
item_serial_no = frappe.get_doc("Serial No", {"item_code": item.item_code})
from erpnext.manufacturing.doctype.work_order.work_order import \
make_stock_entry as make_production_stock_entry
se = frappe.get_doc(make_production_stock_entry(work_order.name, "Manufacture", 1))
se.submit()
reserved_serial_no = se.get("items")[2].serial_no
serial_no_so = frappe.get_value("Serial No", reserved_serial_no, "sales_order")
self.assertEqual(serial_no_so, so.name)
dn = make_delivery_note(so.name)
dn.save()
self.assertEqual(reserved_serial_no, dn.get("items")[0].serial_no)
item_line = dn.get("items")[0]
item_line.serial_no = item_serial_no.name
self.assertRaises(frappe.ValidationError, dn.submit)
item_line = dn.get("items")[0]
item_line.serial_no = reserved_serial_no
self.assertTrue(dn.submit)
dn.load_from_db()
dn.cancel()
si = make_sales_invoice(so.name)
si.update_stock = 1
si.save()
self.assertEqual(si.get("items")[0].serial_no, reserved_serial_no)
item_line = si.get("items")[0]
item_line.serial_no = item_serial_no.name
self.assertRaises(frappe.ValidationError, dn.submit)
item_line = si.get("items")[0]
item_line.serial_no = reserved_serial_no
self.assertTrue(si.submit)
si.submit()
si.load_from_db()
si.cancel()
si = make_sales_invoice(so.name)
si.update_stock = 0
si.submit()
from erpnext.accounts.doctype.sales_invoice.sales_invoice import \
make_delivery_note as make_delivery_note_from_invoice
dn = make_delivery_note_from_invoice(si.name)
dn.save()
dn.submit()
self.assertEqual(dn.get("items")[0].serial_no, reserved_serial_no)
dn.load_from_db()
dn.cancel()
si.load_from_db()
si.cancel()
se.load_from_db()
se.cancel()
self.assertFalse(frappe.db.exists("Serial No", {"sales_order": so.name}))
def run_stock(current_date): make_purchase_receipt(current_date) make_delivery_note(current_date) make_stock_reconciliation(current_date) submit_draft_stock_entries(current_date)
