Results

    $country = $this->getRequest->getCurrentRequest()->query->get('country');
    $state = $this->getRequest->getCurrentRequest()->query->get('state');

    $query = $this->dbConnection->select('dependent_state"', 'st');

    if (!empty($country)) {
      $query = $query->condition('st.countryId', $country, '=');
    }

  public function callback(Request $request): RedirectResponse {
    $code = $request->query->get('code');
    $state = $request->query->get('state');
    $error = $request->query->get('error');

    // Check for OAuth errors.
    if ($error) {
      $error_description = $request->query->get('error_description', 'Unknown OAuth error');
      $this->messenger()->addError($this->t('OAuth authorization failed: @error - @description', [

   */
  public function listUserTodos(Request $request): array {
    $state_filter = $request->query->get('state');
    $share_filter = $request->query->get('share');
    if (!in_array($state_filter, TodoState::getStateKeys())) {
      $state_filter = null;
    }

    $filters = [

  public function callback(Request $request): RedirectResponse {
    $code = $request->query->get('code');
    $state = $request->query->get('state');
    $saved_state = $request->getSession()->get('link_orcid_state');

    if (!$code || !$state || !$saved_state || !hash_equals((string) $saved_state, (string) $state)) {
      $this->messenger->addError($this->t('Missing or invalid parameters from ORCID.'));
      return $this->redirectToProfile();
    }

    assert($request !== NULL);
    $code = $request->query->get('code', '');
    $state = $request->query->get('state', '');

    try {
      $this->authService->finalize($code, $state);
      return new RedirectResponse(
        Url::fromRoute('acquia_connector.setup_configure')->toString()
      );

    // State value is validated in $this->auth0->getUser() above.
    $returnTo = NULL;
    $validatedState = $request->query->get('state');
    $currentSession = $this->tempStore->get(AuthController::STATE);
    if (!empty($currentSession[$validatedState])) {
      $returnTo = $currentSession[$validatedState];
      unset($currentSession[$validatedState]);
    }

   */
  public function access(Request $request, AuthmanAuthInterface $authman_auth): AccessResultInterface {
    $state = $request->query->get('state');
    $code = $request->query->get('code');
    if (empty($state) || empty($code)) {
      // DefaultExceptionHtmlSubscriber::on4xx captures this.
      throw new BadRequestHttpException('Missing query arguments');
    }

    /** @noinspection NullPointerExceptionInspection */
    $session__state = $request->getSession()->get(self::SESSION_OAUTH_STATE_NAME);
    $request__state = $request->query->get('state');
    // Both 'states' need to have a value.
    if ($session__state === NULL || $request__state === NULL) {
      return FALSE;
    }

    return $session__state === $request__state;

    // $request is not passed in to _custom_access.
    // @see https://www.drupal.org/node/2786941
    if ($this->csrfToken->validate($this->currentRequest->query->get('state'))) {
      return AccessResult::allowed();
    }

    return AccessResult::forbidden('Could not validate state in OAuth validation handshake.');
  }

    $provider = $this->getOauthProvider();
    $request = \Drupal::requestStack()->getCurrentRequest();
    $state = $request->query->get('state');

    // Check given state against previously stored one to mitigate CSRF attack.
    if (
      empty($state) ||
      (
        !empty($this->tempStore->get('oauth2state')) &&

      if ($isLoginRequest && $responseIsHttpFound && $returnTo) {
        $request = Request::create($returnTo);
        if ($stateId = $request->query->get('State')) {
          $this->sspHandler->saveIdToStat($this->accountProxy->id(), $stateId);
        }
        $response->setTargetUrl($returnTo);
        $event->stopPropagation();
      }
    }

  if (!empty($returnTo) && $sspHandler->returnPathIsAllowed($returnTo)) {
    $request = Request::create($returnTo);
    if ($stateId = $request->query->get('State')) {
      $sspHandler->saveIdToStat($account->id(), $stateId);
    }
  }
}

/**

    $code = $request->query->get('code');
    $state = $request->query->get('state');

    if (!$code) {

      // If we don't have an authorization code then get one.
      $authUrl = $provider->getAuthorizationUrl();
      $oauth2_state = $provider->getState();

    // ensure that the user, not a malicious script, is making the request.
    $query = $this->requestStack->getCurrentRequest()->query;
    $state_token = $query->get('state');
    if ($state_token && StateToken::confirm($state_token)) {
      return AccessResult::allowed();
    }
    return AccessResult::forbidden();
  }

    else {
      // Process the login or connect operations.
      $this->id4meService->setState($query->get('state'));
      $authorizationTokens = $this->id4meService->getAuthorizationTokens($query->get('code'));
      $userInfo = $this->id4meService->getUserInfo();

      $account = $this->authmapService->userLoadByIdentifier(
        $authorizationTokens->getIdTokenDecoded()->getIss(),
        $authorizationTokens->getIdTokenDecoded()->getSub()

    $error = $request->query->get('error');
    $error_description = $request->query->get('error_description');
    $state = $request->query->get('state');

    // Validate CSRF state parameter.
    $session = $request->getSession();
    $stored_state = $session->get('nextcloud_oauth2_state');
    $state_time = $session->get('nextcloud_oauth2_state_time');

    $error = $request->query->get('error');
    $error_description = $request->query->get('error_description');
    $state = $request->query->get('state');

    $current_user = $this->currentUser();
    $user = $this->entityTypeManager()->getStorage('user')->load($current_user->id());

    // Validate CSRF state parameter.
    $session = $request->getSession();

      throw new \UnexpectedValueException("The code query parameter is missing.");
    }
    $state = $this->requestStack->getCurrentRequest()->query->get('state');
    if (empty($state)) {
      throw new \UnexpectedValueException("The state query parameter is missing.");
    }
    $oauth2Client = $this->entityTypeManager()->getStorage('oauth2_client')->load($clientId);
    if (!($oauth2Client instanceof Oauth2Client)) {
      throw new NotFoundHttpException();

    $state = $this->session->getState();

    if ($state === NULL || $state !== $request->query->get('state')) {
      return AccessResult::forbidden();
    }

    return AccessResult::allowed();
  }

    // Get the variables we need.
    $code = $this->stack->getCurrentRequest()->query->get('code');
    $state = $this->stack->getCurrentRequest()->query->get('state');

    $session = $this->stack->getCurrentRequest()->getSession();
    $session_state = $session->get('oauth2state');

    // Now we have what we need, we can clear out the session for security
    // reasons.

  public function access() {
    $auth_state = $this->state->get(QuickbooksService::STATE_OAUTH_SECURITY);
    $query_state = $this->requestStack->getMainRequest()->query->get('state');

    if ($auth_state !== $query_state) {
      return AccessResult::forbidden("Invalid authorization state query parameter.");
    }

    return AccessResult::allowed();