Performs Web service request

@param \OxidEsales\Eshop\Core\OnlineLicenseCheckRequest $oRequest Object with request parameters

@throws oxException
@return \OxidEsales\Eshop\Core\OnlineLicenseCheckResponse
510493
public function doRequest(\OxidEsales\Eshop\Core\OnlineLicenseCheckRequest $oRequest)
    {
        return $this->_formResponse($this->call($oRequest));
    }
435271
public function setRequest(JsonRequest $request)
    {
        $this->id = $request->getId();
        $this->jsonrpc = $request->getJsonrpc();
        $this->method = $request->getMethod();
        $this->request = $request;

        if (!$request->getResponse()) {
            $request->setResponse($this);
        }

        return $this;
    }
941579
public function checkElementKey(ServerRequest $request, Response $response): Response
    {
        $elementKey = $request->getQueryParams()['key'];

        $objectManager = GeneralUtility::makeInstance(ObjectManager::class);
        $storageRepository = $objectManager->get(StorageRepository::class);

        $isAvailable = true;
        if ($storageRepository->loadElement('tt_content', $elementKey)) {
            $isAvailable = false;
        }

        return new JsonResponse(['isAvailable' => $isAvailable]);
    }
753851
public function transform(\swoole_http_request $swooleRequest)
    {
        return $this->useServerRequest ?
            $this->transformServerRequest($swooleRequest) : $this->transformRequest($swooleRequest);
    }
550268
public function dispatch($action, ServerRequestInterface $request) : ResponseInterface
    {
        $this->getLogger()->debug('dispatching to action: '.$action);
        if (!method_exists($this, $action) && !method_exists($this, '__call')) {
            throw new ActionDoesNotExistException();
        }

        $response = $this->$action($request);
        return $response;
    }
1194063
public function doVoid($request)
    {
        $caller = $this->getCaller();
        $caller->setRequest($request);

        $response = oxNew(\OxidEsales\PayPalModule\Model\Response\ResponseDoVoid::class);
        $response->setData($caller->call('DoVoid'));

        return $response;
    }
223650
protected function doRequest($request)
    {
        if (!$this->firstRequest) {
            $this->initialize($request);
        }
        $this->firstRequest = false;

        $this->applyBindings();
        $this->applyContextualBindings();
        $this->applyInstances();
        $this->applyApplicationHandlers();

        $request = Request::createFromBase($request);
        $response = $this->kernel->handle($request);

        $method = new \ReflectionMethod(get_class($this->app), 'callTerminableMiddleware');
        $method->setAccessible(true);
        $method->invoke($this->app, $response);

        return $response;
    }
643860
public HttpService orElse(Service<HttpRequest, HttpResponse> nextService) {
        requireNonNull(nextService, "nextService");
        return new OrElseHttpService(this, nextService);
    }
661692
public function __doRequest($request, $location, $action, $version, $oneWay = 0)
    {
        LogHandler::log([
            'location' => $location,
            'xml' => $request
        ], LoggerInterface::LEVEL_INFO, 'unsigned_request_raw');

        $doc = new DOMDocument('1.0');
        $doc->loadXML($request);
        $objWSSE = new WSSESoap($doc);
        $objKey = new XMLSecurityKey(XMLSecurityKey::RSA_SHA1, array('type' =>
            'private'));
        $objKey->loadKey($this->getPrivateKey());
        $options = array("insertBefore" => true);
        $objWSSE->signSoapDoc($objKey, $options);
        $objWSSE->addIssuerSerial($this->getCertificate());
        $objKey = new XMLSecurityKey(XMLSecurityKey::AES256_CBC);
        $objKey->generateSessionKey();

        $signed_request = $objWSSE->saveXML();
        LogHandler::log([
            'location' => $location,
            'xml' => $signed_request
        ], LoggerInterface::LEVEL_INFO, 'signed_request_raw');

        $retVal = parent::__doRequest(
            $signed_request,
            $location,
            $action,
            $version,
            $oneWay
        );
        $doc = new DOMDocument();
        $doc->loadXML($retVal);
        LogHandler::log([
            'location' => $location,
            'xml' => $retVal
        ], LoggerInterface::LEVEL_INFO, 'response_raw');
        return $doc->saveXML();
    }
631155
public function create(CreateServiceRequest $serviceRequest)
    {
        $response = $this->httpClient->post(
            'service/',
            [
                'body' => json_encode($serviceRequest->toArray())
            ]
        );

        return ServiceResponse::createFromHttpResponse($response);
    }
