def hourly_reminder(): fields = ["from_time", "to_time"] projects = get_projects_for_collect_progress("Hourly", fields) for project in projects: if (get_time(nowtime()) >= get_time(project.from_time) or get_time(nowtime()) <= get_time(project.to_time)): send_project_update_email_to_users(project.name)
def make_stock_transfer(self, out_list): se = frappe.new_doc('Stock Entry') se.naming_series = get_series("Stock Entry") se.purpose_type = 'Material Out' se.purpose = 'Material Issue' se.branch = frappe.db.get_value('User', frappe.session.user, 'branch') se.posting_date = nowdate() se.posting_time = nowtime().split('.')[0] for item in out_list: frappe.errprint(item) fab_details = get_fabric_details(item[2]) sed = se.append('mtn_details', {}) sed.invoice_no = item[0] sed.s_warehouse = get_warehouse(item[4]) sed.target_branch = get_branch(item[5]) sed.item_code = item[2] sed.item_name = fab_details.get('item_name') sed.description = fab_details.get('description') sed.qty = cint(item[3]) sed.stock_uom = fab_details.get('stock_uom') sed.uom = fab_details.get('stock_uom') sed.conversion_factor = 1 sed.incoming_rate = 0.0 sed.transfet_qty = cint(item[3]) * 1 se.save()
def test_delivery_note_no_gl_entry(self): set_perpetual_inventory(0) self.assertEqual(cint(frappe.defaults.get_global_default("auto_accounting_for_stock")), 0) make_stock_entry(target="_Test Warehouse - _TC", qty=5, basic_rate=100) stock_queue = json.loads( get_previous_sle( { "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC", "posting_date": nowdate(), "posting_time": nowtime(), } ).stock_queue or "[]" ) dn = create_delivery_note() sle = frappe.get_doc("Stock Ledger Entry", {"voucher_type": "Delivery Note", "voucher_no": dn.name}) self.assertEqual(sle.stock_value_difference, -1 * stock_queue[0][1]) self.assertFalse(get_gl_entries("Delivery Note", dn.name))
def create_delivery_note(**args): dn = frappe.new_doc("Delivery Note") args = frappe._dict(args) dn.posting_date = args.posting_date or nowdate() dn.posting_time = args.posting_time or nowtime() dn.set_posting_time = 1 dn.company = args.company or "_Test Company" dn.customer = args.customer or "_Test Customer" dn.currency = args.currency or "INR" dn.is_return = args.is_return dn.return_against = args.return_against dn.append("items", { "item_code": args.item or args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty or 1, "rate": args.rate if args.get("rate") is not None else 100, "conversion_factor": 1.0, "allow_zero_valuation_rate": args.allow_zero_valuation_rate or 1, "expense_account": args.expense_account or "Cost of Goods Sold - _TC", "cost_center": args.cost_center or "_Test Cost Center - _TC", "serial_no": args.serial_no, "target_warehouse": args.target_warehouse }) if not args.do_not_save: dn.insert() if not args.do_not_submit: dn.submit() return dn
def deduplicate(self): if frappe.form_dict.client == "app": # Get current time - 1 hour vars = self.as_dict() time = nowtime() time = time.split(':') time[0] = str(int(time[0]) - 1) time = ':'.join(time) # set creation time to 1 hour back from current time vars['creation'] = time voucher = frappe.db.sql( """ select name from `tabGoods Receipt` where creation >= "{creation}" and posting_date = "{posting_date}" and customer = "{customer}" and vehicle = "{vehicle}" and item_delivered = "{item_delivered}" and delivered_quantity = "{delivered_quantity}" and item_received = "{item_received}" and received_quantity = "{received_quantity}" """.format(**vars), as_dict=True ) if voucher: frappe.throw( "Entry OK. Challan Number {}".format(voucher[0].name))
def create_delivery_note(**args): dn = frappe.new_doc("Delivery Note") args = frappe._dict(args) dn.posting_date = args.posting_date or nowdate() dn.posting_time = args.posting_time or nowtime() dn.set_posting_time = 1 dn.company = args.company or "_Test Company" dn.customer = args.customer or "_Test Customer" dn.currency = args.currency or "INR" dn.is_return = args.is_return dn.return_against = args.return_against dn.append("items", { "item_code": args.item or args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty or 1, "rate": args.rate or 100, "conversion_factor": 1.0, "expense_account": "Cost of Goods Sold - _TC", "cost_center": args.cost_center or "_Test Cost Center - _TC", "serial_no": args.serial_no, "target_warehouse": args.target_warehouse }) if not args.do_not_save: dn.insert() if not args.do_not_submit: dn.submit() return dn
def test_repack_no_change_in_valuation(self): set_perpetual_inventory(0) make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) make_stock_entry( item_code="_Test Item Home Desktop 100", target="_Test Warehouse - _TC", qty=50, basic_rate=100 ) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.insert() repack.submit() self.check_stock_ledger_entries( "Stock Entry", repack.name, [ ["_Test Item", "_Test Warehouse - _TC", -50.0], ["_Test Item Home Desktop 100", "_Test Warehouse - _TC", 1], ], ) gl_entries = frappe.db.sql( """select account, debit, credit from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s order by account desc""", repack.name, as_dict=1, ) self.assertFalse(gl_entries) set_perpetual_inventory(0)
def get_stock_balance_for(item_code, warehouse, posting_date=None, posting_time=None, batch_no=None, with_valuation_rate= True): # frappe.has_permission("Stock Reconciliation", "write", throw = True) if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() item_dict = frappe.db.get_value("Item", item_code, ["has_serial_no", "has_batch_no"], as_dict=1) serial_nos = "" with_serial_no = True if item_dict.get("has_serial_no") else False data = get_stock_balance(item_code, warehouse, posting_date, posting_time, with_valuation_rate=with_valuation_rate, with_serial_no=with_serial_no) if with_serial_no: qty, rate, serial_nos = data else: qty, rate = data if item_dict.get("has_batch_no"): qty = get_batch_qty(batch_no, warehouse) or 0 return { 'qty': qty, 'rate': rate, 'serial_nos': serial_nos }
def test_get_items(self): create_warehouse( "_Test Warehouse Group 1", { "is_group": 1, "company": "_Test Company", "parent_warehouse": "All Warehouses - _TC" }) create_warehouse( "_Test Warehouse Ledger 1", { "is_group": 0, "parent_warehouse": "_Test Warehouse Group 1 - _TC", "company": "_Test Company" }) create_item("_Test Stock Reco Item", is_stock_item=1, valuation_rate=100, warehouse="_Test Warehouse Ledger 1 - _TC", opening_stock=100) items = get_items("_Test Warehouse Group 1 - _TC", nowdate(), nowtime(), "_Test Company") self.assertEqual( ["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100], [items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def make_stock_transfer(proc_warehouse, warehouse, fabric, qty): fab_details = get_fabric_details(fabric) se = frappe.new_doc('Stock Entry') se.naming_series = get_series("Stock Entry") se.purpose_type = 'Material Out' se.purpose = 'Material Issue' se.branch = frappe.db.get_value('User', frappe.session.use, 'branch') se.posting_date = nowdate() se.posting_time = nowtime().split('.')[0] sed = se.append('mtn_details', {}) sed.s_warehouse = get_warehouse(warehouse) sed.target_branch = proc_warehouse sed.item_code = fabric sed.item_name = fab_details.get('item_name') sed.description = fab_details.get('description') sed.qty = qty sed.stock_uom = fab_details.get('stock_uom') sed.uom = fab_details.get('stock_uom') sed.conversion_factor = 1 sed.incoming_rate = 0.0 sed.transfet_qty = qty * 1 se.save()
def create_stock_reconciliation(**args): args = frappe._dict(args) sr = frappe.new_doc("Stock Reconciliation") sr.purpose = args.purpose or "Stock Reconciliation" sr.posting_date = args.posting_date or nowdate() sr.posting_time = args.posting_time or nowtime() sr.set_posting_time = 1 sr.company = args.company or "_Test Company" sr.expense_account = args.expense_account or \ ("Stock Adjustment - _TC" if frappe.get_all("Stock Ledger Entry") else "Temporary Opening - _TC") sr.cost_center = args.cost_center \ or frappe.get_cached_value("Company", sr.company, "cost_center") \ or "_Test Cost Center - _TC" sr.append("items", { "item_code": args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty, "valuation_rate": args.rate, "serial_no": args.serial_no, "batch_no": args.batch_no }) try: if not args.do_not_submit: sr.submit() except EmptyStockReconciliationItemsError: pass return sr
def scheduled_sync(): f2g_settings = frappe.get_doc('Furniture To Go Settings') if f2g_settings.auto_sync: scheduled_times = f2g_settings.sync_frequency if scheduled_times: for scheduled_time in scheduled_times: start_time = datetime.datetime.strptime( scheduled_time.time, '%H:%M:%S') end_time = start_time + datetime.timedelta(hours=1) end_time = end_time.time() if (get_time(nowtime()) >= get_time(start_time) and get_time(nowtime()) <= get_time(end_time)): # scheduled_f2g_sync() frappe.enqueue( 'erpnext_furniture_to_go.erpnext_furniture_to_go.doctype.furniture_to_go_settings.furniture_to_go_methods.scheduled_f2g_sync', timeout=7200)
def get_stock_qty(item_code, warehouse): return get_previous_sle({ "item_code": item_code, "warehouse": warehouse, "posting_date": nowdate(), "posting_time": nowtime() }).get("qty_after_transaction") or 0
def get_stock_qty(item_code, warehouse): return (get_previous_sle({ "item_code": item_code, "warehouse": warehouse, "posting_date": nowdate(), "posting_time": nowtime(), }).get("qty_after_transaction") or 0)
def get_stock_qty(item_code, warehouse): return get_previous_sle({ 'item_code': item_code, 'warehouse': warehouse, 'posting_date': nowdate(), 'posting_time': nowtime() }).get('qty_after_transaction') or 0
def test_delivery_note_no_gl_entry(self): company = frappe.db.get_value('Warehouse', '_Test Warehouse - _TC', 'company') set_perpetual_inventory(0, company) make_stock_entry(target="_Test Warehouse - _TC", qty=5, basic_rate=100) stock_queue = json.loads( get_previous_sle({ "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC", "posting_date": nowdate(), "posting_time": nowtime() }).stock_queue or "[]") dn = create_delivery_note() sle = frappe.get_doc("Stock Ledger Entry", { "voucher_type": "Delivery Note", "voucher_no": dn.name }) self.assertEqual(sle.stock_value_difference, flt(-1 * stock_queue[0][1], 2)) self.assertFalse(get_gl_entries("Delivery Note", dn.name))
def get_stock_balance(item_code, warehouse, posting_date=None, posting_time=None, with_valuation_rate=False): """Returns stock balance quantity at given warehouse on given posting date or current date. If `with_valuation_rate` is True, will return tuple (qty, rate)""" from erpnext.stock.stock_ledger import get_previous_sle if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() last_entry = get_previous_sle({ "item_code": item_code, "warehouse": warehouse, "posting_date": posting_date, "posting_time": posting_time }) if with_valuation_rate: return (last_entry.qty_after_transaction, last_entry.valuation_rate) if last_entry else (0.0, 0.0) else: return last_entry.qty_after_transaction if last_entry else 0.0
def test_repack_no_change_in_valuation(self): company = frappe.db.get_value('Warehouse', '_Test Warehouse - _TC', 'company') set_perpetual_inventory(0, company) make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) make_stock_entry(item_code="_Test Item Home Desktop 100", target="_Test Warehouse - _TC", qty=50, basic_rate=100) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.insert() repack.submit() self.check_stock_ledger_entries( "Stock Entry", repack.name, [["_Test Item", "_Test Warehouse - _TC", -50.0], ["_Test Item Home Desktop 100", "_Test Warehouse - _TC", 1]]) gl_entries = frappe.db.sql("""select account, debit, credit from `tabGL Entry` where voucher_type='Stock Entry' and voucher_no=%s order by account desc""", repack.name, as_dict=1) self.assertFalse(gl_entries) set_perpetual_inventory(0, repack.company)
def test_repack_with_change_in_valuation(self): set_perpetual_inventory() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, incoming_rate=100) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.additional_operating_cost = 1000.0 repack.insert() repack.submit() stock_in_hand_account = frappe.db.get_value("Account", {"account_type": "Warehouse", "warehouse": repack.get("items")[1].t_warehouse}) rm_stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item"}, "stock_value_difference")) fg_stock_value_diff = abs(frappe.db.get_value("Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item Home Desktop 100"}, "stock_value_difference")) stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2) self.check_gl_entries("Stock Entry", repack.name, sorted([ [stock_in_hand_account, stock_value_diff, 0.0], ["Stock Adjustment - _TC", 0.0, stock_value_diff], ]) ) set_perpetual_inventory(0)
def test_delivery_note_no_gl_entry(self): set_perpetual_inventory(0) self.assertEqual( cint( frappe.defaults.get_global_default( "auto_accounting_for_stock")), 0) make_stock_entry(target="_Test Warehouse - _TC", qty=5, basic_rate=100) stock_queue = json.loads( get_previous_sle({ "item_code": "_Test Item", "warehouse": "_Test Warehouse - _TC", "posting_date": nowdate(), "posting_time": nowtime() }).stock_queue or "[]") dn = create_delivery_note() sle = frappe.get_doc("Stock Ledger Entry", { "voucher_type": "Delivery Note", "voucher_no": dn.name }) self.assertEqual(sle.stock_value_difference, -1 * stock_queue[0][1]) self.assertFalse(get_gl_entries("Delivery Note", dn.name))
def get_new_doc(doctype, parent_doc=None, parentfield=None): doc = frappe.get_doc({ "doctype": doctype, "__islocal": 1, "owner": frappe.session.user, "docstatus": 0 }) restrictions = frappe.defaults.get_restrictions() if parent_doc: doc.parent = parent_doc.name doc.parenttype = parent_doc.doctype if parentfield: doc.parentfield = parentfield defaults = frappe.defaults.get_defaults() for d in doc.meta.get("fields"): default = defaults.get(d.fieldname) if (d.fieldtype=="Link") and d.ignore_restrictions != 1 and (d.options in restrictions)\ and len(restrictions[d.options])==1: doc.set(d.fieldname, restrictions[d.options][0]) elif default: doc.set(d.fieldname, default) elif d.get("default"): if d.default == "__user": doc.set(d.fieldname, frappe.session.user) elif d.default == "Today": doc.set(d.fieldname, nowdate()) elif d.default.startswith(":"): ref_doctype = d.default[1:] ref_fieldname = ref_doctype.lower().replace(" ", "_") if parent_doc: ref_docname = parent_doc.get(ref_fieldname) else: ref_docname = frappe.db.get_default(ref_fieldname) doc.set( d.fieldname, frappe.db.get_value(ref_doctype, ref_docname, d.fieldname)) else: doc.set(d.fieldname, d.default) # convert type of default if d.fieldtype in ("Int", "Check"): doc.set(d.fieldname, cint(doc.get(d.fieldname))) elif d.fieldtype in ("Float", "Currency"): doc.set(d.fieldname, flt(doc.get(d.fieldname))) elif d.fieldtype == "Time": doc.set(d.fieldname, nowtime()) elif (d.fieldtype == "Select" and d.options and d.options != "[Select]"): doc.set(d.fieldname, d.options.split("\n")[0]) return doc
def send_project_update_email_to_users(project): doc = frappe.get_doc('Project', project) if is_holiday_today(doc.holiday_list) or not doc.users: return project_update = frappe.get_doc({ "doctype": "Project Update", "project": project, "sent": 0, "date": today(), "time": nowtime(), "naming_series": "UPDATE-.project.-.YY.MM.DD.-", }).insert() subject = "For project %s, update your status" % (project) incoming_email_account = frappe.db.get_value( 'Email Account', dict(enable_incoming=1, default_incoming=1), 'email_id') frappe.sendmail(recipients=get_users_email(doc), message=doc.message, subject=_(subject), reference_doctype=project_update.doctype, reference_name=project_update.name, reply_to=incoming_email_account)
def upsert_profile(user, pwd, groups, roles): """ Creates or updates user profile. """ result = None profile = frappe.db.sql("select name from tabUser where username = '******'" % user['username']) if not profile: d = frappe.new_doc("User") d.owner = "Administrator" d.email = user['mail'] d.username = user['username'] d.first_name = user['first_name'] d.last_name = user['last_name'] d.enabled = 1 d.new_password = pwd d.creation = nowdate() + ' ' + nowtime() d.user_type = "System User" d.save(ignore_permissions=True) result = "insert" else: frappe.db.sql( "update tabUser set email='%s', first_name='%s', last_name='%s' where username='******'" % (user['mail'], user['first_name'], user['last_name'], user['username'])) result = "update" # update user's roles, as they might have changed from last login update_roles(user, get_role_list(roles)) update_user_permissions(user, groups) return result
def on_session_creation(login_manager): """make feed""" if frappe.session['user'] != 'Guest': # create feed make_feed('Login', 'User', login_manager.user, login_manager.user, '%s logged in at %s' % (get_user_fullname(login_manager.user), nowtime()), login_manager.user=='Administrator' and '#8CA2B3' or '#1B750D')
def send_project_update_email_to_users(project): doc = frappe.get_doc('Project', project) if is_holiday_today(doc.holiday_list) or not doc.users: return project_update = frappe.get_doc({ "doctype" : "Project Update", "project" : project, "sent": 0, "date": today(), "time": nowtime(), "naming_series": "UPDATE-.project.-.YY.MM.DD.-", }).insert() subject = "For project %s, update your status" % (project) incoming_email_account = frappe.db.get_value('Email Account', dict(enable_incoming=1, default_incoming=1), 'email_id') frappe.sendmail(recipients=get_users_email(doc), message=doc.message, subject=_(subject), reference_doctype=project_update.doctype, reference_name=project_update.name, reply_to=incoming_email_account )
def test_conversion_factor_change(self): frappe.db.set_value("Stock Settings", None, "allow_negative_stock", 1) repack_entry = frappe.copy_doc(test_records[3]) repack_entry.posting_date = nowdate() repack_entry.posting_time = nowtime() repack_entry.set_stock_entry_type() repack_entry.insert() # check current uom and conversion factor self.assertTrue(repack_entry.items[0].uom, "_Test UOM") self.assertTrue(repack_entry.items[0].conversion_factor, 1) # change conversion factor repack_entry.items[0].uom = "_Test UOM 1" repack_entry.items[0].stock_uom = "_Test UOM 1" repack_entry.items[0].conversion_factor = 2 repack_entry.save() repack_entry.submit() self.assertEqual(repack_entry.items[0].conversion_factor, 2) self.assertEqual(repack_entry.items[0].uom, "_Test UOM 1") self.assertEqual(repack_entry.items[0].qty, 50) self.assertEqual(repack_entry.items[0].transfer_qty, 100) frappe.db.set_default("allow_negative_stock", 0)
def get_stock_balance(item_code, warehouse, posting_date=None, posting_time=None, with_valuation_rate=False, with_serial_no=False): """Returns stock balance quantity at given warehouse on given posting date or current date. If `with_valuation_rate` is True, will return tuple (qty, rate)""" from erpnext.stock.stock_ledger import get_previous_sle if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() args = { "item_code": item_code, "warehouse":warehouse, "posting_date": posting_date, "posting_time": posting_time } last_entry = get_previous_sle(args) if with_valuation_rate: if with_serial_no: serial_nos = last_entry.get("serial_no") if (serial_nos and len(get_serial_nos_data(serial_nos)) < last_entry.qty_after_transaction): serial_nos = get_serial_nos_data_after_transactions(args) return ((last_entry.qty_after_transaction, last_entry.valuation_rate, serial_nos) if last_entry else (0.0, 0.0, 0.0)) else: return (last_entry.qty_after_transaction, last_entry.valuation_rate) if last_entry else (0.0, 0.0) else: return last_entry.qty_after_transaction if last_entry else 0.0
def set_stock_balance_as_per_serial_no(item_code=None, posting_date=None, posting_time=None, fiscal_year=None): if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() condition = " and item.name='%s'" % item_code.replace("'", "\'") if item_code else "" bin = frappe.db.sql("""select bin.item_code, bin.warehouse, bin.actual_qty, item.stock_uom from `tabBin` bin, tabItem item where bin.item_code = item.name and item.has_serial_no = 1 %s""" % condition) for d in bin: serial_nos = frappe.db.sql("""select count(name) from `tabSerial No` where item_code=%s and warehouse=%s and docstatus < 2""", (d[0], d[1])) if serial_nos and flt(serial_nos[0][0]) != flt(d[2]): print d[0], d[1], d[2], serial_nos[0][0] sle = frappe.db.sql("""select valuation_rate, company from `tabStock Ledger Entry` where item_code = %s and warehouse = %s and ifnull(is_cancelled, 'No') = 'No' order by posting_date desc limit 1""", (d[0], d[1])) sle_dict = { 'doctype' : 'Stock Ledger Entry', 'item_code' : d[0], 'warehouse' : d[1], 'transaction_date' : nowdate(), 'posting_date' : posting_date, 'posting_time' : posting_time, 'voucher_type' : 'Stock Reconciliation (Manual)', 'voucher_no' : '', 'voucher_detail_no' : '', 'actual_qty' : flt(serial_nos[0][0]) - flt(d[2]), 'stock_uom' : d[3], 'incoming_rate' : sle and flt(serial_nos[0][0]) > flt(d[2]) and flt(sle[0][0]) or 0, 'company' : sle and cstr(sle[0][1]) or 0, 'is_cancelled' : 'No', 'batch_no' : '', 'serial_no' : '' } sle_doc = frappe.get_doc(sle_dict) sle_doc.flags.ignore_validate = True sle_doc.flags.ignore_links = True sle_doc.insert() args = sle_dict.copy() args.update({ "sle_id": sle_doc.name, "is_amended": 'No' }) update_bin(args) update_entries_after({ "item_code": d[0], "warehouse": d[1], "posting_date": posting_date, "posting_time": posting_time })
def set_stock_balance_as_per_serial_no(item_code=None, posting_date=None, posting_time=None, fiscal_year=None): if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() condition = " and item.name='%s'" % item_code.replace("'", "\'") if item_code else "" bin = frappe.db.sql("""select bin.item_code, bin.warehouse, bin.actual_qty, item.stock_uom from `tabBin` bin, tabItem item where bin.item_code = item.name and item.has_serial_no = 1 %s""" % condition) for d in bin: serial_nos = frappe.db.sql("""select count(name) from `tabSerial No` where item_code=%s and warehouse=%s and docstatus < 2""", (d[0], d[1])) if serial_nos and flt(serial_nos[0][0]) != flt(d[2]): print(d[0], d[1], d[2], serial_nos[0][0]) sle = frappe.db.sql("""select valuation_rate, company from `tabStock Ledger Entry` where item_code = %s and warehouse = %s and ifnull(is_cancelled, 'No') = 'No' order by posting_date desc limit 1""", (d[0], d[1])) sle_dict = { 'doctype' : 'Stock Ledger Entry', 'item_code' : d[0], 'warehouse' : d[1], 'transaction_date' : nowdate(), 'posting_date' : posting_date, 'posting_time' : posting_time, 'voucher_type' : 'Stock Reconciliation (Manual)', 'voucher_no' : '', 'voucher_detail_no' : '', 'actual_qty' : flt(serial_nos[0][0]) - flt(d[2]), 'stock_uom' : d[3], 'incoming_rate' : sle and flt(serial_nos[0][0]) > flt(d[2]) and flt(sle[0][0]) or 0, 'company' : sle and cstr(sle[0][1]) or 0, 'is_cancelled' : 'No', 'batch_no' : '', 'serial_no' : '' } sle_doc = frappe.get_doc(sle_dict) sle_doc.flags.ignore_validate = True sle_doc.flags.ignore_links = True sle_doc.insert() args = sle_dict.copy() args.update({ "sle_id": sle_doc.name, "is_amended": 'No' }) update_bin(args) update_entries_after({ "item_code": d[0], "warehouse": d[1], "posting_date": posting_date, "posting_time": posting_time })
def create_delivery_note_from_LRPT(LRPT_doc, patient_encounter_doc): if not patient_encounter_doc.appointment: return insurance_subscription, insurance_company = frappe.get_value( "Patient Appointment", patient_encounter_doc.appointment, ["insurance_subscription", "insurance_company"]) if not insurance_subscription: return warehouse = get_warehouse_from_service_unit( patient_encounter_doc.healthcare_service_unit) items = [] item = get_item_form_LRPT(LRPT_doc) item_code = item.get("item_code") if not item_code: return is_stock, item_name = frappe.get_value("Item", item_code, ["is_stock_item", "item_name"]) if is_stock: return item_row = frappe.new_doc("Delivery Note Item") item_row.item_code = item_code item_row.item_name = item_name item_row.warehouse = warehouse item_row.healthcare_service_unit = item.healthcare_service_unit item_row.practitioner = patient_encounter_doc.practitioner item_row.qty = item.qty item_row.rate = get_item_rate(item_code, patient_encounter_doc.company, insurance_subscription, insurance_company) item_row.reference_doctype = LRPT_doc.doctype item_row.reference_name = LRPT_doc.name item_row.description = frappe.get_value("Item", item_code, "description") items.append(item_row) if len(items) == 0: return doc = frappe.get_doc( dict(doctype="Delivery Note", posting_date=nowdate(), posting_time=nowtime(), set_warehouse=warehouse, company=patient_encounter_doc.company, customer=frappe.get_value("Healthcare Insurance Company", insurance_company, "customer"), currency=frappe.get_value("Company", patient_encounter_doc.company, "default_currency"), items=items, reference_doctype=LRPT_doc.doctype, reference_name=LRPT_doc.name, patient=patient_encounter_doc.patient, patient_name=patient_encounter_doc.patient_name)) doc.flags.ignore_permissions = True # doc.set_missing_values() doc.insert(ignore_permissions=True) doc.submit() if doc.get('name'): frappe.msgprint(_('Delivery Note {0} created successfully.').format( frappe.bold(doc.name)), alert=True)
def get_new_doc(doctype, parent_doc = None, parentfield = None): doc = frappe.get_doc({ "doctype": doctype, "__islocal": 1, "owner": frappe.session.user, "docstatus": 0 }) restrictions = frappe.defaults.get_restrictions() if parent_doc: doc.parent = parent_doc.name doc.parenttype = parent_doc.doctype if parentfield: doc.parentfield = parentfield defaults = frappe.defaults.get_defaults() for d in doc.meta.get("fields"): default = defaults.get(d.fieldname) if (d.fieldtype=="Link") and d.ignore_restrictions != 1 and (d.options in restrictions)\ and len(restrictions[d.options])==1: doc.set(d.fieldname, restrictions[d.options][0]) elif default: doc.set(d.fieldname, default) elif d.get("default"): if d.default == "__user": doc.set(d.fieldname, frappe.session.user) elif d.default == "Today": doc.set(d.fieldname, nowdate()) elif d.default.startswith(":"): ref_doctype = d.default[1:] ref_fieldname = ref_doctype.lower().replace(" ", "_") if parent_doc: ref_docname = parent_doc.get(ref_fieldname) else: ref_docname = frappe.db.get_default(ref_fieldname) doc.set(d.fieldname, frappe.db.get_value(ref_doctype, ref_docname, d.fieldname)) else: doc.set(d.fieldname, d.default) # convert type of default if d.fieldtype in ("Int", "Check"): doc.set(d.fieldname, cint(doc.get(d.fieldname))) elif d.fieldtype in ("Float", "Currency"): doc.set(d.fieldname, flt(doc.get(d.fieldname))) elif d.fieldtype == "Time": doc.set(d.fieldname, nowtime()) elif (d.fieldtype == "Select" and d.options and not d.options.startswith("link:") and d.options != "[Select]"): doc.set(d.fieldname, d.options.split("\n")[0]) return doc
def set_incoming_rate_selling(self): if self.doctype not in ("Delivery Note", "Sales Invoice", "Sales Order"): return items = self.get("items") + (self.get("packed_items") or []) for d in items: if not self.get("return_against"): # Get incoming rate based on original item cost based on valuation method qty = flt(d.get('stock_qty') or d.get('actual_qty')) d.incoming_rate = get_incoming_rate( { "item_code": d.item_code, "warehouse": d.warehouse, "posting_date": self.get('posting_date') or self.get('transaction_date'), "posting_time": self.get('posting_time') or nowtime(), "qty": qty if cint(self.get("is_return")) else (-1 * qty), "serial_no": d.get('serial_no'), "company": self.company, "voucher_type": self.doctype, "voucher_no": self.name, "allow_zero_valuation": d.get("allow_zero_valuation"), "batch_no": d.get('batch_no') #FinByz Changes }, raise_error_if_no_rate=False) # For internal transfers use incoming rate as the valuation rate if self.is_internal_transfer(): rate = flt(d.incoming_rate * d.conversion_factor, d.precision('rate')) if d.rate != rate: d.rate = rate d.discount_percentage = 0 d.discount_amount = 0 frappe.msgprint(_( "Row {0}: Item rate has been updated as per valuation rate since its an internal stock transfer" ).format(d.idx), alert=1) elif self.get("return_against"): # Get incoming rate of return entry from reference document # based on original item cost as per valuation method d.incoming_rate = get_rate_for_return(self.doctype, self.name, d.item_code, self.return_against, item_row=d)
def get_default_value(df, defaults, user_permissions, parent_doc): # 1 - look in user permissions user_permissions_exist = (df.fieldtype == "Link" and not getattr(df, "ignore_user_permissions", False) and df.options in (user_permissions or [])) if user_permissions_exist and len(user_permissions[df.options]) == 1: return user_permissions[df.options][0] # 2 - Look in user defaults user_default = defaults.get(df.fieldname) is_allowed_user_default = user_default and ( not user_permissions_exist or (user_default in user_permissions.get(df.options, []))) # is this user default also allowed as per user permissions? if is_allowed_user_default: return user_default # 3 - look in default of docfield if df.get("default"): if df.default == "__user": return frappe.session.user elif df.default == "Today": return nowdate() elif df.default.startswith(":"): # default value based on another document ref_doctype = df.default[1:] ref_fieldname = ref_doctype.lower().replace(" ", "_") ref_docname = parent_doc.get( ref_fieldname) if parent_doc else frappe.db.get_default( ref_fieldname) default_value = frappe.db.get_value(ref_doctype, ref_docname, df.fieldname) is_allowed_default_value = (not user_permissions_exist or (default_value in user_permissions.get( df.options, []))) # is this allowed as per user permissions if is_allowed_default_value: return default_value # a static default value is_allowed_default_value = (not user_permissions_exist or (df.default in user_permissions.get( df.options, []))) if is_allowed_default_value: return df.default elif df.fieldtype == "Time": return nowtime() elif (df.fieldtype == "Select" and df.options and df.options != "[Select]"): return df.options.split("\n")[0]
def on_session_creation(login_manager): """make feed""" if frappe.session['user'] != 'Guest': # create feed make_feed( 'Login', 'User', login_manager.user, login_manager.user, '%s logged in at %s' % (get_user_fullname(login_manager.user), nowtime()), login_manager.user == 'Administrator' and '#8CA2B3' or '#1B750D')
def get_qty_after_transaction(**args): args = frappe._dict(args) last_sle = get_previous_sle({ "item_code": args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "posting_date": args.posting_date or nowdate(), "posting_time": args.posting_time or nowtime() }) return flt(last_sle.get("qty_after_transaction"))
def before_insert(doc, method): if doc.default_strength: doc.append( "dosage_strength", { "strength": abs(doc.default_strength), "strength_time": nowtime() }, )
def test_repack_with_additional_costs(self): company = frappe.db.get_value('Warehouse', '_Test Warehouse - _TC', 'company') set_perpetual_inventory(1, company) make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.set("additional_costs", [ { "description": "Actual Oerating Cost", "amount": 1000 }, { "description": "additional operating costs", "amount": 200 }, ]) repack.set_stock_entry_type() repack.insert() repack.submit() stock_in_hand_account = get_inventory_account( repack.company, repack.get("items")[1].t_warehouse) rm_stock_value_diff = abs( frappe.db.get_value( "Stock Ledger Entry", { "voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item" }, "stock_value_difference")) fg_stock_value_diff = abs( frappe.db.get_value( "Stock Ledger Entry", { "voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item Home Desktop 100" }, "stock_value_difference")) stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2) self.assertEqual(stock_value_diff, 1200) self.check_gl_entries( "Stock Entry", repack.name, sorted([[stock_in_hand_account, 1200, 0.0], ["Expenses Included In Valuation - _TC", 0.0, 1200.0]])) set_perpetual_inventory(0, repack.company)
def test_stock_reco_for_batch_item(self): set_perpetual_inventory() to_delete_records = [] to_delete_serial_nos = [] # Add new serial nos item_code = "Stock-Reco-batch-Item-1" warehouse = "_Test Warehouse for Stock Reco2 - _TC" sr = create_stock_reconciliation(item_code=item_code, warehouse=warehouse, qty=5, rate=200, do_not_submit=1) sr.save(ignore_permissions=True) sr.submit() self.assertTrue(sr.items[0].batch_no) to_delete_records.append(sr.name) sr1 = create_stock_reconciliation(item_code=item_code, warehouse=warehouse, qty=6, rate=300, batch_no=sr.items[0].batch_no) args = { "item_code": item_code, "warehouse": warehouse, "posting_date": nowdate(), "posting_time": nowtime(), } valuation_rate = get_incoming_rate(args) self.assertEqual(valuation_rate, 300) to_delete_records.append(sr1.name) sr2 = create_stock_reconciliation(item_code=item_code, warehouse=warehouse, qty=0, rate=0, batch_no=sr.items[0].batch_no) stock_value = get_stock_value_on(warehouse, nowdate(), item_code) self.assertEqual(stock_value, 0) to_delete_records.append(sr2.name) to_delete_records.reverse() for d in to_delete_records: stock_doc = frappe.get_doc("Stock Reconciliation", d) stock_doc.cancel() frappe.delete_doc("Batch", sr.items[0].batch_no) for d in to_delete_records: frappe.delete_doc("Stock Reconciliation", d)
def test_get_items(self): create_warehouse("_Test Warehouse Group 1", {"is_group": 1}) create_warehouse("_Test Warehouse Ledger 1", {"is_group": 0, "parent_warehouse": "_Test Warehouse Group 1 - _TC"}) make_item("_Test Stock Reco Item", {"default_warehouse": "_Test Warehouse Ledger 1 - _TC", "is_stock_item": 1, "opening_stock": 100, "valuation_rate": 100}) items = get_items("_Test Warehouse Group 1 - _TC", nowdate(), nowtime()) self.assertEqual(["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100], [items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def before_save(doc, method): if not doc.pb_posting_time: doc.pb_posting_time = nowtime() for ref in doc.references: if not ref.pb_invoice_date: date_field = ("transaction_date" if ref.reference_doctype == "Sales Order" else "posting_date") ref.pb_invoice_date = frappe.db.get_value(ref.reference_doctype, ref.reference_name, date_field)
def create_profile(usr, name): d = frappe.new_doc("User") d.owner = "Administrator" d.email = user d.first_name = user_id d.enabled = 1 d.new_password = pwd d.creation = nowdate() + ' ' + nowtime() d.user_type = "System User" d.save(ignore_permissions=True)
def allow_to_make_project_update(project, time, frequency): data = frappe.db.sql(""" SELECT name from `tabProject Update` WHERE project = %s and date = %s """, (project, today())) # len(data) > 1 condition is checked for twicely frequency if data and (frequency in ['Daily', 'Weekly'] or len(data) > 1): return False if get_time(nowtime()) >= get_time(time): return True
def test_get_items(self): create_warehouse("_Test Warehouse Group 1", {"is_group": 1}) create_warehouse("_Test Warehouse Ledger 1", {"is_group": 0, "parent_warehouse": "_Test Warehouse Group 1 - _TC"}) create_item("_Test Stock Reco Item", is_stock_item=1, valuation_rate=100, warehouse="_Test Warehouse Ledger 1 - _TC", opening_stock=100) items = get_items("_Test Warehouse Group 1 - _TC", nowdate(), nowtime(), "_Test Company") self.assertEqual(["_Test Stock Reco Item", "_Test Warehouse Ledger 1 - _TC", 100], [items[0]["item_code"], items[0]["warehouse"], items[0]["qty"]])
def get_default_value(df, defaults, user_permissions, parent_doc): user_permissions_exist = (df.fieldtype=="Link" and not getattr(df, "ignore_user_permissions", False) and df.options in (user_permissions or [])) # don't set defaults for "User" link field using User Permissions! if df.fieldtype == "Link" and df.options != "User": # 1 - look in user permissions if user_permissions_exist and len(user_permissions[df.options])==1: return user_permissions[df.options][0] # 2 - Look in user defaults user_default = defaults.get(df.fieldname) is_allowed_user_default = user_default and (not user_permissions_exist or (user_default in user_permissions.get(df.options, []))) # is this user default also allowed as per user permissions? if is_allowed_user_default: return user_default # 3 - look in default of docfield if df.get("default"): if df.default == "__user": return frappe.session.user elif df.default == "Today": return nowdate() elif df.default.startswith(":"): # default value based on another document ref_doctype = df.default[1:] ref_fieldname = ref_doctype.lower().replace(" ", "_") ref_docname = parent_doc.get(ref_fieldname) if parent_doc else frappe.db.get_default(ref_fieldname) default_value = frappe.db.get_value(ref_doctype, ref_docname, df.fieldname) is_allowed_default_value = (not user_permissions_exist or (default_value in user_permissions.get(df.options, []))) # is this allowed as per user permissions if is_allowed_default_value: return default_value # a static default value is_allowed_default_value = (not user_permissions_exist or (df.default in user_permissions.get(df.options, []))) if df.fieldtype!="Link" or df.options=="User" or is_allowed_default_value: return df.default elif df.fieldtype == "Time": return nowtime() elif (df.fieldtype == "Select" and df.options and df.options not in ("[Select]", "Loading...")): return df.options.split("\n")[0]
def log_response(docname, response=None): """ update the response for the request """ log = frappe.get_doc("API Log", docname) log.response_time = nowtime() log.response_date = nowdate() res = json.loads(response) log.request_status = "Success" if res.get("code") == 200 else "Failed" log.response = json.dumps(res, indent=2) log.save(ignore_permissions=True) frappe.db.commit()
def test_repack_with_additional_costs(self): set_perpetual_inventory() make_stock_entry(item_code="_Test Item", target="_Test Warehouse - _TC", qty=50, basic_rate=100) repack = frappe.copy_doc(test_records[3]) repack.posting_date = nowdate() repack.posting_time = nowtime() repack.set( "additional_costs", [ {"description": "Actual Oerating Cost", "amount": 1000}, {"description": "additional operating costs", "amount": 200}, ], ) repack.insert() repack.submit() stock_in_hand_account = frappe.db.get_value( "Account", {"account_type": "Warehouse", "warehouse": repack.get("items")[1].t_warehouse} ) rm_stock_value_diff = abs( frappe.db.get_value( "Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item"}, "stock_value_difference", ) ) fg_stock_value_diff = abs( frappe.db.get_value( "Stock Ledger Entry", {"voucher_type": "Stock Entry", "voucher_no": repack.name, "item_code": "_Test Item Home Desktop 100"}, "stock_value_difference", ) ) stock_value_diff = flt(fg_stock_value_diff - rm_stock_value_diff, 2) self.assertEqual(stock_value_diff, 1200) self.check_gl_entries( "Stock Entry", repack.name, sorted([[stock_in_hand_account, 1200, 0.0], ["Expenses Included In Valuation - _TC", 0.0, 1200.0]]), ) set_perpetual_inventory(0)
def log_request(request, form_dict): """ Create new request log """ log = frappe.new_doc("API Log") log.request_date = nowdate() log.request_time = nowtime() log.request_method = request.method log.request_url = request.url log.request_body = json.dumps(json.loads(form_dict.data), indent=2) \ if form_dict and form_dict.data else json.dumps(form_dict, indent=2) log.owner = frappe.session.user log.save(ignore_permissions=True) return log.name
def check_profile(user, user_id, pwd, role): "check for profile, if not exist creates new profile" profile = frappe.db.sql("select name from tabUser where name = %s",user) if not profile: # from webnotes.model.doc import Document from frappe.utils import nowdate, nowtime d = frappe.new_doc("User") d.owner = "Administrator" d.email = user d.first_name = user_id d.enabled = 1 d.new_password = pwd d.creation = nowdate() + ' ' + nowtime() d.user_type = "System User" d.save(ignore_permissions=True) assign_role(user, user_id, role)
def create_stock_reconciliation(**args): args = frappe._dict(args) sr = frappe.new_doc("Stock Reconciliation") sr.posting_date = args.posting_date or nowdate() sr.posting_time = args.posting_time or nowtime() sr.company = args.company or "_Test Company" sr.fiscal_year = get_fiscal_year(sr.posting_date)[0] sr.expense_account = args.expense_account or "Stock Adjustment - _TC" sr.cost_center = args.cost_center or "_Test Cost Center - _TC" sr.append("items", { "item_code": args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty, "valuation_rate": args.rate }) sr.insert() sr.submit() return sr
def create_sales_return_invoice(sales_return, device, sales_invoice): """ make sales return """ from frappe.utils import nowdate, nowtime from erpnext.controllers.sales_and_purchase_return import make_return_doc bill_no = sales_return.get("strBillNumber") try: doc = make_return_doc("Sales Invoice", sales_invoice, target_doc=None) # doc.posting_date = sales_return.get("date") doc.posting_date = nowdate() doc.posting_time = nowtime() items_to_return = { item.get("strProductCode"):item for item in sales_return.get("products") } to_remove = [] for item in doc.items: # update item qty, rate and removed items that are not in sales return if item.item_code not in items_to_return.keys(): to_remove.append(item) else: item.qty = items_to_return.get(item.item_code).get("strQty") * -1 item.rate = items_to_return.get(item.item_code).get("dblMRP") if to_remove: [doc.remove(item) for item in to_remove] doc.owner = frappe.session.user doc.submit() return { bill_no: { "invStatus": 200, "message": "Sales Return Created", "strInvoiceDate": doc.creation, "strERPBillNumber": doc.name } } except Exception, e: return { bill_no: { "invStatus": 500, "message": "Error while creating Invoice", "errors": e.message } }
def get_stock_balance(item_code, warehouse, posting_date=None, posting_time=None, with_valuation_rate=False): """Returns stock balance quantity at given warehouse on given posting date or current date. If `with_valuation_rate` is True, will return tuple (qty, rate)""" from erpnext.stock.stock_ledger import get_previous_sle if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() last_entry = get_previous_sle({ "item_code": item_code, "warehouse":warehouse, "posting_date": posting_date, "posting_time": posting_time }) if with_valuation_rate: return (last_entry.qty_after_transaction, last_entry.valuation_rate) if last_entry else (0.0, 0.0) else: return last_entry.qty_after_transaction or 0.0
def check_profile(user, user_id, pwd, role,enabled_profiles=[]): "check for profile, if not exist creates new profile" profile = frappe.db.sql("select name from tabUser where name = %s",user) #Make session user as Admin to create share doc entry frappe.session.user = '******' if not profile: from frappe.utils import nowdate, nowtime d = frappe.new_doc("User") d.owner = "Administrator" d.email = user d.first_name = user_id d.enabled = 1 d.new_password = pwd d.creation = nowdate() + ' ' + nowtime() d.user_type = "System User" d.save(ignore_permissions=True) enabled_profiles.append(user_id) assign_role(user, user_id, role)
def create_stock_reconciliation(**args): args = frappe._dict(args) sr = frappe.new_doc("Stock Reconciliation") sr.posting_date = args.posting_date or nowdate() sr.posting_time = args.posting_time or nowtime() sr.company = args.company or "_Test Company" sr.expense_account = args.expense_account or \ ("Stock Adjustment - _TC" if frappe.get_all("Stock Ledger Entry") else "Temporary Opening - _TC") sr.cost_center = args.cost_center or "_Test Cost Center - _TC" sr.append("items", { "item_code": args.item_code or "_Test Item", "warehouse": args.warehouse or "_Test Warehouse - _TC", "qty": args.qty, "valuation_rate": args.rate }) try: sr.submit() except EmptyStockReconciliationItemsError: pass return sr
def set_dynamic_default_values(doc, parent_doc, parentfield): # these values should not be cached user_permissions = get_user_permissions() for df in frappe.get_meta(doc["doctype"]).get("fields"): if df.get("default"): if df.default.startswith(":"): default_value = get_default_based_on_another_field(df, user_permissions, parent_doc) if default_value is not None and not doc.get(df.fieldname): doc[df.fieldname] = default_value elif df.fieldtype == "Datetime" and df.default.lower() == "now": doc[df.fieldname] = now_datetime() if df.fieldtype == "Time": doc[df.fieldname] = nowtime() if parent_doc: doc["parent"] = parent_doc.name doc["parenttype"] = parent_doc.doctype if parentfield: doc["parentfield"] = parentfield
def set_stock_balance_as_per_serial_no(item_code=None, posting_date=None, posting_time=None, fiscal_year=None): if not posting_date: posting_date = nowdate() if not posting_time: posting_time = nowtime() if not fiscal_year: fiscal_year = get_fiscal_year(posting_date)[0] condition = " and item.name='%s'" % item_code.replace("'", "'") if item_code else "" bin = frappe.db.sql( """select bin.item_code, bin.warehouse, bin.actual_qty, item.stock_uom from `tabBin` bin, tabItem item where bin.item_code = item.name and item.has_serial_no = 'Yes' %s""" % condition ) for d in bin: serial_nos = frappe.db.sql( """select count(name) from `tabSerial No` where item_code=%s and warehouse=%s and status = 'Available' and docstatus < 2""", (d[0], d[1]), ) if serial_nos and flt(serial_nos[0][0]) != flt(d[2]): print d[0], d[1], d[2], serial_nos[0][0] sle = frappe.db.sql( """select valuation_rate, company from `tabStock Ledger Entry` where item_code = %s and warehouse = %s and ifnull(is_cancelled, 'No') = 'No' order by posting_date desc limit 1""", (d[0], d[1]), ) sle_dict = { "doctype": "Stock Ledger Entry", "item_code": d[0], "warehouse": d[1], "transaction_date": nowdate(), "posting_date": posting_date, "posting_time": posting_time, "voucher_type": "Stock Reconciliation (Manual)", "voucher_no": "", "voucher_detail_no": "", "actual_qty": flt(serial_nos[0][0]) - flt(d[2]), "stock_uom": d[3], "incoming_rate": sle and flt(serial_nos[0][0]) > flt(d[2]) and flt(sle[0][0]) or 0, "company": sle and cstr(sle[0][1]) or 0, "fiscal_year": fiscal_year, "is_cancelled": "No", "batch_no": "", "serial_no": "", } sle_doc = frappe.get_doc(sle_dict) sle_doc.insert() args = sle_dict.copy() args.update({"sle_id": sle_doc.name, "is_amended": "No"}) update_bin(args) update_entries_after( {"item_code": d[0], "warehouse": d[1], "posting_date": posting_date, "posting_time": posting_time} )