Merge pull request #2 from acelaya/feature/46

Feature/46

composer.json

@@ -28,7 +28,8 @@
         "symfony/console": "^3.0",
         "firebase/php-jwt": "^4.0",
         "monolog/monolog": "^1.21",
-        "theorchard/monolog-cascade": "^0.4"
+        "theorchard/monolog-cascade": "^0.4",
+        "endroid/qrcode": "^1.7"
     },
     "require-dev": {
         "phpunit/phpunit": "^5.0",

module/Common/src/Response/QrCodeResponse.php

@@ -0,0 +1,35 @@
+<?php
+namespace Shlinkio\Shlink\Common\Response;
+
+use Endroid\QrCode\QrCode;
+use Psr\Http\Message\StreamInterface;
+use Zend\Diactoros\Response;
+use Zend\Diactoros\Stream;
+
+class QrCodeResponse extends Response
+{
+    use Response\InjectContentTypeTrait;
+
+    public function __construct(QrCode $qrCode, $status = 200, array $headers = [])
+    {
+        parent::__construct(
+            $this->createBody($qrCode),
+            $status,
+            $this->injectContentType($qrCode->getContentType(), $headers)
+        );
+    }
+
+    /**
+     * Create the message body.
+     *
+     * @param QrCode $qrCode
+     * @return StreamInterface
+     */
+    private function createBody(QrCode $qrCode)
+    {
+        $body = new Stream('php://temp', 'wb+');
+        $body->write($qrCode->get());
+        $body->rewind();
+        return $body;
+    }
+}

module/Core/config/dependencies.config.php

@@ -1,6 +1,7 @@
 <?php
 use Acelaya\ZsmAnnotatedServices\Factory\V3\AnnotatedFactory;
-use Shlinkio\Shlink\Core\Action\RedirectAction;
+use Shlinkio\Shlink\Core\Action;
+use Shlinkio\Shlink\Core\Middleware;
 use Shlinkio\Shlink\Core\Options\AppOptions;
 use Shlinkio\Shlink\Core\Service;
 
@@ -17,7 +18,9 @@ return [
             Service\VisitService::class => AnnotatedFactory::class,
 
             // Middleware
-            RedirectAction::class => AnnotatedFactory::class,
+            Action\RedirectAction::class => AnnotatedFactory::class,
+            Action\QrCodeAction::class => AnnotatedFactory::class,
+            Middleware\QrCodeCacheMiddleware::class => AnnotatedFactory::class,
         ],
     ],
 

module/Core/config/routes.config.php

@@ -1,5 +1,6 @@
 <?php
