first impl for api

src/Bundle/ChillMainBundle/CRUD/Controller/AbstractCRUDController.php

@@ -0,0 +1,117 @@
+<?php
+
+namespace Chill\MainBundle\CRUD\Controller;
+
+use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Annotation\Route;
+use Chill\MainBundle\Pagination\PaginatorFactory;
+
+class AbstractCRUDController extends AbstractController
+{
+    /**
+     * The crud configuration 
+     *
+     * This configuration si defined by `chill_main['crud']` or `chill_main['apis']`
+     *
+     * @var array
+     */
+    protected array $crudConfig = [];
+
+    /**
+     * get the instance of the entity with the given id
+     * 
+     * @param string $id
+     * @return object
+     */
+    protected function getEntity($action, $id, Request $request): ?object
+    {
+        return $this->getDoctrine()
+            ->getRepository($this->getEntityClass())
+            ->find($id);
+    }
+
+    /**
+     * 
+     * @return string the complete fqdn of the class
+     */
+    protected function getEntityClass(): string
+    {
+        return $this->crudConfig['class'];
+    }
+    
+    /**
+     * 
+     */
+    protected function onPostFetchEntity(string $action, Request $request, $entity, $_format): ?Response
+    {
+        return null;
+    }
+
+    /**
+     * 
+     */
+    protected function onPostCheckACL(string $action, Request $request, $entity, $_format): ?Response
+    {
+        return null;
+    }
+
+
+    /**
+     * check the acl. Called by every action.
+     * 
+     * By default, check the role given by `getRoleFor` for the value given in 
+     * $entity.
+     * 
+     * Throw an \Symfony\Component\Security\Core\Exception\AccessDeniedHttpException
+     * if not accessible.
+     * 
+     * @throws \Symfony\Component\Security\Core\Exception\AccessDeniedHttpException
+     */
+    protected function checkACL(string $action, Request $request, $entity, $_format)
+    {
+        $this->denyAccessUnlessGranted($this->getRoleFor($action, $request, $entity, $_format), $entity);
+    }
+
+    protected function getActionConfig(string $action)
+    {
+        return $this->crudConfig['actions'][$action];
+    }
+
+
+    /**
+     * Set the crud configuration
+     *
+     * Used by the container to inject configuration for this crud.
+     */
+    public function setCrudConfig(array $config): void
+    {
+        dump($config);
+        $this->crudConfig = $config;
+    }
+
+    /**
+     * @return PaginatorFactory
+     */
+    protected function getPaginatorFactory(): PaginatorFactory
+    {
+        return $this->container->get(PaginatorFactory::class);
+    }
+
+    /**
+     * Defined the services necessary for this controller
+     *
+     * @return array
+     */
+    public static function getSubscribedServices(): array
+    {
+        return \array_merge(
+            parent::getSubscribedServices(),
+            [
+                PaginatorFactory::class => PaginatorFactory::class,
+
+            ]
+        );
+    }
+}

