coati-payroll 0.0.2__py3-none-any.whl

coati_payroll/nomina_engine/processors/accumulation_processor.py

@@ -0,0 +1,90 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Accumulation processor for annual accumulated values."""
+
+from __future__ import annotations
+
+from datetime import date
+
+from coati_payroll.model import db, Deduccion
+from coati_payroll.i18n import _
+from ..domain.employee_calculation import EmpleadoCalculo
+from ..repositories.acumulado_repository import AcumuladoRepository
+from ..validators import ValidationError
+
+
+class AccumulationProcessor:
+    """Processor for updating accumulated annual values."""
+
+    def __init__(self, acumulado_repository: AcumuladoRepository):
+        self.acumulado_repo = acumulado_repository
+
+    def update_accumulations(
+        self,
+        emp_calculo: EmpleadoCalculo,
+        planilla,
+        periodo_fin: date,
+        fecha_calculo: date,
+    ) -> None:
+        """Update accumulated annual values for the employee."""
+        if not planilla.tipo_planilla:
+            return
+
+        tipo_planilla = planilla.tipo_planilla
+        empleado = emp_calculo.empleado
+
+        # Calculate fiscal period
+        anio = fecha_calculo.year
+        mes_inicio = tipo_planilla.mes_inicio_fiscal
+        dia_inicio = tipo_planilla.dia_inicio_fiscal
+
+        if fecha_calculo.month < mes_inicio:
+            anio -= 1
+
+        periodo_fiscal_inicio = date(anio, mes_inicio, dia_inicio)
+
+        # Determine empresa_id
+        empresa_id = planilla.empresa_id or empleado.empresa_id
+        if not empresa_id:
+            raise ValidationError(
+                _("No se puede crear acumulado anual: ni la planilla ni el empleado tienen empresa_id asignado")
+            )
+
+        # Get or create accumulated record
+        acumulado = self.acumulado_repo.get_or_create(empleado, tipo_planilla.id, empresa_id, periodo_fiscal_inicio)
+
+        # Reset monthly accumulation if entering a new month
+        acumulado.reset_mes_acumulado_if_needed(periodo_fin)
+
+        # Update accumulated values
+        acumulado.salario_bruto_acumulado += emp_calculo.salario_bruto
+        acumulado.salario_acumulado_mes += emp_calculo.salario_bruto
+        acumulado.periodos_procesados += 1
+        acumulado.ultimo_periodo_procesado = periodo_fin
+
+        # Calculate gravable income (perceptions that are gravable)
+        salario_gravable = emp_calculo.salario_base
+        for percepcion in emp_calculo.percepciones:
+            if percepcion.gravable:
+                salario_gravable += percepcion.monto
+        acumulado.salario_gravable_acumulado += salario_gravable
+
+        # Sum up before-tax deductions and taxes
+        for deduccion in emp_calculo.deducciones:
+            deduccion_obj = db.session.get(Deduccion, deduccion.deduccion_id) if deduccion.deduccion_id else None
+            if deduccion_obj:
+                if deduccion_obj.es_impuesto:
+                    acumulado.impuesto_retenido_acumulado += deduccion.monto
+                elif deduccion_obj.antes_impuesto:
+                    acumulado.deducciones_antes_impuesto_acumulado += deduccion.monto

coati_payroll/nomina_engine/processors/loan_processor.py

@@ -0,0 +1,227 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Loan processor for automatic loan and advance deductions."""
+
+from __future__ import annotations
+
+from datetime import date
+from decimal import Decimal
+
+from coati_payroll.model import db, Adelanto, AdelantoAbono, Nomina, Liquidacion
+from coati_payroll.enums import AdelantoEstado
+from coati_payroll.i18n import _
+from ..domain.calculation_items import DeduccionItem
+
+
+class LoanProcessor:
+    """Processor for automatic loan and advance deductions."""
+
+    def __init__(
+        self,
+        nomina: Nomina | None,
+        fecha_calculo: date,
+        periodo_inicio: date,
+        periodo_fin: date,
+        liquidacion: Liquidacion | None = None,
+        calcular_interes: bool = True,
+    ):
+        self.nomina = nomina
+        self.liquidacion = liquidacion
+        self.fecha_calculo = fecha_calculo
+        self.periodo_inicio = periodo_inicio
+        self.periodo_fin = periodo_fin
+        self.calcular_interes = calcular_interes
+
+    def process_loans(
+        self, empleado_id: str, saldo_disponible: Decimal, aplicar_prestamos: bool, prioridad_prestamos: int
+    ) -> list[DeduccionItem]:
+        """Process loans for an employee."""
+        deductions = []
+
+        if not aplicar_prestamos:
+            return deductions
+
+        # Get active loans
+        from sqlalchemy import select
+
+        prestamos = list(
+            db.session.execute(
+                select(Adelanto).filter(
+                    Adelanto.empleado_id == empleado_id,
+                    Adelanto.estado == AdelantoEstado.APROBADO,
+                    Adelanto.saldo_pendiente > 0,
+                    Adelanto.deduccion_id.isnot(None),  # Only loans, not advances
+                )
+            )
+            .scalars()
+            .all()
+        )
+
+        for prestamo in prestamos:
+            if saldo_disponible <= 0:
+                break
+
+            # Calculate and apply interest if applicable
+            if self.calcular_interes:
+                self._calculate_interest(prestamo)
+
+            monto_cuota = Decimal(str(prestamo.monto_por_cuota or 0))
+            if monto_cuota <= 0:
+                continue
+
+            monto_aplicar = min(monto_cuota, saldo_disponible)
+
+            item = DeduccionItem(
+                codigo=f"PRESTAMO_{prestamo.id[:8]}",
+                nombre=f"Cuota préstamo - {prestamo.motivo or 'N/A'}",
+                monto=monto_aplicar,
+                prioridad=prioridad_prestamos,
+                es_obligatoria=False,
+                tipo="prestamo",
+            )
+            deductions.append(item)
+            saldo_disponible -= monto_aplicar
+
+            # Record the payment
+            self._record_payment(prestamo, monto_aplicar)
+
+        return deductions
+
+    def process_advances(
+        self, empleado_id: str, saldo_disponible: Decimal, aplicar_adelantos: bool, prioridad_adelantos: int
+    ) -> list[DeduccionItem]:
+        """Process salary advances for an employee."""
+        deductions = []
+
+        if not aplicar_adelantos:
+            return deductions
+
+        from sqlalchemy import select
+
+        adelantos = list(
+            db.session.execute(
+                select(Adelanto).filter(
+                    Adelanto.empleado_id == empleado_id,
+                    Adelanto.estado == AdelantoEstado.APROBADO,
+                    Adelanto.saldo_pendiente > 0,
+                    Adelanto.deduccion_id.is_(None),  # Only advances, not loans
+                )
+            )
+            .scalars()
+            .all()
+        )
+
+        for adelanto in adelantos:
+            if saldo_disponible <= 0:
+                break
+
+            monto_cuota = Decimal(str(adelanto.monto_por_cuota or adelanto.saldo_pendiente))
+            monto_aplicar = min(monto_cuota, saldo_disponible)
+
+            item = DeduccionItem(
+                codigo=f"ADELANTO_{adelanto.id[:8]}",
+                nombre=f"Adelanto salarial - {adelanto.motivo or 'N/A'}",
+                monto=monto_aplicar,
+                prioridad=prioridad_adelantos,
+                es_obligatoria=False,
+                tipo="adelanto",
+            )
+            deductions.append(item)
+            saldo_disponible -= monto_aplicar
+
+            # Record the payment
+            self._record_payment(adelanto, monto_aplicar)
+
+        return deductions
+
+    def _calculate_interest(self, prestamo: Adelanto) -> None:
+        """Calculate and apply interest for a loan."""
+        from coati_payroll.interes_engine import calcular_interes_periodo
+        from coati_payroll.model import InteresAdelanto
+
+        tasa_interes = prestamo.tasa_interes or Decimal("0.0000")
+        if tasa_interes <= 0:
+            return
+
+        if prestamo.saldo_pendiente <= 0:
+            return
+
+        fecha_desde = prestamo.fecha_ultimo_calculo_interes
+        if not fecha_desde:
+            fecha_desde = prestamo.fecha_desembolso or prestamo.fecha_aprobacion
+
+        if not fecha_desde:
+            return
+
+        fecha_hasta = self.fecha_calculo
+
+        if fecha_desde >= fecha_hasta:
+            return
+
+        tipo_interes = prestamo.tipo_interes or "simple"
+        interes_calculado, dias = calcular_interes_periodo(
+            saldo=prestamo.saldo_pendiente,
+            tasa_anual=tasa_interes,
+            fecha_desde=fecha_desde,
+            fecha_hasta=fecha_hasta,
+            tipo_interes=tipo_interes,
+        )
+
+        if interes_calculado <= 0:
+            return
+
+        # Record interest in journal
+        interes_entrada = InteresAdelanto(
+            adelanto_id=prestamo.id,
+            nomina_id=self.nomina.id if self.nomina else None,
+            fecha_desde=fecha_desde,
+            fecha_hasta=fecha_hasta,
+            dias_transcurridos=dias,
+            saldo_base=prestamo.saldo_pendiente,
+            tasa_aplicada=tasa_interes,
+            interes_calculado=interes_calculado,
+            saldo_anterior=prestamo.saldo_pendiente,
+            saldo_posterior=prestamo.saldo_pendiente + interes_calculado,
+            observaciones=_("Interés calculado por nómina del {inicio} al {fin}").format(
+                inicio=self.periodo_inicio, fin=self.periodo_fin
+            ),
+        )
+        db.session.add(interes_entrada)
+
+        # Update loan with interest
+        prestamo.saldo_pendiente += interes_calculado
+        prestamo.interes_acumulado = (prestamo.interes_acumulado or Decimal("0.00")) + interes_calculado
+        prestamo.fecha_ultimo_calculo_interes = fecha_hasta
+
+    def _record_payment(self, adelanto: Adelanto, monto: Decimal) -> None:
+        """Record a payment towards a loan/advance."""
+        saldo_anterior = Decimal(str(adelanto.saldo_pendiente))
+        saldo_posterior = saldo_anterior - monto
+
+        abono = AdelantoAbono(
+            adelanto_id=adelanto.id,
+            nomina_id=self.nomina.id if self.nomina else None,
+            liquidacion_id=self.liquidacion.id if self.liquidacion else None,
+            fecha_abono=self.fecha_calculo,
+            monto_abonado=monto,
+            saldo_anterior=saldo_anterior,
+            saldo_posterior=max(saldo_posterior, Decimal("0.00")),
+            tipo_abono="liquidacion" if self.liquidacion else "nomina",
+        )
+        db.session.add(abono)
+
+        # Update adelanto balance
+        adelanto.saldo_pendiente = max(saldo_posterior, Decimal("0.00"))
+        if adelanto.saldo_pendiente <= 0:
+            adelanto.estado = AdelantoEstado.PAGADO

