def test_not_accept_duplicate_serial_no(self):
from epaas.stock.doctype.stock_entry.test_stock_entry import make_stock_entry
from epaas.stock.doctype.delivery_note.test_delivery_note import create_delivery_note
item_code = dataent.db.get_value('Item', {
'has_serial_no': 1,
'is_fixed_asset': 0
})
if not item_code:
item = make_item("Test Serial Item 1", dict(has_serial_no=1))
item_code = item.name
serial_no = random_string(5)
make_purchase_receipt(item_code=item_code, qty=1, serial_no=serial_no)
create_delivery_note(item_code=item_code, qty=1, serial_no=serial_no)
pr = make_purchase_receipt(item_code=item_code,
qty=1,
serial_no=serial_no,
do_not_submit=True)
self.assertRaises(SerialNoDuplicateError, pr.submit)
se = make_stock_entry(item_code=item_code,
target="_Test Warehouse - _TC",
qty=1,
serial_no=serial_no,
basic_rate=100,
do_not_submit=True)
self.assertRaises(SerialNoDuplicateError, se.submit)
def test_make_vehicle_log(self):
license_plate = random_string(10).upper()
employee_id = dataent.db.sql(
"""select name from `tabEmployee` order by modified desc limit 1"""
)[0][0]
vehicle = dataent.get_doc({
"doctype": "Vehicle",
"license_plate": cstr(license_plate),
"make": "Maruti",
"model": "PCM",
"last_odometer": 5000,
"acquisition_date": dataent.utils.nowdate(),
"location": "Mumbai",
"chassis_no": "1234ABCD",
"uom": "Litre",
"vehicle_value": dataent.utils.flt(500000)
})
try:
vehicle.insert()
except dataent.DuplicateEntryError:
pass
vehicle_log = dataent.get_doc({
"doctype": "Vehicle Log",
"license_plate": cstr(license_plate),
"employee": employee_id,
"date": dataent.utils.nowdate(),
"odometer": 5010,
"fuel_qty": dataent.utils.flt(50),
"price": dataent.utils.flt(500)
})
vehicle_log.insert()
vehicle_log.submit()
def replace_filename_with_cid(message):
""" Replaces <img embed="assets/dataent/images/filename.jpg" ...> with
<img src="cid:content_id" ...> and return the modified message and
a list of inline_images with {filename, filecontent, content_id}
"""
inline_images = []
while True:
matches = re.search('''embed=["'](.*?)["']''', message)
if not matches: break
groups = matches.groups()
# found match
img_path = groups[0]
filename = img_path.rsplit('/')[-1]
filecontent = get_filecontent_from_path(img_path)
if not filecontent:
message = re.sub('''embed=['"]{0}['"]'''.format(img_path), '', message)
continue
content_id = random_string(10)
inline_images.append({
'filename': filename,
'filecontent': filecontent,
'content_id': content_id
})
message = re.sub('''embed=['"]{0}['"]'''.format(img_path),
'src="cid:{0}"'.format(content_id), message)
return (message, inline_images)
def make_route(self):
if not self.route:
return cstr(
dataent.db.get_value('Item Group', self.item_group, 'route')
) + '/' + self.scrub(
(self.item_name if self.item_name else self.item_code) + '-' +
random_string(5))
def get_random_filename(extn=None, content_type=None):
if extn:
if not extn.startswith("."):
extn = "." + extn
elif content_type:
extn = mimetypes.guess_extension(content_type)
return random_string(7) + (extn or "")
def get_conf_params(db_name=None, db_password=None):
if not db_name:
db_name = input("Database Name: ")
if not db_name:
raise Exception("Database Name Required")
if not db_password:
from dataent.utils import random_string
db_password = random_string(16)
return {"db_name": db_name, "db_password": db_password}
def reset_password(self, send_email=False):
from dataent.utils import random_string, get_url
key = random_string(32)
self.db_set("reset_password_key", key)
link = get_url("/update-password?key=" + key)
if send_email:
self.password_reset_mail(link)
return link
def work():
dataent.set_user(dataent.db.get_global('demo_accounts_user'))
if random.random() <= 0.6:
report = "Ordered Items to be Billed"
for so in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
si = dataent.get_doc(make_sales_invoice(so))
si.posting_date = dataent.flags.current_date
for d in si.get("items"):
if not d.income_account:
d.income_account = "Sales - {}".format(dataent.get_cached_value('Company', si.company, 'abbr'))
si.insert()
si.submit()
dataent.db.commit()
except dataent.ValidationError:
pass
if random.random() <= 0.6:
report = "Received Items to be Billed"
for pr in list(set([r[0] for r in query_report.run(report)["result"]
if r[0]!="Total"]))[:random.randint(1, 5)]:
try:
pi = dataent.get_doc(make_purchase_invoice(pr))
pi.posting_date = dataent.flags.current_date
pi.bill_no = random_string(6)
pi.insert()
pi.submit()
dataent.db.commit()
except dataent.ValidationError:
pass
if random.random() < 0.5:
make_payment_entries("Sales Invoice", "Accounts Receivable")
if random.random() < 0.5:
make_payment_entries("Purchase Invoice", "Accounts Payable")
if random.random() < 0.4:
#make payment request against sales invoice
sales_invoice_name = get_random("Sales Invoice", filters={"docstatus": 1})
if sales_invoice_name:
si = dataent.get_doc("Sales Invoice", sales_invoice_name)
if si.outstanding_amount > 0:
payment_request = make_payment_request(dt="Sales Invoice", dn=si.name, recipient_id=si.contact_email,
submit_doc=True, mute_email=True, use_dummy_message=True)
payment_entry = dataent.get_doc(make_payment_entry(payment_request.name))
payment_entry.posting_date = dataent.flags.current_date
payment_entry.submit()
make_pos_invoice()
def test_make_vehicle(self):
vehicle = dataent.get_doc({
"doctype": "Vehicle",
"license_plate": random_string(10).upper(),
"make": "Maruti",
"model": "PCM",
"last_odometer":5000,
"acquisition_date":dataent.utils.nowdate(),
"location": "Mumbai",
"chassis_no": "1234ABCD",
"uom": "Litre",
"vehicle_value":dataent.utils.flt(500000)
})
vehicle.insert()
def make_payment_entries(ref_doctype, report):
outstanding_invoices = list(set([r[3] for r in query_report.run(report,
{"report_date": dataent.flags.current_date })["result"] if r[2]==ref_doctype]))
# make Payment Entry
for inv in outstanding_invoices[:random.randint(1, 2)]:
pe = get_payment_entry(ref_doctype, inv)
pe.posting_date = dataent.flags.current_date
pe.reference_no = random_string(6)
pe.reference_date = dataent.flags.current_date
pe.insert()
pe.submit()
dataent.db.commit()
outstanding_invoices.remove(inv)
# make payment via JV
for inv in outstanding_invoices[:1]:
jv = dataent.get_doc(get_payment_entry_against_invoice(ref_doctype, inv))
jv.posting_date = dataent.flags.current_date
jv.cheque_no = random_string(6)
jv.cheque_date = dataent.flags.current_date
jv.insert()
jv.submit()
dataent.db.commit()
def sign_up(email, full_name, redirect_to):
if not is_signup_enabled():
dataent.throw(_('Sign Up is disabled'), title='Not Allowed')
user = dataent.db.get("User", {"email": email})
if user:
if user.disabled:
return 0, _("Registered but disabled")
else:
return 0, _("Already Registered")
else:
if dataent.db.sql("""select count(*) from tabUser where
HOUR(TIMEDIFF(CURRENT_TIMESTAMP, TIMESTAMP(modified)))=1""")[0][0] > 300:
dataent.respond_as_web_page(
_('Temperorily Disabled'),
_('Too many users signed up recently, so the registration is disabled. Please try back in an hour'
),
http_status_code=429)
from dataent.utils import random_string
user = dataent.get_doc({
"doctype": "User",
"email": email,
"first_name": full_name,
"enabled": 1,
"new_password": random_string(10),
"user_type": "Website User"
})
user.flags.ignore_permissions = True
user.insert()
# set default signup role as per Portal Settings
default_role = dataent.db.get_value("Portal Settings", None,
"default_role")
if default_role:
user.add_roles(default_role)
if redirect_to:
dataent.cache().hset('redirect_after_login', user.name,
redirect_to)
if user.flags.email_sent:
return 1, _("Please check your email for verification")
else:
return 2, _("Please ask your administrator to verify your sign-up")
def test_expense_claim_status(self):
payable_account = get_payable_account("Wind Power LLC")
expense_claim = make_expense_claim(payable_account, 300, 200,
"Wind Power LLC",
"Travel Expenses - WP")
je_dict = make_bank_entry("Expense Claim", expense_claim.name)
je = dataent.get_doc(je_dict)
je.posting_date = nowdate()
je.cheque_no = random_string(5)
je.cheque_date = nowdate()
je.submit()
expense_claim = dataent.get_doc("Expense Claim", expense_claim.name)
self.assertEqual(expense_claim.status, "Paid")
je.cancel()
expense_claim = dataent.get_doc("Expense Claim", expense_claim.name)
self.assertEqual(expense_claim.status, "Unpaid")
def setup_salary_structure(employees, salary_slip_based_on_timesheet=0):
ss = dataent.new_doc('Salary Structure')
ss.name = "Sample Salary Structure - " + random_string(5)
ss.salary_slip_based_on_timesheet = salary_slip_based_on_timesheet
if salary_slip_based_on_timesheet:
ss.salary_component = 'Basic'
ss.hour_rate = flt(random.random() * 10, 2)
else:
ss.payroll_frequency = 'Monthly'
ss.payment_account = dataent.get_value('Account',
{'account_type': 'Cash', 'company': epaas.get_default_company(),'is_group':0}, "name")
ss.append('earnings', {
'salary_component': 'Basic',
"abbr":'B',
'formula': 'base*.2',
'amount_based_on_formula': 1,
"idx": 1
})
ss.append('deductions', {
'salary_component': 'Income Tax',
"abbr":'IT',
'condition': 'base > 10000',
'formula': 'base*.1',
"idx": 1
})
ss.insert()
ss.submit()
for e in employees:
sa = dataent.new_doc("Salary Structure Assignment")
sa.employee = e.name
sa.salary_structure = ss.name
sa.from_date = "2015-01-01"
sa.base = random.random() * 10000
sa.insert()
sa.submit()
return ss
def test_coa_based_on_country_template(self):
countries = ["India", "Brazil", "United Arab Emirates", "Canada", "Germany", "France",
"Guatemala", "Indonesia", "Italy", "Mexico", "Nicaragua", "Netherlands", "Singapore",
"Brazil", "Argentina", "Hungary", "Taiwan"]
for country in countries:
templates = get_charts_for_country(country)
if len(templates) != 1 and "Standard" in templates:
templates.remove("Standard")
self.assertTrue(templates)
for template in templates:
try:
company = dataent.new_doc("Company")
company.company_name = template
company.abbr = random_string(3)
company.default_currency = "USD"
company.create_chart_of_accounts_based_on = "Standard Template"
company.chart_of_accounts = template
company.save()
account_types = ["Cost of Goods Sold", "Depreciation",
"Expenses Included In Valuation", "Fixed Asset", "Payable", "Receivable",
"Stock Adjustment", "Stock Received But Not Billed", "Bank", "Cash", "Stock"]
for account_type in account_types:
filters = {
"company": template,
"account_type": account_type
}
if account_type in ["Bank", "Cash"]:
filters["is_group"] = 1
has_matching_accounts = dataent.get_all("Account", filters)
error_message = _("No Account matched these filters: {}".format(json.dumps(filters)))
self.assertTrue(has_matching_accounts, msg=error_message)
finally:
self.delete_mode_of_payment(template)
dataent.delete_doc("Company", template)
def get_message_id():
'''Returns Message ID created from doctype and name'''
return "<{unique}@{site}>".format(
site=dataent.local.site,
unique=email.utils.make_msgid(random_string(10)).split('@')[0].split('<')[1])
def before_insert(self):
from dataent.utils import random_string
self.key = random_string(32)
def work():
dataent.set_user(dataent.db.get_global('demo_hr_user'))
year, month = dataent.flags.current_date.strftime("%Y-%m").split("-")
setup_department_approvers()
mark_attendance()
make_leave_application()
# payroll entry
if not dataent.db.sql(
'select name from `tabSalary Slip` where month(adddate(start_date, interval 1 month))=month(curdate())'
):
# based on frequency
payroll_entry = get_payroll_entry()
payroll_entry.salary_slip_based_on_timesheet = 0
payroll_entry.save()
payroll_entry.create_salary_slips()
payroll_entry.submit_salary_slips()
payroll_entry.make_accrual_jv_entry()
payroll_entry.submit()
# payroll_entry.make_journal_entry(reference_date=dataent.flags.current_date,
# reference_number=random_string(10))
# based on timesheet
payroll_entry = get_payroll_entry()
payroll_entry.salary_slip_based_on_timesheet = 1
payroll_entry.save()
payroll_entry.create_salary_slips()
payroll_entry.submit_salary_slips()
payroll_entry.make_accrual_jv_entry()
payroll_entry.submit()
# payroll_entry.make_journal_entry(reference_date=dataent.flags.current_date,
# reference_number=random_string(10))
if dataent.db.get_global('demo_hr_user'):
make_timesheet_records()
#expense claim
expense_claim = dataent.new_doc("Expense Claim")
expense_claim.extend('expenses', get_expenses())
expense_claim.employee = get_random("Employee")
expense_claim.company = dataent.flags.company
expense_claim.payable_account = get_payable_account(
expense_claim.company)
expense_claim.posting_date = dataent.flags.current_date
expense_claim.expense_approver = dataent.db.get_global('demo_hr_user')
expense_claim.save()
rand = random.random()
if rand < 0.4:
update_sanctioned_amount(expense_claim)
expense_claim.approval_status = 'Approved'
expense_claim.submit()
if random.randint(0, 1):
#make journal entry against expense claim
je = dataent.get_doc(
make_bank_entry("Expense Claim", expense_claim.name))
je.posting_date = dataent.flags.current_date
je.cheque_no = random_string(10)
je.cheque_date = dataent.flags.current_date
je.flags.ignore_permissions = 1
je.submit()
