def scrap_asset(asset_name):
asset = dataent.get_doc("Asset", asset_name)
if asset.docstatus != 1:
dataent.throw(_("Asset {0} must be submitted").format(asset.name))
elif asset.status in ("Cancelled", "Sold", "Scrapped"):
dataent.throw(_("Asset {0} cannot be scrapped, as it is already {1}").format(asset.name, asset.status))
depreciation_series = dataent.get_cached_value('Company', asset.company, "series_for_depreciation_entry")
je = dataent.new_doc("Journal Entry")
je.voucher_type = "Journal Entry"
je.naming_series = depreciation_series
je.posting_date = today()
je.company = asset.company
je.remark = "Scrap Entry for asset {0}".format(asset_name)
for entry in get_gl_entries_on_asset_disposal(asset):
entry.update({
"reference_type": "Asset",
"reference_name": asset_name
})
je.append("accounts", entry)
je.flags.ignore_permissions = True
je.submit()
dataent.db.set_value("Asset", asset_name, "disposal_date", today())
dataent.db.set_value("Asset", asset_name, "journal_entry_for_scrap", je.name)
asset.set_status("Scrapped")
dataent.msgprint(_("Asset scrapped via Journal Entry {0}").format(je.name))
def test_leave_grant(self):
leave_type = "_Test Leave Type"
# create the leave policy
leave_policy = dataent.get_doc({
"doctype":
"Leave Policy",
"leave_policy_details": [{
"leave_type": leave_type,
"annual_allocation": 20
}]
}).insert()
leave_policy.submit()
# create employee and assign the leave period
employee = "*****@*****.**"
employee_doc_name = make_employee(employee)
dataent.db.set_value("Employee", employee_doc_name, "leave_policy",
leave_policy.name)
# clear the already allocated leave
dataent.db.sql(
'''delete from `tabLeave Allocation` where employee=%s''',
"*****@*****.**")
# create the leave period
leave_period = create_leave_period(add_months(today(), -3),
add_months(today(), 3))
# test leave_allocation
leave_period.grant_leave_allocation(employee=employee_doc_name)
self.assertEqual(
get_leave_balance_on(employee_doc_name, leave_type, today()), 20)
def monthly_auto_repeat(self, doctype, docname, start_date, end_date):
def get_months(start, end):
diff = (12 * end.year + end.month) - (12 * start.year +
start.month)
return diff + 1
doc = make_auto_repeat(reference_doctype=doctype,
frequency='Monthly',
reference_document=docname,
start_date=start_date,
end_date=end_date)
disable_auto_repeat(doc)
for data in get_auto_repeat_entries(today()):
create_repeated_entries(data)
docnames = dataent.get_all(doc.reference_doctype,
{'auto_repeat': doc.name})
self.assertEqual(len(docnames), 1)
doc = dataent.get_doc('Auto Repeat', doc.name)
doc.db_set('disabled', 0)
months = get_months(getdate(start_date), getdate(today()))
for data in get_auto_repeat_entries(today()):
create_repeated_entries(data)
docnames = dataent.get_all(doc.reference_doctype,
{'auto_repeat': doc.name})
self.assertEqual(len(docnames), months)
def make_auto_repeat(**args):
args = dataent._dict(args)
doc = dataent.get_doc({
'doctype':
'Auto Repeat',
'reference_doctype':
args.reference_doctype or 'ToDo',
'reference_document':
args.reference_document
or dataent.db.get_value('ToDo', {'docstatus': 1}, 'name'),
'frequency':
args.frequency or 'Daily',
'start_date':
args.start_date or add_days(today(), -1),
'end_date':
args.end_date or add_days(today(), 2),
'submit_on_creation':
args.submit_on_creation or 0,
'notify_by_email':
args.notify or 0,
'recipients':
args.recipients or "",
'subject':
args.subject or "",
'message':
args.message or ""
}).insert(ignore_permissions=True)
if not args.do_not_submit:
doc.submit()
return doc
def sync_transactions(bank, bank_account):
last_sync_date = dataent.db.get_value("Bank Account", bank_account,
"last_integration_date")
if last_sync_date:
start_date = formatdate(last_sync_date, "YYYY-MM-dd")
else:
start_date = formatdate(add_months(today(), -12), "YYYY-MM-dd")
end_date = formatdate(today(), "YYYY-MM-dd")
try:
transactions = get_transactions(bank=bank,
bank_account=bank_account,
start_date=start_date,
end_date=end_date)
result = []
if transactions:
for transaction in transactions:
result.append(new_bank_transaction(transaction))
dataent.db.set_value("Bank Account", bank_account,
"last_integration_date", getdate(end_date))
return result
except Exception:
dataent.log_error(dataent.get_traceback(),
_("Plaid transactions sync error"))
def get_loyalty_programs(doc):
''' returns applicable loyalty programs for a customer '''
from dataent.desk.treeview import get_children
lp_details = []
loyalty_programs = dataent.get_all(
"Loyalty Program",
fields=["name", "customer_group", "customer_territory"],
filters={
"auto_opt_in": 1,
"from_date": ["<=", today()],
"ifnull(to_date, '2500-01-01')": [">=", today()]
})
for loyalty_program in loyalty_programs:
customer_groups = [
d.value for d in get_children("Customer Group",
loyalty_program.customer_group)
] + [loyalty_program.customer_group]
customer_territories = [
d.value for d in get_children("Territory",
loyalty_program.customer_territory)
] + [loyalty_program.customer_territory]
if (not loyalty_program.customer_group or doc.customer_group in customer_groups)\
and (not loyalty_program.customer_territory or doc.territory in customer_territories):
lp_details.append(loyalty_program.name)
return lp_details
def test_closing_entry(self):
year_start_date = get_fiscal_year(today(), company="_Test Company")[1]
make_journal_entry("_Test Bank - _TC", "Sales - _TC", 400,
"_Test Cost Center - _TC", posting_date=now(), submit=True)
make_journal_entry("_Test Account Cost for Goods Sold - _TC",
"_Test Bank - _TC", 600, "_Test Cost Center - _TC", posting_date=now(), submit=True)
random_expense_account = dataent.db.sql("""
select t1.account,
sum(t1.debit) - sum(t1.credit) as balance,
sum(t1.debit_in_account_currency) - sum(t1.credit_in_account_currency) \
as balance_in_account_currency
from `tabGL Entry` t1, `tabAccount` t2
where t1.account = t2.name and t2.root_type = 'Expense'
and t2.docstatus < 2 and t2.company = '_Test Company'
and t1.posting_date between %s and %s
group by t1.account
having sum(t1.debit) > sum(t1.credit)
limit 1""", (year_start_date, today()), as_dict=True)
profit_or_loss = dataent.db.sql("""select sum(t1.debit) - sum(t1.credit) as balance
from `tabGL Entry` t1, `tabAccount` t2
where t1.account = t2.name and t2.report_type = 'Profit and Loss'
and t2.docstatus < 2 and t2.company = '_Test Company'
and t1.posting_date between %s and %s""", (year_start_date, today()))
profit_or_loss = flt(profit_or_loss[0][0]) if profit_or_loss else 0
pcv = self.make_period_closing_voucher()
# Check value for closing account
gle_amount_for_closing_account = dataent.db.sql("""select debit - credit
from `tabGL Entry` where voucher_type='Period Closing Voucher' and voucher_no=%s
and account = '_Test Account Reserves and Surplus - _TC'""", pcv.name)
gle_amount_for_closing_account = flt(gle_amount_for_closing_account[0][0]) \
if gle_amount_for_closing_account else 0
self.assertEqual(gle_amount_for_closing_account, profit_or_loss)
if random_expense_account:
# Check posted value for teh above random_expense_account
gle_for_random_expense_account = dataent.db.sql("""
select sum(debit - credit) as amount,
sum(debit_in_account_currency - credit_in_account_currency) as amount_in_account_currency
from `tabGL Entry`
where voucher_type='Period Closing Voucher' and voucher_no=%s and account =%s""",
(pcv.name, random_expense_account[0].account), as_dict=True)
self.assertEqual(gle_for_random_expense_account[0].amount, -1*random_expense_account[0].balance)
self.assertEqual(gle_for_random_expense_account[0].amount_in_account_currency,
-1*random_expense_account[0].balance_in_account_currency)
def make_period_closing_voucher(self):
pcv = dataent.get_doc({
"doctype": "Period Closing Voucher",
"closing_account_head": "_Test Account Reserves and Surplus - _TC",
"company": "_Test Company",
"fiscal_year": get_fiscal_year(today(), company="_Test Company")[0],
"posting_date": today(),
"cost_center": "_Test Cost Center - _TC",
"remarks": "test"
})
pcv.insert()
pcv.submit()
return pcv
def set_tax_withholding_category(company):
accounts = []
abbr = dataent.get_value("Company", company, "abbr")
tds_account = dataent.get_value("Account", 'TDS Payable - {0}'.format(abbr), 'name')
if company and tds_account:
accounts = [dict(company=company, account=tds_account)]
fiscal_year = get_fiscal_year(today(), company=company)[0]
docs = get_tds_details(accounts, fiscal_year)
for d in docs:
try:
doc = dataent.get_doc(d)
doc.flags.ignore_permissions = True
doc.flags.ignore_mandatory = True
doc.insert()
except dataent.DuplicateEntryError:
doc = dataent.get_doc("Tax Withholding Category", d.get("name"))
doc.append("accounts", accounts[0])
# if fiscal year don't match with any of the already entered data, append rate row
fy_exist = [k for k in doc.get('rates') if k.get('fiscal_year')==fiscal_year]
if not fy_exist:
doc.append("rates", d.get('rates')[0])
doc.save()
def get_data(doctype, date_field):
return dataent.db.sql(""" select name, from_date, end_date, recurring_type, recurring_id,
next_date, notify_by_email, notification_email_address, recurring_print_format,
repeat_on_day_of_month, submit_on_creation, docstatus, {0}
from `tab{1}` where is_recurring = 1 and next_date >= %s and docstatus < 2
order by next_date desc
""".format(date_field, doctype), today(), as_dict=1)
def send_project_update_email_to_users(project):
doc = dataent.get_doc('Project', project)
if is_holiday_today(doc.holiday_list) or not doc.users: return
project_update = dataent.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 = dataent.db.get_value(
'Email Account', dict(enable_incoming=1, default_incoming=1),
'email_id')
dataent.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_get_monthly_results(self):
'''Test monthly aggregation values of a field'''
result_dict = get_monthly_results('Event', 'subject', 'creation',
'event_type="Private"', 'count')
from dataent.utils import today, formatdate
self.assertEqual(result_dict[formatdate(today(), "MM-yyyy")], 2)
def get_booking_dates(doc, item, posting_date=None):
if not posting_date:
posting_date = add_days(today(), -1)
last_gl_entry = False
deferred_account = "deferred_revenue_account" if doc.doctype=="Sales Invoice" else "deferred_expense_account"
prev_gl_entry = dataent.db.sql('''
select name, posting_date from `tabGL Entry` where company=%s and account=%s and
voucher_type=%s and voucher_no=%s and voucher_detail_no=%s
order by posting_date desc limit 1
''', (doc.company, item.get(deferred_account), doc.doctype, doc.name, item.name), as_dict=True)
if prev_gl_entry:
start_date = getdate(add_days(prev_gl_entry[0].posting_date, 1))
else:
start_date = item.service_start_date
end_date = get_last_day(start_date)
if end_date >= item.service_end_date:
end_date = item.service_end_date
last_gl_entry = True
elif item.service_stop_date and end_date >= item.service_stop_date:
end_date = item.service_stop_date
last_gl_entry = True
if end_date > getdate(posting_date):
end_date = posting_date
if getdate(start_date) <= getdate(end_date):
return start_date, end_date, last_gl_entry
else:
return None, None, None
def make_course_schedule_test_record(**args):
args = dataent._dict(args)
course_schedule = dataent.new_doc("Course Schedule")
course_schedule.student_group = args.student_group or "Course-TC101-2014-2015 (_Test Academic Term)"
course_schedule.course = args.course or "TC101"
course_schedule.instructor = args.instructor or "_Test Instructor"
course_schedule.room = args.room or dataent.get_all("Room")[0].name
course_schedule.schedule_date = args.schedule_date or today()
course_schedule.from_time = args.from_time or to_timedelta("01:00:00")
course_schedule.to_time = args.to_time or course_schedule.from_time + datetime.timedelta(
hours=1)
if not args.do_not_save:
if args.simulate:
while True:
try:
course_schedule.save()
break
except OverlapError:
course_schedule.from_time = course_schedule.from_time + datetime.timedelta(
minutes=10)
course_schedule.to_time = course_schedule.from_time + datetime.timedelta(
hours=1)
else:
course_schedule.save()
return course_schedule
def make_opportunity(**args):
args = dataent._dict(args)
opp_doc = dataent.get_doc({
"doctype": "Opportunity",
"company": args.company or "_Test Company",
"opportunity_from": args.opportunity_from or "Customer",
"opportunity_type": "Sales",
"with_items": args.with_items or 0,
"transaction_date": today()
})
if opp_doc.opportunity_from == 'Customer':
opp_doc.party_name = args.customer or "_Test Customer"
if opp_doc.opportunity_from == 'Lead':
opp_doc.party_name = args.lead or "_T-Lead-00001"
if args.with_items:
opp_doc.append('items', {
"item_code": args.item_code or "_Test Item",
"qty": args.qty or 1
})
opp_doc.insert()
return opp_doc
def test_notification_is_attached(self):
todo = dataent.get_doc(
dict(doctype='ToDo',
description='Test recurring notification attachment',
assigned_by='Administrator')).insert()
doc = make_auto_repeat(
reference_document=todo.name,
notify=1,
recipients="*****@*****.**",
subject="New ToDo",
message="A new ToDo has just been created for you")
for data in get_auto_repeat_entries(today()):
create_repeated_entries(data)
dataent.db.commit()
new_todo = dataent.db.get_value('ToDo', {
'auto_repeat': doc.name,
'name': ('!=', todo.name)
}, 'name')
linked_comm = dataent.db.exists(
"Communication",
dict(reference_doctype="ToDo", reference_name=new_todo))
self.assertTrue(linked_comm)
def convert_deferred_revenue_to_income(start_date=None, end_date=None):
# book the expense/income on the last day, but it will be trigger on the 1st of month at 12:00 AM
if not start_date:
start_date = add_months(today(), -1)
if not end_date:
end_date = add_days(today(), -1)
# check for the sales invoice for which GL entries has to be done
invoices = dataent.db.sql_list('''
select distinct parent from `tabSales Invoice Item`
where service_start_date<=%s and service_end_date>=%s
and enable_deferred_revenue = 1 and docstatus = 1 and ifnull(amount, 0) > 0
''', (end_date, start_date))
for invoice in invoices:
doc = dataent.get_doc("Sales Invoice", invoice)
book_deferred_income_or_expense(doc, end_date)
def make_auto_repeat_entry(date=None):
enqueued_method = 'dataent.desk.doctype.auto_repeat.auto_repeat.create_repeated_entries'
jobs = get_jobs()
if not jobs or enqueued_method not in jobs[dataent.local.site]:
date = date or today()
for data in get_auto_repeat_entries(date):
dataent.enqueue(enqueued_method, data=data)
def test_monthly_auto_repeat(self):
start_date = today()
end_date = add_months(start_date, 12)
todo = dataent.get_doc(
dict(doctype='ToDo',
description='test recurring todo',
assigned_by='Administrator')).insert()
self.monthly_auto_repeat('ToDo', todo.name, start_date, end_date)
def post_depreciation_entries(date=None):
# Return if automatic booking of asset depreciation is disabled
if not cint(dataent.db.get_value("Accounts Settings", None, "book_asset_depreciation_entry_automatically")):
return
if not date:
date = today()
for asset in get_depreciable_assets(date):
make_depreciation_entry(asset, date)
dataent.db.commit()
def before_submit(self):
start_date_copy = self.start_date
today_copy = add_days(today(), -1)
if start_date_copy <= today_copy:
start_date_copy = today_copy
if not self.next_schedule_date:
self.next_schedule_date = get_next_schedule_date(
start_date_copy, self.frequency, self.repeat_on_day)
def test_create_training_event(self):
if not dataent.db.get_value("Training Event", "Basic Training Event"):
dataent.get_doc({
"doctype":
"Training Event",
"event_name":
"Basic Training Event",
"training_program":
"Basic Training",
"location":
"Union Square",
"start_time":
add_days(today(), 5),
"end_time":
add_days(today(), 6),
"introduction":
"Welcome to the Basic Training Event",
"employees":
get_attendees(self.employee, self.employee2)
}).insert()
def allow_to_make_project_update(project, time, frequency):
data = dataent.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 make_sales_invoice():
dataent.set_user("Administrator")
si = create_sales_invoice(company="_Test Company 2",
customer = '_Test Customer 2',
currency = 'EUR',
warehouse = 'Finished Goods - _TC2',
debit_to = 'Debtors - _TC2',
income_account = 'Sales - _TC2',
expense_account = 'Cost of Goods Sold - _TC2',
cost_center = '_Test Company 2 - _TC2',
do_not_save=1)
si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 30)), invoice_portion=30.00, payment_amount=30))
si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 60)), invoice_portion=50.00, payment_amount=50))
si.append('payment_schedule', dict(due_date=getdate(add_days(today(), 90)), invoice_portion=20.00, payment_amount=20))
si.submit()
return si.name
def stop_resume_auto_repeat(auto_repeat, status):
doc = dataent.get_doc('Auto Repeat', auto_repeat)
dataent.msgprint(_("Auto Repeat has been {0}").format(status))
if status == 'Resumed':
doc.next_schedule_date = get_next_schedule_date(
today(), doc.frequency, doc.repeat_on_day)
doc.update_status(status)
doc.save()
return doc.status
def create_sales_invoice_record(qty=1):
# return sales invoice doc object
return dataent.get_doc({
"doctype":
"Sales Invoice",
"customer":
dataent.get_doc('Customer', {
"customer_name": "Prestiga-Biz"
}).name,
"company":
'_Test Company',
"due_date":
today(),
"posting_date":
today(),
"currency":
"INR",
"taxes_and_charges":
"",
"debit_to":
"Debtors - _TC",
"taxes": [],
"items": [{
'doctype':
'Sales Invoice Item',
'item_code':
dataent.get_doc('Item', {
'item_name': 'Consulting'
}).name,
'qty':
qty,
"rate":
10000,
'income_account':
'Sales - _TC',
'cost_center':
'Main - _TC',
'expense_account':
'Cost of Goods Sold - _TC'
}]
})
def make_depreciation_entry(asset_name, date=None):
dataent.has_permission('Journal Entry', throw=True)
if not date:
date = today()
asset = dataent.get_doc("Asset", asset_name)
fixed_asset_account, accumulated_depreciation_account, depreciation_expense_account = \
get_depreciation_accounts(asset)
depreciation_cost_center, depreciation_series = dataent.get_cached_value('Company', asset.company,
["depreciation_cost_center", "series_for_depreciation_entry"])
depreciation_cost_center = asset.cost_center or depreciation_cost_center
for d in asset.get("schedules"):
if not d.journal_entry and getdate(d.schedule_date) <= getdate(date):
je = dataent.new_doc("Journal Entry")
je.voucher_type = "Depreciation Entry"
je.naming_series = depreciation_series
je.posting_date = d.schedule_date
je.company = asset.company
je.finance_book = d.finance_book
je.remark = "Depreciation Entry against {0} worth {1}".format(asset_name, d.depreciation_amount)
je.append("accounts", {
"account": accumulated_depreciation_account,
"credit_in_account_currency": d.depreciation_amount,
"reference_type": "Asset",
"reference_name": asset.name
})
je.append("accounts", {
"account": depreciation_expense_account,
"debit_in_account_currency": d.depreciation_amount,
"reference_type": "Asset",
"reference_name": asset.name,
"cost_center": depreciation_cost_center
})
je.flags.ignore_permissions = True
je.submit()
d.db_set("journal_entry", je.name)
idx = cint(d.finance_book_id)
finance_books = asset.get('finance_books')[idx - 1]
finance_books.value_after_depreciation -= d.depreciation_amount
finance_books.db_update()
asset.set_status()
return asset
def test_pr_billing_status(self):
# PO -> PR1 -> PI and PO -> PI and PO -> PR2
from epaas.buying.doctype.purchase_order.test_purchase_order import create_purchase_order
from epaas.buying.doctype.purchase_order.purchase_order \
import make_purchase_receipt, make_purchase_invoice as make_purchase_invoice_from_po
po = create_purchase_order()
pr1 = make_purchase_receipt(po.name)
pr1.posting_date = today()
pr1.posting_time = "10:00"
pr1.get("items")[0].received_qty = 2
pr1.get("items")[0].qty = 2
pr1.submit()
pi1 = make_purchase_invoice(pr1.name)
pi1.submit()
pr1.load_from_db()
self.assertEqual(pr1.per_billed, 100)
pi2 = make_purchase_invoice_from_po(po.name)
pi2.get("items")[0].qty = 4
pi2.submit()
pr2 = make_purchase_receipt(po.name)
pr2.posting_date = today()
pr2.posting_time = "08:00"
pr2.get("items")[0].received_qty = 5
pr2.get("items")[0].qty = 5
pr2.submit()
pr1.load_from_db()
self.assertEqual(pr1.get("items")[0].billed_amt, 1000)
self.assertEqual(pr1.per_billed, 100)
self.assertEqual(pr1.status, "Completed")
self.assertEqual(pr2.get("items")[0].billed_amt, 2000)
self.assertEqual(pr2.per_billed, 80)
self.assertEqual(pr2.status, "To Bill")
def test_restrict_scheduler_events(self):
dataent.set_user("Administrator")
dormant_date = add_days(today(), -5)
dataent.db.sql('update tabUser set last_active=%s', dormant_date)
restrict_scheduler_events_if_dormant()
dataent.local.conf = _dict(dataent.get_site_config())
self.assertFalse("all" in get_enabled_scheduler_events())
self.assertTrue(dataent.conf.get('dormant', False))
clear_limit("expiry")
dataent.local.conf = _dict(dataent.get_site_config())
def is_holiday(employee, date=None):
'''Returns True if given Employee has an holiday on the given date
:param employee: Employee `name`
:param date: Date to check. Will check for today if None'''
holiday_list = get_holiday_list_for_employee(employee)
if not date:
date = today()
if holiday_list:
return dataent.get_all('Holiday List',
dict(name=holiday_list,
holiday_date=date)) and True or False
