initial commit

.env

@@ -0,0 +1,17 @@
+SECRET_KEY=09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7
+ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+
+# DB_SERVER=localhost
+# DB_NAME=tian
+# DB_PORT=5432 
+# DB_USER=postgres
+# DB_PASSWORD=serG
+
+DB_SQLITE=test.db
+
+SU_NAME=khawir
+SU_PASSWORD=1qaz2wsx
+
+EZV_KEY=fc2c7d28d761409ca6c2a1340490cd12
+EZV_SECRET=ed8d3fbe7316413b90fdf00df9c13c01

config.py

@@ -0,0 +1,29 @@
+import os
+from dotenv import load_dotenv
+
+from pathlib import Path
+env_path = Path('.env')
+load_dotenv(dotenv_path=env_path)
+
+class Settings:
+    PROJECT_NAME:str = "Pulsse"
+    PROJECT_VERSION: str = "1.0.0"
+    DB_SERVER = os.getenv("DB_SERVER", "localhost")
+    DB_NAME = os.getenv("DB_NAME")
+    DB_PORT = os.getenv("DB_PORT", 5432)
+    DB_USER = os.getenv("DB_USER")
+    DB_PASSWORD = os.getenv("DB_PASSWORD")
+    DB_SQLITE = os.getenv("DB_SQLITE")
+    DB_URL = f"postgresql://{DB_USER}:{DB_PASSWORD}@{DB_SERVER}:{DB_PORT}/{DB_NAME}"
+    DB_SQLITE = f"sqlite:///{DB_SQLITE}"
+    SECRET_KEY = os.getenv("SECRET_KEY")
+    ALGORITHM = os.getenv("ALGORITHM")
+    ACCESS_TOKEN_EXPIRE_MINUTES = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES"))
+    SU_NAME = os.getenv("SU_NAME")
+    SU_PASSWORD = os.getenv("SU_PASSWORD")
+    EZV_KEY = os.getenv("EZV_KEY")
+    EZV_SECRET = os.getenv("EZV_SECRET")
+
+# INSERT INTO user (username, full_name, email, password, disabled) VALUES ('johndoe', 'John Doe', 'johndoe@example.com', '$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW', False)
+
+settings = Settings()

core/crud.py

