SetupWizard::createConfigFile() - Code Metrics - Inspection of "Fix: #3331 - Do not allow legacy placelist.php han..." - fisharebest/webtrees - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 573931...5c073d )

by Greg

created 2020-06-16 08:26 UTC

SetupWizard::createConfigFile() A

↳ Parent: SetupWizard

Complexity

Conditions	3
Paths	4

Size

Total Lines	39
Code Lines	22

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	22
nc	4
nop	1
dl	0
loc	39
rs	9.568
c	0
b	0
f	0

<?php

/**
 * webtrees: online genealogy
 * Copyright (C) 2019 webtrees development team
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

declare(strict_types=1);

namespace Fisharebest\Webtrees\Http\RequestHandlers;

use Exception;
use Fisharebest\Localization\Locale;
use Fisharebest\Localization\Locale\LocaleEnUs;
use Fisharebest\Localization\Locale\LocaleInterface;
use Fisharebest\Webtrees\Auth;
use Fisharebest\Webtrees\Cache;
use Fisharebest\Webtrees\Http\ViewResponseTrait;
use Fisharebest\Webtrees\I18N;
use Fisharebest\Webtrees\Module\ModuleLanguageInterface;
use Fisharebest\Webtrees\Services\MigrationService;
use Fisharebest\Webtrees\Services\ModuleService;
use Fisharebest\Webtrees\Services\ServerCheckService;
use Fisharebest\Webtrees\Services\UserService;
use Fisharebest\Webtrees\Session;
use Fisharebest\Webtrees\User;
use Fisharebest\Webtrees\Webtrees;
use Illuminate\Database\Capsule\Manager as DB;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\RequestHandlerInterface;
use Symfony\Component\Cache\Adapter\NullAdapter;
use Throwable;

use function app;
use function e;
use function file_get_contents;
use function file_put_contents;
use function ini_get;
use function random_bytes;
use function realpath;
use function redirect;
use function substr;
use function touch;
use function unlink;
use function view;

/**
 * Controller for the installation wizard
 */
class SetupWizard implements RequestHandlerInterface
{
    use ViewResponseTrait;

    private const DEFAULT_DBTYPE = 'mysql';
    private const DEFAULT_PREFIX = 'wt_';
    private const DEFAULT_DATA   = [
        'baseurl' => '',
        'lang'    => '',
        'dbtype'  => self::DEFAULT_DBTYPE,
        'dbhost'  => '',
        'dbport'  => '',
        'dbuser'  => '',
        'dbpass'  => '',
        'dbname'  => '',
        'tblpfx'  => self::DEFAULT_PREFIX,
        'wtname'  => '',
        'wtuser'  => '',
        'wtpass'  => '',
        'wtemail' => '',
    ];

    /** @var MigrationService */
    private $migration_service;

    /** @var ModuleService */
    private $module_service;

    /** @var ServerCheckService */
    private $server_check_service;

    /** @var UserService */
    private $user_service;

    /**
     * SetupWizard constructor.
     *
     * @param MigrationService   $migration_service
     * @param ModuleService      $module_service
     * @param ServerCheckService $server_check_service
     * @param UserService        $user_service
     */
    public function __construct(
        MigrationService $migration_service,
        ModuleService $module_service,
        ServerCheckService $server_check_service,
        UserService $user_service
    ) {
        $this->user_service         = $user_service;
        $this->migration_service    = $migration_service;
        $this->module_service       = $module_service;
        $this->server_check_service = $server_check_service;
    }

