+global\FrontendPage::__buildPage()

Complexity

Conditions	37
Paths	2177

Size

Total Lines	220
Code Lines	117

Duplication

Lines	0
Ratio	0 %

Importance

Changes	3
Bugs	2	Features	0

<?php
    private function __buildPage()

__buildPage uses the super-global variable $_SERVER which is generally not recommended.

__buildPage uses the super-global variable $_COOKIE which is generally not recommended.

    {
        $start = precision_timer();

        if (!$page = $this->resolvePage()) {
            throw new FrontendPageNotFoundException;
        }

        /**
         * Just after having resolved the page, but prior to any commencement of output creation
         * @delegate FrontendPageResolved
         * @param string $context
         * '/frontend/'
         * @param FrontendPage $page
         *  An instance of this class, passed by reference
         * @param array $page_data
         *  An associative array of page data, which is a combination from `tbl_pages` and
         *  the path of the page on the filesystem. Passed by reference
         */
        Symphony::ExtensionManager()->notifyMembers('FrontendPageResolved', '/frontend/', array('page' => &$this, 'page_data' => &$page));

        $this->_pageData = $page;

It seems like $page can also be of type boolean. However, the property $_pageData is declared as type array. Maybe add an additional type check?

        $path = explode('/', $page['path']);
        $root_page = is_array($path) ? array_shift($path) : $path;
        $current_path = explode(dirname($_SERVER['SCRIPT_NAME']), $_SERVER['REQUEST_URI'], 2);
        $current_path = '/' . ltrim(end($current_path), '/');
        $split_path = explode('?', $current_path, 3);
        $current_path = rtrim(current($split_path), '/');
        $querystring = next($split_path);

        // Get max upload size from php and symphony config then choose the smallest
        $upload_size_php = ini_size_to_bytes(ini_get('upload_max_filesize'));
        $upload_size_sym = Symphony::Configuration()->get('max_upload_size', 'admin');
        $date = new DateTime();

        $this->_param = array(
            'today' => $date->format('Y-m-d'),
            'current-time' => $date->format('H:i'),
            'this-year' => $date->format('Y'),
            'this-month' => $date->format('m'),
            'this-day' => $date->format('d'),
            'timezone' => $date->format('P'),
            'website-name' => Symphony::Configuration()->get('sitename', 'general'),
            'page-title' => $page['title'],
            'root' => URL,
            'workspace' => URL . '/workspace',
            'http-host' => HTTP_HOST,
            'root-page' => ($root_page ? $root_page : $page['handle']),
            'current-page' => $page['handle'],
            'current-page-id' => $page['id'],
            'current-path' => ($current_path === '') ? '/' : $current_path,
            'parent-path' => '/' . $page['path'],
            'current-query-string' => self::sanitizeParameter($querystring),
            'current-url' => URL . $current_path,
            'upload-limit' => min($upload_size_php, $upload_size_sym),
            'symphony-version' => Symphony::Configuration()->get('version', 'symphony'),
        );

        if (isset($this->_env['url']) && is_array($this->_env['url'])) {
            foreach ($this->_env['url'] as $key => $val) {
                $this->_param[$key] = $val;
            }
        }

        if (is_array($_GET) && !empty($_GET)) {
            foreach ($_GET as $key => $val) {
                if (in_array($key, array('symphony-page', 'debug', 'profile'))) {
                    continue;
                }

                // If the browser sends encoded entities for &, ie. a=1&b=2
                // this causes the $_GET to output they key as amp;b, which results in
                // $url-amp;b. This pattern will remove amp; allow the correct param
                // to be used, $url-b
                $key = preg_replace('/(^amp;|\/)/', null, $key);

                // If the key gets replaced out then it will break the XML so prevent
                // the parameter being set.
                $key = General::createHandle($key);
                if (!$key) {
                    continue;
                }

                // Handle ?foo[bar]=hi as well as straight ?foo=hi RE: #1348
                if (is_array($val)) {
                    $val = General::array_map_recursive(array('FrontendPage', 'sanitizeParameter'), $val);

array('FrontendPage', 'sanitizeParameter') is of type array<integer,string,{"0":"string","1":"string"}>, but the function expects a string.

                } else {
                    $val = self::sanitizeParameter($val);
                }

                $this->_param['url-' . $key] = $val;
            }
        }

        if (is_array($_COOKIE[__SYM_COOKIE_PREFIX__]) && !empty($_COOKIE[__SYM_COOKIE_PREFIX__])) {
            foreach ($_COOKIE[__SYM_COOKIE_PREFIX__] as $key => $val) {
                if ($key === 'xsrf-token' && is_array($val)) {
                    $val = key($val);
                }

                $this->_param['cookie-' . $key] = $val;
            }
        }

        // Flatten parameters:
        General::flattenArray($this->_param);

        // Add Page Types to parameters so they are not flattened too early
        $this->_param['page-types'] = $page['type'];

        // Add Page events the same way
        $this->_param['page-events'] = explode(',', trim(str_replace('_', '-', $page['events']), ','));

        /**
         * Just after having resolved the page params, but prior to any commencement of output creation
         * @delegate FrontendParamsResolve
         * @param string $context
         * '/frontend/'
         * @param array $params
         *  An associative array of this page's parameters
         */
        Symphony::ExtensionManager()->notifyMembers('FrontendParamsResolve', '/frontend/', array('params' => &$this->_param));

        $xml_build_start = precision_timer();

        $xml = new XMLElement('data');
        $xml->setIncludeHeader(true);

        $events = new XMLElement('events');
        $this->processEvents($page['events'], $events);
        $xml->appendChild($events);

        $this->_events_xml = clone $events;

        $this->processDatasources($page['data_sources'], $xml);

        Symphony::Profiler()->seed($xml_build_start);
        Symphony::Profiler()->sample('XML Built', PROFILE_LAP);

        if (isset($this->_env['pool']) && is_array($this->_env['pool']) && !empty($this->_env['pool'])) {
            foreach ($this->_env['pool'] as $handle => $p) {
                if (!is_array($p)) {
                    $p = array($p);
                }

                foreach ($p as $key => $value) {
                    if (is_array($value) && !empty($value)) {
                        foreach ($value as $kk => $vv) {
                            $this->_param[$handle] .= @implode(', ', $vv) . ',';
                        }
                    } else {
                        $this->_param[$handle] = @implode(', ', $p);
                    }
                }

                $this->_param[$handle] = trim($this->_param[$handle], ',');
            }
        }

        /**
         * Access to the resolved param pool, including additional parameters provided by Data Source outputs
         * @delegate FrontendParamsPostResolve
         * @param string $context
         * '/frontend/'
         * @param array $params
         *  An associative array of this page's parameters
         */
        Symphony::ExtensionManager()->notifyMembers('FrontendParamsPostResolve', '/frontend/', array('params' => &$this->_param));

        $params = new XMLElement('params');
        foreach ($this->_param as $key => $value) {
            // To support multiple parameters using the 'datasource.field'
            // we will pop off the field handle prior to sanitizing the
            // key. This is because of a limitation where General::createHandle
            // will strip '.' as it's technically punctuation.
            if (strpos($key, '.') !== false) {
                $parts = explode('.', $key);
                $field_handle = '.' . array_pop($parts);
                $key = implode('', $parts);
            } else {
                $field_handle = '';
            }

            $key = Lang::createHandle($key) . $field_handle;
            $param = new XMLElement($key);

            // DS output params get flattened to a string, so get the original pre-flattened array
            if (isset($this->_env['pool'][$key])) {
                $value = $this->_env['pool'][$key];
            }

            if (is_array($value) && !(count($value) === 1 && empty($value[0]))) {
                foreach ($value as $val) {
                    $item = new XMLElement('item', General::sanitize($val));
                    $param->appendChild($item);
                }
            } elseif (is_array($value)) {
                $param->setValue(General::sanitize($value[0]));
            } elseif (in_array($key, array('xsrf-token', 'current-query-string'))) {
                $param->setValue(General::wrapInCDATA($value));
            } else {
                $param->setValue(General::sanitize($value));
            }

            $params->appendChild($param);
        }
        $xml->prependChild($params);

        $this->setXML($xml);
        $xsl = '<?xml version="1.0" encoding="UTF-8"?>' .
               '<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">' .
               '    <xsl:import href="/' . rawurlencode(ltrim($page['filelocation'], '/')) . '"/>' .
               '</xsl:stylesheet>';

        $this->setXSL($xsl, false);
        $this->setRuntimeParam($this->_param);

        Symphony::Profiler()->seed($start);
        Symphony::Profiler()->sample('Page Built', PROFILE_LAP);
    }