public function trigger($event, array $args = [], $method = null) { $eventName = $this->getEventName($event); $handlers = array_merge(isset($this->events[$eventName]) ? $this->events[$eventName]->getEventHandlers() : [], isset($this->listeners[$eventName]) ? $this->listeners[$eventName] : []); $this->triggers[$eventName] = isset($this->triggers[$eventName]) ? $this->triggers[$eventName] + 1 : 1; if (!$handlers) { return null; } /** * Handlers are not chained anymore. * They are interrupted only if handler returns false. */ foreach ($handlers as $handler) { if (is_string($handler)) { $handler = Reflect::create($handler, $args); } if (is_callable($handler)) { Reflect::call($handler, $args); } else { if (is_object($handler)) { Reflect::method($handler, 'handle', $args); } } } return $this; }
/** * @T00D00 - this needs to be refactored without nesting ... * @return null */ public function runChains() { if (!$this->chains) { return null; } $next = $this->firstChain ?: function () { return $this; }; foreach (array_reverse($this->chains) as $chain) { $next = function () use($chain, $next) { if (is_string($chain)) { $chain = Reflect::create($chain); } if (is_callable($chain)) { $result = $chain(array_merge($this->args, ['next' => $next])); } else { $result = Reflect::method($chain, $this->runMethod, array_merge($this->args, ['next' => $next])); } return $result; }; } //startMeasure('Chain: ' . $this->runMethod . '()'); $result = $next(); //stopMeasure('Chain: ' . $this->runMethod . '()'); return $result; }
/** * @param $method * @param $args * * @return $this */ public function __call($method, $args) { if (method_exists($this->getQuery(), $method)) { /** * First overload Query. */ message(get_class($this) . '->__call(' . $method . ') on query ' . get_class($this->getQuery())); Reflect::method($this->getQuery(), $method, $args); } elseif (method_exists($this->getRightEntity(), $method)) { /** * Then right entity. */ message(get_class($this) . '->__call(' . $method . ') on right entity ' . get_class($this->getRightEntity())); Reflect::method($this->getRightEntity(), $method, $args); } elseif (method_exists($this, 'getMiddleEntity') && method_exists($this->getMiddleEntity(), $method)) { /** * Then middle entity. */ message(get_class($this) . '->__call(' . $method . ') on middle entity ' . get_class($this->getMiddleEntity())); Reflect::method($this->getMiddleEntity(), $method, $args); } else { message(get_class($this) . '->__call(' . $method . ') with right entity ' . get_class($this->getRightEntity())); $this->callWith($method, $args, $this->getRightEntity()); } return $this; }
/** * Register options */ public function register() { if ($this->registered) { return $this; } $hadStack = context()->exists(Stack::class); if (!$hadStack) { context()->bind(Stack::class, new Stack()); } $this->registerAutoloaders($this->autoload()); $this->registerClassMaps($this->classMaps()); $this->registerApps($this->apps()); $this->registerProviders($this->providers()); $this->registerRoutes($this->routes()); $this->registerListeners($this->listeners()); $this->registerMiddlewares($this->middlewares()); $this->registerAfterwares($this->afterwares()); $this->registerPaths($this->paths()); $this->registerViewObjects($this->viewObjects()); $this->registerConsoles($this->consoles()); $this->registerAssets($this->assets()); if (method_exists($this, 'registered')) { Reflect::method($this, 'registered'); } $this->registered = true; /** * Some actions needs to be executed in reverse direction, for example config initialization. */ if (!$hadStack) { $stack = context()->get(Stack::class); $stack->execute(); } return $this; }
/** * @return string * @throws Exception */ public function getHtml() { if ($this->class && $this->method) { $prefix = strtolower(request()->getMethod()); $args = array_merge($this->args, ['action' => $this]); $controller = Reflect::create($this->class, $args); $method = ($prefix ? $prefix . ucfirst($this->method) : $this->method) . 'Action'; if (isset($args['settings'])) { /** * We need to resolve dependencies. ;-) */ $args['settings']->each(function (Setting $setting) use(&$args) { $setting->pivot->resolve($args); }); } $result = null; $e = null; try { $result = Reflect::method($controller, $method, $args); } catch (Throwable $e) { if (prod()) { return null; } throw $e; } if (is_array($result)) { return $result; } else { return '<!-- ' . $this->class . '::' . $method . ' start -->' . ($e ? 'Exception: ' . exception($e) : $result) . '<!-- ' . $this->class . '::' . $method . ' end -->'; } } }
/** * @param $method * @param $args * * @return $this|Relation * @throws Exception */ public function callWith($method, $args, $object, $returnRelation = false) { if (is_string($object)) { $object = Reflect::create($object); } /** * Check if $method prefix is listed in autocallPrefixes. */ foreach ($this->autocallPrefixes as $prefix) { if (substr($method, 0, strlen($prefix)) === $prefix && strtoupper(substr($method, strlen($prefix), 1)) == substr($method, strlen($prefix), 1)) { /** * We are calling relation function without arguments: $entity->something();. */ $relationMethod = lcfirst(substr($method, strlen($prefix))); $relation = Reflect::method($object, $relationMethod, $args); // $relation = $object->{$relationMethod}(); if (isset($args[0]) && ($args[0] instanceof Closure || is_callable($args[0]))) { /** * If callback was added, we run it. * Now, this is a problem if we're making join because query was already merged. * So, we'll call this magically and provide both - relation and query. * * @T00D00 */ if ($prefix == 'join') { $rightEntity = $relation->getRightEntity(); $oldEntityQuery = $rightEntity->getQuery(); $rightEntity->setQuery($relation->getQuery()); Reflect::call($args[0], [$relation, $relation->getQuery()]); $rightEntity->setQuery($oldEntityQuery); } else { Reflect::call($args[0], [$relation, $relation->getQuery()]); } } /** * We'll call $entity->with($relation), and return Relation; */ $return = $object->{$prefix}($relation); /** * Then we return relation. */ return $returnRelation ? $relation : $return; } } if (!method_exists($object, $method)) { if (prod()) { return null; } throw new Exception('Method ' . $method . ' does not exist in ' . get_class($object)); } /** * Autoprefixes failed, return relation, probably? */ $relation = Reflect::method($object, $method, $args); if (isset($args[0]) && ($args[0] instanceof Closure || is_callable($args[0]))) { Reflect::call($args[0], [$relation, $relation->getQuery()]); } return $relation; }
public function make($controller, $method, $params = [], $byRequest = false) { /** * Create controller. */ $controller = Reflect::create($controller, $params); /** * Call action. */ $view = Reflect::method($controller, (!$byRequest ? $method : (request()->isPost() ? 'post' : 'get') . ucfirst($method)) . 'Action', $params); return (string) $view; }
public function execute() { $viewHttp = $this->request->isPost() ? 'post' . ucfirst($this->view) : 'get' . ucfirst($this->view); $result = null; $data = $this->getResolved(); if (!method_exists($this->controller, $viewHttp . "Action")) { throw new Exception('Method ' . $viewHttp . 'Action() does not exist in ' . get_class($this->controller)); } /** * Call main route action. */ $result = Reflect::method($this->controller, $viewHttp . "Action", array_merge($this->data, $data)); return $result; }
/** * @return $this */ public function initExtensions() { foreach (get_class_methods($this) as $method) { if (substr($method, 0, 4) == 'init' && substr($method, -9) == 'Extension') { $this->{$method}(); } else { if (substr($method, 0, 6) == 'inject' && substr($method, -12) == 'Dependencies') { Reflect::method($this, $method); } } } return $this; }
public function init() { list($namespace, $method) = explode('::', $this->config); Reflect::method($namespace, $method); }
public function execute(callable $next) { if (isConsole()) { return $next(); } $router = router()->get(); $routeName = $router['name']; foreach (config('pckg.auth.gates', []) as $gate) { $auth = auth($gate['provider']); /** * Check status rules. */ if ($gate['status']) { if ($gate['status'] == 'logged-out' && $auth->isLoggedIn()) { continue; } elseif ($gate['status'] == 'logged-in' && !$auth->isLoggedIn()) { continue; } } /** * Check user group rules. */ if ($gate['userGroup']) { if (!in_array($auth->getGroupId(), $gate['userGroup'])) { continue; } } /** * Check if route is excluded in rule. */ if (isset($gate['exclude'])) { if (in_array($routeName, $gate['exclude'])) { continue; } foreach ($gate['exclude'] as $route) { if (preg_match('#' . $route . '#', $routeName)) { continue; } } } /** * Check if route is included in rule. */ if (isset($gate['include']) && !in_array($routeName, $gate['include'])) { $found = false; foreach ($gate['include'] as $route) { if (preg_match('#' . $route . '#', $routeName)) { $found = true; break; } } if (!$found) { continue; } } /** * Check for callback. */ if (isset($gate['callback'])) { if (Reflect::method($gate['callback']['class'], $gate['callback']['method'])) { continue; } } redirect(url($gate['redirect'])); } return $next(); }
public function execute(InputInterface $input, OutputInterface $output) { Reflect::method($this, 'handle'); }