Add dispute system

backend/app/services/dispute_scheduler.py

@@ -0,0 +1,89 @@
+"""
+Dispute Scheduler for automatic dispute resolution after 24 hours.
+"""
+import asyncio
+from datetime import datetime, timedelta
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models import Dispute, DisputeStatus, Assignment, AssignmentStatus
+from app.services.disputes import dispute_service
+
+
+# Configuration
+CHECK_INTERVAL_SECONDS = 300  # Check every 5 minutes
+DISPUTE_WINDOW_HOURS = 24  # Disputes auto-resolve after 24 hours
+
+
+class DisputeScheduler:
+    """Background scheduler for automatic dispute resolution."""
+
+    def __init__(self):
+        self._running = False
+        self._task: asyncio.Task | None = None
+
+    async def start(self, session_factory) -> None:
+        """Start the scheduler background task."""
+        if self._running:
+            return
+
+        self._running = True
+        self._task = asyncio.create_task(self._run_loop(session_factory))
+        print("[DisputeScheduler] Started")
+
+    async def stop(self) -> None:
+        """Stop the scheduler."""
+        self._running = False
+        if self._task:
+            self._task.cancel()
+            try:
+                await self._task
+            except asyncio.CancelledError:
+                pass
+        print("[DisputeScheduler] Stopped")
+
+    async def _run_loop(self, session_factory) -> None:
+        """Main scheduler loop."""
+        while self._running:
+            try:
+                async with session_factory() as db:
+                    await self._process_expired_disputes(db)
+            except Exception as e:
+                print(f"[DisputeScheduler] Error in loop: {e}")
+
+            await asyncio.sleep(CHECK_INTERVAL_SECONDS)
+
+    async def _process_expired_disputes(self, db: AsyncSession) -> None:
+        """Process and resolve expired disputes."""
+        cutoff_time = datetime.utcnow() - timedelta(hours=DISPUTE_WINDOW_HOURS)
+
+        # Find all open disputes that have expired
+        result = await db.execute(
+            select(Dispute)
+            .options(
+                selectinload(Dispute.votes),
+                selectinload(Dispute.assignment).selectinload(Assignment.participant),
+            )
+            .where(
+                Dispute.status == DisputeStatus.OPEN.value,
+                Dispute.created_at < cutoff_time,
+            )
+        )
+        expired_disputes = result.scalars().all()
+
+        for dispute in expired_disputes:
+            try:
+                result_status, votes_valid, votes_invalid = await dispute_service.resolve_dispute(
+                    db, dispute.id
+                )
+                print(
+                    f"[DisputeScheduler] Auto-resolved dispute {dispute.id}: "
+                    f"{result_status} (valid: {votes_valid}, invalid: {votes_invalid})"
+                )
+            except Exception as e:
+                print(f"[DisputeScheduler] Failed to resolve dispute {dispute.id}: {e}")
+
+
+# Global scheduler instance
+dispute_scheduler = DisputeScheduler()

backend/app/services/disputes.py

@@ -0,0 +1,103 @@
+"""
+Dispute resolution service.
+"""
+from datetime import datetime
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+
+from app.models import (
+    Dispute, DisputeStatus, DisputeVote,
+    Assignment, AssignmentStatus, Participant,
+)
+
+
+class DisputeService:
+    """Service for dispute resolution logic"""
+
+    async def resolve_dispute(self, db: AsyncSession, dispute_id: int) -> tuple[str, int, int]:
+        """
+        Resolve a dispute based on votes.
+
+        Returns:
+            Tuple of (result_status, votes_valid, votes_invalid)
+        """
+        # Get dispute with votes and assignment
+        result = await db.execute(
+            select(Dispute)
+            .options(
+                selectinload(Dispute.votes),
+                selectinload(Dispute.assignment).selectinload(Assignment.participant),
+            )
+            .where(Dispute.id == dispute_id)
+        )
+        dispute = result.scalar_one_or_none()
+
+        if not dispute:
+            raise ValueError(f"Dispute {dispute_id} not found")
+
+        if dispute.status != DisputeStatus.OPEN.value:
+            raise ValueError(f"Dispute {dispute_id} is already resolved")
+
+        # Count votes
+        votes_valid = sum(1 for v in dispute.votes if v.vote is True)
+        votes_invalid = sum(1 for v in dispute.votes if v.vote is False)
+
+        # Determine result: tie goes to the accused (valid)
+        if votes_invalid > votes_valid:
+            # Proof is invalid - mark assignment as RETURNED
+            result_status = DisputeStatus.RESOLVED_INVALID.value
+            await self._handle_invalid_proof(db, dispute)
+        else:
+            # Proof is valid (or tie)
+            result_status = DisputeStatus.RESOLVED_VALID.value
+
+        # Update dispute
+        dispute.status = result_status
+        dispute.resolved_at = datetime.utcnow()
+
+        await db.commit()
+
+        return result_status, votes_valid, votes_invalid
+
+    async def _handle_invalid_proof(self, db: AsyncSession, dispute: Dispute) -> None:
+        """
+        Handle the case when proof is determined to be invalid.
+
+        - Mark assignment as RETURNED
+        - Subtract points from participant
+        - Reset streak if it was affected
+        """
+        assignment = dispute.assignment
+        participant = assignment.participant
+
+        # Subtract points that were earned
+        points_to_subtract = assignment.points_earned
+        participant.total_points = max(0, participant.total_points - points_to_subtract)
+
+        # Reset assignment
+        assignment.status = AssignmentStatus.RETURNED.value
+        assignment.points_earned = 0
+        # Keep proof data so it can be reviewed
+
+        print(f"[DisputeService] Assignment {assignment.id} marked as RETURNED, "
+              f"subtracted {points_to_subtract} points from participant {participant.id}")
+
+    async def get_pending_disputes(self, db: AsyncSession, older_than_hours: int = 24) -> list[Dispute]:
+        """Get all open disputes older than specified hours"""
+        from datetime import timedelta
+
+        cutoff_time = datetime.utcnow() - timedelta(hours=older_than_hours)
+
+        result = await db.execute(
+            select(Dispute)
+            .where(
+                Dispute.status == DisputeStatus.OPEN.value,
+                Dispute.created_at < cutoff_time,
+            )
+        )
+        return list(result.scalars().all())
+
+
+# Global service instance
+dispute_service = DisputeService()