322 lines
16 KiB
Python
322 lines
16 KiB
Python
import hashlib
|
|
import json
|
|
from uuid import UUID
|
|
from django.core.exceptions import PermissionDenied, ValidationError
|
|
from django.db import transaction
|
|
from django.db.models import Q, Max
|
|
from django.core.validators import URLValidator
|
|
from django.shortcuts import get_object_or_404
|
|
from django.utils import timezone
|
|
from django.utils.text import slugify
|
|
from .models import Activity, Board, BulkUpdateKey, Card, CardRevision, Column, CreationKey, Membership, Project, Tag
|
|
|
|
|
|
class RevisionConflict(Exception):
|
|
def __init__(self, current):
|
|
self.current = current
|
|
|
|
|
|
def accessible(user):
|
|
if not user.is_authenticated:
|
|
return Project.objects.none()
|
|
return Project.objects.filter(Q(owner=user) | Q(memberships__user=user)).distinct()
|
|
|
|
|
|
def project_for(user, identifier, write=False):
|
|
project = get_object_or_404(accessible(user), pk=identifier)
|
|
if write and project.owner_id != user.pk and not Membership.objects.filter(project=project, user=user, role='editor').exists():
|
|
raise PermissionDenied
|
|
return project
|
|
|
|
|
|
def card_for(user, identifier, write=False):
|
|
card = get_object_or_404(Card.objects.select_related('project', 'column'), pk=identifier, project__in=accessible(user))
|
|
if write:
|
|
project_for(user, card.project_id, write=True)
|
|
return card
|
|
|
|
|
|
@transaction.atomic
|
|
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'
|
|
slug = base
|
|
n = 2
|
|
while Project.objects.filter(owner=user, slug=slug).exists():
|
|
slug = f'{base}-{n}'
|
|
n += 1
|
|
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)
|
|
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)
|
|
Activity.objects.create(project=project, actor=user, action='project.created')
|
|
return project
|
|
|
|
|
|
@transaction.atomic
|
|
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)
|
|
if priority not in dict(Card.PRIORITY) or card_type not in dict(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)
|
|
if column.board_id != project.board.pk or column.archived:
|
|
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
|
|
card = Card(project=project, column=column, title=title, description_markdown=markdown,
|
|
priority=priority, card_type=card_type, position=position, created_by=user,
|
|
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)
|
|
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
|
|
|
|
|
|
@transaction.atomic
|
|
def update_card(user, card, *, expected_revision=None, origin='web', **changes):
|
|
card = Card.objects.select_for_update().get(pk=card.pk)
|
|
project_for(user, card.project_id, write=True)
|
|
allowed = {'title', 'description_markdown', 'priority', 'card_type', 'is_blocked', 'blocked_reason', 'archived', 'due_date'}
|
|
if set(changes) - allowed:
|
|
raise ValidationError('Unsupported card field.')
|
|
if 'priority' in changes and changes['priority'] not in dict(Card.PRIORITY):
|
|
raise ValidationError('Invalid priority.')
|
|
markdown_changed = 'description_markdown' in changes and changes['description_markdown'] != card.description_markdown
|
|
if changes and (expected_revision is None or int(expected_revision) != card.revision):
|
|
raise RevisionConflict(card.revision)
|
|
changed = []
|
|
for field, value in changes.items():
|
|
if getattr(card, field) != value:
|
|
setattr(card, field, value)
|
|
changed.append(field)
|
|
if changed:
|
|
card.revision += 1
|
|
card.full_clean()
|
|
card.save()
|
|
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)
|
|
return card
|
|
|
|
|
|
@transaction.atomic
|
|
def move_card(user, card, column, position=None, origin='web', record_revision=True):
|
|
card = Card.objects.select_for_update().get(pk=card.pk)
|
|
project_for(user, card.project_id, write=True)
|
|
if column.board.project_id != card.project_id or column.archived:
|
|
raise ValidationError('Column is not available in this project.')
|
|
old_column = card.column_id
|
|
old_position = card.position
|
|
card.column = column
|
|
card.completed_at = timezone.now() if column.is_done and not card.completed_at else (None if not column.is_done else card.completed_at)
|
|
siblings = list(Card.objects.filter(column=column, archived=False).exclude(pk=card.pk).order_by('position', 'created_at'))
|
|
index = len(siblings) if position is None else max(0, min(int(position), len(siblings)))
|
|
siblings.insert(index, card)
|
|
for i, item in enumerate(siblings):
|
|
item.position = i
|
|
item.save(update_fields=['position'])
|
|
moved = old_column != column.pk or old_position != card.position
|
|
if moved and record_revision:
|
|
card.revision += 1
|
|
card.save()
|
|
if moved and record_revision:
|
|
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.moved', detail={'from': str(old_column), 'to': str(column.pk)}, origin=origin)
|
|
return card
|
|
|
|
|
|
@transaction.atomic
|
|
def set_default(user, column):
|
|
project_for(user, column.board.project_id, write=True)
|
|
if column.archived:
|
|
raise ValidationError('Archived column cannot be the default.')
|
|
Column.objects.filter(board=column.board, is_default=True).update(is_default=False)
|
|
column.is_default = True
|
|
column.save(update_fields=['is_default'])
|
|
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
|
|
|
|
|
|
@transaction.atomic
|
|
def bulk_update_cards(user, project, card_ids, expected_revisions, changes, *, dry_run=False, idempotency_key=None, origin='web'):
|
|
"""Validate the entire batch before writing; every mutation shares one transaction."""
|
|
project_for(user, project.pk, write=True)
|
|
if not isinstance(card_ids, list) or not 1 <= len(card_ids) <= 100:
|
|
raise ValidationError('Select between 1 and 100 cards.')
|
|
try:
|
|
ids = [str(UUID(str(value))) for value in card_ids]
|
|
except (ValueError, TypeError, AttributeError):
|
|
raise ValidationError('Invalid card ID.')
|
|
if len(set(ids)) != len(ids):
|
|
raise ValidationError('Duplicate card IDs are not allowed.')
|
|
if not isinstance(changes, dict) or not changes or set(changes) - {'column_id', 'priority', 'assignee_id', 'tag_ids'}:
|
|
raise ValidationError('Supply supported changes: column_id, priority, assignee_id or tag_ids.')
|
|
if 'priority' in changes and changes['priority'] not in dict(Card.PRIORITY):
|
|
raise ValidationError('Invalid priority.')
|
|
payload_hash = hashlib.sha256(json.dumps({'project': str(project.pk), 'ids': ids, 'revisions': expected_revisions, 'changes': changes}, sort_keys=True).encode()).hexdigest()
|
|
if idempotency_key and not dry_run:
|
|
if len(idempotency_key) > 128:
|
|
raise ValidationError('Idempotency key is too long.')
|
|
user.__class__.objects.select_for_update().get(pk=user.pk)
|
|
existing = BulkUpdateKey.objects.select_for_update().filter(user=user, key=idempotency_key).first()
|
|
if existing:
|
|
if existing.payload_hash != payload_hash:
|
|
raise ValidationError('Idempotency key was already used with different changes.')
|
|
return existing.result
|
|
cards = {str(card.pk): card for card in Card.objects.select_for_update().filter(pk__in=ids, project=project, archived=False).select_related('column')}
|
|
if len(cards) != len(ids):
|
|
raise ValidationError('One or more cards are unavailable in this project.')
|
|
if not isinstance(expected_revisions, dict):
|
|
raise ValidationError('Expected revisions are required for every card.')
|
|
conflicts = [{'id': identifier, 'expected': expected_revisions.get(identifier), 'current': cards[identifier].revision}
|
|
for identifier in ids if expected_revisions.get(identifier) != cards[identifier].revision]
|
|
if conflicts:
|
|
raise ValidationError({'revision_conflicts': conflicts})
|
|
column = None
|
|
if 'column_id' in changes:
|
|
try:
|
|
column = Column.objects.get(pk=UUID(str(changes['column_id'])), board=project.board, archived=False)
|
|
except (Column.DoesNotExist, ValueError, TypeError):
|
|
raise ValidationError('Column is not available in this project.')
|
|
assignee = None
|
|
if 'assignee_id' in changes and changes['assignee_id'] is not None:
|
|
try:
|
|
assignee = user.__class__.objects.get(pk=changes['assignee_id'])
|
|
except (user.__class__.DoesNotExist, ValueError, TypeError):
|
|
raise ValidationError('Invalid assignee.')
|
|
if assignee.pk != project.owner_id and not Membership.objects.filter(project=project, user=assignee).exists():
|
|
raise ValidationError('Assignee must have access to this project.')
|
|
tags = None
|
|
if 'tag_ids' in changes:
|
|
tag_ids = changes['tag_ids']
|
|
if not isinstance(tag_ids, list) or any(type(value) is not int for value in tag_ids) or len(tag_ids) != len(set(tag_ids)):
|
|
raise ValidationError('Tag IDs must be a unique list.')
|
|
tags = list(Tag.objects.filter(project=project, pk__in=tag_ids))
|
|
if len(tags) != len(tag_ids):
|
|
raise ValidationError('Tags must belong to this project.')
|
|
results = []
|
|
for identifier in ids:
|
|
card = cards[identifier]
|
|
before = {'column_id': str(card.column_id), 'priority': card.priority, 'assignee_id': card.assignee_id,
|
|
'tag_ids': sorted(card.tags.values_list('pk', flat=True))}
|
|
after = dict(before)
|
|
if column is not None: after['column_id'] = str(column.pk)
|
|
if 'priority' in changes: after['priority'] = changes['priority']
|
|
if 'assignee_id' in changes: after['assignee_id'] = assignee.pk if assignee else None
|
|
if tags is not None: after['tag_ids'] = sorted(tag.pk for tag in tags)
|
|
delta = {field: {'from': before[field], 'to': after[field]} for field in changes if field in before and before[field] != after[field]}
|
|
results.append({'id': identifier, 'title': card.title, 'revision': card.revision + bool(delta), 'changes': delta, 'changed': bool(delta)})
|
|
if not dry_run:
|
|
for result in results:
|
|
if not result['changed']:
|
|
continue
|
|
card = cards[result['id']]
|
|
delta = result['changes']
|
|
if 'column_id' in delta:
|
|
move_card(user, card, column, origin=origin, record_revision=False)
|
|
card.refresh_from_db()
|
|
if 'priority' in delta: card.priority = changes['priority']
|
|
if 'assignee_id' in delta: card.assignee = assignee
|
|
if 'tag_ids' in delta: card.tags.set(tags)
|
|
card.revision += 1
|
|
card.full_clean()
|
|
card.save()
|
|
CardRevision.objects.create(card=card, revision=card.revision, markdown=card.description_markdown, actor=user)
|
|
Activity.objects.create(project=project, card=card, actor=user, action='card.bulk_updated', detail={'changes': delta}, origin=origin)
|
|
response = {'dry_run': dry_run, 'total': len(ids), 'changed_count': sum(item['changed'] for item in results),
|
|
'unchanged_count': sum(not item['changed'] for item in results), 'items': results}
|
|
if idempotency_key and not dry_run:
|
|
BulkUpdateKey.objects.create(user=user, key=idempotency_key, payload_hash=payload_hash, result=response)
|
|
return response
|