coati-payroll 0.0.2__py3-none-any.whl

coati_payroll/vistas/planilla/services/nomina_service.py

@@ -0,0 +1,233 @@
+# 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.
+"""Service for nomina business logic."""
+
+from datetime import date, timedelta
+from flask import current_app
+from coati_payroll.model import db, Planilla, Nomina
+from coati_payroll.enums import NominaEstado
+from coati_payroll.nomina_engine import NominaEngine
+from coati_payroll.queue import get_queue_driver
+
+
+class NominaService:
+    """Service for nomina operations."""
+
+    @staticmethod
+    def calcular_periodo_sugerido(planilla: Planilla) -> tuple[date, date]:
+        """Calculate suggested period dates for a new nomina.
+
+        Args:
+            planilla: The planilla to calculate period for
+
+        Returns:
+            Tuple of (periodo_inicio, periodo_fin)
+        """
+        # Get last nomina for default dates
+        ultima_nomina = db.session.execute(
+            db.select(Nomina).filter_by(planilla_id=planilla.id).order_by(Nomina.periodo_fin.desc())
+        ).scalar_one_or_none()
+
+        hoy = date.today()
+
+        if ultima_nomina:
+            # Start from the day after last period ended
+            periodo_inicio_sugerido = ultima_nomina.periodo_fin + timedelta(days=1)
+        else:
+            # First day of current month
+            periodo_inicio_sugerido = hoy.replace(day=1)
+
+        # Calculate end of period based on tipo_planilla
+        tipo = planilla.tipo_planilla
+        match tipo.periodicidad if tipo else "mensual":
+            case "semanal":
+                periodo_fin_sugerido = periodo_inicio_sugerido + timedelta(days=6)
+            case "quincenal":
+                if periodo_inicio_sugerido.day <= 15:
+                    periodo_fin_sugerido = periodo_inicio_sugerido.replace(day=15)
+                else:
+                    # End of month
+                    next_month = periodo_inicio_sugerido.replace(day=28) + timedelta(days=4)
+                    periodo_fin_sugerido = next_month - timedelta(days=next_month.day)
+            case _:  # mensual or other
+                # End of month
+                next_month = periodo_inicio_sugerido.replace(day=28) + timedelta(days=4)
+                periodo_fin_sugerido = next_month - timedelta(days=next_month.day)
+
+        return periodo_inicio_sugerido, periodo_fin_sugerido
+
+    @staticmethod
+    def ejecutar_nomina(
+        planilla: Planilla,
+        periodo_inicio: date,
+        periodo_fin: date,
+        fecha_calculo: date,
+        usuario: str,
+    ) -> tuple[Nomina | None, list[str], list[str]]:
+        """Execute a nomina calculation.
+
+        Args:
+            planilla: The planilla to execute
+            periodo_inicio: Start date of the period
+            periodo_fin: End date of the period
+            fecha_calculo: Calculation date
+            usuario: Username of the user executing
+
+        Returns:
+            Tuple of (nomina, errors, warnings)
+        """
+        # Count active employees
+        num_empleados = sum(1 for pe in planilla.planilla_empleados if pe.activo and pe.empleado.activo)
+
+        # Get configurable threshold for background processing
+        threshold = current_app.config.get("BACKGROUND_PAYROLL_THRESHOLD", 100)
+
+        # Determine if we should process in background
+        if num_empleados > threshold:
+            # Create nomina record with "calculando" status
+            nomina = Nomina(
+                planilla_id=planilla.id,
+                periodo_inicio=periodo_inicio,
+                periodo_fin=periodo_fin,
+                generado_por=usuario,
+                estado=NominaEstado.CALCULANDO,
+                total_bruto=0,
+                total_deducciones=0,
+                total_neto=0,
+                total_empleados=num_empleados,
+                empleados_procesados=0,
+                empleados_con_error=0,
+                procesamiento_en_background=True,
+            )
+            db.session.add(nomina)
+            db.session.commit()
+
+            # Enqueue background task
+            try:
+                queue = get_queue_driver()
+                queue.enqueue(
+                    "process_large_payroll",
+                    nomina_id=nomina.id,
+                    planilla_id=planilla.id,
+                    periodo_inicio=periodo_inicio.isoformat(),
+                    periodo_fin=periodo_fin.isoformat(),
+                    fecha_calculo=fecha_calculo.isoformat(),
+                    usuario=usuario,
+                )
+                return nomina, [], []
+            except Exception as e:
+                # If background processing fails, mark nomina as error
+                nomina.estado = NominaEstado.ERROR
+                nomina.errores_calculo = {"background_task_initialization_error": str(e)}
+                db.session.commit()
+                return None, [f"Error al iniciar el procesamiento en segundo plano: {str(e)}"], []
+        else:
+            # For smaller payrolls, process synchronously
+            engine = NominaEngine(
+                planilla=planilla,
+                periodo_inicio=periodo_inicio,
+                periodo_fin=periodo_fin,
+                fecha_calculo=fecha_calculo,
+                usuario=usuario,
+            )
+
+            nomina = engine.ejecutar()
+            return nomina, engine.errors, engine.warnings
+
+    @staticmethod
+    def recalcular_nomina(
+        nomina: Nomina, planilla: Planilla, usuario: str
+    ) -> tuple[Nomina | None, list[str], list[str]]:
+        """Recalculate an existing nomina.
+
+        Args:
+            nomina: The nomina to recalculate
+            planilla: The planilla
+            usuario: Username of the user recalculating
+
+        Returns:
+            Tuple of (new_nomina, errors, warnings)
+        """
+        from coati_payroll.model import (
+            NominaEmpleado,
+            NominaDetalle,
+            NominaNovedad,
+            AdelantoAbono,
+        )
+
+        # Store the original period and calculation date for consistency
+        periodo_inicio = nomina.periodo_inicio
+        periodo_fin = nomina.periodo_fin
+        fecha_calculo_original = nomina.fecha_calculo_original or nomina.fecha_generacion.date()
+        nomina_original_id = nomina.id
+
+        # Delete related AdelantoAbono records
+        db.session.execute(db.delete(AdelantoAbono).where(AdelantoAbono.nomina_id == nomina.id))
+
+        # Delete NominaNovedad records
+        db.session.execute(db.delete(NominaNovedad).where(NominaNovedad.nomina_id == nomina.id))
+
+        # Delete NominaDetalle records
+        db.session.execute(
+            db.delete(NominaDetalle).where(
+                NominaDetalle.nomina_empleado_id.in_(
+                    db.select(NominaEmpleado.id).where(NominaEmpleado.nomina_id == nomina.id)
+                )
+            )
+        )
+
+        # Delete all NominaEmpleado records
+        db.session.execute(db.delete(NominaEmpleado).where(NominaEmpleado.nomina_id == nomina.id))
+
+        # Delete the nomina record itself
+        db.session.delete(nomina)
+        db.session.commit()
+
+        # Re-execute the payroll with the ORIGINAL calculation date for consistency
+        engine = NominaEngine(
+            planilla=planilla,
+            periodo_inicio=periodo_inicio,
+            periodo_fin=periodo_fin,
+            fecha_calculo=fecha_calculo_original,
+            usuario=usuario,
+        )
+
+        new_nomina = engine.ejecutar()
+
+        # Mark as recalculation and link to original
+        if new_nomina:
+            new_nomina.es_recalculo = True
+            new_nomina.nomina_original_id = nomina_original_id
+
+            # Create audit log for recalculation
+            from coati_payroll.audit_helpers import crear_log_auditoria_nomina
+
+            crear_log_auditoria_nomina(
+                nomina=new_nomina,
+                accion="recalculated",
+                usuario=usuario,
+                descripcion=f"Nómina recalculada desde nómina original {nomina_original_id}",
+                cambios={
+                    "nomina_original_id": nomina_original_id,
+                    "fecha_calculo_original": fecha_calculo_original.isoformat(),
+                    "periodo_inicio": periodo_inicio.isoformat(),
+                    "periodo_fin": periodo_fin.isoformat(),
+                },
+                estado_anterior="deleted",
+                estado_nuevo=new_nomina.estado,
+            )
+
+            db.session.commit()
+
+        return new_nomina, engine.errors, engine.warnings