@@ -0,0 +1,200 @@
+from datetime import datetime
+from typing import Annotated
+from sqlmodel import Session, select
+from fastapi import Depends, HTTPException, status
+from fastapi.security import OAuth2PasswordBearer
+from jose import JWTError, jwt
+import core.utils as utils
+from models import User, UserCreate, Site, SiteCreate, Guest
+from models import TokenData
+from config import settings
+
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="login")
+
+
+def authenticate_user(username: str, password: str):
+    with Session(utils.engine) as session:
+        statement = select(User).where(User.username == username)
+        user = session.exec(statement).first()
+        if not user:
+            return False
+        if not utils.verify_password(password, user.password):
+            return False
+        return user
+
+
+
+def get_user(username: str):
+    with Session(utils.engine) as session:
+        statement = select(User).where(User.username == username)
+        user = session.exec(statement).first()
+        if not user:
+            raise HTTPException(status_code=404, detail="User not found")
+        return user
+
+
+
+def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
+    credentials_exception = HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except JWTError:
+        raise credentials_exception
+    user = get_user(username=token_data.username)
+    if user is None:
+        raise credentials_exception
+    return user
+
+
+
+def get_current_active_user(
+    current_user: Annotated[User, Depends(get_current_user)],
+):
+    if current_user.disabled:
+        raise HTTPException(status_code=400, detail="Inactive user")
+    return current_user
+
+
+
+def get_current_super_user(
+    current_user: Annotated[User, Depends(get_current_user)],
+):
+    if not current_user.is_su:
+        raise HTTPException(status_code=403, detail="Action only allowed for admin")
+    return current_user
+
+
+
+def add_user(session: Session, user: UserCreate):
+    statement = select(User).where(User.username == user.email)
+    db_user = session.exec(statement).first()
+    if not db_user:
+        hashed_password = utils.get_password_hash(user.password)
+        extra_data = {"password": hashed_password,
+                    "username": user.email,
+                    "created_at": datetime.now(),
+                    "updated_at": datetime.now()}
+        db_user = User.model_validate(user, update=extra_data)
+        session.add(db_user)
+        session.commit()
+        session.refresh(db_user)
+        return db_user
+    raise HTTPException(status_code=400, detail="Email already registered")
+
+
+
+def edit_user(session: Session, db_user: User, user):
+    user_data = user.model_dump(exclude_unset=True)
+    if "password" in user_data:
+        hashed_password = utils.get_password_hash(user_data["password"])
+        user_data["password"] = hashed_password
+    extra_data = {"updated_at": datetime.now()}
+    db_user.sqlmodel_update(user_data, update=extra_data)
+    try:
+        session.add(db_user)
+        session.commit()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail="Update failed -> Hint: check for unique username")
+    else:
+        session.refresh(db_user)
+        return db_user
+
+
+
+# --------------------
+# ------ Sites -------
+# --------------------
+
+
+
+def camera_exists(session: Session, site):
+    exists = None
+    cameras = session.exec(select(Site.in_camera, Site.out_camera)).all()
+    camera_list = [item for inner_tuple in cameras for item in inner_tuple if item is not None]
+    if site.in_camera is not None:
+        exists = "in_camera" if site.in_camera in camera_list else None
+    if site.out_camera is not None:
+        exists = "out_camera" if site.out_camera in camera_list else None
+    if exists is not None:
+        raise HTTPException(status_code=400, detail=f"Camera (Device ID) already exists in {exists}s")
+
+
+
+def push_site(session: Session, site: SiteCreate):
+    try:
+        session.add(site)
+        session.commit()
+    except Exception as e:
+        raise HTTPException(status_code=400, detail="Action failed -> Hint: Check for unique site name")
+    else:
+        session.refresh(site)
+        return site
+
+
+
+def get_current_site(session: Session, current_user: User, site_id: int):
+    session.add(current_user)
+    user_site_ids = [site.id for site in current_user.sites]
+    if site_id not in user_site_ids:
+        raise HTTPException(status_code=403, detail="Access only allowed for own sites")
+    site = session.get(Site, site_id)
+    if not site:
+        raise HTTPException(status_code=404, detail="Site not found")
+    return site
+    
+
+
+
+# --------------------
+# ------ Hosts -------
+# --------------------
+
+def vector_exists(session: Session, guest):
+    statement = select(Guest).where(Guest.vector == guest.vector)
+    db_guest = session.exec(statement).first()
+    if db_guest:
+        raise HTTPException(status_code=400, detail=f"Guest/Host vector already exists at id {db_guest.id}")
+
+
+
+def get_host_of_site(session: Session, current_site: Site, host_id:int):
+    site_host_ids = [host.id for host in current_site.hosts]
+    if host_id not in site_host_ids:
+        raise HTTPException(status_code=403, detail="Access only allowed for own hosts")
+    host = session.get(Guest, host_id)
+    if not host:
+        raise HTTPException(status_code=404, detail="Host not found")
+    return host
+
+
+
+
+
+# --------------------
+# ------ Admin -------
+# --------------------
+
+
+
+def create_su():
+    with Session(utils.engine) as session:
+        statement = select(User).where(User.username == settings.SU_NAME)
+        su = session.exec(statement).first()
+        if not su:
+           su = User(
+               username = settings.SU_NAME,
+               password = utils.get_password_hash(settings.SU_PASSWORD),
+               is_su=True,
+               disabled=False
+               )
+           session.add(su)
+           session.commit()

core/utils.py

@@ -0,0 +1,45 @@
+from datetime import datetime, timedelta, timezone
+from sqlmodel import Session, SQLModel, create_engine
+from passlib.context import CryptContext
+from jose import jwt
+from config import settings
+
+
+db_url = settings.DB_SQLITE
+
+
+engine = create_engine(db_url, echo=True, 
+                       connect_args={"check_same_thread": False}
+                    )
+
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+
+def create_db_and_tables():
+    SQLModel.metadata.create_all(engine)
+
+
+def get_session():
+    with Session(engine) as session:
+        yield session
+
+
+def verify_password(plain_password, hashed_password):
+    return pwd_context.verify(plain_password, hashed_password)
+
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: dict, expires_delta: timedelta | None = None):
+    to_encode = data.copy()
+    if expires_delta:
+        expire = datetime.now(timezone.utc) + expires_delta
+    else:
+        expire = datetime.now(timezone.utc) + timedelta(minutes=15)
+    to_encode.update({"exp": expire})
+    print(to_encode)
+    encoded_jwt = jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+    return encoded_jwt

