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)
