Add contest judging system

app/Http/Controllers/Admin/ContestsController.php

@@ -6,6 +6,7 @@
 namespace App\Http\Controllers\Admin;
 
 use App\Models\Contest;
+use App\Models\ContestJudgeVote;
 use App\Models\DeletedUser;
 use App\Models\UserContestEntry;
 use ZipStream\ZipStream;
@@ -21,15 +22,26 @@ public function index()
 
     public function show($id)
     {
-        $contest = Contest::findOrFail($id);
+        $contest = Contest::with('judges')
+            ->withCount('entries')
+            ->findOrFail($id);
+
         $entries = UserContestEntry::withTrashed()
             ->where('contest_id', $id)
             ->with('user')
             ->get();
 
+        if ($contest->isJudged()) {
+            $judgeVoteCounts = ContestJudgeVote::whereIn('contest_entry_id', $contest->entries()->pluck('id'))
+                ->groupBy('user_id')
+                ->selectRaw('COUNT(*) as judge_votes_count, user_id')
+                ->get();
+        }
+
         return ext_view('admin.contests.show', [
             'contest' => $contest,
             'entries' => json_collection($entries, 'UserContestEntry', ['user']),
+            'judgeVoteCounts' => $judgeVoteCounts ??= null,
         ]);
     }
 

app/Http/Controllers/ContestEntriesController.php

@@ -5,20 +5,114 @@
 
 namespace App\Http\Controllers;
 
+use App\Exceptions\InvariantException;
 use App\Models\Contest;
 use App\Models\ContestEntry;
 use App\Models\UserContestEntry;
+use App\Transformers\ContestTransformer;
 use Auth;
+use Ds\Set;
+use Illuminate\Support\Facades\DB;
 use Request;
 
 class ContestEntriesController extends Controller
 {
+    public function judgeResults($id)
+    {
+        $entry = ContestEntry::with('contest')->findOrFail($id);
+
+        abort_if(!$entry->contest->isJudged() || !$entry->contest->show_votes, 404);
+
+        $entry->load([
+            'contest.entries',
+            'contest.scoringCategories',
+            'judgeVotes.scores',
+            'judgeVotes.user',
+            'user',
+        ])->loadSum('scores', 'value');
+
+        $contest = $entry->contest
+            ->loadCount('judges')
+            ->loadSum('scoringCategories', 'max_value');
+
+        $contestJson = json_item(
+            $contest,
+            new ContestTransformer(),
+            [
+                'max_judging_score',
+                'max_total_score',
+                'scoring_categories',
+            ],
+        );
+
+        $entryJson = json_item($entry, 'ContestEntry', [
+            'judge_votes.scores',
+            'judge_votes.total_score',
+            'judge_votes.user',
+            'results',
+            'user',
+        ]);
+
+        $entriesJson = json_collection($entry->contest->entries, 'ContestEntry');
+
+        return ext_view('contest_entries.judge-results', [
+            'contestJson' => $contestJson,
+            'entryJson' => $entryJson,
+            'entriesJson' => $entriesJson,
+        ]);
+    }
+
+    public function judgeVote($id)
+    {
+        $entry = ContestEntry::with('contest.scoringCategories')->findOrFail($id);
+
+        priv_check('ContestJudge', $entry->contest)->ensureCan();
+
+        $params = get_params(request()->all(), null, [
+            'scores:array',
+            'comment',
+        ], ['null_missing' => true]);
+
+        $scoresByCategoryId = collect($params['scores'])
+            ->keyBy('contest_scoring_category_id');
+
+        $expectedCategoryIds = new Set($entry->contest->scoringCategories->pluck('id'));
+        $givenCategoryIds = new Set($scoresByCategoryId->keys());
+
+        if ($expectedCategoryIds->diff($givenCategoryIds)->count() > 0) {
+            throw new InvariantException(osu_trans('contest.judge.validation.missing_score'));
+        }
+
+        DB::transaction(function () use ($entry, $params, $scoresByCategoryId) {
+            $vote = $entry->judgeVotes()->firstOrNew(['user_id' => Auth::user()->getKey()]);
+            $vote->fill(['comment' => $params['comment']])->save();
+
+            foreach ($entry->contest->scoringCategories as $category) {
+                $score = $scoresByCategoryId[$category->getKey()];
+                $value = clamp($score['value'], 0, $category->max_value);
+
+                $vote->scores()->firstOrNew([
+                    'contest_judge_vote_id' => $vote->getKey(),
+                    'contest_scoring_category_id' => $category->getKey(),
+                ])->fill(['value' => $value])->save();
+            }
+        });
+
+        $updatedEntry = $entry->refresh()->load('judgeVotes.scores');
+
+        return json_item($updatedEntry, 'ContestEntry', ['current_user_judge_vote.scores']);
+    }
+
     public function vote($id)
     {
         $user = Auth::user();
         $entry = ContestEntry::findOrFail($id);
         $contest = Contest::with('entries')->with('entries.contest')->findOrFail($entry->contest_id);
 
+        if ($contest->isJudged()) {
+            throw new InvariantException(osu_trans('contest.judge.validation.contest_vote_judged'));
+        }
+
         priv_check('ContestVote', $contest)->ensureCan();
 
         $contest->vote($user, $entry);

app/Http/Controllers/ContestsController.php

@@ -7,6 +7,7 @@
 
 use App\Exceptions\InvariantException;
 use App\Models\Contest;
+use App\Transformers\ContestTransformer;
 use Auth;
 
 class ContestsController extends Controller
@@ -24,6 +25,27 @@ public function index()
         ]);
     }
 