coati_payroll/nomina_engine/processors/novelty_processor.py

@@ -0,0 +1,42 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Novelty processor for loading employee novelties."""
+
+from __future__ import annotations
+
+from datetime import date
+from decimal import Decimal
+
+from coati_payroll.model import Empleado
+from ..repositories.novelty_repository import NoveltyRepository
+
+
+class NoveltyProcessor:
+    """Processor for loading employee novelties."""
+
+    def __init__(self, novelty_repository: NoveltyRepository):
+        self.novelty_repo = novelty_repository
+
+    def load_novelties(self, empleado: Empleado, periodo_inicio: date, periodo_fin: date) -> dict[str, Decimal]:
+        """Load novelties for the employee in this period."""
+        novedades: dict[str, Decimal] = {}
+
+        nomina_novedades = self.novelty_repo.get_by_employee_and_period(empleado.id, periodo_inicio, periodo_fin)
+
+        for novedad in nomina_novedades:
+            codigo = novedad.codigo_concepto
+            valor = Decimal(str(novedad.valor_cantidad or 0))
+            novedades[codigo] = novedades.get(codigo, Decimal("0")) + valor
+
+        return novedades

coati_payroll/nomina_engine/processors/vacation_processor.py

@@ -0,0 +1,67 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Vacation processor for vacation accrual and usage."""
+
+from __future__ import annotations
+
+from coati_payroll.model import Planilla, Empleado, NominaEmpleado
+from coati_payroll.log import log
+from ..domain.employee_calculation import EmpleadoCalculo
+
+
+class VacationProcessor:
+    """Processor for vacation accrual and usage."""
+
+    def __init__(
+        self, planilla: Planilla, periodo_inicio, periodo_fin, usuario: str | None = None, warnings: list[str] = None
+    ):
+        self.planilla = planilla
+        self.periodo_inicio = periodo_inicio
+        self.periodo_fin = periodo_fin
+        self.usuario = usuario
+        self.warnings = warnings or []
+
+    def process_vacations(
+        self, empleado: Empleado, emp_calculo: EmpleadoCalculo, nomina_empleado: NominaEmpleado
+    ) -> None:
+        """Process vacation accrual and usage for an employee."""
+        try:
+            from coati_payroll.vacation_service import VacationService
+
+            vacation_service = VacationService(
+                planilla=self.planilla,
+                periodo_inicio=self.periodo_inicio,
+                periodo_fin=self.periodo_fin,
+            )
+
+            # Accumulate vacation time
+            vacation_service.acumular_vacaciones_empleado(
+                empleado=empleado,
+                nomina_empleado=nomina_empleado,
+                usuario=self.usuario,
+            )
+
+            # Process vacation novelties (time off taken)
+            vacation_service.procesar_novedades_vacaciones(
+                empleado=empleado,
+                novedades=emp_calculo.novedades,
+                usuario=self.usuario,
+            )
+
+        except Exception as e:
+            log.error(f"Error procesando vacaciones para empleado {empleado.codigo_empleado}: {str(e)}")
+            self.warnings.append(
+                f"No se pudieron procesar vacaciones para {empleado.primer_nombre} "
+                f"{empleado.primer_apellido}: {str(e)}"
+            )