coati_payroll/vistas/planilla/services/novedad_service.py

@@ -0,0 +1,126 @@
+# 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.
+"""Service for novedad business logic."""
+
+from decimal import Decimal
+from coati_payroll.model import db, Planilla, Nomina, NominaNovedad
+from coati_payroll.vistas.planilla.helpers.form_helpers import get_concepto_ids_from_form
+
+
+class NovedadService:
+    """Service for novedad operations."""
+
+    @staticmethod
+    def listar_novedades(planilla: Planilla, nomina: Nomina) -> list:
+        """List all novedades for a nomina.
+
+        Args:
+            planilla: The planilla
+            nomina: The nomina
+
+        Returns:
+            List of NominaNovedad objects
+        """
+        # Get all employees in this planilla
+        empleado_ids = [pe.empleado_id for pe in planilla.planilla_empleados if pe.activo]
+
+        # Query novedades that fall within the nomina period and are for employees in this planilla
+        novedades = (
+            db.session.execute(
+                db.select(NominaNovedad)
+                .filter(
+                    NominaNovedad.empleado_id.in_(empleado_ids),
+                    NominaNovedad.fecha_novedad >= nomina.periodo_inicio,
+                    NominaNovedad.fecha_novedad <= nomina.periodo_fin,
+                )
+                .order_by(NominaNovedad.fecha_novedad.desc(), NominaNovedad.timestamp.desc())
+            )
+            .scalars()
+            .all()
+        )
+
+        return novedades
+
+    @staticmethod
+    def validar_fecha_novedad(fecha_novedad, nomina: Nomina) -> tuple[bool, str | None]:
+        """Validate that fecha_novedad falls within the nomina period.
+
+        Args:
+            fecha_novedad: The date to validate
+            nomina: The nomina
+
+        Returns:
+            Tuple of (is_valid, error_message)
+        """
+        from coati_payroll.i18n import _
+
+        if fecha_novedad:
+            if fecha_novedad < nomina.periodo_inicio or fecha_novedad > nomina.periodo_fin:
+                return False, _(
+                    "La fecha de la novedad debe estar dentro del período de la nómina " "({} a {})."
+                ).format(
+                    nomina.periodo_inicio.strftime("%d/%m/%Y"),
+                    nomina.periodo_fin.strftime("%d/%m/%Y"),
+                )
+        return True, None
+
+    @staticmethod
+    def crear_novedad(nomina: Nomina, form, usuario: str) -> NominaNovedad:
+        """Create a new novedad.
+
+        Args:
+            nomina: The nomina
+            form: The form with novedad data
+            usuario: Username of the user creating
+
+        Returns:
+            The created NominaNovedad
+        """
+        percepcion_id, deduccion_id = get_concepto_ids_from_form(form)
+
+        novedad = NominaNovedad(
+            nomina_id=nomina.id,
+            empleado_id=form.empleado_id.data,
+            codigo_concepto=form.codigo_concepto.data,
+            tipo_valor=form.tipo_valor.data,
+            valor_cantidad=Decimal(str(form.valor_cantidad.data)),
+            fecha_novedad=form.fecha_novedad.data,
+            percepcion_id=percepcion_id,
+            deduccion_id=deduccion_id,
+            creado_por=usuario,
+        )
+        db.session.add(novedad)
+        db.session.commit()
+        return novedad
+
+    @staticmethod
+    def actualizar_novedad(novedad: NominaNovedad, form, usuario: str):
+        """Update an existing novedad.
+
+        Args:
+            novedad: The novedad to update
+            form: The form with updated data
+            usuario: Username of the user updating
+        """
+        percepcion_id, deduccion_id = get_concepto_ids_from_form(form)
+
+        novedad.empleado_id = form.empleado_id.data
+        novedad.codigo_concepto = form.codigo_concepto.data
+        novedad.tipo_valor = form.tipo_valor.data
+        novedad.valor_cantidad = Decimal(str(form.valor_cantidad.data))
+        novedad.fecha_novedad = form.fecha_novedad.data
+        novedad.percepcion_id = percepcion_id
+        novedad.deduccion_id = deduccion_id
+        novedad.modificado_por = usuario
+        db.session.commit()

