Creacion de CRUDs

se crearon los cruds de los catalogos que se encuentran en
public/reference_data
No se agrego autenticacion de los endpoints

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

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class CodePedimentoRegimenDTO(BaseModel):
+    id: int
+    pedimento_code: str = Field(..., min_length=1, max_length=3)
+    regimen_code: Optional[str] = Field(None, min_length=1, max_length=3)
+    type_code: Optional[str] = Field(None, min_length=1, max_length=1)
+
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import CodePedimentoRegimen
+from .dto import CodePedimentoRegimenDTO
+
+router = APIRouter(prefix="/code-pedimento-regimens", tags=["Code Pedimento Regimens"])
+
+@router.get("/", response_model=list[CodePedimentoRegimenDTO])
+def list_code_pedimento_regimens(db: Session = Depends(get_core_db)):
+    objs = db.query(CodePedimentoRegimen).all()
+    return [CodePedimentoRegimenDTO.model_validate(obj) for obj in objs]
+
+@router.get("/{id}", response_model=CodePedimentoRegimenDTO)
+def get_code_pedimento_regimen(id: int, db: Session = Depends(get_core_db)):
+    obj = db.query(CodePedimentoRegimen).filter(CodePedimentoRegimen.id == id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return CodePedimentoRegimenDTO.model_validate(obj)
+
+@router.post("/", response_model=CodePedimentoRegimenDTO, status_code=201)
+def create_code_pedimento_regimen(data: CodePedimentoRegimenDTO, db: Session = Depends(get_core_db)):
+    obj = CodePedimentoRegimen(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return CodePedimentoRegimenDTO.model_validate(obj)
+
+@router.put("/{id}", response_model=CodePedimentoRegimenDTO)
+def update_code_pedimento_regimen(id: int, data: CodePedimentoRegimenDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(CodePedimentoRegimen).filter(CodePedimentoRegimen.id == id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.model_dump().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return CodePedimentoRegimenDTO.model_validate(obj)
+
+@router.delete("/{id}", status_code=204)
+def delete_code_pedimento_regimen(id: int, db: Session = Depends(get_core_db)):
+    obj = db.query(CodePedimentoRegimen).filter(CodePedimentoRegimen.id == id).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class ContainerDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=3)
+    description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import Container
+from .dto import ContainerDTO
+
+router = APIRouter(prefix="/containers", tags=["Containers"])
+
+@router.get("/", response_model=list[ContainerDTO])
+def list_containers(db: Session = Depends(get_core_db)):
+    return db.query(Container).all()
+
+@router.get("/{key}", response_model=ContainerDTO)
+def get_container(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Container).filter(Container.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=ContainerDTO, status_code=201)
+def create_container(data: ContainerDTO, db: Session = Depends(get_core_db)):
+    obj = Container(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}", response_model=ContainerDTO)
+def update_container(key: str, data: ContainerDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(Container).filter(Container.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}", status_code=204)
+def delete_container(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Container).filter(Container.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+class CountryDTO(BaseModel):
+    m3_key: str = Field(..., min_length=1, max_length=3)
+    mex_key: str = Field(..., min_length=1, max_length=2)
+    ame_key: str = Field(..., min_length=1, max_length=2)
+    description_es: str
+    description_en: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import Country
+from .dto import CountryDTO
+
+router = APIRouter(prefix="/countries", tags=["Countries"])
+
+@router.get("/", response_model=list[CountryDTO])
+def list_countries(db: Session = Depends(get_core_db)):
+    return db.query(Country).all()
+
+@router.get("/{m3_key}", response_model=CountryDTO)
+def get_country(m3_key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Country).filter(Country.m3_key == m3_key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=CountryDTO, status_code=201)
+def create_country(data: CountryDTO, db: Session = Depends(get_core_db)):
+    obj = Country(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{m3_key}", response_model=CountryDTO)
+def update_country(m3_key: str, data: CountryDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(Country).filter(Country.m3_key == m3_key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{m3_key}", status_code=204)
+def delete_country(m3_key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Country).filter(Country.m3_key == m3_key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+class CurrencyTypeDTO(BaseModel):
+    code: str = Field(..., min_length=1, max_length=3)
+    currency_name: str
+    country_description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import CurrencyType
+from .dto import CurrencyTypeDTO
+
+router = APIRouter(prefix="/currency-types", tags=["Currency Types"])
+
+@router.get("/", response_model=list[CurrencyTypeDTO])
+def list_currency_types(db: Session = Depends(get_core_db)):
+    return db.query(CurrencyType).all()
+
+@router.get("/{code}", response_model=CurrencyTypeDTO)
+def get_currency_type(code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(CurrencyType).filter(CurrencyType.code == code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=CurrencyTypeDTO, status_code=201)
+def create_currency_type(data: CurrencyTypeDTO, db: Session = Depends(get_core_db)):
+    obj = CurrencyType(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{code}", response_model=CurrencyTypeDTO)
+def update_currency_type(code: str, data: CurrencyTypeDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(CurrencyType).filter(CurrencyType.code == code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{code}", status_code=204)
+def delete_currency_type(code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(CurrencyType).filter(CurrencyType.code == code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class CustomsSectionDTO(BaseModel):
+    customs_code: str = Field(..., min_length=1, max_length=3)
+    section_name: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import CustomsSection
+from .dto import CustomsSectionDTO
+
+router = APIRouter(prefix="/customs-sections", tags=["Customs Sections"])
+
+@router.get("/", response_model=list[CustomsSectionDTO])
+def list_customs_sections(db: Session = Depends(get_core_db)):
+    return db.query(CustomsSection).all()
+
+@router.get("/{customs_code}", response_model=CustomsSectionDTO)
+def get_customs_section(customs_code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(CustomsSection).filter(CustomsSection.customs_code == customs_code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=CustomsSectionDTO, status_code=201)
+def create_customs_section(data: CustomsSectionDTO, db: Session = Depends(get_core_db)):
+    obj = CustomsSection(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{customs_code}", response_model=CustomsSectionDTO)
+def update_customs_section(customs_code: str, data: CustomsSectionDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(CustomsSection).filter(CustomsSection.customs_code == customs_code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{customs_code}", status_code=204)
+def delete_customs_section(customs_code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(CustomsSection).filter(CustomsSection.customs_code == customs_code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+class CustomsWarehouseDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=3)
+    customs: str
+    fiscalized_warehouse: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import CustomsWarehouse
+from .dto import CustomsWarehouseDTO
+
+router = APIRouter(prefix="/customs-warehouses", tags=["Customs Warehouses"])
+
+@router.get("/", response_model=list[CustomsWarehouseDTO])
+def list_customs_warehouses(db: Session = Depends(get_core_db)):
+    return db.query(CustomsWarehouse).all()
+
+@router.get("/{key}/{customs}", response_model=CustomsWarehouseDTO)
+def get_customs_warehouse(key: str, customs: str, db: Session = Depends(get_core_db)):
+    obj = db.query(CustomsWarehouse).filter(CustomsWarehouse.key == key, CustomsWarehouse.customs == customs).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=CustomsWarehouseDTO, status_code=201)
+def create_customs_warehouse(data: CustomsWarehouseDTO, db: Session = Depends(get_core_db)):
+    obj = CustomsWarehouse(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}/{customs}", response_model=CustomsWarehouseDTO)
+def update_customs_warehouse(key: str, customs: str, data: CustomsWarehouseDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(CustomsWarehouse).filter(CustomsWarehouse.key == key, CustomsWarehouse.customs == customs).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}/{customs}", status_code=204)
+def delete_customs_warehouse(key: str, customs: str, db: Session = Depends(get_core_db)):
+    obj = db.query(CustomsWarehouse).filter(CustomsWarehouse.key == key, CustomsWarehouse.customs == customs).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class IncotermDTO(BaseModel):
+    code: str = Field(..., min_length=1, max_length=5)
+    description_es: str
+    description_en: str
+
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import Incoterm
+from .dto import IncotermDTO
+
+router = APIRouter(prefix="/incoterms", tags=["Incoterms"])
+
+@router.get("/", response_model=list[IncotermDTO])
+def list_incoterms(db: Session = Depends(get_core_db)):
+    objs = db.query(Incoterm).all()
+    return [IncotermDTO.model_validate(obj) for obj in objs]
+
+@router.get("/{key}", response_model=IncotermDTO)
+def get_incoterm(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Incoterm).filter(Incoterm.code == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return IncotermDTO.model_validate(obj)
+
+@router.post("/", response_model=IncotermDTO, status_code=201)
+def create_incoterm(data: IncotermDTO, db: Session = Depends(get_core_db)):
+    obj = Incoterm(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return IncotermDTO.model_validate(obj)
+
+@router.put("/{key}", response_model=IncotermDTO)
+def update_incoterm(key: str, data: IncotermDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(Incoterm).filter(Incoterm.code == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.model_dump().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return IncotermDTO.model_validate(obj)
+
+@router.delete("/{key}", status_code=204)
+def delete_incoterm(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Incoterm).filter(Incoterm.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,11 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class InvoiceTypeDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=5)
+    description: str
+    note: Optional[str] = None
+    type: Optional[str] = None
+
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import InvoiceType
+from .dto import InvoiceTypeDTO
+
+router = APIRouter(prefix="/invoice-types", tags=["Invoice Types"])
+
+@router.get("/", response_model=list[InvoiceTypeDTO])
+def list_invoice_types(db: Session = Depends(get_core_db)):
+    objs = db.query(InvoiceType).all()
+    return [InvoiceTypeDTO.model_validate(obj) for obj in objs]
+
+@router.get("/{key}", response_model=InvoiceTypeDTO)
+def get_invoice_type(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(InvoiceType).filter(InvoiceType.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return InvoiceTypeDTO.model_validate(obj)
+
+@router.post("/", response_model=InvoiceTypeDTO, status_code=201)
+def create_invoice_type(data: InvoiceTypeDTO, db: Session = Depends(get_core_db)):
+    obj = InvoiceType(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return InvoiceTypeDTO.model_validate(obj)
+
+@router.put("/{key}", response_model=InvoiceTypeDTO)
+def update_invoice_type(key: str, data: InvoiceTypeDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(InvoiceType).filter(InvoiceType.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.model_dump().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return InvoiceTypeDTO.model_validate(obj)
+
+@router.delete("/{key}", status_code=204)
+def delete_invoice_type(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(InvoiceType).filter(InvoiceType.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+class MaterialTypeDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=10)
+    type: str = Field(..., min_length=1, max_length=15)
+    description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import MaterialType
+from .dto import MaterialTypeDTO
+
+router = APIRouter(prefix="/material-types", tags=["Material Types"])
+
+@router.get("/", response_model=list[MaterialTypeDTO])
+def list_material_types(db: Session = Depends(get_core_db)):
+    return db.query(MaterialType).all()
+
+@router.get("/{key}", response_model=MaterialTypeDTO)
+def get_material_type(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(MaterialType).filter(MaterialType.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=MaterialTypeDTO, status_code=201)
+def create_material_type(data: MaterialTypeDTO, db: Session = Depends(get_core_db)):
+    obj = MaterialType(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}", response_model=MaterialTypeDTO)
+def update_material_type(key: str, data: MaterialTypeDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(MaterialType).filter(MaterialType.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}", status_code=204)
+def delete_material_type(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(MaterialType).filter(MaterialType.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class PaymentMethodDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=2)
+    description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import PaymentMethod
+from .dto import PaymentMethodDTO
+
+router = APIRouter(prefix="/payment-methods", tags=["Payment Methods"])
+
+@router.get("/", response_model=list[PaymentMethodDTO])
+def list_payment_methods(db: Session = Depends(get_core_db)):
+    return db.query(PaymentMethod).all()
+
+@router.get("/{key}", response_model=PaymentMethodDTO)
+def get_payment_method(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(PaymentMethod).filter(PaymentMethod.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=PaymentMethodDTO, status_code=201)
+def create_payment_method(data: PaymentMethodDTO, db: Session = Depends(get_core_db)):
+    obj = PaymentMethod(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}", response_model=PaymentMethodDTO)
+def update_payment_method(key: str, data: PaymentMethodDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(PaymentMethod).filter(PaymentMethod.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}", status_code=204)
+def delete_payment_method(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(PaymentMethod).filter(PaymentMethod.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class PedimentoCodeDTO(BaseModel):
+    code: str = Field(..., min_length=1, max_length=3)
+    description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import PedimentoCode
+from .dto import PedimentoCodeDTO
+
+router = APIRouter(prefix="/pedimento-codes", tags=["Pedimento Codes"])
+
+@router.get("/", response_model=list[PedimentoCodeDTO])
+def list_pedimento_codes(db: Session = Depends(get_core_db)):
+    return db.query(PedimentoCode).all()
+
+@router.get("/{code}", response_model=PedimentoCodeDTO)
+def get_pedimento_code(code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(PedimentoCode).filter(PedimentoCode.code == code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=PedimentoCodeDTO, status_code=201)
+def create_pedimento_code(data: PedimentoCodeDTO, db: Session = Depends(get_core_db)):
+    obj = PedimentoCode(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{code}", response_model=PedimentoCodeDTO)
+def update_pedimento_code(code: str, data: PedimentoCodeDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(PedimentoCode).filter(PedimentoCode.code == code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{code}", status_code=204)
+def delete_pedimento_code(code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(PedimentoCode).filter(PedimentoCode.code == code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+from typing import List
+
+class RegimenPedimentoDTO(BaseModel):
+    code: str = Field(..., min_length=1, max_length=3)
+    description: str
+
+    class Config:
+        from_attributes = True

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

@@ -0,0 +1,47 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import RegimenPedimento
+from .dto import RegimenPedimentoDTO
+
+router = APIRouter(prefix="/pedimento-regimens", tags=["Pedimento Regimens"])
+
+@router.get("/", response_model=list[RegimenPedimentoDTO])
+def list_pedimento_regimens(db: Session = Depends(get_core_db)):
+    objs = db.query(RegimenPedimento).all()
+    return [RegimenPedimentoDTO.model_validate(obj) for obj in objs]
+
+@router.get("/{key}", response_model=RegimenPedimentoDTO)
+def get_pedimento_regimen(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(RegimenPedimento).filter(RegimenPedimento.code == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return RegimenPedimentoDTO.model_validate(obj)
+
+@router.post("/", response_model=RegimenPedimentoDTO, status_code=201)
+def create_pedimento_regimen(data: RegimenPedimentoDTO, db: Session = Depends(get_core_db)):
+    obj = RegimenPedimento(**data.model_dump())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return RegimenPedimentoDTO.model_validate(obj)
+
+@router.put("/{key}", response_model=RegimenPedimentoDTO)
+def update_pedimento_regimen(key: str, data: RegimenPedimentoDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(RegimenPedimento).filter(RegimenPedimento.code == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.model_dump().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return RegimenPedimentoDTO.model_validate(obj)
+
+@router.delete("/{key}", status_code=204)
+def delete_pedimento_regimen(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(RegimenPedimento).filter(RegimenPedimento.code == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,10 @@
+from pydantic import BaseModel, Field
+
+class SectorDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=8)
+    description: str
+    authorized: int
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import Sector
+from .dto import SectorDTO
+
+router = APIRouter(prefix="/sectors", tags=["Sectors"])
+
+@router.get("/", response_model=list[SectorDTO])
+def list_sectors(db: Session = Depends(get_core_db)):
+    return db.query(Sector).all()
+
+@router.get("/{key}", response_model=SectorDTO)
+def get_sector(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Sector).filter(Sector.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=SectorDTO, status_code=201)
+def create_sector(data: SectorDTO, db: Session = Depends(get_core_db)):
+    obj = Sector(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}", response_model=SectorDTO)
+def update_sector(key: str, data: SectorDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(Sector).filter(Sector.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}", status_code=204)
+def delete_sector(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(Sector).filter(Sector.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+from typing import Optional
+
+class StateDTO(BaseModel):
+    m3_key: str = Field(..., min_length=1, max_length=3)
+    description: str
+    mex_key: Optional[str] = None
+    ame_key: Optional[str] = None
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import State
+from .dto import StateDTO
+
+router = APIRouter(prefix="/states", tags=["States"])
+
+@router.get("/", response_model=list[StateDTO])
+def list_states(db: Session = Depends(get_core_db)):
+    return db.query(State).all()
+
+@router.get("/{m3_key}", response_model=StateDTO)
+def get_state(m3_key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(State).filter(State.m3_key == m3_key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=StateDTO, status_code=201)
+def create_state(data: StateDTO, db: Session = Depends(get_core_db)):
+    obj = State(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{m3_key}", response_model=StateDTO)
+def update_state(m3_key: str, data: StateDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(State).filter(State.m3_key == m3_key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{m3_key}", status_code=204)
+def delete_state(m3_key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(State).filter(State.m3_key == m3_key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class TransportModeDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=3)
+    name: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import TransportMode
+from .dto import TransportModeDTO
+
+router = APIRouter(prefix="/transport-modes", tags=["Transport Modes"])
+
+@router.get("/", response_model=list[TransportModeDTO])
+def list_transport_modes(db: Session = Depends(get_core_db)):
+    return db.query(TransportMode).all()
+
+@router.get("/{key}", response_model=TransportModeDTO)
+def get_transport_mode(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(TransportMode).filter(TransportMode.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=TransportModeDTO, status_code=201)
+def create_transport_mode(data: TransportModeDTO, db: Session = Depends(get_core_db)):
+    obj = TransportMode(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}", response_model=TransportModeDTO)
+def update_transport_mode(key: str, data: TransportModeDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(TransportMode).filter(TransportMode.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}", status_code=204)
+def delete_transport_mode(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(TransportMode).filter(TransportMode.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class TransportTypeDTO(BaseModel):
+    transport_code: str = Field(..., min_length=1, max_length=2)
+    description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import TransportType
+from .dto import TransportTypeDTO
+
+router = APIRouter(prefix="/transport-types", tags=["Transport Types"])
+
+@router.get("/", response_model=list[TransportTypeDTO])
+def list_transport_types(db: Session = Depends(get_core_db)):
+    return db.query(TransportType).all()
+
+@router.get("/{transport_code}", response_model=TransportTypeDTO)
+def get_transport_type(transport_code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(TransportType).filter(TransportType.transport_code == transport_code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=TransportTypeDTO, status_code=201)
+def create_transport_type(data: TransportTypeDTO, db: Session = Depends(get_core_db)):
+    obj = TransportType(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{transport_code}", response_model=TransportTypeDTO)
+def update_transport_type(transport_code: str, data: TransportTypeDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(TransportType).filter(TransportType.transport_code == transport_code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{transport_code}", status_code=204)
+def delete_transport_type(transport_code: str, db: Session = Depends(get_core_db)):
+    obj = db.query(TransportType).filter(TransportType.transport_code == transport_code).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

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

@@ -0,0 +1,9 @@
+from pydantic import BaseModel, Field
+
+class ValuationMethodDTO(BaseModel):
+    key: str = Field(..., min_length=1, max_length=2)
+    description: str
+
+    class Config:
+        from_attributes = True
+

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

@@ -0,0 +1,46 @@
+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+from core.database import get_core_db
+from .models import ValuationMethod
+from .dto import ValuationMethodDTO
+
+router = APIRouter(prefix="/valuation-methods", tags=["Valuation Methods"])
+
+@router.get("/", response_model=list[ValuationMethodDTO])
+def list_valuation_methods(db: Session = Depends(get_core_db)):
+    return db.query(ValuationMethod).all()
+
+@router.get("/{key}", response_model=ValuationMethodDTO)
+def get_valuation_method(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(ValuationMethod).filter(ValuationMethod.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    return obj
+
+@router.post("/", response_model=ValuationMethodDTO, status_code=201)
+def create_valuation_method(data: ValuationMethodDTO, db: Session = Depends(get_core_db)):
+    obj = ValuationMethod(**data.dict())
+    db.add(obj)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.put("/{key}", response_model=ValuationMethodDTO)
+def update_valuation_method(key: str, data: ValuationMethodDTO, db: Session = Depends(get_core_db)):
+    obj = db.query(ValuationMethod).filter(ValuationMethod.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    for field, value in data.dict().items():
+        setattr(obj, field, value)
+    db.commit()
+    db.refresh(obj)
+    return obj
+
+@router.delete("/{key}", status_code=204)
+def delete_valuation_method(key: str, db: Session = Depends(get_core_db)):
+    obj = db.query(ValuationMethod).filter(ValuationMethod.key == key).first()
+    if not obj:
+        raise HTTPException(status_code=404, detail="Not found")
+    db.delete(obj)
+    db.commit()
+    return None

backend/api/v1/router.py

@@ -7,6 +7,24 @@ from fastapi import APIRouter
 # Importar routers de módulos
 from .modules.a76.auth import router as auth_router
 from .modules.a76.tenants import router as tenants_router
+
+from .modules.public.reference_data.pedimento_codes.routes import router as pedimento_codes_router
+from .modules.public.reference_data.payment_methods.routes import router as payment_methods_router
+from .modules.public.reference_data.containers.routes import router as containers_router
+from .modules.public.reference_data.countries.routes import router as countries_router
+from .modules.public.reference_data.material_types.routes import router as material_types_router
+from .modules.public.reference_data.currency_types.routes import router as currency_types_router
+from .modules.public.reference_data.states.routes import router as states_router
+from .modules.public.reference_data.transport_types.routes import router as transport_types_router
+from .modules.public.reference_data.customs_warehouses.routes import router as customs_warehouses_router
+from .modules.public.reference_data.valuation_methods.routes import router as valuation_methods_router
+from .modules.public.reference_data.sectors.routes import router as sectors_router
+from .modules.public.reference_data.transport_modes.routes import router as transport_modes_router
+from .modules.public.reference_data.customs_sections.routes import router as customs_sections_router
+from .modules.public.reference_data.invoice_types.routes import router as invoice_types_router
+from .modules.public.reference_data.code_pedimento_regimens.routes import router as code_pedimento_regimens_router
+from .modules.public.reference_data.pedimento_regimens.routes import router as pedimento_regimens_router
+from .modules.public.reference_data.incoterms.routes import router as incoterms_router
 from .modules.a76.licenses import router as licenses_router
 
 # Router principal
@@ -16,8 +34,27 @@ router = APIRouter()
 router.include_router(auth_router)
 router.include_router(tenants_router)
 router.include_router(licenses_router)
+router.include_router(pedimento_codes_router)
+router.include_router(payment_methods_router)
+router.include_router(containers_router)
+router.include_router(countries_router)
+router.include_router(material_types_router)
+router.include_router(currency_types_router)
+router.include_router(states_router)
+router.include_router(transport_types_router)
+router.include_router(customs_warehouses_router)
+router.include_router(valuation_methods_router)
+router.include_router(sectors_router)
+router.include_router(transport_modes_router)
+router.include_router(customs_sections_router)
+router.include_router(invoice_types_router)
+router.include_router(code_pedimento_regimens_router)
+router.include_router(pedimento_regimens_router)
+router.include_router(incoterms_router)
 
 # Health check
+
+
 @router.get("/status")
 def status():
     """Health check de la API"""