Salary processing method and device, electronic equipment and storage medium

Abstract

The invention provides a salary processing method and device, electronic equipment and a storage medium. The salary processing method comprises the steps that salary data sources of all employees in a target salary issuing period are acquired; obtaining a salary calculation snapshot of the current latest version from a configuration unit; compiling and verifying a DSL salary calculation formula in the salary calculation snapshot; if compiling and checking succeed, based on a DSL salary calculation formula, a tax rate table, social security and public accumulation fund cardinal number parameters and a salary data source, salary data of all employees are calculated in parallel through a code running unit; and performing unified rounding processing on the salary data of each employee based on the precision strategy of each currency, and generating a final salary amount. According to the invention, the efficiency and accuracy of salary processing are improved.

Description

Technical Field

[0001] This invention relates to the field of data processing technology, and more specifically, to a payroll processing method, apparatus, electronic device, and storage medium. Background Technology

[0002] In large enterprises, salary calculations typically involve highly complex business rules that must be adapted to different regional tax policies, social security and housing fund contribution standards, currency systems, and diverse incentive structures (such as tiered tax rates, regional subsidies, performance bonuses, and stock options).

[0003] Traditional payroll systems often employ hard-coded logic or calculation mechanisms based on simple expression engines, which are difficult to effectively support such dynamic and heterogeneous payroll scenarios.

[0004] On the one hand, whenever tax rates are adjusted, social security bases are updated, or new wage items are added, developers need to intervene to modify the source code, perform full regression testing, and arrange for system shutdown for release, resulting in long response cycles, high maintenance costs, and the risk of inconsistent configurations due to oversights in version management.

[0005] On the other hand, when faced with batch calculation tasks involving tens of thousands or even hundreds of thousands of employees, payroll calculation is inefficient, the calculation process is easily affected by intermediate states, resulting in deviations in the results and low accuracy. Summary of the Invention

[0006] In view of this, the purpose of the present invention is to provide a payroll processing method, apparatus, electronic device and storage medium to improve the efficiency and accuracy of payroll processing.

[0007] Firstly, a payroll processing method is provided, applied to a payroll calculation engine. The payroll calculation engine includes a configuration unit and a code execution unit. The configuration unit is used to configure payroll calculation rule parameters independently of the code, and generates a payroll calculation snapshot based on the configured payroll calculation rule parameters, thereby decoupling the payroll calculation rule parameters from the payroll calculation code. The code execution unit is used to load the payroll calculation snapshot and execute the payroll calculation. The method includes: Obtain the salary data source for each employee within the target pay period; Obtain the latest version of the payroll calculation snapshot from the configuration unit. The payroll calculation snapshot encapsulates at least several DSL payroll calculation formulas, tax rate tables, social security and housing provident fund base parameters, and precision strategies for each currency. Compile and verify the DSL salary calculation formula in the salary calculation snapshot; If compilation and verification are successful, the salary data of each employee will be calculated in parallel using the code execution unit based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and salary data source. The salary data of each employee is uniformly rounded based on the precision strategy of each currency to generate the final salary amount.

[0008] Optionally, compiling and verifying the DSL salary calculation formula in the salary calculation snapshot includes: Parse the salary calculation formula for each DSL and generate the corresponding abstract syntax tree; The type of each node in the abstract syntax tree is deduced to obtain the type of each node, and type validation is performed based on the preset type rules; In response to successful type validation, extract the variable names of other formulas referenced in the DSL salary calculation formula and construct a directed graph of dependencies with each DSL salary calculation formula as a node; Perform a depth-first search on the directed graph of dependencies to detect the existence of circular dependency cycles; In response to a type validation failure or the detection of a circular dependency cycle, the currently compiling DSL salary calculation formula is marked as a compilation failure, and location information including the formula name, row and column numbers, context code snippets, and error type is generated.

[0009] Optionally, based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters, and salary data source, the salary data of each employee is calculated in parallel using code execution units, including: Based on employee identification, all employee payroll data sources are distributed to multiple parallel computing threads; In each parallel computing thread, a unique idempotent key is generated for each employee's computing task. The idempotent key consists of the payroll batch identifier, the employee identifier, and the payroll calculation snapshot. Before performing the calculation, check if the idempotent key already exists; In response to the absence of an idempotent key, the task status of the corresponding employee is marked as "processing", and the salary calculation is performed based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and salary data source. If the idempotent key already exists and the status is successful, the stored calculation result is returned directly. If an idempotent key already exists but is in the processing state and a preset timeout threshold has been exceeded, the calculation will be re-executed.

[0010] Optionally, the salary data for each employee is uniformly rounded based on the precision strategy for each currency, generating the final salary amount, including: After all employees' salaries have been calculated, a one-time rounding process is performed on each employee's salary data according to the precision strategy and rounding mode corresponding to the target currency. The salary data includes gross payable, deductions, and net pay. The precision strategy includes the number of decimal places. The rounding mode includes rounding to the nearest whole number, rounding up, or rounding down, and is configured according to the currency. Perform a global tail error check on the salary data of each employee after rounding; the global tail error check is to check the deviation between the total amount after rounding and the total amount before rounding. If the deviation of the global tail difference check exceeds the preset deviation value, the payroll process will be blocked and a financial review alarm will be generated.

[0011] Optionally, the method further includes: Using employee identifiers as keys, the rounded salary data for each employee is aggregated to generate a summary vector containing total payable, individual income tax, social security deductions, housing provident fund deductions, and net pay. Assemble the summary vectors of all employees into a payroll bill object with a uniform format; Perform deterministic serialization on the payroll object to generate a standardized JSON string. The deterministic serialization includes: sorting all field names in lexicographical order, removing irrelevant whitespace characters, and uniformly representing numerical values ​​as decimal strings without thousands separators. Call the key management service to obtain the key bound to the current pay cycle; Calculate the digital signature based on the standardized JSON string and the obtained key; Encapsulate the digital signature, the key used, and the payroll object into a digitally signed payroll statement.

