def test_update_child_qty_rate(self): so = make_sales_order(item_code="_Test Item", qty=4) create_dn_against_so(so.name, 4) make_sales_invoice(so.name) existing_reserved_qty = get_reserved_qty() trans_item = json.dumps([{ 'item_code': '_Test Item', 'rate': 200, 'qty': 7, 'docname': so.items[0].name }]) update_child_qty_rate('Sales Order', trans_item, so.name) so.reload() self.assertEqual(so.get("items")[0].rate, 200) self.assertEqual(so.get("items")[0].qty, 7) self.assertEqual(so.get("items")[0].amount, 1400) self.assertEqual(so.status, 'To Deliver and Bill') self.assertEqual(get_reserved_qty(), existing_reserved_qty + 3) trans_item = json.dumps([{ 'item_code': '_Test Item', 'rate': 200, 'qty': 2, 'docname': so.items[0].name }]) self.assertRaises(dataent.ValidationError, update_child_qty_rate, 'Sales Order', trans_item, so.name)
def test_make_sales_invoice_with_terms(self): so = make_sales_order(do_not_submit=True) self.assertRaises(dataent.ValidationError, make_sales_invoice, so.name) so.update({"payment_terms_template": "_Test Payment Term Template"}) so.save() so.submit() si = make_sales_invoice(so.name) self.assertEqual(len(si.get("items")), len(so.get("items"))) self.assertEqual(len(si.get("items")), 1) si.insert() self.assertEqual(si.payment_schedule[0].payment_amount, 500.0) self.assertEqual(si.payment_schedule[0].due_date, so.transaction_date) self.assertEqual(si.payment_schedule[1].payment_amount, 500.0) self.assertEqual(si.payment_schedule[1].due_date, add_days(so.transaction_date, 30)) si.submit() si1 = make_sales_invoice(so.name) self.assertEqual(len(si1.get("items")), 0)
def test_update_qty(self): so = make_sales_order() create_dn_against_so(so.name, 6) so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 6) # Check delivered_qty after make_sales_invoice without update_stock checked si1 = make_sales_invoice(so.name) si1.get("items")[0].qty = 6 si1.insert() si1.submit() so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 6) # Check delivered_qty after make_sales_invoice with update_stock checked si2 = make_sales_invoice(so.name) si2.set("update_stock", 1) si2.get("items")[0].qty = 3 si2.insert() si2.submit() so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 9)
def test_make_sales_invoice(self): so = make_sales_order(do_not_submit=True) self.assertRaises(dataent.ValidationError, make_sales_invoice, so.name) so.submit() si = make_sales_invoice(so.name) self.assertEqual(len(si.get("items")), len(so.get("items"))) self.assertEqual(len(si.get("items")), 1) si.insert() si.submit() si1 = make_sales_invoice(so.name) self.assertEqual(len(si1.get("items")), 0)
def test_reserved_qty_for_over_delivery_via_sales_invoice(self): make_stock_entry(target="_Test Warehouse - _TC", qty=10, rate=100) # set over-delivery tolerance dataent.db.set_value('Item', "_Test Item", 'tolerance', 50) existing_reserved_qty = get_reserved_qty() so = make_sales_order() self.assertEqual(get_reserved_qty(), existing_reserved_qty + 10) si = make_sales_invoice(so.name) si.update_stock = 1 si.get("items")[0].qty = 12 si.insert() si.submit() self.assertEqual(get_reserved_qty(), existing_reserved_qty) so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 12) self.assertEqual(so.per_delivered, 100) si.cancel() self.assertEqual(get_reserved_qty(), existing_reserved_qty + 10) so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 0) self.assertEqual(so.per_delivered, 0)
def make_invoice(self): ref_doc = dataent.get_doc(self.reference_doctype, self.reference_name) if (hasattr(ref_doc, "order_type") and getattr(ref_doc, "order_type") == "Shopping Cart"): from epaas.selling.doctype.sales_order.sales_order import make_sales_invoice si = make_sales_invoice(self.reference_name, ignore_permissions=True) si = si.insert(ignore_permissions=True) si.submit()
def test_terms_copied(self): so = make_sales_order(do_not_copy=1, do_not_save=1) so.payment_terms_template = '_Test Payment Term Template' so.insert() so.submit() self.assertTrue(so.get('payment_schedule')) si = make_sales_invoice(so.name) si.insert() self.assertTrue(si.get('payment_schedule'))
def work(): dataent.set_user(dataent.db.get_global('demo_accounts_user')) if random.random() <= 0.6: report = "Ordered Items to be Billed" for so in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:random.randint(1, 5)]: try: si = dataent.get_doc(make_sales_invoice(so)) si.posting_date = dataent.flags.current_date for d in si.get("items"): if not d.income_account: d.income_account = "Sales - {}".format(dataent.get_cached_value('Company', si.company, 'abbr')) si.insert() si.submit() dataent.db.commit() except dataent.ValidationError: pass if random.random() <= 0.6: report = "Received Items to be Billed" for pr in list(set([r[0] for r in query_report.run(report)["result"] if r[0]!="Total"]))[:random.randint(1, 5)]: try: pi = dataent.get_doc(make_purchase_invoice(pr)) pi.posting_date = dataent.flags.current_date pi.bill_no = random_string(6) pi.insert() pi.submit() dataent.db.commit() except dataent.ValidationError: pass if random.random() < 0.5: make_payment_entries("Sales Invoice", "Accounts Receivable") if random.random() < 0.5: make_payment_entries("Purchase Invoice", "Accounts Payable") if random.random() < 0.4: #make payment request against sales invoice sales_invoice_name = get_random("Sales Invoice", filters={"docstatus": 1}) if sales_invoice_name: si = dataent.get_doc("Sales Invoice", sales_invoice_name) if si.outstanding_amount > 0: payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email, submit_doc=True, mute_email=True, use_dummy_message=True) payment_entry = dataent.get_doc(make_payment_entry(payment_request.name)) payment_entry.posting_date = dataent.flags.current_date payment_entry.submit() make_pos_invoice()
def create_sales_invoice(shopify_order, shopify_settings, so): if not dataent.db.get_value("Sales Invoice", {"shopify_order_id": shopify_order.get("id")}, "name")\ and so.docstatus==1 and not so.per_billed and cint(shopify_settings.sync_sales_invoice): si = make_sales_invoice(so.name, ignore_permissions=True) si.shopify_order_id = shopify_order.get("id") si.naming_series = shopify_settings.sales_invoice_series or "SI-Shopify-" si.flags.ignore_mandatory = True set_cost_center(si.items, shopify_settings.cost_center) si.submit() make_payament_entry_against_sales_invoice(si, shopify_settings) dataent.db.commit()
def test_so_billed_amount_against_return_entry(self): from epaas.accounts.doctype.sales_invoice.sales_invoice import make_sales_return so = make_sales_order(do_not_submit=True) so.submit() si = make_sales_invoice(so.name) si.insert() si.submit() si1 = make_sales_return(si.name) si1.update_billed_amount_in_sales_order = 1 si1.submit() so.load_from_db() self.assertEquals(so.per_billed, 0)
def make_pos_invoice(): make_sales_order() for data in dataent.get_all('Sales Order', fields=["name"], filters = [["per_billed", "<", "100"]]): si = dataent.get_doc(make_sales_invoice(data.name)) si.is_pos =1 si.posting_date = dataent.flags.current_date for d in si.get("items"): if not d.income_account: d.income_account = "Sales - {}".format(dataent.get_cached_value('Company', si.company, 'abbr')) si.set_missing_values() make_payment_entries_for_pos_invoice(si) si.insert() si.submit()
def test_return_against_sales_order(self): so = make_sales_order() dn = create_dn_against_so(so.name, 6) so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 6) # Check delivered_qty after make_sales_invoice with update_stock checked si2 = make_sales_invoice(so.name) si2.set("update_stock", 1) si2.get("items")[0].qty = 3 si2.insert() si2.submit() so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 9) # Make return deliver note, sales invoice and check quantity from epaas.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from epaas.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice dn1 = create_delivery_note(is_return=1, return_against=dn.name, qty=-3, do_not_submit=True) dn1.items[0].against_sales_order = so.name dn1.items[0].so_detail = so.items[0].name dn1.submit() si1 = create_sales_invoice(is_return=1, return_against=si2.name, qty=-1, update_stock=1, do_not_submit=True) si1.items[0].sales_order = so.name si1.items[0].so_detail = so.items[0].name si1.submit() so.load_from_db() self.assertEqual(so.get("items")[0].delivered_qty, 5)
def test_create_quotation_with_margin(self): from epaas.selling.doctype.quotation.quotation import make_sales_order from epaas.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 = dataent.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(dataent.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_customer_credit_limit(self): from epaas.stock.doctype.delivery_note.test_delivery_note import create_delivery_note from epaas.accounts.doctype.sales_invoice.test_sales_invoice import create_sales_invoice from epaas.selling.doctype.sales_order.test_sales_order import make_sales_order from epaas.selling.doctype.sales_order.sales_order import make_sales_invoice outstanding_amt = self.get_customer_outstanding_amount() credit_limit = get_credit_limit('_Test Customer', '_Test Company') if outstanding_amt <= 0.0: item_qty = int((abs(outstanding_amt) + 200) / 100) make_sales_order(qty=item_qty) if credit_limit == 0.0: dataent.db.set_value("Customer", '_Test Customer', 'credit_limit', outstanding_amt - 50.0) # Sales Order so = make_sales_order(do_not_submit=True) self.assertRaises(dataent.ValidationError, so.submit) # Delivery Note dn = create_delivery_note(do_not_submit=True) self.assertRaises(dataent.ValidationError, dn.submit) # Sales Invoice si = create_sales_invoice(do_not_submit=True) self.assertRaises(dataent.ValidationError, si.submit) if credit_limit > outstanding_amt: dataent.db.set_value("Customer", '_Test Customer', 'credit_limit', credit_limit) # Makes Sales invoice from Sales Order so.save(ignore_permissions=True) si = make_sales_invoice(so.name) si.save(ignore_permissions=True) self.assertRaises(dataent.ValidationError, make_sales_order)
def test_serial_no_based_delivery(self): dataent.set_value("Stock Settings", None, "automatically_set_serial_nos_based_on_fifo", 1) from epaas.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" }] }) dataent.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 epaas.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 epaas.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 = dataent.get_doc("Serial No", {"item_code": item.item_code}) from epaas.manufacturing.doctype.work_order.work_order import \ make_stock_entry as make_production_stock_entry se = dataent.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 = dataent.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(dataent.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(dataent.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 epaas.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( dataent.db.exists("Serial No", {"sales_order": so.name}))
def test_terms_not_copied(self): so = make_sales_order() self.assertTrue(so.get('payment_schedule')) si = make_sales_invoice(so.name) self.assertFalse(si.get('payment_schedule'))