feat: enable entering additional remarks in offer confirmation

tests/Controller/Groups/OfferControllerTest.php

@@ -8,6 +8,7 @@ use App\Controller\Groups\OfferController;
 use App\Entity\Groups\Accommodation;
 use App\Entity\Groups\AccommodationBooking;
 use App\Enum\Groups\AccommodationBookingStatus;
+use App\Form\Model\OfferAcceptDto;
 use App\Repository\Groups\AccommodationBookingRepository;
 use App\Service\AccommodationBookingBreakdownCalculator;
 use App\Service\AccommodationBookingLinkSigner;
@@ -208,6 +209,7 @@ class OfferControllerTest extends TestCase
     {
         $booking = new AccommodationBooking();
         $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setRemarks("Bitte Zimmer im EG\nDanke!");
 
         $bookingRepository = $this->createMock(AccommodationBookingRepository::class);
         $bookingRepository->method('findOneBy')->with(['uuid' => $booking->getUuid()])->willReturn($booking);
@@ -233,12 +235,17 @@ class OfferControllerTest extends TestCase
         self::assertSame('groups/booking/_offer_accept_confirmation_modal.html.twig', $controller->renderedView);
         self::assertSame($booking, $controller->renderedParameters['booking']);
         self::assertSame($confirmationForm, $controller->renderedParameters['confirmationForm']);
+
+        self::assertInstanceOf(OfferAcceptDto::class, $controller->formData);
+        self::assertSame("Bitte Zimmer im EG\nDanke!", $controller->formData->remarks, 'the stored remark is prefilled into the modal');
+        self::assertFalse($controller->formData->termsAccepted);
     }
 
     public function testConfirmPostValidAcceptsBookingAndRedirects(): void
     {
         $booking = new AccommodationBooking();
         $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setRemarks('Bitte Zimmer im EG');
 
         $bookingRepository = $this->createMock(AccommodationBookingRepository::class);
         $bookingRepository->method('findOneBy')->willReturn($booking);
@@ -247,7 +254,7 @@ class OfferControllerTest extends TestCase
         $linkSigner->method('isSessionAuthorized')->willReturn(true);
 
         $bookingService = $this->createMock(AccommodationBookingService::class);
-        $bookingService->expects(self::once())->method('acceptBooking')->with($booking);
+        $bookingService->expects(self::once())->method('acceptBooking')->with($booking, 'Bitte Zimmer im EG');
 
         $confirmationForm = $this->createMock(FormInterface::class);
         $confirmationForm->method('handleRequest')->willReturnSelf();
@@ -282,7 +289,8 @@ class OfferControllerTest extends TestCase
         $linkSigner->method('isSessionAuthorized')->willReturn(true);
 
         $bookingService = $this->createMock(AccommodationBookingService::class);
-        $bookingService->expects(self::once())->method('acceptBooking')->with($booking);
+        // No remark on the booking and none submitted: the empty string clears rather than keeps.
+        $bookingService->expects(self::once())->method('acceptBooking')->with($booking, '');
 
         $confirmationForm = $this->createMock(FormInterface::class);
         $confirmationForm->method('handleRequest')->willReturnSelf();
@@ -412,6 +420,8 @@ final class TestableOfferController extends OfferController
     /** @var array<string, mixed> */
     public array $renderedParameters = [];
 
+    public mixed $formData = null;
+
     public function __construct(
         AccommodationBookingRepository $bookingRepository,
         AccommodationBookingLinkSigner $linkSigner,
@@ -430,6 +440,8 @@ final class TestableOfferController extends OfferController
 
     protected function createForm(string $type, mixed $data = null, array $options = []): FormInterface
     {
+        $this->formData = $data;
+
         return $this->confirmationForm ?? throw new \LogicException('No confirmation form mock configured for this test.');
     }
 

tests/Form/Admin/Groups/AccommodationBookingCreateTypeTest.php

@@ -0,0 +1,109 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Form\Admin\Groups;
+
+use App\Entity\Groups\AccommodationBooking;
+use App\Enum\Groups\AccommodationBookingStatus;
+use App\Form\Admin\Groups\AccommodationBookingCreateType;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Form\FormInterface;
+use Symfony\Component\OptionsResolver\OptionsResolver;
+use Symfony\Component\Validator\Constraints\Email;
+use Symfony\Component\Validator\Constraints\EmailValidator;
+use Symfony\Component\Validator\ConstraintValidatorFactory;
+use Symfony\Component\Validator\Validation;
+
+class AccommodationBookingCreateTypeTest extends TestCase
+{
+    public function testDraftsAreValidatedWithoutTheOfferGroup(): void
+    {
+        self::assertSame(['Default'], $this->resolveValidationGroups(AccommodationBookingStatus::Draft));
+    }
+
+    public function testOffersAddTheOfferGroup(): void
+    {
+        self::assertSame(['Default', 'offer'], $this->resolveValidationGroups(AccommodationBookingStatus::Open));
+    }
+
+    public function testDraftCanBeCreatedWithoutAnEmail(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Draft);
+
+        $violations = $this->validate($booking, $this->resolveValidationGroups(AccommodationBookingStatus::Draft));
+
+        self::assertCount(0, $violations);
+    }
+
+    public function testOfferCannotBeCreatedWithoutAnEmail(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+
+        $violations = $this->validate($booking, $this->resolveValidationGroups(AccommodationBookingStatus::Open));
+
+        $properties = array_map(static fn ($violation) => $violation->getPropertyPath(), iterator_to_array($violations));
+
+        self::assertSame(['email'], $properties, 'only the address is enforced here — the rest of the contact data belongs to the edit form');
+    }
+
+    public function testOfferRejectsAMalformedEmail(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setEmail('not-an-address');
+
+        $violations = $this->validate($booking, $this->resolveValidationGroups(AccommodationBookingStatus::Open));
+
+        self::assertCount(1, $violations);
+        self::assertSame('email', $violations[0]->getPropertyPath());
+    }
+
+    public function testOfferWithAnEmailIsValid(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setEmail('[email protected]');
+
+        $violations = $this->validate($booking, $this->resolveValidationGroups(AccommodationBookingStatus::Open));
+
+        self::assertCount(0, $violations);
+    }
+
+    /**
+     * @return string[]
+     */
+    private function resolveValidationGroups(AccommodationBookingStatus $status): array
+    {
+        $resolver = new OptionsResolver();
+        (new AccommodationBookingCreateType())->configureOptions($resolver);
+
+        $booking = new AccommodationBooking();
+        $booking->setStatus($status);
+
+        $form = $this->createMock(FormInterface::class);
+        $form->method('getData')->willReturn($booking);
+
+        return ($resolver->resolve()['validation_groups'])($form);
+    }
+
+    /**
+     * @param string[] $groups
+     */
+    private function validate(AccommodationBooking $booking, array $groups): \Symfony\Component\Validator\ConstraintViolationListInterface
+    {
+        // The app configures email_validation_mode: html5 globally (config/packages/validator.yaml);
+        // the standalone builder would otherwise fall back to the deprecated "loose" mode.
+        $validatorFactory = new ConstraintValidatorFactory([
+            EmailValidator::class => new EmailValidator(Email::VALIDATION_MODE_HTML5),
+        ]);
+
+        return Validation::createValidatorBuilder()
+            ->enableAttributeMapping()
+            ->setConstraintValidatorFactory($validatorFactory)
+            ->getValidator()
+            ->validate($booking, null, $groups);
+    }
+}

tests/Form/Model/OfferAcceptDtoTest.php

@@ -0,0 +1,54 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Tests\Form\Model;
+
+use App\Form\Model\OfferAcceptDto;
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Validator\Validation;
+use Symfony\Component\Validator\Validator\ValidatorInterface;
+
+class OfferAcceptDtoTest extends TestCase
+{
+    public function testAcceptedTermsWithoutRemarksIsValid(): void
+    {
+        $violations = $this->validator()->validate(new OfferAcceptDto(termsAccepted: true));
+
+        self::assertCount(0, $violations);
+    }
+
+    public function testUncheckedTermsAreRejected(): void
+    {
+        $violations = $this->validator()->validate(new OfferAcceptDto(remarks: 'Bitte Zimmer im EG'));
+
+        self::assertCount(1, $violations);
+        self::assertSame('termsAccepted', $violations[0]->getPropertyPath());
+        self::assertSame('Bitte akzeptiere die AGB, um die Buchung abzuschließen.', $violations[0]->getMessage());
+    }
+
+    public function testRemarksAreCappedAt2000Characters(): void
+    {
+        $dto = new OfferAcceptDto(termsAccepted: true, remarks: str_repeat('a', 2001));
+
+        $violations = $this->validator()->validate($dto);
+
+        self::assertCount(1, $violations);
+        self::assertSame('remarks', $violations[0]->getPropertyPath());
+        self::assertSame('Die Anmerkungen dürfen maximal 2000 Zeichen lang sein.', $violations[0]->getMessage());
+    }
+
+    public function testRemarksAtTheLimitAreAccepted(): void
+    {
+        $dto = new OfferAcceptDto(termsAccepted: true, remarks: str_repeat('a', 2000));
+
+        self::assertCount(0, $this->validator()->validate($dto));
+    }
+
+    private function validator(): ValidatorInterface
+    {
+        return Validation::createValidatorBuilder()
+            ->enableAttributeMapping()
+            ->getValidator();
+    }
+}

tests/Service/AccommodationBookingServiceTest.php

@@ -294,6 +294,89 @@ class AccommodationBookingServiceTest extends TestCase
         self::assertNotNull($booking->getAcceptedAt());
     }
 