-use Shlinkio\Shlink\Core\Action\RedirectAction;
+use Shlinkio\Shlink\Core\Action;
+use Shlinkio\Shlink\Core\Middleware;
 
 return [
 
@@ -7,7 +8,16 @@ return [
         [
             'name' => 'long-url-redirect',
             'path' => '/{shortCode}',
-            'middleware' => RedirectAction::class,
+            'middleware' => Action\RedirectAction::class,
+            'allowed_methods' => ['GET'],
+        ],
+        [
+            'name' => 'short-url-qr-code',
+            'path' => '/qr/{shortCode}[/{size:[0-9]+}]',
+            'middleware' => [
+                Middleware\QrCodeCacheMiddleware::class,
+                Action\QrCodeAction::class,
+            ],
             'allowed_methods' => ['GET'],
         ],
     ],

module/Core/src/Action/QrCodeAction.php

@@ -0,0 +1,113 @@
+<?php
+namespace Shlinkio\Shlink\Core\Action;
+
+use Acelaya\ZsmAnnotatedServices\Annotation\Inject;
+use Endroid\QrCode\QrCode;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
+use Shlinkio\Shlink\Common\Response\QrCodeResponse;
+use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
+use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Shlinkio\Shlink\Core\Service\UrlShortenerInterface;
+use Zend\Expressive\Router\RouterInterface;
+use Zend\Stratigility\MiddlewareInterface;
+
+class QrCodeAction implements MiddlewareInterface
+{
+    /**
+     * @var RouterInterface
+     */
+    private $router;
+    /**
+     * @var UrlShortenerInterface
+     */
+    private $urlShortener;
+    /**
+     * @var LoggerInterface
+     */
+    private $logger;
+
+    /**
+     * QrCodeAction constructor.
+     * @param RouterInterface $router
+     * @param UrlShortenerInterface $urlShortener
+     * @param LoggerInterface $logger
+     *
+     * @Inject({RouterInterface::class, UrlShortener::class, "Logger_Shlink"})
+     */
+    public function __construct(
+        RouterInterface $router,
+        UrlShortenerInterface $urlShortener,
+        LoggerInterface $logger = null
+    ) {
+        $this->router = $router;
+        $this->urlShortener = $urlShortener;
+        $this->logger = $logger ?: new NullLogger();
+    }
+
+    /**
+     * Process an incoming request and/or response.
+     *
+     * Accepts a server-side request and a response instance, and does
+     * something with them.
+     *
+     * If the response is not complete and/or further processing would not
+     * interfere with the work done in the middleware, or if the middleware
+     * wants to delegate to another process, it can use the `$out` callable
+     * if present.
+     *
+     * If the middleware does not return a value, execution of the current
+     * request is considered complete, and the response instance provided will
+     * be considered the response to return.
+     *
+     * Alternately, the middleware may return a response instance.
+     *
+     * Often, middleware will `return $out();`, with the assumption that a
+     * later middleware will return a response.
+     *
+     * @param Request $request
+     * @param Response $response
+     * @param null|callable $out
+     * @return null|Response
+     */
+    public function __invoke(Request $request, Response $response, callable $out = null)
+    {
+        // Make sure the short URL exists for this short code
+        $shortCode = $request->getAttribute('shortCode');
+        try {
+            $shortUrl = $this->urlShortener->shortCodeToUrl($shortCode);
+            if (! isset($shortUrl)) {
+                return $out($request, $response->withStatus(404), 'Not Found');
+            }
+        } catch (InvalidShortCodeException $e) {
+            $this->logger->warning('Tried to create a QR code with an invalid short code' . PHP_EOL . $e);
+            return $out($request, $response->withStatus(404), 'Not Found');
+        }
+
+        $path = $this->router->generateUri('long-url-redirect', ['shortCode' => $shortCode]);
+        $size = $this->getSizeParam($request);
+
+        $qrCode = new QrCode($request->getUri()->withPath($path)->withQuery(''));
+        $qrCode->setSize($size)
+               ->setPadding(0);
+        return new QrCodeResponse($qrCode);
+    }
+
+    /**
+     * @param Request $request
+     * @return int
+     */
+    protected function getSizeParam(Request $request)
+    {
+        $size = intval($request->getAttribute('size', 300));
+        if ($size < 50) {
+            return 50;
+        } elseif ($size > 1000) {
+            return 1000;
+        }
+
+        return $size;
+    }
+}

module/Core/src/Middleware/QrCodeCacheMiddleware.php

@@ -0,0 +1,73 @@
+<?php
+namespace Shlinkio\Shlink\Core\Middleware;
+
+use Acelaya\ZsmAnnotatedServices\Annotation\Inject;
+use Doctrine\Common\Cache\Cache;
+use Psr\Http\Message\ResponseInterface as Response;
+use Psr\Http\Message\ServerRequestInterface as Request;
+use Zend\Stratigility\MiddlewareInterface;
+
+class QrCodeCacheMiddleware implements MiddlewareInterface
+{
+    /**
+     * @var Cache
+     */
+    private $cache;
+
+    /**
+     * QrCodeCacheMiddleware constructor.
+     * @param Cache $cache
+     *
+     * @Inject({Cache::class})
+     */
+    public function __construct(Cache $cache)
+    {
+        $this->cache = $cache;
+    }
+
+    /**
+     * Process an incoming request and/or response.
+     *
+     * Accepts a server-side request and a response instance, and does
+     * something with them.
+     *
+     * If the response is not complete and/or further processing would not
+     * interfere with the work done in the middleware, or if the middleware
+     * wants to delegate to another process, it can use the `$out` callable
+     * if present.
+     *
+     * If the middleware does not return a value, execution of the current
+     * request is considered complete, and the response instance provided will
+     * be considered the response to return.
+     *
+     * Alternately, the middleware may return a response instance.
+     *
+     * Often, middleware will `return $out();`, with the assumption that a
+     * later middleware will return a response.
+     *
+     * @param Request $request
+     * @param Response $response
+     * @param null|callable $out
+     * @return null|Response
+     */
+    public function __invoke(Request $request, Response $response, callable $out = null)
+    {
+        $cacheKey = $request->getUri()->getPath();
+
+        // If this QR code is already cached, just return it
+        if ($this->cache->contains($cacheKey)) {
+            $qrData = $this->cache->fetch($cacheKey);
+            $response->getBody()->write($qrData['body']);
+            return $response->withHeader('Content-Type', $qrData['content-type']);
+        }
+
+        // If not, call the next middleware and cache it
+        /** @var Response $resp */
+        $resp = $out($request, $response);
+        $this->cache->save($cacheKey, [
+            'body' => $resp->getBody()->__toString(),
+            'content-type' => $resp->getHeaderLine('Content-Type'),
+        ]);
+        return $resp;
+    }
+}

module/Core/src/Service/UrlShortener.php

@@ -148,9 +148,10 @@ class UrlShortener implements UrlShortenerInterface
      */
     public function shortCodeToUrl($shortCode)
     {
+        $cacheKey = sprintf('%s_longUrl', $shortCode);
         // Check if the short code => URL map is already cached
-        if ($this->cache->contains($shortCode)) {
-            return $this->cache->fetch($shortCode);
+        if ($this->cache->contains($cacheKey)) {
+            return $this->cache->fetch($cacheKey);
         }
 
         // Validate short code format
@@ -165,7 +166,7 @@ class UrlShortener implements UrlShortenerInterface
         // Cache the shortcode
         if (isset($shortUrl)) {
             $url = $shortUrl->getOriginalUrl();
-            $this->cache->save($shortCode, $url);
+            $this->cache->save($cacheKey, $url);
             return $url;
         }
 

module/Core/test/Action/QrCodeActionTest.php

@@ -0,0 +1,93 @@
+<?php
+namespace ShlinkioTest\Shlink\Core\Action;
+
+use PHPUnit_Framework_TestCase as TestCase;
+use Prophecy\Argument;
+use Prophecy\Prophecy\ObjectProphecy;
+use Shlinkio\Shlink\Common\Response\QrCodeResponse;
+use Shlinkio\Shlink\Core\Action\QrCodeAction;
+use Shlinkio\Shlink\Core\Entity\ShortUrl;
+use Shlinkio\Shlink\Core\Exception\InvalidShortCodeException;
+use Shlinkio\Shlink\Core\Service\UrlShortener;
+use Zend\Diactoros\Response;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\Expressive\Router\RouterInterface;
+
+class QrCodeActionTest extends TestCase
+{
+    /**
+     * @var QrCodeAction
+     */
+    protected $action;
+    /**
+     * @var ObjectProphecy
+     */
+    protected $urlShortener;
+
+    public function setUp()
+    {
+        $router = $this->prophesize(RouterInterface::class);
+        $router->generateUri(Argument::cetera())->willReturn('/foo/bar');
+
+        $this->urlShortener = $this->prophesize(UrlShortener::class);
+
+        $this->action = new QrCodeAction($router->reveal(), $this->urlShortener->reveal());
+    }
+
+    /**
+     * @test
+     */
+    public function aNonexistentShortCodeWillReturnNotFoundResponse()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(null)->shouldBeCalledTimes(1);
+
+        $resp = $this->action->__invoke(
+            ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),
+            new Response(),
+            function ($req, $resp) {
+                return $resp;
+            }
+        );
+        $this->assertEquals(404, $resp->getStatusCode());
+    }
+
+    /**
+     * @test
+     */
+    public function anInvalidShortCodeWillReturnNotFoundResponse()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willThrow(InvalidShortCodeException::class)
+                                                       ->shouldBeCalledTimes(1);
+
+        $resp = $this->action->__invoke(
+            ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),
+            new Response(),
+            function ($req, $resp) {
+                return $resp;
+            }
+        );
+        $this->assertEquals(404, $resp->getStatusCode());
+    }
+
+    /**
+     * @test
+     */
+    public function aCorrectRequestReturnsTheQrCodeResponse()
+    {
+        $shortCode = 'abc123';
+        $this->urlShortener->shortCodeToUrl($shortCode)->willReturn(new ShortUrl())->shouldBeCalledTimes(1);
+
+        $resp = $this->action->__invoke(
+            ServerRequestFactory::fromGlobals()->withAttribute('shortCode', $shortCode),
+            new Response(),
+            function ($req, $resp) {
+                return $resp;
+            }
+        );
+
+        $this->assertInstanceOf(QrCodeResponse::class, $resp);
+        $this->assertEquals(200, $resp->getStatusCode());
+    }
+}

