Skip to content

Beautiful Open-Source Form Builder

9.8 KB
Raw Blame
<?php

namespace App\Http\Controllers\Forms;

use App\Http\Controllers\Controller;
use App\Http\Requests\AnswerFormRequest;
use App\Models\Forms\Form;
use App\Models\Forms\FormSubmission;
use App\Http\Resources\FormResource;
use App\Http\Resources\FormSubmissionResource;
use App\Jobs\Form\StoreFormSubmissionJob;
use App\Service\Forms\Analytics\UserAgentHelper;
use App\Service\Forms\FormSubmissionProcessor;
use App\Service\Forms\FormCleaner;
use App\Service\Forms\SubmissionUrlService;
use App\Service\Storage\SafeFileResponseService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class PublicFormController extends Controller
{
    public function show(Request $request, Form $form)
    {
        // Ensure form is public or closed
        if (!in_array($form->visibility, ['public', 'closed'])) {
            abort(404);
        }
        if ($form->workspace == null) {
            // Workspace deleted
            return $this->error([
                'message' => 'Form not found.',
            ], 404);
        }

        $formCleaner = new FormCleaner();

        // Disable pro features if needed
        $form->fill(
            $formCleaner
                ->processForm($request, $form)
                ->performCleaning($form->workspace)
                ->getData()
        );

        return (new FormResource($form))
            ->setCleanings($formCleaner->getPerformedCleanings());
    }

    public function view(Request $request, Form $form)
    {
        // Ensure form is public
        if ($form->visibility !== 'public') {
            abort(404);
        }

        if ($form->workspace == null) {
            return $this->error([
                'message' => 'Form not found.',
            ], 404);
        }

        if (Auth::check()) {
            return $this->success([
                'message' => 'Form viewed by logged in user.',
            ]);
        }

        // Increment view count and store metadata for analytics
        $userAgent = new UserAgentHelper($request);
        $form->views()->create(['meta' => $userAgent->getMetadata()]);

        return $this->success([
            'message' => 'Form viewed.',
        ]);
    }

    public function showAsset(string $assetFileName, SafeFileResponseService $safeFileResponseService)
    {
        $path = FormController::ASSETS_UPLOAD_PATH . '/' . $assetFileName;
        if (!Storage::exists($path)) {
            return $this->error([
                'message' => 'File not found.',
                'file_name' => $assetFileName,
            ]);
        }

        return $safeFileResponseService->serve($path, $assetFileName);
    }

    /**
     * Handle partial form submissions
     *
     * @param array $submissionData
     * @return \Illuminate\Http\JsonResponse
     */
    private function handlePartialSubmissions(array $submissionData, Form $form)
    {
        // Validate that at least one field has a value
        $hasValue = false;
        foreach ($submissionData as $key => $value) {
            if (Str::isUuid($key) && !empty($value)) {
                $hasValue = true;
                break;
            }
        }
        if (!$hasValue) {
            return $this->error([
                'message' => 'At least one field must have a value for partial submissions.'
            ], 422);
        }

        $submissionData['is_partial'] = true;
        $job = new StoreFormSubmissionJob($form, $submissionData);
        $job->handle();

        return $this->success([
            'message' => 'Partial submission saved',
            'submission_hash' => SubmissionUrlService::getSubmissionIdentifierById($form, $job->getSubmissionId())
        ]);
    }

    public function answer(AnswerFormRequest $request, Form $form, FormSubmissionProcessor $formSubmissionProcessor)
    {
        // Check if user can answer this form
        $this->authorize('answer', $form);

        $isFirstSubmission = ($form->submissions_count === 0);

        // Check for partial submission flag early (before validation)
        $isPartial = $request->boolean('is_partial');
        $canPartialSubmit = $form->enable_partial_submissions && $form->workspace->hasFeature('partial_submissions');
        $isPartialSubmission = $isPartial && $canPartialSubmit;

        // Use raw data for partial submissions (don't validate all required fields)
        // Use validated data for complete submissions
        $submissionData = $isPartialSubmission
            ? $request->all()
            : $request->validated();

        // Process submission hash and ID
        $submissionData = $this->processSubmissionIdentifiers($request, $submissionData, $form);

        // Add IP address for tracking if enabled
        unset($submissionData['submitter_ip']);
        if ($form->enable_ip_tracking && $form->workspace->hasFeature('enable_ip_tracking')) {
            $submissionData['submitter_ip'] = $request->ip();
        }

        // Handle partial submissions
        if ($isPartialSubmission) {
            return $this->handlePartialSubmissions($submissionData, $form);
        }

        // Create the job with all data (including metadata)
        $job = new StoreFormSubmissionJob($form, $submissionData);

        // Process the submission
        if ($formSubmissionProcessor->shouldProcessSynchronously($form)) {
            $job->handle();

            $submission = $form->submissions()->findOrFail($job->getSubmissionId());
            $encodedSubmissionId = SubmissionUrlService::getSubmissionIdentifier($submission);

            // Only the completed submission response grants its respondent a download URL.
            // The owner-only signed-URL endpoint remains authenticated.
            if ($form->pdf_download_enabled) {
                $template = $form->pdfTemplates()->find($form->pdf_template_id);
                if ($template) {
                    $pdfDownloadUrl = SubmissionUrlService::buildPdfDownloadUrl($form, $template, $submission);
                }
            }

            // Update submission data with generated values for redirect URL
            $submissionData = $job->getProcessedData();
        } else {
            dispatch($job);
        }

        // Return the response
        return $this->success(array_merge([
            'message' => 'Form submission saved.',
            'submission_id' => $encodedSubmissionId ?? null,
            'pdf_download_url' => $pdfDownloadUrl ?? null,
            'is_first_submission' => $isFirstSubmission,
        ], $formSubmissionProcessor->getRedirectData($form, $submissionData)));
    }

    /**
     * Processes submission identifiers to ensure consistent format
     *
     * Handles UUID submission identifiers and converts them to internal numeric IDs.
     *
     * @param Request $request
     * @param array $submissionData
     * @param Form $form
     * @return array
     */
    private function processSubmissionIdentifiers(Request $request, array $submissionData, Form $form): array
    {
        $submissionIdentifier = $request->get('submission_hash')
            ?? $request->get('submission_id')
            ?? ($submissionData['submission_id'] ?? null);

        if (!$submissionIdentifier) {
            return $submissionData;
        }

        // Only resolve identifiers when the form permits edits or partial draft updates
        $canEditSubmissions = $form->editable_submissions
            && $form->workspace
            && $form->workspace->hasFeature('editable_submissions');
        $canPartialSubmit = $form->enable_partial_submissions
            && $form->workspace
            && $form->workspace->hasFeature('partial_submissions');

        if (!$canEditSubmissions && !$canPartialSubmit) {
            unset($submissionData['submission_id'], $submissionData['submission_hash']);

            return $submissionData;
        }

        $canUseResolvedSubmission = function (?FormSubmission $submission) use ($canEditSubmissions, $canPartialSubmit): bool {
            if ($canEditSubmissions) {
                return true;
            }

            return $canPartialSubmit && $submission?->status === FormSubmission::STATUS_PARTIAL;
        };

        if (!Str::isUuid($submissionIdentifier)) {
            abort(404, 'Submission not found');
        }

        $submission = $form->submissions()
            ->where('public_id', $submissionIdentifier)
            ->first();
        if (!$submission) {
            abort(404, 'Submission not found');
        }
        if (!$canUseResolvedSubmission($submission)) {
            unset($submissionData['submission_id'], $submissionData['submission_hash']);

            return $submissionData;
        }
        $submissionData['submission_id'] = $submission->id;
        unset($submissionData['submission_hash']);

        return $submissionData;
    }

    public function fetchSubmission(Request $request, Form $form, string $submission_id)
    {
        // Ensure form is public and allows editable submissions
        if ($form->visibility !== 'public') {
            abort(404);
        }
        if ($form->workspace == null || !$form->editable_submissions
            || !$form->workspace->hasFeature(\App\Service\Billing\Feature::EDITABLE_SUBMISSIONS)) {
            abort(403);
        }

        if (!Str::isUuid($submission_id)) {
            return $this->error([
                'message' => 'Submission not found.',
            ], 404);
        }

        $submission = $form->submissions()
            ->where('public_id', $submission_id)
            ->first();

        if (!$submission) {
            return $this->error([
                'message' => 'Submission not found.',
            ], 404);
        }

        $submission->setRelation('form', $form);
        $resource = new FormSubmissionResource($submission);
        $resource->publiclyAccessed();

        return $this->success($resource->toArray($request));
    }
}