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 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 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 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 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}
)
