Installer - Code Metrics - Inspection of "Fix when there is no pages" - symphonycms/symphony-2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — integration ( 45cc9f...98bc42 )

by Brendan
created 2016-06-28 06:21 UTC
Installer F

↳ Parent: Project
Complexity

Total Complexity
Size/Duplication

Total Lines	639
Duplicated Lines	9.39 %
Coupling/Cohesion

Components	2
Dependencies	15
Importance

Changes	7
Bugs	3	Features	1
Metric	Value
c	7
b	3
f	1
dl	60
loc	639
rs	1.4557
wmc	87
lcom	2
cbo	15
11 Methods

Rating	Name	Duplication	Size	Complexity
B	run()	28	54	9
A	__abort()	0	10	1
A	__render()	0	8	1
B	__construct()	0	31	2
A	instance()	0	8	2
A	initialiseLang()	0	6	2
A	initialiseDatabase()	0	4	1
A	initialiseLog()	0	8	3
F	__checkRequirements()	24	78	15
F	__checkConfiguration()	0	128	17
F	__install()	8	238	34
How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class
Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.
Complex classes like Installer often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Installer, and based on these observations, apply Extract Interface, too.
<?php

    require_once CORE . "/class.administration.php";

    class Installer extends Administration
    {
        /**
         * Override the default Symphony constructor to initialise the Log, Config
         * and Database objects for installation/update. This allows us to use the
         * normal accessors.
         */
        protected function __construct()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
        {
            self::$Profiler = Profiler::instance();
            self::$Profiler->sample('Engine Initialisation');

            if (get_magic_quotes_gpc()) {
                General::cleanArray($_SERVER);
                General::cleanArray($_COOKIE);
                General::cleanArray($_GET);
                General::cleanArray($_POST);
            }

            // Include the default Config for installation.
            include(INSTALL . '/includes/config_default.php');
            static::initialiseConfiguration($settings);


            // Initialize date/time
            define_safe('__SYM_DATE_FORMAT__', self::Configuration()->get('date_format', 'region'));

            define_safe('__SYM_TIME_FORMAT__', self::Configuration()->get('time_format', 'region'));

            define_safe('__SYM_DATETIME_FORMAT__', __SYM_DATE_FORMAT__ . self::Configuration()->get('datetime_separator', 'region') . __SYM_TIME_FORMAT__);
            DateTimeObj::setSettings(self::Configuration()->get('region'));


            // Initialize Language, Logs and Database
            static::initialiseLang();
            static::initialiseLog(INSTALL_LOGS . '/install');
            static::initialiseDatabase();

            // Initialize error handlers
            GenericExceptionHandler::initialise(Symphony::Log());
            GenericErrorHandler::initialise(Symphony::Log());
        }

        /**
         * This function returns an instance of the Installer
         * class. It is the only way to create a new Installer, as
         * it implements the Singleton interface
         *
         * @return Installer
         */
        public static function instance()
        {
            if (!(self::$_instance instanceof Installer)) {
                self::$_instance = new Installer;
            }

            return self::$_instance;
        }

        /**
         * Initialises the language by looking at the `lang` key,
         * passed via GET or POST
         */
        public static function initialiseLang()
        {
            $lang = !empty($_REQUEST['lang']) ? preg_replace('/[^a-zA-Z\-]/', null, $_REQUEST['lang']) : 'en';
            Lang::initialize();
            Lang::set($lang, false);
        }

        /**
         * Overrides the default `initialiseLog()` method and writes
         * logs to manifest/logs/install
         *
         * @param null $filename
         * @return boolean|void
         * @throws Exception
         */
        public static function initialiseLog($filename = null)
        {
            if (is_dir(INSTALL_LOGS) || General::realiseDirectory(INSTALL_LOGS, self::Configuration()->get('write_mode', 'directory'))) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                return parent::initialiseLog($filename);
            }

            return;
        }

        /**
         * Overrides the default `initialiseDatabase()` method
         * This allows us to still use the normal accessor
         */
        public static function initialiseDatabase()
        {
            self::setDatabase();
        }

        public function run()
        {
            // Make sure a log file is available
            if (is_null(Symphony::Log())) {
                self::__render(new InstallerPage('missing-log'));
            }

            // Check essential server requirements
            $errors = self::__checkRequirements();
            if (!empty($errors)) {
                Symphony::Log()->error('Installer - Missing requirements.');

                foreach ($errors as $err) {
                    Symphony::Log()->error(
                        sprintf('Requirement - %s', $err['msg'])
                    );
                }

                self::__render(new InstallerPage('requirements', array(
                    'errors'=> $errors
                )));
            }

            // If language is not set and there is language packs available, show language selection pages
            if (!isset($_POST['lang']) && count(Lang::getAvailableLanguages(false)) > 1) {
                self::__render(new InstallerPage('languages'));
            }

            // Check for configuration errors and, if there are no errors, install Symphony!
            if (isset($_POST['fields'])) {
                $errors = self::__checkConfiguration();
                if (!empty($errors)) {
                    Symphony::Log()->error('Installer - Wrong configuration.');

                    foreach ($errors as $err) {
                        Symphony::Log()->error(
                            sprintf('Configuration - %s', $err['msg'])
                        );
                    }
                } else {
                    $disabled_extensions = self::__install();

                    self::__render(new InstallerPage('success', array(
                        'disabled-extensions' => $disabled_extensions
                    )));
                }
            }

            // Display the Installation page
            self::__render(new InstallerPage('configuration', array(
                'errors' => $errors,
                'default-config' => Symphony::Configuration()->get()
            )));
        }

        /**
         * This function checks the server can support a Symphony installation.
         * It checks that PHP is 5.2+, MySQL, Zlib, LibXML, XSLT modules are enabled
         * and a `install.sql` file exists.
         * If any of these requirements fail the installation will not proceed.
         *
         * @return array
         *  An associative array of errors, with `msg` and `details` keys
         */
        private static function __checkRequirements()
        {
            $errors = array();

            // Check for PHP 5.2+
            if (version_compare(phpversion(), '5.3', '<=')) {
                $errors[] = array(
                    'msg' => __('PHP Version is not correct'),
                    'details' => __('Symphony requires %1$s or greater to work, however version %2$s was detected.', array('<code><abbr title="PHP: Hypertext Pre-processor">PHP</abbr> 5.3</code>', '<code>' . phpversion() . '</code>'))
                );
            }

            // Make sure the install.sql file exists
            if (!file_exists(INSTALL . '/includes/install.sql') || !is_readable(INSTALL . '/includes/install.sql')) {
                $errors[] = array(
                    'msg' => __('Missing install.sql file'),
                    'details'  => __('It appears that %s is either missing or not readable. This is required to populate the database and must be uploaded before installation can commence. Ensure that PHP has read permissions.', array('<code>install.sql</code>'))
                );
            }

            // Is MySQL available?
            if (!function_exists('mysqli_connect')) {
                $errors[] = array(
                    'msg' => __('MySQLi extension not present'),
                    'details'  => __('Symphony requires PHP to be configured with MySQLi to work.')
                );
            }

            // Is ZLib available?
            if (!extension_loaded('zlib')) {
                $errors[] = array(
                    'msg' => __('ZLib extension not present'),
                    'details' => __('Symphony uses the ZLib compression library for log rotation.')
                );
            }

            // Is libxml available?
            if (!extension_loaded('xml') && !extension_loaded('libxml')) {
                $errors[] = array(
                    'msg' => __('XML extension not present'),
                    'details'  => __('Symphony needs the XML extension to pass data to the site frontend.')
                );
            }

            // Is libxslt available?
            if (!extension_loaded('xsl') && !extension_loaded('xslt') && !function_exists('domxml_xslt_stylesheet')) {
                $errors[] = array(
                    'msg' => __('XSLT extension not present'),
                    'details'  => __('Symphony needs an XSLT processor such as %s or Sablotron to build pages.', array('Lib<abbr title="eXtensible Stylesheet Language Transformation">XSLT</abbr>'))
                );
            }

            // Is json_encode available?
            if (!function_exists('json_decode')) {
                $errors[] = array(
                    'msg' => __('JSON functionality is not present'),
                    'details'  => __('Symphony uses JSON functionality throughout the backend for translations and the interface.')
                );
            }

            // Cannot write to root folder.
            if (!is_writable(DOCROOT)) {
                $errors['no-write-permission-root'] = array(
                    'msg' => 'Root folder not writable: ' . DOCROOT,
                    'details' => __('Symphony does not have write permission to the root directory. Please modify permission settings on %s. This can be reverted once installation is complete.', array('<code>' . DOCROOT . '</code>'))
                );
            }

            // Cannot write to workspace
            if (is_dir(DOCROOT . '/workspace') && !is_writable(DOCROOT . '/workspace')) {
                $errors['no-write-permission-workspace'] = array(
                    'msg' => 'Workspace folder not writable: ' . DOCROOT . '/workspace',
                    'details' => __('Symphony does not have write permission to the existing %1$s directory. Please modify permission settings on this directory and its contents to allow this, such as with a recursive %2$s command.', array('<code>/workspace</code>', '<code>chmod -R</code>'))
                );
            }

            return $errors;
        }

        /**
         * This function checks the current Configuration (which is the values entered
         * by the user on the installation form) to ensure that `/symphony` and `/workspace`
         * folders exist and are writable and that the Database credentials are correct.
         * Once those initial checks pass, the rest of the form values are validated.
         *
         * @return array An associative array of errors if something went wrong, otherwise an empty array.
         */
        private static function __checkConfiguration()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
        {
            $errors = array();
            $fields = $_POST['fields'];

            // Testing the database connection
            try {
                Symphony::Database()->connect(
                    $fields['database']['host'],
                    $fields['database']['user'],
                    $fields['database']['password'],
                    $fields['database']['port'],
                    $fields['database']['db']
                );
            } catch (DatabaseException $e) {
                // Invalid credentials
                // @link http://dev.mysql.com/doc/refman/5.5/en/error-messages-server.html
                if ($e->getDatabaseErrorCode() === 1044 || $e->getDatabaseErrorCode() === 1045) {
                    $errors['database-invalid-credentials'] = array(
                        'msg' => 'Database credentials were denied',
                        'details' => __('Symphony was unable to access the database with these credentials.')
                    );
                }
                // Connection related
                else {
                    $errors['no-database-connection'] = array(
                        'msg' => 'Could not establish database connection.',
                        'details' => __('Symphony was unable to establish a valid database connection. You may need to modify host or port settings.')
                    );
                }
            }

            try {
                // Check the database table prefix is legal. #1815
                if (!preg_match('/^[0-9a-zA-Z\$_]*$/', $fields['database']['tbl_prefix'])) {
                    $errors['database-table-prefix']  = array(
                        'msg' => 'Invalid database table prefix: ‘' . $fields['database']['tbl_prefix'] . '’',
                        'details' =>  __('The table prefix %s is invalid. The table prefix must only contain numbers, letters or underscore characters.', array('<code>' . $fields['database']['tbl_prefix'] . '</code>'))
                    );
                }
                // Check the database credentials
                elseif (Symphony::Database()->isConnected()) {
                    // Incorrect MySQL version
                    $version = Symphony::Database()->fetchVar('version', 0, "SELECT VERSION() AS `version`;");
                    if (version_compare($version, '5.5', '<')) {
                        $errors['database-incorrect-version']  = array(
                            'msg' => 'MySQL Version is not correct. '. $version . ' detected.',
                            'details' => __('Symphony requires %1$s or greater to work, however version %2$s was detected. This requirement must be met before installation can proceed.', array('<code>MySQL 5.5</code>', '<code>' . $version . '</code>'))
                        );
                    }
                    else {
                        // Existing table prefix
                        if (Symphony::Database()->tableExists($fields['database']['tbl_prefix'] . '%')) {
                            $errors['database-table-prefix'] = array(
                                'msg'     => 'Database table prefix clash with ‘' . $fields['database']['db'] . '’',
                                'details' => __('The table prefix %s is already in use. Please choose a different prefix to use with Symphony.', array(

                                    '<code>' . $fields['database']['tbl_prefix'] . '</code>'
                                ))
                            );
                        }
                    }
                }
            } catch (DatabaseException $e) {
                $errors['unknown-database']  = array(
                        'msg' => 'Database ‘' . $fields['database']['db'] . '’ not found.',
                        'details' =>  __('Symphony was unable to connect to the specified database.')
                    );
            }

            // Website name not entered
            if (trim($fields['general']['sitename']) === '') {
                $errors['general-no-sitename']  = array(
                    'msg' => 'No sitename entered.',
                    'details' => __('You must enter a Site name. This will be shown at the top of your backend.')
                );
            }

            // Username Not Entered
            if (trim($fields['user']['username']) === '') {
                $errors['user-no-username']  = array(
                    'msg' => 'No username entered.',
                    'details' => __('You must enter a Username. This will be your Symphony login information.')
                );
            }

            // Password Not Entered
            if (trim($fields['user']['password']) === '') {
                $errors['user-no-password']  = array(
                    'msg' => 'No password entered.',
                    'details' => __('You must enter a Password. This will be your Symphony login information.')
                );
            }

            // Password mismatch
            elseif ($fields['user']['password'] !== $fields['user']['confirm-password']) {
                $errors['user-password-mismatch']  = array(
                    'msg' => 'Passwords did not match.',
                    'details' => __('The password and confirmation did not match. Please retype your password.')
                );
            }

            // No Name entered
            if (trim($fields['user']['firstname']) === '' || trim($fields['user']['lastname']) === '') {
                $errors['user-no-name']  = array(
                    'msg' => 'Did not enter First and Last names.',
                    'details' =>  __('You must enter your name.')
                );
            }

            // Invalid Email
            if (!preg_match('/^\w(?:\.?[\w%+-]+)*@\w(?:[\w-]*\.)+?[a-z]{2,}$/i', $fields['user']['email'])) {
                $errors['user-invalid-email']  = array(
                    'msg' => 'Invalid email address supplied.',
                    'details' =>  __('This is not a valid email address. You must provide an email address since you will need it if you forget your password.')
                );
            }

            // Admin path not entered
            if (trim($fields['symphony']['admin-path']) === '') {
                $errors['no-symphony-path']  = array(
                    'msg' => 'No Symphony path entered.',
                    'details' => __('You must enter a path for accessing Symphony, or leave the default. This will be used to access Symphony\'s backend.')
                );
            }

            return $errors;
        }

        /**
         * If something went wrong, the `__abort` function will write an entry to the Log
         * file and display the failure page to the user.
         *
         * @todo: Resume installation after an error has been fixed.
         * @param string $message
         * @param integer $start
         */
        protected static function __abort($message, $start)
        {
            Symphony::Log()->error($message);
            Symphony::Log()->error(sprintf('INSTALLATION ABORTED: Execution Time - %d sec (%s)',
                max(1, time() - $start),
                date('d.m.y H:i:s')
            ));

            self::__render(new InstallerPage('failure'));
        }

        private static function __install()
