File Coverage

blib/lib/WebService/Pandora.pm
Criterion Covered Total %
statement 38 311 12.2
branch 5 108 4.6
condition 1 27 3.7
subroutine 10 33 30.3
pod 26 26 100.0
total 80 505 15.8


line stmt bran cond sub pod time code
1             package WebService::Pandora;
2              
3 2     2   72758 use strict;
  2         4  
  2         81  
4 2     2   12 use warnings;
  2         5  
  2         63  
5              
6 2     2   1260 use WebService::Pandora::Method;
  2         6  
  2         6051  
7 2     2   16 use WebService::Pandora::Cryptor;
  2         3  
  2         47  
8 2     2   1757 use WebService::Pandora::Partner::iOS;
  2         4  
  2         57  
9              
10 2     2   13 use JSON;
  2         3  
  2         18  
11 2     2   322 use Data::Dumper;
  2         4  
  2         11158  
12              
13             our $VERSION = '0.2';
14              
15             ### constructor ###
16              
17             sub new {
18              
19 1     1 1 13 my $caller = shift;
20              
21 1         2 my $class = ref( $caller );
22 1 50       5 $class = $caller if ( !$class );
23              
24 1         7 my $self = {'username' => undef,
25             'password' => undef,
26             'timeout' => 10,
27             'partner' => undef,
28             @_};
29              
30             # be nice and default to iOS partner if one wasn't given..
31 1 50       5 if ( !defined( $self->{'partner'} ) ) {
32              
33 1         11 $self->{'partner'} = WebService::Pandora::Partner::iOS->new();
34             }
35              
36             # create and store cryptor object, using the partner's encryption keys
37 1         17 my $cryptor = WebService::Pandora::Cryptor->new( decryption_key => $self->{'partner'}{'decryption_key'},
38             encryption_key => $self->{'partner'}{'encryption_key'} );
39              
40 1         3 $self->{'cryptor'} = $cryptor;
41              
42 1         3 bless( $self, $class );
43              
44 1         3 return $self;
45             }
46              
47             ### getters/setters ###
48              
49             sub error {
50              
51 2     2 1 773 my ( $self, $error ) = @_;
52              
53 2 100       8 $self->{'error'} = $error if ( defined( $error ) );
54              
55 2         8 return $self->{'error'};
56             }
57              
58             ### public methods ###
59              
60             sub login {
61              
62 1     1 1 6 my ( $self ) = @_;
63              
64             # make sure both username and password were given
65 1 50 33     9 if ( !defined( $self->{'username'} ) || !defined( $self->{'password'} ) ) {
66              
67 1         5 $self->error( 'Both username and password must be given in the constructor.' );
68 1         3 return;
69             }
70              
71             # first, do the partner login
72 0           my $ret = $self->{'partner'}->login();
73              
74             # detect error
75 0 0         if ( !$ret ) {
76              
77             # return the error message from the partner
78 0           $self->error( $self->{'partner'}->error() );
79 0           return;
80             }
81              
82             # store the important attributes we got back as we'll need them later
83 0           $self->{'partnerAuthToken'} = $ret->{'partnerAuthToken'};
84 0           $self->{'partnerId'} = $ret->{'partnerId'};
85 0           $self->{'syncTime'} = $ret->{'syncTime'};
86              
87             # throw an error if for some reason we didn't get them
88 0 0 0       if ( !defined( $self->{'partnerAuthToken'} ) ||
      0        
89             !defined( $self->{'partnerId'} ) ||
90             !defined( $self->{'syncTime'} ) ) {
91              
92 0           $self->error( 'Either partnerAuthToken, partnerId, or syncTime was not returned!' );
93 0           return;
94             }
95              
96             # handle special case of decrypting the sync time
97 0           $self->{'syncTime'} = $self->{'cryptor'}->decrypt( $self->{'syncTime'} );
98              
99             # detect error decrypting
100 0 0         if ( !defined( $self->{'syncTime'} ) ) {
101              
102 0           $self->error( "An error occurred decrypting the syncTime: " . $self->{'cryptor'}->error() );
103 0           return;
104             }
105              
106 0           $self->{'syncTime'} = substr( $self->{'syncTime'}, 4 );
107              
108             # now create and execute the method for the user login request
109 0           my $method = WebService::Pandora::Method->new( name => 'auth.userLogin',
110             partnerAuthToken => $self->{'partnerAuthToken'},
111             partnerId => $self->{'partnerId'},
112             syncTime => $self->{'syncTime'},
113             host => $self->{'partner'}{'host'},
114             ssl => 1,
115             encrypt => 1,
116             cryptor => $self->{'cryptor'},
117             timeout => $self->{'timeout'},
118             params => {'loginType' => 'user',
119             'username' => $self->{'username'},
120             'password' => $self->{'password'},
121             'partnerAuthToken' => $self->{'partnerAuthToken'}} );
122              
123 0           $ret = $method->execute();
124              
125             # detect error
126 0 0         if ( !$ret ) {
127              
128 0           $self->error( $method->error() );
129 0           return;
130             }
131              
132             # store even more attributes we'll need later
133 0           $self->{'userId'} = $ret->{'userId'};
134 0           $self->{'userAuthToken'} = $ret->{'userAuthToken'};
135              
136             # make sure we actually got them
137 0 0 0       if ( !defined( $self->{'userId'} ) || !defined( $self->{'userAuthToken'} ) ) {
138              
139 0           $self->error( 'Either userId or userAuthToken was not returned!' );
140 0           return;
141             }
142              
143             # success
144 0           return 1;
145             }
146              
147             sub getBookmarks {
148              
149 0     0 1   my ( $self ) = @_;
150              
151             # create the user.getBookmarks method w/ appropriate params
152 0           my $method = WebService::Pandora::Method->new( name => 'user.getBookmarks',
153             partnerAuthToken => $self->{'partnerAuthToken'},
154             userAuthToken => $self->{'userAuthToken'},
155             partnerId => $self->{'partnerId'},
156             userId => $self->{'userId'},
157             syncTime => $self->{'syncTime'},
158             host => $self->{'partner'}{'host'},
159             ssl => 0,
160             encrypt => 1,
161             cryptor => $self->{'cryptor'},
162             timeout => $self->{'timeout'},
163             params => {} );
164              
165 0           my $ret = $method->execute();
166              
167 0 0         if ( !$ret ) {
168              
169 0           $self->error( $method->error() );
170 0           return;
171             }
172              
173 0           return $ret;
174             }
175              
176             sub getStationList {
177              
178 0     0 1   my ( $self ) = @_;
179              
180             # create the user.getStationList method w/ appropriate params
181 0           my $method = WebService::Pandora::Method->new( name => 'user.getStationList',
182             partnerAuthToken => $self->{'partnerAuthToken'},
183             userAuthToken => $self->{'userAuthToken'},
184             partnerId => $self->{'partnerId'},
185             userId => $self->{'userId'},
186             syncTime => $self->{'syncTime'},
187             host => $self->{'partner'}{'host'},
188             ssl => 0,
189             encrypt => 1,
190             cryptor => $self->{'cryptor'},
191             timeout => $self->{'timeout'},
192             params => {} );
193              
194 0           my $ret = $method->execute();
195              
196 0 0         if ( !$ret ) {
197              
198 0           $self->error( $method->error() );
199 0           return;
200             }
201              
202 0           return $ret;
203             }
204              
205             sub getStationListChecksum {
206              
207 0     0 1   my ( $self ) = @_;
208              
209             # create the user.getStationListChecksum method w/ appropriate params
210 0           my $method = WebService::Pandora::Method->new( name => 'user.getStationListChecksum',
211             partnerAuthToken => $self->{'partnerAuthToken'},
212             userAuthToken => $self->{'userAuthToken'},
213             partnerId => $self->{'partnerId'},
214             userId => $self->{'userId'},
215             syncTime => $self->{'syncTime'},
216             host => $self->{'partner'}{'host'},
217             ssl => 0,
218             encrypt => 1,
219             cryptor => $self->{'cryptor'},
220             timeout => $self->{'timeout'},
221             params => {} );
222              
223 0           my $ret = $method->execute();
224              
225 0 0         if ( !$ret ) {
226              
227 0           $self->error( $method->error() );
228 0           return;
229             }
230              
231 0           return $ret;
232             }
233              
234             sub getStation {
235              
236 0     0 1   my ( $self, %args ) = @_;
237              
238 0           my $stationToken = $args{'stationToken'};
239 0           my $includeExtendedAttributes = $args{'includeExtendedAttributes'};
240              
241 0 0         $includeExtendedAttributes = ( $includeExtendedAttributes ) ? JSON::true() : JSON::false();
242              
243             # make sure they provided a stationToken argument
244 0 0         if ( !defined( $stationToken ) ) {
245              
246 0           $self->error( 'A stationToken must be specified.' );
247 0           return;
248             }
249              
250             # create the user.getStation method w/ appropriate params
251 0           my $method = WebService::Pandora::Method->new( name => 'station.getStation',
252             partnerAuthToken => $self->{'partnerAuthToken'},
253             userAuthToken => $self->{'userAuthToken'},
254             partnerId => $self->{'partnerId'},
255             userId => $self->{'userId'},
256             syncTime => $self->{'syncTime'},
257             host => $self->{'partner'}{'host'},
258             ssl => 0,
259             encrypt => 1,
260             cryptor => $self->{'cryptor'},
261             timeout => $self->{'timeout'},
262             params => {'stationToken' => $stationToken,
263             'includeExtendedAttributes' => $includeExtendedAttributes} );
264              
265 0           my $ret = $method->execute();
266              
267 0 0         if ( !$ret ) {
268              
269 0           $self->error( $method->error() );
270 0           return;
271             }
272              
273 0           return $ret;
274             }
275              
276             sub search {
277              
278 0     0 1   my ( $self, %args ) = @_;
279              
280 0           my $searchText = $args{'searchText'};
281              
282             # make sure they provided a searchText argument
283 0 0         if ( !defined( $searchText ) ) {
284              
285 0           $self->error( 'A searchText must be specified.' );
286 0           return;
287             }
288              
289             # create the music.search method w/ appropriate params
290 0           my $method = WebService::Pandora::Method->new( name => 'music.search',
291             partnerAuthToken => $self->{'partnerAuthToken'},
292             userAuthToken => $self->{'userAuthToken'},
293             partnerId => $self->{'partnerId'},
294             userId => $self->{'userId'},
295             syncTime => $self->{'syncTime'},
296             host => $self->{'partner'}{'host'},
297             ssl => 0,
298             encrypt => 1,
299             cryptor => $self->{'cryptor'},
300             timeout => $self->{'timeout'},
301             params => {'searchText' => $searchText} );
302              
303 0           my $ret = $method->execute();
304              
305 0 0         if ( !$ret ) {
306              
307 0           $self->error( $method->error() );
308 0           return;
309             }
310              
311 0           return $ret;
312             }
313              
314             sub getPlaylist {
315              
316 0     0 1   my ( $self, %args ) = @_;
317              
318 0           my $stationToken = $args{'stationToken'};
319              
320             # make sure they provided a stationToken argument
321 0 0         if ( !defined( $stationToken ) ) {
322              
323 0           $self->error( 'A stationToken must be specified.' );
324 0           return;
325             }
326              
327             # create the station.getPlaylist method w/ appropriate params
328 0           my $method = WebService::Pandora::Method->new( name => 'station.getPlaylist',
329             partnerAuthToken => $self->{'partnerAuthToken'},
330             userAuthToken => $self->{'userAuthToken'},
331             partnerId => $self->{'partnerId'},
332             userId => $self->{'userId'},
333             syncTime => $self->{'syncTime'},
334             host => $self->{'partner'}{'host'},
335             ssl => 0,
336             encrypt => 1,
337             cryptor => $self->{'cryptor'},
338             timeout => $self->{'timeout'},
339             params => {'stationToken' => $stationToken} );
340              
341 0           my $ret = $method->execute();
342              
343 0 0         if ( !$ret ) {
344              
345 0           $self->error( $method->error() );
346 0           return;
347             }
348              
349 0           return $ret;
350             }
351              
352             sub explainTrack {
353              
354 0     0 1   my ( $self, %args ) = @_;
355              
356 0           my $trackToken = $args{'trackToken'};
357              
358             # make sure they provided a trackToken argument
359 0 0         if ( !defined( $trackToken ) ) {
360              
361 0           $self->error( 'A trackToken must be specified.' );
362 0           return;
363             }
364              
365             # create the track.explainTrack method w/ appropriate params
366 0           my $method = WebService::Pandora::Method->new( name => 'track.explainTrack',
367             partnerAuthToken => $self->{'partnerAuthToken'},
368             userAuthToken => $self->{'userAuthToken'},
369             partnerId => $self->{'partnerId'},
370             userId => $self->{'userId'},
371             syncTime => $self->{'syncTime'},
372             host => $self->{'partner'}{'host'},
373             ssl => 0,
374             encrypt => 1,
375             cryptor => $self->{'cryptor'},
376             timeout => $self->{'timeout'},
377             params => {'trackToken' => $trackToken} );
378              
379 0           my $ret = $method->execute();
380              
381 0 0         if ( !$ret ) {
382              
383 0           $self->error( $method->error() );
384 0           return;
385             }
386              
387 0           return $ret;
388             }
389              
390             sub addArtistBookmark {
391              
392 0     0 1   my ( $self, %args ) = @_;
393              
394 0           my $trackToken = $args{'trackToken'};
395              
396             # make sure they provided a trackToken argument
397 0 0         if ( !defined( $trackToken ) ) {
398              
399 0           $self->error( 'A trackToken must be specified.' );
400 0           return;
401             }
402              
403             # create the bookmark.addArtistBookmark method w/ appropriate params
404 0           my $method = WebService::Pandora::Method->new( name => 'bookmark.addArtistBookmark',
405             partnerAuthToken => $self->{'partnerAuthToken'},
406             userAuthToken => $self->{'userAuthToken'},
407             partnerId => $self->{'partnerId'},
408             userId => $self->{'userId'},
409             syncTime => $self->{'syncTime'},
410             host => $self->{'partner'}{'host'},
411             ssl => 0,
412             encrypt => 1,
413             cryptor => $self->{'cryptor'},
414             timeout => $self->{'timeout'},
415             params => {'trackToken' => $trackToken} );
416              
417 0           my $ret = $method->execute();
418              
419 0 0         if ( !$ret ) {
420              
421 0           $self->error( $method->error() );
422 0           return;
423             }
424              
425 0           return $ret;
426             }
427              
428             sub addSongBookmark {
429              
430 0     0 1   my ( $self, %args ) = @_;
431              
432 0           my $trackToken = $args{'trackToken'};
433              
434             # make sure they provided a trackToken argument
435 0 0         if ( !defined( $trackToken ) ) {
436              
437 0           $self->error( 'A trackToken must be specified.' );
438 0           return;
439             }
440              
441             # create the bookmark.addSongBookmark method w/ appropriate params
442 0           my $method = WebService::Pandora::Method->new( name => 'bookmark.addSongBookmark',
443             partnerAuthToken => $self->{'partnerAuthToken'},
444             userAuthToken => $self->{'userAuthToken'},
445             partnerId => $self->{'partnerId'},
446             userId => $self->{'userId'},
447             syncTime => $self->{'syncTime'},
448             host => $self->{'partner'}{'host'},
449             ssl => 0,
450             encrypt => 1,
451             cryptor => $self->{'cryptor'},
452             timeout => $self->{'timeout'},
453             params => {'trackToken' => $trackToken} );
454              
455 0           my $ret = $method->execute();
456              
457 0 0         if ( !$ret ) {
458              
459 0           $self->error( $method->error() );
460 0           return;
461             }
462              
463 0           return $ret;
464             }
465              
466             sub addFeedback {
467              
468 0     0 1   my ( $self, %args ) = @_;
469              
470 0           my $trackToken = $args{'trackToken'};
471 0           my $isPositive = $args{'isPositive'};
472              
473             # make sure both the trackToken and isPositive arguments are provided
474 0 0 0       if ( !defined( $trackToken ) || !defined( $isPositive ) ) {
475              
476 0           $self->error( 'Both trackToken and isPositive must be specified.' );
477 0           return;
478             }
479              
480 0 0         $isPositive = ( $isPositive ) ? JSON::true() : JSON::false();
481              
482             # create the station.addFeedback method w/ appropriate params
483 0           my $method = WebService::Pandora::Method->new( name => 'station.addFeedback',
484             partnerAuthToken => $self->{'partnerAuthToken'},
485             userAuthToken => $self->{'userAuthToken'},
486             partnerId => $self->{'partnerId'},
487             userId => $self->{'userId'},
488             syncTime => $self->{'syncTime'},
489             host => $self->{'partner'}{'host'},
490             ssl => 0,
491             encrypt => 1,
492             cryptor => $self->{'cryptor'},
493             timeout => $self->{'timeout'},
494             params => {'trackToken' => $trackToken,
495             'isPositive' => $isPositive} );
496              
497 0           my $ret = $method->execute();
498              
499 0 0         if ( !$ret ) {
500              
501 0           $self->error( $method->error() );
502 0           return;
503             }
504              
505 0           return $ret;
506             }
507              
508             sub deleteFeedback {
509              
510 0     0 1   my ( $self, %args ) = @_;
511              
512 0           my $feedbackId = $args{'feedbackId'};
513              
514             # make sure they provided a feedbackId argument
515 0 0         if ( !defined( $feedbackId ) ) {
516              
517 0           $self->error( 'A feedbackId must be specified.' );
518 0           return;
519             }
520              
521             # create the station.deleteFeedback method w/ appropriate params
522 0           my $method = WebService::Pandora::Method->new( name => 'station.deleteFeedback',
523             partnerAuthToken => $self->{'partnerAuthToken'},
524             userAuthToken => $self->{'userAuthToken'},
525             partnerId => $self->{'partnerId'},
526             userId => $self->{'userId'},
527             syncTime => $self->{'syncTime'},
528             host => $self->{'partner'}{'host'},
529             ssl => 0,
530             encrypt => 1,
531             cryptor => $self->{'cryptor'},
532             timeout => $self->{'timeout'},
533             params => {'feedbackId' => $feedbackId} );
534              
535 0           my $ret = $method->execute();
536              
537 0 0         if ( !$ret ) {
538              
539 0           $self->error( $method->error() );
540 0           return;
541             }
542              
543 0           return $ret;
544             }
545              
546             sub addMusic {
547              
548 0     0 1   my ( $self, %args ) = @_;
549              
550 0           my $musicToken = $args{'musicToken'};
551 0           my $stationToken = $args{'stationToken'};
552              
553             # make sure both the musicToken and stationToken arguments are provided
554 0 0 0       if ( !defined( $musicToken ) || !defined( $stationToken ) ) {
555              
556 0           $self->error( 'Both musicToken and stationToken must be specified.' );
557 0           return;
558             }
559              
560             # create the station.addMusic method w/ appropriate params
561 0           my $method = WebService::Pandora::Method->new( name => 'station.addMusic',
562             partnerAuthToken => $self->{'partnerAuthToken'},
563             userAuthToken => $self->{'userAuthToken'},
564             partnerId => $self->{'partnerId'},
565             userId => $self->{'userId'},
566             syncTime => $self->{'syncTime'},
567             host => $self->{'partner'}{'host'},
568             ssl => 0,
569             encrypt => 1,
570             cryptor => $self->{'cryptor'},
571             timeout => $self->{'timeout'},
572             params => {'musicToken' => $musicToken,
573             'stationToken' => $stationToken} );
574              
575 0           my $ret = $method->execute();
576              
577 0 0         if ( !$ret ) {
578              
579 0           $self->error( $method->error() );
580 0           return;
581             }
582              
583 0           return $ret;
584             }
585              
586             sub deleteMusic {
587              
588 0     0 1   my ( $self, %args ) = @_;
589              
590 0           my $seedId = $args{'seedId'};
591              
592             # make sure they provided a seedId argument
593 0 0         if ( !defined( $seedId ) ) {
594              
595 0           $self->error( 'A seedId must be specified.' );
596 0           return;
597             }
598              
599             # create the station.deleteMusic method w/ appropriate params
600 0           my $method = WebService::Pandora::Method->new( name => 'station.deleteMusic',
601             partnerAuthToken => $self->{'partnerAuthToken'},
602             userAuthToken => $self->{'userAuthToken'},
603             partnerId => $self->{'partnerId'},
604             userId => $self->{'userId'},
605             syncTime => $self->{'syncTime'},
606             host => $self->{'partner'}{'host'},
607             ssl => 0,
608             encrypt => 1,
609             cryptor => $self->{'cryptor'},
610             timeout => $self->{'timeout'},
611             params => {'seedId' => $seedId} );
612              
613 0           my $ret = $method->execute();
614              
615 0 0         if ( !$ret ) {
616              
617 0           $self->error( $method->error() );
618 0           return;
619             }
620              
621 0           return $ret;
622             }
623              
624             sub createStation {
625              
626 0     0 1   my ( $self, %args ) = @_;
627              
628 0           my $musicToken = $args{'musicToken'};
629 0           my $trackToken = $args{'trackToken'};
630 0           my $musicType = $args{'musicType'};
631              
632 0           my $params = {};
633              
634             # did they specify a music token, obtained via search?
635 0 0         if ( defined( $musicToken ) ) {
    0          
636              
637 0           $params->{'musicToken'} = $musicToken;
638             }
639              
640             # did they specify a track token, provided from a playlist?
641             elsif ( defined( $trackToken ) ) {
642              
643             # make sure they also specific either song or artist type
644 0 0         if ( !defined( $musicType ) ) {
645              
646 0           $self->error( "A musicType must be specified (either 'song' or 'artist') when supplying a track token." );
647 0           return;
648             }
649              
650 0           $params->{'trackToken'} = $trackToken;
651 0           $params->{'musicType'} = $musicType;
652             }
653              
654             # they didn't specify either
655             else {
656              
657 0           $self->error( "Either musicToken or trackToken must be specified." );
658 0           return;
659             }
660              
661             # create the station.createStation method w/ appropriate params
662 0           my $method = WebService::Pandora::Method->new( name => 'station.createStation',
663             partnerAuthToken => $self->{'partnerAuthToken'},
664             userAuthToken => $self->{'userAuthToken'},
665             partnerId => $self->{'partnerId'},
666             userId => $self->{'userId'},
667             syncTime => $self->{'syncTime'},
668             host => $self->{'partner'}{'host'},
669             ssl => 0,
670             encrypt => 1,
671             cryptor => $self->{'cryptor'},
672             timeout => $self->{'timeout'},
673             params => $params );
674              
675 0           my $ret = $method->execute();
676              
677 0 0         if ( !$ret ) {
678              
679 0           $self->error( $method->error() );
680 0           return;
681             }
682              
683 0           return $ret;
684             }
685              
686             sub renameStation {
687              
688 0     0 1   my ( $self, %args ) = @_;
689              
690 0           my $stationToken = $args{'stationToken'};
691 0           my $stationName = $args{'stationName'};
692              
693             # make sure both the stationToken and stationName arguments are provided
694 0 0 0       if ( !defined( $stationToken ) || !defined( $stationName ) ) {
695              
696 0           $self->error( 'Both stationToken and stationName must be specified.' );
697 0           return;
698             }
699              
700             # create the station.renameStation method w/ appropriate params
701 0           my $method = WebService::Pandora::Method->new( name => 'station.renameStation',
702             partnerAuthToken => $self->{'partnerAuthToken'},
703             userAuthToken => $self->{'userAuthToken'},
704             partnerId => $self->{'partnerId'},
705             userId => $self->{'userId'},
706             syncTime => $self->{'syncTime'},
707             host => $self->{'partner'}{'host'},
708             ssl => 0,
709             encrypt => 1,
710             cryptor => $self->{'cryptor'},
711             timeout => $self->{'timeout'},
712             params => {'stationToken' => $stationToken,
713             'stationName' => $stationName} );
714              
715 0           my $ret = $method->execute();
716              
717 0 0         if ( !$ret ) {
718              
719 0           $self->error( $method->error() );
720 0           return;
721             }
722              
723 0           return $ret;
724             }
725              
726             sub shareStation {
727              
728 0     0 1   my ( $self, %args ) = @_;
729              
730 0           my $stationId = $args{'stationId'};
731 0           my $stationToken = $args{'stationToken'};
732 0           my $emails = $args{'emails'};
733              
734             # make sure both the stationId, stationToken, and emails arguments are provided
735 0 0 0       if ( !defined( $stationId ) || !defined( $stationToken ) || !defined( $emails ) ) {
      0        
736              
737 0           $self->error( 'The stationId, stationToken, and emails must be specified.' );
738 0           return;
739             }
740              
741             # create the station.shareStation method w/ appropriate params
742 0           my $method = WebService::Pandora::Method->new( name => 'station.shareStation',
743             partnerAuthToken => $self->{'partnerAuthToken'},
744             userAuthToken => $self->{'userAuthToken'},
745             partnerId => $self->{'partnerId'},
746             userId => $self->{'userId'},
747             syncTime => $self->{'syncTime'},
748             host => $self->{'partner'}{'host'},
749             ssl => 0,
750             encrypt => 1,
751             cryptor => $self->{'cryptor'},
752             timeout => $self->{'timeout'},
753             params => {'stationId' => $stationId,
754             'stationToken' => $stationToken,
755             'emails' => $emails} );
756              
757 0           my $ret = $method->execute();
758              
759 0 0         if ( !$ret ) {
760              
761 0           $self->error( $method->error() );
762 0           return;
763             }
764              
765 0           return $ret;
766             }
767              
768             sub transformSharedStation {
769              
770 0     0 1   my ( $self, %args ) = @_;
771              
772 0           my $stationToken = $args{'stationToken'};
773              
774             # make sure they provided a stationToken argument
775 0 0         if ( !defined( $stationToken ) ) {
776              
777 0           $self->error( 'A stationToken must be specified.' );
778 0           return;
779             }
780              
781             # create the station.transformSharedStation method w/ appropriate params
782 0           my $method = WebService::Pandora::Method->new( name => 'station.transformSharedStation',
783             partnerAuthToken => $self->{'partnerAuthToken'},
784             userAuthToken => $self->{'userAuthToken'},
785             partnerId => $self->{'partnerId'},
786             userId => $self->{'userId'},
787             syncTime => $self->{'syncTime'},
788             host => $self->{'partner'}{'host'},
789             ssl => 0,
790             encrypt => 1,
791             cryptor => $self->{'cryptor'},
792             timeout => $self->{'timeout'},
793             params => {'stationToken' => $stationToken} );
794              
795 0           my $ret = $method->execute();
796              
797 0 0         if ( !$ret ) {
798              
799 0           $self->error( $method->error() );
800 0           return;
801             }
802              
803 0           return $ret;
804             }
805              
806             sub deleteStation {
807              
808 0     0 1   my ( $self, %args ) = @_;
809              
810 0           my $stationToken = $args{'stationToken'};
811              
812             # make sure they provided a stationToken argument
813 0 0         if ( !defined( $stationToken ) ) {
814              
815 0           $self->error( 'A stationToken must be specified.' );
816 0           return;
817             }
818              
819             # create the station.deleteStation method w/ appropriate params
820 0           my $method = WebService::Pandora::Method->new( name => 'station.deleteStation',
821             partnerAuthToken => $self->{'partnerAuthToken'},
822             userAuthToken => $self->{'userAuthToken'},
823             partnerId => $self->{'partnerId'},
824             userId => $self->{'userId'},
825             syncTime => $self->{'syncTime'},
826             host => $self->{'partner'}{'host'},
827             ssl => 0,
828             encrypt => 1,
829             cryptor => $self->{'cryptor'},
830             timeout => $self->{'timeout'},
831             params => {'stationToken' => $stationToken} );
832              
833 0           my $ret = $method->execute();
834              
835 0 0         if ( !$ret ) {
836              
837 0           $self->error( $method->error() );
838 0           return;
839             }
840              
841 0           return $ret;
842             }
843              
844             sub sleepSong {
845              
846 0     0 1   my ( $self, %args ) = @_;
847              
848 0           my $trackToken = $args{'trackToken'};
849              
850             # make sure they provided a trackToken argument
851 0 0         if ( !defined( $trackToken ) ) {
852              
853 0           $self->error( 'A trackToken must be specified.' );
854 0           return;
855             }
856              
857             # create the user.sleepSong method w/ appropriate params
858 0           my $method = WebService::Pandora::Method->new( name => 'user.sleepSong',
859             partnerAuthToken => $self->{'partnerAuthToken'},
860             userAuthToken => $self->{'userAuthToken'},
861             partnerId => $self->{'partnerId'},
862             userId => $self->{'userId'},
863             syncTime => $self->{'syncTime'},
864             host => $self->{'partner'}{'host'},
865             ssl => 0,
866             encrypt => 1,
867             cryptor => $self->{'cryptor'},
868             timeout => $self->{'timeout'},
869             params => {'trackToken' => $trackToken} );
870              
871 0           my $ret = $method->execute();
872              
873 0 0         if ( !$ret ) {
874              
875 0           $self->error( $method->error() );
876 0           return;
877             }
878              
879 0           return $ret;
880             }
881              
882             sub getGenreStations {
883              
884 0     0 1   my ( $self ) = @_;
885              
886             # create the station.getGenreStations method w/ appropriate params
887 0           my $method = WebService::Pandora::Method->new( name => 'station.getGenreStations',
888             partnerAuthToken => $self->{'partnerAuthToken'},
889             userAuthToken => $self->{'userAuthToken'},
890             partnerId => $self->{'partnerId'},
891             userId => $self->{'userId'},
892             syncTime => $self->{'syncTime'},
893             host => $self->{'partner'}{'host'},
894             ssl => 0,
895             encrypt => 1,
896             cryptor => $self->{'cryptor'},
897             timeout => $self->{'timeout'},
898             params => {} );
899              
900 0           my $ret = $method->execute();
901              
902 0 0         if ( !$ret ) {
903              
904 0           $self->error( $method->error() );
905 0           return;
906             }
907              
908 0           return $ret;
909             }
910              
911             sub getGenreStationsChecksum {
912              
913 0     0 1   my ( $self ) = @_;
914              
915             # create the station.getGenreStationsChecksum method w/ appropriate params
916 0           my $method = WebService::Pandora::Method->new( name => 'station.getGenreStationsChecksum',
917             partnerAuthToken => $self->{'partnerAuthToken'},
918             userAuthToken => $self->{'userAuthToken'},
919             partnerId => $self->{'partnerId'},
920             userId => $self->{'userId'},
921             syncTime => $self->{'syncTime'},
922             host => $self->{'partner'}{'host'},
923             ssl => 0,
924             encrypt => 1,
925             cryptor => $self->{'cryptor'},
926             timeout => $self->{'timeout'},
927             params => {} );
928              
929 0           my $ret = $method->execute();
930              
931 0 0         if ( !$ret ) {
932              
933 0           $self->error( $method->error() );
934 0           return;
935             }
936              
937 0           return $ret;
938             }
939              
940             sub setQuickMix {
941              
942 0     0 1   my ( $self, %args ) = @_;
943              
944 0           my $stationIds = $args{'stationIds'};
945              
946             # also allow quickMixStationIds alias since thats what its called in the JSON API
947 0 0         $stationIds = $args{'quickMixStationIds'} if ( !defined( $stationIds ) );
948              
949             # make sure they provided a stationIds argument
950 0 0         if ( !defined( $stationIds ) ) {
951              
952 0           $self->error( 'stationIds must be specified.' );
953 0           return;
954             }
955              
956             # create the user.setQuickMix method w/ appropriate params
957 0           my $method = WebService::Pandora::Method->new( name => 'user.setQuickMix',
958             partnerAuthToken => $self->{'partnerAuthToken'},
959             userAuthToken => $self->{'userAuthToken'},
960             partnerId => $self->{'partnerId'},
961             userId => $self->{'userId'},
962             syncTime => $self->{'syncTime'},
963             host => $self->{'partner'}{'host'},
964             ssl => 0,
965             encrypt => 1,
966             cryptor => $self->{'cryptor'},
967             timeout => $self->{'timeout'},
968             params => {'quickMixStationIds' => $stationIds} );
969              
970 0           my $ret = $method->execute();
971              
972 0 0         if ( !$ret ) {
973              
974 0           $self->error( $method->error() );
975 0           return;
976             }
977              
978 0           return $ret;
979             }
980              
981             sub canSubscribe {
982              
983 0     0 1   my ( $self ) = @_;
984              
985             # create the user.canSubscribe method w/ appropriate params
986 0           my $method = WebService::Pandora::Method->new( name => 'user.canSubscribe',
987             partnerAuthToken => $self->{'partnerAuthToken'},
988             userAuthToken => $self->{'userAuthToken'},
989             partnerId => $self->{'partnerId'},
990             userId => $self->{'userId'},
991             syncTime => $self->{'syncTime'},
992             host => $self->{'partner'}{'host'},
993             ssl => 1,
994             encrypt => 1,
995             cryptor => $self->{'cryptor'},
996             timeout => $self->{'timeout'},
997             params => {} );
998              
999 0           my $ret = $method->execute();
1000              
1001 0 0         if ( !$ret ) {
1002              
1003 0           $self->error( $method->error() );
1004 0           return;
1005             }
1006              
1007 0           return $ret;
1008             }
1009              
1010             1;