coati_payroll/nomina_engine/repositories/__init__.py

@@ -0,0 +1,32 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Repository layer for data access."""
+
+from .base_repository import BaseRepository
+from .planilla_repository import PlanillaRepository
+from .employee_repository import EmployeeRepository
+from .acumulado_repository import AcumuladoRepository
+from .novelty_repository import NoveltyRepository
+from .exchange_rate_repository import ExchangeRateRepository
+from .config_repository import ConfigRepository
+
+__all__ = [
+    "BaseRepository",
+    "PlanillaRepository",
+    "EmployeeRepository",
+    "AcumuladoRepository",
+    "NoveltyRepository",
+    "ExchangeRateRepository",
+    "ConfigRepository",
+]

coati_payroll/nomina_engine/repositories/acumulado_repository.py

@@ -0,0 +1,83 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Repository for AcumuladoAnual operations."""
+
+from __future__ import annotations
+
+from datetime import date
+from typing import Optional
+
+from coati_payroll.model import AcumuladoAnual, Empleado
+from .base_repository import BaseRepository
+
+
+class AcumuladoRepository(BaseRepository[AcumuladoAnual]):
+    """Repository for AcumuladoAnual operations."""
+
+    def get_by_id(self, acumulado_id: str) -> Optional[AcumuladoAnual]:
+        """Get acumulado by ID."""
+        return self.session.get(AcumuladoAnual, acumulado_id)
+
+    def get_or_create(
+        self,
+        empleado: Empleado,
+        tipo_planilla_id: str,
+        empresa_id: str,
+        periodo_fiscal_inicio: date,
+    ) -> AcumuladoAnual:
+        """Get or create acumulado for employee and fiscal period."""
+        from sqlalchemy import select
+
+        acumulado = (
+            self.session.execute(
+                select(AcumuladoAnual).filter(
+                    AcumuladoAnual.empleado_id == empleado.id,
+                    AcumuladoAnual.tipo_planilla_id == tipo_planilla_id,
+                    AcumuladoAnual.empresa_id == empresa_id,
+                    AcumuladoAnual.periodo_fiscal_inicio == periodo_fiscal_inicio,
+                )
+            )
+            .unique()
+            .scalar_one_or_none()
+        )
+
+        if not acumulado:
+            from datetime import date as date_type
+            from decimal import Decimal
+
+            periodo_fiscal_fin = date_type(
+                periodo_fiscal_inicio.year + 1, periodo_fiscal_inicio.month, periodo_fiscal_inicio.day
+            )
+
+            acumulado = AcumuladoAnual(
+                empleado_id=empleado.id,
+                tipo_planilla_id=tipo_planilla_id,
+                empresa_id=empresa_id,
+                periodo_fiscal_inicio=periodo_fiscal_inicio,
+                periodo_fiscal_fin=periodo_fiscal_fin,
+                salario_bruto_acumulado=empleado.salario_acumulado or Decimal("0.00"),
+                salario_gravable_acumulado=Decimal("0.00"),
+                deducciones_antes_impuesto_acumulado=empleado.impuesto_acumulado or Decimal("0.00"),
+                impuesto_retenido_acumulado=Decimal("0.00"),
+                periodos_procesados=0,
+                salario_acumulado_mes=Decimal("0.00"),
+            )
+            self.session.add(acumulado)
+
+        return acumulado
+
+    def save(self, acumulado: AcumuladoAnual) -> AcumuladoAnual:
+        """Save acumulado."""
+        self.session.add(acumulado)
+        return acumulado

