def make_quotation(domain): # get open opportunites opportunity = get_random("Opportunity", { "status": "Open", "with_items": 1 }) if opportunity: from erpbee.crm.doctype.opportunity.opportunity import make_quotation qtn = frappe.get_doc(make_quotation(opportunity)) qtn.insert() frappe.db.commit() qtn.submit() frappe.db.commit() else: # make new directly # get customer, currency and exchange_rate customer = get_random("Customer") company_currency = frappe.get_cached_value( 'Company', erpbee.get_default_company(), "default_currency") party_account_currency = get_party_account_currency( "Customer", customer, erpbee.get_default_company()) if company_currency == party_account_currency: exchange_rate = 1 else: exchange_rate = get_exchange_rate(party_account_currency, company_currency, args="for_selling") qtn = frappe.get_doc({ "creation": frappe.flags.current_date, "doctype": "Quotation", "quotation_to": "Customer", "party_name": customer, "currency": party_account_currency or company_currency, "conversion_rate": exchange_rate, "order_type": "Sales", "transaction_date": frappe.flags.current_date, }) add_random_children(qtn, "items", rows=3, randomize={ "qty": (1, 5), "item_code": ("Item", { "has_variants": "0", "is_fixed_asset": 0, "domain": domain }) }, unique="item_code") qtn.insert() frappe.db.commit() qtn.submit() frappe.db.commit()
def work(): if random.random() < 0.3: return frappe.set_user(frappe.db.get_global('demo_manufacturing_user')) if not frappe.get_all('Sales Order'): return from erpbee.projects.doctype.timesheet.timesheet import OverlapError ppt = frappe.new_doc("Production Plan") ppt.company = erpbee.get_default_company() # ppt.use_multi_level_bom = 1 #refactored ppt.get_items_from = "Sales Order" # ppt.purchase_request_for_warehouse = "Stores - WPL" # refactored ppt.run_method("get_open_sales_orders") if not ppt.get("sales_orders"): return ppt.run_method("get_items") ppt.run_method("raise_material_requests") ppt.save() ppt.submit() ppt.run_method("raise_work_orders") frappe.db.commit() # submit work orders for pro in frappe.db.get_values("Work Order", {"docstatus": 0}, "name"): b = frappe.get_doc("Work Order", pro[0]) b.wip_warehouse = "Work in Progress - WPL" b.submit() frappe.db.commit() # submit material requests for pro in frappe.db.get_values("Material Request", {"docstatus": 0}, "name"): b = frappe.get_doc("Material Request", pro[0]) b.submit() frappe.db.commit() # stores -> wip if random.random() < 0.4: for pro in query_report.run("Open Work Orders")["result"][:how_many("Stock Entry for WIP")]: make_stock_entry_from_pro(pro[0], "Material Transfer for Manufacture") # wip -> fg if random.random() < 0.4: for pro in query_report.run("Work Orders in Progress")["result"][:how_many("Stock Entry for FG")]: make_stock_entry_from_pro(pro[0], "Manufacture") for bom in frappe.get_all('BOM', fields=['item'], filters = {'with_operations': 1}): pro_order = make_wo_order_test_record(item=bom.item, qty=2, source_warehouse="Stores - WPL", wip_warehouse = "Work in Progress - WPL", fg_warehouse = "Stores - WPL", company = erpbee.get_default_company(), stock_uom = frappe.db.get_value('Item', bom.item, 'stock_uom'), planned_start_date = frappe.flags.current_date) # submit job card if random.random() < 0.4: submit_job_cards()
def setup_mode_of_payment(): company_abbr = frappe.get_cached_value('Company', erpbee.get_default_company(), "abbr") account_dict = {'Cash': 'Cash - '+ company_abbr , 'Bank': 'National Bank - '+ company_abbr} for payment_mode in frappe.get_all('Mode of Payment', fields = ["name", "type"]): if payment_mode.type: mop = frappe.get_doc('Mode of Payment', payment_mode.name) mop.append('accounts', { 'company': erpbee.get_default_company(), 'default_account': account_dict.get(payment_mode.type) }) mop.save(ignore_permissions=True)
def get_holiday_list(company=None): if not company: company = get_default_company() or frappe.get_all('Company')[0].name holiday_list = frappe.get_cached_value('Company', company, 'default_holiday_list') if not holiday_list: frappe.throw( _('Please set a default Holiday List for Company {0}').format( frappe.bold(get_default_company()))) return holiday_list
def setup_account_to_expense_type(): company_abbr = frappe.get_cached_value('Company', erpbee.get_default_company(), "abbr") expense_types = [{'name': _('Calls'), "account": "Sales Expenses - "+ company_abbr}, {'name': _('Food'), "account": "Entertainment Expenses - "+ company_abbr}, {'name': _('Medical'), "account": "Utility Expenses - "+ company_abbr}, {'name': _('Others'), "account": "Miscellaneous Expenses - "+ company_abbr}, {'name': _('Travel'), "account": "Travel Expenses - "+ company_abbr}] for expense_type in expense_types: doc = frappe.get_doc("Expense Claim Type", expense_type["name"]) doc.append("accounts", { "company" : erpbee.get_default_company(), "default_account" : expense_type["account"] }) doc.save(ignore_permissions=True)
def make_payment_entries(ref_doctype, report): outstanding_invoices = frappe.get_all(ref_doctype, fields=["name"], filters={ "company": erpbee.get_default_company(), "outstanding_amount": (">", 0.0) }) # make Payment Entry for inv in outstanding_invoices[:random.randint(1, 2)]: pe = get_payment_entry(ref_doctype, inv.name) pe.posting_date = frappe.flags.current_date pe.reference_no = random_string(6) pe.reference_date = frappe.flags.current_date pe.insert() pe.submit() frappe.db.commit() outstanding_invoices.remove(inv) # make payment via JV for inv in outstanding_invoices[:1]: jv = frappe.get_doc( get_payment_entry_against_invoice(ref_doctype, inv.name)) jv.posting_date = frappe.flags.current_date jv.cheque_no = random_string(6) jv.cheque_date = frappe.flags.current_date jv.insert() jv.submit() frappe.db.commit()
def complete_setup(domain='Manufacturing'): print("Complete Setup...") from frappe.desk.page.setup_wizard.setup_wizard import setup_complete if not frappe.get_all('Company', limit=1): setup_complete({ "full_name": "Test User", "email": "*****@*****.**", "company_tagline": 'Awesome Products and Services', "password": "******", "fy_start_date": "2015-01-01", "fy_end_date": "2015-12-31", "bank_account": "National Bank", "domains": [domain], "company_name": data.get(domain).get('company_name'), "chart_of_accounts": "Standard", "company_abbr": ''.join([d[0] for d in data.get(domain).get('company_name').split()]).upper(), "currency": 'USD', "timezone": 'America/New_York', "country": 'United States', "language": "english" }) company = erpbee.get_default_company() if company: company_doc = frappe.get_doc("Company", company) company_doc.db_set('default_payroll_payable_account', frappe.db.get_value('Account', dict(account_name='Payroll Payable')))
def test_payroll_frequency(self): fiscal_year = get_fiscal_year(nowdate(), company=erpbee.get_default_company())[0] month = "%02d" % getdate(nowdate()).month m = get_month_details(fiscal_year, month) for payroll_frequency in [ "Monthly", "Bimonthly", "Fortnightly", "Weekly", "Daily" ]: make_employee(payroll_frequency + "*****@*****.**") ss = make_employee_salary_slip( payroll_frequency + "*****@*****.**", payroll_frequency, payroll_frequency + "_Test Payroll Frequency") if payroll_frequency == "Monthly": self.assertEqual(ss.end_date, m['month_end_date']) elif payroll_frequency == "Bimonthly": if getdate(ss.start_date).day <= 15: self.assertEqual(ss.end_date, m['month_mid_end_date']) else: self.assertEqual(ss.end_date, m['month_end_date']) elif payroll_frequency == "Fortnightly": self.assertEqual(ss.end_date, add_days(nowdate(), 13)) elif payroll_frequency == "Weekly": self.assertEqual(ss.end_date, add_days(nowdate(), 6)) elif payroll_frequency == "Daily": self.assertEqual(ss.end_date, nowdate())
def make_employee(user, company=None, **kwargs): if not frappe.db.get_value("User", user): frappe.get_doc({ "doctype": "User", "email": user, "first_name": user, "new_password": "******", "roles": [{"doctype": "Has Role", "role": "Employee"}] }).insert() if not frappe.db.get_value("Employee", {"user_id": user}): employee = frappe.get_doc({ "doctype": "Employee", "naming_series": "EMP-", "first_name": user, "company": company or erpbee.get_default_company(), "user_id": user, "date_of_birth": "1990-05-08", "date_of_joining": "2013-01-01", "department": frappe.get_all("Department", fields="name")[0].name, "gender": "Female", "company_email": user, "prefered_contact_email": "Company Email", "prefered_email": user, "status": "Active", "employment_type": "Intern" }) if kwargs: employee.update(kwargs) employee.insert() return employee.name else: return frappe.get_value("Employee", {"employee_name":user}, "name")
def get_appropriate_company(filters): if filters.get('company'): company = filters['company'] else: company = get_default_company() return company
def test_payroll_entry(self): # pylint: disable=no-self-use company = erpbee.get_default_company() for data in frappe.get_all('Salary Component', fields=["name"]): if not frappe.db.get_value('Salary Component Account', { 'parent': data.name, 'company': company }, 'name'): get_salary_component_account(data.name) employee = frappe.db.get_value("Employee", {'company': company}) company_doc = frappe.get_doc('Company', company) make_salary_structure("_Test Salary Structure", "Monthly", employee, company=company, currency=company_doc.default_currency) dates = get_start_end_dates('Monthly', nowdate()) if not frappe.db.get_value("Salary Slip", { "start_date": dates.start_date, "end_date": dates.end_date }): make_payroll_entry( start_date=dates.start_date, end_date=dates.end_date, payable_account=company_doc.default_payroll_payable_account, currency=company_doc.default_currency)
def test_holiday(self): today = getdate() leave_application = create_leave_application(from_date=today, to_date=add_days( today, 1), submit=0) # holiday list validation company = get_default_company() or frappe.get_all('Company')[0].name frappe.db.set_value('Company', company, 'default_holiday_list', '') self.assertRaises(frappe.ValidationError, leave_application.save) frappe.db.set_value('Company', company, 'default_holiday_list', 'Test Holiday List for Student') leave_application.save() leave_application.reload() self.assertEqual(leave_application.total_leave_days, 1) # check no attendance record created for a holiday leave_application.submit() self.assertIsNone( frappe.db.exists( 'Student Attendance', { 'leave_application': leave_application.name, 'date': add_days(today, 1) }))
def create_delivery_trip(driver, address, contact=None): if not contact: contact = get_contact_and_address("_Test Customer") delivery_trip = frappe.get_doc({ "doctype": "Delivery Trip", "company": erpbee.get_default_company(), "departure_time": add_days(now_datetime(), 5), "driver": driver.name, "driver_address": address.name, "vehicle": "JB 007", "delivery_stops": [{ "customer": "_Test Customer", "address": contact.shipping_address.parent, "contact": contact.contact_person.parent }, { "customer": "_Test Customer", "address": contact.shipping_address.parent, "contact": contact.contact_person.parent }] }).insert(ignore_permissions=True) return delivery_trip
def merge_similar_entries(gl_map): merged_gl_map = [] accounting_dimensions = get_accounting_dimensions() for entry in gl_map: # if there is already an entry in this account then just add it # to that entry same_head = check_if_in_list(entry, merged_gl_map, accounting_dimensions) if same_head: same_head.debit = flt(same_head.debit) + flt(entry.debit) same_head.debit_in_account_currency = \ flt(same_head.debit_in_account_currency) + flt(entry.debit_in_account_currency) same_head.credit = flt(same_head.credit) + flt(entry.credit) same_head.credit_in_account_currency = \ flt(same_head.credit_in_account_currency) + flt(entry.credit_in_account_currency) else: merged_gl_map.append(entry) company = gl_map[0].company if gl_map else erpbee.get_default_company() company_currency = erpbee.get_company_currency(company) precision = get_field_precision( frappe.get_meta("GL Entry").get_field("debit"), company_currency) # filter zero debit and credit entries merged_gl_map = filter( lambda x: flt(x.debit, precision) != 0 or flt(x.credit, precision) != 0, merged_gl_map) merged_gl_map = list(merged_gl_map) return merged_gl_map
def get_payment_account(): return frappe.get_value( 'Account', { 'account_type': 'Cash', 'company': erpbee.get_default_company(), 'is_group': 0 }, "name")
def make_payroll_entry(**args): args = frappe._dict(args) payroll_entry = frappe.new_doc("Payroll Entry") payroll_entry.company = args.company or erpbee.get_default_company() payroll_entry.start_date = args.start_date or "2016-11-01" payroll_entry.end_date = args.end_date or "2016-11-30" payroll_entry.payment_account = get_payment_account() payroll_entry.posting_date = nowdate() payroll_entry.payroll_frequency = "Monthly" payroll_entry.branch = args.branch or None payroll_entry.department = args.department or None payroll_entry.payroll_payable_account = args.payable_account payroll_entry.currency = args.currency payroll_entry.exchange_rate = args.exchange_rate or 1 if args.cost_center: payroll_entry.cost_center = args.cost_center if args.payment_account: payroll_entry.payment_account = args.payment_account payroll_entry.fill_employee_details() payroll_entry.save() payroll_entry.create_salary_slips() payroll_entry.submit_salary_slips() if payroll_entry.get_sal_slip_list(ss_status=1): payroll_entry.make_payment_entry() return payroll_entry
def create_leave_period(from_date, to_date, company=None): leave_period = frappe.db.get_value('Leave Period', dict(company=company or erpbee.get_default_company(), from_date=from_date, to_date=to_date, is_active=1), 'name') if leave_period: return frappe.get_doc("Leave Period", leave_period) leave_period = frappe.get_doc({ "doctype": "Leave Period", "company": company or erpbee.get_default_company(), "from_date": from_date, "to_date": to_date, "is_active": 1 }).insert() return leave_period
def test_duplicate_entry_for_payroll_period(self): declaration = frappe.get_doc({ "doctype": "Employee Tax Exemption Declaration", "employee": frappe.get_value("Employee", {"user_id": "*****@*****.**"}, "name"), "company": erpbee.get_default_company(), "payroll_period": "_Test Payroll Period", "currency": erpbee.get_default_currency(), "declarations": [ dict(exemption_sub_category="_Test Sub Category", exemption_category="_Test Category", amount=100000), dict(exemption_sub_category="_Test1 Sub Category", exemption_category="_Test Category", amount=50000), ] }).insert() duplicate_declaration = frappe.get_doc({ "doctype": "Employee Tax Exemption Declaration", "employee": frappe.get_value("Employee", {"user_id": "*****@*****.**"}, "name"), "company": erpbee.get_default_company(), "payroll_period": "_Test Payroll Period", "currency": erpbee.get_default_currency(), "declarations": [ dict(exemption_sub_category="_Test Sub Category", exemption_category="_Test Category", amount=100000) ] }) self.assertRaises(DuplicateDeclarationError, duplicate_declaration.insert) duplicate_declaration.employee = frappe.get_value( "Employee", {"user_id": "*****@*****.**"}, "name") self.assertTrue(duplicate_declaration.insert)
def test_multi_currency_payroll_entry(self): # pylint: disable=no-self-use company = erpbee.get_default_company() employee = make_employee("*****@*****.**", company=company) for data in frappe.get_all('Salary Component', fields=["name"]): if not frappe.db.get_value('Salary Component Account', { 'parent': data.name, 'company': company }, 'name'): get_salary_component_account(data.name) company_doc = frappe.get_doc('Company', company) salary_structure = make_salary_structure( "_Test Multi Currency Salary Structure", "Monthly", company=company, currency='USD') create_salary_structure_assignment(employee, salary_structure.name, company=company) frappe.db.sql( """delete from `tabSalary Slip` where employee=%s""", (frappe.db.get_value( "Employee", {"user_id": "*****@*****.**"}))) salary_slip = get_salary_slip( "*****@*****.**", "Monthly", "_Test Multi Currency Salary Structure") dates = get_start_end_dates('Monthly', nowdate()) payroll_entry = make_payroll_entry( start_date=dates.start_date, end_date=dates.end_date, payable_account=company_doc.default_payroll_payable_account, currency='USD', exchange_rate=70) payroll_entry.make_payment_entry() salary_slip.load_from_db() payroll_je = salary_slip.journal_entry payroll_je_doc = frappe.get_doc('Journal Entry', payroll_je) self.assertEqual(salary_slip.base_gross_pay, payroll_je_doc.total_debit) self.assertEqual(salary_slip.base_gross_pay, payroll_je_doc.total_credit) payment_entry = frappe.db.sql(''' Select ifnull(sum(je.total_debit),0) as total_debit, ifnull(sum(je.total_credit),0) as total_credit from `tabJournal Entry` je, `tabJournal Entry Account` jea Where je.name = jea.parent And jea.reference_name = %s ''', (payroll_entry.name), as_dict=1) self.assertEqual(salary_slip.base_net_pay, payment_entry[0].total_debit) self.assertEqual(salary_slip.base_net_pay, payment_entry[0].total_credit)
def make_salary_structure(salary_structure, payroll_frequency, employee=None, dont_submit=False, other_details=None, test_tax=False, company=None, currency=erpbee.get_default_currency(), payroll_period=None): if test_tax: frappe.db.sql("""delete from `tabSalary Structure` where name=%s""", (salary_structure)) if not frappe.db.exists('Salary Structure', salary_structure): details = { "doctype": "Salary Structure", "name": salary_structure, "company": company or erpbee.get_default_company(), "earnings": make_earning_salary_component(test_tax=test_tax, company_list=["_Test Company"]), "deductions": make_deduction_salary_component(test_tax=test_tax, company_list=["_Test Company"]), "payroll_frequency": payroll_frequency, "payment_account": get_random("Account", filters={'account_currency': currency}), "currency": currency } if other_details and isinstance(other_details, dict): details.update(other_details) salary_structure_doc = frappe.get_doc(details) salary_structure_doc.insert() if not dont_submit: salary_structure_doc.submit() else: salary_structure_doc = frappe.get_doc("Salary Structure", salary_structure) if employee and not frappe.db.get_value("Salary Structure Assignment", { 'employee': employee, 'docstatus': 1 }) and salary_structure_doc.docstatus == 1: create_salary_structure_assignment(employee, salary_structure, company=company, currency=currency, payroll_period=payroll_period) return salary_structure_doc
def get_company_address_details(doc): """Return default company address details""" company_address = get_company_address( get_default_company()).company_address if not company_address: frappe.throw(_("Please set a default company address")) company_address = frappe.get_doc("Address", company_address) return company_address
def get_customer_details(filters): customer_details = get_party_details(party=filters.get("customer"), party_type="Customer") customer_details.update({ "company": get_default_company(), "price_list": customer_details.get("selling_price_list") }) return customer_details
def simulate(domain='Manufacturing', days=100): runs_for = frappe.flags.runs_for or days frappe.flags.company = erpbee.get_default_company() frappe.flags.mute_emails = True if not frappe.flags.start_date: # start date = 100 days back frappe.flags.start_date = frappe.utils.add_days( frappe.utils.nowdate(), -1 * runs_for) current_date = frappe.utils.getdate(frappe.flags.start_date) # continue? demo_last_date = frappe.db.get_global('demo_last_date') if demo_last_date: current_date = frappe.utils.add_days( frappe.utils.getdate(demo_last_date), 1) # run till today if not runs_for: runs_for = frappe.utils.date_diff(frappe.utils.nowdate(), current_date) # runs_for = 100 fixed_asset.work() for i in range(runs_for): sys.stdout.write("\rSimulating {0}: Day {1}".format( current_date.strftime("%Y-%m-%d"), i)) sys.stdout.flush() frappe.flags.current_date = current_date if current_date.weekday() in (5, 6): current_date = frappe.utils.add_days(current_date, 1) continue try: hr.work() purchase.work() stock.work() accounts.work() projects.run_projects(current_date) sales.work(domain) # run_messages() if domain == 'Manufacturing': manufacturing.work() elif domain == 'Education': edu.work() except: frappe.db.set_global('demo_last_date', current_date) raise finally: current_date = frappe.utils.add_days(current_date, 1) frappe.db.commit()
def create_additional_salary(employee, payroll_period, amount): salary_date = add_months(payroll_period.start_date, random.randint(0, 11)) frappe.get_doc({ "doctype": "Additional Salary", "employee": employee, "company": erpbee.get_default_company(), "salary_component": "Performance Bonus", "payroll_date": salary_date, "amount": amount, "type": "Earning", "currency": erpbee.get_default_currency() }).submit() return salary_date
def setUp(self): for dt in [ "Salary Slip", "Salary Structure", "Salary Structure Assignment" ]: frappe.db.sql("delete from `tab%s`" % dt) self.make_holiday_list() frappe.db.set_value("Company", erpbee.get_default_company(), "default_holiday_list", "Salary Structure Test Holiday List") make_employee("*****@*****.**") make_employee("*****@*****.**")
def make_holiday_list(): fiscal_year = get_fiscal_year(nowdate(), company=erpbee.get_default_company()) if not frappe.db.get_value("Holiday List", "Salary Slip Test Holiday List"): holiday_list = frappe.get_doc({ "doctype": "Holiday List", "holiday_list_name": "Salary Slip Test Holiday List", "from_date": fiscal_year[1], "to_date": fiscal_year[2], "weekly_off": "Sunday" }).insert() holiday_list.get_weekly_off_dates() holiday_list.save()
def set_missing_fields(self): if not self.company: self.company = erpbee.get_default_company() if not self.posting_date: self.posting_date = nowdate() if self.loan_type and not self.rate_of_interest: self.rate_of_interest = frappe.db.get_value( "Loan Type", self.loan_type, "rate_of_interest") if self.repayment_method == "Repay Over Number of Periods": self.monthly_repayment_amount = get_monthly_repayment_amount( self.repayment_method, self.loan_amount, self.rate_of_interest, self.repayment_periods)
def execute(filters=None): columns, data, chart = [], [], [] if filters.get('fiscal_year'): company = erpbee.get_default_company() period_list = get_period_list(filters.get('fiscal_year'), filters.get('fiscal_year'), '', '', 'Fiscal Year', 'Monthly', company=company) columns = get_columns() data = get_log_data(filters) chart = get_chart_data(data, period_list) return columns, data, None, chart
def setup_employee(): frappe.db.set_value("HR Settings", None, "emp_created_by", "Naming Series") frappe.db.commit() for d in frappe.get_all('Salary Component'): salary_component = frappe.get_doc('Salary Component', d.name) salary_component.append('accounts', dict( company=erpbee.get_default_company(), account=frappe.get_value('Account', dict(account_name=('like', 'Salary%'))) )) salary_component.save() import_json('Employee') holiday_list = frappe.db.get_value("Holiday List", {"holiday_list_name": str(now_datetime().year)}, 'name') frappe.db.sql('''update tabEmployee set holiday_list={0}'''.format(holiday_list))
def create_payroll_period(**args): args = frappe._dict(args) name = args.name or "_Test Payroll Period" if not frappe.db.exists("Payroll Period", name): from datetime import date payroll_period = frappe.get_doc( dict(doctype='Payroll Period', name=name, company=args.company or erpbee.get_default_company(), start_date=args.start_date or date(date.today().year, 1, 1), end_date=args.end_date or date(date.today().year, 12, 31))).insert() return payroll_period else: return frappe.get_doc("Payroll Period", name)