HasAndBelongsToMany::remove() - Code Metrics - Inspection of "Add/Remove feature to HABTM relation" - slickframework/orm - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 2a9f41...e2e9c6 )

by Filipe

created 2016-03-31 02:02 UTC

HasAndBelongsToMany::remove() A

↳ Parent: HasAndBelongsToMany

Complexity

Conditions	1
Paths	1

Size

Total Lines	6
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	6
ccs	0
cts	5
cp	0
rs	9.4285
cc	1
eloc	4
nc	1
nop	1
crap	2

<?php

/**
 * This file is part of slick/orm package
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Slick\Orm\Mapper\Relation;
use Slick\Common\Utils\Text;
use Slick\Database\Sql;
use Slick\Database\Sql\Select;
use Slick\Orm\Entity\EntityCollectionInterface;
use Slick\Orm\EntityInterface;
use Slick\Orm\Event\EntityAdded;
use Slick\Orm\Event\EntityRemoved;

/**
 * HasAndBelongsToMany relation
 * 
 * @package Slick\Orm\Mapper\Relation
 * @author  Filipe Silva <[email protected]>
 */
class HasAndBelongsToMany extends HasMany
{

    /**
     * @readwrite
     * @var string
     */
    protected $relatedForeignKey;

    /**
     * @readwrite
     * @var string
     */
    protected $relationTable;

    /**
     * Gets the related foreign key
     * 
     * @return string
     */
    public function getRelatedForeignKey()
    {
        if (null == $this->relatedForeignKey) {
            $name = $this->getParentTableName();
            $this->relatedForeignKey = "{$this->normalizeFieldName($name)}_id";
        }
        return $this->relatedForeignKey;
    }

    /**
     * Gets the related table
     * 
     * @return string
     */
    public function getRelationTable()
    {
        if (is_null($this->relationTable)) {
            $parentTable = $this->getParentTableName();
            $table = $this->getEntityDescriptor()->getTableName();
            $names = [$parentTable, $table];
            asort($names);
            $first = array_shift($names);
            $tableName = $this->normalizeFieldName($first);
            array_unshift($names, $tableName);
            $this->relationTable = implode('_', $names);
        }
        return $this->relationTable;
    }

    /**
     * Loads the entity or entity collection for this relation
     *
     * @param EntityInterface $entity
     *
     * @return EntityCollectionInterface|EntityInterface[]
     */
    public function load(EntityInterface $entity)
    {
        $repository = $this->getParentRepository();

        $query = $repository->find()
            ->where($this->getConditions($entity))
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            ->limit($this->limit);
        $this->addJoinTable($query);
        $this->checkConditions($query)
            ->checkOrder($query);

        /** @var EntityCollectionInterface $collection */
        $collection = $query->all();

        $collection
            ->setParentEntity($entity)
            ->getEmitter()
            ->addListener(EntityAdded::ACTION_ADD, [$this, 'add'])
            ->addListener(EntityRemoved::ACTION_REMOVE, [$this, 'remove']);

        return $collection;
    }

    /**
     * Saves the relation row upon entity add
     *
     * @param EntityAdded $event
     */
    public function add(EntityAdded $event)
    {
        $entity = $event->getEntity();
        $collection = $event->getCollection();
        $this->deleteRelation($entity, $collection);

        $repository = $this->getParentRepository();
        $adapter = $repository->getAdapter();
        $value = $collection->parentEntity()->getId();

        Sql::createSql($adapter)
            ->insert($this->getRelationTable())
            ->set(
                [
                    "{$this->getRelatedForeignKey()}" => $entity->getId(),
                    "{$this->getForeignKey()}" => $value
                ]
            )
            ->execute();
    }

    /**
     * Deletes the relation row upon entity remove
     * 
     * @param EntityRemoved $event
     */
    public function remove(EntityRemoved $event)
    {
        $entity = $event->getEntity();
        $collection = $event->getCollection();
        $this->deleteRelation($entity, $collection);
    }

