gestione documentale avanzata 1 parte

vendor/league/flysystem-webdav/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2026 Frank de Jonge
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

vendor/league/flysystem-webdav/WebDAVAdapter.php

@@ -0,0 +1,462 @@
+<?php
+
+declare(strict_types=1);
+
+namespace League\Flysystem\WebDAV;
+
+use League\Flysystem\Config;
+use League\Flysystem\DirectoryAttributes;
+use League\Flysystem\FileAttributes;
+use League\Flysystem\FilesystemAdapter;
+use League\Flysystem\PathPrefixer;
+use League\Flysystem\UnableToCheckDirectoryExistence;
+use League\Flysystem\UnableToCheckFileExistence;
+use League\Flysystem\UnableToCopyFile;
+use League\Flysystem\UnableToCreateDirectory;
+use League\Flysystem\UnableToDeleteDirectory;
+use League\Flysystem\UnableToDeleteFile;
+use League\Flysystem\UnableToMoveFile;
+use League\Flysystem\UnableToReadFile;
+use League\Flysystem\UnableToRetrieveMetadata;
+use League\Flysystem\UnableToSetVisibility;
+use League\Flysystem\UnableToWriteFile;
+use League\Flysystem\UrlGeneration\PublicUrlGenerator;
+use RuntimeException;
+use Sabre\DAV\Client;
+use Sabre\DAV\Xml\Property\ResourceType;
+use Sabre\HTTP\ClientHttpException;
+use Sabre\HTTP\Request;
+use Throwable;
+
+use function array_key_exists;
+use function array_shift;
+use function dirname;
+use function explode;
+use function fclose;
+use function implode;
+use function parse_url;
+use function rawurldecode;
+
+class WebDAVAdapter implements FilesystemAdapter, PublicUrlGenerator
+{
+    public const ON_VISIBILITY_THROW_ERROR = 'throw';
+    public const ON_VISIBILITY_IGNORE = 'ignore';
+    public const FIND_PROPERTIES = [
+        '{DAV:}displayname',
+        '{DAV:}getcontentlength',
+        '{DAV:}getcontenttype',
+        '{DAV:}getlastmodified',
+        '{DAV:}iscollection',
+        '{DAV:}resourcetype',
+    ];
+
+    private PathPrefixer $prefixer;
+
+    public function __construct(
+        private Client $client,
+        string $prefix = '',
+        private string $visibilityHandling = self::ON_VISIBILITY_THROW_ERROR,
+        private bool $manualCopy = false,
+        private bool $manualMove = false,
+    ) {
+        $this->prefixer = new PathPrefixer($prefix);
+    }
+
+    public function fileExists(string $path): bool
+    {
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $properties = $this->client->propFind($location, ['{DAV:}resourcetype', '{DAV:}iscollection']);
+
+            return ! $this->propsIsDirectory($properties);
+        } catch (Throwable $exception) {
+            if ($exception instanceof ClientHttpException && $exception->getHttpStatus() === 404) {
+                return false;
+            }
+
+            throw UnableToCheckFileExistence::forLocation($path, $exception);
+        }
+    }
+
+    protected function encodePath(string $path): string
+    {
+        $parts = explode('/', $path);
+
+        foreach ($parts as $i => $part) {
+            $parts[$i] = rawurlencode($part);
+        }
+
+        return implode('/', $parts);
+    }
+
+    public function directoryExists(string $path): bool
+    {
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $properties = $this->client->propFind($location, ['{DAV:}resourcetype', '{DAV:}iscollection']);
+
+            return $this->propsIsDirectory($properties);
+        } catch (Throwable $exception) {
+            if ($exception instanceof ClientHttpException && $exception->getHttpStatus() === 404) {
+                return false;
+            }
+
+            throw UnableToCheckDirectoryExistence::forLocation($path, $exception);
+        }
+    }
+
+    public function write(string $path, string $contents, Config $config): void
+    {
+        $this->upload($path, $contents);
+    }
+
+    public function writeStream(string $path, $contents, Config $config): void
+    {
+        $this->upload($path, $contents);
+    }
+
+    /**
+     * @param resource|string $contents
+     */
+    private function upload(string $path, mixed $contents): void
+    {
+        $this->createParentDirFor($path);
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $response = $this->client->request('PUT', $location, $contents);
+            $statusCode = $response['statusCode'];
+
+            if ($statusCode < 200 || $statusCode >= 300) {
+                throw new RuntimeException('Unexpected status code received: ' . $statusCode);
+            }
+        } catch (Throwable $exception) {
+            throw UnableToWriteFile::atLocation($path, $exception->getMessage(), $exception);
+        }
+    }
+
+    public function read(string $path): string
+    {
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $response = $this->client->request('GET', $location);
+
+            if ($response['statusCode'] !== 200) {
+                throw new RuntimeException('Unexpected response code for GET: ' . $response['statusCode']);
+            }
+
+            return $response['body'];
+        } catch (Throwable $exception) {
+            throw UnableToReadFile::fromLocation($path, $exception->getMessage(), $exception);
+        }
+    }
+
+    public function readStream(string $path)
+    {
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $url = $this->client->getAbsoluteUrl($location);
+            $request = new Request('GET', $url);
+            $response = $this->client->send($request);
+            $status = $response->getStatus();
+
+            if ($status !== 200) {
+                throw new RuntimeException('Unexpected response code for GET: ' . $status);
+            }
+
+            return $response->getBodyAsStream();
+        } catch (Throwable $exception) {
+            throw UnableToReadFile::fromLocation($path, $exception->getMessage(), $exception);
+        }
+    }
+
+    public function delete(string $path): void
+    {
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $response = $this->client->request('DELETE', $location);
+            $statusCode = $response['statusCode'];
+
+            if ($statusCode !== 404 && ($statusCode < 200 || $statusCode >= 300)) {
+                throw new RuntimeException('Unexpected status code received while deleting file: ' . $statusCode);
+            }
+        } catch (Throwable $exception) {
+            if ( ! ($exception instanceof ClientHttpException && $exception->getCode() === 404)) {
+                throw UnableToDeleteFile::atLocation($path, $exception->getMessage(), $exception);
+            }
+        }
+    }
+
+    public function deleteDirectory(string $path): void
+    {
+        $location = $this->encodePath($this->prefixer->prefixDirectoryPath($path));
+
+        try {
+            $statusCode = $this->client->request('DELETE', $location)['statusCode'];
+
+            if ($statusCode !== 404 && ($statusCode < 200 || $statusCode >= 300)) {
+                throw new RuntimeException('Unexpected status code received while deleting file: ' . $statusCode);
+            }
+        } catch (Throwable $exception) {
+            if ( ! ($exception instanceof ClientHttpException && $exception->getCode() === 404)) {
+                throw UnableToDeleteDirectory::atLocation($path, $exception->getMessage(), $exception);
+            }
+        }
+    }
+
+    public function createDirectory(string $path, Config $config): void
+    {
+        $parts = explode('/', $this->prefixer->prefixDirectoryPath($path));
+        $directoryParts = [];
+
+        foreach ($parts as $directory) {
+            if ($directory === '.' || $directory === '') {
+                return;
+            }
+
+            $directoryParts[] = $directory;
+            $directoryPath = implode('/', $directoryParts);
+            $location = $this->encodePath($directoryPath) . '/';
+
+            if ($this->directoryExists($this->prefixer->stripDirectoryPrefix($directoryPath))) {
+                continue;
+            }
+
+            try {
+                $response = $this->client->request('MKCOL', $location);
+            } catch (Throwable $exception) {
+                throw UnableToCreateDirectory::dueToFailure($path, $exception);
+            }
+
+            if ($response['statusCode'] === 405) {
+                continue;
+            }
+
+            if ($response['statusCode'] !== 201) {
+                throw UnableToCreateDirectory::atLocation($path, 'Failed to create directory at: ' . $location);
+            }
+        }
+    }
+
+    public function setVisibility(string $path, string $visibility): void
+    {
+        if ($this->visibilityHandling === self::ON_VISIBILITY_THROW_ERROR) {
+            throw UnableToSetVisibility::atLocation($path, 'WebDAV does not support this operation.');
+        }
+    }
+
+    public function visibility(string $path): FileAttributes
+    {
+        throw UnableToRetrieveMetadata::visibility($path, 'WebDAV does not support this operation.');
+    }
+
+    public function mimeType(string $path): FileAttributes
+    {
+        $mimeType = (string) $this->propFind($path, 'mime_type', '{DAV:}getcontenttype');
+
+        return new FileAttributes($path, mimeType: $mimeType);
+    }
+
+    public function lastModified(string $path): FileAttributes
+    {
+        $lastModified = $this->propFind($path, 'last_modified', '{DAV:}getlastmodified');
+
+        return new FileAttributes($path, lastModified: strtotime($lastModified));
+    }
+
+    public function fileSize(string $path): FileAttributes
+    {
+        $fileSize = (int) $this->propFind($path, 'file_size', '{DAV:}getcontentlength');
+
+        return new FileAttributes($path, fileSize: $fileSize);
+    }
+
+    public function listContents(string $path, bool $deep): iterable
+    {
+        $location = $this->encodePath($this->prefixer->prefixDirectoryPath($path));
+        $response = $this->client->propFind($location, self::FIND_PROPERTIES, 1);
+
+        // This is the directory itself, the files are subsequent entries.
+        array_shift($response);
+
+        foreach ($response as $path => $object) {
+            $path = (string) parse_url(rawurldecode($path), PHP_URL_PATH);
+            $path = $this->prefixer->stripPrefix($path);
+            $object = $this->normalizeObject($object);
+
+            if ($this->propsIsDirectory($object)) {
+                yield new DirectoryAttributes($path, lastModified: $object['last_modified'] ?? null);
+
+                if ( ! $deep) {
+                    continue;
+                }
+
+                foreach ($this->listContents($path, true) as $child) {
+                    yield $child;
+                }
+            } else {
+                yield new FileAttributes(
+                    $path,
+                    fileSize:     $object['file_size'] ?? null,
+                    lastModified: $object['last_modified'] ?? null,
+                    mimeType:     $object['mime_type'] ?? null,
+                );
+            }
+        }
+    }
+
+    private function normalizeObject(array $object): array
+    {
+        $mapping = [
+            '{DAV:}getcontentlength' => 'file_size',
+            '{DAV:}getcontenttype' => 'mime_type',
+            'content-length' => 'file_size',
+            'content-type' => 'mime_type',
+        ];
+
+        foreach ($mapping as $from => $to) {
+            if (array_key_exists($from, $object)) {
+                $object[$to] = $object[$from];
+            }
+        }
+
+        array_key_exists('file_size', $object) && $object['file_size'] = (int) $object['file_size'];
+
+        if (array_key_exists('{DAV:}getlastmodified', $object)) {
+            $object['last_modified'] = strtotime($object['{DAV:}getlastmodified']);
+        }
+
+        return $object;
+    }
+
+    public function move(string $source, string $destination, Config $config): void
+    {
+        if ($source === $destination) {
+            return;
+        }
+
+        if ($this->manualMove) {
+            $this->manualMove($source, $destination);
+
+            return;
+        }
+
+        $this->createParentDirFor($destination);
+        $location = $this->encodePath($this->prefixer->prefixPath($source));
+        $newLocation = $this->encodePath($this->prefixer->prefixPath($destination));
+
+        try {
+            $response = $this->client->request('MOVE', $location, null, [
+                'Destination' => $this->client->getAbsoluteUrl($newLocation),
+            ]);
+
+            if ($response['statusCode'] < 200 || $response['statusCode'] >= 300) {
+                throw new RuntimeException('MOVE command returned unexpected status code: ' . $response['statusCode'] . "\n{$response['body']}");
+            }
+        } catch (Throwable $e) {
+            throw UnableToMoveFile::fromLocationTo($source, $destination, $e);
+        }
+    }
+
+    private function manualMove(string $source, string $destination): void
+    {
+        try {
+            $handle = $this->readStream($source);
+            $this->writeStream($destination, $handle, new Config());
+            @fclose($handle);
+            $this->delete($source);
+        } catch (Throwable $exception) {
+            throw UnableToMoveFile::fromLocationTo($source, $destination, $exception);
+        }
+    }
+
+    public function copy(string $source, string $destination, Config $config): void
+    {
+        if ($source === $destination) {
+            return;
+        }
+
+        if ($this->manualCopy) {
+            $this->manualCopy($source, $destination);
+
+            return;
+        }
+
+        $this->createParentDirFor($destination);
+        $location = $this->encodePath($this->prefixer->prefixPath($source));
+        $newLocation = $this->encodePath($this->prefixer->prefixPath($destination));
+
+        try {
+            $response = $this->client->request('COPY', $location, null, [
+                'Destination' => $this->client->getAbsoluteUrl($newLocation),
+            ]);
+
+            if ($response['statusCode'] < 200 || $response['statusCode'] >= 300) {
+                throw new RuntimeException('COPY command returned unexpected status code: ' . $response['statusCode']);
+            }
+        } catch (Throwable $e) {
+            throw UnableToCopyFile::fromLocationTo($source, $destination, $e);
+        }
+    }
+
+    private function manualCopy(string $source, string $destination): void
+    {
+        try {
+            $handle = $this->readStream($source);
+            $this->writeStream($destination, $handle, new Config());
+            @fclose($handle);
+        } catch (Throwable $exception) {
+            throw UnableToCopyFile::fromLocationTo($source, $destination, $exception);
+        }
+    }
+
+    private function propsIsDirectory(array $properties): bool
+    {
+        if (isset($properties['{DAV:}resourcetype'])) {
+            /** @var ResourceType $resourceType */
+            $resourceType = $properties['{DAV:}resourcetype'];
+
+            return $resourceType->is('{DAV:}collection');
+        }
+
+        return isset($properties['{DAV:}iscollection']) && $properties['{DAV:}iscollection'] === '1';
+    }
+
+    private function createParentDirFor(string $path): void
+    {
+        $dirname = dirname($path);
+
+        if ($this->directoryExists($dirname)) {
+            return;
+        }
+
+        $this->createDirectory($dirname, new Config());
+    }
+
+    private function propFind(string $path, string $section, string $property): mixed
+    {
+        $location = $this->encodePath($this->prefixer->prefixPath($path));
+
+        try {
+            $result = $this->client->propFind($location, [$property]);
+
+            if ( ! array_key_exists($property, $result)) {
+                throw new RuntimeException('Invalid response, missing key: ' . $property);
+            }
+
+            return $result[$property];
+        } catch (Throwable $exception) {
+            throw UnableToRetrieveMetadata::create($path, $section, $exception->getMessage(), $exception);
+        }
+    }
+
+    public function publicUrl(string $path, Config $config): string
+    {
+        return $this->client->getAbsoluteUrl($this->encodePath($this->prefixer->prefixPath($path)));
+    }
+}

vendor/league/flysystem-webdav/composer.json

@@ -0,0 +1,22 @@
+{
+    "name": "league/flysystem-webdav",
+    "description": "WebDAV filesystem adapter for Flysystem.",
+    "keywords": ["flysystem", "filesystem", "webdav", "files", "file"],
+    "autoload": {
+        "psr-4": {
+                "League\\Flysystem\\WebDAV\\": ""
+        }
+    },
+    "require": {
+        "php": "^8.0.2",
+        "league/flysystem": "^3.6.0",
+        "sabre/dav": "^4.6.0"
+    },
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Frank de Jonge",
+            "email": "info@frankdejonge.nl"
+        }
+    ]
+}