autocde2.0/app/Services/File/Upload/FilesUploadTrait.php

<?php

namespace App\Services\File\Upload;

use App\BO\BimFileBO;
use App\Http\Resources\API\FileUploadSuccessResource;
use App\Libraries\BIM\BIMFactory;
use App\Libraries\ChunkedUpload\ChunkedUploadFactory;
use App\Models\BimFile;
use App\Models\ContainerContent;
use App\Models\Enums\ActionObjectType;
use App\Models\Enums\FileObjectType;
use App\Models\Enums\ObjectAction;
use App\Models\File;
use App\Repositories\ActionRepository;
use App\Services\NamingRule\NamingRuleCheck;
use Illuminate\Http\Request;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Storage;

trait FilesUploadTrait
{
    protected ?FileObjectType $fileObjectType = null;

    protected $object = null;

    private function isBIM(string $ext)
    {
        return in_array($ext, array_merge(config('bim.gis_extensions'), config('bim.extensions')));
    }

    protected function checkRequestData(Request $request): int
    {
        $this->fileObjectType = FileObjectType::from($request->object_type);

        if ($request->object_id) {
            $this->object = $this->fileObjectType->modelBuilderAllowed($request->object_id)->findOrFail($request->object_id);
        }

        $nameRuleCheck = new NamingRuleCheck($this->fileObjectType, $this->object);

        $filesSize = 0;

        $files = $request->file("files");//文件流
        if ($files) {
            $fileNames = $this->request->get("file_names", []);
            foreach ($files as $index => $file) {
                throw_validation_if(!$file->isValid(), "File upload failed.");

                $filesSize += $file->getSize();

                $nameRuleCheck->checkByFileName($fileNames[$index] ?? $file->getClientOriginalName());
            }
        } else {//文件路径
            $files = $request->get('files', []);

            foreach ($files as $file) {
                $filesSize += (int) ($file['size'] ?? 0);
                $nameRuleCheck->checkByFileName($file['title']);
            }
        }


        throw_validation_if(
            $filesSize + Auth::user()->company->used_storage_capacity > Auth::user()->company->storage_size,
            "Storage capacity is insufficient, please contact the administrator."
        );

        return $filesSize;
    }

    protected function buildFileArr(string $extension, string $fileName, string $path = '', int $size = 0, Request $request)
    {
        return [
            'pathname' => $path,
            'title' => $fileName,
            'size' => $size,
            'extension' => $extension,
            'object_type' => $request->object_type,
            'object_id' => $request->object_id,
            'created_by' => Auth::id(),
            'company_id' => Auth::user()->company_id,
            'source' => $request->get("source", 1),
            'uuid' => $request->get("uuid"),
            'folder_id' => $request->get("folder_id", 0),
        ];
    }

    protected function uploadFileWithPath(Request $request, string $path, string $fileName, int $size = 0)
    {
        $extension = pathinfo($path, PATHINFO_EXTENSION);

        $gisType = $request->input('gis_type', '');

        $fileArr = $this->buildFileArr($extension, $fileName, $path, $size, $request);
        $fileArr['is_bim'] = 0;

        if ($this->isBIM($extension) || $gisType == 'osgb' && $request->object_type == FileObjectType::CONTAINER->value) {
            $fileArr['is_bim'] = 1;
        }

        $uploadedFile = $this->storeFile($fileArr);

        return $uploadedFile;
    }

    protected function uploadFile(Request $request, UploadedFile $file, ?ProgressBar $progressBar = null): array
    {
        $extension = $file->getClientOriginalExtension()
            ? $file->getClientOriginalExtension()
            : pathinfo($file->getClientOriginalName(), PATHINFO_EXTENSION);

        $pathname = ChunkedUploadFactory::make()->upload(
            $file,
            cos_upload_prefix(Auth::user()->company_id, $request->get("object_type")),
            sprintf("%s.%s", md5(uniqid()), $extension),
            $progressBar
        );

        $data = [
            'bim' => [],
        ];

        $gisType = $request->input('gis_type', '');

        if ($this->isBIM($extension) || $gisType == 'osgb' && $request->object_type == FileObjectType::CONTAINER->value) {
            $bimFileBO = new BimFileBO($extension, $file->getClientOriginalName(), Auth::user()->name, $gisType);
            $bimFileBO->setPointCloudConfigJson($request->input('pointCloudConfigJson', []));

            $data['bim'] = BIMFactory::make()->uploadFile($file, $bimFileBO);
        }

        $data['file'] = [
            'pathname' => $pathname,
            'title' => $file->getClientOriginalName(),
            'size' => $file->getSize(),
            'extension' => $extension,
            'object_type' => $request->object_type,
            'object_id' => $request->object_id,
            'created_by' => Auth::id(),
            'company_id' => Auth::user()->company_id,
            'source' => $request->get("source", 1),
            'uuid' => $request->get("uuid"),
            'is_bim' => count($data['bim']) > 0 ? 1 : 0,
        ];

        return $data;
    }

