ldc-ovoteam/app/Http/Controllers/Back/ProductController.php

<?php

declare(strict_types=1);

namespace App\Http\Controllers\Back;

use App\Http\Requests\Back\Products\IndexProductRequest;
use App\Http\Requests\Back\Products\StoreProductRequest;
use App\Http\Requests\Back\Products\UpdateProductRequest;
use App\Http\Resources\CommonResource;
use App\Models\Product;
use Domain\Models\ValueObjects\Products\BreedingMethod;
use Domain\Models\ValueObjects\Products\Business;
use Domain\Models\ValueObjects\Products\ProductCategory;
use Domain\Models\ValueObjects\Products\ProductFormat;
use Domain\Models\ValueObjects\Products\Technology;
use Illuminate\Contracts\Session\Session;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Inertia\Response;

class ProductController extends BackendController
{
    public function __construct(
        Request $request,
        Session $session,
    ) {
        parent::__construct(
            $request,
            $session
        );

        $this->modelName = Product::modelName();
        $this->modelPage = Product::modelPage();
    }

    public function index(IndexProductRequest $request): Response
    {
        $this->authorize('viewAny', Product::class);

        /** @var \Illuminate\Database\Eloquent\Builder<\App\Models\Product> $query */
        $query = Product::query();

        if ($request->routeIs("back.{$this->modelName}.trash")) {
            $query = $query->onlyTrashed();
        }

        $searchValue = $request->getSearchValue();
        if ($searchValue) {
            $this->searchQuery(
                $query,
                $searchValue,
                null,
                'name'
            );
        }
        $searchFields = \implode(', ', [
            trans('validation.attributes.name'),
        ]);

        $this->sortQuery($query);

        $paginatedModels = $this->paginate($query);

        return $this->inertiaRender("back/Pages/{$this->modelPage}/Index", [
            'paginatedModels' => CommonResource::collection($paginatedModels),
            'search'          => $searchValue,
            'searchFields'    => $searchFields,
        ]);
    }

    public function show(Product $product): RedirectResponse
    {
        $this->authorize('viewAny', Product::class);

        // FIXME: Use the route name instead.
        return redirect("/produits/{$product->slug}");
    }

    public function create(Product $product): Response
    {
        $this->authorize('create', Product::class);

        return $this->inertiaRender("back/Pages/{$this->modelPage}/Create", [
            'data'                => CommonResource::make($product),
            'enumProductCategory' => ProductCategory::toArray(),
            'enumTechnology'      => Technology::toArray(),
            'enumBreedingMethod'  => BreedingMethod::toArray(),
            'enumBusiness'        => Business::toArray(),
            'enumProductFormat'   => ProductFormat::toArray(),
        ]);
    }

    public function store(StoreProductRequest $request): RedirectResponse
    {
        $this->authorize('create', Product::class);

        return DB::transaction(function () use ($request) {
            $product = new Product();
            $product->inertiaFill($request->validated());

            if ($product->saveOrFail()) {
                return redirect()->route("back.{$this->modelName}.edit", $product)
                    ->with('success', trans('uwil-backend::crud.messages.has_been_created', [
                        'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                    ]));
            }

            return redirect()->back()
                ->with('error', trans('uwil-backend::crud.messages.cannot_be_created', [
                    'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                ]));
        });
    }

    public function edit(Product $product): Response
    {
        $this->authorize('update', $product);

        return $this->inertiaRender("back/Pages/{$this->modelPage}/Edit", [
            'data'                => CommonResource::make($product),
            'enumProductCategory' => ProductCategory::toArray(),
            'enumTechnology'      => Technology::toArray(),
            'enumBreedingMethod'  => BreedingMethod::toArray(),
            'enumBusiness'        => Business::toArray(),
            'enumProductFormat'   => ProductFormat::toArray(),
        ]);
    }

    public function update(
        UpdateProductRequest $request,
        Product $product
    ): RedirectResponse {
        $this->authorize('update', $product);

        return DB::transaction(function () use ($request, $product) {
            $product->inertiaFill($request->validated());

            if ($product->saveOrFail()) {
                return redirect()->route("back.{$this->modelName}.edit", $product)
                    ->with('success', trans('uwil-backend::crud.messages.has_been_updated', [
                        'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                    ]));
            }

            return redirect()->route("back.{$this->modelName}.edit", $product)
                ->with('error', trans('uwil-backend::crud.messages.cannot_be_updated', [
                    'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                ]));
        });
    }

    public function duplicate(Product $product): Response
    {
        return $this->create($product->replicate());
    }

    public function restore(int $product): RedirectResponse
    {
        $this->authorize('restore', $product);
        $product = Product::withTrashed()->findOrFail($product);

        $previousQueries = $this->getPreviousQueries();

        if ($product->restore()) {
            return redirect()->route("back.{$this->modelName}.trash", $previousQueries)
                ->with('success', trans('uwil-backend::crud.messages.has_been_restored', [
                    'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                ]));
        }

        return redirect()->back()
            ->with('error', trans('uwil-backend::crud.messages.cannot_be_restored', [
                'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
            ]));
    }

    public function destroy(Product $product): RedirectResponse
    {
        $this->authorize('delete', $product);
        $previousQueries = $this->getPreviousQueries();

        if ($product->delete()) {
            return redirect()->route("back.{$this->modelName}.index", $previousQueries)
                ->with('success', trans('uwil-backend::crud.messages.has_been_deleted', [
                    'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                ]));
        }

        return redirect()->back()
            ->with('error', trans('uwil-backend::crud.messages.cannot_be_deleted', [
                'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
            ]));
    }

    public function forceDestroy(Product | int $product): RedirectResponse
    {
        $this->authorize('forceDelete', $product);

        if (is_int($product)) {
            $product = Product::withTrashed()->findOrFail($product);
        }

        $previousQueries = $this->getPreviousQueries();

        if ($product->forceDelete()) {
            return redirect()->route("back.{$this->modelName}.trash", $previousQueries)
                ->with('success', trans('uwil-backend::crud.messages.has_been_deleted', [
                    'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
                ]));
        }

        return redirect()->back()
            ->with('error', trans('uwil-backend::crud.messages.cannot_be_deleted', [
                'model' => Str::ucfirst(trans_choice("models.classes.{$this->modelName}", 1)),
            ]));
    }

    /** @return array<array-key,string|array<mixed>> */
    private function getPreviousQueries(): array
    {
        $previousQueries     = [];
        $previousQueryString = \parse_url($this->getPreviousUrl(), \PHP_URL_QUERY) ?? '' ?: '';
        \parse_str($previousQueryString, $previousQueries);

        return $previousQueries;
    }

    private function getPreviousUrl(): string
    {
        return url()->previous(route('back.dashboard.index'));
    }
}