App\Controller\Admin\ImageController

Complexity

Total Complexity

20

Size/Duplication

Total Lines	167
Duplicated Lines	0 %

Importance

Changes	2
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	cluster()	0	3	1
A	index()	0	16	1
A	setLocation()	0	12	3
A	delete()	0	9	2
B	upload()	0	54	6
A	show()	0	4	1
A	setAutoTags()	0	11	3
A	edit()	0	13	3

<?php

namespace App\Controller\Admin;

use App\Entity\Image;
use App\Form\ImageType;
use App\Message\RecogniseImage;
use App\Message\WarmImageCache;
use App\Repository\ImageRepository;
use App\Service\LocationService;
use Doctrine\ORM\EntityManagerInterface;
use Exception;
use Knp\Component\Pager\PaginatorInterface;
use Liip\ImagineBundle\Imagine\Cache\CacheManager;
use Liip\ImagineBundle\Imagine\Filter\FilterManager;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Symfony\Component\Messenger\MessageBusInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Routing\Exception\InvalidParameterException;
use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
use Symfony\Component\Serializer\Serializer;
use Symfony\Component\Serializer\SerializerInterface;
use Vich\UploaderBundle\Form\Type\VichImageType;
use Vich\UploaderBundle\Templating\Helper\UploaderHelper;

/**
 * @Route("/admin/image", name="admin_image_")
 */
class ImageController extends AbstractController
{
    /**
     * @Route("/", name="index", methods={"GET"})
     */
    public function index(ImageRepository $imageRepository, PaginatorInterface $paginator, Request $request): Response
    {
        $query = $imageRepository
            ->createQueryBuilder('i')
            // Nice orphan check: ->where('i.wanders is empty')
            ->orderBy('i.capturedAt', 'DESC')
            ->addOrderBy('i.id', 'DESC')
            ->getQuery();

        $pagination = $paginator->paginate(
            $query,
            $request->query->getInt('page', 1),
            10);

        return $this->render('admin/image/index.html.twig', [
            'pagination' => $pagination
        ]);
    }

    /**
     * @Route("/cluster", name="cluster", methods={"GET"})
     */
    public function cluster()
    {
        return $this->render('admin/image/cluster.html.twig', [
        ]);
    }

    /**
     * @Route("/upload", name="upload", methods={"GET", "POST"})
     */
    public function upload(
        Request $request,
        SerializerInterface $serializer,
        string $gpxDirectory, // TODO Fix this; it should be using the image uploads directory
        MessageBusInterface $messageBus,
        UploaderHelper $uploaderHelper
        ): Response
    {
        if ($request->isMethod('POST')) {

            $token = $request->request->get('token');
            if (!$this->isCsrfTokenValid('image_upload', $token)) {
                return $this->json([ 'error' => 'Invalid CSRF token'], 401);
            }

            $file = $request->files->get('file');
            if (!$file instanceof UploadedFile) {
                throw new HttpException(500, "No uploaded file found.");
            }

            $image = new Image();
            $image->setImageFile($file);
            $entityManager = $this->getDoctrine()->getManager();
            $entityManager->persist($image);
            $entityManager->flush();

            // Queue up some image recognition
            $id = $image->getId();
            if ($id !== null) {

The condition $id !== null is always true.

                $messageBus->dispatch(new RecogniseImage($id));
            }

            // And warm up the image cache the new image
            $imagePath = $uploaderHelper->asset($image);
            if ($imagePath !== null) {
                $messageBus->dispatch(new WarmImageCache($imagePath));
            }

            // It's not exactly an API response, but it'll do until we switch to handling this
            // a bit more properly. At least it's a JSON repsonse and *doesn't include the entire
            // file we just uploaded*, thanks to the IGNORED_ATTRIBUTES. Because we set up the
            // image URIs in a postPersist event listener, this also contains everything you'd
            // need to build an image in HTML.
            return new JsonResponse($serializer->serialize($image, 'jsonld', [AbstractNormalizer::IGNORED_ATTRIBUTES => ['imageFile']]), 201,[], true);
        }

        // Normal GET request.
        $disk = [];
        $disk['free'] = disk_free_space($gpxDirectory);
        $disk['total'] = disk_total_space($gpxDirectory);
        $disk['used'] = $disk['total'] - $disk['free'];
        $disk['percent'] = $disk['used'] / $disk['total'];
        return $this->render('admin/image/upload.html.twig', [
                'disk' => $disk
        ]);
    }

    /**
     * @Route("/{id}", name="show", methods={"GET"})
     */
    public function show(Image $image): Response
    {
        return $this->render('/admin/image/show.html.twig', [
            'image' => $image,
        ]);
    }

    /**
     * @Route("/{id}/edit", name="edit", methods={"GET","POST"})
     */
    public function edit(Request $request, Image $image): Response
    {
        $form = $this->createForm(ImageType::class, $image);
        $form->handleRequest($request);
        if ($form->isSubmitted() && $form->isValid()) {
            $this->getDoctrine()->getManager()->flush();
            //dd($form);
            return $this->redirectToRoute('admin_image_show', ['id' => $image->getId()]);
        }

        return $this->render('admin/image/edit.html.twig', [
            'image' => $image,
            'form' => $form->createView(),
        ]);
    }

    /**
     * @Route("/{id}", name="delete", methods={"DELETE"})
     */
    public function delete(Request $request, Image $image): Response
    {
        if ($this->isCsrfTokenValid('delete'.$image->getId(), $request->request->get('_token'))) {
            $entityManager = $this->getDoctrine()->getManager();
            $entityManager->remove($image);
            $entityManager->flush();
        }

        return $this->redirectToRoute('admin_image_index');
    }

    /**
     * @Route("/{id}/set_location", name="set_location", methods={"POST"})
     */
    public function setLocation(Request $request, Image $image, LocationService $locationService, EntityManagerInterface $entityManager): Response
    {
        if ($this->isCsrfTokenValid('set_location'.$image->getId(), $request->request->get('_token'))) {
            $neighbourhood  = $locationService->getLocationName($image->getLatitude(), $image->getLongitude());
            if ($neighbourhood !== null) {
                $image->setLocation($neighbourhood);
                $entityManager->persist($image);
                $entityManager->flush();
            }
        }

        return $this->redirectToRoute('admin_image_show', ['id' => $image->getId()]);
    }

    /**
     * @Route("/{id}/set_auto_tags", name="set_auto_tags", methods={"POST"})
     */
    public function setAutoTags(Request $request, Image $image, MessageBusInterface $messageBus): Response
    {
        if ($this->isCsrfTokenValid('set_auto_tags'.$image->getId(), $request->request->get('_token'))) {
            $imageId = $image->getId();
            if ($imageId === null) {
                throw new InvalidParameterException('No image id in setAutoTags');
            }
            $messageBus->dispatch(new RecogniseImage($imageId, true));
            $this->addFlash('success', 'Image re-queued for recognition.');
        }
        return $this->redirectToRoute('admin_image_show', ['id' => $image->getId()]);
    }
}