143 lines
5.7 KiB
Python
143 lines
5.7 KiB
Python
from sqlalchemy import select
|
|
from sqlalchemy.orm import Session
|
|
|
|
from backend.app.models.system import Menu, Role, User
|
|
|
|
|
|
class SystemRepository:
|
|
def get_user_by_username(self, session: Session, username: str) -> User | None:
|
|
stmt = select(User).where(User.username == username)
|
|
return session.execute(stmt).scalar_one_or_none()
|
|
|
|
def get_user(self, session: Session, user_id: int) -> User | None:
|
|
stmt = select(User).where(User.id == user_id)
|
|
return session.execute(stmt).scalar_one_or_none()
|
|
|
|
def create_user(self, session: Session, payload: dict) -> User:
|
|
user = User(
|
|
username=payload["username"],
|
|
password_hash=payload["password_hash"],
|
|
real_name=payload["real_name"],
|
|
mobile=payload.get("mobile") or "",
|
|
role_id=payload["role_id"],
|
|
status=payload.get("status", 1),
|
|
)
|
|
session.add(user)
|
|
session.flush()
|
|
return user
|
|
|
|
def update_user(self, user: User, payload: dict) -> User:
|
|
user.real_name = payload["real_name"]
|
|
user.mobile = payload.get("mobile") or ""
|
|
user.role_id = payload["role_id"]
|
|
user.status = payload.get("status", 1)
|
|
return user
|
|
|
|
def reset_password(self, user: User, password_hash: str) -> User:
|
|
user.password_hash = password_hash
|
|
return user
|
|
|
|
def get_role(self, session: Session, role_id: int) -> Role | None:
|
|
stmt = select(Role).where(Role.id == role_id)
|
|
return session.execute(stmt).scalar_one_or_none()
|
|
|
|
def get_role_by_code(self, session: Session, role_code: str) -> Role | None:
|
|
stmt = select(Role).where(Role.role_code == role_code)
|
|
return session.execute(stmt).scalar_one_or_none()
|
|
|
|
def create_role(self, session: Session, payload: dict) -> Role:
|
|
role = Role(
|
|
role_name=payload["role_name"],
|
|
role_code=payload["role_code"],
|
|
status=payload.get("status", 1),
|
|
remark=payload.get("remark"),
|
|
)
|
|
session.add(role)
|
|
session.flush()
|
|
return role
|
|
|
|
def update_role(self, role: Role, payload: dict) -> Role:
|
|
role.role_name = payload["role_name"]
|
|
role.status = payload.get("status", 1)
|
|
role.remark = payload.get("remark")
|
|
return role
|
|
|
|
def get_menu(self, session: Session, menu_id: int) -> Menu | None:
|
|
stmt = select(Menu).where(Menu.id == menu_id)
|
|
return session.execute(stmt).scalar_one_or_none()
|
|
|
|
def get_menu_by_permission_code(self, session: Session, permission_code: str) -> Menu | None:
|
|
stmt = select(Menu).where(Menu.permission_code == permission_code)
|
|
return session.execute(stmt).scalar_one_or_none()
|
|
|
|
def create_menu(self, session: Session, payload: dict) -> Menu:
|
|
menu = Menu(
|
|
parent_id=payload.get("parent_id", 0),
|
|
menu_name=payload["menu_name"],
|
|
menu_path=payload.get("menu_path") or "",
|
|
menu_type=payload.get("menu_type", "page"),
|
|
permission_code=payload["permission_code"],
|
|
icon=payload.get("icon"),
|
|
sort_no=payload.get("sort_no", 0),
|
|
status=payload.get("status", 1),
|
|
)
|
|
session.add(menu)
|
|
session.flush()
|
|
return menu
|
|
|
|
def update_menu(self, menu: Menu, payload: dict) -> Menu:
|
|
menu.parent_id = payload.get("parent_id", 0)
|
|
menu.menu_name = payload["menu_name"]
|
|
menu.menu_path = payload.get("menu_path") or ""
|
|
menu.menu_type = payload.get("menu_type", "page")
|
|
menu.permission_code = payload["permission_code"]
|
|
menu.icon = payload.get("icon")
|
|
menu.sort_no = payload.get("sort_no", 0)
|
|
menu.status = payload.get("status", 1)
|
|
return menu
|
|
|
|
def list_users(self, session: Session, filters: dict) -> list[tuple[User, Role | None]]:
|
|
stmt = select(User, Role).outerjoin(Role, User.role_id == Role.id)
|
|
|
|
if filters.get("username"):
|
|
stmt = stmt.where(User.username.contains(filters["username"]))
|
|
if filters.get("real_name"):
|
|
stmt = stmt.where(User.real_name.contains(filters["real_name"]))
|
|
if filters.get("mobile"):
|
|
stmt = stmt.where(User.mobile.contains(filters["mobile"]))
|
|
if filters.get("role_id") is not None:
|
|
stmt = stmt.where(User.role_id == filters["role_id"])
|
|
if filters.get("status") is not None:
|
|
stmt = stmt.where(User.status == filters["status"])
|
|
|
|
stmt = stmt.order_by(User.id.asc())
|
|
return list(session.execute(stmt).all())
|
|
|
|
def list_roles(self, session: Session, filters: dict) -> list[Role]:
|
|
stmt = select(Role)
|
|
|
|
if filters.get("role_name"):
|
|
stmt = stmt.where(Role.role_name.contains(filters["role_name"]))
|
|
if filters.get("role_code"):
|
|
stmt = stmt.where(Role.role_code.contains(filters["role_code"]))
|
|
if filters.get("status") is not None:
|
|
stmt = stmt.where(Role.status == filters["status"])
|
|
|
|
stmt = stmt.order_by(Role.id.asc())
|
|
return list(session.execute(stmt).scalars())
|
|
|
|
def count_active_users_by_role(self, session: Session, role_id: int) -> int:
|
|
stmt = select(User).where(User.role_id == role_id, User.status == 1)
|
|
return len(list(session.execute(stmt).scalars()))
|
|
|
|
def list_menus(self, session: Session, filters: dict) -> list[Menu]:
|
|
stmt = select(Menu)
|
|
|
|
if filters.get("status") is not None:
|
|
stmt = stmt.where(Menu.status == filters["status"])
|
|
if filters.get("menu_type"):
|
|
stmt = stmt.where(Menu.menu_type == filters["menu_type"])
|
|
|
|
stmt = stmt.order_by(Menu.sort_no.asc(), Menu.id.asc())
|
|
return list(session.execute(stmt).scalars())
|