App\Services\SmartPlaylistService

Complexity

Total Complexity

11

Size/Duplication

Total Lines	70
Duplicated Lines	0 %

Test Coverage

Coverage

82.14%

Importance

Changes	1
Bugs	0	Features	0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	getSongs()	0	9	2
A	createRequireUserRule()	0	6	1
A	buildQueryFromRules()	0	13	2
A	addRequiresUserRules()	0	18	5
A	__construct()	0	3	1

<?php

namespace App\Services;

use App\Models\Playlist;
use App\Models\Rule;
use App\Models\Song;
use App\Models\User;
use App\Repositories\SongRepository;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Collection;
use RuntimeException;

class SmartPlaylistService
{
    private const RULE_REQUIRES_USER_PREFIXES = ['interactions.'];

    private $songRepository;

    public function __construct(SongRepository $songRepository)
    {
        $this->songRepository = $songRepository;
    }

    public function getSongs(Playlist $playlist): Collection
    {
        if (!$playlist->is_smart) {
            throw new RuntimeException($playlist->name.' is not a smart playlist.');
        }

        $rules = $this->addRequiresUserRules($playlist->rules, $playlist->user);

$playlist->rules of type string is incompatible with the type array expected by parameter $rules of App\Services\SmartPlaylistService::addRequiresUserRules().

        return $this->buildQueryFromRules($rules)->get();
    }

    public function buildQueryFromRules(array $rules): Builder
    {
        $query = Song::query();

        collect($rules)->each(static function (array $ruleGroup) use ($query): void {
            $query->orWhere(static function (Builder $subQuery) use ($ruleGroup): void {
                foreach ($ruleGroup['rules'] as $config) {
                    Rule::create($config)->build($subQuery);
                }
            });
        });

        return $query;
    }

    /**
     * Some rules need to be driven by an additional "user" factor, for example play count, liked, or last played
     * (basically everything related to interactions).
     * For those, we create an additional "user_id" rule.
     *
     * @param array[] $rules
     */
    public function addRequiresUserRules(array $rules, User $user): array
    {
        foreach ($rules as &$ruleGroup) {
            $additionalRules = [];

            foreach ($ruleGroup['rules'] as &$config) {
                foreach (self::RULE_REQUIRES_USER_PREFIXES as $modelPrefix) {
                    if (starts_with($config['model'], $modelPrefix)) {
                        $additionalRules[] = $this->createRequireUserRule($user, $modelPrefix);
                    }
                }
            }

            // make sure all those additional rules are unique.
            $ruleGroup['rules'] = array_merge($ruleGroup['rules'], collect($additionalRules)->unique('model')->all());
        }

        return $rules;
    }

    private function createRequireUserRule(User $user, string $modelPrefix): array
    {
        return [
            'model' => $modelPrefix.'user_id',
            'operator' => 'is',
            'value' => [$user->id],
        ];
    }
}