[增添]添加了datasource的setting数据库以及默认值

vendor/spatie/temporary-directory/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Spatie bvba <info@spatie.be>
+
+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/spatie/temporary-directory/README.md

@@ -0,0 +1,180 @@
+# Quickly create, use and delete temporary directories
+
+[![Latest Version on Packagist](https://img.shields.io/packagist/v/spatie/temporary-directory.svg?style=flat-square)](https://packagist.org/packages/spatie/temporary-directory)
+![Tests](https://github.com/spatie/temporary-directory/workflows/run-tests/badge.svg?label=tests)
+[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square)](LICENSE.md)
+[![Total Downloads](https://img.shields.io/packagist/dt/spatie/temporary-directory.svg?style=flat-square)](https://packagist.org/packages/spatie/temporary-directory)
+
+This package allows you to quickly create, use and delete a temporary directory in the system's temporary directory.
+
+Here's a quick example on how to create a temporary directory and delete it:
+
+```php
+use Spatie\TemporaryDirectory\TemporaryDirectory;
+
+$temporaryDirectory = (new TemporaryDirectory())->create();
+
+// Get a path inside the temporary directory
+$temporaryDirectory->path('temporaryfile.txt');
+
+// Delete the temporary directory and all the files inside it
+$temporaryDirectory->delete();
+```
+
+## Support us
+
+[<img src="https://github-ads.s3.eu-central-1.amazonaws.com/temporary-directory.jpg?t=1" width="419px" />](https://spatie.be/github-ad-click/temporary-directory)
+
+We invest a lot of resources into creating [best in class open source packages](https://spatie.be/open-source). You can support us by [buying one of our paid products](https://spatie.be/open-source/support-us).
+
+We highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using. You'll find our address on [our contact page](https://spatie.be/about-us). We publish all received postcards on [our virtual postcard wall](https://spatie.be/open-source/postcards).
+
+## Installation
+
+You can install the package via composer:
+
+```bash
+composer require spatie/temporary-directory
+```
+
+## Usage
+
+### Creating a temporary directory
+
+To create a temporary directory simply call the `create` method on a `TemporaryDirectory` object.
+
+```php
+(new TemporaryDirectory())->create();
+```
+
+Alternatively, use the static `make` method on a `TemporaryDirectory` object.
+
+```php
+TemporaryDirectory::make();
+```
+
+By default, the temporary directory will be created in a timestamped directory in your system's temporary directory (usually `/tmp`).
+
+### Naming your temporary directory
+
+If you want to use a custom name for your temporary directory instead of the timestamp call the `name` method with a string `$name` argument before the `create` method.
+
+```php
+(new TemporaryDirectory())
+   ->name($name)
+   ->create();
+```
+
+By default an exception will be thrown if a directory already exists with the given argument. You can override this behaviour by calling the `force` method in combination with the `name` method.
+
+```php
+(new TemporaryDirectory())
+   ->name($name)
+   ->force()
+   ->create();
+```
+
+### Setting a custom location for a temporary directory
+
+You can set a custom location in which your temporary directory will be created by passing a string `$location` argument to the `TemporaryDirectory` constructor.
+
+```php
+(new TemporaryDirectory($location))
+   ->create();
+```
+
+The `make` method also accepts a `$location` argument.
+
+```php
+TemporaryDirectory::make($location);
+```
+
+Finally, you can call the `location` method with a `$location` argument.
+
+```php
+(new TemporaryDirectory())
+   ->location($location)
+   ->create();
+```
+
+### Determining paths within the temporary directory
+
+You can use the `path` method to determine the full path to a file or directory in the temporary directory:
+
+```php
+$temporaryDirectory = (new TemporaryDirectory())->create();
+$temporaryDirectory->path('dumps/datadump.dat'); // return  /tmp/1485941876276/dumps/datadump.dat
+```
+
+### Emptying a temporary directory
+
+Use the `empty` method to delete all the files inside the temporary directory.
+
+```php
+$temporaryDirectory->empty();
+```
+
+### Deleting a temporary directory
+
+Once you're done processing your temporary data you can delete the entire temporary directory using the `delete` method. All files inside of it will be deleted.
+
+```php
+$temporaryDirectory->delete();
+```
+
+### Deleting a temporary directory when the object is destroyed
+
+If you want to automatically have the filesystem directory deleted when the object instance has no more references in
+its defined scope, you can enable `deleteWhenDestroyed()` on the TemporaryDirectory object.
+
+```php
+function handleTemporaryFiles()
+{
+    $temporaryDirectory = (new TemporaryDirectory())
+        ->deleteWhenDestroyed()
+        ->create();
+
+    // ... use the temporary directory
+
+    return; // no need to manually call $temporaryDirectory->delete()!
+}
+
+handleTemporaryFiles();
+```
+
+You can also call `unset()` on an object instance.
+
+## Testing
+
+```bash
+composer test
+```
+
+## Changelog
+
+Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.
+
+## Contributing
+
+Please see [CONTRIBUTING](https://github.com/spatie/.github/blob/main/CONTRIBUTING.md) for details.
+
+## Security Vulnerabilities
+
+Please review [our security policy](../../security/policy) on how to report security vulnerabilities.
+
+## Postcardware
+
+You're free to use this package, but if it makes it to your production environment we highly appreciate you sending us a postcard from your hometown, mentioning which of our package(s) you are using.
+
+Our address is: Spatie, Kruikstraat 22, 2018 Antwerp, Belgium.
+
+We publish all received postcards [on our company website](https://spatie.be/en/opensource/postcards).
+
+## Credits
+
+- [Alex Vanderbist](https://github.com/AlexVanderbist)
+- [All Contributors](../../contributors)
+
+## License
+
+The MIT License (MIT). Please see [License File](LICENSE.md) for more information.

vendor/spatie/temporary-directory/composer.json

@@ -0,0 +1,44 @@
+{
+    "name": "spatie/temporary-directory",
+    "description": "Easily create, use and destroy temporary directories",
+    "license": "MIT",
+    "keywords": [
+        "spatie",
+        "php",
+        "temporary-directory"
+    ],
+    "authors": [
+        {
+            "name": "Alex Vanderbist",
+            "email": "alex@spatie.be",
+            "homepage": "https://spatie.be",
+            "role": "Developer"
+        }
+    ],
+    "homepage": "https://github.com/spatie/temporary-directory",
+    "require": {
+        "php": "^8.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^9.5"
+    },
+    "minimum-stability": "dev",
+    "prefer-stable": true,
+    "autoload": {
+        "psr-4": {
+            "Spatie\\TemporaryDirectory\\": "src"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Spatie\\TemporaryDirectory\\Test\\": "tests"
+        }
+    },
+    "config": {
+        "sort-packages": true
+    },
+    "scripts": {
+        "test": "vendor/bin/phpunit",
+        "test-coverage": "vendor/bin/phpunit --coverage-html coverage"
+    }
+}

vendor/spatie/temporary-directory/src/Exceptions/InvalidDirectoryName.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Spatie\TemporaryDirectory\Exceptions;
+
+class InvalidDirectoryName extends \Exception
+{
+    public static function create(string $directoryName): static
+    {
+        return new static("The directory name `{$directoryName}` contains invalid characters.");
+    }
+}

vendor/spatie/temporary-directory/src/Exceptions/PathAlreadyExists.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Spatie\TemporaryDirectory\Exceptions;
+
+class PathAlreadyExists extends \Exception
+{
+    public static function create(string $path): static
+    {
+        return new static("Path `{$path}` already exists.");
+    }
+}

vendor/spatie/temporary-directory/src/TemporaryDirectory.php

@@ -0,0 +1,201 @@
+<?php
+
+namespace Spatie\TemporaryDirectory;
+
+use FilesystemIterator;
+use Spatie\TemporaryDirectory\Exceptions\InvalidDirectoryName;
+use Spatie\TemporaryDirectory\Exceptions\PathAlreadyExists;
+use Throwable;
+
+class TemporaryDirectory
+{
+    protected string $location;
+
+    protected string $name = '';
+
+    protected bool $forceCreate = false;
+
+    protected bool $deleteWhenDestroyed = false;
+
+    public function __construct(string $location = '')
+    {
+        $this->location = $this->sanitizePath($location);
+    }
+
+    public static function make(string $location = ''): self
+    {
+        return (new self($location))->create();
+    }
+
+    public function create(): self
+    {
+        if (empty($this->location)) {
+            $this->location = $this->getSystemTemporaryDirectory();
+        }
+
+        if (empty($this->name)) {
+            $this->name = mt_rand().'-'.str_replace([' ', '.'], '', microtime());
+        }
+
+        if ($this->forceCreate && file_exists($this->getFullPath())) {
+            $this->deleteDirectory($this->getFullPath());
+        }
+
+        if ($this->exists()) {
+            throw PathAlreadyExists::create($this->getFullPath());
+        }
+
+        mkdir($this->getFullPath(), 0777, true);
+
+        return $this;
+    }
+
+    public function force(): self
+    {
+        $this->forceCreate = true;
+
+        return $this;
+    }
+
+    public function name(string $name): self
+    {
+        $this->name = $this->sanitizeName($name);
+
+        return $this;
+    }
+
+    public function location(string $location): self
+    {
+        $this->location = $this->sanitizePath($location);
+
+        return $this;
+    }
+
+    public function path(string $pathOrFilename = ''): string
+    {
+        if (empty($pathOrFilename)) {
+            return $this->getFullPath();
+        }
+
+        $path = $this->getFullPath().DIRECTORY_SEPARATOR.trim($pathOrFilename, '/');
+
+        $directoryPath = $this->removeFilenameFromPath($path);
+
+        if (! file_exists($directoryPath)) {
+            mkdir($directoryPath, 0777, true);
+        }
+
+        return $path;
+    }
+
+    public function empty(): self
+    {
+        $this->deleteDirectory($this->getFullPath());
+
+        mkdir($this->getFullPath(), 0777, true);
+
+        return $this;
+    }
+
+    public function delete(): bool
+    {
+        return $this->deleteDirectory($this->getFullPath());
+    }
+
+    public function exists(): bool
+    {
+        return file_exists($this->getFullPath());
+    }
+
+    protected function getFullPath(): string
+    {
+        return $this->location.(! empty($this->name) ? DIRECTORY_SEPARATOR.$this->name : '');
+    }
+
+    protected function isValidDirectoryName(string $directoryName): bool
+    {
+        return strpbrk($directoryName, '\\/?%*:|"<>') === false;
+    }
+
+    protected function getSystemTemporaryDirectory(): string
+    {
+        return rtrim(sys_get_temp_dir(), DIRECTORY_SEPARATOR);
+    }
+
+    protected function sanitizePath(string $path): string
+    {
+        $path = rtrim($path);
+
+        return rtrim($path, DIRECTORY_SEPARATOR);
+    }
+
+    protected function sanitizeName(string $name): string
+    {
+        if (! $this->isValidDirectoryName($name)) {
+            throw InvalidDirectoryName::create($name);
+        }
+
+        return trim($name);
+    }
+
+    protected function removeFilenameFromPath(string $path): string
+    {
+        if (! $this->isFilePath($path)) {
+            return $path;
+        }
+
+        return substr($path, 0, strrpos($path, DIRECTORY_SEPARATOR));
+    }
+
+    protected function isFilePath(string $path): bool
+    {
+        return str_contains($path, '.');
+    }
+
+    protected function deleteDirectory(string $path): bool
+    {
+        try {
+            if (is_link($path)) {
+                return unlink($path);
+            }
+
+            if (! file_exists($path)) {
+                return true;
+            }
+
+            if (! is_dir($path)) {
+                return unlink($path);
+            }
+
+            foreach (new FilesystemIterator($path) as $item) {
+                if (! $this->deleteDirectory((string) $item)) {
+                    return false;
+                }
+            }
+
+            /*
+             * By forcing a php garbage collection cycle using gc_collect_cycles() we can ensure
+             * that the rmdir does not fail due to files still being reserved in memory.
+             */
+            gc_collect_cycles();
+
+            return rmdir($path);
+        } catch (Throwable) {
+            return false;
+        }
+    }
+
+    public function deleteWhenDestroyed(bool $deleteWhenDestroyed = true): self
+    {
+        $this->deleteWhenDestroyed = $deleteWhenDestroyed;
+
+        return $this;
+    }
+
+    public function __destruct()
+    {
+        if ($this->deleteWhenDestroyed) {
+            $this->delete();
+        }
+    }
+}