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