RecordWrapper::getHasMany() - Code Metrics - ntentan/nibii - Measure and Improve Code Quality continuously with Scrutinizer

RecordWrapper::getHasMany() A
last analyzed 2020-02-25 13:07 UTC

↳ Parent: RecordWrapper

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
ccs	0
cts	2
cp	0
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	0
crap	2

<?php

/*
 * The MIT License
 *
 * Copyright 2014-2018 James Ekow Abaka Ainooson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

namespace ntentan\nibii;

use ntentan\nibii\exceptions\NibiiException;
use ntentan\utils\Text;

/**
 * An active record wrapper for database records.
 */
class RecordWrapper implements \ArrayAccess, \Countable, \Iterator
{
    /**
     * An associative array of models to which this model has a one to may relationship.
     *
     * @var array
     */
    protected $hasMany = [];

    /**
     * An associative array of models which have a one-to-many relationship with this model.
     *
     * @var array
     */
    protected $belongsTo = [];

    /**
     * An associative array of models with which this model has a many to many relationship.
     *
     * @var array
     */
    protected $manyHaveMany = [];

    /**
     * The name of the database table.
     *
     * @var string
     */
    protected $table;

    /**
     * The name of the schema to which this table belongs.
     *
     * @var string
     */
    protected $schema;

    /**
     * Temporary data held in the model object.
     *
     * @var array
     */
    protected $modelData = [];

    /**
     * Extra validation rules to use over the model's inherent validation requirements.
     * @var array
     */
    protected $validationRules = [];

    /**
     * A quoted string of the table name used for building queries.
     *
     * @var string
     */
    private $quotedTable;

    /**
     * The raw table name without any quotes.
     *
     * @var string
     */
    private $unquotedTable;

    /**
     * An array of fields that contain validation errors after an attempted save.
     *
     * @var array
     */
    private $invalidFields;

    /**
     * An instance of the operations dispatcher.
     *
     * @var Operations
     */
    private $dynamicOperations;

    /**
     * Location of the RecordWrapper's internal iterator.
     *
     * @var int
     */
    private $index = 0;

    /**
     * This flag is set whenever data is manually put in the model with the setData method.
     *
     * @var bool
     */
    private $dataSet = false;

    /**
     * The name of the class for this model obtained through reflection.
     *
     * @var string
     */
    private $className;

    /**
     * An instance of the driver adapter for interacting with the database.
     *
     * @var DriverAdapter
     */
    private $adapter;

    /**
     * An instance of the ORMContext through which this model is operating.
     *
     * @var ORMContext
     */
    private $context;

    /**
     * Keys for the various fields when model is accessed as an associative array.
     *
     * @var array
     */
    private $keys = [];

    /**
     * This flag is set after the model has been properly initialized.
     * Useful after model is unserialized or accessed through the static interface.
     *
     * @var bool
     */
    private $initialized = false;

    /**
     * Initialize the record wrapper and setup the adapters, drivers, tables and schemas.
     * After initialization, this method sets the initialized flag.
     *
     * @return void
     */
    protected function initialize(): void
    {
        if ($this->initialized) {
            return;
        }
        $this->context = ORMContext::getInstance();

        $this->adapter = $this->context->getDriverAdapter();
        $table = $this->table ?? $this->context->getModelTable($this);
        $driver = $this->context->getDbContext()->getDriver();
        $this->adapter->setContext($this->context);
        $this->className = (new \ReflectionClass($this))->getName();
        if (is_string($table)) {
            $this->table = $this->unquotedTable = $table;
        } else {
            $this->table = $table['table'];
            $this->schema = $table['schema'];
        }
        $this->quotedTable = ($this->schema ? "{$driver->quoteIdentifier($this->schema)}." : '').$driver->quoteIdentifier($this->table);
        $this->unquotedTable = ($this->schema ? "{$this->schema}." : '').$this->table;
        $this->adapter->setModel($this, $this->quotedTable);
        $this->initialized = true;
    }

    public function __debugInfo()

