Part-DB-server/src/Controller/TypeaheadController.php

<?php
/**
 * This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
 *
 * Copyright (C) 2019 - 2022 Jan Böhmer (https://github.com/jbtronics)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace App\Controller;

use App\Entity\Attachments\Attachment;
use App\Entity\Parameters\AbstractParameter;
use App\Entity\Parameters\AttachmentTypeParameter;
use App\Entity\Parameters\CategoryParameter;
use App\Entity\Parameters\FootprintParameter;
use App\Entity\Parameters\GroupParameter;
use App\Entity\Parameters\ManufacturerParameter;
use App\Entity\Parameters\MeasurementUnitParameter;
use App\Entity\Parameters\PartParameter;
use App\Entity\Parameters\ProjectParameter;
use App\Entity\Parameters\StorageLocationParameter;
use App\Entity\Parameters\SupplierParameter;
use App\Entity\Parts\Category;
use App\Entity\Parts\Footprint;
use App\Entity\Parts\Part;
use App\Entity\PriceInformations\Currency;
use App\Repository\ParameterRepository;
use App\Services\AI\AIPlatformRegistry;
use App\Services\AI\AIPlatforms;
use App\Services\Attachments\AttachmentURLGenerator;
use App\Services\Attachments\BuiltinAttachmentsFinder;
use App\Services\Attachments\PartPreviewGenerator;
use App\Services\Tools\TagFinder;
use App\Settings\MiscSettings\IpnSuggestSettings;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\AI\Platform\Capability;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Asset\Packages;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
use Symfony\Component\Serializer\Serializer;
use Symfony\Contracts\Cache\CacheInterface;
use Symfony\Contracts\Cache\ItemInterface;

/**
 * In this controller the endpoints for the typeaheads are collected.
 */
#[Route(path: '/typeahead')]
class TypeaheadController extends AbstractController
{
    public function __construct(
        protected AttachmentURLGenerator $urlGenerator,
        protected Packages $assets,
        protected IpnSuggestSettings $ipnSuggestSettings,
    ) {
    }

    #[Route(path: '/builtInResources/search', name: 'typeahead_builtInRessources')]
    public function builtInResources(Request $request, BuiltinAttachmentsFinder $finder): JsonResponse
    {
        //Ensure that the user can access Part-DB at all
        $this->denyAccessUnlessGranted('HAS_ACCESS_PERMISSIONS');

        $query = $request->query->getString('query');
        $array = $finder->find($query);

        $result = [];

        foreach ($array as $path) {
            $result[] = [
                'name' => $path,
                'image' => $this->assets->getUrl($this->urlGenerator->placeholderPathToAssetPath($path)),
            ];
        }

        $normalizers = [
            new ObjectNormalizer(),
        ];
        $encoders = [
            new JsonEncoder(),
        ];
        $serializer = new Serializer($normalizers, $encoders);
        $data = $serializer->serialize($result, 'json');

        return new JsonResponse($data, Response::HTTP_OK, [], true);
    }

    /**
     * This function map the parameter type to the class, so we can access its repository
     * @return class-string<AbstractParameter>
     */
    private function typeToParameterClass(string $type): string
    {
        return match ($type) {
            'category' => CategoryParameter::class,
            'part' => PartParameter::class,
            'device' => ProjectParameter::class,
            'footprint' => FootprintParameter::class,
            'manufacturer' => ManufacturerParameter::class,
            'storelocation' => StorageLocationParameter::class,
            'supplier' => SupplierParameter::class,
            'attachment_type' => AttachmentTypeParameter::class,
            'group' => GroupParameter::class,
            'measurement_unit' => MeasurementUnitParameter::class,
            'currency' => Currency::class,
            default => throw new \InvalidArgumentException('Invalid parameter type: '.$type),
        };
    }

