BaseRepository::postSave() - Code Metrics - Inspection of "suporte aos eventos postPersist e postUpdate" - raivieira/base-api-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 14edcf...67a112 )

by Rai

created 2017-02-01 18:23 UTC

BaseRepository::postSave() A

↳ Parent: BaseRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
nc	1
cc	1
eloc	2
nop	1
rs	10

<?php

namespace Bludata\Doctrine\ORM\Repositories;

use Bludata\Doctrine\Common\Interfaces\BaseEntityInterface;
use Bludata\Doctrine\Common\Interfaces\BaseRepositoryInterface;
use Doctrine\ORM\EntityRepository;
use Symfony\Component\Validator\ValidatorBuilder;

abstract class BaseRepository extends EntityRepository implements BaseRepositoryInterface

{
    /**
     * Método executado nos eventos ORM\PrePersist e ORM\PreUpdate
     */
    public function preSave(BaseEntityInterface $entity)
    {
        return $this;
    }

    /**
     * Método executado nos eventos ORM\PostPersist e ORM\PostUpdate
     */
    public function postSave(BaseEntityInterface $entity)
    {
        return $this;
    }

    public function validate(BaseEntityInterface $entity)
    {
        $validator = (new ValidatorBuilder())
                    ->enableAnnotationMapping()
                    ->getValidator();

        $violations = $validator->validate($entity);

        $errors = [];

        if (count($violations)) {
            foreach ($violations as $violation) {
                $errors[] = $violation->getMessage();
            }

            abort(400, json_encode($errors));
        }
    }

    public function getClassMetadata()
    {
        return parent::getClassMetadata();
    }

    public function getEntityName()
    {
        return parent::getEntityName();
    }

    public function createEntity()
    {
        return app($this->getEntityName());
    }

    public function createQueryWorker()
    {
        return new QueryWorker($this);
    }

    public function query()
    {
        return $this->createQueryBuilder('t');
    }