    {
        $data = $this->getData();

        return $this->hasMultipleItems() ? $data : isset($data[0]) ? $data[0] : [];
    }

    /**
     * Return a description of the model wrapped by this wrapper.
     *
     * @return ModelDescription
     */
    public function getDescription() : ModelDescription
    {
        $this->initialize();

        return $this->context->getCache()->read(
            "{$this->className}::desc", function () {
                return $this->context->getModelDescription($this);
            }
        );
    }

    /**
     * Return the number of items stored in the model or matched by the query.
     * Depending on the state of the model, the count method will return different values. For models that have data
     * values set with calls to setData, this method returns the number of records that were added. On the other hand,
     * for models that do not have data set, this method queries the database to find out the number of records that
     * are either in the model, or for models that have been filtered, the number of records that match the filter.
     *
     * @param int|array|QueryParameters $query
     *
     * @return int

     */
    public function count($query = null)
    {
        if ($this->dataSet) {
            return count($this->getData());
        }

        return $this->__call('count', [$query]);
    }

    /**
     * Retrieve an item stored in the record.
     * This method returns items that are directly stored in the model, or lazy loads related items if needed.
     * The key could be a field in the model's table or the name of a related model.
     *
     * @param string $key A key identifying the item to be retrieved.
     *
     * @return mixed
     */
    private function retrieveItem($key)
    {
        if ($this->hasMultipleItems()) {
            throw new NibiiException('Current model object state contains multiple items. Please index with a numeric key to select a specific item first.');
        }
        $relationships = $this->getDescription()->getRelationships();
        $decamelizedKey = Text::deCamelize($key);
        if (isset($relationships[$key])) {
            return $this->fetchRelatedFields($relationships[$key]);
        }

        return isset($this->modelData[$decamelizedKey]) ? $this->modelData[$decamelizedKey] : null;
    }

    /**
     * Calls dynamic methods.
     *
     * @param string $name
     * @param array  $arguments
     *
     * @throws exceptions\NibiiException
     *
     * @return type
     */
    public function __call($name, $arguments)
    {
        $this->initialize();
        if ($this->dynamicOperations === null) {
            $this->dynamicOperations = new Operations($this, $this->quotedTable);
        }

        return $this->dynamicOperations->perform($name, $arguments);
    }

    /**
     * Set a value for a field in the model.
     *
     * @param string $name
     * @param mixed  $value
     */
    public function __set($name, $value)
    {
        $this->dataSet = true;
        $this->modelData[Text::deCamelize($name)] = $value;
    }

    public function __get($name)
    {
        return $this->retrieveItem($name);
    }

    public function save()
    {
        $return = $this->__call('save', [$this->hasMultipleItems()]);
        $this->invalidFields = $this->dynamicOperations->getInvalidFields();

        return $return;
    }

    private function hasMultipleItems()
    {
        if (count($this->modelData) > 0) {
            return is_numeric(array_keys($this->modelData)[0]);
        } else {
            return false;
        }
    }

    public function getData()
    {
        $data = [];

        if (count($this->modelData) == 0) {
            $data = $this->modelData;
        } elseif ($this->hasMultipleItems()) {
            $data = $this->modelData;
        } elseif (count($this->modelData) > 0) {
            $data[] = $this->modelData;
        }

        return $data;
    }

    public function setData($data)
    {
        $this->dataSet = is_array($data) ? true : false;
        $this->modelData = $data;
    }

    public function mergeData($data)
    {
        foreach ($data as $key => $value) {
            $this->modelData[$key] = $value;
        }
        $this->dataSet = true;
    }

    public function offsetExists($offset)
    {
        return isset($this->modelData[$offset]);
    }

    public function offsetGet($offset)
    {
        if (is_numeric($offset)) {
            return $this->wrap($offset);
        } else {
            return $this->retrieveItem($offset);
        }
    }

    public function offsetSet($offset, $value)
    {
        $this->dataSet = true;
        $this->modelData[$offset] = $value;
    }

    public function offsetUnset($offset)
    {
        unset($this->modelData[$offset]);
    }

