all model tests

Author: mariusandra

backend/app/api/auth.py

@@ -5,11 +5,12 @@
 from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
 from jose import jwt, JWTError
 from sqlalchemy.orm import Session
+from redis.asyncio import Redis
 
 from app.config import get_config
 from app.models.user import User
 from app.database import get_db
-from app.redis import redis
+from app.redis import get_redis
 from werkzeug.security import generate_password_hash, check_password_hash
 from app.schemas.auth import Token, UserSignup
 
@@ -18,7 +19,7 @@
 config = get_config()
 SECRET_KEY = config.SECRET_KEY
 ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 60
+ACCESS_TOKEN_EXPIRE_MINUTES = 7 * 24 * 60  # 7 days
 
 oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/login")
 
@@ -52,7 +53,7 @@ async def get_current_user(token: str = Depends(oauth2_scheme), db: Session = De
     return user
 
 @public_api.post("/login", response_model=Token)
-async def login(request: Request, form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db)):
+async def login(request: Request, form_data: OAuth2PasswordRequestForm = Depends(), db: Session = Depends(get_db), redis: Redis = Depends(get_redis)):
     email = form_data.username
     password = form_data.password
     ip = request.client.host

backend/app/api/frames.py

@@ -15,7 +15,7 @@
 from sqlalchemy.orm import Session
 
 from app.database import get_db
-from app.redis import redis
+from redis.asyncio import Redis
 from app.models.frame import Frame, new_frame, delete_frame, update_frame
 from app.models.log import new_log as log
 from app.models.metrics import Metrics
@@ -28,6 +28,7 @@
 )
 from app.api.auth import ALGORITHM, SECRET_KEY, get_current_user
 from app.utils.network import is_safe_host
+from app.redis import get_redis
 from . import private_api, public_api
 
 
