Dimsav\Translatable\Translatable::save()

Complexity

Conditions	6
Paths	5

Size

Total Lines

24

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	6.027

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	Translatable::useFallback()	0	8	3
A	Translatable::isTranslationAttribute()	0	4	1
A	Translatable::isKeyALocale()	0	4	1

<?php

namespace Dimsav\Translatable;

use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Query\JoinClause;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Database\Query\Builder as QueryBuilder;
use Illuminate\Support\Str;

/**
 * @property-read Collection|Model[] $translations
 * @property-read string $translationModel
 * @property-read string $translationForeignKey
 * @property-read string $localeKey
 * @property-read bool $useTranslationFallback
 *
 * @mixin Model
 */
trait Translatable
{
    protected static $autoloadTranslations = null;

    protected $defaultLocale;

    public static function bootTranslatable(): void
    {
        static::saved(function (Model $model) {
            /* @var Translatable $model */
            return $model->saveTranslations();
        });
    }

    public function translate(?string $locale = null, bool $withFallback = false): ?Model
    {
        return $this->getTranslation($locale, $withFallback);
    }

    public function translateOrDefault(?string $locale = null): ?Model
    {
        return $this->getTranslation($locale, true);
    }

    public function translateOrNew(?string $locale = null): Model
    {
        return $this->getTranslationOrNew($locale);
    }

    public function getTranslation(?string $locale = null, bool $withFallback = null): ?Model
    {
        $configFallbackLocale = $this->getFallbackLocale();
        $locale = $locale ?: $this->locale();
        $withFallback = $withFallback === null ? $this->useFallback() : $withFallback;
        $fallbackLocale = $this->getFallbackLocale($locale);

        if ($translation = $this->getTranslationByLocaleKey($locale)) {
            return $translation;
        }
        if ($withFallback && $fallbackLocale) {
            if ($translation = $this->getTranslationByLocaleKey($fallbackLocale)) {
                return $translation;
            }
            if ($fallbackLocale !== $configFallbackLocale && $translation = $this->getTranslationByLocaleKey($configFallbackLocale)) {
                return $translation;
            }
        }

        return null;
    }

    public function hasTranslation(?string $locale = null): bool
    {
        $locale = $locale ?: $this->locale();

        foreach ($this->translations as $translation) {
            if ($translation->getAttribute($this->getLocaleKey()) == $locale) {
                return true;
            }
        }

        return false;
    }

    public function getTranslationModelName(): string
    {
        return $this->translationModel ?: $this->getTranslationModelNameDefault();
    }

    public function getTranslationModelNameDefault(): string
    {
        $modelName = get_class($this);

        if ($namespace = $this->getTranslationModelNamespace()) {
            $modelName = $namespace.'\\'.class_basename(get_class($this));
        }

        return $modelName.config('translatable.translation_suffix', 'Translation');
    }

    public function getTranslationModelNamespace(): ?string
    {
        return config('translatable.translation_model_namespace');
    }

    public function getRelationKey(): string
    {
        if ($this->translationForeignKey) {
            return $this->translationForeignKey;
        }

        return $this->getForeignKey();

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

    }

    public function getLocaleKey(): string
    {
        return $this->localeKey ?: config('translatable.locale_key', 'locale');
    }

    public function translations(): HasMany
    {
        return $this->hasMany($this->getTranslationModelName(), $this->getRelationKey());

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

    }

    private function usePropertyFallback(): bool
    {
        return $this->useFallback() && config('translatable.use_property_fallback', false);
    }

    private function getAttributeOrFallback(?string $locale, string $attribute)
    {
        $translation = $this->getTranslation($locale);

        if (
            (
                ! $translation instanceof Model
                || $this->isEmptyTranslatableAttribute($attribute, $translation->$attribute)
            )
            && $this->usePropertyFallback()
        ) {
            $translation = $this->getTranslation($this->getFallbackLocale(), false);
        }

        if ($translation instanceof Model) {
            return $translation->$attribute;
        }

        return null;
    }

    protected function isEmptyTranslatableAttribute(string $key, $value): bool

The parameter $key is not used and could be removed.

    {
        return empty($value);
    }

