first commit

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.cpnl.connection.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_cpnl_connection extends DUPX_Validation_abstract_item
+{
+    protected function runTest(): int
+    {
+        if (
+            DUPX_Validation_database_service::getInstance()->skipDatabaseTests() ||
+            PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_VIEW_MODE) !== 'cpnl'
+        ) {
+            return self::LV_SKIP;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+
+        if (DUPX_Validation_database_service::getInstance()->getCpnlConnection() === false) {
+            return self::LV_FAIL;
+        } else {
+            DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+            return self::LV_PASS;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Cpanel connection';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/cpnl-connection', [
+            'isOk'     => false,
+            'cpnlHost' => PrmMng::getInstance()->getValue(PrmMng::PARAM_CPNL_HOST),
+            'cpnlUser' => PrmMng::getInstance()->getValue(PrmMng::PARAM_CPNL_USER),
+            'cpnlPass' => PrmMng::getInstance()->getValue(PrmMng::PARAM_CPNL_PASS),
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/cpnl-connection', [
+            'isOk'     => true,
+            'cpnlHost' => PrmMng::getInstance()->getValue(PrmMng::PARAM_CPNL_HOST),
+            'cpnlUser' => PrmMng::getInstance()->getValue(PrmMng::PARAM_CPNL_USER),
+            'cpnlPass' => '*****',
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.cpnl.new.user.php

@@ -0,0 +1,65 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_cpnl_new_user extends DUPX_Validation_abstract_item
+{
+    /** @var ?mixed[] */
+    private $user;
+
+    protected function runTest(): int
+    {
+        if (
+            DUPX_Validation_database_service::getInstance()->skipDatabaseTests() ||
+            PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_VIEW_MODE) !== 'cpnl' ||
+            PrmMng::getInstance()->getValue(PrmMng::PARAM_CPNL_DB_USER_CHK) != true
+        ) {
+            return self::LV_SKIP;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+        if ((DUPX_Validation_database_service::getInstance()->cpnlCreateDbUser($this->user)) === false) {
+            return self::LV_FAIL;
+        } else {
+            DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+            return self::LV_PASS;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Create Database User';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/cpnl-create-user', [
+            'isOk'         => false,
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'dbpass'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_PASS),
+            'errorMessage' => $this->user['status'],
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/cpnl-create-user', [
+            'isOk'         => true,
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'dbpass'       => '*****',
+            'errorMessage' => '',
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.affected.tables.php

@@ -0,0 +1,102 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\InstState;
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_affected_tables extends DUPX_Validation_abstract_item
+{
+    const MAX_DISPLAY_TABLE_COUNT = 1000;
+
+    /** @var int */
+    private $affectedTableCount = 0;
+    /** @var string[] */
+    private $affectedTables = [];
+    /** @var string */
+    private $message = "";
+
+    /**
+     * @return int
+     * @throws Exception
+     */
+    protected function runTest(): int
+    {
+        $dbAction = PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_ACTION);
+
+        if (
+            DUPX_Validation_database_service::getInstance()->skipDatabaseTests()
+            || $dbAction === DUPX_DBInstall::DBACTION_MANUAL
+            || $dbAction === DUPX_DBInstall::DBACTION_CREATE
+        ) {
+            return self::LV_SKIP;
+        }
+
+        if (DUPX_Validation_database_service::getInstance()->dbTablesCount() === 0) {
+            return self::LV_PASS;
+        }
+
+        $this->affectedTables     = DUPX_Validation_database_service::getInstance()->getDBActionAffectedTables($dbAction);
+        $this->affectedTableCount = count($this->affectedTables);
+        $partialText              = $this->affectedTableCount > self::MAX_DISPLAY_TABLE_COUNT ? self::MAX_DISPLAY_TABLE_COUNT . " of " . $this->affectedTableCount : "All";
+
+        if ($dbAction === DUPX_DBInstall::DBACTION_REMOVE_ONLY_TABLES || $dbAction === DUPX_DBInstall::DBACTION_EMPTY) {
+            $this->message = "{$partialText} tables flagged for <b>removal</b> are list below:";
+        } else {
+            $this->message = "{$partialText} tables flagged for <b>back-up and rename</b> are list below:";
+        }
+
+        if (
+            $this->affectedTableCount > 0 &&
+            !InstState::isRestoreBackup()
+        ) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Tables Flagged for Removal or Backup';
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-affected-tables', [
+            'isOk'               => true,
+            'message'            => $this->message,
+            'affectedTableCount' => $this->affectedTableCount,
+            'affectedTables'     => array_slice($this->affectedTables, 0, self::MAX_DISPLAY_TABLE_COUNT),
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-affected-tables', [
+            'isOk'               => false,
+            'message'            => $this->message,
+            'affectedTableCount' => $this->affectedTableCount,
+            'affectedTables'     => array_slice($this->affectedTables, 0, self::MAX_DISPLAY_TABLE_COUNT),
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.case.sentivie.tables.php

@@ -0,0 +1,89 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_case_sensitive_tables extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+
+    /** @var int<-1, max> */
+    protected $lowerCaseTableNames = -1;
+
+    /** @var int<0, max> */
+    protected $lowerCaseTableNamesSource = 0;
+
+    /** @var array<string[]> */
+    protected $duplicateTables = [];
+
+    /** @var string[] */
+    protected $redundantTables = [];
+
+    protected function runTest(): int
+    {
+        $archiveConfig             = DUPX_ArchiveConfig::getInstance();
+        $caseSensitiveTablePresent = $archiveConfig->isTablesCaseSensitive();
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests() || !$caseSensitiveTablePresent) {
+            return self::LV_SKIP;
+        }
+
+        $this->duplicateTables           = DUPX_ArchiveConfig::getInstance()->getDuplicateTableNames();
+        $this->redundantTables           = DUPX_ArchiveConfig::getInstance()->getRedundantDuplicateTableNames();
+        $this->lowerCaseTableNames       = DUPX_Validation_database_service::getInstance()->caseSensitiveTablesValue();
+        $this->lowerCaseTableNamesSource = $archiveConfig->dbInfo->lowerCaseTableNames;
+        $destIsCaseInsensitive           = $this->lowerCaseTableNames !== 0;
+        $sourceIsCaseSensitive           = $this->lowerCaseTableNamesSource === 0;
+
+        if ($destIsCaseInsensitive && $sourceIsCaseSensitive && count($this->duplicateTables) > 0) {
+            return self::LV_HARD_WARNING;
+        }
+
+        if ($destIsCaseInsensitive) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    public function getTitle(): string
+    {
+        return 'Tables Case Sensitivity';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-case-sensitive-tables', [
+            'isOk'                => false,
+            'errorMessage'        => $this->errorMessage,
+            'lowerCaseTableNames' => $this->lowerCaseTableNames,
+        ], false);
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-case-sensitive-duplicates', [
+            'lowerCaseTableNames' => $this->lowerCaseTableNames,
+            'duplicateTableNames' => $this->duplicateTables,
+            'reduntantTableNames' => $this->redundantTables,
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-case-sensitive-tables', [
+            'isOk'                => true,
+            'errorMessage'        => $this->errorMessage,
+            'lowerCaseTableNames' => $this->lowerCaseTableNames,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.cleanup.php

@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_cleanup extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->isDatabaseCreated() === false) {
+            return self::LV_SKIP;
+        }
+
+        if (DUPX_Validation_database_service::getInstance()->cleanUpDatabase($this->errorMessage)) {
+            return self::LV_PASS;
+        } else {
+            return self::LV_HARD_WARNING;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Database cleanup';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-cleanup', [
+            'isOk'         => false,
+            'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'isCpanel'     => (PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_VIEW_MODE) === 'cpnl'),
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-cleanup', [
+            'isOk'         => true,
+            'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'isCpanel'     => (PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_VIEW_MODE) === 'cpnl'),
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.connection.php

@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_connection extends DUPX_Validation_abstract_item
+{
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+        if (DUPX_Validation_database_service::getInstance()->getDbConnection() === false) {
+            return self::LV_FAIL;
+        } else {
+            DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+            return self::LV_PASS;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Host Connection';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-connection', [
+            'isOk'         => false,
+            'dbhost'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_HOST),
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'dbpass'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_PASS),
+            'mysqlConnErr' => mysqli_connect_error(),
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-connection', [
+            'isOk'         => true,
+            'dbhost'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_HOST),
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'dbpass'       => '*****',
+            'mysqlConnErr' => '',
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.create.php

@@ -0,0 +1,80 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_create extends DUPX_Validation_abstract_item
+{
+    /**
+     *
+     * @var bool
+     */
+    protected $alreadyExists = false;
+
+    /**
+     *
+     * @var string
+     */
+    protected $errorMessage = '';
+
+    protected function runTest(): int
+    {
+        if (
+            DUPX_Validation_database_service::getInstance()->skipDatabaseTests() ||
+            PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_ACTION) !== DUPX_DBInstall::DBACTION_CREATE
+        ) {
+            return self::LV_SKIP;
+        }
+
+        // already exists test
+        if (DUPX_Validation_database_service::getInstance()->databaseExists()) {
+            $this->errorMessage  = 'Database already exists';
+            $this->alreadyExists = true;
+            return self::LV_FAIL;
+        }
+
+        if (DUPX_Validation_database_service::getInstance()->createDatabase($this->errorMessage) === false) {
+            return self::LV_FAIL;
+        }
+
+        return self::LV_PASS;
+    }
+
+    public function getTitle(): string
+    {
+        return 'Create New Database';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-create', [
+            'isOk'          => false,
+            'alreadyExists' => $this->alreadyExists,
+            'errorMessage'  => $this->errorMessage,
+            'isCpanel'      => (PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_VIEW_MODE) === 'cpnl'),
+            'dbname'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-create', [
+            'isOk'          => true,
+            'alreadyExists' => $this->alreadyExists,
+            'errorMessage'  => $this->errorMessage,
+            'isCpanel'      => (PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_VIEW_MODE) === 'cpnl'),
+            'dbname'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.excluded.php

@@ -0,0 +1,62 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\InstState;
+
+class DUPX_Validation_test_db_excluded extends DUPX_Validation_abstract_item
+{
+    /**
+     * @return int
+     */
+    protected function runTest(): int
+    {
+        if (!InstState::dbDoNothing()) {
+             return self::LV_PASS;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests();
+
+        return self::LV_SOFT_WARNING;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Extract only files';
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-excluded', [
+            'dbExcluded' => DUPX_ArchiveConfig::getInstance()->isDBExcluded(),
+            'isOk'       => false,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-excluded', [
+            'dbExcluded' => false,
+            'isOk'       => true,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.gtid.mode.php

@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_gtid_mode extends DUPX_Validation_abstract_item
+{
+    /** @var string[] */
+    protected $errorMessage = [];
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        if (DUPX_Validation_database_service::getInstance()->dbGtidModeEnabled($this->errorMessage)) {
+            return self::LV_SOFT_WARNING;
+        } else {
+            return self::LV_PASS;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Database GTID Mode';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-gtid-mode', [
+            'isOk'         => false,
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-gtid-mode', [
+            'isOk'         => true,
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.host.name.php

@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+use Duplicator\Libs\Snap\SnapIO;
+
+class DUPX_Validation_test_db_host_name extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $fixedHost = '';
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+
+        $host = PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_HOST);
+        //Host check
+        $parsed_host_info = DUPX_DB::parseDBHost($host);
+        $parsed_host      = $parsed_host_info[0];
+        $isInvalidHost    = $parsed_host == 'http' || $parsed_host == "https";
+
+        if ($isInvalidHost) {
+            $this->fixedHost = SnapIO::untrailingslashit(str_replace($parsed_host . "://", "", $host));
+            return self::LV_FAIL;
+        } else {
+            DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+            return self::LV_PASS;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Host Name';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-host-name', [
+            'isOk'      => false,
+            'host'      => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_HOST),
+            'fixedHost' => $this->fixedHost,
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-host-name', [
+            'isOk'      => true,
+            'host'      => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_HOST),
+            'fixedHost' => '',
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.manual.tables.count.php

@@ -0,0 +1,76 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_manual_tables_count extends DUPX_Validation_abstract_item
+{
+    const MIN_TABLES_NUM = 10;
+
+    /** @var string */
+    protected $errorMessage = '';
+    /** @var int<0, max> */
+    protected $numTables = 0;
+
+    protected function runTest(): int
+    {
+        if (
+            DUPX_Validation_database_service::getInstance()->skipDatabaseTests() ||
+            PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_ACTION) !== DUPX_DBInstall::DBACTION_MANUAL
+        ) {
+            return self::LV_SKIP;
+        }
+
+        $this->numTables = DUPX_Validation_database_service::getInstance()->dbTablesCount($this->errorMessage);
+
+        if ($this->numTables >= self::MIN_TABLES_NUM) {
+            return self::LV_PASS;
+        } else {
+            return self::LV_HARD_WARNING;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Manual Table Check';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender(
+            'parts/validation/database-tests/db-manual-tables-count',
+            [
+                'isOk'         => false,
+                'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+                'numTables'    => $this->numTables,
+                'errorMessage' => $this->errorMessage,
+            ],
+            false
+        );
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender(
+            'parts/validation/database-tests/db-manual-tables-count',
+            [
+                'isOk'         => true,
+                'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+                'numTables'    => $this->numTables,
+                'errorMessage' => $this->errorMessage,
+            ],
+            false
+        );
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.multiple.wp.installs.php

@@ -0,0 +1,91 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\InstState;
+use Duplicator\Installer\Core\Params\PrmMng;
+use Duplicator\Libs\Snap\SnapWP;
+
+class DUPX_Validation_test_db_multiple_wp_installs extends DUPX_Validation_abstract_item
+{
+    /**
+     * @var string[] unique wp prefixes in the DB
+     */
+    protected $uniquePrefixes = [];
+
+    /**
+     * Check mutiple db install in database
+     *
+     * @return int
+     */
+    protected function runTest(): int
+    {
+        $dbAction = PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_ACTION);
+        if (
+            DUPX_Validation_database_service::getInstance()->skipDatabaseTests()
+            || $dbAction === DUPX_DBInstall::DBACTION_MANUAL
+            || $dbAction === DUPX_DBInstall::DBACTION_CREATE
+        ) {
+            return self::LV_SKIP;
+        }
+
+        if (DUPX_Validation_database_service::getInstance()->dbTablesCount() === 0 || InstState::isAddSiteOnMultisite()) {
+            return self::LV_PASS;
+        }
+
+        $affectedTables       = DUPX_Validation_database_service::getInstance()->getDBActionAffectedTables($dbAction);
+        $this->uniquePrefixes = SnapWP::getUniqueWPTablePrefixes($affectedTables);
+
+        if (count($this->uniquePrefixes) > 1) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * Get test title
+     *
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Multiple WP Installs';
+    }
+
+    /**
+     * Return content for test status: soft warning
+     *
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-multiple-wp-installs', [
+            'isOk'           => false,
+            'uniquePrefixes' => $this->uniquePrefixes,
+        ], false);
+    }
+
+    /**
+     * Return content for test status: pass
+     *
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-multiple-wp-installs', [
+            'isOk'           => true,
+            'uniquePrefixes' => $this->uniquePrefixes,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.prefix.too.long.php

@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_prefix_too_long extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+        if (DUPX_Validation_database_service::getInstance()->checkDbPrefixTooLong($this->errorMessage)) {
+            DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+            return self::LV_PASS;
+        } else {
+            return self::LV_FAIL;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Prefix too long';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-prefix-too-long', [
+            'isOk'                 => false,
+            'errorMessage'         => $this->errorMessage,
+            'tooLongNewTableNames' => DUPX_Validation_database_service::getInstance()->getTooLongNewTableNames(),
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-prefix-too-long', [
+            'isOk'                 => true,
+            'errorMessage'         => $this->errorMessage,
+            'tooLongNewTableNames' => DUPX_Validation_database_service::getInstance()->getTooLongNewTableNames(),
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.show.variables.php

@@ -0,0 +1,44 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_custom_queries extends DUPX_Validation_abstract_item
+{
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        if (!DUPX_Validation_database_service::getInstance()->isQueryWorking('SHOW VARIABLES LIKE "version"')) {
+            return self::LV_FAIL;
+        }
+
+        return self::LV_PASS;
+    }
+
+    public function getTitle(): string
+    {
+        return "Privileges: 'Show Variables' Query";
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-show-variables', ['pass' => false], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-show-variables', ['pass' => true], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.supported.charset.php

@@ -0,0 +1,86 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_supported_charset extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+    /** @var string[] */
+    protected $charsetsList = [];
+    /** @var string[] */
+    protected $collationsList = [];
+    /** @var string[] */
+    protected $invalidCharsets = [];
+    /** @var string[] */
+    protected $invalidCollations = [];
+    /** @var mixed[] */
+    protected $extraData = [];
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        try {
+            $archiveConfig = DUPX_ArchiveConfig::getInstance();
+
+            $this->charsetsList      = $archiveConfig->dbInfo->charSetList;
+            $this->collationsList    = $archiveConfig->dbInfo->collationList;
+            $this->invalidCharsets   = $archiveConfig->invalidCharsets();
+            $this->invalidCollations = $archiveConfig->invalidCollations();
+
+            if (empty($this->invalidCharsets) && empty($this->invalidCollations)) {
+                return self::LV_PASS;
+            } else {
+                return self::LV_HARD_WARNING;
+            }
+        } catch (Exception $e) {
+            $this->errorMessage = $e->getMessage();
+            return self::LV_FAIL;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Character Set and  Collation Capability';
+    }
+
+    protected function failContent()
+    {
+        $dbFuncs = DUPX_DB_Functions::getInstance();
+
+        return dupxTplRender('parts/validation/database-tests/db-supported-charset', [
+            'testResult'        => $this->testResult,
+            'extraData'         => $this->extraData,
+            'charsetsList'      => $this->charsetsList,
+            'collationsList'    => $this->collationsList,
+            'invalidCharsets'   => $this->invalidCharsets,
+            'invalidCollations' => $this->invalidCollations,
+            'usedCharset'       => $dbFuncs->getRealCharsetByParam(),
+            'usedCollate'       => $dbFuncs->getRealCollateByParam(),
+            'errorMessage'      => $this->errorMessage,
+        ], false);
+    }
+
+    protected function hwarnContent()
+    {
+        return $this->failContent();
+    }
+
+    protected function passContent()
+    {
+        return $this->failContent();
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.supported.default.charset.php

@@ -0,0 +1,105 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_supported_default_charset extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+    /** @var bool */
+    protected $charsetOk = true;
+    /** @var bool */
+    protected $collateOk = true;
+    /** @var string */
+    protected $sourceCharset = '';
+    /** @var string */
+    protected $sourceCollate = '';
+
+    /**
+     * Run the test
+     *
+     * @return int Enum LV_* result
+     */
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        try {
+            $archiveConfig       = DUPX_ArchiveConfig::getInstance();
+            $dbFuncs             = DUPX_DB_Functions::getInstance();
+            $this->sourceCharset = $archiveConfig->getWpConfigDefineValue('DB_CHARSET', '');
+            $this->sourceCollate = $archiveConfig->getWpConfigDefineValue('DB_COLLATE', '');
+            $data                = $dbFuncs->getCharsetAndCollationData();
+
+            if (!array_key_exists($this->sourceCharset, $data)) {
+                $this->charsetOk = false;
+            } elseif (strlen($this->sourceCollate) > 0 && !in_array($this->sourceCollate, $data[$this->sourceCharset]['collations'])) {
+                $this->collateOk = false;
+            }
+
+            if ($this->charsetOk && $this->collateOk) {
+                return self::LV_PASS;
+            } else {
+                return self::LV_SOFT_WARNING;
+            }
+        } catch (Exception $e) {
+            $this->errorMessage = $e->getMessage();
+            return self::LV_FAIL;
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Character Set and Collation Support';
+    }
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        $dbFuncs = DUPX_DB_Functions::getInstance();
+
+        return dupxTplRender('parts/validation/database-tests/db-supported-default-charset', [
+            'testResult'    => $this->testResult,
+            'charsetOk'     => $this->charsetOk,
+            'collateOk'     => $this->collateOk,
+            'sourceCharset' => $this->sourceCharset,
+            'sourceCollate' => $this->sourceCollate,
+            'usedCharset'   => $dbFuncs->getRealCharsetByParam(),
+            'usedCollate'   => $dbFuncs->getRealCollateByParam(),
+            'errorMessage'  => $this->errorMessage,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return $this->failContent();
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return $this->failContent();
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.supported.engine.php

@@ -0,0 +1,74 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_supported_engine extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+    /** @var string[] */
+    protected $invalidEngines = [];
+    /** @var string */
+    protected $defaultEngine = "";
+    /** @var bool */
+    protected $engineListRead = false;
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        try {
+            $this->invalidEngines = DUPX_ArchiveConfig::getInstance()->invalidEngines();
+            $this->defaultEngine  = DUPX_DB_Functions::getInstance()->getDefaultEngine();
+            $this->engineListRead = true;
+
+            if (empty($this->invalidEngines)) {
+                return self::LV_PASS;
+            } else {
+                return self::LV_HARD_WARNING;
+            }
+        } catch (Exception $e) {
+            $this->errorMessage   = $e->getMessage();
+            $this->engineListRead = false;
+            return self::LV_HARD_WARNING;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'Database Engine Support';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-supported-engine', [
+            'testResult'     => $this->testResult,
+            'invalidEngines' => $this->invalidEngines,
+            'defaultEngine'  => $this->defaultEngine,
+            'errorMessage'   => $this->errorMessage,
+            'engineListRead' => $this->engineListRead,
+        ], false);
+    }
+
+    protected function hwarnContent()
+    {
+        return $this->failContent();
+    }
+
+    protected function passContent()
+    {
+        return $this->failContent();
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.triggers.php

@@ -0,0 +1,50 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_db_triggers extends DUPX_Validation_abstract_item
+{
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        if (count(DUPX_ArchiveConfig::getInstance()->dbInfo->triggerList) > 0) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    public function getTitle(): string
+    {
+        return 'Source Database Triggers';
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-triggers', [
+            'isOk'     => true,
+            'triggers' => DUPX_ArchiveConfig::getInstance()->dbInfo->triggerList,
+        ], false);
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-triggers', [
+            'isOk'     => false,
+            'triggers' => DUPX_ArchiveConfig::getInstance()->dbInfo->triggerList,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.user.cleanup.php

@@ -0,0 +1,57 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_user_cleanup extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->isUserCreated() === false) {
+            return self::LV_SKIP;
+        }
+
+        if (DUPX_Validation_database_service::getInstance()->cleanUpUser($this->errorMessage)) {
+            return self::LV_PASS;
+        } else {
+            return self::LV_HARD_WARNING;
+        }
+    }
+
+    public function getTitle(): string
+    {
+        return 'User created cleanup';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-cleanup', [
+            'isOk'         => false,
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-cleanup', [
+            'isOk'         => true,
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.user.perms.php

@@ -0,0 +1,94 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_user_perms extends DUPX_Validation_abstract_item
+{
+    /** @var array<string,int> */
+    protected $perms = [];
+    /** @var string[] */
+    protected $errorMessages = [];
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        return DUPX_Validation_database_service::getInstance()->dbCheckUserPerms($this->perms, $this->errorMessages);
+    }
+
+    public function getTitle(): string
+    {
+        return 'Privileges: User Table Access';
+    }
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-perms', [
+            'testResult'    => self::LV_FAIL,
+            'perms'         => $this->perms,
+            'failedPerms'   => array_keys($this->perms, false, true),
+            'dbname'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'dbuser'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessages' => $this->errorMessages,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-perms', [
+            'testResult'    => self::LV_PASS,
+            'perms'         => $this->perms,
+            'dbname'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'dbuser'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessages' => $this->errorMessages,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-perms', [
+            'testResult'    => self::LV_HARD_WARNING,
+            'perms'         => $this->perms,
+            'dbname'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'dbuser'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessages' => $this->errorMessages,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-perms', [
+            'testResult'    => self::LV_HARD_WARNING,
+            'perms'         => $this->perms,
+            'dbname'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'dbuser'        => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessages' => $this->errorMessages,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.user.resources.php

@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Libs\Snap\SnapUtil;
+
+class DUPX_Validation_test_db_user_resources extends DUPX_Validation_abstract_item
+{
+    /** @var array<string, int|string> */
+    private $userResources = [];
+    /** @var bool */
+    private $userHasRestrictedResource = false;
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        if (($this->userResources = DUPX_Validation_database_service::getInstance()->getUserResources()) !== false) {
+            $this->userHasRestrictedResource = SnapUtil::inArrayExtended($this->userResources, fn($value): bool => $value > 0);
+        }
+
+        if ($this->userHasRestrictedResource) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Privileges: User Resources';
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-resources', [
+            'isOk'          => !$this->userHasRestrictedResource,
+            'userResources' => $this->userResources,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-resources', [
+            'isOk'          => !$this->userHasRestrictedResource,
+            'userResources' => $this->userResources,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.version.php

@@ -0,0 +1,110 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Utils\Log\Log;
+use Duplicator\Libs\Snap\SnapDB;
+
+class DUPX_Validation_test_db_version extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $sourceDBVersion = '';
+    /** @var string */
+    protected $hostDBVersion = '';
+    /** @var string */
+    protected $hostDBEngine = '';
+    /** @var string */
+    protected $sourceDBEngine = '';
+    /** @var bool */
+    protected $dbsOfSameType = true;
+
+    /**
+     * Run the test
+     *
+     * @return int Enum LV_* result
+     */
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+
+        $this->hostDBVersion   = DUPX_DB::getVersion(DUPX_Validation_database_service::getInstance()->getDbConnection());
+        $this->sourceDBVersion = DUPX_ArchiveConfig::getInstance()->version_db;
+        Log::info('Current DB version: ' . Log::v2str($this->hostDBVersion) . ' Source DB version: ' . Log::v2str($this->sourceDBVersion), Log::LV_DETAILED);
+
+        if (version_compare($this->hostDBVersion, '5.0.0', '<')) {
+            return self::LV_FAIL;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+        $this->hostDBEngine   = SnapDB::getDBEngine(DUPX_Validation_database_service::getInstance()->getDbConnection());
+        $this->sourceDBEngine = DUPX_ArchiveConfig::getInstance()->dbInfo->dbEngine;
+        $this->dbsOfSameType  = $this->sourceDBEngine === $this->hostDBEngine;
+
+        if (!$this->dbsOfSameType || intval($this->hostDBVersion) < intval($this->sourceDBVersion)) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * Get the title of the test
+     *
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Database Version';
+    }
+
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-version', [
+            'isOk'          => false,
+            'hostDBVersion' => $this->hostDBVersion,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-version-swarn', [
+            'hostDBVersion'   => $this->hostDBVersion,
+            'sourceDBVersion' => $this->sourceDBVersion,
+            'hostDBEngine'    => $this->hostDBEngine,
+            'sourceDBEngine'  => $this->sourceDBEngine,
+            'dbsOfSameType'   => $this->dbsOfSameType,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-version', [
+            'isOk'          => true,
+            'hostDBVersion' => $this->hostDBVersion,
+        ], false);
+    }
+}

wp-content/plugins/duplicator-pro/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.visibility.php

@@ -0,0 +1,72 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_db_visibility extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+
+    protected function runTest(): int
+    {
+        if (DUPX_Validation_database_service::getInstance()->skipDatabaseTests()) {
+            return self::LV_SKIP;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests(true);
+        if (DUPX_Validation_database_service::getInstance()->checkDbVisibility($this->errorMessage)) {
+            DUPX_Validation_database_service::getInstance()->setSkipOtherTests(false);
+            return self::LV_PASS;
+        } else {
+            return self::LV_FAIL;
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle(): string
+    {
+        return 'Privileges: User Visibility';
+    }
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-visibility', [
+            'isOk'         => false,
+            'databases'    => DUPX_Validation_database_service::getInstance()->getDatabases(),
+            'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-visibility', [
+            'isOk'         => true,
+            'databases'    => DUPX_Validation_database_service::getInstance()->getDatabases(),
+            'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessage' => $this->errorMessage,
+        ], false);
+    }
+}