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

<?php

namespace App\Http\Controllers\API;

use App\Http\Controllers\Controller;
use App\Http\Requests\API\NamingRule\AutonameRequest;
use App\Http\Requests\API\NamingRule\CombinationSettingRequest;
use App\Http\Requests\API\NamingRule\CreateOrUpdateRequest;
use App\Http\Requests\API\NamingRule\ParseRequest;
use App\Http\Resources\API\NamingRuleCombinationResource;
use App\Http\Resources\API\NamingRuleResource;
use App\Http\Resources\API\NamingRuleSimpleResource;
use App\Models\Asset;
use App\Models\CustomField;
use App\Models\Enums\LibraryType;
use App\Models\NamingRule;
use App\Models\Project;
use App\Services\NamingRule\NamingRuleCheck;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;

class NameRuleController extends Controller
{
    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        $pageSize=$request->get('page_size') ?? 10;
        $sort=$request->input('sort','desc');
        $namingRules = NamingRule::allowed()->with(['company'])->filter($request->all())->orderBy('created_at',$sort)->paginate($pageSize);
        if(Auth::user()->super_admin){
            $namingRules->transform(function (NamingRule $namingRules) {
                $namingRules->display_id = $namingRules->id;
                return $namingRules;
            });
            return NamingRuleResource::collection($namingRules);
        }
        return NamingRuleResource::collection($namingRules);
    }


    /**
     * Store a newly created resource in storage.
     */
    public function store(CreateOrUpdateRequest $request)
    {
        $formData = $request->only(['name', 'status', 'company_id', 'global']);

        if (! Auth::user()->super_admin) {
            $formData['company_id'] = Auth::user()->company_id;
            unset($formData['global']);
        }

        NamingRule::create($formData);

        return $this->created();
    }

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

        return new NamingRuleResource($namingRule);
    }

    /**
     * Update the specified resource in storage.
     */
    public function update(CreateOrUpdateRequest $request, string $id)
    {
        $namingRule = NamingRule::query()->allowed()->findOrFail($id);

        $namingRule->fill($request->only([
            'name', 'status', 'global'
        ]));
        $namingRule->save();

        return $this->noContent();
    }

    /**
     * Remove the specified resource from storage.
     */
    public function destroy(string $id)
    {
        DB::transaction(function () use ($id) {
            $namerule = NamingRule::query()->allowed()->findOrFail($id);
            $namerule->delete();

            $customfield = CustomField::query()->where('group', $id);
            if (!empty($customfield)) {
                $customfield->delete();
            }
        });
            return $this->noContent();

    }

    public function enabled()
    {
        $namingRules = NamingRule::where('status', 1)->where(function ($query) {
            return $query->where("company_id", Auth::user()->company_id)->orWhere(function ($query){
                $query->where('company_id',0)->where( 'global',1);
            });
        })->select(['id', 'name'])->get();

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

    public function combinationSetting(CombinationSettingRequest $request, string $id)
    {
        $namingRule = NamingRule::query()->allowed()->findOrFail($id);

        $namingRule->combination_rules = $request->all();
        $namingRule->save();

        return $this->noContent();
    }

    public function combinationShow(string $id){
        $nameRule=NamingRule::query()->allowed()->findOrFail($id);

        return new NamingRuleCombinationResource($nameRule);
    }

    public function autoname(AutonameRequest $request, string $id)
    {
        $namingRule = NamingRule::query()->allowed()->findOrFail($id);

        if (! $namingRule->combination_rules) {
            return $this->badRequest("Please set naming combination rules");
        }

        $code = match ($request->code_type) {
            "project","container_project"=> Project::query()->find($request->code_id)?->code,
            "container_asset" => Asset::query()->find($request->code_id)?->code,
            "container_custom"=>'custom',
            default => ""
        };
        if (! $code) {
            return $this->badRequest("The supported type or selected item does not exist");
        }

        $name = $code;
        foreach ($namingRule->combination_rules as $rule) {
            if (! isset($request->fields[$rule['field']])) {
                return $this->badRequest(sprintf("%s field is required", $rule['field']));
            }

            $name .= $rule['link'] . $request->fields[$rule['field']];
        }

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

    public function parse(ParseRequest $request, string $id)
    {
        $namingRule = NamingRule::query()->allowed()->findOrFail($id);

        if (! $namingRule->combination_rules) {
            return $this->badRequest("Please set naming combination rules");
        }

        $code = match (LibraryType::from($request->object_type)) {
            LibraryType::PROJECT => Project::query()->find($request->object_id)?->code,
            LibraryType::ASSET => Asset::query()->find($request->object_id)?->code,
            LibraryType::CUSTOM =>"custom",
        };

        $namingRuleCheck = new NamingRuleCheck();

        $items = [];
        foreach ($request->names as $name) {
            $items[] = [
                'name' => $name,
                ...$namingRuleCheck->checkByName($name, $namingRule, $code)
            ];
        }

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