    public function getAttribute(string $key)
    {
        [$attribute, $locale] = $this->getAttributeAndLocale($key);

The variable $attribute does not exist. Did you forget to declare it?

The variable $locale does not exist. Did you forget to declare it?

        if ($this->isTranslationAttribute($attribute)) {
            if ($this->getTranslation($locale) === null) {
                return $this->getAttributeValue($attribute);

The method getAttributeValue() does not exist on Dimsav\Translatable\Translatable. Did you maybe mean getAttribute()?

            }

            // If the given $attribute has a mutator, we push it to $attributes and then call getAttributeValue
            // on it. This way, we can use Eloquent's checking for Mutation, type casting, and
            // Date fields.
            if ($this->hasGetMutator($attribute)) {

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

                $this->attributes[$attribute] = $this->getAttributeOrFallback($locale, $attribute);

The property attributes does not exist. Did you maybe forget to declare it?

                return $this->getAttributeValue($attribute);

The method getAttributeValue() does not exist on Dimsav\Translatable\Translatable. Did you maybe mean getAttribute()?

            }

            return $this->getAttributeOrFallback($locale, $attribute);
        }

        return parent::getAttribute($key);
    }

    public function setAttribute(string $key, $value)
    {
        [$attribute, $locale] = $this->getAttributeAndLocale($key);

The variable $attribute does not exist. Did you forget to declare it?

The variable $locale does not exist. Did you forget to declare it?

        if ($this->isTranslationAttribute($attribute)) {
            $this->getTranslationOrNew($locale)->$attribute = $value;
        } else {
            return parent::setAttribute($key, $value);
        }

        return $this;
    }

    protected function getTranslationOrNew(?string $locale = null): Model
    {
        $locale = $locale ?: $this->locale();

        if (($translation = $this->getTranslation($locale, false)) === null) {
            $translation = $this->getNewTranslation($locale);
        }

        return $translation;
    }

    public function fill(array $attributes)
    {
        foreach ($attributes as $key => $values) {
            if ($this->isKeyALocale($key)) {
                $this->getTranslationOrNew($key)->fill($values);
                unset($attributes[$key]);
            } else {
                [$attribute, $locale] = $this->getAttributeAndLocale($key);

The variable $attribute does not exist. Did you mean $attributes?

The variable $locale does not exist. Did you forget to declare it?

                if ($this->isTranslationAttribute($attribute) and $this->isKeyALocale($locale)) {

The variable $attribute does not exist. Did you mean $attributes?

                    $this->getTranslationOrNew($locale)->fill([$attribute => $values]);

The variable $attribute does not exist. Did you mean $attributes?

                    unset($attributes[$key]);
                }
            }
        }

        return parent::fill($attributes);
    }

    private function getTranslationByLocaleKey(string $key): ?Model
    {
        foreach ($this->translations as $translation) {
            if ($translation->getAttribute($this->getLocaleKey()) == $key) {
                return $translation;
            }
        }

        return null;
    }

    private function getFallbackLocale(?string $locale = null): ?string
    {
        if ($locale && $this->isLocaleCountryBased($locale)) {
            if ($fallback = $this->getLanguageFromCountryBasedLocale($locale)) {
                return $fallback;
            }
        }

        return config('translatable.fallback_locale');
    }

    private function isLocaleCountryBased(string $locale): bool
    {
        return $this->getLocalesHelper()->isLocaleCountryBased($locale);
    }

    private function getLanguageFromCountryBasedLocale(string $locale): string
    {
        return $this->getLocalesHelper()->getLanguageFromCountryBasedLocale($locale);
    }

    private function useFallback(): bool
    {
        if (isset($this->useTranslationFallback) && $this->useTranslationFallback !== null) {
            return $this->useTranslationFallback;
        }

        return (bool) config('translatable.use_fallback');
    }

    public function isTranslationAttribute(string $key): bool
    {
        return in_array($key, $this->translatedAttributes);

The property translatedAttributes does not seem to exist. Did you mean attributes?

    }

    protected function isKeyALocale(string $key): bool
    {
        return $this->getLocalesHelper()->has($key);
    }

    protected function getLocales(): array
    {
        return $this->getLocalesHelper()->all();
    }

    protected function getLocaleSeparator(): string
    {
        return $this->getLocalesHelper()->getLocaleSeparator();
    }

    protected function saveTranslations(): bool
    {
        $saved = true;

        if (! $this->relationLoaded('translations')) {

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

            return $saved;
        }

        foreach ($this->translations as $translation) {
            if ($saved && $this->isTranslationDirty($translation)) {
                if (! empty($connectionName = $this->getConnectionName())) {

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

                    $translation->setConnection($connectionName);
                }

                $translation->setAttribute($this->getRelationKey(), $this->getKey());

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

                $saved = $translation->save();
            }
        }

        return $saved;
    }

