turnstile

TurnstileSettingsForm.php (7778B)

---

 <?php
 
 namespace Drupal\taler_turnstile\Form;
 
 use Drupal\Core\Form\ConfigFormBase;
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\Core\Config\ConfigFactoryInterface;
 use Drupal\Core\Entity\EntityTypeManagerInterface;
 use Drupal\taler_turnstile\TalerBackendErrorKind;
 use Drupal\taler_turnstile\TurnstileFieldManager;
 use Drupal\taler_turnstile\TalerMerchantApiService;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 
 /**
  * Configure GNU Taler Turnstile settings.
  */
 class TurnstileSettingsForm extends ConfigFormBase {
 
   /**
    * The entity type manager.
    *
    * @var \Drupal\Core\Entity\EntityTypeManagerInterface
    */
   protected $entityTypeManager;
 
   /**
    * The Turnstile field manager.
    *
    * @var \Drupal\taler_turnstile\TurnstileFieldManager
    */
   protected $fieldManager;
 
   /**
    * The Taler Merchant API service.
    *
    * @var \Drupal\taler_turnstile\TalerMerchantApiService
    */
   protected $apiService;
 
   /**
    * Constructs a TurnstileSettingsForm object.
    *
    * @param \Drupal\Core\Config\ConfigFactoryInterface $config_factory
    *   The factory for configuration objects.
    * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
    *   The entity type manager.
    * @param \Drupal\taler_turnstile\TurnstileFieldManager $field_manager
    *   The field manager.
    * @param \Drupal\taler_turnstile\TalerMerchantApiService $api_service
    *   The API service.
    */
   public function __construct(ConfigFactoryInterface $config_factory, EntityTypeManagerInterface $entity_type_manager, TurnstileFieldManager $field_manager, TalerMerchantApiService $api_service) {
     parent::__construct($config_factory);
     $this->entityTypeManager = $entity_type_manager;
     $this->fieldManager = $field_manager;
     $this->apiService = $api_service;
   }
 
   /**
    * {@inheritdoc}
    */
   public static function create(ContainerInterface $container) {
     return new static(
       $container->get('config.factory'),
       $container->get('entity_type.manager'),
       $container->get('taler_turnstile.field_manager'),
       $container->get('taler_turnstile.api_service')
     );
   }
 
   /**
    * {@inheritdoc}
    */
   protected function getEditableConfigNames() {
     return ['taler_turnstile.settings'];
   }
 
   /**
    * {@inheritdoc}
    */
   public function getFormId() {
     return 'taler_turnstile_settings_form';
   }
 
   /**
    * {@inheritdoc}
    */
   public function buildForm(array $form, FormStateInterface $form_state) {
     $config = $this->config('taler_turnstile.settings');
 
     // Get all available content types.
     $content_types = $this->entityTypeManager->getStorage('node_type')->loadMultiple();
     $type_options = [];
     foreach ($content_types as $type) {
       $type_options[$type->id()] = $type->label();
     }
 
     $form['enabled_content_types'] = [
       '#type' => 'checkboxes',
       '#title' => $this->t('Enabled content types'),
       '#description' => $this->t('Select which content types should have the price field and be subject to paywall transformation.'),
       '#options' => $type_options,
       '#default_value' => $config->get('enabled_content_types') ?: [],
     ];
 
     $form['payment_backend_url'] = [
       '#type' => 'url',
       '#title' => $this->t('Payment backend URL'),
       '#description' => $this->t('HTTP URL for the payment backend service.'),
       '#default_value' => $config->get('payment_backend_url') ?: '',
       '#maxlength' => 255,
     ];
 
     $form['access_token'] = [
       '#type' => 'textfield',
       '#title' => $this->t('Access token'),
       '#description' => $this->t('Access token for authenticating with the payment backend.'),
       '#default_value' => $config->get('access_token') ?: '',
       '#maxlength' => 255,
     ];
 
     $form['grant_access_on_error'] = [
       '#type' => 'checkbox',
       '#title' => $this->t('Disable Turnstile when payment backend is unavailable'),
       '#description' => $this->t('Allows users gratis access when Turnstile is unable to communicate with the GNU Taler merchant backend. Use this setting to avoid exposing users to configuration errors.'),
       '#default_value' => $config->get('grant_access_on_error') ?: '',
     ];
 
     return parent::buildForm($form, $form_state);
   }
 
 
   /**
    * {@inheritdoc}
    */
   public function validateForm(array &$form, FormStateInterface $form_state) {
     parent::validateForm($form, $form_state);
     $payment_backend_url = $form_state->getValue('payment_backend_url');
     $access_token = $form_state->getValue('access_token');
 
     // Validate the URL only if one was actually supplied; leaving
     // the backend unconfigured is an intentional path (covered by
     // the "warn but don't block" branch at the bottom).
     if (!empty($payment_backend_url)) {
       if (!str_ends_with($payment_backend_url, '/')) {
         $form_state->setErrorByName('payment_backend_url',
                                     $this->t('Payment backend URL must end with a "/".'));
         return;
       }
       $cfg_result = $this->apiService->checkConfig($payment_backend_url);
       if (!$cfg_result->isOk()) {
         $form_state->setErrorByName(
           'payment_backend_url',
           $cfg_result->toUserMessage($payment_backend_url)
         );
         return;
       }
     }
 
     if ( (!empty($access_token)) &&
          (!str_starts_with($access_token, 'secret-token:')) ) {
       $form_state->setErrorByName('access_token',
                                   $this->t('Access token must begin with a "secret-token:".'));
       return;
     }
 
     // Only verify the access token when both fields are present;
     // otherwise we hit the warn-but-don't-block branch below.
     // AUTH_FAILED is attached to the access_token field; every other
     // failure (unreachable, 5xx, unknown instance, ...) is attached
     // to the URL field.
     if (!empty($payment_backend_url) && !empty($access_token)) {
       $access_result = $this->apiService->checkAccess($payment_backend_url, $access_token);
       if (!$access_result->isOk()) {
         $field = ($access_result->kind === TalerBackendErrorKind::AUTH_FAILED)
           ? 'access_token'
           : 'payment_backend_url';
         $form_state->setErrorByName(
           $field,
           $access_result->toUserMessage($payment_backend_url)
         );
         return;
       }
     }
 
     // If the merchant backend is not configured at all, we allow the user
     // to save the settings. But, we warn them if they did not set
     // grant_access_on_error.
     $grant_access_on_error = $form_state->getValue('grant_access_on_error');
     if ( (! $grant_access_on_error) &&
          (empty($payment_backend_url) ||
           empty($access_token)) ) {
       $this->messenger()->addWarning(
         $this->t('Warning: Merchant backend is not configured correctly. To keep the site working, you probably should set the "Disable Turnstile when payment backend is unavailable" option!'));
       return;
     }
   }
 
   /**
    * {@inheritdoc}
    */
   public function submitForm(array &$form, FormStateInterface $form_state) {
     $config = $this->config('taler_turnstile.settings');
 
     $payment_backend_url = $form_state->getValue('payment_backend_url');
     $access_token = $form_state->getValue('access_token');
     $new_enabled_types = array_values(array_filter($form_state->getValue('enabled_content_types')));
     $grant_access_on_error = $form_state->getValue('grant_access_on_error');
 
     // Save configuration.
     $config->set('enabled_content_types', $new_enabled_types);
     $config->set('payment_backend_url', $payment_backend_url);
     $config->set('access_token', $access_token);
     $config->set('grant_access_on_error', $grant_access_on_error);
     $config->save();
 
     parent::submitForm($form, $form_state);
   }
 }