+global\FrontendPage::__buildPage()

Complexity

Conditions	37
Paths	2177

Size

Total Lines	226
Code Lines	120

Duplication

Lines	0
Ratio	0 %

Importance

Changes	4
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);
        }