[0012] Optionally, the method further includes: Build a payment request based on each employee's payroll; By calling the disbursement adapter corresponding to the target bank, a payment request is sent to the target bank's API interface; Receive payment receipts returned by the target bank's API interface; Perform a reconciliation operation based on the total amount actually paid in the payroll statement and the total amount received in the payment receipt.

[0013] Optionally, the method further includes: Serialize the salary data source of each employee within the target pay period into a read-only input file and calculate the hash value of the input file; After payroll disbursement and reconciliation are completed, the hash value of the input file, payroll calculation snapshot, payroll statement summary, payment receipt and reconciliation results are packaged into an audit record; Audit records are written to the audit repository, and a hash chain is generated based on the hash value of the previous audit records to form an audit snapshot that can be replayed and verified later.

[0014] Secondly, a payroll processing device is provided, applied to a payroll calculation engine. The payroll calculation engine includes a configuration unit and a code execution unit. The configuration unit is used to configure payroll calculation rule parameters independently of the code, and to generate a payroll calculation snapshot based on the configured payroll calculation rule parameters, thereby decoupling the payroll calculation rule parameters from the payroll calculation code. The code execution unit is used to load the payroll calculation snapshot and execute the payroll calculation. This includes: The first acquisition unit is used to acquire the salary data source of each employee within the target pay period; The second acquisition unit is used to obtain the latest version of the salary calculation snapshot from the configuration unit. The salary calculation snapshot encapsulates at least several DSL salary calculation formulas, tax rate tables, social security and housing provident fund base parameters, and precision strategies for each currency. The compilation unit is used to compile and verify the DSL salary calculation formula in the salary calculation snapshot; The calculation unit, if the compilation and verification are successful, uses the code execution unit to calculate the salary data of each employee in parallel based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and salary data source. The rounding unit is used to perform uniform rounding of each employee's salary data based on the precision strategy of each currency, and generate the final salary amount.

[0015] Thirdly, an electronic device is provided, including a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; Memory, used to store computer programs; A processor, when executing a program stored in memory, implements any of the methods of the first aspect.

[0016] Fourthly, a computer-readable storage medium is provided, wherein a computer program is stored therein, and when the computer program is executed by a processor, it implements any of the methods of the first aspect.

[0017] This invention provides a payroll processing method, apparatus, electronic device, and storage medium. Firstly, by configuring a unit and establishing a payroll calculation snapshot mechanism, it completely decouples payroll rules from the calculation code. When a company needs to update tiered tax rates, regional subsidy rules, or add performance bonus items due to policy adjustments, business personnel only need to complete the modifications in the configuration interface and generate a new snapshot. No development intervention, no system downtime for deployment, and no full regression testing are required. This significantly shortens the response cycle for rule changes from the traditional days or even weeks to minutes, while fundamentally avoiding the inconsistency risks caused by code and configuration version mismatches. It meets the business needs of high-frequency iteration of payroll rules under multiple regions, currencies, and policies.

[0018] Secondly, by performing static verification of the DSL salary calculation formula during compilation, the interruption of the entire payroll or financial errors caused by formula errors by individual employees are avoided, which greatly improves the robustness of the calculation process and the accuracy of the results.

[0019] Finally, relying on the parallel computing architecture and unified rounding processing strategy of the code execution unit, it can complete the accurate calculation of hundreds of thousands of employees within minutes, improving computing efficiency and ensuring that the final output salary amount strictly complies with the financial compliance requirements of each currency.

[0020] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, preferred embodiments are described below in detail with reference to the accompanying drawings. Attached Figure Description

[0021] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the embodiments will be briefly introduced below. It should be understood that the following drawings only show some embodiments of the present invention and should not be regarded as a limitation on the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0022] Figure 1 A flowchart of a payroll processing method provided by an embodiment of the present invention is shown; Figure 2 A flowchart of another payroll processing method provided by an embodiment of the present invention is shown; Figure 3 A schematic diagram of the structure of a payroll processing device provided in an embodiment of the present invention is shown; Figure 4 A schematic diagram of the structure of an electronic device provided in an embodiment of the present invention is shown. Detailed Implementation

[0023] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without inventive effort are within the scope of protection of the present invention.

[0024] This invention provides a payroll processing method applied to a payroll calculation engine. The payroll calculation engine includes a configuration unit and a code execution unit. The configuration unit is used to configure payroll calculation rule parameters independently of the code and generate a payroll calculation snapshot based on the configured payroll calculation rule parameters, so as to decouple the payroll calculation rule parameters from the payroll calculation code. The code execution unit is used to load the payroll calculation snapshot and execute the payroll calculation.

[0025] The generation of payroll calculation snapshots follows a strict version control process, including four stages: draft, review, pre-release, and official release.

[0026] Specifically, each rule change must go through a process of "draft → review → pre-release → official release". Upon official release, a structured version identifier is automatically generated, and a unique run_tag is constructed for this payroll run. The generation algorithm is defined as follows: run_tag:=<period_id> _<batch_no> _<cfg_hash> _ <seq>; Where: period_id: target pay period (e.g., 202506); batch_no: batch number within this period (e.g., 01 for the first pay period, 02 for the supplementary pay period); cfg_hash: Global fingerprint of configuration content; calculated using SHA256(rules_ver_content||formula_ver_content||exchange_tag_content||precision_policy_content), ensuring that any changes to rules, formulas, exchange rate tags, or precision policies generate a new hash; seq: Sequence number under the same configuration, used to distinguish rerun scenarios such as reversal and reissue.

[0027] At the same time, rules_ver (business rule set version) and formula_ver (DSL formula set version) are generated respectively, and together with cfg_hash, they form the metadata core of the snapshot.

[0028] All versioned content is persistently stored as immutable documents, supporting highly reliable retrieval and auditing.

