DatabaseInstaller::salt() - Code Metrics - quickapps/cms - Measure and Improve Code Quality continuously with Scrutinizer

DatabaseInstaller::salt() A
last analyzed 2018-05-15 17:59 UTC

↳ Parent: DatabaseInstaller

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

<?php
/**
 * Licensed under The GPL-3.0 License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @since    2.0.0
 * @author   Christopher Castro <[email protected]>
 * @link     http://www.quickappscms.org
 * @license  http://opensource.org/licenses/gpl-3.0.html GPL-3.0 License
 */
namespace Installer\Utility;

use Cake\Core\InstanceConfigTrait;
use Cake\Database\Connection;
use Cake\Database\Schema\Table as TableSchema;
use Cake\Datasource\ConnectionManager;
use Cake\Filesystem\File;
use Cake\Filesystem\Folder;
use Cake\Utility\Hash;
use Cake\Utility\Inflector;

/**
 * Handles database initialization for QuickAppsCMS's first installations.
 *
 */
class DatabaseInstaller
{

    use InstanceConfigTrait;

    /**
     * Error messages list.
     *
     * @var array
     */
    protected $_errors = [];

    /**
     * Whether the install() method was invoked or not.
     *
     * @var bool
     */
    protected $_installed = false;

    /**
     * Default configuration for this class.
     *
     * - settingsPath: Full path to the "settings.php" file where store connection
     *   information used by QuickAppsCMS. This should NEVER be changed, use with
     *   caution.
     *
     * - schemaPath: Path to directory containing all tables information to be
     *   imported (fixtures).
     *
     * - maxExecutionTime: Time in seconds for PHP's "max_execution_time" directive.
     *   Defaults to 480 (8 minutes).
     *
     * @var array
     */
    protected $_defaultConfig = [
        'settingsPath' => null,
        'schemaPath' => null,
        'maxExecutionTime' => 480,
    ];

    /**
     * Default database connection config.
     *
     * @var array
     */
    protected $_defaultConnection = [
        'className' => 'Cake\Database\Connection',
        'driver' => '',
        'database' => '',
        'username' => '',
        'password' => '',
        'host' => '',
        'prefix' => '',
        'encoding' => 'utf8',
        'timezone' => 'UTC',
        'log' => false,
        'cacheMetadata' => true,
    ];

    /**
     * Constructor.
     *
     * @param array $config Configuration options
     */
    public function __construct($config = [])
    {
        $this->_defaultConfig['settingsPath'] = ROOT . '/config/settings.php';
        $this->_defaultConfig['schemaPath'] = dirname(dirname(__DIR__)) . '/config/fixture/';
        $this->config($config);

        if (function_exists('ini_set')) {
            ini_set('max_execution_time', (int)$this->config('maxExecutionTime'));
        } elseif (function_exists('set_time_limit')) {
            set_time_limit((int)$this->config('maxExecutionTime'));
        }
    }

    /**
     * Starts the process.
     *
     * @param array $dbConfig Database connection information
     * @return bool True on success, false otherwise
     */
    public function install($dbConfig = [])
    {
        $this->_installed = true;

        if (!$this->prepareConfig($dbConfig)) {
            return false;
        }

        $conn = $this->getConn();
        if ($conn === false) {
            return false;
        }

        if (!$this->isDbEmpty($conn)) {
            return false;
        }

        if (!$this->importTables($conn)) {
            return false;
        }

        $this->writeSetting();

        return true;
    }

    /**
     * Registers an error message.
     *
     * @param string $message The error message
     * @return void
     */
    public function error($message)
    {
        $this->_errors[] = $message;
    }

    /**
     * Get all error messages.
     *
     * @return array
     */
    public function errors()
    {
        if (!$this->_installed) {
            $this->error(__d('installer', 'Nothing installed'));
        }

        return $this->_errors;
    }