    /**
     * Removes existing relations
     *
     * @param EntityInterface $entity
     * @param EntityCollectionInterface $collection
     *
     * @return self
     */
    protected function deleteRelation(
        EntityInterface $entity,
        EntityCollectionInterface $collection
    ) {
        $repository = $this->getParentRepository();
        $adapter = $repository->getAdapter();
        $parts = explode('\\', $this->getEntityDescriptor()->className());
        $entityName = lcfirst(array_pop($parts));
        $parts = explode('\\', $this->getParentEntityDescriptor()->className());
        $relatedName = lcfirst(array_pop($parts));
        $value = $collection->parentEntity()->getId();
        Sql::createSql($adapter)
            ->delete($this->getRelationTable())
            ->where(
                [
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                    "{$this->getRelatedForeignKey()} = :{$relatedName} AND
                     {$this->getForeignKey()} = :{$entityName}" => [
                        ":{$relatedName}" => $entity->getId(),
                        ":{$entityName}" => $value
                    ]
                ]
            )
            ->execute();
        return $this;
    }

    /**
     * Gets the relation conditions
     *
     * @param EntityInterface $entity
     * @return array
     */
    protected function getConditions(EntityInterface $entity)
    {
        $parts = explode('\\', $this->getEntityDescriptor()->className());
        $property = lcfirst(array_pop($parts));
        return [
            "rel.{$this->getForeignKey()} = :{$property}" => [
                ":{$property}" => $entity->getId()
            ]
        ];
    }

    /**
     * Adds the join table to the query
     *
     * @param Select $query
     * @return self
     */
    protected function addJoinTable(Select $query)
    {
        $relationTable = $this->getRelationTable();
        $table = $this->getParentTableName();
        $pmk = $this->getParentPrimaryKey();
        $rfk = $this->getRelatedForeignKey();
        $query->join(
            $relationTable,
            "rel.{$rfk} = {$table}.{$pmk}",
            null,
            'rel'
        );
        return $this;
    }

}

