Adding Manufacturers and ScopeModels

2026-06-25 10:46:39 -03:00
1 parent 9111117404
commit b7ad517174
@@ -6,7 +6,9 @@ from sqlalchemy.ext.asyncio import AsyncSession

 from app.core.database import get_db
 from app.crud import iso_thread as iso_thread_crud
+from app.crud import manufacturer as manufacturer_crud
 from app.crud import role as role_crud
+from app.crud import scope_model as scope_model_crud
 from app.crud import unc_thread as unc_thread_crud
 from app.crud import user as user_crud
 from app.deps import get_current_web_user
@@ -483,3 +485,223 @@ async def delete_unc_thread(
    if thread is not None:
        await unc_thread_crud.delete(db, thread)
    return Response(status_code=status.HTTP_200_OK)
+
+
+# --- Manufacturers -----------------------------------------------------------
+
+
+@router.get("/manufacturers", response_class=HTMLResponse)
+async def manufacturers_page(
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(web_require("manufacturers:read")),
+):
+    return templates.TemplateResponse(
+        request,
+        "admin/manufacturers.html",
+        {"user": user, "manufacturers": await manufacturer_crud.list_all(db)},
+    )
+
+
+@router.post("/manufacturers", response_class=HTMLResponse)
+async def create_manufacturer(
+    request: Request,
+    name: str = Form(...),
+    url: str = Form(...),
+    logo_url: str = Form(""),
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("manufacturers:write")),
+):
+    await manufacturer_crud.create(
+        db,
+        name=name,
+        url=url,
+        logo_url=logo_url.strip() or None,
+    )
+    return templates.TemplateResponse(
+        request,
+        "admin/_manufacturers_table.html",
+        {"manufacturers": await manufacturer_crud.list_all(db)},
+    )
+
+
+@router.get("/manufacturers/{manufacturer_id}/edit", response_class=HTMLResponse)
+async def edit_manufacturer_row(
+    request: Request,
+    manufacturer_id: int,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("manufacturers:write")),
+):
+    m = await manufacturer_crud.get(db, manufacturer_id)
+    if m is None:
+        raise HTTPException(status_code=404, detail="Manufacturer not found")
+    return templates.TemplateResponse(
+        request, "admin/_manufacturer_row_edit.html", {"m": m}
+    )
+
+
+@router.get("/manufacturers/{manufacturer_id}/row", response_class=HTMLResponse)
+async def manufacturer_row(
+    request: Request,
+    manufacturer_id: int,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("manufacturers:read")),
+):
+    m = await manufacturer_crud.get(db, manufacturer_id)
+    if m is None:
+        raise HTTPException(status_code=404, detail="Manufacturer not found")
+    return templates.TemplateResponse(
+        request, "admin/_manufacturer_row.html", {"m": m}
+    )
+
+
+@router.post("/manufacturers/{manufacturer_id}", response_class=HTMLResponse)
+async def update_manufacturer(
+    request: Request,
+    manufacturer_id: int,
+    name: str = Form(...),
+    url: str = Form(...),
+    logo_url: str = Form(""),
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("manufacturers:write")),
+):
+    m = await manufacturer_crud.get(db, manufacturer_id)
+    if m is None:
+        raise HTTPException(status_code=404, detail="Manufacturer not found")
+    await manufacturer_crud.update(
+        db,
+        m,
+        {
+            "name": name,
+            "url": url,
+            "logo_url": logo_url.strip() or None,
+        },
+    )
+    return templates.TemplateResponse(
+        request, "admin/_manufacturer_row.html", {"m": m}
+    )
+
+
+@router.delete("/manufacturers/{manufacturer_id}")
+async def delete_manufacturer(
+    manufacturer_id: int,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("manufacturers:delete")),
+):
+    m = await manufacturer_crud.get(db, manufacturer_id)
+    if m is not None:
+        await manufacturer_crud.delete(db, m)
+    return Response(status_code=status.HTTP_200_OK)
+
+
+# --- Scope Models ------------------------------------------------------------
+
+
+@router.get("/scope-models", response_class=HTMLResponse)
+async def scope_models_page(
+    request: Request,
+    db: AsyncSession = Depends(get_db),
+    user: User = Depends(web_require("scope_models:read")),
+):
+    return templates.TemplateResponse(
+        request,
+        "admin/scope_models.html",
+        {
+            "user": user,
+            "scope_models": await scope_model_crud.list_all(db),
+            "manufacturers": await manufacturer_crud.list_all(db),
+        },
+    )
+
+
+@router.post("/scope-models", response_class=HTMLResponse)
+async def create_scope_model(
+    request: Request,
+    name: str = Form(...),
+    manufacturer_id: int = Form(...),
+    url: str = Form(""),
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("scope_models:write")),
+):
+    await scope_model_crud.create(
+        db,
+        name=name,
+        manufacturer_id=manufacturer_id,
+        url=url.strip() or None,
+    )
+    return templates.TemplateResponse(
+        request,
+        "admin/_scope_models_table.html",
+        {"scope_models": await scope_model_crud.list_all(db)},
+    )
+
+
+@router.get("/scope-models/{scope_model_id}/edit", response_class=HTMLResponse)
+async def edit_scope_model_row(
+    request: Request,
+    scope_model_id: int,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("scope_models:write")),
+):
+    sm = await scope_model_crud.get(db, scope_model_id)
+    if sm is None:
+        raise HTTPException(status_code=404, detail="Scope model not found")
+    return templates.TemplateResponse(
+        request,
+        "admin/_scope_model_row_edit.html",
+        {"sm": sm, "manufacturers": await manufacturer_crud.list_all(db)},
+    )
+
+
+@router.get("/scope-models/{scope_model_id}/row", response_class=HTMLResponse)
+async def scope_model_row(
+    request: Request,
+    scope_model_id: int,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("scope_models:read")),
+):
+    sm = await scope_model_crud.get(db, scope_model_id)
+    if sm is None:
+        raise HTTPException(status_code=404, detail="Scope model not found")
+    return templates.TemplateResponse(
+        request, "admin/_scope_model_row.html", {"sm": sm}
+    )
+
+
+@router.post("/scope-models/{scope_model_id}", response_class=HTMLResponse)
+async def update_scope_model(
+    request: Request,
+    scope_model_id: int,
+    name: str = Form(...),
+    manufacturer_id: int = Form(...),
+    url: str = Form(""),
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("scope_models:write")),
+):
+    sm = await scope_model_crud.get(db, scope_model_id)
+    if sm is None:
+        raise HTTPException(status_code=404, detail="Scope model not found")
+    await scope_model_crud.update(
+        db,
+        sm,
+        {
+            "name": name,
+            "manufacturer_id": manufacturer_id,
+            "url": url.strip() or None,
+        },
+    )
+    return templates.TemplateResponse(
+        request, "admin/_scope_model_row.html", {"sm": sm}
+    )
+
+
+@router.delete("/scope-models/{scope_model_id}")
+async def delete_scope_model(
+    scope_model_id: int,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("scope_models:delete")),
+):
+    sm = await scope_model_crud.get(db, scope_model_id)
+    if sm is not None:
+        await scope_model_crud.delete(db, sm)
+    return Response(status_code=status.HTTP_200_OK)