spletna-postaja / translatable

src/Translatable.php

<?php

namespace Laraplus\Data;

use Illuminate\Database\Eloquent\Relations\HasMany;

trait Translatable
{
    protected $overrideLocale = null;

    protected $overrideFallbackLocale = null;

    protected $overrideOnlyTranslated = null;

    protected $overrideWithFallback = null;

    protected $localeChanged = false;

    /**
     * Translated attributes cache.
     *
     * @var array
     */
    protected static $i18nAttributes = [];

    /**
     * Boot the trait.
     */
    public static function bootTranslatable()
    {
        static::addGlobalScope(new TranslatableScope);
    }

    /**
     * Save a new model and return the instance.
     *
     * @param array $attributes
     * @param array|string $translations
     *
     * @return static
     */
    public static function create(array $attributes = [], $translations = [])
    {
        $model = new static($attributes);

        if ($model->save() && is_array($translations)) {

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

            $model->saveTranslations($translations);
        }

        return $model;
    }

    /**
     * Save a new model in provided locale and return the instance.
     *
     * @param string $locale
     * @param array $attributes
     * @param array|string $translations
     *
     * @return Translatable|string
     */
    public static function createInLocale(string $locale, array $attributes = [], $translations = [])
    {
        $model = (new static($attributes))->setLocale($locale);

        if ($model->save() && is_array($translations)) {
            $model->saveTranslations($translations);
        }

        return $model;
    }

    /**
     * Save a new model and return the instance. Allow mass-assignment.
     *
     * @param array $attributes
     * @param array|string $translations
     *
     * @return static
     */
    public static function forceCreate(array $attributes, $translations = [])
    {
        $model = new static;

        return static::unguarded(function () use ($model, $attributes, $translations) {
            return $model->create($attributes, $translations);
        });
    }

    /**
     * Save a new model in provided locale and return the instance. Allow mass-assignment.
     *
     * @param string $locale
     * @param array $attributes
     * @param array|string $translations
     *
     * @return static
     */
    public static function forceCreateInLocale($locale, array $attributes, $translations = [])
    {
        $model = new static;

        return static::unguarded(function () use ($locale, $model, $attributes, $translations) {
            return $model->createInLocale($locale, $attributes, $translations);
        });
    }

    /**
     * Reload a fresh model instance from the database.
     *
     * @param array|string $with
     *
     * @return static|null
     */
    public function fresh($with = [])
    {
        if (!$this->exists) {
            return null;
        }

        $query = static::newQueryWithoutScopes()
            ->with(is_string($with) ? func_get_args() : $with)
            ->where($this->getKeyName(), $this->getKey());

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

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

        (new TranslatableScope)->apply($query, $this);

$this of type Laraplus\Data\Translatable is incompatible with the type Illuminate\Database\Eloquent\Model expected by parameter $model of Laraplus\Data\TranslatableScope::apply().

        return $query->first();
    }

    /**
     * Save the translations.
     *
     * @param array $translations
     *
     * @return bool
     */
    public function saveTranslations(array $translations)
    {
        $success = true;
        $fresh = parent::fresh();

        foreach ($translations as $locale => $attributes) {
            $model = clone $fresh;

            $model->setLocale($locale);
            $model->fill($attributes);

            $success &= $model->save();
        }

        return $success;

The expression return $success also could return the type integer which is incompatible with the documented return type boolean.

    }

    /**
     * Force saving the translations.
     *
     * @param array $translations
     *
     * @return bool
     */
    public function forceSaveTranslations(array $translations)
    {
        return static::unguarded(function () use ($translations) {
            return $this->saveTranslations($translations);
        });
    }

    /**
     * Save the translation.
     *
     * @param $locale
     * @param array $attributes
     *
     * @return bool
     */
    public function saveTranslation($locale, array $attributes)
    {
        return $this->saveTranslations([
            $locale => $attributes,
        ]);
    }

    /**
     * Force saving the translation.
     *
     * @param $locale
     * @param array $attributes
     *
     * @return bool
     */
    public function forceSaveTranslation($locale, array $attributes)
    {
        return static::unguarded(function () use ($locale, $attributes) {
            return $this->saveTranslation($locale, $attributes);
        });
    }

