diff --git a/hrms/payroll/report/salary_register/salary_register.js b/hrms/payroll/report/salary_register/salary_register.js index 4458c91026f..a0d5c1d9301 100644 --- a/hrms/payroll/report/salary_register/salary_register.js +++ b/hrms/payroll/report/salary_register/salary_register.js @@ -90,5 +90,11 @@ frappe.query_reports["Salary Register"] = { options: "Branch", width: "100px", }, + { + fieldname: "show_employer_contributions", + label: __("Show Employer Contributions"), + fieldtype: "Check", + default: 0, + }, ], }; diff --git a/hrms/payroll/report/salary_register/salary_register.py b/hrms/payroll/report/salary_register/salary_register.py index e8c41f26eb5..a377819bbed 100644 --- a/hrms/payroll/report/salary_register/salary_register.py +++ b/hrms/payroll/report/salary_register/salary_register.py @@ -8,9 +8,10 @@ import erpnext +from hrms.payroll.utils import COMPONENT_PARENTFIELDS + salary_slip = frappe.qb.DocType("Salary Slip") salary_detail = frappe.qb.DocType("Salary Detail") -salary_component = frappe.qb.DocType("Salary Component") def execute(filters=None): @@ -26,11 +27,15 @@ def execute(filters=None): if not salary_slips: return [], [] - earning_types, ded_types = get_earning_and_deduction_types(salary_slips) - columns = get_columns(earning_types, ded_types) + parentfields = get_active_parentfields(filters) + components = get_components_by_parentfield(salary_slips, parentfields) + fieldnames = get_component_fieldnames(components, parentfields) + columns = get_columns(components, fieldnames) - ss_earning_map = get_salary_slip_details(salary_slips, currency, company_currency, "earnings") - ss_ded_map = get_salary_slip_details(salary_slips, currency, company_currency, "deductions") + component_maps = { + parentfield: get_salary_slip_details(salary_slips, currency, company_currency, parentfield) + for parentfield in parentfields + } doj_map = get_employee_doj_map() @@ -56,11 +61,21 @@ def execute(filters=None): update_column_width(ss, columns) - for e in earning_types: - row.update({frappe.scrub(e): ss_earning_map.get(ss.name, {}).get(e)}) + for parentfield in parentfields: + amounts = component_maps[parentfield].get(ss.name, {}) + for component, amount in amounts.items(): + fieldname = fieldnames.get((parentfield, component)) + if fieldname: + row[fieldname] = amount - for d in ded_types: - row.update({frappe.scrub(d): ss_ded_map.get(ss.name, {}).get(d)}) + if components["employer_contributions"]: + row.update( + { + "total_employer_contribution": sum( + component_maps["employer_contributions"].get(ss.name, {}).values() + ) + } + ) if currency == company_currency: row.update( @@ -86,14 +101,49 @@ def execute(filters=None): return columns, data -def get_earning_and_deduction_types(salary_slips): - salary_component_and_type = {_("Earning"): [], _("Deduction"): []} +def get_active_parentfields(filters): + if filters.get("show_employer_contributions"): + return COMPONENT_PARENTFIELDS + + return ("earnings", "deductions") + + +def get_component_fieldnames(components, parentfields): + fieldnames = {} + used = set() + + for parentfield in parentfields: + for component in components[parentfield]: + fieldname = frappe.scrub(component) + if parentfield == "employer_contributions": + fieldname = f"employer_contribution_{fieldname}" + + if fieldname in used: + fieldname = f"{fieldname}_{len(used)}" + + used.add(fieldname) + fieldnames[(parentfield, component)] = fieldname - for salary_component in get_salary_components(salary_slips): - component_type = get_salary_component_type(salary_component) - salary_component_and_type[_(component_type)].append(salary_component) + return fieldnames - return sorted(salary_component_and_type[_("Earning")]), sorted(salary_component_and_type[_("Deduction")]) + +def get_components_by_parentfield(salary_slips, parentfields): + rows = get_salary_components(salary_slips) + components = {parentfield: set() for parentfield in COMPONENT_PARENTFIELDS} + pay_components = set() + + for parentfield in parentfields: + for row in rows: + if row.parentfield != parentfield: + continue + + if parentfield == "employer_contributions": + components[parentfield].add(row.salary_component) + elif row.salary_component not in pay_components: + components[parentfield].add(row.salary_component) + pay_components.add(row.salary_component) + + return {parentfield: sorted(names) for parentfield, names in components.items()} def update_column_width(ss, columns): @@ -107,7 +157,7 @@ def update_column_width(ss, columns): columns[9].update({"width": 120}) -def get_columns(earning_types, ded_types): +def get_columns(components, fieldnames): columns = [ { "label": _("Salary Slip ID"), @@ -195,11 +245,11 @@ def get_columns(earning_types, ded_types): }, ] - for earning in earning_types: + for earning in components["earnings"]: columns.append( { "label": earning, - "fieldname": frappe.scrub(earning), + "fieldname": fieldnames[("earnings", earning)], "fieldtype": "Currency", "options": "currency", "width": 120, @@ -216,11 +266,11 @@ def get_columns(earning_types, ded_types): } ) - for deduction in ded_types: + for deduction in components["deductions"]: columns.append( { "label": deduction, - "fieldname": frappe.scrub(deduction), + "fieldname": fieldnames[("deductions", deduction)], "fieldtype": "Currency", "options": "currency", "width": 120, @@ -254,15 +304,40 @@ def get_columns(earning_types, ded_types): "options": "currency", "width": 120, }, - { - "label": _("Currency"), - "fieldtype": "Data", - "fieldname": "currency", - "options": "Currency", - "hidden": 1, - }, ] ) + + for contribution in components["employer_contributions"]: + columns.append( + { + "label": contribution, + "fieldname": fieldnames[("employer_contributions", contribution)], + "fieldtype": "Currency", + "options": "currency", + "width": 120, + } + ) + + if components["employer_contributions"]: + columns.append( + { + "label": _("Total Employer Contribution"), + "fieldname": "total_employer_contribution", + "fieldtype": "Currency", + "options": "currency", + "width": 120, + } + ) + + columns.append( + { + "label": _("Currency"), + "fieldtype": "Data", + "fieldname": "currency", + "options": "Currency", + "hidden": 1, + } + ) return columns @@ -270,13 +345,9 @@ def get_salary_components(salary_slips): return ( frappe.qb.from_(salary_detail) .where((salary_detail.amount != 0) & (salary_detail.parent.isin([d.name for d in salary_slips]))) - .select(salary_detail.salary_component) + .select(salary_detail.parentfield, salary_detail.salary_component) .distinct() - ).run(pluck=True) - - -def get_salary_component_type(salary_component): - return frappe.db.get_value("Salary Component", salary_component, "type", cache=True) + ).run(as_dict=True) def get_salary_slips(filters, company_currency): @@ -324,14 +395,14 @@ def get_employee_doj_map(): return frappe._dict(result) -def get_salary_slip_details(salary_slips, currency, company_currency, component_type): +def get_salary_slip_details(salary_slips, currency, company_currency, parentfield): salary_slips = [ss.name for ss in salary_slips] result = ( frappe.qb.from_(salary_slip) .join(salary_detail) .on(salary_slip.name == salary_detail.parent) - .where((salary_detail.parent.isin(salary_slips)) & (salary_detail.parentfield == component_type)) + .where((salary_detail.parent.isin(salary_slips)) & (salary_detail.parentfield == parentfield)) .select( salary_detail.parent, salary_detail.salary_component, diff --git a/hrms/payroll/report/salary_register/test_salary_register.py b/hrms/payroll/report/salary_register/test_salary_register.py new file mode 100644 index 00000000000..8faa26de4b2 --- /dev/null +++ b/hrms/payroll/report/salary_register/test_salary_register.py @@ -0,0 +1,180 @@ +# Copyright (c) 2026, Frappe Technologies Pvt. Ltd. and Contributors +# License: GNU General Public License v3. See license.txt + +import frappe +from frappe.utils import add_months, get_first_day, get_last_day, getdate + +from erpnext.setup.doctype.employee.test_employee import make_employee + +from hrms.payroll.doctype.salary_structure.salary_structure import make_salary_slip +from hrms.payroll.doctype.salary_structure.test_salary_structure import ( + create_salary_structure_assignment, + make_salary_structure, +) +from hrms.payroll.report.salary_register.salary_register import execute +from hrms.tests.utils import HRMSTestSuite + +EMPLOYER_PF = "_Test Register Employer PF" +SHARED_PF = "_Test Register Shared PF" +PREFIXED_PF = "_Test Register PF" +CLASHING_PF = "Employer Contribution _Test Register PF" + + +class TestSalaryRegister(HRMSTestSuite): + def setUp(self): + self.employee = make_employee("test_salary_register@example.com", company="_Test Company") + self.start_date = get_first_day(add_months(getdate(), -1)) + self.end_date = get_last_day(self.start_date) + + def create_component(self, component, abbr, component_type): + if frappe.db.exists("Salary Component", component): + frappe.delete_doc("Salary Component", component, force=True) + + frappe.get_doc( + { + "doctype": "Salary Component", + "salary_component": component, + "salary_component_abbr": abbr, + "type": component_type, + } + ).insert() + + def create_salary_slip(self, salary_structure, posting_date): + salary_slip = make_salary_slip(salary_structure, employee=self.employee, posting_date=posting_date) + salary_slip.insert() + salary_slip.submit() + + return salary_slip + + def get_report(self, **filters): + return execute( + frappe._dict( + { + "company": "_Test Company", + "employee": self.employee, + "docstatus": "Submitted", + **filters, + } + ) + ) + + def create_structure_with_employer_contribution(self): + self.create_component(EMPLOYER_PF, "TREPF", "Employer Contribution") + + return make_salary_structure( + "_Test Salary Register Structure", + "Monthly", + employee=self.employee, + company="_Test Company", + currency="INR", + from_date=self.start_date, + other_details={ + "employer_contributions": [{"salary_component": EMPLOYER_PF, "abbr": "TREPF", "amount": 1800}] + }, + ) + + def test_employer_contributions_hidden_by_default(self): + salary_structure = self.create_structure_with_employer_contribution() + self.create_salary_slip(salary_structure.name, self.end_date) + + columns, data = self.get_report() + + fieldnames = [column["fieldname"] for column in columns] + self.assertNotIn(f"employer_contribution_{frappe.scrub(EMPLOYER_PF)}", fieldnames) + self.assertNotIn("total_employer_contribution", fieldnames) + self.assertEqual(len(data), 1) + + def test_employer_contributions_shown_with_filter(self): + salary_structure = self.create_structure_with_employer_contribution() + salary_slip = self.create_salary_slip(salary_structure.name, self.end_date) + + columns, data = self.get_report(show_employer_contributions=1) + + fieldname = f"employer_contribution_{frappe.scrub(EMPLOYER_PF)}" + fieldnames = [column["fieldname"] for column in columns] + self.assertIn(fieldname, fieldnames) + self.assertIn("total_employer_contribution", fieldnames) + + self.assertEqual(data[0][fieldname], 1800) + self.assertEqual(data[0]["total_employer_contribution"], 1800) + self.assertEqual(data[0]["net_pay"], salary_slip.net_pay) + + def test_component_shared_across_parentfields(self): + self.create_component(SHARED_PF, "TRSPF", "Deduction") + + deduction_structure = make_salary_structure( + "_Test Salary Register Deduction Structure", + "Monthly", + employee=self.employee, + company="_Test Company", + currency="INR", + from_date=self.start_date, + deductions=[{"salary_component": SHARED_PF, "abbr": "TRSPF", "amount": 1800}], + ) + deduction_slip = self.create_salary_slip(deduction_structure.name, self.end_date) + + frappe.db.set_value("Salary Component", SHARED_PF, "type", "Employer Contribution") + + next_start_date = add_months(self.start_date, 1) + contribution_structure = make_salary_structure( + "_Test Salary Register Contribution Structure", + "Monthly", + company="_Test Company", + currency="INR", + other_details={ + "employer_contributions": [{"salary_component": SHARED_PF, "abbr": "TRSPF", "amount": 2400}] + }, + ) + create_salary_structure_assignment( + self.employee, + contribution_structure.name, + from_date=next_start_date, + currency="INR", + allow_duplicate=True, + ) + contribution_slip = self.create_salary_slip( + contribution_structure.name, get_last_day(next_start_date) + ) + + columns, data = self.get_report(show_employer_contributions=1) + + deduction_fieldname = frappe.scrub(SHARED_PF) + contribution_fieldname = f"employer_contribution_{frappe.scrub(SHARED_PF)}" + fieldnames = [column["fieldname"] for column in columns] + + self.assertEqual(fieldnames.count(deduction_fieldname), 1) + self.assertEqual(fieldnames.count(contribution_fieldname), 1) + self.assertIn("total_employer_contribution", fieldnames) + + rows = {row["salary_slip_id"]: row for row in data} + self.assertEqual(rows[deduction_slip.name][deduction_fieldname], 1800) + self.assertEqual(rows[contribution_slip.name][contribution_fieldname], 2400) + self.assertEqual(rows[contribution_slip.name]["total_employer_contribution"], 2400) + + def test_scrubbed_names_do_not_clash_across_parentfields(self): + self.create_component(PREFIXED_PF, "TRPF", "Employer Contribution") + self.create_component(CLASHING_PF, "ECTRPF", "Deduction") + + salary_structure = make_salary_structure( + "_Test Salary Register Clash Structure", + "Monthly", + employee=self.employee, + company="_Test Company", + currency="INR", + from_date=self.start_date, + deductions=[{"salary_component": CLASHING_PF, "abbr": "ECTRPF", "amount": 500}], + other_details={ + "employer_contributions": [{"salary_component": PREFIXED_PF, "abbr": "TRPF", "amount": 1800}] + }, + ) + self.create_salary_slip(salary_structure.name, self.end_date) + + columns, data = self.get_report(show_employer_contributions=1) + + deduction_column = next(column for column in columns if column["label"] == CLASHING_PF) + contribution_column = next(column for column in columns if column["label"] == PREFIXED_PF) + + self.assertNotEqual(deduction_column["fieldname"], contribution_column["fieldname"]) + self.assertEqual(data[0][deduction_column["fieldname"]], 500) + self.assertEqual(data[0][contribution_column["fieldname"]], 1800) + self.assertEqual(data[0]["total_employer_contribution"], 1800)