Checked the alembic migration. It is fine

Fixed errors in user / roles / etc. mostly introduced due to the renaming of tables

alembic/versions/eed0b382c287_lowercase_fastapi.py

@@ -27,10 +27,12 @@ def upgrade():
     op.rename_table('auth_roles', 'auth_permissions')
     with op.batch_alter_table("auth_permissions") as batch_op:
         batch_op.alter_column('RoleID', new_column_name='id')
+        batch_op.alter_column('Name', new_column_name='name')
 
     op.rename_table('auth_groups', 'auth_roles')
     with op.batch_alter_table("auth_roles") as batch_op:
         batch_op.alter_column('GroupID', new_column_name='id')
+        batch_op.alter_column('Name', new_column_name='name')
 
     op.rename_table('auth_rolegroups', 'role_permissions')
     with op.batch_alter_table("role_permissions") as batch_op:
@@ -138,14 +140,10 @@ def upgrade():
     op.drop_constraint('auth_clients_Name_key', 'auth_clients', type_='unique')
     op.create_unique_constraint(op.f('uq_auth_login_history_user_id'), 'auth_login_history', ['user_id', 'client_id', 'date'])
     op.drop_constraint('auth_login_history_user_id_client_id_date_key', 'auth_login_history', type_='unique')
-    op.add_column('auth_permissions', sa.Column('name', sa.Unicode(length=255), nullable=True))
     op.create_unique_constraint(op.f('uq_auth_permissions_name'), 'auth_permissions', ['name'])
     op.drop_constraint('auth_roles_Name_key', 'auth_permissions', type_='unique')
-    op.drop_column('auth_permissions', 'Name')
-    op.add_column('auth_roles', sa.Column('name', sa.Unicode(length=255), nullable=True))
     op.create_unique_constraint(op.f('uq_auth_roles_name'), 'auth_roles', ['name'])
     op.drop_constraint('auth_groups_Name_key', 'auth_roles', type_='unique')
-    op.drop_column('auth_roles', 'Name')
     op.create_unique_constraint(op.f('uq_auth_users_username'), 'auth_users', ['username'])
     op.drop_constraint('auth_users_Name_key', 'auth_users', type_='unique')
     op.create_unique_constraint(op.f('uq_cost_centres_name'), 'cost_centres', ['name'])

brewman/models/auth.py

@@ -29,7 +29,7 @@ class Client(Base):
     login_history = relationship("LoginHistory", backref="client")
 
     def __init__(
-        self, code=None, name=None, enabled=False, otp=None, creation_date=None, id=None
+        self, code=None, name=None, enabled=False, otp=None, creation_date=None, id_=None
     ):
         self.code = code
         self.name = name
@@ -38,7 +38,7 @@ class Client(Base):
         self.creation_date = (
             datetime.utcnow() if creation_date is None else creation_date
         )
-        self.id = id
+        self.id = id_
 
     @classmethod
     def by_code(cls, code, dbsession):
@@ -80,7 +80,7 @@ role_permission = Table(
 class User(Base):
     __tablename__ = "auth_users"
 
-    id_ = Column("id", GUID(), primary_key=True, default=uuid.uuid4)
+    id = Column("id", GUID(), primary_key=True, default=uuid.uuid4)
     name = Column("username", Unicode(255), unique=True)
     _password = Column("password", Unicode(60))
     locked_out = Column("disabled", Boolean)
@@ -105,7 +105,7 @@ class User(Base):
         self.name = name
         self.password = password
         self.locked_out = locked_out
-        self.id_ = id_
+        self.id = id_
 
     @classmethod
     def auth(cls, name, password, db) -> (bool, any):
@@ -130,32 +130,32 @@ class LoginHistory(Base):
     )
     date = Column("date", DateTime(timezone=True), nullable=False)
 
-    def __init__(self, user_id=None, client_id=None, date=None, id=None):
+    def __init__(self, user_id=None, client_id=None, date=None, id_=None):
         self.user_id = user_id
         self.client_id = client_id
         self.date = datetime.utcnow() if date is None else date
-        self.id = id
+        self.id = id_
 
 
 class Role(Base):
     __tablename__ = "auth_roles"
 
-    id_ = Column("id", GUID(), primary_key=True, default=uuid.uuid4)
+    id = Column("id", GUID(), primary_key=True, default=uuid.uuid4)
     name = Column("name", Unicode(255), unique=True)
 
     def __init__(self, name=None, id_=None):
         self.name = name
-        self.id_ = id_
+        self.id = id_
 
 
 class Permission(Base):
     __tablename__ = "auth_permissions"
 
-    id_ = Column("id", GUID(), primary_key=True, default=uuid.uuid4)
+    id = Column("id", GUID(), primary_key=True, default=uuid.uuid4)
     name = Column("name", Unicode(255), unique=True)
 
     roles = relationship("Role", secondary=role_permission, backref="permissions")
 
     def __init__(self, name=None, id_=None):
         self.name = name
-        self.id_ = id_
+        self.id = id_

brewman/models/master.py

