pandora_client 0.1.0

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bin/
+vendor/

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2012-05-20)
+
+* First release. Basic Tuner API with station song fetching support.

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'pry'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Gopal Patel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+Pandora API Ruby Client
+=======================
+
+A Ruby wrapper for the [Pandora Tuner JSON API][tuner_api].
+
+
+## Usage
+
+```ruby
+require 'pandora'
+
+partner = Pandora::Partner.new(username, password, device, encryption_key, decryption_key)
+
+john = partner.login_user(john_email, john_password)   # Returns a Pandora::User
+john.stations
+
+jane = partner.login_user(jane_email, jane_pasword)
+jane.stations
+```
+
+`Pandora::Partner` and `Pandora::User` objects can be marshalled via Ruby's
+`Marshal`. In a web application this can be useful to avoid re-authenticating on
+every request---just marshal the appropriate object to the user session or
+temporary storage. Note that the marshalled data may contain sensitive passwords
+or tokens.
+
+
+## Contributing
+
+Patches and bug reports are welcome. Just send a [pull request][pullrequests] or
+file an [issue][issues]. [Project changelog][changelog].
+
+
+
+[tuner_api]:      http://pan-do-ra-api.wikia.com/wiki/Json/5
+[pullrequests]:   https://github.com/nixme/pandora_client/pulls
+[issues]:         https://github.com/nixme/pandora_client/issues
+[changelog]:      https://github.com/nixme/pandora_client/blob/master/CHANGELOG.md

data/Rakefile

@@ -0,0 +1,3 @@
+#!/usr/bin/env rake
+
+require 'bundler/gem_tasks'

data/lib/pandora.rb

@@ -0,0 +1,4 @@
+require 'pandora/version'
+
+require 'pandora/partner'
+require 'pandora/user'

data/lib/pandora/partner.rb

@@ -0,0 +1,60 @@
+require 'pandora/util/client'
+require 'pandora/util/cryptor'
+
+module Pandora
+  class Partner
+    include Client
+
+    attr_reader :username, :password, :device, :encryption_key, :decryption_key
+    attr_reader :partner_id, :partner_auth_token, :time_offset
+
+    def initialize(username, password, device, encryption_key, decryption_key)
+      @username, @password, @device, @encryption_key, @decryption_key =
+        username, password, device, encryption_key, decryption_key
+      authenticate
+    end
+
+    def login_user(username, password)
+      User.new(self, username, password)
+    end
+
+    def cryptor
+      @cryptor ||= Cryptor.new(@encryption_key, @decryption_key)
+    end
+
+    def marshal_dump
+      [@username, @password, @device, @encryption_key, @decryption_key,
+        @partner_id, @partner_auth_token, @time_offset]
+    end
+
+    def marshal_load(objects)
+      @username, @password, @device, @encryption_key, @decryption_key,
+        @partner_id, @partner_auth_token, @time_offset = objects
+    end
+
+
+   private
+
+    def authenticate
+      result = call 'auth.partnerLogin', { secure: true, encrypt: false }, {
+        username:    @username,
+        password:    @password,
+        deviceModel: @device,
+        version:     '5'
+      }
+
+      @partner_id = result['partnerId']
+      @partner_auth_token = result['partnerAuthToken']
+      server_time = cryptor.decrypt(result['syncTime'])[4..-1].to_i
+      @time_offset = Time.now.to_i - server_time
+    end
+
+    def user_auth_token
+      nil
+    end
+
+    def user_id
+      nil
+    end
+  end
+end

data/lib/pandora/song.rb