    /**
     * Installation wizard - check user input and proceed to the next step.
     *
     * @param ServerRequestInterface $request
     *
     * @return ResponseInterface
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        $this->layout = 'layouts/setup';

        // We will need an IP address for the logs.
        $ip_address  = $request->getServerParams()['REMOTE_ADDR'] ?? '127.0.0.1';
        $request     = $request->withAttribute('client-ip', $ip_address);

        app()->instance(ServerRequestInterface::class, $request);
        app()->instance('cache.array', new Cache(new NullAdapter()));

        $data = $this->userData($request);

        $params = (array) $request->getParsedBody();
        $step   = (int) ($params['step'] ?? '1');

        $locales = $this->module_service
            ->setupLanguages()
            ->map(static function (ModuleLanguageInterface $module): LocaleInterface {
                return $module->locale();
            });

        if ($data['lang'] === '') {
            $default = new LocaleEnUs();

            $locale  = Locale::httpAcceptLanguage($request->getServerParams(), $locales->all(), $default);

            $data['lang'] = $locale->languageTag();
        }

        I18N::init($data['lang'], true);

        $data['cpu_limit']    = $this->maxExecutionTime();
        $data['locales']      = $locales->all();
        $data['memory_limit'] = $this->memoryLimit();

        // Only show database errors after the user has chosen a driver.
        if ($step >= 4) {
            $data['errors']   = $this->server_check_service->serverErrors($data['dbtype']);
            $data['warnings'] = $this->server_check_service->serverWarnings($data['dbtype']);
        } else {
            $data['errors']   = $this->server_check_service->serverErrors();
            $data['warnings'] = $this->server_check_service->serverWarnings();
        }

        if (!$this->checkFolderIsWritable(Webtrees::DATA_DIR)) {
            $data['errors']->push(
                '<code>' . e(realpath(Webtrees::DATA_DIR)) . '</code><br>' .
                I18N::translate('Oops! webtrees was unable to create files in this folder.') . ' ' .
                I18N::translate('This usually means that you need to change the folder permissions to 777.')
            );
        }

        switch ($step) {
            default:
            case 1:
                return $this->step1Language($data);
            case 2:
                return $this->step2CheckServer($data);
            case 3:
                return $this->step3DatabaseType($data);
            case 4:
                return $this->step4DatabaseConnection($data);
            case 5:
                return $this->step5Administrator($data);
            case 6:
                return $this->step6Install($data);
        }
    }

    /**
     * @param ServerRequestInterface $request
     *
     * @return array<string,mixed>
     */
    private function userData(ServerRequestInterface $request): array
    {
        $params = (array) $request->getParsedBody();

        $data = [];

        foreach (self::DEFAULT_DATA as $key => $default) {
            $data[$key] = $params[$key] ?? $default;
        }

        return $data;
    }

    /**
     * The server's memory limit
     *
     * @return int
     */
    private function maxExecutionTime(): int
    {
        return (int) ini_get('max_execution_time');
    }

    /**
     * The server's memory limit (in MB).
     *
     * @return int
     */
    private function memoryLimit(): int
    {
        $memory_limit = ini_get('memory_limit');

        $number = (int) $memory_limit;

        switch (substr($memory_limit, -1)) {
            case 'g':
            case 'G':
                return $number * 1024;
            case 'm':
            case 'M':
                return $number;
            case 'k':
            case 'K':
                return (int) ($number / 1024);
            default:
                return (int) ($number / 1048576);
        }
    }

