Omatech\Mage\Core\Domains\Translations\Translation

Complexity

Total Complexity

29

Size/Duplication

Total Lines	260
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

100%

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	getId()	0	4	1
A	setId()	0	6	1
A	getGroup()	0	4	1
A	getKey()	0	4	1
A	setKey()	0	14	2
A	setTranslation()	0	6	1
A	getTranslations()	0	4	1
A	setTranslations()	0	8	2
A	getLocales()	0	13	3
A	setMissingTranslations()	0	8	3
A	getSyncAt()	0	4	1
A	setSyncAt()	0	6	1
A	getCreatedAt()	0	4	1
A	setCreatedAt()	0	6	1
A	getUpdatedAt()	0	4	1
A	setUpdatedAt()	0	6	1
A	all()	0	4	1
A	find()	0	7	2
A	save()	0	6	1
A	delete()	0	4	1
A	export()	0	9	1
A	import()	0	8	1

<?php

namespace Omatech\Mage\Core\Domains\Translations;

use Omatech\Mage\Core\Domains\Shared\Traits\FromArray;
use Omatech\Mage\Core\Domains\Translations\Contracts\AllTranslationInterface;
use Omatech\Mage\Core\Domains\Translations\Contracts\ExportTranslationInterface;
use Omatech\Mage\Core\Domains\Translations\Contracts\FindTranslationInterface;
use Omatech\Mage\Core\Domains\Translations\Contracts\ImportTranslationInterface;
use Omatech\Mage\Core\Domains\Translations\Contracts\TranslationInterface;
use Omatech\Mage\Core\Domains\Translations\Features\ExistsAndDeleteTranslation;
use Omatech\Mage\Core\Domains\Translations\Features\FindOrFailTranslation;
use Omatech\Mage\Core\Domains\Translations\Features\UpdateOrCreateTranslation;
use Omatech\Mage\Core\Domains\Translations\Jobs\ExportTranslation;
use Omatech\Mage\Core\Domains\Translations\Jobs\ImportTranslation;

class Translation implements TranslationInterface
{
    use FromArray;

    private $id;
    private $group;
    private $key;
    private $translations = [];
    private $syncAt;
    private $createdAt;
    private $updatedAt;

    /**
     * @return int|null
     */
    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * @param int $id
     * @return $this
     */
    public function setId(int $id)
    {
        $this->id = $id;

        return $this;
    }

    /**
     * @return string
     */
    public function getGroup(): string
    {
        return $this->group;
    }

    /**
     * @return string
     */
    public function getKey(): string
    {
        return $this->key;
    }

    /**
     * @param string $key
     * @return $this
     */
    public function setKey(string $key)
    {
        $key = explode('.', $key);

        if (count($key) > 1) {
            $this->group = $key[0];
            $this->key = implode('.', array_slice($key, 1));
        } else {
            $this->group = 'single';
            $this->key = $key[0];
        }

        return $this;
    }

    /**
     * @param string $language
     * @param string $text
     * @return $this
     */
    public function setTranslation(string $language, string $text)
    {
        $this->translations[$language] = $text;

        return $this;
    }

    /**
     * @return array
     */
    public function getTranslations(): array
    {
        return $this->translations;
    }

    /**
     * @param array $translations
     * @return $this
     */
    public function setTranslations(array $translations)
    {
        foreach ($translations as $language => $text) {
            $this->setTranslation($language, $text);
        }

        return $this;
    }

    /**
     * @return array
     */
    private static function getLocales(): array
    {
        $availableLocales = config('mage.translations.available_locales');
        $locales = [];

        foreach ($availableLocales as $locale) {
            if (! array_key_exists($locale['locale'], $locales)) {
                $locales[] = $locale['locale'];
            }
        }

        return $locales;
    }

    /**
     * @return void
     */
    private function setMissingTranslations(): void
    {
        foreach (static::getLocales() as $locale) {

Since getLocales() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of getLocales() to at least protected.

            if (! array_key_exists($locale, $this->getTranslations())) {
                $this->setTranslation($locale, $this->getGroup().'.'.$this->getKey());
            }
        }
    }

    /**
     * @return string
     */
    public function getSyncAt(): ?string
    {
        return $this->syncAt;
    }

    /**
     * @param string|null $syncAt
     * @return $this
     */
    public function setSyncAt(?string $syncAt)
    {
        $this->syncAt = $syncAt;

        return $this;
    }

    /**
     * @return string
     */
    public function getCreatedAt(): string
    {
        return $this->createdAt;
    }

    /**
     * @param string $createdAt
     * @return $this
     */
    public function setCreatedAt(string $createdAt)
    {
        $this->createdAt = $createdAt;

        return $this;
    }

    /**
     * @return string
     */
    public function getUpdatedAt(): string
    {
        return $this->updatedAt;
    }

    /**
     * @param string $updatedAt
     * @return $this
     */
    public function setUpdatedAt(string $updatedAt)
    {
        $this->updatedAt = $updatedAt;

        return $this;
    }

    /**
     * @param AllTranslationInterface $all
     * @return mixed
     */
    public static function all(AllTranslationInterface $all)
    {
        return $all->get(static::getLocales());

Since getLocales() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of getLocales() to at least protected.

    }

    /**
     * @param FindTranslationInterface $find
     * @param array $params
     * @return $this
     */
    public static function find(FindTranslationInterface $find, array $params): self
    {
        if (isset($params['key'])) {
            $params['key'] = strtolower(str_replace(' ', '.', $params['key']));
        }
        return (new FindOrFailTranslation())->make($find, $params);
    }

    /**
     * @return bool
     * @throws Exceptions\TranslationAlreadyExistsException
     * @throws Exceptions\TranslationDoesNotExistsException
     * @throws Exceptions\TranslationExistsMustBeUniqueException
     */
    public function save(): bool
    {
        $this->setMissingTranslations();

        return (new UpdateOrCreateTranslation())->make($this);
    }

    /**
     * @throws Exceptions\TranslationDoesNotExistsException
     */
    public function delete(): bool
    {
        return (new ExistsAndDeleteTranslation())->make($this);
    }

    /**
     * @param AllTranslationInterface $all
     * @param ExportTranslationInterface $export
     * @param array|null $locales
     * @return string
     */
    public static function export(
        AllTranslationInterface $all,
        ExportTranslationInterface $export,
        array $locales = null
    ) {
        $locales = $locales ?? static::getLocales();

Since getLocales() is declared private, calling it with static will lead to errors in possible sub-classes. You can either use self, or increase the visibility of getLocales() to at least protected.

        return (new ExportTranslation())->make($all, $export, $locales);
    }

    /**
     * @param FindTranslationInterface $find
     * @param ImportTranslationInterface $import
     * @param string $path
     * @param string $locale
     * @return bool
     */
    public static function import(
        FindTranslationInterface $find,
        ImportTranslationInterface $import,
        string $path,
        string $locale = ''
    ) {
        return (new ImportTranslation())->make($find, $import, $path, $locale);
    }
}