res_levis_API/routes/reslevis.py

from fastapi import APIRouter, Depends, HTTPException
from typing import List

from schemas.reslevis import (
    BuildingItem,
    PlanItem,
    ZoneItem,
    GatewayItem,
    TrackerItem,
    OperatorItem,
    SubjectItem,
    AlarmItem,
    TrackItem,
)

from logica_reslevis.gateway import GatewayJsonRepository
from logica_reslevis.building import BuildingJsonRepository
from logica_reslevis.plan import PlanJsonRepository
from logica_reslevis.zone import ZoneJsonRepository
from logica_reslevis.tracker import TrackerJsonRepository
from logica_reslevis.operator import OperatorJsonRepository
from logica_reslevis.subject import SubjectJsonRepository
from logica_reslevis.alarm import AlarmJsonRepository
from logica_reslevis.track import TrackJsonRepository

from security import get_current_user

router = APIRouter()

gateway_repo = GatewayJsonRepository()
building_repo = BuildingJsonRepository()
plan_repo = PlanJsonRepository()
zone_repo = ZoneJsonRepository()
tracker_repo = TrackerJsonRepository()
operator_repo = OperatorJsonRepository()
subject_repo = SubjectJsonRepository()
alarm_repo = AlarmJsonRepository()
track_repo = TrackJsonRepository()


@router.get(
    "/getGateways",
    response_model=List[GatewayItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getGateway",
)
def getGateways():
    return gateway_repo.list()


@router.post(
    "/postGateway",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postGateway",
)
def postGateway(item: GatewayItem):
    try:
        gateway_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateGateway",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putGateway",
)
def updateGateway(item: GatewayItem):
    try:
        gateway_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeGateway/{gateway_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeGateway",
)
def removeGateway(gateway_id: str):
    try:
        gateway_repo.remove(gateway_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getBuildings",
    response_model=List[BuildingItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getBuilding",
)
def getBuildings():
    return building_repo.list()


@router.post(
    "/postBuilding",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postBuilding",
)
def postBuilding(item: BuildingItem):
    try:
        building_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateBuilding",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putBuilding",
)
def updateBuilding(item: BuildingItem):
    try:
        building_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeBuilding/{building_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeBuilding",
)
def removeBuilding(building_id: str):
    try:
        building_repo.remove(building_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getPlans",
    response_model=List[PlanItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getPlan",
)
def getPlans():
    return plan_repo.list()


@router.post(
    "/postPlan",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postPlan",
)
def postPlan(item: PlanItem):
    try:
        plan_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updatePlan",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putPlan",
)
def updatePlan(item: PlanItem):
    try:
        plan_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removePlan/{plan_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removePlan",
)
def removePlan(plan_id: str):
    try:
        plan_repo.remove(plan_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getZones",
    response_model=List[ZoneItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getZone",
)
def getZones():
    return zone_repo.list()


@router.post(
    "/postZone",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postZone",
)
def postZone(item: ZoneItem):
    try:
        zone_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateZone",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putZone",
)
def updateZone(item: ZoneItem):
    try:
        zone_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeZone/{zone_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeZone",
)
def removeZone(zone_id: str):
    try:
        zone_repo.remove(zone_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getTrackers",
    response_model=List[TrackerItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getTracker",
)
def getTrackers():
    return tracker_repo.list()


@router.post(
    "/postTracker",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postTracker",
)
def postTracker(item: TrackerItem):
    try:
        tracker_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateTracker",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putTracker",
)
def updateTracker(item: TrackerItem):
    try:
        tracker_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeTracker/{tracker_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeTracker",
)
def removeTracker(tracker_id: str):
    try:
        tracker_repo.remove(tracker_id)
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")
    return {"message": "OK"}


@router.get(
    "/getOperators",
    response_model=List[OperatorItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getOperator",
)
def getOperators():
    return operator_repo.list()


@router.post(
    "/postOperator",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postOperator",
)
def postOperator(item: OperatorItem):
    try:
        operator_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateOperator",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putOperator",
)
def updateOperator(item: OperatorItem):
    try:
        operator_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeOperator/{operator_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeOperator",
)
def removeOperator(operator_id: str):
    try:
        operator_repo.remove(operator_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getSubjects",
    response_model=List[SubjectItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getSubject",
)
def getSubjects():
    return subject_repo.list()


@router.post(
    "/postSubject",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postSubject",
)
def postSubject(item: SubjectItem):
    try:
        subject_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateSubject",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putSubject",
)
def updateSubject(item: SubjectItem):
    try:
        subject_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeSubject/{subject_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeSubject",
)
def removeSubject(subject_id: str):
    try:
        subject_repo.remove(subject_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getAlarms",
    response_model=List[AlarmItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getAlarm",
)
def getAlarms():
    return alarm_repo.list()


@router.post(
    "/postAlarm",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postAlarm",
)
def postAlarm(item: AlarmItem):
    try:
        alarm_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateAlarm",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putAlarm",
)
def updateAlarm(item: AlarmItem):
    try:
        alarm_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeAlarm/{alarm_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeAlarm",
)
def removeAlarm(alarm_id: str):
    try:
        alarm_repo.remove(alarm_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.get(
    "/getTracks",
    response_model=List[TrackItem],
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="getTrack",
)
def getTracks():
    return track_repo.list()


@router.post(
    "/postTrack",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="postTrack",
)
def postTrack(item: TrackItem):
    try:
        track_repo.add(item)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=409, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.put(
    "/updateTrack",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="putTrack",
)
def updateTrack(item: TrackItem):
    try:
        track_repo.update(item)
        return {"message": "OK"}
    except ValueError as e:
        msg = str(e)
        if "non trovato" in msg:
            raise HTTPException(status_code=404, detail=msg)
        raise HTTPException(status_code=409, detail=msg)
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")


@router.delete(
    "/removeTrack/{track_id}",
    tags=["Reslevis"],
    dependencies=[Depends(get_current_user)],
    summary="removeTrack",
)
def removeTrack(track_id: str):
    try:
        track_repo.remove(track_id)
        return {"message": "OK"}
    except ValueError as e:
        raise HTTPException(status_code=404, detail=str(e))
    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Errore interno: {e}")