Collection::handler() - Code Metrics - Inspection of "Fixed travis tests" - samsoncms/api - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Push — master ( 8e26dc...2fb1c1 )

by Vitaly
created 2016-02-11 10:19 UTC
Collection::handler() A

↳ Parent: Collection
Complexity

Conditions	1
Paths	1
Size

Total Lines	7
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Metric	Value
dl	0
loc	7
rs	9.4285
cc	1
eloc	3
nc	1
nop	2
<?php
/**
 * Created by PhpStorm.
 * User: egorov
 * Date: 26.12.2014
 * Time: 16:22
 */
namespace samsoncms\api;

use samsonframework\orm\Condition;
use samsonframework\collection\Paged;
use samsonframework\orm\Relation;
use samsonframework\pager\PagerInterface;
use samsonframework\core\RenderInterface;
use samsonframework\orm\QueryInterface;

/**
 * Collection query builder for filtering
 * @package samsonos\cms\collection
 * @author Egorov Vitaly <[email protected]>
 * @deprecated Use generated Entities and EntityQueries classes.
 */
class Collection extends Paged
{
    /** @var string Entity manager instance */
    protected $managerEntity = '\samsoncms\api\query\Generic';

    /** @var array Collection for current filtered material identifiers */
    protected $materialIDs = array();

    /** @var array Collection of navigation filters */
    protected $navigation = array();

    /** @var array Collection of field filters */
    protected $field = array();

    /** @var array Collection of query handlers */
    protected $idHandlers = array();

    /** @var array External material handler and params array */
    protected $entityHandlers = array();

    /** @var array Base material entity handler callbacks array */
    protected $baseEntityHandlers = array();

    /** @var string Collection entities class name */
    protected $entityName = 'samson\cms\CMSMaterial';

    /**
     * Generic collection constructor
     * @param RenderInterface $renderer View render object
     * @param QueryInterface $query Query object
     */
    public function __construct(RenderInterface $renderer, QueryInterface $query, PagerInterface $pager)
    {
        // Call parent initialization
        parent::__construct($renderer, $query->className('material'), $pager);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
    }