60823
private function requestMethodMatchesExpectation(ServerRequestInterface $httpRequest, RequestConditions $expectedRequest)
    {
        $inputSource = $this->inputSourceLocator->locate(InputSources::METHOD);
        $matcher = $this->matcherLocator->locate(Matchers::SAME_STRING);

        return $matcher->match(
            $inputSource->getValue($httpRequest),
            $expectedRequest->getMethod()->asString()
        );
    }
171300
public function vote(
        ItemsServiceContract $pollsService,
        Request $request
    ): VoteResponseContract {
        $pollID = $request->get('id', 0);
        $optionID = $request->get('answer', 0);

        $item = $pollsService->vote($pollID, $optionID);

        return $this->app->make(VoteResponseContract::class, compact('item'));
    }
1231151
public function validateAuthorizationRequest(ServerRequestInterface $request)
    {
        foreach ($this->enabledGrantTypes as $grantType) {
            if ($grantType->canRespondToAuthorizationRequest($request)) {
                return $grantType->validateAuthorizationRequest($request);
            }
        }

        throw OAuthServerException::unsupportedGrantType();
    }
40191
public function authenticate(HTTPRequest $request): HTTPRequest
    {
        $requestAdapter = new HttpRequestAdapter();
        $responseAdapter = new HttpResponseAdapter();

        // missing vars (cli)
        $this->addMissingServerVariables($requestAdapter);

        $server = $this->getServer();
        $psrRequest = $requestAdapter->toPsr7($request);
        $psrResponse = new Response();

        try {
            $psrRequest = $server->validateAuthenticatedRequest($psrRequest);
        } catch (OAuthServerException $exception) {
            // convert to authentication exception
            throw new AuthenticationException(
                $exception->getMessage(),
                $exception->getCode(),
                $responseAdapter->fromPsr7($exception->generateHttpResponse($psrResponse))
            );
        } catch (\Exception $exception) {
            // convert to authentication exception
            throw new AuthenticationException(
                $exception->getMessage(),
                $exception->getCode(),
                $responseAdapter->fromPsr7(
                    (new OAuthServerException($exception->getMessage(), 0, 'unknown_error', 500))
                        ->generateHttpResponse($psrResponse)
                )
            );
        }
        // add the request attributes as custom auth headers
        foreach ($psrRequest->getAttributes() as $attribute => $value) {
            $request->addHeader($attribute, $value);
        }

        return $request;
    }
1366556
@Override
    protected Event doExecute(final RequestContext context) {
        try {
            val request = WebUtils.getHttpServletRequestFromExternalWebflowContext(context);
            val wa = request.getParameter(WA);
            if (StringUtils.isNotBlank(wa) && wa.equalsIgnoreCase(WSIGNIN)) {
                wsFederationResponseValidator.validateWsFederationAuthenticationRequest(context);
                return super.doExecute(context);
            }
            return wsFederationRequestBuilder.buildAuthenticationRequestEvent(context);
        } catch (final Exception ex) {
            LOGGER.error(ex.getMessage(), ex);
            throw new UnauthorizedServiceException(UnauthorizedServiceException.CODE_UNAUTHZ_SERVICE, ex.getMessage());
        }
    }
758408
public function createResponse(
        MockConfig $expectation,
        ResponseInterface $transactionData,
        ServerRequestInterface $request
    ) {
        $url = $expectation->getProxyTo();
        $this->logger->debug('Proxying request to : ' . $url);
        $this->processScenario($expectation);
        $this->processDelay($expectation->getResponse());

        return $this->httpService->send(
            $request->withUri(new Uri($url))
        );
    }
702861
protected function _callOrderRequest(
        $sRequestFunction,
        $oOrder,
        array $aRequestParameters,
        array $aFields,
        &$blProcessable = false,
        $sErrorCode = null
    ) {
        $blProcessable = false;

        //Set default params
        if ($oOrder !== null) {
            $this->_mapOrderToRequestParameters($oOrder, $aRequestParameters, $aFields);
        }

        //Make request and return result
        $this->_addSandboxSimulationParams($sRequestFunction, $aRequestParameters);
        $oData = $this->_convertResponse($this->_getAmazonClient()->{$sRequestFunction}($aRequestParameters));

        //Update Order info
        if ($oOrder !== null) {
            $blProcessable = $this->_setOrderTransactionErrorStatus($oOrder, $oData, $sErrorCode) === false;
        }

        return $oData;
    }