[0029] In addition, to ensure the integrity and tamper-proof nature of the snapshot, secure signatures are implemented through an enterprise-level key management system, which includes: Key escrow: The master key is escrowed by a cloud key management service (such as CMK in AWSKMS), and compute nodes only call the "signature API" through short-term access credentials; the key is never stored in the public domain. Signature generation: Calculate HMAC-SHA256(snapshot_body, KMS.sign()) on the main content (snapshot_body) of activity_snapshot to generate a digital signature; Atomicity guarantee: Signature calculation and audit log writing operations are included in the same database transaction to ensure that every log entry has a valid signature and to prevent forgery after the fact.

[0030] Through the above mechanism, the embodiments of the present invention achieve complete decoupling of rules and code: after HR modifies the social security base, a new snapshot can be released after review without the need for development intervention; any payroll result can be accurately restored through run_tag to restore the rules, formulas, exchange rates and precision strategies at that time; from configuration generation to running records, the entire process relies on cryptographic hashes and digital signatures to meet financial-grade audit requirements.

[0031] like Figure 1 As shown, the method includes the following steps: Step S101: Obtain the salary data source for each employee within the target pay period.

[0032] In this embodiment of the invention, the payroll data source refers to the set of original business data required for payroll calculation. This data typically originates from the enterprise's human resources information system or master data management platform, including but not limited to basic employee information (such as employee ID and name), attendance data (such as attendance days and overtime hours), performance results, preset pay items (such as basic salary and position allowance), and special additional deduction information obtained from external systems.

[0033] Specifically, in one feasible implementation, the relevant data of all employees within the target payroll period (e.g., June 2025) can be retrieved from the upstream HR system before the payroll process starts via API interface or database synchronization task, and loaded into the memory or temporary storage area of ​​the computing engine to provide input for subsequent batch calculations.

[0034] This step, by centrally acquiring and structuring these heterogeneous data sources, lays a solid data foundation for achieving efficient and accurate automated payroll calculation.

[0035] Step S102: Obtain the latest version of the payroll calculation snapshot from the configuration unit.

[0036] In this embodiment of the invention, the configuration unit is a rule management module independent of the core calculation code, which allows payroll specialists or HR to maintain the salary calculation logic through a graphical interface or configuration file.

[0037] A payroll calculation snapshot is an immutable, self-contained configuration package generated by this configuration unit at a specific point in time.

[0038] For example, the payroll calculation snapshot encapsulates at least several payroll calculation formulas written in a domain-specific language (DSL) (such as net_pay=gross_pay-tax-social_security), tax rate tables applicable to different regions, upper and lower limits and ratio parameters of social security and housing provident fund contribution bases, and precision strategies (i.e. decimal places) defined for different currencies (such as CNY, USD, JPY).

[0039] It should be noted that by introducing a snapshot mechanism, the dynamically changing business rules are successfully decoupled from the static computing engine code, so that any rule change does not require redeployment or service restart, which greatly improves the system's flexibility and maintainability.

[0040] Step S103: Compile and verify the DSL salary calculation formula in the salary calculation snapshot.

[0041] Following the previous example, to ensure the correctness and security of the formulas, a rigorous static analysis must be performed on all DSL salary calculation formulas in the snapshot before the formal calculation is executed. This step is a crucial preliminary step to ensure the reliability of the entire salary calculation process, and its specific details will be elaborated in subsequent embodiments.

[0042] Step S104: If compilation and verification are successful, the salary data of each employee will be calculated in parallel using the code execution unit based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and salary data source.

[0043] In this embodiment of the invention, the code execution unit is the core unit responsible for performing actual numerical calculations. After the verification in step S103 passes, this unit loads the verified salary calculation snapshot and starts large-scale parallel computing.

[0044] Specifically, distributed computing frameworks (such as Apache Spark or Flink) can be used to distribute the computing tasks of a large number of employees to multiple worker nodes in the cluster for simultaneous processing. Each worker node, based on the assigned employee data, sequentially applies the DSL salary calculation formula, queries the tax rate table and social security parameters, and calculates the employee's gross salary, various deductions, and final net pay amount item by item.

[0045] This parallel processing mode can reduce computational tasks that originally took hours to complete in minutes, significantly improving the efficiency and timeliness of payroll calculation for large enterprises.

[0046] Step S105: Based on the precision strategy of each currency, perform unified rounding processing on the salary data of each employee to generate the final salary amount.

[0047] In this embodiment of the invention, since different countries and regions have strict rules on the number of decimal places in their monetary systems (for example, the Japanese yen usually does not retain decimals, while the RMB and the US dollar retain two decimal places), directly using floating-point numbers to calculate the result may lead to bank payment failures or financial reconciliation discrepancies.

[0048] Therefore, after the accurate calculations for all employees are completed, the system will query the preset precision strategy and rounding mode (such as rounding to the nearest whole number, rounding up, etc.) based on the currency corresponding to each employee's salary, and perform a one-time rounding operation on all amount fields, including total payable, individual income tax, social security deductions, housing provident fund deductions, and net pay.

[0049] For example, a calculated amount of RMB 8500.456 will be determined as 8500.46 after applying the strategy of "keeping two decimal places and rounding".

[0050] This step ensures that the final output salary amount fully complies with the compliance requirements of financial transactions.

[0051] As described in the above embodiments, this invention first decouples salary rules from the calculation code through a configuration unit and a salary calculation snapshot mechanism. When an enterprise needs to update tiered tax rates, regional subsidy rules, or add performance bonus items due to policy adjustments, business personnel only need to complete the modifications in the configuration interface and generate a new snapshot, without development intervention, downtime for release, or full regression testing. This significantly shortens the response cycle for rule changes from the traditional days or even weeks to minutes, while fundamentally avoiding the inconsistency risk caused by code and configuration version mismatch, meeting the business needs of high-frequency iteration of salary rules under multiple regions, currencies, and policies.

[0052] Secondly, by performing static verification of the DSL salary calculation formula during compilation, the interruption of the entire payroll or financial errors caused by formula errors by individual employees are avoided, which greatly improves the robustness of the calculation process and the accuracy of the results.