    /**
     * Populate the translations.
     *
     * @param array $attributes
     *
     * @return $this
     *
     * @throws \Illuminate\Database\Eloquent\MassAssignmentException
     */
    public function fill(array $attributes)
    {
        if (!isset(static::$i18nAttributes[$this->getTable()])) {

The method getTable() does not exist on Laraplus\Data\Translatable. Did you maybe mean getI18nTable()?

            $this->initTranslatableAttributes();
        }

        return parent::fill($attributes);
    }

    /**
     * Initialize translatable attributes.
     */
    protected function initTranslatableAttributes()
    {
        if (property_exists($this, 'translatable')) {
            $attributes = $this->translatable;
        } else {
            $attributes = $this->getTranslatableAttributesFromSchema();
        }

        static::$i18nAttributes[$this->getTable()] = $attributes;
    }

    /**
     * Return an array of translatable attributes from schema.
     *
     * @return array
     */
    protected function getTranslatableAttributesFromSchema()
    {
        if ((!$con = $this->getConnection()) || (!$builder = $con->getSchemaBuilder())) {

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

            return [];
        }

        if ($columns = TranslatableConfig::cacheGet($this->getI18nTable())) {
            return $columns;
        }

        $columns = $builder->getColumnListing($this->getI18nTable());

        unset($columns[array_search($this->getForeignKey(), $columns)]);

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

        TranslatableConfig::cacheSet($this->getI18nTable(), $columns);

        return $columns;
    }

    /**
     * Return a collection of translated attributes in a given locale.
     *
     * @param $locale
     *
     * @return \Laraplus\Data\TranslationModel|null
     */
    public function translate($locale)
    {
        $found = $this->translations->where($this->getLocaleKey(), $locale)->first();

        if (!$found && $this->shouldFallback($locale)) {
            return $this->translate($this->getFallbackLocale());
        }

        return $found;
    }

    /**
     * Return a collection of translated attributes in a given locale or create a new one.
     *
     * @param $locale
     *
     * @return \Laraplus\Data\TranslationModel
     */
    public function translateOrNew($locale)
    {
        if (is_null($instance = $this->translate($locale))) {
            return $this->newModelInstance();

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

        }

        return $instance;
    }

    /**
     * Translations relationship.
     *
     * @return \Illuminate\Database\Eloquent\Relations\HasMany
     */
    public function translations()
    {
        $localKey = $this->getKeyName();
        $foreignKey = $this->getForeignKey();
        $instance = $this->translationModel();

        return new HasMany($instance->newQuery(), $this, $instance->getTable().'.'.$foreignKey, $localKey);

$this of type Laraplus\Data\Translatable is incompatible with the type Illuminate\Database\Eloquent\Model expected by parameter $parent of Illuminate\Database\Eloquent\Relations\HasMany::__construct().

    }

    /**
     * Returns the default translation model instance.
     *
     * @return TranslationModel
     */
    public function translationModel()
    {
        $translation = new TranslationModel;

        $translation->setConnection($this->getI18nConnection());
        $translation->setTable($this->getI18nTable());
        $translation->setKeyName($this->getForeignKey());
        $translation->setLocaleKey($this->getLocaleKey());

        if ($attributes = $this->translatableAttributes()) {
            $translation->fillable(array_intersect($attributes, $this->getFillable()));

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

        }

        return $translation;
    }

    /**
     * Return an array of translatable attributes.
     *
     * @return array
     */
    public function translatableAttributes()
    {
        if (!isset(static::$i18nAttributes[$this->getTable()])) {
            return [];
        }

        return static::$i18nAttributes[$this->getTable()];
    }

    /**
     * Return the name of the locale key.
     *
     * @return string
     */
    public function getLocaleKey()
    {
        return TranslatableConfig::dbKey();
    }

    /**
     * Set the current locale.
     *
     * @param $locale
     *
     * @return $this
     */
    public function setLocale($locale)
    {
        $this->overrideLocale = $locale;
        $this->localeChanged = true;

        return $this;
    }

    /**
     * Return the current locale.
     *
     * @return string
     */
    public function getLocale()
    {
        if ($this->overrideLocale) {
            return $this->overrideLocale;
        }

        if (property_exists($this, 'locale')) {
            return $this->locale;
        }

        return TranslatableConfig::currentLocale();
    }

    /**
     * Set the fallback locale.
     *
     * @param $locale
     *
     * @return $this
     */
    public function setFallbackLocale($locale)
    {
        $this->overrideFallbackLocale = $locale;

        return $this;
    }