    public function replicateWithTranslations(array $except = null): Model
    {
        $newInstance = parent::replicate($except);

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

        unset($newInstance->translations);
        foreach ($this->translations as $translation) {
            $newTranslation = $translation->replicate();
            $newInstance->translations->add($newTranslation);
        }

        return $newInstance;
    }

    protected function isTranslationDirty(Model $translation): bool
    {
        $dirtyAttributes = $translation->getDirty();
        unset($dirtyAttributes[$this->getLocaleKey()]);

        return count($dirtyAttributes) > 0;
    }

    public function getNewTranslation(string $locale): Model
    {
        $modelName = $this->getTranslationModelName();
        $translation = new $modelName();
        $translation->setAttribute($this->getLocaleKey(), $locale);
        $this->translations->add($translation);

        return $translation;
    }

    public function __isset($key)
    {
        return $this->isTranslationAttribute($key) || parent::__isset($key);
    }

    public function scopeTranslatedIn(Builder $query, ?string $locale = null)
    {
        $locale = $locale ?: $this->locale();

        return $query->whereHas('translations', function (Builder $q) use ($locale) {
            $q->where($this->getLocaleKey(), '=', $locale);
        });
    }

    public function scopeNotTranslatedIn(Builder $query, ?string $locale = null)
    {
        $locale = $locale ?: $this->locale();

        return $query->whereDoesntHave('translations', function (Builder $q) use ($locale) {
            $q->where($this->getLocaleKey(), '=', $locale);
        });
    }

    public function scopeTranslated(Builder $query)
    {
        return $query->has('translations');
    }

    public function scopeListsTranslations(Builder $query, string $translationField)
    {
        $withFallback = $this->useFallback();
        $translationTable = $this->getTranslationsTable();
        $localeKey = $this->getLocaleKey();

        $query

The method select() does not exist on Illuminate\Database\Eloquent\Builder. Did you maybe mean createSelectWithConstraint()?

            ->select($this->getTable().'.'.$this->getKeyName(), $translationTable.'.'.$translationField)

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

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

            ->leftJoin($translationTable, $translationTable.'.'.$this->getRelationKey(), '=', $this->getTable().'.'.$this->getKeyName())

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

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

            ->where($translationTable.'.'.$localeKey, $this->locale());
        if ($withFallback) {
            $query->orWhere(function (Builder $q) use ($translationTable, $localeKey) {
                $q->where($translationTable.'.'.$localeKey, $this->getFallbackLocale())
                  ->whereNotIn($translationTable.'.'.$this->getRelationKey(), function (QueryBuilder $q) use (
                      $translationTable,
                      $localeKey
                  ) {
                      $q->select($translationTable.'.'.$this->getRelationKey())
                        ->from($translationTable)
                        ->where($translationTable.'.'.$localeKey, $this->locale());
                  });
            });
        }
    }

    public function scopeWithTranslation(Builder $query)
    {
        $query->with([
            'translations' => function (Relation $query) {
                if ($this->useFallback()) {
                    $locale = $this->locale();
                    $countryFallbackLocale = $this->getFallbackLocale($locale); // e.g. de-DE => de
                    $locales = array_unique([$locale, $countryFallbackLocale, $this->getFallbackLocale()]);

                    return $query->whereIn($this->getTranslationsTable().'.'.$this->getLocaleKey(), $locales);

The method whereIn() does not exist on Illuminate\Database\Eloquent\Relations\Relation. Did you maybe mean whereInMethod()?

                }

                return $query->where($this->getTranslationsTable().'.'.$this->getLocaleKey(), $this->locale());
            },
        ]);
    }

    public function scopeWhereTranslation(Builder $query, string $translationField, $value, ?string $locale = null)
    {
        return $query->whereHas('translations', function (Builder $query) use ($translationField, $value, $locale) {
            $query->where($this->getTranslationsTable().'.'.$translationField, $value);
            if ($locale) {
                $query->where($this->getTranslationsTable().'.'.$this->getLocaleKey(), $locale);
            }
        });
    }

    public function scopeOrWhereTranslation(Builder $query, string $translationField, $value, ?string $locale = null)
    {
        return $query->orWhereHas('translations', function (Builder $query) use ($translationField, $value, $locale) {
            $query->where($this->getTranslationsTable().'.'.$translationField, $value);
            if ($locale) {
                $query->where($this->getTranslationsTable().'.'.$this->getLocaleKey(), $locale);
            }
        });
    }

