ONGR\TranslationsBundle\Service\TranslationManager

Complexity

Total Complexity

24

Size/Duplication

Total Lines	184
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	12

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
A	save()	0	8	2
C	updateMessages()	0	22	7
A	updateMessageData()	0	9	1
A	getItems()	0	14	2
A	get()	0	4	1
A	getTags()	0	4	1
A	getDomains()	0	4	1
A	getAll()	0	14	3
B	update()	0	28	5

<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <info@nfq.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\TranslationsBundle\Service;

use ONGR\ElasticsearchBundle\Result\DocumentIterator;
use ONGR\ElasticsearchDSL\Aggregation\Bucketing\TermsAggregation;
use ONGR\ElasticsearchDSL\Query\MatchAllQuery;
use ONGR\ElasticsearchDSL\Query\TermsQuery;
use ONGR\ElasticsearchBundle\Service\Repository;
use ONGR\TranslationsBundle\Document\Message;
use ONGR\TranslationsBundle\Document\Translation;
use ONGR\TranslationsBundle\Event\Events;
use ONGR\TranslationsBundle\Event\MessageUpdateEvent;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\HttpFoundation\Request;

/**
 * Handles translation objects by http requests.
 */
class TranslationManager
{
    /**
     * @var Repository
     */
    private $repository;

    /**
     * @var EventDispatcherInterface
     */
    private $dispatcher;

    /**
     * @param Repository               $repository
     * @param EventDispatcherInterface $dispatcher
     */
    public function __construct(Repository $repository, EventDispatcherInterface $dispatcher)
    {
        $this->repository = $repository;
        $this->dispatcher = $dispatcher;
    }

    /**
     * @param string $id
     *
     * @return Translation
     */
    public function get($id)
    {
        return $this->repository->find($id);
    }

    /**
     * Returns all active tags from translations
     * @return array
     */
    public function getTags()
    {
        return $this->getItems('tags');
    }

    /**
     * Returns all active domains from translations
     * @return array
     */
    public function getDomains()
    {
        return $this->getItems('domain');
    }

    /**
     * Returns all translations if filters are not specified
     *
     * @param array $filters An array with specified limitations for results
     *
     * @return DocumentIterator
     */
    public function getAll(array $filters = null)
    {
        $search = $this->repository->createSearch();
        $search->addQuery(new MatchAllQuery());
        $search->setScroll('2m');

        if ($filters) {
            foreach ($filters as $field => $value) {
                $search->addFilter(new TermsQuery($field, $value));
            }
        }

        return $this->repository->findDocuments($search);
    }

    /**
     * Edits object from translation.
     *
     * @param string $id
     * @param Request $request Http request object.
     */
    public function update($id, Request $request)
    {
        $content = json_decode($request->getContent(), true);

        if (empty($content)) {
            return;
        }

        $document = $this->get($id);

        if (isset($content['messages'])) {
            $this->updateMessages($document, $content['messages']);

$document is of type null|object<ReflectionClass>, but the function expects a object<ONGR\TranslationsBundle\Document\Translation>.

            unset($content['messages']);
        }

        try {
            foreach ($content as $key => $value) {
                $document->{'set'.ucfirst($key)}($value);
            }

            $document->setUpdatedAt(new \DateTime());
        } catch (\Error $e) {
            throw new \LogicException('Illegal variable provided for translation');
        }

        $this->repository->getManager()->persist($document);

It seems like $document defined by $this->get($id) on line 115 can be null; however, ONGR\ElasticsearchBundle\Service\Manager::persist() does not accept null, maybe add an additional type check?

        $this->repository->getManager()->commit();
    }

    /**
     * @param Translation[] $translations
     */
    public function save($translations)
    {
        foreach ($translations as $translation) {
            $this->repository->getManager()->persist($translation);
        }

        $this->repository->getManager()->commit();
    }

    /**
     * @param Translation $document
     * @param array $messages
     */
    private function updateMessages(Translation $document, array $messages)
    {
        $setMessagesLocales = array_keys($document->getMessagesArray());
        $documentMessages = $document->getMessages();

        foreach ($messages as $locale => $messageText) {
            if (!empty($messageText) && is_string($messageText)) {
                if (in_array($locale, $setMessagesLocales)) {
                    $message = $document->getMessageByLocale($locale);

                    if ($message && $message->getMessage() != $messageText) {
                        $this->dispatcher->dispatch(Events::ADD_HISTORY, new MessageUpdateEvent($document, $message));
                        $this->updateMessageData($message, $locale, $messages[$locale]);
                    }
                } else {
                    $documentMessages[] = $this->updateMessageData(new Message(), $locale, $messageText);
                }
            }
        }

        $document->setMessages($documentMessages);

$documentMessages is of type array<integer,object<ONGR\TranslationsBundle\Document\Message>>, but the function expects a null|object<ONGR\ElasticsearchBundle\Collection\Collection>.

    }

    /**
     * @param Message   $message
     * @param string    $locale
     * @param string    $text
     *
     * @return Message
     */
    private function updateMessageData(Message $message, $locale, $text)
    {
        $message->setLocale($locale);
        $message->setStatus(Message::DIRTY);
        $message->setMessage($text);
        $message->setUpdatedAt(new \DateTime());

        return $message;
    }

    /**
     * Returns a list of available tags or domains
     *
     * @param string $type
     * @return array
     */
    private function getItems($type)
    {
        $search = $this->repository->createSearch();
        $search->addAggregation(new TermsAggregation($type, $type));
        $result = $this->repository->findDocuments($search);
        $aggregation = $result->getAggregation($type);
        $items = [];

        foreach ($aggregation as $item) {

The expression $aggregation of type null|object<ONGR\ElasticsearchBundle\Result\Aggregation\AggregationValue> is not guaranteed to be traversable. How about adding an additional type check?

            $items[] = $item['key'];
        }

        return $items;
    }
}