PHP Relation::getRelated方法代码示例

 public function __construct(array $config, ModelManager $modelManager, Model $model, EloquentRelation $eloquentRelation, FieldFactory $fieldFactory)
 {
     $this->checkNameConfig($config);
     $this->name = $config['name'];
     $this->slug = $config['name'];
     $this->relatedModel = $model;
     $this->eloquentRelation = $eloquentRelation;
     $this->fieldFactory = $fieldFactory;
     $this->modelManager = $modelManager;
     $this->config = $config;
     $this->setup();
     $this->modelAbstractor = \App::make('Anavel\\Crud\\Contracts\\Abstractor\\ModelFactory')->getByClassName(get_class($this->eloquentRelation->getRelated()), $this->config);
 }

 protected function verifyRelation(ReflectionMethod $method, Relation $relationship)
 {
     $expectedRelatedModel = $this->relatedModel === get_class($relationship->getRelated());
     $expectedRelationName = get_class($relationship) === $this->type;
     $expectedReturnAnnotation = $this->getReturnAnnotation($method) === $this->type;
     return $expectedRelationName && $expectedRelatedModel && $expectedReturnAnnotation;
 }

 /**
  *	Adds a join clause to the current relatedQuery using the relation Object.
  *
  *	@param \Illuminate\Database\Query 											$query
  *	@param \Illuminate\Database\Eloquent\Relations\Relation $relation
  *	@return \Illuminate\Database\Querys
  */
 protected function joinRelated($query, $relation)
 {
     $parentTable = $relation->getParent()->getTable();
     $parentKey = $relation->getParent()->getKeyName();
     $relatedTable = $relation->getRelated()->getTable();
     $fk = $relation->getForeignKey();
     $relationType = str_replace('Illuminate\\Database\\Eloquent\\Relations\\', '', get_class($relation));
     switch ($relationType) {
         case 'BelongsTo':
             $query->join($relatedTable, "{$relatedTable}.{$parentKey}", '=', "{$parentTable}.{$fk}");
             break;
         case 'HasOne':
         case 'HasMany':
         case 'MorphOne':
         case 'MorphMany':
             $query->join($relatedTable, "{$parentTable}.{$parentKey}", '=', "{$fk}");
             break;
         case 'BelongsToMany':
             $table = $relation->getTable();
             $otherKey = $relation->getOtherKey();
             $query->join($table, "{$parentTable}.{$parentKey}", '=', "{$fk}")->join($relatedTable, "{$relatedTable}.{$parentKey}", '=', "{$otherKey}");
             break;
         default:
             break;
     }
     return $query;
 }

 /**
  * @param Relation $relation
  * @param array    $excluded_ids
  */
 public static function deleteAllRelatedExcept(Relation $relation, $excluded_ids = [])
 {
     $related = $relation->getRelated();
     $key_name = $related->getKeyName();
     $query = $relation->getQuery();
     if (count($excluded_ids) > 0) {
         $query->whereNotIn($key_name, $excluded_ids);
     }
     $query->delete();
 }

 /**
  * @param $joinTableAlias
  * @param $currentTableAlias
  * @param BelongsTo|Relation $relation
  * @param string $columnsPrefix
  */
 protected function addJoinToQuery($joinTableAlias, $currentTableAlias, Relation $relation, $columnsPrefix = '')
 {
     $joinTableName = $relation->getRelated()->getTable();
     $joinTable = implode(' as ', [$joinTableName, $joinTableAlias]);
     $joinLeftCondition = implode('.', [$joinTableAlias, $relation->getOtherKey()]);
     $joinRightCondition = implode('.', [$currentTableAlias, $relation->getForeignKey()]);
     $this->query->leftJoin($joinTable, $joinLeftCondition, '=', $joinRightCondition);
     $columns = $this->getColumns($joinTableName);
     $prefix = static::$prefix . $columnsPrefix . $joinTableAlias . '---';
     foreach ($columns as $column) {
         $this->selectFromQuery($joinTableAlias, $column, $prefix . $column);
     }
 }

 public function __construct(array $config, ModelManager $modelManager, Model $model, EloquentRelation $eloquentRelation, FieldFactoryContract $fieldFactory)
 {
     $this->checkNameConfig($config);
     $this->name = $config['name'];
     $this->slug = $config['name'];
     $this->relatedModel = $model;
     $this->eloquentRelation = $eloquentRelation;
     $this->fieldFactory = $fieldFactory;
     $this->modelManager = $modelManager;
     $this->config = $config;
     $this->setup();
     $relatedModelClassName = get_class($this->eloquentRelation->getRelated());
     $relatedmodelRelationsConfig = [];
     foreach (config('anavel-crud.models') as $modelConfig) {
         if (is_array($modelConfig) && array_key_exists('model', $modelConfig) && $relatedModelClassName == $modelConfig['model']) {
             if (array_key_exists('relations', $modelConfig)) {
                 $relatedmodelRelationsConfig['relations'] = $modelConfig['relations'];
             }
         }
     }
     $this->modelAbstractor = \App::make('Anavel\\Crud\\Contracts\\Abstractor\\ModelFactory')->getByClassName(get_class($this->eloquentRelation->getRelated()), $relatedmodelRelationsConfig);
 }

 /**
  * Sets up the existing relationship wheres.
  *
  * @param \Illuminate\Database\Eloquent\Relations\Relation $relationship
  * @param string                                           $tableAlias
  * @param string                                           $pivotAlias
  * @param string                                           $pivot
  *
  * @return string
  */
 public function getRelationshipWheres($relationship, $tableAlias, $pivotAlias = null, $pivot = null)
 {
     //get the relationship model
     $relationshipModel = $relationship->getRelated();
     //get the query instance
     $query = $relationship->getQuery()->getQuery();
     //get the connection instance
     $connection = $query->getConnection();
     //one element of the relationship query's wheres is always useless (it will say pivot_table.other_id is null)
     //depending on whether or not softdeletes are enabled on the other model, this will be in either position 0
     //or 1 of the wheres array
     array_splice($query->wheres, method_exists($relationshipModel, 'getDeletedAtColumn') ? 1 : 0, 1);
     //iterate over the wheres to properly alias the columns
     foreach ($query->wheres as &$where) {
         //alias the where columns
         $where['column'] = $this->aliasRelationshipWhere($where['column'], $tableAlias, $pivotAlias, $pivot);
     }
     $sql = $query->toSql();
     $fullQuery = $this->interpolateQuery($sql, $connection->prepareBindings($query->getBindings()));
     $split = explode(' where ', $fullQuery);
     return isset($split[1]) ? $split[1] : '';
 }

 /**
  * Build join parameters.
  *
  * @param Relation $relation
  * @return array
  */
 protected function joinParameters(Relation $relation)
 {
     return [$relation->getRelated()->getTable(), $relation->getQualifiedParentKeyName(), '=', $relation->getForeignKey()];
 }

 /**
  * Get pair of the keys from relation in order to join the table.
  *
  * @param  \Illuminate\Database\Eloquent\Relations\Relation $relation
  * @return array
  *
  * @throws \LogicException
  */
 protected function getJoinKeys(Relation $relation)
 {
     if ($relation instanceof MorphTo) {
         throw new LogicException("MorphTo relation cannot be joined.");
     }
     if ($relation instanceof HasOneOrMany) {
         return [$relation->getForeignKey(), $relation->getQualifiedParentKeyName()];
     }
     if ($relation instanceof BelongsTo) {
         return [$relation->getQualifiedForeignKey(), $relation->getQualifiedOtherKeyName()];
     }
     if ($relation instanceof BelongsToMany) {
         return [$relation->getOtherKey(), $relation->getRelated()->getQualifiedKeyName()];
     }
     if ($relation instanceof HasManyThrough) {
         $fk = $relation->getRelated()->getTable() . '.' . $relation->getParent()->getForeignKey();
         return [$fk, $relation->getParent()->getQualifiedKeyName()];
     }
 }

 /**
  * Returns FQN for related model.
  *
  * @param Relation $relation
  * @return Model
  */
 protected function getModelForRelation(Relation $relation)
 {
     return $relation->getRelated();
 }