+    public function judge($id)
+    {
+        $contest = Contest::with('entries.judgeVotes')
+            ->with('entries.judgeVotes.scores')
+            ->with('scoringCategories')
+            ->findOrFail($id);
+
+        abort_if(!$contest->isJudged(), 404);
+
+        priv_check('ContestJudgeShow', $contest)->ensureCan();
+
+        $contestJson = json_item($contest, new ContestTransformer(), [
+            'entries.current_user_judge_vote.scores',
+            'scoring_categories',
+        ]);
+
+        return ext_view('contests.judge', [
+            'contestJson' => $contestJson,
+        ]);
+    }
+
     public function show($id)
     {
         $contest = Contest::findOrFail($id);

app/Libraries/OsuAuthorize.php

@@ -44,6 +44,7 @@ public static function alwaysCheck($ability)
         static $set;
 
         $set ??= new Ds\Set([
+            'ContestJudge',
             'IsOwnClient',
             'IsNotOAuth',
             'IsSpecialScope',
@@ -1330,6 +1331,39 @@ public function checkContestEntryDestroy(?User $user, UserContestEntry $contestE
         return 'ok';
     }
 
+    /**
+     * @param User|null $user
+     * @param Contest $contest
+     * @return string
+     * @throws AuthorizationCheckException
+     */
+    public function checkContestJudge(?User $user, Contest $contest): string
+    {
+        $this->ensureLoggedIn($user);
+
+        if (!$contest->isJudgingActive()) {
+            return 'contest.judging_not_active';
+        }
+
+        if (!$contest->isJudge($user)) {
+            return 'unauthorized';
+        }
+
+        return 'ok';
+    }
+
+    /**
+     * @param User|null $user
+     * @param Contest $contest
+     * @return string
+     * @throws AuthorizationCheckException
+     */
+    public function checkContestJudgeShow(?User $user, Contest $contest): string
+    {
+        // so that admins can show the panel but not vote (ContestJudge is alwaysCheck)
+        return $this->checkContestJudge($user, $contest);
+    }
+
     /**
      * @param User|null $user
      * @param Contest $contest

app/Models/Contest.php

@@ -12,29 +12,34 @@
 use App\Transformers\UserContestEntryTransformer;
 use Cache;
 use Exception;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Database\Eloquent\Relations\BelongsToMany;
+use Illuminate\Database\Eloquent\Relations\HasMany;
 
 /**
  * @property \Carbon\Carbon|null $created_at
  * @property string $description_enter
  * @property string|null $description_voting
- * @property \Illuminate\Database\Eloquent\Collection $entries ContestEntry
+ * @property-read Collection<ContestEntry> $entries
  * @property \Carbon\Carbon|null $entry_ends_at
  * @property mixed $thumbnail_shape
  * @property \Carbon\Carbon|null $entry_starts_at
  * @property json|null $extra_options
  * @property string $header_url
  * @property int $id
  * @property mixed $link_icon
+ * @property-read Collection<ContestJudge> $judges
  * @property int $max_entries
  * @property int $max_votes
  * @property string $name
  * @property bool $show_votes
  * @property mixed $type
  * @property mixed $unmasked
+ * @property-read Collection<ContestScoringCategory> $scoringCategories
  * @property bool $show_names
  * @property \Carbon\Carbon|null $updated_at
  * @property bool $visible
- * @property \Illuminate\Database\Eloquent\Collection $votes ContestVote
+ * @property-read Collection<ContestVote> $votes
  * @property \Carbon\Carbon|null $voting_ends_at
  * @property \Carbon\Carbon|null $voting_starts_at
  */
@@ -57,6 +62,11 @@ public function entries()
         return $this->hasMany(ContestEntry::class);
     }
 
+    public function judges(): BelongsToMany
+    {
+        return $this->belongsToMany(User::class, ContestJudge::class);
+    }
+
     public function userContestEntries()
     {
         return $this->hasMany(UserContestEntry::class);
@@ -110,6 +120,23 @@ public function isBestOf(): bool
         return isset($this->getExtraOptions()['best_of']);
     }
 
+    public function isJudge(User $user): bool
+    {
+        $judges = $this->judges();
+
+        return $judges->where($judges->qualifyColumn('user_id'), $user->getKey())->exists();
+    }
+
+    public function isJudged(): bool
+    {
+        return $this->getExtraOptions()['judged'] ?? false;
+    }
+
+    public function isJudgingActive(): bool
+    {
+        return $this->isJudged() && $this->isVotingStarted() && !$this->show_votes;
+    }
+
     public function isSubmittedBeatmaps(): bool
     {
         return $this->isBestOf() || ($this->getExtraOptions()['submitted_beatmaps'] ?? false);
@@ -133,6 +160,11 @@ public function isVotingStarted()
         return $this->voting_starts_at !== null && $this->voting_starts_at->isPast();
     }
 
+    public function scoringCategories(): HasMany
+    {
+        return $this->hasMany(ContestScoringCategory::class);
+    }
+
     public function state()
     {
         if ($this->entry_starts_at === null || $this->entry_starts_at->isFuture()) {
@@ -245,16 +277,21 @@ public function entriesByType($user = null, array $preloads = [])
 
         if ($this->show_votes) {
             return Cache::remember("contest_entries_with_votes_{$this->id}", 300, function () use ($entries) {
+                $orderValue = 'votes_count';
+
                 if ($this->isBestOf()) {
                     $entries = $entries
                         ->selectRaw('*')
                         ->selectRaw('(SELECT FLOOR(SUM(`weight`)) FROM `contest_votes` WHERE `contest_entries`.`id` = `contest_votes`.`contest_entry_id`) AS votes_count')
                         ->limit(50); // best of contests tend to have a _lot_ of entries...
+                } else if ($this->isJudged()) {
+                    $entries = $entries->withSum('scores', 'value');
+                    $orderValue = 'scores_sum_value';
                 } else {
                     $entries = $entries->withCount('votes');
                 }
 
-                return $entries->orderBy('votes_count', 'desc')->get();
+                return $entries->orderBy($orderValue, 'desc')->get();
             });
         } else {
             if ($this->isBestOf()) {

app/Models/ContestEntry.php

@@ -5,27 +5,43 @@
 
 namespace App\Models;
 
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Database\Eloquent\Relations\HasManyThrough;
+
 /**
- * @property Contest $contest
+ * @property-read Contest $contest
  * @property int $contest_id
  * @property \Carbon\Carbon|null $created_at
  * @property string|null $entry_url
  * @property string|null $thumbnail_url
  * @property int $id
+ * @property-read Collection<ContestJudgeVote> $judgeVotes
  * @property string $masked_name
  * @property string $name
+ * @property-read Collection<ContestJudgeScore> $scores
  * @property \Carbon\Carbon|null $updated_at
- * @property User $user
+ * @property-read User $user
  * @property int|null $user_id
- * @property \Illuminate\Database\Eloquent\Collection $votes ContestVote
+ * @property-read Collection<ContestVote> $votes
  */
 class ContestEntry extends Model
 {
+    public function scores(): HasManyThrough
+    {
+        return $this->hasManyThrough(ContestJudgeScore::class, ContestJudgeVote::class);
+    }
+
     public function contest()
     {
         return $this->belongsTo(Contest::class);
     }
 
+    public function judgeVotes(): HasMany
+    {
+        return $this->hasMany(ContestJudgeVote::class);
+    }
+
     public function user()
     {
         return $this->belongsTo(User::class, 'user_id');