@@ -0,0 +1,79 @@
+require 'pandora/util/client'
+require 'forwardable'
+require 'nokogiri'
+
+module Pandora
+  class Song
+    include Client
+    extend Forwardable
+
+    ALL_AUDIO_FORMATS =
+      ['HTTP_40_AAC_MONO', 'HTTP_64_AAC', 'HTTP_64_AACPLUS',
+       'HTTP_24_AACPLUS_ADTS', 'HTTP_32_AACPLUS_ADTS', 'HTTP_64_AACPLUS_ADTS',
+       'HTTP_128_MP3', 'HTTP_192_MP3', 'HTTP_32_WMA']
+    DEFAULT_AUDIO_FORMATS =
+      ['HTTP_32_AACPLUS_ADTS', 'HTTP_64_AACPLUS_ADTS', 'HTTP_192_MP3']
+
+    attr_reader :title, :token, :artist, :album, :album_art_url, :rating, :gain,
+                :allow_feedback, :url, :album_url, :artist_url,
+                :amazon_album_asin, :amazon_album_digital_asin,
+                :amazon_song_digital_asin, :amazon_album_url, :itunes_song_url,
+                :song_explorer_url, :album_explorer_url, :artist_explorer_url,
+                :audio_url, :audio_urls
+
+    def_delegators :@station, *Client::ALL_STATE_ATTRIBUTES
+
+    def initialize(station, data, audio_formats)
+      @station = station
+      load_from_data(data, audio_formats)
+    end
+
+    def id
+      load_explorer_data unless @id
+      @id
+    end
+
+
+   private
+
+    def load_from_data(data, audio_formats)
+      @title = data['songName']
+      @token = data['trackToken']
+      @artist = data['artistName']
+      @album = data['albumName']
+      @album_art_url = data['albumArtUrl']
+      @rating = data['songRating']
+      @gain = data['trackGain']
+      @allow_feedback = data['allowFeedback']
+      @url = data['songDetailUrl']
+      @album_url = data['albumDetailUrl']
+      @artist_url = data['artistDetailUrl']
+
+      @amazon_album_asin = data['amazonAlbumAsin']
+      @amazon_album_digital_asin = data['amazonAlbumDigitalAsin']
+      @amazon_song_digital_asin = data['amazonSongDigitalAsin']
+      @amazon_album_url = data['amazonAlbumUrl']
+      @itunes_song_url = data['itunesSongUrl']
+
+      @song_explorer_url = data['songExplorerUrl']
+      @album_explorer_url = data['albumExplorerUrl']
+      @artist_explorer_url = data['artistDetailUrl']
+
+      @audio_url = data['audioUrl']
+      @audio_urls =
+        if (additional_audio_urls = data['additionalAudioUrl'])
+          Hash[audio_formats.zip(additional_audio_urls)]
+        else
+          {}
+        end
+    end
+
+    # Unfortunately the Tuner API track JSON doesn't include the musicId, a
+    # track identifier that's constant among different user sessions. However,
+    # we can fetch it via the Song's Explorer XML URL.
+    def load_explorer_data
+      document = Nokogiri::XML(Faraday.get(@song_explorer_url).body)
+      @id = document.search('songExplorer').first['musicId']
+    end
+  end
+end

data/lib/pandora/station.rb

