315 lines
7.8 KiB
Python
315 lines
7.8 KiB
Python
from datetime import datetime
|
|
from typing import List, Optional
|
|
|
|
from sqlalchemy.orm import Session
|
|
|
|
from db.models import Camera, CameraStatus, ROI, Alarm
|
|
|
|
|
|
def get_all_cameras(db: Session, enabled_only: bool = True) -> List[Camera]:
|
|
query = db.query(Camera)
|
|
if enabled_only:
|
|
query = query.filter(Camera.enabled == True)
|
|
return query.all()
|
|
|
|
|
|
def get_camera_by_id(db: Session, camera_id: int) -> Optional[Camera]:
|
|
return db.query(Camera).filter(Camera.id == camera_id).first()
|
|
|
|
|
|
def create_camera(
|
|
db: Session,
|
|
name: str,
|
|
rtsp_url: str,
|
|
fps_limit: int = 30,
|
|
process_every_n_frames: int = 3,
|
|
) -> Camera:
|
|
camera = Camera(
|
|
name=name,
|
|
rtsp_url=rtsp_url,
|
|
fps_limit=fps_limit,
|
|
process_every_n_frames=process_every_n_frames,
|
|
)
|
|
db.add(camera)
|
|
db.commit()
|
|
db.refresh(camera)
|
|
return camera
|
|
|
|
|
|
def update_camera(
|
|
db: Session,
|
|
camera_id: int,
|
|
name: Optional[str] = None,
|
|
rtsp_url: Optional[str] = None,
|
|
fps_limit: Optional[int] = None,
|
|
process_every_n_frames: Optional[int] = None,
|
|
enabled: Optional[bool] = None,
|
|
) -> Optional[Camera]:
|
|
camera = get_camera_by_id(db, camera_id)
|
|
if not camera:
|
|
return None
|
|
|
|
if name is not None:
|
|
camera.name = name
|
|
if rtsp_url is not None:
|
|
camera.rtsp_url = rtsp_url
|
|
if fps_limit is not None:
|
|
camera.fps_limit = fps_limit
|
|
if process_every_n_frames is not None:
|
|
camera.process_every_n_frames = process_every_n_frames
|
|
if enabled is not None:
|
|
camera.enabled = enabled
|
|
|
|
db.commit()
|
|
db.refresh(camera)
|
|
return camera
|
|
|
|
|
|
def delete_camera(db: Session, camera_id: int) -> bool:
|
|
camera = get_camera_by_id(db, camera_id)
|
|
if not camera:
|
|
return False
|
|
|
|
db.delete(camera)
|
|
db.commit()
|
|
return True
|
|
|
|
|
|
def get_camera_status(db: Session, camera_id: int) -> Optional[CameraStatus]:
|
|
return (
|
|
db.query(CameraStatus).filter(CameraStatus.camera_id == camera_id).first()
|
|
)
|
|
|
|
|
|
def update_camera_status(
|
|
db: Session,
|
|
camera_id: int,
|
|
is_running: Optional[bool] = None,
|
|
fps: Optional[float] = None,
|
|
error_message: Optional[str] = None,
|
|
) -> Optional[CameraStatus]:
|
|
status = get_camera_status(db, camera_id)
|
|
if not status:
|
|
status = CameraStatus(camera_id=camera_id)
|
|
db.add(status)
|
|
|
|
if is_running is not None:
|
|
status.is_running = is_running
|
|
if fps is not None:
|
|
status.fps = fps
|
|
if error_message is not None:
|
|
status.error_message = error_message
|
|
|
|
status.last_check_time = datetime.utcnow()
|
|
|
|
db.commit()
|
|
db.refresh(status)
|
|
return status
|
|
|
|
|
|
def get_all_rois(db: Session, camera_id: Optional[int] = None) -> List[ROI]:
|
|
query = db.query(ROI)
|
|
if camera_id is not None:
|
|
query = query.filter(ROI.camera_id == camera_id)
|
|
return query.filter(ROI.enabled == True).all()
|
|
|
|
|
|
def get_roi_by_id(db: Session, roi_id: int) -> Optional[ROI]:
|
|
return db.query(ROI).filter(ROI.id == roi_id).first()
|
|
|
|
|
|
def get_roi_by_roi_id(db: Session, camera_id: int, roi_id: str) -> Optional[ROI]:
|
|
return (
|
|
db.query(ROI)
|
|
.filter(ROI.camera_id == camera_id, ROI.roi_id == roi_id)
|
|
.first()
|
|
)
|
|
|
|
|
|
def create_roi(
|
|
db: Session,
|
|
camera_id: int,
|
|
roi_id: str,
|
|
name: str,
|
|
roi_type: str,
|
|
points: List[List[float]],
|
|
rule_type: str,
|
|
direction: Optional[str] = None,
|
|
stay_time: Optional[int] = None,
|
|
threshold_sec: int = 360,
|
|
confirm_sec: int = 30,
|
|
return_sec: int = 5,
|
|
) -> ROI:
|
|
import json
|
|
|
|
roi = ROI(
|
|
camera_id=camera_id,
|
|
roi_id=roi_id,
|
|
name=name,
|
|
roi_type=roi_type,
|
|
points=json.dumps(points),
|
|
rule_type=rule_type,
|
|
direction=direction,
|
|
stay_time=stay_time,
|
|
threshold_sec=threshold_sec,
|
|
confirm_sec=confirm_sec,
|
|
return_sec=return_sec,
|
|
)
|
|
db.add(roi)
|
|
db.commit()
|
|
db.refresh(roi)
|
|
return roi
|
|
|
|
|
|
def update_roi(
|
|
db: Session,
|
|
roi_id: int,
|
|
name: Optional[str] = None,
|
|
points: Optional[List[List[float]]] = None,
|
|
rule_type: Optional[str] = None,
|
|
direction: Optional[str] = None,
|
|
stay_time: Optional[int] = None,
|
|
enabled: Optional[bool] = None,
|
|
threshold_sec: Optional[int] = None,
|
|
confirm_sec: Optional[int] = None,
|
|
return_sec: Optional[int] = None,
|
|
) -> Optional[ROI]:
|
|
import json
|
|
|
|
roi = get_roi_by_id(db, roi_id)
|
|
if not roi:
|
|
return None
|
|
|
|
if name is not None:
|
|
roi.name = name
|
|
if points is not None:
|
|
roi.points = json.dumps(points)
|
|
if rule_type is not None:
|
|
roi.rule_type = rule_type
|
|
if direction is not None:
|
|
roi.direction = direction
|
|
if stay_time is not None:
|
|
roi.stay_time = stay_time
|
|
if enabled is not None:
|
|
roi.enabled = enabled
|
|
if threshold_sec is not None:
|
|
roi.threshold_sec = threshold_sec
|
|
if confirm_sec is not None:
|
|
roi.confirm_sec = confirm_sec
|
|
if return_sec is not None:
|
|
roi.return_sec = return_sec
|
|
|
|
db.commit()
|
|
db.refresh(roi)
|
|
return roi
|
|
|
|
|
|
def delete_roi(db: Session, roi_id: int) -> bool:
|
|
roi = get_roi_by_id(db, roi_id)
|
|
if not roi:
|
|
return False
|
|
|
|
db.delete(roi)
|
|
db.commit()
|
|
return True
|
|
|
|
|
|
def get_roi_points(db: Session, camera_id: int) -> List[dict]:
|
|
import json
|
|
|
|
rois = get_all_rois(db, camera_id)
|
|
return [
|
|
{
|
|
"id": roi.id,
|
|
"roi_id": roi.roi_id,
|
|
"name": roi.name,
|
|
"type": roi.roi_type,
|
|
"points": json.loads(roi.points),
|
|
"rule": roi.rule_type,
|
|
"direction": roi.direction,
|
|
"stay_time": roi.stay_time,
|
|
"enabled": roi.enabled,
|
|
"threshold_sec": roi.threshold_sec,
|
|
"confirm_sec": roi.confirm_sec,
|
|
"return_sec": roi.return_sec,
|
|
}
|
|
for roi in rois
|
|
]
|
|
|
|
|
|
def create_alarm(
|
|
db: Session,
|
|
camera_id: int,
|
|
event_type: str,
|
|
confidence: float = 0.0,
|
|
snapshot_path: Optional[str] = None,
|
|
roi_id: Optional[str] = None,
|
|
llm_checked: bool = False,
|
|
llm_result: Optional[str] = None,
|
|
) -> Alarm:
|
|
alarm = Alarm(
|
|
camera_id=camera_id,
|
|
roi_id=roi_id,
|
|
event_type=event_type,
|
|
confidence=confidence,
|
|
snapshot_path=snapshot_path,
|
|
llm_checked=llm_checked,
|
|
llm_result=llm_result,
|
|
)
|
|
db.add(alarm)
|
|
db.commit()
|
|
db.refresh(alarm)
|
|
return alarm
|
|
|
|
|
|
def get_alarms(
|
|
db: Session,
|
|
camera_id: Optional[int] = None,
|
|
event_type: Optional[str] = None,
|
|
limit: int = 100,
|
|
offset: int = 0,
|
|
) -> List[Alarm]:
|
|
query = db.query(Alarm)
|
|
if camera_id is not None:
|
|
query = query.filter(Alarm.camera_id == camera_id)
|
|
if event_type is not None:
|
|
query = query.filter(Alarm.event_type == event_type)
|
|
return query.order_by(Alarm.created_at.desc()).offset(offset).limit(limit).all()
|
|
|
|
|
|
def update_alarm(
|
|
db: Session,
|
|
alarm_id: int,
|
|
llm_checked: Optional[bool] = None,
|
|
llm_result: Optional[str] = None,
|
|
processed: Optional[bool] = None,
|
|
) -> Optional[Alarm]:
|
|
alarm = db.query(Alarm).filter(Alarm.id == alarm_id).first()
|
|
if not alarm:
|
|
return None
|
|
|
|
if llm_checked is not None:
|
|
alarm.llm_checked = llm_checked
|
|
if llm_result is not None:
|
|
alarm.llm_result = llm_result
|
|
if processed is not None:
|
|
alarm.processed = processed
|
|
|
|
db.commit()
|
|
db.refresh(alarm)
|
|
return alarm
|
|
|
|
|
|
def get_alarm_stats(db: Session) -> dict:
|
|
total = db.query(Alarm).count()
|
|
unprocessed = db.query(Alarm).filter(Alarm.processed == False).count()
|
|
llm_pending = db.query(Alarm).filter(
|
|
Alarm.llm_checked == False, Alarm.processed == False
|
|
).count()
|
|
|
|
return {
|
|
"total": total,
|
|
"unprocessed": unprocessed,
|
|
"llm_pending": llm_pending,
|
|
}
|