AlgoWeb\PODataLaravel\Query\LaravelReadQueryUtilityTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	128
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	processKeyDescriptor()	0	7	4
A	getLaravelRelationName()	0	8	2
A	processEagerLoadList()	0	17	5
A	getSourceEntityInstance()	0	4	1
A	checkSourceInstance()	0	12	5
B	processSkipToken()	0	33	6

<?php
/**
 * Created by PhpStorm.
 * User: alex
 * Date: 14/02/20
 * Time: 10:54 PM
 */

namespace AlgoWeb\PODataLaravel\Query;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\Relation;
use Illuminate\Support\Facades\App;
use POData\Providers\Metadata\ResourceSet;
use POData\UriProcessor\QueryProcessor\SkipTokenParser\SkipTokenInfo;
use POData\Common\InvalidOperationException;
use POData\Common\ODataException;
use POData\UriProcessor\ResourcePathProcessor\SegmentParser\KeyDescriptor;
use Symfony\Component\Process\Exception\InvalidArgumentException;

trait LaravelReadQueryUtilityTrait
{
    protected $name;

    /**
     * @param SkipTokenInfo $skipToken
     * @param Model|Builder $sourceEntityInstance
     * @return mixed
     * @throws InvalidOperationException
     */
    protected function processSkipToken(SkipTokenInfo $skipToken, $sourceEntityInstance)
    {
        $parameters = [];
        $processed = [];
        $segments = $skipToken->getOrderByInfo()->getOrderByPathSegments();
        $values = $skipToken->getOrderByKeysInToken();
        $numValues = count($values);
        if ($numValues != count($segments)) {
            $msg = 'Expected '.count($segments).', got '.$numValues;
            throw new InvalidOperationException($msg);
        }

        for ($i = 0; $i < $numValues; $i++) {
            $relation = $segments[$i]->isAscending() ? '>' : '<';
            $name = $segments[$i]->getSubPathSegments()[0]->getName();
            $parameters[$name] = ['direction' => $relation, 'value' => trim($values[$i][0], '\'')];

$values[$i][0] of type POData\Providers\Metadata\Type\IType is incompatible with the type string expected by parameter $str of trim().

        }

        foreach ($parameters as $name => $line) {
            $processed[$name] = ['direction' => $line['direction'], 'value' => $line['value']];
            $sourceEntityInstance = $sourceEntityInstance
                ->orWhere(
                    function (Builder $query) use ($processed) {
                        foreach ($processed as $key => $proc) {
                            $query->where($key, $proc['direction'], $proc['value']);
                        }
                    }
                );
            // now we've handled the later-in-order segment for this key, drop it back to equality in prep
            // for next key - same-in-order for processed keys and later-in-order for next
            $processed[$name]['direction'] = '=';
        }
        return $sourceEntityInstance;
    }

    /**
     * @param  ResourceSet $resourceSet
     * @return mixed
     * @throws \ReflectionException
     */
    protected function getSourceEntityInstance(ResourceSet $resourceSet)
    {
        $entityClassName = $resourceSet->getResourceType()->getInstanceType()->name;
        return App::make($entityClassName);
    }

    /**
     * @param Model|Relation|null $source
     * @param ResourceSet|null $resourceSet
     * @return Model|Relation|mixed|null
     * @throws \ReflectionException
     */
    protected function checkSourceInstance($source, ResourceSet $resourceSet = null)
    {
        if (!(null == $source || $source instanceof Model || $source instanceof Relation)) {

$source is always a sub-type of Illuminate\Database\Eloquent\Relations\Relation.

            $msg = 'Source entity instance must be null, a model, or a relation.';
            throw new InvalidArgumentException($msg);
        }

        if (null == $source) {
            $source = $this->getSourceEntityInstance(/** @scrutinizer ignore-type */$resourceSet);
        }

        return $source;
    }

    /**
     * @param Model|Builder $sourceEntityInstance
     * @param  KeyDescriptor|null        $keyDescriptor
     * @throws InvalidOperationException
     */
    protected function processKeyDescriptor(&$sourceEntityInstance, KeyDescriptor $keyDescriptor = null)
    {
        if ($keyDescriptor) {
            $table = ($sourceEntityInstance instanceof Model) ? $sourceEntityInstance->getTable() . '.' : '';
            foreach ($keyDescriptor->getValidatedNamedValues() as $key => $value) {
                $trimValue = trim($value[0], '\'');
                $sourceEntityInstance = $sourceEntityInstance->where($table . $key, $trimValue);
            }
        }
    }

    /**
     * @param  string[]|null $eagerLoad
     * @return array
     * @throws InvalidOperationException
     */
    protected function processEagerLoadList(array $eagerLoad = null)
    {
        $load = (null === $eagerLoad) ? [] : $eagerLoad;
        $rawLoad = [];
        foreach ($load as $line) {
            if (!is_string($line)) {
                throw new InvalidOperationException('Eager-load elements must be non-empty strings');
            }
            $lineParts = explode('/', $line);
            $numberOfParts = count($lineParts);
            for ($i = 0; $i < $numberOfParts; $i++) {
                $lineParts[$i] = $this->getLaravelRelationName($lineParts[$i]);
            }
            $remixLine = implode('.', $lineParts);
            $rawLoad[] = $remixLine;
        }
        return $rawLoad;
    }

    /**
     * @param  string $odataProperty
     * @return string
     */
    protected function getLaravelRelationName($odataProperty)
    {
        $laravelProperty = $odataProperty;
        $pos = strrpos($laravelProperty, '_');
        if ($pos !== false) {
            $laravelProperty = substr($laravelProperty, 0, $pos);
        }
        return $laravelProperty;
    }
}