Add base for members

backend/app/api/main.py

@@ -5,6 +5,7 @@ from app.api.routes import (
     teams,
     associations,
     divisions,
+    members,
     login,
     private,
     users,
@@ -22,6 +23,7 @@ api_router.include_router(events.router)
 api_router.include_router(teams.router)
 api_router.include_router(associations.router)
 api_router.include_router(divisions.router)
+api_router.include_router(members.router)
 
 
 if settings.ENVIRONMENT == "local":

backend/app/api/routes/members.py

@@ -0,0 +1,208 @@
+from typing import Any
+
+import sqlalchemy
+from fastapi import APIRouter, HTTPException, status
+from sqlmodel import func, select, and_, or_, SQLModel
+from sqlalchemy.orm import joinedload
+
+from app.api.deps import CurrentUser, SessionDep
+from app.models.base import (
+    ApiTags,
+    Message,
+    RowId,
+)
+from app.models.member import (
+    Member,
+    MemberCreate,
+    MemberUpdate,
+    MemberPublic,
+    MembersPublic,
+    MemberTeamLink,
+)
+
+from app.models.event import Event, EventUserLink
+from app.models.team import Team
+from app.models.user import (
+    PermissionModule,
+    PermissionPart,
+    PermissionRight,
+)
+
+router = APIRouter(prefix="/members", tags=[ApiTags.MEMBERS])
+
+
+# region # Members #############################################################
+
+def load_member(
+    session: SessionDep,
+    current_user: CurrentUser,
+    id: RowId | None = None,
+    module: PermissionModule = PermissionModule.MEMBER,
+    part: PermissionPart = PermissionPart.ADMIN,
+    user_rights: PermissionRight | None = None,
+    event_rights: PermissionRight | None = PermissionRight.MANAGE_MEMBERS,
+) -> Member | None:
+    member = session.get(Member, id)
+
+    if id and not member:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Member not found")
+
+    no_links = True
+    valid = False
+    # Global member permissions
+    if current_user.has_permissions(module=module, part=part, rights=user_rights):
+        # Also valid for create new
+        valid = True
+
+    # Own member items
+    elif hasattr(member, "user") and member.user and member.user == current_user:
+        valid = True
+
+    # Event member permissions
+    elif hasattr(member, "team_links"):
+        for link in member.team_links:
+            team = link.team
+            if team and team.event:
+                no_links = False
+                if team.event.user_has_rights(user=current_user, rights=event_rights):
+                    valid = True
+                    break
+
+    # Not yet linked, or unlinked member
+    if no_links and hasattr(member, "created_by") and member.created_by == current_user.id:
+        valid = True
+
+    if not valid:
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Not enough permissions")
+
+    return member
+
+
+@router.get("/", response_model=MembersPublic)
+def read_members(
+    session: SessionDep, current_user: CurrentUser, skip: int = 0, limit: int = 100
+) -> Any:
+    """
+    Retrieve all members.
+    """
+
+    if current_user.has_permissions(
+        module=PermissionModule.MEMBER,
+        part=PermissionPart.ADMIN,
+        rights=PermissionRight.READ,
+    ):
+        data_query = (
+            select(Member)
+        )
+    else:
+        data_query = (
+            select(Member)
+            .outerjoin(MemberTeamLink, MemberTeamLink.member_id == Member.id)
+            .outerjoin(Team, MemberTeamLink.team_id == Team.id)
+            .outerjoin(Event, Team.event_id == Event.id)
+            .outerjoin(EventUserLink, EventUserLink.event_id == Event.id)
+            .where(
+                or_(
+                    # Own member
+                    Member.id == current_user.member_id,
+
+                    # Created by user and unlinked
+                    and_(
+                        Member.created_by == current_user.id,
+                        MemberTeamLink.team_id == None
+                    ),
+
+                    # Event permissions via team -> event -> EventUserLink
+                    and_(
+                        EventUserLink.user_id == current_user.id,
+                        # FIXME: EventUserLink.rights.op("&")(PermissionRight.MANAGE_MEMBERS) != 0
+                    ),
+                )
+            )
+        )
+
+    # Cache as subquery
+    data_sub_query = data_query.subquery()
+    aliased_member = sqlalchemy.orm.aliased(Member, data_sub_query)
+
+    # Count using subquery
+    count = session.exec(
+        select(func.count()).select_from(data_sub_query)
+    ).one()
+
+    # Paginated data query using same subquery
+    data = session.exec(
+        select(aliased_member).offset(skip).limit(limit)
+    ).all()
+
+    return MembersPublic(count=count, data=data)
+
+
+@router.get("/{id}", response_model=MemberPublic)
+def read_member(session: SessionDep, current_user: CurrentUser, id: RowId) -> Any:
+    """
+    Get member by ID.
+    """
+    member = load_member(
+        session=session,
+        current_user=current_user,
+        id=id,
+        user_rights=PermissionRight.READ,
+    )
+
+    return member
+
+
+@router.post("/", response_model=MemberPublic)
+def create_member(
+    *, session: SessionDep, current_user: CurrentUser, member_in: MemberCreate
+) -> Any:
+    """
+    Create new member.
+    """
+
+    load_member(
+        session=session,
+        current_user=current_user,
+        user_rights=PermissionRight.CREATE,
+    )
+
+    member = Member.create(create_obj=member_in, session=session, user=current_user)
+    return member
+
+
+@router.put("/{id}", response_model=MemberPublic)
+def update_member(
+    *, session: SessionDep, current_user: CurrentUser, id: RowId, member_in: MemberUpdate
+) -> Any:
+    """
+    Update a member.
+    """
+    member = load_member(
+        session=session,
+        current_user=current_user,
+        id=id,
+        user_rights=PermissionRight.UPDATE,
+    )
+
+    member = Member.update(db_obj=member, in_obj=member_in, session=session)
+    return member
+
+
+@router.delete("/{id}")
+def delete_member(session: SessionDep,current_user: CurrentUser, id: RowId) -> Message:
+    """
+    Delete a member.
+    """
+    member = load_member(
+        session=session,
+        current_user=current_user,
+        id=id,
+        user_rights=PermissionRight.DELETE,
+    )
+
+    session.delete(member)
+    session.commit()
+    return Message(message="Member deleted successfully")
+
+# endregion

backend/app/api/routes/private.py

@@ -17,7 +17,6 @@ router = APIRouter(tags=[ApiTags.PRIVATE], prefix="/private")
 class PrivateUserCreate(BaseModel):
     email: str
     password: str
-    full_name: str
     is_verified: bool = False
 
 
@@ -29,7 +28,6 @@ def create_user(user_in: PrivateUserCreate, session: SessionDep) -> Any:
 
     user = User(
         email=user_in.email,
-        full_name=user_in.full_name,
         hashed_password=get_password_hash(user_in.password),
     )
 

backend/app/api/routes/teams.py

@@ -4,11 +4,13 @@ from fastapi import APIRouter, HTTPException, status
 from sqlmodel import func, select
 
 from app.api.deps import CurrentUser, SessionDep
+from app.api.routes.members import load_member
 from app.models.base import (
     ApiTags,
     Message,
     RowId,
 )
+from app.models.member import MemberTeamLink, MemberTeamLinkCreate, MemberTeamLinkUpdate
 from app.models.team import (
     Team,
     TeamCreate,
@@ -263,3 +265,136 @@ def delete_team_division_link(session: SessionDep, current_user: CurrentUser, id
     return Message(message="Division deleted from team successfully")
 
 # endregion
+
+# region # Teams / Members #####################################################
+
+def load_member_link(team: Team, member_id: RowId):
+    link = next((link for link in team.member_links if link.member_id == member_id), None)
+    if not link:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Member not found")
+
+    return link
+
+
+@router.get("/{team_id}/members", response_model=TeamsPublic)
+def read_team_member_links(
+    session: SessionDep, current_user: CurrentUser, team_id: RowId, skip: int = 0, limit: int = 100
+) -> Any:
+    """
+    Retrieve all member links from a teams.
+    """
+
+    if current_user.has_permissions(
+        module=PermissionModule.TEAM,
+        part=PermissionPart.ADMIN,
+        rights=PermissionRight.READ,
+    ):
+        data_query = (
+            select(MemberTeamLink)
+            .where(MemberTeamLink.team_id == team_id)
+        )
+    else:
+        data_query = (
+            select(MemberTeamLink)
+            .join(Team, Team.id == MemberTeamLink.team_id)
+            .join(EventUserLink, EventUserLink.event_id == Team.event_id)
+            .where(
+                MemberTeamLink.team_id == team_id,
+                EventUserLink.user_id == current_user.id,
+                # FIXME: (EventUserLink.rights & (PermissionRight.MANAGE_MEMBERS)) > 0
+            )
+        )
+
+    count = session.exec(select(func.count()).select_from(data_query.subquery())).one()
+    data = session.exec(data_query.offset(skip).limit(limit)).all()
+    return TeamsPublic(data=data, count=count)
+
+
+@router.get("/{team_id}/members/{member_id}", response_model=TeamPublic)
+def read_team_member_link(session: SessionDep, current_user: CurrentUser, team_id: RowId, member_id: RowId) -> Any:
+    """
+    Get member link by member ID.
+    """
+    team = load_team(
+        session=session,
+        current_user=current_user,
+        id=team_id,
+        user_rights=PermissionRight.MANAGE_MEMBERS,
+        event_rights=PermissionRight.MANAGE_MEMBERS,
+    )
+
+    link = load_member_link(team=team, member_id=member_id)
+
+    return link
+
+
+@router.post("/{team_id}/members", response_model=TeamPublic)
+def create_team_member_link(
+    *, session: SessionDep, current_user: CurrentUser, team_id: RowId, link_in: MemberTeamLinkCreate
+) -> Any:
+    """
+    Create new team.
+    """
+
+    team = load_team(
+        session=session,
+        current_user=current_user,
+        id=team_id,
+        user_rights=PermissionRight.MANAGE_MEMBERS,
+        event_rights=PermissionRight.MANAGE_MEMBERS,
+    )
+
+    # Check if user has rights for current status of the member
+    load_member(
+        session=session,
+        current_user=current_user,
+        id=link_in.member_id,
+        user_rights=PermissionRight.MANAGE_MEMBERS,
+    )
+
+    link = MemberTeamLink.create(session=session, create_obj=link_in, team=team)
+
+    return link
+
+
+@router.put("/{team_id}/members/{member_id}", response_model=TeamPublic)
+def update_team_member_link(
+    *, session: SessionDep, current_user: CurrentUser, team_id: RowId, member_id: RowId, link_in: MemberTeamLinkUpdate
+) -> Any:
+    """
+    Update a team member link.
+    """
+    team = load_team(
+        session=session,
+        current_user=current_user,
+        id=team_id,
+        user_rights=PermissionRight.MANAGE_MEMBERS,
+        event_rights=PermissionRight.MANAGE_MEMBERS,
+    )
+
+    link = load_member_link(team=team, member_id=member_id)
+    link = MemberTeamLink.update(session=session, db_obj=link, in_obj=link_in)
+
+    return link
+
+
+@router.delete("/{team_id}/members/{member_id}")
+def delete_team_member_link(session: SessionDep,current_user: CurrentUser, team_id: RowId, member_id: RowId) -> Message:
+    """
+    Delete a team member link.
+    """
+    team = load_team(
+        session=session,
+        current_user=current_user,
+        id=team_id,
+        user_rights=PermissionRight.MANAGE_MEMBERS,
+        event_rights=PermissionRight.MANAGE_MEMBERS,
+    )
+
+    link = load_member_link(team=team, member_id=member_id)
+
+    session.delete(link)
+    session.commit()
+    return Message(message="Team member link deleted successfully")
+
+# endregion

backend/app/api/routes/users.py

@@ -19,6 +19,7 @@ from app.models.apikey import (
     ApiKeysPublic,
 )
 from app.models.base import ApiTags, Message, RowId
+from app.models.member import MemberPublic, MemberUpdate, Member
 from app.models.user import (
     PermissionModule,
     PermissionPart,
@@ -195,6 +196,37 @@ def read_user_me(current_user: CurrentUser) -> Any:
     return current_user
 
 
+@router.get("/me/member", response_model=MemberPublic, tags=[ApiTags.MEMBERS])
+def read_user_me_member(current_user: CurrentUser) -> Any:
+    """
+    Get current user member.
+    """
+    return current_user.member
+
+
+@router.put("/me/member", response_model=MemberPublic, tags=[ApiTags.MEMBERS])
+def update_user_me_member(
+    *, session: SessionDep, current_user: CurrentUser, member_in: MemberUpdate
+) -> Any:
+    """
+    Get current user member.
+    """
+    member = session.get(Member, current_user.member_id)
+    data_obj = member_in.model_dump(exclude_unset=True)
+
+    if not member:
+        member = Member.model_validate(data_obj)
+        current_user.member_id = member.id
+        session.add(current_user)
+    else:
+        member.sqlmodel_update(data_obj)
+    session.add(member)
+    session.commit()
+    session.refresh(member)
+
+    return member
+
+
 @router.delete("/me", response_model=Message)
 def delete_user_me(session: SessionDep, current_user: CurrentUser) -> Any:
     """