bert.hausmans/crewli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

S2a: purge legacy Form Builder PHP code and routes

Browse Source
This commit is contained in:
bert.hausmans
2026-04-17 18:43:00 +02:00
parent cfc7610497
commit a3ca596362
55 changed files with 128 additions and 6057 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
api/app/Http/Controllers/Api/V1/PersonController.php
View File

@@ -19,7 +19,6 @@ use App\Models\Person;
use App\Models\User;
use App\Services\EmailService;
use App\Services\PersonIdentityService;
use App\Services\TagSyncService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Gate;
@@ -34,7 +33,6 @@ final class PersonController extends Controller
public function __construct(
private readonly PersonIdentityService $identityService,
private readonly TagSyncService $tagSyncService,
private readonly EmailService $emailService,
) {}
@@ -188,8 +186,6 @@ final class PersonController extends Controller
$person->save();
}
$this->tagSyncService->syncFromRegistration($person);
if ($person->email) {
$portalUrl = config('app.frontend_portal_url');

48
api/app/Http/Controllers/Api/V1/PersonFieldValueController.php
View File

@@ -1,48 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Controllers\Controller;
use App\Http\Controllers\Api\V1\Traits\VerifiesOrganisationEvent;
use App\Http\Requests\Api\V1\UpsertPersonFieldValuesRequest;
use App\Http\Resources\Api\V1\PersonFieldValueResource;
use App\Models\Event;
use App\Models\Organisation;
use App\Models\Person;
use App\Services\RegistrationFormFieldService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
use Illuminate\Support\Facades\Gate;
final class PersonFieldValueController extends Controller
{
use VerifiesOrganisationEvent;
public function __construct(
private readonly RegistrationFormFieldService $service,
) {}
public function index(Organisation $organisation, Event $event, Person $person): AnonymousResourceCollection
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('view', [$person, $event]);
$values = $this->service->getPersonValues($person);
return PersonFieldValueResource::collection($values);
}
public function upsert(UpsertPersonFieldValuesRequest $request, Organisation $organisation, Event $event, Person $person): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('update', [$person, $event]);
$this->service->upsertPersonValues($person, $request->validated()['values']);
$values = $this->service->getPersonValues($person);
return $this->success(PersonFieldValueResource::collection($values));
}
}

48
api/app/Http/Controllers/Api/V1/PersonSectionPreferenceController.php
View File

@@ -1,48 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Controllers\Controller;
use App\Http\Controllers\Api\V1\Traits\VerifiesOrganisationEvent;
use App\Http\Requests\Api\V1\ReplacePersonSectionPreferencesRequest;
use App\Http\Resources\Api\V1\PersonSectionPreferenceResource;
use App\Models\Event;
use App\Models\Organisation;
use App\Models\Person;
use App\Services\PersonSectionPreferenceService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
use Illuminate\Support\Facades\Gate;
final class PersonSectionPreferenceController extends Controller
{
use VerifiesOrganisationEvent;
public function __construct(
private readonly PersonSectionPreferenceService $service,
) {}
public function index(Organisation $organisation, Event $event, Person $person): AnonymousResourceCollection
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('view', [$person, $event]);
$preferences = $this->service->getPreferences($person);
return PersonSectionPreferenceResource::collection($preferences);
}
public function replace(ReplacePersonSectionPreferencesRequest $request, Organisation $organisation, Event $event, Person $person): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('update', [$person, $event]);
$this->service->replacePreferences($person, $request->validated()['preferences']);
$preferences = $this->service->getPreferences($person);
return $this->success(PersonSectionPreferenceResource::collection($preferences));
}
}

1
api/app/Http/Controllers/Api/V1/PortalMeController.php
View File

@@ -37,7 +37,6 @@ final class PortalMeController extends Controller
'shiftAssignments.shift.festivalSection',
'shiftAssignments.shift.timeSlot',
'volunteerAvailabilities.timeSlot',
'fieldValues.registrationFormField',
'sectionPreferences.festivalSection',
])
->first();

129
api/app/Http/Controllers/Api/V1/PublicRegistrationDataController.php
View File