    private function wrap($offset)
    {
        $this->initialize();
        if (isset($this->modelData[$offset])) {
            $className = $this->className;
            $newInstance = new $className();
            $newInstance->initialize();
            $newInstance->setData($this->modelData[$offset]);

            return $newInstance;
        } else {
            return;
        }
    }

    public function getInvalidFields()
    {
        return $this->invalidFields;
    }

    public function getHasMany()
    {
        return $this->hasMany;
    }

    public function getBelongsTo()
    {
        return $this->belongsTo;
    }

    public function current()
    {
        return $this->wrap($this->keys[$this->index]);
    }

    public function key()
    {
        return $this->keys[$this->index];
    }

    public function next()
    {
        $this->index++;
    }

    public function rewind()
    {
        $this->keys = array_keys($this->modelData);
        $this->index = 0;
    }

    public function valid()
    {
        return isset($this->keys[$this->index]) && isset($this->modelData[$this->keys[$this->index]]);
    }

    /**
     * A custom validator for the record wrapper.
     *
     * @return mixed
     */
    public function onValidate($invalidFields) : array 

    {
        return [];
    }

    private function fetchRelatedFields($relationship, $index = null)

    {
        if ($index === null) {
            $data = $this->modelData;
        } else {
            $data = $this->modelData[$index];
        }
        $model = $relationship->getModelInstance();
        if (empty($data)) {
            return $model;
        }
        $query = $relationship->prepareQuery($data);

        return $query ? $model->fetch($query) : $model;
    }

    public function getRelationships()
    {
        return [
            'HasMany'      => $this->hasMany,
            'BelongsTo'    => $this->belongsTo,
            'ManyHaveMany' => $this->manyHaveMany,
        ];
    }

    public function usetField($field)
    {
        unset($this->modelData[$field]);
    }

    /**
     * Callback for when a record is either added or modified.
     */
    public function preSaveCallback()
    {
    }

    /**
     * Callback for when a record has been added or modified.
     *
     * @param $id
     */
    public function postSaveCallback()
    {
    }

    /**
     * Callback for when a new record is about to be created.
     */
    public function preCreateCallback()
    {
    }

    /**
     * Callback for when a new record has been created.
     * This callback can be most useful for obtaining the primary key of a newly created record.
     *
     * @param $id
     */
    public function postCreateCallback($id)

    {
    }

    /**
     * Callback for when a record is about to be updated.
     */
    public function preUpdateCallback()
    {
    }

    /**
     * Callback for when a record has been updated.
     */
    public function postUpdateCallback()
    {
    }

    public function getDBStoreInformation()
    {
        $this->initialize();

        return [
            'schema'         => $this->schema,
            'table'          => $this->table,
            'quoted_table'   => $this->quotedTable,
            'unquoted_table' => $this->unquotedTable,
        ];
    }

    /**
     * @return DriverAdapter
     */
    public function getAdapter()
    {
        $this->initialize();
        return $this->adapter;
    }

    private function expandArrayValue($array, $relationships, $depth, $expandableModels = [], $index = null)

    {
        if (empty($expandableModels)) {
            foreach ($relationships as $name => $relationship) {
                $array[$name] = $this->fetchRelatedFields($relationship, $index)->toArray($depth);
            }
        } else {
            foreach ($expandableModels as $name) {
                $array[$name] = $this->fetchRelatedFields($relationships[$name], $index)->toArray($depth, $expandableModels);
            }
        }

        return $array;
    }

    public function getValidationRules() : array
    {
        return $this->validationRules;
    }

    public function toArray($depth = 0, $expandableModels = [])

    {
        $relationships = $this->getDescription()->getRelationships();
        $array = $this->modelData;
        if ($depth > 0) {
            if ($this->hasMultipleItems()) {
                foreach ($array as $i => $value) {
                    $array[$i] = $this->expandArrayValue($value, $relationships, $depth - 1, $expandableModels, $i);
                }
            } else {
                $array = $this->expandArrayValue($array, $relationships, $depth - 1, $expandableModels);
            }
        }

        return $array;
    }
}