coati_payroll/nomina_engine/repositories/base_repository.py

@@ -0,0 +1,40 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Base repository for data access."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar, Optional
+
+from sqlalchemy.orm import Session
+
+T = TypeVar("T")
+
+
+class BaseRepository(ABC, Generic[T]):
+    """Base repository for data access operations."""
+
+    def __init__(self, session: Session):
+        self.session = session
+
+    @abstractmethod
+    def get_by_id(self, id: str) -> Optional[T]:
+        """Get entity by ID."""
+        pass
+
+    @abstractmethod
+    def save(self, entity: T) -> T:
+        """Save entity."""
+        pass

coati_payroll/nomina_engine/repositories/config_repository.py

@@ -0,0 +1,102 @@
+# Copyright 2025 BMO Soluciones, S.A.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Repository for ConfiguracionCalculos operations."""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from typing import Optional
+
+from coati_payroll.model import ConfiguracionCalculos
+from .base_repository import BaseRepository
+
+
+class ConfigRepository(BaseRepository[ConfiguracionCalculos]):
+    """Repository for ConfiguracionCalculos operations."""
+
+    def get_by_id(self, config_id: str) -> Optional[ConfiguracionCalculos]:
+        """Get configuration by ID."""
+        return self.session.get(ConfiguracionCalculos, config_id)
+
+    def get_for_empresa(self, empresa_id: Optional[str]) -> ConfiguracionCalculos:
+        """Get configuration for empresa, or global default."""
+        from sqlalchemy import select
+
+        # Try company-specific configuration
+        if empresa_id:
+            config = (
+                self.session.execute(
+                    select(ConfiguracionCalculos).filter(
+                        ConfiguracionCalculos.empresa_id == empresa_id,
+                        ConfiguracionCalculos.activo.is_(True),
+                    )
+                )
+                .unique()
+                .scalar_one_or_none()
+            )
+            if config:
+                return config
+
+        # Try global default
+        config = (
+            self.session.execute(
+                select(ConfiguracionCalculos).filter(
+                    ConfiguracionCalculos.empresa_id.is_(None),
+                    ConfiguracionCalculos.pais_id.is_(None),
+                    ConfiguracionCalculos.activo.is_(True),
+                )
+            )
+            .unique()
+            .scalar_one_or_none()
+        )
+
+        if config:
+            return config
+
+        # Return default instance (not saved to DB)
+        # =====================================================================
+        # DEFAULT VALUES DISCLAIMER (Per Social Contract)
+        # =====================================================================
+        # These default values are provided SOLELY to facilitate initial adoption.
+        # They do NOT represent legal rules for any specific jurisdiction.
+        # They are completely configurable by the implementer.
+        # They should NOT be assumed as correct for any specific jurisdiction.
+        #
+        # Implementers MUST review and configure these values according to
+        # their specific legal and business requirements before production use.
+        # =====================================================================
+        return ConfiguracionCalculos(
+            empresa_id=None,
+            pais_id=None,
+            dias_mes_nomina=30,  # Example default - configure per jurisdiction
+            dias_anio_nomina=365,  # Example default - configure per jurisdiction
+            horas_jornada_diaria=Decimal("8.00"),  # Example default - configure per jurisdiction
+            dias_mes_vacaciones=30,  # Example default - configure per jurisdiction
+            dias_anio_vacaciones=365,  # Example default - configure per jurisdiction
+            considerar_bisiesto_vacaciones=True,  # Example default - configure per jurisdiction
+            dias_anio_financiero=365,  # Example default - configure per jurisdiction
+            meses_anio_financiero=12,  # Example default - configure per jurisdiction
+            dias_quincena=15,  # Example default - configure per jurisdiction
+            liquidacion_modo_dias="calendario",
+            liquidacion_factor_calendario=30,
+            liquidacion_factor_laboral=28,
+            dias_mes_antiguedad=30,  # Example default - configure per jurisdiction
+            dias_anio_antiguedad=365,  # Example default - configure per jurisdiction
+            activo=True,
+        )
+
+    def save(self, config: ConfiguracionCalculos) -> ConfiguracionCalculos:
+        """Save configuration."""
+        self.session.add(config)
+        return config