Se subió aplicación utils y agentes

 from sqlalchemy import create_engine, MetaData, Table
 from sqlalchemy import create_engine, MetaData, Table
-from sqlalchemy.orm import mapper
+from sqlalchemy.orm import mapper, sessionmaker
 from sqlalchemy.sql import select
 from sqlalchemy.sql import select
 
 
-from config import settings
+from project.config import settings
 
 
 
 
 class Persona(object):
 class Persona(object):
@@ -11,6 +11,8 @@ class Persona(object):
 
 
 engine = create_engine(settings.database_url)
 engine = create_engine(settings.database_url)
 metadata = MetaData(engine)
 metadata = MetaData(engine)
+Session = sessionmaker(engine)
+session = Session()
 
 
 tabla_persona = Table('tb_personas', metadata, autoload=True)
 tabla_persona = Table('tb_personas', metadata, autoload=True)
 mapper(Persona, tabla_persona)
 mapper(Persona, tabla_persona)
@@ -18,9 +20,10 @@ mapper(Persona, tabla_persona)
 print(tabla_persona.columns)
 print(tabla_persona.columns)
 
 
 # Ejecutar una query
 # Ejecutar una query
-conn = engine.connect()
-s = select([Persona.Apellido]).where(Persona.id == 802)
-res = conn.execute(s)
-row = res.fetchone()
-res = None if row is None else row['ColumnName']
-print(res)
+if __name__ == '__main__':
+    conn = engine.connect()
+    s = select([Persona.Apellido]).where(Persona.id == 802)
+    res = conn.execute(s)
+    row = res.fetchone()
+    res = None if row is None else row['ColumnName']
+    print(res)

+from sqlalchemy import Column, INTEGER, VARCHAR, DATE, ForeignKey
+from sqlalchemy.orm import relationship
+
+from database import ModelBase
+from persona.models import Persona
+
+
+class Agente(ModelBase):
+    __tablename__ = 'tb_agentes'
+
+    id = Column('idAgente', INTEGER(), primary_key=True, nullable=False)
+    legajo = Column('Legajo', VARCHAR(length=10))
+    observaciones = Column('Observaciones', VARCHAR(length=250))
+
+    causa_baja = Column('CausaBaja', INTEGER())
+    fecha_alta = Column('FechaAlta', DATE(), nullable=False)
+    fecha_baja = Column('FechaBaja', DATE())
+
+    # Relaciones
+    persona_id = Column('Persona', INTEGER(), ForeignKey('tb_Personas.idPersona'), nullable=False)
+    # persona = relationship(Persona, primaryjoin="Agente.Persona == Persona.idPersona", lazy='dynamic')
+
+    def __str__(self):
+        return f"{self.persona_id}"
+
+    def __repr__(self):
+        return f"<Agente: {self}>"

+from fastapi import APIRouter, Depends, HTTPException
+from sqlalchemy.orm import Session
+
+from agente.models import Agente
+from agente.schemas import AgenteSchema
+from database import get_db
+
+router = APIRouter()
+
+
+@router.get('/agentes/{persona_id}/', response_model=AgenteSchema)
+def obtener_agente_por_persona_id(persona_id: int, db: Session = Depends(get_db)):
+    agente = db.query(Agente).filter(Agente.persona_id == persona_id).first()
+
+    if agente is None:
+        raise HTTPException(status_code=404, detail=f"No se encontró el Agente para la Persona con id {persona_id}")
+
+    return agente

+from datetime import date
+from typing import Optional
+
+import pydantic
+
+from persona.schemas import PersonaSchema
+
+
+class AgenteSchema(pydantic.BaseModel):
+    id: int
+    legajo: Optional[str] = None
+    observaciones: Optional[str] = None
+    causa_baja: Optional[int] = None
+    fecha_alta: date
+    fecha_baja: Optional[date] = None
+
+    # persona: PersonaSchema
+
+    class Config:
+        orm_mode = True

@@ -2,6 +2,7 @@ from sqlalchemy import Column, INTEGER, VARCHAR, ForeignKey, DATE
 from sqlalchemy.orm import relationship
 from sqlalchemy.orm import relationship
 
 
 from database import ModelBase
 from database import ModelBase
+from utils.models import Nacionalidad
 
 
 
 
 class Sexo(ModelBase):
 class Sexo(ModelBase):
@@ -28,11 +29,21 @@ class Persona(ModelBase):
     documento = Column('Documento', INTEGER(), nullable=False)
     documento = Column('Documento', INTEGER(), nullable=False)
     fecha_nacimiento = Column('FechaNacimiento', DATE(), nullable=False)
     fecha_nacimiento = Column('FechaNacimiento', DATE(), nullable=False)
     domicilio = Column('Domicilio', VARCHAR(length=100))
     domicilio = Column('Domicilio', VARCHAR(length=100))
+    codigo_postal = Column('CodPostal', VARCHAR(length=20))
+    telefono = Column('Telefono', VARCHAR(length=30))
     email = Column('Email', VARCHAR(length=50))
     email = Column('Email', VARCHAR(length=50))
+
+    es_discapacitado = Column('EsDiscapacitado', VARCHAR(length=1), nullable=False)
+    vive = Column('Vive', VARCHAR(length=1))
+
+    # Relaciones.
     sexo_id = Column('Sexo', INTEGER(), ForeignKey('tb_sexo.idSexo'), nullable=False)
     sexo_id = Column('Sexo', INTEGER(), ForeignKey('tb_sexo.idSexo'), nullable=False)
     sexo = relationship('Sexo')
     sexo = relationship('Sexo')
