599 lines
32 KiB
Python
599 lines
32 KiB
Python
from django.contrib.auth.decorators import login_required
|
|
from django.contrib.auth import get_user_model
|
|
from django.contrib import messages
|
|
from django.contrib.auth.views import LoginView
|
|
from django.core.cache import cache
|
|
from django.core import signing
|
|
from django.http import HttpResponse, FileResponse
|
|
from django.http import Http404
|
|
import hashlib
|
|
import json
|
|
import uuid
|
|
from urllib.parse import urlsplit
|
|
from django.core.exceptions import ValidationError
|
|
from django.db.models import Q, Count
|
|
from django.db import transaction
|
|
from django.core.paginator import Paginator
|
|
from django.http import HttpResponseBadRequest, JsonResponse
|
|
from django.shortcuts import get_object_or_404, redirect, render
|
|
from django.views.decorators.http import require_POST
|
|
from django.utils import timezone
|
|
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, CardAttachment, Column, Profile, Membership, Tag, Project
|
|
from . import services
|
|
from . import attachments
|
|
from . import documentation
|
|
from .templatetags.project_markdown import safe_markdown
|
|
from .templatetags.project_markdown import render_document_markdown
|
|
from .models import DocumentationSync, ProjectDocument
|
|
from urllib.parse import quote
|
|
|
|
|
|
ACTIVITY_ACTION_LABELS = {
|
|
'project.created': 'created the project', 'card.created': 'created a card',
|
|
'card.updated': 'updated a card', 'card.moved': 'moved a card',
|
|
'card.moved_project': 'moved this card to another project',
|
|
'card.moved_project_out': 'moved a card to another project',
|
|
'card.assigned': 'changed a card assignment', 'card.tags_changed': 'updated card tags',
|
|
'card.bulk_updated': 'updated a card', 'column.updated': 'updated a column',
|
|
'attachment.added': 'added an attachment', 'attachment.deleted': 'removed an attachment',
|
|
}
|
|
|
|
|
|
def activity_display_action(action):
|
|
return ACTIVITY_ACTION_LABELS.get(action, action.replace('.', ' ').replace('_', ' '))
|
|
|
|
|
|
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
|
|
def project_list(request):
|
|
query = request.GET.get('q', '').strip()
|
|
show_archived = request.GET.get('archived') == '1'
|
|
projects = services.accessible(request.user).filter(archived=show_archived)
|
|
if query:
|
|
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),
|
|
active_card_count=Count('cards', filter=Q(cards__archived=False), distinct=True),
|
|
done_card_count=Count('cards', filter=Q(cards__archived=False, cards__column__is_done=True), distinct=True),
|
|
).order_by('name')
|
|
page_obj = Paginator(projects, 12).get_page(request.GET.get('page'))
|
|
for project in page_obj:
|
|
project.progress_percent = round(project.done_card_count * 100 / project.active_card_count) if project.active_card_count else 0
|
|
filters = request.GET.copy(); filters.pop('page', None)
|
|
template = 'projects/_project_list.html' if request.headers.get('HX-Request') else 'projects/list.html'
|
|
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
|
|
def project_create(request):
|
|
form = ProjectForm(request.POST or None, user=request.user)
|
|
if request.method == 'POST' and form.is_valid():
|
|
project = services.create_project(request.user, **form.cleaned_data)
|
|
return redirect('projects:board', project_id=project.pk)
|
|
return render(request, 'projects/form.html', {'form': form, 'title': 'New project', 'section': 'projects'})
|
|
|
|
|
|
@login_required
|
|
def project_edit(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
form = ProjectForm(request.POST or None, instance=project, user=project.owner)
|
|
if request.method == 'POST' and form.is_valid():
|
|
form.save()
|
|
return redirect('projects:board', project_id=project.pk)
|
|
return render(request, 'projects/form.html', {'form': form, 'title': 'Edit project', 'section': 'projects'})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def project_archive(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
project.archived = True
|
|
project.save(update_fields=['archived'])
|
|
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
|
|
def board(request, 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))
|
|
show_archived = request.GET.get('archived') == '1'
|
|
cards = Card.objects.filter(project=project, archived=show_archived)
|
|
query = request.GET.get('q', '').strip()
|
|
if query:
|
|
cards = cards.filter(Q(title__icontains=query) | Q(description_markdown__icontains=query) | Q(tags__name__icontains=query)).distinct()
|
|
for field in ('priority', 'card_type'):
|
|
if request.GET.get(field):
|
|
cards = cards.filter(**{field: request.GET[field]})
|
|
if request.GET.get('column'):
|
|
cards = cards.filter(column_id__in=[c.pk for c in columns if str(c.pk) == request.GET['column']])
|
|
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:
|
|
column.visible_cards = [card for card in cards if card.column_id == column.pk]
|
|
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)
|
|
is_htmx = bool(request.headers.get('HX-Request'))
|
|
all_activity = [] if is_htmx else list(Activity.objects.filter(project=project).select_related('actor', 'card'))
|
|
for event in all_activity:
|
|
event.display_action = activity_display_action(event.action)
|
|
done_count = active_cards.filter(column__is_done=True).count()
|
|
total_count = active_cards.count()
|
|
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': total_count, 'done_count': done_count, 'progress_percent': round(done_count * 100 / total_count) if total_count else 0, 'priority_counts': [(label, active_cards.filter(priority=value, column__is_done=False).count()) for value, label in Card.PRIORITY], 'recent_activity': all_activity[:3], 'older_activity': all_activity[3:], '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, 'active_filter_count': sum(bool(request.GET.get(key)) for key in ('priority', 'card_type', 'column', 'assignee', 'tag')), '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 is_htmx else 'projects/board.html'
|
|
return render(request, template, context)
|
|
|
|
|
|
@login_required
|
|
def cards_bulk_edit(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
ids = request.GET.getlist('card') if request.method == 'GET' else request.POST.getlist('card')
|
|
if not 1 <= len(ids) <= 100 or len(set(ids)) != len(ids):
|
|
return HttpResponseBadRequest('Select between 1 and 100 unique cards.')
|
|
try:
|
|
cards = list(Card.objects.filter(project=project, archived=False, pk__in=ids).select_related('column'))
|
|
except (ValueError, ValidationError):
|
|
return HttpResponseBadRequest('Invalid card selection.')
|
|
if len(cards) != len(ids):
|
|
return HttpResponseBadRequest('One or more selected cards are unavailable.')
|
|
by_id = {str(card.pk): card for card in cards}
|
|
cards = [by_id[identifier] for identifier in ids]
|
|
context = {'project': project, 'cards': cards, 'columns': project.board.columns.filter(archived=False),
|
|
'assignable': get_user_model().objects.filter(pk__in=[project.owner_id, *project.memberships.values_list('user_id', flat=True)]).order_by('username'),
|
|
'tags': Tag.objects.filter(project=project).order_by('name'), 'selected_tag_ids': request.POST.getlist('tag_ids'),
|
|
'revisions_json': request.POST.get('expected_revisions', ''), 'idempotency_key': request.POST.get('idempotency_key', ''),
|
|
'title': 'Bulk edit cards', 'section': 'projects'}
|
|
if request.method == 'POST':
|
|
try:
|
|
revisions = json.loads(request.POST['expected_revisions'])
|
|
changes = {}
|
|
for field in ('column_id', 'priority', 'assignee_id', 'tag_ids'):
|
|
if request.POST.get('change_' + field):
|
|
if field == 'tag_ids': changes[field] = [int(value) for value in request.POST.getlist('tag_ids')]
|
|
elif field == 'assignee_id': changes[field] = int(request.POST[field]) if request.POST.get(field) else None
|
|
else: changes[field] = request.POST[field]
|
|
context.update({'revisions_json': json.dumps(revisions), 'changes_json': json.dumps(changes), 'idempotency_key': request.POST.get('idempotency_key') or str(uuid.uuid4())})
|
|
confirmation = {'user': request.user.pk, 'project': str(project.pk), 'ids': ids, 'revisions': revisions, 'changes': changes}
|
|
if request.POST.get('action') == 'apply':
|
|
try:
|
|
submitted = signing.loads(request.POST['preview_token'], salt='card-bulk-preview', max_age=1800)
|
|
except (signing.BadSignature, signing.SignatureExpired):
|
|
raise ValidationError('Preview expired or changed. Preview again.')
|
|
if submitted != confirmation:
|
|
raise ValidationError('Selection or changes differ from the preview. Preview again.')
|
|
context['applied'] = services.bulk_update_cards(request.user, project, ids, revisions, changes, idempotency_key=request.POST['idempotency_key'])
|
|
else:
|
|
context['preview'] = services.bulk_update_cards(request.user, project, ids, revisions, changes, dry_run=True)
|
|
context['preview_token'] = signing.dumps(confirmation, salt='card-bulk-preview')
|
|
except (KeyError, ValueError, TypeError, ValidationError) as exc:
|
|
context['error'] = str(exc)
|
|
else:
|
|
context['revisions_json'] = json.dumps({str(card.pk): card.revision for card in cards})
|
|
return render(request, 'projects/bulk_edit.html', context)
|
|
|
|
|
|
@login_required
|
|
def card_create(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
form = CardForm(request.POST or None, project=project)
|
|
if request.method == 'POST' and form.is_valid():
|
|
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'])
|
|
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 render(request, 'projects/form.html', {'form': form, 'title': 'New card', 'section': 'projects', 'show_preview': True})
|
|
|
|
|
|
@login_required
|
|
def card_detail(request, card_id):
|
|
card = services.card_for(request.user, card_id)
|
|
can_edit = card.project.owner_id == request.user.pk or Membership.objects.filter(project=card.project, user=request.user, role='editor').exists()
|
|
history = card.activity.select_related('actor').all()
|
|
for event in history:
|
|
event.display_action = activity_display_action(event.action).replace('a card', 'this card')
|
|
destinations = Project.objects.filter(archived=False).filter(Q(owner=request.user) | Q(memberships__user=request.user, memberships__role='editor')).exclude(pk=card.project_id).distinct().select_related('board').order_by('name') if can_edit else Project.objects.none()
|
|
destination_options = []
|
|
for project in destinations:
|
|
columns = list(project.board.columns.filter(archived=False).order_by('position'))
|
|
if not columns:
|
|
continue
|
|
default_column = next((column for column in columns if column.is_default), columns[0])
|
|
destination_options.append({'project': project, 'columns': columns,
|
|
'default_column': default_column})
|
|
return render(request, 'projects/card.html', {'card': card, 'can_edit': can_edit, 'title': card.title, 'section': 'projects', 'history': history,
|
|
'destination_options': destination_options, 'move_idempotency_key': uuid.uuid4(),
|
|
'card_files': card.attachments.filter(comment__isnull=True).select_related('uploaded_by'),
|
|
'comments': card.comments.prefetch_related('attachments').select_related('author').order_by('created_at')})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def card_move_project(request, card_id):
|
|
card = services.card_for(request.user, card_id, write=True)
|
|
try:
|
|
target_id = uuid.UUID(request.POST.get('target_project_id', ''))
|
|
target_project = services.project_for(request.user, target_id, write=True)
|
|
column_id = request.POST.get('target_column_id') or None
|
|
target_column = get_object_or_404(Column, pk=column_id) if column_id else None
|
|
moved, result = services.move_card_to_project(
|
|
request.user, card, target_project, target_column=target_column,
|
|
expected_revision=request.POST.get('expected_revision'),
|
|
idempotency_key=request.POST.get('idempotency_key') or None,
|
|
)
|
|
except services.RevisionConflict as conflict:
|
|
messages.error(request, f'This card changed before it could be moved. Current revision: {conflict.current}. Reload the card and try again.')
|
|
return redirect('projects:card', card_id=card.pk)
|
|
except (ValueError, TypeError, ValidationError) as exc:
|
|
messages.error(request, '; '.join(exc.messages) if isinstance(exc, ValidationError) else 'The card could not be moved. Reload the card and try again.')
|
|
return redirect('projects:card', card_id=card.pk)
|
|
message = f'Moved “{moved.title}” from {result["source_project_name"]} to {result["target_project_name"]}.'
|
|
if result['warnings']:
|
|
message += ' ' + ' '.join(result['warnings'])
|
|
messages.success(request, message)
|
|
return redirect('projects:card', card_id=moved.pk)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def attachment_upload(request, card_id):
|
|
card = services.card_for(request.user, card_id, write=True)
|
|
files = request.FILES.getlist('files')
|
|
if not files:
|
|
return HttpResponseBadRequest('Select one or more files.')
|
|
if len(files) > 10:
|
|
return HttpResponseBadRequest('Upload at most 10 files at once.')
|
|
comment_id = request.POST.get('comment_id') or None
|
|
created = []
|
|
try:
|
|
with transaction.atomic():
|
|
for file in files:
|
|
if file.size > settings.PROJECTS_ATTACHMENT_MAX_BYTES:
|
|
raise ValidationError('File exceeds the per-file size limit.')
|
|
created.append(attachments.upload_attachment(request.user, card, filename=file.name, data=file.read(),
|
|
comment_id=comment_id, title=request.POST.get('title', ''), description=request.POST.get('description', '')))
|
|
except Exception as exc:
|
|
for item in created:
|
|
item.file.delete(save=False)
|
|
if isinstance(exc, ValidationError):
|
|
return HttpResponseBadRequest('; '.join(exc.messages))
|
|
raise
|
|
return redirect('projects:card', card_id=card.pk)
|
|
|
|
|
|
@login_required
|
|
def attachment_download(request, attachment_id):
|
|
item = get_object_or_404(CardAttachment.objects.select_related('card'), pk=attachment_id)
|
|
services.card_for(request.user, item.card_id)
|
|
response = FileResponse(item.file.open('rb'), as_attachment=True, filename=item.original_filename,
|
|
content_type='application/octet-stream')
|
|
response['X-Content-Type-Options'] = 'nosniff'
|
|
response['Cache-Control'] = 'private, no-store'
|
|
return response
|
|
|
|
|
|
@login_required
|
|
def attachment_preview(request, attachment_id):
|
|
item = get_object_or_404(CardAttachment.objects.select_related('card'), pk=attachment_id)
|
|
services.card_for(request.user, item.card_id)
|
|
if item.mime_type not in {'image/png', 'image/jpeg', 'image/webp', 'text/plain'} or item.byte_size > 1024 * 1024:
|
|
return HttpResponseBadRequest('Preview unavailable for this file.')
|
|
if item.mime_type == 'text/plain':
|
|
with item.file.open('rb') as stream:
|
|
response = HttpResponse(stream.read(1024 * 1024).decode('utf-8'), content_type='text/plain; charset=utf-8')
|
|
else:
|
|
response = FileResponse(item.file.open('rb'), content_type=item.mime_type)
|
|
response['X-Content-Type-Options'] = 'nosniff'
|
|
response['Content-Security-Policy'] = "default-src 'none'; sandbox"
|
|
response['Cache-Control'] = 'private, no-store'
|
|
return response
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def attachment_delete(request, attachment_id):
|
|
item = get_object_or_404(CardAttachment.objects.select_related('card__project'), pk=attachment_id)
|
|
services.card_for(request.user, item.card_id, write=True)
|
|
attachments.delete_attachment(request.user, item)
|
|
return redirect('projects:card', card_id=item.card_id)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def attachment_update(request, attachment_id):
|
|
item = get_object_or_404(CardAttachment.objects.select_related('card'), pk=attachment_id)
|
|
services.card_for(request.user, item.card_id, write=True)
|
|
title = request.POST.get('title', '').strip()
|
|
if not title or len(title) > 255:
|
|
return HttpResponseBadRequest('Title must be between 1 and 255 characters.')
|
|
item.title = title
|
|
item.save(update_fields=['title'])
|
|
return redirect('projects:card', card_id=item.card_id)
|
|
|
|
|
|
@login_required
|
|
def card_edit(request, card_id):
|
|
card = services.card_for(request.user, card_id, write=True)
|
|
form = CardForm(request.POST or None, instance=card, initial={'expected_revision': card.revision}, project=card.project)
|
|
if request.method == 'POST' and form.is_valid():
|
|
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 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)
|
|
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.')
|
|
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', 'show_preview': True})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def markdown_preview(request):
|
|
return HttpResponse(safe_markdown(request.POST.get('description_markdown', '')))
|
|
|
|
|
|
def _documentation_context(request, project):
|
|
state = documentation.maybe_sync(request.user, project)
|
|
can_edit = project.owner_id == request.user.pk or Membership.objects.filter(project=project, user=request.user, role='editor').exists()
|
|
return {'project': project, 'sync': state, 'sync_status': documentation.sync_status(project, state),
|
|
'can_edit': can_edit, 'audit_label': documentation.audit_status(state),
|
|
'section': 'projects', 'title': f'{project.name} documentation'}
|
|
|
|
|
|
@login_required
|
|
def docs_home(request, project_id):
|
|
project = services.project_for(request.user, project_id)
|
|
context = _documentation_context(request, project)
|
|
query = request.GET.get('q', '').strip()[:200]
|
|
prefix = request.GET.get('path', '').strip()
|
|
if prefix:
|
|
try:
|
|
documentation.normal_path(prefix)
|
|
except ValidationError as exc:
|
|
raise Http404('Folder unavailable') from exc
|
|
page = max(1, int(request.GET.get('page', '1'))) if request.GET.get('page', '1').isdigit() else 1
|
|
if query:
|
|
documents, total = documentation.search_documents(request.user, query, project=project, limit=30, offset=(page - 1) * 30)
|
|
else:
|
|
documents, total = documentation.list_documents(request.user, project, path=prefix, limit=30, offset=(page - 1) * 30)
|
|
paths = ProjectDocument.objects.filter(project=project).values_list('path', flat=True)
|
|
folders = sorted({part for path in paths for part in ('/'.join(path.split('/')[:i]) for i in range(1, len(path.split('/'))))})
|
|
folder_tree = []
|
|
folder_nodes = {}
|
|
for folder in folders:
|
|
node = {'name': folder.rsplit('/', 1)[-1], 'path': folder, 'children': []}
|
|
folder_nodes[folder] = node
|
|
parent = folder.rpartition('/')[0]
|
|
(folder_nodes[parent]['children'] if parent else folder_tree).append(node)
|
|
context.update({'documents': documents, 'query': query, 'page': page, 'has_next': page * 30 < total,
|
|
'has_previous': page > 1, 'total': total, 'prefix': prefix, 'folder_tree': folder_tree,
|
|
'results': [{'document': item, 'snippet': documentation.excerpt(item, query)} for item in documents] if query else []})
|
|
return render(request, 'projects/docs_home.html', context)
|
|
|
|
|
|
@login_required
|
|
def docs_document(request, project_id, path):
|
|
project = services.project_for(request.user, project_id)
|
|
context = _documentation_context(request, project)
|
|
try:
|
|
current = documentation.read_document(request.user, project, path)
|
|
revision = request.GET.get('revision', '')
|
|
document = documentation.historical_document(request.user, project, path, revision) if revision else current
|
|
except (ProjectDocument.DoesNotExist, ValidationError, documentation.DocumentationError) as exc:
|
|
raise Http404('Document unavailable') from exc
|
|
paths = set(ProjectDocument.objects.filter(project=project).values_list('path', flat=True))
|
|
context['document'] = document
|
|
context['file_name'] = path.rsplit('/', 1)[-1]
|
|
context['breadcrumbs'] = [{'name': part, 'path': '/'.join(path.split('/')[:index + 1])}
|
|
for index, part in enumerate(path.split('/')[:-1])]
|
|
context['is_historical'] = document.source_commit != current.source_commit
|
|
try:
|
|
context['history'] = documentation.document_history(request.user, project, path)
|
|
except documentation.DocumentationError:
|
|
context['history'] = []
|
|
context['document_commit_time'] = next((item['committed_at'] for item in context['history']
|
|
if item['commit'] == document.source_commit),
|
|
context['sync'].commit_time if context['sync'] and not context['is_historical'] else None)
|
|
context['rendered'] = render_document_markdown(document.markdown, project.pk, document.path, paths)
|
|
if context['sync'] and context['sync'].indexed_repository_url:
|
|
base = context['sync'].indexed_repository_url.rstrip('/').removesuffix('.git')
|
|
context['source_url'] = f'{base}/src/commit/{document.source_commit}/{quote(document.path)}'
|
|
return render(request, 'projects/docs_document.html', context)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def docs_refresh(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
documentation.sync_project(request.user, project, force=True)
|
|
return redirect('projects:docs_home', project_id=project.pk)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def card_move(request, card_id):
|
|
card = services.card_for(request.user, card_id, write=True)
|
|
column = get_object_or_404(Column, pk=request.POST.get('column_id'), board=card.project.board, archived=False)
|
|
try:
|
|
services.move_card(request.user, card, column, request.POST.get('position') or None)
|
|
except (ValidationError, ValueError) as exc:
|
|
return HttpResponseBadRequest(str(exc))
|
|
if request.headers.get('HX-Request'):
|
|
return JsonResponse({'ok': True})
|
|
return redirect('projects:board', project_id=card.project_id)
|
|
|
|
|
|
@login_required
|
|
def column_create(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
form = ColumnForm(request.POST or None)
|
|
if request.method == 'POST' and form.is_valid():
|
|
column = form.save(commit=False)
|
|
column.board = project.board
|
|
column.position = project.board.columns.count()
|
|
column.save()
|
|
return redirect('projects:board', project_id=project.pk)
|
|
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
|
|
def column_edit(request, column_id):
|
|
column = get_object_or_404(Column, pk=column_id)
|
|
services.project_for(request.user, column.board.project_id, write=True)
|
|
form = ColumnForm(request.POST or None, instance=column)
|
|
if request.method == 'POST' and form.is_valid():
|
|
services.update_column(request.user, column, **form.cleaned_data)
|
|
return redirect('projects:board', project_id=column.board.project_id)
|
|
return render(request, 'projects/form.html', {'form': form, 'title': 'Edit column', 'section': 'projects'})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def column_default(request, column_id):
|
|
column = get_object_or_404(Column, pk=column_id)
|
|
services.set_default(request.user, column)
|
|
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
|
|
@require_POST
|
|
def column_archive(request, column_id):
|
|
column = get_object_or_404(Column, pk=column_id)
|
|
try:
|
|
services.archive_column(request.user, column)
|
|
except ValidationError as exc:
|
|
return HttpResponseBadRequest(str(exc))
|
|
return redirect('projects:board', project_id=column.board.project_id)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def column_reorder(request, project_id):
|
|
project = services.project_for(request.user, project_id, write=True)
|
|
ids = request.POST.getlist('columns')
|
|
try:
|
|
services.reorder_columns(request.user, project, ids)
|
|
except ValidationError as exc:
|
|
return HttpResponseBadRequest(str(exc))
|
|
return JsonResponse({'ok': True})
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def card_comment(request, card_id):
|
|
card = services.card_for(request.user, card_id, write=True)
|
|
body = request.POST.get('body', '').strip()
|
|
if not body:
|
|
return HttpResponseBadRequest('Comment is required')
|
|
CardComment.objects.create(card=card, author=request.user, body=body)
|
|
return redirect('projects:card', card_id=card.pk)
|
|
|
|
|
|
@login_required
|
|
@require_POST
|
|
def card_archive(request, card_id):
|
|
card = services.card_for(request.user, card_id, write=True)
|
|
services.update_card(request.user, card, expected_revision=card.revision, archived=True)
|
|
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
|
|
def profile(request):
|
|
profile, _ = Profile.objects.get_or_create(user=request.user)
|
|
form = ProfileForm(request.POST or None, instance=profile, initial={'email': request.user.email})
|
|
if request.method == 'POST' and form.is_valid():
|
|
form.save()
|
|
request.user.email = form.cleaned_data['email']
|
|
request.user.save(update_fields=['email'])
|
|
return redirect('projects:profile')
|
|
grants = get_access_token_model().objects.filter(user=request.user, expires__gt=timezone.now()).select_related('application').order_by('-created')
|
|
visiting_url = request.build_absolute_uri('/mcp')
|
|
# Local development uses a separate MCP port; public deployments route /mcp through HTTPS.
|
|
mcp_url = settings.MCP_PUBLIC_URL if urlsplit(visiting_url).hostname in {'localhost', '127.0.0.1', '::1'} else visiting_url
|
|
mcp_configured = mcp_url.rstrip('/') == settings.MCP_PUBLIC_URL.rstrip('/')
|
|
return render(request, 'projects/profile.html', {'form': form, 'grants': grants, 'identities': request.user.oauth_identities.all(), 'mcp_url': mcp_url, 'mcp_configured': mcp_configured, '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')
|