@@ -0,0 +1,75 @@
+require 'pandora/util/client'
+require 'pandora/song'
+require 'forwardable'
+
+module Pandora
+  class Station
+    include Client
+    extend Forwardable
+
+    attr_reader :id, :name, :created_at, :url, :shared, :sharing_url,
+                :quick_mix, :quick_mix_station_ids, :allow_rename,
+                :allow_add_music, :allow_delete
+    attr_reader :user
+    attr_accessor :token
+
+    [:quick_mix, :allow_rename, :allow_add_music, :allow_delete].each do |method|
+      alias_method "#{method}?".to_sym, method
+    end
+
+    def_delegators :@user, *Client::ALL_STATE_ATTRIBUTES
+
+    def initialize(user, data = nil)
+      @user = user
+      load_from_data(data) if data
+    end
+
+    def rename(new_name)
+      # TODO: check allow_rename? force option?
+      result = call 'station.renameStation', { secure: false, encrypt: true }, {
+        stationToken: @token,
+        stationName:  new_name
+      }
+      load_from_data(result)
+    end
+
+    def delete
+      # TODO: check allow_delete? force option?
+      call 'station.deleteStation', { secure: false, encrypt: true }, {
+        stationToken: @token
+      }
+    end
+
+    def next_songs(audio_formats = Song::DEFAULT_AUDIO_FORMATS)
+      result = call 'station.getPlaylist', { secure: true, encrypt: true }, {
+        stationToken:       @token,
+        additionalAudioUrl: audio_formats.join(',')
+      }
+
+      result['items'].map do |song_data|
+        Song.new(self, song_data, audio_formats)
+      end
+    end
+
+
+   private
+
+    def load_from_data(data)
+      @id                    = data['stationId']
+      @name                  = data['stationName']
+      @token                 = data['stationToken']
+      @created_at            = Time.at(data['dateCreated']['time'] / 1000.0)
+      @url                   = data['stationDetailUrl']
+      @shared                = data['isShared']
+      @sharing_url           = data['stationSharingUrl']
+      @quick_mix             = data['isQuickMix']
+      @quick_mix_station_ids = data['quickMixStationIds']
+      @allow_rename          = data['allowRename']
+      @allow_add_music       = data['allowAddMusic']
+      @allow_delete          = data['allowDelete']
+    end
+  end
+end
+
+
+# TODO: override inspect so cryptor doesn't ruin it

data/lib/pandora/user.rb

@@ -0,0 +1,51 @@
+require 'pandora/util/client'
+require 'pandora/station'
+require 'forwardable'
+
+module Pandora
+  class User
+    include Client
+    extend Forwardable
+
+    attr_reader :partner, :username, :password
+    attr_reader :user_auth_token, :user_id
+
+    def_delegators :@partner, :cryptor, :partner_id, :partner_auth_token,
+                              :time_offset
+
+    def initialize(partner, username, password)
+      @partner, @username, @password = partner, username, password
+      login
+    end
+
+    def stations
+      call('user.getStationList')['stations'].map do |station_data|
+        Station.new(self, station_data)
+      end
+    end
+
+    def marshal_dump
+      [@partner, @username, @password, @user_auth_token, @user_id]
+    end
+
+    def marshal_load(objects)
+      @partner, @username, @password, @user_auth_token, @user_id = objects
+    end
+
+
+   private
+
+    def login
+      result = call 'auth.userLogin', { secure: true, encrypt: true }, {
+        loginType: 'user',
+        username: username,
+        password: password
+      }
+
+      @user_auth_token = result['userAuthToken']
+      @user_id = result['userId']
+
+      result
+    end
+  end
+end

data/lib/pandora/util/client.rb

@@ -0,0 +1,69 @@
+require 'pandora/util/errors'
+require 'faraday'
+require 'json' unless defined?(JSON)
+
+module Pandora
+
+  # Standardized Tuner API calls
+  #
+  # Expects the target class to respond to the following methods:
+  #   cryptor
+  #   user_auth_token
+  #   partner_auth_token
+  #   partner_id
+  #   user_id
+  #   time_offset
+  #
+  module Client
+   private
+
+    ALL_STATE_ATTRIBUTES = [:cryptor, :user_auth_token, :partner_auth_token,
+                            :partner_id, :user_id, :time_offset]
+
+    def call(method, options = { secure: false, encrypt: true }, payload = {})
+      connection = (options[:secure] ? secure_connection : insecure_connection)
+      response = connection.post do |request|
+        request.url 'services/json/'
+        request.headers['Content-Type'] = 'text/plain'
+        request.params['method'] = method
+
+        # Attach additional tokens and IDs as URL parameters if available
+        request.params['auth_token'] = user_auth_token || partner_auth_token
+        request.params['partner_id'] = partner_id if partner_id
+        request.params['user_id']    = user_id    if user_id
+
+        # Attach tokens and server time to JSON payload
+        payload.merge!(syncTime: Time.now.to_i - time_offset) if time_offset
+        if user_auth_token
+          payload.merge!(userAuthToken: user_auth_token)
+        elsif partner_auth_token
+          payload.merge!(partnerAuthToken: partner_auth_token)
+        end
+
+        # Optionally encrypt the JSON request payload
+        json = JSON.dump(payload)
+        request.body = (options[:encrypt] ? cryptor.encrypt(json) : json)
+      end
+
+      # Check for API errors
+      json = JSON.load(response.body)
+      if json['stat'] != 'ok' || !json['result']
+        raise APIError.new(json['message'], json['code'])
+      end
+
+      json['result']
+    end
+
+    def secure_connection
+      @secure_connection ||= Faraday.new(url: "https://#{host}")
+    end
+
+    def insecure_connection
+      @insecure_connection ||= Faraday.new(url: "http://#{host}")
+    end
+
+    def host
+      'tuner.pandora.com'
+    end
+  end
+end

