| import config from '../../config.js' | |
| import { debugLog, makeRequest, encodeTrack, http1makeRequest } from '../utils.js' | |
| import searchWithDefault from './default.js' | |
| let csrfToken = null | |
| let authToken = null | |
| async function init() { | |
| debugLog('pandora', 5, { type: 1, message: 'Setting Pandora auth and CSRF token.' }) | |
| const { headers: headers } = await makeRequest('https://www.pandora.com', { method: 'HEAD' }) | |
| const csfr = headers['set-cookie'] | |
| if (!csfr[1]) return debugLog('pandora', 5, { type: 2, message: 'Failed to set CSRF token from Pandora.' }) | |
| csrfToken = { raw: csfr[1], parsed: /csrftoken=([a-f0-9]{16});/.exec(csfr[1])[1] } | |
| const { body: token } = await makeRequest('https://www.pandora.com/api/v1/auth/anonymousLogin', { | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'Content-Type': 'application/json', | |
| 'Accept': '*/*', | |
| 'X-CsrfToken': csrfToken.parsed | |
| }, | |
| method: 'POST' | |
| }) | |
| if (token.errorCode === 0) return debugLog('pandora', 5, { type: 2, message: 'Failed to set auth token from Pandora.' }) | |
| authToken = token.authToken | |
| debugLog('pandora', 5, { type: 1, message: 'Successfully set Pandora auth and CSRF token.' }) | |
| } | |
| async function search(query) { | |
| return new Promise(async (resolve) => { | |
| debugLog('search', 4, { type: 1, sourceName: 'Pandora', query }) | |
| const body = { | |
| query, | |
| types: ['TR'], | |
| listener: null, | |
| start: 0, | |
| count: config.options.maxResultsLength, | |
| annotate: true, | |
| searchTime: 0, | |
| annotationRecipe: 'CLASS_OF_2019' | |
| } | |
| const { body: data } = await makeRequest('https://www.pandora.com/api/v3/sod/search', { | |
| method: 'POST', | |
| headers: { | |
| 'Content-Type': 'application/json', | |
| 'Accept': '*/*', | |
| 'Content-Length': JSON.stringify(body).length | |
| }, | |
| body, | |
| disableBodyCompression: true | |
| }) | |
| if (data.results.length === 0) { | |
| return { | |
| loadType: 'empty', | |
| data: {} | |
| } | |
| } | |
| const tracks = [] | |
| let index = 0 | |
| let annotationKeys = Object.keys(data.annotations) | |
| if (annotationKeys.length > config.options.maxResultsLength) | |
| annotationKeys = annotationKeys.slice(0, config.options.maxResultsLength) | |
| annotationKeys.forEach(async (key) => { | |
| if (data.annotations[key].type === 'TR') { | |
| const search = await searchWithDefault(`${data.annotations[key].name} ${data.annotations[key].artistName}`) | |
| if (search.loadType === 'search') { | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: data.annotations[key].artistName, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: data.annotations[key].name, | |
| uri: `https://www.pandora.com${data.annotations[key].shareableUrlPath}`, | |
| artworkUrl: `https://content-images.p-cdn.com/${data.annotations[key].icon.artUrl}`, | |
| isrc: data.annotations[key].isrc, | |
| sourceName: 'pandora' | |
| } | |
| tracks.push({ | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| }) | |
| } | |
| } | |
| if (index !== data.results.length - 1) return index++ | |
| const new_tracks = [] | |
| annotationKeys.nForEach(async (key2) => { | |
| await tracks.nForEach((track) => { | |
| if (track.info.title !== data.annotations[key2].name || track.info.author !== data.annotations[key2].artistName) return false | |
| new_tracks.push(track) | |
| return true | |
| }) | |
| if (new_tracks.length !== tracks.length) return false | |
| debugLog('search', 4, { type: 2, sourceName: 'Pandora', tracksLen: new_tracks.length, query }) | |
| resolve({ | |
| loadType: 'search', | |
| data: new_tracks | |
| }) | |
| return true | |
| }) | |
| }) | |
| }) | |
| } | |
| async function loadFrom(query) { | |
| return new Promise(async (resolve) => { | |
| const type = /^(https:\/\/www\.pandora\.com\/)((playlist)|(station)|(podcast)|(artist))\/.+/.exec(query) | |
| debugLog('loadtracks', 4, { type: 1, loadType: type[2], sourceName: 'Pandora', query }) | |
| if (!type) { | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| if (!csrfToken) { | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: 'Pandora not available in current country.', | |
| severity: 'common', | |
| cause: 'Pandora availability' | |
| } | |
| }) | |
| } | |
| let lastPart = query.split('/') | |
| lastPart = lastPart[lastPart.length - 1] | |
| switch (type[2]) { | |
| case 'artist': { | |
| const { body: trackData } = await http1makeRequest('https://www.pandora.com/api/v4/catalog/annotateObjectsSimple', { | |
| body: { | |
| pandoraIds: [ lastPart ], | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken, | |
| 'Content-Type': 'application/json', | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| const keysTrackData = Object.keys(trackData) | |
| let trackType = null | |
| switch (trackData[keysTrackData[0]] ? trackData[keysTrackData[0]].type : 'unknown') { | |
| case 'TR': trackType = 'track'; break | |
| case 'AL': trackType = 'album'; break | |
| case 'AR': trackType = 'artist'; break | |
| default: trackType = 'unknown'; break | |
| } | |
| if (keysTrackData.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: trackType, sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| if (trackData.message) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: trackType, sourceName: 'Pandora', query, message: trackData.message }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: trackData.message, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| const trackId = trackData[keysTrackData[0]].pandoraId | |
| switch (trackData[keysTrackData].type) { | |
| case 'TR': { | |
| const item = trackData[keysTrackData] | |
| const search = await searchWithDefault(`${item.name} ${item.artistName}`) | |
| if (search.loadType !== 'search') | |
| return resolve(search) | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: item.artistName, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: item.name, | |
| uri: `https://www.pandora.com${item.shareableUrlPath}`, | |
| artworkUrl: `https://content-images.p-cdn.com/${item.icon.artUrl}`, | |
| isrc: item.isrc, | |
| sourceName: 'pandora' | |
| } | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Pandora', track, query }) | |
| resolve({ | |
| loadType: 'track', | |
| data: { | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| } | |
| }) | |
| break | |
| } | |
| case 'AL': { | |
| const { body: data } = await http1makeRequest('https://www.pandora.com/api/v4/catalog/getDetails', { | |
| body: { | |
| pandoraId: trackId | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| if (data.errors || typeof data !== 'object') { | |
| const errorMessage = typeof data !== 'object' ? 'Unknown error' : data.errors.map((err) => `${err.message} (${err.extensions.code})`).join('; ') | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'album', sourceName: 'Pandora', query, message: errorMessage }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: errorMessage, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| const tracks = [] | |
| let index = 0 | |
| let trackKeys = Object.keys(data.annotations) | |
| if (trackKeys.length > config.options.maxAlbumPlaylistLength) | |
| trackKeys = trackKeys.slice(0, config.options.maxAlbumPlaylistLength) | |
| trackKeys.forEach(async (key) => { | |
| const search = await searchWithDefault(`${data.annotations[key].name} ${data.annotations[key].artistName}`) | |
| if (search.loadType === 'search') { | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: data.annotations[key].artistName, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: data.annotations[key].name, | |
| uri: `https://www.pandora.com${data.annotations[key].shareableUrlPath}`, | |
| artworkUrl: `https://content-images.p-cdn.com/${data.annotations[key].icon.artUrl}`, | |
| isrc: data.annotations[key].isrc, | |
| sourceName: 'pandora' | |
| } | |
| tracks.push({ | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| }) | |
| } | |
| if (index !== trackKeys.length - 1) return index++ | |
| if (tracks.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'album', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| const new_tracks = [] | |
| trackKeys.nForEach(async (key2) => { | |
| await tracks.nForEach((track) => { | |
| if (track.info.title !== data.annotations[key2].name || track.info.author !== data.annotations[key2].artistName) return false | |
| new_tracks.push(track) | |
| return true | |
| }) | |
| if (new_tracks.length !== tracks.length) return false | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'album', sourceName: 'Pandora', playlistName: trackData[trackId].name }) | |
| resolve({ | |
| loadType: 'album', | |
| data: { | |
| info: { | |
| name: trackData[trackId].name, | |
| selectedTrack: 0, | |
| }, | |
| pluginInfo: {}, | |
| tracks: new_tracks, | |
| } | |
| }) | |
| return true | |
| }) | |
| }) | |
| break | |
| } | |
| case 'AR': { | |
| const { body: data } = await http1makeRequest('https://www.pandora.com/api/v1/graphql/graphql', { | |
| body: { | |
| operationName: 'GetArtistDetailsWithCuratorsWeb', | |
| query: 'query GetArtistDetailsWithCuratorsWeb($pandoraId: String!) {\n entity(id: $pandoraId) {\n ... on Artist {\n id\n type\n urlPath\n name\n trackCount\n albumCount\n bio\n canSeedStation\n stationListenerCount\n albumCount\n artistTracksId\n art {\n ...ArtFragment\n __typename\n }\n isMegastar\n headerArt {\n ...ArtFragment\n __typename\n }\n topTracksWithCollaborations {\n ...TrackFragment\n __typename\n }\n artistPlay {\n id\n __typename\n }\n events {\n externalId\n __typename\n }\n latestReleaseWithCollaborations {\n ...AlbumFragment\n __typename\n }\n topAlbumsWithCollaborations {\n ...AlbumFragment\n __typename\n }\n similarArtists {\n id\n name\n art {\n ...ArtFragment\n __typename\n }\n urlPath\n __typename\n }\n twitterHandle\n twitterUrl\n allArtistAlbums {\n totalItems\n __typename\n }\n curator {\n ...CurationFragment\n __typename\n }\n featured(types: [PL, AR, AL, TR, SF, PC, PE]) {\n ... on Playlist {\n ...PlaylistFragment\n __typename\n }\n ... on StationFactory {\n ...StationFactoryFragment\n __typename\n }\n ... on Artist {\n ...ArtistFragment\n __typename\n }\n ... on Album {\n ...AlbumFragment\n __typename\n }\n ... on Track {\n ...TrackFragment\n __typename\n }\n ... on Podcast {\n ...PodcastFragment\n __typename\n }\n ... on PodcastEpisode {\n ...PodcastEpisodeFragment\n __typename\n }\n __typename\n }\n __typename\n }\n __typename\n }\n}\n\nfragment ArtFragment on Art {\n artId\n dominantColor\n artUrl: url(size: WIDTH_500)\n}\n\nfragment TrackFragment on Track {\n pandoraId: id\n type\n name\n sortableName\n duration\n trackNumber\n explicitness\n hasRadio: canSeedStation\n shareableUrlPath: urlPath\n modificationtime: dateModified\n slugPlusPandoraId: slugPlusId\n artistId: artist {\n pandoraId: id\n __typename\n }\n artistName: artist {\n name\n __typename\n }\n albumId: album {\n pandoraId: id\n __typename\n }\n albumName: album {\n name\n __typename\n }\n album {\n urlPath\n __typename\n }\n icon: art {\n ...ArtFragment\n __typename\n }\n rightsInfo: rights {\n ...RightsFragment\n __typename\n }\n}\n\nfragment AlbumFragment on Album {\n pandoraId: id\n type\n name\n sortableName\n duration\n trackCount\n releaseDate\n explicitness\n isCompilation\n shareableUrlPath: urlPath\n modificationTime: dateModified\n slugPlusPandoraId: slugPlusId\n artistId: artist {\n pandoraId: id\n __typename\n }\n artistName: artist {\n name\n __typename\n }\n icon: art {\n ...ArtFragment\n __typename\n }\n artist {\n url\n __typename\n }\n rightsInfo: rights {\n ...RightsFragment\n __typename\n }\n}\n\nfragment CurationFragment on Curator {\n curatedStations {\n items {\n ...StationFactoryFragment\n __typename\n }\n __typename\n }\n playlists {\n items {\n ...PlaylistFragment\n __typename\n }\n __typename\n }\n}\n\nfragment PlaylistFragment on Playlist {\n pandoraId: id\n type\n name\n sortableName\n description\n duration\n totalTracks\n version\n isEditable\n linkedId\n linkedType: origin\n shareableUrlPath: urlPath\n modificationTime: dateModified\n unlocked: isUnlocked\n autogenForListener: isOfAnyOrigin(origins: [PERSONALIZED, SHARED])\n hasVoiceTrack: includesAny(types: [AM])\n listenerIdInfo: owner {\n listenerPandoraId: id\n displayName\n isMe\n __typename\n }\n icon: art {\n ...ArtFragment\n __typename\n }\n}\n\nfragment StationFactoryFragment on StationFactory {\n pandoraId: id\n type\n name\n sortableName\n hasTakeoverModes\n isHosted\n shareableUrlPath: urlPath\n modificationTime: dateModified\n seedId: seed {\n pandoraId: id\n __typename\n }\n seedType: seed {\n type\n __typename\n }\n icon: art {\n ...ArtFragment\n __typename\n }\n listenerCount\n}\n\nfragment ArtistFragment on Artist {\n pandoraId: id\n type\n name\n sortableName\n trackCount\n collaboration: isCollaboration\n megastar: isMegastar\n shareableUrlPath: urlPath\n modificationTime: dateModified\n hasRadio: canSeedStation\n icon: art {\n ...ArtFragment\n __typename\n }\n}\n\nfragment PodcastFragment on Podcast {\n pandoraId: id\n type\n name\n sortableName\n publisherName\n ordering: releaseType\n episodeCount: totalEpisodeCount\n shareableUrlPath: urlPath\n modificationTime: dateModified\n icon: art {\n ...ArtFragment\n __typename\n }\n rightsInfo: rights {\n ...RightsFragment\n __typename\n }\n}\n\nfragment PodcastEpisodeFragment on PodcastEpisode {\n pandoraId: id\n type\n name\n sortableName\n duration\n releaseDate\n explicitness\n shareableUrlPath: urlPath\n modificationTime: dateModified\n podcastId: podcast {\n pandoraId: id\n __typename\n }\n programName: podcast {\n name\n __typename\n }\n elapsedTime: playbackProgress {\n elapsedTime\n __typename\n }\n icon: art {\n ...ArtFragment\n __typename\n }\n rightsInfo: rights {\n ...RightsFragment\n __typename\n }\n}\n\nfragment RightsFragment on Rights {\n expirationTime\n hasInteractive\n hasRadioRights\n hasOffline\n}\n', | |
| variables: { | |
| pandoraId: trackId | |
| } | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| if (data.errors || typeof data !== 'object') { | |
| const errorMessage = typeof data !== 'object' ? 'Unknown error' : data.errors.map((err) => `${err.message} (${err.extensions.code})`).join('; ') | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'artist', sourceName: 'Pandora', query, message: errorMessage }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: errorMessage, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| const tracks = [] | |
| let index = 0 | |
| let topTracks = data.data.entity.topTracksWithCollaborations | |
| if (topTracks.length > config.options.maxAlbumPlaylistLength) | |
| topTracks = topTracks.slice(0, config.options.maxAlbumPlaylistLength) | |
| topTracks.forEach(async (pTrack) => { | |
| const search = await searchWithDefault(`${pTrack.name} ${pTrack.artistName.name}`) | |
| if (search.loadType === 'search') { | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: pTrack.artistName.name, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: pTrack.name, | |
| uri: `https://www.pandora.com${pTrack.shareableUrlPath}`, | |
| artworkUrl: pTrack.icon.artUrl, | |
| isrc: null, | |
| sourceName: 'pandora' | |
| } | |
| tracks.push({ | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| }) | |
| } | |
| if (index !== topTracks.length - 1) return index++ | |
| if (tracks.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'artist', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| const new_tracks = [] | |
| topTracks.nForEach(async (pTrack2) => { | |
| await tracks.nForEach((track) => { | |
| if (track.info.title !== pTrack2.name || track.info.author !== pTrack2.artistName.name) return false | |
| track.push(track) | |
| return true | |
| }) | |
| if (new_tracks.length !== tracks.length) return false | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: 'Pandora', playlistName: data.data.entity.name }) | |
| resolve({ | |
| loadType: 'artist', | |
| data: { | |
| info: { | |
| name: trackData[trackId].name, | |
| artworkUrl: `https://content-images.p-cdn.com/${trackData[trackId].icon.artUrl}`, | |
| }, | |
| pluginInfo: {}, | |
| tracks: new_tracks, | |
| } | |
| }) | |
| return true | |
| }) | |
| }) | |
| break | |
| } | |
| } | |
| break | |
| } | |
| case 'playlist': { | |
| const body = { | |
| request: { | |
| pandoraId: lastPart, | |
| playlistVersion: 0, | |
| offset: 0, | |
| limit: config.options.maxAlbumPlaylistLength, | |
| annotationLimit: config.options.maxAlbumPlaylistLength, | |
| allowedTypes: ['TR', 'AM'], | |
| bypassPrivacyRules: true | |
| } | |
| } | |
| const { body: data } = await makeRequest('https://www.pandora.com/api/v7/playlists/getTracks', { | |
| method: 'POST', | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'Content-Type': 'application/json', | |
| 'Accept': '*/*', | |
| 'Content-Length': JSON.stringify(body).length, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| body, | |
| disableBodyCompression: true | |
| }) | |
| const tracks = [] | |
| let index = 0 | |
| let keys = Object.keys(data.annotations).filter((key) => key.indexOf('TR:') !== -1) | |
| if (keys.length > config.options.maxAlbumPlaylistLength) | |
| keys = keys.slice(0, config.options.maxAlbumPlaylistLength) | |
| keys.forEach(async (key) => { | |
| const search = await searchWithDefault(`${data.annotations[key].name} ${data.annotations[key].artistName}`) | |
| if (search.loadType === 'search') { | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: data.annotations[key].visible, | |
| author: data.annotations[key].artistName, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: data.annotations[key].name, | |
| uri: search.data[0].info.uri, | |
| artworkUrl: `https://content-images.p-cdn.com/${data.annotations[key].icon.artUrl}`, | |
| isrc: data.annotations[key].isrc, | |
| sourceName: 'pandora' | |
| } | |
| tracks.push({ | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| }) | |
| } | |
| if (index !== keys.length - 1) return index++ | |
| if (tracks.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'playlist', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| const new_tracks = [] | |
| keys.nForEach(async (key2) => { | |
| await tracks.nForEach((track) => { | |
| if (track.info.title !== data.annotations[key2].name || track.info.author !== data.annotations[key2].artistName) return false | |
| new_tracks.push(track) | |
| return true | |
| }) | |
| if (new_tracks.length !== tracks.length) return false | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'playlist', sourceName: 'Pandora', playlistName: data.name }) | |
| resolve({ | |
| loadType: 'playlist', | |
| data: { | |
| info: { | |
| name: data.name, | |
| selectedTrack: 0, | |
| }, | |
| pluginInfo: {}, | |
| tracks: new_tracks, | |
| } | |
| }) | |
| return true | |
| }) | |
| }) | |
| break | |
| } | |
| case 'station': { | |
| const { body: stationData } = await http1makeRequest('https://www.pandora.com/api/v1/station/getStationDetails', { | |
| body: { | |
| stationId: lastPart | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| if (stationData.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'station', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| if (stationData.message) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'station', sourceName: 'Pandora', query, message: stationData.message }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: stationData.message, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| const tracks = [] | |
| let index = 0 | |
| let seeds = stationData.seeds | |
| if (seeds.length > config.options.maxAlbumPlaylistLength) | |
| seeds = seeds.slice(0, config.options.maxAlbumPlaylistLength) | |
| seeds.forEach(async (seed) => { | |
| const search = await searchWithDefault(`${seed.song.songTitle} ${seed.song.artistSummary}`) | |
| if (search.loadType === 'search') { | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: seed.song.artistSummary, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: seed.song.songTitle, | |
| uri: seed.song.songDetailUrl, | |
| artworkUrl: seed.art[seed.art.length - 1].url, | |
| isrc: null, | |
| sourceName: 'pandora' | |
| } | |
| tracks.push({ | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| }) | |
| } | |
| if (index !== seeds.length - 1) return index++ | |
| if (tracks.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'station', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| const new_tracks = [] | |
| seeds.nForEach(async (seed2) => { | |
| await tracks.nForEach((track) => { | |
| if (track.info.title !== seed2.song.songTitle || track.info.author !== seed2.song.artistSummary) return false | |
| new_tracks.push(track) | |
| return true | |
| }) | |
| if (new_tracks.length !== tracks.length) return false | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'station', sourceName: 'Pandora', playlistName: stationData.name }) | |
| resolve({ | |
| loadType: 'station', | |
| data: { | |
| info: { | |
| name: stationData.name, | |
| selectedTrack: 0, | |
| }, | |
| pluginInfo: {}, | |
| tracks: new_tracks, | |
| } | |
| }) | |
| return true | |
| }) | |
| }) | |
| break | |
| } | |
| case 'podcast': { | |
| const { body: podcastData } = await http1makeRequest('https://www.pandora.com/api/v1/aesop/getDetails', { | |
| body: { | |
| catalogVersion: 4, | |
| pandoraId: lastPart | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| if (podcastData.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| if (podcastData.message) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: podcastData.message }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: podcastData.message, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| const tracks = [] | |
| let index = 0 | |
| switch (podcastData.details.podcastProgramDetails ? podcastData.details.podcastProgramDetails.type : podcastData.details.podcastEpisodeDetails.type) { | |
| case 'PE': { | |
| const podcastEpisode = podcastData.details.annotations[Object.keys(podcastData.details.annotations).find((key) => key === podcastData.details.podcastEpisodeDetails.pandoraId)] | |
| const search = await searchWithDefault(`${podcastEpisode.name} ${podcastEpisode.programName}`) | |
| if (search.loadType !== 'search') | |
| return resolve(search) | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: podcastEpisode.programName, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: podcastEpisode.name, | |
| uri: `https://www.pandora.com${podcastEpisode.shareableUrlPath}`, | |
| artworkUrl: `https://content-images.p-cdn.com/${podcastEpisode.icon.artUrl}`, | |
| isrc: null, | |
| sourceName: 'pandora' | |
| } | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'track', sourceName: 'Pandora', track, query }) | |
| resolve({ | |
| loadType: 'track', | |
| data: { | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| } | |
| }) | |
| break | |
| } | |
| case 'PC': { | |
| const { body: allEpisodesIdsData } = await http1makeRequest('https://www.pandora.com/api/v1/aesop/getAllEpisodesByPodcastProgram', { | |
| body: { | |
| catalogVersion: 4, | |
| pandoraId: lastPart | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| if (allEpisodesIdsData.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| if (allEpisodesIdsData.message) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: allEpisodesIdsData.message }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: allEpisodesIdsData.message, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| let allEpisodesIds = [] | |
| allEpisodesIdsData.episodes.episodesWithLabel.forEach((yearInfo) => { | |
| allEpisodesIds.push(...yearInfo.episodes) | |
| }) | |
| if (allEpisodesIds.length > config.options.maxAlbumPlaylistLength) | |
| allEpisodesIds = allEpisodesIds.slice(0, config.options.maxAlbumPlaylistLength) | |
| const { body: allEpisodesData } = await http1makeRequest('https://www.pandora.com/api/v1/aesop/annotateObjects', { | |
| body: { | |
| catalogVersion: 4, | |
| pandoraIds: allEpisodesIds | |
| }, | |
| headers: { | |
| 'Cookie': csrfToken.raw, | |
| 'X-CsrfToken': csrfToken.parsed, | |
| 'X-AuthToken': authToken | |
| }, | |
| method: 'POST', | |
| disableBodyCompression: true | |
| }) | |
| if (allEpisodesData.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| if (allEpisodesData.message) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: allEpisodesData.message }) | |
| return resolve({ | |
| loadType: 'error', | |
| data: { | |
| message: allEpisodesData.message, | |
| severity: 'common', | |
| cause: 'Unknown' | |
| } | |
| }) | |
| } | |
| let episodes = Object.keys(allEpisodesData.annotations) | |
| episodes.forEach(async (episode) => { | |
| episode = allEpisodesData.annotations[episode] | |
| const search = await searchWithDefault(`${episode.name} ${episode.programName}`) | |
| if (search.loadType === 'search') { | |
| const track = { | |
| identifier: search.data[0].info.identifier, | |
| isSeekable: true, | |
| author: episode.programName, | |
| length: search.data[0].info.length, | |
| isStream: false, | |
| position: 0, | |
| title: episode.name, | |
| uri: `https://www.pandora.com${episode.shareableUrlPath}`, | |
| artworkUrl: `https://content-images.p-cdn.com/${episode.icon.artUrl}`, | |
| isrc: null, | |
| sourceName: 'pandora' | |
| } | |
| tracks.push({ | |
| encoded: encodeTrack(track), | |
| info: track, | |
| playlistInfo: {} | |
| }) | |
| } | |
| if (index !== episodes.length - 1) return index++ | |
| if (tracks.length === 0) { | |
| debugLog('loadtracks', 4, { type: 3, loadType: 'podcast', sourceName: 'Pandora', query, message: 'No matches found.' }) | |
| return resolve({ | |
| loadType: 'empty', | |
| data: {} | |
| }) | |
| } | |
| const new_tracks = [] | |
| episodes.nForEach(async (episode2) => { | |
| if (typeof episode2 !== 'object') episode2 = allEpisodesData.annotations[episode2] | |
| await tracks.nForEach((track) => { | |
| if (track.info.title !== episode2.name || track.info.author !== episode2.programName) return false | |
| new_tracks.push(track) | |
| return true | |
| }) | |
| if (new_tracks.length !== tracks.length) return false | |
| const podcastName = podcastData.details.annotations[Object.keys(podcastData.details.annotations).find((key) => key === podcastData.details.podcastProgramDetails.pandoraId)].name | |
| debugLog('loadtracks', 4, { type: 2, loadType: 'podcast', sourceName: 'Pandora', playlistName: podcastName }) | |
| resolve({ | |
| loadType: 'podcast', | |
| data: { | |
| info: { | |
| name: podcastName, | |
| selectedTrack: 0, | |
| }, | |
| pluginInfo: {}, | |
| tracks: new_tracks, | |
| } | |
| }) | |
| return true | |
| }) | |
| }) | |
| break | |
| } | |
| } | |
| } | |
| } | |
| }) | |
| } | |
| export default { | |
| init, | |
| search, | |
| loadFrom | |
| } |