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\Http\Resources\API\UserProfileResource;
use App\Models\Enums\FolderObjectType;
use App\Models\Enums\ObjectApprovalStatus;
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;
use function Symfony\Component\String\s;

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::select(['id', 'name', 'parent_id'])->withCount('children')->withCount('files')
            ->where([
                'object_type' => $objectType,
                'object_id' => $objectId,
            ])
            ->where('parent_id', $parentFolderId)
            ->orderByDesc("sequence")
            ->get()
            ->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']];
                $data['updated_by'] = Auth::user()->id;
                $folder->fill($data);
                $folder->save();
            } else {
                $folder = Folder::query()->create([
                    'company_id' => Auth::user()->company_id,
                    ...$objectWhere,
                    'parent_id' => $request->parent_id,
                    ...$data,
                    'created_by' => Auth::user()->id,
                ]);

                $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;

        $docStages = $request->get('doc_stage', []); // 支持多选
        $docTypes = $request->get('doc_type', []); // 支持多选
        $type = $request->get('type', []); // 支持多选
        $namingRuleId = $request->get('naming_rule_id');
        $statusCode = $request->get('RevisionCodes');
        $revisionCodes = $request->get('RevisionCodes');
        $name = $request->get('name');
        $approvalStatus = $request->get('approval_status', []); // 支持多选

        $folderId = $request->get("id", 0);
        $orderByFiled = $request->get('order_by_column','updated_at');// 设置默认字段
        $orderByType = $request->get('order_by_direction','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']);
        }])
            ->where($objectWhere)
            ->when($name, fn($query) => $query->where("name", "like", "%$name%"))
            ->when($folderId, fn($query) => $query->where("parent_id", $folderId))
            ->when(! $folderId, fn($query) => $query->where("parent_id", 0))
            ->when($namingRuleId, fn($query) => $query->where("naming_rule_id", $namingRuleId))
            ->when($type, fn($query) => $query->whereRaw("1=?", in_array('folder', $type) ? 1 : 0))
            ->orderBy(in_array($orderByFiled, Folder::getColumns()) ? $orderByFiled : 'updated_at', $orderByType)
            ->paginate($pageSize);
        $folders_total = $folders->total();

        $index=1;
        $folders = $folders->map(function (Folder $folder) use (&$index) {
            $folder->display_id=(string)$index++;
            return $folder;
        });

       $fileQuery = File::query()->where($objectWhere)
            ->with('bimFile')
            ->where("folder_id", $folderId)
            ->where("is_latest_version", 1)
            ->when($name, fn($query) => $query->where("title", "like", "%$name%"))
            ->when($docStages, fn($query) => $query->whereIn('doc_stage', $docStages))
            ->when($docTypes, fn($query) => $query->whereIn('doc_type', $docTypes))
            ->when($namingRuleId, fn($query) => $query->where('naming_rule_id', $namingRuleId))
            ->when($type, fn($query) => $query->whereIn("extension", $type))
            ->when($statusCode, fn($query) => $query->whereRaw('naming_rules->>"$.StatusCode"=?', $statusCode))
            ->when($revisionCodes, fn($query) => $query->whereRaw('naming_rules->>"$.RevisionCodes"=?', $revisionCodes))
            ->when($approvalStatus, fn($query) => $query->whereIn('approval_status', $approvalStatus))
            ->orderBy(in_array($orderByFiled, File::getColumns()) ? $orderByFiled : 'updated_at', $orderByType);

        $files = $fileQuery->get();

        $files_total = $files->count();

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

            $files = $fileQuery->offset($offset)->limit($limit)->get();
            //因为要接着文件夹进行文件id递增
            $folderCount=$folders->count()+1;
            $files->map(function (File $file) use (&$folderCount) {
                $file->approval_status = match ($file->approval_status) {
                    ObjectApprovalStatus::WAIT->value => 'Not Submitted',
                    ObjectApprovalStatus::DOING->value => 'Pending for Approval',
                    ObjectApprovalStatus::APPROVED->value => 'A-Approved & B-Approved w/comment',
                    ObjectApprovalStatus::REJECTED->value => 'D-Rejected',
                    ObjectApprovalStatus::CANCELED->value => 'Cancelled',
                    ObjectApprovalStatus::RESUBMISSION->value => "C-Resubmission Reg'd",
                    default => 'Not Submitted'
                };
                $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' => FolderDetailResource::collection($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');
        $docStages = $request->get('doc_stage', []); // 支持多选
        $docTypes = $request->get('doc_type', []); // 支持多选
        $namingRuleIds = $request->get('naming_rule_id', []); // 支持多选

        $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) : [];

        $fileQuery = File::query()
            ->with('bimFile')
            ->where($objectWhere)
            ->where('title','like',"%$name%")
            ->where("is_latest_version", 1);

        // 添加doc_stage多选过滤
        if (!empty($docStages)) {
            $fileQuery->whereIn('doc_stage', $docStages);
        }

        // 添加doc_type多选过滤
        if (!empty($docTypes)) {
            $fileQuery->whereIn('doc_type', $docTypes);
        }

        // 添加naming_rule_id多选过滤
        if (!empty($namingRuleIds)) {
            $fileQuery->whereIn('naming_rule_id', $namingRuleIds);
        }

        $file = $fileQuery->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();
    }
}