UploadedFile.php

<?php declare(strict_types=1);

/*
 * This file is part of Polymorphine/Message package.
 *
 * (c) Shudd3r <q3.shudder@gmail.com>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Polymorphine\Message;

use Psr\Http\Message\UploadedFileInterface;
use Psr\Http\Message\StreamInterface;
use InvalidArgumentException;
use RuntimeException;


class UploadedFile implements UploadedFileInterface
{
 /**
 * @param array $file Associative array with keys corresponding to $_FILES[name] array
 * for single uploaded file
 *
 * @see https://www.php.net/manual/en/features.file-upload.post-method.php
 */
 public static function fromFileArray(array $file): self
 {
 $stream = Stream::fromResourceUri($file['tmp_name']);
 return new self($stream, $file['size'], $file['error'], $file['name'], $file['type']);
 }

 protected StreamInterface $stream;
 protected bool $isMoved = false;

 private int $errorCode;
 private ?int $fileSize;
 private ?string $clientFilename;
 private ?string $clientMediaType;

 /**
 * @param StreamInterface $stream
 * @param int|null $size
 * @param int $error
 * @param string|null $clientFilename
 * @param string|null $clientMediaType
 */
 public function __construct(
 StreamInterface $stream,
 ?int $size = null,
 int $error = UPLOAD_ERR_OK,
 ?string $clientFilename = null,
 ?string $clientMediaType = null
 ) {
 if (!$stream->isReadable()) {
 throw new InvalidArgumentException('Stream is not readable');
 }
 if ($error < 0 || $error > 8) {
 throw new InvalidArgumentException('Error code out of range - must be UPLOAD_ERR_* constant <0 - 8>');
 }

 $this->stream = $stream;
 $this->fileSize = $size;
 $this->errorCode = $error;
 $this->clientFilename = $clientFilename;
 $this->clientMediaType = $clientMediaType;
 }

 public function getStream(): StreamInterface
 {
 $this->checkFileAccess();
 return $this->stream;
 }

 public function moveTo($targetPath): void
 {
 if (!is_string($targetPath) || empty($targetPath)) {
 throw new InvalidArgumentException('Invalid target path');
 }

 $this->checkFileAccess();
 if (!$source = $this->stream->getMetadata('uri')) {
 $this->isMoved = true;
 throw new RuntimeException('Cannot access file stream - assume already moved');
 }

 $this->moveFile($source, $targetPath);
 $this->isMoved = true;
 }

 public function getSize(): ?int
 {
 return $this->fileSize ?? $this->fileSize = $this->stream->getSize();
 }

 public function getError(): int
 {
 return $this->errorCode;
 }

 public function getClientFilename(): ?string
 {
 return $this->clientFilename;
 }

 public function getClientMediaType(): ?string
 {
 return $this->clientMediaType;
 }

 protected function moveFile($source, $target): void
 {
 $this->stream->close();
 if (!move_uploaded_file($source, $target)) {
 throw new RuntimeException('Failed to move uploaded file');
 }
 }

 private function checkFileAccess(): void
 {
 if ($this->errorCode !== UPLOAD_ERR_OK) {
 throw new RuntimeException('Cannot access file - upload error');
 }

 if ($this->isMoved) {
 throw new RuntimeException('Cannot access file - file already moved');
 }
 }
}