Issues in DataIntegrityTest.php (master) - Issues in master - sunnysideup/silverstripe-dataintegritytests - Measure and Improve Code Quality continuously with Scrutinizer

Issues (62)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

code/DataIntegrityTest.php (19 issues)

Labels

Severity

www-data 19

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php


class DataIntegrityTest extends BuildTask
{


    /**
     * standard SS variable
     * @var String
     */
    protected $title = "Check Database Integrity";

    /**
     * standard SS variable
     * @var String
     */
    protected $description = "Go through all fields in the database and work out what fields are superfluous.";

    private static $warning = "are you sure - this step is irreversible! - MAKE SURE TO MAKE A BACKUP OF YOUR DATABASE BEFORE YOU CONFIRM THIS!";

    private static $test_array = array(
        "In SiteTree_Live but not in SiteTree" =>
        "SELECT SiteTree.ID, SiteTree.Title FROM SiteTree_Live RIGHT JOIN SiteTree ON SiteTree_Live.ID = SiteTree.ID WHERE SiteTree.ID IS NULL;",
        "ParentID does not exist in SiteTree" =>
            "SELECT SiteTree.ID, SiteTree.Title FROM SiteTree RIGHT JOIN SiteTree Parent ON SiteTree.ParentID = Parent.ID Where SiteTree.ID IS NULL and SiteTree.ParentID <> 0;",
        "ParentID does not exists in SiteTree_Live" =>
            "SELECT SiteTree_Live.ID, SiteTree_Live.Title FROM SiteTree_Live RIGHT JOIN SiteTree_Live Parent ON SiteTree_Live.ParentID = Parent.ID Where SiteTree_Live.ID IS NULL and SiteTree_Live.ParentID <> 0;",
    );

    private static $global_exceptions = array(
        "EditableFormField" => "Version",
        "EditableOption" => "Version",
        "OrderItem" => "Version"
    );

    /**
    *@param array = should be provided as follows: array("Member.UselessField1", "Member.UselessField2", "SiteTree.UselessField3")
    */
    private static $fields_to_delete = array();

    private static $allowed_actions = array(
        "obsoletefields" => "ADMIN",
        "deleteonefield" => "ADMIN",
        "deletemarkedfields" => "ADMIN",
        "deleteobsoletetables" => "ADMIN",
        "deleteallversions" => "ADMIN",
        "cleanupdb" => "ADMIN"
    );


    public function init()
    {
        //this checks security
        parent::init();
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
    }

    public function run($request)

    {
        ini_set('max_execution_time', 3000);
        if ($action = $request->getVar("do")) {
            $methodArray = explode("/", $action);
            $method = $methodArray[0];
            $allowedActions = Config::inst()->get("DataIntegrityTest", "allowed_actions");
            if (isset($allowedActions[$method])) {
                if ($method == "obsoletefields") {
                    $deletesafeones = $fixbrokendataobjects = $deleteall = false;
                    if (isset($_GET["deletesafeones"]) && $_GET["deletesafeones"]) {
                        $deletesafeones = true;
                    }
                    if (isset($_GET["fixbrokendataobjects"]) && $_GET["fixbrokendataobjects"]) {
                        $fixbrokendataobjects = true;
                    }
                    if (isset($_GET["deleteall"]) && $_GET["deleteall"]) {
                        $deleteall = true;
                    }
                    return $this->$method($deletesafeones, $fixbrokendataobjects, $deleteall);
                } else {
                    return $this->$method();
                }
            } else {
                user_error("could not find method: $method");
            }
        }
        $warning = Config::inst()->get("DataIntegrityTest", "warning");
        echo "<h2>Database Administration Helpers</h2>";
        echo "<p><a href=\"".$this->Link()."?do=obsoletefields\">Prepare a list of obsolete fields.</a></p>";
        echo "<p><a href=\"".$this->Link()."?do=obsoletefields&amp;deletesafeones=1\" onclick=\"return confirm('".$warning."');\">Prepare a list of obsolete fields and DELETE! obsolete fields without any data.</a></p>";
        echo "<p><a href=\"".$this->Link()."?do=obsoletefields&amp;fixbrokendataobjects=1\" onclick=\"return confirm('".$warning."');\">Fix broken dataobjects.</a></p>";
        echo "<p><a href=\"".$this->Link()."?do=obsoletefields&amp;deleteall=1\" onclick=\"return confirm('".$warning."');\">Delete all obsolete fields now!</a></p>";
        echo "<hr />";
        echo "<p><a href=\"".$this->Link()."?do=deletemarkedfields\" onclick=\"return confirm('".$warning."');\">Delete fields listed in _config.</a></p>";
        echo "<hr />";
        echo "<p><a href=\"".$this->Link()."?do=deleteobsoletetables\" onclick=\"return confirm('".$warning."');\">Delete all tables that are marked as obsolete</a></p>";
        echo "<hr />";
        echo "<p><a href=\"".$this->Link()."?do=deleteallversions\" onclick=\"return confirm('".$warning."');\">Delete all versioned data</a></p>";
        echo "<hr />";
        echo "<p><a href=\"".$this->Link()."?do=cleanupdb\" onclick=\"return confirm('".$warning."');\">Clean up Database (remove obsolete records)</a></p>";
        echo "<hr />";
        echo "<p><a href=\"/dev/tasks/DataIntegrityTestInnoDB/\" onclick=\"return confirm('".$warning."');\">Set all tables to innoDB</a></p>";
        echo "<p><a href=\"/dev/tasks/DataIntegrityTestUTF8/\" onclick=\"return confirm('".$warning."');\">Set all tables to utf-8</a></p>";
    }