    #[Route(path: '/parts/search/{query}', name: 'typeahead_parts')]
    public function parts(
        EntityManagerInterface $entityManager,
        PartPreviewGenerator $previewGenerator,
        AttachmentURLGenerator $attachmentURLGenerator,
        string $query = ""
    ): JsonResponse {
        $this->denyAccessUnlessGranted('@parts.read');

        $repo = $entityManager->getRepository(Part::class);

        $parts = $repo->autocompleteSearch($query, 100);

        $data = [];
        foreach ($parts as $part) {
            //Determine the picture to show:
            $preview_attachment = $previewGenerator->getTablePreviewAttachment($part);
            if ($preview_attachment instanceof Attachment) {
                $preview_url = $attachmentURLGenerator->getThumbnailURL($preview_attachment, 'thumbnail_sm');
            } else {
                $preview_url = '';
            }

            /** @var Part $part */
            $data[] = [
                'id' => $part->getID(),
                'name' => $part->getName(),
                'category' => $part->getCategory() instanceof Category ? $part->getCategory()->getName() : 'Unknown',
                'footprint' => $part->getFootprint() instanceof Footprint ? $part->getFootprint()->getName() : '',
                'description' => mb_strimwidth($part->getDescription(), 0, 127, '...'),
                'image' => $preview_url,
            ];
        }

        return new JsonResponse($data);
    }

    #[Route(path: '/parameters/{type}/search/{query}', name: 'typeahead_parameters', requirements: ['type' => '.+'])]
    public function parameters(string $type, EntityManagerInterface $entityManager, string $query = ""): JsonResponse
    {
        $class = $this->typeToParameterClass($type);

        $test_obj = new $class();
        //Ensure user has the correct permissions
        $this->denyAccessUnlessGranted('read', $test_obj);

        /** @var ParameterRepository<AbstractParameter> $repository */
        $repository = $entityManager->getRepository($class);

        $data = $repository->autocompleteParamName($query);

        return new JsonResponse($data);
    }

    #[Route(path: '/tags/search/{query}', name: 'typeahead_tags', requirements: ['query' => '.+'])]
    public function tags(string $query, TagFinder $finder): JsonResponse
    {
        $this->denyAccessUnlessGranted('@parts.read');

        $array = $finder->searchTags($query);

        $normalizers = [
            new ObjectNormalizer(),
        ];
        $encoders = [
            new JsonEncoder(),
        ];

        $serializer = new Serializer($normalizers, $encoders);
        $data = $serializer->serialize($array, 'json');

        return new JsonResponse($data, Response::HTTP_OK, [], true);
    }

    #[Route(path: '/parts/ipn-suggestions', name: 'ipn_suggestions', methods: ['GET'])]
    public function ipnSuggestions(
        Request $request,
        EntityManagerInterface $entityManager
    ): JsonResponse {
        $partId = $request->query->get('partId');
        if ($partId === '0' || $partId === 'undefined' || $partId === 'null') {
            $partId = null;
        }
        $categoryId = $request->query->getInt('categoryId');
        $description = base64_decode($request->query->getString('description'), true);

        /** @var Part $part */
        $part = $partId !== null ? $entityManager->getRepository(Part::class)->find($partId) : new Part();
        /** @var Category|null $category */
        $category = $entityManager->getRepository(Category::class)->find($categoryId);

        //Ensure the user has access to both the part and the category
        $this->denyAccessUnlessGranted('read', $part);
        if ($category !== null) {
            $this->denyAccessUnlessGranted('read', $category);
        }

        $clonedPart = clone $part;
        $clonedPart->setCategory($category);


        $partRepository = $entityManager->getRepository(Part::class);
        $ipnSuggestions = $partRepository->autoCompleteIpn($clonedPart, $description,
            $this->ipnSuggestSettings->suggestPartDigits);

        return new JsonResponse($ipnSuggestions);
    }

    #[Route(path: '/ai/{platform}/models', name: 'typeahead_ai_models', requirements: ['platform' => '.+'])]
    public function aiModels(
        AIPlatforms $platform,
        Request $request,
        AIPlatformRegistry $platformRegistry,
        CacheInterface $cache,
    ): JsonResponse {
        $this->denyAccessUnlessGranted('@config.change_system_settings');

        $capability_filter = $request->query->getEnum('capability', Capability::class);

        $models = $cache->get('ai_models_'.$platform->value.'_'.($capability_filter->value ?? 'all'),
            function (ItemInterface $item) use ($platformRegistry, $platform, $capability_filter) {
                $item->expiresAfter(3600); //Cache for 1 hour
                if ($capability_filter === null) {
                    return $platformRegistry->getPlatform($platform)->getModelCatalog()->getModels();
                }

                //Otherwise filter the models by the capability
                return array_filter($platformRegistry->getPlatform($platform)->getModelCatalog()->getModels(),
                    static fn(array $model) => in_array($capability_filter, $model['capabilities'], true)
                );
            });

        return new JsonResponse($models);
    }
}