1		<?php
2
3		/*
4		* The MIT License
5		*
6		* Copyright 2014-2018 James Ekow Abaka Ainooson
7		*
8		* Permission is hereby granted, free of charge, to any person obtaining a copy
9		* of this software and associated documentation files (the "Software"), to deal
10		* in the Software without restriction, including without limitation the rights
11		* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12		* copies of the Software, and to permit persons to whom the Software is
13		* furnished to do so, subject to the following conditions:
14		*
15		* The above copyright notice and this permission notice shall be included in
16		* all copies or substantial portions of the Software.
17		*
18		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21		* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22		* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23		* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24		* THE SOFTWARE.
25		*/
26
27		namespace ntentan\nibii;
28
29		use ntentan\nibii\exceptions\NibiiException;
30		use ntentan\utils\Text;
31
32		/**
33		* An active record wrapper for database records.
34		*/
35		class RecordWrapper implements \ArrayAccess, \Countable, \Iterator
36		{
37		/**
38		* An associative array of models to which this model has a one to may relationship.
39		*
40		* @var array
41		*/
42		protected $hasMany = [];
43
44		/**
45		* An associative array of models which have a one-to-many relationship with this model.
46		*
47		* @var array
48		*/
49		protected $belongsTo = [];
50
51		/**
52		* An associative array of models with which this model has a many to many relationship.
53		*
54		* @var array
55		*/
56		protected $manyHaveMany = [];
57
58		/**
59		* The name of the database table.
60		*
61		* @var string
62		*/
63		protected $table;
64
65		/**
66		* The name of the schema to which this table belongs.
67		*
68		* @var string
69		*/
70		protected $schema;
71
72		/**
73		* Temporary data held in the model object.
74		*
75		* @var array
76		*/
77		protected $modelData = [];
78
79		/**
80		* Extra validation rules to use over the model's inherent validation requirements.
81		* @var array
82		*/
83		protected $validationRules = [];
84
85		/**
86		* A quoted string of the table name used for building queries.
87		*
88		* @var string
89		*/
90		private $quotedTable;
91
92		/**
93		* The raw table name without any quotes.
94		*
95		* @var string
96		*/
97		private $unquotedTable;
98
99		/**
100		* An array of fields that contain validation errors after an attempted save.
101		*
102		* @var array
103		*/
104		private $invalidFields;
105
106		/**
107		* An instance of the operations dispatcher.
108		*
109		* @var Operations
110		*/
111		private $dynamicOperations;
112
113		/**
114		* Location of the RecordWrapper's internal iterator.
115		*
116		* @var int
117		*/
118		private $index = 0;
119
120		/**
121		* This flag is set whenever data is manually put in the model with the setData method.
122		*
123		* @var bool
124		*/
125		private $dataSet = false;
126
127		/**
128		* The name of the class for this model obtained through reflection.
129		*
130		* @var string
131		*/
132		private $className;
133
134		/**
135		* An instance of the driver adapter for interacting with the database.
136		*
137		* @var DriverAdapter
138		*/
139		private $adapter;
140
141		/**
142		* An instance of the ORMContext through which this model is operating.
143		*
144		* @var ORMContext
145		*/
146		private $context;
147
148		/**
149		* Keys for the various fields when model is accessed as an associative array.
150		*
151		* @var array
152		*/
153		private $keys = [];
154
155		/**
156		* This flag is set after the model has been properly initialized.
157		* Useful after model is unserialized or accessed through the static interface.
158		*
159		* @var bool
160		*/
161		private $initialized = false;
162
163		/**
164		* Initialize the record wrapper and setup the adapters, drivers, tables and schemas.
165		* After initialization, this method sets the initialized flag.
166		*
167		* @return void
168		*/
169	36	protected function initialize(): void
170		{
171	36	if ($this->initialized) {
172	36	return;
173		}
174	36	$this->context = ORMContext::getInstance();
		0 ignored issues – show Documentation Bug introduced 2018-12-03 07:10 UTC by Report Bug Copy Issue Report It seems like `\ntentan\nibii\ORMContext::getInstance()` of type `object<self>` is incompatible with the declared type `object<ntentan\nibii\ORMContext>` of property `$context`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
175	36	$this->adapter = $this->context->getDriverAdapter();
176	36	$table = $this->table ?? $this->context->getModelTable($this);
177	36	$driver = $this->context->getDbContext()->getDriver();
178	36	$this->adapter->setContext($this->context);
179	36	$this->className = (new \ReflectionClass($this))->getName();
180	36	if (is_string($table)) {
181	36	$this->table = $this->unquotedTable = $table;
182		} else {
183		$this->table = $table['table'];
184		$this->schema = $table['schema'];
185		}
186	36	$this->quotedTable = ($this->schema ? "{$driver->quoteIdentifier($this->schema)}." : '').$driver->quoteIdentifier($this->table);
187	36	$this->unquotedTable = ($this->schema ? "{$this->schema}." : '').$this->table;
188	36	$this->adapter->setModel($this, $this->quotedTable);
189	36	$this->initialized = true;
190	36	}
191
192		public function __debugInfo()
		0 ignored issues – show Documentation introduced 2017-08-06 18:08 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
193		{
194		$data = $this->getData();
195
196		return $this->hasMultipleItems() ? $data : isset($data[0]) ? $data[0] : [];
197		}
198
199		/**
200		* Return a description of the model wrapped by this wrapper.
201		*
202		* @return ModelDescription
203		*/
204	28	public function getDescription() : ModelDescription
205		{
206	28	$this->initialize();
207
208	28	return $this->context->getCache()->read(
209		"{$this->className}::desc", function () {
210	28	return $this->context->getModelDescription($this);
211	28	}
212		);
213		}
214
215		/**
216		* Return the number of items stored in the model or matched by the query.
217		* Depending on the state of the model, the count method will return different values. For models that have data
218		* values set with calls to setData, this method returns the number of records that were added. On the other hand,
219		* for models that do not have data set, this method queries the database to find out the number of records that
220		* are either in the model, or for models that have been filtered, the number of records that match the filter.
221		*
222		* @param int\|array\|QueryParameters $query
223		*
224		* @return int
		0 ignored issues – show Documentation introduced 2018-12-03 07:10 UTC by Report Bug Copy Issue Report Should the return type not be `integer\|type`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
225		*/
226	8	public function count($query = null)
227		{
228	8	if ($this->dataSet) {
229	8	return count($this->getData());
230		}
231
232		return $this->__call('count', [$query]);
233		}
234
235		/**
236		* Retrieve an item stored in the record.
237		* This method returns items that are directly stored in the model, or lazy loads related items if needed.
238		* The key could be a field in the model's table or the name of a related model.
239		*
240		* @param string $key A key identifying the item to be retrieved.
241		*
242		* @return mixed
243		*/
244	12	private function retrieveItem($key)
245		{
246	12	if ($this->hasMultipleItems()) {
247		throw new NibiiException('Current model object state contains multiple items. Please index with a numeric key to select a specific item first.');
248		}
249	12	$relationships = $this->getDescription()->getRelationships();
250	12	$decamelizedKey = Text::deCamelize($key);
251	12	if (isset($relationships[$key])) {
252	8	return $this->fetchRelatedFields($relationships[$key]);
253		}
254
255	4	return isset($this->modelData[$decamelizedKey]) ? $this->modelData[$decamelizedKey] : null;
256		}
257
258		/**
259		* Calls dynamic methods.
260		*
261		* @param string $name
262		* @param array $arguments
263		*
264		* @throws exceptions\NibiiException
265		*
266		* @return type
267		*/
268	34	public function __call($name, $arguments)
269		{
270	34	$this->initialize();
271	34	if ($this->dynamicOperations === null) {
272	34	$this->dynamicOperations = new Operations($this, $this->quotedTable);
273		}
274
275	34	return $this->dynamicOperations->perform($name, $arguments);
276		}
277
278		/**
279		* Set a value for a field in the model.
280		*
281		* @param string $name
282		* @param mixed $value
283		*/
284	8	public function __set($name, $value)
285		{
286	8	$this->dataSet = true;
287	8	$this->modelData[Text::deCamelize($name)] = $value;
288	8	}
289
290	12	public function __get($name)
291		{
292	12	return $this->retrieveItem($name);
293		}
294
295	10	public function save()
296		{
297	10	$return = $this->__call('save', [$this->hasMultipleItems()]);
298	10	$this->invalidFields = $this->dynamicOperations->getInvalidFields();
299
300	10	return $return;
301		}
302
303	26	private function hasMultipleItems()
304		{
305	26	if (count($this->modelData) > 0) {
306	24	return is_numeric(array_keys($this->modelData)[0]);
307		} else {
308	2	return false;
309		}
310		}
311
312	18	public function getData()
313		{
314	18	$data = [];
315
316	18	if (count($this->modelData) == 0) {
317	2	$data = $this->modelData;
318	16	} elseif ($this->hasMultipleItems()) {
319	6	$data = $this->modelData;
320	12	} elseif (count($this->modelData) > 0) {
321	12	$data[] = $this->modelData;
322		}
323
324	18	return $data;
325		}
326
327	26	public function setData($data)
328		{
329	26	$this->dataSet = is_array($data) ? true : false;
330	26	$this->modelData = $data;
331	26	}
332
333		public function mergeData($data)
334		{
335		foreach ($data as $key => $value) {
336		$this->modelData[$key] = $value;
337		}
338		$this->dataSet = true;
339		}
340
341	2	public function offsetExists($offset)
342		{
343	2	return isset($this->modelData[$offset]);
344		}
345
346	2	public function offsetGet($offset)
347		{
348	2	if (is_numeric($offset)) {
349	2	return $this->wrap($offset);
350		} else {
351	2	return $this->retrieveItem($offset);
352		}
353		}
354
355	2	public function offsetSet($offset, $value)
356		{
357	2	$this->dataSet = true;
358	2	$this->modelData[$offset] = $value;
359	2	}
360
361		public function offsetUnset($offset)
362		{
363		unset($this->modelData[$offset]);
364		}
365
366	6	private function wrap($offset)
367		{
368	6	$this->initialize();
369	6	if (isset($this->modelData[$offset])) {
370	6	$className = $this->className;
371	6	$newInstance = new $className();
372	6	$newInstance->initialize();
373	6	$newInstance->setData($this->modelData[$offset]);
374
375	6	return $newInstance;
376		} else {
377		return;
378		}
379		}
380
381	4	public function getInvalidFields()
382		{
383	4	return $this->invalidFields;
384		}
385
386		public function getHasMany()
387		{
388		return $this->hasMany;
389		}
390
391		public function getBelongsTo()
392		{
393		return $this->belongsTo;
394		}
395
396	4	public function current()
397		{
398	4	return $this->wrap($this->keys[$this->index]);
399		}
400
401		public function key()
402		{
403		return $this->keys[$this->index];
404		}
405
406	4	public function next()
407		{
408	4	$this->index++;
409	4	}
410
411	4	public function rewind()
412		{
413	4	$this->keys = array_keys($this->modelData);
414	4	$this->index = 0;
415	4	}
416
417	4	public function valid()
418		{
419	4	return isset($this->keys[$this->index]) && isset($this->modelData[$this->keys[$this->index]]);
420		}
421
422		/**
423		* A custom validator for the record wrapper.
424		*
425		* @return mixed
426		*/
427	10	public function onValidate($invalidFields) : array
		0 ignored issues – show Unused Code introduced 2019-12-28 02:00 UTC by Report Bug Copy Issue Report The parameter `$invalidFields` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
428		{
429	10	return [];
430		}
431
432	12	private function fetchRelatedFields($relationship, $index = null)
		0 ignored issues – show Documentation introduced 2017-08-06 18:08 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
433		{
434	12	if ($index === null) {
435	12	$data = $this->modelData;
436		} else {
437		$data = $this->modelData[$index];
438		}
439	12	$model = $relationship->getModelInstance();
440	12	if (empty($data)) {
441		return $model;
442		}
443	12	$query = $relationship->prepareQuery($data);
444
445	12	return $query ? $model->fetch($query) : $model;
446		}
447
448	28	public function getRelationships()
449		{
450		return [
451	28	'HasMany' => $this->hasMany,
452	28	'BelongsTo' => $this->belongsTo,
453	28	'ManyHaveMany' => $this->manyHaveMany,
454		];
455		}
456
457		public function usetField($field)
458		{
459		unset($this->modelData[$field]);
460		}
461
462		/**
463		* Callback for when a record is either added or modified.
464		*/
465	10	public function preSaveCallback()
466		{
467	10	}
468
469		/**
470		* Callback for when a record has been added or modified.
471		*
472		* @param $id
473		*/
474	6	public function postSaveCallback()
475		{
476	6	}
477
478		/**
479		* Callback for when a new record is about to be created.
480		*/
481	8	public function preCreateCallback()
482		{
483	8	}
484
485		/**
486		* Callback for when a new record has been created.
487		* This callback can be most useful for obtaining the primary key of a newly created record.
488		*
489		* @param $id
490		*/
491	4	public function postCreateCallback($id)
		0 ignored issues – show Unused Code introduced 2018-10-18 11:53 UTC by Report Bug Copy Issue Report The parameter `$id` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
492		{
493	4	}
494
495		/**
496		* Callback for when a record is about to be updated.
497		*/
498	2	public function preUpdateCallback()
499		{
500	2	}
501
502		/**
503		* Callback for when a record has been updated.
504		*/
505	2	public function postUpdateCallback()
506		{
507	2	}
508
509	36	public function getDBStoreInformation()
510		{
511	36	$this->initialize();
512
513		return [
514	36	'schema' => $this->schema,
515	36	'table' => $this->table,
516	36	'quoted_table' => $this->quotedTable,
517	36	'unquoted_table' => $this->unquotedTable,
518		];
519		}
520
521		/**
522		* @return DriverAdapter
523		*/
524	36	public function getAdapter()
525		{
526	36	$this->initialize();
527	36	return $this->adapter;
528		}
529
530	4	private function expandArrayValue($array, $relationships, $depth, $expandableModels = [], $index = null)
		0 ignored issues – show Documentation introduced 2017-11-13 04:31 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
531		{
532	4	if (empty($expandableModels)) {
533	4	foreach ($relationships as $name => $relationship) {
534	4	$array[$name] = $this->fetchRelatedFields($relationship, $index)->toArray($depth);
535		}
536		} else {
537		foreach ($expandableModels as $name) {
538		$array[$name] = $this->fetchRelatedFields($relationships[$name], $index)->toArray($depth, $expandableModels);
539		}
540		}
541
542	4	return $array;
543		}
544
545	10	public function getValidationRules() : array
546		{
547	10	return $this->validationRules;
548		}
549
550	24	public function toArray($depth = 0, $expandableModels = [])
		0 ignored issues – show Documentation introduced 2017-11-17 07:46 UTC by Report Bug Copy Issue Report The return type could not be reliably inferred; please add a `@return` annotation. Our type inference engine in quite powerful, but sometimes the code does not provide enough clues to go by. In these cases we request you to add a `@return` annotation as described here. Loading history...
551		{
552	24	$relationships = $this->getDescription()->getRelationships();
553	24	$array = $this->modelData;
554	24	if ($depth > 0) {
555	4	if ($this->hasMultipleItems()) {
556		foreach ($array as $i => $value) {
557		$array[$i] = $this->expandArrayValue($value, $relationships, $depth - 1, $expandableModels, $i);
558		}
559		} else {
560	4	$array = $this->expandArrayValue($array, $relationships, $depth - 1, $expandableModels);
561		}
562		}
563
564	24	return $array;
565		}
566		}
567

ntentan / nibii

RecordWrapper::getHasMany() A last analyzed 2020-02-25 13:07 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

RecordWrapper::getHasMany() A
last analyzed 2020-02-25 13:07 UTC