Introduced alternative way to pass params to the target action.

Author: georgique

Action.php

@@ -5,6 +5,8 @@
 use yii\base\InvalidRouteException;
 use yii\base\UserException;
 use yii\helpers\Json;
+use yii\web\NotFoundHttpException;
+use yii\web\Request;
 
 /**
  * Class Action
@@ -17,6 +19,11 @@
  */
 class Action extends \yii\base\Action {
 
+    /** @var Request $originalYiiRequest */
+    private $originalYiiRequest;
+
+    public $paramsPassMethod;
+
     /**
      * Parses json body.
      * @param $rawBody
@@ -39,7 +46,8 @@ public function parseJsonRpcBody($rawBody) {
 
 
     /**
-     * Validates method string and converts it into a route.
+     * Validates method string and converts it into a route, which is going to be parsed by UrlManager before executing
+     * the request.
      * @param $method
      * @return bool|string
      */
@@ -80,7 +88,7 @@ public function parseRequest($request) {
             throw new JsonRpcException($request->id, "The JSON sent is not a correct JSON-RPC request - missing or incorrect method.", JSON_RPC_ERROR_REQUEST_INVALID);
         }
 
-        $params = null;
+        $params = [];
         if (isset($request->params)) {
             $params = (array) $request->params;
         }
@@ -121,30 +129,79 @@ public function parseRequests($params) {
         throw new JsonRpcException(null, "The JSON sent is not a correct JSON-RPC request.", JSON_RPC_ERROR_REQUEST_INVALID);
     }
 
+    /**
+     * Preserves original Yii request.
+     * @param $request
+     * @return $this
+     */
+    protected function preserveYiiRequest() {
+        $this->originalYiiRequest = clone \Yii::$app->request;
+        return $this;
+    }
+
+    protected function restoreYiiRequest() {
+        \Yii::$app->request->setUrl($this->originalYiiRequest->getUrl());
+        \Yii::$app->request->setPathInfo($this->originalYiiRequest->getPathInfo());
+        \Yii::$app->request->setBodyParams($this->originalYiiRequest->getBodyParams());
+        \Yii::$app->request->setQueryParams($this->originalYiiRequest->getQueryParams());
+        \Yii::$app->request->setRawBody($this->originalYiiRequest->getRawBody());
+        return $this;
+    }
+
     /**
      * Executes JSON-RPC request by route.
-     * @param JsonRpcRequest $request
+     * @param JsonRpcRequest $jsonRpcRequest
      * @return JsonRpcException|mixed
      */
-    public function executeRequest($request) {
-        $route = $request->route;
+    public function executeRequest($jsonRpcRequest) {
+        $this->preserveYiiRequest();
+        $route = $jsonRpcRequest->route;
         try {
-            \Yii::trace("Route requested: '$route'", __METHOD__);
+            // Replacing requested URL and path info
+            \Yii::$app->request->setUrl($route);
+            \Yii::$app->request->setPathInfo(null);
+
+            try {
+                $routeWithParams = \Yii::$app->request->resolve();
+            }
+            catch (NotFoundHttpException $exception) {
+                $routeWithParams = false;
+            }
+
+            if (!$routeWithParams) {
+                $this->restoreYiiRequest();
+                return new JsonRpcException($jsonRpcRequest->id, 'Method not found: ' . $route . '.',
+                    JSON_RPC_ERROR_METHOD_NOT_FOUND);
+            }
+            list($routeParsed, $params) = $routeWithParams;
+
+            // Replacing route
             \Yii::$app->requestedRoute = $route;
-            $result = \Yii::$app->runAction($request->route, $request->params);
+            if ($this->paramsPassMethod == JSON_RPC_PARAMS_PASS_BODY) {
+                \Yii::$app->request->setBodyParams($jsonRpcRequest->params);
+                \Yii::$app->request->setRawBody(Json::encode($jsonRpcRequest->params));
+                $result = \Yii::$app->runAction($routeParsed, $params);
+            }
+            else {
+                $params += $jsonRpcRequest->params;
+                $result = \Yii::$app->runAction($routeParsed, $params);
+            }
+            $this->restoreYiiRequest();
+
             return $result;
         }
         catch (\Exception $exception) {
             if ($exception instanceof InvalidRouteException) {
-                $result = new JsonRpcException($request->id, 'Method not found: ' . $route . '.',
+                $result = new JsonRpcException($jsonRpcRequest->id, 'Method not found: ' . $route . '.',
                     JSON_RPC_ERROR_METHOD_NOT_FOUND, $exception);
             }
             else if ($exception instanceof JsonRpcException) {
                 $result = $exception;
             }
             else {
-                $result = new JsonRpcException($request->id, 'Internal error.', JSON_RPC_ERROR_INTERNAL, $exception);
+                $result = new JsonRpcException($jsonRpcRequest->id, 'Internal error.', JSON_RPC_ERROR_INTERNAL, $exception);
             }
+            $this->restoreYiiRequest();
 
             return $result;
         }

Controller.php

@@ -12,13 +12,25 @@
 const JSON_RPC_ERROR_METHOD_PARAMS_INVALID = -32602;
 const JSON_RPC_ERROR_INTERNAL = -32603;
 
+// Pass params as function arguments
+const JSON_RPC_PARAMS_PASS_FUNCARGS = 1;
+
+// Pass params as request body
+const JSON_RPC_PARAMS_PASS_BODY = 2;
+
 class Controller extends \yii\web\Controller {
 
+    /**
+     * @var int $paramsPassMethod Defines method to pass params to the target action.
+     */
+    public $paramsPassMethod = JSON_RPC_PARAMS_PASS_FUNCARGS;
+
     public function actions()
     {
         return [
             'index' => [
                 'class' => Action::class,
+                'paramsPassMethod' => $this->paramsPassMethod
             ]
         ];
     }

JsonRpcRequest.php

@@ -14,7 +14,6 @@ class JsonRpcRequest extends BaseObject {
 
     public $id;
     public $route;
-    public $params;
-    public $originalRequest;
+    public $params = [];
 
 }

README.md

@@ -14,15 +14,32 @@ Entry point:
 <?php
 
 namespace app\controllers;
+use \georgique\yii2\json-rpc\Controller;
 
-class JsonRpcController extends \georgique\yii2\json-rpc\Controller {
+class JsonRpcController extends Controller {
 
 	// Practically you don't need anything else in this controller, 
 	// unless you want to customize entry point somehow.
 
 }
 ```
 
+Entry point with different way to pass params:
+```php
+<?php
+
+namespace app\controllers;
+use \georgique\yii2\json-rpc\Controller;
+
+class JsonRpcBodyController extends Controller {
+
+	// With the customization JSON RPC params will be passed to the target action
+	// as request body params, not as action function arguments
+    public $paramsPassMethod = JSON_RPC_PARAMS_PASS_BODY;
+
+}
+```
+
 Controller with target actions which we are going to call:
 ```php
 <?php
@@ -47,6 +64,16 @@ class ExampleController extends \yii\web\Controller {
     public function actionTryWithParams($foo) {
         return "Params received: \$foo = $foo.";
     }
+    
+    // Passing params as Yii request body params must be handy too, when we need to do a bulk
+    // attribute assignment for example.
+    public function actionTryWithBodyParams() {
+        $output = "Params received: \n";
+        foreach (\Yii::$app->request->getBodyParams() as $name => $value) {
+            $output .= "$name = $value\n";
+        }
+        return $output;
+    }
 
 }
 ```
@@ -59,6 +86,12 @@ Now this is how calls and responses will look like:
 -> {"jsonrpc": "2.0", "method": "api1.example.try-with-params", "params": {"foo": "bar"}, "id": 2}
 <- {"jsonrpc": "2.0", "result": "Params received: $foo = bar.", "id": 2}
 
+// Using alternative entry point:
+-> {"jsonrpc": "2.0", "method": "api1.example.try-with-body-params", "params": {"foo": "bar"}, "id": 2}
+<- {"jsonrpc": "2.0", "result": "Params received: 
+    $foo = bar.
+    ", "id": 2}
+
 -> {"jsonrpc": "2.0", "method": "api1.example.garbage", "id": 3}
 <- {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Method not found."}, "id": 3}
 
@@ -74,5 +107,4 @@ Now this is how calls and responses will look like:
    ]
 ```
 
-
 Author: George Shestayev [email protected]