LaTevaWeb\Translatable\Traits\Translatable

Complexity

Total Complexity

38

Size/Duplication

Total Lines	229
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

90.91%

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	create()	0	23	5
A	getAttributeValue()	0	8	2
A	setAttribute()	0	8	3
A	isTranslatableAttribute()	0	4	1
A	getLocale()	0	4	1
A	getTranslatableAttributes()	0	4	2
A	getTranslation()	0	14	2
A	setTranslation()	0	27	3
A	guardAgainstNonTranslatableAttribute()	0	6	2
A	translations()	0	9	1
A	getTranslatedLocales()	0	4	1
A	getTranslations()	0	9	1
A	save()	0	12	3
B	originalSave()	0	40	7
A	normalizeLocale()	0	14	4

<?php

namespace LaTevaWeb\Translatable\Traits;

use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Config;
use LaTevaWeb\Translatable\Exceptions\AttributeIsNotTranslatable;

trait Translatable
{
    protected $tempTranslations = [];

    public static function create(array $attributes = [])
    {
        $translatables = [];

        foreach ($attributes as $field => $values) {
            if (in_array($field, self::$translatable)) {
                $translatables[$field] = $values;
                unset($attributes[$field]);
            }
        }

        $model = static::query()->create($attributes);

        foreach ($translatables as $field => $values) {
            foreach ($values as $locale => $value) {
                $model->setTranslation($field, $locale, $value);
            }
        }

        $model->save();

        return $model;
    }

    public function getAttributeValue($field)
    {
        if (! $this->isTranslatableAttribute($field)) {
            return parent::getAttributeValue($field);
        }

        return $this->getTranslation($field, $this->getLocale());
    }

    public function setAttribute($field, $value)
    {
        if (! $this->isTranslatableAttribute($field) || is_array($value)) {
            return parent::setAttribute($field, $value);
        }

        return $this->setTranslation($field, $this->getLocale(), $value);
    }

    public function isTranslatableAttribute(string $field): bool
    {
        return in_array($field, $this->getTranslatableAttributes());
    }

    protected function getLocale(): string
    {
        return Config::get('app.locale');
    }

    public function getTranslatableAttributes(): array
    {
        return is_array(self::$translatable) ? self::$translatable : [];
    }

    public function getTranslation(string $field, string $locale, bool $useFallbackLocale = true): ?string
    {
        $translations = $this->getTranslations($field)->all();

        $locale = $this->normalizeLocale(array_keys($translations), $field, $locale, $useFallbackLocale);

        $translation = $translations[$locale] ?? '';

        if ($this->hasGetMutator($field)) {

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

            return $this->mutateAttribute($field, $translation);

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

        }

        return $translation;
    }

    public function setTranslation(string $field, string $locale, $content): self
    {
        $this->guardAgainstNonTranslatableAttribute($field);

        $translation = $this->translations()
            ->where('field', $field)
            ->where('locale', $locale)
            ->first();

        if (! empty($translation)) {
            $translation->content = $content;
            $translation->save();
        } elseif (! empty($this->id)) {

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

            $this->translations()->create([
                'field' => $field,
                'locale' => $locale,
                'content' => $content,
            ]);
        } else {
            $this->tempTranslations[$field] = [
                'locale' => $locale,
                'content' => $content,
            ];
        }

        return $this;
    }

    protected function guardAgainstNonTranslatableAttribute(string $key)
    {
        if (! $this->isTranslatableAttribute($key)) {
            throw AttributeIsNotTranslatable::make($key, $this);
        }
    }

    public function translations(): MorphToMany
    {
        return $this->morphToMany(

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

            config('latevaweb-translatable.models.translation'),
            'translatable',
            config('latevaweb-translatable.table_names.translatables'),
            config('latevaweb-translatable.column_names.model_morph_key'),
            'translation_id');
    }

    protected function normalizeLocale($locales, string $field, string $locale, bool $useFallbackLocale): string

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

    {
        if (in_array($locale, $locales)) {
            return $locale;
        }
        if (! $useFallbackLocale) {
            return $locale;
        }
        if (! is_null($fallbackLocale = Config::get('app.fallback_locale'))) {
            return $fallbackLocale;
        }

        return $locale;
    }

    /**
     * Returns a collection with all locales [ locales ].
     *
     * @param string $field
     * @return Collection
     */
    public function getTranslatedLocales(string $field): Collection
    {
        return $this->getTranslations($field)->keys();
    }

    /**
     * Returns a collection with [ locale => content ].
     *
     * @param string|null $field
     * @return Collection
     */
    public function getTranslations(string $field = null): Collection
    {
        return $this->translations()
            ->where('field', $field)
            ->select('locale', 'content')
            ->get()
            ->keyBy('locale')
            ->pluck('content', 'locale');
    }

    /**
     * Override default Eloquent save method to add dynamically stored tempTranslations array.
     *
     * @param  array $options
     * @return bool
     */
    public function save(array $options = [])
    {
        $response = $this->originalSave($options);

        if ($response === true) {
            foreach ($this->tempTranslations as $field => $data) {
                $this->setTranslation($field, $data['locale'] ?? null, $data['content'] ?? null);
            }
        }

        return $response;
    }

    /**
     * Save the model to the database.
     *
     * @param  array  $options
     * @return bool
     */
    public function originalSave(array $options = [])
    {
        $query = $this->newModelQuery();

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

        // If the "saving" event returns false we'll bail out of the save and return
        // false, indicating that the save failed. This provides a chance for any
        // listeners to cancel save operations if validations fail or whatever.
        if ($this->fireModelEvent('saving') === false) {

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

            return false;
        }

        // If the model already exists in the database we can just update our record
        // that is already in this database using the current IDs in this "where"
        // clause to only update this model. Otherwise, we'll just insert them.
        if ($this->exists) {

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

            $saved = $this->isDirty() ?

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

                $this->performUpdate($query) : true;

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

        }

        // If the model is brand new, we'll insert it into our database and set the
        // ID attribute on the model to the value of the newly inserted row's ID
        // which is typically an auto-increment value managed by the database.
        else {
            $saved = $this->performInsert($query);

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

            if (! $this->getConnectionName() &&

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

                $connection = $query->getConnection()) {
                $this->setConnection($connection->getName());

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

            }
        }

        // If the model is successfully saved, we need to do a few more things once
        // that is done. We will call the "saved" method here to run any actions
        // we need to happen after a model gets successfully saved right here.
        if ($saved) {
            $this->finishSave($options);

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

        }

        return $saved;
    }
}