Subversion-Projekte lars-tiefland.laravel_shop

<?php

namespace Illuminate\Database\Eloquent;

use ArrayAccess;

use Illuminate\Contracts\Broadcasting\HasBroadcastChannel;

use Illuminate\Contracts\Queue\QueueableCollection;

use Illuminate\Contracts\Queue\QueueableEntity;

use Illuminate\Contracts\Routing\UrlRoutable;

use Illuminate\Contracts\Support\Arrayable;

use Illuminate\Contracts\Support\CanBeEscapedWhenCastToString;

use Illuminate\Contracts\Support\Jsonable;

use Illuminate\Database\ConnectionResolverInterface as Resolver;

use Illuminate\Database\Eloquent\Collection as EloquentCollection;

use Illuminate\Database\Eloquent\Relations\BelongsToMany;

use Illuminate\Database\Eloquent\Relations\Concerns\AsPivot;

use Illuminate\Database\Eloquent\Relations\HasManyThrough;

use Illuminate\Database\Eloquent\Relations\Pivot;

use Illuminate\Support\Arr;

use Illuminate\Support\Collection as BaseCollection;

use Illuminate\Support\Str;

use Illuminate\Support\Traits\ForwardsCalls;

use JsonSerializable;

use LogicException;

abstract class Model implements Arrayable, ArrayAccess, CanBeEscapedWhenCastToString, HasBroadcastChannel, Jsonable, JsonSerializable, QueueableEntity, UrlRoutable

{

    use Concerns\HasAttributes,

        Concerns\HasEvents,

        Concerns\HasGlobalScopes,

        Concerns\HasRelationships,

        Concerns\HasTimestamps,

        Concerns\HidesAttributes,

        Concerns\GuardsAttributes,

        ForwardsCalls;

    /**

     * The connection name for the model.

     *

     * @var string|null

     */

    protected $connection;

    /**

     * The table associated with the model.

     *

     * @var string

     */

    protected $table;

    /**

     * The primary key for the model.

     *

     * @var string

     */

    protected $primaryKey = 'id';

    /**

     * The "type" of the primary key ID.

     *

     * @var string

     */

    protected $keyType = 'int';

    /**

     * Indicates if the IDs are auto-incrementing.

     *

     * @var bool

     */

    public $incrementing = true;

    /**

     * The relations to eager load on every query.

     *

     * @var array

     */

    protected $with = [];

    /**

     * The relationship counts that should be eager loaded on every query.

     *

     * @var array

     */

    protected $withCount = [];

    /**

     * Indicates whether lazy loading will be prevented on this model.

     *

     * @var bool

     */

    public $preventsLazyLoading = false;

    /**

     * The number of models to return for pagination.

     *

     * @var int

     */

    protected $perPage = 15;

    /**

     * Indicates if the model exists.

     *

     * @var bool

     */

    public $exists = false;

    /**

     * Indicates if the model was inserted during the current request lifecycle.

     *

     * @var bool

     */

    public $wasRecentlyCreated = false;

    /**

     * Indicates that the object's string representation should be escaped when __toString is invoked.

     *

     * @var bool

     */

    protected $escapeWhenCastingToString = false;

    /**

     * The connection resolver instance.

     *

     * @var \Illuminate\Database\ConnectionResolverInterface

     */

    protected static $resolver;

    /**

     * The event dispatcher instance.

     *

     * @var \Illuminate\Contracts\Events\Dispatcher

     */

    protected static $dispatcher;

    /**

     * The array of booted models.

     *

     * @var array

     */

    protected static $booted = [];

    /**

     * The array of trait initializers that will be called on each new instance.

     *

     * @var array

     */

    protected static $traitInitializers = [];

    /**

     * The array of global scopes on the model.

     *

     * @var array

     */

    protected static $globalScopes = [];

    /**

     * The list of models classes that should not be affected with touch.

     *

     * @var array

     */

    protected static $ignoreOnTouch = [];

    /**

     * Indicates whether lazy loading should be restricted on all models.

     *

     * @var bool

     */

    protected static $modelsShouldPreventLazyLoading = false;

    /**

     * The callback that is responsible for handling lazy loading violations.

     *

     * @var callable|null

     */

    protected static $lazyLoadingViolationCallback;

    /**

     * Indicates if an exception should be thrown instead of silently discarding non-fillable attributes.

     *

     * @var bool

     */

    protected static $modelsShouldPreventSilentlyDiscardingAttributes = false;