@@ -1,129 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Controllers\Controller;
use App\Models\Event;
use App\Models\FestivalSection;
use App\Models\PersonTag;
use App\Models\RegistrationFormField;
use App\Models\TimeSlot;
use Illuminate\Http\JsonResponse;
final class PublicRegistrationDataController extends Controller
{
public function __invoke(string $slug): JsonResponse
{
$event = Event::where('slug', $slug)
->where('status', 'registration_open')
->first();
if ($event === null) {
abort(404, 'Event not found or not accepting registrations.');
}
$festivalEvent = $event->isSubEvent() ? $event->parent : $event;
if ($festivalEvent->isFestival() || $festivalEvent->hasChildren()) {
// Festival: get child event sections only (skip parent operational sections)
$childIds = Event::where('parent_event_id', $festivalEvent->id)->pluck('id');
$sections = FestivalSection::whereIn('event_id', $childIds)
->where('show_in_registration', true)
->where('type', 'standard')
->select('id', 'name', 'category', 'icon', 'registration_description')
->orderBy('category')
->orderBy('sort_order')
->get()
->unique('name')
->values();
} else {
// Flat event: all sections of the event
$sections = FestivalSection::where('event_id', $festivalEvent->id)
->where('show_in_registration', true)
->where('type', 'standard')
->select('id', 'name', 'category', 'icon', 'registration_description')
->orderBy('category')
->orderBy('sort_order')
->get();
}
$timeSlots = $festivalEvent->getAllRelevantTimeSlots()
->where('person_type', 'VOLUNTEER')
->values();
$registrationFields = RegistrationFormField::where('event_id', $festivalEvent->id)
->portalVisible()
->ordered()
->get();
$organisationId = $festivalEvent->organisation_id;
return response()->json([
'data' => [
'event' => [
'id' => $festivalEvent->id,
'name' => $festivalEvent->name,
'start_date' => $festivalEvent->start_date->toDateString(),
'end_date' => $festivalEvent->end_date->toDateString(),
'organisation_id' => $organisationId,
'registration_banner_url' => $festivalEvent->registration_banner_url,
'registration_welcome_text' => $festivalEvent->registration_welcome_text,
'registration_logo_url' => $festivalEvent->registration_logo_url,
'registration_show_section_preferences' => (bool) $festivalEvent->registration_show_section_preferences,
'registration_show_availability' => (bool) $festivalEvent->registration_show_availability,
],
'sections' => $sections->map(fn (FestivalSection $section) => [
'id' => $section->id,
'name' => $section->name,
'category' => $section->category,
'icon' => $section->icon,
'registration_description' => $section->registration_description,
]),
'time_slots' => $timeSlots->map(fn (TimeSlot $slot) => [
'id' => $slot->id,
'name' => $slot->name,
'date' => $slot->date->toDateString(),
'start_time' => $slot->start_time,
'end_time' => $slot->end_time,
'duration_hours' => $slot->duration_hours,
]),
'registration_fields' => $registrationFields->map(function (RegistrationFormField $field) use ($organisationId) {
$data = [
'id' => $field->id,
'label' => $field->label,
'slug' => $field->slug,
'field_type' => $field->field_type->value,
'options' => $field->options,
'normalized_options' => $field->normalized_options,
'tag_categories' => $field->tag_categories,
'is_required' => $field->is_required,
'help_text' => $field->help_text,
'display_width' => $field->display_width->value,
];
if ($field->field_type === \App\Enums\RegistrationFieldType::TAG_PICKER) {
$query = PersonTag::where('organisation_id', $organisationId)
->where('is_active', true);
if (!empty($field->tag_categories)) {
$query->whereIn('category', $field->tag_categories);
}
$data['available_tags'] = $query->orderBy('category')->orderBy('sort_order')
->get()
->map(fn (PersonTag $tag) => [
'id' => $tag->id,
'name' => $tag->name,
'category' => $tag->category,
]);
}
return $data;
}),
],
]);
}
}

62
api/app/Http/Controllers/Api/V1/RegistrationFieldTemplateController.php
View File

@@ -1,62 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Controllers\Controller;
use App\Http\Requests\Api\V1\StoreRegistrationFieldTemplateRequest;
use App\Http\Requests\Api\V1\UpdateRegistrationFieldTemplateRequest;
use App\Http\Resources\Api\V1\RegistrationFieldTemplateResource;
use App\Models\Organisation;
use App\Models\RegistrationFieldTemplate;
use App\Services\RegistrationFieldTemplateService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
use Illuminate\Support\Facades\Gate;
final class RegistrationFieldTemplateController extends Controller
{
public function __construct(
private readonly RegistrationFieldTemplateService $service,
) {}
public function index(Organisation $organisation): AnonymousResourceCollection
{
Gate::authorize('viewAny', [RegistrationFieldTemplate::class, $organisation]);
$templates = $this->service->listForOrganisation($organisation);
return RegistrationFieldTemplateResource::collection($templates);
}
public function store(StoreRegistrationFieldTemplateRequest $request, Organisation $organisation): JsonResponse
{
Gate::authorize('create', [RegistrationFieldTemplate::class, $organisation]);
$template = $this->service->createTemplate($organisation, $request->validated());
return $this->created(new RegistrationFieldTemplateResource($template));
}
public function update(
UpdateRegistrationFieldTemplateRequest $request,
Organisation $organisation,
RegistrationFieldTemplate $registrationFieldTemplate,
): JsonResponse {
Gate::authorize('update', [$registrationFieldTemplate, $organisation]);
$template = $this->service->updateTemplate($registrationFieldTemplate, $request->validated());
return $this->success(new RegistrationFieldTemplateResource($template));
}
public function destroy(Organisation $organisation, RegistrationFieldTemplate $registrationFieldTemplate): JsonResponse
{
Gate::authorize('delete', [$registrationFieldTemplate, $organisation]);
$this->service->deleteTemplate($registrationFieldTemplate);
return response()->json(null, 204);
}
}

