LaravelFreelancerNL\Aranguent\Eloquent\Concerns\QueriesAranguentRelationships::withAggregate()

Complexity

Conditions	9
Paths	29

Size

Total Lines	69
Code Lines	31

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	32
CRAP Score	9.0164

Importance

Changes	2
Bugs	0	Features	0

<?php
    public function withAggregate($relations, $column, $function = null)
    {
        if (empty($relations)) {
            return $this;
        }

        if (empty($this->query->columns)) {
            $this->query->select([$this->query->from . '.*']);
        }

        $relations = is_array($relations) ? $relations : [$relations];

        foreach ($this->parseWithRelations($relations) as $name => $constraints) {

It seems like parseWithRelations() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            // First we will determine if the name has been aliased using an "as" clause on the name
            // and if it has we will extract the actual relationship name and the desired name of
            // the resulting column. This allows multiple aggregates on the same relationships.
            $segments = explode(' ', $name);

            [$name, $alias] = $this->extractNameAndAlias($segments, $name);

            $relation = $this->getRelationWithoutConstraints((string) $name);

It seems like getRelationWithoutConstraints() must be provided by classes using this trait. How about adding it as abstract method to this trait?

            $expression = $column;

            if ($function) {
                $hashedColumn = $this->getRelationHashedColumn($column, $relation);

It seems like getRelationHashedColumn() must be provided by classes using this trait. How about adding it as abstract method to this trait?

                $wrappedColumn = $this->getQuery()->getGrammar()->wrap(
                    $column === '*' ? $column : $relation->getRelated()->qualifyColumn($hashedColumn)
                );

                $expression = $function === 'exists' ? $wrappedColumn : sprintf('%s(%s)', $function, $wrappedColumn);
            }

            // Here, we will grab the relationship sub-query and prepare to add it to the main query
            // as a sub-select. First, we'll get the "has" query and use that to get the relation
            // sub-query. We'll format this relationship name and append this column if needed.
            $query = $relation->getRelationExistenceQuery(
                $relation->getRelated()->newQuery(),
                $this,
                new Expression($expression)
            )->setBindings([], 'select');

            $query->callScope($constraints);

            $query = $query->mergeConstraintsFrom($relation->getQuery())->toBase();

            // If the query contains certain elements like orderings / more than one column selected
            // then we will remove those elements from the query so that it will execute properly
            // when given to the database. Otherwise, we may receive SQL errors or poor syntax.
            unset($query->orders);
            $query->setBindings([], 'order');

            if (count($query->columns) > 1) {
                $query->columns = [$query->columns[0]];
                $query->bindings['select'] = [];
            }

            // Finally, we will make the proper column alias to the query and run this sub-select on
            // the query builder. Then, we will return the builder instance back to the developer
            // for further constraint chaining that needs to take place on the query as needed.
            $alias = Str::snake(
                (string) preg_replace('/[^[:alnum:][:space:]_]/u', '', "$name $function $column")
            );

            $this->handleAggregateFunction($query, $function, $alias);
        }

        return $this;
    }