DbRepository - Code Metrics - Inspection of "Updated requirements" - lrc-se/bth-anax-repository - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 281d16...f910eb )

by LRC

created 2017-10-22 08:09 UTC

DbRepository B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	402
Duplicated Lines	8.46 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
wmc	53
lcom	1
cbo	5
dl	34
loc	402
ccs	168
cts	168
cp	1
rs	7.4757
c	0
b	0
f	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	getCollectionName()	0	4	1
A	getModelClass()	0	4	1
A	find()	0	4	2
B	getFirst()	15	15	5
B	getAll()	19	19	5
A	save()	0	8	2
A	delete()	0	8	1
A	count()	0	6	2
C	executeQuery()	0	25	8
C	populateModelFromJoin()	0	35	8
C	setupJoin()	0	56	10
A	prefixModelAttributes()	0	7	2
A	create()	0	9	1
A	update()	0	11	1
A	getMutableAttributes()	0	14	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like DbRepository often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use DbRepository, and based on these observations, apply Extract Interface, too.

<?php

namespace LRC\Repository;

/**
 * Base class for database-backed repositories for data access.
 *
 * @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
 */
class DbRepository extends ManagedRepository implements RepositoryInterface
{
    /**
     * @var \Anax\Database\DatabaseQueryBuilder     Database service.
     */
    protected $db;
    
    /**
     * @var string  Database table name.
     */
    protected $table;
    
    /**
     * @var string  Model class name.
     */
    protected $modelClass;
    
    /**
     * @var string  Primary key column.
     */
    protected $key;
    
    
    /**
     * Constructor.
     *
     * @param \Anax\Database\DatabaseQueryBuilder   $db         Database service.
     * @param string                                $table      Database table name.
     * @param string                                $modelClass Model class name.
     * @param string                                $key        Primary key column.
     */
    public function __construct($db, $table, $modelClass, $key = 'id')
    {
        $this->db = $db;
        $this->table = $table;
        $this->modelClass = $modelClass;
        $this->key = $key;
    }
    
    
    /**
     * Return the name of the database table represented by the repository.
     */
    public function getCollectionName()
    {
        return $this->table;
    }
    
    
    /**
     * Return the class of the model handled by the repository.
     */
    public function getModelClass()
    {
        return $this->modelClass;
    }
    
    
    /**
     * Find and return first entry by key.
     *
     * @param string|null   $column Key column name (pass null to use registered primary key).
     * @param mixed         $value  Key value.
     *
     * @return mixed                Model instance.
     */
    public function find($column, $value)
    {
        return $this->getFirst((is_null($column) ? $this->key : $column) . ' = ?', [$value]);
    }
    
    
    /**
     * Retrieve first entry, optionally filtered by search criteria.
     * 
     * @param string $conditions    Where conditions.
     * @param array  $values        Array of condition values to bind.
     * @param array  $options       Query options.
     * 
     * @return mixed                Model instance.
     */
    public function getFirst($conditions = null, $values = [], $options = [])