src/Bundle/ChillMainBundle/CRUD/Controller/ApiController.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace Chill\MainBundle\CRUD\Controller;
+
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\Routing\Annotation\Route;
+
+class ApiController extends AbstractCRUDController
+{
+    /**
+     * The view action.
+     * 
+     * Some steps may be overriden during this process of rendering:
+     * 
+     * This method:
+     * 
+     * 1.  fetch the entity, using `getEntity`
+     * 2.  launch `onPostFetchEntity`. If postfetch is an instance of Response,
+     *     this response is returned.
+     * 2.  throw an HttpNotFoundException if entity is null
+     * 3.  check ACL using `checkACL` ;
+     * 4.  launch `onPostCheckACL`. If the result is an instance of Response, 
+     *     this response is returned ;
+     * 5.  Serialize the entity and return the result. The serialization context is given by `getSerializationContext`
+     * 
+     */
+    protected function entityGet(string $action, Request $request, $id, $_format = 'html'): Response
+    {
+        $entity = $this->getEntity($action, $id, $request, $_format);
+        
+        $postFetch = $this->onPostFetchEntity($action, $request, $entity, $_format);
+        
+        if ($postFetch instanceof Response) {
+            return $postFetch;
+        }
+        
+        if (NULL === $entity) {
+            throw $this->createNotFoundException(sprintf("The %s with id %s "
+                . "is not found", $this->getCrudName(), $id));
+        }
+        
+        $response = $this->checkACL($action, $request, $entity, $_format);
+        if ($response instanceof Response) {
+            return $response;
+        }
+        
+        $response = $this->onPostCheckACL($action, $request, $entity, $_format);
+        if ($response instanceof Response) {
+            return $response;
+        }
+
+        $response = $this->onBeforeSerialize($action, $request, $entity, $_format);
+        if ($response instanceof Response) {
+            return $response;
+        }
+
+        if ($_format === 'json') {
+            $context = $this->getContextForSerialization($action, $request, $entity, $_format);
+
+            return $this->json($entity, Response::HTTP_OK, [], $context);
+        } else {
+            throw new \Symfony\Component\HttpFoundation\Exception\BadRequestException("This format is not implemented");
+        }
+    }
+
+    public function onBeforeSerialize(string $action, Request $request, $entity, string $_format): ?Response
+    {
+        return null;
+    }
+
+    /**
+     * Base method for handling api action
+     *
+     * @return void
+     */
+    public function entityApi(Request $request, $id, $_format): Response
+    {
+        switch ($request->getMethod()) {
+            case Request::METHOD_GET:
+            case REQUEST::METHOD_HEAD:
+                return $this->entityGet('_entity', $request, $id, $_format);
+            default:
+                throw new \Symfony\Component\HttpFoundation\Exception\BadRequestException("This method is not implemented");
+        }
+    }
+
+
+    protected function getContextForSerialization(string $action, Request $request, $entity, $_format): array
+    {
+        return [];
+    }
+
+    /**
+     * get the role given from the config.
+     */
+    protected function getRoleFor(string $action, Request $request, $entity, $_format): string
+    {
+        $actionConfig = $this->getActionConfig($action);
+
+        if (NULL !== $actionConfig['roles'][$request->getMethod()]) {
+            return $actionConfig['roles'][$request->getMethod()];
+        }
+
+        if ($this->crudConfig['role']) {
+            return $this->crudConfig['role'];
+        }
+
+        throw new \RuntimeException(sprintf("the config does not have any role for the ".
+            "method %s nor a global role for the whole action. Add those to your ".
+            "configuration or override the required method", $request->getMethod()));
+        
+    }
+
+    protected function getSerializer(): SerializerInterface
+    {
+        return $this->get(SerializerInterface::class);
+    }
+
+    /**
+     * Defined the services necessary for this controller
+     *
+     * @return array
+     */
+    public static function getSubscribedServices(): array
+    {
+        return \array_merge(
+            parent::getSubscribedServices(),
+            [
+                SerializerInterface::class => SerializerInterface::class,
+            ]
+        );
+    }
+    
+}

src/Bundle/ChillMainBundle/CRUD/Controller/CRUDController.php

@@ -34,6 +34,7 @@ use Chill\MainBundle\CRUD\Form\CRUDDeleteEntityForm;
 use Chill\MainBundle\Pagination\PaginatorFactory;
 use Chill\MainBundle\Pagination\PaginatorInterface;
 use Chill\MainBundle\Security\Authorization\AuthorizationHelper;
+use Symfony\Component\Serializer\SerializerInterface;
 
 /**
  * Class CRUDController
@@ -484,7 +485,7 @@ class CRUDController extends AbstractController
      * @param mixed $id
      * @return Response
      */
-    protected function viewAction(string $action, Request $request, $id) 
+    protected function viewAction(string $action, Request $request, $id, $_format = 'html'): Response
     {
         $entity = $this->getEntity($action, $id, $request);
         
@@ -496,7 +497,7 @@ class CRUDController extends AbstractController
         
         if (NULL === $entity) {
             throw $this->createNotFoundException(sprintf("The %s with id %s "
-                . "is not found"), $this->getCrudName(), $id);
+                . "is not found", $this->getCrudName(), $id));
         }
         
         $response = $this->checkACL($action, $entity);
@@ -508,17 +509,36 @@ class CRUDController extends AbstractController
         if ($response instanceof Response) {
             return $response;
         }
