first commit

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/class.validation.abstract.item.php

@@ -0,0 +1,294 @@
+<?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;
+
+/**
+ * Validation abstract item
+ */
+abstract class DUPX_Validation_abstract_item
+{
+    const LV_FAIL         = 0;
+    const LV_HARD_WARNING = 1;
+    const LV_SOFT_WARNING = 2;
+    const LV_GOOD         = 3;
+    const LV_PASS         = 4;
+    const LV_SKIP         = 1000;
+
+    /** @var string */
+    protected $category = '';
+    /** @var ?int Enum LV_*  */
+    protected $testResult = null;
+
+    /**
+     * Class Constructor
+     *
+     * @param string $category Category
+     */
+    public function __construct($category = '')
+    {
+        $this->category = $category;
+    }
+
+    /**
+     *
+     * @param bool $reset Reset test result
+     *
+     * @return int test result level
+     */
+    public function test($reset = false)
+    {
+        if ($reset || is_null($this->testResult)) {
+            try {
+                Log::resetTime(Log::LV_DEBUG);
+                Log::info('START TEST "' . $this->getTitle() . '" [CLASS: ' . get_called_class() . ']');
+                $this->testResult = $this->runTest();
+            } catch (Exception $e) {
+                Log::logException($e, Log::LV_DEFAULT, '      TEST "' . $this->getTitle() . '" EXCEPTION:');
+                $this->testResult = self::LV_FAIL;
+            } catch (Error $e) {
+                Log::logException($e, Log::LV_DEFAULT, '      TEST "' . $this->getTitle() . '" EXCEPTION:');
+                $this->testResult = self::LV_FAIL;
+            }
+            Log::logTime('TEST "' . $this->getTitle() . '" RESULT: ' . $this->resultString() . "\n", Log::LV_DEFAULT, false);
+        }
+
+        return $this->testResult;
+    }
+
+
+    /**
+     * Run the test
+     *
+     * @return int Enum LV_* result
+     */
+    abstract protected function runTest();
+
+    /**
+     * If true the test will be displayed in the validation section else will be skipped
+     *
+     * @return bool
+     */
+    public function display()
+    {
+        if ($this->testResult === self::LV_SKIP) {
+            return false;
+        } else {
+            return true;
+        }
+    }
+
+    /**
+     * Get test category
+     *
+     * @return string
+     */
+    public function getCategory()
+    {
+        return $this->category;
+    }
+
+    /**
+     * Get test title
+     *
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Test class ' . get_called_class();
+    }
+
+    /**
+     * Get test content
+     *
+     * @return string
+     */
+    public function getContent()
+    {
+        try {
+            switch ($this->test(false)) {
+                case self::LV_SKIP:
+                    return $this->skipContent();
+                case self::LV_GOOD:
+                    return $this->goodContent();
+                case self::LV_PASS:
+                    return $this->passContent();
+                case self::LV_SOFT_WARNING:
+                    return $this->swarnContent();
+                case self::LV_HARD_WARNING:
+                    return $this->hwarnContent();
+                case self::LV_FAIL:
+                default:
+                    return $this->failContent();
+            }
+        } catch (Exception $e) {
+            Log::logException($e, Log::LV_DEFAULT, 'VALIDATION DISPLAY CONTENT ' . get_called_class() . ' RESULT: ' . $this->resultString() . ' EXCEPTION:');
+            return 'DISPLAY CONTENT PROBLEM <br>'
+                . 'MESSAGE: ' . $e->getMessage() . '<br>'
+                . 'TRACE:'
+                . '<pre>' . $e->getTraceAsString() . '</pre>';
+        } catch (Error $e) {
+            Log::logException($e, Log::LV_DEFAULT, 'VALIDATION DISPLAY CONTENT ' . get_called_class() . ' ERROR:');
+            return 'DISPLAY CONTENT PROBLEM <br>'
+                . 'MESSAGE: ' . $e->getMessage() . '<br>'
+                . 'TRACE:'
+                . '<pre>' . $e->getTraceAsString() . '</pre>';
+        }
+    }
+
+
+    /**
+     * Get badge class for result level
+     *
+     * @return string
+     */
+    public function getBadgeClass()
+    {
+        return self::resultLevelToBadgeClass($this->test(false));
+    }
+
+    /**
+     * Get unique selector
+     *
+     * @return string
+     */
+    public function getUniqueSelector()
+    {
+        return strtolower(str_replace("_", "-", get_called_class()));
+    }
+
+    /**
+     * Get level label
+     *
+     * @return string
+     */
+    public function resultString()
+    {
+        return self::resultLevelToString($this->test(false));
+    }
+
+
+    /**
+     * Level to string
+     *
+     * @param int $level Enum LV_*
+     *
+     * @return string
+     */
+    public static function resultLevelToString($level)
+    {
+        switch ($level) {
+            case self::LV_SKIP:
+                return 'skip';
+            case self::LV_GOOD:
+                return 'good';
+            case self::LV_PASS:
+                return 'passed';
+            case self::LV_SOFT_WARNING:
+                return 'soft warning';
+            case self::LV_HARD_WARNING:
+                return 'hard warning';
+            case self::LV_FAIL:
+            default:
+                return 'failed';
+        }
+    }
+
+
+    /**
+     * Get badge class for result level
+     *
+     * @param int $level Enum LV_*
+     *
+     * @return string
+     */
+    public static function resultLevelToBadgeClass($level)
+    {
+        switch ($level) {
+            case self::LV_SKIP:
+                return '';
+            case self::LV_GOOD:
+                return 'good';
+            case self::LV_PASS:
+                return 'pass';
+            case self::LV_SOFT_WARNING:
+                return 'warn';
+            case self::LV_HARD_WARNING:
+                return 'hwarn';
+            case self::LV_FAIL:
+            default:
+                return 'fail';
+        }
+    }
+
+    /**
+     * Return content for test status: fail warning
+     *
+     * @return string
+     */
+    protected function failContent()
+    {
+        return 'test result: fail';
+    }
+
+    /**
+     * Return content for test status: hard warning
+     *
+     * @return string
+     */
+    protected function hwarnContent()
+    {
+        return 'test result: hard warning';
+    }
+
+    /**
+     * Return content for test status: soft warning
+     *
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return 'test result: soft warning';
+    }
+
+    /**
+     * Return content for test status: good
+     *
+     * @return string
+     */
+    protected function goodContent()
+    {
+        return 'test result: good';
+    }
+
+    /**
+     * Return content for test status: pass
+     *
+     * @return string
+     */
+    protected function passContent()
+    {
+        return 'test result: pass';
+    }
+
+    /**
+     * Return content for test status: skip
+     *
+     * @return string
+     */
+    protected function skipContent()
+    {
+        return 'test result: skipped';
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/class.validation.manager.php

@@ -0,0 +1,342 @@
+<?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\Bootstrap;
+use Duplicator\Installer\Core\Params\PrmMng;
+
+require_once(DUPX_INIT . '/classes/validation/class.validation.database.service.php');
+require_once(DUPX_INIT . '/classes/validation/class.validation.abstract.item.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.owrinstall.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.addon.sites.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.manual.extraction.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.dbonly.iswordpress.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.package.age.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.php.version.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.open.basedir.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.memory.limit.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.php.extensions.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.timeout.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.wordfence.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.disk.space.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.importer.version.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.importable.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.rest.api.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.managed.tprefix.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.iswritable.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.iswritable.configs.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.mysql.connect.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.php.functionalities.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.replace.paths.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.managed.supported.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.siteground.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.multisite.subfolder.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.archive.check.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.recovery.link.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.excluded.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.cpnl.connection.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.cpnl.new.user.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.host.name.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.connection.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.version.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.create.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.user.cleanup.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.cleanup.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.affected.tables.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.prefix.too.long.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.visibility.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.manual.tables.count.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.multiple.wp.installs.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.user.perms.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.user.resources.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.triggers.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.show.variables.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.supported.charset.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.supported.engine.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.gtid.mode.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.case.sentivie.tables.php');
+require_once(DUPX_INIT . '/classes/validation/database-tests/class.validation.test.db.supported.default.charset.php');
+require_once(DUPX_INIT . '/classes/validation/tests/class.validation.test.wp.config.php');
+
+class DUPX_Validation_manager
+{
+    const CAT_GENERAL            = 'general';
+    const CAT_FILESYSTEM         = 'filesystem';
+    const CAT_PHP                = 'php';
+    const CAT_DATABASE           = 'database';
+    const ACTION_ON_START_NORMAL = 'normal';
+    const ACTION_ON_START_AUTO   = 'auto';
+    const MIN_LEVEL_VALID        = DUPX_Validation_abstract_item::LV_HARD_WARNING;
+
+    /** @var ?self */
+    private static $instance = null;
+    /** @var DUPX_Validation_abstract_item[] */
+    private $tests = array();
+    /** @var array<string, mixed> */
+    private $extraData = array();
+
+    /**
+     *
+     * @return self
+     */
+    public static function getInstance()
+    {
+        if (is_null(self::$instance)) {
+            self::$instance = new self();
+        }
+
+        return self::$instance;
+    }
+
+    /**
+     * Class constructor
+     */
+    private function __construct()
+    {
+        // GENERAL
+        $this->tests[] = new DUPX_Validation_test_archive_check(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_importer_version(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_owrinstall(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_recovery(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_importable(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_rest_api(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_manual_extraction(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_dbonly_iswordpress(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_package_age(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_replace_paths(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_managed_supported(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_siteground(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_multisite_subfolder(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_addon_sites(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_wordfence(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_managed_tprefix(self::CAT_GENERAL);
+        $this->tests[] = new DUPX_Validation_test_wp_config(self::CAT_GENERAL);
+
+        // PHP
+        $this->tests[] = new DUPX_Validation_test_php_version(self::CAT_PHP);
+        $this->tests[] = new DUPX_Validation_test_open_basedir(self::CAT_PHP);
+        $this->tests[] = new DUPX_Validation_test_memory_limit(self::CAT_PHP);
+        $this->tests[] = new DUPX_Validation_test_extensions(self::CAT_PHP);
+        $this->tests[] = new DUPX_Validation_test_mysql_connect(self::CAT_PHP);
+        $this->tests[] = new DUPX_Validation_test_php_functionalities(self::CAT_PHP);
+        $this->tests[] = new DUPX_Validation_test_timeout(self::CAT_PHP);
+
+        // FILESYSTEM
+        $this->tests[] = new DUPX_Validation_test_disk_space(self::CAT_FILESYSTEM);
+        $this->tests[] = new DUPX_Validation_test_iswritable(self::CAT_FILESYSTEM);
+        $this->tests[] = new DUPX_Validation_test_iswritable_configs(self::CAT_FILESYSTEM);
+
+        // DATABASE
+        $this->tests[] = new DUPX_Validation_test_db_excluded(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_cpnl_connection(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_cpnl_new_user(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_host_name(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_connection(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_version(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_create(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_supported_engine(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_gtid_mode(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_visibility(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_manual_tabels_count(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_multiple_wp_installs(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_user_resources(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_user_perms(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_custom_queries(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_triggers(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_supported_default_charset(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_supported_charset(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_case_sensitive_tables(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_affected_tables(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_prefix_too_long(self::CAT_DATABASE);
+        // after all database tests
+        $this->tests[] = new DUPX_Validation_test_db_cleanup(self::CAT_DATABASE);
+        $this->tests[] = new DUPX_Validation_test_db_user_cleanup(self::CAT_DATABASE);
+    }
+
+    /**
+     * True if the validation is valid
+     *
+     * @return bool
+     */
+    public static function isValidated()
+    {
+        $paramsManager = PrmMng::getInstance();
+        return $paramsManager->getValue(PrmMng::PARAM_VALIDATION_LEVEL) >= self::MIN_LEVEL_VALID;
+    }
+
+    /**
+     * True if start is validated on load
+     *
+     * @return bool
+     */
+    public static function isFirstValidationOnLoad()
+    {
+        return (
+            Bootstrap::isInit() &&
+            PrmMng::getInstance()->getValue(PrmMng::PARAM_VALIDATION_ACTION_ON_START) === DUPX_Validation_manager::ACTION_ON_START_AUTO
+        );
+    }
+
+    /**
+     * True if start validation is set to auto
+     *
+     * @return bool
+     */
+    public static function validateOnLoad()
+    {
+        $paramsManager = PrmMng::getInstance();
+        if ($paramsManager->getValue(PrmMng::PARAM_VALIDATION_ACTION_ON_START) === DUPX_Validation_manager::ACTION_ON_START_AUTO) {
+            return true;
+        }
+        if ($paramsManager->getValue(PrmMng::PARAM_STEP_ACTION) === DUPX_CTRL::ACTION_STEP_ON_VALIDATE) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get validation data
+     *
+     * @return array<string, mixed>
+     */
+    public function getValidateData()
+    {
+        $this->runTests();
+        $mainResult = $this->getMainResult();
+
+        $paramsManager = PrmMng::getInstance();
+        $paramsManager->setValue(PrmMng::PARAM_VALIDATION_LEVEL, $mainResult);
+        $paramsManager->save();
+
+        return array(
+            'mainLevel'        => $mainResult,
+            'mainBagedClass'   => DUPX_Validation_abstract_item::resultLevelToBadgeClass($mainResult),
+            'mainText'         => DUPX_Validation_abstract_item::resultLevelToString($mainResult),
+            'categoriesLevels' => array(
+                'database'   => $this->getCagegoryResult(self::CAT_DATABASE),
+                'php'        => $this->getCagegoryResult(self::CAT_PHP),
+                'general'    => $this->getCagegoryResult(self::CAT_GENERAL),
+                'filesystem' => $this->getCagegoryResult(self::CAT_FILESYSTEM),
+            ),
+            'htmlResult'       => DUPX_CTRL::renderPostProcessings($this->getValidationHtmlResult()),
+            'extraData'        => $this->extraData,
+        );
+    }
+
+    /**
+     * Run all tests
+     *
+     * @return void
+     */
+    protected function runTests()
+    {
+        $this->extraData = array();
+
+        foreach ($this->tests as $test) {
+            $test->test(true);
+        }
+    }
+
+    /**
+     * Gte validation main result
+     *
+     * @return string
+     */
+    protected function getValidationHtmlResult()
+    {
+        return dupxTplRender('parts/validation/validation-result', array('validationManager' => $this), false);
+    }
+
+    /**
+     * Add extra data
+     *
+     * @param string $key   data key
+     * @param mixed  $value data value
+     *
+     * @return void
+     */
+    public function addExtraData($key, $value)
+    {
+        $this->extraData[$key] = $value;
+    }
+
+    /**
+     * Get category result
+     *
+     * @param string $category category
+     *
+     * @return DUPX_Validation_abstract_item[]
+     */
+    public function getTestsCategory($category)
+    {
+        $result = array();
+        foreach ($this->tests as $test) {
+            if ($test->getCategory() === $category) {
+                $result[] = $test;
+            }
+        }
+        return $result;
+    }
+
+    /**
+     * Get category result
+     *
+     * @param string $category category
+     *
+     * @return int result level enum LV_*
+     */
+    public function getCagegoryResult($category)
+    {
+        $result = PHP_INT_MAX;
+        foreach ($this->tests as $test) {
+            if ($test->getCategory() === $category && $test->test() < $result) {
+                $result = $test->test();
+            }
+        }
+        if ($result === DUPX_Validation_abstract_item::LV_GOOD) {
+            $result = DUPX_Validation_abstract_item::LV_PASS;
+        }
+        return $result;
+    }
+
+    /**
+     * Get category badge
+     *
+     * @param string $category category
+     *
+     * @return string
+     */
+    public function getCagegoryBadge($category)
+    {
+        return DUPX_Validation_abstract_item::resultLevelToBadgeClass($this->getCagegoryResult($category));
+    }
+
+    /**
+     * Get main result
+     *
+     * @return int result level enum LV_*
+     */
+    public function getMainResult()
+    {
+        $result = PHP_INT_MAX;
+        foreach ($this->tests as $test) {
+            if ($test->test() < $result) {
+                $result = $test->test();
+            }
+        }
+        if ($result === DUPX_Validation_abstract_item::LV_GOOD) {
+            $result = DUPX_Validation_abstract_item::LV_PASS;
+        }
+        return $result;
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Cpanel connection';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/cpnl-connection', array(
+            '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', array(
+            '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-v4.5.16.2/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 = null;
+
+    protected function runTest()
+    {
+        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()
+    {
+        return 'Create Database User';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/cpnl-create-user', array(
+            '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', array(
+            'isOk'         => true,
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'dbpass'       => '*****',
+            'errorMessage' => '',
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        $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()
+    {
+        return 'Tables Flagged for Removal or Backup';
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-affected-tables', array(
+            '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', array(
+            '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-v4.5.16.2/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()
+    {
+        $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()
+    {
+        return 'Tables Case Sensitivity';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-case-sensitive-tables', array(
+            'isOk'                => false,
+            'errorMessage'        => $this->errorMessage,
+            'lowerCaseTableNames' => $this->lowerCaseTableNames,
+        ), false);
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-case-sensitive-duplicates', array(
+            'lowerCaseTableNames' => $this->lowerCaseTableNames,
+            'duplicateTableNames' => $this->duplicateTables,
+            'reduntantTableNames' => $this->redundantTables,
+        ), false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-case-sensitive-tables', array(
+            'isOk'                => true,
+            'errorMessage'        => $this->errorMessage,
+            'lowerCaseTableNames' => $this->lowerCaseTableNames,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Database cleanup';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-cleanup', array(
+            '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', array(
+            '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-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Host Connection';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-connection', array(
+            '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', array(
+            '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-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Create New Database';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-create', array(
+            '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', array(
+            '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-v4.5.16.2/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()
+    {
+        if (!InstState::dbDoNothing()) {
+             return self::LV_PASS;
+        }
+
+        DUPX_Validation_database_service::getInstance()->setSkipOtherTests();
+
+        return self::LV_SOFT_WARNING;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Extract only files';
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-excluded', array(
+            'dbExcluded' => DUPX_ArchiveConfig::getInstance()->isDBExcluded(),
+            'isOk'       => false,
+        ), false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-excluded', array(
+            'dbExcluded' => false,
+            'isOk'       => true,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Database GTID Mode';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-gtid-mode', array(
+            'isOk'         => false,
+            'errorMessage' => $this->errorMessage,
+        ), false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-gtid-mode', array(
+            'isOk'         => true,
+            'errorMessage' => $this->errorMessage,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Host Name';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-host-name', array(
+            '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', array(
+            'isOk'      => true,
+            'host'      => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_HOST),
+            'fixedHost' => '',
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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_tabels_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()
+    {
+        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()
+    {
+        return 'Manual Table Check';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender(
+            'parts/validation/database-tests/db-manual-tables-count',
+            array(
+                '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',
+            array(
+                'isOk'         => true,
+                'dbname'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_NAME),
+                'numTables'    => $this->numTables,
+                'errorMessage' => $this->errorMessage,
+            ),
+            false
+        );
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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 = array();
+
+    /**
+     * Check mutiple db install in database
+     *
+     * @return int
+     */
+    protected function runTest()
+    {
+        $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()
+    {
+        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', array(
+            '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', array(
+            'isOk'           => true,
+            'uniquePrefixes' => $this->uniquePrefixes,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Prefix too long';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-prefix-too-long', array(
+            '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', array(
+            'isOk'                 => true,
+            'errorMessage'         => $this->errorMessage,
+            'tooLongNewTableNames' => DUPX_Validation_database_service::getInstance()->getTooLongNewTableNames(),
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return "Privileges: 'Show Variables' Query";
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-show-variables', array('pass' => false), false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-show-variables', array('pass' => true), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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 = array();
+    /** @var string[] */
+    protected $collationsList = array();
+    /** @var string[] */
+    protected $invalidCharsets = array();
+    /** @var string[] */
+    protected $invalidCollations = array();
+    /** @var mixed[] */
+    protected $extraData = array();
+
+    protected function runTest()
+    {
+        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()
+    {
+        return 'Character Set and  Collation Capability';
+    }
+
+    protected function failContent()
+    {
+        $dbFuncs = DUPX_DB_Functions::getInstance();
+
+        return dupxTplRender('parts/validation/database-tests/db-supported-charset', array(
+            '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-v4.5.16.2/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()
+    {
+        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()
+    {
+        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', array(
+            '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-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Database Engine Support';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-supported-engine', array(
+            '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-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Source Database Triggers';
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-triggers', array(
+            'isOk'     => true,
+            'triggers' => DUPX_ArchiveConfig::getInstance()->dbInfo->triggerList,
+        ), false);
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-triggers', array(
+            'isOk'     => false,
+            'triggers' => DUPX_ArchiveConfig::getInstance()->dbInfo->triggerList,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'User created cleanup';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-cleanup', array(
+            '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', array(
+            'isOk'         => true,
+            'dbuser'       => PrmMng::getInstance()->getValue(PrmMng::PARAM_DB_USER),
+            'errorMessage' => $this->errorMessage,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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, bool> */
+    protected $perms = array();
+    /** @var array<string, bool> */
+    protected $errorMessages = array();
+
+    protected function runTest()
+    {
+        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()
+    {
+        return 'Privileges: User Table Access';
+    }
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-perms', array(
+            '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', array(
+            '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', array(
+            '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', array(
+            '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-v4.5.16.2/installer/dup-installer/classes/validation/database-tests/class.validation.test.db.user.resources.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\Libs\Snap\SnapUtil;
+
+class DUPX_Validation_test_db_user_resources extends DUPX_Validation_abstract_item
+{
+    /** @var array<string, int|string> */
+    private $userResources = array();
+    /** @var bool */
+    private $userHasRestrictedResource = false;
+
+    protected function runTest()
+    {
+        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, function ($value) {
+                return $value > 0;
+            });
+        }
+
+        if ($this->userHasRestrictedResource) {
+            return self::LV_SOFT_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Privileges: User Resources';
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-resources', array(
+            'isOk'          => !$this->userHasRestrictedResource,
+            'userResources' => $this->userResources,
+        ), false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-user-resources', array(
+            'isOk'          => !$this->userHasRestrictedResource,
+            'userResources' => $this->userResources,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Database Version';
+    }
+
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-version', array(
+            'isOk'          => false,
+            'hostDBVersion' => $this->hostDBVersion,
+        ), false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-version-swarn', array(
+            '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', array(
+            'isOk'          => true,
+            'hostDBVersion' => $this->hostDBVersion,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/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()
+    {
+        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()
+    {
+        return 'Privileges: User Visibility';
+    }
+
+    /**
+     * @return string
+     */
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/database-tests/db-visibility', array(
+            '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', array(
+            '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);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.addon.sites.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\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_addon_sites extends DUPX_Validation_abstract_item
+{
+    /**
+     *
+     * @return int
+     */
+    protected function runTest()
+    {
+        $list = self::getAddonsListsFolders();
+
+        if (PrmMng::getInstance()->getValue(PrmMng::PARAM_ARCHIVE_ACTION) === DUP_PRO_Extraction::ACTION_DO_NOTHING) {
+            return self::LV_GOOD;
+        }
+
+        if (count($list) > 0) {
+            return self::LV_SOFT_WARNING;
+        } else {
+            return self::LV_GOOD;
+        }
+    }
+
+    /**
+     *
+     * @staticvar string[] $addonListFolder
+     *
+     * @return string[]
+     */
+    public static function getAddonsListsFolders()
+    {
+        static $addonListFolder = null;
+        if (is_null($addonListFolder)) {
+            $addonListFolder = DUPX_Server::getWpAddonsSiteLists();
+        }
+        return $addonListFolder;
+    }
+
+    public function getTitle()
+    {
+        return 'Addon Sites';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/addon-sites', array(
+            'testResult' => $this->testResult,
+            'pathsList'  => self::getAddonsListsFolders(),
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return $this->swarnContent();
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.archive.check.php

@@ -0,0 +1,47 @@
+<?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_archive_check extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (DUPX_Conf_Utils::archiveExists()) {
+            return self::LV_PASS;
+        } else {
+            return self::LV_SOFT_WARNING;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Archive Check';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/tests/archive-check', array(
+            'testResult' => $this->testResult,
+        ), false);
+    }
+
+    protected function swarnContent()
+    {
+        return $this->failContent();
+    }
+
+    protected function passContent()
+    {
+        return $this->failContent();
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.dbonly.iswordpress.php

@@ -0,0 +1,43 @@
+<?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_dbonly_iswordpress extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (!DUPX_ArchiveConfig::getInstance()->isDBOnly()) {
+            return self::LV_SKIP;
+        }
+        if (DUPX_Server::isWordPress()) {
+            return self::LV_GOOD;
+        } else {
+            return self::LV_SOFT_WARNING;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Database Only';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/dbonly-iswordpress', array(), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/dbonly-iswordpress', array(), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.disk.space.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\Installer\Core\InstState;
+use Duplicator\Installer\Core\Params\PrmMng;
+use Duplicator\Installer\Models\ScanInfo;
+use Duplicator\Libs\Snap\SnapIO;
+
+class DUPX_Validation_test_disk_space extends DUPX_Validation_abstract_item
+{
+    /** @var int */
+    private $freeSpace = 0;
+    /** @var int */
+    private $archiveSize = 0;
+    /** @var int */
+    private $extractedSize = 0;
+
+    protected function runTest()
+    {
+        if (!function_exists('disk_free_space') || InstState::isRecoveryMode()) {
+            return self::LV_SKIP;
+        }
+
+        // if home path is root path is necessary do a trailingslashit
+        $realPath            = SnapIO::safePathTrailingslashit(PrmMng::getInstance()->getValue(PrmMng::PARAM_PATH_NEW));
+        $this->freeSpace     = (int) @disk_free_space($realPath);
+        $this->archiveSize   = DUPX_Conf_Utils::archiveExists() ? DUPX_Conf_Utils::archiveSize() : 1;
+        $this->extractedSize = ScanInfo::getInstance()->getUSize();
+
+        if ($this->freeSpace && $this->archiveSize > 0 && $this->freeSpace > ($this->extractedSize + $this->archiveSize)) {
+            return self::LV_GOOD;
+        } else {
+            return self::LV_SOFT_WARNING;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Disk Space';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/diskspace', array(
+            'freeSpace'     => DUPX_U::readableByteSize($this->freeSpace),
+            'requiredSpace' => DUPX_U::readableByteSize($this->archiveSize + $this->extractedSize),
+            'isOk'          => false,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/diskspace', array(
+            'freeSpace'     => DUPX_U::readableByteSize($this->freeSpace),
+            'requiredSpace' => DUPX_U::readableByteSize($this->archiveSize + $this->extractedSize),
+            'isOk'          => true,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.importable.php

@@ -0,0 +1,170 @@
+<?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\Models\ScanInfo;
+use Duplicator\Installer\Package\PComponents;
+
+class DUPX_Validation_test_importable extends DUPX_Validation_abstract_item
+{
+    /** @var string[] */
+    protected $failMessages = [];
+
+    /**
+     * Run test
+     *
+     * @return int  test status enum
+     */
+    protected function runTest()
+    {
+        $archiveConf = DUPX_ArchiveConfig::getInstance();
+
+        $coreFoldersCheck     = false;
+        $subsitesCheck        = false;
+        $globalTablesCheck    = false;
+        $partialSubsitesCheck = false;
+
+        switch (InstState::getInstType()) {
+            case InstState::TYPE_SINGLE:
+            case InstState::TYPE_RBACKUP_SINGLE:
+            case InstState::TYPE_RECOVERY_SINGLE:
+                $coreFoldersCheck  = true;
+                $globalTablesCheck = true;
+                break;
+            case InstState::TYPE_MSUBDOMAIN:
+            case InstState::TYPE_MSUBFOLDER:
+            case InstState::TYPE_RBACKUP_MSUBDOMAIN:
+            case InstState::TYPE_RBACKUP_MSUBFOLDER:
+            case InstState::TYPE_RECOVERY_MSUBDOMAIN:
+            case InstState::TYPE_RECOVERY_MSUBFOLDER:
+                $coreFoldersCheck     = true;
+                $subsitesCheck        = true;
+                $globalTablesCheck    = true;
+                $partialSubsitesCheck = true;
+                break;
+            case InstState::TYPE_STANDALONE:
+                $coreFoldersCheck = true;
+                $subsitesCheck    = true;
+                break;
+            case InstState::TYPE_SINGLE_ON_SUBDOMAIN:
+            case InstState::TYPE_SINGLE_ON_SUBFOLDER:
+                $globalTablesCheck = true;
+                break;
+            case InstState::TYPE_SUBSITE_ON_SUBDOMAIN:
+            case InstState::TYPE_SUBSITE_ON_SUBFOLDER:
+                $subsitesCheck = true;
+                break;
+            case InstState::TYPE_NOT_SET:
+            default:
+                throw new Exception('Unknown mode');
+        }
+
+        $result = self::LV_PASS;
+
+        foreach (PComponents::COMPONENTS_DEFAULT as $component) {
+            if (
+                in_array($component, $archiveConf->components)
+            ) {
+                $this->failMessages[] = 'Component <b>' . PComponents::getLabel($component) . '</b> ' .
+                    '<i class="fas fa-check-circle green"></i>' . ' included.';
+            } else {
+                $this->failMessages[] = 'Component <b>' . PComponents::getLabel($component) . '</b> ' .
+                    '<i class="fas fa-times-circle maroon"></i>' . ' excluded.';
+                if ($component != PComponents::COMP_OTHER) {
+                    $result = self::LV_HARD_WARNING;
+                }
+            }
+        }
+
+        if ($coreFoldersCheck) {
+            if (ScanInfo::getInstance()->hasFilteredCoreFolders()) {
+                $this->failMessages[] = '<i class="fas fa-times-circle maroon"></i>' .
+                    ' Some Wordpress core folders are missing. (e.g. wp-admin, wp-content, wp-includes, uploads, plugins, and themes folders)';
+                $result               = self::LV_HARD_WARNING;
+            }
+        }
+
+        if ($partialSubsitesCheck) {
+            if ($archiveConf->mu_is_filtered) {
+                $this->failMessages[] = '<i class="fas fa-times-circle maroon"></i>' .
+                    ' In This Backup, some sub-sites of the multisite installation have been excluded.';
+                $result               = self::LV_HARD_WARNING;
+            }
+        }
+
+        if ($subsitesCheck) {
+            for ($i = 0; $i < count($archiveConf->subsites); $i++) {
+                if (
+                    empty($archiveConf->subsites[$i]->filteredTables) &&
+                    empty($archiveConf->subsites[$i]->filteredPaths)
+                ) {
+                    break;
+                }
+            }
+
+            if ($i >= count($archiveConf->subsites)) {
+                $this->failMessages[] = '<i class="fas fa-times-circle maroon"></i>' .
+                    ' The Backup does not have any importable subsite.';
+                $result               = self::LV_HARD_WARNING;
+            }
+        }
+
+        if ($globalTablesCheck && !InstState::dbDoNothing()) {
+            if ($archiveConf->dbInfo->tablesBaseCount != $archiveConf->dbInfo->tablesFinalCount) {
+                $this->failMessages[] = '<i class="fas fa-times-circle maroon"></i>' .
+                    ' The Backup is missing some of the site tables.';
+                $result               = self::LV_HARD_WARNING;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     * Get test title
+     *
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Partial Backup Check';
+    }
+
+    /**
+     * Render fail content
+     *
+     * @return string
+     */
+    protected function hwarnContent()
+    {
+        return dupxTplRender(
+            'parts/validation/tests/importable-package',
+            array(
+                'testResult'   => $this->testResult,
+                'failMessages' => $this->failMessages,
+            ),
+            false
+        );
+    }
+
+    /**
+     * Render pass content
+     *
+     * @return string
+     */
+    protected function passContent()
+    {
+        return $this->hwarnContent();
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.importer.version.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
+ */
+
+use Duplicator\Installer\Core\InstState;
+use Duplicator\Installer\Core\Params\PrmMng;
+use Duplicator\Libs\Snap\SnapUtil;
+
+class DUPX_Validation_test_importer_version extends DUPX_Validation_abstract_item
+{
+    /**
+     *
+     * @return int
+     */
+    protected function runTest()
+    {
+
+        if (!InstState::isImportFromBackendMode()) {
+            return self::LV_SKIP;
+        }
+
+        $overwriteData = PrmMng::getInstance()->getValue(PrmMng::PARAM_OVERWRITE_SITE_DATA);
+        if (SnapUtil::versionCompare($overwriteData['dupVersion'], DUPX_VERSION, '<', 3)) {
+            return self::LV_FAIL;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * Return test ticekt
+     *
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Duplicator importer version';
+    }
+
+    protected function failContent()
+    {
+        $overwriteData = PrmMng::getInstance()->getValue(PrmMng::PARAM_OVERWRITE_SITE_DATA);
+
+        return dupxTplRender('parts/validation/tests/importer-version', array(
+            'testResult'  => $this->testResult,
+            'importerVer' => ($overwriteData['dupVersion'] == '0' ? 'Unknown' : $overwriteData['dupVersion']),
+        ), false);
+    }
+
+    protected function passContent()
+    {
+        return $this->failContent();
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.iswritable.configs.php

@@ -0,0 +1,131 @@
+<?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\SnapIO;
+
+class DUPX_Validation_test_iswritable_configs extends DUPX_Validation_abstract_item
+{
+    /** @var bool[] */
+    protected $configsCheck = array(
+        'wpconfig' => false,
+        'htaccess' => false,
+        'other'    => false,
+    );
+    /** @var string[] */
+    protected $notWritableConfigsList = array();
+
+    /**
+     * Run test
+     *
+     * @return int
+     */
+    protected function runTest()
+    {
+        $this->configsCheck = self::configsWritableChecks();
+
+        foreach ($this->configsCheck as $check) {
+            if ($check === false) {
+                if (
+                    InstState::isRestoreBackup() ||
+                    DUPX_Custom_Host_Manager::getInstance()->isManaged() !== false
+                ) {
+                    return self::LV_SOFT_WARNING;
+                } else {
+                    return self::LV_HARD_WARNING;
+                }
+            }
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * try to set wigth config permission and check if configs files are writeable
+     *
+     * @return array<string, bool>
+     */
+    public static function configsWritableChecks()
+    {
+        $result = array();
+        // if home path is root path is necessary do a trailingslashit
+        $homePath = SnapIO::safePathTrailingslashit(PrmMng::getInstance()->getValue(PrmMng::PARAM_PATH_NEW));
+
+        if (!SnapIO::dirAddFullPermsAndCheckResult($homePath)) {
+            $result['wpconfig'] = false;
+            $result['htaccess'] = false;
+            $result['other']    = false;
+        } else {
+            $configFile = $homePath . 'wp-config.php';
+            if (file_exists($configFile)) {
+                $result['wpconfig'] = SnapIO::fileAddFullPermsAndCheckResult($configFile);
+            } else {
+                $result['wpconfig'] = true;
+            }
+
+            $configFile = $homePath . '.htaccess';
+            if (file_exists($configFile)) {
+                $result['htaccess'] = SnapIO::fileAddFullPermsAndCheckResult($configFile);
+            } else {
+                $result['htaccess'] = true;
+            }
+
+            $result['other'] = true;
+            $configFile      = $homePath . 'web.config';
+            if (file_exists($configFile) && !SnapIO::fileAddFullPermsAndCheckResult($configFile)) {
+                $result['other'] = false;
+            }
+
+            $configFile = $homePath . '.user.ini';
+            if (file_exists($configFile) && !SnapIO::fileAddFullPermsAndCheckResult($configFile)) {
+                $result['other'] = false;
+            }
+
+            $configFile = $homePath . 'php.ini';
+            if (file_exists($configFile) && !SnapIO::fileAddFullPermsAndCheckResult($configFile)) {
+                $result['other'] = false;
+            }
+        }
+
+        return $result;
+    }
+
+    /**
+     *
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Permissions: Configs Files ';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/configs-is-writable', array(
+            'testResult'   => $this->testResult,
+            'configsCheck' => $this->configsCheck,
+        ), false);
+    }
+
+    protected function swarnContent()
+    {
+        return $this->hwarnContent();
+    }
+
+    protected function passContent()
+    {
+        return $this->hwarnContent();
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.iswritable.php

@@ -0,0 +1,193 @@
+<?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\SnapIO;
+use Duplicator\Libs\Snap\SnapWP;
+
+class DUPX_Validation_test_iswritable extends DUPX_Validation_abstract_item
+{
+    const TEMP_PHP_FILE_NAME = 'dup_tmp_php_file_test.php';
+
+    /** @var string[] */
+    protected $faildDirPerms = array();
+
+    /** @var mixed[] */
+    protected $phpPerms = array();
+
+    /**
+     * Runs Test
+     *
+     * @return int
+     * @throws Exception
+     */
+    protected function runTest()
+    {
+        $this->faildDirPerms = $this->checkWritePermissions();
+        $testPass            = (count($this->faildDirPerms) == 0);
+
+        $prmMng = PrmMng::getInstance();
+        if ($prmMng->getValue(PrmMng::PARAM_ARCHIVE_ENGINE_SKIP_WP_FILES) === DUP_PRO_Extraction::FILTER_NONE) {
+            $abspath        = $prmMng->getValue(PrmMng::PARAM_PATH_WP_CORE_NEW);
+            $this->phpPerms = array(
+                array(
+                    'dir'     => $abspath . '/wp-admin',
+                    'pass'    => false,
+                    'message' => '',
+                ),
+                array(
+                    'dir'     => $abspath . '/wp-includes',
+                    'pass'    => false,
+                    'message' => '',
+                ),
+            );
+
+            for ($i = 0; $i < count($this->phpPerms); $i++) {
+                $this->phpPerms[$i]['pass'] = self::checkPhpFileCreation(
+                    $this->phpPerms[$i]['dir'],
+                    $this->phpPerms[$i]['message']
+                );
+
+                if ($this->phpPerms[$i]['pass'] == false) {
+                    $testPass = false;
+                }
+            }
+        }
+
+        if ($testPass) {
+            return self::LV_PASS;
+        } else {
+            if (InstState::isRecoveryMode() || DUPX_Custom_Host_Manager::getInstance()->isManaged()) {
+                return self::LV_SOFT_WARNING;
+            } else {
+                return self::LV_HARD_WARNING;
+            }
+        }
+    }
+
+    /**
+     * Returns list of paths that we don't have "write" permissions on
+     *
+     * @return string[]
+     * @throws Exception
+     */
+    protected function checkWritePermissions()
+    {
+        $prmMng        = PrmMng::getInstance();
+        $failResult    = array();
+        $dirFiles      = DUPX_Package::getDirsListPath();
+        $archiveConfig = DUPX_ArchiveConfig::getInstance();
+        $skipWpCore    = ($prmMng->getValue(PrmMng::PARAM_ARCHIVE_ENGINE_SKIP_WP_FILES) !== DUP_PRO_Extraction::FILTER_NONE);
+
+        if (($handle = fopen($dirFiles, "r")) === false) {
+            throw new Exception('Can\'t open dirs file list');
+        }
+
+        while (($line = fgets($handle)) !== false) {
+            if (($info = json_decode($line)) === null) {
+                throw new Exception('Invalid json line in dirs file: ' . $line);
+            }
+            if ($skipWpCore && SnapWP::isWpCore($info->p, SnapWP::PATH_RELATIVE)) {
+                continue;
+            }
+            $destPath = $archiveConfig->destFileFromArchiveName($info->p);
+            if (file_exists($destPath) && !SnapIO::dirAddFullPermsAndCheckResult($destPath)) {
+                $failResult[] = $destPath;
+            }
+        }
+        fclose($handle);
+        return $failResult;
+    }
+
+    /**
+     * Check if PHP files can be creatend in passed folder
+     *
+     * @param string $dir     folder to check
+     * @param string $message error message
+     *
+     * @return bool
+     */
+    protected static function checkPhpFileCreation($dir, &$message = '')
+    {
+        $removeDir = false;
+        $exception = null;
+
+        try {
+            if (!file_exists($dir)) {
+                if (!SnapIO::mkdirP($dir)) {
+                    throw new Exception('Don\'t have permissition to create folder "' . $dir . '"');
+                }
+                $removeDir = true;
+            } elseif (!is_dir($dir)) {
+                throw new Exception('"' . $dir . '" must be a folder');
+            } elseif (!is_writable($dir) || !is_executable($dir)) {
+                if (SnapIO::chmod($dir, 'u+rwx') == false) {
+                    throw new Exception('"' . $dir . '" don\'t have write permissions');
+                }
+            }
+
+            $tmpFile = SnapIO::trailingslashit($dir) . self::TEMP_PHP_FILE_NAME;
+
+            if (file_exists($tmpFile) && unlink($tmpFile) == false) {
+                throw new Exception('Can\'t remove temp php file \"' . $tmpFile . '\" to check if php files are writable');
+            }
+
+            if (file_put_contents($tmpFile, "<?php\n\n//silent") == false) {
+                throw new Exception('Cannot create PHP files even if the "' . basename($dir) . '" folder has permissions');
+            }
+
+            unlink($tmpFile);
+        } catch (Exception $e) {
+            $exception = $e;
+        }
+
+        if ($removeDir) {
+            rmdir($dir);
+        }
+
+        if (is_null($exception)) {
+            return true;
+        } else {
+            $message = $exception->getMessage();
+            return false;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Permissions: General';
+    }
+
+    protected function hwarnContent()
+    {
+        $result = dupxTplRender('parts/validation/tests/writeable-checks', array(
+            'testResult'    => $this->testResult,
+            'phpPerms'      => $this->phpPerms,
+            'faildDirPerms' => $this->faildDirPerms,
+        ), false);
+
+        return $result;
+    }
+
+    protected function swarnContent()
+    {
+        return $this->hwarnContent();
+    }
+
+    protected function passContent()
+    {
+        return $this->hwarnContent();
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.managed.supported.php

@@ -0,0 +1,90 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+use Duplicator\Installer\Core\InstState;
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_managed_supported extends DUPX_Validation_abstract_item
+{
+    /** @var bool */
+    private $managed = false;
+    /** @var string */
+    private $failMessage = '';
+
+    protected function runTest()
+    {
+        if (!($this->managed = DUPX_Custom_Host_Manager::getInstance()->isManaged())) {
+            return self::LV_SKIP;
+        }
+
+        if (InstState::isRecoveryMode()) {
+            return self::LV_PASS;
+        }
+
+        if (InstState::isNewSiteIsMultisite()) {
+            $this->failMessage = "Installing multisites on managed hosts is not supported";
+            return self::LV_FAIL;
+        }
+
+        if (InstState::isImportFromBackendMode()) {
+            return self::LV_PASS;
+        }
+
+        switch ($this->managed) {
+            case DUPX_Custom_Host_Manager::HOST_GODADDY:
+            case DUPX_Custom_Host_Manager::HOST_LIQUIDWEB:
+            case DUPX_Custom_Host_Manager::HOST_WPENGINE:
+                return self::LV_PASS;
+            case DUPX_Custom_Host_Manager::HOST_PANTHEON:
+            case DUPX_Custom_Host_Manager::HOST_WORDPRESSCOM:
+            case DUPX_Custom_Host_Manager::HOST_FLYWHEEL:
+                $this->failMessage = 'Standard installations on this managed host are not supported because it uses a non-standard configuration that can ' .
+                    'only be read at runtime. Use Drop and Drop install to overwrite the site instead.';
+                return self::LV_FAIL;
+            default:
+                $this->failMessage = "Unknown managed host type.";
+                return self::LV_FAIL;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Managed hosting supported';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender(
+            'parts/validation/tests/managed-supported',
+            array(
+                'isOk'           => false,
+                'managedHosting' => $this->managed,
+                'failMessage'    => $this->failMessage,
+            ),
+            false
+        );
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender(
+            'parts/validation/tests/managed-supported',
+            array(
+                'isOk'           => true,
+                'managedHosting' => $this->managed,
+                'failMessage'    => $this->failMessage,
+            ),
+            false
+        );
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.managed.tprefix.php

@@ -0,0 +1,47 @@
+<?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_managed_tprefix extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (!DUPX_Custom_Host_Manager::getInstance()->isManaged()) {
+            return self::LV_SKIP;
+        }
+
+        $overwriteData = PrmMng::getInstance()->getValue(PrmMng::PARAM_OVERWRITE_SITE_DATA);
+        if (DUPX_ArchiveConfig::getInstance()->wp_tableprefix != $overwriteData['table_prefix']) {
+            return self::LV_SOFT_WARNING;
+        } else {
+            return self::LV_GOOD;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Table prefix of managed hosting';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/managed-tprefix', array('isOk' => false), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/managed-tprefix', array('isOk' => true), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.manual.extraction.php

@@ -0,0 +1,49 @@
+<?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_manual_extraction extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (DUPX_Conf_Utils::isManualExtractFilePresent()) {
+            return self::LV_SOFT_WARNING;
+        } else {
+            return self::LV_GOOD;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Manual extraction detected';
+    }
+
+    public function display()
+    {
+        if ($this->testResult === self::LV_SKIP) {
+            return false;
+        } else {
+            return DUPX_Conf_Utils::isManualExtractFilePresent();
+        }
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/manual-extraction', array(), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/manual-extraction', array(), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.memory.limit.php

@@ -0,0 +1,64 @@
+<?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_memory_limit extends DUPX_Validation_abstract_item
+{
+    const MIN_MEMORY_LIMIT = '256M';
+
+    /** @var int */
+    private $memoryLimit = -1;
+
+    protected function runTest()
+    {
+        if (($memoryLimit = @ini_get('memory_limit')) === false || strlen($memoryLimit) == 0) {
+            return self::LV_SKIP;
+        }
+
+        $this->memoryLimit = is_numeric($memoryLimit) ? (int) $memoryLimit : SnapUtil::convertToBytes($memoryLimit);
+        if ($this->memoryLimit < 0) {
+            return self::LV_SKIP;
+        }
+
+        if ($this->memoryLimit >= SnapUtil::convertToBytes(self::MIN_MEMORY_LIMIT)) {
+            return self::LV_GOOD;
+        }
+
+        return self::LV_SOFT_WARNING;
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Memory Limit';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/memory-limit', array(
+            'memoryLimit'    => $this->memoryLimit,
+            'minMemoryLimit' => self::MIN_MEMORY_LIMIT,
+            'isOk'           => false,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/memory-limit', array(
+            'memoryLimit'    => DUPX_U::readableByteSize($this->memoryLimit),
+            'minMemoryLimit' => self::MIN_MEMORY_LIMIT,
+            'isOk'           => true,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.multisite.subfolder.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\InstState;
+use Duplicator\Installer\Core\Params\PrmMng;
+
+class DUPX_Validation_test_multisite_subfolder extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (InstState::isRecoveryMode() || !InstState::isNewSiteIsMultisite()) {
+            return self::LV_SKIP;
+        }
+
+        if (InstState::isInstType(InstState::TYPE_MSUBDOMAIN) && $this->newUrlIsInSubFolder()) {
+            return self::LV_HARD_WARNING;
+        }
+
+        return self::LV_PASS;
+    }
+
+    /**
+     * Check if the new url is in a subfolder
+     *
+     * @return bool
+     */
+    private function newUrlIsInSubFolder()
+    {
+        return parse_url(PrmMng::getInstance()->getValue(PrmMng::PARAM_URL_NEW), PHP_URL_PATH) !== null;
+    }
+
+    public function getTitle()
+    {
+        return 'Subomain multisite installation in subfolder';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/multisite-subfolder', array("isOk" => false), false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/tests/multisite-subfolder', array("isOk" => true), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.mysql.connect.php

@@ -0,0 +1,40 @@
+<?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_mysql_connect extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (function_exists('mysqli_connect')) {
+            return self::LV_PASS;
+        } else {
+            return self::LV_FAIL;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Mysqli';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/tests/mysql-connect', array(), false);
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender('parts/validation/tests/mysql-connect', array(), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.open.basedir.php

@@ -0,0 +1,78 @@
+<?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\Libs\Snap\SnapIO;
+
+class DUPX_Validation_test_open_basedir extends DUPX_Validation_abstract_item
+{
+    /** @var bool */
+    private $openBaseDirEnabled = false;
+    /** @var string[] */
+    private $pathsOutsideOpenBaseDir = array();
+
+    protected function runTest()
+    {
+        if (InstState::isRecoveryMode()) {
+            return self::LV_SKIP;
+        }
+
+        if (($this->openBaseDirEnabled = SnapIO::isOpenBaseDirEnabled()) === false) {
+            return self::LV_GOOD;
+        }
+
+        $archivePaths = array();
+        $pathMapping  = DUPX_ArchiveConfig::getInstance()->getPathsMapping();
+        if (is_array($pathMapping)) {
+            $archivePaths = $pathMapping;
+        } else {
+            $archivePaths[] = $pathMapping;
+        }
+
+        foreach ($archivePaths as $archivePath) {
+            if (SnapIO::getOpenBaseDirRootOfPath($archivePath) === false) {
+                $this->pathsOutsideOpenBaseDir[] = $archivePath;
+            }
+        }
+
+        if (empty($this->pathsOutsideOpenBaseDir)) {
+            return self::LV_GOOD;
+        } else {
+            return self::LV_HARD_WARNING;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Open Base';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/open-basedir', array(
+            'openBaseDirEnabled'      => $this->openBaseDirEnabled,
+            'pathsOutsideOpenBaseDir' => $this->pathsOutsideOpenBaseDir,
+            'isOk'                    => false,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/open-basedir', array(
+            'openBaseDirEnabled'      => $this->openBaseDirEnabled,
+            'pathsOutsideOpenBaseDir' => $this->pathsOutsideOpenBaseDir,
+            'isOk'                    => true,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.owrinstall.php

@@ -0,0 +1,49 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+use Duplicator\Installer\Core\InstState;
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_owrinstall extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (
+            InstState::isRecoveryMode() ||
+            InstState::isImportFromBackendMode()
+        ) {
+            return self::LV_SKIP;
+        }
+
+        if (InstState::getInstance()->getMode() === InstState::MODE_OVR_INSTALL) {
+            return self::LV_SOFT_WARNING;
+        } else {
+            return self::LV_GOOD;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Overwrite Install';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/overwrite-install', array(), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/overwrite-install', array(), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.package.age.php

@@ -0,0 +1,58 @@
+<?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_package_age extends DUPX_Validation_abstract_item
+{
+    const PACKAGE_DAYS_BEFORE_WARNING = 180;
+
+    protected function runTest()
+    {
+        if ($this->getPackageDays() <= self::PACKAGE_DAYS_BEFORE_WARNING) {
+            return self::LV_GOOD;
+        } else {
+            return self::LV_SOFT_WARNING;
+        }
+    }
+
+    /**
+     * Get package age in days
+     *
+     * @return int
+     */
+    protected function getPackageDays()
+    {
+        return (int) round((time() - strtotime(DUPX_ArchiveConfig::getInstance()->created)) / 86400);
+    }
+
+    public function getTitle()
+    {
+        return 'Package Age';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/package-age', array(
+            'packageDays'    => $this->getPackageDays(),
+            'maxPackageDays' => self::PACKAGE_DAYS_BEFORE_WARNING,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/package-age', array(
+            'packageDays'    => $this->getPackageDays(),
+            'maxPackageDays' => self::PACKAGE_DAYS_BEFORE_WARNING,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.php.extensions.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\Utils\Log\Log;
+
+class DUPX_Validation_test_extensions extends DUPX_Validation_abstract_item
+{
+    /** @var array<string, mixed> */
+    public $extensionTests = array(
+        "json" => array(
+            "failLevel" => self::LV_FAIL,
+            "pass"      => false,
+        ),
+    );
+
+    protected function runTest()
+    {
+        $result = self::LV_GOOD;
+        foreach ($this->extensionTests as $extensionName => $extensionTest) {
+            $this->extensionTests[$extensionName]["pass"] = extension_loaded($extensionName);
+            if (!$this->extensionTests[$extensionName]["pass"]) {
+                Log::info("The '{$extensionName}' extension is not loaded.");
+                //update fail level
+                if ($extensionTest["failLevel"] < $result) {
+                    $result = $extensionTest["failLevel"];
+                }
+            }
+        }
+
+        return $result;
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Extensions';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-extensions', array(
+            'extensionTests' => $this->extensionTests,
+        ), false);
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-extensions', array(
+            'extensionTests' => $this->extensionTests,
+        ), false);
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-extensions', array(
+            'extensionTests' => $this->extensionTests,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-extensions', array(
+            'extensionTests' => $this->extensionTests,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.php.functionalities.php

@@ -0,0 +1,135 @@
+<?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\FunctionalityCheck;
+
+class DUPX_Validation_test_php_functionalities extends DUPX_Validation_abstract_item
+{
+    /** @var FunctionalityCheck[] */
+    protected $functionalities = array();
+
+    /**
+     * Class contructor
+     *
+     * @param string $category Category
+     */
+    public function __construct($category = '')
+    {
+        parent::__construct($category);
+        $this->functionalities = self::getFunctionalitiesCheckList();
+    }
+
+    protected function runTest()
+    {
+        if (FunctionalityCheck::checkList($this->functionalities)) {
+            return self::LV_PASS;
+        } elseif (FunctionalityCheck::checkList($this->functionalities, true)) {
+            return self::LV_HARD_WARNING;
+        } else {
+            return self::LV_FAIL;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Functions and Classes';
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-functionalities', array(
+            'functionalities' => $this->functionalities,
+            'testResult'      => $this->testResult,
+        ), false);
+    }
+
+    protected function passContent()
+    {
+        return $this->failContent();
+    }
+
+    protected function hwarnContent()
+    {
+        return $this->failContent();
+    }
+
+    /**
+     * Get list of functionalities to check
+     *
+     * @return FunctionalityCheck[]
+     */
+    protected static function getFunctionalitiesCheckList()
+    {
+        $result = [];
+
+        $archiveEngine = PrmMng::getInstance()->getValue(PrmMng::PARAM_ARCHIVE_ENGINE);
+
+        if ($archiveEngine == DUP_PRO_Extraction::ENGINE_ZIP || $archiveEngine == DUP_PRO_Extraction::ENGINE_ZIP_CHUNK) {
+            $result[] = new FunctionalityCheck(
+                FunctionalityCheck::TYPE_CLASS,
+                \ZipArchive::class,
+                true,
+                'https://www.php.net/manual/en/class.ziparchive.php',
+                '<i style="font-size:12px">'
+                    . '<a href="' . DUPX_Constants::FAQ_URL . 'how-to-work-with-the-different-zip-engines" target="_blank">'
+                    . 'Overview on how to enable ZipArchive</i></a>'
+            );
+        }
+
+        $result[] = new FunctionalityCheck(
+            FunctionalityCheck::TYPE_FUNCTION,
+            'json_encode',
+            true,
+            'https://www.php.net/manual/en/function.json-encode.php'
+        );
+
+        $functionality = new FunctionalityCheck(
+            FunctionalityCheck::TYPE_FUNCTION,
+            'token_get_all',
+            false,
+            'https://www.php.net/manual/en/function.token-get-all',
+            "Required for parsing the contents of the wp-config.php file. "
+                . "If test failed, to avoid problems during the installation the handling of the wp-config.php "
+                . "file has been disabled (the setting 'Wordpress wp-config.php' under Advanced Mode > Options > "
+                . "Advanced > Configuration files has been set to 'Do nothing'.)"
+        );
+        $functionality->setFailCallback(function (FunctionalityCheck $item) {
+            PrmMng::getInstance()->setValue(PrmMng::PARAM_WP_CONFIG, 'nothing');
+            PrmMng::getInstance()->save();
+        });
+        $result[] = $functionality;
+
+        $result[] = new FunctionalityCheck(
+            FunctionalityCheck::TYPE_FUNCTION,
+            'file_get_contents',
+            true,
+            'https://www.php.net/manual/en/function.file-get-contents.php'
+        );
+        $result[] = new FunctionalityCheck(
+            FunctionalityCheck::TYPE_FUNCTION,
+            'file_put_contents',
+            true,
+            'https://www.php.net/manual/en/function.file-put-contents.php'
+        );
+        $result[] = new FunctionalityCheck(
+            FunctionalityCheck::TYPE_FUNCTION,
+            'mb_strlen',
+            true,
+            'https://www.php.net/manual/en/mbstring.installation.php'
+        );
+
+        return $result;
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.php.version.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
+ */
+
+use Duplicator\Installer\Core\InstState;
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+class DUPX_Validation_test_php_version extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        $archiveConfig = DUPX_ArchiveConfig::getInstance();
+        if ($archiveConfig->isDBOnly()) {
+            return self::LV_GOOD;
+        }
+
+        // compare only major version ex 5 and 7 not 5.6 and 5.5
+        if (intval($archiveConfig->version_php) === intval(phpversion())) {
+            return self::LV_GOOD;
+        } elseif (InstState::isImportFromBackendMode()) {
+            return self::LV_HARD_WARNING;
+        } else {
+            return self::LV_SOFT_WARNING;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Version Mismatch';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-version', array(
+            'fromPhp' => DUPX_ArchiveConfig::getInstance()->version_php,
+            'toPhp'   => phpversion(),
+            'isOk'    => false,
+        ), false);
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-version', array(
+            'fromPhp' => DUPX_ArchiveConfig::getInstance()->version_php,
+            'toPhp'   => phpversion(),
+            'isOk'    => false,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/php-version', array(
+            'fromPhp' => DUPX_ArchiveConfig::getInstance()->version_php,
+            'toPhp'   => phpversion(),
+            'isOk'    => true,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.recovery.link.php

@@ -0,0 +1,92 @@
+<?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_recovery extends DUPX_Validation_abstract_item
+{
+    /** @var array<string, mixed> */
+    protected $importSiteInfo = array();
+    /** @var bool */
+    protected $recoveryPage = false;
+    /** @var bool */
+    protected $importPage = false;
+    /** @var bool */
+    protected $recoveryIsOutToDate = false;
+    /** @var int */
+    protected $recoveryPackageLife = -1;
+
+    protected function runTest()
+    {
+        $paramsManager = PrmMng::getInstance();
+        if (!InstState::isImportFromBackendMode()) {
+            return self::LV_SKIP;
+        }
+        $this->importSiteInfo      = PrmMng::getInstance()->getValue(PrmMng::PARAM_FROM_SITE_IMPORT_INFO);
+        $this->importPage          = $this->importSiteInfo['import_page'];
+        $this->recoveryPage        = $this->importSiteInfo['recovery_page'];
+        $this->recoveryIsOutToDate = $this->importSiteInfo['recovery_is_out_to_date'];
+        $this->recoveryPackageLife = $this->importSiteInfo['recovery_package_life'];
+
+        $recoveryLink = $paramsManager->getValue(PrmMng::PARAM_RECOVERY_LINK);
+        if (empty($recoveryLink)) {
+            return self::LV_HARD_WARNING;
+        } else {
+            if ($this->importSiteInfo['recovery_is_out_to_date']) {
+                return self::LV_SOFT_WARNING;
+            } else {
+                return self::LV_GOOD;
+            }
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'Disaster Recovery';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/recovery', array(
+            'testResult'          => $this->testResult,
+            'importPage'          => $this->importPage,
+            'recoveryPage'        => $this->recoveryPage,
+            'recoveryIsOutToDate' => $this->recoveryIsOutToDate,
+            'recoveryPackageLife' => $this->recoveryPackageLife,
+        ), false);
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/recovery', array(
+            'testResult'          => $this->testResult,
+            'importPage'          => $this->importPage,
+            'recoveryPage'        => $this->recoveryPage,
+            'recoveryIsOutToDate' => $this->recoveryIsOutToDate,
+            'recoveryPackageLife' => $this->recoveryPackageLife,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/recovery', array(
+            'testResult'          => $this->testResult,
+            'importPage'          => $this->importPage,
+            'recoveryPage'        => $this->recoveryPage,
+            'recoveryIsOutToDate' => $this->recoveryIsOutToDate,
+            'recoveryPackageLife' => $this->recoveryPackageLife,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.replace.paths.php

@@ -0,0 +1,63 @@
+<?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_replace_paths extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $message = '';
+
+    protected function runTest()
+    {
+        $paramsManager = PrmMng::getInstance();
+
+        if (
+            $paramsManager->getValue(PrmMng::PARAM_REPLACE_ENGINE) === DUPX_S3_Funcs::MODE_SKIP ||
+            $paramsManager->getValue(PrmMng::PARAM_SKIP_PATH_REPLACE) === false
+        ) {
+            return self::LV_SKIP;
+        }
+
+        $archivePaths = DUPX_ArchiveConfig::getInstance()->getRealValue("archivePaths");
+        if (strlen($archivePaths->home) == 0) {
+            // if new path is equal at old path the replace isn't necessary so skip message
+            if (strlen($paramsManager->getValue(PrmMng::PARAM_PATH_NEW)) === 0) {
+                return self::LV_SKIP;
+            }
+
+            $this->message = "It was found that the home path of the source was equal to '/'. In this case it's" .
+                " impossible to automatically replace paths, because of that path replacements have been disabled.";
+        }
+
+        return self::LV_HARD_WARNING;
+    }
+
+    public function getTitle()
+    {
+        return 'Replace PATHs in database';
+    }
+
+    protected function hwarnContent()
+    {
+        return dupxTplRender(
+            'parts/validation/tests/replace-paths',
+            array(
+                "message" => $this->message,
+                "isOk"    => false,
+            ),
+            false
+        );
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.rest.api.php

@@ -0,0 +1,78 @@
+<?php
+
+/**
+ * Validation object
+ *
+ * Standard: PSR-2
+ *
+ * @link http://www.php-fig.org/psr/psr-2 Full Documentation
+ *
+ * @package SC\DUPX\U
+ */
+
+use Duplicator\Installer\Core\InstState;
+use Duplicator\Installer\Core\Params\PrmMng;
+use Duplicator\Installer\REST\RESTPoints;
+
+defined('ABSPATH') || defined('DUPXABSPATH') || exit;
+
+
+class DUPX_Validation_test_rest_api extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    protected $errorMessage = '';
+    /** @var string */
+    protected $restUrl = '';
+
+    protected function runTest()
+    {
+        if (!InstState::isAddSiteOnMultisite()) {
+            return self::LV_SKIP;
+        }
+
+        $overwriteData = PrmMng::getInstance()->getValue(PrmMng::PARAM_OVERWRITE_SITE_DATA);
+        if (is_array($overwriteData) && isset($overwriteData['restUrl']) && strlen($overwriteData['restUrl']) > 0) {
+            $this->restUrl = $overwriteData['restUrl'];
+        } else {
+            $this->restUrl = PrmMng::getInstance()->getValue(PrmMng::PARAM_URL_NEW) . '/wp-json';
+        }
+
+
+        $this->errorMessage = "REST API call to WordPress backend failed";
+        if (RESTPoints::getInstance()->checkRest(true, $this->errorMessage)) {
+            return self::LV_PASS;
+        }
+
+        return self::LV_FAIL;
+    }
+
+    public function getTitle()
+    {
+        return 'REST API test';
+    }
+
+    protected function passContent()
+    {
+        return dupxTplRender(
+            'parts/validation/tests/rest-api',
+            array(
+                "isOk"    => true,
+                "restUrl" => $this->restUrl,
+            ),
+            false
+        );
+    }
+
+    protected function failContent()
+    {
+        return dupxTplRender(
+            'parts/validation/tests/rest-api',
+            array(
+                "isOk"         => false,
+                "errorMessage" => $this->errorMessage,
+                "restUrl"      => $this->restUrl,
+            ),
+            false
+        );
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.siteground.php

@@ -0,0 +1,35 @@
+<?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_siteground extends DUPX_Validation_abstract_item
+{
+    protected function runTest()
+    {
+        if (!DUPX_Custom_Host_Manager::getInstance()->isHosting(DUPX_Custom_Host_Manager::HOST_SITEGROUND)) {
+            return self::LV_SKIP;
+        }
+
+        return self::LV_SOFT_WARNING;
+    }
+
+    public function getTitle()
+    {
+        return 'Siteground';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/siteground', array(), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.timeout.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;
+
+class DUPX_Validation_test_timeout extends DUPX_Validation_abstract_item
+{
+    const MAX_TIME_SIZE = 314572800;  //300MB
+
+    /** @var bool|int */
+    protected $maxTimeZero = false;
+
+    protected function runTest()
+    {
+        $max_time_ini      = ini_get('max_execution_time');
+        $this->maxTimeZero = ($GLOBALS['DUPX_ENFORCE_PHP_INI']) ? false : @set_time_limit(0);
+
+        if ((is_numeric($max_time_ini) && $max_time_ini < 31 && $max_time_ini > 0) && DUPX_Conf_Utils::archiveSize() > self::MAX_TIME_SIZE) {
+            return self::LV_SOFT_WARNING;
+        } else {
+            return self::LV_GOOD;
+        }
+    }
+
+    public function getTitle()
+    {
+        return 'PHP Timeout';
+    }
+
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/timeout', array(
+            'maxTimeZero' => $this->maxTimeZero,
+            'maxTimeIni'  => ini_get('max_execution_time'),
+            'archiveSize' => DUPX_U::readableByteSize(DUPX_Conf_Utils::archiveSize()),
+            'maxSize'     => DUPX_U::readableByteSize(self::MAX_TIME_SIZE),
+            'isOk'        => true,
+        ), false);
+    }
+
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/timeout', array(
+            'maxTimeZero' => $this->maxTimeZero,
+            'maxTimeIni'  => ini_get('max_execution_time'),
+            'archiveSize' => DUPX_U::readableByteSize(DUPX_Conf_Utils::archiveSize()),
+            'maxSize'     => DUPX_U::readableByteSize(self::MAX_TIME_SIZE),
+            'isOk'        => true,
+        ), false);
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.wordfence.php

@@ -0,0 +1,138 @@
+<?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\LogHandler;
+use Duplicator\Installer\Core\Params\PrmMng;
+use Duplicator\Libs\Snap\SnapIO;
+
+class DUPX_Validation_test_wordfence extends DUPX_Validation_abstract_item
+{
+    /** @var string */
+    private $wordFencePath = "";
+
+    protected function runTest()
+    {
+        return $this->parentHasWordfence() ? self::LV_HARD_WARNING : self::LV_GOOD;
+    }
+
+    /**
+     * Get test title
+     *
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Wordfence';
+    }
+
+    /**
+     * Return content for test status
+     *
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/wordfence/wordfence-detected', array(
+            'wordFencePath' => $this->wordFencePath,
+        ), false);
+    }
+
+    /**
+     * Return content for test status
+     *
+     * @return string
+     */
+    protected function hwarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/wordfence/wordfence-detected', array(
+            'wordFencePath' => $this->wordFencePath,
+        ), false);
+    }
+
+    /**
+     * Return content for test status
+     *
+     * @return string
+     */
+    protected function goodContent()
+    {
+        return dupxTplRender('parts/validation/tests/wordfence/wordfence-not-detected', array(), false);
+    }
+
+    /**
+     * Check if the Wordfence firewall is enabled in the parent path
+     *
+     * @return bool
+     */
+    protected function parentHasWordfence()
+    {
+        $scanPath = PrmMng::getInstance()->getValue(PrmMng::PARAM_PATH_NEW);
+        $rootPath = SnapIO::getMaxAllowedRootOfPath($scanPath);
+        $result   = false;
+
+        if ($rootPath === false) {
+            //$scanPath is not contained in open_basedir paths skip
+            return false;
+        }
+
+        LogHandler::setMode(LogHandler::MODE_OFF);
+        $continueScan = true;
+        while ($continueScan) {
+            if ($this->wordFenceFirewallEnabled($scanPath)) {
+                $this->wordFencePath = $scanPath;
+                $result              = true;
+                break;
+            }
+            $continueScan = $scanPath !== $rootPath && $scanPath != dirname($scanPath);
+            $scanPath     = dirname($scanPath);
+        }
+        LogHandler::setMode();
+
+        return $result;
+    }
+
+    /**
+     * Check if the Wordfence firewall is enabled in the given path
+     *
+     * @param string $path The path to check
+     *
+     * @return bool
+     */
+    protected function wordFenceFirewallEnabled($path)
+    {
+        $configFiles = array(
+            'php.ini',
+            '.user.ini',
+            '.htaccess',
+        );
+
+        foreach ($configFiles as $configFile) {
+            $file = $path . '/' . $configFile;
+
+            if (!@is_readable($file)) {
+                continue;
+            }
+
+            if (($content = @file_get_contents($file)) === false) {
+                continue;
+            }
+
+            if (strpos($content, 'wordfence-waf.php') !== false) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}

wp-content/plugins/duplicator-pro-v4.5.16.2/installer/dup-installer/classes/validation/tests/class.validation.test.wp.config.php

@@ -0,0 +1,63 @@
+<?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\Deploy\ServerConfigs;
+use Duplicator\Installer\Core\InstState;
+
+class DUPX_Validation_test_wp_config extends DUPX_Validation_abstract_item
+{
+    /**
+     * @return int
+     * @throws Exception
+     */
+    protected function runTest()
+    {
+        if (!InstState::isClassicInstall()) {
+            return self::LV_SKIP;
+        }
+
+        if (DUPX_WPConfig::isSourceWpConfigValid()) {
+            return self::LV_PASS;
+        } else {
+            return self::LV_SOFT_WARNING;
+        }
+    }
+
+    /**
+     * @return string
+     */
+    public function getTitle()
+    {
+        return 'Wordpress Configuration';
+    }
+
+    /**
+     * @return string
+     */
+    protected function swarnContent()
+    {
+        return dupxTplRender('parts/validation/tests/wp-config-check', array(
+            'testResult' => $this->testResult,
+            'configPath' => ServerConfigs::getSourceWpConfigPath(),
+        ), false);
+    }
+
+    /**
+     * @return string
+     */
+    protected function passContent()
+    {
+        return $this->swarnContent();
+    }
+}