[0053] Finally, relying on the parallel computing architecture and unified rounding strategy of the code execution unit, accurate calculations for hundreds of thousands of employees can be completed within minutes, improving computational efficiency and ensuring that the final output salary amount strictly complies with the financial compliance requirements of each currency. The entire calculation process is based on a fixed salary calculation snapshot, unaffected by external state interference, ensuring the reproducibility and consistency of the results.

[0054] Based on the above embodiments, compiling and verifying the DSL salary calculation formula in the salary calculation snapshot includes: Step S103A: Parse the salary calculation formula for each DSL and generate the corresponding abstract syntax tree.

[0055] In this embodiment of the invention, the salary calculation engine has a built-in parser based on predefined EBNF syntax rules.

[0056] The parser reads the DSL salary calculation formula string (such as IF(performance>0.8,bonus*1.2,bonus)) and converts it into a tree-like data structure, namely an Abstract Syntax Tree (AST). Each node in the AST represents a syntactic component of the formula, such as an assignment, function call, variable reference, literal, or operator.

[0057] This step, by constructing an AST, transforms the textual formulas into a structured representation that is easy for computers to understand and process, providing a foundation for subsequent deep analysis.

[0058] Step S103B: Derive the type of each node in the abstract syntax tree to obtain the type of each node, and perform type verification based on the preset type rules.

[0059] In this embodiment of the invention, the salary calculation engine performs a post-order traversal of the AST, deriving the data type of each node from bottom to top. The type fields include numeric, boolean, string, etc., and the numeric type will be further labeled with currency, unit of measurement and decimal places.

[0060] After the derivation is complete, the system will apply a series of preset type rules for verification. For example, addition or subtraction operations require that both operands be numeric types of the same currency, or that one of them is the result of an explicit call to the EXCHANGE currency conversion function; the LOOKUP function must return a numeric type with a currency label; and the ROUND function must inherit the currency of its input value.

[0061] For example, if the formula contains CNY_amount+USD_amount and EXCHANGE is not used, the type validation will fail.

[0062] This process can accurately capture logical errors caused by data type mismatches before calculation, effectively preventing runtime exceptions and financial errors.

[0063] Step S103C: In response to successful type verification, extract the variable names of other formulas referenced in the DSL salary calculation formula, and construct a directed graph of dependencies with each DSL salary calculation formula as a node.

[0064] In this embodiment of the invention, once the internal semantics of a single formula is confirmed to be valid, the salary calculation engine will further analyze its interaction with other formulas.

[0065] Specifically, it will scan all variable nodes in the formula's AST to identify which variable names are actually defined by other DSL formulas (rather than HR master data fields).

[0066] For example, if both `gross` and `tax` in the formula `net=gross-tax` are defined by other formulas, it indicates that the `net` formula depends on the `gross` and `tax` formulas.

[0067] Treat all formulas as nodes in a graph and establish directed edges based on these reference relationships to construct a complete directed graph of dependencies.

[0068] Step S103D: Perform a depth-first search on the directed graph of dependencies to detect whether a circular dependency cycle exists.

[0069] In this embodiment of the invention, in order to avoid the formation of infinite loops due to mutual references between formulas (such as A depending on B, and B depending on A), the depth-first search (DFS) algorithm will be performed on the directed graph constructed above.

[0070] During Depth-First Search (DFS), the system maintains the access state of nodes. If a node that is currently in the recursive stack (i.e., a back edge) is encountered during traversal, it is determined that a circular dependency exists in the graph.

[0071] For example, if the path bonus→performance_bonus→bonus is detected, a dependency cycle is formed.

[0072] This step ensures the computability of the entire formula system and prevents the calculation engine from getting stuck in infinite recursion.

[0073] Step S0103E: In response to a type validation failure or the detection of a circular dependency cycle, mark the currently compiling DSL salary calculation formula as a compilation failure and generate location information including the formula name, row and column numbers, context code snippets, and error type.

[0074] In this embodiment of the invention, if either type verification or dependency loop detection fails, the relevant formula will be marked as compile_failed and prevented from participating in subsequent salary calculations.

[0075] In addition, to facilitate quick problem location and repair by operations and maintenance personnel, a detailed diagnostic report will be generated. This report precisely indicates the name of the formula in which the error occurred, its row and column position in the formula text, the code snippets (context) before and after the error point, and the specific error type (such as "currency mismatch" or "circular dependency exists").

[0076] This sophisticated error feedback mechanism significantly reduces the debugging costs and deployment risks associated with configuring pay rules.

[0077] Based on the above embodiments, and using the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters, and salary data source, the code execution unit calculates the salary data of each employee in parallel, including: Step S104A: Based on the employee identifier, distribute all employee salary data sources to multiple parallel computing threads.

[0078] In this embodiment of the invention, in order to achieve high throughput and low latency batch computing, the Ketama consistent hashing algorithm can be used to intelligently bucket employees.

[0079] For example, using the employee identifier (employee_id) as the hash key, configure 100 virtual nodes (V=100) and divide the hash ring into N slots, where N is dynamically configured proportionally based on the size of the currently available compute nodes or thread pool.

[0080] This strategy not only ensures the balanced distribution of employee tasks across nodes, but also minimizes data migration during scaling up and down, achieving smooth scalability. Each slot corresponds to a "computation bucket," and employees within the bucket are loaded into memory in batches, laying the foundation for subsequent vectorized processing.

[0081] Step S104B: In each parallel computing thread, generate a unique idempotent key for each employee's computing task. The idempotent key consists of the payroll batch identifier, the employee identifier, and the payroll calculation snapshot.

[0082] In this embodiment of the invention, to ensure exactly-once semantics of computation in a distributed environment, the system generates a fine-grained idempotent key for each computation unit. Its structure is defined as: idemp_key =<tenant_id> _<period_id> _<employee_id> _ <component>_<run_tag> ; Among them, tenant_id identifies the tenant, period_id is the pay period (e.g., 202506), employee_id is the unique identifier of the employee, component can be refined to the salary item (e.g., "net_pay"), and run_tag is the running identifier composed of cfg_hash, etc.