data/lib/pandora/util/cryptor.rb

@@ -0,0 +1,50 @@
+require 'crypt/blowfish'
+
+module Pandora
+
+  # Blowfish encryptor/decryptor for the Pandora Tuner API
+  #
+  # Ciphertext is round-tripped to and from ASCII-encoded hexadecimal
+  # characters.
+  #
+  # Keys must be provided. Available at
+  # http://pan-do-ra-api.wikia.com/wiki/Json/5/partners
+  #
+  class Cryptor
+    def initialize(encryption_key, decryption_key)
+      @encryptor = Crypt::Blowfish.new(encryption_key)
+      @decryptor = Crypt::Blowfish.new(decryption_key)
+    end
+
+    def encrypt(str)
+      str.force_encoding(Encoding::BINARY).
+        scan(/.{1,8}/).map do |block|               # Operate on 8 char chunks
+        block = pad(block, 8) if block.length < 8   # Pad to 8 chars if under
+        @encryptor.encrypt_block(block).            # Encrypt the data
+          unpack('H*').first                        # Convert to ASCII hex
+      end.join('')
+    end
+
+    def decrypt(str)
+      str.force_encoding(Encoding::BINARY).
+        scan(/.{1,16}/).map do |block|              # Operate on 16 char chunks
+        block = pad([block].pack('H*'), 8)          # Convert ASCII hex to raw data
+        @decryptor.decrypt_block(block)             # Decrypt the data
+      end.join('').
+        sub(/^(.*?)[[:cntrl:]]*$/, '\1')            # Strip trailing junk
+    end
+
+    # Override inspect so it doesn't include internal Blowfish P-array and
+    # S-boxes from the instance variables.
+    def inspect
+      to_s
+    end
+
+
+   private
+
+    def pad(str, length)
+      str + ("\0" * [length - str.length, 0].max)
+    end
+  end
+end

data/lib/pandora/util/errors.rb

