PHP Builder::getModel方法代码示例

 /**
  * Add the constraints for a relationship count query on the same table.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $query
  * @param  \Illuminate\Database\Eloquent\Builder  $parent
  * @return \Illuminate\Database\Eloquent\Builder
  */
 public function getRelationCountQueryForSelfRelation(Builder $query, Builder $parent)
 {
     $query->select(new Expression('count(*)'));
     $query->from($query->getModel()->getTable() . ' as ' . ($hash = $this->getRelationCountHash()));
     $query->getModel()->setTable($hash);
     $key = $this->wrap($this->getQualifiedParentKeyName());
     return $query->where($hash . '.' . $this->getPlainForeignKey(), '=', new Expression($key));
 }

 /**
  * Applies criterion to query.
  *
  * @param Builder $builder query builder
  */
 public function apply(Builder $builder)
 {
     $sortMethod = 'sort' . studly_case($this->getField());
     if (method_exists($builder->getModel(), $sortMethod)) {
         call_user_func_array([$builder->getModel(), $sortMethod], [$builder, $this->getOrder()]);
     } else {
         $builder->orderBy($this->getField(), $this->getOrder());
     }
 }

 /**
  * @return array list of relations that can be eagerly loaded
  */
 protected function _getWithableRelations(Builder $builder)
 {
     if (method_exists($builder->getModel(), 'getWithableRelations')) {
         return $builder->getModel()->getWithableRelations();
     }
     if (property_exists($builder->getModel(), 'withable')) {
         return $builder->getModel()->withable;
     }
     throw new RuntimeException(sprintf('Model %s must either implement getWithableRelations() or have $withable property set', get_class($builder->getModel())));
 }

 /**
  * @param Builder $builder
  *
  * @return array list of sortable attributes
  */
 protected function _getSortableAttributes(Builder $builder)
 {
     if (method_exists($builder->getModel(), 'getSortableAttributes')) {
         return $builder->getModel()->getSortableAttributes();
     }
     if (property_exists($builder->getModel(), 'sortable')) {
         return $builder->getModel()->sortable;
     }
     throw new RuntimeException(sprintf('Model %s must either implement getSortableAttributes() or have $sortable property set', get_class($builder->getModel())));
 }

 /**
  * Initialize
  *
  * @return void
  */
 public function initialize()
 {
     if (!$this->initialized) {
         $query = $this->builder->toBase();
         $sql = $query->toSql();
         $bindings = $query->getBindings();
         $conn = $query->getConnection();
         $this->statement = $conn->getPdo()->prepare($sql);
         $this->statement->execute($conn->prepareBindings($bindings));
         $this->prototype = $this->builder->getModel()->newFromBuilder();
     }
     $this->initialized = true;
 }

 /**
  * @param Model|Builder $model
  * @return Model
  */
 public function search($model)
 {
     if ($model instanceof SearchableModel) {
         $this->fieldConfig = $model->searchableFields();
         $this->primaryTable = $model->getTable();
     }
     if ($model instanceof Relation) {
         $this->primaryTable = $model->getModel()->getTable();
         $this->fieldConfig = $model->getModel()->searchableFields();
         $this->apply($model->getQuery());
         return $model;
     }
     return $this->apply($model);
 }

 /**
  * @param Builder $query
  */
 private function getOrderColumn($query)
 {
     if ($this->column instanceof Expression) {
         return $this->column;
     }
     return $query->getModel()->getTable() . '.' . $this->column;
 }

 /**
  * If column name could not be resolved then use primary key.
  *
  * @return string
  */
 protected function getPrimaryKeyName()
 {
     if ($this->isEloquent()) {
         return $this->query->getModel()->getKeyName();
     }
     return 'id';
 }

 /**
  * Applies filter to given query
  *
  * @param Builder $queryBuilder
  */
 public function apply(Builder $queryBuilder)
 {
     if ($this->value()) {
         $related = $this->list->getCallable($queryBuilder->getModel(), $this->field, false);
         $queryBuilder->where($this->qualifiedFieldName($related, $related->getKeyName()), $this->value());
     }
 }

 /**
  * Create a new morph to many relationship instance.
  *
  * @param  \Illuminate\Database\Eloquent\Builder  $query
  * @param  \Illuminate\Database\Eloquent\Model  $parent
  * @param  string  $name
  * @param  string  $table
  * @param  string  $foreignKey
  * @param  string  $otherKey
  * @param  string  $relationName
  * @param  bool  $inverse
  * @return void
  */
 public function __construct(Builder $query, Model $parent, $name, $table, $foreignKey, $otherKey, $relationName = null, $inverse = false)
 {
     $this->inverse = $inverse;
     $this->morphType = $name . '_type';
     $this->morphClass = $inverse ? $query->getModel()->getMorphClass() : $parent->getMorphClass();
     parent::__construct($query, $parent, $table, $foreignKey, $otherKey, $relationName);
 }

 public function generateFromRelations()
 {
     $this->parent = $this->query->getModel();
     foreach (explode('.', $this->relations) as $index => $relation) {
         $this->index = $index;
         $this->relation = call_user_func(array($this->parent, $relation));
         $this->related = $this->relation->getRelated();
         if ($this->nested) {
             if (!array_key_exists($this->index, $this->ons)) {
                 $this->ons[$this->index] = [];
             }
             if (!array_key_exists($this->index, $this->conditions)) {
                 $this->conditions[$this->index] = [];
             }
         }
         if ($this->relation instanceof BelongsTo) {
             $this->generateJoinFromBelongsTo($this->relation);
         } elseif ($this->relation instanceof BelongsToMany) {
             $this->generateJoinFromBelongsToMany($this->relation);
         } elseif ($this->relation instanceof HasOneOrMany) {
             $this->generateJoinFromHasOneOrMany($this->relation);
         }
         $this->parent = $this->relation->getRelated();
     }
     if ($this->addNullCondition) {
         if ($this->relation instanceof BelongsTo) {
             $this->generateNullConditionFromBelongsTo($this->relation);
         } elseif ($this->relation instanceof BelongsToMany) {
             $this->generateNullConditionFromBelongsToMany();
         } elseif ($this->relation instanceof HasOneOrMany) {
             $this->generateNullConditionFromHasOneOrMany($this->relation);
         }
     }
 }

 /**
  * Create a new relation instance.
  *
  * @param  Illuminate\Database\Eloquent\Builder
  * @param  Illuminate\Database\Eloquent\Model
  * @return void
  */
 public function __construct(Builder $query, Model $parent)
 {
     $this->query = $query;
     $this->parent = $parent;
     $this->related = $query->getModel();
     $this->addConstraints();
 }

 /**
  * @param Builder $builder
  * @param Model   $model
  */
 public function apply(Builder $builder, Model $model)
 {
     if (!Auth::guest() && Auth::user()->hasCountryRole()) {
         $country = Auth::user()->country;
         if ($builder->getModel()->getTable() == "activity_logs") {
             $builder->whereHas('contract', function ($q) use($country) {
                 $q->whereRaw("contracts.metadata->'country'->>'code' in (?)", $country);
             });
         } elseif ($builder->getModel()->getTable() == "contract_annotations") {
             $builder->whereHas('contract', function ($q) use($country) {
                 $q->whereRaw("contracts.metadata->'country'->>'code' in (?)", $country);
             });
         } else {
             $builder->whereRaw("contracts.metadata->'country'->>'code' in (?)", $country);
         }
     }
 }

 /**
  * Add the only-trashed extension to the builder.
  *
  * @param  \Illuminate\Database\Eloquent\Builder $builder
  * @return void
  */
 protected function addOnlyOffline(Builder $builder)
 {
     $builder->macro('onlyOffline', function (Builder $builder) {
         $model = $builder->getModel();
         $builder->withoutGlobalScope($this)->where($model->getQualifiedStatusColumn(), '=', false);
         return $builder;
     });
 }

 /**
  * @param Builder $builder
  */
 protected function addOnlyOldVersions(Builder $builder)
 {
     $builder->macro('onlyOldVersions', function (Builder $builder) {
         $model = $builder->getModel();
         $builder->withoutGlobalScope($this)->where($model->getQualifiedIsCurrentVersionColumn(), 0);
         return $builder;
     });
 }