main.py

@@ -0,0 +1,86 @@
+from datetime import datetime, timedelta
+from typing import Annotated
+from fastapi import Depends, FastAPI, HTTPException, status
+from fastapi.security import OAuth2PasswordRequestForm
+from sqlmodel import Session, select
+from config import settings
+
+from models import Token, Site, Guest, Visit, User, UserPublicMe, UserCreate
+from routers import users, sites, visits, guests, profile
+from core import utils, crud
+
+app = FastAPI()
+
+app.include_router(profile.router)
+app.include_router(users.router)
+app.include_router(sites.router)
+app.include_router(visits.router)
+app.include_router(guests.router)
+
+@app.on_event("startup")
+def on_startup():
+    utils.create_db_and_tables()
+    crud.create_su()
+
+
+
+@app.post("/login")
+def login_for_access_token(
+    form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+) -> Token:
+    user = crud.authenticate_user(form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    access_token = utils.create_access_token(
+        data={"sub": user.username}, expires_delta=access_token_expires
+    )
+    return Token(access_token=access_token, token_type="bearer")
+
+
+
+@app.post("/register", response_model=UserPublicMe)
+def register_user(*, session: Session = Depends(utils.get_session), user: UserCreate):
+    return crud.add_user(session, user)
+
+
+
+@app.get("/seed")
+def seed_db(*,
+    session: Session = Depends(utils.get_session), 
+    user: Annotated[User, Depends(crud.get_current_super_user)],
+    ):
+    u1 = User(username="cs_admin", password=utils.get_password_hash("csa"))
+    u2 = User(username="is_admin", password=utils.get_password_hash("isa"))
+    u3 = User(username="cs_is_admin", password=utils.get_password_hash("csisa"))
+    u4 = User(username="ee_admin", password=utils.get_password_hash("eea"))
+    s1 = Site(name="CS Dept", location="MCS", in_camera="2a")
+    s2 = Site(name="IS Dept", location="NRB", in_camera="3a")
+    s3 = Site(name="EE Dept", location="MCS", in_camera="1a")
+    u1.sites.append(s1)
+    u2.sites.append(s2)
+    u3.sites.extend([s1, s2])
+    u4.sites.append(s3)
+    session.add(u1)
+    session.add(u2)
+    session.add(u3)
+    session.add(u4)
+    session.add(s1)
+    session.add(s2)
+    session.add(s3)
+    session.add(Guest(name="Arsalan", vector="9874676132", is_female=False,site_id=1))
+    session.add(Guest(name="Zubeela", vector="8564245686", is_female=True, site_id=1))
+    session.add(Guest(name="Zarnaab", vector="5458615856", is_female=False,site_id=2))
+    session.add(Guest(name="Sarmaad", vector="1265645865", is_female=False,site_id=3))
+    session.add(Visit(is_group=False, is_female=False, is_new=False, site_id=1, guest_id=1))
+    session.add(Visit(is_group=False, is_female=True, is_new=True, site_id=1, guest_id=2))
+    session.add(Visit(is_group=True, is_female=False, is_new=False, site_id=2, guest_id=1))
+    session.add(Visit(is_group=True, is_female=False, is_new=False, site_id=2, guest_id=3))
+    session.add(Visit(is_group=False, is_female=False, is_new=False, site_id=2, guest_id=4))
+    session.add(Visit(is_group=False, is_female=False, is_new=False, site_id=3, guest_id=4))
+    session.commit()
+

models.py

@@ -0,0 +1,218 @@
+from datetime import datetime, date, time
+from sqlmodel import SQLModel, Field, Relationship
+
+
+# --------------------
+# --- Token Model ----
+# --------------------
+
+class Token(SQLModel):
+    access_token: str
+    token_type: str
+
+class TokenData(SQLModel):
+    username: str | None = None
+
+
+
+# --------------------
+# --- Many-to-Many ---
+# --------------------
+
+class UserSiteLink(SQLModel, table=True):
+    user_id: int | None = Field(default=None, foreign_key="user.id", primary_key=True)
+    site_id: int | None = Field(default=None, foreign_key="site.id", primary_key=True)
+
+
+
+# --------------------
+# --- User Model -----
+# --------------------
+
+class UserBase(SQLModel):
+    username: str = Field(unique=True)
+    email: str | None = None
+    full_name: str | None = None
+
+class User(UserBase, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    password: str
+    disabled: bool | None = False
+    is_su: bool | None = False
+    created_at: datetime | None = datetime.now()
+    updated_at: datetime | None = datetime.now()
+    sites: list["Site"] = Relationship(back_populates="users", link_model=UserSiteLink)
+
+
+class UserCreate(SQLModel):
+    email: str
+    full_name: str
+    password: str
+
+class UserPublic(UserBase):
+    id: int
+    disabled: bool
+    is_su: bool
+    created_at: datetime
+    updated_at: datetime
+
+class UserUpdate(SQLModel):
+    username: str |  None = None
+    email: str | None = None
+    full_name: str | None = None
+    password: str | None = None
+    disabled: bool | None = None
+    is_su: bool | None = None
+
+class UserPublicMe(UserBase):
+    id: int
+
+class UserUpdateMe(SQLModel):
+    username: str |  None = None
+    email: str | None = None
+    full_name: str | None = None
+    password: str | None = None
+
+
+
+# --------------------
+# --- Site Model ----
+# --------------------
+
+class SiteBase(SQLModel):
+    name: str = Field(unique=True)
+    location: str | None = None
+    contact: str | None = None
+    in_camera: str | None = Field(default=None, unique=True)
+    out_camera: str | None = Field(default=None, unique=True)
+
+class Site(SiteBase, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    created_at: datetime | None = datetime.now()
+    updated_at: datetime | None = datetime.now()
+    visits: list["Visit"] = Relationship(back_populates="site")
+    hosts: list["Guest"] = Relationship(back_populates="site")
+    users: list[User] = Relationship(back_populates="sites", link_model=UserSiteLink)
+
+class SiteCreate(SiteBase):
+    pass
+
+class SitePublic(SiteBase):
+    id: int
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+class SiteUpdate(SQLModel):
+    name: str | None = None
+    location: str | None = None
+    contact: str | None = None
+    in_camera: str | None = Field(default=None, unique=True)
+    out_camera: str | None = Field(default=None, unique=True)
+
+class SitePublicMe(SiteBase):
+    id: int
+
+
+# --------------------
+# --- Guest Model ----
+# --------------------
+
+class GuestBase(SQLModel):
+    name: str | None = None
+    vector: str = Field(unique=True)
+    is_female: bool | None = None
+
+class Guest(GuestBase, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    site_id: int | None = Field(default=None, foreign_key="site.id")
+    created_at: datetime | None = datetime.now()
+    updated_at: datetime | None = datetime.now()
+    visits: list["Visit"] = Relationship(back_populates="guest")
+    site: Site | None = Relationship(back_populates="hosts")
+
+class GuestCreateMe(GuestBase):
+    pass
+
+class GuestCreate(GuestCreateMe):
+    site_id: int | None = None
+
+class GuestPublicMe(GuestBase):
+    id: int
+    site_id: int | None = None
+
+class GuestPublic(GuestPublicMe):
+    created_at: datetime | None = None
+    updated_at: datetime | None = None
+
+class GuestUpdateMe(SQLModel):
+    name: str | None = None
+    vector: str | None = None
+    is_female: bool | None = None
+
+class GuestUpdate(GuestUpdateMe):
+    site_id: bool | None = None
+
+
+
+# --------------------
+# --- Visit Model ----
+# --------------------
+
+class VisitBase(SQLModel):
+    date_in: date | None = datetime.now().date()
+    time_in: time | None = datetime.now().time()
+    time_out: time | None = None
+    is_group: bool | None = False
+    is_female: bool | None = None
+    is_new: bool | None = False    
+    site_id: int | None = Field(default=None, foreign_key="site.id")
+    guest_id: int | None = Field(default=None, foreign_key="guest.id")
+
+class Visit(VisitBase, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    site: Site | None = Relationship(back_populates="visits")
+    guest: Guest | None = Relationship(back_populates="visits")
+
+class VisitCreate(VisitBase):
+    pass
+
+class VisitPublic(VisitBase):
+    id: int
+
+class VisitUpdate(SQLModel):
+    time_out: time | None = None
+    is_group: bool | None = None
+    is_female: bool | None = None
+    is_new: bool | None = None
+
+
+# --------------------
+# --- Relational -----
+# --------------------
+
+class UserPublicWith(UserPublic):
+    sites: list[SitePublic] = []
+
+class VisitPublicWith(VisitPublic):
+    site: SitePublic | None = None
+    guest: GuestPublic | None = None
+
+class SitePublicWith(SitePublic):
+    visits: list[VisitPublic] = []
+    hosts: list[GuestPublic] = []
+    users: list[UserPublic] = []
+
+class GuestPublicWith(GuestPublic):
+    # site: SitePublic | None = None
+    visits: list[VisitPublic] = []
+
+class VisitPublicWithGuest(VisitPublic):
+    guest: GuestPublicMe | None = None
+
+class UserPublicMeWith(UserPublicMe):
+    sites: list[SitePublicMe] = []
+
+class SitePublicMeWith(SitePublicMe):
+    visits: list[VisitPublicWithGuest] = []
+    hosts: list[GuestPublicMe] = []
+

routers/guests.py

@@ -0,0 +1,79 @@
+from datetime import datetime
+from fastapi import Depends, APIRouter, HTTPException, Query
+from models import Guest, GuestCreate, GuestPublic, GuestUpdate, GuestPublicWith
+from sqlmodel import Session, select
+from core import crud, utils
+
+router = APIRouter(
+    prefix="/guests", 
+    tags=["guests"],
+    dependencies=[Depends(crud.get_current_super_user)]
+    )
+
+@router.post("/", response_model=GuestPublic)
+def create_guest(*, 
+                 session: Session = Depends(utils.get_session), 
+                 guest: GuestCreate
+                 ):
+    crud.vector_exists(session, guest)
+    db_guest = Guest.model_validate(guest)
+    session.add(db_guest)
+    session.commit()
+    session.refresh(db_guest)
+    return db_guest
+    
+
+@router.get("/", response_model=list[GuestPublic])
+def read_guests(*,
+                session: Session = Depends(utils.get_session),
+                offset: int = 0,
+                limit: int = Query(default=100, le=100),
+                ):
+    guests = session.exec(select(Guest).offset(offset).limit(limit)).all()
+    return guests
+
+
+
+@router.get("/{guest_id}", response_model=GuestPublicWith)
+def read_guest(*, 
+               session: Session = Depends(utils.get_session), 
+               guest_id: int
+               ):
+    guest = session.get(Guest, guest_id)
+    if not guest:
+        raise HTTPException(status_code=404, detail="Guest not found")
+    return guest
+
+
+
+@router.patch("/{guest_id}", response_model=GuestPublic)
+def update_guest(*, 
+                session: Session = Depends(utils.get_session), 
+                guest_id: int, 
+                guest: GuestUpdate
+                ):
+    db_guest = session.get(Guest, guest_id)
+    if not db_guest:
+        raise HTTPException(status_code=404, detail="Guest not found")
+    if guest.vector is not None:
+        crud.vector_exists(session, guest)
+    guest_data = guest.model_dump(exclude_unset=True)
+    extra_data = {"updated_at": datetime.now()}
+    db_guest.sqlmodel_update(guest_data, update=extra_data)
+    session.add(db_guest)
+    session.commit()
+    session.refresh(db_guest)
+    return db_guest
+
+
+@router.delete("/{guest_id}")
+def delete_guest(*, 
+                 session: Session = Depends(utils.get_session), 
+                 guest_id: int
+                 ):
+    db_guest = session.get(Guest, guest_id)
+    if not db_guest:
+        raise HTTPException(status_code=404, detail="Guest not found")
+    session.delete(db_guest)
+    session.commit()
+    return {"ok": True}

routers/profile.py

@@ -0,0 +1,178 @@
+from datetime import datetime
+from typing import Annotated
+from fastapi import Depends, APIRouter
+from sqlmodel import Session
+from models import User, UserPublicMe, UserPublicMeWith, UserUpdateMe
+from models import Site, SiteCreate, SitePublicMe, SitePublicMeWith, SiteUpdate
+from models import Guest, GuestCreateMe, GuestPublicMe, GuestPublicWith, GuestUpdateMe
+from core import crud, utils
+
+router = APIRouter(
+    prefix="/dashboard", 
+    tags=["dashboard"],
+    )
+
+
+# @router.get("/", response_model=UserPublicMeWith)
+# def read_me(current_user: Annotated[User, Depends(crud.get_current_active_user)]):
+#     return current_user
+
+
+@router.get("/", response_model=UserPublicMeWith)
+def read_dashboard(*,
+            session: Session = Depends(utils.get_session), 
+            current_user: Annotated[User, Depends(crud.get_current_active_user)]
+            ):
+    session.add(current_user)
+    return current_user
+
+
+@router.patch("/", response_model=UserPublicMe)
+def update_dashboard(*,
+              session: Session = Depends(utils.get_session), 
+              current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+              user: UserUpdateMe
+              ):
+    return crud.edit_user(session, current_user, user)
+
+
+
+@router.delete("/")
+def delete_dashboard(*,
+              session: Session = Depends(utils.get_session),
+              current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+              ):
+    session.delete(current_user)
+    session.commit()
+    return {"ok": True}
+
+
+# --------------------
+# ------ Sites -------
+# --------------------
+
+@router.post("/sites", response_model=SitePublicMe)
+def create_site(*, 
+                session: Session = Depends(utils.get_session),
+                current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+                site: SiteCreate
+                ):
+    crud.camera_exists(session, site)
+    extra_data = {"created_at": datetime.now(),
+                  "updated_at": datetime.now()}
+    db_site = Site.model_validate(site, update=extra_data)   
+    db_site  = crud.push_site(session, db_site)
+    session.add(current_user)
+    current_user.sites.append(db_site)
+    session.commit()
+    return db_site
+
+
+
+@router.get("/sites/{site_id}", response_model=SitePublicMeWith)
+def read_site(*, 
+              session: Session = Depends(utils.get_session),
+              current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+              site_id: int
+              ):
+    return crud.get_current_site(session, current_user, site_id)
+
+
+
+@router.patch("/sites/{site_id}", response_model=SitePublicMe)
+def update_site(*, 
+                session: Session = Depends(utils.get_session),
+                current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+                site_id: int, 
+                site: SiteUpdate
+                ):
+    db_site = crud.get_current_site(session, current_user, site_id)
+    crud.camera_exists(session, db_site)
+    site_data = site.model_dump(exclude_unset=True)
+    extra_data = {"updated_at": datetime.now()}
+    db_site.sqlmodel_update(site_data, update=extra_data)
+    return crud.push_site(session, db_site)
+
+
+
+@router.delete("/sites/{site_id}")
+def delete_site(*, 
+                session: Session = Depends(utils.get_session),
+                current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+                site_id: int):
+    db_site = crud.get_current_site(session, current_user, site_id)
+    session.delete(db_site)
+    session.commit()
+    return {"ok": True}
+
+
+# --------------------
+# ------ Hosts -------
+# --------------------
+
+
+@router.post("/sites/{side_id}/hosts", response_model=GuestPublicMe)
+def create_host(*, 
+                session: Session = Depends(utils.get_session),
+                current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+                site_id: int,
+                host: GuestCreateMe
+                ):
+    _ = crud.get_current_site(session, current_user, site_id)
+    if host.vector is not None:
+        crud.vector_exists(session, host)
+    extra_data = {"site_id": site_id}
+    db_host = Guest.model_validate(host, update=extra_data)
+    session.add(db_host)
+    session.commit()
+    session.refresh(db_host)
+    return db_host
+
+
+
+@router.get("/sites/{site_id}/hosts/{host_id}", response_model=GuestPublicWith)
+def read_host(*, 
+              session: Session = Depends(utils.get_session),
+              current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+              site_id: int,
+              host_id: int,
+              ):
+    current_site = crud.get_current_site(session, current_user, site_id)
+    return crud.get_host_of_site(session, current_site, host_id)
+
+
+
+@router.patch("/sites/{site_id}/hosts/{host_id}", response_model=GuestPublicMe)
+def update_host(*, 
+                session: Session = Depends(utils.get_session), 
+                current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+                site_id: int,
+                host_id: int,
+                host: GuestUpdateMe
+                ):
+    current_site = crud.get_current_site(session, current_user, site_id)
+    db_host = crud.get_host_of_site(session, current_site, host_id)
+    if host.vector is not None:
+        crud.vector_exists(session, host)
+    host_data = host.model_dump(exclude_unset=True)
+    extra_data = {"site_id": site_id,
+                  "updated_at": datetime.now()}
+    db_host.sqlmodel_update(host_data, update=extra_data)
+    session.add(db_host)
+    session.commit()
+    session.refresh(db_host)
+    return db_host
+
+
+@router.delete("/sites/{site_id}/hosts/{host_id}")
+def delete_host(*, 
+                session: Session = Depends(utils.get_session),
+                current_user: Annotated[User, Depends(crud.get_current_active_user)], 
+                site_id: int, 
+                host_id: int
+                ):
+    current_site = crud.get_current_site(session, current_user, site_id)
+    db_host = crud.get_host_of_site(session, current_site, host_id)
+    session.delete(db_host)
+    session.commit()
+    return {"ok": True}

routers/sites.py

@@ -0,0 +1,73 @@
+from datetime import datetime
+from fastapi import Depends, APIRouter, HTTPException, Query
+from models import Site, SiteCreate, SitePublic, SiteUpdate, SitePublicWith
+from sqlmodel import Session, select
+from core import crud, utils
+
+router = APIRouter(
+    prefix="/sites", 
+    tags=["sites"],
+    dependencies=[Depends(crud.get_current_super_user)]
+    )
+
+@router.post("/", response_model=SitePublic)
+def create_site(*, 
+                session: Session = Depends(utils.get_session), 
+                site: SiteCreate
+                ):
+    crud.camera_exists(session, site)
+    extra_data = {"created_at": datetime.now(),
+                  "updated_at": datetime.now()}
+    db_site = Site.model_validate(site, update=extra_data)   
+    return crud.push_site(session, db_site)
+
+
+@router.get("/", response_model=list[SitePublic])
+def read_sites(*,
+                session: Session = Depends(utils.get_session),
+                offset: int = 0,
+                limit: int = Query(default=100, le=100),
+                ):
+    sites = session.exec(select(Site).offset(offset).limit(limit)).all()
+    return sites
+
+
+@router.get("/{site_id}", response_model=SitePublicWith)
+def read_site(*, 
+              session: Session = Depends(utils.get_session), 
+              site_id: int
+              ):
+    db_site = session.get(Site, site_id)
+    if not db_site:
+        raise HTTPException(status_code=404, detail="Site not found")
+    return db_site
+
+
+@router.patch("/{site_id}", response_model=SitePublic)
+def update_site(*, 
+                session: Session = Depends(utils.get_session), 
+                site_id: int, 
+                site: SiteUpdate
+                ):
+    crud.camera_exists(session, site)
+    db_site = session.get(Site, site_id)
+    if not db_site:
+        raise HTTPException(status_code=404, detail="Site not found")
+    site_data = site.model_dump(exclude_unset=True)
+    extra_data = {"updated_at": datetime.now()}
+    db_site.sqlmodel_update(site_data, update=extra_data)
+    return crud.push_site(session, db_site)
+
+
+
+@router.delete("/{site_id}")
+def delete_site(*, 
+                session: Session = Depends(utils.get_session), 
+                site_id: int
+                ):
+    db_site = session.get(Site, site_id)
+    if not db_site:
+        raise HTTPException(status_code=404, detail="Site not found")
+    session.delete(db_site)
+    session.commit()
+    return {"ok": True}

routers/users.py

@@ -0,0 +1,57 @@
+from datetime import datetime
+from fastapi import Depends, APIRouter, HTTPException, Query
+from sqlmodel import Session, select
+from models import User, UserCreate, UserPublic, UserUpdate, UserPublicWith
+from core import crud, utils
+
+router = APIRouter(
+    prefix="/users", 
+    tags=["users"],
+    dependencies=[Depends(crud.get_current_super_user)]
+    )
+
+
+@router.post("/", response_model=UserPublic)
+def create_user(*, session: Session = Depends(utils.get_session), user: UserCreate):
+    return crud.add_user(session, user)
+
+
+@router.get("/", response_model=list[UserPublic])
+def read_users(*,
+                session: Session = Depends(utils.get_session),
+                offset: int = 0,
+                limit: int = Query(default=100, le=100),
+                ):
+    users = session.exec(select(User).offset(offset).limit(limit)).all()
+    return users
+
+
+@router.get("/{user_id}", response_model=UserPublicWith)
+def read_user(*, session: Session = Depends(utils.get_session), user_id: int):
+    user = session.get(User, user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return user
+
+
+@router.patch("/{user_id}", response_model=UserPublic)
+def update_user(*, 
+                session: Session = Depends(utils.get_session), 
+                user_id: int, 
+                user: UserUpdate
+                ):
+    db_user = session.get(User, user_id)
+    if not db_user:
+        raise HTTPException(status_code=404, detail="User not found")
+    return crud.edit_user(session, db_user, user)
+
+
+
+@router.delete("/{user_id}")
+def delete_user(*, session: Session = Depends(utils.get_session), user_id: int):
+    user = session.get(User, user_id)
+    if not user:
+        raise HTTPException(status_code=404, detail="User not found")
+    session.delete(user)
+    session.commit()
+    return {"ok": True}

routers/visits.py

@@ -0,0 +1,64 @@
+from datetime import datetime
+from fastapi import Depends, APIRouter, HTTPException, Query
+from models import Visit, VisitCreate, VisitPublic, VisitUpdate, VisitPublicWith
+from sqlmodel import Session, select
+from core import crud, utils
+
+router = APIRouter(
+    prefix="/visits", 
+    tags=["visits"],
+    dependencies=[Depends(crud.get_current_super_user)]
+    )
+
+@router.post("/", response_model=VisitPublic)
+def create_visit(*, session: Session = Depends(utils.get_session), visit: VisitCreate):
+    now = datetime.now()
+    extra_data = {"date_in": now.date(),
+                  "time_in": now.time()}
+    db_visit = Visit.model_validate(visit, update=extra_data)
+    session.add(db_visit)
+    session.commit()
+    session.refresh(db_visit)
+    return db_visit
+
+@router.get("/", response_model=list[VisitPublic])
+def read_visits(*,
+                session: Session = Depends(utils.get_session),
+                offset: int = 0,
+                limit: int = Query(default=100, le=100),
+                ):
+    visits = session.exec(select(Visit).offset(offset).limit(limit)).all()
+    return visits
+
+@router.get("/{visit_id}", response_model=VisitPublicWith)
+def read_visit(*, session: Session = Depends(utils.get_session), visit_id: int):
+    visit = session.get(Visit, visit_id)
+    if not visit:
+        raise HTTPException(status_code=404, detail="Visit not found")
+    return visit
+
+@router.patch("/{visit_id}", response_model=VisitPublic)
+def update_visit(*, 
+                session: Session = Depends(utils.get_session), 
+                visit_id: int, 
+                visit: VisitUpdate
+                ):
+    db_visit = session.get(Visit, visit_id)
+    if not db_visit:
+        raise HTTPException(status_code=404, detail="Visit not found")
+    visit_data = visit.model_dump(exclude_unset=True)
+    db_visit.sqlmodel_update(visit_data)
+    session.add(db_visit)
+    session.commit()
+    session.refresh(db_visit)
+    return db_visit
+
+
+@router.delete("/{visit_id}")
+def delete_visit(*, session: Session = Depends(utils.get_session), visit_id: int):
+    visit = session.get(Visit, visit_id)
+    if not visit:
+        raise HTTPException(status_code=404, detail="Visit not found")
+    session.delete(visit)
+    session.commit()
+    return {"ok": True}