App\Services\LastfmService

Complexity

Total Complexity

44

Size/Duplication

Total Lines	354
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	4

Test Coverage

Coverage

62.73%

Importance

Changes

0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	used()	0	4	1
A	enabled()	0	4	2
B	getArtistInformation()	0	31	6
A	buildArtistInformation()	0	11	2
B	getAlbumInformation()	0	34	6
A	buildAlbumInformation()	0	18	2
A	fetchSessionKeyUsingToken()	0	15	2
A	scrobble()	0	16	3
A	toggleLoveTrack()	0	11	3
A	updateNowPlaying()	0	15	3
A	buildAuthCallParams()	0	27	4
A	formatText()	0	8	2
A	getUserSessionKey()	0	4	1
A	setUserSessionKey()	0	4	1
A	deleteUserSessionKey()	0	4	1
A	isUserConnected()	0	4	1
A	getKey()	0	4	1
A	getEndpoint()	0	4	1
A	getSecret()	0	4	1

<?php

namespace App\Services;

use App\Models\User;
use Exception;
use GuzzleHttp\Client;
use Illuminate\Contracts\Cache\Repository as Cache;
use Illuminate\Log\Logger;

class LastfmService extends ApiClient implements ApiConsumerInterface
{
    public const SESSION_KEY_PREFERENCE_KEY = 'lastfm_session_key';

    /**
     * Specify the response format, since Last.fm only returns XML.
     *
     * @var string
     */
    protected $responseFormat = 'xml';

    /**
     * Override the key param, since, again, Lastfm wants to be different.
     *
     * @var string
     */
    protected $keyParam = 'api_key';

    private $userPreferenceService;

    public function __construct(
        Client $client,
        Cache $cache,
        Logger $logger,
        UserPreferenceService $userPreferenceService
    ) {
        parent::__construct($client, $cache, $logger);
        $this->userPreferenceService = $userPreferenceService;
    }

    /**
     * Determine if our application is using Last.fm.
     */
    public function used(): bool
    {
        return (bool) $this->getKey();
    }

    /**
     * Determine if Last.fm integration is enabled.
     */
    public function enabled(): bool
    {
        return $this->getKey() && $this->getSecret();
    }

    /**
     * Get information about an artist.
     *
     * @param string $name Name of the artist
     *
     * @return mixed[]|null
     */
    public function getArtistInformation(string $name): ?array
    {
        if (!$this->enabled()) {
            return null;
        }

        $name = urlencode($name);

        try {
            return $this->cache->remember(md5("lastfm_artist_$name"), 24 * 60 * 7, function () use ($name): ?array {
                $response = $this->get("?method=artist.getInfo&autocorrect=1&artist=$name");

The call to get() misses a required argument $...$args.

                if (!$response) {
                    return null;
                }

                $response = simplexml_load_string($response->asXML());
                $response = json_decode(json_encode($response), true);

                if (!$response || !$artist = array_get($response, 'artist')) {
                    return null;
                }

                return $this->buildArtistInformation($artist);
            });
        } catch (Exception $e) {
            $this->logger->error($e);

            return null;
        }
    }

    /**
     * Build a Koel-usable array of artist information using the data from Last.fm.
     *
     * @param mixed[] $artistData
     *
     * @return mixed[]
     */
    private function buildArtistInformation(array $artistData): array
    {
        return [
            'url' => array_get($artistData, 'url'),
            'image' => count($artistData['image']) > 3 ? $artistData['image'][3] : $artistData['image'][0],
            'bio' => [
                'summary' => $this->formatText(array_get($artistData, 'bio.summary', '')),
                'full' => $this->formatText(array_get($artistData, 'bio.content', '')),
            ],
        ];
    }

    /**
     * Get information about an album.
     *
     * @return mixed[]|null
     */
    public function getAlbumInformation(string $albumName, string $artistName): ?array
    {
        if (!$this->enabled()) {
            return null;
        }

        $albumName = urlencode($albumName);
        $artistName = urlencode($artistName);

        try {
            $cacheKey = md5("lastfm_album_{$albumName}_{$artistName}");

            return $this->cache->remember($cacheKey, 24 * 60 * 7, function () use ($albumName, $artistName): ?array {
                $response = $this->get("?method=album.getInfo&autocorrect=1&album=$albumName&artist=$artistName");

The call to get() misses a required argument $...$args.

                if (!$response) {
                    return null;
                }

                $response = simplexml_load_string($response->asXML());
                $response = json_decode(json_encode($response), true);

                if (!$response || !$album = array_get($response, 'album')) {
                    return null;
                }

                return $this->buildAlbumInformation($album);
            });
        } catch (Exception $e) {
            $this->logger->error($e);

            return null;
        }
    }

    /**
     * Build a Koel-usable array of album information using the data from Last.fm.
     *
     * @param mixed[] $albumData
     *
     * @return mixed[]
     */
    private function buildAlbumInformation(array $albumData): array
    {
        return [
            'url' => array_get($albumData, 'url'),
            'image' => count($albumData['image']) > 3 ? $albumData['image'][3] : $albumData['image'][0],
            'wiki' => [
                'summary' => $this->formatText(array_get($albumData, 'wiki.summary', '')),
                'full' => $this->formatText(array_get($albumData, 'wiki.content', '')),
            ],
            'tracks' => array_map(function ($track) {
                return [
                    'title' => $track['name'],
                    'length' => (int) $track['duration'],
                    'url' => $track['url'],
                ];
            }, array_get($albumData, 'tracks.track', [])),
        ];
    }

