Clients should now work.

Blacked a lot of files

brewman/routers/auth/client.py

@@ -1,51 +1,92 @@
+import traceback
 import uuid
-from sqlalchemy import desc
-from brewman.models.auth import Client, LoginHistory
 
-from fastapi import APIRouter
+from fastapi import APIRouter, HTTPException, status, Depends, Security
+from sqlalchemy import desc
+from sqlalchemy.exc import SQLAlchemyError
+from sqlalchemy.orm import Session
+
+from ...schemas.auth import UserToken
+from ...core.security import get_current_active_user as get_user
+from ...db.session import SessionLocal
+from ...models.auth import Client, LoginHistory
+import brewman.schemas.auth as schemas
 
 router = APIRouter()
 
 
-@router.put("/{id}")  # "Clients"
-def update(request):
-    item = (
-        request.dbsession.query(Client)
-        .filter(Client.id == uuid.UUID(request.matchdict["id"]))
-        .first()
-    )
-    item.enabled = request.json_body["enabled"]
-    if item.enabled:
-        item.otp = None
-    item.name = request.json_body["name"]
-    transaction.commit()
-    return {}
+# Dependency
+def get_db():
+    try:
+        db = SessionLocal()
+        yield db
+    finally:
+        db.close()
 
 
-@router.delete("/{id}")  # "Clients"
-def delete(request):
-    id_ = request.matchdict.get("id", None)
-    if id_ is None:
-        response = Response("Client not found")
-        response.status_int = 500
-        return response
-
-    client = request.dbsession.query(Client).filter(Client.id == uuid.UUID(id_)).first()
-    request.dbsession.execute(
-        LoginHistory.__table__.delete(LoginHistory.client_id == client.id)
-    )
-    request.dbsession.delete(client)
-    transaction.commit()
-    return {}
+@router.put("/{id_}", response_model=schemas.Client)
+def update(
+    id_: uuid.UUID,
+    data: schemas.ClientIn,
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["clients"]),
+):
+    try:
+        item: Client = db.query(Client).filter(Client.id == id_).first()
+        item.enabled = data.enabled
+        if item.enabled:
+            item.otp = None
+        item.name = data.name
+        db.commit()
+        return {}
+    except SQLAlchemyError as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
+        )
+    except Exception:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=traceback.format_exc(),
+        )
 
 
-@router.get("/")  # "Clients"
-async def show_list(l: bool):
-    list_ = request.dbsession.query(Client).order_by(Client.name).all()
+@router.delete("/{id_}")
+def delete(
+    id_: uuid.UUID,
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["clients"]),
+):
+    try:
+        item: Client = db.query(Client).filter(Client.id == id_).first()
+        db.execute(LoginHistory.__table__.delete(LoginHistory.client_id == item.id))
+        db.delete(item)
+        db.commit()
+        return {}
+    except SQLAlchemyError as e:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
+        )
+    except Exception:
+        db.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=traceback.format_exc(),
+        )
+
+
+@router.get("/list")
+async def show_list(
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["clients"]),
+):
+    list_ = db.query(Client).order_by(Client.name).all()
     clients = []
     for item in list_:
         last_login = (
-            request.dbsession.query(LoginHistory)
+            db.query(LoginHistory)
             .filter(LoginHistory.client_id == item.id)
             .order_by(desc(LoginHistory.date))
             .first()
@@ -69,13 +110,13 @@ async def show_list(l: bool):
     return clients
 
 
-@router.get("/{id}")  # "Clients"
-def show_id(request):
-    item = (
-        request.dbsession.query(Client)
-        .filter(Client.id == uuid.UUID(request.matchdict["id"]))
-        .first()
-    )
+@router.get("/{id_}")
+def show_id(
+    id_: uuid.UUID,
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["clients"]),
+):
+    item: Client = db.query(Client).filter(Client.id == id_).first()
     return {
         "id": item.id,
         "code": item.code,

brewman/routers/auth/role.py

@@ -39,8 +39,7 @@ def save(
     except SQLAlchemyError as e:
         db.rollback()
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
         )
     except Exception:
         db.rollback()
@@ -66,8 +65,7 @@ def update(
     except SQLAlchemyError as e:
         db.rollback()
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
         )
     except Exception:
         db.rollback()
@@ -82,7 +80,9 @@ def add_permissions(role: Role, permissions: List[schemas.PermissionItem], db):
         gp = [p for p in role.permissions if p.id == permission.id_]
         gp = None if len(gp) == 0 else gp[0]
         if permission.enabled and gp is None:
-            role.permissions.append(db.query(Permission).filter(Permission.id == permission.id_).one())
+            role.permissions.append(
+                db.query(Permission).filter(Permission.id == permission.id_).one()
+            )
         elif not permission.enabled and gp:
             role.permissions.remove(gp)
 
@@ -122,9 +122,18 @@ def show_blank(
 
 
 @router.get("/list", response_model=List[schemas.RoleList])
-async def show_list(db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"])):
+async def show_list(
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["users"]),
+):
     return [
-        {"id": item.id, "name": item.name, "permissions": [p.name for p in sorted(item.permissions, key=lambda p: p.name)]}
+        {
+            "id": item.id,
+            "name": item.name,
+            "permissions": [
+                p.name for p in sorted(item.permissions, key=lambda p: p.name)
+            ],
+        }
         for item in db.query(Role).order_by(Role.name).all()
     ]
 
@@ -135,7 +144,7 @@ def show_id(
     db: Session = Depends(get_db),
     user: UserToken = Security(get_user, scopes=["users"]),
 ):
-    item = db.query(Role).filter(Role.id == id_).first()
+    item: Role = db.query(Role).filter(Role.id == id_).first()
     return role_info(item, db)
 
 
@@ -146,7 +155,7 @@ def role_info(item: Optional[Role], db):
             "permissions": [
                 {"id": p.id, "name": p.name, "enabled": False}
                 for p in db.query(Permission).order_by(Permission.name).all()
-            ]
+            ],
         }
     else:
         return {
@@ -159,5 +168,5 @@ def role_info(item: Optional[Role], db):
                     "enabled": True if item in item.permissions else False,
                 }
                 for item in db.query(Role).order_by(Role.name).all()
