public function send(StreamInterface $stream)
{
if (!$stream->isWritable()) {
throw new \InvalidArgumentException('Output stream must be writable');
}
$stream->write($this->contents);
}
public function writeText(StreamInterface $stream)
{
$text = $this->text;
$menu = $this->menu;
$token = $this->requestToken;
$stream->write(<<<HTML
<form method="post" action="{$text->e($text->getUrlPage("rename_menu", $menu->getId()))}">
<p>
{$text->t("main.fields_required")}
</p>
<p>
<label for="menu_name">
{$text->t("links.menu.name")}: <span class="required">*</span>
</label> <br />
<input type="text" name="menu_name" id="menu_name" value="{$text->e($menu->getName())}" size="20"
maxlength="{$text->e(MenuRepository::NAME_MAX_LENGTH)}" />
</p>
<p>
<input type="hidden" name="{$text->e(RequestToken::FIELD_NAME)}" value="{$text->e($token->getTokenString())}" />
<input class="button primary_button" type="submit" value="{$text->t("editor.save")}" />
<a class="button" href="{$text->e($text->getUrlPage("edit_menu", $menu->getId()))}">
{$text->t("main.cancel")}
</a>
</p>
</form>
HTML
);
}
public function writeText(StreamInterface $stream)
{
$text = $this->text;
$stream->write(<<<HTML
<p>
{$text->t("main.fields_required")}
</p>
<form method="post" action="{$text->url("edit_category", $this->category->getId())}">
<p>
<label for="category_name">{$text->t("categories.name")}:</label>
<span class="required">*</span>
<br />
<input type="text" id="category_name" name="category_name"
maxlength="{$text->e(CategoryRepository::NAME_MAX_LENGTH)}"
value="{$text->e($this->category->getName())}" />
</p>
<p>
<label for="category_description">{$text->t("categories.description")}:</label>
<br />
{$this->richEditor->getEditor("category_description", $this->category->getDescriptionHtml())}
</p>
<p>
<input type="hidden" name="{$text->e(RequestToken::FIELD_NAME)}"
value="{$text->e($this->requestToken->getTokenString())}" />
<input type="submit" class="button primary_button" value="{$text->t("editor.save")}" />
<a class="button" href="{$text->url("category_list")}">
{$text->t("main.cancel")}
</a>
</p>
</form>
HTML
);
}
public function send(StreamInterface $stream)
{
if (!$stream->isWritable()) {
throw new \InvalidArgumentException('Output stream must be writable');
}
if (is_array($this->callback)) {
$ref = (new \ReflectionClass(is_object($this->callback[0]) ? get_class($this->callback[0]) : $this->callback[0]))->getMethod($this->callback[1]);
} elseif (is_object($this->callback) && !$this->callback instanceof \Closure) {
$ref = new \ReflectionMethod(get_class($this->callback), '__invoke');
} else {
$ref = new \ReflectionFunction($this->callback);
}
if ($ref->isGenerator()) {
foreach (call_user_func($this->callback) as $chunk) {
$stream->write($chunk);
}
return;
}
foreach ($ref->getParameters() as $param) {
if (NULL !== ($type = $param->getClass())) {
if ($type->name === StreamInterface::class || $type->implementsInterface(StreamInterface::class)) {
call_user_func($this->callback, $stream);
return;
}
}
break;
}
$stream->write((string) call_user_func($this->callback));
}
/**
* Retrieve a single line from the stream.
*
* Retrieves a line from the stream; a line is defined as a sequence of
* characters ending in a CRLF sequence.
*
* @param StreamInterface $stream
* @return string
* @throws UnexpectedValueException if the sequence contains a CR or LF in
* isolation, or ends in a CR.
*/
protected static function getLine(StreamInterface $stream)
{
$line = '';
$crFound = false;
while (!$stream->eof()) {
$char = $stream->read(1);
if ($crFound && $char === self::LF) {
$crFound = false;
break;
}
// CR NOT followed by LF
if ($crFound && $char !== self::LF) {
throw new UnexpectedValueException('Unexpected carriage return detected');
}
// LF in isolation
if (!$crFound && $char === self::LF) {
throw new UnexpectedValueException('Unexpected line feed detected');
}
// CR found; do not append
if ($char === self::CR) {
$crFound = true;
continue;
}
// Any other character: append
$line .= $char;
}
// CR found at end of stream
if ($crFound) {
throw new UnexpectedValueException("Unexpected end of headers");
}
return $line;
}
public function writeText(StreamInterface $stream)
{
$text = $this->text;
foreach ($this->themeInfos as $themeInfo) {
$stream->write(<<<HTML
<h3>{$text->e($themeInfo->getDisplayName())}</h3>
<p>
{$text->e($themeInfo->getDescription())}
{$text->tReplaced("themes.created_by", '<a href="' . $text->e($themeInfo->getAuthorWebsite()) . '">' . $text->e($themeInfo->getAuthor()) . '</a>')}.
<a href="{$text->e($themeInfo->getThemeWebsite())}" class="arrow">{$this->text->t("themes.view_more_information")}</a>
</p>
<p>
<form method="post" action="{$text->url("switch_theme")}">
<input type="hidden" name="theme" value="{$text->e($themeInfo->getDirectoryName())}" />
<input type="hidden" name="{$text->e(RequestToken::FIELD_NAME)}" value="{$text->e($this->requestToken->getTokenString())}" />
<input type="submit" class="button" value="{$text->t("themes.switch_to_this")}" />
</form>
</a>
</p>
HTML
);
}
$stream->write(<<<HTML
<p>
<a class="arrow" href="{$text->url("admin")}">{$text->t("main.admin")}</a>
</p>
HTML
);
}
/**
* Determines if the body should be uploaded using PutObject or the
* Multipart Upload System. It also modifies the passed-in $body as needed
* to support the upload.
*
* @param StreamInterface $body Stream representing the body.
* @param integer $threshold Minimum bytes before using Multipart.
*
* @return bool
*/
private function requiresMultipart(StreamInterface &$body, $threshold)
{
// If body size known, compare to threshold to determine if Multipart.
if ($body->getSize() !== null) {
return $body->getSize() >= $threshold;
}
/**
* Handle the situation where the body size is unknown.
* Read up to 5MB into a buffer to determine how to upload the body.
* @var StreamInterface $buffer
*/
$buffer = Psr7\stream_for();
Psr7\copy_to_stream($body, $buffer, MultipartUploader::PART_MIN_SIZE);
// If body < 5MB, use PutObject with the buffer.
if ($buffer->getSize() < MultipartUploader::PART_MIN_SIZE) {
$buffer->seek(0);
$body = $buffer;
return false;
}
// If body >= 5 MB, then use multipart. [YES]
if ($body->isSeekable()) {
// If the body is seekable, just rewind the body.
$body->seek(0);
} else {
// If the body is non-seekable, stitch the rewind the buffer and
// the partially read body together into one stream. This avoids
// unnecessary disc usage and does not require seeking on the
// original stream.
$buffer->seek(0);
$body = new Psr7\AppendStream([$buffer, $body]);
}
return true;
}
/**
* Append another input stream.
*
* @param StreamInterface $stream
*
* @throws \InvalidArgumentException When the given stream is not readable.
*/
public function appendStream(StreamInterface $stream)
{
if (!$stream->isReadable()) {
throw new \InvalidArgumentException('Appended input stream must be readable');
}
$this->streams[] = $stream;
}
/**
* {@inheritdoc}
*
* @param StreamInterface $content
* (Optional) The content to override the input stream with. This is mainly
* here for testing purposes.
*
*/
public static function fromGlobals(array $server = null, array $query = null, array $body = null, array $cookies = null, array $files = null, StreamInterface $content = null)
{
$server = static::normalizeServer($server ?: $_SERVER);
$files = static::normalizeFiles($files ?: $_FILES);
$headers = static::marshalHeaders($server);
// static::get() has a default parameter, however, if the header is set but
// the value is NULL, e.g. during a drush operation, the NULL result is
// returned, instead of the default.
$method = strtoupper(static::get('REQUEST_METHOD', $server) ?: 'GET');
$request = new JsonRequest($server, $files, static::marshalUriFromServer($server, $headers), $method, $content ?: 'php://input', $headers);
$is_json = strpos(static::get('CONTENT_TYPE', $server), 'application/json') !== FALSE;
$vars_in_body = in_array($method, ['PUT', 'POST', 'PATCH', 'DELETE']);
if ($vars_in_body) {
$data = $content ? $content->getContents() : file_get_contents('php://input');
$body = $body ?: [];
$new = [];
if ($is_json) {
$new = json_decode($data, TRUE);
} else {
parse_str($data, $new);
}
// Merge in data to $body.
$body = array_merge($body, $new);
}
return $request->withCookieParams($cookies ?: $_COOKIE)->withQueryParams($query ?: $_GET)->withParsedBody($body ?: $_POST);
}
/**
* StreamRange constructor.
* @param StreamInterface $stream
* @param string $range
* @throws
*/
public function __construct(StreamInterface $stream, $range)
{
$range = trim($range);
$length = $stream->getSize();
if (preg_match('/^(\\d+)\\-$/', $range, $match)) {
$this->firstPos = intval($match[1]);
if ($this->firstPos > $length - 1) {
throw new StreamRangeException('HTTP/1.1 416 Requested Range Not Satisfiable');
}
$this->lastPos = $length - 1;
} elseif (preg_match('/^(\\d+)\\-(\\d+)$/', $range, $match)) {
$this->firstPos = intval($match[1]);
$this->lastPos = intval($match[2]);
if ($this->lastPos < $this->firstPos || $this->lastPos > $length - 1) {
throw new StreamRangeException('HTTP/1.1 416 Requested Range Not Satisfiable');
}
} elseif (preg_match('/^\\-(\\d+)$/', $range, $match)) {
$suffixLength = intval($match[1]);
if ($suffixLength === 0 || $suffixLength > $length) {
throw new StreamRangeException('HTTP/1.1 416 Requested Range Not Satisfiable');
}
$this->firstPos = $length - $suffixLength;
$this->lastPos = $length - 1;
} else {
throw new StreamRangeException('HTTP/1.1 416 Requested Range Not Satisfiable');
}
}
/**
* @test
*/
public function toolbarIsAppendedWhenContentTypeIsHtml()
{
$this->body->expects($this->once())->method('isWritable')->will($this->returnValue(true));
$this->body->expects($this->once())->method('write');
$this->response->expects($this->once())->method('getHeader')->will($this->returnValue(['text/html']));
$this->middleware->__invoke($this->request, $this->response);
}
public function writeText(StreamInterface $stream)
{
$text = $this->text;
$editorHtml = $this->installedWidgets->getEditor($this->editWidget);
$actionUrl = $text->getUrlPage("edit_widget", $this->editWidget->getId());
$documentEditUrl = $text->getUrlPage("edit_document", $this->editWidget->getDocumentId());
$tokenNameHtml = $text->e(RequestToken::FIELD_NAME);
$tokenValueHtml = $text->e($this->requestToken->getTokenString());
$stream->write(<<<EDITOR
<p>{$this->text->t("main.fields_required")}</p>
<form method="POST" action="{$text->e($actionUrl)}">
{$editorHtml}
<p>
<input type="hidden" name="{$tokenNameHtml}" value="{$tokenValueHtml}" />
<input type="hidden" name="document_id" value="{$this->editWidget->getDocumentId()}" />
<input type="hidden" name="directory_name" value="{$this->editWidget->getDirectoryName()}" />
<input class="button primary_button"
type="submit"
name="submit"
value="{$this->text->t("editor.save")}" />
<a class="button" href="{$text->e($documentEditUrl)}">
{$this->text->t("main.cancel")}
</a>
</p>
</form>
EDITOR
);
}
public function writeUnauthorized()
{
$this->response = $this->response->withStatus(401);
$apiResponse = new ApiResponse();
$apiResponse->setStatusFail();
$apiResponse->setData("Unauthorized");
$this->body->write($apiResponse->toJSON());
}
public function writeText(StreamInterface $stream)
{
if ($this->newUser === null) {
$stream->write($this->getErrorText());
} else {
$stream->write($this->getSuccessText());
}
}
public function send(StreamInterface $stream)
{
if (!$stream->isWritable()) {
throw new \InvalidArgumentException('Output stream must be writable');
}
while (!$this->stream->eof()) {
$stream->write($this->stream->read(4096));
}
}
public function writeText(StreamInterface $stream)
{
// Link to manage widgets
$stream->write($this->getWidgetsEditLinks());
// Output widgets
foreach ($this->placedWidgets as $widget) {
$this->widgetLoader->writeOutput($stream, $widget);
}
}
/**
* @param StreamInterface $stream
*/
protected function body($stream)
{
if ($stream instanceof Messages\Stream\Implementation) {
$stream->rewind();
$this->fpassthru($stream->resource());
} else {
$this->output((string) $stream);
}
}
/**
* Append stream to stack.
*
* @param StreamInterface $stream
* @return self
*/
public function add(StreamInterface $stream)
{
if (!$stream->isReadable()) {
throw new \InvalidArgumentException('Each stream must be readable');
}
$this->seekable = $stream->isSeekable() && $this->seekable;
$this->streams[] = $stream;
return $this;
}
public function writeText(StreamInterface $stream)
{
foreach ($this->comments as $comment) {
$stream->write($this->getSingleComment($comment));
}
if (count($this->comments) == 0) {
$stream->write("<p><em>" . $this->text->t("errors.nothing_found") . "</em></p>\n");
}
}
/**
* Copy stream to another stream.
*
* @param StreamInterface $src Source stream.
* @param StreamInterface $dest Target stream.
*
* @return void
*/
public static function copy(StreamInterface $src, StreamInterface $dest)
{
if ($src->isSeekable()) {
$src->rewind();
}
while (!$src->eof()) {
$dest->write($src->read(4096));
}
}
public function __construct($filename, StreamInterface $stream, $mediaType = NULL)
{
if (!$stream->isReadable()) {
throw new \InvalidArgumentException(sprintf('Input stream of file "%s" must be readable'));
}
$this->fileName = new UnicodeString($filename);
$this->stream = $stream;
$this->mediaType = $mediaType === NULL ? Filesystem::guessMimeTypeFromFilename($this->fileName) : new MediaType($mediaType);
}
/**
* {@inheritDoc}
*/
public function __invoke(StreamInterface $stream)
{
$request = \GuzzleHttp\Psr7\parse_request($stream->getContents());
$response = $this->run($request);
if ($this->getAssertionCallback()) {
call_user_func($this->getAssertionCallback(), $request);
}
return \GuzzleHttp\Psr7\stream_for(\GuzzleHttp\Psr7\str($response));
}
public function writeText(StreamInterface $stream, Website $website, $id, $data)
{
if (!isset($data["text"]) || !isset($data["title"])) {
return;
}
if (strLen($data["title"]) > 0) {
$stream->write("<h2>" . htmlSpecialChars($data["title"]) . "</h2>\n");
}
$stream->write($data["text"]);
}
/**
* Parse a response from a stream.
*
* @param StreamInterface $stream
* @return ResponseInterface
* @throws InvalidArgumentException when the stream is not readable.
* @throws UnexpectedValueException when errors occur parsing the message.
*/
public static function fromStream(StreamInterface $stream)
{
if (!$stream->isReadable() || !$stream->isSeekable()) {
throw new InvalidArgumentException('Message stream must be both readable and seekable');
}
$stream->rewind();
list($version, $status, $reasonPhrase) = self::getStatusLine($stream);
list($headers, $body) = self::splitStream($stream);
return (new Response($body, $status, $headers))->withProtocolVersion($version)->withStatus((int) $status, $reasonPhrase);
}
public function writeText(StreamInterface $stream, Website $website, $id, $data)
{
$title = htmlSpecialChars($data["title"]);
$amount = (int) $data["amount"];
$commentLookup = new CommentRepository($website->getDatabase());
$latestComments = $commentLookup->getCommentsLatest($amount);
$view = new CommentsSmallTemplate($website->getText(), $latestComments);
$stream->write('<h2>' . $title . "</h2>\n");
$view->writeText($stream);
}
function withBody(StreamInterface $body) : self
{
if ($this->stream === $body) {
return $this;
}
$new = clone $this;
$new->stream = $body;
$new->body = $body->extract();
return $new;
}
private function cropContent(StreamInterface $stream = null)
{
if (null === $stream) {
return '';
}
if ($stream->getSize() <= $this->maxBodySize) {
return (string) $stream;
}
$stream->seek(0);
return '(partial content)' . $stream->read($this->maxBodySize) . '(...)';
}
/**
* Add a stream to the AppendStream
*
* @param StreamInterface $stream Stream to append. Must be readable.
*
* @throws \InvalidArgumentException if the stream is not readable
*/
public function addStream(StreamInterface $stream)
{
if (!$stream->isReadable()) {
throw new \InvalidArgumentException('Each stream must be readable');
}
// The stream is only seekable if all streams are seekable
if (!$stream->isSeekable()) {
$this->seekable = false;
}
$this->streams[] = $stream;
}
public function writeText(StreamInterface $stream)
{
$text = $this->text;
$stream->write(<<<HTML
<p>{$text->t("install.no_tables_yet")}</p>
<a href="{$text->e($text->getUrlPage("install", null, ["action" => "install_database"]))}" class="button primary_button">
{$text->t("install.create_tables")}
</a>
HTML
);
}
/**
* Deserialize a request stream to a request instance.
*
* @param StreamInterface $stream
* @return Request
* @throws UnexpectedValueException when errors occur parsing the message.
*/
public static function fromStream(StreamInterface $stream)
{
if (!$stream->isReadable() || !$stream->isSeekable()) {
throw new InvalidArgumentException('Message stream must be both readable and seekable');
}
$stream->rewind();
list($method, $requestTarget, $version) = self::getRequestLine($stream);
$uri = self::createUriFromRequestTarget($requestTarget);
list($headers, $body) = self::splitStream($stream);
return (new Request($uri, $method, $body, $headers))->withProtocolVersion($version)->withRequestTarget($requestTarget);
}