    protected function Link()
    {
        return "/dev/tasks/DataIntegrityTest/";
    }

    protected function obsoletefields($deleteSafeOnes = false, $fixBrokenDataObject = false, $deleteAll = false)
    {
        increase_time_limit_to(600);
        $dataClasses = ClassInfo::subclassesFor('DataObject');
        $notCheckedArray = array();
        $canBeSafelyDeleted = array();
        //remove dataobject
        array_shift($dataClasses);
        $rows = DB::query("SHOW TABLES;");
        $actualTables = array();
        if ($rows) {
            foreach ($rows as $key => $item) {
                foreach ($item as $table) {
                    $actualTables[$table] = $table;
                }
            }
        }
        echo "<h1>Report of fields that may not be required.</h1>";
        echo "<p>NOTE: it may contain fields that are actually required (e.g. versioning or many-many relationships) and it may also leave out some obsolete fields.  Use as a guide only.</p>";
        foreach ($dataClasses as $dataClass) {
            // Check if class exists before trying to instantiate - this sidesteps any manifest weirdness
            if (class_exists($dataClass)) {
                $dataObject = $dataClass::create();
                if (!($dataObject instanceof TestOnly)) {
                    $requiredFields = $this->swapArray(DataObject::database_fields($dataObject->ClassName));
                    if (count($requiredFields)) {
                        foreach ($requiredFields as $field) {
                            if (!$dataObject->hasOwnTableDatabaseField($field)) {
                                DB::alteration_message("  **** $dataClass.$field DOES NOT EXIST BUT IT SHOULD BE THERE!", "deleted");
                            }
                        }
                        $actualFields = $this->swapArray(DB::fieldList($dataClass));

                        if ($actualFields) {

                            foreach ($actualFields as $actualField) {
                                if ($deleteAll) {
                                    $link = " !!!!!!!!!!! DELETED !!!!!!!!!";
                                } else {
                                    $warning = Config::inst()->get("DataIntegrityTest", "warning");
                                    $link = "<a href=\"".Director::absoluteBaseURL()."dev/tasks/DataIntegrityTest/?do=deleteonefield/".$dataClass."/".$actualField."/\" onclick=\"return confirm('".$warning."');\">delete field</a>";
                                }
                                if (!in_array($actualField, array("ID", "Version"))) {
                                    if (!in_array($actualField, $requiredFields)) {
                                        $distinctCount = DB::query("SELECT COUNT(DISTINCT \"$actualField\") FROM \"$dataClass\" WHERE \"$actualField\" IS NOT NULL AND \"$actualField\" <> '' AND \"$actualField\" <> '0';")->value();
                                        DB::alteration_message("<br /><br />\n\n$dataClass.$actualField $link - unique entries: $distinctCount", "deleted");
                                        if ($distinctCount) {
                                            $rows = DB::query("
                                                SELECT \"$actualField\" as N, COUNT(\"$actualField\") as C
                                                FROM \"$dataClass\"
                                                GROUP BY \"$actualField\"
                                                ORDER BY C DESC
                                                LIMIT 7");
                                            if ($rows) {
                                                foreach ($rows as $row) {
                                                    DB::alteration_message(" &nbsp; &nbsp; &nbsp; ".$row["C"].": ".$row["N"]);
                                                }
                                            }
                                        } else {
                                            if (!isset($canBeSafelyDeleted[$dataClass])) {
                                                $canBeSafelyDeleted[$dataClass] = array();
                                            }
                                            $canBeSafelyDeleted[$dataClass][$actualField] = "$dataClass.$actualField";
                                        }
                                        if ($deleteAll || ($deleteSafeOnes && $distinctCount == 0)) {
                                            $this->deleteField($dataClass, $actualField);
                                        }
                                    }
                                }
                                if ($actualField == "Version" && !in_array($actualField, $requiredFields)) {
                                    $versioningPresent = $dataObject->hasVersioning();
                                    if (!$versioningPresent) {
                                        DB::alteration_message("$dataClass.$actualField $link", "deleted");
                                        if ($deleteAll) {
                                            $this->deleteField($dataClass, $actualField);
                                        }
                                    }
                                }
                            }
                        }
                        $rawCount = DB::query("SELECT COUNT(\"ID\") FROM \"$dataClass\"")->value();
                        Versioned::set_reading_mode("Stage.Stage");
                        $realCount = 0;
                        $allSubClasses = array_unique(array($dataClass)+ClassInfo::subclassesFor($dataClass));
                        $objects = $dataClass::get()->filter(array("ClassName" =>  $allSubClasses));
                        if ($objects->count()) {
                            $realCount = $objects->count();
                        }
                        if ($rawCount != $realCount) {
                            echo "<hr />";
                            $sign = " > ";
                            if ($rawCount < $realCount) {
                                $sign = " < ";
                            }
                            DB::alteration_message("The DB Table Row Count does not seem to match the DataObject Count for <strong>$dataClass ($rawCount $sign $realCount)</strong>.  This could indicate an error as generally these numbers should match.", "deleted");
                            if ($fixBrokenDataObject) {
                                $objects = $dataClass::get()->where("LinkedTable.ID IS NULL")->leftJoin($dataClass, "$dataClass.ID = LinkedTable.ID", "LinkedTable");
                                if ($objects->count() > 500) {
                                    DB::alteration_message("It is recommended that you manually fix the difference in real vs object count in $dataClass. There are more than 500 records so it would take too long to do it now.", "deleted");
                                } else {
                                    DB::alteration_message("Now trying to recreate missing items... COUNT = ".$objects->count(), "created");
                                    foreach ($objects as $object) {
                                        if (DB::query("SELECT COUNT(\"ID\") FROM \"$dataClass\" WHERE \"ID\" = ".$object->ID.";")->value() != 1) {
                                            Config::inst()->update('DataObject', 'validation_enabled', false);
                                            $object->write(true, false, true, false);
                                            Config::inst()->update('DataObject', 'validation_enabled', true);
                                        }
                                    }
                                    $objectCount = $dataClass::get()->count();
                                    DB::alteration_message("Consider deleting superfluous records from table $dataClass .... COUNT =".($rawCount - $objectCount));
                                    $ancestors = ClassInfo::ancestry($dataClass, true);
                                    if ($ancestors && is_array($ancestors) && count($ancestors)) {

                                        foreach ($ancestors as $ancestor) {
                                            if ($ancestor != $dataClass) {
                                                echo "DELETE `$dataClass`.* FROM `$dataClass` LEFT JOIN `$ancestor` ON `$dataClass`.`ID` = `$ancestor`.`ID` WHERE `$ancestor`.`ID` IS NULL;";
                                                DB::query("DELETE `$dataClass`.* FROM `$dataClass` LEFT JOIN `$ancestor` ON `$dataClass`.`ID` = `$ancestor`.`ID` WHERE `$ancestor`.`ID` IS NULL;");
                                            }
                                        }
                                    }
                                }
                            }
                            echo "<hr />";
                        }
                        unset($actualTables[$dataClass]);
                    } else {
                        $db = DB::getConn();

                        if ($db->hasTable($dataClass)) {

                            DB::alteration_message("  **** The $dataClass table exists, but according to the data-scheme it should not be there ", "deleted");
                        } else {
                            $notCheckedArray[] = $dataClass;
                        }
                    }
                }
            }
        }

        if (count($canBeSafelyDeleted)) {
            DB::alteration_message("<h2>Can be safely deleted: </h2>");
            foreach ($canBeSafelyDeleted as $table => $fields) {
                DB::alteration_message($table.": ".implode(", ", $fields));
            }
        }

        if (count($notCheckedArray)) {
            echo "<h3>Did not check the following classes as no fields appear to be required and hence there is no database table.</h3>";
            foreach ($notCheckedArray as $table) {
                if (DB::query("SHOW TABLES LIKE '".$table."'")->value()) {

                    DB::alteration_message($table ." - NOTE: a table exists for this Class, this is an unexpected result", "deleted");
                } else {
                    DB::alteration_message($table, "created");
                }
            }
        }

        if (count($actualTables)) {
            echo "<h3>Other Tables in Database not directly linked to a Silverstripe DataObject:</h3>";
            foreach ($actualTables as $table) {
                $remove = true;
                if (class_exists($table)) {
                    $classExistsMessage = " a PHP class with this name exists.";
                    $obj = singleton($table);
                    //not sure why we have this.
                    if ($obj instanceof DataExtension) {
                        $remove = false;
                    } elseif (class_exists("Versioned") && $obj->hasExtension("Versioned")) {
                        $remove = false;
                    }
                } else {
                    $classExistsMessage = " NO PHP class with this name exists.";
                    if (substr($table, -5) == "_Live") {
                        $remove = false;
                    }
                    if (substr($table, -9) == "_versions") {
                        $remove = false;
                    }
                    //many 2 many tables...
                    if (strpos($table, "_")) {
                        $class = explode("_", $table);
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
                        $manyManyClass = substr($table, 0, strrpos($table, '_'));
                        $manyManyExtension = substr($table, strrpos($table, '_') + 1 - strlen($table));
                        if (class_exists($manyManyClass)) {
                            $manyManys = Config::inst()->get($manyManyClass, "many_many");
                            if (isset($manyManys[$manyManyExtension])) {
                                $remove = false;
                            }
                        }
                    }
                }
                if ($remove) {
                    if (substr($table, 0, strlen("_obsolete_")) != "_obsolete_") {
                        $rowCount = DB::query("SELECT COUNT(*) FROM $table")->value();
                        DB::alteration_message($table.", rows ".$rowCount);
                        $obsoleteTableName = "_obsolete_".$table;
                        if (!$this->tableExists($obsoleteTableName)) {
                            DB::alteration_message("We recommend deleting $table or making it obsolete by renaming it to ".$obsoleteTableName, "deleted");
                            if ($deleteAll) {
                                DB::getConn()->renameTable($table, $obsoleteTableName);

                            } else {
                                DB::alteration_message($table." - ".$classExistsMessage." It can be moved to _obsolete_".$table.".", "created");
                            }
                        } else {
                            DB::alteration_message("I'd recommend to move <strong>$table</strong> to <strong>".$obsoleteTableName."</strong>, but that table already exists", "deleted");
                        }
                    }
                }
            }
        }

        echo "<a href=\"".Director::absoluteURL("/dev/tasks/DataIntegrityTest/")."\">back to main menu.</a>";
    }



    public function deletemarkedfields()
    {
        $fieldsToDelete = Config::inst()->get("DataIntegrityTest", "fields_to_delete");
        if (is_array($fieldsToDelete)) {
            if (count($fieldsToDelete)) {
                foreach ($fieldsToDelete as $key => $tableDotField) {
                    $tableFieldArray = explode(".", $tableDotField);
                    $this->deleteField($tableFieldArray[0], $tableFieldArray[1]);
                }
            } else {
                DB::alteration_message("there are no fields to delete", "created");
            }
        } else {
            user_error("you need to select these fields to be deleted first (DataIntegrityTest.fields_to_delete)");
        }
        echo "<a href=\"".Director::absoluteURL("/dev/tasks/DataIntegrityTest/")."\">back to main menu.</a>";
    }

    public function deleteonefield()
    {
        $requestExploded = explode("/", $_GET["do"]);
        if (!isset($requestExploded[1])) {
            user_error("no table has been specified", E_USER_WARNING);
        }
        if (!isset($requestExploded[2])) {
            user_error("no field has been specified", E_USER_WARNING);
        }
        $table = $requestExploded[1];
        $field = $requestExploded[2];
        if ($this->deleteField($table, $field)) {
            DB::alteration_message("successfully deleted $field from $table now");
        } else {
            DB::alteration_message("COULD NOT delete $field from $table now", "deleted");
        }
        DB::alteration_message("<a href=\"".Director::absoluteURL("dev/tasks/DataIntegrityTest/?do=obsoletefields")."\">return to list of obsolete fields</a>", "created");
        echo "<a href=\"".Director::absoluteURL("/dev/tasks/DataIntegrityTest/")."\">back to main menu.</a>";
    }

    private function cleanupdb()
    {
        $obj = new DatabaseAdmin();
        $obj->cleanup();
        DB::alteration_message("============= COMPLETED =================", "");
        echo "<a href=\"".Director::absoluteURL("/dev/tasks/DataIntegrityTest/")."\">back to main menu.</a>";
    }

    private function deleteField($table, $field)
    {
        $fields = $this->swapArray(DB::fieldList($table));

        $globalExeceptions = Config::inst()->get("DataIntegrityTest", "global_exceptions");
        if (count($globalExeceptions)) {
            foreach ($globalExeceptions as $exceptionTable => $exceptionField) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
                if ($exceptionTable == $table && $exceptionField == $field) {
                    DB::alteration_message("tried to delete $table.$field but this is listed as a global exception and can not be deleted", "created");
                    return false;
                }
            }
        }
        if (!DB::query("SHOW TABLES LIKE '".$table."'")->value()) {

            DB::alteration_message("tried to delete $table.$field but TABLE does not exist", "deleted");
            return false;
        }
        if (!class_exists($table)) {
            DB::alteration_message("tried to delete $table.$field but CLASS does not exist", "deleted");
            return false;
        }
        if (!in_array($field, $fields)) {

            DB::alteration_message("tried to delete $table.$field but FIELD does not exist", "deleted");
            return false;
        } else {
            DB::alteration_message("Deleting $field in $table", "deleted");
            DB::query('ALTER TABLE "'.$table.'" DROP "'.$field.'";');
            $obj = singleton($table);
            //to do: make this more reliable - checking for versioning rather than SiteTree
            if ($obj instanceof SiteTree) {
                DB::query('ALTER TABLE "'.$table.'_Live" DROP "'.$field.'";');
                DB::alteration_message("Deleted $field in {$table}_Live", "deleted");
                DB::query('ALTER TABLE "'.$table.'_versions" DROP "'.$field.'";');
                DB::alteration_message("Deleted $field in {$table}_versions", "deleted");
            }
            return true;
        }
    }

