feat: Implement general catalogs for INPC, Legends, Multi-Currency Types, Packages, Ports, Prevalidators, Signatures, Unit Conversions, and Units of Measure

- Added INPC management page with search functionality.
- Created Legends management page with filters for code and description.
- Implemented Multi-Currency Types management with search capabilities.
- Developed Packages management page with filtering options.
- Introduced Ports management page with authentication and data fetching.
- Added Prevalidators management page with search filters.
- Implemented Signatures management page with search by name and position.
- Created Unit Conversions management page for conversion factors.
- Developed Units of Measure management pages for ACE, American, and OMA with data tables and create/edit dialogs.

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

@@ -39,6 +39,11 @@ class Class(Base, TenantScopedMixin, TimestampMixin):
             ["public.material_types.key"],
             name="fk_classes_material_type",
         ),
+        ForeignKeyConstraint(
+            ["unit_of_measure", "tenant_id", "company_id"],
+            ["a76.units_of_measure.code", "a76.units_of_measure.tenant_id",
+                "a76.units_of_measure.company_id"],
+        ),
         UniqueConstraint(
             "tenant_id",
             "company_id",
@@ -63,10 +68,10 @@ class Class(Base, TenantScopedMixin, TimestampMixin):
 
     # Material and measurement
     material_key: Mapped[Optional[str]] = mapped_column(
-        String(10), ForeignKey("public.material_types.key")
+        String(10)
     )  # CLAVEMAT - homologated from TIPOMAT/TIPOMATEQUIPO
     unit_of_measure: Mapped[Optional[str]] = mapped_column(
-        String(5), ForeignKey("a76.units_of_measure.code")
+        String(5)
     )  # UNIMED - homologated from UNIMEDIDA
 
     # Tariff fractions

backend/api/v1/modules/a76/general_catalogs/classification_concepts/models.py

@@ -9,7 +9,7 @@ class ClassificationConcept(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "classification_concepts"
     __table_args__ = (
         UniqueConstraint("classification", name="uq_classification_concept"),
-        {"schema": "a76"}
+        {"schema": "a76", "extend_existing": True},
     )
 
     id: Mapped[int] = mapped_column(

backend/api/v1/modules/a76/general_catalogs/classification_concepts/routes.py

@@ -1,64 +1,14 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from sqlalchemy.orm import Session
-from typing import List
-
-from core.database import get_core_db
-from . import service
 from .dto import ClassificationConceptCreate, ClassificationConceptResponse, ClassificationConceptUpdate
+from .service import ClassificationConceptService
 
-router = APIRouter(prefix="/classification-concepts",
+router = TenantCRUDRoutes(
-                   tags=["a76.general_catalogs.classification_concepts"])
+    service=ClassificationConceptService,
-
+    create_schema=ClassificationConceptCreate,
-
+    update_schema=ClassificationConceptUpdate,
-@router.post("/", response_model=ClassificationConceptResponse, status_code=status.HTTP_201_CREATED)
+    response_schema=ClassificationConceptResponse,
-def create_classification_concept(
+    prefix="/classification-concepts",
-    data: ClassificationConceptCreate,
+    tags=["a76.general_catalogs.classification_concepts"],
-    session: Session = Depends(get_core_db)
+    resource_name="Classification Concept",
-):
+    enable_list=True,
-    return service.create_classification_concept(session, data)
+).router
-
-
-@router.get("/{id}", response_model=ClassificationConceptResponse)
-def get_classification_concept(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_classification_concept(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="ClassificationConcept not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[ClassificationConceptResponse])
-def get_classification_concepts(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_classification_concepts(session, skip, limit)
-
-
-@router.put("/{id}", response_model=ClassificationConceptResponse)
-def update_classification_concept(
-    id: int,
-    data: ClassificationConceptUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_classification_concept(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="ClassificationConcept not found")
-    return service.update_classification_concept(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=ClassificationConceptResponse)
-def delete_classification_concept(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_classification_concept(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="ClassificationConcept not found")
-    return service.delete_classification_concept(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/classification_concepts/service.py

@@ -1,39 +1,81 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import ClassificationConcept
 from .dto import ClassificationConceptCreate, ClassificationConceptUpdate
 
 
-def create_classification_concept(session: Session, data: ClassificationConceptCreate) -> ClassificationConcept:
+class ClassificationConceptService:
-    db_obj = ClassificationConcept(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[List[ClassificationConcept], int]:
+        query = db.query(ClassificationConcept).filter(
+            ClassificationConcept.tenant_id == tenant_id,
+            ClassificationConcept.company_id == company_id
+        )
 
+        total = query.count()
+        items = query.offset(skip).limit(limit).all()
 
-def get_classification_concept(session: Session, id: int) -> Optional[ClassificationConcept]:
+        return items, total
-    return session.get(ClassificationConcept, id)
 
+    @staticmethod
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[ClassificationConcept]:
+        return db.query(ClassificationConcept).filter(
+            ClassificationConcept.id == id,
+            ClassificationConcept.tenant_id == tenant_id,
+            ClassificationConcept.company_id == company_id
+        ).first()
 
-def get_classification_concepts(session: Session, skip: int = 0, limit: int = 100) -> Sequence[ClassificationConcept]:
+    @staticmethod
-    stmt = select(ClassificationConcept).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session, data: ClassificationConceptCreate, tenant_id: int, company_id: int
-    return result.scalars().all()
+    ) -> ClassificationConcept:
+        db_obj = ClassificationConcept(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session, id: int, tenant_id: int, data: ClassificationConceptUpdate, company_id: int
+    ) -> Optional[ClassificationConcept]:
+        db_obj = ClassificationConceptService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_classification_concept(session: Session, db_obj: ClassificationConcept, update_data: ClassificationConceptUpdate) -> ClassificationConcept:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def delete_classification_concept(session: Session, db_obj: ClassificationConcept) -> ClassificationConcept:
+    @staticmethod
-    session.delete(db_obj)
+    def delete(
-    session.commit()
+        db: Session, id: int, tenant_id: int, company_id: int
-    return db_obj
+    ) -> bool:
+        db_obj = ClassificationConceptService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/company/routes.py

@@ -9,15 +9,29 @@ from sqlalchemy.orm import Session
 
 from core.database import get_core_db
 from core.security import get_current_user, validate_access_to_resource
-from .....common.tenant_crud_routes import TenantCRUDRoutes
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
 from .dto import CompanyCreateDTO, CompanyResponseDTO, CompanyUpdateDTO
 from .models import Company
 from .service import CompanyService
 
-# Main router that includes base CRUD
+# Create CRUD router
-router = APIRouter(prefix="/company")
+crud_router = TenantCRUDRoutes(
+    service=CompanyService,
+    create_schema=CompanyCreateDTO,
+    update_schema=CompanyUpdateDTO,
+    response_schema=CompanyResponseDTO,
+    prefix="/company",
+    tags=["a76.general_catalogs.company"],
+    resource_name="Company",
+    enable_list=True,
+    enable_filters=True,
+).router
+
+router = crud_router
 
 # Custom endpoints
+
+
 @router.get(
     "/my-companies",
     response_model=List[CompanyResponseDTO],
@@ -83,7 +97,8 @@ async def get_basic_info(
         db, tenant_id, company_id_from_user, Company, company_id, "id"
     )
 
-    company = CompanyService.get_by_id(db, company_id, tenant_id, company_id_from_user)
+    company = CompanyService.get_by_id(
+        db, company_id, tenant_id, company_id_from_user)
     if not company:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -117,7 +132,8 @@ async def get_responsible_info(
         db, tenant_id, company_id_from_user, Company, company_id, "id"
     )
 
-    company = CompanyService.get_by_id(db, company_id, tenant_id, company_id_from_user)
+    company = CompanyService.get_by_id(
+        db, company_id, tenant_id, company_id_from_user)
     if not company:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -153,7 +169,8 @@ async def get_program_info(
         db, tenant_id, company_id_from_user, Company, company_id, "id"
     )
 
-    company = CompanyService.get_by_id(db, company_id, tenant_id, company_id_from_user)
+    company = CompanyService.get_by_id(
+        db, company_id, tenant_id, company_id_from_user)
     if not company:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -166,7 +183,7 @@ async def get_program_info(
         "prosec": company.prosec,
         "prosec_authorization": company.prosec_authorization,
     }
-    
+
 # Base CRUD routes using TenantCRUDRoutes
 base_router = TenantCRUDRoutes(
     service=CompanyService,
@@ -179,4 +196,4 @@ base_router = TenantCRUDRoutes(
     enable_list=True,
     enable_filters=True,
 ).router
-router.include_router(base_router)
+router.include_router(base_router)

backend/api/v1/modules/a76/general_catalogs/concepts/models.py

@@ -3,7 +3,10 @@ from sqlalchemy import Integer, String, UniqueConstraint, Boolean, ForeignKey
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
 from core.database import Base
-from api.v1.modules.a76.general_catalogs.classification_concepts.models import ClassificationConcept
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from api.v1.modules.a76.general_catalogs.classification_concepts.models import ClassificationConcept
 
 
 class Concept(Base, TenantScopedMixin, TimestampMixin):

backend/api/v1/modules/a76/general_catalogs/concepts/routes.py

@@ -1,71 +1,14 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from sqlalchemy.orm import Session
-from typing import List
-
-from core.database import get_core_db
-from core.security import get_current_user, validate_access_to_resource
-from . import service
 from .dto import ConceptCreate, ConceptResponse, ConceptUpdate
+from .service import ConceptService
 
-router = APIRouter(prefix="/concepts", tags=["a76.general_catalogs.concepts"])
+router = TenantCRUDRoutes(
-
+    service=ConceptService,
-
+    create_schema=ConceptCreate,
-@router.post("/", response_model=ConceptResponse, status_code=status.HTTP_201_CREATED)
+    update_schema=ConceptUpdate,
-def create_concept(
+    response_schema=ConceptResponse,
-    data: ConceptCreate,
+    prefix="/concepts",
-    session: Session = Depends(get_core_db),
+    tags=["a76.general_catalogs.concepts"],
-    current_user=Depends(get_current_user)
+    resource_name="Concept",
-):
+    enable_list=True,
-    tenant_id = validate_access_to_resource(
+).router
-        session, data.company_id, current_user)
-    return service.create_concept(session, data, tenant_id)
-
-
-@router.get("/{id}", response_model=ConceptResponse)
-def get_concept(
-    id: int,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_concept(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Concept not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return db_obj
-
-
-@router.get("/", response_model=List[ConceptResponse])
-def get_concepts(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    return service.get_concepts(session, skip, limit)
-
-
-@router.put("/{id}", response_model=ConceptResponse)
-def update_concept(
-    id: int,
-    data: ConceptUpdate,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_concept(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Concept not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return service.update_concept(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=ConceptResponse)
-def delete_concept(
-    id: int,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_concept(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Concept not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return service.delete_concept(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/concepts/service.py

@@ -1,36 +1,79 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
-from typing import Sequence, Optional
+from sqlalchemy import select
 
 from .models import Concept
 from .dto import ConceptCreate, ConceptUpdate
 
 
-def create_concept(session: Session, data: ConceptCreate, tenant_id: int) -> Concept:
+class ConceptService:
-    db_obj = Concept(**data.model_dump(), tenant_id=tenant_id)
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[List[Concept], int]:
+        query = db.query(Concept).filter(
+            Concept.tenant_id == tenant_id,
+            Concept.company_id == company_id
+        )
 
+        total = query.count()
+        items = query.offset(skip).limit(limit).all()
 
-def get_concept(session: Session, id: int) -> Optional[Concept]:
+        return items, total
-    return session.get(Concept, id)
 
+    @staticmethod
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[Concept]:
+        return db.query(Concept).filter(
+            Concept.id == id,
+            Concept.tenant_id == tenant_id,
+            Concept.company_id == company_id
+        ).first()
 
-def get_concepts(session: Session, skip: int = 0, limit: int = 100) -> Sequence[Concept]:
+    @staticmethod
-    return session.query(Concept).offset(skip).limit(limit).all()
+    def create(
+        db: Session, data: ConceptCreate, tenant_id: int, company_id: int
+    ) -> Concept:
+        data_dict = data.model_dump()
+        data_dict['company_id'] = company_id
+        data_dict['tenant_id'] = tenant_id
 
+        db_obj = Concept(**data_dict)
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def update_concept(session: Session, db_obj: Concept, update_data: ConceptUpdate) -> Concept:
+    @staticmethod
-    update_dict = update_data.model_dump(exclude_unset=True)
+    def update(
-    for key, value in update_dict.items():
+        db: Session, id: int, tenant_id: int, data: ConceptUpdate, company_id: int
-        setattr(db_obj, key, value)
+    ) -> Optional[Concept]:
-    session.commit()
+        db_obj = ConceptService.get_by_id(db, id, tenant_id, company_id)
-    session.refresh(db_obj)
+        if not db_obj:
-    return db_obj
+            return None
 
+        update_dict = data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
+            setattr(db_obj, key, value)
 
-def delete_concept(session: Session, db_obj: Concept) -> Concept:
+        db.commit()
-    session.delete(db_obj)
+        db.refresh(db_obj)
-    session.commit()
+        return db_obj
-    return db_obj
+
+    @staticmethod
+    def delete(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> bool:
+        db_obj = ConceptService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/customs_broker_concepts/routes.py

@@ -1,64 +1,14 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from sqlalchemy.orm import Session
-from typing import List
-
-from core.database import get_core_db
-from . import service
 from .dto import CustomsBrokerConceptCreate, CustomsBrokerConceptResponse, CustomsBrokerConceptUpdate
+from .service import CustomsBrokerConceptService
 
-router = APIRouter(prefix="/customs-broker-concepts",
+router = TenantCRUDRoutes(
-                   tags=["a76.general_catalogs.customs_broker_concepts"])
+    service=CustomsBrokerConceptService,
-
+    create_schema=CustomsBrokerConceptCreate,
-
+    update_schema=CustomsBrokerConceptUpdate,
-@router.post("/", response_model=CustomsBrokerConceptResponse, status_code=status.HTTP_201_CREATED)
+    response_schema=CustomsBrokerConceptResponse,
-def create_customs_broker_concept(
+    prefix="/customs-broker-concepts",
-    data: CustomsBrokerConceptCreate,
+    tags=["a76.general_catalogs.customs_broker_concepts"],
-    session: Session = Depends(get_core_db)
+    resource_name="Customs Broker Concept",
-):
+    enable_list=True,
-    return service.create_customs_broker_concept(session, data)
+).router
-
-
-@router.get("/{id}", response_model=CustomsBrokerConceptResponse)
-def get_customs_broker_concept(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_customs_broker_concept(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="CustomsBrokerConcept not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[CustomsBrokerConceptResponse])
-def get_customs_broker_concepts(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_customs_broker_concepts(session, skip, limit)
-
-
-@router.put("/{id}", response_model=CustomsBrokerConceptResponse)
-def update_customs_broker_concept(
-    id: int,
-    data: CustomsBrokerConceptUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_customs_broker_concept(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="CustomsBrokerConcept not found")
-    return service.update_customs_broker_concept(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=CustomsBrokerConceptResponse)
-def delete_customs_broker_concept(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_customs_broker_concept(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="CustomsBrokerConcept not found")
-    return service.delete_customs_broker_concept(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/customs_broker_concepts/service.py

@@ -1,39 +1,81 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import CustomsBrokerConcept
 from .dto import CustomsBrokerConceptCreate, CustomsBrokerConceptUpdate
 
 
-def create_customs_broker_concept(session: Session, data: CustomsBrokerConceptCreate) -> CustomsBrokerConcept:
+class CustomsBrokerConceptService:
-    db_obj = CustomsBrokerConcept(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[List[CustomsBrokerConcept], int]:
+        query = db.query(CustomsBrokerConcept).filter(
+            CustomsBrokerConcept.tenant_id == tenant_id,
+            CustomsBrokerConcept.company_id == company_id
+        )
 
+        total = query.count()
+        items = query.offset(skip).limit(limit).all()
 
-def get_customs_broker_concept(session: Session, id: int) -> Optional[CustomsBrokerConcept]:
+        return items, total
-    return session.get(CustomsBrokerConcept, id)
 
+    @staticmethod
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[CustomsBrokerConcept]:
+        return db.query(CustomsBrokerConcept).filter(
+            CustomsBrokerConcept.id == id,
+            CustomsBrokerConcept.tenant_id == tenant_id,
+            CustomsBrokerConcept.company_id == company_id
+        ).first()
 
-def get_customs_broker_concepts(session: Session, skip: int = 0, limit: int = 100) -> Sequence[CustomsBrokerConcept]:
+    @staticmethod
-    stmt = select(CustomsBrokerConcept).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session, data: CustomsBrokerConceptCreate, tenant_id: int, company_id: int
-    return result.scalars().all()
+    ) -> CustomsBrokerConcept:
+        db_obj = CustomsBrokerConcept(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session, id: int, tenant_id: int, data: CustomsBrokerConceptUpdate, company_id: int
+    ) -> Optional[CustomsBrokerConcept]:
+        db_obj = CustomsBrokerConceptService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_customs_broker_concept(session: Session, db_obj: CustomsBrokerConcept, update_data: CustomsBrokerConceptUpdate) -> CustomsBrokerConcept:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def delete_customs_broker_concept(session: Session, db_obj: CustomsBrokerConcept) -> CustomsBrokerConcept:
+    @staticmethod
-    session.delete(db_obj)
+    def delete(
-    session.commit()
+        db: Session, id: int, tenant_id: int, company_id: int
-    return db_obj
+    ) -> bool:
+        db_obj = CustomsBrokerConceptService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/doda/routes.py

@@ -8,6 +8,7 @@ from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
 from .dto import (
     DodaCreateDTO,
     DodaResponseDTO,
@@ -25,54 +26,40 @@ from .dto import (
 )
 from .models import Doda
 from .service import DodaService
+from core.security import get_current_user, validate_access_to_resource
 
-router = APIRouter(prefix="/doda", tags=["doda"])
+# Create CRUD router
+crud_router = TenantCRUDRoutes(
+    service=DodaService,
+    create_schema=DodaCreateDTO,
+    update_schema=DodaUpdateDTO,
+    response_schema=DodaResponseDTO,
+    prefix="/doda",
+    tags=["doda"],
+    resource_name="DODA",
+    id_name="doda_id",
+    enable_list=True,
+    enable_filters=True,
+).router
 
+router = crud_router
 
-# ============ MAIN DODA ENDPOINTS ============
+# ============ CUSTOM ENDPOINTS ============
-@router.get(
-    "",
-    response_model=dict,
-    summary="Get all DODAs",
-)
-async def get_all_dodas(
-    skip: int = Query(0, ge=0),
-    limit: int = Query(50, ge=1, le=100),
-    integration_number: str = Query(None),
-    status: str = Query(None),
-    patent: str = Query(None),
-    db: Session = Depends(get_core_db),
-):
-    """Get all DODAs with optional filtering and pagination"""
-    filters = {}
-    if integration_number:
-        filters["integration_number"] = integration_number
-    if status:
-        filters["status"] = status
-    if patent:
-        filters["patent"] = patent
-
-    dodas, total = DodaService.get_all(db, skip, limit, filters)
-
-    return {
-        "data": [DodaResponseDTO.model_validate(doda) for doda in dodas],
-        "total": total,
-        "skip": skip,
-        "limit": limit,
-    }
 
 
 @router.get(
-    "/{sys_id}",
+    "/{doda_id}/detail",
     response_model=DodaDetailResponseDTO,
     summary="Get DODA by ID with all details",
 )
-async def get_doda(
+async def get_doda_detail(
-    sys_id: int,
+    doda_id: int,
+    company_id: int = Query(..., description="Company ID"),
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
-    """Get a DODA by its ID with all related data"""
+    tenant_id = validate_access_to_resource(db, company_id, current_user)
-    doda = DodaService.get_by_id(db, sys_id)
+    doda = DodaService.get_by_id(db, doda_id, tenant_id, company_id)
     if not doda:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -81,88 +68,34 @@ async def get_doda(
     return DodaDetailResponseDTO.model_validate(doda)
 
 
-@router.post(
-    "",
-    response_model=DodaResponseDTO,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create DODA",
-)
-async def create_doda(
-    doda_data: DodaCreateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Create a new DODA"""
-    doda = DodaService.create(db, doda_data)
-    return DodaResponseDTO.model_validate(doda)
-
-
-@router.put(
-    "/{sys_id}",
-    response_model=DodaResponseDTO,
-    summary="Update DODA",
-)
-async def update_doda(
-    sys_id: int,
-    doda_data: DodaUpdateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Update a DODA"""
-    doda = DodaService.update(db, sys_id, doda_data)
-    if not doda:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="DODA not found",
-        )
-    return DodaResponseDTO.model_validate(doda)
-
-
-@router.delete(
-    "/{sys_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    summary="Delete DODA",
-)
-async def delete_doda(
-    sys_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Delete a DODA"""
-    success = DodaService.delete(db, sys_id)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="DODA not found",
-        )
-    return None
-
-
 # ============ CONTAINERS ENDPOINTS ============
 @router.get(
-    "/{sys_id}/containers",
+    "/{doda_id}/containers",
     response_model=List[DodaContainerResponseDTO],
     summary="Get containers for DODA",
 )
 async def get_doda_containers(
-    sys_id: int,
+    doda_id: int,
     db: Session = Depends(get_core_db),
 ):
     """Get all containers for a specific DODA"""
-    containers = DodaService.get_containers(db, sys_id)
+    containers = DodaService.get_containers(db, doda_id)
     return [DodaContainerResponseDTO.model_validate(c) for c in containers]
 
 
 @router.post(
-    "/{sys_id}/containers",
+    "/{doda_id}/containers",
     response_model=DodaContainerResponseDTO,
     status_code=status.HTTP_201_CREATED,
     summary="Add container to DODA",
 )
 async def add_container(
-    sys_id: int,
+    doda_id: int,
     container_data: DodaContainerCreateDTO,
     db: Session = Depends(get_core_db),
 ):
     """Add a new container to a DODA"""
-    container = DodaService.add_container(db, sys_id, container_data)
+    container = DodaService.add_container(db, doda_id, container_data)
     if not container:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -172,19 +105,19 @@ async def add_container(
 
 
 @router.put(
-    "/{sys_id}/containers/{container_line}",
+    "/{doda_id}/containers/{container_line}",
     response_model=DodaContainerResponseDTO,
     summary="Update container",
 )
 async def update_container(
-    sys_id: int,
+    doda_id: int,
     container_line: int,
     container_data: DodaContainerUpdateDTO,
     db: Session = Depends(get_core_db),
 ):
     """Update a container"""
     container = DodaService.update_container(
-        db, sys_id, container_line, container_data
+        db, doda_id, container_line, container_data
     )
     if not container:
         raise HTTPException(
@@ -196,32 +129,32 @@ async def update_container(
 
 # ============ AMERICAN PEDIMENTOS ENDPOINTS ============
 @router.get(
-    "/{sys_id}/american-pedimentos",
+    "/{doda_id}/american-pedimentos",
     response_model=List[DodaAmericanPedimentoResponseDTO],
     summary="Get American pedimentos for DODA",
 )
 async def get_american_pedimentos(
-    sys_id: int,
+    doda_id: int,
     db: Session = Depends(get_core_db),
 ):
     """Get all American pedimentos for a specific DODA"""
-    pedimentos = DodaService.get_american_pedimentos(db, sys_id)
+    pedimentos = DodaService.get_american_pedimentos(db, doda_id)
     return [DodaAmericanPedimentoResponseDTO.model_validate(p) for p in pedimentos]
 
 
 @router.post(
-    "/{sys_id}/american-pedimentos",
+    "/{doda_id}/american-pedimentos",
     response_model=DodaAmericanPedimentoResponseDTO,
     status_code=status.HTTP_201_CREATED,
     summary="Add American pedimento to DODA",
 )
 async def add_american_pedimento(
-    sys_id: int,
+    doda_id: int,
     pedimento_data: DodaAmericanPedimentoCreateDTO,
     db: Session = Depends(get_core_db),
 ):
     """Add a new American pedimento to a DODA"""
-    pedimento = DodaService.add_american_pedimento(db, sys_id, pedimento_data)
+    pedimento = DodaService.add_american_pedimento(db, doda_id, pedimento_data)
     if not pedimento:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -232,32 +165,32 @@ async def add_american_pedimento(
 
 # ============ PEDIMENTOS ENDPOINTS ============
 @router.get(
-    "/{sys_id}/pedimentos",
+    "/{doda_id}/pedimentos",
     response_model=List[DodaPedimentoResponseDTO],
     summary="Get pedimentos for DODA",
 )
 async def get_doda_pedimentos(
-    sys_id: int,
+    doda_id: int,
     db: Session = Depends(get_core_db),
 ):
     """Get all pedimentos for a specific DODA"""
-    pedimentos = DodaService.get_pedimentos(db, sys_id)
+    pedimentos = DodaService.get_pedimentos(db, doda_id)
     return [DodaPedimentoResponseDTO.model_validate(p) for p in pedimentos]
 
 
 @router.post(
-    "/{sys_id}/pedimentos",
+    "/{doda_id}/pedimentos",
     response_model=DodaPedimentoResponseDTO,
     status_code=status.HTTP_201_CREATED,
     summary="Add pedimento to DODA",
 )
 async def add_pedimento(
-    sys_id: int,
+    doda_id: int,
     pedimento_data: DodaPedimentoCreateDTO,
     db: Session = Depends(get_core_db),
 ):
     """Add a new pedimento to a DODA"""
-    pedimento = DodaService.add_pedimento(db, sys_id, pedimento_data)
+    pedimento = DodaService.add_pedimento(db, doda_id, pedimento_data)
     if not pedimento:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,

backend/api/v1/modules/a76/general_catalogs/doda/service.py

@@ -34,19 +34,20 @@ logger = logging.getLogger(__name__)
 class DodaService:
     """Servicio para gestión de DODA"""
 
-    def __init__(self, db: Session):
-        self.db = db
-
-    # ============ DODA MAIN CRUD ============
     @staticmethod
     def get_all(
         db: Session,
+        tenant_id: int,
+        company_id: int,
         skip: int = 0,
         limit: int = 50,
         filters: Optional[Dict[str, Any]] = None,
     ) -> Tuple[List[Doda], int]:
         """Get all DODAs with pagination"""
-        query = db.query(Doda)
+        query = db.query(Doda).filter(
+            Doda.tenant_id == tenant_id,
+            Doda.company_id == company_id
+        )
 
         if filters:
             if filters.get("integration_number"):
@@ -66,15 +67,27 @@ class DodaService:
         return dodas, total
 
     @staticmethod
-    def get_by_id(db: Session, sys_id: int) -> Optional[Doda]:
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[Doda]:
         """Get DODA by ID"""
-        return db.query(Doda).filter(Doda.sys_id == sys_id).first()
+        return db.query(Doda).filter(
+            Doda.id == id,
+            Doda.tenant_id == tenant_id,
+            Doda.company_id == company_id
+        ).first()
 
     @staticmethod
-    def create(db: Session, doda_data: DodaCreateDTO) -> Doda:
+    def create(
+        db: Session, doda_data: DodaCreateDTO, tenant_id: int, company_id: int
+    ) -> Doda:
         """Create a new DODA"""
         try:
-            db_doda = Doda(**doda_data.model_dump(exclude_unset=True))
+            db_doda = Doda(
+                **doda_data.model_dump(exclude_unset=True),
+                tenant_id=tenant_id,
+                company_id=company_id
+            )
             db.add(db_doda)
             db.commit()
             db.refresh(db_doda)
@@ -89,10 +102,12 @@ class DodaService:
             raise HTTPException(status_code=500, detail="Error creating DODA")
 
     @staticmethod
-    def update(db: Session, sys_id: int, doda_data: DodaUpdateDTO) -> Optional[Doda]:
+    def update(
+        db: Session, id: int, tenant_id: int, doda_data: DodaUpdateDTO, company_id: int
+    ) -> Optional[Doda]:
         """Update a DODA"""
         try:
-            db_doda = db.query(Doda).filter(Doda.sys_id == sys_id).first()
+            db_doda = DodaService.get_by_id(db, id, tenant_id, company_id)
             if not db_doda:
                 return None
 
@@ -112,10 +127,12 @@ class DodaService:
             raise HTTPException(status_code=500, detail="Error updating DODA")
 
     @staticmethod
-    def delete(db: Session, sys_id: int) -> bool:
+    def delete(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> bool:
         """Delete a DODA"""
         try:
-            db_doda = db.query(Doda).filter(Doda.sys_id == sys_id).first()
+            db_doda = DodaService.get_by_id(db, id, tenant_id, company_id)
             if not db_doda:
                 return False
 
@@ -130,23 +147,23 @@ class DodaService:
     # ============ CONTAINERS ============
     @staticmethod
     def add_container(
-        db: Session, sys_id: int, container_data: DodaContainerCreateDTO
+        db: Session, doda_id: int, container_data: DodaContainerCreateDTO
     ) -> Optional[DodaContainer]:
         """Add a container to a DODA"""
         try:
-            doda = db.query(Doda).filter(Doda.sys_id == sys_id).first()
+            doda = db.query(Doda).filter(Doda.id == doda_id).first()
             if not doda:
                 return None
 
             # Get max line number
             max_line = (
                 db.query(DodaContainer)
-                .filter(DodaContainer.doda_sys_id == sys_id)
+                .filter(DodaContainer.doda_id == doda_id)
                 .count()
             )
 
             db_container = DodaContainer(
-                doda_sys_id=sys_id,
+                doda_id=doda_id,
                 container_line=max_line + 1,
                 **{
                     k: v
@@ -167,7 +184,7 @@ class DodaService:
     @staticmethod
     def update_container(
         db: Session,
-        sys_id: int,
+        doda_id: int,
         container_line: int,
         container_data: DodaContainerUpdateDTO,
     ) -> Optional[DodaContainer]:
@@ -176,7 +193,7 @@ class DodaService:
             db_container = (
                 db.query(DodaContainer)
                 .filter(
-                    DodaContainer.doda_sys_id == sys_id,
+                    DodaContainer.doda_id == doda_id,
                     DodaContainer.container_line == container_line,
                 )
                 .first()
@@ -197,33 +214,33 @@ class DodaService:
                 status_code=500, detail="Error updating container")
 
     @staticmethod
-    def get_containers(db: Session, sys_id: int) -> List[DodaContainer]:
+    def get_containers(db: Session, doda_id: int) -> List[DodaContainer]:
         """Get all containers for a DODA"""
         return (
             db.query(DodaContainer)
-            .filter(DodaContainer.doda_sys_id == sys_id)
+            .filter(DodaContainer.doda_id == doda_id)
             .all()
         )
 
     # ============ AMERICAN PEDIMENTOS ============
     @staticmethod
     def add_american_pedimento(
-        db: Session, sys_id: int, pedimento_data: DodaAmericanPedimentoCreateDTO
+        db: Session, doda_id: int, pedimento_data: DodaAmericanPedimentoCreateDTO
     ) -> Optional[DodaAmericanPedimento]:
         """Add an American pedimento to a DODA"""
         try:
-            doda = db.query(Doda).filter(Doda.sys_id == sys_id).first()
+            doda = db.query(Doda).filter(Doda.id == doda_id).first()
             if not doda:
                 return None
 
             max_line = (
                 db.query(DodaAmericanPedimento)
-                .filter(DodaAmericanPedimento.doda_sys_id == sys_id)
+                .filter(DodaAmericanPedimento.doda_id == doda_id)
                 .count()
             )
 
             db_pedimento = DodaAmericanPedimento(
-                doda_sys_id=sys_id,
+                doda_id=doda_id,
                 american_pedimento_line=max_line + 1,
                 **pedimento_data.model_dump(exclude_unset=True),
             )
@@ -239,33 +256,33 @@ class DodaService:
             )
 
     @staticmethod
-    def get_american_pedimentos(db: Session, sys_id: int) -> List[DodaAmericanPedimento]:
+    def get_american_pedimentos(db: Session, doda_id: int) -> List[DodaAmericanPedimento]:
         """Get all American pedimentos for a DODA"""
         return (
             db.query(DodaAmericanPedimento)
-            .filter(DodaAmericanPedimento.doda_sys_id == sys_id)
+            .filter(DodaAmericanPedimento.doda_id == doda_id)
             .all()
         )
 
     # ============ PEDIMENTOS ============
     @staticmethod
     def add_pedimento(
-        db: Session, sys_id: int, pedimento_data: DodaPedimentoCreateDTO
+        db: Session, doda_id: int, pedimento_data: DodaPedimentoCreateDTO
     ) -> Optional[DodaPedimento]:
         """Add a pedimento to a DODA"""
         try:
-            doda = db.query(Doda).filter(Doda.sys_id == sys_id).first()
+            doda = db.query(Doda).filter(Doda.id == doda_id).first()
             if not doda:
                 return None
 
             max_line = (
                 db.query(DodaPedimento)
-                .filter(DodaPedimento.doda_sys_id == sys_id)
+                .filter(DodaPedimento.doda_id == doda_id)
                 .count()
             )
 
             db_pedimento = DodaPedimento(
-                doda_sys_id=sys_id,
+                doda_id=doda_id,
                 pedimento_line=max_line + 1,
                 **pedimento_data.model_dump(exclude_unset=True),
             )
@@ -280,9 +297,9 @@ class DodaService:
                 status_code=500, detail="Error adding pedimento")
 
     @staticmethod
-    def get_pedimentos(db: Session, sys_id: int) -> List[DodaPedimento]:
+    def get_pedimentos(db: Session, doda_id: int) -> List[DodaPedimento]:
         """Get all pedimentos for a DODA"""
         return (
             db.query(DodaPedimento).filter(
-                DodaPedimento.doda_sys_id == sys_id).all()
+                DodaPedimento.doda_id == doda_id).all()
         )

backend/api/v1/modules/a76/general_catalogs/electronic_notices/routes.py

@@ -2,12 +2,14 @@
 Rutas para gestión de avisos electrónicos
 """
 
+from core.security import get_current_user, validate_access_to_resource
 from typing import List
 
 from fastapi import APIRouter, Depends, HTTPException, Query, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
 from .dto import (
     ElectronicNoticeCreateDTO,
     ElectronicNoticeResponseDTO,
@@ -16,114 +18,17 @@ from .dto import (
 from .models import ElectronicNotice
 from .service import ElectronicNoticeService
 
-router = APIRouter(prefix="/electronic-notices", tags=["electronic-notices"])
+router = TenantCRUDRoutes(
-
+    service=ElectronicNoticeService,
-
+    create_schema=ElectronicNoticeCreateDTO,
-@router.get(
+    update_schema=ElectronicNoticeUpdateDTO,
-    "",
+    response_schema=ElectronicNoticeResponseDTO,
-    response_model=dict,
+    prefix="/electronic-notices",
-    summary="Get all electronic notices",
+    tags=["electronic-notices"],
-)
+    resource_name="Electronic Notice",
-async def get_all_notices(
+    enable_list=True,
-    skip: int = Query(0, ge=0),
+    enable_filters=True,
-    limit: int = Query(50, ge=1, le=100),
+).router
-    notice_number: str = Query(None),
-    status: str = Query(None),
-    pedimento: str = Query(None),
-    db: Session = Depends(get_core_db),
-):
-    """Get all electronic notices with optional filtering and pagination"""
-    filters = {}
-    if notice_number:
-        filters["notice_number"] = notice_number
-    if status:
-        filters["status"] = status
-    if pedimento:
-        filters["pedimento"] = pedimento
-
-    notices, total = ElectronicNoticeService.get_all(db, skip, limit, filters)
-
-    return {
-        "data": [
-            ElectronicNoticeResponseDTO.model_validate(notice) for notice in notices
-        ],
-        "total": total,
-        "skip": skip,
-        "limit": limit,
-    }
-
-
-@router.get(
-    "/{sys_id}",
-    response_model=ElectronicNoticeResponseDTO,
-    summary="Get electronic notice by ID",
-)
-async def get_notice(
-    sys_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Get an electronic notice by its ID"""
-    notice = ElectronicNoticeService.get_by_id(db, sys_id)
-    if not notice:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Electronic notice not found",
-        )
-    return ElectronicNoticeResponseDTO.model_validate(notice)
-
-
-@router.post(
-    "",
-    response_model=ElectronicNoticeResponseDTO,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create electronic notice",
-)
-async def create_notice(
-    notice_data: ElectronicNoticeCreateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Create a new electronic notice"""
-    notice = ElectronicNoticeService.create(db, notice_data)
-    return ElectronicNoticeResponseDTO.model_validate(notice)
-
-
-@router.put(
-    "/{sys_id}",
-    response_model=ElectronicNoticeResponseDTO,
-    summary="Update electronic notice",
-)
-async def update_notice(
-    sys_id: int,
-    notice_data: ElectronicNoticeUpdateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Update an electronic notice"""
-    notice = ElectronicNoticeService.update(db, sys_id, notice_data)
-    if not notice:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Electronic notice not found",
-        )
-    return ElectronicNoticeResponseDTO.model_validate(notice)
-
-
-@router.delete(
-    "/{sys_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    summary="Delete electronic notice",
-)
-async def delete_notice(
-    sys_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Delete an electronic notice"""
-    success = ElectronicNoticeService.delete(db, sys_id)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Electronic notice not found",
-        )
-    return None
 
 
 @router.get(
@@ -133,10 +38,14 @@ async def delete_notice(
 )
 async def get_notices_by_pedimento(
     pedimento: str,
+    company_id: int = Query(..., description="Company ID"),
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
     """Get all electronic notices for a specific pedimento"""
-    notices = ElectronicNoticeService.get_by_pedimento(db, pedimento)
+    tenant_id = validate_access_to_resource(db, company_id, current_user)
+    notices = ElectronicNoticeService.get_by_pedimento(
+        db, pedimento, tenant_id, company_id)
     return [ElectronicNoticeResponseDTO.model_validate(notice) for notice in notices]
 
 
@@ -147,8 +56,12 @@ async def get_notices_by_pedimento(
 )
 async def get_notices_by_status(
     status: str,
+    company_id: int = Query(..., description="Company ID"),
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
     """Get all electronic notices with a specific status"""
-    notices = ElectronicNoticeService.get_by_status(db, status)
+    tenant_id = validate_access_to_resource(db, company_id, current_user)
+    notices = ElectronicNoticeService.get_by_status(
+        db, status, tenant_id, company_id)
     return [ElectronicNoticeResponseDTO.model_validate(notice) for notice in notices]

backend/api/v1/modules/a76/general_catalogs/electronic_notices/service.py

@@ -22,18 +22,20 @@ logger = logging.getLogger(__name__)
 class ElectronicNoticeService:
     """Servicio para gestión de avisos electrónicos"""
 
-    def __init__(self, db: Session):
-        self.db = db
-
     @staticmethod
     def get_all(
         db: Session,
+        tenant_id: int,
+        company_id: int,
         skip: int = 0,
         limit: int = 50,
         filters: Optional[Dict[str, Any]] = None,
     ) -> Tuple[List[ElectronicNotice], int]:
         """Get all electronic notices with pagination"""
-        query = db.query(ElectronicNotice)
+        query = db.query(ElectronicNotice).filter(
+            ElectronicNotice.tenant_id == tenant_id,
+            ElectronicNotice.company_id == company_id
+        )
 
         # Apply filters if provided
         if filters:
@@ -59,20 +61,26 @@ class ElectronicNoticeService:
         return notices, total
 
     @staticmethod
-    def get_by_id(db: Session, sys_id: int) -> Optional[ElectronicNotice]:
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[ElectronicNotice]:
         """Get electronic notice by ID"""
         return db.query(ElectronicNotice).filter(
-            ElectronicNotice.sys_id == sys_id
+            ElectronicNotice.id == id,
+            ElectronicNotice.tenant_id == tenant_id,
+            ElectronicNotice.company_id == company_id
         ).first()
 
     @staticmethod
     def create(
-        db: Session, notice_data: ElectronicNoticeCreateDTO
+        db: Session, notice_data: ElectronicNoticeCreateDTO, tenant_id: int, company_id: int
     ) -> ElectronicNotice:
         """Create a new electronic notice"""
         try:
             db_notice = ElectronicNotice(
-                **notice_data.model_dump(exclude_unset=True)
+                **notice_data.model_dump(exclude_unset=True),
+                tenant_id=tenant_id,
+                company_id=company_id
             )
 
             db.add(db_notice)
@@ -98,16 +106,12 @@ class ElectronicNoticeService:
 
     @staticmethod
     def update(
-        db: Session,
+        db: Session, id: int, tenant_id: int, notice_data: ElectronicNoticeUpdateDTO, company_id: int
-        sys_id: int,
-        notice_data: ElectronicNoticeUpdateDTO,
     ) -> Optional[ElectronicNotice]:
         """Update an electronic notice"""
         try:
-            db_notice = db.query(ElectronicNotice).filter(
+            db_notice = ElectronicNoticeService.get_by_id(
-                ElectronicNotice.sys_id == sys_id
+                db, id, tenant_id, company_id)
-            ).first()
-
             if not db_notice:
                 return None
 
@@ -116,7 +120,6 @@ class ElectronicNoticeService:
 
             db.commit()
             db.refresh(db_notice)
-
             return db_notice
 
         except IntegrityError as e:
@@ -135,19 +138,18 @@ class ElectronicNoticeService:
             )
 
     @staticmethod
-    def delete(db: Session, sys_id: int) -> bool:
+    def delete(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> bool:
         """Delete an electronic notice"""
         try:
-            db_notice = db.query(ElectronicNotice).filter(
+            db_notice = ElectronicNoticeService.get_by_id(
-                ElectronicNotice.sys_id == sys_id
+                db, id, tenant_id, company_id)
-            ).first()
-
             if not db_notice:
                 return False
 
             db.delete(db_notice)
             db.commit()
-
             return True
 
         except Exception as e:
@@ -159,20 +161,30 @@ class ElectronicNoticeService:
 
     @staticmethod
     def get_by_pedimento(
-        db: Session, pedimento: str
+        db: Session, pedimento: str, tenant_id: int, company_id: int
     ) -> List[ElectronicNotice]:
         """Get all electronic notices by pedimento"""
         return (
             db.query(ElectronicNotice)
-            .filter(ElectronicNotice.pedimento == pedimento)
+            .filter(
+                ElectronicNotice.pedimento == pedimento,
+                ElectronicNotice.tenant_id == tenant_id,
+                ElectronicNotice.company_id == company_id
+            )
             .all()
         )
 
     @staticmethod
-    def get_by_status(db: Session, status: str) -> List[ElectronicNotice]:
+    def get_by_status(
+        db: Session, status: str, tenant_id: int, company_id: int
+    ) -> List[ElectronicNotice]:
         """Get all electronic notices by status"""
         return (
             db.query(ElectronicNotice)
-            .filter(ElectronicNotice.status == status)
+            .filter(
+                ElectronicNotice.status == status,
+                ElectronicNotice.tenant_id == tenant_id,
+                ElectronicNotice.company_id == company_id
+            )
             .all()
         )

backend/api/v1/modules/a76/general_catalogs/equivalencies/models.py

@@ -1,14 +1,16 @@
 from typing import Optional, List
-from sqlalchemy import Integer, String, ForeignKey, UniqueConstraint
+from sqlalchemy import Integer, String, ForeignKey, UniqueConstraint, ForeignKeyConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
+from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
 from core.database import Base
 from api.v1.modules.a76.general_catalogs.units_of_measure.models import UnitOfMeasure
 
 
-class Equivalency(Base):
+class Equivalency(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "equivalencies"
     __table_args__ = (
-        UniqueConstraint("identifier", name="uq_equivalency_identifier"),
+        UniqueConstraint("identifier", "tenant_id", "company_id",
+                         name="uq_equivalency_identifier"),
         {"schema": "a76"}
     )
 
@@ -22,11 +24,16 @@ class Equivalency(Base):
         back_populates="equivalency", cascade="all, delete-orphan")
 
 
-class EquivalencyItem(Base):
+class EquivalencyItem(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "equivalency_items"
     __table_args__ = (
         UniqueConstraint("equivalency_id", "original_field",
-                         "external_field", name="uq_equivalency_item_fields"),
+                         "external_field", "tenant_id", "company_id", name="uq_equivalency_item_fields"),
+        ForeignKeyConstraint(
+            ["original_field", "tenant_id", "company_id"],
+            ["a76.units_of_measure.code", "a76.units_of_measure.tenant_id",
+                "a76.units_of_measure.company_id"]
+        ),
         {"schema": "a76"}
     )
 
@@ -34,8 +41,8 @@ class EquivalencyItem(Base):
         Integer, primary_key=True, autoincrement=True)
     equivalency_id: Mapped[int] = mapped_column(
         Integer, ForeignKey("a76.equivalencies.id"), nullable=False)
-    original_field: Mapped[str] = mapped_column(String(100), ForeignKey(
+    original_field: Mapped[str] = mapped_column(
-        "a76.units_of_measure.code"), nullable=False)  # Relation to Unit of Measure
+        String(100), nullable=False)  # Relation to Unit of Measure
     external_field: Mapped[str] = mapped_column(String(100), nullable=False)
 
     equivalency: Mapped["Equivalency"] = relationship(back_populates="items")

backend/api/v1/modules/a76/general_catalogs/equivalencies/routes.py

@@ -1,106 +1,99 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, status, Query
 from sqlalchemy.orm import Session
-from typing import List
+from typing import List, Dict, Any
 
 from core.database import get_core_db
+from core.security import get_current_user, validate_access_to_resource
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
 from . import service
+from .models import Equivalency, EquivalencyItem
 from .dto import (
     EquivalencyCreate, EquivalencyResponse, EquivalencyUpdate,
     EquivalencyItemCreate, EquivalencyItemResponse, EquivalencyItemUpdate
 )
+from .service import EquivalencyService, EquivalencyItemService
 
 router = APIRouter(prefix="/equivalencies",
                    tags=["a76.general_catalogs.equivalencies"])
 
-# Equivalency Routes
+# Equivalency CRUD
+equivalency_crud = TenantCRUDRoutes(
+    service=EquivalencyService,
+    create_schema=EquivalencyCreate,
+    update_schema=EquivalencyUpdate,
+    response_schema=EquivalencyResponse,
+    prefix="",
+    tags=["Equivalencies"],
+    resource_name="Equivalency",
+    enable_list=True,
+)
+
+# Equivalency Item CRUD
+item_crud = TenantCRUDRoutes(
+    service=EquivalencyItemService,
+    create_schema=EquivalencyItemCreate,
+    update_schema=EquivalencyItemUpdate,
+    response_schema=EquivalencyItemResponse,
+    prefix="/items",
+    tags=["Equivalency Items"],
+    resource_name="EquivalencyItem",
+    enable_list=True,
+)
+
+# Custom endpoint for creating items nested under equivalency
 
 
-@router.post("/", response_model=EquivalencyResponse, status_code=status.HTTP_201_CREATED)
+@equivalency_crud.router.post(
-def create_equivalency(
+    "/{equivalency_id}/items",
-    data: EquivalencyCreate,
+    response_model=EquivalencyItemResponse,
-    session: Session = Depends(get_core_db)
+    status_code=status.HTTP_201_CREATED,
-):
+    summary="Create equivalency item",
-    return service.create_equivalency(session, data)
+)
-
+async def create_equivalency_item(
-
-@router.get("/{id}", response_model=EquivalencyResponse)
-def get_equivalency(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_equivalency(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Equivalency not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[EquivalencyResponse])
-def get_equivalencies(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_equivalencies(session, skip, limit)
-
-
-@router.put("/{id}", response_model=EquivalencyResponse)
-def update_equivalency(
-    id: int,
-    data: EquivalencyUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_equivalency(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Equivalency not found")
-    return service.update_equivalency(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=EquivalencyResponse)
-def delete_equivalency(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_equivalency(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Equivalency not found")
-    return service.delete_equivalency(session, db_obj)
-
-# Equivalency Item Routes
-
-
-@router.post("/{equivalency_id}/items", response_model=EquivalencyItemResponse, status_code=status.HTTP_201_CREATED)
-def create_equivalency_item(
     equivalency_id: int,
     data: EquivalencyItemCreate,
-    session: Session = Depends(get_core_db)
+    company_id: int = Query(..., description="Company ID"),
+    db: Session = Depends(get_core_db),
+    current_user: Dict[str, Any] = Depends(get_current_user),
 ):
+    tenant_id = validate_access_to_resource(db, company_id, current_user)
+
     # Verify parent exists
-    parent = service.get_equivalency(session, equivalency_id)
+    parent = EquivalencyService.get_by_id(
+        db, equivalency_id, tenant_id, company_id)
     if not parent:
         raise HTTPException(status_code=404, detail="Equivalency not found")
-    return service.create_equivalency_item(session, equivalency_id, data)
+
+    # Create item
+    # We need to manually handle the creation because the DTO doesn't have equivalency_id
+    # and the service.create expects data to match the model or DTO.
+    # But service.create takes EquivalencyItemCreate which doesn't have equivalency_id.
+    # So we need to modify the data or handle it in service.
+
+    # Actually, I implemented EquivalencyItemService.create to take EquivalencyItemCreate.
+    # And it tries to create the model.
+    # But the model needs equivalency_id.
+    # So EquivalencyItemService.create will fail if I don't pass equivalency_id.
+    # I should update EquivalencyItemService.create to accept extra kwargs or handle this.
+
+    # Let's update the service call here to pass equivalency_id manually if I can't change the service signature easily.
+    # But wait, I can just instantiate the model here or update the service.
+
+    # I'll update the service to handle it.
+    # But for now, let's assume I can pass it in the data if I convert it to dict.
+
+    item_data = data.model_dump()
+    item_data['equivalency_id'] = equivalency_id
+
+    # I need to call a method that accepts this.
+    # EquivalencyItemService.create takes EquivalencyItemCreate.
+    # I should probably add a specific method for this or update create.
+
+    # Let's use a direct DB call here or add a method to service.
+    # Adding a method to service is cleaner.
+
+    return EquivalencyItemService.create_nested(db, equivalency_id, data, tenant_id, company_id)
 
 
-@router.put("/items/{id}", response_model=EquivalencyItemResponse)
+router.include_router(equivalency_crud.router)
-def update_equivalency_item(
+router.include_router(item_crud.router)
-    id: int,
-    data: EquivalencyItemUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_equivalency_item(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Equivalency Item not found")
-    return service.update_equivalency_item(session, db_obj, data)
-
-
-@router.delete("/items/{id}", response_model=EquivalencyItemResponse)
-def delete_equivalency_item(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_equivalency_item(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Equivalency Item not found")
-    return service.delete_equivalency_item(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/equivalencies/service.py

@@ -1,83 +1,228 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
+from fastapi import HTTPException
 
 from .models import Equivalency, EquivalencyItem
 from .dto import EquivalencyCreate, EquivalencyUpdate, EquivalencyItemCreate, EquivalencyItemUpdate
 
-# Equivalency Services
+
+class EquivalencyService:
+    @staticmethod
+    def get_all(
+        db: Session,
+        tenant_id: int,
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[Equivalency], int]:
+        query = db.query(Equivalency).filter(
+            Equivalency.tenant_id == tenant_id,
+            Equivalency.company_id == company_id
+        )
+
+        if filters:
+            # Add filters here if needed
+            pass
+
+        total = query.count()
+        items = query.offset(skip).limit(limit).all()
+        return items, total
+
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Equivalency]:
+        return db.query(Equivalency).filter(
+            Equivalency.id == id,
+            Equivalency.tenant_id == tenant_id,
+            Equivalency.company_id == company_id
+        ).first()
+
+    @staticmethod
+    def create(
+        db: Session,
+        data: EquivalencyCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> Equivalency:
+        db_obj = Equivalency(
+            identifier=data.identifier,
+            description=data.description,
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+
+        if data.items:
+            for item_data in data.items:
+                item = EquivalencyItem(
+                    **item_data.model_dump(),
+                    equivalency_id=db_obj.id,
+                    tenant_id=tenant_id,
+                    company_id=company_id
+                )
+                db.add(item)
+            db.commit()
+            db.refresh(db_obj)
+
+        return db_obj
+
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        data: EquivalencyUpdate,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Equivalency]:
+        db_obj = EquivalencyService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
+
+        update_dict = data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
+            if key != 'items':  # Handle items separately if needed, or ignore for now as per original code
+                setattr(db_obj, key, value)
+
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    @staticmethod
+    def delete(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = EquivalencyService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True
 
 
-def create_equivalency(session: Session, data: EquivalencyCreate) -> Equivalency:
+class EquivalencyItemService:
-    db_obj = Equivalency(identifier=data.identifier,
+    @staticmethod
-                         description=data.description)
+    def get_all(
-    session.add(db_obj)
+        db: Session,
-    session.commit()
+        tenant_id: int,
-    session.refresh(db_obj)
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[EquivalencyItem], int]:
+        query = db.query(EquivalencyItem).filter(
+            EquivalencyItem.tenant_id == tenant_id,
+            EquivalencyItem.company_id == company_id
+        )
 
-    if data.items:
+        if filters and "equivalency_id" in filters:
-        for item_data in data.items:
+            query = query.filter(
-            item = EquivalencyItem(
+                EquivalencyItem.equivalency_id == filters["equivalency_id"])
-                **item_data.model_dump(), equivalency_id=db_obj.id)
-            session.add(item)
-        session.commit()
-        session.refresh(db_obj)
 
-    return db_obj
+        total = query.count()
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[EquivalencyItem]:
+        return db.query(EquivalencyItem).filter(
+            EquivalencyItem.id == id,
+            EquivalencyItem.tenant_id == tenant_id,
+            EquivalencyItem.company_id == company_id
+        ).first()
 
-def get_equivalency(session: Session, id: int) -> Optional[Equivalency]:
+    @staticmethod
-    stmt = select(Equivalency).where(Equivalency.id == id)
+    def create(
-    result =  session.execute(stmt)
+        db: Session,
-    return result.scalars().first()
+        data: EquivalencyItemCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> EquivalencyItem:
+        # Note: equivalency_id should be in data or handled by the caller if it's a nested route
+        # But TenantCRUDRoutes for child resources might pass it in filters or we need to handle it.
+        # For now, assuming it's in data or we don't use child resource feature yet.
 
+        # If using child resource, the parent_id is usually passed in the path.
+        # But TenantCRUDRoutes passes the body.
 
-def get_equivalencies(session: Session, skip: int = 0, limit: int = 100) -> Sequence[Equivalency]:
+        db_obj = EquivalencyItem(
-    stmt = select(Equivalency).offset(skip).limit(limit)
+            **data.model_dump(),
-    result =  session.execute(stmt)
+            tenant_id=tenant_id,
-    return result.scalars().all()
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def create_nested(
+        db: Session,
+        equivalency_id: int,
+        data: EquivalencyItemCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> EquivalencyItem:
+        db_obj = EquivalencyItem(
+            **data.model_dump(),
+            equivalency_id=equivalency_id,
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def update_equivalency(session: Session, db_obj: Equivalency, update_data: EquivalencyUpdate) -> Equivalency:
+    @staticmethod
-    update_dict = update_data.model_dump(exclude_unset=True)
+    def update(
-    for key, value in update_dict.items():
+        db: Session,
-        setattr(db_obj, key, value)
+        id: int,
-    session.commit()
+        data: EquivalencyItemUpdate,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int
+    ) -> Optional[EquivalencyItem]:
+        db_obj = EquivalencyItemService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
+        update_dict = data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
+            setattr(db_obj, key, value)
 
-def delete_equivalency(session: Session, db_obj: Equivalency) -> Equivalency:
+        db.commit()
-    session.delete(db_obj)
+        db.refresh(db_obj)
-    session.commit()
+        return db_obj
-    return db_obj
 
-# Equivalency Item Services
+    @staticmethod
+    def delete(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = EquivalencyItemService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
 
-
+        db.delete(db_obj)
-def create_equivalency_item(session: Session, equivalency_id: int, data: EquivalencyItemCreate) -> EquivalencyItem:
+        db.commit()
-    db_obj = EquivalencyItem(
+        return True
-        **data.model_dump(), equivalency_id=equivalency_id)
-    session.add(db_obj)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
-
-
-def get_equivalency_item(session: Session, id: int) -> Optional[EquivalencyItem]:
-    return  session.get(EquivalencyItem, id)
-
-
-def update_equivalency_item(session: Session, db_obj: EquivalencyItem, update_data: EquivalencyItemUpdate) -> EquivalencyItem:
-    update_dict = update_data.model_dump(exclude_unset=True)
-    for key, value in update_dict.items():
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
-
-
-def delete_equivalency_item(session: Session, db_obj: EquivalencyItem) -> EquivalencyItem:
-    session.delete(db_obj)
-    session.commit()
-    return db_obj

backend/api/v1/modules/a76/general_catalogs/error_catalogs/routes.py

@@ -4,10 +4,12 @@ Rutas para gestión de catálogos de errores
 
 from typing import List
 
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
+from core.security import get_current_user
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
 from .dto import (
     ErrorClassificationCreateDTO,
     ErrorClassificationResponseDTO,
@@ -23,73 +25,39 @@ from .service import ErrorClassificationService, ErrorCatalogService
 
 router = APIRouter(prefix="/error-catalogs", tags=["error-catalogs"])
 
-
 # ============ ERROR CLASSIFICATIONS ENDPOINTS ============
-@router.get(
+
-    "/classifications",
+classification_crud = TenantCRUDRoutes(
-    response_model=dict,
+    service=ErrorClassificationService,
-    summary="Get all error classifications",
+    create_schema=ErrorClassificationCreateDTO,
+    update_schema=ErrorClassificationUpdateDTO,
+    response_schema=ErrorClassificationResponseDTO,
+    prefix="/classifications",
+    tags=["error-classifications"],
+    resource_name="ErrorClassification",
+    enable_list=True,
 )
-async def get_all_classifications(
-    skip: int = Query(0, ge=0),
-    limit: int = Query(50, ge=1, le=100),
-    code: str = Query(None),
-    level: str = Query(None),
-    db: Session = Depends(get_core_db),
-):
-    """Get all error classifications with optional filtering and pagination"""
-    filters = {}
-    if code:
-        filters["code"] = code
-    if level:
-        filters["level"] = level
 
-    classifications, total = ErrorClassificationService.get_all(
+# Add custom endpoints for classifications
-        db, skip, limit, filters
-    )
-
-    return {
-        "data": [
-            ErrorClassificationResponseDTO.model_validate(classification)
-            for classification in classifications
-        ],
-        "total": total,
-        "skip": skip,
-        "limit": limit,
-    }
 
 
-@router.get(
+@classification_crud.router.get(
-    "/classifications/{classification_id}",
+    "/code/{code}",
-    response_model=ErrorClassificationDetailResponseDTO,
-    summary="Get error classification by ID with errors",
-)
-async def get_classification(
-    classification_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Get an error classification by its ID with all related errors"""
-    classification = ErrorClassificationService.get_by_id(
-        db, classification_id)
-    if not classification:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Classification not found",
-        )
-    return ErrorClassificationDetailResponseDTO.model_validate(classification)
-
-
-@router.get(
-    "/classifications/code/{code}",
     response_model=ErrorClassificationDetailResponseDTO,
     summary="Get error classification by code with errors",
 )
 async def get_classification_by_code(
     code: str,
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
     """Get an error classification by its code with all related errors"""
-    classification = ErrorClassificationService.get_by_code(db, code)
+    classification = ErrorClassificationService.get_by_code(
+        db,
+        code,
+        tenant_id=current_user["tenant_id"],
+        company_id=current_user["company_id"]
+    )
     if not classification:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -97,118 +65,53 @@ async def get_classification_by_code(
         )
     return ErrorClassificationDetailResponseDTO.model_validate(classification)
 
+# Override get_by_id to return detail DTO
 
-@router.post(
+
-    "/classifications",
+@classification_crud.router.get(
-    response_model=ErrorClassificationResponseDTO,
+    "/{id}",
-    status_code=status.HTTP_201_CREATED,
+    response_model=ErrorClassificationDetailResponseDTO,
-    summary="Create error classification",
+    summary="Get error classification by ID with errors",
 )
-async def create_classification(
+async def get_classification(
-    classification_data: ErrorClassificationCreateDTO,
+    id: int,
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
-    """Create a new error classification"""
+    """Get an error classification by its ID with all related errors"""
-    classification = ErrorClassificationService.create(db, classification_data)
+    classification = ErrorClassificationService.get_by_id(
-    return ErrorClassificationResponseDTO.model_validate(classification)
+        db,
-
+        id,
-
+        tenant_id=current_user["tenant_id"],
-@router.put(
+        company_id=current_user["company_id"]
-    "/classifications/{classification_id}",
-    response_model=ErrorClassificationResponseDTO,
-    summary="Update error classification",
-)
-async def update_classification(
-    classification_id: int,
-    classification_data: ErrorClassificationUpdateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Update an error classification"""
-    classification = ErrorClassificationService.update(
-        db, classification_id, classification_data
     )
     if not classification:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
             detail="Classification not found",
         )
-    return ErrorClassificationResponseDTO.model_validate(classification)
+    return ErrorClassificationDetailResponseDTO.model_validate(classification)
 
-
+router.include_router(classification_crud.router)
-@router.delete(
-    "/classifications/{classification_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    summary="Delete error classification",
-)
-async def delete_classification(
-    classification_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Delete an error classification"""
-    success = ErrorClassificationService.delete(db, classification_id)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Classification not found",
-        )
-    return None
 
 
 # ============ ERROR CATALOG ENDPOINTS ============
-@router.get(
+
-    "",
+catalog_crud = TenantCRUDRoutes(
-    response_model=dict,
+    service=ErrorCatalogService,
-    summary="Get all errors in catalog",
+    create_schema=ErrorCatalogCreateDTO,
+    update_schema=ErrorCatalogUpdateDTO,
+    response_schema=ErrorCatalogResponseDTO,
+    prefix="",
+    tags=["error-catalogs"],
+    resource_name="ErrorCatalog",
+    enable_list=True,
 )
-async def get_all_errors(
-    skip: int = Query(0, ge=0),
-    limit: int = Query(50, ge=1, le=100),
-    code: str = Query(None),
-    description: str = Query(None),
-    classification_code: str = Query(None),
-    db: Session = Depends(get_core_db),
-):
-    """Get all error catalogs with optional filtering and pagination"""
-    filters = {}
-    if code:
-        filters["code"] = code
-    if description:
-        filters["description"] = description
-    if classification_code:
-        filters["classification_code"] = classification_code
 
-    catalogs, total = ErrorCatalogService.get_all(db, skip, limit, filters)
+# Add custom endpoints for catalogs
-
-    return {
-        "data": [
-            ErrorCatalogResponseDTO.model_validate(catalog) for catalog in catalogs
-        ],
-        "total": total,
-        "skip": skip,
-        "limit": limit,
-    }
 
 
-@router.get(
+@catalog_crud.router.get(
-    "/{error_id}",
-    response_model=ErrorCatalogDetailResponseDTO,
-    summary="Get error by ID",
-)
-async def get_error(
-    error_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Get an error by its ID with classification details"""
-    error = ErrorCatalogService.get_by_id(db, error_id)
-    if not error:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Error not found",
-        )
-    return ErrorCatalogDetailResponseDTO.model_validate(error)
-
-
-@router.get(
     "/code/{code}",
     response_model=ErrorCatalogDetailResponseDTO,
     summary="Get error by code",
@@ -216,9 +119,15 @@ async def get_error(
 async def get_error_by_code(
     code: str,
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
     """Get an error by its code with classification details"""
-    error = ErrorCatalogService.get_by_code(db, code)
+    error = ErrorCatalogService.get_by_code(
+        db,
+        code,
+        tenant_id=current_user["tenant_id"],
+        company_id=current_user["company_id"]
+    )
     if not error:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -227,61 +136,7 @@ async def get_error_by_code(
     return ErrorCatalogDetailResponseDTO.model_validate(error)
 
 
-@router.post(
+@catalog_crud.router.get(
-    "",
-    response_model=ErrorCatalogResponseDTO,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create error in catalog",
-)
-async def create_error(
-    error_data: ErrorCatalogCreateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Create a new error in the catalog"""
-    error = ErrorCatalogService.create(db, error_data)
-    return ErrorCatalogResponseDTO.model_validate(error)
-
-
-@router.put(
-    "/{error_id}",
-    response_model=ErrorCatalogResponseDTO,
-    summary="Update error in catalog",
-)
-async def update_error(
-    error_id: int,
-    error_data: ErrorCatalogUpdateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Update an error in the catalog"""
-    error = ErrorCatalogService.update(db, error_id, error_data)
-    if not error:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Error not found",
-        )
-    return ErrorCatalogResponseDTO.model_validate(error)
-
-
-@router.delete(
-    "/{error_id}",
-    status_code=status.HTTP_204_NO_CONTENT,
-    summary="Delete error from catalog",
-)
-async def delete_error(
-    error_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Delete an error from the catalog"""
-    success = ErrorCatalogService.delete(db, error_id)
-    if not success:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Error not found",
-        )
-    return None
-
-
-@router.get(
     "/classification/{classification_id}",
     response_model=List[ErrorCatalogResponseDTO],
     summary="Get errors by classification",
@@ -289,7 +144,42 @@ async def delete_error(
 async def get_errors_by_classification(
     classification_id: int,
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
     """Get all errors for a specific classification"""
-    errors = ErrorCatalogService.get_by_classification(db, classification_id)
+    errors = ErrorCatalogService.get_by_classification(
+        db,
+        classification_id,
+        tenant_id=current_user["tenant_id"],
+        company_id=current_user["company_id"]
+    )
     return [ErrorCatalogResponseDTO.model_validate(error) for error in errors]
+
+# Override get_by_id to return detail DTO
+
+
+@catalog_crud.router.get(
+    "/{id}",
+    response_model=ErrorCatalogDetailResponseDTO,
+    summary="Get error by ID",
+)
+async def get_error(
+    id: int,
+    db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
+):
+    """Get an error by its ID with classification details"""
+    error = ErrorCatalogService.get_by_id(
+        db,
+        id,
+        tenant_id=current_user["tenant_id"],
+        company_id=current_user["company_id"]
+    )
+    if not error:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail="Error not found",
+        )
+    return ErrorCatalogDetailResponseDTO.model_validate(error)
+
+router.include_router(catalog_crud.router)

backend/api/v1/modules/a76/general_catalogs/error_catalogs/service.py

@@ -25,18 +25,20 @@ logger = logging.getLogger(__name__)
 class ErrorClassificationService:
     """Servicio para gestión de clasificaciones de errores"""
 
-    def __init__(self, db: Session):
-        self.db = db
-
     @staticmethod
     def get_all(
         db: Session,
+        tenant_id: int,
+        company_id: int,
         skip: int = 0,
         limit: int = 50,
         filters: Optional[Dict[str, Any]] = None,
     ) -> Tuple[List[ErrorClassification], int]:
         """Get all error classifications with pagination"""
-        query = db.query(ErrorClassification)
+        query = db.query(ErrorClassification).filter(
+            ErrorClassification.tenant_id == tenant_id,
+            ErrorClassification.company_id == company_id
+        )
 
         if filters:
             if filters.get("code"):
@@ -54,31 +56,45 @@ class ErrorClassificationService:
         return classifications, total
 
     @staticmethod
-    def get_by_code(db: Session, code: str) -> Optional[ErrorClassification]:
+    def get_by_code(
+        db: Session, code: str, tenant_id: int, company_id: int
+    ) -> Optional[ErrorClassification]:
         """Get error classification by code"""
         return (
             db.query(ErrorClassification)
-            .filter(ErrorClassification.code == code)
+            .filter(
+                ErrorClassification.code == code,
+                ErrorClassification.tenant_id == tenant_id,
+                ErrorClassification.company_id == company_id
+            )
             .first()
         )
 
     @staticmethod
-    def get_by_id(db: Session, classification_id: int) -> Optional[ErrorClassification]:
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[ErrorClassification]:
         """Get error classification by ID"""
         return (
             db.query(ErrorClassification)
-            .filter(ErrorClassification.id == classification_id)
+            .filter(
+                ErrorClassification.id == id,
+                ErrorClassification.tenant_id == tenant_id,
+                ErrorClassification.company_id == company_id
+            )
             .first()
         )
 
     @staticmethod
     def create(
-        db: Session, classification_data: ErrorClassificationCreateDTO
+        db: Session, classification_data: ErrorClassificationCreateDTO, tenant_id: int, company_id: int
     ) -> ErrorClassification:
         """Create a new error classification"""
         try:
             db_classification = ErrorClassification(
-                **classification_data.model_dump(exclude_unset=True)
+                **classification_data.model_dump(exclude_unset=True),
+                tenant_id=tenant_id,
+                company_id=company_id
             )
 
             db.add(db_classification)
@@ -104,18 +120,12 @@ class ErrorClassificationService:
 
     @staticmethod
     def update(
-        db: Session,
+        db: Session, id: int, tenant_id: int, classification_data: ErrorClassificationUpdateDTO, company_id: int
-        classification_id: int,
-        classification_data: ErrorClassificationUpdateDTO,
     ) -> Optional[ErrorClassification]:
         """Update an error classification"""
         try:
-            db_classification = (
+            db_classification = ErrorClassificationService.get_by_id(
-                db.query(ErrorClassification)
+                db, id, tenant_id, company_id)
-                .filter(ErrorClassification.id == classification_id)
-                .first()
-            )
-
             if not db_classification:
                 return None
 
@@ -124,7 +134,6 @@ class ErrorClassificationService:
 
             db.commit()
             db.refresh(db_classification)
-
             return db_classification
 
         except IntegrityError as e:
@@ -143,21 +152,18 @@ class ErrorClassificationService:
             )
 
     @staticmethod
-    def delete(db: Session, classification_id: int) -> bool:
+    def delete(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> bool:
         """Delete an error classification"""
         try:
-            db_classification = (
+            db_classification = ErrorClassificationService.get_by_id(
-                db.query(ErrorClassification)
+                db, id, tenant_id, company_id)
-                .filter(ErrorClassification.id == classification_id)
-                .first()
-            )
-
             if not db_classification:
                 return False
 
             db.delete(db_classification)
             db.commit()
-
             return True
 
         except Exception as e:
@@ -171,18 +177,20 @@ class ErrorClassificationService:
 class ErrorCatalogService:
     """Servicio para gestión de catálogos de errores"""
 
-    def __init__(self, db: Session):
-        self.db = db
-
     @staticmethod
     def get_all(
         db: Session,
+        tenant_id: int,
+        company_id: int,
         skip: int = 0,
         limit: int = 50,
         filters: Optional[Dict[str, Any]] = None,
     ) -> Tuple[List[ErrorCatalog], int]:
         """Get all error catalogs with pagination"""
-        query = db.query(ErrorCatalog)
+        query = db.query(ErrorCatalog).filter(
+            ErrorCatalog.tenant_id == tenant_id,
+            ErrorCatalog.company_id == company_id
+        )
 
         if filters:
             if filters.get("code"):
@@ -204,35 +212,57 @@ class ErrorCatalogService:
         return catalogs, total
 
     @staticmethod
-    def get_by_code(db: Session, code: str) -> Optional[ErrorCatalog]:
+    def get_by_code(
+        db: Session, code: str, tenant_id: int, company_id: int
+    ) -> Optional[ErrorCatalog]:
         """Get error catalog by code"""
-        return db.query(ErrorCatalog).filter(ErrorCatalog.code == code).first()
+        return db.query(ErrorCatalog).filter(
+            ErrorCatalog.code == code,
+            ErrorCatalog.tenant_id == tenant_id,
+            ErrorCatalog.company_id == company_id
+        ).first()
 
     @staticmethod
-    def get_by_id(db: Session, error_id: int) -> Optional[ErrorCatalog]:
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[ErrorCatalog]:
         """Get error catalog by ID"""
-        return db.query(ErrorCatalog).filter(ErrorCatalog.id == error_id).first()
+        return db.query(ErrorCatalog).filter(
+            ErrorCatalog.id == id,
+            ErrorCatalog.tenant_id == tenant_id,
+            ErrorCatalog.company_id == company_id
+        ).first()
 
     @staticmethod
     def get_by_classification(
-        db: Session, classification_id: int
+        db: Session, classification_id: int, tenant_id: int, company_id: int
     ) -> List[ErrorCatalog]:
         """Get all errors by classification"""
         return (
             db.query(ErrorCatalog)
-            .filter(ErrorCatalog.classification_id == classification_id)
+            .filter(
+                ErrorCatalog.classification_id == classification_id,
+                ErrorCatalog.tenant_id == tenant_id,
+                ErrorCatalog.company_id == company_id
+            )
             .all()
         )
 
     @staticmethod
-    def create(db: Session, error_data: ErrorCatalogCreateDTO) -> ErrorCatalog:
+    def create(
+        db: Session, error_data: ErrorCatalogCreateDTO, tenant_id: int, company_id: int
+    ) -> ErrorCatalog:
         """Create a new error catalog"""
         try:
             # Validate classification exists if provided
             if error_data.classification_id:
                 classification = (
                     db.query(ErrorClassification)
-                    .filter(ErrorClassification.id == error_data.classification_id)
+                    .filter(
+                        ErrorClassification.id == error_data.classification_id,
+                        ErrorClassification.tenant_id == tenant_id,
+                        ErrorClassification.company_id == company_id
+                    )
                     .first()
                 )
                 if not classification:
@@ -242,7 +272,10 @@ class ErrorCatalogService:
                     )
 
             db_error = ErrorCatalog(
-                **error_data.model_dump(exclude_unset=True))
+                **error_data.model_dump(exclude_unset=True),
+                tenant_id=tenant_id,
+                company_id=company_id
+            )
 
             db.add(db_error)
             db.commit()
@@ -263,30 +296,17 @@ class ErrorCatalogService:
             db.rollback()
             logger.error(f"Error creating error catalog: {str(e)}")
             raise HTTPException(
-                status_code=500, detail="Error creating error catalog")
+                status_code=500, detail="Error creating error catalog"
+            )
 
     @staticmethod
     def update(
-        db: Session, error_id: int, error_data: ErrorCatalogUpdateDTO
+        db: Session, id: int, tenant_id: int, error_data: ErrorCatalogUpdateDTO, company_id: int
     ) -> Optional[ErrorCatalog]:
         """Update an error catalog"""
         try:
-            # Validate classification exists if provided
+            db_error = ErrorCatalogService.get_by_id(
-            if error_data.classification_id:
+                db, id, tenant_id, company_id)
-                classification = (
-                    db.query(ErrorClassification)
-                    .filter(ErrorClassification.id == error_data.classification_id)
-                    .first()
-                )
-                if not classification:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="Classification not found",
-                    )
-
-            db_error = db.query(ErrorCatalog).filter(
-                ErrorCatalog.id == error_id).first()
-
             if not db_error:
                 return None
 
@@ -295,11 +315,8 @@ class ErrorCatalogService:
 
             db.commit()
             db.refresh(db_error)
-
             return db_error
 
-        except HTTPException:
-            raise
         except IntegrityError as e:
             db.rollback()
             logger.error(f"IntegrityError updating error catalog: {str(e)}")
@@ -315,22 +332,23 @@ class ErrorCatalogService:
             )
 
     @staticmethod
-    def delete(db: Session, error_id: int) -> bool:
+    def delete(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> bool:
         """Delete an error catalog"""
         try:
-            db_error = db.query(ErrorCatalog).filter(
+            db_error = ErrorCatalogService.get_by_id(
-                ErrorCatalog.id == error_id).first()
+                db, id, tenant_id, company_id)
-
             if not db_error:
                 return False
 
             db.delete(db_error)
             db.commit()
-
             return True
 
         except Exception as e:
             db.rollback()
             logger.error(f"Error deleting error catalog: {str(e)}")
             raise HTTPException(
-                status_code=500, detail="Error deleting error catalog")
+                status_code=500, detail="Error deleting error catalog"
+            )

backend/api/v1/modules/a76/general_catalogs/exchange_rate/services.py

@@ -26,7 +26,8 @@ class ExchangeRateService:
         # Apply filters if provided
         if filters:
             if filters.get("date"):
-                query = query.filter(models.ExchangeRate.date == filters["date"])
+                query = query.filter(
+                    models.ExchangeRate.date == filters["date"])
             if filters.get("local_currency"):
                 query = query.filter(
                     models.ExchangeRate.local_currency == filters["local_currency"]
@@ -37,7 +38,8 @@ class ExchangeRateService:
                 )
 
         total = query.count()
-        exchange_rates = query.order_by(models.ExchangeRate.date.desc()).offset(skip).limit(limit).all()
+        exchange_rates = query.order_by(
+            models.ExchangeRate.date.desc()).offset(skip).limit(limit).all()
 
         return exchange_rates, total
 
@@ -76,9 +78,9 @@ class ExchangeRateService:
     def update(
         db: Session,
         exchange_rate_id: int,
+        exchange_rate_data: dto.ExchangeRateUpdateDTO,
         tenant_id: int,
         company_id: int,
-        exchange_rate_data: dto.ExchangeRateUpdateDTO,
     ) -> Optional[models.ExchangeRate]:
         """Update an exchange rate"""
         exchange_rate = ExchangeRateService.get_by_id(

backend/api/v1/modules/a76/general_catalogs/identifiers/routes.py

@@ -1,142 +1,36 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter
-from sqlalchemy.orm import Session
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from typing import List
-
-from core.database import get_core_db
-from core.security import get_current_user, validate_access_to_resource
-from . import service
 from .dto import (
     IdentifierCreate, IdentifierResponse, IdentifierUpdate,
     IdentifierDetailCreate, IdentifierDetailResponse, IdentifierDetailUpdate
 )
+from .service import IdentifierService, IdentifierDetailService
 
 router = APIRouter(prefix="/identifiers",
                    tags=["a76.general_catalogs.identifiers"])
 
-# Identifier Routes
+# Identifier CRUD
+identifier_crud = TenantCRUDRoutes(
+    create_schema=IdentifierCreate,
+    update_schema=IdentifierUpdate,
+    response_schema=IdentifierResponse,
+    service=IdentifierService,
+    prefix="",
+    tags=["Identifiers"],
+    resource_name="Identifier",
+    enable_list=True
+)
 
+# Identifier Detail CRUD
+detail_crud = TenantCRUDRoutes(
+    create_schema=IdentifierDetailCreate,
+    update_schema=IdentifierDetailUpdate,
+    response_schema=IdentifierDetailResponse,
+    service=IdentifierDetailService,
+    prefix="/details",
+    tags=["Identifier Details"],
+    resource_name="Identifier Detail"
+)
 
-@router.post("/", response_model=IdentifierResponse, status_code=status.HTTP_201_CREATED)
+router.include_router(identifier_crud.router)
-def create_identifier(
+router.include_router(detail_crud.router)
-    data: IdentifierCreate,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    tenant_id = validate_access_to_resource(
-        session, data.company_id, current_user)
-    return service.create_identifier(session, data, tenant_id)
-
-
-@router.get("/{id}", response_model=IdentifierResponse)
-def get_identifier(
-    id: int,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_identifier(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Identifier not found")
-    # Validate access to the resource's company
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return db_obj
-
-
-@router.get("/", response_model=List[IdentifierResponse])
-def get_identifiers(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    # Note: Listing usually requires filtering by company/tenant, but for simplicity here we just list.
-    # In a real scenario, we should filter by tenant_id from token or company_id query param.
-    # For now, we just return all, assuming the service might filter later or this is admin only.
-    # But since we need to validate access, we should probably ask for company_id in query.
-    # However, to keep it simple and consistent with previous modules (which didn't have this check),
-    # I will just return the list. But the user asked for validation.
-    # If I don't have a company_id to validate against, I can't validate.
-    # I'll leave it as is for list, but individual access is validated.
-    return service.get_identifiers(session, skip, limit)
-
-
-@router.put("/{id}", response_model=IdentifierResponse)
-def update_identifier(
-    id: int,
-    data: IdentifierUpdate,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_identifier(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Identifier not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return service.update_identifier(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=IdentifierResponse)
-def delete_identifier(
-    id: int,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_identifier(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Identifier not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return service.delete_identifier(session, db_obj)
-
-# Identifier Detail Routes
-
-
-@router.post("/details", response_model=IdentifierDetailResponse, status_code=status.HTTP_201_CREATED)
-def create_identifier_detail(
-    data: IdentifierDetailCreate,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    tenant_id = validate_access_to_resource(
-        session, data.company_id, current_user)
-    return service.create_identifier_detail(session, data, tenant_id)
-
-
-@router.get("/details/{id}", response_model=IdentifierDetailResponse)
-def get_identifier_detail(
-    id: int,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_identifier_detail(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Identifier Detail not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return db_obj
-
-
-@router.put("/details/{id}", response_model=IdentifierDetailResponse)
-def update_identifier_detail(
-    id: int,
-    data: IdentifierDetailUpdate,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_identifier_detail(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Identifier Detail not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return service.update_identifier_detail(session, db_obj, data)
-
-
-@router.delete("/details/{id}", response_model=IdentifierDetailResponse)
-def delete_identifier_detail(
-    id: int,
-    session: Session = Depends(get_core_db),
-    current_user=Depends(get_current_user)
-):
-    db_obj = service.get_identifier_detail(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Identifier Detail not found")
-    validate_access_to_resource(session, db_obj.company_id, current_user)
-    return service.delete_identifier_detail(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/identifiers/service.py

@@ -1,71 +1,196 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
-from typing import Sequence, Optional
+from sqlalchemy import select
 
 from .models import Identifier, IdentifierDetail
 from .dto import IdentifierCreate, IdentifierUpdate, IdentifierDetailCreate, IdentifierDetailUpdate
 
-# Identifier Services
+
+class IdentifierService:
+    @staticmethod
+    def get_all(
+        db: Session,
+        tenant_id: int,
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[Identifier], int]:
+        query = db.query(Identifier).filter(
+            Identifier.tenant_id == tenant_id,
+            Identifier.company_id == company_id
+        )
+
+        if filters:
+            # Add filters here if needed
+            pass
+
+        total = query.count()
+        items = query.offset(skip).limit(limit).all()
+        return items, total
+
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Identifier]:
+        return db.query(Identifier).filter(
+            Identifier.id == id,
+            Identifier.tenant_id == tenant_id,
+            Identifier.company_id == company_id
+        ).first()
+
+    @staticmethod
+    def create(
+        db: Session,
+        data: IdentifierCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> Identifier:
+        # Exclude company_id from data as it is passed separately
+        data_dict = data.model_dump()
+        if 'company_id' in data_dict:
+            del data_dict['company_id']
+
+        db_obj = Identifier(
+            **data_dict,
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        data: IdentifierUpdate,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Identifier]:
+        db_obj = IdentifierService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
+
+        update_dict = data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
+            setattr(db_obj, key, value)
+
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
+
+    @staticmethod
+    def delete(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = IdentifierService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True
 
 
-def create_identifier(session: Session, data: IdentifierCreate, tenant_id: int) -> Identifier:
+class IdentifierDetailService:
-    db_obj = Identifier(**data.model_dump(), tenant_id=tenant_id)
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[IdentifierDetail], int]:
+        query = db.query(IdentifierDetail).filter(
+            IdentifierDetail.tenant_id == tenant_id,
+            IdentifierDetail.company_id == company_id
+        )
 
+        if filters:
+            # Add filters here if needed
+            pass
 
-def get_identifier(session: Session, id: int) -> Optional[Identifier]:
+        total = query.count()
-    return session.get(Identifier, id)
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[IdentifierDetail]:
+        return db.query(IdentifierDetail).filter(
+            IdentifierDetail.id == id,
+            IdentifierDetail.tenant_id == tenant_id,
+            IdentifierDetail.company_id == company_id
+        ).first()
 
-def get_identifiers(session: Session, skip: int = 0, limit: int = 100) -> Sequence[Identifier]:
+    @staticmethod
-    return session.query(Identifier).offset(skip).limit(limit).all()
+    def create(
+        db: Session,
+        data: IdentifierDetailCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> IdentifierDetail:
+        # Exclude company_id from data as it is passed separately
+        data_dict = data.model_dump()
+        if 'company_id' in data_dict:
+            del data_dict['company_id']
 
+        db_obj = IdentifierDetail(
+            **data_dict,
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def update_identifier(session: Session, db_obj: Identifier, update_data: IdentifierUpdate) -> Identifier:
+    @staticmethod
-    update_dict = update_data.model_dump(exclude_unset=True)
+    def update(
-    for key, value in update_dict.items():
+        db: Session,
-        setattr(db_obj, key, value)
+        id: int,
-    session.commit()
+        data: IdentifierDetailUpdate,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int
+    ) -> Optional[IdentifierDetail]:
+        db_obj = IdentifierDetailService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
+        update_dict = data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
+            setattr(db_obj, key, value)
 
-def delete_identifier(session: Session, db_obj: Identifier) -> Identifier:
+        db.commit()
-    session.delete(db_obj)
+        db.refresh(db_obj)
-    session.commit()
+        return db_obj
-    return db_obj
 
-# Identifier Detail Services
+    @staticmethod
+    def delete(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = IdentifierDetailService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
 
-
+        db.delete(db_obj)
-def create_identifier_detail(session: Session, data: IdentifierDetailCreate, tenant_id: int) -> IdentifierDetail:
+        db.commit()
-    db_obj = IdentifierDetail(**data.model_dump(), tenant_id=tenant_id)
+        return True
-    session.add(db_obj)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
-
-
-def get_identifier_detail(session: Session, id: int) -> Optional[IdentifierDetail]:
-    return session.get(IdentifierDetail, id)
-
-
-def get_identifier_details(session: Session, skip: int = 0, limit: int = 100) -> Sequence[IdentifierDetail]:
-    return session.query(IdentifierDetail).offset(skip).limit(limit).all()
-
-
-def update_identifier_detail(session: Session, db_obj: IdentifierDetail, update_data: IdentifierDetailUpdate) -> IdentifierDetail:
-    update_dict = update_data.model_dump(exclude_unset=True)
-    for key, value in update_dict.items():
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
-
-
-def delete_identifier_detail(session: Session, db_obj: IdentifierDetail) -> IdentifierDetail:
-    session.delete(db_obj)
-    session.commit()
-    return db_obj

backend/api/v1/modules/a76/general_catalogs/inpc/models.py

@@ -9,7 +9,8 @@ from core.database import Base
 class INPC(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "inpc"
     __table_args__ = (
-        UniqueConstraint("year", "month", name="uq_inpc_year_month"),
+        UniqueConstraint("year", "month", "tenant_id",
+                         "company_id", name="uq_inpc_year_month"),
         {"schema": "a76"}
     )
 

backend/api/v1/modules/a76/general_catalogs/inpc/routes.py

@@ -1,60 +1,20 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter
-from sqlalchemy.orm import Session
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from typing import List
+from .models import INPC
-
-from core.database import get_core_db
-from . import service
 from .dto import INPCCreate, INPCResponse, INPCUpdate
+from .service import INPCService
 
 router = APIRouter(prefix="/inpc", tags=["a76.general_catalogs.inpc"])
 
+inpc_crud = TenantCRUDRoutes(
+    service=INPCService,
+    create_schema=INPCCreate,
+    update_schema=INPCUpdate,
+    response_schema=INPCResponse,
+    prefix="",
+    tags=["INPC"],
+    resource_name="INPC",
+    enable_list=True,
+)
 
-@router.post("/", response_model=INPCResponse, status_code=status.HTTP_201_CREATED)
+router.include_router(inpc_crud.router)
-def create_inpc(
-    data: INPCCreate,
-    session: Session = Depends(get_core_db)
-):
-    return service.create_inpc(session, data)
-
-
-@router.get("/{id}", response_model=INPCResponse)
-def get_inpc(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_inpc(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="INPC not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[INPCResponse])
-def get_inpcs(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_inpcs(session, skip, limit)
-
-
-@router.put("/{id}", response_model=INPCResponse)
-def update_inpc(
-    id: int,
-    data: INPCUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_inpc(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="INPC not found")
-    return service.update_inpc(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=INPCResponse)
-def delete_inpc(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_inpc(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="INPC not found")
-    return service.delete_inpc(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/inpc/service.py

@@ -1,39 +1,95 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import INPC
 from .dto import INPCCreate, INPCUpdate
 
 
-def create_inpc(session: Session, data: INPCCreate) -> INPC:
+class INPCService:
-    db_obj = INPC(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[INPC], int]:
+        query = db.query(INPC).filter(
+            INPC.tenant_id == tenant_id,
+            INPC.company_id == company_id
+        )
 
+        if filters:
+            # Add filters here if needed
+            pass
 
-def get_inpc(session: Session, id: int) -> Optional[INPC]:
+        total = query.count()
-    return session.get(INPC, id)
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[INPC]:
+        return db.query(INPC).filter(
+            INPC.id == id,
+            INPC.tenant_id == tenant_id,
+            INPC.company_id == company_id
+        ).first()
 
-def get_inpcs(session: Session, skip: int = 0, limit: int = 100) -> Sequence[INPC]:
+    @staticmethod
-    stmt = select(INPC).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session,
-    return result.scalars().all()
+        data: INPCCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> INPC:
+        db_obj = INPC(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        data: INPCUpdate,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[INPC]:
+        db_obj = INPCService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_inpc(session: Session, db_obj: INPC, update_data: INPCUpdate) -> INPC:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def delete_inpc(session: Session, db_obj: INPC) -> INPC:
+    @staticmethod
-    session.delete(db_obj)
+    def delete(
-    session.commit()
+        db: Session,
-    return db_obj
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = INPCService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/legends/models.py

@@ -8,7 +8,8 @@ from core.database import Base
 class Legend(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "legends"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_legend_code"),
+        UniqueConstraint("code", "tenant_id", "company_id",
+                         name="uq_legend_code"),
         {"schema": "a76"}
     )
 

backend/api/v1/modules/a76/general_catalogs/legends/routes.py

@@ -1,60 +1,20 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter
-from sqlalchemy.orm import Session
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from typing import List
+from .models import Legend
-
-from core.database import get_core_db
-from . import service
 from .dto import LegendCreate, LegendResponse, LegendUpdate
+from .service import LegendService
 
 router = APIRouter(prefix="/legends", tags=["a76.general_catalogs.legends"])
 
+legend_crud = TenantCRUDRoutes(
+    service=LegendService,
+    create_schema=LegendCreate,
+    update_schema=LegendUpdate,
+    response_schema=LegendResponse,
+    prefix="",
+    tags=["Legends"],
+    resource_name="Legend",
+    enable_list=True,
+)
 
-@router.post("/", response_model=LegendResponse, status_code=status.HTTP_201_CREATED)
+router.include_router(legend_crud.router)
-def create_legend(
-    data: LegendCreate,
-    session: Session = Depends(get_core_db)
-):
-    return service.create_legend(session, data)
-
-
-@router.get("/{id}", response_model=LegendResponse)
-def get_legend(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_legend(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Legend not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[LegendResponse])
-def get_legends(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_legends(session, skip, limit)
-
-
-@router.put("/{id}", response_model=LegendResponse)
-def update_legend(
-    id: int,
-    data: LegendUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_legend(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Legend not found")
-    return service.update_legend(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=LegendResponse)
-def delete_legend(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_legend(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Legend not found")
-    return service.delete_legend(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/legends/service.py

@@ -1,39 +1,95 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import Legend
 from .dto import LegendCreate, LegendUpdate
 
 
-def create_legend(session: Session, data: LegendCreate) -> Legend:
+class LegendService:
-    db_obj = Legend(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[Legend], int]:
+        query = db.query(Legend).filter(
+            Legend.tenant_id == tenant_id,
+            Legend.company_id == company_id
+        )
 
+        if filters:
+            # Add filters here if needed
+            pass
 
-def get_legend(session: Session, id: int) -> Optional[Legend]:
+        total = query.count()
-    return session.get(Legend, id)
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Legend]:
+        return db.query(Legend).filter(
+            Legend.id == id,
+            Legend.tenant_id == tenant_id,
+            Legend.company_id == company_id
+        ).first()
 
-def get_legends(session: Session, skip: int = 0, limit: int = 100) -> Sequence[Legend]:
+    @staticmethod
-    stmt = select(Legend).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session,
-    return result.scalars().all()
+        data: LegendCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> Legend:
+        db_obj = Legend(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        data: LegendUpdate,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Legend]:
+        db_obj = LegendService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_legend(session: Session, db_obj: Legend, update_data: LegendUpdate) -> Legend:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def delete_legend(session: Session, db_obj: Legend) -> Legend:
+    @staticmethod
-    session.delete(db_obj)
+    def delete(
-    session.commit()
+        db: Session,
-    return db_obj
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = LegendService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/multi_currency_types/models.py

@@ -11,7 +11,7 @@ from api.v1.modules.public.reference_data.countries.models import Country
 class MultiCurrencyType(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "multi_currency_types"
     __table_args__ = (
-        UniqueConstraint("currency_type_code", "publication_date",
+        UniqueConstraint("currency_type_code", "publication_date", "tenant_id", "company_id",
                          name="uq_multi_currency_type_code_date"),
         {"schema": "a76"}
     )

backend/api/v1/modules/a76/general_catalogs/multi_currency_types/routes.py

@@ -1,64 +1,21 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter
-from sqlalchemy.orm import Session
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from typing import List
+from .models import MultiCurrencyType
-
-from core.database import get_core_db
-from . import service
 from .dto import MultiCurrencyTypeCreate, MultiCurrencyTypeResponse, MultiCurrencyTypeUpdate
+from .service import MultiCurrencyTypeService
 
 router = APIRouter(prefix="/multi-currency-types",
                    tags=["a76.general_catalogs.multi_currency_types"])
 
+multi_currency_type_crud = TenantCRUDRoutes(
+    service=MultiCurrencyTypeService,
+    create_schema=MultiCurrencyTypeCreate,
+    update_schema=MultiCurrencyTypeUpdate,
+    response_schema=MultiCurrencyTypeResponse,
+    prefix="",
+    tags=["Multi Currency Types"],
+    resource_name="MultiCurrencyType",
+    enable_list=True,
+)
 
-@router.post("/", response_model=MultiCurrencyTypeResponse, status_code=status.HTTP_201_CREATED)
+router.include_router(multi_currency_type_crud.router)
-def create_multi_currency_type(
-    data: MultiCurrencyTypeCreate,
-    session: Session = Depends(get_core_db)
-):
-    return service.create_multi_currency_type(session, data)
-
-
-@router.get("/{id}", response_model=MultiCurrencyTypeResponse)
-def get_multi_currency_type(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_multi_currency_type(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="MultiCurrencyType not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[MultiCurrencyTypeResponse])
-def get_multi_currency_types(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_multi_currency_types(session, skip, limit)
-
-
-@router.put("/{id}", response_model=MultiCurrencyTypeResponse)
-def update_multi_currency_type(
-    id: int,
-    data: MultiCurrencyTypeUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_multi_currency_type(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="MultiCurrencyType not found")
-    return service.update_multi_currency_type(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=MultiCurrencyTypeResponse)
-def delete_multi_currency_type(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_multi_currency_type(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="MultiCurrencyType not found")
-    return service.delete_multi_currency_type(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/multi_currency_types/service.py

@@ -1,39 +1,97 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import MultiCurrencyType
 from .dto import MultiCurrencyTypeCreate, MultiCurrencyTypeUpdate
 
 
-def create_multi_currency_type(session: Session, data: MultiCurrencyTypeCreate) -> MultiCurrencyType:
+class MultiCurrencyTypeService:
-    db_obj = MultiCurrencyType(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[MultiCurrencyType], int]:
+        query = db.query(MultiCurrencyType).filter(
+            MultiCurrencyType.tenant_id == tenant_id,
+            MultiCurrencyType.company_id == company_id
+        )
 
+        if filters:
+            # Add filters here if needed
+            pass
 
-def get_multi_currency_type(session: Session, id: int) -> Optional[MultiCurrencyType]:
+        total = query.count()
-    return session.get(MultiCurrencyType, id)
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[MultiCurrencyType]:
+        return db.query(MultiCurrencyType).filter(
+            MultiCurrencyType.id == id,
+            MultiCurrencyType.tenant_id == tenant_id,
+            MultiCurrencyType.company_id == company_id
+        ).first()
 
-def get_multi_currency_types(session: Session, skip: int = 0, limit: int = 100) -> Sequence[MultiCurrencyType]:
+    @staticmethod
-    stmt = select(MultiCurrencyType).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session,
-    return result.scalars().all()
+        data: MultiCurrencyTypeCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> MultiCurrencyType:
+        db_obj = MultiCurrencyType(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        data: MultiCurrencyTypeUpdate,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[MultiCurrencyType]:
+        db_obj = MultiCurrencyTypeService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_multi_currency_type(session: Session, db_obj: MultiCurrencyType, update_data: MultiCurrencyTypeUpdate) -> MultiCurrencyType:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def delete_multi_currency_type(session: Session, db_obj: MultiCurrencyType) -> MultiCurrencyType:
+    @staticmethod
-    session.delete(db_obj)
+    def delete(
-    session.commit()
+        db: Session,
-    return db_obj
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = MultiCurrencyTypeService.get_by_id(
+            db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/packages/services.py

@@ -35,7 +35,8 @@ class PackageService:
                 )
             if filters.get("description_es"):
                 query = query.filter(
-                    models.Package.description_es.ilike(f"%{filters['description_es']}%")
+                    models.Package.description_es.ilike(
+                        f"%{filters['description_es']}%")
                 )
 
         total = query.count()
@@ -79,16 +80,18 @@ class PackageService:
         db: Session,
         package_id: int,
         tenant_id: int,
-        company_id: int,
         package_data: dto.PackageUpdateDTO,
+        company_id: int,
     ) -> Optional[models.Package]:
         """Update a package"""
-        package = PackageService.get_by_id(db, package_id, tenant_id, company_id)
+        package = PackageService.get_by_id(
+            db, package_id, tenant_id, company_id)
         if not package:
             return None
 
         # Update fields (excluding key if it's meant to be immutable)
-        update_data = package_data.model_dump(exclude_unset=True, exclude={"key"})
+        update_data = package_data.model_dump(
+            exclude_unset=True, exclude={"key"})
         for field, value in update_data.items():
             setattr(package, field, value)
 
@@ -101,7 +104,8 @@ class PackageService:
         db: Session, package_id: int, tenant_id: int, company_id: int
     ) -> bool:
         """Delete a package"""
-        package = PackageService.get_by_id(db, package_id, tenant_id, company_id)
+        package = PackageService.get_by_id(
+            db, package_id, tenant_id, company_id)
         if not package:
             return False
 

backend/api/v1/modules/a76/general_catalogs/ports/models.py

@@ -15,7 +15,7 @@ class PortType(str, enum.Enum):
 class Port(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "ports"
     __table_args__ = (
-        UniqueConstraint("port_code", "location_code",
+        UniqueConstraint("port_code", "location_code", "tenant_id", "company_id",
                          name="uq_port_location"),
         {"schema": "a76"}
     )

backend/api/v1/modules/a76/general_catalogs/ports/routes.py

@@ -1,60 +1,16 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter
-from sqlalchemy.orm import Session
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from typing import List
+from .models import Port
-
-from core.database import get_core_db
-from . import service
 from .dto import PortCreate, PortResponse, PortUpdate
+from .service import PortService
 
-router = APIRouter(prefix="/ports", tags=["a76.general_catalogs.ports"])
+router = TenantCRUDRoutes(
-
+    service=PortService,
-
+    create_schema=PortCreate,
-@router.post("/", response_model=PortResponse, status_code=status.HTTP_201_CREATED)
+    update_schema=PortUpdate,
-def create_port(
+    response_schema=PortResponse,
-    data: PortCreate,
+    prefix="/ports",
-    session: Session = Depends(get_core_db)
+    tags=["a76.general_catalogs.ports"],
-):
+    resource_name="Port",
-    return service.create_port(session, data)
+    enable_list=True,
-
+).router
-
-@router.get("/{id}", response_model=PortResponse)
-def get_port(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_port(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Port not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[PortResponse])
-def get_ports(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_ports(session, skip, limit)
-
-
-@router.put("/{id}", response_model=PortResponse)
-def update_port(
-    id: int,
-    data: PortUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_port(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Port not found")
-    return service.update_port(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=PortResponse)
-def delete_port(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_port(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Port not found")
-    return service.delete_port(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/ports/service.py

@@ -1,38 +1,95 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import Port
 from .dto import PortCreate, PortUpdate
 
 
-def create_port(session: Session, data: PortCreate) -> Port:
+class PortService:
-    db_obj = Port(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None
+    ) -> Tuple[List[Port], int]:
+        query = db.query(Port).filter(
+            Port.tenant_id == tenant_id,
+            Port.company_id == company_id
+        )
 
+        if filters:
+            # Add filters here if needed
+            pass
 
-def get_port(session: Session, id: int) -> Optional[Port]:
+        total = query.count()
-    return session.get(Port, id)
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Port]:
+        return db.query(Port).filter(
+            Port.id == id,
+            Port.tenant_id == tenant_id,
+            Port.company_id == company_id
+        ).first()
 
-def get_ports(session: Session, skip: int = 0, limit: int = 100) -> Sequence[Port]:
+    @staticmethod
-    stmt = select(Port).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session,
-    return result.scalars().all()
+        data: PortCreate,
+        tenant_id: int,
+        company_id: int
+    ) -> Port:
+        db_obj = Port(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        data: PortUpdate,
+        tenant_id: int,
+        company_id: int
+    ) -> Optional[Port]:
+        db_obj = PortService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_port(session: Session, db_obj: Port, update_data: PortUpdate) -> Port:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
-def delete_port(session: Session, db_obj: Port) -> Port:
+        db.commit()
-    session.delete(db_obj)
+        db.refresh(db_obj)
-    session.commit()
+        return db_obj
-    return db_obj
+
+    @staticmethod
+    def delete(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        company_id: int
+    ) -> bool:
+        db_obj = PortService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/prevalidators/models.py

@@ -18,7 +18,8 @@ class Prevalidator(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "prevalidators"  # GPrevalidadores
     __table_args__ = (
         PrimaryKeyConstraint("id", name="prevalidators_pkey"),
-        UniqueConstraint("code", name="prevalidators_code_unique"),
+        UniqueConstraint("code", "tenant_id", "company_id",
+                         name="prevalidators_code_unique"),
         {"schema": "a76"},
     )
 
@@ -26,7 +27,7 @@ class Prevalidator(Base, TenantScopedMixin, TimestampMixin):
     id: Mapped[int] = mapped_column(Integer, primary_key=True)
 
     # Prevalidator code (unique)
-    code: Mapped[str] = mapped_column(String(20), nullable=False, unique=True)
+    code: Mapped[str] = mapped_column(String(20), nullable=False)
 
     # Prevalidator information
     customs_prevalidator: Mapped[Optional[str]] = mapped_column(String(20))

backend/api/v1/modules/a76/general_catalogs/prevalidators/routes.py

@@ -4,10 +4,12 @@ Rutas para gestión de prevalidadores
 
 from typing import List
 
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
+from core.security import get_current_user
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
 from .dto import (
     PrevalidatorCreateDTO,
     PrevalidatorResponseDTO,
@@ -18,63 +20,21 @@ from .service import PrevalidatorService
 
 router = APIRouter(prefix="/prevalidators", tags=["prevalidators"])
 
-
+prevalidator_crud = TenantCRUDRoutes(
-@router.get(
+    service=PrevalidatorService,
-    "",
+    create_schema=PrevalidatorCreateDTO,
-    response_model=dict,
+    update_schema=PrevalidatorUpdateDTO,
-    summary="Get all prevalidators",
+    response_schema=PrevalidatorResponseDTO,
+    prefix="",
+    tags=["Prevalidators"],
+    resource_name="Prevalidator",
+    enable_list=True,
 )
-async def get_all_prevalidators(
-    skip: int = Query(0, ge=0),
-    limit: int = Query(50, ge=1, le=100),
-    code: str = Query(None),
-    description: str = Query(None),
-    customs_prevalidator: str = Query(None),
-    db: Session = Depends(get_core_db),
-):
-    """Get all prevalidators with optional filtering and pagination"""
-    filters = {}
-    if code:
-        filters["code"] = code
-    if description:
-        filters["description"] = description
-    if customs_prevalidator:
-        filters["customs_prevalidator"] = customs_prevalidator
 
-    prevalidators, total = PrevalidatorService.get_all(
+# Add custom endpoints
-        db, skip, limit, filters)
-
-    return {
-        "data": [
-            PrevalidatorResponseDTO.model_validate(prevalidator)
-            for prevalidator in prevalidators
-        ],
-        "total": total,
-        "skip": skip,
-        "limit": limit,
-    }
 
 
-@router.get(
+@prevalidator_crud.router.get(
-    "/{prevalidator_id}",
-    response_model=PrevalidatorResponseDTO,
-    summary="Get prevalidator by ID",
-)
-async def get_prevalidator(
-    prevalidator_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Get a prevalidator by its ID"""
-    prevalidator = PrevalidatorService.get_by_id(db, prevalidator_id)
-    if not prevalidator:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Prevalidator not found",
-        )
-    return PrevalidatorResponseDTO.model_validate(prevalidator)
-
-
-@router.get(
     "/code/{code}",
     response_model=PrevalidatorResponseDTO,
     summary="Get prevalidator by code",
@@ -82,9 +42,15 @@ async def get_prevalidator(
 async def get_prevalidator_by_code(
     code: str,
     db: Session = Depends(get_core_db),
+    current_user: dict = Depends(get_current_user),
 ):
     """Get a prevalidator by its code"""
-    prevalidator = PrevalidatorService.get_by_code(db, code)
+    prevalidator = PrevalidatorService.get_by_code(
+        db,
+        code,
+        tenant_id=current_user["tenant_id"],
+        company_id=current_user["company_id"]
+    )
     if not prevalidator:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -92,13 +58,9 @@ async def get_prevalidator_by_code(
         )
     return PrevalidatorResponseDTO.model_validate(prevalidator)
 
+router.include_router(prevalidator_crud.router)
+
 
-@router.post(
-    "",
-    response_model=PrevalidatorResponseDTO,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create prevalidator",
-)
 async def create_prevalidator(
     prevalidator_data: PrevalidatorCreateDTO,
     db: Session = Depends(get_core_db),

backend/api/v1/modules/a76/general_catalogs/prevalidators/service.py

@@ -22,18 +22,20 @@ logger = logging.getLogger(__name__)
 class PrevalidatorService:
     """Servicio para gestión de prevalidadores"""
 
-    def __init__(self, db: Session):
-        self.db = db
-
     @staticmethod
     def get_all(
         db: Session,
+        tenant_id: int,
+        company_id: int,
         skip: int = 0,
         limit: int = 50,
         filters: Optional[Dict[str, Any]] = None,
     ) -> Tuple[List[Prevalidator], int]:
         """Get all prevalidators with pagination"""
-        query = db.query(Prevalidator)
+        query = db.query(Prevalidator).filter(
+            Prevalidator.tenant_id == tenant_id,
+            Prevalidator.company_id == company_id
+        )
 
         # Apply filters if provided
         if filters:
@@ -59,21 +61,40 @@ class PrevalidatorService:
         return prevalidators, total
 
     @staticmethod
-    def get_by_code(db: Session, code: str) -> Optional[Prevalidator]:
+    def get_by_code(
+        db: Session, code: str, tenant_id: int, company_id: int
+    ) -> Optional[Prevalidator]:
         """Get prevalidator by code"""
-        return db.query(Prevalidator).filter(Prevalidator.code == code).first()
+        return db.query(Prevalidator).filter(
+            Prevalidator.code == code,
+            Prevalidator.tenant_id == tenant_id,
+            Prevalidator.company_id == company_id
+        ).first()
 
     @staticmethod
-    def get_by_id(db: Session, prevalidator_id: int) -> Optional[Prevalidator]:
+    def get_by_id(
+        db: Session, prevalidator_id: int, tenant_id: int, company_id: int
+    ) -> Optional[Prevalidator]:
         """Get prevalidator by ID"""
-        return db.query(Prevalidator).filter(Prevalidator.id == prevalidator_id).first()
+        return db.query(Prevalidator).filter(
+            Prevalidator.id == prevalidator_id,
+            Prevalidator.tenant_id == tenant_id,
+            Prevalidator.company_id == company_id
+        ).first()
 
     @staticmethod
-    def create(db: Session, prevalidator_data: PrevalidatorCreateDTO) -> Prevalidator:
+    def create(
+        db: Session,
+        prevalidator_data: PrevalidatorCreateDTO,
+        tenant_id: int,
+        company_id: int
+    ) -> Prevalidator:
         """Create a new prevalidator"""
         try:
             db_prevalidator = Prevalidator(
-                **prevalidator_data.model_dump(exclude_unset=True)
+                **prevalidator_data.model_dump(exclude_unset=True),
+                tenant_id=tenant_id,
+                company_id=company_id
             )
 
             db.add(db_prevalidator)
@@ -100,13 +121,14 @@ class PrevalidatorService:
         db: Session,
         prevalidator_id: int,
         prevalidator_data: PrevalidatorUpdateDTO,
+        tenant_id: int,
+        company_id: int
     ) -> Optional[Prevalidator]:
         """Update a prevalidator"""
         try:
-            db_prevalidator = db.query(Prevalidator).filter(
+            db_prevalidator = PrevalidatorService.get_by_id(
-                Prevalidator.id == prevalidator_id
+                db, prevalidator_id, tenant_id, company_id
-            ).first()
+            )
-
             if not db_prevalidator:
                 return None
 
@@ -133,13 +155,14 @@ class PrevalidatorService:
             )
 
     @staticmethod
-    def delete(db: Session, prevalidator_id: int) -> bool:
+    def delete(
+        db: Session, prevalidator_id: int, tenant_id: int, company_id: int
+    ) -> bool:
         """Delete a prevalidator"""
         try:
-            db_prevalidator = db.query(Prevalidator).filter(
+            db_prevalidator = PrevalidatorService.get_by_id(
-                Prevalidator.id == prevalidator_id
+                db, prevalidator_id, tenant_id, company_id
-            ).first()
+            )
-
             if not db_prevalidator:
                 return False
 
@@ -155,10 +178,16 @@ class PrevalidatorService:
                 status_code=500, detail="Error deleting prevalidator")
 
     @staticmethod
-    def get_by_customs(db: Session, customs: str) -> List[Prevalidator]:
+    def get_by_customs(
+        db: Session, customs: str, tenant_id: int, company_id: int
+    ) -> List[Prevalidator]:
         """Get all prevalidators by customs"""
         return (
             db.query(Prevalidator)
-            .filter(Prevalidator.customs_prevalidator == customs)
+            .filter(
+                Prevalidator.customs_prevalidator == customs,
+                Prevalidator.tenant_id == tenant_id,
+                Prevalidator.company_id == company_id
+            )
             .all()
         )

backend/api/v1/modules/a76/general_catalogs/seal/models.py

@@ -1,7 +1,6 @@
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
 from core.database import Base
 from sqlalchemy import (
-    ForeignKeyConstraint,
     Integer,
     PrimaryKeyConstraint,
     String,
@@ -13,7 +12,7 @@ from sqlalchemy.orm import Mapped, mapped_column
 class Seal(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "seal"
     __table_args__ = (
-        PrimaryKeyConstraint("id", name="seal_pkey"),        
+        PrimaryKeyConstraint("id", name="seal_pkey"),
         UniqueConstraint("tenant_id", "company_id", "seal", name="seal_ukey"),
         {"schema": "a76"},
     )

backend/api/v1/modules/a76/general_catalogs/signatures/models.py

@@ -18,7 +18,8 @@ class Signature(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "signatures"  # GFirmas
     __table_args__ = (
         PrimaryKeyConstraint("id", name="signatures_pkey"),
-        UniqueConstraint("code", name="signatures_code_unique"),
+        UniqueConstraint("code", "tenant_id", "company_id",
+                         name="signatures_code_unique"),
         {"schema": "a76"},
     )
 
@@ -27,7 +28,7 @@ class Signature(Base, TenantScopedMixin, TimestampMixin):
         Integer, primary_key=True, autoincrement=True)
 
     # Signature code (unique)
-    code: Mapped[str] = mapped_column(String(10), nullable=False, unique=True)
+    code: Mapped[str] = mapped_column(String(10), nullable=False)
 
     # Signature information
     signature: Mapped[Optional[str]] = mapped_column(String(1000))

backend/api/v1/modules/a76/general_catalogs/signatures/routes.py

@@ -2,60 +2,34 @@
 Rutas para gestión de firmas
 """
 
-from fastapi import APIRouter, Depends, HTTPException, Query, status
+from typing import Any, Dict
+
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes, validate_access_to_resource
+from fastapi import Depends, HTTPException, Query, status
 from sqlalchemy.orm import Session
 
 from core.database import get_core_db
+
 from .dto import SignatureCreateDTO, SignatureResponseDTO, SignatureUpdateDTO
-from .models import Signature
 from .service import SignatureService
 
-router = APIRouter(prefix="/signatures", tags=["signatures"])
+# Create router using TenantCRUDRoutes factory
-
+signature_crud = TenantCRUDRoutes(
-
+    service=SignatureService,
-@router.get(
+    create_schema=SignatureCreateDTO,
-    "",
+    update_schema=SignatureUpdateDTO,
-    response_model=dict,
+    response_schema=SignatureResponseDTO,
-    summary="Get all signatures",
+    prefix="/signatures",
+    tags=["signatures"],
+    resource_name="Signature",
+    id_name="id",  # Using numeric ID
+    enable_list=True,  # Enable GET /signatures with pagination
+    enable_filters=True,  # Enable filtering by code
+    default_page_size=50,
+    max_page_size=100,
 )
-async def get_all_signatures(
-    skip: int = Query(0, ge=0),
-    limit: int = Query(50, ge=1, le=100),
-    code: str = Query(None),
-    db: Session = Depends(get_core_db),
-):
-    """Get all signatures with optional filtering and pagination"""
-    filters = {}
-    if code:
-        filters["code"] = code
 
-    signatures, total = SignatureService.get_all(db, skip, limit, filters)
+router = signature_crud.router
-
-    return {
-        "data": [SignatureResponseDTO.model_validate(sig) for sig in signatures],
-        "total": total,
-        "skip": skip,
-        "limit": limit,
-    }
-
-
-@router.get(
-    "/{signature_id}",
-    response_model=SignatureResponseDTO,
-    summary="Get signature by ID",
-)
-async def get_signature(
-    signature_id: int,
-    db: Session = Depends(get_core_db),
-):
-    """Get a signature by its ID"""
-    signature = SignatureService.get_by_id(db, signature_id)
-    if not signature:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Signature not found",
-        )
-    return SignatureResponseDTO.model_validate(signature)
 
 
 @router.get(
@@ -65,48 +39,16 @@ async def get_signature(
 )
 async def get_signature_by_code(
     code: str,
-    db: Session = Depends(get_core_db),
+    company_id: int = Query(..., description="Company ID"),
+    db: Session = Depends(signature_crud.db_dependency),
+    current_user: Dict[str, Any] = Depends(signature_crud.auth_dependency),
 ):
     """Get a signature by its code"""
-    signature = SignatureService.get_by_code(db, code)
+    tenant_id = validate_access_to_resource(db, company_id, current_user)
+    signature = SignatureService.get_by_code(db, code, tenant_id, company_id)
     if not signature:
         raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
+            status_code=404,
-            detail="Signature not found",
-        )
-    return SignatureResponseDTO.model_validate(signature)
-
-
-@router.post(
-    "",
-    response_model=SignatureResponseDTO,
-    status_code=status.HTTP_201_CREATED,
-    summary="Create signature",
-)
-async def create_signature(
-    signature_data: SignatureCreateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Create a new signature"""
-    signature = SignatureService.create(db, signature_data)
-    return SignatureResponseDTO.model_validate(signature)
-
-
-@router.put(
-    "/{signature_id}",
-    response_model=SignatureResponseDTO,
-    summary="Update signature",
-)
-async def update_signature(
-    signature_id: int,
-    signature_data: SignatureUpdateDTO,
-    db: Session = Depends(get_core_db),
-):
-    """Update a signature"""
-    signature = SignatureService.update(db, signature_id, signature_data)
-    if not signature:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
             detail="Signature not found",
         )
     return SignatureResponseDTO.model_validate(signature)

backend/api/v1/modules/a76/general_catalogs/signatures/service.py

@@ -5,12 +5,9 @@ Capa de servicio para lógica de negocio de firmas
 import logging
 from typing import Any, Dict, List, Optional, Tuple
 
-from fastapi import HTTPException
-from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
-from .dto import SignatureCreateDTO, SignatureResponseDTO, SignatureUpdateDTO
+from . import dto, models
-from .models import Signature
 
 logger = logging.getLogger(__name__)
 
@@ -18,23 +15,25 @@ logger = logging.getLogger(__name__)
 class SignatureService:
     """Servicio para gestión de firmas"""
 
-    def __init__(self, db: Session):
-        self.db = db
-
     @staticmethod
     def get_all(
         db: Session,
+        tenant_id: int,
+        company_id: int,
         skip: int = 0,
         limit: int = 50,
         filters: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[List[Signature], int]:
+    ) -> Tuple[List[models.Signature], int]:
         """Get all signatures with pagination"""
-        query = db.query(Signature)
+        query = db.query(models.Signature).filter(
+            models.Signature.tenant_id == tenant_id,
+            models.Signature.company_id == company_id,
+        )
 
         if filters:
             if filters.get("code"):
                 query = query.filter(
-                    Signature.code.ilike(f"%{filters['code']}%"))
+                    models.Signature.code.ilike(f"%{filters['code']}%"))
 
         total = query.count()
         signatures = query.offset(skip).limit(limit).all()
@@ -42,93 +41,82 @@ class SignatureService:
         return signatures, total
 
     @staticmethod
-    def get_by_id(db: Session, signature_id: int) -> Optional[Signature]:
+    def get_by_id(
+        db: Session, signature_id: int, tenant_id: int, company_id: int
+    ) -> Optional[models.Signature]:
         """Get signature by ID"""
-        return db.query(Signature).filter(Signature.id == signature_id).first()
+        return (
-
+            db.query(models.Signature)
-    @staticmethod
+            .filter(
-    def get_by_code(db: Session, code: str) -> Optional[Signature]:
+                models.Signature.id == signature_id,
-        """Get signature by code"""
+                models.Signature.tenant_id == tenant_id,
-        return db.query(Signature).filter(Signature.code == code).first()
+                models.Signature.company_id == company_id,
-
-    @staticmethod
-    def create(db: Session, signature_data: SignatureCreateDTO) -> Signature:
-        """Create a new signature"""
-        try:
-            db_signature = Signature(
-                **signature_data.model_dump(exclude_unset=True))
-
-            db.add(db_signature)
-            db.commit()
-            db.refresh(db_signature)
-
-            return db_signature
-
-        except IntegrityError as e:
-            db.rollback()
-            logger.error(f"IntegrityError creating signature: {str(e)}")
-            raise HTTPException(
-                status_code=400,
-                detail="Signature code already exists",
             )
-        except Exception as e:
+            .first()
-            db.rollback()
+        )
-            logger.error(f"Error creating signature: {str(e)}")
+
-            raise HTTPException(
+    @staticmethod
-                status_code=500, detail="Error creating signature")
+    def get_by_code(
+        db: Session, code: str, tenant_id: int, company_id: int
+    ) -> Optional[models.Signature]:
+        """Get signature by code"""
+        return (
+            db.query(models.Signature)
+            .filter(
+                models.Signature.code == code,
+                models.Signature.tenant_id == tenant_id,
+                models.Signature.company_id == company_id,
+            )
+            .first()
+        )
+
+    @staticmethod
+    def create(
+        db: Session,
+        signature_data: dto.SignatureCreateDTO,
+        tenant_id: int,
+        company_id: int,
+    ) -> models.Signature:
+        """Create a new signature"""
+        new_signature = models.Signature(
+            **signature_data.model_dump(), tenant_id=tenant_id, company_id=company_id
+        )
+        db.add(new_signature)
+        db.commit()
+        db.refresh(new_signature)
+        return new_signature
 
     @staticmethod
     def update(
-        db: Session, signature_id: int, signature_data: SignatureUpdateDTO
+        db: Session,
-    ) -> Optional[Signature]:
+        signature_id: int,
+        tenant_id: int,
+        signature_data: dto.SignatureUpdateDTO,
+        company_id: int,
+    ) -> Optional[models.Signature]:
         """Update a signature"""
-        try:
+        signature = SignatureService.get_by_id(
-            db_signature = db.query(Signature).filter(
+            db, signature_id, tenant_id, company_id)
-                Signature.id == signature_id
+        if not signature:
-            ).first()
+            return None
 
-            if not db_signature:
+        for key, value in signature_data.model_dump(exclude_unset=True).items():
-                return None
+            setattr(signature, key, value)
 
-            for key, value in signature_data.model_dump(exclude_unset=True).items():
+        db.commit()
-                setattr(db_signature, key, value)
+        db.refresh(signature)
-
+        return signature
-            db.commit()
-            db.refresh(db_signature)
-
-            return db_signature
-
-        except IntegrityError as e:
-            db.rollback()
-            logger.error(f"IntegrityError updating signature: {str(e)}")
-            raise HTTPException(
-                status_code=400,
-                detail="Error updating signature",
-            )
-        except Exception as e:
-            db.rollback()
-            logger.error(f"Error updating signature: {str(e)}")
-            raise HTTPException(
-                status_code=500, detail="Error updating signature")
 
     @staticmethod
-    def delete(db: Session, signature_id: int) -> bool:
+    def delete(
+        db: Session, signature_id: int, tenant_id: int, company_id: int
+    ) -> bool:
         """Delete a signature"""
-        try:
+        signature = SignatureService.get_by_id(
-            db_signature = db.query(Signature).filter(
+            db, signature_id, tenant_id, company_id)
-                Signature.id == signature_id
+        if not signature:
-            ).first()
+            return False
 
-            if not db_signature:
+        db.delete(signature)
-                return False
+        db.commit()
-
+        return True
-            db.delete(db_signature)
-            db.commit()
-
-            return True
-
-        except Exception as e:
-            db.rollback()
-            logger.error(f"Error deleting signature: {str(e)}")
-            raise HTTPException(
-                status_code=500, detail="Error deleting signature")

backend/api/v1/modules/a76/general_catalogs/unit_conversions/models.py

@@ -1,6 +1,6 @@
 from typing import Optional
 from decimal import Decimal
-from sqlalchemy import Integer, String, ForeignKey, UniqueConstraint, Numeric
+from sqlalchemy import Integer, String, ForeignKeyConstraint, UniqueConstraint, Numeric
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
 from core.database import Base
@@ -10,21 +10,27 @@ from api.v1.modules.a76.general_catalogs.units_of_measure.models import UnitOfMe
 class UnitConversion(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "unit_conversions"
     __table_args__ = (
-        UniqueConstraint("from_unit_code", "to_unit_code",
+        UniqueConstraint("from_unit_code", "to_unit_code", "tenant_id", "company_id",
                          name="uq_unit_conversion_pair"),
+        ForeignKeyConstraint(
+            ["from_unit_code", "tenant_id", "company_id"],
+            ["a76.units_of_measure.code", "a76.units_of_measure.tenant_id",
+                "a76.units_of_measure.company_id"],
+        ),
+        ForeignKeyConstraint(
+            ["to_unit_code", "tenant_id", "company_id"],
+            ["a76.units_of_measure.code", "a76.units_of_measure.tenant_id",
+                "a76.units_of_measure.company_id"],
+        ),
         {"schema": "a76"}
     )
 
     id: Mapped[int] = mapped_column(
         Integer, primary_key=True, autoincrement=True)
-    from_unit_code: Mapped[str] = mapped_column(
+    from_unit_code: Mapped[str] = mapped_column(String(5), nullable=False)
-        String(5), ForeignKey("a76.units_of_measure.code"), nullable=False)
+    to_unit_code: Mapped[str] = mapped_column(String(5), nullable=False)
-    to_unit_code: Mapped[str] = mapped_column(
-        String(5), ForeignKey("a76.units_of_measure.code"), nullable=False)
     conversion_factor: Mapped[Optional[Decimal]] = mapped_column(
         Numeric(13, 6), nullable=True)
 
-    from_unit: Mapped["UnitOfMeasure"] = relationship(
+    # Relationships
-        foreign_keys=[from_unit_code])
+    # Note: Complex composite foreign keys might require explicit primaryjoin if used
-    to_unit: Mapped["UnitOfMeasure"] = relationship(
-        foreign_keys=[to_unit_code])

backend/api/v1/modules/a76/general_catalogs/unit_conversions/routes.py

@@ -1,61 +1,16 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from sqlalchemy.orm import Session
-from typing import List
-
-from core.database import get_core_db
-from . import service
 from .dto import UnitConversionCreate, UnitConversionResponse, UnitConversionUpdate
+from .service import UnitConversionService
 
-router = APIRouter(prefix="/unit-conversions",
+router = TenantCRUDRoutes(
-                   tags=["a76.general_catalogs.unit_conversions"])
+    service=UnitConversionService,
-
+    create_schema=UnitConversionCreate,
-
+    update_schema=UnitConversionUpdate,
-@router.post("/", response_model=UnitConversionResponse, status_code=status.HTTP_201_CREATED)
+    response_schema=UnitConversionResponse,
-def create_unit_conversion(
+    prefix="/unit-conversions",
-    data: UnitConversionCreate,
+    tags=["a76.general_catalogs.unit_conversions"],
-    session: Session = Depends(get_core_db)
+    resource_name="UnitConversion",
-):
+    id_name="id",
-    return service.create_unit_conversion(session, data)
+    enable_list=True,
-
+    enable_filters=True,
-
+).router
-@router.get("/{id}", response_model=UnitConversionResponse)
-def get_unit_conversion(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_unit_conversion(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="UnitConversion not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[UnitConversionResponse])
-def get_unit_conversions(
-    skip: int = 0,
-    limit: int = 100,
-    session: Session = Depends(get_core_db)
-):
-    return service.get_unit_conversions(session, skip, limit)
-
-
-@router.put("/{id}", response_model=UnitConversionResponse)
-def update_unit_conversion(
-    id: int,
-    data: UnitConversionUpdate,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_unit_conversion(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="UnitConversion not found")
-    return service.update_unit_conversion(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=UnitConversionResponse)
-def delete_unit_conversion(
-    id: int,
-    session: Session = Depends(get_core_db)
-):
-    db_obj = service.get_unit_conversion(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="UnitConversion not found")
-    return service.delete_unit_conversion(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/unit_conversions/service.py

@@ -1,39 +1,89 @@
+from typing import List, Optional, Tuple, Dict, Any
 from sqlalchemy.orm import Session
 from sqlalchemy import select
-from typing import Sequence, Optional
 
 from .models import UnitConversion
 from .dto import UnitConversionCreate, UnitConversionUpdate
 
 
-def create_unit_conversion(session: Session, data: UnitConversionCreate) -> UnitConversion:
+class UnitConversionService:
-    db_obj = UnitConversion(**data.model_dump())
+    @staticmethod
-    session.add(db_obj)
+    def get_all(
-    session.commit()
+        db: Session,
-    session.refresh(db_obj)
+        tenant_id: int,
-    return db_obj
+        company_id: int,
+        skip: int = 0,
+        limit: int = 100,
+        filters: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[List[UnitConversion], int]:
+        query = db.query(UnitConversion).filter(
+            UnitConversion.tenant_id == tenant_id,
+            UnitConversion.company_id == company_id,
+        )
 
+        if filters:
+            # Add filters if needed
+            pass
 
-def get_unit_conversion(session: Session, id: int) -> Optional[UnitConversion]:
+        total = query.count()
-    return session.get(UnitConversion, id)
+        items = query.offset(skip).limit(limit).all()
+        return items, total
 
+    @staticmethod
+    def get_by_id(
+        db: Session, id: int, tenant_id: int, company_id: int
+    ) -> Optional[UnitConversion]:
+        return db.query(UnitConversion).filter(
+            UnitConversion.id == id,
+            UnitConversion.tenant_id == tenant_id,
+            UnitConversion.company_id == company_id,
+        ).first()
 
-def get_unit_conversions(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitConversion]:
+    @staticmethod
-    stmt = select(UnitConversion).offset(skip).limit(limit)
+    def create(
-    result = session.execute(stmt)
+        db: Session,
-    return result.scalars().all()
+        data: UnitConversionCreate,
+        tenant_id: int,
+        company_id: int,
+    ) -> UnitConversion:
+        db_obj = UnitConversion(
+            **data.model_dump(),
+            tenant_id=tenant_id,
+            company_id=company_id
+        )
+        db.add(db_obj)
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
+    @staticmethod
+    def update(
+        db: Session,
+        id: int,
+        tenant_id: int,
+        data: UnitConversionUpdate,
+        company_id: int,
+    ) -> Optional[UnitConversion]:
+        db_obj = UnitConversionService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return None
 
-def update_unit_conversion(session: Session, db_obj: UnitConversion, update_data: UnitConversionUpdate) -> UnitConversion:
+        update_dict = data.model_dump(exclude_unset=True)
-    update_dict = update_data.model_dump(exclude_unset=True)
+        for key, value in update_dict.items():
-    for key, value in update_dict.items():
+            setattr(db_obj, key, value)
-        setattr(db_obj, key, value)
-    session.commit()
-    session.refresh(db_obj)
-    return db_obj
 
+        db.commit()
+        db.refresh(db_obj)
+        return db_obj
 
-def delete_unit_conversion(session: Session, db_obj: UnitConversion) -> UnitConversion:
+    @staticmethod
-    session.delete(db_obj)
+    def delete(
-    session.commit()
+        db: Session, id: int, tenant_id: int, company_id: int
-    return db_obj
+    ) -> bool:
+        db_obj = UnitConversionService.get_by_id(db, id, tenant_id, company_id)
+        if not db_obj:
+            return False
+
+        db.delete(db_obj)
+        db.commit()
+        return True

backend/api/v1/modules/a76/general_catalogs/units_of_measure/models.py

@@ -1,16 +1,19 @@
 from typing import Optional
 from decimal import Decimal
-from sqlalchemy import Integer, String, ForeignKey, UniqueConstraint, Numeric
+from sqlalchemy import ForeignKey, Integer, String, ForeignKeyConstraint, UniqueConstraint, Numeric
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 from api.v1.common.base_models import TenantScopedMixin, TimestampMixin
 from core.database import Base
 
 # 1. GUniMedACE
+
+
 class UnitOfMeasureACE(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "unit_of_measure_ace"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_uom_ace_code"),
+        UniqueConstraint("code", "tenant_id", "company_id",
-        {"schema": "a76"}
+                         name="uq_uom_ace_code"),
+        {"schema": "a76", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(
@@ -20,11 +23,14 @@ class UnitOfMeasureACE(Base, TenantScopedMixin, TimestampMixin):
         String(49), nullable=True)
 
 # 2. GUMOMA
+
+
 class UnitOfMeasureOMA(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "unit_of_measure_oma"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_uom_oma_code"),
+        UniqueConstraint("code", "tenant_id", "company_id",
-        {"schema": "a76"}
+                         name="uq_uom_oma_code"),
+        {"schema": "a76", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(
@@ -34,11 +40,14 @@ class UnitOfMeasureOMA(Base, TenantScopedMixin, TimestampMixin):
         String(200), nullable=True)
 
 # 3. GUMAme
+
+
 class UnitOfMeasureAmerican(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "unit_of_measure_american"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_uom_american_code"),
+        UniqueConstraint("code", "tenant_id", "company_id",
-        {"schema": "a76"}
+                         name="uq_uom_american_code"),
+        {"schema": "a76", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(
@@ -48,11 +57,14 @@ class UnitOfMeasureAmerican(Base, TenantScopedMixin, TimestampMixin):
         String(40), nullable=True)
 
 # 4. GUMAduana
+
+
 class UnitOfMeasureCustoms(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "unit_of_measure_customs"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_uom_customs_code"),
+        UniqueConstraint("code", "tenant_id", "company_id",
-        {"schema": "a76"}
+                         name="uq_uom_customs_code"),
+        {"schema": "a76", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(
@@ -64,11 +76,42 @@ class UnitOfMeasureCustoms(Base, TenantScopedMixin, TimestampMixin):
         String(5), nullable=True)  # UNIDADSCAII
 
 # 5. GUniMedida (Main)
+
+
 class UnitOfMeasure(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "units_of_measure"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_uom_code"),
+        UniqueConstraint("code", "tenant_id",
-        {"schema": "a76"}
+                         "company_id", name="uq_uom_code"),
+        ForeignKeyConstraint(
+            ["customs_code", "tenant_id", "company_id"],
+            ["a76.unit_of_measure_customs.code", "a76.unit_of_measure_customs.tenant_id",
+                "a76.unit_of_measure_customs.company_id"],
+            use_alter=True,
+            name="fk_uom_customs"
+        ),
+        ForeignKeyConstraint(
+            ["american_code", "tenant_id", "company_id"],
+            ["a76.unit_of_measure_american.code", "a76.unit_of_measure_american.tenant_id",
+                "a76.unit_of_measure_american.company_id"],
+            use_alter=True,
+            name="fk_uom_american"
+        ),
+        ForeignKeyConstraint(
+            ["ace_code", "tenant_id", "company_id"],
+            ["a76.unit_of_measure_ace.code", "a76.unit_of_measure_ace.tenant_id",
+                "a76.unit_of_measure_ace.company_id"],
+            use_alter=True,
+            name="fk_uom_ace"
+        ),
+        ForeignKeyConstraint(
+            ["oma_code", "tenant_id", "company_id"],
+            ["a76.unit_of_measure_oma.code", "a76.unit_of_measure_oma.tenant_id",
+                "a76.unit_of_measure_oma.company_id"],
+            use_alter=True,
+            name="fk_uom_oma"
+        ),
+        {"schema": "a76", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(
@@ -79,26 +122,44 @@ class UnitOfMeasure(Base, TenantScopedMixin, TimestampMixin):
     description_en: Mapped[Optional[str]] = mapped_column(
         String(100), nullable=True)
 
-    customs_code: Mapped[Optional[str]] = mapped_column(String(2), ForeignKey(
+    customs_code: Mapped[Optional[str]] = mapped_column(
-        "a76.unit_of_measure_customs.code"), nullable=True)  # CLAVE_AMEX
+        String(2), nullable=True)  # CLAVE_AMEX
-    american_code: Mapped[Optional[str]] = mapped_column(String(3), ForeignKey(
+    american_code: Mapped[Optional[str]] = mapped_column(
-        "a76.unit_of_measure_american.code"), nullable=True)  # CLAVE_AAMER
+        String(3), nullable=True)  # CLAVE_AAMER
-    ace_code: Mapped[Optional[str]] = mapped_column(String(4), ForeignKey(
+    ace_code: Mapped[Optional[str]] = mapped_column(
-        "a76.unit_of_measure_ace.code"), nullable=True)  # CLAVEACE
+        String(4), nullable=True)  # CLAVEACE
-    oma_code: Mapped[Optional[str]] = mapped_column(String(10), ForeignKey(
+    oma_code: Mapped[Optional[str]] = mapped_column(
-        "a76.unit_of_measure_oma.code"), nullable=True)  # CLAVEOMA
+        String(10), nullable=True)  # CLAVEOMA
 
+    # Relationships omitted for simplicity or need explicit primaryjoin
     customs_unit: Mapped[Optional["UnitOfMeasureCustoms"]] = relationship()
     american_unit: Mapped[Optional["UnitOfMeasureAmerican"]] = relationship()
     ace_unit: Mapped[Optional["UnitOfMeasureACE"]] = relationship()
     oma_unit: Mapped[Optional["UnitOfMeasureOMA"]] = relationship()
 
 # 6. GUniMed (General/Conversion)
+
+
 class UnitOfMeasureGeneral(Base, TenantScopedMixin, TimestampMixin):
     __tablename__ = "units_of_measure_general"
     __table_args__ = (
-        UniqueConstraint("code", name="uq_uom_general_code"),
+        UniqueConstraint("code", "tenant_id", "company_id",
-        {"schema": "a76"}
+                         name="uq_uom_general_code"),
+        ForeignKeyConstraint(
+            ["customs_code", "tenant_id", "company_id"],
+            ["a76.unit_of_measure_customs.code", "a76.unit_of_measure_customs.tenant_id",
+                "a76.unit_of_measure_customs.company_id"],
+            use_alter=True,
+            name="fk_uom_general_customs"
+        ),
+        ForeignKeyConstraint(
+            ["ace_code", "tenant_id", "company_id"],
+            ["a76.unit_of_measure_ace.code", "a76.unit_of_measure_ace.tenant_id",
+                "a76.unit_of_measure_ace.company_id"],
+            use_alter=True,
+            name="fk_uom_general_ace"
+        ),
+        {"schema": "a76", "extend_existing": True}
     )
 
     id: Mapped[int] = mapped_column(
@@ -114,10 +175,10 @@ class UnitOfMeasureGeneral(Base, TenantScopedMixin, TimestampMixin):
     american_unit_code: Mapped[Optional[str]
                                ] = mapped_column(String(5), nullable=True)
 
-    customs_code: Mapped[Optional[str]] = mapped_column(String(2), ForeignKey(
+    customs_code: Mapped[Optional[str]] = mapped_column(
-        "a76.unit_of_measure_customs.code"), nullable=True)  # CLAVE_ADUANA
+        String(2), nullable=True)  # CLAVE_ADUANA
-    ace_code: Mapped[Optional[str]] = mapped_column(String(4), ForeignKey(
+    ace_code: Mapped[Optional[str]] = mapped_column(
-        "a76.unit_of_measure_ace.code"), nullable=True)  # CLAVEACE
+        String(4), nullable=True)  # CLAVEACE
 
     customs_unit: Mapped[Optional["UnitOfMeasureCustoms"]] = relationship()
     ace_unit: Mapped[Optional["UnitOfMeasureACE"]] = relationship()

backend/api/v1/modules/a76/general_catalogs/units_of_measure/routes.py

@@ -1,239 +1,97 @@
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter
-from sqlalchemy.orm import Session
+from api.v1.common.tenant_crud_routes import TenantCRUDRoutes
-from typing import List
+from . import dto, service
-
-from core.database import get_core_db
-from . import service
-from .dto import (
-    UnitOfMeasureACECreate, UnitOfMeasureACEResponse, UnitOfMeasureACEUpdate,
-    UnitOfMeasureOMACreate, UnitOfMeasureOMAResponse, UnitOfMeasureOMAUpdate,
-    UnitOfMeasureAmericanCreate, UnitOfMeasureAmericanResponse, UnitOfMeasureAmericanUpdate,
-    UnitOfMeasureCustomsCreate, UnitOfMeasureCustomsResponse, UnitOfMeasureCustomsUpdate,
-    UnitOfMeasureCreate, UnitOfMeasureResponse, UnitOfMeasureUpdate,
-    UnitOfMeasureGeneralCreate, UnitOfMeasureGeneralResponse, UnitOfMeasureGeneralUpdate
-)
 
 router = APIRouter(prefix="/units-of-measure",
                    tags=["a76.general_catalogs.units_of_measure"])
 
-# --- ACE Routes ---
+# ACE
-
+ace_router = TenantCRUDRoutes(
-
+    service=service.UnitOfMeasureACEService,
-@router.post("/ace", response_model=UnitOfMeasureACEResponse, status_code=status.HTTP_201_CREATED)
+    create_schema=dto.UnitOfMeasureACECreate,
-def create_ace(data: UnitOfMeasureACECreate, session: Session = Depends(get_core_db)):
+    update_schema=dto.UnitOfMeasureACEUpdate,
-    return service.create_ace(session, data)
+    response_schema=dto.UnitOfMeasureACEResponse,
-
+    prefix="/ace",
-
+    tags=["a76.general_catalogs.units_of_measure"],
-@router.get("/ace/{id}", response_model=UnitOfMeasureACEResponse)
+    resource_name="UnitOfMeasureACE",
-def get_ace(id: int, session: Session = Depends(get_core_db)):
+    id_name="id",
-    db_obj = service.get_ace(session, id)
+    enable_list=True,
-    if not db_obj:
+    enable_filters=True,
-        raise HTTPException(status_code=404, detail="ACE Unit not found")
+).router
-    return db_obj
+router.include_router(ace_router)
-
+
-
+# OMA
-@router.get("/ace", response_model=List[UnitOfMeasureACEResponse])
+oma_router = TenantCRUDRoutes(
-def get_all_ace(skip: int = 0, limit: int = 100, session: Session = Depends(get_core_db)):
+    service=service.UnitOfMeasureOMAService,
-    return service.get_all_ace(session, skip, limit)
+    create_schema=dto.UnitOfMeasureOMACreate,
-
+    update_schema=dto.UnitOfMeasureOMAUpdate,
-
+    response_schema=dto.UnitOfMeasureOMAResponse,
-@router.put("/ace/{id}", response_model=UnitOfMeasureACEResponse)
+    prefix="/oma",
-def update_ace(id: int, data: UnitOfMeasureACEUpdate, session: Session = Depends(get_core_db)):
+    tags=["a76.general_catalogs.units_of_measure"],
-    db_obj = service.get_ace(session, id)
+    resource_name="UnitOfMeasureOMA",
-    if not db_obj:
+    id_name="id",
-        raise HTTPException(status_code=404, detail="ACE Unit not found")
+    enable_list=True,
-    return service.update_ace(session, db_obj, data)
+    enable_filters=True,
-
+).router
-
+router.include_router(oma_router)
-@router.delete("/ace/{id}", response_model=UnitOfMeasureACEResponse)
+
-def delete_ace(id: int, session: Session = Depends(get_core_db)):
+# American
-    db_obj = service.get_ace(session, id)
+american_router = TenantCRUDRoutes(
-    if not db_obj:
+    service=service.UnitOfMeasureAmericanService,
-        raise HTTPException(status_code=404, detail="ACE Unit not found")
+    create_schema=dto.UnitOfMeasureAmericanCreate,
-    return service.delete_ace(session, db_obj)
+    update_schema=dto.UnitOfMeasureAmericanUpdate,
-
+    response_schema=dto.UnitOfMeasureAmericanResponse,
-# --- OMA Routes ---
+    prefix="/american",
-
+    tags=["a76.general_catalogs.units_of_measure"],
-
+    resource_name="UnitOfMeasureAmerican",
-@router.post("/oma", response_model=UnitOfMeasureOMAResponse, status_code=status.HTTP_201_CREATED)
+    id_name="id",
-def create_oma(data: UnitOfMeasureOMACreate, session: Session = Depends(get_core_db)):
+    enable_list=True,
-    return service.create_oma(session, data)
+    enable_filters=True,
-
+).router
-
+router.include_router(american_router)
-@router.get("/oma/{id}", response_model=UnitOfMeasureOMAResponse)
+
-def get_oma(id: int, session: Session = Depends(get_core_db)):
+# Customs
-    db_obj = service.get_oma(session, id)
+customs_router = TenantCRUDRoutes(
-    if not db_obj:
+    service=service.UnitOfMeasureCustomsService,
-        raise HTTPException(status_code=404, detail="OMA Unit not found")
+    create_schema=dto.UnitOfMeasureCustomsCreate,
-    return db_obj
+    update_schema=dto.UnitOfMeasureCustomsUpdate,
-
+    response_schema=dto.UnitOfMeasureCustomsResponse,
-
+    prefix="/customs",
-@router.get("/oma", response_model=List[UnitOfMeasureOMAResponse])
+    tags=["a76.general_catalogs.units_of_measure"],
-def get_all_oma(skip: int = 0, limit: int = 100, session: Session = Depends(get_core_db)):
+    resource_name="UnitOfMeasureCustoms",
-    return service.get_all_oma(session, skip, limit)
+    id_name="id",
-
+    enable_list=True,
-
+    enable_filters=True,
-@router.put("/oma/{id}", response_model=UnitOfMeasureOMAResponse)
+).router
-def update_oma(id: int, data: UnitOfMeasureOMAUpdate, session: Session = Depends(get_core_db)):
+router.include_router(customs_router)
-    db_obj = service.get_oma(session, id)
+
-    if not db_obj:
+# General
-        raise HTTPException(status_code=404, detail="OMA Unit not found")
+general_router = TenantCRUDRoutes(
-    return service.update_oma(session, db_obj, data)
+    service=service.UnitOfMeasureGeneralService,
-
+    create_schema=dto.UnitOfMeasureGeneralCreate,
-
+    update_schema=dto.UnitOfMeasureGeneralUpdate,
-@router.delete("/oma/{id}", response_model=UnitOfMeasureOMAResponse)
+    response_schema=dto.UnitOfMeasureGeneralResponse,
-def delete_oma(id: int, session: Session = Depends(get_core_db)):
+    prefix="/general",
-    db_obj = service.get_oma(session, id)
+    tags=["a76.general_catalogs.units_of_measure"],
-    if not db_obj:
+    resource_name="UnitOfMeasureGeneral",
-        raise HTTPException(status_code=404, detail="OMA Unit not found")
+    id_name="id",
-    return service.delete_oma(session, db_obj)
+    enable_list=True,
-
+    enable_filters=True,
-# --- American Routes ---
+).router
-
+router.include_router(general_router)
-
+
-@router.post("/american", response_model=UnitOfMeasureAmericanResponse, status_code=status.HTTP_201_CREATED)
+# Main UnitOfMeasure
-def create_american(data: UnitOfMeasureAmericanCreate, session: Session = Depends(get_core_db)):
+# Note: We use prefix="" to map to /units-of-measure/
-    return service.create_american(session, data)
+main_router = TenantCRUDRoutes(
-
+    service=service.UnitOfMeasureService,
-
+    create_schema=dto.UnitOfMeasureCreate,
-@router.get("/american/{id}", response_model=UnitOfMeasureAmericanResponse)
+    update_schema=dto.UnitOfMeasureUpdate,
-def get_american(id: int, session: Session = Depends(get_core_db)):
+    response_schema=dto.UnitOfMeasureResponse,
-    db_obj = service.get_american(session, id)
+    prefix="",
-    if not db_obj:
+    tags=["a76.general_catalogs.units_of_measure"],
-        raise HTTPException(status_code=404, detail="American Unit not found")
+    resource_name="UnitOfMeasure",
-    return db_obj
+    id_name="id",
-
+    enable_list=True,
-
+    enable_filters=True,
-@router.get("/american", response_model=List[UnitOfMeasureAmericanResponse])
+).router
-def get_all_american(skip: int = 0, limit: int = 100, session: Session = Depends(get_core_db)):
+router.include_router(main_router)
-    return service.get_all_american(session, skip, limit)
-
-
-@router.put("/american/{id}", response_model=UnitOfMeasureAmericanResponse)
-def update_american(id: int, data: UnitOfMeasureAmericanUpdate, session: Session = Depends(get_core_db)):
-    db_obj = service.get_american(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="American Unit not found")
-    return service.update_american(session, db_obj, data)
-
-
-@router.delete("/american/{id}", response_model=UnitOfMeasureAmericanResponse)
-def delete_american(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_american(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="American Unit not found")
-    return service.delete_american(session, db_obj)
-
-# --- Customs Routes ---
-
-
-@router.post("/customs", response_model=UnitOfMeasureCustomsResponse, status_code=status.HTTP_201_CREATED)
-def create_customs(data: UnitOfMeasureCustomsCreate, session: Session = Depends(get_core_db)):
-    return service.create_customs(session, data)
-
-
-@router.get("/customs/{id}", response_model=UnitOfMeasureCustomsResponse)
-def get_customs(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_customs(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Customs Unit not found")
-    return db_obj
-
-
-@router.get("/customs", response_model=List[UnitOfMeasureCustomsResponse])
-def get_all_customs(skip: int = 0, limit: int = 100, session: Session = Depends(get_core_db)):
-    return service.get_all_customs(session, skip, limit)
-
-
-@router.put("/customs/{id}", response_model=UnitOfMeasureCustomsResponse)
-def update_customs(id: int, data: UnitOfMeasureCustomsUpdate, session: Session = Depends(get_core_db)):
-    db_obj = service.get_customs(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Customs Unit not found")
-    return service.update_customs(session, db_obj, data)
-
-
-@router.delete("/customs/{id}", response_model=UnitOfMeasureCustomsResponse)
-def delete_customs(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_customs(session, id)
-    if not db_obj:
-        raise HTTPException(status_code=404, detail="Customs Unit not found")
-    return service.delete_customs(session, db_obj)
-
-# --- Main UnitOfMeasure Routes ---
-
-
-@router.post("/", response_model=UnitOfMeasureResponse, status_code=status.HTTP_201_CREATED)
-def create_uom(data: UnitOfMeasureCreate, session: Session = Depends(get_core_db)):
-    return service.create_uom(session, data)
-
-
-@router.get("/{id}", response_model=UnitOfMeasureResponse)
-def get_uom(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_uom(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Unit of Measure not found")
-    return db_obj
-
-
-@router.get("/", response_model=List[UnitOfMeasureResponse])
-def get_all_uom(skip: int = 0, limit: int = 100, session: Session = Depends(get_core_db)):
-    return service.get_all_uom(session, skip, limit)
-
-
-@router.put("/{id}", response_model=UnitOfMeasureResponse)
-def update_uom(id: int, data: UnitOfMeasureUpdate, session: Session = Depends(get_core_db)):
-    db_obj = service.get_uom(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Unit of Measure not found")
-    return service.update_uom(session, db_obj, data)
-
-
-@router.delete("/{id}", response_model=UnitOfMeasureResponse)
-def delete_uom(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_uom(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="Unit of Measure not found")
-    return service.delete_uom(session, db_obj)
-
-# --- General UnitOfMeasure Routes ---
-
-
-@router.post("/general", response_model=UnitOfMeasureGeneralResponse, status_code=status.HTTP_201_CREATED)
-def create_uom_general(data: UnitOfMeasureGeneralCreate, session: Session = Depends(get_core_db)):
-    return service.create_uom_general(session, data)
-
-
-@router.get("/general/{id}", response_model=UnitOfMeasureGeneralResponse)
-def get_uom_general(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_uom_general(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="General Unit of Measure not found")
-    return db_obj
-
-
-@router.get("/general", response_model=List[UnitOfMeasureGeneralResponse])
-def get_all_uom_general(skip: int = 0, limit: int = 100, session: Session = Depends(get_core_db)):
-    return service.get_all_uom_general(session, skip, limit)
-
-
-@router.put("/general/{id}", response_model=UnitOfMeasureGeneralResponse)
-def update_uom_general(id: int, data: UnitOfMeasureGeneralUpdate, session: Session = Depends(get_core_db)):
-    db_obj = service.get_uom_general(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="General Unit of Measure not found")
-    return service.update_uom_general(session, db_obj, data)
-
-
-@router.delete("/general/{id}", response_model=UnitOfMeasureGeneralResponse)
-def delete_uom_general(id: int, session: Session = Depends(get_core_db)):
-    db_obj = service.get_uom_general(session, id)
-    if not db_obj:
-        raise HTTPException(
-            status_code=404, detail="General Unit of Measure not found")
-    return service.delete_uom_general(session, db_obj)

backend/api/v1/modules/a76/general_catalogs/units_of_measure/service.py

@@ -1,6 +1,6 @@
+from typing import List, Optional, Tuple, Dict, Any, Type
+from sqlalchemy import Sequence
 from sqlalchemy.orm import Session
-from sqlalchemy import select
-from typing import Sequence, Optional, Type, TypeVar
 
 from .models import (
     UnitOfMeasureACE, UnitOfMeasureOMA, UnitOfMeasureAmerican, UnitOfMeasureCustoms,
@@ -15,169 +15,129 @@ from .dto import (
     UnitOfMeasureGeneralCreate, UnitOfMeasureGeneralUpdate
 )
 
-T = TypeVar("T")
 
-
+class BaseService:
-def _create(session: Session, model: Type[T], data) -> T:
+    model = None
-    db_obj = model(**data.model_dump())
+
-    session.add(db_obj)
+    @classmethod
-    session.commit()
+    def get_all(
-    session.refresh(db_obj)
+        cls,
-    return db_obj
+        db: Session,
-
+        tenant_id: int,
-
+        company_id: int,
-def _get(session: Session, model: Type[T], id: int) -> Optional[T]:
+        skip: int = 0,
-    return session.get(model, id)
+        limit: int = 100,
-
+        filters: Optional[Dict[str, Any]] = None,
-
+    ) -> Tuple[List[Any], int]:
-def _get_all(session: Session, model: Type[T], skip: int = 0, limit: int = 100) -> Sequence[T]:
+        query = db.query(cls.model).filter(
-    stmt = select(model).offset(skip).limit(limit)
+            cls.model.tenant_id == tenant_id,
-    result = session.execute(stmt)
+            cls.model.company_id == company_id,
-    return result.scalars().all()
+        )
-
+
-
+        if filters:
-def _update(session: Session, db_obj: T, update_data) -> T:
+            if filters.get("code"):
-    update_dict = update_data.model_dump(exclude_unset=True)
+                query = query.filter(
-    for key, value in update_dict.items():
+                    cls.model.code.ilike(f"%{filters['code']}%"))
-        setattr(db_obj, key, value)
+            if filters.get("description"):
-    session.commit()
+                if hasattr(cls.model, "description"):
-    session.refresh(db_obj)
+                    query = query.filter(cls.model.description.ilike(
-    return db_obj
+                        f"%{filters['description']}%"))
-
+
-
+        total = query.count()
-def _delete(session: Session, db_obj: T) -> T:
+        items = query.offset(skip).limit(limit).all()
-    session.delete(db_obj)
+        return items, total
-    session.commit()
+
-    return db_obj
+    @classmethod
-
+    def get_by_id(
-# --- ACE ---
+        cls, db: Session, id: int, tenant_id: int, company_id: int
-
+    ) -> Optional[Any]:
-
+        return db.query(cls.model).filter(
-def create_ace(session: Session, data: UnitOfMeasureACECreate) -> UnitOfMeasureACE:
+            cls.model.id == id,
-    return  _create(session, UnitOfMeasureACE, data)
+            cls.model.tenant_id == tenant_id,
-
+            cls.model.company_id == company_id,
-
+        ).first()
-def get_ace(session: Session, id: int) -> Optional[UnitOfMeasureACE]:
+
-    return  _get(session, UnitOfMeasureACE, id)
+    @classmethod
-
+    def create(
-
+        cls,
-def get_all_ace(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitOfMeasureACE]:
+        db: Session,
-    return  _get_all(session, UnitOfMeasureACE, skip, limit)
+        data: Any,
-
+        tenant_id: int,
-
+        company_id: int,
-def update_ace(session: Session, db_obj: UnitOfMeasureACE, data: UnitOfMeasureACEUpdate) -> UnitOfMeasureACE:
+    ) -> Any:
-    return  _update(session, db_obj, data)
+        db_obj = cls.model(
-
+            **data.model_dump(), tenant_id=tenant_id, company_id=company_id
-
+        )
-def delete_ace(session: Session, db_obj: UnitOfMeasureACE) -> UnitOfMeasureACE:
+        db.add(db_obj)
-    return  _delete(session, db_obj)
+        db.commit()
-
+        db.refresh(db_obj)
-# --- OMA ---
+        return db_obj
-
+
-
+    @classmethod
-def create_oma(session: Session, data: UnitOfMeasureOMACreate) -> UnitOfMeasureOMA:
+    def update(
-    return  _create(session, UnitOfMeasureOMA, data)
+        cls,
-
+        db: Session,
-
+        id: int,
-def get_oma(session: Session, id: int) -> Optional[UnitOfMeasureOMA]:
+        tenant_id: int,
-    return  _get(session, UnitOfMeasureOMA, id)
+        data: Any,
-
+        company_id: int,
-
+    ) -> Optional[Any]:
-def get_all_oma(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitOfMeasureOMA]:
+        db_obj = cls.get_by_id(db, id, tenant_id, company_id)
-    return  _get_all(session, UnitOfMeasureOMA, skip, limit)
+        if not db_obj:
-
+            return None
-
+
-def update_oma(session: Session, db_obj: UnitOfMeasureOMA, data: UnitOfMeasureOMAUpdate) -> UnitOfMeasureOMA:
+        update_dict = data.model_dump(exclude_unset=True)
-    return  _update(session, db_obj, data)
+        for key, value in update_dict.items():
-
+            setattr(db_obj, key, value)
-
+
-def delete_oma(session: Session, db_obj: UnitOfMeasureOMA) -> UnitOfMeasureOMA:
+        db.commit()
-    return  _delete(session, db_obj)
+        db.refresh(db_obj)
-
+        return db_obj
-# --- American ---
+
-
+    @classmethod
-
+    def delete(
-def create_american(session: Session, data: UnitOfMeasureAmericanCreate) -> UnitOfMeasureAmerican:
+        cls, db: Session, id: int, tenant_id: int, company_id: int
-    return  _create(session, UnitOfMeasureAmerican, data)
+    ) -> bool:
-
+        db_obj = cls.get_by_id(db, id, tenant_id, company_id)
-
+        if not db_obj:
-def get_american(session: Session, id: int) -> Optional[UnitOfMeasureAmerican]:
+            return False
-    return  _get(session, UnitOfMeasureAmerican, id)
+
-
+        db.delete(db_obj)
-
+        db.commit()
-def get_all_american(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitOfMeasureAmerican]:
+        return True
-    return  _get_all(session, UnitOfMeasureAmerican, skip, limit)
+
-
+
-
+class UnitOfMeasureACEService(BaseService):
-def update_american(session: Session, db_obj: UnitOfMeasureAmerican, data: UnitOfMeasureAmericanUpdate) -> UnitOfMeasureAmerican:
+    model = UnitOfMeasureACE
-    return  _update(session, db_obj, data)
+
-
+
-
+class UnitOfMeasureOMAService(BaseService):
-def delete_american(session: Session, db_obj: UnitOfMeasureAmerican) -> UnitOfMeasureAmerican:
+    model = UnitOfMeasureOMA
-    return  _delete(session, db_obj)
+
-
+
-# --- Customs ---
+class UnitOfMeasureAmericanService(BaseService):
-
+    model = UnitOfMeasureAmerican
-
+
-def create_customs(session: Session, data: UnitOfMeasureCustomsCreate) -> UnitOfMeasureCustoms:
+
-    return  _create(session, UnitOfMeasureCustoms, data)
+class UnitOfMeasureCustomsService(BaseService):
-
+    model = UnitOfMeasureCustoms
-
+
-def get_customs(session: Session, id: int) -> Optional[UnitOfMeasureCustoms]:
+
-    return  _get(session, UnitOfMeasureCustoms, id)
+class UnitOfMeasureService(BaseService):
-
+    model = UnitOfMeasure
-
+
-def get_all_customs(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitOfMeasureCustoms]:
+
-    return  _get_all(session, UnitOfMeasureCustoms, skip, limit)
+class UnitOfMeasureGeneralService(BaseService):
-
+    model = UnitOfMeasureGeneral
-
-def update_customs(session: Session, db_obj: UnitOfMeasureCustoms, data: UnitOfMeasureCustomsUpdate) -> UnitOfMeasureCustoms:
-    return  _update(session, db_obj, data)
-
-
-def delete_customs(session: Session, db_obj: UnitOfMeasureCustoms) -> UnitOfMeasureCustoms:
-    return  _delete(session, db_obj)
-
-# --- Main UnitOfMeasure ---
-
-
-def create_uom(session: Session, data: UnitOfMeasureCreate) -> UnitOfMeasure:
-    return  _create(session, UnitOfMeasure, data)
-
-
-def get_uom(session: Session, id: int) -> Optional[UnitOfMeasure]:
-    return  _get(session, UnitOfMeasure, id)
-
-
-def get_all_uom(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitOfMeasure]:
-    return  _get_all(session, UnitOfMeasure, skip, limit)
-
-
-def update_uom(session: Session, db_obj: UnitOfMeasure, data: UnitOfMeasureUpdate) -> UnitOfMeasure:
-    return  _update(session, db_obj, data)
-
-
-def delete_uom(session: Session, db_obj: UnitOfMeasure) -> UnitOfMeasure:
-    return  _delete(session, db_obj)
-
-# --- General UnitOfMeasure ---
-
-
-def create_uom_general(session: Session, data: UnitOfMeasureGeneralCreate) -> UnitOfMeasureGeneral:
-    return  _create(session, UnitOfMeasureGeneral, data)
-
-
-def get_uom_general(session: Session, id: int) -> Optional[UnitOfMeasureGeneral]:
-    return  _get(session, UnitOfMeasureGeneral, id)
 
 
 def get_all_uom_general(session: Session, skip: int = 0, limit: int = 100) -> Sequence[UnitOfMeasureGeneral]:
-    return  _get_all(session, UnitOfMeasureGeneral, skip, limit)
+    return BaseService._get_all(session, UnitOfMeasureGeneral, skip, limit)
 
 
 def update_uom_general(session: Session, db_obj: UnitOfMeasureGeneral, data: UnitOfMeasureGeneralUpdate) -> UnitOfMeasureGeneral:
-    return  _update(session, db_obj, data)
+    return BaseService._update(session, db_obj, data)
 
 
 def delete_uom_general(session: Session, db_obj: UnitOfMeasureGeneral) -> UnitOfMeasureGeneral:
-    return  _delete(session, db_obj)
+    return BaseService._delete(session, db_obj)

backend/api/v1/modules/a76/parts/models.py

@@ -42,6 +42,11 @@ class Part(Base, TenantScopedMixin, TimestampMixin):
         ForeignKeyConstraint(
             ["currency_key"], ["public.currency_types.code"], name="fk_parts_currency"
         ),
+        ForeignKeyConstraint(
+            ["unit_of_measure", "tenant_id", "company_id"],
+            ["a76.units_of_measure.code", "a76.units_of_measure.tenant_id",
+                "a76.units_of_measure.company_id"],
+        ),
         UniqueConstraint(
             "tenant_id", "company_id", "part_number", name="client_part_ukey"
         ),
@@ -60,7 +65,7 @@ class Part(Base, TenantScopedMixin, TimestampMixin):
     description_english: Mapped[Optional[str]] = mapped_column(String(500))
     part_class: Mapped[Optional[str]] = mapped_column(String(8))
     unit_of_measure: Mapped[Optional[str]] = mapped_column(
-        String(5), ForeignKey("a76.units_of_measure.code")
+        String(5)
     )
     commercial_part_number: Mapped[Optional[str]] = mapped_column(String(70))
     country_of_origin: Mapped[Optional[str]] = mapped_column(String(3))

backend/api/v1/modules/a76/router.py

@@ -15,13 +15,29 @@ from .general_catalogs.company import router as company_router
 from .country_rule_oct.routes import router as country_rule_oct_router
 from .transportation.drivers.routes import router as drivers_router
 from .general_catalogs.exchange_rate.routes import router as exchange_rate_router
+from .general_catalogs.identifiers.routes import router as identifiers_router
 from .fraction_rule_octave.routes import router as fraction_rule_octave_router
 from .licenses import router as licenses_router
 from .general_catalogs.packages.routes import router as package_router
+from .general_catalogs.ports.routes import router as ports_router
 from .parts import router as parts_router
 from .pedmientos.router import router as pedimentos_router
 from .permission_rule_oct.routes import router as permission_rule_oct_router
 from .general_catalogs.seal.routes import router as seal_router
+from .general_catalogs.units_of_measure.routes import router as units_of_measure_router
+from .general_catalogs.concepts.routes import router as concepts_router
+from .general_catalogs.customs_broker_concepts.routes import router as customs_broker_concepts_router
+from .general_catalogs.classification_concepts.routes import router as classification_concepts_router
+from .general_catalogs.unit_conversions.routes import router as unit_conversions_router
+from .general_catalogs.equivalencies.routes import router as equivalencies_router
+from .general_catalogs.multi_currency_types.routes import router as multi_currency_types_router
+from .general_catalogs.inpc.routes import router as inpc_router
+from .general_catalogs.legends.routes import router as legends_router
+from .general_catalogs.signatures.routes import router as signatures_router
+from .general_catalogs.error_catalogs.routes import router as error_catalogs_router
+from .general_catalogs.doda.routes import router as doda_router
+from .general_catalogs.prevalidators.routes import router as prevalidators_router
+from .general_catalogs.electronic_notices.routes import router as electronic_notices_router
 from .tenants import router as tenants_router
 from .transportation.trailers.routes import router as trailers_router
 from .transportation.transporters.routes import router as transporters_router
@@ -34,7 +50,8 @@ router = APIRouter()
 # Registrar módulos
 router.include_router(auth_router)
 router.include_router(tenants_router, prefix="/a76", tags=["a76 / tenants"])
-router.include_router(user_tenant_router, prefix="/a76", tags=["a76 / user-tenants"])
+router.include_router(user_tenant_router, prefix="/a76",
+                      tags=["a76 / user-tenants"])
 router.include_router(licenses_router, prefix="/a76", tags=["a76 / licenses"])
 router.include_router(pedimentos_router, prefix="/a76")
 router.include_router(
@@ -47,18 +64,38 @@ router.include_router(
     permission_rule_oct_router, prefix="/a76", tags=["a76 / permission_rule_oct"]
 )
 router.include_router(package_router, prefix="/a76")
+router.include_router(ports_router, prefix="/a76")
 router.include_router(seal_router, prefix="/a76", tags=["a76 / seal"])
+router.include_router(units_of_measure_router, prefix="/a76")
 router.include_router(
     fraction_rule_octave_router, prefix="/a76", tags=["a76 / fraction_rule_octave"]
 )
+router.include_router(identifiers_router, prefix="/a76")
 router.include_router(
     country_rule_oct_router, prefix="/a76", tags=["a76 / country_rule_oct"]
 )
-router.include_router(exchange_rate_router, prefix="/a76", tags=["a76 / exchange_rate"])
+router.include_router(exchange_rate_router, prefix="/a76",
+                      tags=["a76 / exchange_rate"])
 router.include_router(trailers_router, prefix="/a76", tags=["a76 / trailers"])
 router.include_router(
     customs_broker_router, prefix="/a76", tags=["a76 / customs_broker"]
 )
 router.include_router(drivers_router, prefix="/a76", tags=["a76 / drivers"])
-router.include_router(transporters_router, prefix="/a76", tags=["a76 / transporters"])
+router.include_router(transporters_router, prefix="/a76",
+                      tags=["a76 / transporters"])
 router.include_router(vehicles_router, prefix="/a76", tags=["a76 / vehicles"])
+
+# Registrar catálogos generales adicionales
+router.include_router(concepts_router, prefix="/a76")
+router.include_router(customs_broker_concepts_router, prefix="/a76")
+router.include_router(classification_concepts_router, prefix="/a76")
+router.include_router(unit_conversions_router, prefix="/a76")
+router.include_router(equivalencies_router, prefix="/a76")
+router.include_router(multi_currency_types_router, prefix="/a76")
+router.include_router(inpc_router, prefix="/a76")
+router.include_router(legends_router, prefix="/a76")
+router.include_router(signatures_router, prefix="/a76")
+router.include_router(error_catalogs_router, prefix="/a76")
+router.include_router(doda_router, prefix="/a76")
+router.include_router(prevalidators_router, prefix="/a76")
+router.include_router(electronic_notices_router, prefix="/a76")

backend/api/v1/modules/public/reference_data/code_pedimento_regimens/models.py

@@ -19,12 +19,13 @@ class CodePedimentoRegimen(Base):
             ["regimen_code"], ["public.pedimento_regimens.code"], name="fk_regimenped"
         ),
         PrimaryKeyConstraint("id", name="clave_pedimento_regimens_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     id: Mapped[int] = mapped_column(Integer)
     pedimento_code: Mapped[str] = mapped_column(String(3), nullable=False)
-    regimen_code: Mapped[Optional[str]] = mapped_column(String(3), nullable=False)
+    regimen_code: Mapped[Optional[str]] = mapped_column(
+        String(3), nullable=False)
     type_code: Mapped[Optional[str]] = mapped_column(
         String(1)
     )  # si aplica un tipo de relación

backend/api/v1/modules/public/reference_data/containers/models.py

@@ -7,7 +7,7 @@ class Container(Base):
     __tablename__ = "containers"  # GContenedores
     __table_args__ = (
         PrimaryKeyConstraint("key", name="containers_pkey"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
     key: Mapped[str] = mapped_column(

backend/api/v1/modules/public/reference_data/countries/models.py

@@ -8,11 +8,13 @@ class Country(Base):
     __table_args__ = (
         PrimaryKeyConstraint("m3_key", name="countries_pkey"),
         Index("ak_country_ame", "ame_key", unique=True),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
-    m3_key: Mapped[str] = mapped_column(String(3), nullable=False)  # clave M3
+    m3_key: Mapped[str] = mapped_column(
-    mex_key: Mapped[str] = mapped_column(String(2), nullable=False)  # clave país México
+        String(3), primary_key=True, nullable=False)  # clave M3
+    mex_key: Mapped[str] = mapped_column(
+        String(2), nullable=False)  # clave país México
     ame_key: Mapped[str] = mapped_column(
         String(2), nullable=False
     )  # clave país América / regional

backend/api/v1/modules/public/reference_data/currency_types/models.py

@@ -7,11 +7,11 @@ class CurrencyType(Base):
     __tablename__ = "currency_types"  # GTiposMoneda
     __table_args__ = (
         PrimaryKeyConstraint("code", name="currency_types_pkey"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},
     )
 
     code: Mapped[str] = mapped_column(
-        String(3), nullable=False
+        String(3), primary_key=True, nullable=False
     )  # código ISO o clave de moneda
     currency_name: Mapped[str] = mapped_column(
         String(15), nullable=False

backend/api/v1/modules/public/reference_data/customs_sections/models.py

@@ -7,7 +7,7 @@ class CustomsSection(Base):
     __tablename__ = "customs_sections"  # GAduanaSec
     __table_args__ = (
         PrimaryKeyConstraint("customs_code", name="customs_code_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     customs_code = mapped_column(String(3), nullable=False)

backend/api/v1/modules/public/reference_data/customs_warehouses/models.py

@@ -7,11 +7,13 @@ class CustomsWarehouse(Base):
     __tablename__ = "customs_warehouses"  # GRecintos
     __table_args__ = (
         PrimaryKeyConstraint("key", "customs", name="pk_customs_warehouse"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
-    key: Mapped[str] = mapped_column(String(3), nullable=False)  # clave del recinto
+    key: Mapped[str] = mapped_column(
-    customs: Mapped[str] = mapped_column(String(100), nullable=False)  # aduana asociada
+        String(3), nullable=False)  # clave del recinto
+    customs: Mapped[str] = mapped_column(
+        String(100), nullable=False)  # aduana asociada
     fiscalized_warehouse: Mapped[str] = mapped_column(
         String(1000)
     )  # recintos fiscalizados (valor legal)

backend/api/v1/modules/public/reference_data/incoterms/models.py

@@ -7,7 +7,7 @@ class Incoterm(Base):
     __tablename__ = "incoterms"  # GIncoterm
     __table_args__ = (
         PrimaryKeyConstraint("code", name="incoterms_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     code: Mapped[str] = mapped_column(String(5), nullable=False)

backend/api/v1/modules/public/reference_data/invoice_types/models.py

@@ -7,7 +7,7 @@ class InvoiceType(Base):
     __tablename__ = "invoice_types"  # GTiposFactura
     __table_args__ = (
         PrimaryKeyConstraint("key", name="invoice_types_pkey"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
     key: Mapped[str] = mapped_column(
@@ -16,7 +16,8 @@ class InvoiceType(Base):
     description: Mapped[str] = mapped_column(
         String(50), nullable=False
     )  # descripción oficial (en español)
-    note: Mapped[str] = mapped_column(String(500))  # observación o comentario adicional
+    # observación o comentario adicional
+    note: Mapped[str] = mapped_column(String(500))
     type: Mapped[str] = mapped_column(String(15))  # tipo
 
     def __repr__(self):

backend/api/v1/modules/public/reference_data/material_types/models.py

@@ -7,10 +7,11 @@ class MaterialType(Base):
     __tablename__ = "material_types"  # STipoMat QTipoActFijo
     __table_args__ = (
         PrimaryKeyConstraint("key", name="material_types_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
-    key: Mapped[str] = mapped_column(String(10), nullable=False)  # clave del material
+    key: Mapped[str] = mapped_column(
+        String(10), nullable=False)  # clave del material
     type: Mapped[str] = mapped_column(String(15), nullable=False)  # tipo
     description: Mapped[str] = mapped_column(
         String(256), nullable=False

backend/api/v1/modules/public/reference_data/payment_methods/models.py

@@ -7,7 +7,7 @@ class PaymentMethod(Base):
     __tablename__ = "payment_methods"  # GFormaPago
     __table_args__ = (
         PrimaryKeyConstraint("key", name="payment_methods_pkey"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
     key: Mapped[str] = mapped_column(String(2), nullable=False)

backend/api/v1/modules/public/reference_data/pedimento_codes/models.py

@@ -12,7 +12,7 @@ class PedimentoCode(Base):
     __tablename__ = "pedimento_codes"  # GClavePed
     __table_args__ = (
         PrimaryKeyConstraint("code", name="pedimento_codes_pkey"),
-        {"schema": "public"},  # esquema del anexo 22
+        {"schema": "public", "extend_existing": True},  # esquema del anexo 22
     )
 
     code: Mapped[str] = mapped_column(String(3), nullable=False)

backend/api/v1/modules/public/reference_data/pedimento_regimens/models.py

@@ -12,7 +12,7 @@ class RegimenPedimento(Base):
     __tablename__ = "pedimento_regimens"  # GRegimenPed
     __table_args__ = (
         PrimaryKeyConstraint("code", name="pedimento_regimens_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     code: Mapped[str] = mapped_column(

backend/api/v1/modules/public/reference_data/sectors/models.py

@@ -7,10 +7,11 @@ class Sector(Base):
     __tablename__ = "sectors"  # GSectores
     __table_args__ = (
         PrimaryKeyConstraint("key", name="sectors_pkey"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
-    key: Mapped[str] = mapped_column(String(8), nullable=False)  # clave del sector
+    key: Mapped[str] = mapped_column(
+        String(8), nullable=False)  # clave del sector
     description: Mapped[str] = mapped_column(
         String(150), nullable=False
     )  # descripción oficial (en español)

backend/api/v1/modules/public/reference_data/states/models.py

@@ -9,7 +9,7 @@ class State(Base):
     __tablename__ = "states"  # GEstados
     __table_args__ = (
         PrimaryKeyConstraint("m3_key", "description", name="states_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     m3_key: Mapped[str] = mapped_column(String(3), nullable=False)

backend/api/v1/modules/public/reference_data/transport_modes/models.py

@@ -7,7 +7,7 @@ class TransportMode(Base):
     __tablename__ = "transport_modes"  # GModTransporte
     __table_args__ = (
         PrimaryKeyConstraint("key", name="transport_modes_pkey"),
-        {"schema": "public"},  # opcional
+        {"schema": "public", "extend_existing": True},  # opcional
     )
 
     key: Mapped[str] = mapped_column(String(3), nullable=False)

backend/api/v1/modules/public/reference_data/transport_types/models.py

@@ -7,7 +7,7 @@ class TransportType(Base):
     __tablename__ = "transport_types"  # GTiposTransporte
     __table_args__ = (
         PrimaryKeyConstraint("transport_code", name="transport_types_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     transport_code: Mapped[str] = mapped_column(

backend/api/v1/modules/public/reference_data/valuation_methods/models.py

@@ -7,7 +7,7 @@ class ValuationMethod(Base):
     __tablename__ = "valuation_methods"  # GMetValor
     __table_args__ = (
         PrimaryKeyConstraint("key", name="valuation_methods_pkey"),
-        {"schema": "public"},
+        {"schema": "public", "extend_existing": True},
     )
 
     key: Mapped[str] = mapped_column(String(2), nullable=False)

backend/core/database.py

@@ -4,15 +4,19 @@ Configuración de base de datos con soporte multi-tenant
 - Bases de datos dedicadas para clientes enterprise
 """
 
+import logging
 from contextlib import contextmanager
 from typing import AsyncGenerator, Dict, Generator, Optional
 
 from sqlalchemy import create_engine
+from sqlalchemy.exc import ProgrammingError
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
 from sqlalchemy.orm import Session, declarative_base, sessionmaker
 
 from .config import settings
 
+logger = logging.getLogger(__name__)
+
 # Base declarativa para modelos ORM
 Base = declarative_base()
 
@@ -25,7 +29,8 @@ core_engine = create_engine(
     echo=False,
 )
 
-CoreSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=core_engine)
+CoreSessionLocal = sessionmaker(
+    autocommit=False, autoflush=False, bind=core_engine)
 
 # Engine asíncrono para operaciones async
 async_core_engine = create_async_engine(
@@ -106,7 +111,8 @@ def get_tenant_db(
     else:
         # Tenant con BD dedicada
         engine = get_tenant_engine(tenant_id, db_config)
-        SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+        SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=engine)
         db = SessionLocal()
 
     try:
@@ -119,7 +125,15 @@ def init_db():
     """
     Inicializa las tablas de la base de datos core
     """
-    Base.metadata.create_all(bind=core_engine)
+    try:
+        Base.metadata.create_all(bind=core_engine, checkfirst=True)
+    except ProgrammingError as e:
+        # Si la tabla ya existe, es seguro continuar
+        if "already exists" in str(e):
+            logger.warning(
+                f"Algunas tablas ya existen en la base de datos: {e}")
+        else:
+            raise
 
 
 async def init_async_db():

frontend/src/lib/api/dashboard/a76/classification-concepts.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface ClassificationConcept {
+	id: number;
+	classification: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface ClassificationConceptCreate {
+	classification: string;
+	description?: string;
+}
+
+export interface ClassificationConceptUpdate extends Partial<ClassificationConceptCreate> {}
+
+export interface ClassificationConceptListResponse {
+	items: ClassificationConcept[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getClassificationConcepts(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<ClassificationConceptListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/classification_concepts?${params.toString()}`);
+	return response.data;
+}
+
+export async function getClassificationConcept(id: number): Promise<ClassificationConcept> {
+	const response = await api.get(`/a76/classification_concepts/${id}`);
+	return response.data;
+}
+
+export async function createClassificationConcept(data: ClassificationConceptCreate): Promise<ClassificationConcept> {
+	const response = await api.post('/a76/classification_concepts', data);
+	return response.data;
+}
+
+export async function updateClassificationConcept(id: number, data: ClassificationConceptUpdate): Promise<ClassificationConcept> {
+	const response = await api.patch(`/a76/classification_concepts/${id}`, data);
+	return response.data;
+}
+
+export async function deleteClassificationConcept(id: number): Promise<void> {
+	await api.delete(`/a76/classification_concepts/${id}`);
+}

frontend/src/lib/api/dashboard/a76/company.ts

@@ -0,0 +1,91 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Company {
+    id: number;
+    tenant_id: number;
+    name: string | null;
+    rfc: string | null;
+    main_activity: string | null;
+    program: string | null;
+    program_number: string | null;
+    prosec: number | null;
+    prosec_authorization: string | null;
+    manufacturer_id: string | null;
+    broker_company: string | null;
+    responsible: string | null;
+    responsible_name: string | null;
+    responsible_last_name: string | null;
+    responsible_mother_last_name: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+
+export interface CompanyCreate {
+    name?: string | null;
+    rfc?: string | null;
+    main_activity?: string | null;
+    program?: string | null;
+    program_number?: string | null;
+    prosec?: number | null;
+    prosec_authorization?: string | null;
+    manufacturer_id?: string | null;
+    broker_company?: string | null;
+    responsible?: string | null;
+    responsible_name?: string | null;
+    responsible_last_name?: string | null;
+    responsible_mother_last_name?: string | null;
+}
+
+export interface CompanyUpdate {
+    name?: string | null;
+    rfc?: string | null;
+    main_activity?: string | null;
+    program?: string | null;
+    program_number?: string | null;
+    prosec?: number | null;
+    prosec_authorization?: string | null;
+    manufacturer_id?: string | null;
+    broker_company?: string | null;
+    responsible?: string | null;
+    responsible_name?: string | null;
+    responsible_last_name?: string | null;
+    responsible_mother_last_name?: string | null;
+}
+
+export interface CompanyListResponse {
+    items: Company[];
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+}
+
+export async function getCompanies(
+    page = 1,
+    pageSize = 50,
+    filters: Record<string, any> = {}
+): Promise<ApiResponse<CompanyListResponse>> {
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        page_size: pageSize.toString(),
+        ...filters
+    });
+    return await api.get(`/a76/company?${queryParams.toString()}`);
+}
+
+export async function getCompany(id: number): Promise<ApiResponse<Company>> {
+    return await api.get(`/a76/company/${id}`);
+}
+
+export async function createCompany(data: CompanyCreate): Promise<ApiResponse<Company>> {
+    return await api.post(`/a76/company`, data);
+}
+
+export async function updateCompany(id: number, data: CompanyUpdate): Promise<ApiResponse<Company>> {
+    return await api.put(`/a76/company/${id}`, data);
+}
+
+export async function deleteCompany(id: number): Promise<ApiResponse<void>> {
+    return await api.delete(`/a76/company/${id}`);
+}

frontend/src/lib/api/dashboard/a76/concepts.ts

@@ -0,0 +1,79 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Concept {
+	id: number;
+	code: string;
+	description?: string;
+	description_en?: string;
+	detailed_description?: string;
+	priority?: number;
+	priority_ame?: number;
+	first_total?: boolean;
+	type?: string;
+	is_printed?: boolean;
+	section?: number;
+	classification?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface ConceptCreate {
+	code: string;
+	description?: string;
+	description_en?: string;
+	detailed_description?: string;
+	priority?: number;
+	priority_ame?: number;
+	first_total?: boolean;
+	type?: string;
+	is_printed?: boolean;
+	section?: number;
+	classification?: string;
+}
+
+export interface ConceptUpdate extends Partial<ConceptCreate> {}
+
+export interface ConceptListResponse {
+	items: Concept[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getConcepts(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<ConceptListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/concepts?${params.toString()}`);
+	return response.data;
+}
+
+export async function getConcept(id: number): Promise<Concept> {
+	const response = await api.get(`/a76/concepts/${id}`);
+	return response.data;
+}
+
+export async function createConcept(data: ConceptCreate): Promise<Concept> {
+	const response = await api.post('/a76/concepts', data);
+	return response.data;
+}
+
+export async function updateConcept(id: number, data: ConceptUpdate): Promise<Concept> {
+	const response = await api.patch(`/a76/concepts/${id}`, data);
+	return response.data;
+}
+
+export async function deleteConcept(id: number): Promise<void> {
+	await api.delete(`/a76/concepts/${id}`);
+}

frontend/src/lib/api/dashboard/a76/customs-broker-concepts.ts

@@ -0,0 +1,77 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface CustomsBrokerConcept {
+	id: number;
+	code: string;
+	description?: string;
+	description_en?: string;
+	detailed_description?: string;
+	priority?: number;
+	first_total?: boolean;
+	type?: string;
+	is_printed?: boolean;
+	section?: number;
+	classification?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface CustomsBrokerConceptCreate {
+	code: string;
+	description?: string;
+	description_en?: string;
+	detailed_description?: string;
+	priority?: number;
+	first_total?: boolean;
+	type?: string;
+	is_printed?: boolean;
+	section?: number;
+	classification?: string;
+}
+
+export interface CustomsBrokerConceptUpdate extends Partial<CustomsBrokerConceptCreate> {}
+
+export interface CustomsBrokerConceptListResponse {
+	items: CustomsBrokerConcept[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getCustomsBrokerConcepts(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<CustomsBrokerConceptListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/customs_broker_concepts?${params.toString()}`);
+	return response.data;
+}
+
+export async function getCustomsBrokerConcept(id: number): Promise<CustomsBrokerConcept> {
+	const response = await api.get(`/a76/customs_broker_concepts/${id}`);
+	return response.data;
+}
+
+export async function createCustomsBrokerConcept(data: CustomsBrokerConceptCreate): Promise<CustomsBrokerConcept> {
+	const response = await api.post('/a76/customs_broker_concepts', data);
+	return response.data;
+}
+
+export async function updateCustomsBrokerConcept(id: number, data: CustomsBrokerConceptUpdate): Promise<CustomsBrokerConcept> {
+	const response = await api.patch(`/a76/customs_broker_concepts/${id}`, data);
+	return response.data;
+}
+
+export async function deleteCustomsBrokerConcept(id: number): Promise<void> {
+	await api.delete(`/a76/customs_broker_concepts/${id}`);
+}

frontend/src/lib/api/dashboard/a76/doda.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface DODA {
+	id: number;
+	code: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface DODACreate {
+	code: string;
+	description?: string;
+}
+
+export interface DODAUpdate extends Partial<DODACreate> {}
+
+export interface DODAListResponse {
+	items: DODA[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getDODAs(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<DODAListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/doda?${params.toString()}`);
+	return response.data;
+}
+
+export async function getDODA(id: number): Promise<DODA> {
+	const response = await api.get(`/a76/doda/${id}`);
+	return response.data;
+}
+
+export async function createDODA(data: DODACreate): Promise<DODA> {
+	const response = await api.post('/a76/doda', data);
+	return response.data;
+}
+
+export async function updateDODA(id: number, data: DODAUpdate): Promise<DODA> {
+	const response = await api.patch(`/a76/doda/${id}`, data);
+	return response.data;
+}
+
+export async function deleteDODA(id: number): Promise<void> {
+	await api.delete(`/a76/doda/${id}`);
+}

frontend/src/lib/api/dashboard/a76/electronic-notices.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface ElectronicNotice {
+	id: number;
+	code: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface ElectronicNoticeCreate {
+	code: string;
+	description?: string;
+}
+
+export interface ElectronicNoticeUpdate extends Partial<ElectronicNoticeCreate> {}
+
+export interface ElectronicNoticeListResponse {
+	items: ElectronicNotice[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getElectronicNotices(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<ElectronicNoticeListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/electronic_notices?${params.toString()}`);
+	return response.data;
+}
+
+export async function getElectronicNotice(id: number): Promise<ElectronicNotice> {
+	const response = await api.get(`/a76/electronic_notices/${id}`);
+	return response.data;
+}
+
+export async function createElectronicNotice(data: ElectronicNoticeCreate): Promise<ElectronicNotice> {
+	const response = await api.post('/a76/electronic_notices', data);
+	return response.data;
+}
+
+export async function updateElectronicNotice(id: number, data: ElectronicNoticeUpdate): Promise<ElectronicNotice> {
+	const response = await api.patch(`/a76/electronic_notices/${id}`, data);
+	return response.data;
+}
+
+export async function deleteElectronicNotice(id: number): Promise<void> {
+	await api.delete(`/a76/electronic_notices/${id}`);
+}

frontend/src/lib/api/dashboard/a76/equivalencies.ts

@@ -0,0 +1,63 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Equivalency {
+	id: number;
+	fraccion_mex: string;
+	fraccion_us: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface EquivalencyCreate {
+	fraccion_mex: string;
+	fraccion_us: string;
+	description?: string;
+}
+
+export interface EquivalencyUpdate extends Partial<EquivalencyCreate> {}
+
+export interface EquivalencyListResponse {
+	items: Equivalency[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getEquivalencies(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<EquivalencyListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/equivalencies?${params.toString()}`);
+	return response.data;
+}
+
+export async function getEquivalency(id: number): Promise<Equivalency> {
+	const response = await api.get(`/a76/equivalencies/${id}`);
+	return response.data;
+}
+
+export async function createEquivalency(data: EquivalencyCreate): Promise<Equivalency> {
+	const response = await api.post('/a76/equivalencies', data);
+	return response.data;
+}
+
+export async function updateEquivalency(id: number, data: EquivalencyUpdate): Promise<Equivalency> {
+	const response = await api.patch(`/a76/equivalencies/${id}`, data);
+	return response.data;
+}
+
+export async function deleteEquivalency(id: number): Promise<void> {
+	await api.delete(`/a76/equivalencies/${id}`);
+}

frontend/src/lib/api/dashboard/a76/error-catalogs.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface ErrorCatalog {
+	id: number;
+	code: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface ErrorCatalogCreate {
+	code: string;
+	description?: string;
+}
+
+export interface ErrorCatalogUpdate extends Partial<ErrorCatalogCreate> {}
+
+export interface ErrorCatalogListResponse {
+	items: ErrorCatalog[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getErrorCatalogs(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<ErrorCatalogListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/error_catalogs?${params.toString()}`);
+	return response.data;
+}
+
+export async function getErrorCatalog(id: number): Promise<ErrorCatalog> {
+	const response = await api.get(`/a76/error_catalogs/${id}`);
+	return response.data;
+}
+
+export async function createErrorCatalog(data: ErrorCatalogCreate): Promise<ErrorCatalog> {
+	const response = await api.post('/a76/error_catalogs', data);
+	return response.data;
+}
+
+export async function updateErrorCatalog(id: number, data: ErrorCatalogUpdate): Promise<ErrorCatalog> {
+	const response = await api.patch(`/a76/error_catalogs/${id}`, data);
+	return response.data;
+}
+
+export async function deleteErrorCatalog(id: number): Promise<void> {
+	await api.delete(`/a76/error_catalogs/${id}`);
+}

frontend/src/lib/api/dashboard/a76/identifiers.ts

@@ -0,0 +1,62 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Identifier {
+    id: number;
+    code: string;
+    description: string | null;
+    level: string | null;
+    complement: string | null;
+    company_id: number;
+    tenant_id: number;
+    created_at: string | null;
+    updated_at: string | null;
+}
+
+export interface IdentifierCreate {
+    code: string;
+    description?: string | null;
+    level?: string | null;
+    complement?: string | null;
+    company_id: number;
+}
+
+export interface IdentifierUpdate {
+    code?: string;
+    description?: string | null;
+    level?: string | null;
+    complement?: string | null;
+}
+
+export interface IdentifierListResponse {
+    items: Identifier[];
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+}
+
+export async function getIdentifiers(
+    page = 1,
+    pageSize = 50,
+    filters: Record<string, any> = {}
+): Promise<ApiResponse<IdentifierListResponse>> {
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        page_size: pageSize.toString(),
+        ...filters
+    });
+    return await api.get(`/a76/identifiers?${queryParams.toString()}`);
+}
+
+export async function createIdentifier(data: IdentifierCreate): Promise<ApiResponse<Identifier>> {
+    return await api.post('/a76/identifiers', data);
+}
+
+export async function updateIdentifier(id: number, data: IdentifierUpdate): Promise<ApiResponse<Identifier>> {
+    return await api.put(`/a76/identifiers/${id}`, data);
+}
+
+export async function deleteIdentifier(id: number): Promise<ApiResponse<void>> {
+    return await api.delete(`/a76/identifiers/${id}`);
+}

frontend/src/lib/api/dashboard/a76/index.ts

@@ -4,3 +4,16 @@
 export * from './classes';
 export * from './packages';
 export * from './exchange-rate';
+export * from './concepts';
+export * from './customs-broker-concepts';
+export * from './classification-concepts';
+export * from './unit-conversions';
+export * from './equivalencies';
+export * from './multi-currency-types';
+export * from './inpc';
+export * from './legends';
+export * from './signatures';
+export * from './error-catalogs';
+export * from './doda';
+export * from './prevalidators';
+export * from './electronic-notices';

frontend/src/lib/api/dashboard/a76/inpc.ts

@@ -0,0 +1,63 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface INPC {
+	id: number;
+	year: string;
+	month: string;
+	value?: number;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface INPCCreate {
+	year: string;
+	month: string;
+	value?: number;
+}
+
+export interface INPCUpdate extends Partial<INPCCreate> {}
+
+export interface INPCListResponse {
+	items: INPC[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getINPCs(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<INPCListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/inpc?${params.toString()}`);
+	return response.data;
+}
+
+export async function getINPC(id: number): Promise<INPC> {
+	const response = await api.get(`/a76/inpc/${id}`);
+	return response.data;
+}
+
+export async function createINPC(data: INPCCreate): Promise<INPC> {
+	const response = await api.post('/a76/inpc', data);
+	return response.data;
+}
+
+export async function updateINPC(id: number, data: INPCUpdate): Promise<INPC> {
+	const response = await api.patch(`/a76/inpc/${id}`, data);
+	return response.data;
+}
+
+export async function deleteINPC(id: number): Promise<void> {
+	await api.delete(`/a76/inpc/${id}`);
+}

frontend/src/lib/api/dashboard/a76/legends.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Legend {
+	id: number;
+	code: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface LegendCreate {
+	code: string;
+	description?: string;
+}
+
+export interface LegendUpdate extends Partial<LegendCreate> {}
+
+export interface LegendListResponse {
+	items: Legend[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getLegends(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<LegendListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/legends?${params.toString()}`);
+	return response.data;
+}
+
+export async function getLegend(id: number): Promise<Legend> {
+	const response = await api.get(`/a76/legends/${id}`);
+	return response.data;
+}
+
+export async function createLegend(data: LegendCreate): Promise<Legend> {
+	const response = await api.post('/a76/legends', data);
+	return response.data;
+}
+
+export async function updateLegend(id: number, data: LegendUpdate): Promise<Legend> {
+	const response = await api.patch(`/a76/legends/${id}`, data);
+	return response.data;
+}
+
+export async function deleteLegend(id: number): Promise<void> {
+	await api.delete(`/a76/legends/${id}`);
+}

frontend/src/lib/api/dashboard/a76/multi-currency-types.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface MultiCurrencyType {
+	id: number;
+	key: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface MultiCurrencyTypeCreate {
+	key: string;
+	description?: string;
+}
+
+export interface MultiCurrencyTypeUpdate extends Partial<MultiCurrencyTypeCreate> {}
+
+export interface MultiCurrencyTypeListResponse {
+	items: MultiCurrencyType[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getMultiCurrencyTypes(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<MultiCurrencyTypeListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/multi_currency_types?${params.toString()}`);
+	return response.data;
+}
+
+export async function getMultiCurrencyType(id: number): Promise<MultiCurrencyType> {
+	const response = await api.get(`/a76/multi_currency_types/${id}`);
+	return response.data;
+}
+
+export async function createMultiCurrencyType(data: MultiCurrencyTypeCreate): Promise<MultiCurrencyType> {
+	const response = await api.post('/a76/multi_currency_types', data);
+	return response.data;
+}
+
+export async function updateMultiCurrencyType(id: number, data: MultiCurrencyTypeUpdate): Promise<MultiCurrencyType> {
+	const response = await api.patch(`/a76/multi_currency_types/${id}`, data);
+	return response.data;
+}
+
+export async function deleteMultiCurrencyType(id: number): Promise<void> {
+	await api.delete(`/a76/multi_currency_types/${id}`);
+}

frontend/src/lib/api/dashboard/a76/packages.ts

@@ -1,122 +1,78 @@
-/**
- * API para gestión de Packages (Bultos/Embalajes A76)
- */
 import { api } from '$lib/api';
 import type { ApiResponse } from '$lib/api';
 
 export interface Package {
-	id: number;
+    id: number;
-	tenant_id: number;
+    tenant_id: number;
-	company_id: number;
+    company_id: number;
-	key: string;
+    key: string;
-	description_es: string | null;
+    description_es: string | null;
-	description_en: string | null;
+    description_en: string | null;
-	weight_unit: number | null;
+    weight_unit: number | null;
-	plurals: string | null;
+    plurals: string | null;
-	plural_in: string | null;
+    plural_in: string | null;
-	code_ace: string | null;
+    code_ace: string | null;
-	code_aamex: string | null;
+    code_aamex: string | null;
-	created_at: string | null;
+    created_at: string | null;
-	updated_at: string | null;
+    updated_at: string | null;
 }
 
 export interface PackageCreate {
-	key: string;
+    key: string;
-	description_es?: string | null;
+    description_es?: string | null;
-	description_en?: string | null;
+    description_en?: string | null;
-	weight_unit?: number | null;
+    weight_unit?: number | null;
-	plurals?: string | null;
+    plurals?: string | null;
-	plural_in?: string | null;
+    plural_in?: string | null;
-	code_ace?: string | null;
+    code_ace?: string | null;
-	code_aamex?: string | null;
+    code_aamex?: string | null;
+    company_id: number;
 }
 
 export interface PackageUpdate {
-	key?: string;
+    key?: string;
-	description_es?: string | null;
+    description_es?: string | null;
-	description_en?: string | null;
+    description_en?: string | null;
-	weight_unit?: number | null;
+    weight_unit?: number | null;
-	plurals?: string | null;
+    plurals?: string | null;
-	plural_in?: string | null;
+    plural_in?: string | null;
-	code_ace?: string | null;
+    code_ace?: string | null;
-	code_aamex?: string | null;
+    code_aamex?: string | null;
 }
 
 export interface PackageListResponse {
-	items: Package[];
+    items: Package[];
-	total: number;
+    total: number;
-	page: number;
+    page: number;
-	page_size: number;
+    page_size: number;
-	pages: number;
+    pages: number;
 }
 
-export interface PackageFilters {
-	key?: string;
-	description_es?: string;
-}
-
-/**
- * Obtener lista de packages con paginación
- */
 export async function getPackages(
-	companyId: number,
+    page = 1,
-	page: number = 1,
+    pageSize = 50,
-	pageSize: number = 50,
+    filters: Record<string, any> = {}
-	filters?: PackageFilters
 ): Promise<ApiResponse<PackageListResponse>> {
-	const params = new URLSearchParams({
+    const queryParams = new URLSearchParams({
-		company_id: companyId.toString(),
+        page: page.toString(),
-		page: page.toString(),
+        page_size: pageSize.toString(),
-		page_size: pageSize.toString()
+        ...filters
-	});
+    });
-
+    return await api.get(`/a76/packages?${queryParams.toString()}`);
-	if (filters?.key) {
-		params.append('key', filters.key);
-	}
-	if (filters?.description_es) {
-		params.append('description_es', filters.description_es);
-	}
-
-	return api.get<PackageListResponse>(`/v1/a76/packages/?${params.toString()}`);
 }
 
-/**
+export async function getPackage(id: number): Promise<ApiResponse<Package>> {
- * Obtener un package por ID
+    return await api.get(`/a76/packages/${id}`);
- */
-export async function getPackage(
-	packageId: number,
-	companyId: number
-): Promise<ApiResponse<Package>> {
-	return api.get<Package>(`/v1/a76/packages/${packageId}?company_id=${companyId}`);
 }
 
-/**
+export async function createPackage(data: PackageCreate): Promise<ApiResponse<Package>> {
- * Crear un nuevo package
+    return await api.post(`/a76/packages`, data);
- */
-export async function createPackage(
-	data: PackageCreate,
-	companyId: number
-): Promise<ApiResponse<Package>> {
-	return api.post<Package>(`/v1/a76/packages/?company_id=${companyId}`, data);
 }
 
-/**
+export async function updatePackage(id: number, data: PackageUpdate): Promise<ApiResponse<Package>> {
- * Actualizar un package existente
+    return await api.put(`/a76/packages/${id}`, data);
- */
-export async function updatePackage(
-	packageId: number,
-	data: PackageUpdate,
-	companyId: number
-): Promise<ApiResponse<Package>> {
-	return api.put<Package>(`/v1/a76/packages/${packageId}?company_id=${companyId}`, data);
 }
 
-/**
+export async function deletePackage(id: number): Promise<ApiResponse<void>> {
- * Eliminar un package
+    return await api.delete(`/a76/packages/${id}`);
- */
-export async function deletePackage(
-	packageId: number,
-	companyId: number
-): Promise<ApiResponse<void>> {
-	return api.delete<void>(`/v1/a76/packages/${packageId}?company_id=${companyId}`);
 }

frontend/src/lib/api/dashboard/a76/ports.ts

@@ -0,0 +1,68 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export enum PortType {
+    ENTRY = 'ENTRY',
+    EXIT = 'EXIT',
+    BOTH = 'BOTH'
+}
+
+export interface Port {
+    id: number;
+    port_code: string;
+    description: string | null;
+    location_code: string;
+    location_description: string | null;
+    port_type: PortType;
+    created_at: string | null;
+    updated_at: string | null;
+}
+
+export interface PortCreate {
+    port_code: string;
+    description?: string | null;
+    location_code: string;
+    location_description?: string | null;
+    port_type?: PortType;
+}
+
+export interface PortUpdate {
+    port_code?: string;
+    description?: string | null;
+    location_code?: string;
+    location_description?: string | null;
+    port_type?: PortType;
+}
+
+export interface PortListResponse {
+    items: Port[];
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+}
+
+export async function getPorts(
+    page = 1,
+    pageSize = 50,
+    filters: Record<string, any> = {}
+): Promise<ApiResponse<PortListResponse>> {
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        page_size: pageSize.toString(),
+        ...filters
+    });
+    return await api.get(`/a76/ports?${queryParams.toString()}`);
+}
+
+export async function createPort(data: PortCreate): Promise<ApiResponse<Port>> {
+    return await api.post('/a76/ports', data);
+}
+
+export async function updatePort(id: number, data: PortUpdate): Promise<ApiResponse<Port>> {
+    return await api.put(`/a76/ports/${id}`, data);
+}
+
+export async function deletePort(id: number): Promise<ApiResponse<void>> {
+    return await api.delete(`/a76/ports/${id}`);
+}

frontend/src/lib/api/dashboard/a76/prevalidators.ts

@@ -0,0 +1,61 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Prevalidator {
+	id: number;
+	code: string;
+	description?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface PrevalidatorCreate {
+	code: string;
+	description?: string;
+}
+
+export interface PrevalidatorUpdate extends Partial<PrevalidatorCreate> {}
+
+export interface PrevalidatorListResponse {
+	items: Prevalidator[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getPrevalidators(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<PrevalidatorListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/prevalidators?${params.toString()}`);
+	return response.data;
+}
+
+export async function getPrevalidator(id: number): Promise<Prevalidator> {
+	const response = await api.get(`/a76/prevalidators/${id}`);
+	return response.data;
+}
+
+export async function createPrevalidator(data: PrevalidatorCreate): Promise<Prevalidator> {
+	const response = await api.post('/a76/prevalidators', data);
+	return response.data;
+}
+
+export async function updatePrevalidator(id: number, data: PrevalidatorUpdate): Promise<Prevalidator> {
+	const response = await api.patch(`/a76/prevalidators/${id}`, data);
+	return response.data;
+}
+
+export async function deletePrevalidator(id: number): Promise<void> {
+	await api.delete(`/a76/prevalidators/${id}`);
+}

frontend/src/lib/api/dashboard/a76/signatures.ts

@@ -0,0 +1,63 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface Signature {
+	id: number;
+	name: string;
+	position?: string;
+	certificate?: string;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface SignatureCreate {
+	name: string;
+	position?: string;
+	certificate?: string;
+}
+
+export interface SignatureUpdate extends Partial<SignatureCreate> {}
+
+export interface SignatureListResponse {
+	items: Signature[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getSignatures(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<SignatureListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/signatures?${params.toString()}`);
+	return response.data;
+}
+
+export async function getSignature(id: number): Promise<Signature> {
+	const response = await api.get(`/a76/signatures/${id}`);
+	return response.data;
+}
+
+export async function createSignature(data: SignatureCreate): Promise<Signature> {
+	const response = await api.post('/a76/signatures', data);
+	return response.data;
+}
+
+export async function updateSignature(id: number, data: SignatureUpdate): Promise<Signature> {
+	const response = await api.patch(`/a76/signatures/${id}`, data);
+	return response.data;
+}
+
+export async function deleteSignature(id: number): Promise<void> {
+	await api.delete(`/a76/signatures/${id}`);
+}

frontend/src/lib/api/dashboard/a76/unit-conversions.ts

@@ -0,0 +1,63 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+export interface UnitConversion {
+	id: number;
+	from_unit_id: number;
+	to_unit_id: number;
+	conversion_factor: number;
+	tenant_id: string;
+	company_id?: string;
+	created_at: string;
+	updated_at?: string;
+}
+
+export interface UnitConversionCreate {
+	from_unit_id: number;
+	to_unit_id: number;
+	conversion_factor: number;
+}
+
+export interface UnitConversionUpdate extends Partial<UnitConversionCreate> {}
+
+export interface UnitConversionListResponse {
+	items: UnitConversion[];
+	total: number;
+	page: number;
+	page_size: number;
+	pages: number;
+}
+
+export async function getUnitConversions(
+	page: number = 1,
+	pageSize: number = 50,
+	filters: Record<string, any> = {}
+): Promise<ApiResponse<UnitConversionListResponse>> {
+	const params = new URLSearchParams({
+		page: page.toString(),
+		page_size: pageSize.toString(),
+		...filters
+	});
+
+	const response = await api.get(`/a76/unit_conversions?${params.toString()}`);
+	return response.data;
+}
+
+export async function getUnitConversion(id: number): Promise<UnitConversion> {
+	const response = await api.get(`/a76/unit_conversions/${id}`);
+	return response.data;
+}
+
+export async function createUnitConversion(data: UnitConversionCreate): Promise<UnitConversion> {
+	const response = await api.post('/a76/unit_conversions', data);
+	return response.data;
+}
+
+export async function updateUnitConversion(id: number, data: UnitConversionUpdate): Promise<UnitConversion> {
+	const response = await api.patch(`/a76/unit_conversions/${id}`, data);
+	return response.data;
+}
+
+export async function deleteUnitConversion(id: number): Promise<void> {
+	await api.delete(`/a76/unit_conversions/${id}`);
+}

frontend/src/lib/api/dashboard/a76/units-of-measure.ts

@@ -0,0 +1,158 @@
+import { api } from '$lib/api';
+import type { ApiResponse } from '$lib/api';
+
+// --- ACE ---
+export interface UnitOfMeasureACE {
+    id: number;
+    code: string;
+    description: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+
+export interface UnitOfMeasureACECreate {
+    code: string;
+    description?: string | null;
+}
+
+export interface UnitOfMeasureACEUpdate {
+    code?: string;
+    description?: string | null;
+}
+
+export interface UnitOfMeasureACEListResponse {
+    items: UnitOfMeasureACE[];
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+}
+
+export async function getUnitsOfMeasureACE(
+    page = 1,
+    pageSize = 50,
+    filters: Record<string, any> = {}
+): Promise<ApiResponse<UnitOfMeasureACEListResponse>> {
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        page_size: pageSize.toString(),
+        ...filters
+    });
+    return await api.get(`/a76/units-of-measure/ace?${queryParams.toString()}`);
+}
+
+export async function createUnitOfMeasureACE(data: UnitOfMeasureACECreate): Promise<ApiResponse<UnitOfMeasureACE>> {
+    return await api.post('/a76/units-of-measure/ace', data);
+}
+
+export async function updateUnitOfMeasureACE(id: number, data: UnitOfMeasureACEUpdate): Promise<ApiResponse<UnitOfMeasureACE>> {
+    return await api.put(`/a76/units-of-measure/ace/${id}`, data);
+}
+
+export async function deleteUnitOfMeasureACE(id: number): Promise<ApiResponse<void>> {
+    return await api.delete(`/a76/units-of-measure/ace/${id}`);
+}
+
+// --- OMA ---
+export interface UnitOfMeasureOMA {
+    id: number;
+    code: string;
+    description: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+
+export interface UnitOfMeasureOMACreate {
+    code: string;
+    description?: string | null;
+}
+
+export interface UnitOfMeasureOMAUpdate {
+    code?: string;
+    description?: string | null;
+}
+
+export interface UnitOfMeasureOMAListResponse {
+    items: UnitOfMeasureOMA[];
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+}
+
+export async function getUnitsOfMeasureOMA(
+    page = 1,
+    pageSize = 50,
+    filters: Record<string, any> = {}
+): Promise<ApiResponse<UnitOfMeasureOMAListResponse>> {
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        page_size: pageSize.toString(),
+        ...filters
+    });
+    return await api.get(`/a76/units-of-measure/oma?${queryParams.toString()}`);
+}
+
+export async function createUnitOfMeasureOMA(data: UnitOfMeasureOMACreate): Promise<ApiResponse<UnitOfMeasureOMA>> {
+    return await api.post('/a76/units-of-measure/oma', data);
+}
+
+export async function updateUnitOfMeasureOMA(id: number, data: UnitOfMeasureOMAUpdate): Promise<ApiResponse<UnitOfMeasureOMA>> {
+    return await api.put(`/a76/units-of-measure/oma/${id}`, data);
+}
+
+export async function deleteUnitOfMeasureOMA(id: number): Promise<ApiResponse<void>> {
+    return await api.delete(`/a76/units-of-measure/oma/${id}`);
+}
+
+// --- American ---
+export interface UnitOfMeasureAmerican {
+    id: number;
+    code: string;
+    description: string | null;
+    created_at: string | null;
+    updated_at: string | null;
+}
+
+export interface UnitOfMeasureAmericanCreate {
+    code: string;
+    description?: string | null;
+}
+
+export interface UnitOfMeasureAmericanUpdate {
+    code?: string;
+    description?: string | null;
+}
+
+export interface UnitOfMeasureAmericanListResponse {
+    items: UnitOfMeasureAmerican[];
+    total: number;
+    page: number;
+    page_size: number;
+    pages: number;
+}
+
+export async function getUnitsOfMeasureAmerican(
+    page = 1,
+    pageSize = 50,
+    filters: Record<string, any> = {}
+): Promise<ApiResponse<UnitOfMeasureAmericanListResponse>> {
+    const queryParams = new URLSearchParams({
+        page: page.toString(),
+        page_size: pageSize.toString(),
+        ...filters
+    });
+    return await api.get(`/a76/units-of-measure/american?${queryParams.toString()}`);
+}
+
+export async function createUnitOfMeasureAmerican(data: UnitOfMeasureAmericanCreate): Promise<ApiResponse<UnitOfMeasureAmerican>> {
+    return await api.post('/a76/units-of-measure/american', data);
+}
+
+export async function updateUnitOfMeasureAmerican(id: number, data: UnitOfMeasureAmericanUpdate): Promise<ApiResponse<UnitOfMeasureAmerican>> {
+    return await api.put(`/a76/units-of-measure/american/${id}`, data);
+}
+
+export async function deleteUnitOfMeasureAmerican(id: number): Promise<ApiResponse<void>> {
+    return await api.delete(`/a76/units-of-measure/american/${id}`);
+}

frontend/src/lib/components/dashboard/company/columns.ts

@@ -0,0 +1,38 @@
+import type { Company } from '$lib/api/dashboard/a76/company';
+import type { ColumnDef } from '@tanstack/table-core';
+import { renderComponent } from '$lib/components/ui/data-table';
+import DataTableActions from './data-table-actions.svelte';
+
+export function createColumns(onSuccess?: () => void): ColumnDef<Company>[] {
+    return [
+        {
+            accessorKey: 'name',
+            header: 'Nombre',
+            cell: ({ row }) => row.original.name || '-'
+        },
+        {
+            accessorKey: 'rfc',
+            header: 'RFC',
+            cell: ({ row }) => row.original.rfc || '-'
+        },
+        {
+            accessorKey: 'program',
+            header: 'Programa',
+            cell: ({ row }) => row.original.program || '-'
+        },
+        {
+            accessorKey: 'program_number',
+            header: 'No. Programa',
+            cell: ({ row }) => row.original.program_number || '-'
+        },
+        {
+            id: 'actions',
+            cell: ({ row }) => {
+                return renderComponent(DataTableActions, {
+                    item: row.original,
+                    onSuccess
+                });
+            }
+        }
+    ];
+}

frontend/src/lib/components/dashboard/company/create-edit-dialog.svelte

@@ -0,0 +1,127 @@
+<script lang="ts">
+    import { Button } from "$lib/components/ui/button";
+    import * as Dialog from "$lib/components/ui/dialog";
+    import { Input } from "$lib/components/ui/input";
+    import { Label } from "$lib/components/ui/label";
+    import { createCompany, updateCompany, type Company } from "$lib/api/dashboard/a76/company";
+
+    let {
+        open = $bindable(false),
+        item = null,
+        onSuccess
+    }: {
+        open: boolean;
+        item?: Company | null;
+        onSuccess?: () => void;
+    } = $props();
+
+    const isEdit = $derived(!!item);
+    const title = $derived(isEdit ? "Editar Empresa" : "Nueva Empresa");
+
+    let formData = $state({
+        name: item?.name || '',
+        rfc: item?.rfc || '',
+        main_activity: item?.main_activity || '',
+        program: item?.program || '',
+        program_number: item?.program_number || ''
+    });
+
+    let loading = $state(false);
+    let error = $state<string | null>(null);
+
+    $effect(() => {
+        if (item) {
+            formData = {
+                name: item.name || '',
+                rfc: item.rfc || '',
+                main_activity: item.main_activity || '',
+                program: item.program || '',
+                program_number: item.program_number || ''
+            };
+        } else {
+            formData = {
+                name: '',
+                rfc: '',
+                main_activity: '',
+                program: '',
+                program_number: ''
+            };
+        }
+    });
+
+    async function handleSubmit() {
+        error = null;
+        loading = true;
+
+        try {
+            if (!formData.name.trim()) throw new Error('El nombre es requerido');
+
+            const dataToSend = {
+                name: formData.name.trim(),
+                rfc: formData.rfc.trim() || null,
+                main_activity: formData.main_activity.trim() || null,
+                program: formData.program.trim() || null,
+                program_number: formData.program_number.trim() || null
+            };
+
+            let response;
+            if (isEdit && item) {
+                response = await updateCompany(item.id, dataToSend);
+            } else {
+                response = await createCompany(dataToSend);
+            }
+
+            if (response.error) {
+                throw new Error(response.error);
+            }
+
+            open = false;
+            if (onSuccess) onSuccess();
+        } catch (e) {
+            error = e instanceof Error ? e.message : 'Error al guardar';
+        } finally {
+            loading = false;
+        }
+    }
+</script>
+
+<Dialog.Root bind:open>
+    <Dialog.Content class="max-w-md">
+        <Dialog.Header>
+            <Dialog.Title>{title}</Dialog.Title>
+        </Dialog.Header>
+
+        <form onsubmit={(e) => { e.preventDefault(); handleSubmit(); }} class="space-y-4">
+            {#if error}
+                <div class="text-destructive text-sm">{error}</div>
+            {/if}
+
+            <div class="grid gap-2">
+                <Label for="name">Nombre <span class="text-destructive">*</span></Label>
+                <Input id="name" bind:value={formData.name} />
+            </div>
+
+            <div class="grid gap-2">
+                <Label for="rfc">RFC</Label>
+                <Input id="rfc" bind:value={formData.rfc} />
+            </div>
+
+            <div class="grid gap-2">
+                <Label for="program">Programa</Label>
+                <Input id="program" bind:value={formData.program} />
+            </div>
+
+            <div class="grid gap-2">
+                <Label for="program_number">No. Programa</Label>
+                <Input id="program_number" bind:value={formData.program_number} />
+            </div>
+
+            <Dialog.Footer>
+                <Button type="button" variant="outline" onclick={() => open = false}>Cancelar</Button>
+                <Button type="submit" disabled={loading}>
+                    {loading ? 'Guardando...' : 'Guardar'}
+                </Button>
+            </Dialog.Footer>
+        </form>
+    </Dialog.Content>
+</Dialog.Root>

frontend/src/lib/components/dashboard/company/data-table-actions.svelte

@@ -0,0 +1,78 @@
+<script lang="ts">
+    import { Button } from "$lib/components/ui/button";
+    import * as DropdownMenu from "$lib/components/ui/dropdown-menu";
+    import { deleteCompany, type Company } from "$lib/api/dashboard/a76/company";
+    import { EllipsisVertical, Pencil, LoaderCircle, Trash2 } from 'lucide-svelte';
+    import CreateEditDialog from "./create-edit-dialog.svelte";
+
+    let {
+        item,
+        onSuccess
+    }: {
+        item: Company;
+        onSuccess?: () => void;
+    } = $props();
+
+    let loading = $state(false);
+    let error = $state<string | null>(null);
+    let dialogOpen = $state(false);
+
+    async function handleDelete() {
+        if (!confirm(`¿Estás seguro de eliminar la empresa "${item.name}"?`)) {
+            return;
+        }
+
+        loading = true;
+        error = null;
+
+        try {
+            const response = await deleteCompany(item.id);
+
+            if (response.error) {
+                alert(`Error al eliminar: ${response.error}`);
+                return;
+            }
+
+            if (onSuccess) {
+                onSuccess();
+            }
+        } catch (e) {
+            alert('Error al eliminar el registro');
+        } finally {
+            loading = false;
+        }
+    }
+</script>
+
+<DropdownMenu.Root>
+    <DropdownMenu.Trigger>
+        {#snippet child({ props })}
+            <Button {...props} variant="ghost" size="icon" class="h-8 w-8 p-0">
+                <span class="sr-only">Abrir menú</span>
+                <EllipsisVertical class="h-4 w-4" />
+            </Button>
+        {/snippet}
+    </DropdownMenu.Trigger>
+    <DropdownMenu.Content align="end">
+        <DropdownMenu.Label>Acciones</DropdownMenu.Label>
+        <DropdownMenu.Item onclick={() => dialogOpen = true}>
+            <Pencil class="mr-2 h-4 w-4" />
+            Editar
+        </DropdownMenu.Item>
+        <DropdownMenu.Separator />
+        <DropdownMenu.Item class="text-destructive focus:text-destructive" onclick={handleDelete} disabled={loading}>
+            {#if loading}
+                <LoaderCircle class="mr-2 h-4 w-4 animate-spin" />
+            {:else}
+                <Trash2 class="mr-2 h-4 w-4" />
+            {/if}
+            Eliminar
+        </DropdownMenu.Item>
+    </DropdownMenu.Content>
+</DropdownMenu.Root>
+
+<CreateEditDialog 
+    bind:open={dialogOpen} 
+    item={item} 
+    onSuccess={onSuccess}
+/>

frontend/src/lib/components/dashboard/general_catalogs/simple-data-table.svelte

@@ -0,0 +1,93 @@
+<script lang="ts" generics="T extends Record<string, any>">
+	import * as Table from "$lib/components/ui/table/index.js";
+    import { Button } from "$lib/components/ui/button";
+    import { goto } from "$app/navigation";
+    import { page } from "$app/stores";
+
+	type Column = {
+		key: string;
+		label: string;
+		format?: (value: any, row: T) => string;
+	};
+
+	type SimpleDataTableProps<T> = {
+		columns: Column[];
+		data: T[];
+        pageCount: number;
+        totalItems: number;
+	};
+
+	let {
+		data,
+		columns,
+        pageCount,
+        totalItems
+	}: SimpleDataTableProps<T> = $props();
+
+    function handlePageChange(newPage: number) {
+        const url = new URL($page.url);
+        url.searchParams.set('page', newPage.toString());
+        goto(url);
+    }
+
+	function getCellValue(row: T, column: Column): string {
+		const value = row[column.key];
+		if (column.format) {
+			return column.format(value, row);
+		}
+		return value !== null && value !== undefined ? String(value) : '-';
+	}
+</script>
+
+<div class="rounded-md border">
+	<Table.Root>
+		<Table.Header>
+			<Table.Row>
+				{#each columns as column (column.key)}
+					<Table.Head>{column.label}</Table.Head>
+				{/each}
+			</Table.Row>
+		</Table.Header>
+		<Table.Body>
+			{#each data as row, i (i)}
+				<Table.Row>
+					{#each columns as column (column.key)}
+						<Table.Cell>
+							{getCellValue(row, column)}
+						</Table.Cell>
+					{/each}
+				</Table.Row>
+			{:else}
+				<Table.Row>
+					<Table.Cell colspan={columns.length} class="h-24 text-center">
+						No hay resultados.
+					</Table.Cell>
+				</Table.Row>
+			{/each}
+		</Table.Body>
+	</Table.Root>
+</div>
+
+<div class="flex items-center justify-end space-x-2 py-4">
+    <div class="flex-1 text-sm text-muted-foreground">
+        Total: {totalItems}
+    </div>
+    <div class="space-x-2">
+        <Button
+            variant="outline"
+            size="sm"
+            onclick={() => handlePageChange(Number($page.url.searchParams.get('page') || 1) - 1)}
+            disabled={Number($page.url.searchParams.get('page') || 1) <= 1}
+        >
+            Anterior
+        </Button>
+        <Button
+            variant="outline"
+            size="sm"
+            onclick={() => handlePageChange(Number($page.url.searchParams.get('page') || 1) + 1)}
+            disabled={Number($page.url.searchParams.get('page') || 1) >= pageCount}
+        >
+            Siguiente
+        </Button>
+    </div>
+</div>

frontend/src/lib/components/dashboard/identifiers/columns.ts

@@ -0,0 +1,37 @@
+import type { Identifier } from '$lib/api/dashboard/a76/identifiers';
+import type { ColumnDef } from '@tanstack/table-core';
+import { renderComponent } from '$lib/components/ui/data-table';
+import DataTableActions from './data-table-actions.svelte';
+
+export function createColumns(onSuccess?: () => void): ColumnDef<Identifier>[] {
+    return [
+        {
+            accessorKey: 'code',
+            header: 'Clave',
+        },
+        {
+            accessorKey: 'description',
+            header: 'Descripción',
+            cell: ({ row }) => row.original.description || '-'
+        },
+        {
+            accessorKey: 'level',
+            header: 'Nivel',
+            cell: ({ row }) => row.original.level || '-'
+        },
+        {
+            accessorKey: 'complement',
+            header: 'Complemento',
+            cell: ({ row }) => row.original.complement || '-'
+        },
+        {
+            id: 'actions',
+            cell: ({ row }) => {
+                return renderComponent(DataTableActions, {
+                    item: row.original,
+                    onSuccess
+                });
+            }
+        }
+    ];
+}

frontend/src/lib/components/dashboard/identifiers/create-edit-dialog.svelte

@@ -0,0 +1,139 @@
+<script lang="ts">
+	import { Button } from "$lib/components/ui/button";
+	import * as Dialog from "$lib/components/ui/dialog";
+	import { Input } from "$lib/components/ui/input";
+	import { Label } from "$lib/components/ui/label";
+    import { Textarea } from "$lib/components/ui/textarea";
+	import { createIdentifier, updateIdentifier, type Identifier } from "$lib/api/dashboard/a76/identifiers";
+    import { companyStore } from "$lib/stores/company.svelte";
+
+	let {
+		open = $bindable(false),
+		mode = 'create',
+		item = null,
+		onSuccess
+	}: {
+		open: boolean;
+		mode?: 'create' | 'edit';
+		item?: Identifier | null;
+		onSuccess?: () => void;
+	} = $props();
+
+	const isEdit = $derived(mode === 'edit');
+	const title = $derived(isEdit ? "Editar Identificador" : "Nuevo Identificador");
+
+	let formData = $state({
+		code: '',
+		description: '',
+        level: '',
+        complement: ''
+	});
+
+	let loading = $state(false);
+	let error = $state<string | null>(null);
+
+	$effect(() => {
+		if (open) {
+			if (isEdit && item) {
+				formData = {
+					code: item.code,
+					description: item.description || '',
+                    level: item.level || '',
+                    complement: item.complement || ''
+				};
+			} else {
+				formData = {
+					code: '',
+					description: '',
+                    level: '',
+                    complement: ''
+				};
+			}
+			error = null;
+		}
+	});
+
+	async function handleSubmit() {
+        const companyId = companyStore.activeCompany?.id;
+        if (!companyId) {
+            error = 'No hay compañía seleccionada';
+            return;
+        }
+
+		loading = true;
+		error = null;
+
+		try {
+			let response;
+			if (isEdit && item) {
+				response = await updateIdentifier(item.id, {
+					code: formData.code,
+					description: formData.description || null,
+                    level: formData.level || null,
+                    complement: formData.complement || null
+				});
+			} else {
+				response = await createIdentifier({
+					code: formData.code,
+					description: formData.description || null,
+                    level: formData.level || null,
+                    complement: formData.complement || null,
+                    company_id: companyId
+				});
+			}
+
+			if (response.error) {
+				error = response.error;
+				return;
+			}
+
+			open = false;
+			if (onSuccess) onSuccess();
+		} catch (e) {
+			error = 'Error de conexión';
+			console.error(e);
+		} finally {
+			loading = false;
+		}
+	}
+</script>
+
+<Dialog.Root bind:open>
+	<Dialog.Content class="sm:max-w-[425px]">
+		<Dialog.Header>
+			<Dialog.Title>{title}</Dialog.Title>
+		</Dialog.Header>
+		
+		<div class="grid gap-4 py-4">
+			{#if error}
+				<div class="text-red-500 text-sm mb-2">{error}</div>
+			{/if}
+			
+			<div class="grid grid-cols-4 items-center gap-4">
+				<Label for="code" class="text-right">Clave</Label>
+				<Input id="code" bind:value={formData.code} class="col-span-3" disabled={loading} />
+			</div>
+			
+			<div class="grid grid-cols-4 items-center gap-4">
+				<Label for="description" class="text-right">Descripción</Label>
+				<Textarea id="description" bind:value={formData.description} class="col-span-3" disabled={loading} />
+			</div>
+
+            <div class="grid grid-cols-4 items-center gap-4">
+				<Label for="level" class="text-right">Nivel</Label>
+				<Input id="level" bind:value={formData.level} class="col-span-3" disabled={loading} />
+			</div>
+
+            <div class="grid grid-cols-4 items-center gap-4">
+				<Label for="complement" class="text-right">Complemento</Label>
+				<Textarea id="complement" bind:value={formData.complement} class="col-span-3" disabled={loading} />
+			</div>
+		</div>
+
+		<Dialog.Footer>
+			<Button type="submit" onclick={handleSubmit} disabled={loading}>
+				{loading ? 'Guardando...' : 'Guardar'}
+			</Button>
+		</Dialog.Footer>
+	</Dialog.Content>
+</Dialog.Root>

frontend/src/lib/components/dashboard/identifiers/data-table-actions.svelte

@@ -0,0 +1,79 @@
+<script lang="ts">
+	import { Button } from "$lib/components/ui/button";
+	import * as DropdownMenu from "$lib/components/ui/dropdown-menu";
+	import { deleteIdentifier, type Identifier } from "$lib/api/dashboard/a76/identifiers";
+	import { EllipsisVertical, Pencil, LoaderCircle, Trash2 } from 'lucide-svelte';
+	import CreateEditDialog from "./create-edit-dialog.svelte";
+
+	let {
+		item,
+		onSuccess
+	}: {
+		item: Identifier;
+		onSuccess?: () => void;
+	} = $props();
+
+	let loading = $state(false);
+	let error = $state<string | null>(null);
+	let dialogOpen = $state(false);
+
+	async function handleDelete() {
+		if (!confirm(`¿Estás seguro de eliminar el identificador "${item.code}"?`)) {
+			return;
+		}
+
+		loading = true;
+		error = null;
+
+		try {
+			const response = await deleteIdentifier(item.id);
+
+			if (response.error) {
+                error = response.error;
+                alert(`Error al eliminar: ${response.error}`);
+				return;
+			}
+
+			if (onSuccess) onSuccess();
+		} catch (e) {
+			error = 'Error de conexión';
+			console.error(e);
+            alert('Error de conexión al eliminar');
+		} finally {
+			loading = false;
+		}
+	}
+</script>
+
+<DropdownMenu.Root>
+	<DropdownMenu.Trigger>
+		{#snippet child({ props })}
+			<Button {...props} variant="ghost" size="icon" class="h-8 w-8 p-0">
+				<span class="sr-only">Abrir menú</span>
+				<EllipsisVertical class="h-4 w-4" />
+			</Button>
+		{/snippet}
+	</DropdownMenu.Trigger>
+	<DropdownMenu.Content align="end">
+		<DropdownMenu.Label>Acciones</DropdownMenu.Label>
+		<DropdownMenu.Item onclick={() => dialogOpen = true}>
+			<Pencil class="mr-2 h-4 w-4" />
+			Editar
+		</DropdownMenu.Item>
+		<DropdownMenu.Item onclick={handleDelete} class="text-red-600">
+			{#if loading}
+				<LoaderCircle class="mr-2 h-4 w-4 animate-spin" />
+			{:else}
+				<Trash2 class="mr-2 h-4 w-4" />
+			{/if}
+			Eliminar
+		</DropdownMenu.Item>
+	</DropdownMenu.Content>
+</DropdownMenu.Root>
+
+<CreateEditDialog 
+	bind:open={dialogOpen} 
+	mode="edit" 
+	{item} 
+	{onSuccess} 
+/>

frontend/src/lib/components/dashboard/identifiers/data-table.svelte

@@ -0,0 +1,106 @@
+<script lang="ts" generics="TData, TValue">
+	import {
+		type ColumnDef,
+		getCoreRowModel,
+	} from "@tanstack/table-core";
+	import { createSvelteTable, FlexRender } from "$lib/components/ui/data-table/index.js";
+	import * as Table from "$lib/components/ui/table/index.js";
+    import { Button } from "$lib/components/ui/button";
+    import { goto } from "$app/navigation";
+    import { page } from "$app/stores";
+
+	type DataTableProps<TData, TValue> = {
+		columns: ColumnDef<TData, TValue>[];
+		data: TData[];
+        pageCount: number;
+        totalItems: number;
+	};
+
+	let {
+		data,
+		columns,
+        pageCount,
+        totalItems
+	}: DataTableProps<TData, TValue> = $props();
+
+	const table = createSvelteTable({
+		get data() {
+			return data;
+		},
+		columns,
+		getCoreRowModel: getCoreRowModel(),
+        manualPagination: true,
+        pageCount: pageCount,
+	});
+
+    function handlePageChange(newPage: number) {
+        const url = new URL($page.url);
+        url.searchParams.set('page', newPage.toString());
+        goto(url);
+    }
+</script>
+
+<div class="rounded-md border">
+	<Table.Root>
+		<Table.Header>
+			{#each table.getHeaderGroups() as headerGroup (headerGroup.id)}
+				<Table.Row>
+					{#each headerGroup.headers as header (header.id)}
+						<Table.Head>
+							{#if !header.isPlaceholder}
+								<FlexRender
+									content={header.column.columnDef.header}
+									context={header.getContext()}
+								/>
+							{/if}
+						</Table.Head>
+					{/each}
+				</Table.Row>
+			{/each}
+		</Table.Header>
+		<Table.Body>
+			{#each table.getRowModel().rows as row (row.id)}
+				<Table.Row data-state={row.getIsSelected() && "selected"}>
+					{#each row.getVisibleCells() as cell (cell.id)}
+						<Table.Cell>
+							<FlexRender
+								content={cell.column.columnDef.cell}
+								context={cell.getContext()}
+							/>
+						</Table.Cell>
+					{/each}
+				</Table.Row>
+			{:else}
+				<Table.Row>
+					<Table.Cell colspan={columns.length} class="h-24 text-center">
+						No hay resultados.
+					</Table.Cell>
+				</Table.Row>
+			{/each}
+		</Table.Body>
+	</Table.Root>
+</div>
+
+<div class="flex items-center justify-end space-x-2 py-4">
+    <div class="flex-1 text-sm text-muted-foreground">
+        Total: {totalItems}
+    </div>
+    <div class="space-x-2">
+        <Button
+            variant="outline"
+            size="sm"
+            onclick={() => handlePageChange(Number($page.url.searchParams.get('page') || 1) - 1)}
+            disabled={Number($page.url.searchParams.get('page') || 1) <= 1}
+        >
+            Anterior
+        </Button>
+        <Button
+            variant="outline"
+            size="sm"
+            onclick={() => handlePageChange(Number($page.url.searchParams.get('page') || 1) + 1)}
+            disabled={Number($page.url.searchParams.get('page') || 1) >= pageCount}
+        >
+            Siguiente
+        </Button>
+    </div>
+</div>

frontend/src/lib/components/dashboard/packages/create-edit-dialog.svelte

@@ -95,9 +95,9 @@
 
 			let response;
 			if (isEdit && item) {
-				response = await updatePackage(item.id, dataToSend as PackageUpdate, companyId);
+				response = await updatePackage(item.id, dataToSend);
 			} else {
-				response = await createPackage(dataToSend as PackageCreate, companyId);
+				response = await createPackage({ ...dataToSend, company_id: companyId });
 			}
 
 			if (response.error) {

frontend/src/lib/components/dashboard/packages/data-table-actions.svelte

@@ -7,10 +7,10 @@
 	import CreateEditDialog from "./create-edit-dialog.svelte";
 
 	let {
-		package: item,
+		item,
 		onSuccess
 	}: {
-		package: Package;
+		item: Package;
 		onSuccess?: () => void;
 	} = $props();
 
@@ -24,17 +24,11 @@
 			return;
 		}
 
-		const companyId = companyStore.activeCompany?.id;
-		if (!companyId) {
-			alert('No hay compañía seleccionada');
-			return;
-		}
-
 		loading = true;
 		error = null;
 
 		try {
-			const response = await deletePackage(item.id, companyId);
+			const response = await deletePackage(item.id);
 
 			if (response.error) {
 				if (response.status === 401) {

frontend/src/lib/components/dashboard/ports/columns.ts

@@ -0,0 +1,47 @@
+import type { Port } from '$lib/api/dashboard/a76/ports';
+import type { ColumnDef } from '@tanstack/table-core';
+import { renderComponent } from '$lib/components/ui/data-table';
+import DataTableActions from './data-table-actions.svelte';
+
+export function createColumns(onSuccess?: () => void): ColumnDef<Port>[] {
+    return [
+        {
+            accessorKey: 'port_code',
+            header: 'Código Puerto',
+        },
+        {
+            accessorKey: 'description',
+            header: 'Descripción',
+            cell: ({ row }) => row.original.description || '-'
+        },
+        {
+            accessorKey: 'location_code',
+            header: 'Código Ubicación',
+        },
+        {
+            accessorKey: 'location_description',
+            header: 'Ubicación',
+            cell: ({ row }) => row.original.location_description || '-'
+        },
+        {
+            accessorKey: 'port_type',
+            header: 'Tipo',
+            cell: ({ row }) => {
+                const type = row.original.port_type;
+                if (type === 'ENTRY') return 'Entrada';
+                if (type === 'EXIT') return 'Salida';
+                if (type === 'BOTH') return 'Ambos';
+                return type;
+            }
+        },
+        {
+            id: 'actions',
+            cell: ({ row }) => {
+                return renderComponent(DataTableActions, {
+                    item: row.original,
+                    onSuccess
+                });
+            }
+        }
+    ];
+}

frontend/src/lib/components/dashboard/ports/create-edit-dialog.svelte

@@ -0,0 +1,154 @@
+<script lang="ts">
+	import { Button } from "$lib/components/ui/button";
+	import * as Dialog from "$lib/components/ui/dialog";
+	import { Input } from "$lib/components/ui/input";
+	import { Label } from "$lib/components/ui/label";
+    import * as Select from "$lib/components/ui/select";
+	import { createPort, updatePort, type Port, PortType } from "$lib/api/dashboard/a76/ports";
+
+	let {
+		open = $bindable(false),
+		mode = 'create',
+		item = null,
+		onSuccess
+	}: {
+		open: boolean;
+		mode?: 'create' | 'edit';
+		item?: Port | null;
+		onSuccess?: () => void;
+	} = $props();
+
+	const isEdit = $derived(mode === 'edit');
+	const title = $derived(isEdit ? "Editar Puerto" : "Nuevo Puerto");
+
+	let formData = $state({
+		port_code: '',
+		description: '',
+        location_code: '',
+        location_description: '',
+        port_type: PortType.ENTRY
+	});
+
+	let loading = $state(false);
+	let error = $state<string | null>(null);
+
+	$effect(() => {
+		if (open) {
+			if (isEdit && item) {
+				formData = {
+					port_code: item.port_code,
+					description: item.description || '',
+                    location_code: item.location_code,
+                    location_description: item.location_description || '',
+                    port_type: item.port_type
+				};
+			} else {
+				formData = {
+					port_code: '',
+					description: '',
+                    location_code: '',
+                    location_description: '',
+                    port_type: PortType.ENTRY
+				};
+			}
+			error = null;
+		}
+	});
+
+	async function handleSubmit() {
+		loading = true;
+		error = null;
+
+		try {
+			let response;
+			if (isEdit && item) {
+				response = await updatePort(item.id, {
+					port_code: formData.port_code,
+					description: formData.description || null,
+                    location_code: formData.location_code,
+                    location_description: formData.location_description || null,
+                    port_type: formData.port_type
+				});
+			} else {
+				response = await createPort({
+					port_code: formData.port_code,
+					description: formData.description || null,
+                    location_code: formData.location_code,
+                    location_description: formData.location_description || null,
+                    port_type: formData.port_type
+				});
+			}
+
+			if (response.error) {
+				error = response.error;
+				return;
+			}
+
+			open = false;
+			if (onSuccess) onSuccess();
+		} catch (e) {
+			error = 'Error de conexión';
+			console.error(e);
+		} finally {
+			loading = false;
+		}
+	}
+</script>
+
+<Dialog.Root bind:open>
+	<Dialog.Content class="sm:max-w-[425px]">
+		<Dialog.Header>
+			<Dialog.Title>{title}</Dialog.Title>
+		</Dialog.Header>
+		
+		<div class="grid gap-4 py-4">
+			{#if error}
+				<div class="text-red-500 text-sm mb-2">{error}</div>
+			{/if}
+			
+			<div class="grid grid-cols-4 items-center gap-4">
+				<Label for="port_code" class="text-right">Código Puerto</Label>
+				<Input id="port_code" bind:value={formData.port_code} class="col-span-3" disabled={loading} />
+			</div>
+			
+			<div class="grid grid-cols-4 items-center gap-4">
+				<Label for="description" class="text-right">Descripción</Label>
+				<Input id="description" bind:value={formData.description} class="col-span-3" disabled={loading} />
+			</div>
+
+            <div class="grid grid-cols-4 items-center gap-4">
+				<Label for="location_code" class="text-right">Código Ubicación</Label>
+				<Input id="location_code" bind:value={formData.location_code} class="col-span-3" disabled={loading} />
+			</div>
+
+            <div class="grid grid-cols-4 items-center gap-4">
+				<Label for="location_description" class="text-right">Ubicación</Label>
+				<Input id="location_description" bind:value={formData.location_description} class="col-span-3" disabled={loading} />
+			</div>
+
+            <div class="grid grid-cols-4 items-center gap-4">
+                <Label for="port_type" class="text-right">Tipo</Label>
+                <div class="col-span-3">
+                    <Select.Root type="single" bind:value={formData.port_type}>
+                        <Select.Trigger>
+                            {formData.port_type === 'ENTRY' ? 'Entrada' : 
+                             formData.port_type === 'EXIT' ? 'Salida' : 
+                             formData.port_type === 'BOTH' ? 'Ambos' : 'Seleccionar'}
+                        </Select.Trigger>
+                        <Select.Content>
+                            <Select.Item value="ENTRY">Entrada</Select.Item>
+                            <Select.Item value="EXIT">Salida</Select.Item>
+                            <Select.Item value="BOTH">Ambos</Select.Item>
+                        </Select.Content>
+                    </Select.Root>
+                </div>
+            </div>
+		</div>
+
+		<Dialog.Footer>
+			<Button type="submit" onclick={handleSubmit} disabled={loading}>
+				{loading ? 'Guardando...' : 'Guardar'}
+			</Button>
+		</Dialog.Footer>
+	</Dialog.Content>
+</Dialog.Root>

frontend/src/lib/components/dashboard/ports/data-table-actions.svelte

@@ -0,0 +1,79 @@
+<script lang="ts">
+	import { Button } from "$lib/components/ui/button";
+	import * as DropdownMenu from "$lib/components/ui/dropdown-menu";
+	import { deletePort, type Port } from "$lib/api/dashboard/a76/ports";
+	import { EllipsisVertical, Pencil, LoaderCircle, Trash2 } from 'lucide-svelte';
+	import CreateEditDialog from "./create-edit-dialog.svelte";
+
+	let {
+		item,
+		onSuccess
+	}: {
+		item: Port;
+		onSuccess?: () => void;
+	} = $props();
+
+	let loading = $state(false);
+	let error = $state<string | null>(null);
+	let dialogOpen = $state(false);
+
+	async function handleDelete() {
+		if (!confirm(`¿Estás seguro de eliminar el puerto "${item.port_code}"?`)) {
+			return;
+		}
+
+		loading = true;
+		error = null;
+
+		try {
+			const response = await deletePort(item.id);
+
+			if (response.error) {
+                error = response.error;
+                alert(`Error al eliminar: ${response.error}`);
+				return;
+			}
+
+			if (onSuccess) onSuccess();
+		} catch (e) {
+			error = 'Error de conexión';
+			console.error(e);
+            alert('Error de conexión al eliminar');
+		} finally {
+			loading = false;
+		}
+	}
+</script>
+
+<DropdownMenu.Root>
+	<DropdownMenu.Trigger>
+		{#snippet child({ props })}
+			<Button {...props} variant="ghost" size="icon" class="h-8 w-8 p-0">
+				<span class="sr-only">Abrir menú</span>
+				<EllipsisVertical class="h-4 w-4" />
+			</Button>
+		{/snippet}
+	</DropdownMenu.Trigger>
+	<DropdownMenu.Content align="end">
+		<DropdownMenu.Label>Acciones</DropdownMenu.Label>
+		<DropdownMenu.Item onclick={() => dialogOpen = true}>
+			<Pencil class="mr-2 h-4 w-4" />
+			Editar
+		</DropdownMenu.Item>
+		<DropdownMenu.Item onclick={handleDelete} class="text-red-600">
+			{#if loading}
+				<LoaderCircle class="mr-2 h-4 w-4 animate-spin" />
+			{:else}
+				<Trash2 class="mr-2 h-4 w-4" />
+			{/if}
+			Eliminar
+		</DropdownMenu.Item>
+	</DropdownMenu.Content>
+</DropdownMenu.Root>
+
+<CreateEditDialog 
+	bind:open={dialogOpen} 
+	mode="edit" 
+	{item} 
+	{onSuccess} 
+/>