bruno
7b2fa01b0a
- create_issue: utilise _issue_column() au lieu de hardcoder 'Backlog'
- update_issue_api: recalcule la colonne après changement de labels
- update_issue_api: utilise l'endpoint PUT /labels au lieu de PATCH (Gitea ignore labels dans PATCH)
- webhooks: utilise _issue_column() pour 'opened'/'reopened'
- saveIssueEdit: rafraîchit le board (HTMX) après édition au lieu de rouvrir la modale
- update_issue_labels: corrigé pour utiliser PUT /issues/{id}/labels (liste d'entiers)
301 lines
10 KiB
Python
301 lines
10 KiB
Python
"""FlowDeck — Gitea API client with caching."""
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from datetime import datetime, timedelta
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
from app.config import settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class GiteaClient:
|
|
"""Async Gitea API v1 client with simple TTL cache."""
|
|
|
|
def __init__(self) -> None:
|
|
self._base = f"{settings.gitea_url}/api/v1"
|
|
self._headers = {"Authorization": f"token {settings.gitea_token}"}
|
|
self._cache: dict[str, tuple[datetime, Any]] = {}
|
|
self._ttl = timedelta(seconds=settings.gitea_cache_ttl)
|
|
|
|
# ── cache helper ──
|
|
|
|
def _cached(self, key: str) -> Any | None:
|
|
entry = self._cache.get(key)
|
|
if entry and entry[0] > datetime.now():
|
|
return entry[1]
|
|
return None
|
|
|
|
def _set_cache(self, key: str, value: Any) -> None:
|
|
self._cache[key] = (datetime.now() + self._ttl, value)
|
|
|
|
# ── repos ──
|
|
|
|
async def get_user_repos(self, page: int = 1, limit: int = 30) -> list[dict]:
|
|
cache_key = f"repos:{page}:{limit}"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=15) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/user/repos",
|
|
headers=self._headers,
|
|
params={"page": page, "limit": limit, "sort": "updated", "order": "desc"},
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
async def get_org_repos(self, org: str, page: int = 1, limit: int = 20) -> list[dict]:
|
|
cache_key = f"org_repos:{org}:{page}:{limit}"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=15) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/orgs/{org}/repos",
|
|
headers=self._headers,
|
|
params={"page": page, "limit": limit},
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
async def get_user_orgs(self) -> list[dict]:
|
|
cache_key = "user_orgs"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/user/orgs", headers=self._headers
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
# ── issues ──
|
|
|
|
async def get_issues(
|
|
self, owner: str, repo: str, state: str = "all", page: int = 1, limit: int = 50
|
|
) -> list[dict]:
|
|
cache_key = f"issues:{owner}:{repo}:{state}:{page}:{limit}"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=15) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/issues",
|
|
headers=self._headers,
|
|
params={"state": state, "page": page, "limit": limit},
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
async def get_issue(self, owner: str, repo: str, issue_id: int) -> dict:
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/issues/{issue_id}",
|
|
headers=self._headers,
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
async def create_issue(
|
|
self, owner: str, repo: str, title: str, body: str = "",
|
|
labels: list[int] | None = None, milestone: int | None = None,
|
|
assignee: str = "",
|
|
) -> dict:
|
|
"""Create a new issue in Gitea."""
|
|
payload: dict[str, Any] = {"title": title, "body": body}
|
|
if labels:
|
|
payload["labels"] = labels
|
|
if milestone:
|
|
payload["milestone"] = milestone
|
|
if assignee:
|
|
payload["assignees"] = [assignee]
|
|
|
|
self._invalidate_issue_cache(owner, repo)
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.post(
|
|
f"{self._base}/repos/{owner}/{repo}/issues",
|
|
headers=self._headers,
|
|
json=payload,
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
async def update_issue(
|
|
self, owner: str, repo: str, issue_id: int, **kwargs
|
|
) -> dict:
|
|
"""Update an issue (title, body, state, labels, milestone, assignees)."""
|
|
self._invalidate_issue_cache(owner, repo)
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.patch(
|
|
f"{self._base}/repos/{owner}/{repo}/issues/{issue_id}",
|
|
headers=self._headers,
|
|
json=kwargs,
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
async def update_issue_labels(
|
|
self, owner: str, repo: str, issue_id: int, labels: list[int]
|
|
) -> list[dict]:
|
|
"""Replace all labels on an issue (PUT endpoint)."""
|
|
self._invalidate_issue_cache(owner, repo)
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.put(
|
|
f"{self._base}/repos/{owner}/{repo}/issues/{issue_id}/labels",
|
|
headers=self._headers,
|
|
json={"labels": labels},
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
async def close_issue(self, owner: str, repo: str, issue_id: int) -> dict:
|
|
return await self.update_issue(owner, repo, issue_id, state="closed")
|
|
|
|
async def reopen_issue(self, owner: str, repo: str, issue_id: int) -> dict:
|
|
return await self.update_issue(owner, repo, issue_id, state="open")
|
|
|
|
async def get_issue_comments(
|
|
self, owner: str, repo: str, issue_id: int
|
|
) -> list[dict]:
|
|
"""Get comments for an issue."""
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/issues/{issue_id}/comments",
|
|
headers=self._headers,
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
def _invalidate_issue_cache(self, owner: str, repo: str) -> None:
|
|
prefix = f"issues:{owner}:{repo}:"
|
|
to_delete = [k for k in self._cache if k.startswith(prefix)]
|
|
for k in to_delete:
|
|
del self._cache[k]
|
|
|
|
# ── labels ──
|
|
|
|
async def get_labels(self, owner: str, repo: str) -> list[dict]:
|
|
cache_key = f"labels:{owner}:{repo}"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/labels",
|
|
headers=self._headers,
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
# ── milestones ──
|
|
|
|
async def get_milestones(
|
|
self, owner: str, repo: str, state: str = "open"
|
|
) -> list[dict]:
|
|
cache_key = f"milestones:{owner}:{repo}:{state}"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/milestones",
|
|
headers=self._headers,
|
|
params={"state": state},
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
# ── webhooks ──
|
|
|
|
async def list_webhooks(self, owner: str, repo: str) -> list[dict]:
|
|
"""List webhooks for a repo."""
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/hooks",
|
|
headers=self._headers,
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
async def create_webhook(
|
|
self, owner: str, repo: str, url: str, secret: str,
|
|
events: list[str] | None = None,
|
|
) -> dict:
|
|
"""Create a webhook for a repo."""
|
|
if events is None:
|
|
events = ["issues", "pull_request", "repository", "issue_comment"]
|
|
payload = {
|
|
"type": "gitea",
|
|
"config": {
|
|
"url": url,
|
|
"content_type": "json",
|
|
"secret": secret,
|
|
},
|
|
"events": events,
|
|
"active": True,
|
|
}
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.post(
|
|
f"{self._base}/repos/{owner}/{repo}/hooks",
|
|
headers=self._headers,
|
|
json=payload,
|
|
)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
async def delete_webhook(self, owner: str, repo: str, hook_id: int) -> bool:
|
|
"""Delete a webhook."""
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.delete(
|
|
f"{self._base}/repos/{owner}/{repo}/hooks/{hook_id}",
|
|
headers=self._headers,
|
|
)
|
|
return resp.status_code == 204
|
|
|
|
# ── assignees/collaborators ──
|
|
|
|
async def get_collaborators(self, owner: str, repo: str) -> list[dict]:
|
|
"""List repo collaborators."""
|
|
cache_key = f"collaborators:{owner}:{repo}"
|
|
cached = self._cached(cache_key)
|
|
if cached:
|
|
return cached
|
|
|
|
async with httpx.AsyncClient(timeout=10) as client:
|
|
resp = await client.get(
|
|
f"{self._base}/repos/{owner}/{repo}/collaborators",
|
|
headers=self._headers,
|
|
)
|
|
resp.raise_for_status()
|
|
data = resp.json()
|
|
self._set_cache(cache_key, data)
|
|
return data
|
|
|
|
|
|
# ── singleton ──
|
|
|
|
gitea = GiteaClient()
|