pygitweb 0.1.0__py3-none-any.whl

pygitweb/tasks.py

@@ -0,0 +1,595 @@
+"""
+Task-related routes: Task, comment, board creation, listing, and management.
+Data is stored in the repo ODB/RefDB via pygittools.tasks (Board, Task, Comment).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import time
+from typing import Annotated, Any
+
+import pygit2
+from fastapi import APIRouter, Depends, HTTPException, Query, Request
+from fastapi.responses import JSONResponse
+
+from pygittools.tasks import (
+	BOARD_REF_PREFIX,
+	TASK_REF_PREFIX,
+	Board,
+	Comment,
+	Task,
+	get_board,
+	get_comment,
+	get_task,
+	get_task_by_oid,
+)
+from pygitweb.auth import (
+	access_token_from_request,
+	principal_from_session,
+	require_active_user_if_auth_enabled,
+	require_permission,
+)
+from pygitweb.config import settings
+from pygitweb.dependencies import ValidatedQueryProject
+from pygitweb.gravatar import gravatar_url
+from pygitweb.permissions import Permission, PermissionPrincipal
+
+# Well-known empty tree OID for boards/tasks when repo has no HEAD
+EMPTY_TREE_OID = pygit2.Oid(hex="4b825dc642cb6eb9a060e54bf8d69288fbee4904")
+
+
+def _board_ref(name: str) -> str:
+	return f"{BOARD_REF_PREFIX}{name}"
+
+
+def _task_ref(task_id: str) -> str:
+	return f"{TASK_REF_PREFIX}{task_id}"
+
+
+def _repo_head_or_empty(repo: pygit2.Repository) -> pygit2.Oid | str:
+	try:
+		return repo.head.target
+	except KeyError:
+		return EMPTY_TREE_OID
+
+
+def _sync_board_task_oid(
+	repo: pygit2.Repository,
+	board: str,
+	old_oid: str,
+	new_oid: pygit2.Oid | str,
+	*,
+	move_to_end: bool = False,
+) -> None:
+	"""Replace a task OID on the board after the task tag object was rewritten."""
+	b = get_board(repo, _board_ref(board))
+	if not b or not getattr(b, "tasks", None):
+		return
+	new_oid_str = str(new_oid)
+	tasks_list = [new_oid_str if o == old_oid else o for o in b.tasks]
+	if move_to_end and new_oid_str in tasks_list:
+		tasks_list = [o for o in tasks_list if o != new_oid_str] + [new_oid_str]
+	b.tasks = tasks_list
+	b.update_message()
+	b.write(repo)
+
+
+def _task_from_board_entry(
+	repo: pygit2.Repository,
+	oid_hex: str | pygit2.Oid,
+	*,
+	board: str | None = None,
+) -> Task | None:
+	"""
+	Load a task listed on a board by OID.
+
+	Board entries can lag behind ``refs/tags/tasks/…`` after a task rewrite (e.g. a new
+	comment). When the ref points at a newer tag object, return that version and repair
+	the board list when ``board`` is provided.
+	"""
+	oid = pygit2.Oid(hex=oid_hex) if isinstance(oid_hex, str) else oid_hex
+	t = get_task_by_oid(repo, oid)
+	if not t or not t.name:
+		return t
+	try:
+		if t.name not in repo.references:
+			return t
+		current_oid = repo.references[t.name].resolve().target
+	except KeyError:
+		return t
+	if str(current_oid) == str(oid):
+		return t
+	t_current = get_task(repo, t.name)
+	if t_current and board:
+		_sync_board_task_oid(repo, board, str(oid), current_oid)
+	return t_current or t
+
+
+def create_board_for_project(
+	project: str,
+	name: str = "Tasks",
+	description: str = "",
+) -> str:
+	"""Create a board in the project repo. Returns the board ref. Raises HTTPException on error."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = _board_ref(name)
+	if ref in repo.references:
+		raise HTTPException(status_code=409, detail="Board already exists")
+	target = _repo_head_or_empty(repo)
+	board = Board(target, ref, tagger="", description=description)
+	board.write(repo)
+	return ref
+
+
+# ---------- Board Routes ----------
+
+board_router = APIRouter(tags=["boards"])
+
+
+@board_router.get(
+	"/list",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_active_user_if_auth_enabled)],
+)
+def boards_list(project: ValidatedQueryProject) -> JSONResponse:
+	"""List all boards for the project."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	refs = [
+		(ref_name, str(repo.references[ref_name].resolve().target))
+		for ref_name in repo.references
+		if ref_name.startswith(BOARD_REF_PREFIX)
+	]
+	boards = []
+	for ref_name, _ in refs:
+		try:
+			b = get_board(repo, ref_name)
+			if b:
+				boards.append({
+					"name": ref_name.replace(BOARD_REF_PREFIX, ""),
+					"description": getattr(b, "description", "") or "",
+					"task_count": len(getattr(b, "tasks", [])),
+				})
+		except (ValueError, KeyError):
+			continue
+	return JSONResponse(content=boards)
+
+
+@board_router.post(
+	"/create",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_permission(Permission.BOARDS, project_from_query=True))],
+)
+def boards_create(
+	project: ValidatedQueryProject,
+	name: str = Query(..., description="Board name"),
+	description: str = Query("", description="Board description"),
+) -> JSONResponse:
+	"""Create a new board."""
+	if not name or "/" in name or ".." in name:
+		raise HTTPException(status_code=400, detail="Invalid board name")
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = _board_ref(name)
+	if ref in repo.references:
+		raise HTTPException(status_code=409, detail="Board already exists")
+	target = _repo_head_or_empty(repo)
+	board = Board(target, ref, tagger="", description=description or "")
+	oid = board.write(repo)
+	return JSONResponse(content={"name": name, "ref": ref, "oid": str(oid)})
+
+
+@board_router.post(
+	"/delete",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_permission(Permission.BOARDS, project_from_query=True))],
+)
+def boards_delete(
+	project: ValidatedQueryProject,
+	name: str = Query(..., description="Board name"),
+) -> JSONResponse:
+	"""Delete a board (removes ref; tag object remains in ODB)."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = _board_ref(name)
+	if ref not in repo.references:
+		raise HTTPException(status_code=404, detail="Board not found")
+	repo.references.delete(ref)
+	return JSONResponse(content={"message": "Board deleted"})
+
+
+# ---------- Task Routes ----------
+
+task_router = APIRouter(tags=["tasks"])
+
+
+def _task_to_json(t: Task) -> dict[str, Any]:
+	return {
+		"ref": t.name,
+		"title": t.title,
+		"description": getattr(t, "description", "") or "",
+		"status": t.status.value if t.status else None,
+		"priority": t.priority.value if t.priority else None,
+		"assignee": t.assignee,
+		"due_date": t.due_date.isoformat() if t.due_date else None,
+		"created_at": t.created_at.isoformat() if t.created_at else None,
+		"updated_at": t.updated_at.isoformat() if t.updated_at else None,
+		"comments_count": len(getattr(t, "comments", [])),
+	}
+
+
+# Status order for board columns
+BOARD_STATUS_ORDER = ["TODO", "IN_PROGRESS", "IN_REVIEW", "DONE", "CANCELLED"]
+
+
+def get_board_tasks_grouped(
+	project: str,
+	board_name: str,
+) -> list[dict[str, Any]]:
+	"""
+	Return tasks for a board grouped by status for board view.
+	Returns a list of { "status": str, "label": str, "tasks": [ _task_to_json, ... ] }
+	in BOARD_STATUS_ORDER. Skips validation/auth (caller must validate project).
+	"""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = _board_ref(board_name)
+	b = get_board(repo, ref)
+	task_oids = getattr(b, "tasks", []) or []
+	by_status: dict[str, list[dict[str, Any]]] = {s: [] for s in BOARD_STATUS_ORDER}
+	for oid_hex in task_oids:
+		try:
+			t = _task_from_board_entry(repo, oid_hex, board=board_name)
+			if t:
+				d = _task_to_json(t)
+				status_key = (d.get("status") or "TODO") if d else "TODO"
+				if status_key not in by_status:
+					by_status[status_key] = []
+				by_status[status_key].append(d)
+		except (ValueError, KeyError, TypeError):
+			continue
+	return [
+		{
+			"status": s,
+			"label": s.replace("_", " ").title(),
+			"tasks": by_status.get(s, []),
+		}
+		for s in BOARD_STATUS_ORDER
+	]
+
+
+@task_router.get(
+	"/list",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_active_user_if_auth_enabled)],
+)
+def task_list(
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+) -> JSONResponse:
+	"""List all tasks on a board."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = _board_ref(board)
+	b = get_board(repo, ref)
+	if not b:
+		raise HTTPException(status_code=404, detail="Board not found")
+	task_oids = getattr(b, "tasks", [])
+	tasks = []
+	for oid_hex in task_oids:
+		try:
+			t = _task_from_board_entry(repo, oid_hex, board=board)
+			if t:
+				tasks.append(_task_to_json(t))
+		except (ValueError, KeyError, TypeError):
+			continue
+	return JSONResponse(content=tasks)
+
+
+@task_router.post(
+	"/create",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_permission(Permission.TASKS, project_from_query=True))],
+)
+def task_create(
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	title: str = Query(..., description="Task title"),
+	description: str = Query("", description="Task description"),
+	status: str = Query("TODO", description="Task status"),
+	priority: str = Query("LOW", description="Task priority"),
+	assignee: str = Query("", description="Assignee"),
+	due_date: str = Query("", description="Due date ISO"),
+) -> JSONResponse:
+	"""Create a new task on a board."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	board_ref = _board_ref(board)
+	b = get_board(repo, board_ref)
+	if not b:
+		raise HTTPException(status_code=404, detail="Board not found")
+	task_id = f"task_{int(time.time() * 1000)}"
+	ref = _task_ref(task_id)
+	target = _repo_head_or_empty(repo)
+	status_enum = getattr(Task.Status, status, None) or Task.Status.TODO
+	priority_enum = getattr(Task.Priority, priority, None) or Task.Priority.LOW
+	due = None
+	if due_date:
+		try:
+			from datetime import datetime
+
+			due = datetime.fromisoformat(due_date.replace("Z", "+00:00"))
+		except ValueError:
+			pass
+	task = Task(
+		target,
+		ref,
+		tagger="",
+		title=title,
+		description=description or "",
+		status=status_enum,
+		priority=priority_enum,
+		assignee=assignee or None,
+		due_date=due,
+	)
+	oid = task.write(repo)
+	b.tasks = getattr(b, "tasks", []) or []
+	b.tasks.append(str(oid))
+	b.update_message()
+	b.write(repo)
+	return JSONResponse(content={"task_id": task_id, "ref": ref, "oid": str(oid)})
+
+
+@task_router.post(
+	"/update",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_permission(Permission.TASKS, project_from_query=True))],
+)
+async def task_update(
+	request: Request,
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	task_ref: str = Query(..., alias="task", description="Task ref (e.g. refs/tags/tasks/task_123)"),
+) -> JSONResponse:
+	"""Update a task (body: optional title, description, status, priority, assignee, due_date)."""
+	try:
+		body = await request.json() if request.headers.get("content-type", "").startswith("application/json") else {}
+	except Exception:
+		body = {}
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = task_ref if task_ref.startswith("refs/") else _task_ref(task_ref)
+	t = get_task(repo, ref)
+	if not t:
+		raise HTTPException(status_code=404, detail="Task not found")
+	status_changed = bool("status" in body and hasattr(Task.Status, body["status"]))
+	if "title" in body:
+		t.title = body["title"]
+	if "description" in body:
+		t.description = body.get("description", "")
+	if status_changed:
+		t.status = Task.Status(body["status"])
+	if "priority" in body and hasattr(Task.Priority, body["priority"]):
+		t.priority = Task.Priority(body["priority"])
+	if "assignee" in body:
+		t.assignee = body["assignee"] or None
+	if "due_date" in body:
+		try:
+			from datetime import datetime
+
+			t.due_date = (
+				datetime.fromisoformat(str(body["due_date"]).replace("Z", "+00:00")) if body["due_date"] else None
+			)
+		except ValueError:
+			pass
+	old_oid = str(repo.references[ref].resolve().target)
+	t.update_message()
+	new_oid = t.write(repo)
+	_sync_board_task_oid(repo, board, old_oid, new_oid, move_to_end=status_changed)
+	return JSONResponse(content=_task_to_json(t))
+
+
+@task_router.post(
+	"/delete",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_permission(Permission.TASKS, project_from_query=True))],
+)
+def task_delete(
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	task_ref: str = Query(..., alias="task", description="Task ref"),
+) -> JSONResponse:
+	"""Delete a task (remove ref and remove from board.tasks)."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	ref = task_ref if task_ref.startswith("refs/") else _task_ref(task_ref)
+	if ref not in repo.references:
+		raise HTTPException(status_code=404, detail="Task not found")
+	oid_hex = str(repo.references[ref].resolve().target)
+	repo.references.delete(ref)
+	board_ref = _board_ref(board)
+	b = get_board(repo, board_ref)
+	if b and getattr(b, "tasks", None):
+		try:
+			b.tasks = [x for x in b.tasks if x != oid_hex]
+			b.update_message()
+			b.write(repo)
+		except Exception:
+			pass
+	return JSONResponse(content={"message": "Task deleted"})
+
+
+# ---------- Comment Routes ----------
+
+comment_router = APIRouter(tags=["comments"])
+
+
+def _parse_tagger_display(tagger: str) -> tuple[str, str | None]:
+	s = (tagger or "").strip()
+	if not s:
+		return ("Unknown", None)
+	m = re.match(r"^(.+?)\s*<([^>]+)>", s)
+	if m:
+		name = m.group(1).strip() or "Unknown"
+		return (name, m.group(2).strip())
+	return (s, None)
+
+
+def _tagger_from_principal(principal: PermissionPrincipal | None) -> str:
+	if principal is None:
+		return ""
+	email = (principal.email or "").strip() or f"{principal.username}@local"
+	name = principal.username.strip() or email
+	return f"{name} <{email}>"
+
+
+def _comment_to_json(c: Comment) -> dict[str, Any]:
+	author, email = _parse_tagger_display(c.tagger)
+	return {
+		"content": c.content,
+		"tagger": c.tagger,
+		"author": author,
+		"gravatar_url": gravatar_url(email) if email else None,
+		"created_at": c.created_at.isoformat() if c.created_at else None,
+		"edited_at": c.edited_at.isoformat() if c.edited_at else None,
+	}
+
+
+def _comment_sort_key(entry: dict[str, Any]) -> str:
+	return entry.get("edited_at") or entry.get("created_at") or ""
+
+
+@comment_router.get(
+	"/list",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_active_user_if_auth_enabled)],
+)
+def comment_list(
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	task: str = Query(..., description="Task ref (e.g. refs/tags/tasks/task_123)"),
+) -> JSONResponse:
+	"""List all comments for a task."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	task_ref = task if task.startswith("refs/") else _task_ref(task)
+	t = get_task(repo, task_ref)
+	if not t:
+		raise HTTPException(status_code=404, detail="Task not found")
+	comment_oids = getattr(t, "comments", []) or []
+	comments = []
+	for oid_hex in comment_oids:
+		try:
+			oid = pygit2.Oid(hex=oid_hex) if isinstance(oid_hex, str) else oid_hex
+			c = get_comment(repo, oid)
+			if c:
+				comments.append(_comment_to_json(c))
+		except (ValueError, KeyError, TypeError):
+			continue
+	comments.sort(key=_comment_sort_key)
+	return JSONResponse(content=comments)
+
+
+@comment_router.post(
+	"/create",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_permission(Permission.COMMENTS, project_from_query=True))],
+)
+def comment_create(
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	task: str = Query(..., description="Task ref"),
+	content: str = Query(..., description="Comment content"),
+	token: Annotated[str | None, Depends(access_token_from_request)] = None,
+) -> JSONResponse:
+	"""Create a new comment on a task."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	task_ref = task if task.startswith("refs/") else _task_ref(task)
+	t = get_task(repo, task_ref)
+	if not t:
+		raise HTTPException(status_code=404, detail="Task not found")
+	try:
+		target_oid = repo.references[task_ref].resolve().target
+	except KeyError as exc:
+		raise HTTPException(status_code=404, detail="Task not found") from exc
+	tagger = _tagger_from_principal(principal_from_session(token))
+	comment = Comment(target=target_oid, tagger=tagger, content=content or "")
+	comment_oid = comment.write(repo)
+	t.comments = getattr(t, "comments", []) or []
+	t.comments.append(str(comment_oid))
+	old_task_oid = str(target_oid)
+	t.update_message()
+	new_task_oid = t.write(repo)
+	_sync_board_task_oid(repo, board, old_task_oid, new_task_oid)
+	return JSONResponse(
+		content={
+			"oid": str(comment_oid),
+			"message": "Comment created",
+			"comments_count": len(t.comments),
+		}
+	)
+
+
+@comment_router.post(
+	"/update",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_active_user_if_auth_enabled)],
+)
+async def comment_update(
+	request: Request,
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	task: str = Query(..., description="Task ref (to update task.comments)"),
+	comment_oid: str = Query(..., alias="comment", description="Comment OID hex"),
+) -> JSONResponse:
+	"""Update a comment (body: content). Writes new comment object and updates task.comments."""
+	try:
+		body = await request.json() if request.headers.get("content-type", "").startswith("application/json") else {}
+	except Exception:
+		body = {}
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	oid = pygit2.Oid(hex=comment_oid)
+	c = get_comment(repo, oid)
+	if not c:
+		raise HTTPException(status_code=404, detail="Comment not found")
+	if "content" in body:
+		c.content = body["content"]
+	from datetime import datetime
+
+	c.edited_at = datetime.now()
+	c.update_message()
+	new_oid = c.write(repo)
+	task_ref = task if task.startswith("refs/") else _task_ref(task)
+	t = get_task(repo, task_ref)
+	if t and getattr(t, "comments", None):
+		t.comments = [str(new_oid) if str(co) == comment_oid else co for co in t.comments]
+		try:
+			old_task_oid = str(repo.references[task_ref].resolve().target)
+		except KeyError:
+			old_task_oid = ""
+		t.update_message()
+		new_task_oid = t.write(repo)
+		if old_task_oid:
+			_sync_board_task_oid(repo, board, old_task_oid, new_task_oid)
+	return JSONResponse(
+		content={
+			**_comment_to_json(c),
+			"oid": str(new_oid),
+			"message": "Comment updated",
+		}
+	)
+
+
+@comment_router.post(
+	"/delete",
+	response_class=JSONResponse,
+	dependencies=[Depends(require_active_user_if_auth_enabled)],
+)
+def comment_delete(
+	project: ValidatedQueryProject,
+	board: str = Query(..., description="Board name"),
+	comment_oid: str = Query(..., alias="comment", description="Comment OID hex"),
+) -> JSONResponse:
+	"""Delete a comment (object remains in ODB; caller may remove from task.comments)."""
+	repo = pygit2.Repository(os.path.join(settings.PROJECTROOT, project))
+	oid = pygit2.Oid(hex=comment_oid)
+	try:
+		c = get_comment(repo, oid)
+	except (ValueError, KeyError) as e:
+		raise HTTPException(status_code=404, detail="Comment not found") from e
+	if not c:
+		raise HTTPException(status_code=404, detail="Comment not found")
+	return JSONResponse(content={"message": "Comment deleted"})