    /**

     * The callback that is responsible for handling discarded attribute violations.

     *

     * @var callable|null

     */

    protected static $discardedAttributeViolationCallback;

    /**

     * Indicates if an exception should be thrown when trying to access a missing attribute on a retrieved model.

     *

     * @var bool

     */

    protected static $modelsShouldPreventAccessingMissingAttributes = false;

    /**

     * The callback that is responsible for handling missing attribute violations.

     *

     * @var callable|null

     */

    protected static $missingAttributeViolationCallback;

    /**

     * Indicates if broadcasting is currently enabled.

     *

     * @var bool

     */

    protected static $isBroadcasting = true;

    /**

     * The name of the "created at" column.

     *

     * @var string|null

     */

    const CREATED_AT = 'created_at';

    /**

     * The name of the "updated at" column.

     *

     * @var string|null

     */

    const UPDATED_AT = 'updated_at';

    /**

     * Create a new Eloquent model instance.

     *

     * @param  array  $attributes

     * @return void

     */

    public function __construct(array $attributes = [])

    {

        $this->bootIfNotBooted();

        $this->initializeTraits();

        $this->syncOriginal();

        $this->fill($attributes);

    }

    /**

     * Check if the model needs to be booted and if so, do it.

     *

     * @return void

     */

    protected function bootIfNotBooted()

    {

        if (! isset(static::$booted[static::class])) {

            static::$booted[static::class] = true;

            $this->fireModelEvent('booting', false);

            static::booting();

            static::boot();

            static::booted();

            $this->fireModelEvent('booted', false);

        }

    }

    /**

     * Perform any actions required before the model boots.

     *

     * @return void

     */

    protected static function booting()

    {

        //

    }

    /**

     * Bootstrap the model and its traits.

     *

     * @return void

     */

    protected static function boot()

    {

        static::bootTraits();

    }

    /**

     * Boot all of the bootable traits on the model.

     *

     * @return void

     */

    protected static function bootTraits()

    {

        $class = static::class;

        $booted = [];

        static::$traitInitializers[$class] = [];

        foreach (class_uses_recursive($class) as $trait) {

            $method = 'boot'.class_basename($trait);

            if (method_exists($class, $method) && ! in_array($method, $booted)) {

                forward_static_call([$class, $method]);

                $booted[] = $method;

            }

            if (method_exists($class, $method = 'initialize'.class_basename($trait))) {

                static::$traitInitializers[$class][] = $method;

                static::$traitInitializers[$class] = array_unique(

                    static::$traitInitializers[$class]

                );

            }

        }

    }

    /**

     * Initialize any initializable traits on the model.

     *

     * @return void

     */

    protected function initializeTraits()

    {

        foreach (static::$traitInitializers[static::class] as $method) {

            $this->{$method}();

        }

    }

    /**

     * Perform any actions required after the model boots.

     *

     * @return void

     */

    protected static function booted()

    {

        //

    }

    /**

     * Clear the list of booted models so they will be re-booted.

     *

     * @return void

     */

    public static function clearBootedModels()

    {

        static::$booted = [];

        static::$globalScopes = [];

    }

    /**

     * Disables relationship model touching for the current class during given callback scope.

     *

     * @param  callable  $callback

     * @return void

     */

    public static function withoutTouching(callable $callback)

    {

        static::withoutTouchingOn([static::class], $callback);

    }

    /**

     * Disables relationship model touching for the given model classes during given callback scope.

     *

     * @param  array  $models

     * @param  callable  $callback

     * @return void

     */

    public static function withoutTouchingOn(array $models, callable $callback)

    {

        static::$ignoreOnTouch = array_values(array_merge(static::$ignoreOnTouch, $models));

        try {

            $callback();

        } finally {

            static::$ignoreOnTouch = array_values(array_diff(static::$ignoreOnTouch, $models));

        }

    }

    /**

     * Determine if the given model is ignoring touches.

     *

     * @param  string|null  $class

     * @return bool

     */

    public static function isIgnoringTouch($class = null)

    {

        $class = $class ?: static::class;

        if (! get_class_vars($class)['timestamps'] || ! $class::UPDATED_AT) {

            return true;

        }

        foreach (static::$ignoreOnTouch as $ignoredClass) {

            if ($class === $ignoredClass || is_subclass_of($class, $ignoredClass)) {

                return true;

            }

        }

        return false;

    }