    /**
     * Render products collection block
     * @param string $prefix Prefix for view variables
     * @param array $restricted Collection of ignored keys
     * @return array Collection key => value
     */
    public function toView($prefix = null, array $restricted = array())
    {
        // Render pager and collection
        return array(
            $prefix.'html' => $this->render(),
            $prefix.'pager' => $this->pager->total > 1 ? $this->pager->toHTML() : ''
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}
        );
    }

    /**
     * Add external identifier filter handler
     * @param callback $handler
     * @param array $params
     * @return self Chaining
     */
    public function handler($handler, array $params = array())
    {
        // Add callback with parameters to array
        $this->idHandlers[] = array($handler, $params);

        return $this;
    }

    /**
     * Set external entity handler
     * @param callback $handler
     * @param array $params
     * @return self Chaining
     */
    public function baseEntityHandler($handler, array $params = array())
    {
        // Add callback with parameters to array
        $this->baseEntityHandlers[] = array($handler, $params);

        return $this;
    }

    /**
     * Set external entity handler
     * @param callback $handler
     * @param array $params
     * @return self Chaining
     */
    public function entityHandler($handler, array $params = array())
    {
        // Add callback with parameters to array
        $this->entityHandlers[] = array($handler, $params);

        return $this;
    }

    /**
     * Set collection sorter parameters
     * @param string|integer $field Field identifier or name
     * @param string $destination ASC|DESC
     * @return void
     */
    public function sorter($field, $destination = 'ASC')
    {
        /**@var \samson\activerecord\field $field */
        // TODO: Add ability to sort with entity fields
        if (in_array($field, \samson\activerecord\material::$_attributes)) {
            $this->sorter = array(
                'field' => $field,
                'name' => $field,
                'destination' => $destination
            );
        } else if ($this->isFieldObject($field)) {
            $this->sorter = array(
                'entity' => $field,
                'name' => $field->Name,
                'field' => in_array($field->Type, array(3, 7, 10)) ? 'numeric_value' : 'value',
                'destination' => $destination
            );
        }
    }

    /**
     * Filter collection using navigation entity or collection of them.
     * If collection of navigation Url or Ids is passed then this group will be
     * applied as single navigation filter to retrieve materials.
     *
     * @param string|integer|array $navigation Navigation URL or identifier for filtering
     * @return self Chaining
     */
    public function navigation($navigation)
    {
        // Do not allow empty strings
        if (!empty($navigation)) {
            // Create id or URL condition
            $idOrUrl = new Condition('OR');
            $idOrUrl->add('StructureID', $navigation)->add('Url', $navigation);

            /** @var array $navigationIds  */
            $navigationIds = null;
            if ($this->query->className('structure')->cond($idOrUrl)->fields('StructureID', $navigationIds)) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                // Store all retrieved navigation elements as navigation collection filter
                $this->navigation[] = $navigationIds;
            }
        }

        // Chaining
        return $this;
    }

    /**
     * Filter collection using additional field entity.
     *
     * @param string|integer|Field $field Additional field identifier or name
     * @param mixed $value Additional field value for filtering
     * @param string $relation Additional field relation for filtering
     * @return self Chaining
     */
    public function field($field, $value, $relation = Relation::EQUAL)
    {
        // Do not allow empty strings
        if ($this->isFieldObject($field)) {
            // Get field value column
            $valueField = in_array($field->Type, array(3, 7, 10)) ? 'numeric_value' : 'value';
			$valueField = $field->Type == 6 ? 'key_value' : $valueField;
			
            /** @var Condition $condition Ranged condition */
            $condition = new Condition('AND');

            // Add min value for ranged condition
            $condition->add($valueField, $value, $relation);

            // Store retrieved field element and its value as field collection filter
            $this->field[] = array($field, $condition);
        }

        // Chaining
        return $this;
    }

    /**
     * Filter collection using additional field entity values and LIKE relation.
     * If this method is called more then once, it will use materials, previously filtered by this method.
     *
     * @param string $search Search string
     * @return self Chaining
     */
    public function search($search)
    {
        // If input parameter is a string add it to search string collection
        if (isset($search{0})) {
            $this->search[] = $search;
        }

        // Chaining
        return $this;
    }

    /**
     * Filter collection of numeric field in range from min to max values
     * @param string|integer|Field $field Additional field identifier or name
     * @param integer $minValue Min value for range filter
     * @param integer $maxValue Max value for range filter
     * @return self Chaining
     */
    public function ranged($field, $minValue, $maxValue)
    {
        // Check input parameters and try to find field
        if (($minValue <= $maxValue) && $this->isFieldObject($field)) {
            // TODO: Remove integers from code, handle else
            // Only numeric fields are supported
            if (in_array($field->Type, array(3, 7, 10))) {
                /** @var Condition $condition Ranged condition */
                $condition = new Condition('AND');

                // Add min value for ranged condition
                $condition->add('numeric_value', $minValue, Relation::GREATER_EQ);

                // Add max value for ranged condition
                $condition->add('numeric_value', $maxValue, Relation::LOWER_EQ);

                // Store created condition
                $this->field[] = array($field, $condition);
            }
        }

        // Chaining
        return $this;
    }

    /**
     * Try to find additional field record
     * @param string|integer $field Additional field identifier or name
     * @return bool True if field record has been found
     */
    protected function isFieldObject(&$field)
    {
        // Do not allow empty strings
        if (!empty($field)) {
            // Create id or URL condition
            $idOrUrl = new Condition('OR');
            $idOrUrl->add('FieldID', $field)->add('Name', $field);

            // Perform query
            return $this->query->className('field')->cond($idOrUrl)->first($field);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
        }

        // Field not found
        return false;
    }

    /**
     * Try to get all material identifiers filtered by navigation
     * if no navigation filtering is set - nothing will happen.
     *
     * @param array $filteredIds Collection of filtered material identifiers
     * @return bool True if ALL navigation filtering succeeded or there was no filtering at all otherwise false
     */
    protected function applyNavigationFilter(& $filteredIds = array())

    {
        // Iterate all applied navigation filters
        foreach ($this->navigation as $navigation) {
            // Create navigation-material query
            $this->query->className('structurematerial')
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}

                ->cond('StructureID', $navigation)
                ->cond('Active', 1)
                ->group_by('MaterialID')
            ;

            if (isset($filteredIds)) {
                $this->query->cond('MaterialID', $filteredIds);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
            }

            // Perform request to get next portion of filtered material identifiers
            if (!$this->query->fields('MaterialID', $filteredIds)) {

                // This filter applying failed
                return false;
            }
        }

        // We have no navigation collection filters
        return true;
    }

    /**
     * Try to get all material identifiers filtered by additional field
     * if no field filtering is set - nothing will happen.
     *
     * @param array $filteredIds Collection of filtered material identifiers
     * @return bool True if ALL field filtering succeeded or there was no filtering at all otherwise false
     */
    protected function applyFieldFilter(& $filteredIds = array())

    {
        // Iterate all applied field filters
        foreach ($this->field as $field) {
            // Create material-field query
            $this->query->className('materialfield')
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                ->cond('FieldID', $field[0]->id)
                ->cond($field[1])
                ->group_by('MaterialID')
            ;

            if (isset($filteredIds)) {
                $this->query->cond('MaterialID', $filteredIds);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
            }

            // Perform request to get next portion of filtered material identifiers
            if (!$this->query->fields('MaterialID', $filteredIds)) {

                // This filter applying failed
                return false;
            }
        }

        // We have no field collection filters
        return true;
    }

    /**
     * Try to find all materials which have fields similar to search strings
     *
     * @param array $filteredIds Collection of filtered material identifiers
     * @return bool True if ALL field filtering succeeded or there was no filtering at all otherwise false
     */
    protected function applySearchFilter(& $filteredIds = array())
    {
        /** @var array $fields Variable to store all fields related to set navigation */
        $fields = array();
        /** @var array $navigationArray Array of set navigation identifiers */
        $navigationArray = array();
        /** @var array $fieldFilter Array of filtered material identifiers via materialfield table */
        $fieldFilter = array();
        /** @var array $materialFilter Array of filtered material identifiers via material table */
        $materialFilter = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

        // If there are at least one search string
        if (!empty($this->search)) {
            // Create array containing all navigation identifiers
            foreach ($this->navigation as $navigation) {
                // Navigation hook for searching action
                $navigation = is_array($navigation) ? $navigation : array($navigation);
                $navigationArray = array_merge($navigationArray, $navigation);
            }

            // Get all related fields
            $this->query->className('structurefield')
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                ->cond('StructureID', $navigationArray)
                ->group_by('FieldID')
                ->fields('FieldID', $fields);

            // Iterate over search strings
            foreach ($this->search as $searchString) {
                // Try to find search value in materialfield table
                $this->query->className('materialfield')
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                    ->cond('FieldID', $fields)
                    ->cond('MaterialID', $filteredIds)
                    ->cond('Value', '%' . $searchString . '%', Relation::LIKE)
                    ->cond('Active', 1)
                    ->group_by('MaterialID')
                    ->fields('MaterialID', $fieldFilter);

                // TODO: Add generic support for all native fields or their configuration
                // Condition to search in material table by Name and URL
                $materialCondition = new Condition('OR');
                $materialCondition->add('Name', '%' . $searchString . '%', Relation::LIKE)
                    ->add('Url', '%' . $searchString . '%', Relation::LIKE);


                // Try to find search value in material table
                $this->query->className('material')
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                    ->cond($materialCondition)
                    ->cond('Active', 1);

                // If we have not empty collection of filtering identifiers
                if (sizeof($filteredIds)) {
                    $this->query->cond('MaterialID', $filteredIds);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                }

                $materialFilter = $this->query->fields('MaterialID');

                // If there are no materials with specified conditions
                if (empty($materialFilter) && empty($fieldFilter)) {
                    // Filter applying failed
                    return false;
                } else {// Otherwise set filtered material identifiers
                    $filteredIds = array_unique(array_merge($materialFilter, $fieldFilter));
                }
            }
        }

        // We have no search collection filters
        return true;
    }

    /**
     * Apply all possible material filters
     * @param array $filteredIds Collection of material identifiers
     * @return bool True if ALL filtering succeeded or there was no filtering at all otherwise false
     */
    protected function applyFilter(& $filteredIds = array())
    {
        return $this->applyNavigationFilter($filteredIds)
            && $this->applyFieldFilter($filteredIds)
            && $this->applySearchFilter($filteredIds);
    }

    /**
     * Perform material identifiers collection sorting
     * @param array $materialIDs Variable to return sorted collection
     */
    protected function applyFieldSorter(&$materialIDs = array())
    {
        // Check if sorter is configured
        if (sizeof($this->sorter)) {
            // If we need to sort by entity additional field(column)
            if (!in_array($this->sorter['field'], \samson\activerecord\material::$_attributes)) {
                // Sort material identifiers by its additional fields
                $this->query->className('materialfield')
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
                    ->cond('FieldID', $this->sorter['entity']->id)
                    ->order_by($this->sorter['field'], $this->sorter['destination'])
                    ->cond('MaterialID', $materialIDs)
                    ->fields('MaterialID', $materialIDs);
            }
        }
    }

    /**
     * Call handlers stack
     * @param array $handlers Collection of callbacks with their parameters
     * @param array $params External parameters to pass to callback at first
     * @return bool True if all handlers succeeded
     */
    protected function callHandlers(& $handlers = array(), $params = array())
    {
        // Call external handlers
        foreach ($handlers as $handler) {
            // Call external handlers chain
            if (call_user_func_array(
                $handler[0],
                array_merge($params, $handler[1]) // Merge params and handler params
            ) === false) {
                // Stop - if one of external handlers has failed
                return false;
            }
        }

        return true;
    }

    /**
     * Perform filtering on base material entity
     * @param array $materialIDs Variable to return sorted collection
     */
    protected function applyBaseEntityFilter(& $materialIDs = array())
    {
        // TODO: Change this to new OOP approach
        $class = $this->entityName;

        // Configure query to base entity
        $this->query->className('samson\activerecord\material');
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}

        // Call base material entity handlers to prepare query
        $this->callHandlers($this->baseEntityHandlers, array(&$this->query));

        // Check if sorter is configured
        if (sizeof($this->sorter)) {
            // If we need to sort by entity own field(column)
            if (in_array($this->sorter['field'], $class::$_attributes)) {
                // Add material entity sorter
                $this->query->order_by($this->sorter['field'], $this->sorter['destination']);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
            }
        }

        // Perform main entity query
        $this->materialIDs = $this->query
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
            ->cond('Active', 1) // Remove deleted entities
            ->cond('system', 0) // Remove system entities
            ->cond($class::$_primary, $materialIDs) // Filter to current set
            ->fields($class::$_primary)
        ;
    }

    /**
     * Perform collection database retrieval using set filters
     *
     * @return self Chaining
     */
    public function fill()
    {
        // Clear current materials identifiers list
        $this->materialIDs = null;


        // TODO: Change this to new OOP approach
        $class = $this->entityName;

        // If no filters is set
        if (!sizeof($this->search) && !sizeof($this->navigation) && !sizeof($this->field)) {
            // Get all entity records identifiers
            $this->materialIDs = $this->query->cond('Active', 1)->cond('system', 0)->fields($class::$_primary);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
        }

        // Perform material filtering
        if ($this->applyFilter($this->materialIDs)) {
            // Now we have all possible material filters applied and final material identifiers collection

            // Store filtered collection size
            $this->count = sizeof($this->materialIDs);

            // Call material identifier handlers
            $this->callHandlers($this->idHandlers, array(&$this->materialIDs));

            // Perform base entity query for final filtering
            $this->applyBaseEntityFilter($this->materialIDs);

            // Perform sorting
            $this->applyFieldSorter($this->materialIDs);

            // Create count request to count pagination
            $this->pager->update(sizeof($this->materialIDs));


            // Cut only needed materials identifiers from array
            $this->materialIDs = array_slice($this->materialIDs, $this->pager->start, $this->pager->end);
interface SomeInterface { }
class SomeClass implements SomeInterface {
    public $a;
}

function someFunction(SomeInterface $object) {
    if ($object instanceof SomeClass) {
        $a = $object->a;
    }
}

            // Create final material query
            $this->query->className($this->entityName)->cond($class::$_primary, $this->materialIDs);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}

            // Call material query handlers
            $this->callHandlers($this->entityHandlers, array(&$this->query));

            // Add query sorter for showed page
            if (sizeof($this->sorter)) {
                $this->query->order_by($this->sorter['name'], $this->sorter['destination']);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements 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.
    }
}
            }

            // Return final filtered entity query result
            $this->collection = $this->query->exec();
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        } else { // Collection is empty

            // Clear current materials identifiers list
            $this->materialIDs = array();

            // Updated pagination
            $this->pager->update(sizeof($this->materialIDs));

        }

        // Chaining
        return $this;
    }
}

Push — master ( 8e26dc...2fb1c1 )

Collection::handler() A

Complexity

Size

Duplication

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

samsoncms / api

Push — master ( 8e26dc...2fb1c1 )

Collection::handler() A

Complexity

Size

Duplication

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
