from itertools import count from typing import Annotated, Literal from fastapi import APIRouter, Depends, HTTPException, Path, Query, Request, status from fastapi.responses import HTMLResponse, Response from sqlalchemy import select from sqlalchemy.ext.asyncio import AsyncSession from app.auth.crypto import decrypt_token from app.auth.session import get_current_session from app.clients import forgejo from app.deps import get_db from app.models.app_settings import AppSettings from app.models.session import Session as UserBrowserSession from app.models.user import LinkedIdentity from app.settings import get_app_settings, get_fernet from app.templating import templates router = APIRouter(prefix="/links", tags=["repositories"]) picker_router = APIRouter(prefix="/dashboard/snapshot-picker", include_in_schema=False) async def get_forgejo_token( sess: Annotated[UserBrowserSession, Depends(get_current_session)], ) -> str: """Decrypt the current user's Forgejo access token. Args: sess: The authenticated browser session. Returns: The decrypted Forgejo access token. Raises: HTTPException: If no token is registered, or it cannot be decrypted. """ encrypted_token = sess.user.pat_encrypted if encrypted_token is None: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="Personal access token not found. Please register one and try again.", ) try: return decrypt_token(get_fernet(), encrypted_token) except ValueError: raise HTTPException( status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="Stored Forgejo token cannot be decrypted. Reconnect your account in settings.", ) from None async def get_forgejo_owner( sess: Annotated[UserBrowserSession, Depends(get_current_session)], db: Annotated[AsyncSession, Depends(get_db)], ) -> str: """Resolve the {owner} path value from the user's linked identity. Owner is derived server-side rather than taken from the request so a caller cannot address repositories belonging to someone else. Args: sess: The authenticated browser session. db: A request-scoped database session. Returns: The Forgejo username linked to the signed-in user. Raises: HTTPException: If the session has no linked Forgejo identity. """ stmt = select(LinkedIdentity).where( LinkedIdentity.user_id == sess.user_id, LinkedIdentity.provider == "forgejo" ) result = await db.execute(stmt) identity = result.scalar_one_or_none() if identity is None: raise HTTPException( status_code=status.HTTP_403_FORBIDDEN, detail="No linked identity for forgejo was found. Please sign-in and try again.", ) return identity.provider_username @router.get("/repositories") async def get_repositories( app_settings: Annotated[AppSettings, Depends(get_app_settings)], access_token: Annotated[str, Depends(get_forgejo_token)], owner: Annotated[str, Depends(get_forgejo_owner)], limit: Annotated[int, Query(ge=1, le=50)] = 30, page: Annotated[int, Query(ge=1)] = 1, ): """Get a page of repositories owned by the linked Forgejo account.""" repo_page = await forgejo.get_repos( app_settings, access_token, owner=owner, limit=limit, page=page ) return repo_page.repos @router.get("/repositories/{repo}/branches") async def get_repository_branches( app_settings: Annotated[AppSettings, Depends(get_app_settings)], access_token: Annotated[str, Depends(get_forgejo_token)], owner: Annotated[str, Depends(get_forgejo_owner)], repo: Annotated[str, Path(min_length=1, description="The name of the repository")], limit: int = 10, page: int = 1, ): """List the branches of the signed-in user's repository.""" branches = await forgejo.get_branches( app_settings, access_token, owner, repo, limit=limit, page=page ) return branches @router.get("/repositories/{repo}/commits") async def get_repository_commits( app_settings: Annotated[AppSettings, Depends(get_app_settings)], access_token: Annotated[str, Depends(get_forgejo_token)], owner: Annotated[str, Depends(get_forgejo_owner)], repo: Annotated[str, Path(min_length=1, description="The name of the repository")], ref: Annotated[str, Query(description="Branch name, commit sha, or tag")] = "main", limit: int = 10, page: int = 1, ): """List the commits of the signed-in user's repository at a ref.""" commits = await forgejo.get_commits( app_settings, access_token, owner, repo, ref=ref, limit=limit, page=page ) return commits RECENT_COMMITS = 30 PICKER_PAGE_SIZE = 50 @picker_router.get("/preview", response_class=HTMLResponse) async def preview_snapshot( request: Request, _session: Annotated[UserBrowserSession, Depends(get_current_session)], repo: Annotated[str, Query(max_length=255)] = "", ref: Annotated[str, Query(max_length=1024)] = "", commit: Annotated[str, Query(pattern=r"^(?:[a-f0-9]{40}|[a-f0-9]{64})?$")] = "", ) -> Response: """Render a display-only preview, or clear it when no snapshot is supplied.""" confirmed = bool(repo and ref and commit) return templates.TemplateResponse( request, "snapshot_preview.html", {"repo": repo, "ref": ref, "commit": commit, "confirmed": confirmed}, headers={"Cache-Control": "no-store"}, block_name="preview_confirmation" if confirmed else "selected_snapshot", ) @picker_router.get("/{step}", response_class=HTMLResponse) async def get_snapshot_picker_step( request: Request, step: Literal["repository", "branch", "commit"], app_settings: Annotated[AppSettings, Depends(get_app_settings)], session: Annotated[UserBrowserSession, Depends(get_current_session)], db: Annotated[AsyncSession, Depends(get_db)], repo: Annotated[str, Query(max_length=255)] = "", ref: Annotated[str, Query(max_length=1024)] = "", ) -> Response: """Load dependent picker options without changing the JSON listing API.""" if step != "repository" and (repo in {".", ".."} or "/" in repo or "\\" in repo): raise HTTPException(status_code=400, detail="Invalid repository name.") options: list[tuple[str, str]] = [] error = False message = "" try: if step == "repository" or (repo and (step == "branch" or ref)): access_token = await get_forgejo_token(session) owner = await get_forgejo_owner(session, db) options = await _snapshot_options( step, app_settings, access_token, owner, repo, ref ) if not options: message = { "repository": "No repositories found.", "branch": "No branches found.", "commit": "No commits found.", }[step] except HTTPException as exc: if exc.status_code not in {403, 502, 503}: raise error = True message = str(exc.detail) return templates.TemplateResponse( request, "snapshot_picker.html", { "step": step, "options": options, "message": message, "error": error, "repo": repo, "ref": ref, }, headers={"Cache-Control": "no-store"}, block_name={ "repository": "picker_steps", "branch": "branch_steps", "commit": "commit_step", }[step], ) async def _snapshot_options( step: Literal["repository", "branch", "commit"], app_settings: AppSettings, access_token: str, owner: str, repo: str, ref: str, ) -> list[tuple[str, str]]: options: list[tuple[str, str]] = [] for page in count(1): if step == "repository": result = await forgejo.get_repos( app_settings, access_token, owner=owner, page=page, limit=PICKER_PAGE_SIZE, ) options.extend((item.repo_name, item.repo_name) for item in result.repos) if not result.has_next_page or not result.repos: break elif step == "branch": branches = await forgejo.get_branches( app_settings, access_token, owner, repo, page=page, limit=PICKER_PAGE_SIZE, ) if not branches: break options.extend((item.name, item.name) for item in branches) else: commits = await forgejo.get_commits( app_settings, access_token, owner, repo, ref=ref, page=page, limit=RECENT_COMMITS, ) if not commits: break for item in commits[: RECENT_COMMITS - len(options)]: subject = item.message.partition("\n")[0] options.append((item.id, f"{item.id[:7]} — {subject}")) if len(options) == RECENT_COMMITS: break return options