    /**
     * Return the fallback locale.
     *
     * @return string
     */
    public function getFallbackLocale()
    {
        if ($this->overrideFallbackLocale) {
            return $this->overrideFallbackLocale;
        }

        if (property_exists($this, 'fallbackLocale')) {
            return $this->fallbackLocale;
        }

        return TranslatableConfig::fallbackLocale();
    }

    /**
     * Set if model should select only translated rows.
     *
     * @param bool $onlyTranslated
     *
     * @return $this
     */
    public function setOnlyTranslated($onlyTranslated)
    {
        $this->overrideOnlyTranslated = $onlyTranslated;

        return $this;
    }

    /**
     * Return only translated rows.
     *
     * @return bool
     */
    public function getOnlyTranslated()
    {
        if (!is_null($this->overrideOnlyTranslated)) {
            return $this->overrideOnlyTranslated;
        }

        if (property_exists($this, 'onlyTranslated')) {
            return $this->onlyTranslated;
        }

        return TranslatableConfig::onlyTranslated();
    }

    /**
     * Set if model should select only translated rows.
     *
     * @param bool $withFallback
     *
     * @return $this
     */
    public function setWithFallback($withFallback)
    {
        $this->overrideWithFallback = $withFallback;

        return $this;
    }

    /**
     * Return current locale with fallback.
     *
     * @return bool
     */
    public function getWithFallback()
    {
        if (!is_null($this->overrideWithFallback)) {
            return $this->overrideWithFallback;
        }

        if (property_exists($this, 'withFallback')) {
            return $this->withFallback;
        }

        return TranslatableConfig::withFallback();
    }

    /**
     * Return the i18n connection name associated with the model.
     *
     * @return string
     */
    public function getI18nConnection()
    {
        return $this->getConnectionName();

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

    }

    /**
     * Return the i18n table associated with the model.
     *
     * @return string
     */
    public function getI18nTable()
    {
        return $this->getTable().$this->getTranslationTableSuffix();
    }

    /**
     * Return the i18n table suffix.
     *
     * @return string
     */
    public function getTranslationTableSuffix()
    {
        return TranslatableConfig::dbSuffix();
    }

    /**
     * Should fall back to a primary translation.
     *
     * @param string|null $locale
     *
     * @return bool
     */
    public function shouldFallback($locale = null)
    {
        if (!$this->getWithFallback() || !$this->getFallbackLocale()) {
            return false;
        }

        $locale = $locale ?: $this->getLocale();

        return $locale != $this->getFallbackLocale();
    }

    /**
     * Create a new Eloquent query builder for the model.
     *
     * @param \Illuminate\Database\Query\Builder $query
     *
     * @return \Illuminate\Database\Eloquent\Builder|static
     */
    public function newEloquentBuilder($query)
    {
        return new Builder($query);
    }

    /**
     * Return a new query builder instance for the connection.
     *
     * @return \Illuminate\Database\Query\Builder
     */
    protected function newBaseQueryBuilder()
    {
        $conn = $this->getConnection();
        $grammar = $conn->getQueryGrammar();
        $builder = new QueryBuilder($conn, $grammar, $conn->getPostProcessor());

        return $builder->setModel($this);

$this of type Laraplus\Data\Translatable is incompatible with the type Illuminate\Database\Eloquent\Model expected by parameter $model of Laraplus\Data\QueryBuilder::setModel().

    }

    /**
     * Return the attributes that have been changed since the last sync.
     *
     * @return array
     */
    public function getDirty()
    {
        $dirty = parent::getDirty();

        if (!$this->localeChanged) {
            return $dirty;
        }

        foreach ($this->translatableAttributes() as $key) {
            if (isset($this->attributes[$key])) {
                $dirty[$key] = $this->attributes[$key];
            }
        }

        return $dirty;
    }

    /**
     * Sync the original attributes with the current.
     *
     * @return $this
     */
    public function syncOriginal()
    {
        $this->localeChanged = false;

        return parent::syncOriginal();
    }

    /**
     * Prefix column names with the translation table instead of the model table if the given column is translated.
     *
     * @param $column
     *
     * @return string
     */
    public function qualifyColumn($column)
    {
        if (in_array($column, $this->translatableAttributes(), true)) {
            return sprintf('%s.%s', $this->getI18nTable(), $column);
        }

        return parent::qualifyColumn($column);
    }
}