unsupervised-scheduler/src/Registration/QuestionController.php

<?php
declare(strict_types=1);

namespace Unsupervised\Schedular\Registration;

use Unsupervised\Schedular\Auth\RoleManager;
use Unsupervised\Schedular\Offering\Offering;
use Unsupervised\Schedular\Offering\OfferingRepository;
use Unsupervised\Schedular\Val;

class QuestionController {

	public function __construct(
		private QuestionRepository $questions,
		private OfferingRepository $offerings,
	) {}

	public function renderPage(): void {
		if ( ! current_user_can( RoleManager::CAP_MANAGE_QUESTIONS ) ) {
			wp_die( esc_html__( 'You do not have permission to manage questions.', 'unsupervised-schedular' ) );
		}

		$userId    = get_current_user_id();
		$manageAll = current_user_can( RoleManager::CAP_MANAGE_INSTRUCTORS );

		// The selector posts either an offering id or the sentinel `account`.
		// Account-signup questions are studio-wide, so only studio admins manage them.
		// phpcs:ignore WordPress.Security.NonceVerification.Recommended -- read-only selector.
		$selection    = sanitize_text_field( Val::string( wp_unslash( $_GET['offering_id'] ?? '' ) ) );
		$accountScope = $manageAll && Question::SCOPE_ACCOUNT === $selection;

		$offeringId       = $accountScope ? 0 : absint( Val::int( $selection ) );
		$offeringList     = $manageAll ? $this->offerings->findAll() : $this->offerings->findAll( $userId );
		$selectedOffering = $offeringId > 0 ? $this->offerings->findById( $offeringId ) : null;

		if ( null !== $selectedOffering && ! $this->canManageOffering( $selectedOffering, $userId, $manageAll ) ) {
			$selectedOffering = null;
		}

		$questions = null;
		if ( $accountScope ) {
			if ( isset( $_POST['usc_action'] ) && check_admin_referer( 'usc_question_action' ) ) {
				$this->handleFormAction( null );
			}

			$questions = $this->questions->findByScope( Question::SCOPE_ACCOUNT );
		} elseif ( null !== $selectedOffering ) {
			if ( isset( $_POST['usc_action'] ) && check_admin_referer( 'usc_question_action' ) ) {
				$this->handleFormAction( $selectedOffering );
			}

			$questions = $this->questions->findByOffering( (int) $selectedOffering->id );
		}

		include USC_PLUGIN_DIR . 'templates/admin/questions.php';
	}

	/**
	 * Handle an add/delete action for the given context: an offering, or account
	 * scope when $offering is null.
	 */
	private function handleFormAction( ?Offering $offering ): void {
		// Nonce is verified by the caller (renderPage) before this method runs.
		// phpcs:disable WordPress.Security.NonceVerification.Missing
		$action = sanitize_key( Val::string( wp_unslash( $_POST['usc_action'] ?? '' ) ) );

		if ( 'add' === $action ) {
			$this->addQuestion( $offering );
		}

		if ( 'delete' === $action ) {
			$questionId = absint( Val::int( $_POST['question_id'] ?? 0 ) );
			if ( $questionId > 0 ) {
				$question = $this->questions->findById( $questionId );
				if ( $question && $this->belongsToContext( $question, $offering ) ) {
					$this->questions->delete( $questionId );
				}
			}
		}
		// phpcs:enable WordPress.Security.NonceVerification.Missing
	}

	private function addQuestion( ?Offering $offering ): void {
		// phpcs:disable WordPress.Security.NonceVerification.Missing
		$label     = sanitize_text_field( Val::string( wp_unslash( $_POST['label'] ?? '' ) ) );
		$fieldType = sanitize_key( Val::string( wp_unslash( $_POST['field_type'] ?? Question::FIELD_TEXT ) ) );

		if ( '' === $label || mb_strlen( $label ) > Question::MAX_LABEL_LENGTH || ! in_array( $fieldType, Question::VALID_FIELD_TYPES, true ) ) {
			return;
		}

		// Audience and the students' own required-ness are asked for on the
		// account-scope form only; an offering's questions are answered once about
		// the student being booked, so there is no second audience to differ from.
		// An offering question therefore mirrors its single "required" into both
		// columns rather than storing a distinction it does not have.
		$accountScope = null === $offering;
		$audience     = sanitize_key( Val::string( wp_unslash( $_POST['audience'] ?? '' ) ) );

		$this->questions->insert(
			new Question(
				offeringId:      $accountScope ? null : (int) $offering->id,
				label:           $label,
				fieldType:       $fieldType,
				options:         $this->parseOptions( sanitize_textarea_field( Val::string( wp_unslash( $_POST['options'] ?? '' ) ) ) ),
				isRequired:      isset( $_POST['is_required'] ),
				sortOrder:       absint( Val::int( $_POST['sort_order'] ?? 0 ) ),
				scope:           $accountScope ? Question::SCOPE_ACCOUNT : Question::SCOPE_OFFERING,
				audience:        $accountScope && in_array( $audience, Question::VALID_AUDIENCES, true ) ? $audience : Question::AUDIENCE_ALL,
				isRequiredChild: $accountScope ? isset( $_POST['is_required_child'] ) : isset( $_POST['is_required'] ),
			)
		);
		// phpcs:enable WordPress.Security.NonceVerification.Missing
	}

	/**
	 * Whether a question belongs to the current editing context — the given
	 * offering, or account scope when $offering is null.
	 */
	private function belongsToContext( Question $question, ?Offering $offering ): bool {
		if ( null === $offering ) {
			return Question::SCOPE_ACCOUNT === $question->scope;
		}

		return $question->offeringId === (int) $offering->id;
	}

	private function canManageOffering( Offering $offering, int $userId, bool $manageAll ): bool {
		return $manageAll || $offering->instructorId === $userId;
	}

	/**
	 * Parse a newline-separated textarea into a list of option strings.
	 *
	 * @return list<string>|null
	 */
	private function parseOptions( string $raw ): ?array {
		$lines   = preg_split( '/\r\n|\r|\n/', $raw );
		$options = array_values(
			array_filter(
				array_map(
					static fn( string $line ): string => sanitize_text_field( trim( $line ) ),
					false === $lines ? [] : $lines
				)
			)
		);

		return [] === $options ? null : $options;
	}
}