feat: Implement consolidated catalog services and endpoints for pedimento and invoice creation/edition.

backend/api/v1/modules/a76/classes/service.py

@@ -73,6 +73,91 @@ class ClassService:
         
         return items, total
 
+    @staticmethod
+    def get_all_with_fa_data(
+        db: Session,
+        tenant_id: int,
+        company_id: int,
+        skip: int = 0,
+        limit: int = 1000,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> tuple[List[Dict[str, Any]], int]:
+        """
+        Get all classes with their FA data in a single query using LEFT JOIN.
+        This eliminates the N+1 query problem.
+        
+        Returns a list of dicts with combined base class + FA data.
+        """
+        from api.v1.modules.a24.fa.fa_classes.models import QClasses
+        
+        # Build query with LEFT JOIN
+        query = (
+            db.query(Class, QClasses)
+            .outerjoin(QClasses, and_(
+                Class.id == QClasses.class_id,
+                QClasses.tenant_id == tenant_id
+            ))
+            .filter(Class.tenant_id == tenant_id)
+            .filter(Class.company_id == company_id)
+        )
+        
+        # Apply filters if provided
+        if filters:
+            if filters.get("class_code"):
+                query = query.filter(
+                    Class.class_code.ilike(f"%{filters['class_code']}%")
+                )
+            if filters.get("description"):
+                description_pattern = f"%{filters['description']}%"
+                query = query.filter(
+                    or_(
+                        Class.description_es.ilike(description_pattern),
+                        Class.description_en.ilike(description_pattern),
+                    )
+                )
+            if filters.get("material_key"):
+                query = query.filter(
+                    Class.material_key.ilike(f"%{filters['material_key']}%")
+                )
+            if filters.get("fraction"):
+                query = query.filter(Class.fraction.ilike(f"%{filters['fraction']}%"))
+        
+        # Count total before pagination
+        total = query.count()
+        
+        # Apply pagination
+        results = query.offset(skip).limit(limit).all()
+        
+        # Combine base class + FA data into dicts
+        combined = []
+        for base_class, fa_class in results:
+            class_dict = {
+                # Base class fields
+                "id": base_class.id,
+                "tenant_id": base_class.tenant_id,
+                "company_id": base_class.company_id,
+                "class_code": base_class.class_code,
+                "description_es": base_class.description_es,
+                "description_en": base_class.description_en,
+                "material_key": base_class.material_key,
+                "unit_of_measure": base_class.unit_of_measure,
+                "fraction": base_class.fraction,
+                "us_fraction": base_class.us_fraction,
+                "sub_key": base_class.sub_key,
+                "physical_review": base_class.physical_review,
+                "iva_exempt_fraction": base_class.iva_exempt_fraction,
+                "created_at": base_class.created_at,
+                "updated_at": base_class.updated_at,
+                # FA extension fields (None if no FA record exists)
+                "fa_class_id": fa_class.id if fa_class else None,
+                "depreciation_rate": fa_class.depreciation_rate if fa_class else None,
+                "fda_code": fa_class.fda_code if fa_class else None,
+                "class_enabled": fa_class.class_enabled if fa_class else None,
+            }
+            combined.append(class_dict)
+        
+        return combined, total
+
     @staticmethod
     def get_by_id(
         db: Session, class_id: int, tenant_id: int, company_id: int