mirror of
https://github.com/ZTatman/myst.git
synced 2026-11-21 12:27:59 +00:00
262 lines
9.2 KiB
Python
262 lines
9.2 KiB
Python
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]] = []
|
|
if step == "commit":
|
|
ref = await forgejo.get_branch_tip(app_settings, access_token, owner, repo, ref)
|
|
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
|