    /**
     * Get Last.fm's session key for the authenticated user using a token.
     *
     * @param string $token The token after successfully connecting to Last.fm
     *
     * @link http://www.last.fm/api/webauth#4
     */
    public function fetchSessionKeyUsingToken(string $token): ?string
    {
        $query = $this->buildAuthCallParams([
            'method' => 'auth.getSession',
            'token' => $token,
        ], true);

        try {
            return (string) $this->get("/?$query", [], false)->session->key;

The call to LastfmService::get() has too many arguments starting with false.

        } catch (Exception $e) {
            $this->logger->error($e);

            return null;
        }
    }

    /**
     * Scrobble a song.
     *
     * @param string     $artist    The artist name
     * @param string     $track     The track name
     * @param string|int $timestamp The UNIX timestamp
     * @param string     $album     The album name
     * @param string     $sk        The session key
     */
    public function scrobble(string $artist, string $track, $timestamp, string $album, string $sk): void
    {
        $params = compact('artist', 'track', 'timestamp', 'sk');

        if ($album) {
            $params['album'] = $album;
        }

        $params['method'] = 'track.scrobble';

        try {
            $this->post('/', $this->buildAuthCallParams($params), false);

The call to LastfmService::post() has too many arguments starting with false.

        } catch (Exception $e) {
            $this->logger->error($e);
        }
    }

    /**
     * Love or unlove a track on Last.fm.
     *
     * @param string $track  The track name
     * @param string $artist The artist's name
     * @param string $sk     The session key
     * @param bool   $love   Whether to love or unlove. Such cheesy terms... urrgggh
     */
    public function toggleLoveTrack(string $track, string $artist, string $sk, ?bool $love = true): void
    {
        $params = compact('track', 'artist', 'sk');
        $params['method'] = $love ? 'track.love' : 'track.unlove';

        try {
            $this->post('/', $this->buildAuthCallParams($params), false);

The call to LastfmService::post() has too many arguments starting with false.

        } catch (Exception $e) {
            $this->logger->error($e);
        }
    }

    /**
     * Update a track's "now playing" on Last.fm.
     *
     * @param string    $artist   Name of the artist
     * @param string    $track    Name of the track
     * @param string    $album    Name of the album
     * @param int|float $duration Duration of the track, in seconds
     * @param string    $sk       The session key
     */
    public function updateNowPlaying(string $artist, string $track, string $album, $duration, string $sk): void
    {
        $params = compact('artist', 'track', 'duration', 'sk');
        $params['method'] = 'track.updateNowPlaying';

        if ($album) {
            $params['album'] = $album;
        }

        try {
            $this->post('/', $this->buildAuthCallParams($params), false);

The call to LastfmService::post() has too many arguments starting with false.

        } catch (Exception $e) {
            $this->logger->error($e);
        }
    }

    /**
     * Build the parameters to use for _authenticated_ Last.fm API calls.
     * Such calls require:
     * - The API key (api_key)
     * - The API signature (api_sig).
     *
     * @link http://www.last.fm/api/webauth#5
     *
     * @param array $params   The array of parameters.
     * @param bool  $toString Whether to turn the array into a query string
     *
     * @return array|string
     */
    public function buildAuthCallParams(array $params, bool $toString = false)
    {
        $params['api_key'] = $this->getKey();
        ksort($params);

        // Generate the API signature.
        // @link http://www.last.fm/api/webauth#6
        $str = '';

        foreach ($params as $name => $value) {
            $str .= $name.$value;
        }

        $str .= $this->getSecret();
        $params['api_sig'] = md5($str);

        if (!$toString) {
            return $params;
        }

        $query = '';
        foreach ($params as $key => $value) {
            $query .= "$key=$value&";
        }

        return rtrim($query, '&');
    }

    /**
     * Correctly format a value returned by Last.fm.
     *
     * @param string|array $value
     */
    protected function formatText($value): string
    {
        if (!$value) {
            return '';
        }

        return trim(str_replace('Read more on Last.fm', '', nl2br(strip_tags(html_entity_decode($value)))));
    }

    public function getUserSessionKey(User $user): ?string
    {
        return $this->userPreferenceService->get($user, self::SESSION_KEY_PREFERENCE_KEY);
    }

    public function setUserSessionKey(User $user, string $sessionKey): void
    {
        $this->userPreferenceService->set($user, self::SESSION_KEY_PREFERENCE_KEY, $sessionKey);
    }

    public function deleteUserSessionKey(User $user): void
    {
        $this->userPreferenceService->delete($user, self::SESSION_KEY_PREFERENCE_KEY);
    }

    public function isUserConnected(User $user): bool
    {
        return (bool) $this->getUserSessionKey($user);
    }

    public function getKey(): ?string
    {
        return config('koel.lastfm.key');
    }

    public function getEndpoint(): ?string
    {
        return config('koel.lastfm.endpoint');
    }

    public function getSecret(): ?string
    {
        return config('koel.lastfm.secret');
    }
}