Struct PayrollWriteService 

pub struct PayrollWriteService { /* private fields */ }

Implementations

impl PayrollWriteService

pub fn new(pool: PgPool) -> Self

pub fn with_overtime_inputs(self, inputs: Box<dyn OvertimeInputs>) -> Self

Override where overtime hours come from (default: the pool read mirroring attendance’s export).

pub fn set_timesheet_inputs(&self, inputs: Arc<dyn ApprovedTimesheetInputs>)

Wire the approved-timesheet input port (the composing app’s adapter when it wants the SQL in one place; the pool default reads the timesheet tables directly under the fence).

pub fn with_employee_inputs( self, inputs: Box<dyn EmployeeStatutoryInputs>, ) -> Self

Override where employee statutory facts come from (default: the pool read mirroring the employee module’s export).

pub fn with_gl_sink(self, sink: Arc<dyn GlPostSink>) -> Self

Override the GL-posting seam (default UnwiredGlSink — post refuses with gl_seam_unwired).

pub fn with_event_sink(self, sink: Arc<dyn PayrollEventSink>) -> Self

Override the domain-event sink (default LoggingSink). A durable composition stages into an outbox here.

pub fn with_remit_sink(self, sink: Arc<dyn RemittanceSink>) -> Self

Override the remittance seam (default UnwiredRemittance — remit refuses with remittance_seam_unwired).

pub async fn post_run( &self, run_id: Uuid, posting_date: NaiveDate, ) -> Result<PostOutcome, PayrollError>

Post through the module-held GL + event seams — the composition-root convenience over Self::post_payroll_entry (which stays public for callers supplying their own sinks, e.g. tests driving a real accounting adapter).

pub async fn remit_run( &self, run_id: Uuid, ) -> Result<RemitOutcome, PayrollError>

Remit through the module-held remittance seam — the composition-root convenience over Self::remit_payroll_entry.

pub async fn create_structure( &self, s: NewStructure, ) -> Result<Uuid, PayrollError>

Define a salary structure with its earning/deduction components.

pub async fn create_payroll_entry( &self, e: NewPayrollEntry, ) -> Result<Uuid, PayrollError>

Open a payroll run for a period (draft). Unique per (org unit, year, month) once the composing service’s tenancy decorator has re-declared the run unique org-scoped.

pub async fn add_salary_slip( &self, run_id: Uuid, s: NewSalarySlip, ) -> Result<Uuid, PayrollError>

Add an employee’s slip to a DRAFT run. Earnings come from the structure, prorated by unpaid days (gross = Σ earning · (working − unpaid)/working); fixed + supplied statutory deductions subtract. net = gross − deductions and must be non-negative.

pub async fn add_computed_salary_slip( &self, r: ComputedSlipRequest, ) -> Result<Uuid, PayrollError>

Build one employee’s slip end-to-end: period → effective statutory params → employee facts → TER/bracket dispatch → overtime pay → the same Self::add_salary_slip write path a manual caller uses. The statutory base is the structure’s un-prorated monthly earning total (the salary being paid); overtime pay rides in as an ordinary earning line so gross stays balanced through the existing journal.

pub async fn process_payroll_entry( &self, run_id: Uuid, ) -> Result<(), PayrollError>

Roll the run’s slips up into its totals and move draft → processed (ready to post).

pub async fn render_slip_pdf( &self, slip_id: Uuid, ) -> Result<Vec<u8>, PayrollError>

Post the processed run to the GL — the 8th producer. Builds ONE balanced posting (Dr Salary Expense (gross) · Cr Salary Payable (net) · Cr Σ deduction-account), drives the GlPostSink (idempotent per run), then transition-gates processed → posted with the journal. Posts at most once. Emits PayrollPosted. Render one slip as a PDF (#553). Published-run gated like the self-service read: a slip on a draft or processed run is an internal draft, not a promise to the employee.

pub async fn cancel_payroll_entry( &self, run_id: Uuid, ) -> Result<bool, PayrollError>

Cancel a run that has not left draft (#605): the month opens for a fresh run, the slips go with it. Only draft may cancel (posted history is immutable — reverse, don’t delete); idempotent on an already-cancelled row.

pub async fn post_payroll_entry( &self, run_id: Uuid, posting_date: NaiveDate, sink: &dyn GlPostSink, events: &dyn PayrollEventSink, ) -> Result<PostOutcome, PayrollError>

pub async fn remit_payroll_entry( &self, run_id: Uuid, sink: &dyn RemittanceSink, ) -> Result<RemitOutcome, PayrollError>

Remit a posted run’s payables — one instruction per deduction account, each carrying the stable payroll_remittance:{company}:{run}:{account} idempotency key so retries dedup at the sink (the company segment is the legacy tenancy twin echo, ADR-0029 — stable per unit under a composing service, nil undecorated). Requires posted (an unposted run has no settled obligations to pay). Payee resolution is the composing host’s adapter, never payroll’s.