second phase of the project management dashboard

This commit is contained in:
Joren de Graaf
2026-10-13 20:37:56 +02:00
parent 3559b367e6
commit e4419b4a18
27 changed files with 1317 additions and 63 deletions
+26 -10
View File
@@ -1,24 +1,40 @@
# Unified Dashboard · design showcase # Common Ground dashboard and projects
A Django template based design foundation using demo data only. Django 6.1, Vite, SCSS, Bootstrap, Bootstrap Icons, Chart.js, and vanilla JavaScript. Django dashboard with an authenticated project manager, Kanban boards, Markdown specifications, and a separate Streamable HTTP MCP server. The original Today, Health, Energy, Home, and Showcase page templates remain in place.
## Run locally ## Local setup
```sh ```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt .venv/bin/python -m pip install -r requirements.txt
.venv/bin/python manage.py migrate
.venv/bin/python manage.py createsuperuser
npm install npm install
npm run dev npm run dev
``` ```
Open http://127.0.0.1:8765/. The dev command checks that Django port **8765** and Vite port **5174** are free before launching either server. Ports 8000 and 1234 are not used. The dashboard runs at `http://127.0.0.1:8765/`. `npm run dev` uses the existing package scripts; `npm run dev:mcp` starts the MCP process at `http://127.0.0.1:8766/mcp`. If Node.js is unavailable, use `.venv/bin/uvicorn mcp_server.server:app --host 127.0.0.1 --port 8766`. Port 8766 is separate from TasksNest's MCP listener.
## Projects manager `/projects/` contains active and archived projects. New projects seed editable To-do, In Progress, and Done columns. New cards use the board's selected default column and Medium priority. Cards store raw Markdown, a revision history, explicit blockers, comments, and activity. HTML output is sanitized. Git URLs are metadata; the server does not fetch or clone them.
Run `.venv/bin/python manage.py migrate` and create a local account with `.venv/bin/python manage.py createsuperuser`. All dashboard and project pages require sign-in. Projects can be created at `/projects/`; each gets an editable To-do, In Progress, Done board. New cards enter its selected default column with Medium priority. Cards store full Markdown and revision history. The project URL is metadata and is never fetched by the server. ## OAuth and MCP
Configuration: `DJANGO_SECRET_KEY` must be set for deployment; `DJANGO_DEBUG=0` enables secure session and CSRF cookies; `DJANGO_ALLOWED_HOSTS` is a comma-separated host list. Serve the site behind HTTPS in production. The Django server hosts OAuth authorization, token, revocation, and discovery endpoints under `/o/` and `/.well-known/oauth-authorization-server`. The MCP process hosts `/mcp` and `/.well-known/oauth-protected-resource/mcp`. The server registers 51 tools; reads require `projects:read`, and writes require `projects:write`. OAuth authorization codes require PKCE. Tokens expire after one hour, can be revoked from Profile, and are stored hashed by django-oauth-toolkit.
The MCP server is a later integration. Reserve **8766** for its separate listener so it does not collide with TasksNest. Do not point an MCP client at the Django page server: OAuth discovery, token issuance, and MCP transport are not yet implemented here. The reference TasksNest implementation is in `/home/jorenmartijn/django/main/mcp_server` and uses Streamable HTTP with a separate OAuth-enabled Django API. Authenticated dynamic client registration is enabled at `/o/register/`. A signed-in user can register a client; session requests also need a CSRF token. Anonymous registration is denied. You can also create a public authorization-code client in Django admin, setting its exact HTTPS redirect URI and the needed scopes. Profile shows active grants and revocation controls.
For a compiled frontend, run `npm run build`; Django then serves the compiled assets via its static file finder. The templates use Vite when its dev server is running, the build manifest when available, and checked-in preview assets otherwise. A Node.js 20.19+ installation is needed for Vite 7. This workspace had no system Node.js; the build was verified with a temporary Node.js binary. Local accounts work by default. To enable separate OIDC sign-in to the dashboard, set `OIDC_OP_ISSUER`, `OIDC_OP_AUTHORIZATION_ENDPOINT`, `OIDC_OP_TOKEN_ENDPOINT`, `OIDC_OP_USER_ENDPOINT`, `OIDC_OP_JWKS_ENDPOINT`, `OIDC_RP_CLIENT_ID`, and `OIDC_RP_CLIENT_SECRET`. Register `/oidc/callback/` at the provider. OIDC identities are linked by verified issuer and subject; a matching email does not link an existing local account. The actual provider callback still needs an integration test with your provider configuration.
Set `MCP_PUBLIC_URL` and `OAUTH_ISSUER_URL` to the public HTTPS MCP endpoint and Django origin. Route `/mcp` and `/.well-known/oauth-protected-resource/mcp` to port 8766, and OAuth routes to the Django process. Preserve the Authorization header. The MCP process and Django must use the same database and `DJANGO_SECRET_KEY`.
## Deployment settings
Set `DJANGO_DEBUG=0`, a strong `DJANGO_SECRET_KEY`, `DJANGO_ALLOWED_HOSTS`, `MCP_PUBLIC_URL`, and `OAUTH_ISSUER_URL`. `DJANGO_CSRF_TRUSTED_ORIGINS` accepts a comma-separated origin list if needed behind a proxy. Production mode requires HTTPS URLs and enables secure cookies, SSL redirect, and HSTS. The local sign-in throttle uses Django's process-local cache; use a shared cache when running multiple workers.
Run checks and tests with:
```sh
.venv/bin/python manage.py check
.venv/bin/python manage.py test projects
```
For compiled frontend assets, run `npm run build`. Django uses Vite in development, the build manifest when present, and checked-in preview assets otherwise.
+49
View File
@@ -1,9 +1,12 @@
import os import os
from pathlib import Path from pathlib import Path
from django.core.exceptions import ImproperlyConfigured
BASE_DIR = Path(__file__).resolve().parent.parent BASE_DIR = Path(__file__).resolve().parent.parent
SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'django-insecure-local-development-only') SECRET_KEY = os.environ.get('DJANGO_SECRET_KEY', 'django-insecure-local-development-only')
DEBUG = os.environ.get('DJANGO_DEBUG', '1') == '1' DEBUG = os.environ.get('DJANGO_DEBUG', '1') == '1'
if not DEBUG and (SECRET_KEY.startswith('django-insecure-') or len(SECRET_KEY) < 50):
raise ImproperlyConfigured('Set a strong DJANGO_SECRET_KEY when DJANGO_DEBUG=0.')
ALLOWED_HOSTS = os.environ.get('DJANGO_ALLOWED_HOSTS', 'localhost,127.0.0.1').split(',') ALLOWED_HOSTS = os.environ.get('DJANGO_ALLOWED_HOSTS', 'localhost,127.0.0.1').split(',')
INSTALLED_APPS = [ INSTALLED_APPS = [
'django.contrib.admin', 'django.contrib.auth', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.sessions', 'django.contrib.messages',
@@ -11,6 +14,7 @@ INSTALLED_APPS = [
"django.contrib.staticfiles", "django.contrib.staticfiles",
"core", "core",
'projects', 'projects',
'oauth2_provider',
] ]
MIDDLEWARE = [ MIDDLEWARE = [
"django.middleware.security.SecurityMiddleware", "django.middleware.security.SecurityMiddleware",
@@ -19,6 +23,7 @@ MIDDLEWARE = [
'django.middleware.csrf.CsrfViewMiddleware', 'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware', 'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
] ]
ROOT_URLCONF = "config.urls" ROOT_URLCONF = "config.urls"
TEMPLATES = [{ TEMPLATES = [{
@@ -39,3 +44,47 @@ LOGOUT_REDIRECT_URL = 'login'
CSRF_COOKIE_SECURE = not DEBUG CSRF_COOKIE_SECURE = not DEBUG
SESSION_COOKIE_SECURE = not DEBUG SESSION_COOKIE_SECURE = not DEBUG
SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https')
SECURE_SSL_REDIRECT = not DEBUG
SECURE_HSTS_SECONDS = 31536000 if not DEBUG else 0
CSRF_TRUSTED_ORIGINS = [item for item in os.environ.get('DJANGO_CSRF_TRUSTED_ORIGINS', '').split(',') if item]
MCP_PUBLIC_URL = os.environ.get('MCP_PUBLIC_URL', 'http://127.0.0.1:8766/mcp')
OAUTH_ISSUER_URL = os.environ.get('OAUTH_ISSUER_URL', 'http://127.0.0.1:8765/')
if not DEBUG and (not MCP_PUBLIC_URL.startswith('https://') or not OAUTH_ISSUER_URL.startswith('https://')):
raise ImproperlyConfigured('MCP_PUBLIC_URL and OAUTH_ISSUER_URL must use HTTPS in production.')
OAUTH2_PROVIDER = {
'SCOPES': {'projects:read': 'Read projects and cards', 'projects:write': 'Create and edit projects and cards'},
'DEFAULT_SCOPES': ['projects:read'],
'ALLOWED_REDIRECT_URI_SCHEMES': ['http', 'https'] if DEBUG else ['https'],
'PKCE_REQUIRED': True,
'COMPLIANT_BCP_RFC9700_PKCE_METHOD': True,
'COMPLIANT_BCP_RFC9700_ACCESS_TOKEN_TRANSPORT': True,
'COMPLIANT_BCP_RFC9700_TOKEN_STORAGE': True,
'ACCESS_TOKEN_EXPIRE_SECONDS': 3600,
'REFRESH_TOKEN_REUSE_PROTECTION': True,
'DCR_ENABLED': True,
'DCR_REGISTRATION_PERMISSION_CLASSES': ['oauth2_provider.dcr.IsAuthenticatedDCRPermission'],
'COMPLIANT_BCP_RFC9700_IMPLICIT_GRANT': True,
'COMPLIANT_BCP_RFC9700_PASSWORD_GRANT': True,
'COMPLIANT_BCP_RFC9700_AUTHZ_RESPONSE_ISS': True,
}
OIDC_KEYS = ('OIDC_OP_ISSUER', 'OIDC_OP_AUTHORIZATION_ENDPOINT', 'OIDC_OP_TOKEN_ENDPOINT',
'OIDC_OP_USER_ENDPOINT', 'OIDC_OP_JWKS_ENDPOINT', 'OIDC_RP_CLIENT_ID', 'OIDC_RP_CLIENT_SECRET')
OIDC_ENABLED = all(os.environ.get(key) for key in OIDC_KEYS)
if any(os.environ.get(key) for key in OIDC_KEYS) and not OIDC_ENABLED:
raise ImproperlyConfigured('Set every OIDC provider variable, or leave all of them unset.')
if OIDC_ENABLED:
if not DEBUG and any(not os.environ[key].startswith('https://') for key in OIDC_KEYS[:5]):
raise ImproperlyConfigured('OIDC provider URLs must use HTTPS in production.')
INSTALLED_APPS.append('mozilla_django_oidc')
AUTHENTICATION_BACKENDS = ['django.contrib.auth.backends.ModelBackend', 'projects.oidc.IdentityBackend']
OIDC_OP_ISSUER = os.environ['OIDC_OP_ISSUER']
OIDC_OP_AUTHORIZATION_ENDPOINT = os.environ['OIDC_OP_AUTHORIZATION_ENDPOINT']
OIDC_OP_TOKEN_ENDPOINT = os.environ['OIDC_OP_TOKEN_ENDPOINT']
OIDC_OP_USER_ENDPOINT = os.environ['OIDC_OP_USER_ENDPOINT']
OIDC_OP_JWKS_ENDPOINT = os.environ['OIDC_OP_JWKS_ENDPOINT']
OIDC_RP_CLIENT_ID = os.environ['OIDC_RP_CLIENT_ID']
OIDC_RP_CLIENT_SECRET = os.environ['OIDC_RP_CLIENT_SECRET']
OIDC_RP_SIGN_ALGO = 'RS256'
OIDC_RP_SCOPES = 'openid email profile'
OIDC_STORE_ACCESS_TOKEN = False
OIDC_STORE_ID_TOKEN = False
+8 -1
View File
@@ -1,11 +1,16 @@
from django.urls import path, include from django.urls import path, include
from django.contrib.auth import views as auth_views from django.contrib.auth import views as auth_views
from django.contrib import admin from django.contrib import admin
from django.conf import settings
from oauth2_provider.urls import metadata_urlpatterns
from core import views from core import views
from projects import views as project_views
urlpatterns = [ urlpatterns = [
*metadata_urlpatterns,
path('o/', include('oauth2_provider.urls', namespace='oauth2_provider')),
path('admin/', admin.site.urls), path('admin/', admin.site.urls),
path('accounts/login/', auth_views.LoginView.as_view(template_name='projects/login.html'), name='login'), path('accounts/login/', project_views.ThrottledLoginView.as_view(), name='login'),
path('accounts/logout/', auth_views.LogoutView.as_view(), name='logout'), path('accounts/logout/', auth_views.LogoutView.as_view(), name='logout'),
path('accounts/password/change/', auth_views.PasswordChangeView.as_view(template_name='projects/form.html', success_url='/projects/profile/'), name='password_change'), path('accounts/password/change/', auth_views.PasswordChangeView.as_view(template_name='projects/form.html', success_url='/projects/profile/'), name='password_change'),
path('projects/', include('projects.urls')), path('projects/', include('projects.urls')),
@@ -15,3 +20,5 @@ urlpatterns = [
path("home/", views.home, name="home"), path("home/", views.home, name="home"),
path("showcase/", views.showcase, name="showcase"), path("showcase/", views.showcase, name="showcase"),
] ]
if settings.OIDC_ENABLED:
urlpatterns.insert(0, path('oidc/', include('mozilla_django_oidc.urls')))
+1 -1
View File
@@ -5,7 +5,7 @@
<meta name="theme-color" content="#f6f7f5"> <meta name="theme-color" content="#f6f7f5">
<link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 40 40'%3E%3Crect width='40' height='40' rx='10' fill='%23315d4d'/%3E%3Cpath d='M10 10h8v8h-8zm12 0h8v8h-8zM10 22h8v8h-8zm12 0h8v8h-8z' fill='white'/%3E%3C/svg%3E"> <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 40 40'%3E%3Crect width='40' height='40' rx='10' fill='%23315d4d'/%3E%3Cpath d='M10 10h8v8h-8zm12 0h8v8h-8zM10 22h8v8h-8zm12 0h8v8h-8z' fill='white'/%3E%3C/svg%3E">
<title>{{ title }} · Common Ground</title> <title>{{ title }} · Common Ground</title>
<script>document.documentElement.dataset.theme=localStorage.getItem('dashboard-theme')||'system';</script> <script>document.documentElement.dataset.theme=localStorage.getItem('dashboard-theme')||'{{ user.profile.theme|default:'system' }}';</script>
<link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin> <link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&family=Manrope:wght@400;500;600;700;800&display=swap" rel="stylesheet"> <link href="https://fonts.googleapis.com/css2?family=DM+Sans:wght@400;500;600;700&family=Manrope:wght@400;500;600;700;800&display=swap" rel="stylesheet">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css"> <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css">
View File
+545
View File
@@ -0,0 +1,545 @@
"""Streamable HTTP MCP server for project management. Run on port 8766."""
import os
from datetime import date
from typing import Any, Literal
from urllib.parse import urlsplit
from uuid import UUID
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings')
import django
django.setup()
from asgiref.sync import sync_to_async
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.exceptions import PermissionDenied, ValidationError
from django.db.models import Q
from django.db import transaction
from django.http import Http404
from django.test.client import RequestFactory
from oauth2_provider.oauth2_backends import OAuthLibCore
from mcp.server.auth.middleware.auth_context import get_access_token
from mcp.server.auth.provider import AccessToken, TokenVerifier
from mcp.server.auth.routes import create_protected_resource_routes
from mcp.server.auth.settings import AuthSettings
from mcp.server.mcpserver import MCPServer
from mcp.server.mcpserver.exceptions import ToolError
from mcp.server.transport_security import TransportSecuritySettings
from pydantic import AnyHttpUrl
from projects import services
from projects.models import Activity, Card, CardComment, CardRevision, Column, Project, Tag
def _verified(raw):
resource = urlsplit(settings.MCP_PUBLIC_URL)
request = RequestFactory().get(resource.path, HTTP_HOST=resource.netloc,
HTTP_AUTHORIZATION=f'Bearer {raw}', secure=resource.scheme == 'https')
valid, result = OAuthLibCore().verify_request(request, scopes=[])
if not valid or not getattr(result, 'user', None):
return None
return {'user_id': result.user.pk, 'scopes': list(result.scopes), 'expires_at': getattr(result, 'expires_at', None)}
class OAuthTokenVerifier(TokenVerifier):
async def verify_token(self, token: str) -> AccessToken | None:
if len(token) > 512:
return None
info = await sync_to_async(_verified)(token)
if not info:
return None
return AccessToken(token=token, client_id='dashboard', scopes=info['scopes'], subject=str(info['user_id']))
def _actor(scope='projects:read'):
access = get_access_token()
if access is None or scope not in access.scopes:
raise ToolError(f'permission_denied: {scope} authorization required')
return get_user_model().objects.get(pk=access.subject)
def _project(user, value, write=False):
try:
identifier = UUID(value)
except (ValueError, TypeError):
matches = list(services.accessible(user).filter(name__iexact=value)[:3])
if len(matches) != 1:
raise ToolError(f'ambiguous_project: supply a project UUID; candidates: {[str(p.pk) for p in matches]}')
identifier = matches[0].pk
return services.project_for(user, identifier, write=write)
def _card(user, value, write=False):
return services.card_for(user, UUID(value), write=write)
def _project_data(project):
cards = Card.objects.filter(project=project, archived=False)
return {'id': str(project.pk), 'name': project.name, 'slug': project.slug, 'description': project.description,
'git_repository_url': project.git_repository_url or None, 'archived': project.archived,
'card_count': cards.count(), 'done_count': cards.filter(column__is_done=True).count()}
def _card_data(card):
return {'id': str(card.pk), 'project_id': str(card.project_id), 'column_id': str(card.column_id), 'title': card.title,
'markdown': card.description_markdown, 'priority': card.priority, 'card_type': card.card_type,
'revision': card.revision, 'position': card.position, 'is_blocked': card.is_blocked,
'blocked_reason': card.blocked_reason, 'archived': card.archived,
'assignee_id': card.assignee_id,
'tags': [{'id': tag.pk, 'name': tag.name} for tag in card.tags.all()],
'due_date': card.due_date.isoformat() if card.due_date else None,
'completed_at': card.completed_at.isoformat() if card.completed_at else None,
'created_at': card.created_at.isoformat(), 'updated_at': card.updated_at.isoformat(),
'url': f'{settings.OAUTH_ISSUER_URL.rstrip("/")}/projects/cards/{card.pk}/'}
def _column_data(column):
return {'id': str(column.pk), 'name': column.name, 'position': column.position,
'color': column.color, 'is_default': column.is_default, 'is_done': column.is_done}
def _safe(operation):
try:
return operation()
except (Http404, Project.DoesNotExist, Card.DoesNotExist, Column.DoesNotExist, CardRevision.DoesNotExist, Tag.DoesNotExist, get_user_model().DoesNotExist):
raise ToolError('not_found: project or card is unavailable')
except PermissionDenied:
raise ToolError('permission_denied: write access required')
except ValidationError as exc:
raise ToolError(f'invalid_input: {exc}')
except services.RevisionConflict as exc:
raise ToolError(f'revision_conflict: current revision is {exc.current}')
except ValueError as exc:
raise ToolError(f'invalid_input: {exc}')
def create_server():
server = MCPServer('Common Ground Projects', description='Projects, Kanban cards, and Markdown specifications.',
token_verifier=OAuthTokenVerifier(), auth=AuthSettings(
issuer_url=AnyHttpUrl(settings.OAUTH_ISSUER_URL),
resource_server_url=AnyHttpUrl(settings.MCP_PUBLIC_URL), required_scopes=[], validate_token_resource=False))
@server.tool(structured_output=True, description='List projects accessible to the connected user, with counts and repository metadata.')
async def projects_list(limit: int = 50, offset: int = 0) -> dict[str, Any]:
def run():
user = _actor()
qs = services.accessible(user).filter(archived=False).order_by('name')
return {'items': [_project_data(p) for p in qs[offset:offset + min(max(limit, 1), 100)]], 'total': qs.count()}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Get a project, its default column, counts, and Git repository URL. The URL is metadata only.')
async def projects_get(project: str) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
return {**_project_data(p), 'default_column_id': str(p.board.columns.get(is_default=True, archived=False).pk)}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Update project name, description, or HTTPS Git repository metadata.')
async def projects_update(project: str, name: str | None = None, description: str | None = None, git_repository_url: str | None = None) -> dict[str, Any]:
def run():
user = _actor('projects:write')
p = _project(user, project, write=True)
if name is not None: p.name = name
if description is not None: p.description = description
if git_repository_url is not None: p.git_repository_url = git_repository_url
p.full_clean()
if p.git_repository_url and not p.git_repository_url.startswith('https://'):
raise ValidationError('Use an HTTPS repository URL.')
p.save()
Activity.objects.create(project=p, actor=user, action='project.updated', origin='mcp')
return _project_data(p)
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Archive a project without deleting its board or cards.')
async def projects_archive(project: str) -> dict[str, Any]:
def run():
user = _actor('projects:write')
p = _project(user, project, write=True)
p.archived = True; p.save(update_fields=['archived'])
Activity.objects.create(project=p, actor=user, action='project.archived', origin='mcp')
return _project_data(p)
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Get project progress and workload by priority with repository metadata.')
async def projects_summary(project: str) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
cards = Card.objects.filter(project=p, archived=False)
return {**_project_data(p), 'by_priority': {priority: cards.filter(priority=priority).count() for priority in ('high', 'medium', 'low')}, 'blocked_count': cards.filter(is_blocked=True).count()}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Search accessible project names and descriptions.')
async def projects_search(query: str, limit: int = 50) -> dict[str, Any]:
def run():
qs = services.accessible(_actor()).filter(Q(name__icontains=query) | Q(description__icontains=query), archived=False)[:min(max(limit, 1), 100)]
return {'items': [_project_data(p) for p in qs]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Create a project and seed editable To-do, In Progress, and Done columns.')
async def projects_create(name: str, description: str = '', git_repository_url: str = '') -> dict[str, Any]:
return await sync_to_async(lambda: _safe(lambda: _project_data(services.create_project(_actor('projects:write'), name=name, description=description, git_repository_url=git_repository_url))))()
@server.tool(structured_output=True, description='List active columns for a project, including default and completion flags.')
async def columns_list(project: str) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
return {'items': [_column_data(c) for c in p.board.columns.filter(archived=False)]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Get a project board with its columns and card summaries.')
async def boards_get(project: str) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
return {'project': _project_data(p), 'columns': [{**_column_data(c), 'cards': [_card_data(card) for card in c.cards.filter(archived=False)[:100]]} for c in p.board.columns.filter(archived=False)]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Create an editable Kanban column in a project.')
async def columns_create(project: str, name: str, color: str = '#315d4d', is_done: bool = False) -> dict[str, Any]:
def run():
p = _project(_actor('projects:write'), project, write=True)
column = Column(board=p.board, name=name, color=color, is_done=is_done, position=p.board.columns.count())
column.full_clean(); column.save()
return _column_data(column)
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Rename or recolor a column, or change its completed state.')
async def columns_update(column_id: str, name: str | None = None, color: str | None = None, is_done: bool | None = None) -> dict[str, Any]:
def run():
column = Column.objects.get(pk=UUID(column_id))
return _column_data(services.update_column(_actor('projects:write'), column, name=name, color=color, is_done=is_done, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Choose the one default destination column for new cards.')
async def columns_set_default(column_id: str) -> dict[str, Any]:
def run():
column = Column.objects.get(pk=UUID(column_id))
return _column_data(services.set_default(_actor('projects:write'), column))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Reorder active columns by supplying every column UUID exactly once.')
async def columns_reorder(project: str, column_ids: list[str]) -> dict[str, Any]:
def run():
user = _actor('projects:write'); p = _project(user, project, write=True)
services.reorder_columns(user, p, column_ids)
return {'items': [_column_data(c) for c in p.board.columns.filter(archived=False)]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Archive an empty, non-default column.')
async def columns_archive(column_id: str) -> dict[str, Any]:
def run():
column = Column.objects.get(pk=UUID(column_id))
services.archive_column(_actor('projects:write'), column)
return {'id': str(column.pk), 'archived': True}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Create a card in the project default column with Medium priority unless specified.')
async def cards_create(project: str, title: str, markdown: str = '', priority: Literal['low', 'medium', 'high'] = 'medium', card_type: Literal['feature', 'bug', 'task', 'research', 'idea'] = 'task', column_id: str | None = None, idempotency_key: str | None = None) -> dict[str, Any]:
def run():
user = _actor('projects:write')
p = _project(user, project, write=True)
column = Column.objects.get(pk=UUID(column_id)) if column_id else None
return _card_data(services.create_card(user, p, title=title, markdown=markdown, priority=priority, card_type=card_type, column=column, origin='mcp', idempotency_key=idempotency_key))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Create a Markdown specification card; the configured default column and Medium priority are used if omitted.')
async def specs_create(project: str, title: str, markdown: str, priority: Literal['low', 'medium', 'high'] = 'medium', column_id: str | None = None, idempotency_key: str | None = None) -> dict[str, Any]:
return await cards_create(project, title, markdown, priority, 'feature', column_id, idempotency_key)
@server.tool(structured_output=True, description='Get full card details including exact raw Markdown and revision.')
async def cards_get(card_id: str) -> dict[str, Any]:
return await sync_to_async(lambda: _safe(lambda: _card_data(_card(_actor(), card_id))))()
@server.tool(structured_output=True, description='Update card fields; supply the expected revision to prevent lost edits.')
async def cards_update(card_id: str, expected_revision: int, title: str | None = None, markdown: str | None = None, priority: Literal['low', 'medium', 'high'] | None = None, card_type: Literal['feature', 'bug', 'task', 'research', 'idea'] | None = None, due_date: str | None = None, is_blocked: bool | None = None, blocked_reason: str | None = None) -> dict[str, Any]:
def run():
user = _actor('projects:write')
card = _card(user, card_id, write=True)
values = {'title': title, 'description_markdown': markdown, 'priority': priority, 'card_type': card_type, 'is_blocked': is_blocked, 'blocked_reason': blocked_reason}
values = {key: value for key, value in values.items() if value is not None}
if due_date is not None:
values['due_date'] = date.fromisoformat(due_date) if due_date else None
return _card_data(services.update_card(user, card, expected_revision=expected_revision, origin='mcp', **values))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List cards in an accessible project; filter by priority, column, or archived state.')
async def cards_list(project: str, priority: Literal['low', 'medium', 'high'] | None = None, card_type: Literal['feature', 'bug', 'task', 'research', 'idea'] | None = None, column_id: str | None = None, tag_id: int | None = None, assignee_id: int | None = None, archived: bool = False, limit: int = 50, offset: int = 0) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
qs = Card.objects.filter(project=p, archived=archived)
if priority: qs = qs.filter(priority=priority)
if card_type: qs = qs.filter(card_type=card_type)
if column_id: qs = qs.filter(column_id=UUID(column_id))
if tag_id: qs = qs.filter(tags__pk=tag_id)
if assignee_id: qs = qs.filter(assignee_id=assignee_id)
return {'items': [_card_data(c) for c in qs[offset:offset + min(max(limit, 1), 100)]], 'total': qs.count()}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Search card titles and full Markdown within an accessible project.')
async def cards_search(project: str, query: str, priority: Literal['low', 'medium', 'high'] | None = None, limit: int = 50) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
qs = Card.objects.filter(project=p, archived=False).filter(Q(title__icontains=query) | Q(description_markdown__icontains=query))
if priority: qs = qs.filter(priority=priority)
return {'items': [_card_data(c) for c in qs[:min(max(limit, 1), 100)]]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Archive a card without permanently deleting its content or history.')
async def cards_archive(card_id: str, expected_revision: int) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
return _card_data(services.update_card(user, card, expected_revision=expected_revision, archived=True, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Restore an archived card to its existing column.')
async def cards_restore(card_id: str, expected_revision: int) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
return _card_data(services.update_card(user, card, expected_revision=expected_revision, archived=False, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Add a progress comment to a card.')
async def cards_add_comment(card_id: str, body: str) -> dict[str, Any]:
def run():
if not body.strip(): raise ValidationError('Comment is required.')
user = _actor('projects:write'); card = _card(user, card_id, write=True)
note = CardComment.objects.create(card=card, author=user, body=body)
Activity.objects.create(project=card.project, card=card, actor=user, action='card.commented', origin='mcp')
return {'id': note.pk, 'card_id': str(card.pk), 'body': note.body, 'created_at': note.created_at.isoformat()}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List progress comments on a card.')
async def cards_list_comments(card_id: str, limit: int = 50) -> dict[str, Any]:
def run():
card = _card(_actor(), card_id)
return {'items': [{'id': c.pk, 'body': c.body, 'author_id': c.author_id, 'created_at': c.created_at.isoformat()} for c in card.comments.order_by('-created_at')[:min(max(limit, 1), 100)]]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List card activity and revision numbers.')
async def cards_history(card_id: str, limit: int = 50) -> dict[str, Any]:
def run():
card = _card(_actor(), card_id)
return {'items': [{'action': a.action, 'detail': a.detail, 'origin': a.origin, 'created_at': a.created_at.isoformat()} for a in card.activity.all()[:min(max(limit, 1), 100)]], 'revision': card.revision}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Replace raw Markdown only when expected_revision matches the current card revision.')
async def specs_replace(card_id: str, markdown: str, expected_revision: int) -> dict[str, Any]:
def run():
user = _actor('projects:write')
card = _card(user, card_id, write=True)
return _card_data(services.update_card(user, card, expected_revision=expected_revision, description_markdown=markdown, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Append raw Markdown with an optimistic revision check.')
async def specs_append(card_id: str, markdown: str, expected_revision: int) -> dict[str, Any]:
def run():
user = _actor('projects:write')
card = _card(user, card_id, write=True)
return _card_data(services.update_card(user, card, expected_revision=expected_revision, description_markdown=card.description_markdown + markdown, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Set one of the three supported card priorities without changing its column.')
async def cards_set_priority(card_id: str, priority: Literal['low', 'medium', 'high'], expected_revision: int) -> dict[str, Any]:
def run():
user = _actor('projects:write')
card = _card(user, card_id, write=True)
return _card_data(services.update_card(user, card, expected_revision=expected_revision, priority=priority, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Move a card to another column in the same project, optionally to a zero-based position.')
async def cards_move(card_id: str, column_id: str, position: int | None = None) -> dict[str, Any]:
def run():
user = _actor('projects:write')
return _card_data(services.move_card(user, _card(user, card_id, write=True), Column.objects.get(pk=UUID(column_id)), position, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Reorder a card within its current column using a zero-based position.')
async def cards_reorder(card_id: str, position: int) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
return _card_data(services.move_card(user, card, card.column, position, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Duplicate a card and its raw Markdown into the same project and column.')
async def cards_duplicate(card_id: str) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
copy = services.create_card(user, card.project, title=f'{card.title} (copy)', markdown=card.description_markdown, column=card.column, priority=card.priority, card_type=card.card_type, origin='mcp')
copy.tags.set(card.tags.all())
return _card_data(copy)
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Replace a card’s tags with existing tag IDs from the same project.')
async def cards_set_tags(card_id: str, tag_ids: list[int]) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
tags = list(Tag.objects.filter(project=card.project, pk__in=tag_ids))
if len(tags) != len(set(tag_ids)): raise ValidationError('All tags must belong to this project.')
card.tags.set(tags)
Activity.objects.create(project=card.project, card=card, actor=user, action='card.tags_changed', origin='mcp')
return {**_card_data(card), 'tags': [{'id': t.pk, 'name': t.name} for t in tags]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Assign a card to a user who has access to its project, or clear assignment.')
async def cards_set_assignee(card_id: str, user_id: int | None = None) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
assignee = get_user_model().objects.get(pk=user_id) if user_id is not None else None
services.set_assignee(user, card, assignee, origin='mcp')
return {**_card_data(card), 'assignee_id': card.assignee_id}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List unfinished cards grouped by their exact High, Medium, and Low priorities.')
async def cards_list_by_priority(project: str, limit: int = 100) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
cards = Card.objects.filter(project=p, archived=False, column__is_done=False)[:min(max(limit, 1), 100)]
return {priority: [_card_data(c) for c in cards if c.priority == priority] for priority in ('high', 'medium', 'low')}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List tags in an accessible project.')
async def tags_list(project: str) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
return {'items': [{'id': t.pk, 'name': t.name} for t in Tag.objects.filter(project=p).order_by('name')]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Create a tag within a project.')
async def tags_create(project: str, name: str) -> dict[str, Any]:
def run():
p = _project(_actor('projects:write'), project, write=True)
tag = Tag(project=p, name=name); tag.full_clean(); tag.save()
return {'id': tag.pk, 'name': tag.name}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Rename a tag in a project you may edit.')
async def tags_update(tag_id: int, name: str) -> dict[str, Any]:
def run():
tag = Tag.objects.get(pk=tag_id)
services.project_for(_actor('projects:write'), tag.project_id, write=True)
tag.name = name; tag.full_clean(); tag.save()
return {'id': tag.pk, 'name': tag.name}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Show the connected account without exposing credentials.')
async def users_me() -> dict[str, Any]:
def run():
user = _actor()
return {'id': user.pk, 'username': user.get_username(), 'email': user.email}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List users eligible to be assigned cards in a project.')
async def users_list_assignable(project: str) -> dict[str, Any]:
def run():
p = _project(_actor(), project)
ids = {p.owner_id, *p.memberships.values_list('user_id', flat=True)}
return {'items': [{'id': user.pk, 'username': user.get_username()} for user in get_user_model().objects.filter(pk__in=ids).order_by('username')]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List activity across projects visible to the connected user.')
async def activity_list(limit: int = 50) -> dict[str, Any]:
def run():
events = Activity.objects.filter(project__in=services.accessible(_actor())).order_by('-created_at')[:min(max(limit, 1), 100)]
return {'items': [{'project_id': str(e.project_id), 'card_id': str(e.card_id) if e.card_id else None, 'action': e.action, 'detail': e.detail, 'origin': e.origin, 'created_at': e.created_at.isoformat()} for e in events]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List Markdown versions of a card, newest first.')
async def specs_versions(card_id: str, limit: int = 50) -> dict[str, Any]:
def run():
card = _card(_actor(), card_id)
return {'items': [{'revision': v.revision, 'markdown': v.markdown, 'created_at': v.created_at.isoformat()} for v in card.revisions.order_by('-revision')[:min(max(limit, 1), 100)]]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Get full exact Markdown and revision for a specification card.')
async def specs_get(card_id: str) -> dict[str, Any]:
return await cards_get(card_id)
@server.tool(structured_output=True, description='Restore an earlier Markdown version while retaining revision history.')
async def specs_restore_version(card_id: str, revision: int, expected_revision: int) -> dict[str, Any]:
def run():
user = _actor('projects:write'); card = _card(user, card_id, write=True)
version = CardRevision.objects.get(card=card, revision=revision)
return _card_data(services.update_card(user, card, expected_revision=expected_revision, description_markdown=version.markdown, origin='mcp'))
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Suggest actionable cards using live columns, priority, due date, and explicit blockers. Does not change any card.')
async def planning_next(project: str | None = None, limit: int = 20) -> dict[str, Any]:
def run():
user = _actor()
projects = services.accessible(user).filter(archived=False)
if project: projects = projects.filter(pk=_project(user, project).pk)
cards = Card.objects.filter(project__in=projects, archived=False, column__is_done=False).select_related('project', 'column')
ranked = sorted(cards, key=lambda c: (c.is_blocked, c.column.is_default, {'high': 0, 'medium': 1, 'low': 2}[c.priority], c.due_date or date.max, c.created_at))
return {'items': [{**_card_data(c), 'project_name': c.project.name, 'git_repository_url': c.project.git_repository_url or None} for c in ranked[:min(max(limit, 1), 100)]]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Summarize open work by project, column, and priority with Git repository metadata.')
async def planning_overview() -> dict[str, Any]:
def run():
items = []
for p in services.accessible(_actor()).filter(archived=False):
cards = Card.objects.filter(project=p, archived=False)
items.append({**_project_data(p), 'columns': [{**_column_data(c), 'count': cards.filter(column=c).count()} for c in p.board.columns.filter(archived=False)], 'priorities': {key: cards.filter(priority=key).count() for key in ('high', 'medium', 'low')}})
return {'items': items}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List only cards explicitly marked blocked, with their stated reasons.')
async def planning_blocked(limit: int = 50) -> dict[str, Any]:
def run():
cards = Card.objects.filter(project__in=services.accessible(_actor()), archived=False, is_blocked=True)[:min(max(limit, 1), 100)]
return {'items': [_card_data(c) for c in cards]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List recent project and card changes visible to the connected user.')
async def planning_recent(limit: int = 50) -> dict[str, Any]:
def run():
events = Activity.objects.filter(project__in=services.accessible(_actor())).order_by('-created_at')[:min(max(limit, 1), 100)]
return {'items': [{'project_id': str(e.project_id), 'card_id': str(e.card_id) if e.card_id else None, 'action': e.action, 'detail': e.detail, 'origin': e.origin, 'created_at': e.created_at.isoformat()} for e in events]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Summarize outstanding High, Medium, and Low cards without changing priorities.')
async def planning_priorities() -> dict[str, Any]:
def run():
cards = Card.objects.filter(project__in=services.accessible(_actor()), archived=False, column__is_done=False)
return {'high': cards.filter(priority='high').count(), 'medium': cards.filter(priority='medium').count(), 'low': cards.filter(priority='low').count()}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='List unfinished cards grouped by priority across accessible projects.')
async def planning_backlog(limit: int = 100) -> dict[str, Any]:
def run():
cards = Card.objects.filter(project__in=services.accessible(_actor()), archived=False, column__is_done=False)[:min(max(limit, 1), 100)]
return {priority: [_card_data(c) for c in cards if c.priority == priority] for priority in ('high', 'medium', 'low')}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Search accessible projects and cards. Results include only data the connected user may read.')
async def search_global(query: str, limit: int = 50) -> dict[str, Any]:
def run():
user = _actor()
projects = services.accessible(user).filter(Q(name__icontains=query) | Q(description__icontains=query))[:min(max(limit, 1), 100)]
cards = Card.objects.filter(project__in=services.accessible(user), archived=False).filter(Q(title__icontains=query) | Q(description_markdown__icontains=query))[:min(max(limit, 1), 100)]
return {'projects': [_project_data(p) for p in projects], 'cards': [_card_data(c) for c in cards]}
return await sync_to_async(lambda: _safe(run))()
@server.tool(structured_output=True, description='Report supported MCP tools, scopes, and result limits.')
async def system_capabilities() -> dict[str, Any]:
_actor()
return {'scopes': ['projects:read', 'projects:write'], 'max_page_size': 100, 'version': '0.2', 'transport': 'streamable_http'}
return server
app = create_server().streamable_http_app(
streamable_http_path='/mcp', stateless_http=True, json_response=True,
transport_security=TransportSecuritySettings(
allowed_hosts=[urlsplit(settings.MCP_PUBLIC_URL).netloc, '127.0.0.1:*', 'localhost:*'],
allowed_origins=[f'{urlsplit(settings.MCP_PUBLIC_URL).scheme}://{urlsplit(settings.MCP_PUBLIC_URL).netloc}', 'https://chatgpt.com', 'http://127.0.0.1:*', 'http://localhost:*'],
),
)
metadata_route = create_protected_resource_routes(
resource_url=AnyHttpUrl(settings.MCP_PUBLIC_URL),
authorization_servers=[AnyHttpUrl(settings.OAUTH_ISSUER_URL)],
scopes_supported=['projects:read', 'projects:write'],
)[0]
for index, route in enumerate(app.router.routes):
if getattr(route, 'path', None) == metadata_route.path:
app.router.routes[index] = metadata_route
break
+1
View File
@@ -6,6 +6,7 @@
"dev": "node scripts/dev.mjs", "dev": "node scripts/dev.mjs",
"dev:servers": "concurrently -k -n django,vite -c cyan,green \"npm:dev:django\" \"npm:dev:vite\"", "dev:servers": "concurrently -k -n django,vite -c cyan,green \"npm:dev:django\" \"npm:dev:vite\"",
"dev:django": ".venv/bin/python manage.py runserver 127.0.0.1:8765", "dev:django": ".venv/bin/python manage.py runserver 127.0.0.1:8765",
"dev:mcp": ".venv/bin/uvicorn mcp_server.server:app --host 127.0.0.1 --port 8766",
"dev:vite": "vite --host 127.0.0.1", "dev:vite": "vite --host 127.0.0.1",
"build": "vite build" "build": "vite build"
}, },
+28 -2
View File
@@ -1,5 +1,6 @@
from django import forms from django import forms
from .models import Card, Column, Profile, Project from .models import Card, Column, Profile, Project, Tag, Membership
from django.contrib.auth import get_user_model
class ProjectForm(forms.ModelForm): class ProjectForm(forms.ModelForm):
@@ -7,6 +8,16 @@ class ProjectForm(forms.ModelForm):
model = Project model = Project
fields = ['name', 'description', 'git_repository_url'] fields = ['name', 'description', 'git_repository_url']
def __init__(self, *args, user=None, **kwargs):
super().__init__(*args, **kwargs)
self.user = user
def clean_name(self):
value = self.cleaned_data['name'].strip()
if self.user and Project.objects.filter(owner=self.user, name__iexact=value).exclude(pk=self.instance.pk).exists():
raise forms.ValidationError('You already have a project with this name.')
return value
def clean_git_repository_url(self): def clean_git_repository_url(self):
value = self.cleaned_data['git_repository_url'] value = self.cleaned_data['git_repository_url']
if value and not value.startswith('https://'): if value and not value.startswith('https://'):
@@ -16,12 +27,21 @@ class ProjectForm(forms.ModelForm):
class CardForm(forms.ModelForm): class CardForm(forms.ModelForm):
expected_revision = forms.IntegerField(widget=forms.HiddenInput, required=False) expected_revision = forms.IntegerField(widget=forms.HiddenInput, required=False)
assignee = forms.ModelChoiceField(queryset=get_user_model().objects.none(), required=False)
tags = forms.ModelMultipleChoiceField(queryset=Tag.objects.none(), required=False)
class Meta: class Meta:
model = Card model = Card
fields = ['title', 'description_markdown', 'priority', 'card_type', 'due_date', 'is_blocked', 'blocked_reason'] fields = ['title', 'description_markdown', 'priority', 'card_type', 'due_date', 'is_blocked', 'blocked_reason', 'assignee', 'tags']
widgets = {'description_markdown': forms.Textarea(attrs={'rows': 16}), 'due_date': forms.DateInput(attrs={'type': 'date'})} widgets = {'description_markdown': forms.Textarea(attrs={'rows': 16}), 'due_date': forms.DateInput(attrs={'type': 'date'})}
def __init__(self, *args, project=None, **kwargs):
super().__init__(*args, **kwargs)
if project:
ids = [project.owner_id, *Membership.objects.filter(project=project).values_list('user_id', flat=True)]
self.fields['assignee'].queryset = get_user_model().objects.filter(pk__in=ids).order_by('username')
self.fields['tags'].queryset = Tag.objects.filter(project=project).order_by('name')
class ColumnForm(forms.ModelForm): class ColumnForm(forms.ModelForm):
class Meta: class Meta:
@@ -30,6 +50,12 @@ class ColumnForm(forms.ModelForm):
widgets = {'color': forms.TextInput(attrs={'type': 'color'})} widgets = {'color': forms.TextInput(attrs={'type': 'color'})}
class TagForm(forms.ModelForm):
class Meta:
model = Tag
fields = ['name']
class ProfileForm(forms.ModelForm): class ProfileForm(forms.ModelForm):
email = forms.EmailField(required=False) email = forms.EmailField(required=False)
+30
View File
@@ -0,0 +1,30 @@
# Generated by Django 6.1.2 on 2026-10-13 13:30
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('projects', '0001_initial'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='CreationKey',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('key', models.CharField(max_length=128)),
('payload_hash', models.CharField(max_length=64)),
('created_at', models.DateTimeField(auto_now_add=True)),
('card', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='projects.card')),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
],
options={
'constraints': [models.UniqueConstraint(fields=('user', 'key'), name='unique_card_creation_key')],
},
),
]
+29
View File
@@ -0,0 +1,29 @@
# Generated by Django 6.1.2 on 2026-10-13 18:28
import django.db.models.deletion
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('projects', '0002_creationkey'),
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
migrations.CreateModel(
name='OAuthIdentity',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('issuer', models.URLField()),
('subject', models.CharField(max_length=255)),
('created_at', models.DateTimeField(auto_now_add=True)),
('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='oauth_identities', to=settings.AUTH_USER_MODEL)),
],
options={
'constraints': [models.UniqueConstraint(fields=('issuer', 'subject'), name='unique_oidc_identity')],
},
),
]
+21
View File
@@ -14,6 +14,16 @@ class Profile(models.Model):
theme = models.CharField(max_length=16, default='system') theme = models.CharField(max_length=16, default='system')
class OAuthIdentity(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='oauth_identities')
issuer = models.URLField()
subject = models.CharField(max_length=255)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [models.UniqueConstraint(fields=['issuer', 'subject'], name='unique_oidc_identity')]
class Project(models.Model): class Project(models.Model):
id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='owned_projects') owner = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='owned_projects')
@@ -112,6 +122,17 @@ class CardComment(models.Model):
created_at = models.DateTimeField(auto_now_add=True) created_at = models.DateTimeField(auto_now_add=True)
class CreationKey(models.Model):
user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
key = models.CharField(max_length=128)
payload_hash = models.CharField(max_length=64)
card = models.ForeignKey(Card, on_delete=models.CASCADE)
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [models.UniqueConstraint(fields=['user', 'key'], name='unique_card_creation_key')]
class Activity(models.Model): class Activity(models.Model):
project = models.ForeignKey(Project, on_delete=models.CASCADE, related_name='activity') project = models.ForeignKey(Project, on_delete=models.CASCADE, related_name='activity')
card = models.ForeignKey(Card, null=True, blank=True, on_delete=models.CASCADE, related_name='activity') card = models.ForeignKey(Card, null=True, blank=True, on_delete=models.CASCADE, related_name='activity')
+44
View File
@@ -0,0 +1,44 @@
import hashlib
from django.conf import settings
from django.core.exceptions import SuspiciousOperation
from django.db import transaction
from mozilla_django_oidc.auth import OIDCAuthenticationBackend
from .models import OAuthIdentity
class IdentityBackend(OIDCAuthenticationBackend):
"""Map an external account by verified issuer and subject, never by email."""
def verify_token(self, token, **kwargs):
payload = super().verify_token(token, **kwargs)
audience = payload.get('aud', [])
if isinstance(audience, str):
audience = [audience]
if payload.get('iss') != settings.OIDC_OP_ISSUER or settings.OIDC_RP_CLIENT_ID not in audience or not payload.get('sub'):
raise SuspiciousOperation('OIDC issuer, audience, or subject mismatch.')
return payload
def get_userinfo(self, access_token, id_token, payload):
claims = super().get_userinfo(access_token, id_token, payload)
if claims.get('sub') != payload.get('sub'):
raise SuspiciousOperation('OIDC subject mismatch.')
claims['issuer'] = payload['iss']
return claims
def verify_claims(self, claims):
return bool(claims.get('issuer') == settings.OIDC_OP_ISSUER and claims.get('sub'))
def filter_users_by_claims(self, claims):
ids = OAuthIdentity.objects.filter(issuer=claims['issuer'], subject=claims['sub']).values_list('user_id', flat=True)
return self.UserModel.objects.filter(pk__in=ids)
@transaction.atomic
def create_user(self, claims):
digest = hashlib.sha256(f"{claims['issuer']}:{claims['sub']}".encode()).hexdigest()[:30]
username = f'oidc_{digest}'
email = claims.get('email', '') if claims.get('email_verified') else ''
user = self.UserModel.objects.create_user(username=username, email=email)
user.set_unusable_password()
user.save(update_fields=['password'])
OAuthIdentity.objects.create(user=user, issuer=claims['issuer'], subject=claims['sub'])
return user
+110 -10
View File
@@ -1,10 +1,13 @@
import hashlib
import json
from django.core.exceptions import PermissionDenied, ValidationError from django.core.exceptions import PermissionDenied, ValidationError
from django.db import transaction from django.db import transaction
from django.db.models import Q, Max from django.db.models import Q, Max
from django.core.validators import URLValidator
from django.shortcuts import get_object_or_404 from django.shortcuts import get_object_or_404
from django.utils import timezone from django.utils import timezone
from django.utils.text import slugify from django.utils.text import slugify
from .models import Activity, Board, Card, CardRevision, Column, Membership, Project from .models import Activity, Board, Card, CardRevision, Column, CreationKey, Membership, Project, Tag
class RevisionConflict(Exception): class RevisionConflict(Exception):
@@ -13,6 +16,8 @@ class RevisionConflict(Exception):
def accessible(user): def accessible(user):
if not user.is_authenticated:
return Project.objects.none()
return Project.objects.filter(Q(owner=user) | Q(memberships__user=user)).distinct() return Project.objects.filter(Q(owner=user) | Q(memberships__user=user)).distinct()
@@ -32,13 +37,21 @@ def card_for(user, identifier, write=False):
@transaction.atomic @transaction.atomic
def create_project(user, *, name, description='', git_repository_url=''): def create_project(user, *, name, description='', git_repository_url=''):
if not name.strip():
raise ValidationError('Project name is required.')
if Project.objects.filter(owner=user, name__iexact=name.strip()).exists():
raise ValidationError('You already have a project with this name.')
if git_repository_url:
URLValidator(schemes=['https'])(git_repository_url)
base = slugify(name) or 'project' base = slugify(name) or 'project'
slug = base slug = base
n = 2 n = 2
while Project.objects.filter(owner=user, slug=slug).exists(): while Project.objects.filter(owner=user, slug=slug).exists():
slug = f'{base}-{n}' slug = f'{base}-{n}'
n += 1 n += 1
project = Project.objects.create(owner=user, name=name, slug=slug, description=description, git_repository_url=git_repository_url) project = Project(owner=user, name=name, slug=slug, description=description, git_repository_url=git_repository_url)
project.full_clean()
project.save()
board = Board.objects.create(project=project) board = Board.objects.create(project=project)
for index, title in enumerate(('To-do', 'In Progress', 'Done')): for index, title in enumerate(('To-do', 'In Progress', 'Done')):
Column.objects.create(board=board, name=title, position=index, is_default=index == 0, is_done=index == 2) Column.objects.create(board=board, name=title, position=index, is_default=index == 0, is_done=index == 2)
@@ -47,19 +60,35 @@ def create_project(user, *, name, description='', git_repository_url=''):
@transaction.atomic @transaction.atomic
def create_card(user, project, *, title, markdown='', column=None, priority='medium', card_type='task', origin='web'): def create_card(user, project, *, title, markdown='', column=None, priority='medium', card_type='task', origin='web', idempotency_key=None):
project_for(user, project.pk, write=True) project_for(user, project.pk, write=True)
if priority not in dict(Card.PRIORITY) or card_type not in dict(Card.TYPE): if priority not in dict(Card.PRIORITY) or card_type not in dict(Card.TYPE):
raise ValidationError('Invalid priority or card type.') raise ValidationError('Invalid priority or card type.')
if not title.strip():
raise ValidationError('Card title is required.')
if idempotency_key:
if len(idempotency_key) > 128:
raise ValidationError('Idempotency key is too long.')
payload = json.dumps({'project': str(project.pk), 'title': title, 'markdown': markdown, 'column': str(column.pk) if column else None, 'priority': priority, 'card_type': card_type}, sort_keys=True)
payload_hash = hashlib.sha256(payload.encode()).hexdigest()
existing = CreationKey.objects.filter(user=user, key=idempotency_key).select_related('card').first()
if existing:
if existing.payload_hash != payload_hash:
raise ValidationError('Idempotency key was already used with different card details.')
return existing.card
column = column or project.board.columns.get(is_default=True, archived=False) column = column or project.board.columns.get(is_default=True, archived=False)
if column.board_id != project.board.pk or column.archived: if column.board_id != project.board.pk or column.archived:
raise ValidationError('Column is not available in this project.') raise ValidationError('Column is not available in this project.')
position = (Card.objects.filter(column=column, archived=False).aggregate(Max('position'))['position__max'] or 0) + 1 position = (Card.objects.filter(column=column, archived=False).aggregate(Max('position'))['position__max'] or 0) + 1
card = Card.objects.create(project=project, column=column, title=title, description_markdown=markdown, card = Card(project=project, column=column, title=title, description_markdown=markdown,
priority=priority, card_type=card_type, position=position, created_by=user, priority=priority, card_type=card_type, position=position, created_by=user,
completed_at=timezone.now() if column.is_done else None) completed_at=timezone.now() if column.is_done else None)
card.full_clean()
card.save()
CardRevision.objects.create(card=card, revision=1, markdown=markdown, actor=user) CardRevision.objects.create(card=card, revision=1, markdown=markdown, actor=user)
Activity.objects.create(project=project, card=card, actor=user, action='card.created', origin=origin) Activity.objects.create(project=project, card=card, actor=user, action='card.created', origin=origin)
if idempotency_key:
CreationKey.objects.create(user=user, key=idempotency_key, payload_hash=payload_hash, card=card)
return card return card
@@ -80,12 +109,11 @@ def update_card(user, card, *, expected_revision=None, origin='web', **changes):
if getattr(card, field) != value: if getattr(card, field) != value:
setattr(card, field, value) setattr(card, field, value)
changed.append(field) changed.append(field)
if markdown_changed:
card.revision += 1
if changed: if changed:
card.revision += 1
card.full_clean()
card.save() card.save()
if markdown_changed: CardRevision.objects.create(card=card, revision=card.revision, markdown=card.description_markdown, actor=user)
CardRevision.objects.create(card=card, revision=card.revision, markdown=card.description_markdown, actor=user)
Activity.objects.create(project=card.project, card=card, actor=user, action='card.updated', detail={'fields': changed}, origin=origin) Activity.objects.create(project=card.project, card=card, actor=user, action='card.updated', detail={'fields': changed}, origin=origin)
return card return card
@@ -119,3 +147,75 @@ def set_default(user, column):
column.is_default = True column.is_default = True
column.save(update_fields=['is_default']) column.save(update_fields=['is_default'])
return column return column
@transaction.atomic
def archive_column(user, column):
project_for(user, column.board.project_id, write=True)
if column.is_default or column.cards.filter(archived=False).exists():
raise ValidationError('Choose another default and move cards before archiving this column.')
column.archived = True
column.save(update_fields=['archived'])
return column
@transaction.atomic
def reorder_columns(user, project, ids):
project_for(user, project.pk, write=True)
columns = list(project.board.columns.filter(archived=False))
if len(ids) != len(columns) or set(map(str, ids)) != {str(c.pk) for c in columns}:
raise ValidationError('Invalid column order.')
for index, identifier in enumerate(ids):
Column.objects.filter(pk=identifier, board=project.board).update(position=index)
return columns
@transaction.atomic
def shift_column(user, column, direction):
project = project_for(user, column.board.project_id, write=True)
ids = [str(c.pk) for c in project.board.columns.filter(archived=False)]
index = ids.index(str(column.pk))
target = max(0, min(index + direction, len(ids) - 1))
ids[index], ids[target] = ids[target], ids[index]
reorder_columns(user, project, ids)
return column
@transaction.atomic
def update_column(user, column, *, name=None, color=None, is_done=None, origin='web'):
column = Column.objects.select_for_update().get(pk=column.pk)
project = project_for(user, column.board.project_id, write=True)
if name is not None:
column.name = name
if color is not None:
column.color = color
completion_changed = is_done is not None and column.is_done != is_done
if is_done is not None:
column.is_done = is_done
column.full_clean()
column.save()
if completion_changed:
Card.objects.filter(column=column, archived=False).update(completed_at=timezone.now() if is_done else None)
Activity.objects.create(project=project, actor=user, action='column.updated', detail={'column_id': str(column.pk)}, origin=origin)
return column
def set_assignee(user, card, assignee, origin='web'):
project_for(user, card.project_id, write=True)
if assignee and assignee.pk != card.project.owner_id and not Membership.objects.filter(project=card.project, user=assignee).exists():
raise ValidationError('Assignee must have access to this project.')
card.assignee = assignee
card.save(update_fields=['assignee', 'updated_at'])
Activity.objects.create(project=card.project, card=card, actor=user, action='card.assigned', detail={'assignee': assignee.pk if assignee else None}, origin=origin)
return card
@transaction.atomic
def set_tags(user, card, tags, origin='web'):
project_for(user, card.project_id, write=True)
tags = list(tags)
if any(tag.project_id != card.project_id for tag in tags):
raise ValidationError('Tags must belong to this project.')
card.tags.set(tags)
Activity.objects.create(project=card.project, card=card, actor=user, action='card.tags_changed', origin=origin)
return card
+37 -1
View File
@@ -1 +1,37 @@
<div class="d-flex gap-3 overflow-auto" style="min-height:20rem">{% for column in columns %}<section class="card flex-shrink-0" style="width:19rem;border-top:4px solid {{ column.color }}"><div class="card-header"><strong>{{ column.name }}</strong>{% if column.is_default %}<small> · Default</small>{% endif %}<a class="float-end" href="{% url 'projects:column_edit' column.id %}" aria-label="Edit {{ column.name }}">Edit</a></div><div class="card-body" data-column="{{ column.id }}" style="min-height:12rem">{% for card in column.visible_cards %}<article class="card mb-2" data-move="{% url 'projects:card_move' card.id %}"><div class="card-body"><a href="{% url 'projects:card' card.id %}"><strong>{{ card.title }}</strong></a><div><span class="badge text-bg-secondary">{{ card.get_priority_display }}</span> <small>{{ card.get_card_type_display }}</small>{% if card.is_blocked %}<span class="badge text-bg-danger">Blocked</span>{% endif %}</div><form method="post" action="{% url 'projects:card_move' card.id %}" class="mt-2">{% csrf_token %}<select name="column_id" aria-label="Move {{ card.title }}" class="form-select form-select-sm" onchange="this.form.submit()">{% for choice in columns %}<option value="{{ choice.id }}" {% if choice.id == column.id %}selected{% endif %}>{{ choice.name }}</option>{% endfor %}</select></form></div></article>{% endfor %}</div></section>{% endfor %}</div> <div id="kanban-columns" class="d-flex gap-3 overflow-auto" style="min-height:20rem">
{% for column in columns %}
<section class="card flex-shrink-0" style="width:19rem;border-top:4px solid {{ column.color }}" data-column-card="{{ column.id }}">
<div class="card-header d-flex justify-content-between align-items-center">
<div><strong>{{ column.name }}</strong>{% if column.is_default %}<small> · Default</small>{% endif %}</div>
{% if can_edit %}<a href="{% url 'projects:column_edit' column.id %}" aria-label="Edit {{ column.name }}">Edit</a>{% endif %}
</div>
{% if can_edit %}<div class="px-3 pt-2 d-flex gap-1">
<form method="post" action="{% url 'projects:column_shift' column.id %}">{% csrf_token %}<input type="hidden" name="direction" value="left"><button class="btn btn-sm btn-outline-secondary" aria-label="Move {{ column.name }} left">←</button></form>
<form method="post" action="{% url 'projects:column_shift' column.id %}">{% csrf_token %}<input type="hidden" name="direction" value="right"><button class="btn btn-sm btn-outline-secondary" aria-label="Move {{ column.name }} right">→</button></form>
{% if not column.is_default %}<form method="post" action="{% url 'projects:column_default' column.id %}">{% csrf_token %}<button class="btn btn-sm btn-outline-secondary">Make default</button></form>{% endif %}
{% if not column.is_default and not column.active_count %}<form method="post" action="{% url 'projects:column_archive' column.id %}">{% csrf_token %}<button class="btn btn-sm btn-outline-danger">Archive</button></form>{% endif %}
</div>{% endif %}
<div class="card-body" data-column="{{ column.id }}" style="min-height:12rem">
{% for card in column.visible_cards %}
<article class="card mb-2" data-move="{% url 'projects:card_move' card.id %}">
<div class="card-body">
<a href="{% url 'projects:card' card.id %}"><strong>{{ card.title }}</strong></a>
<div><span class="badge text-bg-secondary">{{ card.get_priority_display }}</span> <small>{{ card.get_card_type_display }}</small>{% if card.is_blocked %}<span class="badge text-bg-danger">Blocked</span>{% endif %}</div>
{% if can_edit %}<form method="post" action="{% url 'projects:card_move' card.id %}" class="mt-2">
{% csrf_token %}
<select name="column_id" aria-label="Move {{ card.title }}" class="form-select form-select-sm" onchange="this.form.submit()">
{% for choice in columns %}<option value="{{ choice.id }}" {% if choice.id == column.id %}selected{% endif %}>{{ choice.name }}</option>{% endfor %}
</select>
</form>
<div class="d-flex gap-1 mt-2">
<form method="post" action="{% url 'projects:card_move' card.id %}">{% csrf_token %}<input type="hidden" name="column_id" value="{{ column.id }}"><input type="hidden" name="position" value="{{ forloop.counter0|add:'-1' }}"><button class="btn btn-sm btn-outline-secondary" aria-label="Move {{ card.title }} up">↑</button></form>
<form method="post" action="{% url 'projects:card_move' card.id %}">{% csrf_token %}<input type="hidden" name="column_id" value="{{ column.id }}"><input type="hidden" name="position" value="{{ forloop.counter0|add:'1' }}"><button class="btn btn-sm btn-outline-secondary" aria-label="Move {{ card.title }} down">↓</button></form>
</div>{% endif %}
</div>
</article>
{% endfor %}
</div>
</section>
{% endfor %}
</div>
{% if page_obj.has_other_pages %}<nav aria-label="Card pages" class="mt-3">{% if page_obj.has_previous %}<a href="?{{ filters_query }}&page={{ page_obj.previous_page_number }}">Previous</a>{% endif %} <span>Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}</span> {% if page_obj.has_next %}<a href="?{{ filters_query }}&page={{ page_obj.next_page_number }}">Next</a>{% endif %}</nav>{% endif %}
@@ -1 +1 @@
<div class="row g-3">{% for project in projects %}<div class="col-md-6 col-xl-4"><div class="card h-100"><div class="card-body"><h2 class="h5"><a href="{% url 'projects:board' project.id %}">{{ project.name }}</a></h2><p>{{ project.description|truncatechars:180 }}</p><small>{{ project.card_count }} cards</small>{% if project.git_repository_url %}<p><a href="{{ project.git_repository_url }}" rel="noopener noreferrer">Repository</a></p>{% endif %}</div></div></div>{% empty %}<p>No projects found.</p>{% endfor %}</div> <div class="row g-3">{% for project in projects %}<div class="col-md-6 col-xl-4"><div class="card h-100"><div class="card-body"><h2 class="h5"><a href="{% url 'projects:board' project.id %}">{{ project.name }}</a></h2><p>{{ project.description|truncatechars:180 }}</p><small>{{ project.card_count }} cards</small>{% if project.git_repository_url %}<p><a href="{{ project.git_repository_url }}" rel="noopener noreferrer">Repository</a></p>{% endif %}</div></div></div>{% empty %}<p>No projects found.</p>{% endfor %}</div>{% if page_obj.has_other_pages %}<nav aria-label="Project pages" class="mt-3">{% if page_obj.has_previous %}<a href="?{{ filters_query }}&page={{ page_obj.previous_page_number }}">Previous</a>{% endif %} <span>Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}</span> {% if page_obj.has_next %}<a href="?{{ filters_query }}&page={{ page_obj.next_page_number }}">Next</a>{% endif %}</nav>{% endif %}
+43 -1
View File
@@ -1 +1,43 @@
{% extends 'core/base.html' %}{% block content %}<div class="d-flex justify-content-between align-items-center mb-3"><div><a href="{% url 'projects:list' %}">All projects</a><h1>{{ project.name }}</h1><p>{{ project.description }}</p>{% if project.git_repository_url %}<a href="{{ project.git_repository_url }}" rel="noopener noreferrer">Repository</a>{% endif %}</div><div><a class="btn btn-outline-secondary" href="{% url 'projects:edit' project.id %}">Edit project</a> <a class="btn btn-success" href="{% url 'projects:card_create' project.id %}">New card</a></div></div><form class="row g-2 mb-3" method="get"><div class="col"><input class="form-control" name="q" value="{{ query }}" placeholder="Search cards and specifications" aria-label="Search cards" hx-get="{% url 'projects:board' project.id %}" hx-trigger="input changed delay:300ms" hx-target="#board-results" hx-include="closest form"></div><div class="col-auto"><select class="form-select" name="priority" aria-label="Priority" hx-get="{% url 'projects:board' project.id %}" hx-trigger="change" hx-target="#board-results" hx-include="closest form"><option value="">All priorities</option><option value="high">High</option><option value="medium">Medium</option><option value="low">Low</option></select></div><div class="col-auto"><button class="btn btn-outline-secondary">Search</button></div></form><div id="board-results">{% include 'projects/_board.html' %}</div><a class="btn btn-outline-secondary mt-3" href="{% url 'projects:column_create' project.id %}">Add column</a><script src="https://unpkg.com/htmx.org@2.0.4"></script><script src="https://cdn.jsdelivr.net/npm/sortablejs@1.15.6/Sortable.min.js"></script><script>document.querySelectorAll('[data-column]').forEach(el=>new Sortable(el,{group:'cards',animation:150,onEnd:e=>{const form=new FormData();form.append('column_id',e.to.dataset.column);form.append('position',e.newIndex);fetch(e.item.dataset.move,{method:'POST',headers:{'X-CSRFToken':document.querySelector('[name=csrfmiddlewaretoken]').value},body:form}).then(r=>{if(!r.ok)location.reload()})}}));</script>{% csrf_token %}{% endblock %} {% extends 'core/base.html' %}
{% block content %}
<div class="d-flex justify-content-between align-items-center mb-3">
<div><a href="{% url 'projects:list' %}">All projects</a><h1>{{ project.name }}</h1><p>{{ project.description }}</p>{% if project.git_repository_url %}<a href="{{ project.git_repository_url }}" rel="noopener noreferrer">Repository</a>{% endif %}<p>{{ done_count }} of {{ total_count }} cards done</p></div>
{% if can_edit %}<div><a class="btn btn-outline-secondary" href="{% url 'projects:edit' project.id %}">Edit project</a> {% if project.archived %}<form class="d-inline" method="post" action="{% url 'projects:restore' project.id %}">{% csrf_token %}<button class="btn btn-outline-success">Restore project</button></form>{% else %}<form class="d-inline" method="post" action="{% url 'projects:archive' project.id %}">{% csrf_token %}<button class="btn btn-outline-danger">Archive project</button></form> <a class="btn btn-success" href="{% url 'projects:card_create' project.id %}">New card</a>{% endif %}</div>{% endif %}
</div>
<div class="d-flex gap-3 flex-wrap mb-3">{% for label,count in priority_counts %}<span class="badge text-bg-light border">{{ label }}: {{ count }} open</span>{% endfor %}</div>
<form class="row g-2 mb-3" method="get" role="search">
<div class="col"><input class="form-control" name="q" value="{{ query }}" placeholder="Search cards and specifications" aria-label="Search cards" hx-get="{% url 'projects:board' project.id %}" hx-trigger="input changed delay:300ms" hx-target="#board-results" hx-include="closest form"></div>
<div class="col-auto"><select class="form-select" name="priority" aria-label="Priority" hx-get="{% url 'projects:board' project.id %}" hx-trigger="change" hx-target="#board-results" hx-include="closest form"><option value="">All priorities</option><option value="high" {% if selected_priority == 'high' %}selected{% endif %}>High</option><option value="medium" {% if selected_priority == 'medium' %}selected{% endif %}>Medium</option><option value="low" {% if selected_priority == 'low' %}selected{% endif %}>Low</option></select></div>
<div class="col-auto"><select class="form-select" name="card_type" aria-label="Card type" hx-get="{% url 'projects:board' project.id %}" hx-trigger="change" hx-target="#board-results" hx-include="closest form"><option value="">All types</option>{% for value,label in card_types %}<option value="{{ value }}" {% if value == selected_type %}selected{% endif %}>{{ label }}</option>{% endfor %}</select></div>
<div class="col-auto"><select class="form-select" name="column" aria-label="Column" hx-get="{% url 'projects:board' project.id %}" hx-trigger="change" hx-target="#board-results" hx-include="closest form"><option value="">All columns</option>{% for choice in columns %}<option value="{{ choice.id }}" {% if choice.id|stringformat:'s' == selected_column %}selected{% endif %}>{{ choice.name }}</option>{% endfor %}</select></div>
<div class="col-auto"><select class="form-select" name="assignee" aria-label="Assignee" hx-get="{% url 'projects:board' project.id %}" hx-trigger="change" hx-target="#board-results" hx-include="closest form"><option value="">All assignees</option>{% for person in assignable %}<option value="{{ person.id }}" {% if person.id|stringformat:'s' == selected_assignee %}selected{% endif %}>{{ person.username }}</option>{% endfor %}</select></div>
<div class="col-auto"><select class="form-select" name="tag" aria-label="Tag" hx-get="{% url 'projects:board' project.id %}" hx-trigger="change" hx-target="#board-results" hx-include="closest form"><option value="">All tags</option>{% for tag in tags %}<option value="{{ tag.id }}" {% if tag.id|stringformat:'s' == selected_tag %}selected{% endif %}>{{ tag.name }}</option>{% endfor %}</select></div>
<div class="col-auto"><label><input type="checkbox" name="archived" value="1" {% if show_archived %}checked{% endif %}> Archived</label></div>
<div class="col-auto"><a class="btn btn-outline-secondary" href="{% url 'projects:board' project.id %}">Clear</a></div>
</form>
<div id="board-results">{% include 'projects/_board.html' %}</div>
{% if can_edit %}<a class="btn btn-outline-secondary mt-3" href="{% url 'projects:column_create' project.id %}">Add column</a>
<a class="btn btn-outline-secondary mt-3" href="{% url 'projects:tag_create' project.id %}">Add tag</a>{% endif %}
<h2 class="h5 mt-4">Recent activity</h2><ul>{% for event in recent_activity %}<li>{{ event.created_at }} · {{ event.action }}{% if event.actor %} by {{ event.actor }}{% endif %}</li>{% empty %}<li>No activity yet.</li>{% endfor %}</ul>
<script src="https://unpkg.com/htmx.org@2.0.4"></script>
{% if can_edit %}
<script src="https://cdn.jsdelivr.net/npm/sortablejs@1.15.6/Sortable.min.js"></script>
<script>
const csrf = document.querySelector('[name=csrfmiddlewaretoken]').value;
function wireBoard() {
document.querySelectorAll('[data-column]').forEach(el => new Sortable(el, {group:'cards', animation:150, onEnd:event => {
const form = new FormData(); form.append('column_id', event.to.dataset.column); form.append('position', event.newIndex);
fetch(event.item.dataset.move, {method:'POST', headers:{'X-CSRFToken':csrf}, body:form}).then(response => {if (!response.ok) location.reload()});
}}));
const columns = document.querySelector('#kanban-columns');
if (columns) new Sortable(columns, {animation:150, handle:'.card-header', onEnd:() => {
const form = new FormData();
columns.querySelectorAll('[data-column-card]').forEach(item => form.append('columns', item.dataset.columnCard));
fetch('{% url 'projects:column_reorder' project.id %}', {method:'POST', headers:{'X-CSRFToken':csrf}, body:form}).then(response => {if (!response.ok) location.reload()});
}});
}
wireBoard(); document.body.addEventListener('htmx:afterSwap', wireBoard);
</script>
{% csrf_token %}
{% endif %}
{% endblock %}
+12 -1
View File
@@ -1 +1,12 @@
{% extends 'core/base.html' %}{% load project_markdown %}{% block content %}<a href="{% url 'projects:board' card.project_id %}">← {{ card.project.name }}</a><div class="d-flex justify-content-between mt-3"><h1>{{ card.title }}</h1><a class="btn btn-outline-secondary" href="{% url 'projects:card_edit' card.id %}">Edit</a></div><p><span class="badge text-bg-secondary">{{ card.get_priority_display }}</span> {{ card.column.name }} · {{ card.get_card_type_display }} · Revision {{ card.revision }}</p><div class="card card-body mb-4 markdown-body">{{ card.description_markdown|safe_markdown }}</div><h2 class="h4">Progress notes</h2>{% for comment in card.comments.all %}<div class="card card-body mb-2"><small>{{ comment.author }} · {{ comment.created_at }}</small><p>{{ comment.body|linebreaksbr }}</p></div>{% endfor %}<form method="post" action="{% url 'projects:card_comment' card.id %}">{% csrf_token %}<label for="comment">Add note</label><textarea class="form-control" id="comment" name="body" required></textarea><button class="btn btn-success mt-2">Add note</button></form><h2 class="h4 mt-4">History</h2><ul>{% for event in card.activity.all %}<li>{{ event.created_at }} · {{ event.action }} by {{ event.actor }}</li>{% endfor %}</ul>{% endblock %} {% extends 'core/base.html' %}{% load project_markdown %}
{% block content %}
<a href="{% url 'projects:board' card.project_id %}">← {{ card.project.name }}</a>
<div class="d-flex justify-content-between mt-3"><h1>{{ card.title }}</h1>{% if can_edit %}<div><a class="btn btn-outline-secondary" href="{% url 'projects:card_edit' card.id %}">Edit</a> {% if card.archived %}<form method="post" action="{% url 'projects:card_restore' card.id %}" class="d-inline">{% csrf_token %}<button class="btn btn-outline-success">Restore</button></form>{% else %}<form method="post" action="{% url 'projects:card_archive' card.id %}" class="d-inline">{% csrf_token %}<button class="btn btn-outline-danger">Archive</button></form>{% endif %}</div>{% endif %}</div>
<p><span class="badge text-bg-secondary">{{ card.get_priority_display }}</span> {{ card.column.name }} · {{ card.get_card_type_display }} · Revision {{ card.revision }}</p>
<div class="card card-body mb-4 markdown-body">{{ card.description_markdown|safe_markdown }}</div>
<details><summary>Raw Markdown</summary><pre>{{ card.description_markdown }}</pre></details>
<h2 class="h4 mt-4">Progress notes</h2>
{% for comment in card.comments.all %}<div class="card card-body mb-2"><small>{{ comment.author }} · {{ comment.created_at }}</small><p>{{ comment.body|linebreaksbr }}</p></div>{% endfor %}
{% if can_edit %}<form method="post" action="{% url 'projects:card_comment' card.id %}">{% csrf_token %}<label for="comment">Add note</label><textarea class="form-control" id="comment" name="body" required></textarea><button class="btn btn-success mt-2">Add note</button></form>{% endif %}
<h2 class="h4 mt-4">History</h2><ul>{% for event in card.activity.all %}<li>{{ event.created_at }} · {{ event.action }} by {{ event.actor }}</li>{% endfor %}</ul>
{% endblock %}
+1 -1
View File
@@ -1 +1 @@
{% extends 'core/base.html' %}{% block content %}<div style="max-width:52rem"><h1>{{ title }}</h1><form method="post" class="card card-body">{% csrf_token %}{{ form.as_p }}<button class="btn btn-success align-self-start">Save</button></form></div>{% endblock %} {% extends 'core/base.html' %}{% block content %}<div style="max-width:52rem"><h1>{{ title }}</h1><form method="post" class="card card-body" id="editor-form">{% csrf_token %}{{ form.as_p }}{% if show_preview %}<button type="button" class="btn btn-outline-secondary align-self-start mb-3" id="preview-button">Preview Markdown</button><div class="card card-body mb-3 markdown-body" id="preview-result" aria-live="polite" hidden></div>{% endif %}<button class="btn btn-success align-self-start">Save</button></form></div>{% if show_preview %}<script>document.querySelector('#preview-button').addEventListener('click',async()=>{const form=document.querySelector('#editor-form');const result=await fetch('{% url 'projects:preview' %}',{method:'POST',body:new FormData(form)});if(result.ok){const target=document.querySelector('#preview-result');target.innerHTML=await result.text();target.hidden=false}});</script>{% endif %}{% endblock %}
+1 -1
View File
@@ -1 +1 @@
{% extends 'core/base.html' %}{% block content %}<div class="d-flex justify-content-between align-items-center mb-4"><div><h1>Projects</h1><p>Boards and specifications across your workspace.</p></div><a class="btn btn-success" href="{% url 'projects:create' %}">New project</a></div><form method="get" role="search" class="mb-3"><label for="project-search" class="form-label">Search projects and cards</label><input id="project-search" class="form-control" name="q" value="{{ query }}" hx-get="{% url 'projects:list' %}" hx-trigger="input changed delay:300ms" hx-target="#project-results" hx-indicator="#search-loading"><span id="search-loading" class="htmx-indicator">Searching…</span></form><div id="project-results">{% include 'projects/_project_list.html' %}</div><script src="https://unpkg.com/htmx.org@2.0.4"></script>{% endblock %} {% extends 'core/base.html' %}{% block content %}<div class="d-flex justify-content-between align-items-center mb-4"><div><h1>Projects</h1><p>Boards and specifications across your workspace.</p></div><a class="btn btn-success" href="{% url 'projects:create' %}">New project</a></div><p><a href="{% url 'projects:list' %}">Active</a> · <a href="{% url 'projects:list' %}?archived=1">Archived</a></p><form method="get" role="search" class="mb-3"><label for="project-search" class="form-label">Search projects and cards</label><input id="project-search" class="form-control" name="q" value="{{ query }}" hx-get="{% url 'projects:list' %}{% if show_archived %}?archived=1{% endif %}" hx-trigger="input changed delay:300ms" hx-target="#project-results" hx-indicator="#search-loading"><span id="search-loading" class="htmx-indicator">Searching…</span></form><div id="project-results">{% include 'projects/_project_list.html' %}</div><script src="https://unpkg.com/htmx.org@2.0.4"></script>{% endblock %}
+1 -1
View File
@@ -1 +1 @@
<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Sign in · Common Ground</title><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css"></head><body class="bg-light"><main class="container" style="max-width:28rem;margin-top:12vh"><h1>Common Ground</h1><p>Sign in to your dashboard.</p><form method="post" class="card card-body">{% csrf_token %}{{ form.as_p }}<input type="hidden" name="next" value="{{ next }}"><button class="btn btn-success">Sign in</button></form></main></body></html> <!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>Sign in · Common Ground</title><link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.8/dist/css/bootstrap.min.css"></head><body class="bg-light"><main class="container" style="max-width:28rem;margin-top:12vh"><h1>Common Ground</h1><p>Sign in to your dashboard.</p><form method="post" class="card card-body">{% csrf_token %}{{ form.as_p }}<input type="hidden" name="next" value="{{ next }}"><button class="btn btn-success">Sign in</button></form>{% if oidc_enabled %}<a class="btn btn-outline-primary mt-3" href="{% url 'oidc_authentication_init' %}">Sign in with your organization</a>{% endif %}</main></body></html>
+17 -1
View File
@@ -1 +1,17 @@
{% extends 'core/base.html' %}{% block content %}<h1>Profile</h1><div class="card card-body" style="max-width:40rem"><h2 class="h5">Account</h2><form method="post">{% csrf_token %}{{ form.as_p }}<button class="btn btn-success">Save profile</button></form><a class="mt-3" href="{% url 'password_change' %}">Change password</a><form method="post" action="{% url 'logout' %}" class="mt-3">{% csrf_token %}<button class="btn btn-outline-secondary">Sign out</button></form></div><h2 class="h5 mt-4">MCP connections</h2><p>Remote MCP and OAuth connections are being prepared. No clients are connected.</p>{% endblock %} {% extends 'core/base.html' %}
{% block content %}
<h1>Profile</h1>
<div class="card card-body" style="max-width:40rem">
<h2 class="h5">Account</h2>
<form method="post">{% csrf_token %}{{ form.as_p }}<button class="btn btn-success">Save profile</button></form>
<a class="mt-3" href="{% url 'password_change' %}">Change password</a>
<form method="post" action="{% url 'logout' %}" class="mt-3">{% csrf_token %}<button class="btn btn-outline-secondary">Sign out</button></form>
</div>
<h2 class="h5 mt-4">Connected sign-in identities</h2>
{% for identity in identities %}<p>{{ identity.issuer }} · {{ identity.subject }}</p>{% empty %}<p>No external sign-in identity connected.</p>{% endfor %}
<h2 class="h5 mt-4">MCP connections</h2>
<p>Endpoint: <code>{{ mcp_url }}</code>. Authorize a registered client with <code>projects:read</code> and optionally <code>projects:write</code>. Client registration requires a signed-in account and a CSRF token for browser requests.</p>
{% for grant in grants %}
<div class="card card-body mb-2" style="max-width:40rem"><strong>{{ grant.application.name|default:'Connected client' }}</strong><span>Permissions: {{ grant.scope }}</span><small>Expires {{ grant.expires }}</small><form method="post" action="{% url 'projects:revoke_connection' grant.id %}">{% csrf_token %}<button class="btn btn-sm btn-outline-danger mt-2">Revoke</button></form></div>
{% empty %}<p>No active MCP clients.</p>{% endfor %}
{% endblock %}
+90
View File
@@ -0,0 +1,90 @@
import base64
import hashlib
import json
from urllib.parse import parse_qs, urlparse
from django.contrib.auth import get_user_model
from django.test import TestCase, Client as DjangoClient
from django.conf import settings
from asgiref.sync import async_to_sync
from unittest.mock import patch
from mcp.server.auth.provider import AccessToken as McpAccessToken
from mcp.server.mcpserver.exceptions import ToolError
from oauth2_provider.models import Application
from mcp_server.server import _verified, create_server
from .services import create_project
class OAuthMcpTests(TestCase):
def setUp(self):
self.user = get_user_model().objects.create_user('mcp-user', password='test-password')
self.application = Application.objects.create(
user=self.user, name='Test client', client_type=Application.CLIENT_PUBLIC,
authorization_grant_type=Application.GRANT_AUTHORIZATION_CODE,
redirect_uris='http://localhost:9876/callback',
)
def test_pkce_token_and_revocation(self):
self.client.force_login(self.user)
verifier = 'v' * 64
challenge = base64.urlsafe_b64encode(hashlib.sha256(verifier.encode()).digest()).decode().rstrip('=')
params = {'response_type': 'code', 'client_id': self.application.client_id,
'redirect_uri': 'http://localhost:9876/callback', 'scope': 'projects:read projects:write',
'state': 'test-state', 'code_challenge': challenge, 'code_challenge_method': 'S256',
'resource': settings.MCP_PUBLIC_URL}
response = self.client.get('/o/authorize/', params)
self.assertEqual(response.status_code, 200, response.content[:300])
form = response.context['form']
payload = {field.name: field.value() for field in form if field.field.widget.is_hidden and field.value() is not None}
payload['allow'] = 'Authorize'
response = self.client.post('/o/authorize/', payload)
self.assertEqual(response.status_code, 302, response.content[:300])
code = parse_qs(urlparse(response['Location']).query)['code'][0]
response = self.client.post('/o/token/', {'grant_type': 'authorization_code', 'code': code,
'redirect_uri': 'http://localhost:9876/callback', 'client_id': self.application.client_id,
'code_verifier': verifier, 'resource': settings.MCP_PUBLIC_URL})
self.assertEqual(response.status_code, 200, response.content[:300])
secret = response.json()['access_token']
info = _verified(secret)
self.assertEqual(info['user_id'], self.user.pk)
self.assertIn('projects:write', info['scopes'])
self.client.post(f'/projects/profile/connections/{self.user.oauth2_provider_accesstoken.first().pk}/revoke/')
self.assertIsNone(_verified(secret))
def test_discovery_and_project_access(self):
self.assertEqual(self.client.get('/.well-known/oauth-authorization-server').status_code, 200)
project = create_project(self.user, name='Private')
self.assertEqual(self.client.get(f'/projects/{project.pk}/').status_code, 302)
def test_client_registration_requires_authenticated_user_and_csrf(self):
metadata = {'client_name': 'Private test client', 'redirect_uris': ['https://client.example/callback'],
'grant_types': ['authorization_code', 'refresh_token'], 'token_endpoint_auth_method': 'none'}
browser = DjangoClient(enforce_csrf_checks=True)
response = browser.post('/o/register/', data=json.dumps(metadata), content_type='application/json')
self.assertEqual(response.status_code, 401)
browser.force_login(self.user)
response = browser.post('/o/register/', data=json.dumps(metadata), content_type='application/json')
self.assertEqual(response.status_code, 401)
browser.get('/projects/profile/')
csrf = browser.cookies['csrftoken'].value
response = browser.post('/o/register/', data=json.dumps(metadata), content_type='application/json', HTTP_X_CSRFTOKEN=csrf)
self.assertEqual(response.status_code, 201, response.content[:300])
client_id = response.json()['client_id']
registered = Application.objects.get(client_id=client_id)
self.assertEqual(registered.user_id, self.user.pk)
def test_mcp_default_card_and_scope_enforcement(self):
project = create_project(self.user, name='BoomCast', git_repository_url='https://example.com/repo')
server = create_server()
access = McpAccessToken(token='test', client_id='test', scopes=['projects:read', 'projects:write'], subject=str(self.user.pk))
with patch('mcp_server.server.get_access_token', return_value=access):
result = async_to_sync(server.call_tool)('specs_create', {'project': str(project.pk), 'title': 'Field notes', 'markdown': '# Notes\n\n```py\nprint(1)\n```'})
card = result.structured_content
self.assertEqual(card['priority'], 'medium')
self.assertEqual(card['markdown'], '# Notes\n\n```py\nprint(1)\n```')
result = async_to_sync(server.call_tool)('projects_get', {'project': str(project.pk)})
self.assertEqual(result.structured_content['git_repository_url'], 'https://example.com/repo')
read = McpAccessToken(token='test', client_id='test', scopes=['projects:read'], subject=str(self.user.pk))
with patch('mcp_server.server.get_access_token', return_value=read):
with self.assertRaises(ToolError):
async_to_sync(server.call_tool)('cards_set_priority', {'card_id': card['id'], 'priority': 'high', 'expected_revision': 1})
+22
View File
@@ -0,0 +1,22 @@
from django.contrib.auth import get_user_model
from django.test import TestCase, override_settings
from .models import OAuthIdentity
from .oidc import IdentityBackend
@override_settings(
OIDC_OP_TOKEN_ENDPOINT='https://id.example/token', OIDC_OP_USER_ENDPOINT='https://id.example/userinfo',
OIDC_OP_JWKS_ENDPOINT='https://id.example/jwks', OIDC_RP_CLIENT_ID='dashboard',
OIDC_RP_CLIENT_SECRET='test-secret', OIDC_RP_SIGN_ALGO='RS256', OIDC_OP_ISSUER='https://id.example/',
)
class IdentityMappingTests(TestCase):
def test_matching_email_does_not_link_existing_local_account(self):
local = get_user_model().objects.create_user('local', email='same@example.com', password='password')
backend = IdentityBackend()
claims = {'issuer': 'https://id.example/', 'sub': 'subject-1', 'email': 'same@example.com', 'email_verified': True}
self.assertFalse(backend.filter_users_by_claims(claims).exists())
external = backend.create_user(claims)
self.assertNotEqual(local.pk, external.pk)
self.assertFalse(external.has_usable_password())
self.assertEqual(OAuthIdentity.objects.get(user=external).subject, 'subject-1')
self.assertEqual(list(backend.filter_users_by_claims(claims)), [external])
+53 -2
View File
@@ -1,8 +1,9 @@
from django.contrib.auth import get_user_model from django.contrib.auth import get_user_model
from django.test import TestCase from django.test import TestCase
from django.core.exceptions import ValidationError
from django.urls import reverse from django.urls import reverse
from .models import Card, CardRevision from .models import Card, CardRevision, Membership
from .services import RevisionConflict, card_for, create_card, create_project, move_card, update_card from .services import RevisionConflict, card_for, create_card, create_project, move_card, update_card, update_column
class ProjectWorkflowTests(TestCase): class ProjectWorkflowTests(TestCase):
@@ -22,6 +23,13 @@ class ProjectWorkflowTests(TestCase):
update_card(self.owner, card, expected_revision=1, description_markdown='# Overwritten') update_card(self.owner, card, expected_revision=1, description_markdown='# Overwritten')
self.assertEqual(Card.objects.get(pk=card.pk).description_markdown, '# Revised') self.assertEqual(Card.objects.get(pk=card.pk).description_markdown, '# Revised')
def test_idempotent_spec_creation(self):
first = create_card(self.owner, self.project, title='Spec', markdown='# Exact\n', idempotency_key='client-request-1')
second = create_card(self.owner, self.project, title='Spec', markdown='# Exact\n', idempotency_key='client-request-1')
self.assertEqual(first.pk, second.pk)
with self.assertRaises(ValidationError):
create_card(self.owner, self.project, title='Different', idempotency_key='client-request-1')
def test_access_and_move(self): def test_access_and_move(self):
card = create_card(self.owner, self.project, title='A') card = create_card(self.owner, self.project, title='A')
self.assertEqual(self.client.get(reverse('projects:board', args=[self.project.pk])).status_code, 302) self.assertEqual(self.client.get(reverse('projects:board', args=[self.project.pk])).status_code, 302)
@@ -33,7 +41,50 @@ class ProjectWorkflowTests(TestCase):
card.refresh_from_db() card.refresh_from_db()
self.assertIsNotNone(card.completed_at) self.assertIsNotNone(card.completed_at)
def test_board_filters_and_escaped_markdown(self):
card = create_card(self.owner, self.project, title='Danger', markdown='<script>alert(1)</script>\n\n# Safe')
self.client.force_login(self.owner)
response = self.client.get(reverse('projects:board', args=[self.project.pk]), {'priority': 'medium'})
self.assertContains(response, 'Danger')
response = self.client.get(reverse('projects:board', args=[self.project.pk]), {'priority': 'high'})
self.assertNotContains(response, 'Danger')
response = self.client.get(reverse('projects:card', args=[card.pk]))
self.assertNotContains(response, '<script>alert(1)</script>', html=False)
self.assertContains(response, '<h1>Safe</h1>', html=False)
def test_completion_flag_updates_existing_cards(self):
card = create_card(self.owner, self.project, title='Complete later')
column = card.column
update_column(self.owner, column, is_done=True)
card.refresh_from_db()
self.assertIsNotNone(card.completed_at)
update_column(self.owner, column, is_done=False)
card.refresh_from_db()
self.assertIsNone(card.completed_at)
def test_preview_sanitizes_script(self):
self.client.force_login(self.owner)
response = self.client.post(reverse('projects:preview'), {'description_markdown': '# Hello\n\n<script>alert(1)</script>'})
self.assertEqual(response.status_code, 200)
self.assertIn('<h1>Hello</h1>', response.content.decode())
self.assertNotIn('<script>', response.content.decode())
def test_existing_dashboard_requires_login(self): def test_existing_dashboard_requires_login(self):
self.assertEqual(self.client.get('/').status_code, 302) self.assertEqual(self.client.get('/').status_code, 302)
self.client.force_login(self.owner) self.client.force_login(self.owner)
self.assertEqual(self.client.get('/').status_code, 200) self.assertEqual(self.client.get('/').status_code, 200)
def test_login_throttles_failed_attempts(self):
for _ in range(5):
self.assertEqual(self.client.post('/accounts/login/', {'username': 'owner', 'password': 'wrong'}).status_code, 200)
self.assertEqual(self.client.post('/accounts/login/', {'username': 'owner', 'password': 'wrong'}).status_code, 429)
def test_viewer_can_read_but_cannot_move_or_edit(self):
Membership.objects.create(project=self.project, user=self.other, role='viewer')
card = create_card(self.owner, self.project, title='Visible')
self.client.force_login(self.other)
response = self.client.get(reverse('projects:board', args=[self.project.pk]))
self.assertContains(response, 'Visible')
self.assertNotContains(response, 'New card')
response = self.client.post(reverse('projects:card_move', args=[card.pk]), {'column_id': str(card.column_id)})
self.assertEqual(response.status_code, 403)
+6
View File
@@ -4,20 +4,26 @@ from . import views
app_name = 'projects' app_name = 'projects'
urlpatterns = [ urlpatterns = [
path('', views.project_list, name='list'), path('', views.project_list, name='list'),
path('preview/', views.markdown_preview, name='preview'),
path('new/', views.project_create, name='create'), path('new/', views.project_create, name='create'),
path('profile/', views.profile, name='profile'), path('profile/', views.profile, name='profile'),
path('profile/connections/<int:grant_id>/revoke/', views.revoke_connection, name='revoke_connection'),
path('<uuid:project_id>/', views.board, name='board'), path('<uuid:project_id>/', views.board, name='board'),
path('<uuid:project_id>/edit/', views.project_edit, name='edit'), path('<uuid:project_id>/edit/', views.project_edit, name='edit'),
path('<uuid:project_id>/archive/', views.project_archive, name='archive'), path('<uuid:project_id>/archive/', views.project_archive, name='archive'),
path('<uuid:project_id>/restore/', views.project_restore, name='restore'),
path('<uuid:project_id>/cards/new/', views.card_create, name='card_create'), path('<uuid:project_id>/cards/new/', views.card_create, name='card_create'),
path('<uuid:project_id>/columns/new/', views.column_create, name='column_create'), path('<uuid:project_id>/columns/new/', views.column_create, name='column_create'),
path('<uuid:project_id>/tags/new/', views.tag_create, name='tag_create'),
path('<uuid:project_id>/columns/reorder/', views.column_reorder, name='column_reorder'), path('<uuid:project_id>/columns/reorder/', views.column_reorder, name='column_reorder'),
path('columns/<uuid:column_id>/edit/', views.column_edit, name='column_edit'), path('columns/<uuid:column_id>/edit/', views.column_edit, name='column_edit'),
path('columns/<uuid:column_id>/default/', views.column_default, name='column_default'), path('columns/<uuid:column_id>/default/', views.column_default, name='column_default'),
path('columns/<uuid:column_id>/shift/', views.column_shift, name='column_shift'),
path('columns/<uuid:column_id>/archive/', views.column_archive, name='column_archive'), path('columns/<uuid:column_id>/archive/', views.column_archive, name='column_archive'),
path('cards/<uuid:card_id>/', views.card_detail, name='card'), path('cards/<uuid:card_id>/', views.card_detail, name='card'),
path('cards/<uuid:card_id>/edit/', views.card_edit, name='card_edit'), path('cards/<uuid:card_id>/edit/', views.card_edit, name='card_edit'),
path('cards/<uuid:card_id>/move/', views.card_move, name='card_move'), path('cards/<uuid:card_id>/move/', views.card_move, name='card_move'),
path('cards/<uuid:card_id>/comment/', views.card_comment, name='card_comment'), path('cards/<uuid:card_id>/comment/', views.card_comment, name='card_comment'),
path('cards/<uuid:card_id>/archive/', views.card_archive, name='card_archive'), path('cards/<uuid:card_id>/archive/', views.card_archive, name='card_archive'),
path('cards/<uuid:card_id>/restore/', views.card_restore, name='card_restore'),
] ]
+137 -29
View File
@@ -1,28 +1,66 @@
from django.contrib.auth.decorators import login_required from django.contrib.auth.decorators import login_required
from django.contrib.auth import get_user_model
from django.contrib.auth.views import LoginView
from django.core.cache import cache
from django.http import HttpResponse
import hashlib
from django.core.exceptions import ValidationError from django.core.exceptions import ValidationError
from django.db.models import Q, Count from django.db.models import Q, Count
from django.core.paginator import Paginator
from django.http import HttpResponseBadRequest, JsonResponse from django.http import HttpResponseBadRequest, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render from django.shortcuts import get_object_or_404, redirect, render
from django.views.decorators.http import require_POST from django.views.decorators.http import require_POST
from .forms import CardForm, ColumnForm, ProfileForm, ProjectForm from django.utils import timezone
from .models import Card, CardComment, Column, Profile from django.conf import settings
from oauth2_provider.models import get_access_token_model, revoke_access_token
from .forms import CardForm, ColumnForm, ProfileForm, ProjectForm, TagForm
from .models import Activity, Card, CardComment, Column, Profile, Membership, Tag
from . import services from . import services
from .templatetags.project_markdown import safe_markdown
class ThrottledLoginView(LoginView):
template_name = 'projects/login.html'
def get_context_data(self, **kwargs):
return {**super().get_context_data(**kwargs), 'oidc_enabled': settings.OIDC_ENABLED}
def _key(self):
address = self.request.META.get('REMOTE_ADDR', '')
return 'login-attempts:' + hashlib.sha256(address.encode()).hexdigest()
def dispatch(self, request, *args, **kwargs):
if request.method == 'POST' and cache.get(self._key(), 0) >= 5:
return HttpResponse('Too many sign-in attempts. Try again in five minutes.', status=429)
return super().dispatch(request, *args, **kwargs)
def form_invalid(self, form):
key = self._key()
cache.set(key, cache.get(key, 0) + 1, timeout=300)
return super().form_invalid(form)
def form_valid(self, form):
cache.delete(self._key())
return super().form_valid(form)
@login_required @login_required
def project_list(request): def project_list(request):
query = request.GET.get('q', '').strip() query = request.GET.get('q', '').strip()
projects = services.accessible(request.user).filter(archived=False) show_archived = request.GET.get('archived') == '1'
projects = services.accessible(request.user).filter(archived=show_archived)
if query: if query:
projects = projects.filter(Q(name__icontains=query) | Q(description__icontains=query) | Q(cards__title__icontains=query) | Q(cards__description_markdown__icontains=query)).distinct() projects = projects.filter(Q(name__icontains=query) | Q(description__icontains=query) | Q(cards__title__icontains=query) | Q(cards__description_markdown__icontains=query) | Q(tag__name__icontains=query)).distinct()
projects = projects.annotate(card_count=Count('cards', distinct=True)).order_by('name') projects = projects.annotate(card_count=Count('cards', distinct=True)).order_by('name')
page_obj = Paginator(projects, 12).get_page(request.GET.get('page'))
filters = request.GET.copy(); filters.pop('page', None)
template = 'projects/_project_list.html' if request.headers.get('HX-Request') else 'projects/list.html' template = 'projects/_project_list.html' if request.headers.get('HX-Request') else 'projects/list.html'
return render(request, template, {'projects': projects, 'query': query, 'section': 'projects', 'title': 'Projects'}) return render(request, template, {'projects': page_obj, 'page_obj': page_obj, 'filters_query': filters.urlencode(), 'query': query, 'show_archived': show_archived, 'section': 'projects', 'title': 'Projects'})
@login_required @login_required
def project_create(request): def project_create(request):
form = ProjectForm(request.POST or None) form = ProjectForm(request.POST or None, user=request.user)
if request.method == 'POST' and form.is_valid(): if request.method == 'POST' and form.is_valid():
project = services.create_project(request.user, **form.cleaned_data) project = services.create_project(request.user, **form.cleaned_data)
return redirect('projects:board', project_id=project.pk) return redirect('projects:board', project_id=project.pk)
@@ -32,7 +70,7 @@ def project_create(request):
@login_required @login_required
def project_edit(request, project_id): def project_edit(request, project_id):
project = services.project_for(request.user, project_id, write=True) project = services.project_for(request.user, project_id, write=True)
form = ProjectForm(request.POST or None, instance=project) form = ProjectForm(request.POST or None, instance=project, user=project.owner)
if request.method == 'POST' and form.is_valid(): if request.method == 'POST' and form.is_valid():
form.save() form.save()
return redirect('projects:board', project_id=project.pk) return redirect('projects:board', project_id=project.pk)
@@ -48,11 +86,22 @@ def project_archive(request, project_id):
return redirect('projects:list') return redirect('projects:list')
@login_required
@require_POST
def project_restore(request, project_id):
project = services.project_for(request.user, project_id, write=True)
project.archived = False
project.save(update_fields=['archived'])
return redirect('projects:board', project_id=project.pk)
@login_required @login_required
def board(request, project_id): def board(request, project_id):
project = services.project_for(request.user, project_id) project = services.project_for(request.user, project_id)
can_edit = project.owner_id == request.user.pk or Membership.objects.filter(project=project, user=request.user, role='editor').exists()
columns = list(project.board.columns.filter(archived=False)) columns = list(project.board.columns.filter(archived=False))
cards = Card.objects.filter(project=project, archived=False) show_archived = request.GET.get('archived') == '1'
cards = Card.objects.filter(project=project, archived=show_archived)
query = request.GET.get('q', '').strip() query = request.GET.get('q', '').strip()
if query: if query:
cards = cards.filter(Q(title__icontains=query) | Q(description_markdown__icontains=query) | Q(tags__name__icontains=query)).distinct() cards = cards.filter(Q(title__icontains=query) | Q(description_markdown__icontains=query) | Q(tags__name__icontains=query)).distinct()
@@ -61,10 +110,19 @@ def board(request, project_id):
cards = cards.filter(**{field: request.GET[field]}) cards = cards.filter(**{field: request.GET[field]})
if request.GET.get('column'): if request.GET.get('column'):
cards = cards.filter(column_id__in=[c.pk for c in columns if str(c.pk) == request.GET['column']]) cards = cards.filter(column_id__in=[c.pk for c in columns if str(c.pk) == request.GET['column']])
cards = list(cards) if request.GET.get('assignee', '').isdigit():
cards = cards.filter(assignee_id=request.GET['assignee'])
if request.GET.get('tag', '').isdigit():
cards = cards.filter(tags__pk=request.GET['tag'])
page_obj = Paginator(cards.order_by('column__position', 'position', 'created_at'), 60).get_page(request.GET.get('page'))
filters = request.GET.copy(); filters.pop('page', None)
cards = list(page_obj)
for column in columns: for column in columns:
column.visible_cards = [card for card in cards if card.column_id == column.pk] column.visible_cards = [card for card in cards if card.column_id == column.pk]
context = {'project': project, 'columns': columns, 'query': query, 'title': project.name, 'section': 'projects', 'card_count': len(cards)} column.active_count = Card.objects.filter(column=column, archived=False).count()
assignable_ids = [project.owner_id, *project.memberships.values_list('user_id', flat=True)]
active_cards = Card.objects.filter(project=project, archived=False)
context = {'project': project, 'columns': columns, 'page_obj': page_obj, 'filters_query': filters.urlencode(), 'query': query, 'title': project.name, 'section': 'projects', 'card_count': len(cards), 'total_count': active_cards.count(), 'done_count': active_cards.filter(column__is_done=True).count(), 'priority_counts': [(label, active_cards.filter(priority=value, column__is_done=False).count()) for value, label in Card.PRIORITY], 'recent_activity': Activity.objects.filter(project=project).select_related('actor')[:5], 'selected_priority': request.GET.get('priority', ''), 'selected_type': request.GET.get('card_type', ''), 'selected_assignee': request.GET.get('assignee', ''), 'selected_tag': request.GET.get('tag', ''), 'selected_column': request.GET.get('column', ''), 'show_archived': show_archived, 'tags': Tag.objects.filter(project=project).order_by('name'), 'assignable': get_user_model().objects.filter(pk__in=assignable_ids).order_by('username'), 'card_types': Card.TYPE, 'can_edit': can_edit}
template = 'projects/_board.html' if request.headers.get('HX-Request') else 'projects/board.html' template = 'projects/_board.html' if request.headers.get('HX-Request') else 'projects/board.html'
return render(request, template, context) return render(request, template, context)
@@ -72,33 +130,44 @@ def board(request, project_id):
@login_required @login_required
def card_create(request, project_id): def card_create(request, project_id):
project = services.project_for(request.user, project_id, write=True) project = services.project_for(request.user, project_id, write=True)
form = CardForm(request.POST or None) form = CardForm(request.POST or None, project=project)
if request.method == 'POST' and form.is_valid(): if request.method == 'POST' and form.is_valid():
data = form.cleaned_data data = form.cleaned_data
card = services.create_card(request.user, project, title=data['title'], markdown=data['description_markdown'], priority=data['priority'], card_type=data['card_type']) card = services.create_card(request.user, project, title=data['title'], markdown=data['description_markdown'], priority=data['priority'], card_type=data['card_type'])
services.update_card(request.user, card, expected_revision=card.revision, due_date=data['due_date'], is_blocked=data['is_blocked'], blocked_reason=data['blocked_reason']) services.update_card(request.user, card, expected_revision=card.revision, due_date=data['due_date'], is_blocked=data['is_blocked'], blocked_reason=data['blocked_reason'])
services.set_assignee(request.user, card, data['assignee'])
services.set_tags(request.user, card, data['tags'])
return redirect('projects:card', card_id=card.pk) return redirect('projects:card', card_id=card.pk)
return render(request, 'projects/form.html', {'form': form, 'title': 'New card', 'section': 'projects'}) return render(request, 'projects/form.html', {'form': form, 'title': 'New card', 'section': 'projects', 'show_preview': True})
@login_required @login_required
def card_detail(request, card_id): def card_detail(request, card_id):
card = services.card_for(request.user, card_id) card = services.card_for(request.user, card_id)
return render(request, 'projects/card.html', {'card': card, 'title': card.title, 'section': 'projects'}) can_edit = card.project.owner_id == request.user.pk or Membership.objects.filter(project=card.project, user=request.user, role='editor').exists()
return render(request, 'projects/card.html', {'card': card, 'can_edit': can_edit, 'title': card.title, 'section': 'projects'})
@login_required @login_required
def card_edit(request, card_id): def card_edit(request, card_id):
card = services.card_for(request.user, card_id, write=True) card = services.card_for(request.user, card_id, write=True)
form = CardForm(request.POST or None, instance=card, initial={'expected_revision': card.revision}) form = CardForm(request.POST or None, instance=card, initial={'expected_revision': card.revision}, project=card.project)
if request.method == 'POST' and form.is_valid(): if request.method == 'POST' and form.is_valid():
try: try:
services.update_card(request.user, card, expected_revision=form.cleaned_data['expected_revision'], **{field: form.cleaned_data[field] for field in CardForm.Meta.fields}) services.update_card(request.user, card, expected_revision=form.cleaned_data['expected_revision'], **{field: form.cleaned_data[field] for field in CardForm.Meta.fields if field not in ('assignee', 'tags')})
services.set_assignee(request.user, card, form.cleaned_data['assignee'])
services.set_tags(request.user, card, form.cleaned_data['tags'])
return redirect('projects:card', card_id=card.pk) return redirect('projects:card', card_id=card.pk)
except services.RevisionConflict as conflict: except services.RevisionConflict as conflict:
form.add_error(None, f'This card changed since you opened it. Current revision: {conflict.current}. Copy your changes before reloading.') form.add_error(None, f'This card changed since you opened it. Current revision: {conflict.current}. Copy your changes before reloading.')
return render(request, 'projects/form.html', {'form': form, 'title': 'Edit card', 'section': 'projects'}, status=409) return render(request, 'projects/form.html', {'form': form, 'title': 'Edit card', 'section': 'projects', 'show_preview': True}, status=409)
return render(request, 'projects/form.html', {'form': form, 'title': 'Edit card', 'section': 'projects'}) return render(request, 'projects/form.html', {'form': form, 'title': 'Edit card', 'section': 'projects', 'show_preview': True})
@login_required
@require_POST
def markdown_preview(request):
return HttpResponse(safe_markdown(request.POST.get('description_markdown', '')))
@login_required @login_required
@@ -128,13 +197,28 @@ def column_create(request, project_id):
return render(request, 'projects/form.html', {'form': form, 'title': 'New column', 'section': 'projects'}) return render(request, 'projects/form.html', {'form': form, 'title': 'New column', 'section': 'projects'})
@login_required
def tag_create(request, project_id):
project = services.project_for(request.user, project_id, write=True)
form = TagForm(request.POST or None)
if request.method == 'POST' and form.is_valid():
tag = form.save(commit=False)
tag.project = project
if project.tag_set.filter(name__iexact=tag.name).exists():
form.add_error('name', 'This tag already exists in the project.')
else:
tag.save()
return redirect('projects:board', project_id=project.pk)
return render(request, 'projects/form.html', {'form': form, 'title': 'New tag', 'section': 'projects'})
@login_required @login_required
def column_edit(request, column_id): def column_edit(request, column_id):
column = get_object_or_404(Column, pk=column_id) column = get_object_or_404(Column, pk=column_id)
services.project_for(request.user, column.board.project_id, write=True) services.project_for(request.user, column.board.project_id, write=True)
form = ColumnForm(request.POST or None, instance=column) form = ColumnForm(request.POST or None, instance=column)
if request.method == 'POST' and form.is_valid(): if request.method == 'POST' and form.is_valid():
form.save() services.update_column(request.user, column, **form.cleaned_data)
return redirect('projects:board', project_id=column.board.project_id) return redirect('projects:board', project_id=column.board.project_id)
return render(request, 'projects/form.html', {'form': form, 'title': 'Edit column', 'section': 'projects'}) return render(request, 'projects/form.html', {'form': form, 'title': 'Edit column', 'section': 'projects'})
@@ -147,15 +231,23 @@ def column_default(request, column_id):
return redirect('projects:board', project_id=column.board.project_id) return redirect('projects:board', project_id=column.board.project_id)
@login_required
@require_POST
def column_shift(request, column_id):
column = get_object_or_404(Column, pk=column_id, archived=False)
direction = -1 if request.POST.get('direction') == 'left' else 1
services.shift_column(request.user, column, direction)
return redirect('projects:board', project_id=column.board.project_id)
@login_required @login_required
@require_POST @require_POST
def column_archive(request, column_id): def column_archive(request, column_id):
column = get_object_or_404(Column, pk=column_id) column = get_object_or_404(Column, pk=column_id)
services.project_for(request.user, column.board.project_id, write=True) try:
if column.is_default or column.cards.filter(archived=False).exists(): services.archive_column(request.user, column)
return HttpResponseBadRequest('Choose another default and move cards before archiving this column.') except ValidationError as exc:
column.archived = True return HttpResponseBadRequest(str(exc))
column.save(update_fields=['archived'])
return redirect('projects:board', project_id=column.board.project_id) return redirect('projects:board', project_id=column.board.project_id)
@@ -164,11 +256,10 @@ def column_archive(request, column_id):
def column_reorder(request, project_id): def column_reorder(request, project_id):
project = services.project_for(request.user, project_id, write=True) project = services.project_for(request.user, project_id, write=True)
ids = request.POST.getlist('columns') ids = request.POST.getlist('columns')
columns = list(project.board.columns.filter(archived=False)) try:
if set(ids) != {str(c.pk) for c in columns} or len(ids) != len(columns): services.reorder_columns(request.user, project, ids)
return HttpResponseBadRequest('Invalid column order') except ValidationError as exc:
for index, value in enumerate(ids): return HttpResponseBadRequest(str(exc))
Column.objects.filter(pk=value).update(position=index)
return JsonResponse({'ok': True}) return JsonResponse({'ok': True})
@@ -191,6 +282,14 @@ def card_archive(request, card_id):
return redirect('projects:board', project_id=card.project_id) return redirect('projects:board', project_id=card.project_id)
@login_required
@require_POST
def card_restore(request, card_id):
card = services.card_for(request.user, card_id, write=True)
services.update_card(request.user, card, expected_revision=card.revision, archived=False)
return redirect('projects:card', card_id=card.pk)
@login_required @login_required
def profile(request): def profile(request):
profile, _ = Profile.objects.get_or_create(user=request.user) profile, _ = Profile.objects.get_or_create(user=request.user)
@@ -200,4 +299,13 @@ def profile(request):
request.user.email = form.cleaned_data['email'] request.user.email = form.cleaned_data['email']
request.user.save(update_fields=['email']) request.user.save(update_fields=['email'])
return redirect('projects:profile') return redirect('projects:profile')
return render(request, 'projects/profile.html', {'form': form, 'title': 'Profile', 'section': 'profile'}) grants = get_access_token_model().objects.filter(user=request.user, expires__gt=timezone.now()).select_related('application').order_by('-created')
return render(request, 'projects/profile.html', {'form': form, 'grants': grants, 'identities': request.user.oauth_identities.all(), 'mcp_url': settings.MCP_PUBLIC_URL, 'oidc_enabled': settings.OIDC_ENABLED, 'title': 'Profile', 'section': 'profile'})
@login_required
@require_POST
def revoke_connection(request, grant_id):
grant = get_object_or_404(get_access_token_model(), pk=grant_id, user=request.user)
revoke_access_token(grant)
return redirect('projects:profile')
+4
View File
@@ -1,3 +1,7 @@
Django>=6.1,<6.2 Django>=6.1,<6.2
Markdown>=3.8,<4 Markdown>=3.8,<4
nh3>=0.2.21,<1 nh3>=0.2.21,<1
mcp==2.3.0
django-oauth-toolkit==3.4.1
uvicorn>=0.30,<1
mozilla-django-oidc>=5,<6