+    public function testAcceptBookingStoresTrimmedRemarks(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setEmail('[email protected]');
+        $booking->setRemarks('vom Telefonat');
+
+        $service = $this->createServiceWithAccommodation(mailer: $this->createMock(Mailer::class));
+
+        $service->acceptBooking($booking, "  Bitte Zimmer im EG\nund Frühstück um 8  \n");
+
+        self::assertSame("Bitte Zimmer im EG\nund Frühstück um 8", $booking->getRemarks(), 'inner line breaks survive, outer whitespace does not');
+    }
+
+    public function testAcceptBookingClearsRemarksForEmptySubmission(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setEmail('[email protected]');
+        $booking->setRemarks('vom Telefonat');
+
+        $service = $this->createServiceWithAccommodation(mailer: $this->createMock(Mailer::class));
+
+        $service->acceptBooking($booking, '   ');
+
+        self::assertNull($booking->getRemarks(), 'an emptied textarea clears the stored remark');
+    }
+
+    public function testAcceptBookingLeavesRemarksUntouchedWithoutSubmission(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+        $booking->setEmail('[email protected]');
+        $booking->setRemarks('vom Telefonat');
+
+        $service = $this->createServiceWithAccommodation(mailer: $this->createMock(Mailer::class));
+
+        $service->acceptBooking($booking);
+
+        self::assertSame('vom Telefonat', $booking->getRemarks(), 'the API path must not wipe the remark');
+    }
+
+    public function testAcceptBookingDoesNotStoreRemarksWhenOfferIsNotOpen(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Accepted);
+        $booking->setRemarks('vom Telefonat');
+
+        $service = $this->createServiceWithAccommodation(mailer: $this->createMock(Mailer::class));
+
+        $service->acceptBooking($booking, 'zu spät');
+
+        self::assertSame('vom Telefonat', $booking->getRemarks());
+    }
+
+    public function testAcceptBookingSkipsTheCustomerEmailWhenNoAddressIsStored(): void
+    {
+        $booking = new AccommodationBooking();
+        $booking->setStatus(AccommodationBookingStatus::Open);
+
+        // Only the office notification goes out — the customer copy has no recipient.
+        $mailer = $this->createMock(Mailer::class);
+        $mailer
+            ->expects(self::once())
+            ->method('createAndSendEmail')
+            ->with(
+                self::anything(),
+                self::callback(static fn (array $options) => '[email protected]' === $options['to']),
+            );
+
+        $logger = $this->createMock(LoggerInterface::class);
+        $logger
+            ->expects(self::once())
+            ->method('warning')
+            ->with('Failed to send offer accepted customer email', self::anything());
+
+        $service = $this->createServiceWithAccommodation(mailer: $mailer, logger: $logger);
+
+        $service->acceptBooking($booking);
+
+        self::assertSame(AccommodationBookingStatus::Accepted, $booking->getStatus(), 'the acceptance itself must not fail');
+    }
+
     public function testAcceptBookingIsIdempotentAndSendsNoNotifications(): void
     {
         $entityManager = $this->createMock(EntityManagerInterface::class);