BrunoFernandes\LaravelMultiLanguage\Translatable

Complexity

Total Complexity

23

Size/Duplication

Total Lines	196
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Importance

Changes

0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	bootTranslatable()	0	21	4
	getKeyName()	0	1	?
A	getLangKey()	0	4	1
A	getForeignKey()	0	4	1
A	translations()	0	4	1
A	fieldsToExclude()	0	12	3
A	translateTo()	0	19	2
A	hasTranslation()	0	7	2
A	getTranslationBaseQuery()	0	6	1
A	translation()	0	4	1
A	scopeWithTranslations()	0	6	1
A	scopeLang()	0	4	2
A	scopeNotLang()	0	5	2
A	scopeOnlyOriginal()	0	4	1
A	scopeOnlyOriginals()	0	4	1

<?php

namespace BrunoFernandes\LaravelMultiLanguage;

use Illuminate\Support\Arr;
use Illuminate\Support\Facades\App;
use Illuminate\Database\Eloquent\Builder;
use BrunoFernandes\LaravelMultiLanguage\Scopes\LangScope;
use BrunoFernandes\LaravelMultiLanguage\Exceptions\ModelTranslationAlreadyExistsException;

trait Translatable
{
    abstract public function getKeyName();

    /**
     * @return void
     */
    public static function bootTranslatable(): void
    {
        static::creating(function ($model) {
            // set default language if not set
            if (!$model->{$model->getLangKey()}) {
                $model->{$model->getLangKey()} = App::getLocale();
            }
        });

        static::created(function ($model) {
            // Set original field id when created
            if (!$model->{$model->getForeignKey()}) {
                $model->{$model->getForeignKey()} = $model->id;
                $model->save();
            }
        });

        if (config('laravel-multi-language.apply_lang_global_scope')) {
            static::addGlobalScope(new LangScope);
        }
    }

    /**
     * @return string
     */
    public function getLangKey(): String
    {
        return config('laravel-multi-language.lang_key', 'lang');
    }

    /**
     * @return string
     */
    public function getForeignKey(): String
    {
        return config('laravel-multi-language.foreign_key', 'original_id');
    }

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

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

    }

    // public function original()
    // {
    //     return $this->belongsTo(get_class($this), 'profile_id', 'id');
    // }

    /**
     * Determin fields to be excluded from the translation
     *
     * @return array
     */
    private function fieldsToExclude(): array
    {
        $exclude = [];
        if ($this->excludeFieldsFromTranslation && is_array($this->excludeFieldsFromTranslation)) {
            $exclude = $this->excludeFieldsFromTranslation;

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

        }

        return array_merge(
            [$this->getKeyName(), $this->getLangKey(), $this->getForeignKey(), 'created_at', 'updated_at'],
            $exclude
        );
    }

    /**
     * Translate model to another language
     *
     * @param String $lang
     * @param array $data
     * @return Illuminate\Database\Eloquent\Model
     */
    public function translateTo($lang, $data = [])
    {
        $newLangData = [$this->getLangKey() => $lang, $this->getForeignKey() => $this->{$this->getForeignKey()}];
        $originalData = Arr::except($this->toArray(), $this->fieldsToExclude());

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

        $data = Arr::except($data, $this->fieldsToExclude()); // clean up passed data
        $data = array_merge($originalData, $data, $newLangData);

        if ($this->hasTranslation($lang)) {
            throw new ModelTranslationAlreadyExistsException('Translation already exists.', 1);
        }

        // TODO: add event here: model.translating

        $translation =  self::create($data);

        // TODO: add event here: model.translated

        return $translation;
    }

    /**
     * Checks if record has a  translation
     *
     * @param String $lang
     * @return Boolean
     */
    public function hasTranslation($lang): bool
    {
        if ($this->lang == $lang) {

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

            return true;
        }
        return $this->getTranslationBaseQuery($lang)->exists();

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

    }

    /**
     * Undocumented function
     *
     * @param String $lang
     * @return \Illuminate\Database\Eloquent\Builder
     */
    private function getTranslationBaseQuery($lang): Builder
    {
        return self::withoutGlobalScope(LangScope::class)
            ->where($this->getLangKey(), $lang)
            ->where($this->getForeignKey(), $this->{$this->getForeignKey()});
    }

    /**
     * Get translation
     *
     * @param String $lang
     * @return Illuminate\Database\Eloquent\Model|null
     */
    public function translation($lang)
    {
        return $this->getTranslationBaseQuery($lang)->first();
    }

    /*
     * Return translation excluding the current language
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function scopeWithTranslations(Builder $query, $lang = null, $fields = [])
    {
        return $query->with(['translations' => function ($q) use ($lang, $fields) {
            $q->notLang($lang, $fields);
        }]);
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string                                $lang
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function scopeLang(Builder $query, $lang = null)
    {
        return $query->where($this->getLangKey(), $lang ?: App::getLocale());
    }

    /**
     * @param \Illuminate\Database\Eloquent\Builder $query
     * @param string                                $lang
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function scopeNotLang(Builder $query, $lang = null)
    {
        return $query->where($this->getLangKey(), '!=', $lang ?: App::getLocale())
            ->withoutGlobalScope(LangScope::class);
    }

    /**
     * Return only original rows
     * @param \Illuminate\Database\Eloquent\Builder $query
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function scopeOnlyOriginal(Builder $query)
    {
        return $query->whereRaw($this->getTable() . '.id = ' . $this->getTable() . '.' . $this->getForeignKey());

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

    }

    /* @param \Illuminate \Database \Eloquent \Builder $query
    *
    * @return \Illuminate\Database\Eloquent\Builder | static
    */
    public function scopeOnlyOriginals(Builder $query)
    {
        return $this->scopeOnlyOriginal($query);
    }
}