coati_payroll/vistas/planilla/services/planilla_service.py

@@ -0,0 +1,34 @@
+# 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.
+"""Service for planilla business logic."""
+
+from coati_payroll.model import Planilla
+
+
+class PlanillaService:
+    """Service for planilla operations."""
+
+    @staticmethod
+    def can_delete(planilla: Planilla) -> tuple[bool, str | None]:
+        """Check if a planilla can be deleted.
+
+        Args:
+            planilla: The planilla to check
+
+        Returns:
+            Tuple of (can_delete, error_message). If can_delete is True, error_message is None.
+        """
+        if planilla.nominas:
+            return False, "No se puede eliminar una planilla con nóminas generadas."
+        return True, None

coati_payroll/vistas/planilla/validators/__init__.py

@@ -0,0 +1,18 @@
+# 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.
+"""Validators for planilla business logic."""
+
+from coati_payroll.vistas.planilla.validators.planilla_validators import PlanillaValidator
+
+__all__ = ["PlanillaValidator"]

coati_payroll/vistas/planilla/validators/planilla_validators.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.
+"""Business logic validators for planilla operations."""
+
+from coati_payroll.model import Planilla, Empleado
+from coati_payroll.i18n import _
+
+
+class PlanillaValidator:
+    """Validators for planilla business logic."""
+
+    @staticmethod
+    def validar_empresa_empleado(planilla: Planilla, empleado: Empleado) -> tuple[bool, str | None]:
+        """Validate that planilla and employee belong to the same company.
+
+        Args:
+            planilla: The planilla to validate
+            empleado: The employee to validate
+
+        Returns:
+            Tuple of (is_valid, error_message). If valid, error_message is None.
+        """
+        if not planilla.empresa_id:
+            return False, _("La planilla debe tener una empresa asignada antes de agregar empleados.")
+        if not empleado.empresa_id:
+            return False, _("El empleado debe tener una empresa asignada antes de ser agregado a una planilla.")
+        if planilla.empresa_id != empleado.empresa_id:
+            return False, _("El empleado y la planilla deben pertenecer a la misma empresa.")
+        return True, None