1		<?php
2
3		/**
4		* This file is part of slick/orm package
5		*
6		* For the full copyright and license information, please view the LICENSE
7		* file that was distributed with this source code.
8		*/
9
10		namespace Slick\Orm\Mapper\Relation;
11		use Slick\Common\Utils\Text;
12		use Slick\Database\Sql;
13		use Slick\Database\Sql\Select;
14		use Slick\Orm\Entity\EntityCollectionInterface;
15		use Slick\Orm\EntityInterface;
16		use Slick\Orm\Event\EntityAdded;
17		use Slick\Orm\Event\EntityRemoved;
18
19		/**
20		* HasAndBelongsToMany relation
21		*
22		* @package Slick\Orm\Mapper\Relation
23		* @author Filipe Silva <[email protected]>
24		*/
25		class HasAndBelongsToMany extends HasMany
26		{
27
28		/**
29		* @readwrite
30		* @var string
31		*/
32		protected $relatedForeignKey;
33
34		/**
35		* @readwrite
36		* @var string
37		*/
38		protected $relationTable;
39
40		/**
41		* Gets the related foreign key
42		*
43		* @return string
44		*/
45	4	public function getRelatedForeignKey()
46		{
47	4	if (null == $this->relatedForeignKey) {
48	4	$name = $this->getParentTableName();
49	4	$this->relatedForeignKey = "{$this->normalizeFieldName($name)}_id";
50	4	}
51	4	return $this->relatedForeignKey;
52		}
53
54		/**
55		* Gets the related table
56		*
57		* @return string
58		*/
59	4	public function getRelationTable()
60		{
61	4	if (is_null($this->relationTable)) {
62	4	$parentTable = $this->getParentTableName();
63	4	$table = $this->getEntityDescriptor()->getTableName();
64	4	$names = [$parentTable, $table];
65	4	asort($names);
66	4	$first = array_shift($names);
67	4	$tableName = $this->normalizeFieldName($first);
68	4	array_unshift($names, $tableName);
69	4	$this->relationTable = implode('_', $names);
70	4	}
71	4	return $this->relationTable;
72		}
73
74		/**
75		* Loads the entity or entity collection for this relation
76		*
77		* @param EntityInterface $entity
78		*
79		* @return EntityCollectionInterface\|EntityInterface[]
80		*/
81	2	public function load(EntityInterface $entity)
82		{
83	2	$repository = $this->getParentRepository();
84
85	2	$query = $repository->find()
86	2	->where($this->getConditions($entity))
		0 ignored issues – show Documentation introduced 2016-03-29 00:27 UTC by Report Bug Copy Issue Report `$this->getConditions($entity)` is of type `array<string\|integer,array<string\|integer,*>>`, but the function expects a `string`. 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...
87	2	->limit($this->limit);
88	2	$this->addJoinTable($query);
89	2	$this->checkConditions($query)
90	2	->checkOrder($query);
91
92		/** @var EntityCollectionInterface $collection */
93	2	$collection = $query->all();
94
95		$collection
96	2	->setParentEntity($entity)
97	2	->getEmitter()
98	2	->addListener(EntityAdded::ACTION_ADD, [$this, 'add'])
99	2	->addListener(EntityRemoved::ACTION_REMOVE, [$this, 'remove']);
100
101	2	return $collection;
102		}
103
104		/**
105		* Saves the relation row upon entity add
106		*
107		* @param EntityAdded $event
108		*/
109		public function add(EntityAdded $event)
110		{
111		$entity = $event->getEntity();
112		$collection = $event->getCollection();
113		$this->deleteRelation($entity, $collection);
114
115		$repository = $this->getParentRepository();
116		$adapter = $repository->getAdapter();
117		$value = $collection->parentEntity()->getId();
118
119		Sql::createSql($adapter)
120		->insert($this->getRelationTable())
121		->set(
122		[
123		"{$this->getRelatedForeignKey()}" => $entity->getId(),
124		"{$this->getForeignKey()}" => $value
125		]
126		)
127		->execute();
128		}
129
130		/**
131		* Deletes the relation row upon entity remove
132		*
133		* @param EntityRemoved $event
134		*/
135		public function remove(EntityRemoved $event)
136		{
137		$entity = $event->getEntity();
138		$collection = $event->getCollection();
139		$this->deleteRelation($entity, $collection);
140		}
141
142		/**
143		* Removes existing relations
144		*
145		* @param EntityInterface $entity
146		* @param EntityCollectionInterface $collection
147		*
148		* @return self
149		*/
150		protected function deleteRelation(
151		EntityInterface $entity,
152		EntityCollectionInterface $collection
153		) {
154		$repository = $this->getParentRepository();
155		$adapter = $repository->getAdapter();
156		$parts = explode('\\', $this->getEntityDescriptor()->className());
157		$entityName = lcfirst(array_pop($parts));
158		$parts = explode('\\', $this->getParentEntityDescriptor()->className());
159		$relatedName = lcfirst(array_pop($parts));
160		$value = $collection->parentEntity()->getId();
161		Sql::createSql($adapter)
162		->delete($this->getRelationTable())
163		->where(
164		[
		0 ignored issues – show Documentation introduced 2016-03-31 02:04 UTC by Report Bug Copy Issue Report `array("{$this->getRelate...ntityName}" => $value))` is of type `array<string\|integer,array<string\|integer,*>>`, but the function expects a `string`. 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...
165		"{$this->getRelatedForeignKey()} = :{$relatedName} AND
166		{$this->getForeignKey()} = :{$entityName}" => [
167		":{$relatedName}" => $entity->getId(),
168		":{$entityName}" => $value
169		]
170		]
171		)
172		->execute();
173		return $this;
174		}
175
176		/**
177		* Gets the relation conditions
178		*
179		* @param EntityInterface $entity
180		* @return array
181		*/
182	2	protected function getConditions(EntityInterface $entity)
183		{
184	2	$parts = explode('\\', $this->getEntityDescriptor()->className());
185	2	$property = lcfirst(array_pop($parts));
186		return [
187	2	"rel.{$this->getForeignKey()} = :{$property}" => [
188	2	":{$property}" => $entity->getId()
189	2	]
190	2	];
191		}
192
193		/**
194		* Adds the join table to the query
195		*
196		* @param Select $query
197		* @return self
198		*/
199	2	protected function addJoinTable(Select $query)
200		{
201	2	$relationTable = $this->getRelationTable();
202	2	$table = $this->getParentTableName();
203	2	$pmk = $this->getParentPrimaryKey();
204	2	$rfk = $this->getRelatedForeignKey();
205	2	$query->join(
206	2	$relationTable,
207	2	"rel.{$rfk} = {$table}.{$pmk}",
208	2	null,
209		'rel'
210	2	);
211	2	return $this;
212		}
213
214		}

slickframework / orm

Push — master ( 2a9f41...e2e9c6 )

HasAndBelongsToMany::remove() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like