@@ -0,0 +1,68 @@
+module Pandora
+  # Raised on errors from the Tuner API
+  #
+  class APIError < StandardError
+    # API error code to reason mapping.
+    # From http://pan-do-ra-api.wikia.com/wiki/Json/5#Error_codes
+    ERROR_CODE_TO_REASON = {
+      0 => 'INTERNAL',
+      1 => 'MAINTENANCE_MODE',
+      2 => 'URL_PARAM_MISSING_METHOD',
+      3 => 'URL_PARAM_MISSING_AUTH_TOKEN',
+      4 => 'URL_PARAM_MISSING_PARTNER_ID',
+      5 => 'URL_PARAM_MISSING_USER_ID',
+      6 => 'SECURE_PROTOCOL_REQUIRED',
+      7 => 'CERTIFICATE_REQUIRED',
+      8 => 'PARAMETER_TYPE_MISMATCH',
+      9 => 'PARAMETER_MISSING',
+      10 => 'PARAMETER_VALUE_INVALID',
+      11 => 'API_VERSION_NOT_SUPPORTED',
+      12 => 'Pandora not available in this country',
+      13 => 'INSUFFICIENT_CONNECTIVITY. Bad sync time?',
+      14 => 'Unknown method name?',
+      15 => 'Wrong protocol (http/https)?',
+      1000 => 'READ_ONLY_MODE',
+      1001 => 'INVALID_AUTH_TOKEN',
+      1002 => 'INVALID_PARTNER_LOGIN',
+      1003 => 'LISTENER_NOT_AUTHORIZED. Account suspended, or Pandora One Subscription or Trial expired.',
+      1004 => 'USER_NOT_AUTHORIZED',
+      1005 => 'Station limit reached',
+      1006 => 'STATION_DOES_NOT_EXIST',
+      1007 => 'COMPLIMENTARY_PERIOD_ALREADY_IN_USE',
+      1008 => 'CALL_NOT_ALLOWED. Trying to add feedback to a shared station?',
+      1009 => 'DEVICE_NOT_FOUND',
+      1010 => 'PARTNER_NOT_AUTHORIZED',
+      1011 => 'INVALID_USERNAME',
+      1012 => 'INVALID_PASSWORD',
+      1013 => 'USERNAME_ALREADY_EXISTS',
+      1014 => 'DEVICE_ALREADY_ASSOCIATED_TO_ACCOUNT',
+      1015 => 'UPGRADE_DEVICE_MODEL_INVALID',
+      1018 => 'EXPLICIT_PIN_INCORRECT',
+      1020 => 'EXPLICIT_PIN_MALFORMED',
+      1023 => 'DEVICE_MODEL_INVALID',
+      1024 => 'ZIP_CODE_INVALID',
+      1025 => 'BIRTH_YEAR_INVALID',
+      1026 => 'BIRTH_YEAR_TOO_YOUNG',
+      1027 => 'INVALID_COUNTRY_CODE',
+      1027 => 'INVALID_GENDER',
+      1034 => 'DEVICE_DISABLED',
+      1035 => 'DAILY_TRIAL_LIMIT_REACHED',
+      1036 => 'INVALID_SPONSOR',
+      1037 => 'USER_ALREADY_USED_TRIAL'
+    }
+
+    attr_reader :api_message, :code
+
+    def initialize(api_message, code)
+      @api_message = api_message
+      @code = code.to_i
+    end
+
+    def message
+      msg = "#{@api_message} (Code: #{@code}"
+      reason = ERROR_CODE_TO_REASON[@code]
+      msg += " - #{reason}" if reason
+      msg + ')'
+    end
+  end
+end

data/lib/pandora/version.rb

@@ -0,0 +1,3 @@
+module Pandora
+  VERSION = '0.1.0'
+end

data/lib/pandora_client.rb

@@ -0,0 +1 @@
+require 'pandora'

data/pandora_client.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/pandora/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'pandora_client'
+  gem.version       = Pandora::VERSION
+  gem.author        = 'Gopal Patel'
+  gem.email         = 'nixme@stillhope.com'
+  gem.license       = 'MIT'
+  gem.homepage      = 'https://github.com/nixme/pandora_client'
+  gem.description   = 'A ruby wrapper for the Pandora Tuner JSON API'
+  gem.summary       = 'A ruby wrapper for the Pandora Tuner JSON API'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  # Dependencies
+  gem.required_ruby_version = '>= 1.9.2'
+  gem.add_runtime_dependency 'faraday', '~> 0.8'
+  gem.add_runtime_dependency 'crypt19', '~> 1.2.1'
+  gem.add_runtime_dependency 'nokogiri', '~> 1.5.2'
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: pandora_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Gopal Patel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: crypt19
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+description: A ruby wrapper for the Pandora Tuner JSON API
+email: nixme@stillhope.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/pandora.rb
+- lib/pandora/partner.rb
+- lib/pandora/song.rb
+- lib/pandora/station.rb
+- lib/pandora/user.rb
+- lib/pandora/util/client.rb
+- lib/pandora/util/cryptor.rb
+- lib/pandora/util/errors.rb
+- lib/pandora/version.rb
+- lib/pandora_client.rb
+- pandora_client.gemspec
+homepage: https://github.com/nixme/pandora_client
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A ruby wrapper for the Pandora Tuner JSON API
+test_files: []