KoenHoeijmakers\LaravelTranslatable\HasTranslations

Complexity

Total Complexity

32

Size/Duplication

Total Lines	291
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	20
Bugs	2	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	purgeTranslations()	0	3	1
A	getTranslationTable()	0	5	1
A	storeTranslation()	0	13	2
A	getTranslationModel()	0	5	2
A	getTranslatableAttributes()	0	3	1
A	getTranslationForeignKey()	0	3	2
A	bootHasTranslations()	0	19	2
A	translationExists()	0	3	1
A	getTranslationValue()	0	3	1
A	getLocaleKeyName()	0	5	2
A	getTranslationModelSuffix()	0	3	1
A	getTranslatable()	0	7	2
A	translations()	0	3	1
A	getLocale()	0	5	2
A	storeTranslations()	0	7	2
A	getTranslation()	0	3	1
A	formatTranslatableColumnsForSelect()	0	7	1
A	refreshTranslation()	0	17	3
A	newQueryWithoutScopes()	0	4	1
A	resolveRouteBinding()	0	5	1
A	translate()	0	9	2

<?php declare(strict_types=1);

namespace KoenHoeijmakers\LaravelTranslatable;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Support\Arr;
use KoenHoeijmakers\LaravelTranslatable\Exceptions\MissingTranslationsException;
use KoenHoeijmakers\LaravelTranslatable\Scopes\JoinTranslationScope;
use KoenHoeijmakers\LaravelTranslatable\Services\TranslationSavingService;

/**
 * Trait HasTranslations
 *
 * @mixin \Illuminate\Database\Eloquent\Model
 */
trait HasTranslations
{
    /**
     * The current locale, used to handle internal states.
     *
     * @var string|null
     */
    protected $currentLocale = null;

    /**
     * Boot the translatable trait.
     *
     * @return void
     */
    public static function bootHasTranslations()
    {
        if (config('translatable.use_saving_service', true)) {
            self::saving(function ($model) {
                app(TranslationSavingService::class)->rememberTranslationForModel($model);
            });

            self::saved(function ($model) {
                app(TranslationSavingService::class)->storeTranslationOnModel($model);

                $model->refreshTranslation();
            });
        }

        self::deleting(function ($model) {
            $model->purgeTranslations();
        });

        self::addGlobalScope(new JoinTranslationScope());
    }

    /**
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function translations(): HasMany
    {
        return $this->hasMany($this->getTranslationModel(), $this->getTranslationForeignKey());

It seems like hasMany() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Check if the translation by the given locale exists.
     *
     * @param  string $locale
     * @return bool
     */
    public function translationExists(string $locale): bool
    {
        return $this->translations()->where($this->getLocaleKeyName(), $locale)->exists();
    }

    /**
     * Purge the translations.
     *
     * @return mixed
     */
    public function purgeTranslations()
    {
        return $this->translations()->delete();
    }

    /**
     * Get the translation model.
     *
     * @return string
     */
    public function getTranslationModel(): string
    {
        return property_exists($this, 'translationModel')
            ? $this->translationModel
            : get_class($this) . $this->getTranslationModelSuffix();
    }

    /**
     * Get the translation model suffix.
     *
     * @return string
     */
    protected function getTranslationModelSuffix(): string
    {
        return 'Translation';
    }

    /**
     * Get the translation table.
     *
     * @return string
     */
    public function getTranslationTable(): string
    {
        $model = $this->getTranslationModel();

        return (new $model())->getTable();
    }