    /**
     * Prepares database configuration attributes.
     *
     * If the file "ROOT/config/settings.php.tmp" exists, and has declared a
     * connection named "default" it will be used.
     *
     * @param array $dbConfig Database connection info coming from POST
     * @return bool True on success, false otherwise
     */
    public function prepareConfig($dbConfig = [])
    {
        if ($this->config('connection')) {
            return true;
        }

        if (is_readable(ROOT . '/config/settings.php.tmp')) {
            $dbConfig = include ROOT . '/config/settings.php.tmp';
            if (empty($dbConfig['Datasources']['default'])) {
                $this->error(__d('installer', 'Invalid database information in file "{0}"', ROOT . '/config/settings.php.tmp'));

                return false;
            }
            $dbConfig = $dbConfig['Datasources']['default'];
        } else {
            if (empty($dbConfig['driver'])) {
                $dbConfig['driver'] = '__INVALID__';
            }
            if (strpos($dbConfig['driver'], "\\") === false) {
                $dbConfig['driver'] = "Cake\\Database\\Driver\\{$dbConfig['driver']}";
            }
        }

        list(, $driverClass) = namespaceSplit($dbConfig['driver']);
        if (!in_array($driverClass, ['Mysql', 'Postgres', 'Sqlite', 'Sqlserver'])) {
            $this->error(__d('installer', 'Invalid database type ({0}).', $driverClass));

            return false;
        }

        $this->config('connection', Hash::merge($this->_defaultConnection, $dbConfig));

        return true;
    }

    /**
     * Generates a new connection to DB.
     *
     * @return \Cake\Database\Connection|bool A connection object, or false on
     *  failure. On failure error messages are automatically set
     */
    public function getConn()
    {
        if (!$this->config('connection.className')) {
            $this->error(__d('installer', 'Database engine cannot be empty.'));

            return false;
        }

        try {
            ConnectionManager::drop('installation');
            ConnectionManager::config('installation', $this->config('connection'));
            $conn = ConnectionManager::get('installation');
            $conn->connect();

            return $conn;
        } catch (\Exception $ex) {
            $this->error(__d('installer', 'Unable to connect to database, please check your information. Details: {0}', '<p>' . $ex->getMessage() . '</p>'));

            return false;
        }
    }

    /**
     * Imports tables schema and populates them.
     *
     * @param \Cake\Database\Connection $conn Database connection to use
     * @return bool True on success, false otherwise. On failure error messages
     *  are automatically set
     */
    public function importTables($conn)
    {
        $Folder = new Folder($this->config('schemaPath'));
        $fixtures = $Folder->read(false, false, true)[1];
        try {
            return (bool)$conn->transactional(function ($connection) use ($fixtures) {
                foreach ($fixtures as $fixture) {
                    $result = $this->_processFixture($fixture, $connection);
                    if (!$result) {
                        $this->error(__d('installer', 'Error importing "{0}".', $fixture));

                        return false;
                    }
                }

                return true;
            });
        } catch (\Exception $ex) {
            $this->error(__d('installer', 'Unable to import database information. Details: {0}', '<p>' . $ex->getMessage() . '</p>'));

            return false;
        }
    }

    /**
     * Checks whether connected database is empty or not.
     *
     * @param \Cake\Database\Connection $conn Database connection to use
     * @return bool True if database if empty and tables can be imported, false if
     *  there are some existing tables
     */
    public function isDbEmpty($conn)
    {
        $Folder = new Folder($this->config('schemaPath'));
        $existingSchemas = $conn->schemaCollection()->listTables();
        $newSchemas = array_map(function ($item) {
            return Inflector::underscore(str_replace('Schema.php', '', $item));
        }, $Folder->read()[1]);
        $result = !array_intersect($existingSchemas, $newSchemas);
        if (!$result) {
            $this->error(__d('installer', 'A previous installation of QuickAppsCMS already exists, please drop your database tables before continue.'));
        }

        return $result;
    }

    /**
     * Creates site's "settings.php" file.
     *
     * @return bool True on success
     */
    public function writeSetting()
    {
        $config = [
            'Datasources' => [
                'default' => $this->config('connection'),
            ],
            'Security' => [
                'salt' => $this->salt()
            ],
            'debug' => false,
        ];

        $filePath = $this->config('settingsPath');
        if (!str_ends_with(strtolower($filePath), '.tmp')) {
            $filePath .= '.tmp';
        }

        $settingsFile = new File($filePath, true);

        return $settingsFile->write("<?php\n return " . var_export($config, true) . ";\n");
    }