-        
-        $defaultTemplateParameters = [
-            'entity' => $entity,
-            'crud_name' => $this->getCrudName()
-        ];
-        
-        return $this->render(
-            $this->getTemplateFor($action, $entity, $request), 
-            $this->generateTemplateParameter($action, $entity, $request, $defaultTemplateParameters)
+
+        if ($_format === 'html') {
+            $defaultTemplateParameters = [
+                'entity' => $entity,
+                'crud_name' => $this->getCrudName()
+            ];
+            
+            return $this->render(
+                $this->getTemplateFor($action, $entity, $request), 
+                $this->generateTemplateParameter($action, $entity, $request, $defaultTemplateParameters)
             );
+        } elseif ($_format === 'json') {
+            $context = $this->getContextForSerialization($action, $request, $entity, $_format);
+
+            return $this->json($entity, Response::HTTP_OK, [], $context);
+        } else {
+            throw new \Symfony\Component\HttpFoundation\Exception\BadRequestException("This format is not implemented");
+        }
+
     }
+
+    /**
+     * Get the context for the serialization
+     */
+    public function getContextForSerialization(string $action, Request $request, $entity, string $_format): array
+    {
+        return [];
+    }
+    
+
     
     /**
      * The edit action.
@@ -799,7 +819,7 @@ class CRUDController extends AbstractController
      */
     protected function getRoleFor($action)
     {
-        if (NULL !== ($this->getActionConfig($action)['role'])) {
+        if (\array_key_exists('role', $this->getActionConfig($action))) {
             return $this->getActionConfig($action)['role'];
         }
         
@@ -1181,6 +1201,7 @@ class CRUDController extends AbstractController
                 AuthorizationHelper::class => AuthorizationHelper::class,
                 EventDispatcherInterface::class => EventDispatcherInterface::class,
                 Resolver::class => Resolver::class,
+                SerializerInterface::class => SerializerInterface::class,
             ]
         );
     }

src/Bundle/ChillMainBundle/CRUD/Routing/CRUDRoutesLoader.php

@@ -23,6 +23,9 @@ namespace Chill\MainBundle\CRUD\Routing;
 use Symfony\Component\Config\Loader\Loader;
 use Symfony\Component\Routing\Route;
 use Symfony\Component\Routing\RouteCollection;
