autocde2.0/app/Http/Controllers/API/FolderController.php

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use App\Http\Requests\API\Folder\CreateRequest;
use App\Http\Requests\API\Folder\UpdateRequest;
use App\Http\Resources\API\FileByObjectResource;
use App\Http\Resources\API\FileVersioTreeByObjectResource;
use App\Http\Resources\API\FolderDetailResource;
use App\Models\Enums\FolderObjectType;
use App\Models\File;
use App\Models\Folder;
use App\Models\Library;
use App\Services\File\FileService;
use App\Services\File\FolderUrlService;
use App\Services\Folder\FoldersService;
use App\Services\Folder\VersionFileTreeByObjectService;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;

class FolderController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function tree(string $objectType, string $objectId, $parentFolderId = 0)
    {
        $folderObjectType = FolderObjectType::from($objectType);

        $object=$folderObjectType->modelBuilderAllowed()->with(['library'])->findOrFail($objectId);

        $folders = Folder::withCount('children')
            ->where([
                'object_type' => $objectType,
                'object_id' => $objectId,
            ])
            ->where('parent_id', $parentFolderId)
            ->orderByDesc("sequence")
            ->get([
                'id',
                'name',
                'parent_id'
            ])
            ->each(function ($folders){
                $folders->type='folder';
                $folders->uniId=$folders->type.'_'.$folders->id;
            });

        $container=[
            'id'=>$object->id,
            'name'=>$object->name,
            'naming_rule_id'=>$object->naming_rule_id,
            'naming_rules'=>$object->naming_rules,
            'object_type'=>$object->library->type,
            'asset_id'=>$object->library->asset_id,
            'project_id'=>$object->library->project_id,
        ];

        return $this->success([
            'object'=> $container,
            'data' => $folders
        ]);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(CreateRequest $request)
    {
        $folderObjectType = FolderObjectType::from($request->object_type);

        $object = $folderObjectType->modelBuilderAllowed()->findOrFail($request->object_id);

        $objectWhere = [
            'object_type' => $folderObjectType->value, 'object_id' => $object->id
        ];

        $parentFolder = $request->parent_id > 0
            ? Folder::query()->where($objectWhere)->findOrFail($request->parent_id)
            : null;

        $names = [];
        $updateFolders = [];

        foreach ($request->items as $item) {
            if (! isset($item['name']) || !$item['name']) {
                return $this->badRequest("Folder name cannot be empty");
            }

            if (in_array($item['name'], $names)) {
                return $this->badRequest("Folder names must be unique");
            }
            $names[] = $item['name'];

            $isUpdate = isset($item['id']) && $item['id'];

            $count = Folder::query()
                ->where($objectWhere)
                ->where("parent_id", $request->parent_id)
                ->when($isUpdate, function ($query) use ($item) {
                    return $query->where("id", "!=", $item['id']);
                })
                ->where("name", $item['name'])
                ->count();
            if ($count > 0) {
                return $this->badRequest(sprintf("Folder '%s' must be unique", $item['name']));
            }

            if ($isUpdate) {
                $folder = Folder::query()
                    ->where($objectWhere)
                    ->where("parent_id", $request->parent_id)
                    ->find($item['id']);
                if (! $folder) {
                    return $this->badRequest("Illegal parameters or the file relationship that needs to be updated has changed.");
                }

                $updateFolders[$item['id']] = $folder;
            }
        }

        foreach ($request->items as $item) {
            $isUpdate = isset($item['id']) && $item['id'];
            $data = [
                'name' => $item['name'],
                'sequence' => data_get($item, "sequence", 0),
            ];

            if ($isUpdate) {
                $folder = $updateFolders[$item['id']];
                $folder->fill($data);
                $folder->save();
            } else {
                $folder = Folder::query()->create([
                    'company_id' => Auth::user()->company_id,
                    ...$objectWhere,
                    'parent_id' => $request->parent_id,
                    ...$data
                ]);

                $folder->path = $parentFolder ? $parentFolder?->path . $folder->id . "," : sprintf(",%s,", $folder->id);
                $folder->naming_rule_id = $parentFolder?->naming_rule_id;
                $folder->save();
            }
        }

        return $this->created();
    }

    /**
     * Display the specified resource.
     */
    public function show(string $id)
    {
        $folder = Folder::query()->findOrFail($id);

        return new FolderDetailResource($folder);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(UpdateRequest $request, string $id)
    {
        $folder = Folder::query()->findOrFail($id);

        $folderObjectType = FolderObjectType::from($folder->object_type);

        $object = $folderObjectType->modelBuilderAllowed()->findOrFail($folder->object_id);

        $objectWhere = [
            'object_type' => $folderObjectType->value, 'object_id' => $object->id
        ];

        $parentFolder = Folder::query()->where($objectWhere)->findOrFail($request->parent_id ?? $folder->id);
        if (! $parentFolder) {
            return $this->badRequest("Parent folder does not exist");
        }

        $count = Folder::query()
            ->where($objectWhere)
            ->where("parent_id", $request->parent_id)
            ->where("name", $request->name)
            ->where("id", "!=", $folder->id)
            ->count();
        if ($count > 0) {
            return $this->badRequest(sprintf("Folder '%s' must be unique", $request->name));
        }

        $fields = ['name', 'sequence'];
        if ($parentFolder?->id == $folder->parent_id) {
            $folder->fill($request->only($fields));
            $folder->save();
        } else {
            $path = $parentFolder->path . $folder->id . ",";
            $folderData = [
                ...$request->only($fields),
                'path' => $path,
                'parent_id' => $request->parent_id,
            ];

            $children = Folder::query()
                ->where($objectWhere)
                ->where("id", "!=", $folder->id)
                ->where("path", "like", "%," . $folder->id . ",%")
                ->get();

            foreach ($children as $child) {
                $child->fill([
                    'path' => str_replace($folder->path, $path, $child->path),
                ]);
                $child->save();
            }

            $folder->fill($folderData);
            $folder->save();
        }

        return $this->noContent();
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(string $id)
    {
        $folder = Folder::query()->findOrFail($id);

        $folderObjectType = FolderObjectType::from($folder->object_type);

        $folderObjectType->modelBuilderAllowed()->findOrFail($folder->object_id);

        $children = Folder::query()->where("parent_id", $folder->id)->count();
        if ($children > 0) {
            return $this->badRequest("Subordinate folders or containers exist and are not allowed to be deleted.");
        }

        $folder->files()->delete();

        $folder->delete();

        return $this->noContent();
    }

    public function open(Request $request)
    {
        $pageSize = $request->get('page_size') ?? 10;
        $page = $request->get('page') ?? 1;

        $folderId = $request->get("id", 0);
        $orderBy=$request->get('order_by','desc');
        if ($folderId > 0) {
            $folder = Folder::query()->findOrFail($folderId);
            $objectType = $folder->object_type;
            $objectId = $folder->object_id;
        } else {
            $objectType = $request->get("object_type");
            $objectId = $request->get("object_id");
        }

        $folderObjectType = FolderObjectType::from($objectType);

        $object=$folderObjectType->modelBuilderAllowed()->with(['library'])->findOrFail($objectId);


        $objectWhere = ['object_type' => $objectType, 'object_id' => $objectId,];
        $folders = Folder::with(["namingRule" => function ($query) {
            $query->select(['id', 'name', 'combination_rules']);
        }])
            ->select(['id', 'name', 'naming_rule_id'])
            ->where($objectWhere)
            ->when($folderId, fn($query) => $query->where("parent_id", $folderId))
            ->when(! $folderId, fn($query) => $query->where("parent_id", 0))
            ->orderBy('updated_at', $orderBy)
            ->paginate($pageSize);
        $folders_total = $folders->total();
        $sonFolderCount=Folder::query()
            ->where($objectWhere)
            ->whereIn('parent_id',$folders->pluck('id'))
            ->selectRaw("count(*) as cut, parent_id")
            ->groupBy("parent_id")
            ->pluck("cut", "parent_id");

        $sonFileCount=File::query()
            ->where($objectWhere)
            ->whereIn('folder_id',$folders->pluck('id'))
            ->where("is_latest_version", 1)
            ->selectRaw("count(*) as cut, folder_id")
            ->groupBy("folder_id")
            ->pluck("cut", "folder_id");


        $index=1;
        $folders = $folders->map(function (Folder $folder) use ($sonFolderCount,$sonFileCount,&$index) {
            $folder->itemCount =$sonFolderCount->get($folder->id, 0)+$sonFileCount->get($folder->id, 0);
            $folder->type = 'folder';
            $folder->uniId = $folder->type . '_' . $folder->id;
            $folder->display_id=(string)$index++;
            return $folder;
        });

        $files = File::query()->where($objectWhere)
            ->with('bimFile')
            ->where("folder_id", $folderId)
            ->where("is_latest_version", 1)
            ->orderBy('updated_at', $orderBy)
            ->get();

        $files_total = $files->count();

        $total = $files_total + $folders_total;
        //分页
        if ($folders_total < $pageSize * $page){
            $offset = $pageSize * $page - $folders_total <= $pageSize ?  0 : $pageSize  * $page - $pageSize * ($page - 1) - $folders_total ; // 查看当前页面是否有包含文件夹
            $limit = $pageSize * $page - $folders_total > $pageSize ? $pageSize : $pageSize * $page - $folders_total;

            $files = File::query()->where($objectWhere)
                ->with('bimFile')
                ->where("folder_id", $folderId)
                ->where("is_latest_version", 1)
                ->orderBy('updated_at', $orderBy)
                ->offset($offset)
                ->limit($limit)
                ->get();
            //因为要接着文件夹进行文件id递增
            $folderCount=$folders->count()+1;
            $files->map(function (File $file) use (&$folderCount) {
                $file->display_id=$folderCount++;
            });
        }else{
            //目录的总数 大于 显示数 时，不显示文件列表
            $files = [];
        }

        //因为要接着文件夹进行文件id递增


        $container=[
            'id'=>$object->id,
            'name'=>$object->name,
            'naming_rule_id'=>$object->naming_rule_id,
            'naming_rules'=>$object->naming_rules,
            'object_type'=>$object->library->type,
            'asset_id'=>$object->library->asset_id,
            'project_id'=>$object->library->project_id,
        ];


        return $this->success([
            'object'=>$container,
            'data' => [
                'folders' => $folders,
                'total' => $folders_total + $files_total,
                'files' => FileByObjectResource::collection($files),
                'folder_parent_id'=>$folderId>0?$folder->parent_id:$folderId,
                'folder_parent_name'=>$folderId>0?$folder->parent?->name:''
            ]
        ]);
    }

    /**
     * 基于类型的文件夹、文件版本树
     *
     * @param Request $request
     * @param string $objectType
     * @param string $objectId
     * @return \Illuminate\Http\JsonResponse
     */
    public function versionFileTreeByObject(Request $request, string $objectType, string $objectId)
    {
        $tree = (new VersionFileTreeByObjectService($request->all(), $objectType, $objectId))->versionFileTreeByObject();

        return $this->success([
            'data' => $tree
        ]);
    }

    /**
     * 基于容器文件夹改名字
     */
    public function changeName(UpdateRequest $request,string $id){
        $newName=$request->name;
        $folder=Folder::query()->findOrFail($id);
        $objectWhere = [
            'object_type' => $folder->object_type, 'object_id' => $folder->object_id
        ];
        $folders=Folder::query()->where('parent_id',$request->parent_id)->where($objectWhere)->pluck('name');
        if($folders->contains($newName)&&$newName!=$folder->name){
            return $this->badRequest("Folder '%s' must be unique", $newName);
        }else{
            $folder->name=$newName;
            $folder->save();
            return $this->noContent();
        }

    }

    public function search(Request $request,FolderUrlService $service){
        $objectType = $request->get("object_type");
        $objectId = $request->get("object_id");
        $name=$request->get('name');

        $folderObjectType = FolderObjectType::from($objectType);

        $folderObjectType->modelBuilderAllowed()->findOrFail($objectId);

        $objectWhere = ['object_type' => $objectType, 'object_id' => $objectId,];

        $folders = Folder::query()
            ->where($objectWhere)
            ->where('name','like',"%$name%")
            ->get();

        $newFolders=$folders?$service->folderFormat($folders):[];

        $file=File::query()
            ->with('bimFile')
            ->where($objectWhere)
            ->where('title','like',"%$name%")
            ->where("is_latest_version", 1)
            ->get();
        $folderCount=count($newFolders)+1;
        $newFiles=$file?$service->filesFormat($file,$folderCount):[];


        return $this->success([
            'data' => [
                'folders' => $newFolders,
                'files' => $newFiles,
            ]
        ]);

    }

    /**
     * 针对一级文件夹设定命名规则
     *
     * @param string $folderId
     * @param string $namingRuleId
     * @param FoldersService $foldersService
     * @return void
     */
    public function applyNaming(string $folderId, string $namingRuleId, FoldersService $foldersService): void
    {
        $foldersService->applyNaming($folderId, $namingRuleId);
        $this->noContent();
    }
}