    /**
     * @return QueryWorker
     */
    public function findAll()
    {
        return $this->createQueryWorker();
class Author {
    private $name;

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

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

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    public function findOneBy(array $filters, $abort = true)
    {
        $entity = parent::findOneBy($filters);

        if (!$entity && $abort) {
            abort(404, $this->getMessageNotFound());
        }

        return $entity;
    }

    public function find($id, $abort = true)
    {
        return is_object($id) ? $id : $this->findOneBy(['id' => $id], $abort);
    }

    /**
     * Inserir ou atualizar um registro.
     *
     * @param null | string | int | array
     *
     * @throws InvalidArgumentException Se $input não for null | string | int | array é lançada a exceção

     */
    public function findOrCreate($input)
    {
        if (is_null($input)) {
            return $input;
        }

        if (is_string($input)) {
            $input = json_decode($input, true);

        }

        if (is_numeric($input)) {
            return $this->find($input);
        }

        if (is_array($input)) {
            if (array_key_exists('id', $input) && $input['id']) {
                $object = $this->find($input['id']);
            } else {
                $object = $this->createEntity();
            }

            $object->setPropertiesEntity($input);

            return $object;
        }

        throw new InvalidArgumentException('O parâmetro $input pode ser um null | string | int | array');

    }

    /**
     * Marcar um registro como deletado.
     *
     * @param object | int $target
     *
     * @throws Symfony\Component\HttpKernel\Exception\NotFoundHttpException Se $target não for encontrado

     *
     * Bludata\Doctrine\Common\Interfaces
     */
    public function remove($target)
    {
        $entity = $this->find($target);

        $this->em()->remove($entity);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        return $entity;
    }

    /**
     * @param Bludata\Doctrine\Common\Interfaces\BaseEntityInterface $entity

     *
     * @return Bludata\Doctrine\ORM\Repositories\QueryWorker

     */
    public function save(BaseEntityInterface $entity)
    {
        $this->em()->persist($entity);

        return $this;
    }

    /**
     * @param Bludata\Doctrine\Common\Interfaces\BaseEntityInterface $entity

     *
     * @return Bludata\Doctrine\ORM\Repositories\QueryWorker

     */
    public function flush(BaseEntityInterface $entity = null)
    {
        $this->em()->flush($entity);

        return $this;
    }

    public function em()

    {
        return parent::getEntityManager();
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
    }
}


1			<?php
2
3			namespace Bludata\Doctrine\ORM\Repositories;
4
5			use Bludata\Doctrine\Common\Interfaces\BaseEntityInterface;
6			use Bludata\Doctrine\Common\Interfaces\BaseRepositoryInterface;
7			use Doctrine\ORM\EntityRepository;
8			use Symfony\Component\Validator\ValidatorBuilder;
9
10			abstract class BaseRepository extends EntityRepository implements BaseRepositoryInterface
			0 ignored issues – show Coding Style introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 89 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
11			{
12			/**
13			* Método executado nos eventos ORM\PrePersist e ORM\PreUpdate
14			*/
15			public function preSave(BaseEntityInterface $entity)
16			{
17			return $this;
18			}
19
20			/**
21			* Método executado nos eventos ORM\PostPersist e ORM\PostUpdate
22			*/
23			public function postSave(BaseEntityInterface $entity)
24			{
25			return $this;
26			}
27
28			public function validate(BaseEntityInterface $entity)
29			{
30			$validator = (new ValidatorBuilder())
31			->enableAnnotationMapping()
32			->getValidator();
33
34			$violations = $validator->validate($entity);
35
36			$errors = [];
37
38			if (count($violations)) {
39			foreach ($violations as $violation) {
40			$errors[] = $violation->getMessage();
41			}
42
43			abort(400, json_encode($errors));
44			}
45			}
46
47			public function getClassMetadata()
48			{
49			return parent::getClassMetadata();
50			}
51
52			public function getEntityName()
53			{
54			return parent::getEntityName();
55			}
56
57			public function createEntity()
58			{
59			return app($this->getEntityName());
60			}
61
62			public function createQueryWorker()
63			{
64			return new QueryWorker($this);
65			}
66
67			public function query()
68			{
69			return $this->createQueryBuilder('t');
70			}
71
72			/**
73			* @return QueryWorker
74			*/
75			public function findAll()
76			{
77			return $this->createQueryWorker();
			0 ignored issues – show Bug Best Practice introduced 2016-09-06 13:00 UTC by Report Bug Copy Issue Report The return type of `return $this->createQueryWorker();` (`Bludata\Doctrine\ORM\Repositories\QueryWorker`) is incompatible with the return type declared by the interface `Doctrine\Common\Persiste...jectRepository::findAll` of type `array`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
78			}
79
80			public function findOneBy(array $filters, $abort = true)
81			{
82			$entity = parent::findOneBy($filters);
83
84			if (!$entity && $abort) {
85			abort(404, $this->getMessageNotFound());
86			}
87
88			return $entity;
89			}
90
91			public function find($id, $abort = true)
92			{
93			return is_object($id) ? $id : $this->findOneBy(['id' => $id], $abort);
94			}
95
96			/**
97			* Inserir ou atualizar um registro.
98			*
99			* @param null \| string \| int \| array
100			*
101			* @throws InvalidArgumentException Se $input não for null \| string \| int \| array é lançada a exceção
			0 ignored issues – show Coding Style introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 105 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
102			*/
103			public function findOrCreate($input)
104			{
105			if (is_null($input)) {
106			return $input;
107			}
108
109			if (is_string($input)) {
110			$input = json_decode($input, true);
			0 ignored issues – show Coding Style introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report Consider using a different name than the parameter `$input`. This often makes code more readable. Loading history...
111			}
112
113			if (is_numeric($input)) {
114			return $this->find($input);
115			}
116
117			if (is_array($input)) {
118			if (array_key_exists('id', $input) && $input['id']) {
119			$object = $this->find($input['id']);
120			} else {
121			$object = $this->createEntity();
122			}
123
124			$object->setPropertiesEntity($input);
125
126			return $object;
127			}
128
129			throw new InvalidArgumentException('O parâmetro $input pode ser um null \| string \| int \| array');
			0 ignored issues – show Coding Style introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 105 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
130			}
131
132			/**
133			* Marcar um registro como deletado.
134			*
135			* @param object \| int $target
136			*
137			* @throws Symfony\Component\HttpKernel\Exception\NotFoundHttpException Se $target não for encontrado
			0 ignored issues – show Coding Style introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report This line exceeds maximum limit of 80 characters; contains 105 characters Overly long lines are hard to read on any screen. Most code styles therefor impose a maximum limit on the number of characters in a line. Loading history...
138			*
139			* Bludata\Doctrine\Common\Interfaces
140			*/
141			public function remove($target)
142			{
143			$entity = $this->find($target);
144
145			$this->em()->remove($entity);
			0 ignored issues – show Bug introduced 2016-09-06 13:00 UTC by Report Bug Copy Issue Report It seems like `$entity` defined by `$this->find($target)` on line `143` can also be of type `null`; however, `Doctrine\ORM\EntityManager::remove()` 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...
146
147			return $entity;
148			}
149
150			/**
151			* @param Bludata\Doctrine\Common\Interfaces\BaseEntityInterface $entity
			0 ignored issues – show Documentation introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report Should the type for parameter `$entity` not be `BaseEntityInterface`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
152			*
153			* @return Bludata\Doctrine\ORM\Repositories\QueryWorker
			0 ignored issues – show Documentation introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report Should the return type not be `BaseRepository`? 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...
154			*/
155			public function save(BaseEntityInterface $entity)
156			{
157			$this->em()->persist($entity);
158
159			return $this;
160			}
161
162			/**
163			* @param Bludata\Doctrine\Common\Interfaces\BaseEntityInterface $entity
			0 ignored issues – show Documentation introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report Should the type for parameter `$entity` not be `null\|BaseEntityInterface`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
164			*
165			* @return Bludata\Doctrine\ORM\Repositories\QueryWorker
			0 ignored issues – show Documentation introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report Should the return type not be `BaseRepository`? 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...
166			*/
167			public function flush(BaseEntityInterface $entity = null)
168			{
169			$this->em()->flush($entity);
170
171			return $this;
172			}
173
174			public function em()
			0 ignored issues – show Coding Style introduced 2016-09-06 13:58 UTC by Report Bug Copy Issue Report This method's name is shorter than the configured minimum length of `3` characters. Even though PHP does not care about the name of your methods, it is generally a good practice to choose method names which can be easily understood by other human readers. Loading history...
175			{
176			return parent::getEntityManager();
			0 ignored issues – show Comprehensibility Bug introduced 2016-09-06 13:00 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`getEntityManager()` instead of `em()`). Are you sure this is correct? If so, you might want to change this to `$this->getEntityManager()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
177			}
178			}
179

raivieira / base-api-php

Push — master ( 14edcf...67a112 )

BaseRepository::postSave() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like