    public function scopeWhereTranslationLike(Builder $query, string $translationField, $value, ?string $locale = null)
    {
        return $query->whereHas('translations', function (Builder $query) use ($translationField, $value, $locale) {
            $query->where($this->getTranslationsTable().'.'.$translationField, 'LIKE', $value);
            if ($locale) {
                $query->where($this->getTranslationsTable().'.'.$this->getLocaleKey(), 'LIKE', $locale);
            }
        });
    }

    public function scopeOrWhereTranslationLike(Builder $query, string $translationField, $value, ?string $locale = null)
    {
        return $query->orWhereHas('translations', function (Builder $query) use ($translationField, $value, $locale) {
            $query->where($this->getTranslationsTable().'.'.$translationField, 'LIKE', $value);
            if ($locale) {
                $query->where($this->getTranslationsTable().'.'.$this->getLocaleKey(), 'LIKE', $locale);
            }
        });
    }

    public function scopeOrderByTranslation(Builder $query, string $translationField, string $sortMethod = 'asc')
    {
        $translationTable = $this->getTranslationsTable();
        $localeKey = $this->getLocaleKey();
        $table = $this->getTable();

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

        $keyName = $this->getKeyName();

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

        return $query
            ->join($translationTable, function (JoinClause $join) use ($translationTable, $localeKey, $table, $keyName) {
                $join
                    ->on($translationTable.'.'.$this->getRelationKey(), '=', $table.'.'.$keyName)
                    ->where($translationTable.'.'.$localeKey, $this->locale());
            })
            ->orderBy($translationTable.'.'.$translationField, $sortMethod)
            ->select($table.'.*')
            ->with('translations');
    }

    public function attributesToArray()
    {
        $attributes = parent::attributesToArray();

        if (
            (! $this->relationLoaded('translations') && ! $this->toArrayAlwaysLoadsTranslations() && is_null(self::$autoloadTranslations))

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

            || self::$autoloadTranslations === false
        ) {
            return $attributes;
        }

        $hiddenAttributes = $this->getHidden();

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

        foreach ($this->translatedAttributes as $field) {

The property translatedAttributes does not seem to exist. Did you mean attributes?

            if (in_array($field, $hiddenAttributes)) {
                continue;
            }

            $attributes[$field] = $this->getAttributeOrFallback(null, $field);
        }

        return $attributes;
    }

    public function getTranslationsArray(): array
    {
        $translations = [];

        foreach ($this->translations as $translation) {
            foreach ($this->translatedAttributes as $attr) {

The property translatedAttributes does not seem to exist. Did you mean attributes?

                $translations[$translation->{$this->getLocaleKey()}][$attr] = $translation->{$attr};
            }
        }

        return $translations;
    }

    private function getTranslationsTable(): string
    {
        return app()->make($this->getTranslationModelName())->getTable();
    }

    protected function locale(): string
    {
        if ($this->defaultLocale) {
            return $this->defaultLocale;
        }

        return $this->getLocalesHelper()->current();
    }

    public function setDefaultLocale(string $locale)
    {
        $this->defaultLocale = $locale;

        return $this;
    }

    public function getDefaultLocale(): ?string
    {
        return $this->defaultLocale;
    }

    /**
     * @param string|array|null $locales The locales to be deleted
     */
    public function deleteTranslations($locales = null)
    {
        if ($locales === null) {
            $translations = $this->translations()->get();
        } else {
            $locales = (array) $locales;
            $translations = $this->translations()->whereIn($this->getLocaleKey(), $locales)->get();

The method whereIn() does not exist on Illuminate\Database\Eloquent\Relations\HasMany. Did you maybe mean whereInMethod()?

        }
        foreach ($translations as $translation) {
            $translation->delete();
        }

        // we need to manually "reload" the collection built from the relationship
        // otherwise $this->translations()->get() would NOT be the same as $this->translations
        $this->load('translations');

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

    }

    private function getAttributeAndLocale(string $key): array
    {
        if (Str::contains($key, ':')) {
            return explode(':', $key);
        }

        return [$key, $this->locale()];
    }

    private function toArrayAlwaysLoadsTranslations(): bool
    {
        return config('translatable.to_array_always_loads_translations', true);
    }

    public static function enableAutoloadTranslations(): void
    {
        self::$autoloadTranslations = true;
    }

    public static function defaultAutoloadTranslations(): void
    {
        self::$autoloadTranslations = null;
    }

    public static function disableAutoloadTranslations(): void
    {
        self::$autoloadTranslations = false;
    }

    protected function getLocalesHelper(): Locales
    {
        return app(Locales::class);
    }
}