    /**
     * Generates a random string suitable for security's salt.
     *
     * @return string
     */
    public function salt()
    {
        $space = '$%&()=!#@~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';

        return substr(str_shuffle($space), 0, rand(40, 60));
    }

    /**
     * Process the given fixture class, creates its schema and imports its records.
     *
     * @param string $path Full path to schema class file
     * @param \Cake\Database\Connection $connection Database connection to use
     * @return bool True on success
     */
    protected function _processFixture($path, Connection $connection)
    {
        if (!is_readable($path)) {
            return false;
        }

        require $path;
        $fixtureClass = str_replace('.php', '', basename($path));
        $schema = $this->_prepareSchema($fixtureClass);
        $sql = $schema->createSql($connection);
        $tableCreated = true;

        foreach ($sql as $stmt) {
            try {
                if (!$connection->execute($stmt)) {
                    $tableCreated = false;
                }
            } catch (\Exception $ex) {
                $this->error(__d('installer', 'Unable to create table "{0}". Details: {1}', $schema->name(), $ex->getMessage()));
                $tableCreated = false;
            }
        }

        if (!$tableCreated) {
            return false;
        }

        if (!$this->_importRecords($fixtureClass, $schema, $connection)) {
            return false;
        }

        return true;
    }

    /**
     * Gets an schema instance for the given fixture class.
     *
     * @param string $fixtureClassName The fixture to be "converted"
     * @return \Cake\Database\Schema\Table Schema instance
     */
    protected function _prepareSchema($fixtureClassName)
    {
        $fixture = new $fixtureClassName;
        if (!empty($fixture->table)) {
            $tableName = $fixture->table;
        } else {
            $tableName = (string)Inflector::underscore(str_replace_last('Fixture', '', $fixtureClassName));
        }

        list($fields, $constraints, $indexes, $options) = $this->_prepareSchemaProperties($fixture);
        $schema = new TableSchema($tableName, $fields);

        foreach ($constraints as $name => $attrs) {
            $schema->addConstraint($name, $attrs);
        }

        foreach ($indexes as $name => $attrs) {
            $schema->addIndex($name, $attrs);
        }

        if (!empty($options)) {
            $schema->options($options);
        }

        return $schema;
    }

    /**
     * Extracts some properties from the given fixture instance to properly
     * build a new table schema instance (constrains, indexes, etc).
     *
     * @param object $fixture Fixture instance from which extract schema
     *  properties
     * @return array Where with keys 0 => $fields, 1 => $constraints, 2 =>
     *  $indexes and 3 => $options
     */
    protected function _prepareSchemaProperties($fixture)
    {
        $fields = (array)$fixture->fields;
        $constraints = [];
        $indexes = [];
        $options = [];

        if (isset($fields['_constraints'])) {
            $constraints = $fields['_constraints'];
            unset($fields['_constraints']);
        }

        if (isset($fields['_indexes'])) {
            $indexes = $fields['_indexes'];
            unset($fields['_indexes']);
        }

        if (isset($fields['_options'])) {
            $options = $fields['_options'];
            unset($fields['_options']);
        }

        return [
            $fields,
            $constraints,
            $indexes,
            $options,
        ];
    }

    /**
     * Imports all records of the given fixture.
     *
     * @param string $fixtureClassName Fixture class name
     * @param \Cake\Database\Schema\Table $schema Table schema for which records
     *  will be imported
     * @param \Cake\Database\Connection $connection Database connection to use
     * @return bool True on success
     */
    protected function _importRecords($fixtureClassName, TableSchema $schema, Connection $connection)
    {
        $fixture = new $fixtureClassName;
        if (!isset($fixture->records) || empty($fixture->records)) {
            return true;
        }

        $fixture->records = (array)$fixture->records;
        if (count($fixture->records) > 100) {
            $chunk = array_chunk($fixture->records, 100);
        } else {
            $chunk = [0 => $fixture->records];
        }

        foreach ($chunk as $records) {
            list($fields, $values, $types) = $this->_getRecords($records, $schema);
            $query = $connection->newQuery()
                ->insert($fields, $types)
                ->into($schema->name());

            foreach ($values as $row) {
                $query->values($row);
            }

            try {
                $statement = $query->execute();
                $statement->closeCursor();
            } catch (\Exception $ex) {
                $this->error(__d('installer', 'Error while importing data for table "{0}". Details: {1}', $schema->name(), $ex->getMessage()));

                return false;
            }
        }

        return true;
    }