[0083] This design allows for precise differentiation of computational tasks performed by the same employee under different cycles, configurations, or payroll components, avoiding cross-interference.

[0084] Step S104C: Before performing the calculation, determine whether the idempotent key already exists.

[0085] In this embodiment of the invention, before executing any computational logic, the system initiates an atomic operation with a high-concurrency caching service (such as Redis) to query the status of the idemp_key. This operation is a crucial pre-check to ensure idempotency.

[0086] Step S104D: In response to the absence of an idempotent key, mark the task status of the corresponding employee as "processing" and perform salary calculation based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters, and salary data source.

[0087] In this embodiment of the invention, if the idemp_key does not exist in Redis, the lock will be preempted by the atomic command SETNX(idemp_key,"in_progress",EX=900). If successful, the task status will be set to "processing" and the computation will be started.

[0088] It's worth noting that in-bucket computations are not processed row by row, but rather employ a columnar memory layout (such as Apache Arrow or the Vector API). Fields like base_salary, bonus, and insurance for employees in the same batch are organized into vectors, and batch operations and window aggregation are performed using the CPU's SIMD instructions, significantly improving computational efficiency. For example, the individual income tax calculation for 10,000 employees can be completed in a single vectorized expression, instead of looping 10,000 times.

[0089] Step S104E: In response to the existence of an idempotent key and a success status, the stored calculation result is returned directly.

[0090] In this embodiment of the invention, if the query finds that the idemp_key already exists and has the value "done" (usually with an expiration time of 86400 seconds), it indicates that the task has been successfully completed. The system directly returns the cached data from the result storage to avoid duplicate calculations and ensure result consistency.

[0091] Step S104F: In response to the fact that an idempotent key already exists but the status is "processing" and the preset timeout threshold has been exceeded, the calculation is re-executed.

[0092] In this embodiment of the invention, if idemp_key exists and its value is "in_progress", its remaining Time-to-Live (TTL) will be further checked. If the TTL has been exhausted (i.e., more than 900 seconds), it indicates that the original task may have been abnormally interrupted due to process crash, node failure, or other reasons.

[0093] At this point, the background timeout inspector will periodically scan keys that have been in the "in_progress" state for a long time and add them back to the calculation queue for retry.

[0094] To prevent infinite retries, if an employee's task fails after a preset threshold of retries (e.g., 3 times), it will be sent to the Dead Letter Queue (DLQ) and an alarm will be triggered to notify manual intervention for review.

[0095] Furthermore, if a computing slot fails more than the circuit breaker threshold within a given time period, the system will automatically trigger a slot-level circuit breaker mechanism, suspending the injection of new tasks into that slot and generating an engineering work order so that the operations team can promptly investigate underlying resource or logic defects. Upon successful task completion, the system updates the idemp_key value to "done" and sets a relatively long expiration time (e.g., 86400 seconds), preserving short-term idempotency while preventing long-term cache accumulation.

[0096] This invention, through a state machine design based on idempotent keys, effectively solves the problem of duplicate calculations or calculation loss caused by network jitter or service restarts in a distributed environment, ensuring that each employee's salary is calculated correctly only once.

[0097] Based on the above embodiments, the salary data of each employee is uniformly rounded according to the precision strategy of each currency to generate the final salary amount, including: Step S105A: After all employees have completed their calculations, perform a one-time rounding process on each employee's salary data according to the precision strategy and rounding mode corresponding to the target currency.

[0098] As mentioned earlier, this step ensures the compliance of the amount format. Specifically, the payroll calculation engine maintains a currency configuration table, which defines the number of decimal places and rounding mode for each currency. The calculation engine reads this table during the aggregation phase and rounds the salary details for each employee.

[0099] The salary data includes gross payable, deducted amount, and net payable amount; the precision strategy includes the number of decimal places; the rounding mode includes rounding to the nearest whole number, rounding up or rounding down, and is configured by currency.

[0100] It should be noted that all intermediate calculation results use high-precision decimal (such as BigDecimal / fixed-point scale=9~12) and are not rounded. Only end formatting is performed at the component output and final aggregation / billing to avoid the accumulation of errors from multiple rounding steps.

[0101] Step S105B: Perform a global tail error check on the rounded salary data of each employee; the global tail error check is to check the deviation between the total amount after rounding and the total amount before rounding.

[0102] In this embodiment of the invention, although the rounding error of a single employee is small, the accumulation of these tiny errors (i.e., the tail error) can become significant when there are tens of thousands of employees.

[0103] Therefore, this embodiment of the invention calculates the total amount actually paid to all employees before rounding. Total amount actually paid after rounding And calculate the difference. .

[0104] Step S105C: If the deviation of the global tail difference verification exceeds the preset deviation value, the payroll process will be blocked and a financial review alarm will be generated.

[0105] In this embodiment of the invention, a reasonable tolerance threshold can be set (e.g., ±0.50 yuan). Within this threshold, the system can be automatically balanced using a preset tail difference adjustment account.

[0106] However, if |Δ| exceeds the threshold, it indicates that there may be a more serious calculation logic error or data anomaly. At this time, the entire payroll process will be immediately blocked, and a high-priority alarm will be sent to the finance team, requiring manual intervention for verification, thereby eliminating the financial risks caused by large discrepancies.

[0107] Based on the above embodiments, such as Figure 2 As shown, the method also includes: Step S106: Using the employee identifier as the key, aggregate the rounded salary data for each employee to generate a summary vector containing the total amount payable, individual income tax, social security deductions, housing provident fund deductions, and net amount paid.

[0108] This step aims to organize the scattered calculation results into structured data units. Each employee corresponds to a summary vector, which is a set of key-value pairs that clearly lists the final amount of each salary component.

[0109] Step S107: Assemble the summary vectors of all employees into a payroll bill object with a uniform format.

