public static function scopeWithTag(Builder $query, $tags, $type = 'slug') { $tags = (new static())->prepareTags($tags); return $query->whereHas('tags', function ($query) use($type, $tags) { $query->whereIn($type, $tags); }); }
/** * @param Builder $src * @param OperationInterface|SortOperation $operation * @return mixed */ public function process($src, OperationInterface $operation) { $field = $operation->getField(); $order = $operation->getOrder(); $src->orderBy($field, $order); return $src; }
/** * Apply the scope to a given Eloquent query builder. * @param Builder $builder * @param Model $model */ public function apply(Builder $builder, Model $model) { $builder->join('uris', function ($join) use($model) { $join->where('uris.owner_type', '=', get_class($model)); $join->on('uris.owner_id', '=', $model->getTable() . '.' . $model->getKeyName()); })->select([$model->getTable() . '.*', 'uris.uri']); }
/** * 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(); }
/** * Scope a query to only include records that are visible to a user. * * @param Builder $query * @param User $actor * @return Builder */ protected function scopeVisibleTo(Builder $query, User $actor = null) { if ($actor !== null) { $query->whereVisibleTo($actor); } return $query; }
/** * Handle the filter. * * @param Builder $query * @param SearchFilterInterface $filter */ public function handle(Builder $query, TableBuilder $builder, SearchFilterInterface $filter) { $stream = $filter->getStream(); $model = $builder->getTableModel(); /** * If the model is translatable then * join it's translations so they * are filterable too. * * @var EloquentQueryBuilder $query */ if ($model->getTranslationModelName() && !$query->hasJoin($model->getTranslationTableName())) { $query->leftJoin($model->getTranslationTableName(), $model->getTableName() . '.id', '=', $model->getTranslationTableName() . '.' . $model->getRelationKey()); } $query->where(function (Builder $query) use($filter, $stream) { foreach ($filter->getColumns() as $column) { $query->orWhere($column, 'LIKE', "%{$filter->getValue()}%"); } foreach ($filter->getFields() as $field) { $filter->setField($field); $fieldType = $stream->getFieldType($field); $fieldTypeQuery = $fieldType->getQuery(); $fieldTypeQuery->setConstraint('or'); $this->container->call([$fieldTypeQuery, 'filter'], compact('query', 'filter', 'builder')); } }); }
/** * @param User $actor * @param Builder $query */ public function find(User $actor, Builder $query) { // Hide discussions which have tags that the user is not allowed to see. $query->whereNotExists(function ($query) use($actor) { return $query->select(new Expression(1))->from('discussions_tags')->whereIn('tag_id', Tag::getIdsWhereCannot($actor, 'viewDiscussions'))->where('discussions.id', new Expression('discussion_id')); }); }
/** * @param Builder $query * @param SortInterface $sort */ public static function sort(Builder $query, SortInterface $sort) { /** @var Order $order */ foreach ($sort->orders() as $propertyName => $order) { $query->getQuery()->orderBy($propertyName, $order->isAscending() ? 'ASC' : 'DESC'); } }
/** * @param Builder $query * @param $wheres */ private function processWhere(Builder $query, $wheres) { $self = $this; foreach ($wheres as $where) { /** @var WhereParameter $where */ $query->where(function (Builder $query) use($self, $where) { if ($comparison = $where->getComparison()) { $query->where($comparison->getSubject(), $comparison->getOperator(), $comparison->getValue()); } foreach ($where->getChildren() as $child) { if ($child instanceof AndConjunction) { $query->where(function (Builder $query) use($self, $child) { $this->processWhere($query, [$child->getSubject()]); }); } elseif ($child instanceof OrConjunction) { $query->orWhere(function (Builder $query) use($self, $child) { $this->processWhere($query, [$child->getSubject()]); }); } else { throw new \InvalidArgumentException("Got an unknown conjunction"); } } }); } }
public function build(Builder $query) { $page = $this->page; return $query->join('pages_tags', 'tags.id', '=', 'pages_tags.tag_id')->join('pages', 'pages_tags.page_id', '=', 'pages.id')->where(function ($query) use($page) { $query->where('pages.id', '=', $page->getId())->orWhere('pages.parent_id', '=', $page->getId()); })->groupBy('tags.id')->orderBy('tags.name', 'asc'); }
/** * Extend Builder with custom method * * @param \Illuminate\Database\Eloquent\Builder $builder */ protected function addUnordered(Builder $builder) { $builder->macro('unordered', function (Builder $builder) { $this->remove($builder, $builder->getModel()); return $builder; }); }
public function withRelatedCriterion(QueryBuilder $query) { if ($this->related === null) { throw new \RuntimeException('No relationships defined in the repository. Eloquent does ' . 'not support reading relationships from the Model. Related ' . 'models must be defined in the $related property of the ' . 'repository.'); } return $query->with($this->related); }
/** * Set the keys for a save update query. * * @param \Illuminate\Database\Eloquent\Builder $query * @return \Illuminate\Database\Eloquent\Builder */ protected function setKeysForSaveQuery(Builder $query) { foreach ($this->getKeyName() as $key) { $query->where($key, '=', $this->getAttribute($key)); } return $query; }
/** * @param Builder $query * * @return Builder */ public function scopeSearch($query) { if (Input::has('q')) { $q = Input::get('q'); $model = $this; $query->where(function ($query2) use($q, $model) { foreach ($model->getColumns() as $searchColumn) { $table = $model->getTable(); $searchColumnExplode = explode('.', $searchColumn); if (count($searchColumnExplode) > 1) { $table = $searchColumnExplode[0]; $searchColumn = $searchColumnExplode[1]; } switch (Schema::getColumnType($table, $searchColumn)) { case 'integer': case 'bigint': case 'smallint': case 'float': if (is_numeric($q)) { $query2->orWhere($table . '.' . $searchColumn, '=', (int) $q); } break; case 'string': case 'text': $query2->orWhere($table . '.' . $searchColumn, 'ilike', "%{$q}%"); break; } } }); } return $query; }
/** * Query scope for finding "similar" slugs, used to determine uniqueness. * * @param \Illuminate\Database\Eloquent\Builder $query * @param \Illuminate\Database\Eloquent\Model $model * @param string $attribute * @param array $config * @param string $slug * @return \Illuminate\Database\Eloquent\Builder */ public function scopeFindSimilarSlugs(Builder $query, Model $model, $attribute, $config, $slug) { $separator = $config['separator']; return $query->where(function (Builder $q) use($attribute, $slug, $separator) { $q->where($attribute, '=', $slug)->orWhere($attribute, 'LIKE', $slug . $separator . '%'); }); }
protected function addWithDrafts(Builder $builder) { $builder->macro('withDrafts', function (Builder $builder) { $this->remove($builder, $builder->getModel()); return $builder; }); }
/** * 重写插入方法 * param Builder $query * param $attributes */ protected function insertAndSetId(Builder $query, $attributes) { //默认父ID $attributes[$this->treeField['parent_key']] = array_get($attributes, $this->treeField['parent_key'], 1); //初始化配置 $this->treeInit(app('NestedSetsService')); //开启事务,处理边界 DB::beginTransaction(); //边界处理,返回修改值 $attributes = $this->nestend->insert($attributes[$this->treeField['parent_key']], $attributes, 'bottom'); //保存数据 $id = $query->insertGetId($attributes, $keyName = $this->getKeyName()); //结果提交 if ($attributes !== false && $id) { DB::commit(); } else { DB::rollback(); return false; } //赋值 $this->setAttribute($keyName, $id); $this->setAttribute($this->treeField['parent_key'], $attributes[$this->treeField['parent_key']]); $this->setAttribute($this->treeField['level_key'], $attributes[$this->treeField['level_key']]); $this->setAttribute($this->treeField['left_key'], $attributes[$this->treeField['left_key']]); $this->setAttribute($this->treeField['right_key'], $attributes[$this->treeField['right_key']]); }
/** * Scope a query to only include records that are visible to a user. * * @param \Illuminate\Database\Eloquent\Builder $query * @param \Flarum\Core\Models\User $user * @return \Illuminate\Database\Eloquent\Builder */ protected function scopeVisibleForUser(Builder $query, User $user = null) { if ($user !== null) { $query->whereCan($user, 'view'); } return $query; }
public function build(Builder $query) { $text = $this->title; return $query->whereNested(function (QueryBuilder $query) use($text) { return $query->where('title', 'like', "%{$text}%")->orWhere('description', 'like', "%{$text}%"); }); }
/** * Constrain a query to an ability for a specific model. * * @param \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Builder $query * @param \Illuminate\Database\Eloquent\Model $model * @param bool $strict * @return void */ protected function constrainByModel($query, Model $model, $strict = false) { $query->where(function ($query) use($model, $strict) { $query->where($this->table . '.entity_type', $model->getMorphClass()); $query->where($this->abilitySubqueryConstraint($model, $strict)); }); }
/** * Fired just before querying * for table entries. * * @param Builder $query */ public function onQuerying(Builder $query) { $uploaded = $this->getUploaded(); $query->whereIn('id', $uploaded ?: [0]); $query->orderBy('updated_at', 'ASC'); $query->orderBy('created_at', 'ASC'); }
/** * Apply the scope to a given Eloquent query builder. * @param Builder $builder * @param Model $model */ public function apply(Builder $builder, Model $model) { $builder->join('product_translations', function ($join) { $join->on('products.id', '=', 'product_translations.product_id')->where('product_translations.locale', '=', app()->getLocale())->where('product_translations.published', '=', 1); }); $builder->select(['products.*']); }
/** * 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); }
/** * @param \Illuminate\Database\Eloquent\Builder $query * @param int $id * * @return \Illuminate\Database\Eloquent\Builder */ public function scopeEnabled($query, $id = null) { if ($id) { $query->where('id', '=', $id); } return $query->where('disabled', '=', false); }
/** * Get the siblings of the specified entry ID * * @param \Illuminate\Database\Eloquent\Builder $query * @param int|array $entryId * @return \Illuminate\Database\Eloquent\Builder */ public function scopeSiblings(Builder $query, $entryId) { $entryId = is_array($entryId) ? $entryId : array($entryId); $connection = $query->getQuery()->getConnection(); $tablePrefix = $connection->getTablePrefix(); return $query->join('relationships', 'relationships.child_id', '=', 'channel_titles.entry_id')->join($connection->raw("`{$tablePrefix}relationships` AS `{$tablePrefix}relationships_2`"), 'relationships_2.parent_id', '=', 'relationships.parent_id')->addSelect('*')->addSelect('relationships_2.child_id AS sibling_id')->whereIn('relationships_2.child_id', $entryId)->orderBy('relationships.order', 'asc')->groupBy('relationships_2.child_id')->groupBy('relationships.field_id')->groupBy('channel_titles.entry_id'); }
/** * Fired just before querying * for table entries. * * @param Builder $query */ public function onQuerying(Builder $query) { $uploaded = $this->getUploaded(); if ($fieldType = $this->getFieldType()) { /* * If we have the entry available then * we can determine saved sort order. */ $entry = $fieldType->getEntry(); $table = $fieldType->getPivotTableName(); if ($entry->getId() && !$uploaded) { $query->join($table, $table . '.file_id', '=', 'files_files.id'); $query->where($table . '.entry_id', $entry->getId()); $query->orderBy($table . '.sort_order', 'ASC'); } else { $query->whereIn('id', $uploaded ?: [0]); } } else { /* * If all we have is ID then just use that. * The JS / UI will be handling the sort * order at this time. */ $query->whereIn('id', $uploaded ?: [0]); } }
public function processField2Filter(Builder $builder, Constraint $constraint) { if ($constraint->getOperator() == Constraint::OPERATOR_IN && is_array($constraint->getValue()) && $constraint->getValue()) { $builder->where('field2', $constraint->getValue()[0]); return true; } }
/** * Adds a sort scope. * * @param \Illuminate\Database\Eloquent\Builder $query * @param string $column * @param string $direction * * @return \Illuminate\Database\Eloquent\Builder */ public function scopeSort(Builder $query, $column, $direction) { if (!in_array($column, $this->sortable)) { return $query; } return $query->orderBy($column, $direction); }
/** * 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())); $key = $this->wrap($this->getQualifiedParentKeyName()); return $query->where($hash . '.' . $this->getPlainForeignKey(), '=', new Expression($key)); }
/** * Returns a new Issue table. * * @param Issue|Builder $issue * @param array $with * @param Closure $closure * * @return \Orchestra\Contracts\Html\Builder */ public function table($issue, array $with = ['users', 'labels'], Closure $closure = null) { $label = request('label'); // Filter issues with the specified request label. $issue->with($with)->label($label)->latest(); return $this->table->of('issues', function (TableGrid $table) use($issue, $closure) { if ($closure instanceof Closure) { $table = call_user_func($closure, $table, $issue); } else { $table->with($issue)->paginate($this->perPage); } $table->sortable(['title', 'description', 'created_at']); $table->searchable(['title', 'description']); $table->column('status', function (Column $column) { $column->label = ''; $column->value = function (Issue $issue) { return $issue->present()->statusIcon(); }; $column->attributes(function () { return ['width' => '30']; }); }); $table->column('title', function (Column $column) { return $this->tableTitle($column); }); }); }