Sunnysideup\MigrateData\Traits\HelperMethods

Complexity

Total Complexity

47

Size/Duplication

Total Lines	246
Duplicated Lines	0 %

Importance

Changes	21
Bugs	0	Features	0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	clearTable()	0	3	1
A	dropTable()	0	5	1
A	renameTable()	0	18	5
A	makeTableObsolete()	0	15	4
A	replaceTable()	0	16	6
A	runSQLQueries()	0	6	3
B	runPublishClasses()	0	29	7
A	runUpdateQuery()	0	11	2
A	tableExists()	0	5	1
A	deleteObject()	0	13	3
A	getSchema()	0	10	2
A	getSchemaForDataObject()	0	7	2
A	writeObject()	0	11	2
A	getListOfIDs()	0	4	1
A	getListAsIterableQuery()	0	16	3
A	renameField()	0	3	1
A	writePage()	0	3	1
A	fieldExists()	0	9	2

<?php

namespace Sunnysideup\MigrateData\Traits;

use Exception;
use SilverStripe\ORM\DataObject;
use SilverStripe\ORM\DB;
use SilverStripe\ORM\Queries\SQLSelect;
use SilverStripe\Versioned\Versioned;

The type SilverStripe\Versioned\Versioned was not found. Maybe you did not declare it correctly or list all dependencies?

use Sunnysideup\Flush\FlushNow;
use Sunnysideup\Flush\FlushNowImplementor;

trait HelperMethods
{
    use FlushNow;

    public function deleteObject($obj)
    {
        if ($obj->exists()) {
            FlushNowImplementor::do_flush('DELETING ' . $obj->ClassName . '.' . $obj->ID, 'deleted');
            if ($obj->hasExtension(Versioned::class)) {
                $obj->DeleteFromStage(Versioned::LIVE);
                $obj->DeleteFromStage(Versioned::DRAFT);
            } else {
                $obj->delete();
            }
            @$obj->flushCache();

It seems like you do not handle an error condition for flushCache(). This can introduce security issues, and is generally not recommended.

        } else {
            FlushNowImplementor::do_flush('DOES NOT EXIST', 'added');
        }
    }

    /**
     * @param array  $queries list of queries
     * @param string $name    what is this list about?
     */
    protected function runSQLQueries($queries, $name = 'UPDATE QUERIES')
    {
        if ([] !== $queries) {
            $this->flushNow('<h3>Performing ' . $name . ' Queries</h3>');
            foreach ($queries as $sqlQuery) {
                $this->runUpdateQuery($sqlQuery);
            }
        }
    }

    /**
     * @param string $sqlQuery list of queries
     * @param int    $indents  what is this list about?
     */
    protected function runUpdateQuery(string $sqlQuery, ?int $indents = 1)
    {
        $this->flushNow(str_replace('"', '`', $sqlQuery), 'created');
        $prefix = str_repeat(' ... ', $indents);

It seems like $indents can also be of type null; however, parameter $times of str_repeat() does only seem to accept integer, maybe add an additional type check?

        try {
            DB::query($sqlQuery);
            $this->flushNow($prefix . ' DONE ' . DB::affected_rows() . ' rows affected');
        } catch (Exception $exception) {
            $this->flushNow($prefix . "ERROR: Unable to run '{$sqlQuery}'", 'deleted');
            $this->flushNow('' . $exception->getMessage() . '', 'deleted');
        }
    }

    /**
     * @param array $publishClasses list of class names to write / publish
     */
    protected function runPublishClasses(array $publishClasses)
    {
        if ([] !== $publishClasses) {
            $this->flushNow('<h3>Publish classes</h3>');
            foreach ($publishClasses as $publishClass) {
                $this->flushNow('<h6>Publishing ' . $publishClass . '</h6>');

                try {
                    $count = 0;
                    $publishItems = $publishClass::get();
                    foreach ($publishItems as $publishItem) {
                        ++$count;
                        $this->flushNow(
                            'Publishing ' . $count . ' of ' . $publishItems->count() .
                                ' ' .
                                $publishClass .
                                ' item' . (1 === $publishItems->exists() ? '' : 's') . '.'
                        );
                        $publishItem->write();
                        if ($publishItem->hasMethod('publishRecursive')) {
                            $publishItem->publishRecursive();
                            $this->flushNow('... DONE - PUBLISHED');
                        } else {
                            $this->flushNow('... DONE - WRITE ONLY');
                        }
                    }
                } catch (Exception $e) {
                    $this->flushNow('Unable to publish ' . $publishClass . '', 'error');
                    $this->flushNow('' . $e->getMessage() . '', 'error');
                }
            }
        }
    }

    protected function makeTableObsolete(string $tableName, ?bool $doEvenIfAlreadyObsolete = false): bool
    {
        $schema = $this->getSchema();
        if ($this->tableExists($tableName)) {
            if (!$this->tableExists('_obsolete_' . $tableName) || $doEvenIfAlreadyObsolete) {
                $schema->dontRequireTable($tableName);

                return true;
            }
            $this->flushNow('Table ' . $tableName . ' is already obsolete');
        } else {
            $this->flushNow('Table ' . $tableName . ' does not exist.');
        }

        return false;
    }