119
api/app/Http/Controllers/Api/V1/RegistrationFormFieldController.php
View File

@@ -1,119 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Controllers\Controller;
use App\Http\Controllers\Api\V1\Traits\VerifiesOrganisationEvent;
use App\Http\Requests\Api\V1\ImportFromEventRequest;
use App\Http\Requests\Api\V1\ReorderRegistrationFormFieldsRequest;
use App\Http\Requests\Api\V1\StoreRegistrationFormFieldRequest;
use App\Http\Requests\Api\V1\UpdateRegistrationFormFieldRequest;
use App\Http\Resources\Api\V1\RegistrationFormFieldResource;
use App\Models\Event;
use App\Models\Organisation;
use App\Models\RegistrationFieldTemplate;
use App\Models\RegistrationFormField;
use App\Services\RegistrationFieldTemplateService;
use App\Services\RegistrationFormFieldService;
use Illuminate\Http\JsonResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
use Illuminate\Support\Facades\Gate;
final class RegistrationFormFieldController extends Controller
{
use VerifiesOrganisationEvent;
public function __construct(
private readonly RegistrationFormFieldService $service,
private readonly RegistrationFieldTemplateService $templateService,
) {}
public function index(Organisation $organisation, Event $event): AnonymousResourceCollection
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('viewAny', [RegistrationFormField::class, $event]);
$fields = $this->service->listForEvent($event);
return RegistrationFormFieldResource::collection($fields);
}
public function store(StoreRegistrationFormFieldRequest $request, Organisation $organisation, Event $event): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('create', [RegistrationFormField::class, $event]);
$field = $this->service->createField($event, $request->validated());
return $this->created(new RegistrationFormFieldResource($field));
}
public function update(
UpdateRegistrationFormFieldRequest $request,
Organisation $organisation,
Event $event,
RegistrationFormField $registrationField,
): JsonResponse {
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('update', [$registrationField, $event]);
$field = $this->service->updateField($registrationField, $request->validated());
return $this->success(new RegistrationFormFieldResource($field));
}
public function destroy(Organisation $organisation, Event $event, RegistrationFormField $registrationField): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('delete', [$registrationField, $event]);
$this->service->deleteField($registrationField);
return response()->json(null, 204);
}
public function reorder(ReorderRegistrationFormFieldsRequest $request, Organisation $organisation, Event $event): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('reorder', [RegistrationFormField::class, $event]);
$this->service->reorderFields($event, $request->validated()['ids']);
return response()->json(null, 204);
}
public function fromTemplate(Request $request, Organisation $organisation, Event $event): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('create', [RegistrationFormField::class, $event]);
$request->validate([
'template_id' => ['required', 'ulid', 'exists:registration_field_templates,id'],
]);
$template = RegistrationFieldTemplate::findOrFail($request->input('template_id'));
if ($template->organisation_id !== $event->organisation_id) {
return $this->error('Template does not belong to this organisation.', 422);
}
$field = $this->templateService->createFieldFromTemplate($event, $template);
return $this->created(new RegistrationFormFieldResource($field));
}
public function importFromEvent(ImportFromEventRequest $request, Organisation $organisation, Event $event): JsonResponse
{
$this->verifyEventBelongsToOrganisation($organisation, $event);
Gate::authorize('create', [RegistrationFormField::class, $event]);
$sourceEvent = Event::findOrFail($request->validated()['source_event_id']);
$fields = $this->service->importFromEvent($event, $sourceEvent);
return $this->success(RegistrationFormFieldResource::collection($fields));
}
}

42
api/app/Http/Controllers/Api/V1/VolunteerRegistrationController.php
View File

@@ -1,42 +0,0 @@
<?php
declare(strict_types=1);
namespace App\Http\Controllers\Api\V1;
use App\Http\Controllers\Controller;
use App\Http\Requests\Api\V1\VolunteerRegistrationRequest;
use App\Http\Resources\Api\V1\PersonResource;
use App\Models\Event;
use App\Services\VolunteerRegistrationService;
use Illuminate\Http\JsonResponse;
final class VolunteerRegistrationController extends Controller
{
public function __construct(
private readonly VolunteerRegistrationService $registrationService,
) {}
public function __invoke(VolunteerRegistrationRequest $request, Event $event): JsonResponse
{
$user = auth('sanctum')->user();
$person = $this->registrationService->register(
$event,
$request->validated(),
$user
);
$person->load('crowdType');
$responseData = [
'person' => new PersonResource($person),
];
if ($person->wasRecentlyCreated) {
return $this->created($responseData);
}
return $this->success($responseData);
}
}