Brands

 
        if (array_key_exists(2, $this->routeInfo)) {
            $params = $this->routeInfo[2];
            if (array_key_exists('pagenbr', $params)) {
                $input->setPageNum(intval($params['pagenbr']));
            }
        }
        return $this->handleRoute($this->routeInfo);
    }
 
    /**
     * Try Calling the Handler Function, catch errors if needed
     * @param  array $routeInfo
     * @return strings
     */
    protected function handleRoute() {
        $response = '';
 
        try {
            $response = $this->handle($this->routeInfo);
        } catch (Wire404Exception $e) {
            $this->error = true;
            throw $e;
        } catch (Exception $e) {
            $this->error = true;
            $response = $this->handleException($e);
        }
        return $response;
    }
 
    /**
     * Return Response after Handling Exception
     * @param  Exception $e
     * @return string
     */
    protected function handleException(Exception $e) {
        $whoops = new Whoops();
        $whoops->allowQuit(false);
        $whoops->writeToOutput(false);
        $whoops->pushHandler($this->getWhoopsEmailPageHandler());

    public function setRoutePrefix($prefix = '') {
        $this->routeprefix = $prefix;
    }
 
    /**
     * Return Route Handler Call
     * @return mixed
     */
    public function route() {
        $input = $this->wire('input');
        $dispatcher = $this->dispatcher();
        $this->routeInfo  = $dispatcher->dispatch($input->requestMethod(), $input->url());
 
        if (array_key_exists(2, $this->routeInfo)) {
            $params = $this->routeInfo[2];
            if (array_key_exists('pagenbr', $params)) {
                $input->setPageNum(intval($params['pagenbr']));
            }
        }
        return $this->handleRoute($this->routeInfo);
    }
 
    /**
     * Try Calling the Handler Function, catch errors if needed
     * @param  array $routeInfo
     * @return strings
     */
    protected function handleRoute() {
        $response = '';
 
        try {
            $response = $this->handle($this->routeInfo);
        } catch (Wire404Exception $e) {
            $this->error = true;
            throw $e;
        } catch (Exception $e) {
            $this->error = true;
            $response = $this->handleException($e);
        }
        return $response;

<?php
    use Controllers\Brands;
 
    $routes = [
        ['GET',  '', \ProcessWire\Brands::class, 'index'],
    ];
    $router = new Mvc\Routers\Router();
    $router->setRoutes($routes);
    $router->setRoutePrefix($page->url);
    $page->html = $router->route();
 
 include(\ProcessWire\wire('files')->compile(\ProcessWire\wire("config")->paths->root . 'site/templates/basic-page.php',array('includes'=>true,'namespace'=>true,'modules'=>true,'skipIfNamespace'=>true)));
 

        try {
            // include prepend files
            foreach($this->prependFilename as $_filename) {
                if($this->halt) break;
                $this->fileReady($_filename);
                require($_filename);
                $this->fileFinished();
            }
        } catch(\Exception $e) {
            if($this->fileFailed($this->currentFilename, $e)) throw $this->renderFailed($e);
        }
        
        if($this->halt) {
            // if prepend file indicates we should halt, then do not render next file
            $this->returnValue = 0;
        } else {
            // include main file to render
            try {
                $this->fileReady($this->filename);
                $this->returnValue = require($this->filename);
                $this->fileFinished();
            } catch(\Exception $e) {
                if($this->fileFailed($this->filename, $e)) throw $this->renderFailed($e);
            }
        }
    
        try {
            // include append files
            foreach($this->appendFilename as $_filename) {
                if($this->halt) break;
                $this->fileReady($_filename);
                require($_filename);
                $this->fileFinished();
            }
        } catch(\Exception $e) {
            if($this->fileFailed($this->currentFilename, $e)) throw $this->renderFailed($e);
        }
        
        $out = ob_get_contents();
        ob_end_clean();

    public function setLocalHooks(array $hooks) {
        $this->localHooks = $hooks;
    }
 
    /**
     * Call a method in this object, for use by WireHooks
     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

                } else {
                    throw new WireException("Invalid output file location or specified file does not exist. $setFilename"); 
                }
            } else {
                if($compiler) {
                    $options['filename'] = $compiler->compile($template->filename);
                    $output->setFilename($options['filename']);
                    $output->setChdir(dirname($template->filename));
                } else {
                    $options['filename'] = $template->filename;
                }
            }
 
            // pass along the $options as a local variable to the template so that one can provide their 
            // own additional variables in it if they want to
            $output->set('options', $options);
 
            $profiler = $this->wire('profiler');
            $profilerEvent = $profiler ? $profiler->start($page->path, $this, array('page' => $page)) : null;
            $data = $output->render();
            if($profilerEvent) $profiler->stop($profilerEvent);
            if(!strlen($data) && $page->template->name === 'admin' && !is_readable($options['filename'])) {
                throw new WireException('Missing or non-readable template file: ' . basename($options['filename']));
            }
        }
 
        if($this->wire('config')->useMarkupRegions) {
            $contentType = $template->contentType; 
            if(empty($contentType) || stripos($contentType, 'html') !== false) {
                $this->populateMarkupRegions($data);
            }
        }
 
        if($data && $cacheAllowed && $cacheFile) {
            $data = $this->saveCacheFileReady($page, $data);
            $cacheFile->save($data);
        }
        
        $event->return = $data; 
 

 
    /**
     * Call a method in this object, for use by WireHooks
     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal
     * 
     * @param string $method Method name, without leading "___"
     * @param array $arguments

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

                    if(!$toMethodCallable && strpos($toMethod, "\\") === false && __NAMESPACE__) {
                        $_toMethod = $toMethod;
                        $toMethod = "\\" . __NAMESPACE__ . "\\$toMethod";
                        $toMethodCallable = is_callable($toMethod);
                        if(!$toMethodCallable) {
                            $toMethod = "\\$_toMethod";
                            $toMethodCallable = is_callable($toMethod);
                        }
                    }
                    if($toMethodCallable) {
                        $returnValue = $toMethod($event);
                    } else {
                        // hook fail, not callable
                        $returnValue = null;
                    }
                } else {
                    /** @var Wire $toObject */
                    if($hook['toPublic']) {
                        // public
                        $returnValue = $toObject->$toMethod($event);
                    } else {
                        // protected or private
                        $returnValue = $toObject->_callMethod($toMethod, array($event));
                    }
                    $toMethodCallable = true; 
                }
 
                if($returnValue !== null) {
                    // hook method/func had an explicit 'return $value;' statement 
                    // we can optionally use this rather than $event->return. Can be useful
                    // in cases where a return value doesn’t need to be passed around to
                    // more than one hook
                    if($useHookReturnValue) {
                        $event->return = $returnValue;
                    }
                }
                
                if($profilerEvent) $profiler->stop($profilerEvent);
                
                if(!$toMethodCallable) continue;

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

        if($this->delayRedirects) {
            $this->checkProtocol($page);
            if($this->redirectURL) $this->redirect($this->redirectURL);
        }
 
        try {
 
            if($this->requestFile) {
 
                $this->responseType = self::responseTypeFile;
                $this->wire()->setStatus(ProcessWire::statusDownload, array('downloadFile' => $this->requestFile));
                $this->sendFile($page, $this->requestFile);
 
            } else {
 
                $contentType = $this->contentTypeHeader($page, true);
                $this->wire()->setStatus(ProcessWire::statusRender, array('contentType' => $contentType));
                if($config->ajax) $this->responseType = self::responseTypeAjax;
                
                return $page->render();
            }
 
        } catch(Wire404Exception $e) {
            // 404 exception
            TemplateFile::clearAll();
            return $this->renderNoPage(array(
                'reason404' => '404 thrown during page render',
                'exception404' => $e, 
                'page' => $page, 
                'ready' => true, // let it know ready state already executed
            ));
 
        } catch(\Exception $e) {
            // other exception (re-throw non 404 exceptions)
            $this->responseType = self::responseTypeError;
            $this->failed($e, "Thrown during page render", $page);
            throw $e; 
        }
 
        return '';

      *
     */
    public function ___execute($internal = true) {
    
        if(!$internal) return $this->executeExternal();
 
        $this->responseType = self::responseTypeNormal;
        $config = $this->wire()->config; 
        $timerKey = $config->debug ? 'ProcessPageView.getPage()' : ''; 
        if($config->usePoweredBy !== null) header('X-Powered-By:' . ($config->usePoweredBy ? ' ProcessWire CMS' : ''));
        
        $this->wire()->pages->setOutputFormatting(true); 
        
        if($timerKey) Debug::timer($timerKey); 
        $page = $this->getPage();
        if($timerKey) Debug::saveTimer($timerKey, ($page && $page->id ? $page->path : '')); 
        
        if(!$page || !$page->id) return $this->renderNoPage();
        
        return $this->renderPage($page);
    }
 
    /**
     * Render Page
     * 
     * @param Page $page
     * @return bool|mixed|string
     * @throws WireException
     * @since 3.0.173
     * 
     */
    protected function renderPage(Page $page) {
        
        $config = $this->wire()->config;
        $page->setOutputFormatting(true);
        $_page = $page;
        
        $page = $this->checkAccess($page);
 
        if(!$page || $_page->id == $config->http404PageID) {

 
    /**
     * Call a method in this object, for use by WireHooks
     * 
     * #pw-internal
     * 
     * @param string $method
     * @param array $arguments
     * @return mixed
     * 
     */
    public function _callMethod($method, $arguments) {
        $qty = $arguments ? count($arguments) : 0;
        $result = null;
        switch($qty) {
            case 0:
                $result = $this->$method();
                break;
            case 1:
                $result = $this->$method($arguments[0]);
                break;
            case 2:
                $result = $this->$method($arguments[0], $arguments[1]);
                break;
            case 3:
                $result = $this->$method($arguments[0], $arguments[1], $arguments[2]);
                break;
            default:
                $result = call_user_func_array(array($this, $method), $arguments);
        }
        return $result;
    }
 
    /**
     * Call a hook method (optimization when it's known for certain the method exists)
     * 
     * #pw-internal
     * 
     * @param string $method Method name, without leading "___"
     * @param array $arguments

            'return' => null,
            'numHooksRun' => 0,
            'methodExists' => $methodExists,
            'replace' => false,
        );
        
        if($type === 'method' || $type === 'property' || $type === 'either') {
            if(!$methodExists && !$this->isHookedOrParents($object, $method, $type)) {
                return $result; // exit quickly when we can
            }
        }
        
        if($hooks === null) $hooks = $this->getHooks($object, $method);
    
        foreach(array('before', 'after') as $when) {
 
            if($type === 'method') {
                if($when === 'after' && $result['replace'] !== true) {
                    if($methodExists) {
                        $result['return'] = $object->_callMethod($realMethod, $arguments);
                    } else {
                        $result['return'] = null;
                    }
                }
            } else if($type === 'after') {
                if($when === 'before') continue;
            } else if($type === 'before') {
                if($when === 'after') break;
            }
 
            foreach($hooks as $priority => $hook) {
 
                if(!$hook['options'][$when]) continue;
                if($type === 'property' && $hook['options']['type'] === 'method') continue;
                if($type === 'method' && $hook['options']['type'] === 'property') continue;
 
                if(!empty($hook['options']['objMatch'])) {
                    /** @var Selectors $objMatch */
                    $objMatch = $hook['options']['objMatch'];
                    // object match comparison to determine at runtime whether to execute the hook

     * See the Wire::runHooks() method for the full implementation of hook calls.
     *
     * @param string $method
     * @param array $arguments
     * @return mixed
     * @throws WireException
     *
     */ 
    public function __call($method, $arguments) {
        if(empty($arguments) && Fuel::isCommon($method)) { 
            // faster version of _callWireAPI for when conditions allow
            if($this->_wire && !method_exists($this, "___$method")) {
                // get a common API var with no arguments as method call more quickly 
                $val = $this->_wire->fuel($method);
                if($val !== null) return $val;
            }
        }
        $hooks = $this->_wireHooks();
        if($hooks) {
            $result = $hooks->runHooks($this, $method, $arguments);
            if(!$result['methodExists'] && !$result['numHooksRun']) {
                $result = $this->_callWireAPI($method, $arguments);
                if(!$result) return $this->callUnknown($method, $arguments);
            }
        } else {
            $result = $this->_callWireAPI($method, $arguments);
            if(!$result) return $this->___callUnknown($method, $arguments);
        }
        return $result['return'];
    }
 
    /**
     * Helper to __call() method that maps a call to an API variable when appropriate
     * 
     * @param string $method
     * @param array $arguments
     * @return array|bool
     * @internal
     * 
     */

    // If ProcessWire is not installed, go to the installer
    if(is_file("./install.php") && strtolower($_SERVER['REQUEST_URI']) == strtolower($config->urls->root)) {
        require("./install.php");
        exit(0);
    } else {
        header("HTTP/1.1 404 Page Not Found");
        echo "404 page not found (no site configuration or install.php available)";
        exit(0);
    }
}
 
$process = null;
$wire = null;
 
try { 
    // Bootstrap ProcessWire's core and make the API available with $wire
    $wire = new ProcessWire($config);
    $process = $wire->modules->get('ProcessPageView'); /** @var ProcessPageView $process */
    $wire->wire('process', $process); 
    echo $process->execute($config->internal);
    $config->internal ? $process->finished() : extract($wire->wire('all')->getArray());
    
} catch(\Exception $e) {
    // Formulate error message and send to the error handler
    if($process) $process->failed($e);
    $wire ? $wire->trackException($e) : $config->trackException($e);
    $errorMessage = "Exception: " . $e->getMessage() . " (in " . $e->getFile() . " line " . $e->getLine() . ")";
    if($config->debug || ($wire && $wire->user && $wire->user->isSuperuser())) $errorMessage .= "\n\n" . $e->getTraceAsString();
    trigger_error($errorMessage, E_USER_ERROR);
}