    /**

     * Indicate that models should prevent lazy loading, silently discarding attributes, and accessing missing attributes.

     *

     * @param  bool  $shouldBeStrict

     * @return void

     */

    public static function shouldBeStrict(bool $shouldBeStrict = true)

    {

        static::preventLazyLoading($shouldBeStrict);

        static::preventSilentlyDiscardingAttributes($shouldBeStrict);

        static::preventAccessingMissingAttributes($shouldBeStrict);

    }

    /**

     * Prevent model relationships from being lazy loaded.

     *

     * @param  bool  $value

     * @return void

     */

    public static function preventLazyLoading($value = true)

    {

        static::$modelsShouldPreventLazyLoading = $value;

    }

    /**

     * Register a callback that is responsible for handling lazy loading violations.

     *

     * @param  callable|null  $callback

     * @return void

     */

    public static function handleLazyLoadingViolationUsing(?callable $callback)

    {

        static::$lazyLoadingViolationCallback = $callback;

    }

    /**

     * Prevent non-fillable attributes from being silently discarded.

     *

     * @param  bool  $value

     * @return void

     */

    public static function preventSilentlyDiscardingAttributes($value = true)

    {

        static::$modelsShouldPreventSilentlyDiscardingAttributes = $value;

    }

    /**

     * Register a callback that is responsible for handling discarded attribute violations.

     *

     * @param  callable|null  $callback

     * @return void

     */

    public static function handleDiscardedAttributeViolationUsing(?callable $callback)

    {

        static::$discardedAttributeViolationCallback = $callback;

    }

    /**

     * Prevent accessing missing attributes on retrieved models.

     *

     * @param  bool  $value

     * @return void

     */

    public static function preventAccessingMissingAttributes($value = true)

    {

        static::$modelsShouldPreventAccessingMissingAttributes = $value;

    }

    /**

     * Register a callback that is responsible for handling lazy loading violations.

     *

     * @param  callable|null  $callback

     * @return void

     */

    public static function handleMissingAttributeViolationUsing(?callable $callback)

    {

        static::$missingAttributeViolationCallback = $callback;

    }

    /**

     * Execute a callback without broadcasting any model events for all model types.

     *

     * @param  callable  $callback

     * @return mixed

     */

    public static function withoutBroadcasting(callable $callback)

    {

        $isBroadcasting = static::$isBroadcasting;

        static::$isBroadcasting = false;

        try {

            return $callback();

        } finally {

            static::$isBroadcasting = $isBroadcasting;

        }

    }

    /**

     * Fill the model with an array of attributes.

     *

     * @param  array  $attributes

     * @return $this

     *

     * @throws \Illuminate\Database\Eloquent\MassAssignmentException

     */

    public function fill(array $attributes)

    {

        $totallyGuarded = $this->totallyGuarded();

        $fillable = $this->fillableFromArray($attributes);

        foreach ($fillable as $key => $value) {

            // The developers may choose to place some attributes in the "fillable" array

            // which means only those attributes may be set through mass assignment to

            // the model, and all others will just get ignored for security reasons.

            if ($this->isFillable($key)) {

                $this->setAttribute($key, $value);

            } elseif ($totallyGuarded || static::preventsSilentlyDiscardingAttributes()) {

                if (isset(static::$discardedAttributeViolationCallback)) {

                    call_user_func(static::$discardedAttributeViolationCallback, $this, [$key]);

                } else {

                    throw new MassAssignmentException(sprintf(

                        'Add [%s] to fillable property to allow mass assignment on [%s].',

                        $key, get_class($this)

                    ));

                }

            }

        }

        if (count($attributes) !== count($fillable) &&

            static::preventsSilentlyDiscardingAttributes()) {

            $keys = array_diff(array_keys($attributes), array_keys($fillable));

            if (isset(static::$discardedAttributeViolationCallback)) {

                call_user_func(static::$discardedAttributeViolationCallback, $this, $keys);

            } else {

                throw new MassAssignmentException(sprintf(

                    'Add fillable property [%s] to allow mass assignment on [%s].',

                    implode(', ', $keys),

                    get_class($this)

                ));

            }

        }

        return $this;

    }

    /**

     * Fill the model with an array of attributes. Force mass assignment.

     *

     * @param  array  $attributes

     * @return $this

     */

    public function forceFill(array $attributes)

    {

        return static::unguarded(fn () => $this->fill($attributes));

    }

    /**

     * Qualify the given column name by the model's table.

     *

     * @param  string  $column

     * @return string

     */

