* initial commit

src/App/Handler/AbstractCrudHandler.php

@@ -0,0 +1,161 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Zend\Diactoros\Response\EmptyResponse;
+use Zend\Diactoros\Response\JsonResponse;
+use Zend\Json\Json;
+
+abstract class AbstractCrudHandler implements RequestHandlerInterface
+{
+    const IDENTIFIER_NAME = 'id';
+
+    public function handle(ServerRequestInterface $request): ResponseInterface
+    {
+        $requestMethod = strtoupper($request->getMethod());
+        $id = $request->getAttribute(static::IDENTIFIER_NAME);
+
+        switch ($requestMethod) {
+            case 'GET':
+                return isset($id)
+                    ? $this->get($request)
+                    : $this->getList($request);
+            case 'POST':
+                return $this->create($request);
+            case 'PUT':
+                return $this->update($request);
+            case 'DELETE':
+                return isset($id)
+                    ? $this->delete($request)
+                    : $this->deleteList($request);
+            case 'HEAD':
+                return $this->head($request);
+            case 'OPTIONS':
+                return $this->options($request);
+            case 'PATCH':
+                return $this->patch($request);
+            default:
+                return $this->createResponse(['content' => 'Method not allowed'], 405);
+        }
+    }
+
+    public function get(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function getList(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function create(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function update(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function delete(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function deleteList(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function head(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    public function options(ServerRequestInterface $request)
+    {
+        return new EmptyResponse(200);
+    }
+
+    public function patch(ServerRequestInterface $request)
+    {
+        return $this->createResponse(['content' => 'Method not allowed'], 405);
+    }
+
+    final protected function createResponse($data, $status = 200)
+    {
+        return new JsonResponse($data, $status);
+    }
+
+    /**
+     *
+     * @param ServerRequestInterface $request
+     * @return array|object
+     */
+    public function getRequestData(ServerRequestInterface $request)
+    {
+        $body = $request->getParsedBody();
+
+        if (!empty($body)) {
+            return $body;
+        }
+
+        return $this->parseRequestData(
+            $request->getBody()->getContents(),
+            $request->getHeaderLine('content-type')
+        );
+    }
+
+    /**
+     *
+     * @param string $input
+     * @param string $contentType
+     * @return mixed
+     */
+    private function parseRequestData($input, $contentType)
+    {
+        $contentTypeParts = preg_split('/\s*[;,]\s*/', $contentType);
+        $parser = $this->returnParserContentType($contentTypeParts[0]);
+
+        return $parser($input);
+    }
+
+    /**
+     *
+     * @param string $contentType
+     * @return callable
+     */
+    private function returnParserContentType(string $contentType): callable
+    {
+        if ($contentType === 'application/x-www-form-urlencoded') {
+            return function ($input) {
+                parse_str($input, $data);
+                return $data;
+            };
+        } elseif ($contentType === 'application/json') {
+            return function ($input) {
+                $jsonDecoder = new Json();
+                try {
+                    return $jsonDecoder->decode($input, Json::TYPE_ARRAY);
+                } catch (\Exception $e) {
+                    return false;
+                }
+            };
+        } elseif ($contentType === 'multipart/form-data') {
+            return function ($input) {
+                return $input;
+            };
+        }
+
+        return function ($input) {
+            return $input;
+        };
+    }
+}

src/App/Handler/HomePageHandler.php

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Zend\Diactoros\Response\HtmlResponse;
+use Zend\Diactoros\Response\JsonResponse;
+use Zend\Expressive\Plates\PlatesRenderer;
+use Zend\Expressive\Router;
+use Zend\Expressive\Template;
+use Zend\Expressive\Twig\TwigRenderer;
+use Zend\Expressive\ZendView\ZendViewRenderer;
+
+class HomePageHandler implements RequestHandlerInterface
+{
+    private $containerName;
+
+    private $router;
+
+    private $template;
+
+    public function __construct(
+        Router\RouterInterface $router,
+        Template\TemplateRendererInterface $template = null,
+        string $containerName
+    ) {
+        $this->router        = $router;
+        $this->template      = $template;
+        $this->containerName = $containerName;
+    }
+
+    public function handle(ServerRequestInterface $request) : ResponseInterface
+    {
+        if (! $this->template) {
+            return new JsonResponse([
+                'welcome' => 'Congratulations! You have installed the zend-expressive skeleton application.',
+                'docsUrl' => 'https://docs.zendframework.com/zend-expressive/',
+            ]);
+        }
+
+        $data = [];
+
+        switch ($this->containerName) {
+            case 'Aura\Di\Container':
+                $data['containerName'] = 'Aura.Di';
+                $data['containerDocs'] = 'http://auraphp.com/packages/2.x/Di.html';
+                break;
+            case 'Pimple\Container':
+                $data['containerName'] = 'Pimple';
+                $data['containerDocs'] = 'https://pimple.symfony.com/';
+                break;
+            case 'Zend\ServiceManager\ServiceManager':
+                $data['containerName'] = 'Zend Servicemanager';
+                $data['containerDocs'] = 'https://docs.zendframework.com/zend-servicemanager/';
+                break;
+            case 'Auryn\Injector':
+                $data['containerName'] = 'Auryn';
+                $data['containerDocs'] = 'https://github.com/rdlowrey/Auryn';
+                break;
+            case 'Symfony\Component\DependencyInjection\ContainerBuilder':
+                $data['containerName'] = 'Symfony DI Container';
+                $data['containerDocs'] = 'https://symfony.com/doc/current/service_container.html';
+                break;
+        }
+
+        if ($this->router instanceof Router\AuraRouter) {
+            $data['routerName'] = 'Aura.Router';
+            $data['routerDocs'] = 'http://auraphp.com/packages/2.x/Router.html';
+        } elseif ($this->router instanceof Router\FastRouteRouter) {
+            $data['routerName'] = 'FastRoute';
+            $data['routerDocs'] = 'https://github.com/nikic/FastRoute';
+        } elseif ($this->router instanceof Router\ZendRouter) {
+            $data['routerName'] = 'Zend Router';
+            $data['routerDocs'] = 'https://docs.zendframework.com/zend-router/';
+        }
+
+        if ($this->template instanceof PlatesRenderer) {
+            $data['templateName'] = 'Plates';
+            $data['templateDocs'] = 'http://platesphp.com/';
+        } elseif ($this->template instanceof TwigRenderer) {
+            $data['templateName'] = 'Twig';
+            $data['templateDocs'] = 'http://twig.sensiolabs.org/documentation';
+        } elseif ($this->template instanceof ZendViewRenderer) {
+            $data['templateName'] = 'Zend View';
+            $data['templateDocs'] = 'https://docs.zendframework.com/zend-view/';
+        }
+
+        return new HtmlResponse($this->template->render('app::home-page', $data));
+    }
+}

src/App/Handler/HomePageHandlerFactory.php

@@ -0,0 +1,23 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use Psr\Container\ContainerInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Zend\Expressive\Router\RouterInterface;
+use Zend\Expressive\Template\TemplateRendererInterface;
+
+class HomePageHandlerFactory
+{
+    public function __invoke(ContainerInterface $container) : RequestHandlerInterface
+    {
+        $router   = $container->get(RouterInterface::class);
+        $template = $container->has(TemplateRendererInterface::class)
+            ? $container->get(TemplateRendererInterface::class)
+            : null;
+
+        return new HomePageHandler($router, $template, get_class($container));
+    }
+}

src/App/Handler/PingHandler.php

@@ -0,0 +1,18 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+use Zend\Diactoros\Response\JsonResponse;
+
+class PingHandler implements RequestHandlerInterface
+{
+    public function handle(ServerRequestInterface $request) : ResponseInterface
+    {
+        return new JsonResponse(['ack' => time()]);
+    }
+}

src/App/Handler/SlideHandler.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use App\Service\SlideManager;
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Zend\Diactoros\Response\JsonResponse;
+
+class SlideHandler extends AbstractCrudHandler
+{
+    /** @var SlideManager  */
+    private $slideManager;
+
+    public function __construct(SlideManager $teamService) {
+        $this->slideManager = $teamService;
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function getList(ServerRequestInterface $request): ResponseInterface
+    {
+        return new JsonResponse($this->slideManager->listSlides());
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function get(ServerRequestInterface $request): ResponseInterface
+    {
+        $id = $request->getAttribute('id');
+        return new JsonResponse($this->slideManager->getSlide((int)$id));
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return JsonResponse
+     * @throws \Doctrine\ORM\ORMException
+     * @throws \Doctrine\ORM\OptimisticLockException
+     */
+    public function create(ServerRequestInterface $request)
+    {
+        $data = $this->getRequestData($request);
+        try {
+            return new JsonResponse($this->slideManager->addSlide($data));
+        } catch (UniqueConstraintViolationException $e) {
+            return new JsonResponse([
+                'message' => 'The field `name` must be unique',
+            ], 500);
+        } catch (\InvalidArgumentException $e) {
+            return new JsonResponse([
+                'message' => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return JsonResponse
+     * @throws \Doctrine\ORM\ORMException
+     */
+    public function delete(ServerRequestInterface $request)
+    {
+        $id = $request->getAttribute('id');
+        return new JsonResponse($this->slideManager->removeSlide($id));
+    }
+}

src/App/Handler/SlideHandlerFactory.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use App\Service\SlideManager;
+use Psr\Container\ContainerInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class SlideHandlerFactory
+{
+    /**
+     * @param ContainerInterface $container
+     * @return RequestHandlerInterface
+     */
+    public function __invoke(ContainerInterface $container) : RequestHandlerInterface
+    {
+        $slideManager = $container->get(SlideManager::class);
+        return new SlideHandler($slideManager);
+    }
+}

src/App/Handler/TeamHandler.php

@@ -0,0 +1,73 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use App\Service\TeamService;
+use Doctrine\DBAL\Exception\UniqueConstraintViolationException;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Zend\Diactoros\Response\JsonResponse;
+
+class TeamHandler extends AbstractCrudHandler
+{
+    /** @var TeamService  */
+    private $teamService;
+
+    public function __construct(TeamService $teamService) {
+        $this->teamService = $teamService;
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function getList(ServerRequestInterface $request): ResponseInterface
+    {
+        return new JsonResponse($this->teamService->listTeams());
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return ResponseInterface
+     */
+    public function get(ServerRequestInterface $request): ResponseInterface
+    {
+        $id = $request->getAttribute('id');
+        return new JsonResponse($this->teamService->getTeam((int)$id));
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return JsonResponse
+     * @throws \Doctrine\ORM\ORMException
+     * @throws \Doctrine\ORM\OptimisticLockException
+     */
+    public function create(ServerRequestInterface $request)
+    {
+        $data = $this->getRequestData($request);
+        try {
+            return new JsonResponse($this->teamService->addTeam($data));
+        } catch (UniqueConstraintViolationException $e) {
+            return new JsonResponse([
+                'message' => 'The field `name` must be unique',
+            ], 500);
+        } catch (\InvalidArgumentException $e) {
+            return new JsonResponse([
+                'message' => $e->getMessage(),
+            ], 500);
+        }
+    }
+
+    /**
+     * @param ServerRequestInterface $request
+     * @return JsonResponse
+     * @throws \Doctrine\ORM\ORMException
+     */
+    public function delete(ServerRequestInterface $request)
+    {
+        $id = $request->getAttribute('id');
+        return new JsonResponse($this->teamService->removeTeam($id));
+    }
+}

src/App/Handler/TeamHandlerFactory.php

@@ -0,0 +1,22 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Handler;
+
+use App\Service\TeamService;
+use Psr\Container\ContainerInterface;
+use Psr\Http\Server\RequestHandlerInterface;
+
+class TeamHandlerFactory
+{
+    /**
+     * @param ContainerInterface $container
+     * @return RequestHandlerInterface
+     */
+    public function __invoke(ContainerInterface $container) : RequestHandlerInterface
+    {
+        $teamService = $container->get(TeamService::class);
+        return new TeamHandler($teamService);
+    }
+}