    /**
     * Check we can write to the data folder.
     *
     * @param string $data_dir
     *
     * @return bool
     */
    private function checkFolderIsWritable(string $data_dir): bool
    {
        $text1 = random_bytes(32);

        try {
            file_put_contents($data_dir . 'test.txt', $text1);
            $text2 = file_get_contents(Webtrees::DATA_DIR . 'test.txt');
            unlink(Webtrees::DATA_DIR . 'test.txt');
        } catch (Exception $ex) {
            return false;
        }

        return $text1 === $text2;
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return ResponseInterface
     */
    private function step1Language(array $data): ResponseInterface
    {
        return $this->viewResponse('setup/step-1-language', $data);
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return ResponseInterface
     */
    private function step2CheckServer(array $data): ResponseInterface
    {
        return $this->viewResponse('setup/step-2-server-checks', $data);
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return ResponseInterface
     */
    private function step3DatabaseType(array $data): ResponseInterface
    {
        if ($data['errors']->isNotEmpty()) {
            return $this->viewResponse('setup/step-2-server-checks', $data);
        }

        return $this->viewResponse('setup/step-3-database-type', $data);
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return ResponseInterface
     */
    private function step4DatabaseConnection(array $data): ResponseInterface
    {
        if ($data['errors']->isNotEmpty()) {
            return $this->step3DatabaseType($data);
        }

        return $this->viewResponse('setup/step-4-database-' . $data['dbtype'], $data);
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return ResponseInterface
     */
    private function step5Administrator(array $data): ResponseInterface
    {
        try {
            $this->connectToDatabase($data);
        } catch (Throwable $ex) {
            $data['errors']->push($ex->getMessage());

            // Don't jump to step 4, as the error will make it jump to step 3.
            return $this->viewResponse('setup/step-4-database-' . $data['dbtype'], $data);
        }

        return $this->viewResponse('setup/step-5-administrator', $data);
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return ResponseInterface
     */
    private function step6Install(array $data): ResponseInterface
    {
        $error = $this->checkAdminUser($data['wtname'], $data['wtuser'], $data['wtpass'], $data['wtemail']);

        if ($error !== '') {
            $data['errors']->push($error);

            return $this->step5Administrator($data);
        }

        try {
            $this->createConfigFile($data);
        } catch (Throwable $exception) {
            return $this->viewResponse('setup/step-6-failed', ['exception' => $exception]);
        }

        // Done - start using webtrees!
        return redirect($data['baseurl']);
    }

    /**
     * @param string $wtname
     * @param string $wtuser
     * @param string $wtpass
     * @param string $wtemail
     *
     * @return string
     */
    private function checkAdminUser($wtname, $wtuser, $wtpass, $wtemail): string
    {
        if ($wtname === '' || $wtuser === '' || $wtpass === '' || $wtemail === '') {
            return I18N::translate('You must enter all the administrator account fields.');
        }

        if (mb_strlen($wtpass) < 6) {
            return I18N::translate('The password needs to be at least six characters long.');
        }

        return '';
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return void
     */
    private function createConfigFile(array $data): void
    {
        // Create/update the database tables.
        $this->connectToDatabase($data);
        $this->migration_service->updateSchema('\Fisharebest\Webtrees\Schema', 'WT_SCHEMA_VERSION', Webtrees::SCHEMA_VERSION);

        // Add some default/necessary configuration data.
        $this->migration_service->seedDatabase();

        // If we are re-installing, then this user may already exist.
        $admin = $this->user_service->findByIdentifier($data['wtemail']);
        if ($admin === null) {
            $admin = $this->user_service->findByIdentifier($data['wtuser']);
        }
        // Create the user
        if ($admin === null) {
            $admin = $this->user_service->create($data['wtuser'], $data['wtname'], $data['wtemail'], $data['wtpass']);
            $admin->setPreference(User::PREF_LANGUAGE, $data['lang']);
            $admin->setPreference(User::PREF_IS_VISIBLE_ONLINE, '1');
        } else {
            $admin->setPassword($_POST['wtpass']);
        }
        // Make the user an administrator
        $admin->setPreference(User::PREF_IS_ADMINISTRATOR, '1');
        $admin->setPreference(User::PREF_IS_EMAIL_VERIFIED, '1');
        $admin->setPreference(User::PREF_IS_ACCOUNT_APPROVED, '1');

        // Write the config file. We already checked that this would work.
        $config_ini_php = view('setup/config.ini', $data);

        file_put_contents(Webtrees::CONFIG_FILE, $config_ini_php);

        // Login as the new user
        $request = app(ServerRequestInterface::class)
            ->withAttribute('base_url', $data['baseurl']);

        Session::start($request);
        Auth::login($admin);
        Session::put('language', $data['lang']);
    }

    /**
     * @param array<string,mixed> $data
     *
     * @return void
     */
    private function connectToDatabase(array $data): void
    {
        $capsule = new DB();

        // Try to create the database, if it does not already exist.
        switch ($data['dbtype']) {
            case 'sqlite':
                $data['dbname'] = Webtrees::ROOT_DIR . 'data/' . $data['dbname'] . '.sqlite';
                touch($data['dbname']);
                break;

            case 'mysql':
                $capsule->addConnection([
                    'driver'                  => $data['dbtype'],
                    'host'                    => $data['dbhost'],
                    'port'                    => $data['dbport'],
                    'database'                => '',
                    'username'                => $data['dbuser'],
                    'password'                => $data['dbpass'],
                ], 'temp');
                $capsule->getConnection('temp')->statement('CREATE DATABASE IF NOT EXISTS `' . $data['dbname'] . '` COLLATE utf8_unicode_ci');
                break;
        }

        // Connect to the database.
        $capsule->addConnection([
            'driver'                  => $data['dbtype'],
            'host'                    => $data['dbhost'],
            'port'                    => $data['dbport'],
            'database'                => $data['dbname'],
            'username'                => $data['dbuser'],
            'password'                => $data['dbpass'],
            'prefix'                  => $data['tblpfx'],
            'prefix_indexes'          => true,
            // For MySQL
            'charset'                 => 'utf8',
            'collation'               => 'utf8_unicode_ci',
            'timezone'                => '+00:00',
            'engine'                  => 'InnoDB',
            'modes'                   => [
                'ANSI',
                'STRICT_TRANS_TABLES',
                'NO_ZERO_IN_DATE',
                'NO_ZERO_DATE',
                'ERROR_FOR_DIVISION_BY_ZERO',
            ],
            // For SQLite
            'foreign_key_constraints' => true,
        ]);

        $capsule->setAsGlobal();
    }
}


1			<?php
2
3			/**
4			* webtrees: online genealogy
5			* Copyright (C) 2019 webtrees development team
6			* This program is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			* This program is distributed in the hope that it will be useful,
11			* but WITHOUT ANY WARRANTY; without even the implied warranty of
12			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			* GNU General Public License for more details.
14			* You should have received a copy of the GNU General Public License
15			* along with this program. If not, see <http://www.gnu.org/licenses/>.
16			*/
17
18			declare(strict_types=1);
19
20			namespace Fisharebest\Webtrees\Http\RequestHandlers;
21
22			use Exception;
23			use Fisharebest\Localization\Locale;
24			use Fisharebest\Localization\Locale\LocaleEnUs;
25			use Fisharebest\Localization\Locale\LocaleInterface;
26			use Fisharebest\Webtrees\Auth;
27			use Fisharebest\Webtrees\Cache;
28			use Fisharebest\Webtrees\Http\ViewResponseTrait;
29			use Fisharebest\Webtrees\I18N;
30			use Fisharebest\Webtrees\Module\ModuleLanguageInterface;
31			use Fisharebest\Webtrees\Services\MigrationService;
32			use Fisharebest\Webtrees\Services\ModuleService;
33			use Fisharebest\Webtrees\Services\ServerCheckService;
34			use Fisharebest\Webtrees\Services\UserService;
35			use Fisharebest\Webtrees\Session;
36			use Fisharebest\Webtrees\User;
37			use Fisharebest\Webtrees\Webtrees;
38			use Illuminate\Database\Capsule\Manager as DB;
39			use Psr\Http\Message\ResponseInterface;
40			use Psr\Http\Message\ServerRequestInterface;
41			use Psr\Http\Server\RequestHandlerInterface;
42			use Symfony\Component\Cache\Adapter\NullAdapter;
43			use Throwable;
44
45			use function app;
46			use function e;
47			use function file_get_contents;
48			use function file_put_contents;
49			use function ini_get;
50			use function random_bytes;
51			use function realpath;
52			use function redirect;
53			use function substr;
54			use function touch;
55			use function unlink;
56			use function view;
57
58			/**
59			* Controller for the installation wizard
60			*/
61			class SetupWizard implements RequestHandlerInterface
62			{
63			use ViewResponseTrait;
64
65			private const DEFAULT_DBTYPE = 'mysql';
66			private const DEFAULT_PREFIX = 'wt_';
67			private const DEFAULT_DATA = [
68			'baseurl' => '',
69			'lang' => '',
70			'dbtype' => self::DEFAULT_DBTYPE,
71			'dbhost' => '',
72			'dbport' => '',
73			'dbuser' => '',
74			'dbpass' => '',
75			'dbname' => '',
76			'tblpfx' => self::DEFAULT_PREFIX,
77			'wtname' => '',
78			'wtuser' => '',
79			'wtpass' => '',
80			'wtemail' => '',
81			];
82
83			/** @var MigrationService */
84			private $migration_service;
85
86			/** @var ModuleService */
87			private $module_service;
88
89			/** @var ServerCheckService */
90			private $server_check_service;
91
92			/** @var UserService */
93			private $user_service;
94
95			/**
96			* SetupWizard constructor.
97			*
98			* @param MigrationService $migration_service
99			* @param ModuleService $module_service
100			* @param ServerCheckService $server_check_service
101			* @param UserService $user_service
102			*/
103			public function __construct(
104			MigrationService $migration_service,
105			ModuleService $module_service,
106			ServerCheckService $server_check_service,
107			UserService $user_service
108			) {
109			$this->user_service = $user_service;
110			$this->migration_service = $migration_service;
111			$this->module_service = $module_service;
112			$this->server_check_service = $server_check_service;
113			}
114
115			/**
116			* Installation wizard - check user input and proceed to the next step.
117			*
118			* @param ServerRequestInterface $request
119			*
120			* @return ResponseInterface
121			*/
122			public function handle(ServerRequestInterface $request): ResponseInterface
123			{
124			$this->layout = 'layouts/setup';
125
126			// We will need an IP address for the logs.
127			$ip_address = $request->getServerParams()['REMOTE_ADDR'] ?? '127.0.0.1';
128			$request = $request->withAttribute('client-ip', $ip_address);
129
130			app()->instance(ServerRequestInterface::class, $request);
131			app()->instance('cache.array', new Cache(new NullAdapter()));
132
133			$data = $this->userData($request);
134
135			$params = (array) $request->getParsedBody();
136			$step = (int) ($params['step'] ?? '1');
137
138			$locales = $this->module_service
139			->setupLanguages()
140			->map(static function (ModuleLanguageInterface $module): LocaleInterface {
141			return $module->locale();
142			});
143
144			if ($data['lang'] === '') {
145			$default = new LocaleEnUs();
146
147			$locale = Locale::httpAcceptLanguage($request->getServerParams(), $locales->all(), $default);
148
149			$data['lang'] = $locale->languageTag();
150			}
151
152			I18N::init($data['lang'], true);
153
154			$data['cpu_limit'] = $this->maxExecutionTime();
155			$data['locales'] = $locales->all();
156			$data['memory_limit'] = $this->memoryLimit();
157
158			// Only show database errors after the user has chosen a driver.
159			if ($step >= 4) {
160			$data['errors'] = $this->server_check_service->serverErrors($data['dbtype']);
161			$data['warnings'] = $this->server_check_service->serverWarnings($data['dbtype']);
162			} else {
163			$data['errors'] = $this->server_check_service->serverErrors();
164			$data['warnings'] = $this->server_check_service->serverWarnings();
165			}
166
167			if (!$this->checkFolderIsWritable(Webtrees::DATA_DIR)) {
168			$data['errors']->push(
169			'<code>' . e(realpath(Webtrees::DATA_DIR)) . '</code><br>' .
170			I18N::translate('Oops! webtrees was unable to create files in this folder.') . ' ' .
171			I18N::translate('This usually means that you need to change the folder permissions to 777.')
172			);
173			}
174
175			switch ($step) {
176			default:
177			case 1:
178			return $this->step1Language($data);
179			case 2:
180			return $this->step2CheckServer($data);
181			case 3:
182			return $this->step3DatabaseType($data);
183			case 4:
184			return $this->step4DatabaseConnection($data);
185			case 5:
186			return $this->step5Administrator($data);
187			case 6:
188			return $this->step6Install($data);
189			}
190			}
191
192			/**
193			* @param ServerRequestInterface $request
194			*
195			* @return array<string,mixed>
196			*/
197			private function userData(ServerRequestInterface $request): array
198			{
199			$params = (array) $request->getParsedBody();
200
201			$data = [];
202
203			foreach (self::DEFAULT_DATA as $key => $default) {
204			$data[$key] = $params[$key] ?? $default;
205			}
206
207			return $data;
208			}
209
210			/**
211			* The server's memory limit
212			*
213			* @return int
214			*/
215			private function maxExecutionTime(): int
216			{
217			return (int) ini_get('max_execution_time');
218			}
219
220			/**
221			* The server's memory limit (in MB).
222			*
223			* @return int
224			*/
225			private function memoryLimit(): int
226			{
227			$memory_limit = ini_get('memory_limit');
228
229			$number = (int) $memory_limit;
230
231			switch (substr($memory_limit, -1)) {
232			case 'g':
233			case 'G':
234			return $number * 1024;
235			case 'm':
236			case 'M':
237			return $number;
238			case 'k':
239			case 'K':
240			return (int) ($number / 1024);
241			default:
242			return (int) ($number / 1048576);
243			}
244			}
245
246			/**
247			* Check we can write to the data folder.
248			*
249			* @param string $data_dir
250			*
251			* @return bool
252			*/
253			private function checkFolderIsWritable(string $data_dir): bool
254			{
255			$text1 = random_bytes(32);
256
257			try {
258			file_put_contents($data_dir . 'test.txt', $text1);
259			$text2 = file_get_contents(Webtrees::DATA_DIR . 'test.txt');
260			unlink(Webtrees::DATA_DIR . 'test.txt');
261			} catch (Exception $ex) {
262			return false;
263			}
264
265			return $text1 === $text2;
266			}
267
268			/**
269			* @param array<string,mixed> $data
270			*
271			* @return ResponseInterface
272			*/
273			private function step1Language(array $data): ResponseInterface
274			{
275			return $this->viewResponse('setup/step-1-language', $data);
276			}
277
278			/**
279			* @param array<string,mixed> $data
280			*
281			* @return ResponseInterface
282			*/
283			private function step2CheckServer(array $data): ResponseInterface
284			{
285			return $this->viewResponse('setup/step-2-server-checks', $data);
286			}
287
288			/**
289			* @param array<string,mixed> $data
290			*
291			* @return ResponseInterface
292			*/
293			private function step3DatabaseType(array $data): ResponseInterface
294			{
295			if ($data['errors']->isNotEmpty()) {
296			return $this->viewResponse('setup/step-2-server-checks', $data);
297			}
298
299			return $this->viewResponse('setup/step-3-database-type', $data);
300			}
301
302			/**
303			* @param array<string,mixed> $data
304			*
305			* @return ResponseInterface
306			*/
307			private function step4DatabaseConnection(array $data): ResponseInterface
308			{
309			if ($data['errors']->isNotEmpty()) {
310			return $this->step3DatabaseType($data);
311			}
312
313			return $this->viewResponse('setup/step-4-database-' . $data['dbtype'], $data);
314			}
315
316			/**
317			* @param array<string,mixed> $data
318			*
319			* @return ResponseInterface
320			*/
321			private function step5Administrator(array $data): ResponseInterface
322			{
323			try {
324			$this->connectToDatabase($data);
325			} catch (Throwable $ex) {
326			$data['errors']->push($ex->getMessage());
327
328			// Don't jump to step 4, as the error will make it jump to step 3.
329			return $this->viewResponse('setup/step-4-database-' . $data['dbtype'], $data);
330			}
331
332			return $this->viewResponse('setup/step-5-administrator', $data);
333			}
334
335			/**
336			* @param array<string,mixed> $data
337			*
338			* @return ResponseInterface
339			*/
340			private function step6Install(array $data): ResponseInterface
341			{
342			$error = $this->checkAdminUser($data['wtname'], $data['wtuser'], $data['wtpass'], $data['wtemail']);
343
344			if ($error !== '') {
345			$data['errors']->push($error);
346
347			return $this->step5Administrator($data);
348			}
349
350			try {
351			$this->createConfigFile($data);
352			} catch (Throwable $exception) {
353			return $this->viewResponse('setup/step-6-failed', ['exception' => $exception]);
354			}
355
356			// Done - start using webtrees!
357			return redirect($data['baseurl']);
358			}
359
360			/**
361			* @param string $wtname
362			* @param string $wtuser
363			* @param string $wtpass
364			* @param string $wtemail
365			*
366			* @return string
367			*/
368			private function checkAdminUser($wtname, $wtuser, $wtpass, $wtemail): string
369			{
370			if ($wtname === '' \|\| $wtuser === '' \|\| $wtpass === '' \|\| $wtemail === '') {
371			return I18N::translate('You must enter all the administrator account fields.');
372			}
373
374			if (mb_strlen($wtpass) < 6) {
375			return I18N::translate('The password needs to be at least six characters long.');
376			}
377
378			return '';
379			}
380
381			/**
382			* @param array<string,mixed> $data
383			*
384			* @return void
385			*/
386			private function createConfigFile(array $data): void
387			{
388			// Create/update the database tables.
389			$this->connectToDatabase($data);
390			$this->migration_service->updateSchema('\Fisharebest\Webtrees\Schema', 'WT_SCHEMA_VERSION', Webtrees::SCHEMA_VERSION);
391
392			// Add some default/necessary configuration data.
393			$this->migration_service->seedDatabase();
394
395			// If we are re-installing, then this user may already exist.
396			$admin = $this->user_service->findByIdentifier($data['wtemail']);
397			if ($admin === null) {
398			$admin = $this->user_service->findByIdentifier($data['wtuser']);
399			}
400			// Create the user
401			if ($admin === null) {
402			$admin = $this->user_service->create($data['wtuser'], $data['wtname'], $data['wtemail'], $data['wtpass']);
403			$admin->setPreference(User::PREF_LANGUAGE, $data['lang']);
404			$admin->setPreference(User::PREF_IS_VISIBLE_ONLINE, '1');
405			} else {
406			$admin->setPassword($_POST['wtpass']);
407			}
408			// Make the user an administrator
409			$admin->setPreference(User::PREF_IS_ADMINISTRATOR, '1');
410			$admin->setPreference(User::PREF_IS_EMAIL_VERIFIED, '1');
411			$admin->setPreference(User::PREF_IS_ACCOUNT_APPROVED, '1');
412
413			// Write the config file. We already checked that this would work.
414			$config_ini_php = view('setup/config.ini', $data);
415
416			file_put_contents(Webtrees::CONFIG_FILE, $config_ini_php);
417
418			// Login as the new user
419			$request = app(ServerRequestInterface::class)
420			->withAttribute('base_url', $data['baseurl']);
421
422			Session::start($request);
423			Auth::login($admin);
424			Session::put('language', $data['lang']);
425			}
426
427			/**
428			* @param array<string,mixed> $data
429			*
430			* @return void
431			*/
432			private function connectToDatabase(array $data): void
433			{
434			$capsule = new DB();
435
436			// Try to create the database, if it does not already exist.
437			switch ($data['dbtype']) {
438			case 'sqlite':
439			$data['dbname'] = Webtrees::ROOT_DIR . 'data/' . $data['dbname'] . '.sqlite';
440			touch($data['dbname']);
441			break;
442
443			case 'mysql':
444			$capsule->addConnection([
445			'driver' => $data['dbtype'],
446			'host' => $data['dbhost'],
447			'port' => $data['dbport'],
448			'database' => '',
449			'username' => $data['dbuser'],
450			'password' => $data['dbpass'],
451			], 'temp');
452			$capsule->getConnection('temp')->statement('CREATE DATABASE IF NOT EXISTS `' . $data['dbname'] . '` COLLATE utf8_unicode_ci');
453			break;
454			}
455
456			// Connect to the database.
457			$capsule->addConnection([
458			'driver' => $data['dbtype'],
459			'host' => $data['dbhost'],
460			'port' => $data['dbport'],
461			'database' => $data['dbname'],
462			'username' => $data['dbuser'],
463			'password' => $data['dbpass'],
464			'prefix' => $data['tblpfx'],
465			'prefix_indexes' => true,
466			// For MySQL
467			'charset' => 'utf8',
468			'collation' => 'utf8_unicode_ci',
469			'timezone' => '+00:00',
470			'engine' => 'InnoDB',
471			'modes' => [
472			'ANSI',
473			'STRICT_TRANS_TABLES',
474			'NO_ZERO_IN_DATE',
475			'NO_ZERO_DATE',
476			'ERROR_FOR_DIVISION_BY_ZERO',
477			],
478			// For SQLite
479			'foreign_key_constraints' => true,
480			]);
481
482			$capsule->setAsGlobal();
483			}
484			}
485

fisharebest / webtrees

Push — master ( 573931...5c073d )

SetupWizard::createConfigFile() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like