    public function qualifyColumn($column)

    {

        if (str_contains($column, '.')) {

            return $column;

        }

        return $this->getTable().'.'.$column;

    }

    /**

     * Qualify the given columns with the model's table.

     *

     * @param  array  $columns

     * @return array

     */

    public function qualifyColumns($columns)

    {

        return collect($columns)->map(function ($column) {

            return $this->qualifyColumn($column);

        })->all();

    }

    /**

     * Create a new instance of the given model.

     *

     * @param  array  $attributes

     * @param  bool  $exists

     * @return static

     */

    public function newInstance($attributes = [], $exists = false)

    {

        // This method just provides a convenient way for us to generate fresh model

        // instances of this current model. It is particularly useful during the

        // hydration of new objects via the Eloquent query builder instances.

        $model = new static;

        $model->exists = $exists;

        $model->setConnection(

            $this->getConnectionName()

        );

        $model->setTable($this->getTable());

        $model->mergeCasts($this->casts);

        $model->fill((array) $attributes);

        return $model;

    }

    /**

     * Create a new model instance that is existing.

     *

     * @param  array  $attributes

     * @param  string|null  $connection

     * @return static

     */

    public function newFromBuilder($attributes = [], $connection = null)

    {

        $model = $this->newInstance([], true);

        $model->setRawAttributes((array) $attributes, true);

        $model->setConnection($connection ?: $this->getConnectionName());

        $model->fireModelEvent('retrieved', false);

        return $model;

    }

    /**

     * Begin querying the model on a given connection.

     *

     * @param  string|null  $connection

     * @return \Illuminate\Database\Eloquent\Builder

     */

    public static function on($connection = null)

    {

        // First we will just create a fresh instance of this model, and then we can set the

        // connection on the model so that it is used for the queries we execute, as well

        // as being set on every relation we retrieve without a custom connection name.

        $instance = new static;

        $instance->setConnection($connection);

        return $instance->newQuery();

    }

    /**

     * Begin querying the model on the write connection.

     *

     * @return \Illuminate\Database\Eloquent\Builder

     */

    public static function onWriteConnection()

    {

        return static::query()->useWritePdo();

    }

    /**

     * Get all of the models from the database.

     *

     * @param  array|string  $columns

     * @return \Illuminate\Database\Eloquent\Collection<int, static>

     */

    public static function all($columns = ['*'])

    {

        return static::query()->get(

            is_array($columns) ? $columns : func_get_args()

        );

    }

    /**

     * Begin querying a model with eager loading.

     *

     * @param  array|string  $relations

     * @return \Illuminate\Database\Eloquent\Builder

     */

    public static function with($relations)

    {

        return static::query()->with(

            is_string($relations) ? func_get_args() : $relations

        );

    }

    /**

     * Eager load relations on the model.

     *

     * @param  array|string  $relations

     * @return $this

     */

    public function load($relations)

    {

        $query = $this->newQueryWithoutRelationships()->with(

            is_string($relations) ? func_get_args() : $relations

        );

        $query->eagerLoadRelations([$this]);

        return $this;

    }

    /**

     * Eager load relationships on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @return $this

     */

    public function loadMorph($relation, $relations)

    {

        if (! $this->{$relation}) {

            return $this;

        }

        $className = get_class($this->{$relation});

        $this->{$relation}->load($relations[$className] ?? []);

        return $this;

    }

    /**

     * Eager load relations on the model if they are not already eager loaded.

     *

     * @param  array|string  $relations

     * @return $this

     */

    public function loadMissing($relations)

    {

        $relations = is_string($relations) ? func_get_args() : $relations;

        $this->newCollection([$this])->loadMissing($relations);

        return $this;

    }

    /**

     * Eager load relation's column aggregations on the model.

     *

     * @param  array|string  $relations

     * @param  string  $column

     * @param  string  $function

     * @return $this

     */

    public function loadAggregate($relations, $column, $function = null)

    {

        $this->newCollection([$this])->loadAggregate($relations, $column, $function);

        return $this;

    }

    /**

     * Eager load relation counts on the model.

     *

     * @param  array|string  $relations

     * @return $this

     */

    public function loadCount($relations)

    {

        $relations = is_string($relations) ? func_get_args() : $relations;

        return $this->loadAggregate($relations, '*', 'count');

    }

