Bludata\Doctrine\ODM\MongoDB\Repositories\BaseRepository

Complexity

Total Complexity

28

Size/Duplication

Total Lines	179
Duplicated Lines	100 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes

0

18 Methods

Rating	Name	Duplication	Size	Complexity
A	preSave()	4	4	1
A	postSave()	4	4	1
A	preFlush()	4	4	1
	getMessageNotFound()	1	1	?
A	validate()	20	20	3
A	getClassMetadata()	4	4	1
A	getEntityName()	4	4	1
A	createEntity()	4	4	1
A	createQueryWorker()	4	4	1
A	query()	4	4	1
A	findAll()	4	4	1
A	findOneBy()	10	10	3
A	find()	4	4	2
C	findOrCreate()	26	26	7
A	remove()	8	8	1
A	save()	6	6	1
A	flush()	6	6	1
A	em()	4	4	1

<?php

namespace Bludata\Doctrine\ODM\MongoDB\Repositories;

use Bludata\Doctrine\Common\Interfaces\BaseEntityInterface;
use Bludata\Doctrine\Common\Interfaces\BaseRepositoryInterface;
use Bludata\Doctrine\ORM\Repositories\QueryWorker;
use Doctrine\ODM\MongoDB\DocumentRepository;
use Symfony\Component\Validator\ValidatorBuilder;

abstract class BaseRepository extends DocumentRepository implements BaseRepositoryInterface

This class seems to be duplicated in your project.

This line exceeds maximum limit of 80 characters; contains 91 characters

{
    /**
     * 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;
    }

    /**
     * Método executado no evento ORM\PreFlush.
     */
    public function preFlush(BaseEntityInterface $entity)
    {
        return $this;
    }

    abstract public function getMessageNotFound();

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    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));
        }

        return true;
    }

    public function getClassMetadata()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return parent::getClassMetadata();
    }

    public function getEntityName()

The return type could not be reliably inferred; please add a @return annotation.

    {
        return parent::getDocumentName();

It seems like you call parent on a different method (getDocumentName() instead of getEntityName()). Are you sure this is correct? If so, you might want to change this to $this->getDocumentName().

    }

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

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

    public function query()

The return type could not be reliably inferred; please add a @return annotation.

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

    /**
     * @return QueryWorker
     */
    public function findAll()
    {
        return $this->createQueryWorker();
    }

    public function findOneBy(array $filters, $abort = true)

The return type could not be reliably inferred; please add a @return annotation.

    {
        $entity = parent::findOneBy($filters);

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

        return $entity;
    }

    public function find($id, $abort = true)

The return type could not be reliably inferred; please add a @return annotation.

    {
        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

This line exceeds maximum limit of 80 characters; contains 105 characters

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

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

Consider using a different name than the parameter $input. This often makes code more readable.

            }
        }

        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;
        }

        return $this->find($input);
    }

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

This line exceeds maximum limit of 80 characters; contains 105 characters

     *
     * @return Bludata\Entities\BaseEntityInterface
     */
    public function remove($target)
    {
        $entity = $this->find($target);

        $this->em()->remove($entity);

        return $entity;
    }

    /**
     * @param Bludata\Entities\BaseEntityInterface $entity

Should the type for parameter $entity not be BaseEntityInterface?

     *
     * @return Bludata\Repositories\QueryWorker
     */
    public function save(BaseEntityInterface $entity)
    {
        $this->em()->persist($entity);

        return $this;
    }

    /**
     * @param Bludata\Entities\BaseEntityInterface $entity

Should the type for parameter $entity not be null|BaseEntityInterface?

     *
     * @return Bludata\Repositories\QueryWorker
     */
    public function flush(BaseEntityInterface $entity = null)
    {
        $this->em()->flush($entity);

        return $this;
    }

    public function em()

The return type could not be reliably inferred; please add a @return annotation.

This method's name is shorter than the configured minimum length of 3 characters.

    {
        return parent::getDocumentManager();

It seems like you call parent on a different method (getDocumentManager() instead of em()). Are you sure this is correct? If so, you might want to change this to $this->getDocumentManager().

    }
}