@@ -40,15 +41,15 @@ async def api_frames_list(db: Session = Depends(get_db)):
 
 @private_api.get("/frames/{id}", response_model=FrameResponse)
 async def api_frame_get(id: int, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
     return {"frame": frame.to_dict()}
 
 
 @private_api.get("/frames/{id}/logs", response_model=FrameLogsResponse)
 async def api_frame_get_logs(id: int, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
     logs = [ll.to_dict() for ll in frame.logs][-1000:]
@@ -71,15 +72,15 @@ async def get_image_link(id: int, user=Depends(get_current_user)):
     }
 
 @public_api.get("/frames/{id}/image")
-async def api_frame_get_image(id: int, token: str, request: Request, db: Session = Depends(get_db)):
+async def api_frame_get_image(id: int, token: str, request: Request, db: Session = Depends(get_db), redis: Redis = Depends(get_redis)):
     try:
         payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
         if payload.get("sub") != str(id):
             raise HTTPException(status_code=401, detail="Unauthorized")
     except JWTError:
         raise HTTPException(status_code=401, detail="Unauthorized")
 
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -110,8 +111,8 @@ async def api_frame_get_image(id: int, token: str, request: Request, db: Session
 
 
 @private_api.get("/frames/{id}/state", response_model=FrameStateResponse)
-async def api_frame_get_state(id: int, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+async def api_frame_get_state(id: int, db: Session = Depends(get_db), redis: Redis = Depends(get_redis)):
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -147,7 +148,7 @@ async def api_frame_get_state(id: int, db: Session = Depends(get_db)):
 
 @private_api.post("/frames/{id}/event/{event}")
 async def api_frame_event(id: int, event: str, request: Request, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -179,7 +180,7 @@ async def api_frame_event(id: int, event: str, request: Request, db: Session = D
 
 @private_api.get("/frames/{id}/scene_source/{scene}")
 async def api_frame_scene_source(id: int, scene: str, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -191,7 +192,7 @@ async def api_frame_scene_source(id: int, scene: str, db: Session = Depends(get_
 
 @private_api.get("/frames/{id}/assets", response_model=FrameAssetsResponse)
 async def api_frame_get_assets(id: int, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -217,8 +218,8 @@ async def api_frame_get_assets(id: int, db: Session = Depends(get_db)):
 
 
 @private_api.get("/frames/{id}/asset")
-async def api_frame_get_asset(id: int, request: Request, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+async def api_frame_get_asset(id: int, request: Request, db: Session = Depends(get_db), redis: Redis = Depends(get_redis)):
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -325,7 +326,7 @@ async def api_frame_update_endpoint(
     data: FrameUpdateRequest,
     db: Session = Depends(get_db)
 ):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if not frame:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
 
@@ -349,18 +350,18 @@ async def api_frame_update_endpoint(
 
 
 @private_api.post("/frames/new", response_model=FrameResponse)
-async def api_frame_new(data: FrameCreateRequest, db: Session = Depends(get_db)):
+async def api_frame_new(data: FrameCreateRequest, db: Session = Depends(get_db), redis: Redis = Depends(get_redis)):
     try:
-        frame = await new_frame(db, data.name, data.frame_host, data.server_host, data.device, data.interval)
+        frame = await new_frame(db, redis, data.name, data.frame_host, data.server_host, data.device, data.interval)
         return {"frame": frame.to_dict()}
     except Exception as e:
         raise HTTPException(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=str(e))
 
 
 @private_api.delete("/frames/{frame_id}")
-async def api_frame_delete(frame_id: int, db: Session = Depends(get_db)):
+async def api_frame_delete(frame_id: int, db: Session = Depends(get_db), redis: Redis = Depends(get_redis)):
     try:
-        success = await delete_frame(db, frame_id)
+        success = await delete_frame(db, redis, frame_id)
         if success:
             return {"message": "Frame deleted successfully"}
         else:
@@ -371,7 +372,7 @@ async def api_frame_delete(frame_id: int, db: Session = Depends(get_db)):
 
 @private_api.get("/frames/{id}/metrics", response_model=FrameMetricsResponse)
 async def api_frame_metrics(id: int, db: Session = Depends(get_db)):
-    frame = db.query(Frame).get(id)
+    frame = db.get(Frame, id)
     if frame is None:
         raise HTTPException(status_code=HTTPStatus.NOT_FOUND, detail="Frame not found")
     try:

backend/app/api/log.py

@@ -1,16 +1,19 @@
 from fastapi import HTTPException, Depends, Header
 from sqlalchemy.orm import Session
+from redis.asyncio import Redis
 
 from app.database import get_db
 from app.models.frame import Frame
 from app.models.log import process_log
 from app.schemas.log import LogRequest, LogResponse
+from app.redis import get_redis
 from . import public_api
 
 @public_api.post("/log", response_model=LogResponse)
 async def post_api_log(
     data: LogRequest,
     db: Session = Depends(get_db),
+    redis: Redis = Depends(get_redis),
     authorization: str = Header(None)
 ):
     if not authorization:
@@ -27,10 +30,10 @@ async def post_api_log(
         raise HTTPException(status_code=401, detail="Unauthorized")
 
     if data.log:
-        await process_log(db, frame, data.log)
+        await process_log(db, redis, frame, data.log)
 
     if data.logs:
         for log in data.logs:
-            await process_log(db, frame, log)
+            await process_log(db, redis, frame, log)
 
     return LogResponse(message="OK")

backend/app/api/repositories.py

@@ -81,7 +81,7 @@ async def get_repositories(db: Session = Depends(get_db)):
 @private_api.get("/repositories/{repository_id}", response_model=RepositoryResponse)
 async def get_repository(repository_id: int, db: Session = Depends(get_db)):
     try:
-        repository = db.query(Repository).get(repository_id)
+        repository = db.get(Repository, repository_id)
         if not repository:
             raise HTTPException(status_code=404, detail="Repository not found")
         repo_dict = repository.to_dict()
@@ -93,7 +93,7 @@ async def get_repository(repository_id: int, db: Session = Depends(get_db)):
 @private_api.patch("/repositories/{repository_id}", response_model=RepositoryResponse)
 async def update_repository(repository_id: int, data: RepositoryUpdateRequest, db: Session = Depends(get_db)):
     try:
-        repository = db.query(Repository).get(repository_id)
+        repository = db.get(Repository, repository_id)
         if not repository:
             raise HTTPException(status_code=404, detail="Repository not found")
 
@@ -112,7 +112,7 @@ async def update_repository(repository_id: int, data: RepositoryUpdateRequest, d
 @private_api.delete("/repositories/{repository_id}")
 async def delete_repository(repository_id: int, db: Session = Depends(get_db)):
     try:
-        repository = db.query(Repository).get(repository_id)
+        repository = db.get(Repository, repository_id)
         if not repository:
             raise HTTPException(status_code=404, detail="Repository not found")
         db.delete(repository)

backend/app/api/templates.py

@@ -13,14 +13,15 @@
 from sqlalchemy.orm import Session
 
 from app.database import get_db
-from app.redis import redis
+from redis.asyncio import Redis
 from app.models.template import Template
 from app.models.frame import Frame
 from app.schemas.templates import (
     TemplateResponse, TemplatesListResponse, CreateTemplateRequest, UpdateTemplateRequest
 )
 from app.api.auth import SECRET_KEY, ALGORITHM
 from app.api import private_api, public_api
+from app.redis import get_redis
 
 
 def respond_with_template(template: Template):
@@ -54,6 +55,7 @@ def respond_with_template(template: Template):
 @private_api.post("/templates")
 async def create_template(
     db: Session = Depends(get_db),
+    redis: Redis = Depends(get_redis),
     file: UploadFile = File(None),
     url: str = Form(None),
     from_frame_id: int = Form(None),
@@ -143,7 +145,7 @@ async def create_template(
     # If from_frame_id is provided, attempt to fetch image from frame cache
     if data.get('from_frame_id'):
         frame_id = data['from_frame_id']
-        frame = db.query(Frame).get(frame_id)
+        frame = db.get(Frame, frame_id)
         if frame:
             cache_key = f'frame:{frame.frame_host}:{frame.frame_port}:image'
             last_image = await redis.get(cache_key)
@@ -203,21 +205,21 @@ async def get_template_image(template_id: str, token: str, request: Request, db:
     except JWTError:
         raise HTTPException(status_code=401, detail="Unauthorized")
 
-    template = db.query(Template).get(template_id)
+    template = db.get(Template, template_id)
     if not template or not template.image:
         raise HTTPException(status_code=404, detail="Template not found")
     return StreamingResponse(io.BytesIO(template.image), media_type='image/jpeg')
 
 
 @private_api.get("/templates/{template_id}/export")
 async def export_template(template_id: int, db: Session = Depends(get_db)):
-    template = db.query(Template).get(template_id)
+    template = db.get(Template, template_id)
     return respond_with_template(template)
 
 
 @private_api.get("/templates/{template_id}", response_model=TemplateResponse)
 async def get_template(template_id: int, db: Session = Depends(get_db)):
-    template = db.query(Template).get(template_id)
+    template = db.get(Template, template_id)
     if not template:
         raise HTTPException(status_code=404, detail="Template not found")
     d = template.to_dict()
@@ -227,7 +229,7 @@ async def get_template(template_id: int, db: Session = Depends(get_db)):
 
 @private_api.patch("/templates/{template_id}", response_model=TemplateResponse)
 async def update_template(template_id: int, data: UpdateTemplateRequest, db: Session = Depends(get_db)):
-    template = db.query(Template).get(template_id)
+    template = db.get(Template, template_id)
     if not template:
         raise HTTPException(status_code=404, detail="Template not found")
 
@@ -245,7 +247,7 @@ async def update_template(template_id: int, data: UpdateTemplateRequest, db: Ses
 
 @private_api.delete("/templates/{template_id}")
 async def delete_template(template_id: int, db: Session = Depends(get_db)):
-    template = db.query(Template).get(template_id)
+    template = db.get(Template, template_id)
     if not template:
         raise HTTPException(status_code=404, detail="Template not found")
     db.delete(template)