module/Core/test/Middleware/QrCodeCacheMiddlewareTest.php

@@ -0,0 +1,69 @@
+<?php
+namespace ShlinkioTest\Shlink\Core\Middleware;
+
+use Doctrine\Common\Cache\ArrayCache;
+use Doctrine\Common\Cache\Cache;
+use PHPUnit_Framework_TestCase as TestCase;
+use Shlinkio\Shlink\Core\Middleware\QrCodeCacheMiddleware;
+use Zend\Diactoros\Response;
+use Zend\Diactoros\ServerRequestFactory;
+use Zend\Diactoros\Uri;
+
+class QrCodeCacheMiddlewareTest extends TestCase
+{
+    /**
+     * @var QrCodeCacheMiddleware
+     */
+    protected $middleware;
+    /**
+     * @var Cache
+     */
+    protected $cache;
+
+    public function setUp()
+    {
+        $this->cache = new ArrayCache();
+        $this->middleware = new QrCodeCacheMiddleware($this->cache);
+    }
+
+    /**
+     * @test
+     */
+    public function noCachedPathFallbacksToNextMiddleware()
+    {
+        $isCalled = false;
+        $this->middleware->__invoke(
+            ServerRequestFactory::fromGlobals(),
+            new Response(),
+            function ($req, $resp) use (&$isCalled) {
+                $isCalled = true;
+                return $resp;
+            }
+        );
+        $this->assertTrue($isCalled);
+    }
+
+    /**
+     * @test
+     */
+    public function cachedPathReturnsCacheContent()
+    {
+        $isCalled = false;
+        $uri = (new Uri())->withPath('/foo');
+        $this->cache->save('/foo', ['body' => 'the body', 'content-type' => 'image/png']);
+
+        $resp = $this->middleware->__invoke(
+            ServerRequestFactory::fromGlobals()->withUri($uri),
+            new Response(),
+            function ($req, $resp) use (&$isCalled) {
+                $isCalled = true;
+                return $resp;
+            }
+        );
+
+        $this->assertFalse($isCalled);
+        $resp->getBody()->rewind();
+        $this->assertEquals('the body', $resp->getBody()->getContents());
+        $this->assertEquals('image/png', $resp->getHeaderLine('Content-Type'));
+    }
+}

module/Core/test/Service/UrlShortenerTest.php

@@ -129,10 +129,10 @@ class UrlShortenerTest extends TestCase
         $repo->findOneBy(['shortCode' => $shortCode])->willReturn($shortUrl);
         $this->em->getRepository(ShortUrl::class)->willReturn($repo->reveal());
 
-        $this->assertFalse($this->cache->contains($shortCode));
+        $this->assertFalse($this->cache->contains($shortCode . '_longUrl'));
         $url = $this->urlShortener->shortCodeToUrl($shortCode);
         $this->assertEquals($shortUrl->getOriginalUrl(), $url);
-        $this->assertTrue($this->cache->contains($shortCode));
+        $this->assertTrue($this->cache->contains($shortCode . '_longUrl'));
     }
 
     /**
@@ -151,7 +151,7 @@ class UrlShortenerTest extends TestCase
     {
         $shortCode = '12C1c';
         $expectedUrl = 'expected_url';
-        $this->cache->save($shortCode, $expectedUrl);
+        $this->cache->save($shortCode . '_longUrl', $expectedUrl);
         $this->em->getRepository(ShortUrl::class)->willReturn(null)->shouldBeCalledTimes(0);
 
         $url = $this->urlShortener->shortCodeToUrl($shortCode);