Serialization of 'Illuminate\\Http\\UploadedFile' is not allowed"

See:

https://laracasts.com/discuss/channels/laravel/serialization-of-illuminatehttpuploadedfile-is-not-allowed-on-queue

public function makeRequest($request, $template_id) { DB::beginTransaction();

    try {
        $template = $this->template::findOrFail($template_id);

        // Create a new submission
        $submission = $this->answerSubmission::create([
            'request_management_id' => $template->id,
            'department_id' => Auth::user()->department,
            'user_id' => Auth::user()->id,
        ]);

        if ($template->template_type == null) {
            $rules = [
                'answers' => 'required|array',
                'answers.*.question_id' => 'required|exists:request_management_questions,id'
            ];

            foreach ($template->questions as $index => $question) {
                $rule = [];

                if ($question->required) {
                    $rule[] = 'required';
                } else {
                    $rule[] = 'nullable';
                }

                switch ($question->type) {
                    case 'file':
                        if (isset($question->file['maximum_no_of_files'])) {
                            $rule[] = 'max:' . $question->file['maximum_no_of_files'];
                        }
                        if (isset($question->file['file_size'])) {
                            $rule[] = 'max:' . ($question->file['file_size'] * 1024); // Convert MB to KB
                        }
                        break;
                }

                $rules['answers.' . $index . '.answer'] = $rule;
            }

            $validatedData = $request->validate($rules);

            $processedAnswers = [];
            $uploadedFileUrls = [];

            foreach ($validatedData['answers'] as $index => $answerData) {
                $questionId = $answerData['question_id'];
                $answerValue = $answerData['answer'];

                $question = $template->questions->where('id', $questionId)->first();

                if ($question->type == 'file' && $request->hasFile("answers.{$index}.answer")) {
                    $fileInputs = $request->file("answers.{$index}.answer");

                    foreach ($fileInputs as $fileInput) {
                        if ($fileInput && $fileInput->isValid()) {
                            $uploadedFilePath = $fileInput->store('public/uploads'); // Store locally
                            $uploadedFileUrl = Storage::url($uploadedFilePath);   // Get file URL
                            $uploadedFileUrls[] = $uploadedFileUrl;
                        } else {
                            $processedAnswers['errors'][] = "File upload error for question_id: {$questionId}.";
                        }
                    }

                    $processedAnswers[$questionId] = $uploadedFileUrls;
                } else {
                    $processedAnswers[$questionId] = $answerValue;
                }

                $this->saveAnswers($processedAnswers[$questionId], $template, $submission, $questionId);
            }
        }

        // Check if the template type is 'expense-report'
        if ($template->template_type === 'expense-report') {
            $this->expenseReport($request, $submission, $template);
        }

        $emailSent = false;
        $authorizationLevels = $template->authorization_levels;

        // Loop through authorization levels
        for ($i = 1; $i <= $template->no_of_auth_levels; $i++) {
            $levelKey = 'level' . $i;
            $authorizer = isset($authorizationLevels[$levelKey]) ? $authorizationLevels[$levelKey] : null;
            $approverId = self::getAuthorizersId($authorizer);

            $this->requestApproval::create([
                'request_management_answer_submission_id' => $submission->id,
                'level' => $i,
                'status' => 'pending',
                'approver_id' => is_array($approverId) ? $approverId['user_id'] : $approverId
            ]);

            // Send approver email if approver exists and email hasn't been sent yet
            if (!$emailSent && $approverId) {
                $approverEmail = is_array($approverId)
                    ? $this->user::find($approverId['approver_id'])->contactInformation->primary_email
                    : $this->user::find($approverId)->contactInformation->primary_email;

                if ($approverEmail) {
                    Mail::to($approverEmail)->send(new ApproveRequestEmail($submission->id));  // Use send() to avoid queuing
                    $emailSent = true;
                }
            }
        }

        // Send user notification email after approval setup
        $userEmail = $this->user::find(Auth::user()->id)->contactInformation->primary_email;
        Mail::to($userEmail)->send(new UserRequestEmail($submission->id));

        DB::commit();
    } catch (\Exception $e) {
        DB::rollBack();
        // Handle exception (log or rethrow)
        throw $e;
    }
}

here is the updated code.

"Serialization of 'Illuminate\Http\UploadedFile' is not allowed"