-            ]
+            ],
         }

brewman/routers/auth/user.py

@@ -31,11 +31,7 @@ def save(
     user: UserToken = Security(get_user, scopes=["users"]),
 ):
     try:
-        item = User(
-            name=data.name,
-            password=data.password,
-            locked_out=data.locked_out
-        )
+        item = User(name=data.name, password=data.password, locked_out=data.locked_out)
         db.add(item)
         add_roles(item, data.roles, db)
         db.commit()
@@ -43,8 +39,7 @@ def save(
     except SQLAlchemyError as e:
         db.rollback()
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
         )
     except Exception:
         db.rollback()
@@ -56,8 +51,7 @@ def save(
 
 @router.get("/me", response_model=schemas.User)
 def show_me(
-    db: Session = Depends(get_db),
-    user: UserToken = Depends(get_user),
+    db: Session = Depends(get_db), user: UserToken = Depends(get_user),
 ):
     item = db.query(User).filter(User.id == user.id_).first()
     return user_info(item, db, user)
@@ -82,8 +76,7 @@ def update_me(
     except SQLAlchemyError as e:
         db.rollback()
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
         )
     except Exception:
         db.rollback()
@@ -112,8 +105,7 @@ def update(
     except SQLAlchemyError as e:
         db.rollback()
         raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=str(e),
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, detail=str(e),
         )
     except Exception:
         db.rollback()
@@ -135,9 +127,9 @@ def add_roles(user: User, roles: List[schemas.RoleItem], db: Session):
 
 @router.delete("/{id_}")
 def delete(
-        id_: uuid.UUID,
-        db: Session = Depends(get_db),
-        user: UserToken = Security(get_user, scopes=["users"]),
+    id_: uuid.UUID,
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["users"]),
 ):
     try:
         item: User = db.query(User).filter(User.id == id_).first()
@@ -168,15 +160,25 @@ def show_blank(
 
 
 @router.get("/list", response_model=List[schemas.UserList])
-async def show_list(db: Session = Depends(get_db), user: UserToken = Security(get_user, scopes=["users"])):
+async def show_list(
+    db: Session = Depends(get_db),
+    user: UserToken = Security(get_user, scopes=["users"]),
+):
     return [
-        {"id": item.id, "name": item.name, "lockedOut": item.locked_out, "roles": [p.name for p in sorted(item.roles, key=lambda p: p.name)]}
+        {
+            "id": item.id,
+            "name": item.name,
+            "lockedOut": item.locked_out,
+            "roles": [p.name for p in sorted(item.roles, key=lambda p: p.name)],
+        }
         for item in db.query(User).order_by(User.name).all()
     ]
 
 
 @router.get("/active")
-async def show_active(db: Session = Depends(get_db), user: UserToken = Depends(get_user)):
+async def show_active(
+    db: Session = Depends(get_db), user: UserToken = Depends(get_user)
+):
     return [
         {"name": item.name}
         for item in db.query(User).filter(User.locked_out == False).order_by(User.name)
@@ -196,10 +198,12 @@ def show_id(
 def user_info(item: Optional[User], db: Session, user: UserToken):
     if item is None:
         return {
-            "name": "", "lockedOut": False, "roles": [
+            "name": "",
+            "lockedOut": False,
+            "roles": [
                 {"id": r.id, "name": r.name, "enabled": False}
                 for r in db.query(Role).order_by(Role.name).all()
-            ]
+            ],
         }
     else:
         return {
@@ -214,5 +218,7 @@ def user_info(item: Optional[User], db: Session, user: UserToken):
                     "enabled": True if r in item.roles else False,
                 }
                 for r in db.query(Role).order_by(Role.name).all()
-            ] if "advanced-delete" in user.permissions else [],
+            ]
+            if "advanced-delete" in user.permissions
+            else [],
         }