    {
        $query = $this->executeQuery(null, $conditions, $values, $options);
        if (!empty($this->fetchRefs)) {
            $res = $query->fetch();
            $model = ($res ? $this->populateModelFromJoin($res) : $res);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        } else {
            $model = $query->fetchClass($this->modelClass);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if ($model && isset($this->manager)) {
            $this->manager->manageModel($model);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }
        $this->fetchReferences(false);
        return $model;
    }
    
    
    /**
     * Retrieve all entries, optionally filtered by search criteria.
     * 
     * @param string $conditions    Where conditions.
     * @param array  $values        Array of condition values to bind.
     * @param array  $options       Query options.
     * 
     * @return array                Array of all matching entries.
     */
    public function getAll($conditions = null, $values = [], $options = [])

    {
        $query = $this->executeQuery(null, $conditions, $values, $options);
        if (!empty($this->fetchRefs)) {
            $models = [];
            foreach ($query->fetchAll() as $model) {
                $models[] = $this->populateModelFromJoin($model);
            }
        } else {
            $models = $query->fetchAllClass($this->modelClass);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }
        if (isset($this->manager)) {
            foreach ($models as $model) {
                $this->manager->manageModel($model);
            }
        }
        $this->fetchReferences(false);
        return $models;
    }
    
    
    /**
     * Save entry by inserting if ID is missing and updating if ID exists.
     * 
     * @param mixed $model  Model instance.
     *
     * @return void
     */
    public function save($model)
    {
        if (isset($model->{$this->key})) {
            return $this->update($model);
        }
        
        return $this->create($model);
    }
    
    
    /**
     * Delete entry.
     *
     * @param mixed $model  Model instance.
     */
    public function delete($model)
    {
        $this->db->connect()
            ->deleteFrom($this->table)
            ->where($this->key . ' = ?')
            ->execute([$model->{$this->key}]);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $model->{$this->key} = null;
    }
    
    
    /**
     * Count entries, optionally filtered by search criteria.
     *
     * @param string $conditions    Where conditions.
     * @param array  $values        Array of condition values to bind.
     * 
     * @return int                  Number of entries.
     */
    public function count($conditions = null, $values = [])
    {
        $res = $this->executeQuery('COUNT(' . $this->key . ') AS num', $conditions, $values)
            ->fetch();
        return (isset($res->num) ? (int)$res->num : 0);
    }
    
    
    /**
     * Execute query for selection methods.
     * 
     * @param   string  $select                     Selection criteria.
     * @param   string  $conditions                 Where conditions.
     * @param   array   $values                     Array of where condition values to bind.
     * @param   array   $options                    Query options.
     * 
     * @return \Anax\Database\DatabaseQueryBuilder  Database service instance with executed internal query.
     */
    protected function executeQuery($select = null, $conditions = null, $values = [], $options = [])
    {
        $query = $this->db->connect();
        if (!empty($this->fetchRefs)) {
            $query = $this->setupJoin($query, $select, $conditions, (isset($options['order']) ? $options['order'] : null));
        } else {
            $query = (!is_null($select) ? $query->select($select) : $query->select());
            $query = $query->from($this->table);
            if (!is_null($conditions)) {
                $query = $query->where($conditions);
            }
            if (isset($options['order'])) {
                $query = $query->orderBy($options['order']);
            }
        }
        
        if (isset($options['limit'])) {
            $query = $query->limit($options['limit']);
        }
        if (isset($options['offset'])) {
            $query = $query->offset($options['offset']);
        }
        
        return $query->execute($values);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
    
    
    
    /**
     * Populate model instance including retrieved references from join query result.
     * 
     * @param object $result    Query result.
     * 
     * @return mixed            Populated model instance.
     */
    protected function populateModelFromJoin($result)
    {
        // extract main model
        $model = new $this->modelClass();
        foreach (array_keys(get_object_vars($model)) as $attr) {
            $model->$attr = $result->$attr;
        }
        
        // extract referenced models
        $refs = $model->getReferences();
        $refs2 = (is_array($this->fetchRefs) ? $this->fetchRefs : array_keys($refs));
        sort($refs2);
        foreach ($refs2 as $idx => $name) {
            $prefix = "REF{$idx}_{$name}__";
            
            // handle null result
            if (is_null($result->{$prefix . $refs[$name]['key']})) {
                $refModel = null;
            } else {
                $refModel = new $refs[$name]['model']();
                foreach (array_keys(get_object_vars($refModel)) as $attr) {
                    $refModel->$attr = $result->{$prefix . $attr};
                }
            }
            
            // inject manager reference
            if ($refModel && $this->manager) {
                $this->manager->manageModel($refModel);
            }
            
            $model->$name = $refModel;
        }
        
        return $model;
    }
    

    /**
     * Set up join query for reference retrieval.
     *
     * @param \Anax\Database\DatabaseQueryBuilder   $query      Database service instance with initialized query.
     * @param string                                $select     Selection criteria.
     * @param string                                $conditions Where conditions.
     * @param string                                $order      Order by clause.
     *
     * @return \Anax\Database\DatabaseQueryBuilder              Database service instance with prepared join query.
     *
     * @SuppressWarnings(PHPMD.CyclomaticComplexity)
     * @SuppressWarnings(PHPMD.NPathComplexity)
     */
    private function setupJoin($query, $select, $conditions, $order = null)
    {
        // find references
        $model = new $this->modelClass();
        $refs = $model->getReferences();
        if (is_array($this->fetchRefs)) {
            $refs = array_intersect_key($refs, array_flip($this->fetchRefs));
        }
        ksort($refs);
        
        // prefix main model selection
        if (!is_null($select)) {
            $select = $this->prefixModelAttributes($select, $model);
        } else {
            $select = $this->table . '.*';
        }
        
        // set up reference aliases and join conditions
        $select = [$select];
        $join = [];
        $idx = 0;
        foreach ($refs as $name => $ref) {
            // prefix attributes
            $refTable = "REF{$idx}_{$name}";
            $idx++;
            foreach (array_keys(get_object_vars(new $ref['model']())) as $attr) {
                $select[] = "{$refTable}.{$attr} AS '{$refTable}__{$attr}'";
            }
            
            // generate join conditions
            $joinCond = $this->table . '.' . $ref['attribute'] . " = {$refTable}." . $ref['key'];
            $refRepo = $this->manager->getByClass($ref['model']);
            if ($this->softRefs && $refRepo instanceof SoftDbRepository) {
                $joinCond .= " AND $refTable." . $refRepo->getDeletedAttribute() . ' IS NULL';
            }
            $join[] = [$refRepo->getCollectionName() . " AS $refTable", $joinCond];
        }
        
        // generate join query
        $query = $query->select(implode(', ', $select))->from($this->table);
        foreach ($join as $args) {
            $query = $query->leftJoin(...$args);

        }
        
        // prefix where conditions
        if (!is_null($conditions)) {
            $query = $query->where($this->prefixModelAttributes($conditions, $model));
        }
        
        // prefix order by clause
        if (!is_null($order)) {
            $query = $query->orderBy($this->prefixModelAttributes($order, $model));
        }
        
        return $query;
    }
    
    
    /**
     * Prefix model attributes with the associated table name.
     * 
     * @param string $input     Input string.
     * @param object $model     Model instance.
     * 
     * @return string           String with table-prefixed attributes.
     */
    private function prefixModelAttributes($input, $model)
    {
        foreach (array_keys(get_object_vars($model)) as $attr) {
            $input = preg_replace('/\\b' . $attr . '\\b/', $this->table . ".$attr", $input);
        }
        return $input;
    }
    
        
    /**
     * Create new entry.
     * 
     * @param mixed $model  Model instance.
     */
    private function create($model)
    {
        $attrs = $this->getMutableAttributes($model);
        $this->db
            ->connect()
            ->insert($this->table, array_keys($attrs))
            ->execute(array_values($attrs));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $model->{$this->key} = $this->db->lastInsertId();
    }
    
    
    /**
     * Update entry.
     * 
     * @param mixed $model  Model instance.
     */
    private function update($model)
    {
        $attrs = $this->getMutableAttributes($model);
        $values = array_values($attrs);
        $values[] = $model->{$this->key};
        $this->db
            ->connect()
            ->update($this->table, array_keys($attrs))
            ->where($this->key . ' = ?')
            ->execute($values);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }
    
    
    /**
     * Get mutable model attributes.
     *
     * @param object $model Model instance.
     *
     * @return array        Array of attributes.
     */
    private function getMutableAttributes($model)
    {
        $attrs = get_object_vars($model);
        unset($attrs[$this->key]);
        
        // remove reference attributes, if any
        if ($model instanceof ManagedModelInterface) {
            foreach (array_keys($model->getReferences()) as $ref) {
                unset($attrs[$ref]);
            }
        }
        
        return $attrs;
    }
}


1			<?php
2
3			namespace LRC\Repository;
4
5			/**
6			* Base class for database-backed repositories for data access.
7			*
8			* @SuppressWarnings(PHPMD.ExcessiveClassComplexity)
9			*/
10			class DbRepository extends ManagedRepository implements RepositoryInterface
11			{
12			/**
13			* @var \Anax\Database\DatabaseQueryBuilder Database service.
14			*/
15			protected $db;
16
17			/**
18			* @var string Database table name.
19			*/
20			protected $table;
21
22			/**
23			* @var string Model class name.
24			*/
25			protected $modelClass;
26
27			/**
28			* @var string Primary key column.
29			*/
30			protected $key;
31
32
33			/**
34			* Constructor.
35			*
36			* @param \Anax\Database\DatabaseQueryBuilder $db Database service.
37			* @param string $table Database table name.
38			* @param string $modelClass Model class name.
39			* @param string $key Primary key column.
40			*/
41	30		public function __construct($db, $table, $modelClass, $key = 'id')
42			{
43	30		$this->db = $db;
44	30		$this->table = $table;
45	30		$this->modelClass = $modelClass;
46	30		$this->key = $key;
47	30		}
48
49
50			/**
51			* Return the name of the database table represented by the repository.
52			*/
53	7		public function getCollectionName()
54			{
55	7		return $this->table;
56			}
57
58
59			/**
60			* Return the class of the model handled by the repository.
61			*/
62	14		public function getModelClass()
63			{
64	14		return $this->modelClass;
65			}
66
67
68			/**
69			* Find and return first entry by key.
70			*
71			* @param string\|null $column Key column name (pass null to use registered primary key).
72			* @param mixed $value Key value.
73			*
74			* @return mixed Model instance.
75			*/
76	18		public function find($column, $value)
77			{
78	18		return $this->getFirst((is_null($column) ? $this->key : $column) . ' = ?', [$value]);
79			}
80
81
82			/**
83			* Retrieve first entry, optionally filtered by search criteria.
84			*
85			* @param string $conditions Where conditions.
86			* @param array $values Array of condition values to bind.
87			* @param array $options Query options.
88			*
89			* @return mixed Model instance.
90			*/
91	19	View Code Duplication	public function getFirst($conditions = null, $values = [], $options = [])
			0 ignored issues – show Duplication introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
92			{
93	19		$query = $this->executeQuery(null, $conditions, $values, $options);
94	19		if (!empty($this->fetchRefs)) {
95	3		$res = $query->fetch();
96	3		$model = ($res ? $this->populateModelFromJoin($res) : $res);
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `$res` is of type `array`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
97	3		} else {
98	19		$model = $query->fetchClass($this->modelClass);
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `$this->modelClass` is of type `string`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
99			}
100	19		if ($model && isset($this->manager)) {
101	10		$this->manager->manageModel($model);
			0 ignored issues – show Bug introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report It seems like `$model` can also be of type `array`; however, `LRC\Repository\RepositoryManager::manageModel()` does only seem to accept `object`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
102	10		}
103	19		$this->fetchReferences(false);
104	19		return $model;
105			}
106
107
108			/**
109			* Retrieve all entries, optionally filtered by search criteria.
110			*
111			* @param string $conditions Where conditions.
112			* @param array $values Array of condition values to bind.
113			* @param array $options Query options.
114			*
115			* @return array Array of all matching entries.
116			*/
117	4	View Code Duplication	public function getAll($conditions = null, $values = [], $options = [])
			0 ignored issues – show Duplication introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
118			{
119	4		$query = $this->executeQuery(null, $conditions, $values, $options);
120	4		if (!empty($this->fetchRefs)) {
121	2		$models = [];
122	2		foreach ($query->fetchAll() as $model) {
123	2		$models[] = $this->populateModelFromJoin($model);
124	2		}
125	2		} else {
126	2		$models = $query->fetchAllClass($this->modelClass);
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `$this->modelClass` is of type `string`, but the function expects a `object`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
127			}
128	4		if (isset($this->manager)) {
129	3		foreach ($models as $model) {
130	3		$this->manager->manageModel($model);
131	3		}
132	3		}
133	4		$this->fetchReferences(false);
134	4		return $models;
135			}
136
137
138			/**
139			* Save entry by inserting if ID is missing and updating if ID exists.
140			*
141			* @param mixed $model Model instance.
142			*
143			* @return void
144			*/
145	5		public function save($model)
146			{
147	5		if (isset($model->{$this->key})) {
148	5		return $this->update($model);
149			}
150
151	3		return $this->create($model);
152			}
153
154
155			/**
156			* Delete entry.
157			*
158			* @param mixed $model Model instance.
159			*/
160	1		public function delete($model)
161			{
162	1		$this->db->connect()
163	1		->deleteFrom($this->table)
164	1		->where($this->key . ' = ?')
165	1		->execute([$model->{$this->key}]);
			0 ignored issues – show Documentation introduced 2017-10-04 15:29 UTC by Report Bug Copy Issue Report `array($model->{$this->key})` is of type `array<integer,?,{"0":"?"}>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
166	1		$model->{$this->key} = null;
167	1		}
168
169
170			/**
171			* Count entries, optionally filtered by search criteria.
172			*
173			* @param string $conditions Where conditions.
174			* @param array $values Array of condition values to bind.
175			*
176			* @return int Number of entries.
177			*/
178	4		public function count($conditions = null, $values = [])
179			{
180	4		$res = $this->executeQuery('COUNT(' . $this->key . ') AS num', $conditions, $values)
181	4		->fetch();
182	4		return (isset($res->num) ? (int)$res->num : 0);
183			}
184
185
186			/**
187			* Execute query for selection methods.
188			*
189			* @param string $select Selection criteria.
190			* @param string $conditions Where conditions.
191			* @param array $values Array of where condition values to bind.
192			* @param array $options Query options.
193			*
194			* @return \Anax\Database\DatabaseQueryBuilder Database service instance with executed internal query.
195			*/
196	26		protected function executeQuery($select = null, $conditions = null, $values = [], $options = [])
197			{
198	26		$query = $this->db->connect();
199	26		if (!empty($this->fetchRefs)) {
200	6		$query = $this->setupJoin($query, $select, $conditions, (isset($options['order']) ? $options['order'] : null));
201	6		} else {
202	26		$query = (!is_null($select) ? $query->select($select) : $query->select());
203	26		$query = $query->from($this->table);
204	26		if (!is_null($conditions)) {
205	26		$query = $query->where($conditions);
206	26		}
207	26		if (isset($options['order'])) {
208	4		$query = $query->orderBy($options['order']);
209	4		}
210			}
211
212	26		if (isset($options['limit'])) {
213	2		$query = $query->limit($options['limit']);
214	2		}
215	26		if (isset($options['offset'])) {
216	2		$query = $query->offset($options['offset']);
217	2		}
218
219	26		return $query->execute($values);
			0 ignored issues – show Documentation introduced 2017-10-04 15:29 UTC by Report Bug Copy Issue Report `$values` is of type `array`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
220			}
221
222
223
224			/**
225			* Populate model instance including retrieved references from join query result.
226			*
227			* @param object $result Query result.
228			*
229			* @return mixed Populated model instance.
230			*/
231	6		protected function populateModelFromJoin($result)
232			{
233			// extract main model
234	6		$model = new $this->modelClass();
235	6		foreach (array_keys(get_object_vars($model)) as $attr) {
236	6		$model->$attr = $result->$attr;
237	6		}
238
239			// extract referenced models
240	6		$refs = $model->getReferences();
241	6		$refs2 = (is_array($this->fetchRefs) ? $this->fetchRefs : array_keys($refs));
242	6		sort($refs2);
243	6		foreach ($refs2 as $idx => $name) {
244	6		$prefix = "REF{$idx}_{$name}__";
245
246			// handle null result
247	6		if (is_null($result->{$prefix . $refs[$name]['key']})) {
248	3		$refModel = null;
249	3		} else {
250	6		$refModel = new $refs[$name]['model']();
251	6		foreach (array_keys(get_object_vars($refModel)) as $attr) {
252	6		$refModel->$attr = $result->{$prefix . $attr};
253	6		}
254			}
255
256			// inject manager reference
257	6		if ($refModel && $this->manager) {
258	6		$this->manager->manageModel($refModel);
259	6		}
260
261	6		$model->$name = $refModel;
262	6		}
263
264	6		return $model;
265			}
266
267
268			/**
269			* Set up join query for reference retrieval.
270			*
271			* @param \Anax\Database\DatabaseQueryBuilder $query Database service instance with initialized query.
272			* @param string $select Selection criteria.
273			* @param string $conditions Where conditions.
274			* @param string $order Order by clause.
275			*
276			* @return \Anax\Database\DatabaseQueryBuilder Database service instance with prepared join query.
277			*
278			* @SuppressWarnings(PHPMD.CyclomaticComplexity)
279			* @SuppressWarnings(PHPMD.NPathComplexity)
280			*/
281	6		private function setupJoin($query, $select, $conditions, $order = null)
282			{
283			// find references
284	6		$model = new $this->modelClass();
285	6		$refs = $model->getReferences();
286	6		if (is_array($this->fetchRefs)) {
287	5		$refs = array_intersect_key($refs, array_flip($this->fetchRefs));
288	5		}
289	6		ksort($refs);
290
291			// prefix main model selection
292	6		if (!is_null($select)) {
293	1		$select = $this->prefixModelAttributes($select, $model);
294	1		} else {
295	6		$select = $this->table . '.*';
296			}
297
298			// set up reference aliases and join conditions
299	6		$select = [$select];
300	6		$join = [];
301	6		$idx = 0;
302	6		foreach ($refs as $name => $ref) {
303			// prefix attributes
304	6		$refTable = "REF{$idx}_{$name}";
305	6		$idx++;
306	6		foreach (array_keys(get_object_vars(new $ref['model']())) as $attr) {
307	6		$select[] = "{$refTable}.{$attr} AS '{$refTable}__{$attr}'";
308	6		}
309
310			// generate join conditions
311	6		$joinCond = $this->table . '.' . $ref['attribute'] . " = {$refTable}." . $ref['key'];
312	6		$refRepo = $this->manager->getByClass($ref['model']);
313	6		if ($this->softRefs && $refRepo instanceof SoftDbRepository) {
314	3		$joinCond .= " AND $refTable." . $refRepo->getDeletedAttribute() . ' IS NULL';
315	3		}
316	6		$join[] = [$refRepo->getCollectionName() . " AS $refTable", $joinCond];
317	6		}
318
319			// generate join query
320	6		$query = $query->select(implode(', ', $select))->from($this->table);
321	6		foreach ($join as $args) {
322	6		$query = $query->leftJoin(...$args);
			0 ignored issues – show Bug introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report The call to `leftJoin()` misses a required argument `$condition`. This check looks for function calls that miss required arguments. Loading history...
323	6		}
324
325			// prefix where conditions
326	6		if (!is_null($conditions)) {
327	5		$query = $query->where($this->prefixModelAttributes($conditions, $model));
328	5		}
329
330			// prefix order by clause
331	6		if (!is_null($order)) {
332	5		$query = $query->orderBy($this->prefixModelAttributes($order, $model));
333	5		}
334
335	6		return $query;
336			}
337
338
339			/**
340			* Prefix model attributes with the associated table name.
341			*
342			* @param string $input Input string.
343			* @param object $model Model instance.
344			*
345			* @return string String with table-prefixed attributes.
346			*/
347	6		private function prefixModelAttributes($input, $model)
348			{
349	6		foreach (array_keys(get_object_vars($model)) as $attr) {
350	6		$input = preg_replace('/\\b' . $attr . '\\b/', $this->table . ".$attr", $input);
351	6		}
352	6		return $input;
353			}
354
355
356			/**
357			* Create new entry.
358			*
359			* @param mixed $model Model instance.
360			*/
361	3		private function create($model)
362			{
363	3		$attrs = $this->getMutableAttributes($model);
364	3		$this->db
365	3		->connect()
366	3		->insert($this->table, array_keys($attrs))
367	3		->execute(array_values($attrs));
			0 ignored issues – show Documentation introduced 2017-10-22 08:11 UTC by Report Bug Copy Issue Report `array_values($attrs)` is of type `array<integer,?>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
368	3		$model->{$this->key} = $this->db->lastInsertId();
369	3		}
370
371
372			/**
373			* Update entry.
374			*
375			* @param mixed $model Model instance.
376			*/
377	5		private function update($model)
378			{
379	5		$attrs = $this->getMutableAttributes($model);
380	5		$values = array_values($attrs);
381	5		$values[] = $model->{$this->key};
382	5		$this->db
383	5		->connect()
384	5		->update($this->table, array_keys($attrs))
385	5		->where($this->key . ' = ?')
386	5		->execute($values);
			0 ignored issues – show Documentation introduced 2017-10-04 15:29 UTC by Report Bug Copy Issue Report `$values` is of type `array<integer,?>`, but the function expects a `string\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
387	5		}
388
389
390			/**
391			* Get mutable model attributes.
392			*
393			* @param object $model Model instance.
394			*
395			* @return array Array of attributes.
396			*/
397	5		private function getMutableAttributes($model)
398			{
399	5		$attrs = get_object_vars($model);
400	5		unset($attrs[$this->key]);
401
402			// remove reference attributes, if any
403	5		if ($model instanceof ManagedModelInterface) {
404	2		foreach (array_keys($model->getReferences()) as $ref) {
405	2		unset($attrs[$ref]);
406	2		}
407	2		}
408
409	5		return $attrs;
410			}
411			}
412

lrc-se / bth-anax-repository