PHP Helper::normalizeUrl方法代碼示例

 /**
  * Finds a page by its URL. Returns the page object and sets the $parameters property.
  * @param string $url The requested URL string.
  * @return \Cms\Classes\Page Returns \Cms\Classes\Page object or null if the page cannot be found.
  */
 public function findByUrl($url)
 {
     $this->url = $url;
     $url = RouterHelper::normalizeUrl($url);
     $apiResult = Event::fire('cms.router.beforeRoute', [$url], true);
     if ($apiResult !== null) {
         return $apiResult;
     }
     for ($pass = 1; $pass <= 2; $pass++) {
         $fileName = null;
         $urlList = [];
         $cacheable = Config::get('cms.enableRoutesCache');
         if ($cacheable) {
             $fileName = $this->getCachedUrlFileName($url, $urlList);
             if (is_array($fileName)) {
                 list($fileName, $this->parameters) = $fileName;
             }
         }
         /*
          * Find the page by URL and cache the route
          */
         if (!$fileName) {
             $router = $this->getRouterObject();
             if ($router->match($url)) {
                 $this->parameters = $router->getParameters();
                 $fileName = $router->matchedRoute();
                 if ($cacheable) {
                     if (!$urlList || !is_array($urlList)) {
                         $urlList = [];
                     }
                     $urlList[$url] = !empty($this->parameters) ? [$fileName, $this->parameters] : $fileName;
                     $key = $this->getUrlListCacheKey();
                     Cache::put($key, base64_encode(serialize($urlList)), Config::get('cms.urlCacheTtl', 1));
                 }
             }
         }
         /*
          * Return the page
          */
         if ($fileName) {
             if (($page = Page::loadCached($this->theme, $fileName)) === null) {
                 /*
                  * If the page was not found on the disk, clear the URL cache
                  * and repeat the routing process.
                  */
                 if ($pass == 1) {
                     $this->clearCache();
                     continue;
                 }
                 return null;
             }
             return $page;
         }
         return null;
     }
 }

 /**
  * Looks up a path to a skin-based file, if it doesn't exist, the default path is used.
  * @param  string  $path
  * @param  boolean $isPublic
  * @return string
  */
 public function getPath($path = null, $isPublic = false)
 {
     $path = RouterHelper::normalizeUrl($path);
     $assetFile = $this->skinPath . $path;
     if (File::isFile($assetFile)) {
         return $isPublic ? $this->publicSkinPath . $path : $this->skinPath . $path;
     } else {
         return $isPublic ? $this->defaultPublicSkinPath . $path : $this->defaultSkinPath . $path;
     }
 }

 /**
  * Returns the base backend URL
  */
 public function baseUrl($path = null)
 {
     $backendUri = Config::get('cms.backendUri');
     $baseUrl = Request::getBaseUrl();
     if ($path === null) {
         return $baseUrl . '/' . $backendUri;
     }
     $path = RouterHelper::normalizeUrl($path);
     return $baseUrl . '/' . $backendUri . $path;
 }

 /**
  * Returns the base backend URL
  */
 public function baseUrl($path = null)
 {
     $backendUri = $this->uri();
     $baseUrl = Request::getBaseUrl();
     if ($path === null) {
         return $baseUrl . '/' . $backendUri;
     }
     $path = RouterHelper::normalizeUrl($path);
     return $baseUrl . '/' . $backendUri . $path;
 }

 /**
  * Finds a page by its URL. Returns the page object and sets the $parameters property.
  * @param string $url The requested URL string.
  * @return \Cms\Classes\Page Returns \Cms\Classes\Page object or null if the page cannot be found.
  */
 public function findByUrl($url)
 {
     $url = RouterHelper::normalizeUrl($url);
     for ($pass = 1; $pass <= 2; $pass++) {
         $fileName = null;
         $urlList = [];
         $cacheable = Config::get('cms.enableRoutesCache') && in_array(Config::get('cache.driver'), ['apc', 'memcached', 'redis', 'array']);
         if ($cacheable) {
             $fileName = $this->getCachedUrlFileName($url, $urlList);
         }
         /*
          * Find the page by URL and cache the route
          */
         if (!$fileName) {
             $router = $this->getRouterObject();
             if ($router->match($url)) {
                 $this->parameters = $router->getParameters();
                 $fileName = $router->matchedRoute();
                 if ($cacheable) {
                     if (!$urlList || !is_array($urlList)) {
                         $urlList = [];
                     }
                     $urlList[$url] = $fileName;
                     $key = $this->getUrlListCacheKey();
                     Cache::put($key, serialize($urlList), Config::get('cms.urlCacheTtl', 1));
                 }
             }
         }
         /*
          * Return the page 
          */
         if ($fileName) {
             if (($page = Page::loadCached($this->theme, $fileName)) === null) {
                 /*
                  * If the page was not found on the disk, clear the URL cache
                  * and repeat the routing process.
                  */
                 if ($pass == 1) {
                     $this->clearCache();
                     continue;
                 }
                 return null;
             }
             return $page;
         }
         return null;
     }
 }

 private static function getTagRenderUrl($theme, $item)
 {
     $tag = Tag::where('name', $item->reference)->first();
     $page = CmsPage::loadCached($theme, $item->cmsPage);
     // Always check if the page can be resolved
     if (!$page) {
         return;
     }
     $url = null;
     if (!$tag) {
         $options = ['filter' => null, 'slug' => null];
     } else {
         $options = ['filter' => 'tag', 'slug' => $tag->slug];
     }
     // Generate the URL
     $url = CmsPage::url($page->getBaseFileName(), $options, false);
     $url = URL::to(Str::lower(RouterHelper::normalizeUrl($url))) . '/';
     return $url;
 }

 /**
  * Check for CLI or system/updates route and disable any plugin initialization
  */
 protected function registerPrivilegedActions()
 {
     $requests = ['/combine', '@/system/updates', '@/system/install', '@/backend/auth'];
     $commands = ['october:up', 'october:update'];
     /*
      * Requests
      */
     $path = RouterHelper::normalizeUrl(Request::path());
     $backendUri = RouterHelper::normalizeUrl(Config::get('cms.backendUri', 'backend'));
     foreach ($requests as $request) {
         if (substr($request, 0, 1) == '@') {
             $request = $backendUri . substr($request, 1);
         }
         if (stripos($path, $request) === 0) {
             PluginManager::$noInit = true;
         }
     }
     /*
      * CLI
      */
     if (App::runningInConsole() && count(array_intersect($commands, Request::server('argv'))) > 0) {
         PluginManager::$noInit = true;
     }
 }

 /**
  * Builds and caches a menu item tree.
  * This method is used internally for menu items and breadcrumbs.
  * @param \Cms\Classes\Theme $theme Specifies the current theme.
  * @return array Returns an array containing the page information
  */
 public static function buildMenuTree($theme)
 {
     if (self::$menuTreeCache !== null) {
         return self::$menuTreeCache;
     }
     $key = crc32($theme->getPath()) . 'static-page-menu-tree';
     $cached = Cache::get($key, false);
     $unserialized = $cached ? @unserialize($cached) : false;
     if ($unserialized !== false) {
         return self::$menuTreeCache = $unserialized;
     }
     $menuTree = ['--root-pages--' => []];
     $iterator = function ($items, $parent, $level) use(&$menuTree, &$iterator) {
         $result = [];
         foreach ($items as $item) {
             $viewBag = $item->page->getViewBag();
             $pageCode = $item->page->getBaseFileName();
             $itemData = ['url' => Str::lower(RouterHelper::normalizeUrl($viewBag->property('url'))), 'title' => $viewBag->property('title'), 'mtime' => $item->page->mtime, 'items' => $iterator($item->subpages, $pageCode, $level + 1), 'parent' => $parent, 'navigation_hidden' => $viewBag->property('navigation_hidden')];
             if ($level == 0) {
                 $menuTree['--root-pages--'][] = $pageCode;
             }
             $result[] = $pageCode;
             $menuTree[$pageCode] = $itemData;
         }
         return $result;
     };
     $pageList = new PageList($theme);
     $iterator($pageList->getPageTree(), null, 0);
     self::$menuTreeCache = $menuTree;
     Cache::put($key, serialize($menuTree), Config::get('cms.parsedPageCacheTTL', 10));
     return self::$menuTreeCache;
 }

 /**
  * {@inheritDoc}
  */
 public function getPath($path = null, $isPublic = false)
 {
     $path = RouterHelper::normalizeUrl($path);
     return $isPublic ? $this->defaultPublicSkinPath . $path : $this->defaultSkinPath . $path;
 }

 /**
  * Loads the URL map - a list of page file names and corresponding URL patterns.
  * The URL map can is cached. The clearUrlMap() method resets the cache. By default
  * the map is updated every time when a page is saved in the back-end, or 
  * when the interval defined with the cms.urlCacheTtl expires.
  * @return boolean Returns true if the URL map was loaded from the cache. Otherwise returns false.
  */
 protected function loadUrlMap()
 {
     $key = $this->getCacheKey('static-page-url-map');
     $cacheable = Config::get('cms.enableRoutesCache');
     $cached = $cacheable ? Cache::get($key, false) : false;
     if (!$cached || ($unserialized = @unserialize($cached)) === false) {
         /*
          * The item doesn't exist in the cache, create the map
          */
         $pageList = new PageList($this->theme);
         $pages = $pageList->listPages();
         $map = ['urls' => [], 'files' => [], 'titles' => []];
         foreach ($pages as $page) {
             $url = $page->getViewBag()->property('url');
             if (!$url) {
                 continue;
             }
             $url = Str::lower(RouterHelper::normalizeUrl($url));
             $file = $page->getBaseFileName();
             $map['urls'][$url] = $file;
             $map['files'][$file] = $url;
             $map['titles'][$file] = $page->getViewBag()->property('title');
         }
         self::$urlMap = $map;
         if ($cacheable) {
             Cache::put($key, serialize($map), Config::get('cms.urlCacheTtl', 1));
         }
         return false;
     }
     self::$urlMap = $unserialized;
     return true;
 }

 /**
  * Register the service provider.
  *
  * @return void
  */
 public function register()
 {
     /*
      * Register self
      */
     parent::register('system');
     /*
      * Register core providers
      */
     App::register('October\\Rain\\Config\\ConfigServiceProvider');
     App::register('October\\Rain\\Translation\\TranslationServiceProvider');
     /*
      * Define path constants
      */
     if (!defined('PATH_APP')) {
         define('PATH_APP', app_path());
     }
     if (!defined('PATH_BASE')) {
         define('PATH_BASE', base_path());
     }
     if (!defined('PATH_PUBLIC')) {
         define('PATH_PUBLIC', public_path());
     }
     if (!defined('PATH_STORAGE')) {
         define('PATH_STORAGE', storage_path());
     }
     if (!defined('PATH_PLUGINS')) {
         define('PATH_PLUGINS', base_path() . Config::get('cms.pluginsDir', '/plugins'));
     }
     /*
      * Register singletons
      */
     App::singleton('string', function () {
         return new \October\Rain\Support\Str();
     });
     App::singleton('backend.helper', function () {
         return new \Backend\Classes\BackendHelper();
     });
     App::singleton('backend.menu', function () {
         return \Backend\Classes\NavigationManager::instance();
     });
     App::singleton('backend.auth', function () {
         return \Backend\Classes\AuthManager::instance();
     });
     /*
      * Check for CLI or system/updates route and disable any plugin initialization
      * @todo This should be moved to middleware
      */
     $requestPath = \October\Rain\Router\Helper::normalizeUrl(\Request::path());
     $systemPath = \October\Rain\Router\Helper::normalizeUrl(Config::get('cms.backendUri') . '/system/updates');
     if (stripos($requestPath, $systemPath) === 0) {
         PluginManager::$noInit = true;
     }
     $updateCommands = ['october:up', 'october:update'];
     if (App::runningInConsole() && count(array_intersect($updateCommands, Request::server('argv'))) > 0) {
         PluginManager::$noInit = true;
     }
     /*
      * Register all plugins
      */
     $pluginManager = PluginManager::instance();
     $pluginManager->registerAll();
     /*
      * Error handling for uncaught Exceptions
      */
     App::error(function (\Exception $exception, $httpCode) {
         $handler = new ErrorHandler();
         return $handler->handleException($exception, $httpCode);
     });
     /*
      * Write all log events to the database
      */
     Event::listen('illuminate.log', function ($level, $message, $context) {
         if (!DbDongle::hasDatabase()) {
             return;
         }
         EventLog::add($message, $level);
     });
     /*
      * Register basic Twig
      */
     App::bindShared('twig', function ($app) {
         $twig = new Twig_Environment(new TwigLoader(), ['auto_reload' => true]);
         $twig->addExtension(new TwigExtension());
         return $twig;
     });
     /*
      * Register .htm extension for Twig views
      */
     App::make('view')->addExtension('htm', 'twig', function () {
         return new TwigEngine(App::make('twig'));
     });
     /*
      * Register Twig that will parse strings
      */
//.........這裏部分代碼省略.........

 /**
  * Returns URL of a category page.
  */
 protected static function getCategoryPageUrl($pageCode, $category, $theme)
 {
     $page = CmsPage::loadCached($theme, $pageCode);
     if (!$page) {
         return;
     }
     $properties = $page->getComponentProperties('blogPosts');
     if (!isset($properties['categoryFilter'])) {
         return;
     }
     $filter = substr($properties['categoryFilter'], 1);
     $url = CmsPage::url($page->getBaseFileName(), [$filter => $category->slug], false);
     return Str::lower(RouterHelper::normalizeUrl($url));
 }