    private function swapArray($array)
    {
        $newArray = array();
        if (is_array($array)) {
            foreach ($array as $key => $value) {
                $newArray[] = $key;
            }
        }
        return $newArray;
    }

    protected function hasVersioning($dataObject)
    {
        $versioningPresent = false;
        $array = $dataObject->stat('extensions');
        if (is_array($array) && count($array)) {
            if (in_array("Versioned('Stage', 'Live')", $array)) {
                $versioningPresent = true;
            }
        }
        if ($dataObject->stat('versioning')) {
            $versioningPresent = true;
        }
        return $versioningPresent;
    }


    private function deleteobsoletetables()
    {
        $tables = DB::query('SHOW tables');
        $unique = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($tables as $table) {
            $table = array_pop($table);
            if (substr($table, 0, 10) == "_obsolete_") {
                DB::alteration_message("Removing table $table", "deleted");
                DB::query("DROP TABLE \"$table\" ");
            }
        }
        echo "<a href=\"".Director::absoluteURL("/dev/tasks/DataIntegrityTest/")."\">back to main menu.</a>";
    }

    private function deleteallversions()
    {
        $tables = DB::query('SHOW tables');
        $unique = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        foreach ($tables as $table) {
            $table = array_pop($table);
            $endOfTable = substr($table, -9);
            if ($endOfTable == "_versions") {
                $className = substr($table, 0, strlen($table) - 9);
                if (class_exists($className)) {
                    $obj = DataObject::get_one($className);
                    if ($obj) {
                        if ($obj->hasExtension("Versioned")) {
                            DB::alteration_message("Removing all records from $table", "created");
                            DB::query("DELETE FROM \"$table\" ");
                        }
                    }
                } else {
                    DB::alteration_message("Could not find $className class... the $table may be obsolete", "deleted");
                }
            }
        }
        echo "<a href=\"".Director::absoluteURL("/dev/tasks/DataIntegrityTest/")."\">back to main menu.</a>";
    }

    private function tableExists($table)
    {
        $db = DB::getConn();

        return $db->hasTable($table);

    }
}


Issues (62)

Security Analysis not enabled

code/DataIntegrityTest.php (19 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

sunnysideup / silverstripe-dataintegritytests

Issues (62)

Security Analysis not enabled

code/DataIntegrityTest.php (19 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Available Fixes

Duplication Side-by-Side

Filter issues like