Marijn/TijdVoorDeTest
1
0
Fork 0
mirror of https://github.com/MarijnDoeve/TijdVoorDeTest.git synced 2026-07-10 09:30:14 +02:00
Code Issues Packages Projects Releases Activity

feat: season question bank & quiz finalisation (#101) (#176)

Browse Source 
* feat: add question bank management, quiz finalization, and related backend/frontend functionality

* chore: add symfony/object-mapper dependency and fix Finalized translation

* feat: address PR review comments — unassign/sync bank questions, blank quiz creation, deactivate redirect, remove duplicate tab titles

- Use Symfony ObjectMapper for BankQuestion/BankAnswer → Question/Answer copy (#[Map(if: false)] on id, season, etc.)
- Track created Question on BankQuestionUsage (nullable FK, onDelete: SET NULL) for unassign/sync support
- Add unassign route: removes the Question copy + usage record
- Add sync route: pushes bank question edits to a finalized-not-started quiz copy
- Auto-sync non-finalized quiz copies on bank question edit; flash warning for finalized-not-started
- Add blank quiz creation (no XLSX required) with new route + template
- Deactivate quiz button now stays on the quiz overview page (redirect_quiz hidden field)
- Remove duplicate h4 titles below the tab bar on all season tabs
- Add migration for bank_question_usage.question_id
- Add Dutch translations for all new strings

* fix: address CodeRabbit review findings

- Use FlashType enum in clearQuiz/finalizeQuiz/unfinalizeQuiz (was raw 'success'/'error' strings)
- Catch UniqueConstraintViolationException in addLabel to handle concurrent duplicate inserts
- Wrap assignToQuiz in a transaction with PESSIMISTIC_WRITE lock to serialise concurrent assignments of the same BankQuestion

* ci: build SCSS before running PHPUnit tests

* test: remove QueryCountTest (covered by Sentry in production)

* fix: crash on empty-quiz overview and answer-mapping, use FlashType enum consistently

- fetchWithQuestionsAndCandidates / fetchWithQuestions used INNER JOINs on
  questions/answers, so quizzes with no questions threw NoResultException (500)
  when opening the overview tab. Switched to LEFT JOINs.
- answerMapping bare \assert() replaced with a proper flash + redirect when
  the quiz has no questions, instead of crashing with AssertionError.
- Three raw 'success' flash strings in QuizController replaced with FlashType::Success.
- Added Dutch translation for "This quiz has no questions yet".
- Two new tests: empty-quiz overview loads (200), answer-mapping redirects with flash.

* feat: add contextual help panels to all backoffice pages

Add a 50/50 or 66/33 split layout to every backoffice page with Dutch
instructions explaining how to use Tijd voor de Test. Content covers the
overall workflow, quiz finalize/activate flow, and both candidate
participation methods (own device vs. shared laptop).

Help text lives in dedicated partials under templates/backoffice/help/ and
is loaded via Twig include(), keeping page templates clean. All strings use
a separate 'instructions' translation domain (instructions+intl-icu.nl.xliff)
isolated from the main messages domain.

Also updates 'Finalize'-related Dutch translations to use 'Afronden' and
adds tooltips to the finalize/unfinalize buttons.

* refactor: move help content out of translations into locale-specific partials

Replace the instructions translation domain with plain HTML files under
templates/backoffice/help/nl/. Each help/*.html.twig is now a locale
dispatch shim that tries the current locale first and falls back to nl,
so adding English (or any other language) is simply a matter of creating
a help/en/ directory with the translated files — no code changes needed.

Removes instructions+intl-icu.nl.xliff.

* fix: address PR review feedback on help texts and translations

- Replace 'speelronde' with 'spel' in index and season_add help
- Season settings help: remove incorrect claim name is editable, describe
  actual settings (Show Numbers, Confirm Answers)
- quiz_add help: rename 'XLSX-bestand' to 'Excel-bestand', add explanation
  of WAAR/ONWAAR (Dutch Excel) vs TRUE/FALSE (English Excel) for marking
  the correct answer
- quiz_answer_mapping help: remove em-dashes
- quiz_candidates help: clarify that multiple devices and mixed setups
  (multiple laptops, phones, or a mix) are supported
- quiz_question_bank_form help: change 'thema' to 'type vraag' for labels
- Rename 'Add from XLSX' to 'Import' in translation and template

* fix: remove all em-dashes from nl help files, fix remaining XLSX references

Replace all em-dashes with semicolons or colons throughout the nl help
partials. Also replace remaining 'XLSX-bestand' with 'Excel-bestand' in
season_tests and index, and also also fix the em-dash that was still on
the same line as the 'speelronde -> spel' fix in index.

* style: replace semicolons with commas in nl help content, document writing rules

Semicolons in help text read as AI-generated; commas are more natural.
Added writing style rules to CLAUDE.md to prevent recurrence.

* fix: correct lock guards, flush batching, and clearQuiz atomicity in question bank

- syncUsagesAfterEdit: use isLocked() instead of !isFinalized() to avoid
  syncing quizzes with started candidates (would have destroyed GivenAnswer records)
- syncToQuiz action: use isLocked() instead of hasStartedCandidates() to block
  syncing into finalized quizzes that have no started candidates
- QuestionBankService::syncToQuiz: remove internal flush(); callers now
  flush once (syncUsagesAfterEdit after the loop, syncToQuiz action after the call)
- QuizRepository::clearQuiz: delete BankQuestionUsage rows and reset
  finalized_at inside the transaction (previously orphaned usages blocked
  bank question reassignment; finalizedAt reset was a separate non-atomic flush)
- QuizController::finalizeQuiz: add flash when quiz is already finalized
- QuestionBankController::delete: block deletion when any usage references a locked quiz
- BankQuestion::__toString: remove dead null-coalescing on non-nullable string
- SeasonController::addBlankQuiz: align form field with UploadQuizFormType
  (add translation_domain: false, use translator for label)

* fix: pass season variable to season_add_candidates template

* Textual changes to help content.

* Manual text changes

* feat: address PR review — property hooks, slug labels, label colours, drag sort, Loggable, and more

- Convert Quiz.isFinalized/isLocked/hasStartedCandidates and BankQuestion.isUsed/canBeAssigned to PHP 8.4 property get hooks; update all PHP and test call sites
- Add LabelColour enum (Bootstrap colour names) with colour column on QuestionLabel; badges in templates reflect label colour
- Add slug field to QuestionLabel with unique-per-season constraint; label filter and delete URLs now use slug instead of UUID; slugger generates and uniqueness-checks slug on save
- Allow saving bank questions without answers; isCompleteForQuiz hook enforces completeness before assigning to a quiz; BankQuestionIncompleteException for user-facing feedback
- Split BankQuestionRepository findBySeason into separate queries to avoid Cartesian-product row explosion across multiple collections
- Enable Gedmo Loggable on BankQuestion (question and reusable fields versioned); custom LogEntry entity uses json type for PostgreSQL compatibility; migrations for ext_log_entries and new columns
- Add SeasonController blank-quiz form validation (NotBlank, Length) and catch UniqueConstraintViolation as form error
- Replace × with bi-trash icon on answer delete buttons and label delete buttons
- Add drag-and-drop reordering with grab handles, sort-alphabetically, and randomize buttons to answer collection in question bank form
- Replace raw 'success'/'error' flash strings with FlashType enum in RegistrationController and PrepareEliminationController
- Add testDeactivateWithRedirectQuizStaysOnQuizOverview test covering enableQuiz redirect_quiz branch

* fix: migration to align ext_log_entries id/data types and drop slug default

* refactor: squash three PR migrations into one

* feat: question bank UX — ordering, correct-answer toggle, label colour picker

Answer ordering:
- Remove applyAnswerOrdering from edit action (it was overwriting form-submitted
  ordering with the original Doctrine-loaded order, discarding user reordering)
- Call _syncOrdering() on Stimulus connect() and addItem() so hidden ordering
  inputs are always populated before submission
- Fix drag-and-drop to insert before/after based on cursor position relative to
  the target item's midpoint, enabling drop to the bottom position

Correct-answer toggle:
- Replace checkbox + "Correct" label with a filled green ✓ / red ✗ button
- Checkbox is kept hidden (d-none) so form submission still works; button
  syncs the checkbox state on click

Label colour picker:
- Always show label colours in the filter bar (opacity-50 when inactive,
  full opacity when active) so colours are visible without selecting a filter
- Add a reusable modal component (templates/components/modal.html.twig) using
  Twig embed blocks (modal_trigger, modal_body, modal_footer)
- Replace inline add-label form with the modal, adding a colour picker that
  renders swatches as coloured badges (faded when unselected, full opacity
  with white ring when selected) matching how labels appear in the filter bar
- Controller now accepts and persists the selected colour on label creation

* refactor: rename and standardize label colours, update default values, and add new translations

* fix: question bank layout — help text beside content, icon-only action buttons

Move labels filter and table inside the main column so help text sits
beside the full content rather than just the add button. Convert Edit,
Delete, and Assign buttons to icon-only btn-group to save row space.

* refactor: abstract base for Answer/BankAnswer; add quiz question edit

- Extract AbstractBaseAnswer (MappedSuperclass) sharing ordering, text,
  isRightAnswer, constructor, and __toString between Answer and BankAnswer
- Extract AbstractBaseAnswerFormType sharing buildForm between
  BankAnswerFormType and new AnswerFormType
- Add QuestionFormType for editing quiz-level Question entities
- Add QuizQuestionController with edit route guarded by MODIFY_QUIZ_CONTENT
  voter (hidden on locked/finalized quizzes)
- Add question edit template reusing the shared answer_row Twig macro
- Show Edit button per question in quiz overview accordion

* fix: use colour label instead of translated name in question bank picker

* fix: translate LabelColour label in question bank colour picker

TranslatableMessage cannot be coerced to string by Twig without |trans.
This commit is contained in:
Marijn Doeve
2026-07-05 21:36:33 +02:00
committed by GitHub
parent 696537cf35
commit 135e4f0ae5
98 changed files with 4132 additions and 329 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Controller/Backoffice/PrepareEliminationController.php
+2 -1
View File
@@ -15,6 +15,7 @@ use Tvdt\Controller\AbstractController;
use Tvdt\Entity\Elimination;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\Season;
use Tvdt\Enum\FlashType;
use Tvdt\Factory\EliminationFactory;
final class PrepareEliminationController extends AbstractController
@@ -52,7 +53,7 @@ final class PrepareEliminationController extends AbstractController
return $this->redirectToRoute('tvdt_elimination', ['elimination' => $elimination->id]);
}
$this->addFlash('success', 'Elimination updated');
$this->addFlash(FlashType::Success, 'Elimination updated');
return $this->redirectToRoute('tvdt_prepare_elimination_view', ['elimination' => $elimination->id]);
}
src/Controller/Backoffice/QuestionBankController.php
+387
View File
@@ -0,0 +1,387 @@
<?php
declare(strict_types=1);
namespace Tvdt\Controller\Backoffice;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Attribute\AsController;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Routing\Requirement\Requirement;
use Symfony\Component\Security\Http\Attribute\IsCsrfTokenValid;
use Symfony\Component\Security\Http\Attribute\IsGranted;
use Symfony\Component\String\Slugger\SluggerInterface;
use Symfony\Component\Uid\Uuid;
use Symfony\Contracts\Translation\TranslatorInterface;
use Tvdt\Controller\AbstractController;
use Tvdt\Entity\BankQuestion;
use Tvdt\Entity\BankQuestionUsage;
use Tvdt\Entity\QuestionLabel;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\Season;
use Tvdt\Enum\FlashType;
use Tvdt\Enum\LabelColour;
use Tvdt\Exception\BankQuestionAlreadyUsedException;
use Tvdt\Exception\BankQuestionIncompleteException;
use Tvdt\Exception\QuizLockedException;
use Tvdt\Form\BankQuestionFormType;
use Tvdt\Repository\BankQuestionRepository;
use Tvdt\Repository\QuestionLabelRepository;
use Tvdt\Repository\QuizRepository;
use Tvdt\Security\Voter\SeasonVoter;
use Tvdt\Service\QuestionBankService;
#[AsController]
#[IsGranted('ROLE_USER')]
class QuestionBankController extends AbstractController
{
public function __construct(
private readonly TranslatorInterface $translator,
private readonly EntityManagerInterface $em,
private readonly BankQuestionRepository $bankQuestionRepository,
private readonly QuestionLabelRepository $questionLabelRepository,
private readonly QuizRepository $quizRepository,
private readonly QuestionBankService $questionBankService,
private readonly SluggerInterface $slugger,
) {}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank',
name: 'tvdt_backoffice_question_bank',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
priority: 10,
)]
public function index(Season $season, Request $request): Response
{
$label = null;
$labelSlug = $request->query->getString('label');
if ('' !== $labelSlug) {
$label = $this->questionLabelRepository->findBySlugAndSeason($labelSlug, $season);
}
return $this->render('backoffice/season.html.twig', [
'season' => $season,
'bankQuestions' => $this->bankQuestionRepository->findBySeason($season, $label),
'assignableQuizzes' => $this->quizRepository->findAssignableForSeason($season),
'activeLabel' => $label,
'labelColours' => LabelColour::cases(),
'activeTab' => 'question-bank',
'template' => 'backoffice/season/tab_question_bank.html.twig',
]);
}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/new',
name: 'tvdt_backoffice_question_bank_new',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
priority: 10,
)]
public function new(Season $season, Request $request): Response
{
$bankQuestion = new BankQuestion();
$form = $this->createForm(BankQuestionFormType::class, $bankQuestion, ['season' => $season]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$this->applyAnswerOrdering($bankQuestion);
$season->addBankQuestion($bankQuestion);
$this->em->persist($bankQuestion);
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Question added to the question bank'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
return $this->render('backoffice/question_bank/form.html.twig', [
'season' => $season,
'form' => $form,
'bankQuestion' => null,
]);
}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/{bankQuestion}/edit',
name: 'tvdt_backoffice_question_bank_edit',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'bankQuestion' => Requirement::UUID],
priority: 10,
)]
public function edit(Season $season, BankQuestion $bankQuestion, Request $request): Response
{
$this->assertSameSeason($season, $bankQuestion->season);
$form = $this->createForm(BankQuestionFormType::class, $bankQuestion, ['season' => $season]);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$this->em->flush();
$this->syncUsagesAfterEdit($bankQuestion);
$this->addFlash(FlashType::Success, $this->translator->trans('Question updated'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
return $this->render('backoffice/question_bank/form.html.twig', [
'season' => $season,
'form' => $form,
'bankQuestion' => $bankQuestion,
]);
}
#[IsCsrfTokenValid('delete_bank_question')]
#[IsGranted(SeasonVoter::DELETE, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/{bankQuestion}/delete',
name: 'tvdt_backoffice_question_bank_delete',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'bankQuestion' => Requirement::UUID],
methods: ['POST'],
priority: 10,
)]
public function delete(Season $season, BankQuestion $bankQuestion): RedirectResponse
{
$this->assertSameSeason($season, $bankQuestion->season);
$hasLockedUsages = $bankQuestion->usages->exists(
static fn (int $key, BankQuestionUsage $usage): bool => $usage->quiz->isLocked,
);
if ($hasLockedUsages) {
$this->addFlash(FlashType::Danger, $this->translator->trans('This question cannot be deleted because it is used in a locked or active quiz'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
$this->em->remove($bankQuestion);
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Question removed from the question bank'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
#[IsCsrfTokenValid('assign_bank_question')]
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/{bankQuestion}/assign',
name: 'tvdt_backoffice_question_bank_assign',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'bankQuestion' => Requirement::UUID],
methods: ['POST'],
priority: 10,
)]
public function assign(Season $season, BankQuestion $bankQuestion, Request $request): RedirectResponse
{
$this->assertSameSeason($season, $bankQuestion->season);
$quizId = $request->request->getString('quiz');
if (!Uuid::isValid($quizId)) {
throw new BadRequestHttpException('Invalid quiz');
}
$quiz = $this->em->getRepository(Quiz::class)->find($quizId);
if (!$quiz instanceof Quiz || $quiz->season !== $season) {
throw new BadRequestHttpException('Invalid quiz');
}
$this->denyAccessUnlessGranted(SeasonVoter::MODIFY_QUIZ_CONTENT, $quiz);
try {
$this->questionBankService->assignToQuiz($bankQuestion, $quiz);
$this->addFlash(FlashType::Success, $this->translator->trans('Question added to quiz %quiz%', ['%quiz%' => $quiz->name]));
} catch (QuizLockedException) {
$this->addFlash(FlashType::Danger, $this->translator->trans('This quiz can no longer be altered'));
} catch (BankQuestionAlreadyUsedException) {
$this->addFlash(FlashType::Danger, $this->translator->trans('This question has already been used'));
} catch (BankQuestionIncompleteException) {
$this->addFlash(FlashType::Warning, $this->translator->trans('This question is incomplete: it needs at least two answers and exactly one correct answer'));
}
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
#[IsCsrfTokenValid('add_question_label')]
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/labels',
name: 'tvdt_backoffice_question_bank_labels',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
methods: ['POST'],
priority: 15,
)]
public function addLabel(Season $season, Request $request): RedirectResponse
{
$name = mb_trim($request->request->getString('name'));
if ('' === $name || mb_strlen($name) > 64) {
$this->addFlash(FlashType::Danger, $this->translator->trans('Invalid label name'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
$slug = mb_strtolower($this->slugger->slug($name)->toString());
$colour = LabelColour::tryFrom($request->request->getString('colour')) ?? LabelColour::Gray;
$exists = $season->questionLabels->exists(static fn (int $key, QuestionLabel $label): bool => $label->name === $name);
if (!$exists) {
if ($this->questionLabelRepository->slugExistsForSeason($slug, $season)) {
$this->addFlash(FlashType::Danger, $this->translator->trans('A label with a similar name already exists'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
try {
$newLabel = new QuestionLabel($name);
$newLabel->slug = $slug;
$newLabel->colour = $colour;
$season->addQuestionLabel($newLabel);
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Label added'));
} catch (UniqueConstraintViolationException) {
// Concurrent request already inserted the same label; treat as a no-op
}
}
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
#[IsCsrfTokenValid('delete_question_label')]
#[IsGranted(SeasonVoter::DELETE, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/labels/{labelSlug}/delete',
name: 'tvdt_backoffice_question_bank_label_delete',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'labelSlug' => '[a-z0-9-]+'],
methods: ['POST'],
priority: 15,
)]
public function deleteLabel(Season $season, string $labelSlug): RedirectResponse
{
$label = $this->questionLabelRepository->findBySlugAndSeason($labelSlug, $season);
if (!$label instanceof QuestionLabel) {
throw $this->createNotFoundException();
}
foreach ($label->bankQuestions as $bankQuestion) {
$bankQuestion->removeLabel($label);
}
$this->em->remove($label);
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Label removed'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
#[IsCsrfTokenValid('unassign_bank_question')]
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/{bankQuestion}/unassign/{usage}',
name: 'tvdt_backoffice_question_bank_unassign',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'bankQuestion' => Requirement::UUID, 'usage' => Requirement::UUID],
methods: ['POST'],
priority: 10,
)]
public function unassign(Season $season, BankQuestion $bankQuestion, BankQuestionUsage $usage): RedirectResponse
{
$this->assertSameSeason($season, $bankQuestion->season);
if ($usage->bankQuestion !== $bankQuestion) {
throw new NotFoundHttpException();
}
if ($usage->quiz->isLocked) {
$this->addFlash(FlashType::Danger, $this->translator->trans('This quiz can no longer be altered'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
$this->questionBankService->unassignFromQuiz($usage);
$this->addFlash(FlashType::Success, $this->translator->trans('Question removed from quiz %quiz%', ['%quiz%' => $usage->quiz->name]));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
#[IsCsrfTokenValid('sync_bank_question')]
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/question-bank/{bankQuestion}/sync/{usage}',
name: 'tvdt_backoffice_question_bank_sync',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'bankQuestion' => Requirement::UUID, 'usage' => Requirement::UUID],
methods: ['POST'],
priority: 10,
)]
public function syncToQuiz(Season $season, BankQuestion $bankQuestion, BankQuestionUsage $usage): RedirectResponse
{
$this->assertSameSeason($season, $bankQuestion->season);
if ($usage->bankQuestion !== $bankQuestion) {
throw new NotFoundHttpException();
}
if ($usage->quiz->isLocked) {
$this->addFlash(FlashType::Danger, $this->translator->trans('This quiz can no longer be altered'));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
$this->questionBankService->syncToQuiz($bankQuestion, $usage);
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Question synced to quiz %quiz%', ['%quiz%' => $usage->quiz->name]));
return $this->redirectToRoute('tvdt_backoffice_question_bank', ['seasonCode' => $season->seasonCode]);
}
private function assertSameSeason(Season $season, Season $subjectSeason): void
{
if ($season !== $subjectSeason) {
throw new NotFoundHttpException();
}
}
private function applyAnswerOrdering(BankQuestion $bankQuestion): void
{
$ordering = 1;
foreach ($bankQuestion->answers as $answer) {
$answer->ordering = $ordering++;
}
}
private function syncUsagesAfterEdit(BankQuestion $bankQuestion): void
{
$pendingNames = [];
$synced = false;
foreach ($bankQuestion->usages as $usage) {
if (!$usage->quiz->isLocked) {
$this->questionBankService->syncToQuiz($bankQuestion, $usage);
$synced = true;
} else {
$pendingNames[] = $usage->quiz->name;
}
}
if ($synced) {
$this->em->flush();
}
if ([] !== $pendingNames) {
$this->addFlash(
FlashType::Warning,
$this->translator->trans(
'The question was not synced to finalized quiz(zes): %quizzes%. Use the Sync button to update them.',
['%quizzes%' => implode(', ', $pendingNames)],
),
);
}
}
}
src/Controller/Backoffice/QuizController.php
+77 -8
View File
@@ -5,6 +5,7 @@ declare(strict_types=1);
namespace Tvdt\Controller\Backoffice;
use Doctrine\ORM\EntityManagerInterface;
use Safe\DateTimeImmutable;
use Symfony\Component\HttpFoundation\RedirectResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
@@ -22,6 +23,7 @@ use Tvdt\Entity\Question;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\QuizCandidate;
use Tvdt\Entity\Season;
use Tvdt\Enum\FlashType;
use Tvdt\Exception\ErrorClearingQuizException;
use Tvdt\Repository\QuizCandidateRepository;
use Tvdt\Repository\QuizRepository;
@@ -154,7 +156,13 @@ class QuizController extends AbstractController
public function answerMapping(Season $season, Quiz $quiz): Response
{
$fetchedQuiz = $this->quizRepository->fetchWithQuestions($quiz->id);
\assert($fetchedQuiz->questions->count() > 0);
if ($fetchedQuiz->questions->isEmpty()) {
$this->addFlash(FlashType::Warning, $this->translator->trans('This quiz has no questions yet'));
return $this->redirectToRoute('tvdt_backoffice_quiz_overview', ['seasonCode' => $season->seasonCode, 'quiz' => $quiz->id]);
}
$firstQuestion = $fetchedQuiz->questions->first();
\assert($firstQuestion instanceof Question);
@@ -233,7 +241,7 @@ class QuizController extends AbstractController
$this->em->flush();
$this->addFlash('success', $this->translator->trans('Candidate answers saved'));
$this->addFlash(FlashType::Success, $this->translator->trans('Candidate answers saved'));
return $this->redirectToRoute('tvdt_backoffice_quiz_candidates_question', [
'seasonCode' => $season->seasonCode,
@@ -250,13 +258,28 @@ class QuizController extends AbstractController
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'quiz' => Requirement::UUID.'|null'],
methods: ['POST'],
)]
public function enableQuiz(Season $season, ?Quiz $quiz): RedirectResponse
public function enableQuiz(Season $season, ?Quiz $quiz, Request $request): RedirectResponse
{
if ($quiz instanceof Quiz && !$quiz->isFinalized) {
$this->addFlash(FlashType::Danger, $this->translator->trans('The quiz must be finalized before it can be activated'));
return $this->redirectToRoute('tvdt_backoffice_quiz_overview', ['seasonCode' => $season->seasonCode, 'quiz' => $quiz->id]);
}
$season->activeQuiz = $quiz;
$this->em->flush();
if ($quiz instanceof Quiz) {
return $this->redirectToRoute('tvdt_backoffice_quiz', ['seasonCode' => $season->seasonCode, 'quiz' => $quiz->id]);
return $this->redirectToRoute('tvdt_backoffice_quiz_overview', ['seasonCode' => $season->seasonCode, 'quiz' => $quiz->id]);
}
// When deactivating, stay on the quiz page if one was passed
$previousQuizId = $request->request->getString('redirect_quiz');
if ('' !== $previousQuizId) {
$previousQuiz = $this->em->getRepository(Quiz::class)->find($previousQuizId);
if ($previousQuiz instanceof Quiz && $previousQuiz->season === $season) {
return $this->redirectToRoute('tvdt_backoffice_quiz_overview', ['seasonCode' => $season->seasonCode, 'quiz' => $previousQuiz->id]);
}
}
return $this->redirectToRoute('tvdt_backoffice_season', ['seasonCode' => $season->seasonCode]);
@@ -274,9 +297,55 @@ class QuizController extends AbstractController
{
try {
$this->quizRepository->clearQuiz($quiz);
$this->addFlash('success', $this->translator->trans('Quiz cleared'));
$this->addFlash(FlashType::Success, $this->translator->trans('Quiz cleared and no longer finalized'));
} catch (ErrorClearingQuizException) {
$this->addFlash('error', $this->translator->trans('Error clearing quiz'));
$this->addFlash(FlashType::Danger, $this->translator->trans('Error clearing quiz'));
}
return $this->redirectToRoute('tvdt_backoffice_quiz', ['seasonCode' => $quiz->season->seasonCode, 'quiz' => $quiz->id]);
}
#[IsCsrfTokenValid('finalize_quiz')]
#[IsGranted(SeasonVoter::EDIT, subject: 'quiz')]
#[Route(
'/backoffice/quiz/{quiz}/finalize',
name: 'tvdt_backoffice_quiz_finalize',
requirements: ['quiz' => Requirement::UUID],
methods: ['POST'],
)]
public function finalizeQuiz(Quiz $quiz): RedirectResponse
{
if ($quiz->questions->isEmpty() || [] !== $quiz->getQuestionErrors()) {
$this->addFlash(FlashType::Warning, $this->translator->trans('The quiz cannot be finalized while it has errors'));
} elseif (!$quiz->isFinalized) {
$quiz->finalizedAt = new DateTimeImmutable();
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Quiz finalized'));
} else {
$this->addFlash(FlashType::Warning, $this->translator->trans('The quiz is already finalized'));
}
return $this->redirectToRoute('tvdt_backoffice_quiz', ['seasonCode' => $quiz->season->seasonCode, 'quiz' => $quiz->id]);
}
#[IsCsrfTokenValid('unfinalize_quiz')]
#[IsGranted(SeasonVoter::EDIT, subject: 'quiz')]
#[Route(
'/backoffice/quiz/{quiz}/unfinalize',
name: 'tvdt_backoffice_quiz_unfinalize',
requirements: ['quiz' => Requirement::UUID],
methods: ['POST'],
)]
public function unfinalizeQuiz(Quiz $quiz): RedirectResponse
{
if ($quiz->hasStartedCandidates) {
$this->addFlash(FlashType::Danger, $this->translator->trans('The quiz has already been filled in and can no longer be altered'));
} elseif ($quiz->season->activeQuiz === $quiz) {
$this->addFlash(FlashType::Danger, $this->translator->trans('Deactivate the quiz before undoing the finalization'));
} else {
$quiz->finalizedAt = null;
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Quiz is no longer finalized'));
}
return $this->redirectToRoute('tvdt_backoffice_quiz', ['seasonCode' => $quiz->season->seasonCode, 'quiz' => $quiz->id]);
@@ -294,7 +363,7 @@ class QuizController extends AbstractController
{
$this->quizRepository->deleteQuiz($quiz);
$this->addFlash('success', $this->translator->trans('Quiz deleted'));
$this->addFlash(FlashType::Success, $this->translator->trans('Quiz deleted'));
return $this->redirectToRoute('tvdt_backoffice_season', ['seasonCode' => $quiz->season->seasonCode]);
}
@@ -359,7 +428,7 @@ class QuizController extends AbstractController
$this->em->flush();
$this->addFlash('success', $this->translator->trans('Candidate status updated'));
$this->addFlash(FlashType::Success, $this->translator->trans('Candidate status updated'));
return $this->redirectToRoute('tvdt_backoffice_quiz_candidates_tab', ['seasonCode' => $quiz->season->seasonCode, 'quiz' => $quiz->id]);
}
src/Controller/Backoffice/QuizQuestionController.php
+75
View File
@@ -0,0 +1,75 @@
<?php
declare(strict_types=1);
namespace Tvdt\Controller\Backoffice;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Attribute\AsController;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Routing\Requirement\Requirement;
use Symfony\Component\Security\Http\Attribute\IsGranted;
use Symfony\Contracts\Translation\TranslatorInterface;
use Tvdt\Controller\AbstractController;
use Tvdt\Entity\Question;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\Season;
use Tvdt\Enum\FlashType;
use Tvdt\Form\QuestionFormType;
use Tvdt\Security\Voter\SeasonVoter;
#[AsController]
#[IsGranted('ROLE_USER')]
class QuizQuestionController extends AbstractController
{
public function __construct(
private readonly EntityManagerInterface $em,
private readonly TranslatorInterface $translator,
) {}
#[IsGranted(SeasonVoter::MODIFY_QUIZ_CONTENT, subject: 'question')]
#[Route(
'/backoffice/season/{seasonCode:season}/quiz/{quiz}/question/{question}/edit',
name: 'tvdt_backoffice_quiz_question_edit',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX, 'quiz' => Requirement::UUID, 'question' => Requirement::UUID],
)]
public function edit(Season $season, Quiz $quiz, Question $question, Request $request): Response
{
if ($question->quiz !== $quiz || $quiz->season !== $season) {
throw new NotFoundHttpException();
}
$form = $this->createForm(QuestionFormType::class, $question);
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
$this->applyAnswerOrdering($question);
$this->em->flush();
$this->addFlash(FlashType::Success, $this->translator->trans('Question updated'));
return $this->redirectToRoute('tvdt_backoffice_quiz_overview', [
'seasonCode' => $season->seasonCode,
'quiz' => $quiz->id,
]);
}
return $this->render('backoffice/quiz/question_form.html.twig', [
'season' => $season,
'quiz' => $quiz,
'question' => $question,
'form' => $form,
]);
}
private function applyAnswerOrdering(Question $question): void
{
$ordering = 1;
foreach ($question->answers as $answer) {
$answer->ordering = $ordering++;
}
}
}
src/Controller/Backoffice/SeasonController.php
+92 -2
View File
@@ -4,13 +4,19 @@ declare(strict_types=1);
namespace Tvdt\Controller\Backoffice;
use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormError;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Attribute\AsController;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;
use Symfony\Component\Validator\Constraints\Length;
use Symfony\Component\Validator\Constraints\NotBlank;
use Symfony\Contracts\Translation\TranslatorInterface;
use Tvdt\Controller\AbstractController;
use Tvdt\Entity\Candidate;
@@ -39,7 +45,39 @@ class SeasonController extends AbstractController
name: 'tvdt_backoffice_season',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
)]
public function index(Season $season, Request $request): Response
public function index(Season $season): Response
{
return $this->render('backoffice/season.html.twig', [
'season' => $season,
'activeTab' => 'tests',
'template' => 'backoffice/season/tab_tests.html.twig',
]);
}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/candidates',
name: 'tvdt_backoffice_season_candidates',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
priority: 10,
)]
public function candidatesTab(Season $season): Response
{
return $this->render('backoffice/season.html.twig', [
'season' => $season,
'activeTab' => 'candidates',
'template' => 'backoffice/season/tab_candidates.html.twig',
]);
}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/settings',
name: 'tvdt_backoffice_season_settings',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
priority: 10,
)]
public function settingsTab(Season $season, Request $request): Response
{
$form = $this->createForm(SettingsForm::class, $season->settings);
@@ -47,11 +85,15 @@ class SeasonController extends AbstractController
if ($form->isSubmitted() && $form->isValid()) {
$this->em->flush();
return $this->redirectToRoute('tvdt_backoffice_season_settings', ['seasonCode' => $season->seasonCode]);
}
return $this->render('backoffice/season.html.twig', [
'season' => $season,
'form' => $form,
'activeTab' => 'settings',
'template' => 'backoffice/season/tab_settings.html.twig',
]);
}
@@ -78,7 +120,7 @@ class SeasonController extends AbstractController
return $this->redirectToRoute('tvdt_backoffice_season', ['seasonCode' => $season->seasonCode]);
}
return $this->render('backoffice/season_add_candidates.html.twig', ['form' => $form]);
return $this->render('backoffice/season_add_candidates.html.twig', ['form' => $form, 'season' => $season]);
}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
@@ -112,4 +154,52 @@ class SeasonController extends AbstractController
return $this->render('/backoffice/quiz_add.html.twig', ['form' => $form, 'season' => $season]);
}
#[IsGranted(SeasonVoter::EDIT, subject: 'season')]
#[Route(
'/backoffice/season/{seasonCode:season}/add-blank-quiz',
name: 'tvdt_backoffice_quiz_add_blank',
requirements: ['seasonCode' => self::SEASON_CODE_REGEX],
priority: 10,
)]
public function addBlankQuiz(Request $request, Season $season): Response
{
$form = $this->createFormBuilder(new Quiz())
->add('name', TextType::class, [
'label' => $this->translator->trans('Quiz name'),
'translation_domain' => false,
'constraints' => [
new NotBlank(),
new Length(max: 64),
],
])
->add('save', SubmitType::class, ['label' => 'Create'])
->getForm();
$form->handleRequest($request);
if ($form->isSubmitted() && $form->isValid()) {
/** @var Quiz $quiz */
$quiz = $form->getData();
$quiz->season = $season;
$this->em->persist($quiz);
try {
$this->em->flush();
} catch (UniqueConstraintViolationException) {
$form->get('name')->addError(new FormError($this->translator->trans('A quiz with this name already exists in this season')));
return $this->render('/backoffice/quiz_add_blank.html.twig', ['form' => $form, 'season' => $season]);
}
$this->addFlash(FlashType::Success, $this->translator->trans('Quiz Added!'));
return $this->redirectToRoute('tvdt_backoffice_quiz_overview', [
'seasonCode' => $season->seasonCode,
'quiz' => $quiz->id,
]);
}
return $this->render('/backoffice/quiz_add_blank.html.twig', ['form' => $form, 'season' => $season]);
}
}
src/Controller/RegistrationController.php
+2 -1
View File
@@ -19,6 +19,7 @@ use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Contracts\Translation\TranslatorInterface;
use SymfonyCasts\Bundle\VerifyEmail\Exception\VerifyEmailExceptionInterface;
use Tvdt\Entity\User;
use Tvdt\Enum\FlashType;
use Tvdt\Form\RegistrationFormType;
use Tvdt\Repository\UserRepository;
use Tvdt\Security\EmailVerifier;
@@ -95,7 +96,7 @@ final class RegistrationController extends AbstractController
return $this->redirectToRoute('tvdt_register');
}
$this->addFlash('success', $this->translator->trans('Your email address has been verified.'));
$this->addFlash(FlashType::Success->value, $this->translator->trans('Your email address has been verified.'));
return $this->redirectToRoute('tvdt_backoffice_index');
}
src/DataFixtures/DevFixtures.php
+35
View File
@@ -0,0 +1,35 @@
<?php
declare(strict_types=1);
namespace Tvdt\DataFixtures;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Bundle\FixturesBundle\FixtureGroupInterface;
use Doctrine\Persistence\ObjectManager;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Tvdt\Entity\User;
final class DevFixtures extends Fixture implements FixtureGroupInterface
{
public function __construct(
private readonly UserPasswordHasherInterface $passwordHasher,
) {}
public static function getGroups(): array
{
return ['dev'];
}
public function load(ObjectManager $manager): void
{
$user = new User();
$user->email = 'admin@tijdvoordetest.nl';
$user->password = $this->passwordHasher->hashPassword($user, '12345678');
$user->roles = ['ROLE_ADMIN'];
$manager->persist($user);
$manager->flush();
}
}
src/DataFixtures/KrtekFixtures.php
+68 -1
View File
@@ -7,9 +7,14 @@ namespace Tvdt\DataFixtures;
use Doctrine\Bundle\FixturesBundle\Fixture;
use Doctrine\Bundle\FixturesBundle\FixtureGroupInterface;
use Doctrine\Persistence\ObjectManager;
use Safe\DateTimeImmutable;
use Tvdt\Entity\Answer;
use Tvdt\Entity\BankAnswer;
use Tvdt\Entity\BankQuestion;
use Tvdt\Entity\BankQuestionUsage;
use Tvdt\Entity\Candidate;
use Tvdt\Entity\Question;
use Tvdt\Entity\QuestionLabel;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\Season;
use Tvdt\Entity\SeasonSettings;
@@ -18,6 +23,16 @@ final class KrtekFixtures extends Fixture implements FixtureGroupInterface
{
public const string KRTEK_SEASON = 'krtek-seaspm';
public const string KRTEK_QUIZ_1 = 'krtek-quiz-1';
public const string KRTEK_QUIZ_2 = 'krtek-quiz-2';
public const string BANK_QUESTION_REUSABLE = 'bank-question-reusable';
public const string BANK_QUESTION_USED = 'bank-question-used';
public const string BANK_QUESTION_UNUSED = 'bank-question-unused';
public static function getGroups(): array
{
return ['test', 'dev'];
@@ -47,16 +62,68 @@ final class KrtekFixtures extends Fixture implements FixtureGroupInterface
$quiz1 = $this->createQuiz1($season);
$season->addQuiz($quiz1);
$season->activeQuiz = $quiz1;
$season->addQuiz($this->createQuiz2($season));
$quiz1->finalizedAt = new DateTimeImmutable();
$quiz2 = $this->createQuiz2($season);
$season->addQuiz($quiz2);
\assert($season->settings instanceof SeasonSettings);
$season->settings->confirmAnswers = true;
$season->settings->showNumbers = true;
$this->createQuestionBank($season, $quiz2);
$manager->flush();
$this->addReference(self::KRTEK_SEASON, $season);
$this->addReference(self::KRTEK_QUIZ_1, $quiz1);
$this->addReference(self::KRTEK_QUIZ_2, $quiz2);
}
private function createQuestionBank(Season $season, Quiz $usedInQuiz): void
{
$location = new QuestionLabel('Locatie');
$location->slug = 'locatie';
$season->addQuestionLabel($location);
$finale = new QuestionLabel('Finale');
$finale->slug = 'finale';
$season->addQuestionLabel($finale);
$reusable = new BankQuestion();
$reusable->question = 'Wie is de Krtek?';
$reusable->reusable = true;
$reusable->addLabel($finale);
$reusable->addAnswer(new BankAnswer('Claudia', true));
$reusable->addAnswer(new BankAnswer('Eelco'));
$reusable->addAnswer(new BankAnswer('Elise'));
$season->addBankQuestion($reusable);
$used = new BankQuestion();
$used->question = 'Waar sliep de Krtek?';
$used->addLabel($location);
$used->addAnswer(new BankAnswer('Boven', true));
$used->addAnswer(new BankAnswer('Beneden'));
$used->addUsage(new BankQuestionUsage($used, $usedInQuiz));
$season->addBankQuestion($used);
$unused = new BankQuestion();
$unused->question = 'Wat at de Krtek als ontbijt?';
$unused->addLabel($location);
$unused->addLabel($finale);
$unused->addAnswer(new BankAnswer('Brood', true));
$unused->addAnswer(new BankAnswer('Yoghurt'));
$unused->addAnswer(new BankAnswer('Niks'));
$season->addBankQuestion($unused);
$this->addReference(self::BANK_QUESTION_REUSABLE, $reusable);
$this->addReference(self::BANK_QUESTION_USED, $used);
$this->addReference(self::BANK_QUESTION_UNUSED, $unused);
}
private function createQuiz1(Season $season): Quiz
src/Entity/AbstractBaseAnswer.php
+27
View File
@@ -0,0 +1,27 @@
<?php
declare(strict_types=1);
namespace Tvdt\Entity;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
#[ORM\MappedSuperclass]
abstract class AbstractBaseAnswer implements \Stringable
{
#[ORM\Column(type: Types::SMALLINT, options: ['default' => 0])]
public int $ordering = 0;
public function __construct(
#[ORM\Column(length: 255)]
public string $text,
#[ORM\Column]
public bool $isRightAnswer = false,
) {}
public function __toString(): string
{
return $this->text;
}
}
src/Entity/Answer.php
+4 -16
View File
@@ -6,14 +6,13 @@ namespace Tvdt\Entity;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Types\UuidType;
use Symfony\Component\Uid\Uuid;
use Tvdt\Repository\AnswerRepository;
#[ORM\Entity(repositoryClass: AnswerRepository::class)]
class Answer implements \Stringable
class Answer extends AbstractBaseAnswer
{
#[ORM\Column(type: UuidType::NAME)]
#[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
@@ -21,9 +20,6 @@ class Answer implements \Stringable
#[ORM\Id]
public private(set) Uuid $id;
#[ORM\Column(type: Types::SMALLINT, options: ['default' => 0])]
public int $ordering = 0;
#[ORM\JoinColumn(nullable: false)]
#[ORM\ManyToOne(inversedBy: 'answers')]
public Question $question;
@@ -36,12 +32,9 @@ class Answer implements \Stringable
#[ORM\OneToMany(targetEntity: GivenAnswer::class, mappedBy: 'answer', orphanRemoval: true)]
public private(set) Collection $givenAnswers;
public function __construct(
#[ORM\Column(length: 255)]
public string $text,
#[ORM\Column]
public bool $isRightAnswer = false,
) {
public function __construct(string $text, bool $isRightAnswer = false)
{
parent::__construct($text, $isRightAnswer);
$this->candidates = new ArrayCollection();
$this->givenAnswers = new ArrayCollection();
}
@@ -57,9 +50,4 @@ class Answer implements \Stringable
{
$this->candidates->removeElement($candidate);
}
public function __toString(): string
{
return $this->text;
}
}
src/Entity/BankAnswer.php
+26
View File
@@ -0,0 +1,26 @@
<?php
declare(strict_types=1);
namespace Tvdt\Entity;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Types\UuidType;
use Symfony\Component\ObjectMapper\Attribute\Map;
use Symfony\Component\Uid\Uuid;
#[ORM\Entity]
class BankAnswer extends AbstractBaseAnswer
{
#[Map(if: false)]
#[ORM\Column(type: UuidType::NAME)]
#[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
#[ORM\GeneratedValue(strategy: 'CUSTOM')]
#[ORM\Id]
public private(set) Uuid $id;
#[Map(if: false)]
#[ORM\JoinColumn(nullable: false)]
#[ORM\ManyToOne(inversedBy: 'answers')]
public BankQuestion $bankQuestion;
}
src/Entity/BankQuestion.php
+147
View File
@@ -0,0 +1,147 @@
<?php
declare(strict_types=1);
namespace Tvdt\Entity;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;
use Symfony\Bridge\Doctrine\Types\UuidType;
use Symfony\Component\ObjectMapper\Attribute\Map;
use Symfony\Component\Uid\Uuid;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Validator\Context\ExecutionContextInterface;
use Tvdt\Repository\BankQuestionRepository;
#[Gedmo\Loggable(logEntryClass: LogEntry::class)]
#[ORM\Entity(repositoryClass: BankQuestionRepository::class)]
class BankQuestion implements \Stringable
{
#[Map(if: false)]
#[ORM\Column(type: UuidType::NAME)]
#[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
#[ORM\GeneratedValue(strategy: 'CUSTOM')]
#[ORM\Id]
public private(set) Uuid $id;
#[Gedmo\Versioned]
#[ORM\Column(length: 255)]
public string $question;
#[Map(if: false)]
#[ORM\JoinColumn(nullable: false)]
#[ORM\ManyToOne(inversedBy: 'bankQuestions')]
public Season $season;
#[Gedmo\Versioned]
#[Map(if: false)]
#[ORM\Column(options: ['default' => false])]
public bool $reusable = false;
/** @var Collection<int, QuestionLabel> */
#[Map(if: false)]
#[ORM\ManyToMany(targetEntity: QuestionLabel::class, inversedBy: 'bankQuestions')]
public private(set) Collection $labels;
/** @var Collection<int, BankAnswer> */
#[Map(if: false)]
#[ORM\OneToMany(targetEntity: BankAnswer::class, mappedBy: 'bankQuestion', cascade: ['persist'], orphanRemoval: true)]
#[ORM\OrderBy(['ordering' => 'ASC'])]
public private(set) Collection $answers;
/** @var Collection<int, BankQuestionUsage> */
#[Map(if: false)]
#[ORM\OneToMany(targetEntity: BankQuestionUsage::class, mappedBy: 'bankQuestion', cascade: ['persist'], orphanRemoval: true)]
public private(set) Collection $usages;
public function __construct()
{
$this->labels = new ArrayCollection();
$this->answers = new ArrayCollection();
$this->usages = new ArrayCollection();
}
public function addAnswer(BankAnswer $answer): static
{
if (!$this->answers->contains($answer)) {
$this->answers->add($answer);
$answer->bankQuestion = $this;
}
return $this;
}
public function removeAnswer(BankAnswer $answer): static
{
$this->answers->removeElement($answer);
return $this;
}
public function addLabel(QuestionLabel $label): static
{
if (!$this->labels->contains($label)) {
$this->labels->add($label);
}
return $this;
}
public function removeLabel(QuestionLabel $label): static
{
$this->labels->removeElement($label);
return $this;
}
public function addUsage(BankQuestionUsage $usage): static
{
if (!$this->usages->contains($usage)) {
$this->usages->add($usage);
}
return $this;
}
public bool $isUsed {
get => !$this->usages->isEmpty();
}
public bool $canBeAssigned {
get => $this->reusable || !$this->isUsed;
}
/** True when the question is fully complete and can be assigned to a quiz. */
public bool $isCompleteForQuiz {
get => $this->answers->count() >= 2
&& 1 === $this->answers->filter(static fn (BankAnswer $answer): bool => $answer->isRightAnswer)->count();
}
public function isUsedInQuiz(Quiz $quiz): bool
{
return $this->usages->exists(static fn (int $key, BankQuestionUsage $usage): bool => $usage->quiz === $quiz);
}
#[Assert\Callback]
public function validateAnswers(ExecutionContextInterface $context): void
{
if ($this->answers->isEmpty()) {
return;
}
$this->answers->filter(static fn (BankAnswer $answer): bool => $answer->isRightAnswer)->count();
if ($this->answers->count() < 2) {
$context->buildViolation('A question needs at least two answers')
->atPath('answers')
->addViolation();
}
}
public function __toString(): string
{
return $this->question;
}
}
src/Entity/BankQuestionUsage.php
+40
View File
@@ -0,0 +1,40 @@
<?php
declare(strict_types=1);
namespace Tvdt\Entity;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Mapping\Annotation as Gedmo;
use Symfony\Bridge\Doctrine\Types\UuidType;
use Symfony\Component\Uid\Uuid;
#[ORM\Entity]
#[ORM\UniqueConstraint(fields: ['bankQuestion', 'quiz'])]
class BankQuestionUsage
{
#[ORM\Column(type: UuidType::NAME)]
#[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
#[ORM\GeneratedValue(strategy: 'CUSTOM')]
#[ORM\Id]
public private(set) Uuid $id;
#[Gedmo\Timestampable(on: 'create')]
#[ORM\Column(type: Types::DATETIMETZ_IMMUTABLE, nullable: false)]
public private(set) \DateTimeImmutable $created;
#[ORM\JoinColumn(nullable: true, onDelete: 'SET NULL')]
#[ORM\ManyToOne]
public ?Question $question = null;
public function __construct(
#[ORM\JoinColumn(nullable: false)]
#[ORM\ManyToOne(inversedBy: 'usages')]
public private(set) BankQuestion $bankQuestion,
#[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
#[ORM\ManyToOne]
public private(set) Quiz $quiz,
) {}
}
src/Entity/LogEntry.php
+29
View File
@@ -0,0 +1,29 @@
<?php
declare(strict_types=1);
namespace Tvdt\Entity;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Gedmo\Loggable\Entity\MappedSuperclass\AbstractLogEntry;
use Gedmo\Loggable\Entity\Repository\LogEntryRepository;
/**
* Custom LogEntry that stores change data as JSON (instead of serialized `array`)
* so it works with the PostgreSQL-only DBAL setup in this project.
*
* @extends AbstractLogEntry<object>
*/
#[ORM\Entity(repositoryClass: LogEntryRepository::class)]
#[ORM\Index(name: 'log_class_lookup_idx', columns: ['object_class'])]
#[ORM\Index(name: 'log_date_lookup_idx', columns: ['logged_at'])]
#[ORM\Index(name: 'log_user_lookup_idx', columns: ['username'])]
#[ORM\Index(name: 'log_version_lookup_idx', columns: ['object_id', 'object_class', 'version'])]
#[ORM\Table(name: 'ext_log_entries')]
class LogEntry extends AbstractLogEntry
{
#[ORM\Column(type: Types::JSON, nullable: true)]
#[\Override]
protected $data;
}
src/Entity/QuestionLabel.php
+51
View File
@@ -0,0 +1,51 @@
<?php
declare(strict_types=1);
namespace Tvdt\Entity;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Types\UuidType;
use Symfony\Component\Uid\Uuid;
use Tvdt\Enum\LabelColour;
use Tvdt\Repository\QuestionLabelRepository;
#[ORM\Entity(repositoryClass: QuestionLabelRepository::class)]
#[ORM\UniqueConstraint(fields: ['name', 'season'])]
#[ORM\UniqueConstraint(name: 'uq_question_label_slug_season', fields: ['slug', 'season'])]
class QuestionLabel implements \Stringable
{
#[ORM\Column(type: UuidType::NAME)]
#[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
#[ORM\GeneratedValue(strategy: 'CUSTOM')]
#[ORM\Id]
public private(set) Uuid $id;
#[ORM\JoinColumn(nullable: false)]
#[ORM\ManyToOne(inversedBy: 'questionLabels')]
public Season $season;
/** @var Collection<int, BankQuestion> */
#[ORM\ManyToMany(targetEntity: BankQuestion::class, mappedBy: 'labels')]
public private(set) Collection $bankQuestions;
#[ORM\Column(length: 16, enumType: LabelColour::class, options: ['default' => 'secondary'])]
public LabelColour $colour = LabelColour::Gray;
#[ORM\Column(length: 64)]
public string $slug = '';
public function __construct(
#[ORM\Column(length: 64)]
public string $name,
) {
$this->bankQuestions = new ArrayCollection();
}
public function __toString(): string
{
return $this->name;
}
}
src/Entity/Quiz.php
+17
View File
@@ -6,6 +6,7 @@ namespace Tvdt\Entity;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Types\UuidType;
use Symfony\Component\Uid\Uuid;
@@ -40,6 +41,9 @@ class Quiz
#[ORM\Column(nullable: false, options: ['default' => 1])]
public int $dropouts = 1;
#[ORM\Column(type: Types::DATETIMETZ_IMMUTABLE, nullable: true)]
public ?\DateTimeImmutable $finalizedAt = null;
/** @var Collection<int, Elimination> */
#[ORM\OneToMany(targetEntity: Elimination::class, mappedBy: 'quiz', cascade: ['persist'], orphanRemoval: true)]
#[ORM\OrderBy(['createdAt' => 'DESC'])]
@@ -62,6 +66,19 @@ class Quiz
return $this;
}
public bool $isFinalized {
get => $this->finalizedAt instanceof \DateTimeImmutable;
}
public bool $hasStartedCandidates {
get => $this->candidateData->exists(static fn (int $key, QuizCandidate $quizCandidate): bool => $quizCandidate->started instanceof \DateTimeImmutable);
}
/** A locked quiz can no longer be altered: it is either explicitly finalized or a candidate has already started filling it in. */
public bool $isLocked {
get => $this->isFinalized || $this->hasStartedCandidates;
}
public function addElimination(Elimination $elimination): self
{
$this->eliminations->add($elimination);
src/Entity/Season.php
+32
View File
@@ -51,12 +51,24 @@ class Season
#[ORM\OneToOne(cascade: ['persist', 'remove'])]
public ?SeasonSettings $settings = null;
/** @var Collection<int, BankQuestion> */
#[ORM\OneToMany(targetEntity: BankQuestion::class, mappedBy: 'season', cascade: ['persist'], orphanRemoval: true)]
#[ORM\OrderBy(['question' => 'ASC'])]
public private(set) Collection $bankQuestions;
/** @var Collection<int, QuestionLabel> */
#[ORM\OneToMany(targetEntity: QuestionLabel::class, mappedBy: 'season', cascade: ['persist'], orphanRemoval: true)]
#[ORM\OrderBy(['name' => 'ASC'])]
public private(set) Collection $questionLabels;
public function __construct()
{
$this->settings = new SeasonSettings();
$this->quizzes = new ArrayCollection();
$this->candidates = new ArrayCollection();
$this->owners = new ArrayCollection();
$this->bankQuestions = new ArrayCollection();
$this->questionLabels = new ArrayCollection();
}
public function addQuiz(Quiz $quiz): static
@@ -79,6 +91,26 @@ class Season
return $this;
}
public function addBankQuestion(BankQuestion $bankQuestion): static
{
if (!$this->bankQuestions->contains($bankQuestion)) {
$this->bankQuestions->add($bankQuestion);
$bankQuestion->season = $this;
}
return $this;
}
public function addQuestionLabel(QuestionLabel $questionLabel): static
{
if (!$this->questionLabels->contains($questionLabel)) {
$this->questionLabels->add($questionLabel);
$questionLabel->season = $this;
}
return $this;
}
public function addOwner(User $owner): static
{
if (!$this->owners->contains($owner)) {
src/Enum/LabelColour.php
+31
View File
@@ -0,0 +1,31 @@
<?php
declare(strict_types=1);
namespace Tvdt\Enum;
use Symfony\Component\Translation\TranslatableMessage;
enum LabelColour: string
{
case Blue = 'primary';
case Gray = 'secondary';
case Green = 'success';
case Red = 'danger';
case Yellow = 'warning';
case Cyan = 'info';
case White = 'light';
public function label(): TranslatableMessage
{
return match ($this) {
self::Blue => new TranslatableMessage('Blue'),
self::Gray => new TranslatableMessage('Gray'),
self::Green => new TranslatableMessage('Green'),
self::Red => new TranslatableMessage('Red'),
self::Yellow => new TranslatableMessage('Yellow'),
self::Cyan => new TranslatableMessage('Cyan'),
self::White => new TranslatableMessage('White'),
};
}
}
src/Exception/BankQuestionAlreadyUsedException.php
+7
View File
@@ -0,0 +1,7 @@
<?php
declare(strict_types=1);
namespace Tvdt\Exception;
class BankQuestionAlreadyUsedException extends \Exception {}
src/Exception/BankQuestionIncompleteException.php
+7
View File
@@ -0,0 +1,7 @@
<?php
declare(strict_types=1);
namespace Tvdt\Exception;
class BankQuestionIncompleteException extends \Exception {}
src/Exception/QuizLockedException.php
+7
View File
@@ -0,0 +1,7 @@
<?php
declare(strict_types=1);
namespace Tvdt\Exception;
class QuizLockedException extends \Exception {}
src/Form/AbstractBaseAnswerFormType.php
+34
View File
@@ -0,0 +1,34 @@
<?php
declare(strict_types=1);
namespace Tvdt\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
use Symfony\Component\Form\Extension\Core\Type\HiddenType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
/**
* @template TAnswer of object
*
* @extends AbstractType<TAnswer>
*/
abstract class AbstractBaseAnswerFormType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options): void
{
$builder
->add('ordering', HiddenType::class, ['empty_data' => '0'])
->add('text', TextType::class, [
'label' => false,
'attr' => ['placeholder' => 'Answer', 'maxlength' => 255],
])
->add('isRightAnswer', CheckboxType::class, [
'label' => 'Correct',
'required' => false,
])
;
}
}
src/Form/AnswerFormType.php
+20
View File
@@ -0,0 +1,20 @@
<?php
declare(strict_types=1);
namespace Tvdt\Form;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Tvdt\Entity\Answer;
/** @extends AbstractBaseAnswerFormType<Answer> */
class AnswerFormType extends AbstractBaseAnswerFormType
{
public function configureOptions(OptionsResolver $resolver): void
{
$resolver->setDefaults([
'data_class' => Answer::class,
'empty_data' => static fn (): Answer => new Answer(''),
]);
}
}
src/Form/BankAnswerFormType.php
+20
View File
@@ -0,0 +1,20 @@
<?php
declare(strict_types=1);
namespace Tvdt\Form;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Tvdt\Entity\BankAnswer;
/** @extends AbstractBaseAnswerFormType<BankAnswer> */
class BankAnswerFormType extends AbstractBaseAnswerFormType
{
public function configureOptions(OptionsResolver $resolver): void
{
$resolver->setDefaults([
'data_class' => BankAnswer::class,
'empty_data' => static fn (): BankAnswer => new BankAnswer(''),
]);
}
}
src/Form/BankQuestionFormType.php
+75
View File
@@ -0,0 +1,75 @@
<?php
declare(strict_types=1);
namespace Tvdt\Form;
use Doctrine\ORM\QueryBuilder;
use Symfony\Bridge\Doctrine\Form\Type\EntityType;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Tvdt\Entity\BankQuestion;
use Tvdt\Entity\QuestionLabel;
use Tvdt\Entity\Season;
use Tvdt\Repository\QuestionLabelRepository;
/** @extends AbstractType<BankQuestion> */
class BankQuestionFormType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options): void
{
/** @var Season $season */
$season = $options['season'];
$builder
->add('question', TextType::class, [
'label' => 'Question',
'attr' => ['maxlength' => 255],
])
->add('reusable', CheckboxType::class, [
'label' => 'Reusable',
'required' => false,
'label_attr' => ['class' => 'checkbox-switch'],
'attr' => ['role' => 'switch', 'switch' => null],
])
->add('labels', EntityType::class, [
'label' => 'Labels',
'class' => QuestionLabel::class,
'multiple' => true,
'expanded' => true,
'required' => false,
'query_builder' => static fn (QuestionLabelRepository $repository): QueryBuilder => $repository
->createQueryBuilder('l')
->where('l.season = :season')
->orderBy('l.name', 'ASC')
->setParameter('season', $season),
])
->add('answers', CollectionType::class, [
'label' => 'Answers',
'entry_type' => BankAnswerFormType::class,
'entry_options' => ['label' => false],
'allow_add' => true,
'allow_delete' => true,
'by_reference' => false,
'prototype' => true,
])
->add('save', SubmitType::class, [
'label' => 'Save',
])
;
}
public function configureOptions(OptionsResolver $resolver): void
{
$resolver->setDefaults([
'data_class' => BankQuestion::class,
]);
$resolver->setRequired('season');
$resolver->setAllowedTypes('season', Season::class);
}
}
src/Form/QuestionFormType.php
+46
View File
@@ -0,0 +1,46 @@
<?php
declare(strict_types=1);
namespace Tvdt\Form;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CollectionType;
use Symfony\Component\Form\Extension\Core\Type\SubmitType;
use Symfony\Component\Form\Extension\Core\Type\TextType;
use Symfony\Component\Form\FormBuilderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Tvdt\Entity\Question;
/** @extends AbstractType<Question> */
class QuestionFormType extends AbstractType
{
public function buildForm(FormBuilderInterface $builder, array $options): void
{
$builder
->add('question', TextType::class, [
'label' => 'Question',
'attr' => ['maxlength' => 255],
])
->add('answers', CollectionType::class, [
'label' => 'Answers',
'entry_type' => AnswerFormType::class,
'entry_options' => ['label' => false],
'allow_add' => true,
'allow_delete' => true,
'by_reference' => false,
'prototype' => true,
])
->add('save', SubmitType::class, [
'label' => 'Save',
])
;
}
public function configureOptions(OptionsResolver $resolver): void
{
$resolver->setDefaults([
'data_class' => Question::class,
]);
}
}
src/Repository/BankQuestionRepository.php
+71
View File
@@ -0,0 +1,71 @@
<?php
declare(strict_types=1);
namespace Tvdt\Repository;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Tvdt\Entity\BankQuestion;
use Tvdt\Entity\QuestionLabel;
use Tvdt\Entity\Season;
/** @extends ServiceEntityRepository<BankQuestion> */
class BankQuestionRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, BankQuestion::class);
}
/** @return list<BankQuestion> */
public function findBySeason(Season $season, ?QuestionLabel $label = null): array
{
$queryBuilder = $this->createQueryBuilder('bq')
->where('bq.season = :season')
->orderBy('bq.question', 'ASC')
->setParameter('season', $season);
if ($label instanceof QuestionLabel) {
$queryBuilder
->andWhere(':label member of bq.labels')
->setParameter('label', $label);
}
/** @var list<BankQuestion> $questions */
$questions = $queryBuilder->getQuery()->getResult();
if ([] === $questions) {
return [];
}
// Load each many-to-many/one-to-many collection in a separate query to avoid
// the Cartesian-product row explosion that occurs when joining multiple collections at once.
$this->createQueryBuilder('bq')
->select('partial bq.{id}', 'ba')
->leftJoin('bq.answers', 'ba')
->where('bq.season = :season')
->setParameter('season', $season)
->getQuery()
->getResult();
$this->createQueryBuilder('bq')
->select('partial bq.{id}', 'l')
->leftJoin('bq.labels', 'l')
->where('bq.season = :season')
->setParameter('season', $season)
->getQuery()
->getResult();
$this->createQueryBuilder('bq')
->select('partial bq.{id}', 'u', 'uq')
->leftJoin('bq.usages', 'u')
->leftJoin('u.quiz', 'uq')
->where('bq.season = :season')
->setParameter('season', $season)
->getQuery()
->getResult();
return $questions;
}
}
src/Repository/QuestionLabelRepository.php
+39
View File
@@ -0,0 +1,39 @@
<?php
declare(strict_types=1);
namespace Tvdt\Repository;
use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
use Doctrine\Persistence\ManagerRegistry;
use Tvdt\Entity\QuestionLabel;
use Tvdt\Entity\Season;
/** @extends ServiceEntityRepository<QuestionLabel> */
class QuestionLabelRepository extends ServiceEntityRepository
{
public function __construct(ManagerRegistry $registry)
{
parent::__construct($registry, QuestionLabel::class);
}
public function findBySlugAndSeason(string $slug, Season $season): ?QuestionLabel
{
return $this->findOneBy(['slug' => $slug, 'season' => $season]);
}
public function slugExistsForSeason(string $slug, Season $season, ?QuestionLabel $excluding = null): bool
{
$qb = $this->createQueryBuilder('l')
->where('l.slug = :slug')
->andWhere('l.season = :season')
->setParameter('slug', $slug)
->setParameter('season', $season);
if ($excluding instanceof QuestionLabel) {
$qb->andWhere('l.id != :id')->setParameter('id', $excluding->id);
}
return (int) $qb->select('COUNT(l.id)')->getQuery()->getSingleScalarResult() > 0;
}
}
src/Repository/QuizRepository.php
+42 -4
View File
@@ -12,6 +12,7 @@ use Safe\Exceptions\DatetimeException;
use Symfony\Component\Uid\Uuid;
use Tvdt\Dto\Result;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\Season;
use Tvdt\Exception\ErrorClearingQuizException;
/** @extends ServiceEntityRepository<Quiz> */
@@ -22,6 +23,29 @@ class QuizRepository extends ServiceEntityRepository
parent::__construct($registry, Quiz::class);
}
/**
* Quizzes of the season that can still receive bank questions:
* not finalized and not started by any candidate.
*
* @return list<Quiz>
*/
public function findAssignableForSeason(Season $season): array
{
/* @var list<Quiz> */
return $this->getEntityManager()->createQuery(<<<DQL
select q from Tvdt\Entity\Quiz q
where q.season = :season
and q.finalizedAt is null
and not exists (
select 1 from Tvdt\Entity\QuizCandidate qc
where qc.quiz = q and qc.started is not null
)
order by q.id asc
DQL)
->setParameter('season', $season)
->getResult();
}
/** @throws ErrorClearingQuizException */
public function clearQuiz(Quiz $quiz): void
{
@@ -48,6 +72,20 @@ class QuizRepository extends ServiceEntityRepository
DQL)
->setParameter('quiz', $quiz)
->execute();
$em->createQuery(<<<DQL
delete from Tvdt\Entity\BankQuestionUsage bqu
where bqu.quiz = :quiz
DQL)
->setParameter('quiz', $quiz)
->execute();
$em->createQuery(<<<DQL
update Tvdt\Entity\Quiz q set q.finalizedAt = null
where q = :quiz
DQL)
->setParameter('quiz', $quiz)
->execute();
}
// @codeCoverageIgnoreStart
catch (\Throwable $throwable) {
@@ -113,8 +151,8 @@ class QuizRepository extends ServiceEntityRepository
{
return $this->getEntityManager()->createQuery(<<<dql
select q, qz, a from Tvdt\Entity\Quiz q
join q.questions qz
join qz.answers a
left join q.questions qz
left join qz.answers a
where q.id = :id
dql)->setParameter('id', $id)->getSingleResult();
}
@@ -127,8 +165,8 @@ class QuizRepository extends ServiceEntityRepository
{
return $this->getEntityManager()->createQuery(<<<dql
select q, qz, a, ac, s, sc, qc from Tvdt\Entity\Quiz q
join q.questions qz
join qz.answers a
left join q.questions qz
left join qz.answers a
left join a.candidates ac
join q.season s
left join s.candidates sc
src/Security/Voter/SeasonVoter.php
+29 -6
View File
@@ -8,14 +8,16 @@ use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\Voter\Vote;
use Symfony\Component\Security\Core\Authorization\Voter\Voter;
use Tvdt\Entity\Answer;
use Tvdt\Entity\BankQuestion;
use Tvdt\Entity\Candidate;
use Tvdt\Entity\Elimination;
use Tvdt\Entity\Question;
use Tvdt\Entity\QuestionLabel;
use Tvdt\Entity\Quiz;
use Tvdt\Entity\Season;
use Tvdt\Entity\User;
/** @extends Voter<string, Season|Elimination|Quiz|Candidate|Answer|Question> */
/** @extends Voter<string, Season|Elimination|Quiz|Candidate|Answer|Question|BankQuestion|QuestionLabel> */
final class SeasonVoter extends Voter
{
public const string EDIT = 'SEASON_EDIT';
@@ -24,15 +26,19 @@ final class SeasonVoter extends Voter
public const string DELETE = 'SEASON_DELETE';
public const string MODIFY_QUIZ_CONTENT = 'QUIZ_MODIFY_CONTENT';
protected function supports(string $attribute, mixed $subject): bool
{
return \in_array($attribute, [self::EDIT, self::DELETE, self::ELIMINATION], true)
return \in_array($attribute, [self::EDIT, self::DELETE, self::ELIMINATION, self::MODIFY_QUIZ_CONTENT], true)
&& (
$subject instanceof Answer
|| $subject instanceof BankQuestion
|| $subject instanceof Candidate
|| $subject instanceof Elimination
|| $subject instanceof Season
|| $subject instanceof Question
|| $subject instanceof QuestionLabel
|| $subject instanceof Quiz
);
}
@@ -44,19 +50,36 @@ final class SeasonVoter extends Voter
return false;
}
if ($user->isAdmin) {
return true;
}
$season = match (true) {
$subject instanceof Answer => $subject->question->quiz->season,
$subject instanceof Elimination,
$subject instanceof Question => $subject->quiz->season,
$subject instanceof BankQuestion,
$subject instanceof Candidate,
$subject instanceof QuestionLabel,
$subject instanceof Quiz => $subject->season,
$subject instanceof Season => $subject,
};
if (self::MODIFY_QUIZ_CONTENT === $attribute) {
$quiz = match (true) {
$subject instanceof Answer => $subject->question->quiz,
$subject instanceof Question => $subject->quiz,
$subject instanceof Quiz => $subject,
default => null,
};
if (!$quiz instanceof Quiz || $quiz->isLocked) {
return false;
}
return $user->isAdmin || $season->isOwner($user);
}
if ($user->isAdmin) {
return true;
}
return match ($attribute) {
self::EDIT, self::DELETE, self::ELIMINATION => $season->isOwner($user),
default => false,
src/Service/QuestionBankService.php
+121
View File
@@ -0,0 +1,121 @@
<?php
declare(strict_types=1);
namespace Tvdt\Service;
use Doctrine\DBAL\LockMode;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\ObjectMapper\ObjectMapperInterface;
use Tvdt\Entity\Answer;
use Tvdt\Entity\BankQuestion;
use Tvdt\Entity\BankQuestionUsage;
use Tvdt\Entity\Question;
use Tvdt\Entity\Quiz;
use Tvdt\Exception\BankQuestionAlreadyUsedException;
use Tvdt\Exception\BankQuestionIncompleteException;
use Tvdt\Exception\QuizLockedException;
final readonly class QuestionBankService
{
public function __construct(
private EntityManagerInterface $entityManager,
private ObjectMapperInterface $objectMapper,
) {}
/**
* Copy a bank question (with its answers) into a quiz and record the usage.
*
* @throws QuizLockedException when the quiz is finalized or already filled in
* @throws BankQuestionAlreadyUsedException when the question is single-use and used, or already in this quiz
* @throws BankQuestionIncompleteException when the question lacks ≥2 answers or a correct answer
*/
public function assignToQuiz(BankQuestion $bankQuestion, Quiz $quiz): void
{
if ($bankQuestion->season !== $quiz->season) {
throw new \InvalidArgumentException('Bank question and quiz belong to different seasons');
}
if ($quiz->isLocked) {
throw new QuizLockedException();
}
if (!$bankQuestion->isCompleteForQuiz) {
throw new BankQuestionIncompleteException();
}
$this->entityManager->wrapInTransaction(function () use ($bankQuestion, $quiz): void {
// Pessimistic write lock serialises concurrent assignment attempts for the same BankQuestion
$this->entityManager->lock($bankQuestion, LockMode::PESSIMISTIC_WRITE);
if (!$bankQuestion->canBeAssigned || $bankQuestion->isUsedInQuiz($quiz)) {
throw new BankQuestionAlreadyUsedException();
}
$maxOrdering = 0;
foreach ($quiz->questions as $existingQuestion) {
$maxOrdering = max($maxOrdering, $existingQuestion->ordering);
}
/** @var Question $question */
$question = $this->objectMapper->map($bankQuestion, Question::class);
$question->ordering = $maxOrdering + 1;
foreach ($bankQuestion->answers as $bankAnswer) {
/** @var Answer $answer */
$answer = $this->objectMapper->map($bankAnswer, Answer::class);
$question->addAnswer($answer);
}
$quiz->addQuestion($question);
$usage = new BankQuestionUsage($bankQuestion, $quiz);
$usage->question = $question;
$bankQuestion->addUsage($usage);
$this->entityManager->persist($question);
$this->entityManager->flush();
});
}
/**
* Propagate bank question edits to a quiz copy.
* Only safe on quizzes where no candidate has started (no GivenAnswers exist yet).
*/
public function syncToQuiz(BankQuestion $bankQuestion, BankQuestionUsage $usage): void
{
$question = $usage->question;
if (!$question instanceof Question) {
return;
}
$question->question = $bankQuestion->question;
// Replace answers (safe: no started candidates means no GivenAnswers)
foreach ($question->answers->toArray() as $existingAnswer) {
$question->answers->removeElement($existingAnswer);
$this->entityManager->remove($existingAnswer);
}
foreach ($bankQuestion->answers as $bankAnswer) {
/** @var Answer $answer */
$answer = $this->objectMapper->map($bankAnswer, Answer::class);
$question->addAnswer($answer);
}
}
/** Remove the quiz copy created by this usage and delete the usage record. */
public function unassignFromQuiz(BankQuestionUsage $usage): void
{
$question = $usage->question;
if ($question instanceof Question) {
$question->quiz->questions->removeElement($question);
$this->entityManager->remove($question);
}
$usage->bankQuestion->usages->removeElement($usage);
$this->entityManager->remove($usage);
$this->entityManager->flush();
}
}