Retrieve an uninitialized request message.

@return HttpRequestMessageImpl
356784
public HttpRequestMessageImpl getRequest() {
        HttpRequestMessageImpl req = (HttpRequestMessageImpl) this.reqPool.get();
        if (null == req) {
            req = new HttpRequestMessageImpl();
        }
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, "getRequest(): " + req);
        }
        return req;
    }
778962
protected function getRequest()
    {
        if (null === $this->request) {
            $this->request = $this->getParser()->getRequest();
        }

        return $this->request;
    }
172448
public function receive() : Message
    {
        $postText = $this->getInputStream();

        if ($postText === false) {
            throw new \Exception('Invalid message received to AssertionConsumerService endpoint.');
        }

        $document = DOMDocumentFactory::fromString($postText);
        $xml = $document->firstChild;
        Utils::getContainer()->debugMessage($document->documentElement, 'in');
        /** @var \DOMElement[] $results */
        $results = Utils::xpQuery($xml, '/soap-env:Envelope/soap-env:Body/*[1]');

        return Message::fromXML($results[0]);
    }
77323
final protected HttpResponseMessageImpl getResponseImpl() {
        if (null == getMyResponse()) {
            if (getObjectFactory() == null) {
                return null;
            }
            setMyResponse(getObjectFactory().getResponse(this));
        }
        return getMyResponse();
    }
694429
public function getErrorMessage()
    {
        $app = Application::getFacadeApplication();
        $request = $app->make(Request::class);
        $ajax = $app->make(Ajax::class);
        if ($ajax->isAjaxRequest($request)) {
            return t("Invalid token. Please reload the page and retry.");
        } else {
            return t("Invalid form token. Please reload this form and submit again.");
        }
    }
695640
public function getMessage()
    {
        $message = null;

        if (isset($this->data->transactionResponse->messages)) {
            // In case of a successful transaction, a "messages" element is present
            $message = (string)$this->data->transactionResponse->messages->message->description;
        } elseif (isset($this->data->transactionResponse->errors)) {
            // In case of an unsuccessful transaction, an "errors" element is present
            $message = (string)$this->data->transactionResponse->errors->error->errorText;
        } elseif (isset($this->data->messages->message)) {
            // In case of invalid request, the top-level message provides details.
            $message = (string)$this->data->messages->message->text;
        }

        return $message;
    }
820448
public function getRequest()
  {
    if ($this->request === null) {
      // @codeCoverageIgnoreStart
      $this->request = Request::buildFromGlobals();
    }
    // @codeCoverageIgnoreEnd

    return $this->request;
  }
577528
public function getRenderedMessage() {
		if($this->renderedMessage === null and $this->message !== null) {
			if(is_string($this->message)) {
				$this->renderedMessage = $this->message;
			} else {
				$rendererMap = \n2n\log4php\Logger::getHierarchy()->getRendererMap();
				$this->renderedMessage= $rendererMap->findAndRender($this->message);
			}
		}
		return $this->renderedMessage;
	}
883517
public function getMessage()
    {
        $code = $this->getCode();

        if (!array_key_exists($code, $this->_messageMap))
            throw new Error("Unknown HTTP status code: $code");

        return $this->_messageMap[$code];
    }
1288725
private function getRequest()
    {
        $error = null;

        do {
            if (array_key_exists('REQUEST_METHOD', $_SERVER) && $_SERVER['REQUEST_METHOD'] != 'POST') {
                $error = self::INVALIDREQUEST;
                break;
            };

            $request = !empty($_GET['rawRequest']) ? $_GET['rawRequest'] : file_get_contents('php://input');
            $this->request = json_decode($request, false);
            if ($this->request === null) {
                $error = self::PARSEERROR;
                break;
            }

            if ($this->request === []) {
                $error = self::INVALIDREQUEST;
                break;
            }

            // check for batch call
            if (is_array($this->request)) {
                if (count($this->request) > $this->MaxBatchCalls) {
                    $error = self::INVALIDREQUEST;
                    break;
                }

                $this->calls = $this->request;
                $this->isBatchCall = true;
            } else {
                $this->calls[] = $this->request;
            }
        } while (false);

        return $error;
    }
682838
private function getErrorMessage()
    {
        $message = $this->target->resource->timeoutMessage;

        return sprintf(
            $message,
            $this->url,
            $this->totalTime,
            $this->getRoundtripTimeout()
        );
    }
1353079
public function getSignedRequest() {
        if (!$this->signedRequest) {
            $signed_request_paramter = $this->_getRequestParam('signed_request');
            if ($signed_request_paramter) {
                $this->signedRequest = $this->parseSignedRequest($signed_request_paramter);
            }
        }
        return $this->signedRequest;
    }
1317197
public function getInvocationMessage()
    {
        if ($this->invocationMessage === null) {
            // try to create one
            if ($this->registration === null) {
                throw new \Exception('You must set the registration prior to calling getInvocationMessage');
            }

            if ($this->callMessage === null) {
                throw new \Exception('You must set the CallMessage prior to calling getInvocationMessage');
            }

            $invocationMessage = InvocationMessage::createMessageFrom($this->getCallMessage(), $this->getRegistration());

            $invocationMessage->setRequestId($this->getInvocationRequestId());

            $details = [];

            if ($this->getRegistration()->getDiscloseCaller() === true && $this->getCallerSession()->getAuthenticationDetails()) {
                $authenticationDetails = $this->getCallerSession()->getAuthenticationDetails();
                $details               = [
                    'caller'     => $this->getCallerSession()->getSessionId(),
                    'authid'     => $authenticationDetails->getAuthId(),
                    'authrole'   => $authenticationDetails->getAuthRole(),
                    'authroles'  => $authenticationDetails->getAuthRoles(),
                    'authmethod' => $authenticationDetails->getAuthMethod(),
                ];

                if ($authenticationDetails->getAuthExtra() !== null) {
                    $details['_thruway_authextra'] = $authenticationDetails->getAuthExtra();
                }
            }

            // TODO: check to see if callee supports progressive call
            $callOptions   = $this->getCallMessage()->getOptions();
            $isProgressive = false;
            if (is_object($callOptions) && isset($callOptions->receive_progress) && $callOptions->receive_progress) {
                $details       = array_merge($details, ['receive_progress' => true]);
                $isProgressive = true;
            }

            // if nothing was added to details - change ot stdClass so it will serialize correctly
            if (count($details) === 0) {
                $details = new \stdClass();
            }
            $invocationMessage->setDetails($details);

            $this->setIsProgressive($isProgressive);

            $this->setInvocationMessage($invocationMessage);
        }

        return $this->invocationMessage;
    }
1117618
public function getSeverityMessage()
    {
        $severity = $this->getSeverity();

        if(isset(self::$severity_messages[$severity])) {
            $message = self::$severity_messages[$severity];
        } else {
            $message = 'Unknown error';
        }

        return $message;
    }
171116
public function toMessage()
    {
        $msg = new Message(array(
                $this->requestId,
                $this->action,
            ));

        $msg->append($this->params);

        return $msg;
    }
1153438
protected function getMessage() {
		if($message = $this->defaultMessage) {}
		else $message = ':attribute is not valid.';

		$params = [
			'attribute' => $this->getName(),
		];
		return $this->format($message, $params);
	}
32670
public function getPayload()
    {
        $payload = $this->payload;

        // The "message" property is deprecated and replaced by "error_description"
        // TODO: remove "message" property
        if (isset($payload['error_description']) && !isset($payload['message'])) {
            $payload['message'] = $payload['error_description'];
        }

        return $payload;
    }