/**
* 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');
}
/**
* Adds a OrderBy to the query
*
* @param string
* @param string
* @return $this
*/
public function orderBy($column, $order = 'asc')
{
if ($column != null) {
$this->query->orderBy($column, $order);
}
return $this;
}
/**
* @param string $column
* @param string $direction
* @return $this
*/
public function applyOrderBy($column, $direction = 'asc')
{
/**
* Save to conditons.
*/
$this->addCondition('order by', [$column, $direction]);
$this->model = $this->model->orderBy($column, $direction);
return $this;
}
/**
* Order by columns based on parameters
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @param string $orderBy
* @return \Illuminate\Database\Eloquent\Builder
*/
public static function orderByColumns(Builder $query, $orderBy)
{
if (Request::has('orderbycolumn') == TRUE && Request::has('orderbytype') == TRUE) {
$query->orderBy(Request::input('orderbycolumn'), Request::input('orderbytype'));
} else {
foreach ($orderBy as $orderByColumn => $orderByType) {
$query->orderBy($orderByColumn, $orderByType);
}
}
return $query;
}
/**
* Sort
*
* @param \Illuminate\Database\Eloquent\Builder $builder
* @param string|null $sort Optional sort string
*
* @return \Illuminate\Database\Query\Builder
*/
public function scopeSort(Builder $builder, $sort = null)
{
if ((is_null($sort) || empty($sort)) && Input::has($this->getSortParameterName())) {
$sort = Input::get($this->getSortParameterName());
}
if (!is_null($sort)) {
$sort = explode(',', $sort);
foreach ($sort as $field) {
$field = trim($field);
$order = 'asc';
switch ($field[0]) {
case '-':
$field = substr($field, 1);
$order = 'desc';
break;
case '+':
$field = substr($field, 1);
break;
}
$field = trim($field);
if (in_array($field, $this->getSortable())) {
$builder->orderBy($field, $order);
}
}
}
}
/**
* 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]);
}
}
/**
* @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;
}
/**
* 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);
}
protected function parseSort(array $params, Query $query)
{
if (!isset($params['sort'])) {
return $query->orderBy('id', 'desc');
}
$column = strtolower($params['sort']);
$direction = 'asc';
if (strpos($params['sort'], '-') === 0) {
$direction = 'desc';
$column = ltrim($column, '-');
}
if (!in_array($column, Unit::getColumns())) {
return $query->orderBy('id', 'desc');
}
return $query->orderBy($column, $direction);
}
public function apply(Builder $builder, Model $model)
{
$table = $model->getTable();
$columns = $model->getDefaultOrderableColumns() ?: [];
foreach ($columns as $column => $order) {
$builder->orderBy("{$table}.{$column}", $order);
}
}
/**
* Apply scope on the query
*
* @param \Illuminate\Database\Eloquent\Builder $builder
* @param \Illuminate\Database\Eloquent\Model $model
*/
public function apply(Builder $builder, Model $model)
{
$columns = $model->getQualifiedOrderByColumns();
foreach ($columns as $column => $direction) {
$builder->orderBy($column, $direction);
}
$this->addUnordered($builder);
}
/**
* @param $field
* @param $direction
*
* @return $this
*/
protected function sortBy($field, $direction)
{
if (!in_array($direction, [DoplioDbTable::SORT_ASC, DoplioDbTable::SORT_DESC])) {
throw new \InvalidArgumentException(sprintf('%s is an invalid sort direction'), $direction);
}
$this->specificationQuery->orderBy($field, $direction);
return $this;
}
/**
* Orders a given query.
*
* @param \Illuminate\Database\Eloquent\Builder $query
* @return \Illuminate\Database\Eloquent\Builder
*/
public function scopeOrder($query)
{
if ($this->orderBy[0] !== null and $this->orderBy[1] !== null) {
return $query->orderBy($this->orderBy[0], $this->orderBy[1]);
}
// If the orderBy values are invalid, let's just return the query for now.
return $query;
}
/**
* 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());
}
}
/**
* Set the direction of the query.
*
* @param string|null $direction The date direction to order by
* @return Parser The parser instance itself
*/
public function direction($direction = null)
{
if ($direction == 'Latest') {
$this->query->orderBy('created_at', 'desc');
} elseif ($direction == 'Oldest') {
$this->query->orderBy('created_at', 'asc');
}
return $this;
}
public function newQuery()
{
$this->query = $this->getNew()->newQuery();
foreach ($this->orderBy as $column => $dir) {
$this->query->orderBy($column, $dir);
}
$this->applyScope();
return $this;
}
/**
* @param string $sessionKey
* @param Builder $query
* @return Builder
*/
public static function updateQuery($sessionKey, Builder $query)
{
foreach (Session::get($sessionKey, []) as $field => $clause) {
if ($clause == 'asc' || $clause == 'desc') {
$query->orderBy($field, $clause);
}
}
return $query;
}
/**
* Setup basic query string filter to eloquent or query builder.
*
* @param \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Builder $query
* @param array $input
*
* @return \Illuminate\Database\Eloquent\Builder|\Illuminate\Database\Query\Builder
*/
protected function setupBasicQueryFilter($query, array $input = [])
{
$orderBy = $this->getBasicQueryOrderBy($input);
$direction = $this->getBasicQueryDirection($input);
$columns = isset($input['columns']) ? $input['columns'] : null;
if (is_array($columns) && $this->isColumnExcludedFromFilterable($orderBy, $columns)) {
return $query;
}
!empty($orderBy) && $query->orderBy($orderBy, $direction);
return $query;
}
/**
* Apply the scope to a given Eloquent query builder.
* @param Builder $builder
* @param Model $model
*/
public function apply(Builder $builder, Model $model)
{
$field = 'sort';
$order = 'asc';
if (property_exists(get_class($model), 'autosort')) {
$autosort = (array) $model->autosort;
$field = $autosort[0];
$order = isset($autosort[1]) ? $autosort[1] : $order;
}
$builder->orderBy($field, $order);
}
/**
* Get a new query builder instance with the applied
* the order by and scopes.
*
* @param bool $skipOrdering
*
* @return self
*/
public function newQuery($skipOrdering = false)
{
$this->query = $this->getNew()->newQuery();
// Apply order by
if ($skipOrdering === false) {
foreach ($this->orderBy as $column => $dir) {
$this->query->orderBy($column, $dir);
}
}
$this->applyScope();
return $this;
}
public function build()
{
$request = $this->request;
$needle = $request->needle();
if ($needle && $request->searchable) {
$this->qb->where(function ($subQB) use($needle, $request) {
foreach ($request->searchable as $column) {
$subQB->orWhere($column, 'LIKE', "%{$needle}%");
}
});
}
$request->modifyQuery($this->qb);
$this->qb->orderBy($request->orderBy(), $request->sortBy());
$count = $this->qb->count();
$this->qb->take($request->perPage());
$this->qb->offset($request->offset());
$paginator = new LengthAwarePaginator($request->items($this->qb), $count, $request->perPage(), $request->page());
$paginator->request = $request;
$paginator->appends($request->query());
$this->paginator = $paginator;
}
/**
* Set query order
*
* @return $this
*/
public function order()
{
$by = $this->getOrderBy();
$dir = $this->getOrderDir();
if ($by instanceof Closure) {
$by($this->getOrderByField(), $dir, $this->query);
} else {
if ($by) {
$this->query->orderBy($by, $dir);
}
}
return $this;
}
/**
* Datatable ordering
*
* @return null
*/
protected function ordering()
{
if (array_key_exists('order', $this->input) && count($this->input['order']) > 0) {
$columns = $this->cleanColumns($this->aliased_ordered_columns);
for ($i = 0, $c = count($this->input['order']); $i < $c; $i++) {
$order_col = (int) $this->input['order'][$i]['column'];
if (isset($columns[$order_col])) {
if ($this->input['columns'][$order_col]['orderable'] == "true") {
$this->query->orderBy($columns[$order_col], $this->input['order'][$i]['dir']);
}
}
}
}
}
/**
* @param JsonApiSerializer $serializer
* @param Builder $builder
* @param Model $model
*
* @return Builder
*/
protected static function sort(JsonApiSerializer $serializer, Builder $builder, Model $model)
{
$mapping = $serializer->getTransformer()->getMappingByClassName(get_class($model));
$sorts = RequestFactory::create()->getSortDirection();
if (!empty($sorts)) {
$aliased = $mapping->getAliasedProperties();
$sortsFields = str_replace(array_values($aliased), array_keys($aliased), array_keys($sorts));
$sorts = array_combine($sortsFields, array_values($sorts));
foreach ($sorts as $field => $direction) {
$builder->orderBy($field, $direction === 'ascending' ? 'ASC' : 'DESC');
}
}
return $builder;
}
/**
* Apply the scope to a given Eloquent query builder.
*
* @param \Illuminate\Database\Eloquent\Builder $builder
* @param \Illuminate\Database\Eloquent\Model $model
* @return Builder
*/
public function apply(Builder $builder, Model $model)
{
$defaultSort = $model->getDefaultSort() ?? null;
if (!$defaultSort) {
return $builder;
}
// if multidimensional we have multiple orderBy's
if (!is_array($defaultSort[0])) {
return $builder->orderBy(...$defaultSort);
}
foreach ($defaultSort as $orderBy) {
$builder = $builder->orderBy(...$orderBy);
}
return $builder;
}
/**
* Set clauses on the query builder
*
* @return $this
*/
protected function setClauses()
{
foreach ($this->wheres as $where) {
$this->query->where($where['column'], $where['operator'], $where['value']);
}
foreach ($this->whereIns as $whereIn) {
$this->query->whereIn($whereIn['column'], $whereIn['values']);
}
foreach ($this->orderBys as $orders) {
$this->query->orderBy($orders['column'], $orders['direction']);
}
if (isset($this->take) and !is_null($this->take)) {
$this->query->take($this->take);
}
if (isset($this->skip) and !is_null($this->skip)) {
$this->query->skip($this->skip);
}
if (isset($this->paginate) and !is_null($this->paginate)) {
$this->query->paginate($this->paginate);
}
return $this;
}
/**
* @param Builder $query
* @return Builder
*/
public function scopeRandom(Builder $query)
{
return $query->orderBy('RAND()');
}
/**
* Sort the query.
*
* @param Builder $builder
* @param string $direction
*/
public function scopeSorted(Builder $builder, $direction = 'asc')
{
$builder->orderBy('sort_order', $direction);
}
/**
* Takes the supplied $selectedItems mixed value and formats it to a usable array
*
* @param \Illuminate\Database\Query\Builder $query
* @param array $selectedItems
* @param \Frozennode\Administrator\Fields\Field $fieldObject
* @param string $relatedKeyTable
*
* @return array
*/
public function filterQueryBySelectedItems(EloquentBuilder &$query, array $selectedItems, Field $fieldObject, $relatedKeyTable)
{
$query->whereIn($relatedKeyTable, $selectedItems);
//if this is a BelongsToMany and a sort field is set, order it by the sort field
if ($fieldObject->getOption('multiple_values') && $fieldObject->getOption('sort_field')) {
$query->orderBy($fieldObject->getOption('sort_field'));
} else {
$query->orderBy($fieldObject->getOption('name_field'));
}
}
/**
* Let's be nice and provide an ordered scope.
*
* @param \Illuminate\Database\Eloquent\Builder $query
*
* @return \Illuminate\Database\Query\Builder
*/
public function scopeOrdered(\Illuminate\Database\Eloquent\Builder $query)
{
return $query->orderBy($this->determineOrderColumnName());
}