// Bad
class Router
{
    public function generate($path)
    {
        return $_SERVER['HOST'].$path;
    }
}

// Better
class Router
{
    private $host;

    public function __construct($host)
    {
        $this->host = $host;
    }

    public function generate($path)
    {
        return $this->host.$path;
    }
}

class Controller
{
    public function myAction(Request $request)
    {
        // Instead of
        $page = isset($_GET['page']) ? intval($_GET['page']) : 1;

        // Better (assuming you use the Symfony2 request)
        $page = $request->query->get('page', 1);
    }
}
        {
            $fields = $_POST['fields'];
            $start = time();

            Symphony::Log()->info('INSTALLATION PROCESS STARTED (' . DateTimeObj::get('c') . ')');

            // MySQL: Establishing connection
            Symphony::Log()->info('MYSQL: Establishing Connection');

            try {
                Symphony::Database()->connect(
                    $fields['database']['host'],
                    $fields['database']['user'],
                    $fields['database']['password'],
                    $fields['database']['port'],
                    $fields['database']['db']
                );
            } catch (DatabaseException $e) {
                self::__abort(
                    'There was a problem while trying to establish a connection to the MySQL server. Please check your settings.',
                $start);
            }

            // MySQL: Setting prefix & character encoding
            Symphony::Database()->setPrefix($fields['database']['tbl_prefix']);

            // MySQL: Importing schema
            Symphony::Log()->info('MYSQL: Importing Table Schema');

            try {
                Symphony::Database()->import(file_get_contents(INSTALL . '/includes/install.sql'));
            } catch (DatabaseException $e) {
                self::__abort(
                    'There was an error while trying to import data to the database. MySQL returned: ' . $e->getDatabaseErrorCode() . ': ' . $e->getDatabaseErrorMessage(),
                $start);
            }

            // MySQL: Creating default author
            Symphony::Log()->info('MYSQL: Creating Default Author');

            try {
                Symphony::Database()->insert(array(
                    'id'                    => 1,
                    'username'              => Symphony::Database()->cleanValue($fields['user']['username']),
                    'password'              => Cryptography::hash(Symphony::Database()->cleanValue($fields['user']['password'])),
                    'first_name'            => Symphony::Database()->cleanValue($fields['user']['firstname']),
                    'last_name'             => Symphony::Database()->cleanValue($fields['user']['lastname']),
                    'email'                 => Symphony::Database()->cleanValue($fields['user']['email']),
                    'last_seen'             => null,
                    'user_type'             => 'developer',
                    'primary'               => 'yes',
                    'default_area'          => '/blueprints/sections/',
                    'auth_token_active'     => 'no'
                ), 'tbl_authors');
            } catch (DatabaseException $e) {
                self::__abort(
                    'There was an error while trying create the default author. MySQL returned: ' . $e->getDatabaseErrorCode() . ': ' . $e->getDatabaseErrorMessage(),
                $start);
            }

            // Configuration: Populating array
            $conf = Symphony::Configuration()->get();

            foreach ($conf as $group => $settings) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                foreach ($settings as $key => $value) {
                    if (isset($fields[$group]) && isset($fields[$group][$key])) {
                        $conf[$group][$key] = $fields[$group][$key];
                    }
                }
            }

            // Create manifest folder structure
            Symphony::Log()->info('WRITING: Creating ‘manifest’ folder (/manifest)');
            if (!General::realiseDirectory(MANIFEST, $conf['directory']['write_mode'])) {
                self::__abort(
                    'Could not create ‘manifest’ directory. Check permission on the root folder.',
                $start);
            }

            Symphony::Log()->info('WRITING: Creating ‘logs’ folder (/manifest/logs)');
            if (!General::realiseDirectory(LOGS, $conf['directory']['write_mode'])) {
                self::__abort(
                    'Could not create ‘logs’ directory. Check permission on /manifest.',
                $start);
            }

            Symphony::Log()->info('WRITING: Creating ‘cache’ folder (/manifest/cache)');
            if (!General::realiseDirectory(CACHE, $conf['directory']['write_mode'])) {
                self::__abort(
                    'Could not create ‘cache’ directory. Check permission on /manifest.',
                $start);
            }

            Symphony::Log()->info('WRITING: Creating ‘tmp’ folder (/manifest/tmp)');
            if (!General::realiseDirectory(MANIFEST . '/tmp', $conf['directory']['write_mode'])) {
                self::__abort(
                    'Could not create ‘tmp’ directory. Check permission on /manifest.',
                $start);
            }

            // Writing configuration file
            Symphony::Log()->info('WRITING: Configuration File');

            Symphony::Configuration()->setArray($conf);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

            if (!Symphony::Configuration()->write(CONFIG, $conf['file']['write_mode'])) {
                self::__abort(
                    'Could not create config file ‘' . CONFIG . '’. Check permission on /manifest.',
                $start);
            }

            // Writing htaccess file
            Symphony::Log()->info('CONFIGURING: Frontend', E_NOTICE);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

            $rewrite_base = ltrim(preg_replace('/\/install$/i', null, dirname($_SERVER['PHP_SELF'])), '/');
            $htaccess = str_replace(
                '<!-- REWRITE_BASE -->', $rewrite_base,
                file_get_contents(INSTALL . '/includes/htaccess.txt')
            );

            if (!General::writeFile(DOCROOT . "/.htaccess", $htaccess, $conf['file']['write_mode'], 'a')) {
                self::__abort(
                    'Could not write ‘.htaccess’ file. Check permission on ' . DOCROOT,
                $start);
            }

            // Writing /workspace folder
            if (!is_dir(DOCROOT . '/workspace')) {
                // Create workspace folder structure
                Symphony::Log()->info('WRITING: Creating ‘workspace’ folder (/workspace)');
                if (!General::realiseDirectory(WORKSPACE, $conf['directory']['write_mode'])) {
                    self::__abort(
                        'Could not create ‘workspace’ directory. Check permission on the root folder.',
                    $start);
                }

                Symphony::Log()->info('WRITING: Creating ‘data-sources’ folder (/workspace/data-sources)');
                if (!General::realiseDirectory(DATASOURCES, $conf['directory']['write_mode'])) {
                    self::__abort(
                        'Could not create ‘workspace/data-sources’ directory. Check permission on the root folder.',
                    $start);
                }

                Symphony::Log()->info('WRITING: Creating ‘events’ folder (/workspace/events)');
                if (!General::realiseDirectory(EVENTS, $conf['directory']['write_mode'])) {
                    self::__abort(
                        'Could not create ‘workspace/events’ directory. Check permission on the root folder.',
                    $start);
                }

                Symphony::Log()->info('WRITING: Creating ‘pages’ folder (/workspace/pages)');
                if (!General::realiseDirectory(PAGES, $conf['directory']['write_mode'])) {
                    self::__abort(
                        'Could not create ‘workspace/pages’ directory. Check permission on the root folder.',
                    $start);
                }

                Symphony::Log()->info('WRITING: Creating ‘utilities’ folder (/workspace/utilities)');
                if (!General::realiseDirectory(UTILITIES, $conf['directory']['write_mode'])) {
                    self::__abort(
                        'Could not create ‘workspace/utilities’ directory. Check permission on the root folder.',
                    $start);
                }
            } else {
                Symphony::Log()->info('An existing ‘workspace’ directory was found at this location. Symphony will use this workspace.');

                // MySQL: Importing workspace data
                Symphony::Log()->info('MYSQL: Importing Workspace Data...');

                if (is_file(WORKSPACE . '/install.sql')) {
                    try {
                        Symphony::Database()->import(file_get_contents(WORKSPACE . '/install.sql'));
                    } catch (DatabaseException $e) {
                        self::__abort(
                            'There was an error while trying to import data to the database. MySQL returned: ' . $e->getDatabaseErrorCode() . ': ' . $e->getDatabaseErrorMessage(),
                        $start);
                    }
                }
            }

            // Write extensions folder
            if (!is_dir(EXTENSIONS)) {
                // Create extensions folder
                Symphony::Log()->info('WRITING: Creating ‘extensions’ folder (/extensions)');
                if (!General::realiseDirectory(EXTENSIONS, $conf['directory']['write_mode'])) {
                    self::__abort(
                        'Could not create ‘extension’ directory. Check permission on the root folder.',
                    $start);
                }
            }

            // Install existing extensions
            Symphony::Log()->info('CONFIGURING: Installing existing extensions');
            $disabled_extensions = array();
            foreach (new DirectoryIterator(EXTENSIONS) as $e) {
                if ($e->isDot() || $e->isFile() || !is_file($e->getRealPath() . '/extension.driver.php')) {
                    continue;
                }

                $handle = $e->getBasename();
                try {
                    if (!ExtensionManager::enable($handle)) {
                        $disabled_extensions[] = $handle;
                        Symphony::Log()->warning('Could not enable the extension ‘' . $handle . '’.');
                    }
                } catch (Exception $ex) {
                    $disabled_extensions[] = $handle;
                    Symphony::Log()->warning('Could not enable the extension ‘' . $handle . '’. '. $ex->getMessage());
                }
            }

            // Loading default language
            if (isset($_REQUEST['lang']) && $_REQUEST['lang'] !== 'en') {
                Symphony::Log()->info('CONFIGURING: Default language');

                $language = Lang::Languages();
                $language = $language[$_REQUEST['lang']];

                // Is the language extension enabled?
                if (in_array('lang_' . $language['handle'], ExtensionManager::listInstalledHandles())) {
                    Symphony::Configuration()->set('lang', $_REQUEST['lang'], 'symphony');
                    if (!Symphony::Configuration()->write(CONFIG, $conf['file']['write_mode'])) {
                        Symphony::Log()->warning('Could not write default language ‘' . $language['name'] . '’ to config file.');
                    }
                } else {
                    Symphony::Log()->warning('Could not enable the desired language ‘' . $language['name'] . '’.');
                }
            }

            // Installation completed. Woo-hoo!
            Symphony::Log()->info(sprintf('INSTALLATION COMPLETED: Execution Time - %d sec (%s)',
                max(1, time() - $start),
                date('d.m.y H:i:s')
            ));

            return $disabled_extensions;
        }

        protected static function __render(InstallerPage $page)
        {
            $output = $page->generate();

            header('Content-Type: text/html; charset=utf-8');
            echo $output;
            exit;

        }
    }

symphonycms / symphony-2

GitHub Access Token became invalid
