Fixed validateResolved()

Author: huangzhhui

src/Middleware/ValidationMiddleware.php

@@ -12,32 +12,36 @@
 
 namespace Hyperf\Validation\Middleware;
 
+use FastRoute\Dispatcher;
+use Hyperf\Di\ReflectionManager;
 use Hyperf\HttpServer\Router\Dispatched;
-use Hyperf\HttpServer\Router\DispatcherFactory;
+use Hyperf\Server\Exception\ServerException;
+use Hyperf\Utils\Context;
 use Hyperf\Validation\Contracts\Validation\ValidatesWhenResolved;
+use Hyperf\Validation\UnauthorizedException;
 use Psr\Container\ContainerInterface;
 use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 use Psr\Http\Server\MiddlewareInterface;
 use Psr\Http\Server\RequestHandlerInterface;
+use Hyperf\HttpServer\Contract\ResponseInterface as HyperfResponseInterface;
 
 class ValidationMiddleware implements MiddlewareInterface
 {
+
     /**
-     * @var Dispatcher
+     * @var \Psr\Container\ContainerInterface
      */
-    protected $dispatcher;
+    private $container;
 
     /**
-     * @var ContainerInterface
+     * @var array
      */
-    protected $container;
+    private $implements = [];
 
     public function __construct(ContainerInterface $container)
     {
-        $this->container  = $container;
-        $factory          = $this->container->get(DispatcherFactory::class);
-        $this->dispatcher = $factory->getDispatcher('http');
+        $this->container = $container;
     }
 
     /**
@@ -48,13 +52,41 @@ public function process(ServerRequestInterface $request, RequestHandlerInterface
     {
         /** @var Dispatched $dispatched */
         $dispatched = $request->getAttribute(Dispatched::class);
-        $params     = $dispatched->params;
-        foreach ($params as $param) {
-            if ($param instanceof ValidatesWhenResolved) {
-                $param->validateResolved();
+
+        if (! $dispatched instanceof Dispatched) {
+            throw new ServerException(sprintf('The dispatched object is not a %s object.', Dispatched::class));
+        }
+        if ($dispatched->status !== Dispatcher::FOUND) {
+            return $handler->handle($request);
+        }
+
+        $reflectionMethod = ReflectionManager::reflectMethod(...$dispatched->handler->callback);
+        $parmeters = $reflectionMethod->getParameters();
+        try {
+            foreach ($parmeters as $parameter) {
+                $classname = $parameter->getType()->getName();
+                $implements = $this->getClassImplements($classname);
+                if (in_array(ValidatesWhenResolved::class, $implements, true)) {
+                    /** @var ValidatesWhenResolved $parameterInstance */
+                    $parameterInstance = $this->container->get($classname);
+                    $parameterInstance->validateResolved();
+                }
             }
+        } catch (UnauthorizedException $exception) {
+            $response = Context::override(ResponseInterface::class, function (ResponseInterface $response) {
+                return $response->withStatus(403);
+            });
+            return $response;
         }
 
         return $handler->handle($request);
     }
+
+    public function getClassImplements(string $class): array
+    {
+        if (! isset($this->implements[$class])) {
+            $this->implements[$class] = class_implements($class);
+        }
+        return $this->implements[$class];
+    }
 }