Proyectos de Subversion Moodle

Rev

| Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 1 
<?php
2 
 
3 
declare(strict_types=1);
4 
 
5 
namespace GuzzleHttp\Psr7;
6 
 
7 
use InvalidArgumentException;
8 
use Psr\Http\Message\StreamInterface;
9 
use Psr\Http\Message\UploadedFileInterface;
10 
use RuntimeException;
11 
 
12 
class UploadedFile implements UploadedFileInterface
13 
{
14 
    private const ERRORS = [
15 
        UPLOAD_ERR_OK,
16 
        UPLOAD_ERR_INI_SIZE,
17 
        UPLOAD_ERR_FORM_SIZE,
18 
        UPLOAD_ERR_PARTIAL,
19 
        UPLOAD_ERR_NO_FILE,
20 
        UPLOAD_ERR_NO_TMP_DIR,
21 
        UPLOAD_ERR_CANT_WRITE,
22 
        UPLOAD_ERR_EXTENSION,
23 
    ];
24 
 
25 
    /**
26 
     * @var string|null
27 
     */
28 
    private $clientFilename;
29 
 
30 
    /**
31 
     * @var string|null
32 
     */
33 
    private $clientMediaType;
34 
 
35 
    /**
36 
     * @var int
37 
     */
38 
    private $error;
39 
 
40 
    /**
41 
     * @var string|null
42 
     */
43 
    private $file;
44 
 
45 
    /**
46 
     * @var bool
47 
     */
48 
    private $moved = false;
49 
 
50 
    /**
51 
     * @var int|null
52 
     */
53 
    private $size;
54 
 
55 
    /**
56 
     * @var StreamInterface|null
57 
     */
58 
    private $stream;
59 
 
60 
    /**
61 
     * @param StreamInterface|string|resource $streamOrFile
62 
     */
63 
    public function __construct(
64 
        $streamOrFile,
65 
        ?int $size,
66 
        int $errorStatus,
67 
        string $clientFilename = null,
68 
        string $clientMediaType = null
69 
    ) {
70 
        $this->setError($errorStatus);
71 
        $this->size = $size;
72 
        $this->clientFilename = $clientFilename;
73 
        $this->clientMediaType = $clientMediaType;
74 
 
75 
        if ($this->isOk()) {
76 
            $this->setStreamOrFile($streamOrFile);
77 
        }
78 
    }
79 
 
80 
    /**
81 
     * Depending on the value set file or stream variable
82 
     *
83 
     * @param StreamInterface|string|resource $streamOrFile
84 
     *
85 
     * @throws InvalidArgumentException
86 
     */
87 
    private function setStreamOrFile($streamOrFile): void
88 
    {
89 
        if (is_string($streamOrFile)) {
90 
            $this->file = $streamOrFile;
91 
        } elseif (is_resource($streamOrFile)) {
92 
            $this->stream = new Stream($streamOrFile);
93 
        } elseif ($streamOrFile instanceof StreamInterface) {
94 
            $this->stream = $streamOrFile;
95 
        } else {
96 
            throw new InvalidArgumentException(
97 
                'Invalid stream or file provided for UploadedFile'
98 
            );
99 
        }
100 
    }
101 
 
102 
    /**
103 
     * @throws InvalidArgumentException
104 
     */
105 
    private function setError(int $error): void
106 
    {
107 
        if (false === in_array($error, UploadedFile::ERRORS, true)) {
108 
            throw new InvalidArgumentException(
109 
                'Invalid error status for UploadedFile'
110 
            );
111 
        }
112 
 
113 
        $this->error = $error;
114 
    }
115 
 
116 
    private function isStringNotEmpty($param): bool
117 
    {
118 
        return is_string($param) && false === empty($param);
119 
    }
120 
 
121 
    /**
122 
     * Return true if there is no upload error
123 
     */
124 
    private function isOk(): bool
125 
    {
126 
        return $this->error === UPLOAD_ERR_OK;
127 
    }
128 
 
129 
    public function isMoved(): bool
130 
    {
131 
        return $this->moved;
132 
    }
133 
 
134 
    /**
135 
     * @throws RuntimeException if is moved or not ok
136 
     */
137 
    private function validateActive(): void
138 
    {
139 
        if (false === $this->isOk()) {
140 
            throw new RuntimeException('Cannot retrieve stream due to upload error');
141 
        }
142 
 
143 
        if ($this->isMoved()) {
144 
            throw new RuntimeException('Cannot retrieve stream after it has already been moved');
145 
        }
146 
    }
147 
 
148 
    public function getStream(): StreamInterface
149 
    {
150 
        $this->validateActive();
151 
 
152 
        if ($this->stream instanceof StreamInterface) {
153 
            return $this->stream;
154 
        }
155 
 
156 
        /** @var string $file */
157 
        $file = $this->file;
158 
 
159 
        return new LazyOpenStream($file, 'r+');
160 
    }
161 
 
162 
    public function moveTo($targetPath): void
163 
    {
164 
        $this->validateActive();
165 
 
166 
        if (false === $this->isStringNotEmpty($targetPath)) {
167 
            throw new InvalidArgumentException(
168 
                'Invalid path provided for move operation; must be a non-empty string'
169 
            );
170 
        }
171 
 
172 
        if ($this->file) {
173 
            $this->moved = PHP_SAPI === 'cli'
174 
                ? rename($this->file, $targetPath)
175 
                : move_uploaded_file($this->file, $targetPath);
176 
        } else {
177 
            Utils::copyToStream(
178 
                $this->getStream(),
179 
                new LazyOpenStream($targetPath, 'w')
180 
            );
181 
 
182 
            $this->moved = true;
183 
        }
184 
 
185 
        if (false === $this->moved) {
186 
            throw new RuntimeException(
187 
                sprintf('Uploaded file could not be moved to %s', $targetPath)
188 
            );
189 
        }
190 
    }
191 
 
192 
    public function getSize(): ?int
193 
    {
194 
        return $this->size;
195 
    }
196 
 
197 
    public function getError(): int
198 
    {
199 
        return $this->error;
200 
    }
201 
 
202 
    public function getClientFilename(): ?string
203 
    {
204 
        return $this->clientFilename;
205 
    }
206 
 
207 
    public function getClientMediaType(): ?string
208 
    {
209 
        return $this->clientMediaType;
210 
    }
211 
}