[0110] In this embodiment of the invention, this step aims to organize the scattered calculation results into structured data units. Each employee corresponds to a summary vector, which is a set of key-value pairs that clearly lists the final amount of each component of the salary.

[0111] Step S108: Perform deterministic serialization on the payroll object to generate a standardized JSON string.

[0112] In this embodiment of the invention, for subsequent digital signatures, it must be ensured that the string result of the same bill is completely consistent no matter when it is serialized.

[0113] Therefore, a deterministic serialization strategy is adopted: first, all field names of JSON objects are sorted in lexicographical order; then, all unnecessary spaces, tabs and newlines are removed; and all values ​​(even integers) are uniformly formatted as decimal strings without thousands separators (e.g., 1000 becomes "1000.00").

[0114] For example, a nondeterministic {"b":2,"a":1} would be normalized to {"a":"1.00","b":"2.00"}.

[0115] Step S109: Call the key management service to obtain the key bound to the current pay cycle.

[0116] In this embodiment of the invention, the Key Management Service (KMS) is a secure, centralized key escrow system. The payroll calculation engine requests a private key or symmetric key uniquely associated with the current pay period (e.g., June 2025) from the KMS to generate a digital signature.

[0117] Step S110: Calculate the digital signature based on the standardized JSON string and the obtained key.

[0118] In this embodiment of the invention, a standard cryptographic algorithm (such as HMAC-SHA256 or RSA) can be used to sign the standardized JSON string generated in step S108 to obtain a unique and unforgeable digital signature.

[0119] Step S111: Encapsulate the digital signature, the key used, and the payroll object into a digitally signed payroll statement.

[0120] In this embodiment of the invention, the final payroll not only contains the original data, but also includes a digital signature and a key identifier.

[0121] Any recipient (such as a bank or auditing department) can use the publicly available signature verification method and the corresponding public key to verify whether the bill has been tampered with since its generation, thereby ensuring the integrity and non-repudiation of the payroll data.

[0122] Based on the above embodiments, the method further includes: Step S112: Construct a payment request based on each employee's payroll.

[0123] In this step, the payroll calculation engine parses the payroll statement, extracts each employee's bank account information and net payout amount, and assembles it into a batch payment instruction according to the target bank's API specifications (such as ISO20022 XML or JSON format).

[0124] Step S113: Send a payment request to the API interface of the target bank by calling the issuing adapter corresponding to the target bank.

[0125] In this embodiment of the invention, an adapter pattern is adopted to ensure compatibility with the interface differences between different banks. Each bank has a dedicated issuing adapter, which is responsible for converting internally common payment requests into a message format specific to that bank and calling its API.

[0126] Step S114: Receive the payment receipt returned by the target bank's API interface.

[0127] In this step, after the bank processes the payment request, it will return an electronic receipt via API callback or active query, which includes information such as transaction serial number, processing status (success / failure), and actual amount received.

[0128] Step S115: Perform a reconciliation operation based on the total amount actually paid in the payroll statement and the total amount received in the payment receipt.

[0129] In this step, the total amount actually paid in the internal payroll statement is automatically compared with the total amount received in the bank transfer receipt. If they match, the reconciliation is marked as successful and the process ends normally; if there is a discrepancy, the reconciliation exception handling process is triggered immediately.

[0130] Specifically, a detailed discrepancy report is first generated, including key information such as the difference amount, a list of employees involved, transaction serial numbers, and timestamps, and an automated retry mechanism is initiated.

[0131] For example, retries employ an exponential backoff strategy (e.g., retrying after 1 second initially, then after 2 seconds, 4 seconds, 8 seconds, etc.), and the maximum number of retries can be flexibly configured by operations personnel according to channels or business scenarios. This design avoids misjudgments caused by instantaneous network jitter and prevents invalid requests from continuously impacting downstream systems.

[0132] If the difference is not eliminated after the maximum number of retries, it is judged as a long-tail failure. At this time, a financial review work order will be automatically generated and submitted to the designated business processing queue along with the difference report. The work order will be handed over to the finance or payroll specialist for manual verification to ensure that every anomaly is traceable and can be handled.

[0133] In addition, channel-level health monitoring is implemented: real-time statistics are collected on indicators such as the reconciliation anomaly rate and API timeout rate of each bank's disbursement channels.

[0134] If any abnormal indicator of a channel exceeds a preset threshold within the sliding time window (e.g., 5 consecutive timeouts or an anomaly rate > 1%), the channel will be automatically suspended, subsequent payment requests will be halted, and the system will immediately switch to a pre-configured backup payment channel. Simultaneously, a high-priority alarm will be triggered to notify the operations team. To ensure fund security, the recovery operation of a suspended channel must be manually confirmed and approved before execution to prevent risks from erroneous automated recovery.

[0135] Through the above mechanism, not only was the reconciliation process automated and closed-loop, but a multi-level anomaly handling system was also built, which significantly improved the efficiency of reconciliation and enhanced the reliability of payroll disbursement.

[0136] Based on the above embodiments, the method further includes: Step S116: Serialize the salary data source of each employee within the target pay period into a read-only input file and calculate the hash value of the input file.

[0137] In this embodiment of the invention, to achieve complete audit traceability capabilities, before the calculation begins, all original payroll data sources obtained in step S101 are serialized into an immutable file (such as Parquet or JSONL format) and stored in a compliant object storage (such as AWS S3GlacierVaultLock) with WORM (Write Once, Read Many) characteristics. Simultaneously, the SHA-256 hash value of this file is calculated as its unique fingerprint.

[0138] Step S117: After payroll disbursement and reconciliation are completed, encapsulate the hash value of the input file, payroll calculation snapshot, payroll statement summary, payment receipt, and reconciliation results into an audit record.

[0139] Once the entire payroll process (calculation, disbursement, and reconciliation) is successfully completed, the system will package all key elements of this payroll process, including data input (input file hash), calculation logic (payroll calculation snapshot), calculation output (payroll bill summary), execution result (payment receipt), and verification conclusion (reconciliation result), into a structured audit record.

