App\Services\DownloadService

Complexity

Total Complexity

14

Size/Duplication

Total Lines	83
Duplicated Lines	0 %

Test Coverage

Coverage

21.05%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	fromAlbum()	0	3	1
A	fromMultipleSongs()	0	10	2
A	fromArtist()	0	3	1
A	from()	0	16	6
A	__construct()	0	3	1
A	fromSong()	0	20	2
A	fromPlaylist()	0	3	1

<?php

namespace App\Services;

use App\Models\Album;
use App\Models\Artist;
use App\Models\Playlist;
use App\Models\Song;
use App\Models\SongZipArchive;
use Illuminate\Database\Eloquent\Collection;
use InvalidArgumentException;

class DownloadService
{
    private $s3Service;

    public function __construct(S3Service $s3Service)
    {
        $this->s3Service = $s3Service;
    }

    /**
     * Generic method to generate a download archive from various source types.
     *
     * @param Song|Collection|Album|Artist|Playlist $mixed
     *
     * @throws InvalidArgumentException
     *
     * @return string Full path to the generated archive
     */
    public function from($mixed): string
    {
        switch (get_class($mixed)) {
            case Song::class:
                return $this->fromSong($mixed);

It seems like $mixed can also be of type App\Models\Album and App\Models\Artist and App\Models\Playlist and Illuminate\Database\Eloquent\Collection; however, parameter $song of App\Services\DownloadService::fromSong() does only seem to accept App\Models\Song, maybe add an additional type check?

            case Collection::class:
                return $this->fromMultipleSongs($mixed);

It seems like $mixed can also be of type App\Models\Album and App\Models\Artist and App\Models\Playlist and App\Models\Song; however, parameter $songs of App\Services\DownloadService::fromMultipleSongs() does only seem to accept Illuminate\Database\Eloquent\Collection, maybe add an additional type check?

            case Album::class:
                return $this->fromAlbum($mixed);

It seems like $mixed can also be of type App\Models\Artist and App\Models\Playlist and App\Models\Song and Illuminate\Database\Eloquent\Collection; however, parameter $album of App\Services\DownloadService::fromAlbum() does only seem to accept App\Models\Album, maybe add an additional type check?

            case Artist::class:
                return $this->fromArtist($mixed);

It seems like $mixed can also be of type App\Models\Album and App\Models\Playlist and App\Models\Song and Illuminate\Database\Eloquent\Collection; however, parameter $artist of App\Services\DownloadService::fromArtist() does only seem to accept App\Models\Artist, maybe add an additional type check?

            case Playlist::class:
                return $this->fromPlaylist($mixed);

It seems like $mixed can also be of type App\Models\Album and App\Models\Artist and App\Models\Song and Illuminate\Database\Eloquent\Collection; however, parameter $playlist of App\Services\DownloadService::fromPlaylist() does only seem to accept App\Models\Playlist, maybe add an additional type check?

        }

        throw new InvalidArgumentException('Unsupported download type.');
    }

    public function fromSong(Song $song): string
    {
        if ($s3Params = $song->s3_params) {
            // The song is hosted on Amazon S3.
            // We download it back to our local server first.
            $url = $this->s3Service->getSongPublicUrl($song);
            abort_unless($url, 404);

$url of type string is incompatible with the type boolean expected by parameter $boolean of abort_unless().

            $localPath = sys_get_temp_dir().DIRECTORY_SEPARATOR.basename($s3Params['key']);

            // The following function requires allow_url_fopen to be ON.
            // We're just assuming that to be the case here.
            copy($url, $localPath);
        } else {
            // The song is hosted locally. Make sure the file exists.
            $localPath = $song->path;
            abort_unless(file_exists($localPath), 404);
        }

        return $localPath;
    }

    protected function fromMultipleSongs(Collection $songs): string
    {
        if ($songs->count() === 1) {
            return $this->fromSong($songs->first());
        }

        return (new SongZipArchive())
            ->addSongs($songs)
            ->finish()
            ->getPath();
    }

    protected function fromPlaylist(Playlist $playlist): string
    {
        return $this->fromMultipleSongs($playlist->songs);
    }

    protected function fromAlbum(Album $album): string
    {
        return $this->fromMultipleSongs($album->songs);
    }

    protected function fromArtist(Artist $artist): string
    {
        return $this->fromMultipleSongs($artist->songs);

$artist->songs of type App\Models\Song is incompatible with the type Illuminate\Database\Eloquent\Collection expected by parameter $songs of App\Services\DownloadService::fromMultipleSongs().

    }
}