    /**
     * Get the translation foreign key.
     *
     * @return string
     */
    public function getTranslationForeignKey()
    {
        return property_exists($this, 'translationForeignKey') ? $this->translationForeignKey : $this->getForeignKey();

It seems like getForeignKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Get the translatable.
     *
     * @return array
     * @throws \KoenHoeijmakers\LaravelTranslatable\Exceptions\MissingTranslationsException
     */
    public function getTranslatable(): array
    {
        if (! isset($this->translatable)) {
            throw new MissingTranslationsException('Model "' . get_class($this) . '" is missing translations');
        }

        return $this->translatable;
    }

    /**
     * Get the translatable attributes.
     *
     * @return array
     */
    public function getTranslatableAttributes(): array
    {
        return Arr::only($this->getAttributes(), $this->translatable);

It seems like getAttributes() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * @param  string               $locale
     * @param  array<string, mixed> $attributes
     * @return \Illuminate\Database\Eloquent\Model
     */
    public function storeTranslation(string $locale, array $attributes = [])
    {
        if (! is_null($model = $this->translations()->where($this->getLocaleKeyName(), $locale)->first())) {
            $model->update($attributes);

            return $model;
        }

        $model = $this->translations()->make($attributes);
        $model->setAttribute($this->getLocaleKeyName(), $locale);
        $model->save();

        return $model;
    }

    /**
     * Store many translations at once.
     *
     * @param  array<string, array> $translations
     * @return $this
     */
    public function storeTranslations(array $translations)
    {
        foreach ($translations as $locale => $translation) {
            $this->storeTranslation($locale, $translation);
        }

        return $this;
    }

    /**
     * @param  string $locale
     * @return \Illuminate\Database\Eloquent\Model|self
     */
    public function getTranslation(string $locale)
    {
        return $this->translations()->where($this->getLocaleKeyName(), $locale)->first();
    }

    /**
     * @param  string $locale
     * @param  string $name
     * @return mixed
     */
    public function getTranslationValue(string $locale, string $name)
    {
        return $this->translations()->where($this->getLocaleKeyName(), $locale)->value($name);
    }

    /**
     * The locale key name.
     *
     * @return string
     */
    public function getLocaleKeyName(): string
    {
        return property_exists($this, 'localeKeyName')
            ? $this->localeKeyName
            : config()->get('translatable.locale_key_name', 'locale');
    }

    /**
     * Get the locale.
     *
     * @return string
     */
    public function getLocale(): string
    {
        return null !== $this->currentLocale
            ? $this->currentLocale
            : app()->getLocale();

The method getLocale() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

    }

    /**
     * Refresh the translation (in the current locale).
     *
     * @return \Illuminate\Database\Eloquent\Model|null|HasTranslations
     * @throws \KoenHoeijmakers\LaravelTranslatable\Exceptions\MissingTranslationsException
     */
    public function refreshTranslation()
    {
        if (! $this->exists) {
            return null;
        }

        $attributes = Arr::only(
            $this->newQuery()->findOrFail($this->getKey())->attributes, $this->getTranslatable()

The method newQuery() does not exist on KoenHoeijmakers\LaravelTranslatable\HasTranslations. Did you maybe mean newQueryWithoutScopes()?

It seems like getKey() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        );

        foreach ($attributes as $key => $value) {
            $this->setAttribute($key, $value);

It seems like setAttribute() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        $this->syncOriginal();

It seems like syncOriginal() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this;
    }

    /**
     * Translate the model to the given locale.
     *
     * @param  string $locale
     * @return \Illuminate\Database\Eloquent\Model|null
     */
    public function translate(string $locale)
    {
        if (! $this->exists) {
            return null;
        }

        $this->currentLocale = $locale;

        return $this->refreshTranslation();

The expression return $this->refreshTranslation() also could return the type KoenHoeijmakers\LaravelTranslatable\HasTranslations which is incompatible with the documented return type Illuminate\Database\Eloquent\Model|null.

    }

    /**
     * Format the translated columns.
     *
     * @return array
     * @throws \KoenHoeijmakers\LaravelTranslatable\Exceptions\MissingTranslationsException
     */
    public function formatTranslatableColumnsForSelect(): array
    {
        $table = $this->getTranslationTable();

        return array_map(function ($item) use ($table) {
            return $table . '.' . $item;
        }, $this->getTranslatable());
    }

    /**
     * Get a new query builder that doesn't have any global scopes (except the JoinTranslationScope).
     *
     * @return \Illuminate\Database\Eloquent\Builder
     */
    public function newQueryWithoutScopes(): Builder
    {
        return parent::newQueryWithoutScopes()
            ->withGlobalScope(JoinTranslationScope::class, new JoinTranslationScope());
    }

    /**
     * Retrieve the model for a bound value.
     *
     * @param  mixed $value
     * @param  null  $field

Are you sure the doc-type for parameter $field is correct as it would always require null to be passed?

     * @return \Illuminate\Database\Eloquent\Model|null
     */
    public function resolveRouteBinding($value, $field = null)
    {
        $field = $field ?? $this->getRouteKeyName();

It seems like getRouteKeyName() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        return $this->newQuery()->where($this->getTable() . '.' . $field, $value)->first();

It seems like getTable() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }
}