    protected function tableExists(string $tableName): bool
    {
        $schema = $this->getSchema();

        return (bool) $schema->hasTable($tableName);
    }

    protected function clearTable(string $tableName)
    {
        DB::get_conn()->clearTable($tableName);
    }

    protected function replaceTable(string $a, string $b, ?bool $keepBackup = false)
    {
        if ($this->tableExists($a)) {
            if ($this->tableExists($b)) {
                $itemsInDB = DB::query('SELECT DISTINCT ID FROM  ' . stripslashes($b) . ';');
                if ($itemsInDB->numRecords() > 0 && $keepBackup) {
                    $this->makeTableObsolete($b, true);
                    $this->flushNow('Backing up ' . $b, 'deleted');
                }
                $this->dropTable($b);
            }

            if (!$this->tableExists($b)) {
                $this->renameTable($a, $b);
            } else {
                $this->flushNow('Could not delete ' . $b, 'deleted');
            }
        }
    }

    /**
     * delete the table both with and without slashes.
     */
    protected function dropTable(string $tableName)
    {
        $this->flushNow('Deleting ' . $tableName, 'deleted');
        DB::query('DROP TABLE IF EXISTS "' . $tableName . '";');
        DB::query('DROP TABLE IF EXISTS "' . stripslashes($tableName) . '";');
    }

    protected function renameTable(string $a, string $b)
    {
        $this->flushNow('Moving "' . $a . '" to "' . $b . '"', 'warning');
        if (!$this->tableExists($a)) {
            $this->flushNow(' -- Could not find "' . $a . '", consider using replaceTable', 'deleted');

            return;
        }
        if ($this->tableExists($b)) {
            $this->flushNow(' -- Destination table already exists "' . $b . '", consider using replaceTable', 'deleted');

            return;
        }
        if (false !== strpos($a, '\\') || false !== strpos($b, '\\')) {
            $this->flushNow('Special slashes case "' . $a . '" to "' . $b . '"', 'warning');
            DB::query('ALTER TABLE "' . stripslashes($a) . '" RENAME "' . stripslashes($b) . '"');
        } else {
            $this->getSchema()->renameTable($a, $b);
        }
    }

    protected function fieldExists(string $tableName, string $fieldName): bool
    {
        $key = $tableName;
        if (!isset($this->_cacheFieldExists[$key])) {
            $schema = $this->getSchema();
            $this->_cacheFieldExists[$key] = $schema->fieldList($tableName);

The property _cacheFieldExists does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->_cacheFieldExists[$key][$fieldName] ?? false;
    }

    protected function renameField(string $table, string $oldFieldName, string $newFieldName)
    {
        $this->getSchema()->dontRequireField($table, $oldFieldName, $newFieldName);
    }

    protected function getSchema()
    {
        if (null === $this->_schema) {
            $this->_schema = DB::get_schema();

The property _schema does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

            $this->_schema->schemaUpdate(function () {
                return true;
            });
        }

        return $this->_schema;
    }

    protected function getSchemaForDataObject()
    {
        if (null === $this->_schemaForDataObject) {
            $this->_schemaForDataObject = DataObject::getSchema();

The property _schemaForDataObject does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->_schemaForDataObject;
    }

    protected function getListOfIDs(string $tableName, ?array $leftJoin = [], ?string $where = '')

The parameter $where is not used and could be removed.

The parameter $leftJoin is not used and could be removed.

    {
        return $this->getListAsIterableQuery($tableName, $leftJoin = [], $where = '')
            ->keyedColumn('ID');

The call to SilverStripe\ORM\Connect\Query::keyedColumn() has too many arguments starting with 'ID'.

    }

    protected function getListAsIterableQuery(string $tableName, ?array $leftJoin = [], ?string $where = '')
    {
        $sqlSelect = new SQLSelect();
        $sqlSelect->setFrom($tableName);

        if ($leftJoin) {

The expression $leftJoin of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $sqlSelect->addLeftJoin($leftJoin['table'], $leftJoin['onPredicate']);
        }

        if ($where) {
            $sqlSelect->addWhere($where);
        }

        $sqlSelect->setOrderBy($tableName . '.ID');

        return $sqlSelect->execute();
    }

    protected function writeObject($obj, ?array $row = [], ?bool $isPage = false)

The parameter $isPage is not used and could be removed.

The parameter $row is not used and could be removed.

    {
        DataObject::Config()->set('validation_enabled', false);
        if ($obj->hasMethod('writeToStage')) {
            $obj->writeToStage(Versioned::DRAFT);
            $obj->copyVersionToStage(Versioned::DRAFT, Versioned::LIVE);
            $obj->publishRecursive();
        } else {
            $obj->write();
        }
        $obj->flushCache();
    }

    protected function writePage($obj, $row)
    {
        return $this->writeObject($obj, $row, $isPage = true);

Are you sure the usage of $this->writeObject($obj, $row, $isPage = true) targeting Sunnysideup\MigrateData\Traits\HelperMethods::writeObject() seems to always return null.

    }
}