company flows

backend/app/routers/aliases.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_postgres_session
+from app.deps.org_manager import require_org_manager
+from app.models import Account
+from app.schemas import MailAliasCreate, MailAliasListResponse, MailAliasRead
+from app.services.mail_aliases import create_mail_alias, list_mail_aliases
+
+router = APIRouter(prefix="/aliases", tags=["aliases"])
+
+
+@router.get("", response_model=MailAliasListResponse)
+async def get_aliases(
+    manager: Account = Depends(require_org_manager),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> MailAliasListResponse:
+    items, counts = await list_mail_aliases(session, manager.company_domain)
+    return MailAliasListResponse(items=items, counts=counts)
+
+
+@router.post("", response_model=MailAliasRead, status_code=status.HTTP_201_CREATED)
+async def add_alias(
+    payload: MailAliasCreate,
+    manager: Account = Depends(require_org_manager),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> MailAliasRead:
+    try:
+        alias = await create_mail_alias(session, manager=manager, payload=payload)
+        await session.commit()
+        return alias
+    except ValueError as error:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(error),
+        ) from error
+    except IntegrityError as error:
+        await session.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="That alias could not be created.",
+        ) from error

backend/app/routers/auth.py

@@ -176,6 +176,8 @@ async def register(
         date_of_birth=payload.date_of_birth,
         phone_number=phone_number,
         company_domain=company_domain,
+        org_role="owner" if company_domain else "user",
+        member_status="active",
         password_hash=password_hash.hash(payload.password),
     )
     session.add(account)

backend/app/routers/groups.py

@@ -0,0 +1,43 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_postgres_session
+from app.deps.org_manager import require_org_manager
+from app.models import Account
+from app.schemas import MailGroupCreate, MailGroupListResponse, MailGroupRead
+from app.services.mail_groups import create_mail_group, list_mail_groups
+
+router = APIRouter(prefix="/groups", tags=["groups"])
+
+
+@router.get("", response_model=MailGroupListResponse)
+async def get_groups(
+    manager: Account = Depends(require_org_manager),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> MailGroupListResponse:
+    items, counts = await list_mail_groups(session, manager.company_domain)
+    return MailGroupListResponse(items=items, counts=counts)
+
+
+@router.post("", response_model=MailGroupRead, status_code=status.HTTP_201_CREATED)
+async def add_group(
+    payload: MailGroupCreate,
+    manager: Account = Depends(require_org_manager),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> MailGroupRead:
+    try:
+        group = await create_mail_group(session, manager=manager, payload=payload)
+        await session.commit()
+        return group
+    except ValueError as error:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(error),
+        ) from error
+    except IntegrityError as error:
+        await session.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="That group could not be created.",
+        ) from error

backend/app/routers/people.py

@@ -0,0 +1,66 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_postgres_session
+from app.models import Account
+from app.routers.auth import get_current_account, validate_password
+from app.schemas import OrgMemberCreate, OrgMemberListResponse, OrgMemberRead
+from app.services.org_members import (
+    can_manage_org_members,
+    create_org_member,
+    list_org_members,
+)
+
+router = APIRouter(prefix="/people", tags=["people"])
+
+
+async def require_org_manager(
+    account: Account = Depends(get_current_account),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> Account:
+    if not await can_manage_org_members(session, account):
+        raise HTTPException(
+            status_code=status.HTTP_403_FORBIDDEN,
+            detail="Only company admins can manage people.",
+        )
+    return account
+
+
+@router.get("", response_model=OrgMemberListResponse)
+async def get_people(
+    manager: Account = Depends(require_org_manager),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> OrgMemberListResponse:
+    items, counts = await list_org_members(session, manager.company_domain)
+    return OrgMemberListResponse(items=items, counts=counts)
+
+
+@router.post("", response_model=OrgMemberRead, status_code=status.HTTP_201_CREATED)
+async def add_person(
+    payload: OrgMemberCreate,
+    manager: Account = Depends(require_org_manager),
+    session: AsyncSession = Depends(get_postgres_session),
+) -> OrgMemberRead:
+    if not payload.send_invitation:
+        validate_password(payload.password or "")
+
+    try:
+        member = await create_org_member(
+            session,
+            manager=manager,
+            payload=payload,
+        )
+        await session.commit()
+        return member
+    except ValueError as error:
+        raise HTTPException(
+            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
+            detail=str(error),
+        ) from error
+    except IntegrityError as error:
+        await session.rollback()
+        raise HTTPException(
+            status_code=status.HTTP_409_CONFLICT,
+            detail="An account with those details already exists.",
+        ) from error