    /**
     * Converts the given array of records into data used to generate a query.
     *
     * @param array $records Records to be imported
     * @param \Cake\Database\Schema\Table $schema Table schema for which records will
     *  be imported
     * @return array
     */
    protected function _getRecords(array $records, TableSchema $schema)
    {
        $fields = $values = $types = [];
        $columns = $schema->columns();
        foreach ($records as $record) {
            $fields = array_merge($fields, array_intersect(array_keys($record), $columns));
        }
        $fields = array_values(array_unique($fields));
        foreach ($fields as $field) {
            $types[$field] = $schema->column($field)['type'];
        }
        $default = array_fill_keys($fields, null);
        foreach ($records as $record) {
            $values[] = array_merge($default, $record);
        }

        return [$fields, $values, $types];
    }
}


1			<?php
2			/**
3			* Licensed under The GPL-3.0 License
4			* For full copyright and license information, please see the LICENSE.txt
5			* Redistributions of files must retain the above copyright notice.
6			*
7			* @since 2.0.0
8			* @author Christopher Castro <[email protected]>
9			* @link http://www.quickappscms.org
10			* @license http://opensource.org/licenses/gpl-3.0.html GPL-3.0 License
11			*/
12			namespace Installer\Utility;
13
14			use Cake\Core\InstanceConfigTrait;
15			use Cake\Database\Connection;
16			use Cake\Database\Schema\Table as TableSchema;
17			use Cake\Datasource\ConnectionManager;
18			use Cake\Filesystem\File;
19			use Cake\Filesystem\Folder;
20			use Cake\Utility\Hash;
21			use Cake\Utility\Inflector;
22
23			/**
24			* Handles database initialization for QuickAppsCMS's first installations.
25			*
26			*/
27			class DatabaseInstaller
28			{
29
30			use InstanceConfigTrait;
31
32			/**
33			* Error messages list.
34			*
35			* @var array
36			*/
37			protected $_errors = [];
38
39			/**
40			* Whether the install() method was invoked or not.
41			*
42			* @var bool
43			*/
44			protected $_installed = false;
45
46			/**
47			* Default configuration for this class.
48			*
49			* - settingsPath: Full path to the "settings.php" file where store connection
50			* information used by QuickAppsCMS. This should NEVER be changed, use with
51			* caution.
52			*
53			* - schemaPath: Path to directory containing all tables information to be
54			* imported (fixtures).
55			*
56			* - maxExecutionTime: Time in seconds for PHP's "max_execution_time" directive.
57			* Defaults to 480 (8 minutes).
58			*
59			* @var array
60			*/
61			protected $_defaultConfig = [
62			'settingsPath' => null,
63			'schemaPath' => null,
64			'maxExecutionTime' => 480,
65			];
66
67			/**
68			* Default database connection config.
69			*
70			* @var array
71			*/
72			protected $_defaultConnection = [
73			'className' => 'Cake\Database\Connection',
74			'driver' => '',
75			'database' => '',
76			'username' => '',
77			'password' => '',
78			'host' => '',
79			'prefix' => '',
80			'encoding' => 'utf8',
81			'timezone' => 'UTC',
82			'log' => false,
83			'cacheMetadata' => true,
84			];
85
86			/**
87			* Constructor.
88			*
89			* @param array $config Configuration options
90			*/
91			public function __construct($config = [])
92			{
93			$this->_defaultConfig['settingsPath'] = ROOT . '/config/settings.php';
94			$this->_defaultConfig['schemaPath'] = dirname(dirname(__DIR__)) . '/config/fixture/';
95			$this->config($config);
96
97			if (function_exists('ini_set')) {
98			ini_set('max_execution_time', (int)$this->config('maxExecutionTime'));
99			} elseif (function_exists('set_time_limit')) {
100			set_time_limit((int)$this->config('maxExecutionTime'));
101			}
102			}
103
104			/**
105			* Starts the process.
106			*
107			* @param array $dbConfig Database connection information
108			* @return bool True on success, false otherwise
109			*/
110			public function install($dbConfig = [])
111			{
112			$this->_installed = true;
113
114			if (!$this->prepareConfig($dbConfig)) {
115			return false;
116			}
117
118			$conn = $this->getConn();
119			if ($conn === false) {
120			return false;
121			}
122
123			if (!$this->isDbEmpty($conn)) {
124			return false;
125			}
126
127			if (!$this->importTables($conn)) {
128			return false;
129			}
130
131			$this->writeSetting();
132
133			return true;
134			}
135
136			/**
137			* Registers an error message.
138			*
139			* @param string $message The error message
140			* @return void
141			*/
142			public function error($message)
143			{
144			$this->_errors[] = $message;
145			}
146
147			/**
148			* Get all error messages.
149			*
150			* @return array
151			*/
152			public function errors()
153			{
154			if (!$this->_installed) {
155			$this->error(__d('installer', 'Nothing installed'));
156			}
157
158			return $this->_errors;
159			}
160
161			/**
162			* Prepares database configuration attributes.
163			*
164			* If the file "ROOT/config/settings.php.tmp" exists, and has declared a
165			* connection named "default" it will be used.
166			*
167			* @param array $dbConfig Database connection info coming from POST
168			* @return bool True on success, false otherwise
169			*/
170			public function prepareConfig($dbConfig = [])
171			{
172			if ($this->config('connection')) {
173			return true;
174			}
175
176			if (is_readable(ROOT . '/config/settings.php.tmp')) {
177			$dbConfig = include ROOT . '/config/settings.php.tmp';
178			if (empty($dbConfig['Datasources']['default'])) {
179			$this->error(__d('installer', 'Invalid database information in file "{0}"', ROOT . '/config/settings.php.tmp'));
180
181			return false;
182			}
183			$dbConfig = $dbConfig['Datasources']['default'];
184			} else {
185			if (empty($dbConfig['driver'])) {
186			$dbConfig['driver'] = '__INVALID__';
187			}
188			if (strpos($dbConfig['driver'], "\\") === false) {
189			$dbConfig['driver'] = "Cake\\Database\\Driver\\{$dbConfig['driver']}";
190			}
191			}
192
193			list(, $driverClass) = namespaceSplit($dbConfig['driver']);
194			if (!in_array($driverClass, ['Mysql', 'Postgres', 'Sqlite', 'Sqlserver'])) {
195			$this->error(__d('installer', 'Invalid database type ({0}).', $driverClass));
196
197			return false;
198			}
199
200			$this->config('connection', Hash::merge($this->_defaultConnection, $dbConfig));
201
202			return true;
203			}
204
205			/**
206			* Generates a new connection to DB.
207			*
208			* @return \Cake\Database\Connection\|bool A connection object, or false on
209			* failure. On failure error messages are automatically set
210			*/
211			public function getConn()
212			{
213			if (!$this->config('connection.className')) {
214			$this->error(__d('installer', 'Database engine cannot be empty.'));
215
216			return false;
217			}
218
219			try {
220			ConnectionManager::drop('installation');
221			ConnectionManager::config('installation', $this->config('connection'));
222			$conn = ConnectionManager::get('installation');
223			$conn->connect();
224
225			return $conn;
226			} catch (\Exception $ex) {
227			$this->error(__d('installer', 'Unable to connect to database, please check your information. Details: {0}', '<p>' . $ex->getMessage() . '</p>'));
228
229			return false;
230			}
231			}
232
233			/**
234			* Imports tables schema and populates them.
235			*
236			* @param \Cake\Database\Connection $conn Database connection to use
237			* @return bool True on success, false otherwise. On failure error messages
238			* are automatically set
239			*/
240			public function importTables($conn)
241			{
242			$Folder = new Folder($this->config('schemaPath'));
243			$fixtures = $Folder->read(false, false, true)[1];
244			try {
245			return (bool)$conn->transactional(function ($connection) use ($fixtures) {
246			foreach ($fixtures as $fixture) {
247			$result = $this->_processFixture($fixture, $connection);
248			if (!$result) {
249			$this->error(__d('installer', 'Error importing "{0}".', $fixture));
250
251			return false;
252			}
253			}
254
255			return true;
256			});
257			} catch (\Exception $ex) {
258			$this->error(__d('installer', 'Unable to import database information. Details: {0}', '<p>' . $ex->getMessage() . '</p>'));
259
260			return false;
261			}
262			}
263
264			/**
265			* Checks whether connected database is empty or not.
266			*
267			* @param \Cake\Database\Connection $conn Database connection to use
268			* @return bool True if database if empty and tables can be imported, false if
269			* there are some existing tables
270			*/
271			public function isDbEmpty($conn)
272			{
273			$Folder = new Folder($this->config('schemaPath'));
274			$existingSchemas = $conn->schemaCollection()->listTables();
275			$newSchemas = array_map(function ($item) {
276			return Inflector::underscore(str_replace('Schema.php', '', $item));
277			}, $Folder->read()[1]);
278			$result = !array_intersect($existingSchemas, $newSchemas);
279			if (!$result) {
280			$this->error(__d('installer', 'A previous installation of QuickAppsCMS already exists, please drop your database tables before continue.'));
281			}
282
283			return $result;
284			}
285
286			/**
287			* Creates site's "settings.php" file.
288			*
289			* @return bool True on success
290			*/
291			public function writeSetting()
292			{
293			$config = [
294			'Datasources' => [
295			'default' => $this->config('connection'),
296			],
297			'Security' => [
298			'salt' => $this->salt()
299			],
300			'debug' => false,
301			];
302
303			$filePath = $this->config('settingsPath');
304			if (!str_ends_with(strtolower($filePath), '.tmp')) {
305			$filePath .= '.tmp';
306			}
307
308			$settingsFile = new File($filePath, true);
309
310			return $settingsFile->write("<?php\n return " . var_export($config, true) . ";\n");
311			}
312
313			/**
314			* Generates a random string suitable for security's salt.
315			*
316			* @return string
317			*/
318			public function salt()
319			{
320			$space = '$%&()=!#@~0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
321
322			return substr(str_shuffle($space), 0, rand(40, 60));
323			}
324
325			/**
326			* Process the given fixture class, creates its schema and imports its records.
327			*
328			* @param string $path Full path to schema class file
329			* @param \Cake\Database\Connection $connection Database connection to use
330			* @return bool True on success
331			*/
332			protected function _processFixture($path, Connection $connection)
333			{
334			if (!is_readable($path)) {
335			return false;
336			}
337
338			require $path;
339			$fixtureClass = str_replace('.php', '', basename($path));
340			$schema = $this->_prepareSchema($fixtureClass);
341			$sql = $schema->createSql($connection);
342			$tableCreated = true;
343
344			foreach ($sql as $stmt) {
345			try {
346			if (!$connection->execute($stmt)) {
347			$tableCreated = false;
348			}
349			} catch (\Exception $ex) {
350			$this->error(__d('installer', 'Unable to create table "{0}". Details: {1}', $schema->name(), $ex->getMessage()));
351			$tableCreated = false;
352			}
353			}
354
355			if (!$tableCreated) {
356			return false;
357			}
358
359			if (!$this->_importRecords($fixtureClass, $schema, $connection)) {
360			return false;
361			}
362
363			return true;
364			}
365
366			/**
367			* Gets an schema instance for the given fixture class.
368			*
369			* @param string $fixtureClassName The fixture to be "converted"
370			* @return \Cake\Database\Schema\Table Schema instance
371			*/
372			protected function _prepareSchema($fixtureClassName)
373			{
374			$fixture = new $fixtureClassName;
375			if (!empty($fixture->table)) {
376			$tableName = $fixture->table;
377			} else {
378			$tableName = (string)Inflector::underscore(str_replace_last('Fixture', '', $fixtureClassName));
379			}
380
381			list($fields, $constraints, $indexes, $options) = $this->_prepareSchemaProperties($fixture);
382			$schema = new TableSchema($tableName, $fields);
383
384			foreach ($constraints as $name => $attrs) {
385			$schema->addConstraint($name, $attrs);
386			}
387
388			foreach ($indexes as $name => $attrs) {
389			$schema->addIndex($name, $attrs);
390			}
391
392			if (!empty($options)) {
393			$schema->options($options);
394			}
395
396			return $schema;
397			}
398
399			/**
400			* Extracts some properties from the given fixture instance to properly
401			* build a new table schema instance (constrains, indexes, etc).
402			*
403			* @param object $fixture Fixture instance from which extract schema
404			* properties
405			* @return array Where with keys 0 => $fields, 1 => $constraints, 2 =>
406			* $indexes and 3 => $options
407			*/
408			protected function _prepareSchemaProperties($fixture)
409			{
410			$fields = (array)$fixture->fields;
411			$constraints = [];
412			$indexes = [];
413			$options = [];
414
415			if (isset($fields['_constraints'])) {
416			$constraints = $fields['_constraints'];
417			unset($fields['_constraints']);
418			}
419
420			if (isset($fields['_indexes'])) {
421			$indexes = $fields['_indexes'];
422			unset($fields['_indexes']);
423			}
424
425			if (isset($fields['_options'])) {
426			$options = $fields['_options'];
427			unset($fields['_options']);
428			}
429
430			return [
431			$fields,
432			$constraints,
433			$indexes,
434			$options,
435			];
436			}
437
438			/**
439			* Imports all records of the given fixture.
440			*
441			* @param string $fixtureClassName Fixture class name
442			* @param \Cake\Database\Schema\Table $schema Table schema for which records
443			* will be imported
444			* @param \Cake\Database\Connection $connection Database connection to use
445			* @return bool True on success
446			*/
447			protected function _importRecords($fixtureClassName, TableSchema $schema, Connection $connection)
448			{
449			$fixture = new $fixtureClassName;
450			if (!isset($fixture->records) \|\| empty($fixture->records)) {
451			return true;
452			}
453
454			$fixture->records = (array)$fixture->records;
455			if (count($fixture->records) > 100) {
456			$chunk = array_chunk($fixture->records, 100);
457			} else {
458			$chunk = [0 => $fixture->records];
459			}
460
461			foreach ($chunk as $records) {
462			list($fields, $values, $types) = $this->_getRecords($records, $schema);
463			$query = $connection->newQuery()
464			->insert($fields, $types)
465			->into($schema->name());
466
467			foreach ($values as $row) {
468			$query->values($row);
469			}
470
471			try {
472			$statement = $query->execute();
473			$statement->closeCursor();
474			} catch (\Exception $ex) {
475			$this->error(__d('installer', 'Error while importing data for table "{0}". Details: {1}', $schema->name(), $ex->getMessage()));
476
477			return false;
478			}
479			}
480
481			return true;
482			}
483
484			/**
485			* Converts the given array of records into data used to generate a query.
486			*
487			* @param array $records Records to be imported
488			* @param \Cake\Database\Schema\Table $schema Table schema for which records will
489			* be imported
490			* @return array
491			*/
492			protected function _getRecords(array $records, TableSchema $schema)
493			{
494			$fields = $values = $types = [];
495			$columns = $schema->columns();
496			foreach ($records as $record) {
497			$fields = array_merge($fields, array_intersect(array_keys($record), $columns));
498			}
499			$fields = array_values(array_unique($fields));
500			foreach ($fields as $field) {
501			$types[$field] = $schema->column($field)['type'];
502			}
503			$default = array_fill_keys($fields, null);
504			foreach ($records as $record) {
505			$values[] = array_merge($default, $record);
506			}
507
508			return [$fields, $values, $types];
509			}
510			}
511

quickapps / cms

DatabaseInstaller::salt() A last analyzed 2018-05-15 17:59 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DatabaseInstaller::salt() A
last analyzed 2018-05-15 17:59 UTC