    protected function storeFile(array $fileArr): File
    {
        if ($fileArr['object_id'] && $fileArr['source'] == 1 || $fileArr['uuid'] && $fileArr['source'] == 1) {
            $version = File::query()
                ->where('object_type', $fileArr['object_type'])
                ->where('object_id', $fileArr['object_id'])
                ->where("title", $fileArr['title'])
                ->where("source", 1)
                ->where("folder_id", $fileArr['folder_id'] ?? 0)
                ->count();
            $fileArr['version'] = $version + 1;
            $fileArr['is_latest_version'] = 1;

            File::query()
                ->where('object_type', $fileArr['object_type'])
                ->where('object_id', $fileArr['object_id'])
                ->where("title", $fileArr['title'])
                ->where("folder_id", $fileArr['folder_id'] ?? 0)
                ->where("source", 1)
                ->where("is_latest_version", 1)
                ->update([
                    'is_latest_version' => 0
                ]);
        }

        $file = File::query()->create($fileArr);

        BimFile::create([
            'file_id' => $file->id,
            'bim_driver' => config("bim.default"),
        ]);

        ActionRepository::create($file->id, ActionObjectType::CONTAINER_FILE, ObjectAction::UPLOADED);

        return $file;
    }

    protected function storeFiles(array $items)
    {
        $uploadedFiles = [];
        foreach ($items as $item) {
            $fileInfo = $item['file'];
            if ($fileInfo['object_id'] && $fileInfo['source'] == 1 || $fileInfo['uuid'] && $fileInfo['source'] == 1) {
                $version = File::query()
                    ->where('object_type', $fileInfo['object_type'])
                    ->where('object_id', $fileInfo['object_id'])
                    ->where("title", $fileInfo['title'])
                    ->where("source", 1)
                    ->where("folder_id", $fileInfo['folder_id'] ?? 0)
                    ->count();
                $fileInfo['version'] = $version + 1;
                $fileInfo['is_latest_version'] = 1;

                File::query()
                    ->where('object_type', $fileInfo['object_type'])
                    ->where('object_id', $fileInfo['object_id'])
                    ->where("title", $fileInfo['title'])
                    ->where("folder_id", $fileInfo['folder_id'] ?? 0)
                    ->where("source", 1)
                    ->where("is_latest_version", 1)
                    ->update([
                        'is_latest_version' => 0
                    ]);
            }

            $file = File::query()->create($fileInfo);

            if (isset($item['bim']) && $item['bim']) {
                BimFile::query()->create([
                    'file_id' => $file->id,
                    ...$item['bim']
                ]);
            }

            ActionRepository::create($file->id, ActionObjectType::CONTAINER_FILE, ObjectAction::UPLOADED);

            $uploadedFiles[] = new FileUploadSuccessResource($file);
        }

        $this->updateObjectVersion();

        return $uploadedFiles;
    }


    protected function updateObjectVersion()
    {
        if (!$this->object) {
            return;
        }

        if ($this->fileObjectType == FileObjectType::CONTAINER) {
            $version = $this->object->version;

            $this->object->version++;
            $this->object->save();

            $fileIds = File::query()->where([
                'object_type' => $this->fileObjectType->value,
                'object_id' => $this->object->id
            ])->pluck("id");

            ContainerContent::query()->create([
                ...$this->object->content($version)->first()->toArray(),
                'created_by' => Auth::id(),
                'files' => $fileIds->join(","),
                'version' => $this->object->version,
            ]);
        }
    }

    protected function updateUsedStorageCapacity(int $filesSize)
    {
        $company = Auth::user()->company;
        $company->increment("used_storage_capacity", $filesSize);
        $company->save();
    }
}