<?php

use App\Http\Controllers;

class ContestantController extends Controller {
    .
    .
    .
    public function advanceToRound(Request $request) {
    	
        Gate::authorize('contestant-advancement');
        
    	$params = $request->validate([
            'contestantId' => 'required|int',
            'round' => 'required|in:casting,competition',
            'signedContract' => 'required|file',
        ]);
        
        $contestant = Contestant::findOrFail($params['contestantId']);
        
        if ($contestant->jurryApprovals()->doesntExist()) {
            throw new RuntimeException(t('Not approved for advancement!'));
        }
        
        $contestant->round = $params['round'];
        $contastant->advancedByUserId = Auth::id();
        $contestant->save();
        
        $request->file('signedContract')->store('contestants/docs');
        
        return redirect(route('contestant-profile', $params['contenstantId']));
    }
    .
    .
    .
}

<?php 

namespace MusicIdol\Domain\Contestants;

use Exceptions\ContestantNotApprovedForAdvancement;

class AdvanceToRound {

    public function __construct(
        private ActorProvider $ap,
        private ContestantAuthorizations $auth,
        private ContestantsRepository $repo,
        private Transaction $tr
    ) {}
  
    public function __invoke(AdvanceToRoundParams $params): void
    {
        $this->auth->authorizeContestantAdvancement($this->ap->actor());
    
        $contestant = $this->repo->findById($params->contestantId());
        if ($contestant->isNotApproved()) {
            throw new ContestantNotApprovedForAdvancement();
        }
    
        $contestant->round = $params->round();
        $contestant->advancedByUser = $this->ap->actor();
        $contestant->signedContract = $params->signedContract();
    
        $tr->persist($contestant);
    }
}

<?php 

namespace MusicIdol\Domain\Contestants;

class AdvanceToRoundParams {
    private int $contestantId;
    private string $round;
    private File $signedContract;
    
    private function __construct() {}
    
    public function contestantId(): int {
        return $this->contestantId;
    }
    .
    .
    .
    public static function fromArray(array $params): self
    {
        $validated = Validator::make($params, [
            'contestantId' => 'required|int',
            'round' => 'required|in:casting,competition',
            'signedContract' => 'required|file',
        ])->validate();
        
        $instance = new self();
        $instance->contestantId = $validated['contestantId'];
        $instance->round = $validated['round'];
        $instance->signedContract = $validated['signedContract'];
        
        return $instance;
    }
}

<?php 

namespace MusicIdol\Domain\Contestants;

use Excepttions\UnauthorizedToAdvanceUser;

class ContestantAuthorizations {
    
    public function authorizeContestantAdvancement(User $actor): void {
        if ($user->role !== User::ROLE_CASTING_TEAM) {
            throw new UnauthorizedToAdvanceUser();
        }
    }
    
}

<?php 

namespace MusicIdol\Domain\Users;

interface ActorProvider {
    
    public function actor(): User;
    
}

<?php 

namespace MusicIdol\Domain\Transaction;

interface Transaction {
    
    public function persist(): void;
    
}

<?php 

namespace MusicIdol\Domain\Contestants;

interface ContestantsRepository {
    
    public function findById(): Contestant;
    
}

<?php


class AdvanceToRoundController extends Controller {

    public function __contructor(
        private AdvanceToRound $action;
    ) {}
    
    public function __invoke(Request $request) {
    	$params = AdvanceToRoundParams::fromArray($request->post());
        ($this->action)($params);
        return redirect(route('contestant-profile', $request->post('contenstantId')));
    }
}