-    es_discapacitado = Column('EsDiscapacitado', VARCHAR(length=1), nullable=False)
-    codigo_postal = Column('CodPostal', VARCHAR(length=20))
+
+    nacionalidad_id = Column('Nacionalidad', INTEGER(), ForeignKey('tb_Nacionalidad.idNacionalidad'))
+    nacionalidad = relationship(Nacionalidad)
+
+    # TODO: Agregar TipoDocumento, LocalidadNac
 
 
     def __str__(self):
     def __str__(self):
         return f"{self.apellido}, {self.nombres}"
         return f"{self.apellido}, {self.nombres}"

@@ -5,15 +5,25 @@ from sqlalchemy.orm import Session
 
 
 from database import get_db
 from database import get_db
 from persona.models import Sexo, Persona
 from persona.models import Sexo, Persona
-from persona.schemas import SexoSchema, PersonaSchema
+from persona.schemas import SexoSchema, PersonaSchema, SexoSchemaBase
 
 
 router = APIRouter()
 router = APIRouter()
 
 
 
 
-@router.get("/sexos/", response_model=List[SexoSchema])
+@router.get('/sexos/', response_model=List[SexoSchema])
 def obtener_sexos(db: Session = Depends(get_db)):
 def obtener_sexos(db: Session = Depends(get_db)):
-    queryset = db.query(Sexo).all()
-    return queryset
+    lista_sexos = db.query(Sexo).all()
+    return lista_sexos
+
+
+@router.post('/sexos/', response_model=SexoSchema)
+def crear_sexo(sexo: SexoSchemaBase, db: Session = Depends(get_db)):
+    instancia = Sexo(**sexo.dict())
+    db.add(instancia)
+    db.commit()
+    db.refresh(instancia)
+
+    return instancia
 
 
 
 
 @router.get('/personas/', response_model=List[PersonaSchema])
 @router.get('/personas/', response_model=List[PersonaSchema])
@@ -23,10 +33,12 @@ def obtener_personas(
         search: Optional[str] = None,
         search: Optional[str] = None,
         db: Session = Depends(get_db)):
         db: Session = Depends(get_db)):
 
 
+    queryset = db.query(Persona)
+
     if search:
     if search:
-        return db.query(Persona).filter(Persona.documento == search).all()
+        queryset = queryset.filter(Persona.documento == search)
 
 
-    return db.query(Persona).offset(skip).limit(limit).all()
+    return queryset.offset(skip).limit(limit).all()
 
 
 
 
 @router.get('/personas/{persona_id}/', response_model=PersonaSchema)
 @router.get('/personas/{persona_id}/', response_model=PersonaSchema)

@@ -3,12 +3,17 @@ from typing import Optional
 
 
 import pydantic
 import pydantic
 
 
+from utils.schemas import NacionalidadSchema
 
 
-class SexoSchema(pydantic.BaseModel):
-    id: int
+
+class SexoSchemaBase(pydantic.BaseModel):
     nombre: str
     nombre: str
     abreviacion: Optional[str] = None
     abreviacion: Optional[str] = None
 
 
+
+class SexoSchema(SexoSchemaBase):
+    id: int
+
     class Config:
     class Config:
         orm_mode = True
         orm_mode = True
 
 
@@ -21,10 +26,15 @@ class PersonaSchema(pydantic.BaseModel):
     documento: int
     documento: int
     fecha_nacimiento: date
     fecha_nacimiento: date
     domicilio: Optional[str] = None
     domicilio: Optional[str] = None
+    codigo_postal: Optional[str] = None
     email: Optional[str] = None
     email: Optional[str] = None
-    sexo: SexoSchema
+    telefono: Optional[str] = None
     es_discapacitado: str
     es_discapacitado: str
-    codigo_postal: Optional[str] = None
+    vive: Optional[str] = None
+
+    # Relaciones
+    sexo: SexoSchema
+    nacionalidad: Optional[NacionalidadSchema] = None
 
 
     class Config:
     class Config:
         orm_mode = True
         orm_mode = True

+from sqlalchemy import Column, INTEGER, VARCHAR
+
+from database import ModelBase
+
+
+class Nacionalidad(ModelBase):
+    __tablename__ = 'tb_Nacionalidad'
+
+    id = Column('idNacionalidad', INTEGER(), primary_key=True, nullable=False)
+    nombre = Column('Descripcion', VARCHAR(length=50), nullable=False)
+    nacionalidad_anses_id = Column('idNacionalidadAnses', INTEGER())
+
+    def __str__(self):
+        return f"{self.nombre}"
+
+    def __repr__(self):
+        return f"<Nacionalidad: {self}>"

+from typing import Optional
+
+import pydantic
+
+
+class NacionalidadSchemaBase(pydantic.BaseModel):
+    nombre: str
+    nacionalidad_anses_id: Optional[str] = None
+
+
+class NacionalidadSchema(NacionalidadSchemaBase):
+    id: int
+
+    class Config:
+        orm_mode = True

@@ -2,8 +2,9 @@ from fastapi import FastAPI
 
 
 from config import settings
 from config import settings
 from persona.routers import router as persona_router
 from persona.routers import router as persona_router
-
+from agente.routers import router as agente_router
 
 
 app = FastAPI(debug=settings.debug)
 app = FastAPI(debug=settings.debug)
 
 
 app.include_router(persona_router)
 app.include_router(persona_router)
+app.include_router(agente_router)