coati_payroll/vistas/plugins.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+from flask import Blueprint, flash, redirect, render_template, url_for
+
+from coati_payroll.i18n import _
+from coati_payroll.model import PluginRegistry, db
+from coati_payroll.rbac import require_write_access
+
+
+plugins_bp = Blueprint("plugins", __name__, url_prefix="/plugins")
+
+# Constants
+ROUTE_PLUGINS_INDEX = "plugins.index"
+
+
+@plugins_bp.route("/")
+@require_write_access()
+def index():
+    plugins = db.session.execute(db.select(PluginRegistry).order_by(PluginRegistry.distribution_name)).scalars().all()
+    return render_template("modules/plugins/index.html", plugins=plugins)
+
+
+@plugins_bp.route("/toggle/<string:plugin_id>", methods=["POST"])
+@require_write_access()
+def toggle(plugin_id: str):
+    plugin = db.session.get(PluginRegistry, plugin_id)
+    if not plugin:
+        flash(_("Plugin no encontrado."), "error")
+        return redirect(url_for(ROUTE_PLUGINS_INDEX))
+
+    if not plugin.installed and plugin.active:
+        plugin.active = False
+        db.session.commit()
+        flash(_("Plugin marcado como inactivo."), "success")
+        return redirect(url_for(ROUTE_PLUGINS_INDEX))
+
+    plugin.active = not plugin.active
+    db.session.commit()
+
+    if plugin.active:
+        flash(_("Plugin activado. Reinicie la aplicación para cargar sus blueprints."), "success")
+    else:
+        flash(_("Plugin desactivado."), "success")
+
+    return redirect(url_for(ROUTE_PLUGINS_INDEX))