[0140] Step S118: Write the audit record to the audit repository and generate a hash chain based on the hash value of the previous audit record to form an audit snapshot that can be replayed and verified later.

[0141] In this embodiment of the invention, this audit record will be appended to a dedicated audit data warehouse.

[0142] During the writing process, the system reads the hash value of the previous audit record and uses it as one of the inputs to calculate a new hash value together with the content of the current record. In this way, all audit records form a linked, immutable hash chain (similar to the principle of blockchain).

[0143] In the future, any auditor can use this chain to replay and verify the entire process of any payroll cycle in history, starting from any point, in a complete and reliable manner, achieving true end-to-end auditability.

[0144] Based on the same inventive concept, embodiments of the present invention provide a payroll processing apparatus applied to a payroll calculation engine. The payroll calculation engine includes a configuration unit and a code execution unit. The configuration unit is used to configure payroll calculation rule parameters independently of the code, and generate a payroll calculation snapshot based on the configured payroll calculation rule parameters, thereby decoupling the payroll calculation rule parameters from the payroll calculation code. The code execution unit is used to load the payroll calculation snapshot and execute the payroll calculation. Figure 3 As shown, the device includes: The first acquisition unit 301 is used to acquire the salary data source of each employee within the target pay period.

[0145] The second acquisition unit 302 is used to acquire the latest version of the payroll calculation snapshot from the configuration unit.

[0146] The salary calculation snapshot encapsulates at least several DSL salary calculation formulas, tax rate tables, social security and housing provident fund base parameters, and precision strategies for each currency.

[0147] Compilation unit 303 is used to compile and verify the DSL salary calculation formula in the salary calculation snapshot.

[0148] The calculation unit 304 is used to calculate the salary data of each employee in parallel using the code execution unit, based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and salary data source, if the compilation and verification are successful.

[0149] The rounding processing unit 305 is used to perform unified rounding processing on the salary data of each employee based on the precision strategy of each currency, and generate the final salary amount.

[0150] Based on the same technical concept, embodiments of the present invention also provide an electronic device, such as... Figure 4 As shown, it includes a processor 401, a communication interface 402, a memory 403, and a communication bus 404, wherein the processor 401, the communication interface 402, and the memory 403 communicate with each other through the communication bus 404.

[0151] Memory 403 is used to store computer programs; The processor 401 is used to implement the steps of the payroll processing method when executing the program stored in the memory 403.

[0152] The communication bus mentioned in the above electronic devices can be a Peripheral Component Interconnect (PCI) bus or an Extended Industry Standard Architecture (EISA) bus, etc. This communication bus can be divided into address bus, data bus, control bus, etc. For ease of illustration, only one thick line is used to represent it in the diagram, but this does not mean that there is only one bus or one type of bus.

[0153] The communication interface is used for communication between the aforementioned electronic devices and other devices.

[0154] The memory may include random access memory (RAM) or non-volatile memory (NVM), such as at least one disk storage device. Optionally, the memory may also be at least one storage device located remotely from the aforementioned processor.

[0155] The processors mentioned above can be general-purpose processors, including central processing units (CPUs), network processors (NPs), etc.; they can also be digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components.

[0156] In another embodiment of the present invention, a computer-readable storage medium is also provided, which stores a computer program that, when executed by a processor, implements the steps described in the preceding method embodiments. Specific implementation details can be found in the method embodiments and will not be repeated here.

[0157] The payroll processing apparatus provided in this embodiment of the invention can be specific hardware on a device or software or firmware installed on the device. The implementation principle and technical effects of the apparatus provided in this embodiment of the invention are the same as those in the foregoing method embodiments. For the sake of brevity, any parts not mentioned in the apparatus embodiments can be referred to the corresponding content in the foregoing method embodiments. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, apparatuses, and units described above can all be referred to the corresponding processes in the above method embodiments, and will not be repeated here.

[0158] In the embodiments provided by this invention, it should be understood that the disclosed apparatus and method can be implemented in other ways. The apparatus embodiments described above are merely illustrative. For example, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. Furthermore, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Additionally, the displayed or discussed mutual couplings, direct couplings, or communication connections may be through some communication interfaces; indirect couplings or communication connections between devices or units may be electrical, mechanical, or other forms.

[0159] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0160] In addition, the functional units in the embodiments provided by the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0161] If the aforementioned functions are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, essentially, or the part that contributes to the prior art, or a portion of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0162] It should be noted that similar labels and letters in the following figures indicate similar items. Therefore, once an item is defined in one figure, it does not need to be further defined and explained in subsequent figures. In addition, the terms "first", "second", "third", etc. are used only to distinguish descriptions and should not be construed as indicating or implying relative importance.

[0163] Finally, it should be noted that the above-described embodiments are merely specific implementations of the present invention, used to illustrate the technical solutions of the present invention, and not to limit it. The scope of protection of the present invention is not limited thereto. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that any person skilled in the art can still modify or easily conceive of changes to the technical solutions described in the foregoing embodiments within the technical scope disclosed in the present invention, or make equivalent substitutions for some of the technical features; and these modifications, changes, or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention. All should be covered within the scope of protection of the present invention. Therefore, the scope of protection of the present invention should be determined by the scope of the claims.< / component> < / seq>

Claims

1. A payroll processing method, characterized in that, The system is applied to a payroll calculation engine, which includes a configuration unit and a code execution unit. The configuration unit is used to configure payroll calculation rule parameters, generate payroll calculation snapshots based on the configured payroll calculation rule parameters, and manage the payroll calculation snapshots in a versioned manner. The code execution unit is used to load the salary calculation snapshot and perform salary calculation; the method includes: Obtain the salary data source for each employee within the target pay period; Obtain a snapshot of the latest version of salary calculation that supports version traceability from the configuration unit. The salary calculation snapshot encapsulates at least several DSL salary calculation formulas, tax rate tables, social security and housing provident fund base parameters, and precision strategies for each currency. The DSL salary calculation formula in the aforementioned salary calculation snapshot is compiled and verified; If compilation and verification fail, the calculation process is terminated, and feedback information containing error details is returned to the configuration unit. If compilation and verification are successful, the salary data of each employee will be calculated in parallel using the code execution unit based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and the salary data source. Based on the precision strategies for each currency, the salary data of each employee is uniformly rounded to generate the final salary amount.