@@ -119,6 +119,7 @@ class Product(Base):
             for item in term.split():
                 if item.strip() != "":
                     query_ = query_.filter(Product.name.ilike("%" + item + "%"))
+        return query_
 
     @classmethod
     def suspense(cls):

brewman/routers/auth/role.py

@@ -77,14 +77,14 @@ def update(
         )
 
 
-def add_permissions(group: Role, permissions: List[schemas.PermissionItem], db):
+def add_permissions(role: Role, permissions: List[schemas.PermissionItem], db):
     for permission in permissions:
-        gp = [p for p in group.roles if p.id == permission.id_]
+        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:
-            group.roles.append(db.query(Role).filter(Role.id == permission.id_).one())
+            role.permissions.append(db.query(Permission).filter(Permission.id == permission.id_).one())
         elif not permission.enabled and gp:
-            group.roles.remove(gp)
+            role.permissions.remove(gp)
 
 
 @router.delete("/{id_}")
@@ -124,7 +124,7 @@ 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"])):
     return [
-        {"id": item.id, "name": item.name, "permissions": [p.name for p in sorted(item.roles, 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()
     ]
 
@@ -150,13 +150,13 @@ def role_info(item: Optional[Role], db):
         }
     else:
         return {
-            "id": item.id_,
+            "id": item.id,
             "name": item.name,
             "permissions": [
                 {
                     "id": item.id,
                     "name": item.name,
-                    "enabled": True if item in item.roles else False,
+                    "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

@@ -54,25 +54,23 @@ def save(
         )
 
 
-@router.get("/me", response_model=schemas.Role)
+@router.get("/me", response_model=schemas.User)
 def show_me(
-    id_: uuid.UUID,
     db: Session = Depends(get_db),
-    user: User = Depends(get_user),
+    user: UserToken = Depends(get_user),
 ):
-    item = db.query(Role).filter(Role.id_ == id_).first()
+    item = db.query(User).filter(User.id == user.id_).first()
     return user_info(item, db, user)
 
 
 @router.put("/me", response_model=schemas.User)
 def update_me(
-    id_: uuid.UUID,
     data: schemas.UserIn,
     db: Session = Depends(get_db),
-    user: User = Depends(get_user),
+    user: UserToken = Depends(get_user),
 ):
     try:
-        item: User = db.query(User).filter(User.id_ == id_).first()
+        item: User = db.query(User).filter(User.id == user.id_).first()
         if "advanced-delete" in user.permissions:
             item.name = data.name
             item.locked_out = data.locked_out
@@ -103,7 +101,7 @@ def update(
     user: UserToken = Security(get_user, scopes=["users"]),
 ):
     try:
-        item: User = db.query(User).filter(User.id_ == id_).first()
+        item: User = db.query(User).filter(User.id == id_).first()
         item.name = data.name
         if data.password and item.password != data.password:
             item.password = data.password
@@ -127,10 +125,10 @@ def update(
 
 def add_roles(user: User, roles: List[schemas.RoleItem], db: Session):
     for role in roles:
-        ug = [g for g in user.roles if g.id_ == role.id_]
+        ug = [g for g in user.roles if g.id == role.id_]
         ug = None if len(ug) == 0 else ug[0]
         if role.enabled and ug is None:
-            user.roles.append(db.query(Role).filter(Role.id_ == role.id_).one())
+            user.roles.append(db.query(Role).filter(Role.id == role.id_).one())
         elif not role.enabled and ug:
             user.roles.remove(ug)
 
@@ -142,7 +140,7 @@ def delete(
         user: UserToken = Security(get_user, scopes=["users"]),
 ):
     try:
-        item: Role = db.query(Role).filter(Role.id_ == id_).first()
+        item: User = db.query(User).filter(User.id == id_).first()
         if item is None:
             raise HTTPException(
                 status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
@@ -172,13 +170,13 @@ 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"])):
     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: User = 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)
@@ -191,29 +189,29 @@ 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 = db.query(User).filter(User.id == id_).first()
     return user_info(item, db, user)
 
 
-def user_info(item: Optional[User], db: Session, user: User):
+def user_info(item: Optional[User], db: Session, user: UserToken):
     if item is None:
         return {
             "name": "", "lockedOut": False, "roles": [
-                {"id": r.id_, "name": r.name, "enabled": False}
+                {"id": r.id, "name": r.name, "enabled": False}
                 for r in db.query(Role).order_by(Role.name).all()
             ]
         }
     else:
         return {
-            "id": item.id_,
+            "id": item.id,
             "name": item.name,
             "password": "",
             "lockedOut": item.locked_out,
             "roles": [
                 {
-                    "id": r.id_,
+                    "id": r.id,
                     "name": r.name,
-                    "enabled": True if r in r.roles else False,
+                    "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 [],

brewman/routers/login.py

@@ -43,8 +43,8 @@ async def login_for_access_token(
                 set(
                     [
                         p.name.replace(" ", "-").lower()
-                        for g in user.groups
+                        for r in user.roles
-                        for p in g.roles
+                        for p in r.permissions
                     ]
                 )
             ),