moved to static uses

src/Generator/business.php.twig

 use App\Http\DBO\{{ dbo_name.as_it }};
 
 class {{ business_name.as_it }} extends LuBusiness {
-    public function __construct(array $parametersSource)
+    public function __construct()
     {
-        parent::__construct($parametersSource);
         $this->dataAccess = new {{ data_access_name.as_it }}();
     }
 }

src/Utils/LuBusiness.php

 namespace Luticate\Utils;
 
 class LuBusiness {
-    /**
-     * @var array
-     */
-    private $parameters = [];
 
     /**
      * @var LuDataAccess
      */
     protected $dataAccess = null;
 
-    /**
-     * @param array $parametersSource
-     */
-    public function __construct(array $parametersSource)
-    {
-        $this->parameters = $parametersSource;
-    }
-
     /**
      * @param string $name
      * @param mixed  $default
      * @return mixed
      */
-    protected function getParam($name, $default = null)
+    public static function getParam($name, $default = null)
     {
-        return array_key_exists($name, $this->parameters) ? $this->parameters[$name] : $default;
+        return array_key_exists($name, LuController::$parameters) ? LuController::$parameters[$name] : $default;
     }
 
     /**
      * @param string $name
      * @param mixed  $value
      */
-    public function setParam($name, $value)
+    public static function setParam($name, $value)
     {
-        $this->parameters[$name] = $value;
+        LuController::$parameters[$name] = $value;
     }
 
     /**
      * @param string[] $params
      * @return bool
      */
-    public function hasParam(array $params)
+    public static function hasParam(array $params)
     {
         foreach ($params as $p)
         {
-            if (!array_key_exists($p, $this->parameters))
+            if (!array_key_exists($p, LuController::$parameters))
                 return false;
         }
         return true;
      * @param mixed $validate
      * @return string
      */
-    public function checkParam($param, $validate = null)
+    public static function checkParam($param, $validate = null)
     {
-        $value = $this->getParam($param);
+        $value = self::getParam($param);
         if (is_null($value) || trim($value) == '')
             abort(400, 'Missing parameter: ' . $param);
         if ($validate != null) {
     /**
      * @param string
      */
-    public function unauthorized($reason = 'Unauthorized')
+    public static function unauthorized($reason = 'Unauthorized')
     {
         abort(401, $reason);
     }
     /**
      * @param string
      */
-    public function notFound($reason = 'Resource not found')
+    public static function notFound($reason = 'Resource not found')
     {
         abort(404, $reason);
     }
      * @param $values string[]
      * @return string
      */
-    public function getParamInArray($param, $values)
+    public static function getParamInArray($param, $values)
     {
-        $value = $this->getParam($param);
+        $value = self::getParam($param);
         if (is_null($value) || !in_array($value, $values))
             $value = $values[0];
         return $value;
      * @param $default int
      * @return int
      */
-    public function getParamInt($param, $default = 0)
+    public static function getParamInt($param, $default = 0)
     {
-        $value = $this->getParam($param);
+        $value = self::getParam($param);
         if (!is_null($value) && is_numeric($value))
             return (int)$value;
         return $default;
     }
 
+    public static function __callStatic($name, $arguments)
+    {
+        $class = get_called_class();
+        $me = new $class();
+        return call_user_func_array(array($me, $name), $arguments);
+    }
+
     /**
      * @param $page int
      * @param $perPage int
     {
         $this->dataAccess->deleteById($id);
     }
-
-    /**
-     * @param $data LuDbo
-     * @return int
-     */
-    public function addId($data)
-    {
-        return $this->dataAccess->addId($data);
-    }
-
-    /**
-     * @param $data LuDbo
-     */
-    public function add($data)
-    {
-        $this->dataAccess->add($data);
-    }
-
-    /**
-     * @param $id int
-     * @param $data LuDbo
-     * @return LuDbo|null
-     */
-    public function editById($id, $data)
-    {
-        return $this->dataAccess->editById($id, $data);
-    }
 }

src/Utils/LuController.php

 
 class LuController extends BaseController
 {
+    public static $parameters = null;
+
     function execute($businessClass, $businessMethod)
     {
         $params = app('request')->route()[2];
-        $business = new $businessClass(array_merge($_GET, $_POST, $params));
+        self::$parameters = array_merge($_GET, $_POST, $params);
+        $business = new $businessClass();
 
         $reflect = new \ReflectionMethod($businessClass, $businessMethod);
         $params = $reflect->getParameters();
 
         $args = array();
-        foreach ($params as $param)
-            $args[$param->getName()] = $business->checkParam($param->getName());
+        foreach ($params as $param) {
+            if ($param->isOptional()) {
+                $args[$param->getName()] = LuBusiness::getParam($param->getName(), $param->getDefaultValue());
+            }
+            else {
+                $args[$param->getName()] = LuBusiness::checkParam($param->getName());
+            }
+        }
 
         return LuOutputFormatter::formatSuccess(call_user_func_array(array($business, $businessMethod), $args));
     }

src/Utils/LuDataAccess.php

     {
     }
 
+    public static function __callStatic($name, $arguments)
+    {
+        $class = get_called_class();
+        $me = new $class();
+        return call_user_func_array(array($me, $name), $arguments);
+    }
+
     /**
      * @var LuModel
      */
      * @param $data LuModel[]
      * @return LuDbo[]
      */
-    protected function arrayToDbo($data)
+    protected static function arrayToDbo($data)
     {
         $tab = [];
         foreach ($data as $q) {

src/Utils/LuModel.php

 /**
  * LuModel
  *
- * @method Collection where($column, $operator, $value)
- * @method Collection orderBy($column, $order)
+ * @method static LuModel where($column, $operator, $value)
+ * @method static LuModel orderBy($column, $order)
+ * @method static LuModel take($count)
+ * @method static LuModel offset($offset)
+ * @method static LuModel[] get()
+ * @method static LuModel first()
+ * @method static int count()
  */
 abstract class LuModel extends Model
 {