def test_duplicate_entry_for_payroll_period(self):
declaration = dataent.get_doc({
"doctype": "Employee Tax Exemption Declaration",
"employee": dataent.get_value("Employee", {"user_id":"*****@*****.**"}, "name"),
"company": epaas.get_default_company(),
"payroll_period": "_Test Payroll Period",
"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 = dataent.get_doc({
"doctype": "Employee Tax Exemption Declaration",
"employee": dataent.get_value("Employee", {"user_id":"*****@*****.**"}, "name"),
"company": epaas.get_default_company(),
"payroll_period": "_Test Payroll Period",
"declarations": [
dict(exemption_sub_category = "_Test Sub Category",
exemption_category = "_Test Category",
amount = 100000)
]
})
self.assertRaises(DuplicateDeclarationError, duplicate_declaration.insert)
duplicate_declaration.employee = dataent.get_value("Employee", {"user_id":"*****@*****.**"}, "name")
self.assertTrue(duplicate_declaration.insert)
def make_quotation(domain):
# get open opportunites
opportunity = get_random("Opportunity", {
"status": "Open",
"with_items": 1
})
if opportunity:
from epaas.crm.doctype.opportunity.opportunity import make_quotation
qtn = dataent.get_doc(make_quotation(opportunity))
qtn.insert()
dataent.db.commit()
qtn.submit()
dataent.db.commit()
else:
# make new directly
# get customer, currency and exchange_rate
customer = get_random("Customer")
company_currency = dataent.get_cached_value(
'Company', epaas.get_default_company(), "default_currency")
party_account_currency = get_party_account_currency(
"Customer", customer, epaas.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 = dataent.get_doc({
"creation": dataent.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": dataent.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()
dataent.db.commit()
qtn.submit()
dataent.db.commit()
def setup_mode_of_payment():
company_abbr = dataent.get_cached_value('Company', epaas.get_default_company(), "abbr")
account_dict = {'Cash': 'Cash - '+ company_abbr , 'Bank': 'National Bank - '+ company_abbr}
for payment_mode in dataent.get_all('Mode of Payment', fields = ["name", "type"]):
if payment_mode.type:
mop = dataent.get_doc('Mode of Payment', payment_mode.name)
mop.append('accounts', {
'company': epaas.get_default_company(),
'default_account': account_dict.get(payment_mode.type)
})
mop.save(ignore_permissions=True)
def create_loan(applicant, loan_type, loan_amount, repayment_method,
repayment_periods):
create_loan_type(loan_type, 500000, 8.4)
if not dataent.db.get_value("Loan", {"applicant": applicant}):
loan = dataent.new_doc("Loan")
loan.update({
"applicant":
applicant,
"loan_type":
loan_type,
"loan_amount":
loan_amount,
"repayment_method":
repayment_method,
"repayment_periods":
repayment_periods,
"disbursement_date":
nowdate(),
"repayment_start_date":
nowdate(),
"status":
"Disbursed",
"mode_of_payment":
dataent.db.get_value('Mode of Payment', {'type': 'Cash'}, 'name'),
"payment_account":
dataent.db.get_value(
'Account', {
'account_type': 'Cash',
'company': epaas.get_default_company(),
'is_group': 0
}, "name"),
"loan_account":
dataent.db.get_value(
'Account', {
'account_type': 'Cash',
'company': epaas.get_default_company(),
'is_group': 0
}, "name"),
"interest_income_account":
dataent.db.get_value(
'Account', {
'account_type': 'Cash',
'company': epaas.get_default_company(),
'is_group': 0
}, "name")
})
loan.insert()
return loan
else:
return dataent.get_doc("Loan", {"applicant": applicant})
def setup_account_to_expense_type():
company_abbr = dataent.get_cached_value('Company', epaas.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 = dataent.get_doc("Expense Claim Type", expense_type["name"])
doc.append("accounts", {
"company" : epaas.get_default_company(),
"default_account" : expense_type["account"]
})
doc.save(ignore_permissions=True)
def make_salary_structure(salary_structure, payroll_frequency, employee=None, dont_submit=False, other_details=None, test_tax=False):
if test_tax:
dataent.db.sql("""delete from `tabSalary Structure` where name=%s""",(salary_structure))
if not dataent.db.exists('Salary Structure', salary_structure):
details = {
"doctype": "Salary Structure",
"name": salary_structure,
"company": epaas.get_default_company(),
"earnings": make_earning_salary_component(test_tax=test_tax),
"deductions": make_deduction_salary_component(test_tax=test_tax),
"payroll_frequency": payroll_frequency,
"payment_account": get_random("Account")
}
if other_details and isinstance(other_details, dict):
details.update(other_details)
salary_structure_doc = dataent.get_doc(details).insert()
if not dont_submit:
salary_structure_doc.submit()
else:
salary_structure_doc = dataent.get_doc("Salary Structure", salary_structure)
if employee and not dataent.db.get_value("Salary Structure Assignment",
{'employee':employee, 'docstatus': 1}) and salary_structure_doc.docstatus==1:
create_salary_structure_assignment(employee, salary_structure)
return salary_structure_doc
def create_delivery_trip(contact=None):
if not contact:
contact = get_contact_and_address("_Test Customer")
delivery_trip = dataent.new_doc("Delivery Trip")
delivery_trip.update({
"doctype":
"Delivery Trip",
"company":
epaas.get_default_company(),
"departure_time":
add_days(now_datetime(), 5),
"driver":
dataent.db.get_value('Driver', {"full_name": "Newton Scmander"}),
"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
}]
})
delivery_trip.insert()
return delivery_trip
def complete_setup(domain='Manufacturing'):
print("Complete Setup...")
from dataent.desk.page.setup_wizard.setup_wizard import setup_complete
if not dataent.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 = epaas.get_default_company()
if company:
company_doc = dataent.get_doc("Company", company)
company_doc.db_set('default_payroll_payable_account',
dataent.db.get_value('Account', dict(account_name='Payroll Payable')))
def validate(self):
check_repayment_method(self.repayment_method, self.loan_amount,
self.monthly_repayment_amount,
self.repayment_periods)
if not self.company:
self.company = epaas.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 = dataent.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)
if self.status == "Repaid/Closed":
self.total_amount_paid = self.total_payment
if self.status == 'Disbursed' and self.repayment_start_date < self.disbursement_date:
dataent.throw(
_("Repayment Start Date cannot be before Disbursement Date."))
if self.status == "Disbursed":
self.make_repayment_schedule()
self.set_repayment_period()
self.calculate_totals()
def get_payment_account():
return dataent.get_value(
'Account', {
'account_type': 'Cash',
'company': epaas.get_default_company(),
'is_group': 0
}, "name")
def test_payroll_frequency(self):
fiscal_year = get_fiscal_year(nowdate(),
company=epaas.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)
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 get_appropriate_company(filters):
if filters.get('company'):
company = filters['company']
else:
company = get_default_company()
return company
def setUp(self):
for dt in ["Salary Slip", "Salary Structure", "Salary Structure Assignment"]:
dataent.db.sql("delete from `tab%s`" % dt)
self.make_holiday_list()
dataent.db.set_value("Company", epaas.get_default_company(), "default_holiday_list", "Salary Structure Test Holiday List")
make_employee("*****@*****.**")
make_employee("*****@*****.**")
def get_valuation_rate(item_code,
warehouse,
voucher_type,
voucher_no,
allow_zero_rate=False,
currency=None,
company=None,
raise_error_if_no_rate=True):
# Get valuation rate from last sle for the same item and warehouse
if not company:
company = epaas.get_default_company()
last_valuation_rate = dataent.db.sql(
"""select valuation_rate
from `tabStock Ledger Entry`
where item_code = %s and warehouse = %s
and valuation_rate >= 0
order by posting_date desc, posting_time desc, name desc limit 1""",
(item_code, warehouse))
if not last_valuation_rate:
# Get valuation rate from last sle for the item against any warehouse
last_valuation_rate = dataent.db.sql(
"""select valuation_rate
from `tabStock Ledger Entry`
where item_code = %s and valuation_rate > 0
order by posting_date desc, posting_time desc, name desc limit 1""",
item_code)
if last_valuation_rate:
return flt(
last_valuation_rate[0]
[0]) # as there is previous records, it might come with zero rate
# If negative stock allowed, and item delivered without any incoming entry,
# system does not found any SLE, then take valuation rate from Item
valuation_rate = dataent.db.get_value("Item", item_code, "valuation_rate")
if not valuation_rate:
# try Item Standard rate
valuation_rate = dataent.db.get_value("Item", item_code,
"standard_rate")
if not valuation_rate:
# try in price list
valuation_rate = dataent.db.get_value(
'Item Price',
dict(item_code=item_code, buying=1, currency=currency),
'price_list_rate')
if not allow_zero_rate and not valuation_rate and raise_error_if_no_rate \
and cint(epaas.is_perpetual_inventory_enabled(company)):
dataent.local.message_log = []
dataent.throw(
_("Valuation rate not found for the Item {0}, which is required to do accounting entries for {1} {2}. If the item is transacting as a zero valuation rate item in the {1}, please mention that in the {1} Item table. Otherwise, please create an incoming stock transaction for the item or mention valuation rate in the Item record, and then try submiting/cancelling this entry"
).format(item_code, voucher_type, voucher_no))
return valuation_rate
def create_leave_period(from_date, to_date):
leave_period = dataent.get_doc({
"doctype": "Leave Period",
"company": epaas.get_default_company(),
"from_date": from_date,
"to_date": to_date,
"is_active": 1
}).insert()
return leave_period
def get_salary_component_account(sal_comp):
company = epaas.get_default_company()
sal_comp = dataent.get_doc("Salary Component", sal_comp)
if not sal_comp.get("accounts"):
sal_comp.append("accounts", {
"company": company,
"default_account": create_account(company)
})
sal_comp.save()
def test_loan(self):
branch = "Test Employee Branch"
applicant = make_employee("*****@*****.**")
company = epaas.get_default_company()
holiday_list = make_holiday("test holiday for loan")
company_doc = dataent.get_doc('Company', company)
if not company_doc.default_payroll_payable_account:
company_doc.default_payroll_payable_account = dataent.db.get_value(
'Account', {
'company': company,
'root_type': 'Liability',
'account_type': ''
}, 'name')
company_doc.save()
if not dataent.db.exists('Branch', branch):
dataent.get_doc({'doctype': 'Branch', 'branch': branch}).insert()
employee_doc = dataent.get_doc('Employee', applicant)
employee_doc.branch = branch
employee_doc.holiday_list = holiday_list
employee_doc.save()
loan = create_loan(applicant, "Personal Loan", 280000,
"Repay Over Number of Periods", 20)
loan.repay_from_salary = 1
loan.submit()
salary_structure = "Test Salary Structure for Loan"
make_salary_structure(salary_structure, "Monthly", employee_doc.name)
dates = get_start_end_dates('Monthly', nowdate())
make_payroll_entry(start_date=dates.start_date,
end_date=dates.end_date,
branch=branch)
name = dataent.db.get_value('Salary Slip', {
'posting_date': nowdate(),
'employee': applicant
}, 'name')
salary_slip = dataent.get_doc('Salary Slip', name)
for row in salary_slip.loans:
if row.loan == loan.name:
interest_amount = (280000 * 8.4) / (12 * 100)
principal_amount = loan.monthly_repayment_amount - interest_amount
self.assertEqual(row.interest_amount, interest_amount)
self.assertEqual(row.principal_amount, principal_amount)
self.assertEqual(row.total_payment,
interest_amount + principal_amount)
if salary_slip.docstatus == 0:
dataent.delete_doc('Salary Slip', name)
def execute(filters=None):
columns, data, chart = [], [], []
if filters.get('fiscal_year'):
company = epaas.get_default_company()
period_list = get_period_list(filters.get('fiscal_year'),
filters.get('fiscal_year'), "Monthly",
company)
columns = get_columns()
data = get_log_data(filters)
chart = get_chart_data(data, period_list)
return columns, data, None, chart
def create_additional_salary(employee, payroll_period, amount):
salary_date = add_months(payroll_period.start_date, random.randint(0, 11))
dataent.get_doc({
"doctype": "Additional Salary",
"employee": employee,
"company": epaas.get_default_company(),
"salary_component": "Performance Bonus",
"payroll_date": salary_date,
"amount": amount,
"type": "Earning"
}).submit()
return salary_date
def simulate(domain='Manufacturing', days=100):
runs_for = dataent.flags.runs_for or days
dataent.flags.company = epaas.get_default_company()
dataent.flags.mute_emails = True
if not dataent.flags.start_date:
# start date = 100 days back
dataent.flags.start_date = dataent.utils.add_days(
dataent.utils.nowdate(), -1 * runs_for)
current_date = dataent.utils.getdate(dataent.flags.start_date)
# continue?
demo_last_date = dataent.db.get_global('demo_last_date')
if demo_last_date:
current_date = dataent.utils.add_days(
dataent.utils.getdate(demo_last_date), 1)
# run till today
if not runs_for:
runs_for = dataent.utils.date_diff(dataent.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()
dataent.flags.current_date = current_date
if current_date.weekday() in (5, 6):
current_date = dataent.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:
dataent.db.set_global('demo_last_date', current_date)
raise
finally:
current_date = dataent.utils.add_days(current_date, 1)
dataent.db.commit()
def create_payroll_period():
if not dataent.db.exists("Payroll Period", "_Test Payroll Period"):
from datetime import date
payroll_period = dataent.get_doc(dict(
doctype = 'Payroll Period',
name = "_Test Payroll Period",
company = epaas.get_default_company(),
start_date = date(date.today().year, 1, 1),
end_date = date(date.today().year, 12, 31)
)).insert()
return payroll_period
else:
return dataent.get_doc("Payroll Period", "_Test Payroll Period")
def create_salary_structure_assignment(employee, salary_structure, from_date=None):
if dataent.db.exists("Salary Structure Assignment", {"employee": employee}):
dataent.db.sql("""delete from `tabSalary Structure Assignment` where employee=%s""",(employee))
salary_structure_assignment = dataent.new_doc("Salary Structure Assignment")
salary_structure_assignment.employee = employee
salary_structure_assignment.base = 50000
salary_structure_assignment.variable = 5000
salary_structure_assignment.from_date = from_date or add_months(nowdate(), -1)
salary_structure_assignment.salary_structure = salary_structure
salary_structure_assignment.company = epaas.get_default_company()
salary_structure_assignment.save(ignore_permissions=True)
salary_structure_assignment.submit()
return salary_structure_assignment
def make_holiday_list(self):
fiscal_year = get_fiscal_year(nowdate(),
company=epaas.get_default_company())
if not dataent.db.get_value("Holiday List",
"Salary Slip Test Holiday List"):
holiday_list = dataent.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 setUp(self):
make_earning_salary_component(setup=True)
make_deduction_salary_component(setup=True)
for dt in ["Leave Application", "Leave Allocation", "Salary Slip"]:
dataent.db.sql("delete from `tab%s`" % dt)
self.make_holiday_list()
dataent.db.set_value("Company", epaas.get_default_company(),
"default_holiday_list",
"Salary Slip Test Holiday List")
dataent.db.set_value("HR Settings", None,
"email_salary_slip_to_employee", 0)
def setup_employee():
dataent.db.set_value("HR Settings", None, "emp_created_by", "Naming Series")
dataent.db.commit()
for d in dataent.get_all('Salary Component'):
salary_component = dataent.get_doc('Salary Component', d.name)
salary_component.append('accounts', dict(
company=epaas.get_default_company(),
default_account=dataent.get_value('Account', dict(account_name=('like', 'Salary%')))
))
salary_component.save()
import_json('Employee')
holiday_list = dataent.db.get_value("Holiday List", {"holiday_list_name": str(now_datetime().year)}, 'name')
dataent.db.sql('''update tabEmployee set holiday_list={0}'''.format(holiday_list))
def create_exemption_declaration(employee, payroll_period):
create_exemption_category()
declaration = dataent.get_doc({
"doctype": "Employee Tax Exemption Declaration",
"employee": employee,
"payroll_period": payroll_period,
"company": epaas.get_default_company()
})
declaration.append(
"declarations", {
"exemption_sub_category": "_Test Sub Category",
"exemption_category": "_Test Category",
"amount": 100000
})
declaration.submit()
def test_duplicate_category_in_declaration(self):
declaration = dataent.get_doc({
"doctype": "Employee Tax Exemption Declaration",
"employee": dataent.get_value("Employee", {"user_id":"*****@*****.**"}, "name"),
"company": epaas.get_default_company(),
"payroll_period": "_Test Payroll Period",
"declarations": [
dict(exemption_sub_category = "_Test Sub Category",
exemption_category = "_Test Category",
amount = 100000),
dict(exemption_sub_category = "_Test Sub Category",
exemption_category = "_Test Category",
amount = 50000)
]
})
self.assertRaises(dataent.ValidationError, declaration.save)
def make_employee(user):
if not dataent.db.get_value("User", user):
dataent.get_doc({
"doctype": "User",
"email": user,
"first_name": user,
"new_password": "******",
"roles": [{
"doctype": "Has Role",
"role": "Employee"
}]
}).insert()
if not dataent.db.get_value("Employee", {"user_id": user}):
employee = dataent.get_doc({
"doctype":
"Employee",
"naming_series":
"EMP-",
"first_name":
user,
"company":
epaas.get_default_company(),
"user_id":
user,
"date_of_birth":
"1990-05-08",
"date_of_joining":
"2013-01-01",
"department":
dataent.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"
}).insert()
return employee.name
else:
return dataent.get_value("Employee", {"employee_name": user}, "name")
def test_exemption_amount(self):
declaration = dataent.get_doc({
"doctype": "Employee Tax Exemption Declaration",
"employee": dataent.get_value("Employee", {"user_id":"*****@*****.**"}, "name"),
"company": epaas.get_default_company(),
"payroll_period": "_Test Payroll Period",
"declarations": [
dict(exemption_sub_category = "_Test Sub Category",
exemption_category = "_Test Category",
amount = 80000),
dict(exemption_sub_category = "_Test1 Sub Category",
exemption_category = "_Test Category",
amount = 60000),
]
}).insert()
self.assertEqual(declaration.total_exemption_amount, 100000)
def make_timesheet_for_projects(current_date):
for data in dataent.get_all("Task", ["name", "project"], {
"status": "Open",
"exp_end_date": ("<", current_date)
}):
employee = get_random("Employee")
ts = make_timesheet(employee,
simulate=True,
billable=1,
company=epaas.get_default_company(),
activity_type=get_random("Activity Type"),
project=data.project,
task=data.name)
if flt(ts.total_billable_amount) > 0.0:
make_sales_invoice_for_timesheet(ts.name)
dataent.db.commit()