    /**

     * Eager load relation max column values on the model.

     *

     * @param  array|string  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadMax($relations, $column)

    {

        return $this->loadAggregate($relations, $column, 'max');

    }

    /**

     * Eager load relation min column values on the model.

     *

     * @param  array|string  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadMin($relations, $column)

    {

        return $this->loadAggregate($relations, $column, 'min');

    }

    /**

     * Eager load relation's column summations on the model.

     *

     * @param  array|string  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadSum($relations, $column)

    {

        return $this->loadAggregate($relations, $column, 'sum');

    }

    /**

     * Eager load relation average column values on the model.

     *

     * @param  array|string  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadAvg($relations, $column)

    {

        return $this->loadAggregate($relations, $column, 'avg');

    }

    /**

     * Eager load related model existence values on the model.

     *

     * @param  array|string  $relations

     * @return $this

     */

    public function loadExists($relations)

    {

        return $this->loadAggregate($relations, '*', 'exists');

    }

    /**

     * Eager load relationship column aggregation on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @param  string  $column

     * @param  string  $function

     * @return $this

     */

    public function loadMorphAggregate($relation, $relations, $column, $function = null)

    {

        if (! $this->{$relation}) {

            return $this;

        }

        $className = get_class($this->{$relation});

        $this->{$relation}->loadAggregate($relations[$className] ?? [], $column, $function);

        return $this;

    }

    /**

     * Eager load relationship counts on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @return $this

     */

    public function loadMorphCount($relation, $relations)

    {

        return $this->loadMorphAggregate($relation, $relations, '*', 'count');

    }

    /**

     * Eager load relationship max column values on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadMorphMax($relation, $relations, $column)

    {

        return $this->loadMorphAggregate($relation, $relations, $column, 'max');

    }

    /**

     * Eager load relationship min column values on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadMorphMin($relation, $relations, $column)

    {

        return $this->loadMorphAggregate($relation, $relations, $column, 'min');

    }

    /**

     * Eager load relationship column summations on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadMorphSum($relation, $relations, $column)

    {

        return $this->loadMorphAggregate($relation, $relations, $column, 'sum');

    }

    /**

     * Eager load relationship average column values on the polymorphic relation of a model.

     *

     * @param  string  $relation

     * @param  array  $relations

     * @param  string  $column

     * @return $this

     */

    public function loadMorphAvg($relation, $relations, $column)

    {

        return $this->loadMorphAggregate($relation, $relations, $column, 'avg');

    }

    /**

     * Increment a column's value by a given amount.

     *

     * @param  string  $column

     * @param  float|int  $amount

     * @param  array  $extra

     * @return int

     */

    protected function increment($column, $amount = 1, array $extra = [])

    {

        return $this->incrementOrDecrement($column, $amount, $extra, 'increment');

    }

    /**

     * Decrement a column's value by a given amount.

     *

     * @param  string  $column

     * @param  float|int  $amount

     * @param  array  $extra

     * @return int

     */

    protected function decrement($column, $amount = 1, array $extra = [])

    {

        return $this->incrementOrDecrement($column, $amount, $extra, 'decrement');

    }

    /**

     * Run the increment or decrement method on the model.

     *

     * @param  string  $column

     * @param  float|int  $amount

     * @param  array  $extra

     * @param  string  $method

     * @return int

     */

    protected function incrementOrDecrement($column, $amount, $extra, $method)

    {

        $query = $this->newQueryWithoutRelationships();

        if (! $this->exists) {

            return $query->{$method}($column, $amount, $extra);

        }

        $this->{$column} = $this->isClassDeviable($column)

            ? $this->deviateClassCastableAttribute($method, $column, $amount)

            : $this->{$column} + ($method === 'increment' ? $amount : $amount * -1);

        $this->forceFill($extra);

        if ($this->fireModelEvent('updating') === false) {

            return false;

        }

        return tap($this->setKeysForSaveQuery($query)->{$method}($column, $amount, $extra), function () use ($column) {

            $this->syncChanges();

            $this->fireModelEvent('updated', false);

            $this->syncOriginalAttribute($column);

        });

    }

    /**

     * Update the model in the database.

     *

     * @param  array  $attributes

     * @param  array  $options

     * @return bool

     */

    public function update(array $attributes = [], array $options = [])

    {

        if (! $this->exists) {

            return false;

        }

        return $this->fill($attributes)->save($options);

    }

    /**

     * Update the model in the database within a transaction.

     *

     * @param  array  $attributes

     * @param  array  $options

     * @return bool

     *

     * @throws \Throwable