+use Symfony\Component\HttpFoundation\Request;
+use Chill\MainBundle\CRUD\Controller\ApiController;
+use Chill\MainBundle\CRUD\Controller\CRUDController;
 
 /**
  * Class CRUDRoutesLoader
@@ -32,24 +35,34 @@ use Symfony\Component\Routing\RouteCollection;
  */
 class CRUDRoutesLoader extends Loader
 {
-    /**
-     * @var array
-     */
-    protected $config = [];
+    protected array $crudConfig = [];
+
+    protected array $apiCrudConfig = [];
     
     /**
      * @var bool
      */
     private $isLoaded = false;
+
+    private const ALL_SINGLE_METHODS = [
+        Request::METHOD_GET,
+        Request::METHOD_POST,
+        Request::METHOD_PUT,
+        Request::METHOD_DELETE
+    ];
+
+    private const ALL_INDEX_METHODS = [ Request::METHOD_GET, Request::METHOD_HEAD ];
     
     /**
      * CRUDRoutesLoader constructor.
      *
-     * @param $config
+     * @param $crudConfig the config from cruds
+     * @param $apicrudConfig the config from api_crud
      */
-    public function __construct($config)
+    public function __construct(array $crudConfig, array $apiConfig)
     {
-        $this->config = $config;
+        $this->crudConfig = $crudConfig;
+        $this->apiConfig = $apiConfig;
     }
     
     /**
@@ -63,51 +76,132 @@ class CRUDRoutesLoader extends Loader
     }
     
     /**
-     * @return RouteCollection
+     * Load routes for CRUD and CRUD Api
      */
-    public function load($resource, $type = null)
+    public function load($resource, $type = null): RouteCollection
     {
-    
         if (true === $this->isLoaded) {
             throw new \RuntimeException('Do not add the "CRUD" loader twice');
         }
-        
+
         $collection = new RouteCollection();
         
-        foreach ($this->config as $config) {
-            $collection->addCollection($this->loadConfig($config));
+        foreach ($this->crudConfig as $crudConfig) {
+            $collection->addCollection($this->loadCrudConfig($crudConfig));
         }
-        
+        foreach ($this->apiConfig as $crudConfig) {
+            $collection->addCollection($this->loadApiSingle($crudConfig));
+            //$collection->addCollection($this->loadApiMulti($crudConfig));
+        }
+
         return $collection;
     }
     
     /**
-     * @param $config
+     * Load routes for CRUD (without api)
+     *
+     * @param $crudConfig
      * @return RouteCollection
      */
-    protected function loadConfig($config): RouteCollection
+    protected function loadCrudConfig($crudConfig): RouteCollection
     {
         $collection = new RouteCollection();
-        foreach ($config['actions'] as $name => $action) {
+        $controller = $crudConfig['controller'] === CrudController::class ? 
+            'cscrud_'.$crudConfig['name'].'_controller' : $crudConfig['controller'];
+
+        foreach ($crudConfig['actions'] as $name => $action) {
+            // defaults (controller name)
             $defaults = [
-                '_controller' => 'cscrud_'.$config['name'].'_controller'.':'.($action['controller_action'] ?? $name)
+                '_controller' => $controller.':'.($action['controller_action'] ?? $name)
             ];
             
             if ($name === 'index') {
-                $path = "{_locale}".$config['base_path'];
+                $path = "{_locale}".$crudConfig['base_path'];
                 $route = new Route($path, $defaults);
             } elseif ($name === 'new') {
-                $path = "{_locale}".$config['base_path'].'/'.$name;
+                $path = "{_locale}".$crudConfig['base_path'].'/'.$name;
                 $route = new Route($path, $defaults);
             } else {
-                $path = "{_locale}".$config['base_path'].($action['path'] ?? '/{id}/'.$name);
+                $path = "{_locale}".$crudConfig['base_path'].($action['path'] ?? '/{id}/'.$name);
                 $requirements = $action['requirements'] ?? [
                     '{id}' => '\d+'
                 ];
                 $route = new Route($path, $defaults, $requirements);
             }
             
-            $collection->add('chill_crud_'.$config['name'].'_'.$name, $route);
+            $collection->add('chill_crud_'.$crudConfig['name'].'_'.$name, $route);
+        }
+        
+        return $collection;
+    }
+
+    /**
+     * Load routes for api single
+     *
+     * @param $crudConfig
+     * @return RouteCollection
+     */
+    protected function loadApiSingle(array $crudConfig): RouteCollection
+    {
+        $collection = new RouteCollection();
+        $controller = $crudConfig['controller'] === ApiController::class ? 
+            'cscrud_'.$crudConfig['name'].'_controller' : $crudConfig['controller'];
+
+        foreach ($crudConfig['actions'] as $name => $action) {
+            // filter only on single actions
+            $singleCollection = $action['single-collection'] ?? $name === '_entity' ? 'single' : NULL;
+            if ('collection' === $singleCollection) {
+                continue;
+            }
+
+            $defaults = [
+                '_controller' => $controller.':'.($action['controller_action'] ?? '_entity' === $name ? 'entityApi' : $name.'Api')
+            ];
+
+            // path are rewritten
+            // if name === 'default', we rewrite it to nothing :-)
+            $localName = '_entity' === $name ? '' : $name;
+            $localPath = $action['path'] ?? '/{id}'.$localName.'.{_format}';
+            $path = $crudConfig['base_path'].$localPath;
+
+            $requirements = $action['requirements'] ?? [ '{id}' => '\d+' ];
+
+            $methods = \array_keys(\array_filter($action['methods'], function($value, $key) { return $value; },
+                ARRAY_FILTER_USE_BOTH));
+
+            $route = new Route($path, $defaults, $requirements);
+            $route->setMethods($methods);
+            
+            $collection->add('chill_api_single_'.$crudConfig['name'].'_'.$name, $route);
+        }
+
+        return $collection;
+    }
+
+    /**
+     * Load routes for api multi
+     *
+     * @param $crudConfig
+     * @return RouteCollection
+     */
+    protected function loadApiMultiConfig(array $crudConfig): RouteCollection
+    {
+        $collection = new RouteCollection();
+        foreach ($crudConfig['actions_multi'] as $name => $action) {
+            // we compute the data from configuration to a local form
+            $defaults = [
+                '_controller' => 'cscrud_'.$crudConfig['name'].'_controller'.':'.($action['controller_action'] ?? $name.'Api')
+            ];
+            // path are rewritten
+            // if name === 'index', we rewrite it to nothing :-)
+            $localName = 'index' === $name ? '' : $name;
+            $localPath = $action['path'] ?? '.{_format}';
+            $path = $crudConfig['base_path'].$localPath.$name;
+            $requirements = $action['requirements'] ?? [ '{id}' => '\d+' ];
+            $methods = $name === 'default' ? self::ALL_MULTI_METHODS: [];
+            $route = new Route($path, $defaults, $requirements);
+            
+            $collection->add('chill_api_multi'.$crudConfig['name'].'_'.$name, $route);
         }
         
         return $collection;