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)