2. The method according to claim 1, characterized in that, The process of compiling and verifying the DSL salary calculation formula in the salary calculation snapshot includes: Parse each of the DSL salary calculation formulas to generate the corresponding abstract syntax tree; The type of each node in the abstract syntax tree is derived to obtain the type of each node, and type verification is performed based on preset type rules; In response to successful type validation, extract the variable names of other formulas referenced in the DSL salary calculation formula and construct a directed graph of dependencies with each DSL salary calculation formula as a node; Perform a depth-first search on the directed graph of the dependencies to detect whether a circular dependency cycle exists; In response to a type validation failure or the detection of the circular dependency cycle, the currently compiling DSL salary calculation formula is marked as a compilation failure, and location information including the formula name, row and column numbers, context code snippets, and error type is generated.

3. The method according to claim 1, characterized in that, The parallel calculation of each employee's salary data using the code execution unit, based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters, and the salary data source, includes: Based on employee identification, all employee payroll data sources are distributed to multiple parallel computing threads; In each parallel computing thread, a unique idempotent key is generated for each employee's computing task. The idempotent key consists of a payroll batch identifier, an employee identifier, and a payroll calculation snapshot. Before performing the calculation, determine whether the idempotent key already exists; In response to the absence of the idempotent key, the task status of the corresponding employee is marked as processing, and salary calculation is performed based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and the salary data source; If the idempotent key already exists and the status is successful, the stored calculation result is returned directly. If the idempotent key already exists but is in the processing state and a preset timeout threshold has been exceeded, the calculation is re-executed.

4. The method according to claim 1, characterized in that, The precision strategy based on each currency is used to uniformly round the salary data of each employee to generate the final salary amount, including: After all employee salaries have been calculated, a one-time rounding process is performed on each employee's salary data according to the precision strategy and rounding mode corresponding to the target currency. The salary data includes gross payable, deductions, and net pay. The precision strategy includes the number of decimal places. The rounding mode includes rounding to the nearest whole number, rounding up, or rounding down, and is configured according to the currency. Perform a global tail error check on the salary data of each employee after rounding; the global tail error check is to check the deviation between the total amount after rounding and the total amount before rounding. If the deviation of the global tail difference check exceeds the preset deviation value, the payroll process will be blocked and a financial review alarm will be generated.

5. The method according to claim 1, characterized in that, The method further includes: Using employee identifiers as keys, the rounded salary data for each employee is aggregated to generate a summary vector containing total payable, individual income tax, social security deductions, housing provident fund deductions, and net pay. Assemble the summary vectors of all employees into a payroll bill object with a uniform format; Perform deterministic serialization on the payroll object to generate a JSON string, wherein the deterministic serialization includes: sorting all field names in lexicographical order, removing irrelevant whitespace characters, and uniformly representing the numerical values ​​as decimal strings without thousands separators; Call the key management service to obtain the key bound to the current pay cycle; Calculate the digital signature based on the JSON string and the obtained key; The digital signature, the key used, and the payroll object are encapsulated into a digitally signed payroll.

6. The method according to claim 5, characterized in that, The method further includes: Build a payment request based on each employee's payroll; The payment request is sent to the API interface of the target bank by calling the disbursement adapter corresponding to the target bank. Receive the payment receipt returned by the target bank's API interface; Based on the total amount actually paid in the payroll statement and the total amount received in the payment receipt, a reconciliation operation is performed.

7. The method according to claim 6, characterized in that, The method further includes: The salary data source for each employee within the target pay period is serialized into a read-only input file, and the hash value of the input file is calculated. After payroll disbursement and reconciliation are completed, the hash value of the input file, payroll calculation snapshot, payroll statement summary, payment receipt, and reconciliation results are packaged into an audit record. The audit records are written into the audit repository, and a hash chain is generated based on the hash value of the previous audit records to form an audit snapshot that can be replayed and verified later.

8. A payroll processing device, characterized in that, The system is applied to a payroll calculation engine, which includes a configuration unit and a code execution unit. The configuration unit is used to configure payroll calculation rule parameters, generate payroll calculation snapshots based on the configured payroll calculation rule parameters, and manage the payroll calculation snapshots in a versioned manner. The code execution unit is used to load the salary calculation snapshot and perform salary calculation; the device includes: The first acquisition unit is used to acquire the salary data source of each employee within the target pay period; The second acquisition unit is used to acquire the latest version of the salary calculation snapshot that supports version traceability from the configuration unit. The salary calculation snapshot encapsulates at least several DSL salary calculation formulas, tax rate tables, social security and housing provident fund base parameters, and precision strategies for each currency. The compilation unit is used to compile and verify the DSL salary calculation formula in the salary calculation snapshot; if the compilation and verification fail, the calculation process is terminated and feedback information containing error details is returned to the configuration unit. The calculation unit is used to calculate the salary data of each employee in parallel using the code execution unit, based on the DSL salary calculation formula, tax rate table, social security and housing provident fund base parameters and the salary data source, if the compilation and verification are successful. The rounding processing unit is used to perform uniform rounding processing on the salary data of each employee based on the precision strategy of each currency, and generate the final salary amount.

9. An electronic device, characterized in that, It includes a processor, a communication interface, a memory, and a communication bus, wherein the processor, the communication interface, and the memory communicate with each other through the communication bus; The memory is used to store computer programs; When the processor executes the program stored in the memory, it implements the method described in any one of claims 1-7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a computer program that, when executed by a processor, implements the method described in any one of claims 1-7.

Images