Add OAuth

YTMusicAPI/YTMusic.pm

@@ -14,7 +14,8 @@ use JSON;
 use LWP::UserAgent;
 use HTTP::Cookies;
 use URI::Escape;
-use Encode qw(encode_utf8);
+use Encode     qw(encode_utf8);
+use Path::Tiny qw(path);
 use Data::Dumper;
 
 use YTMusicAPI::Constants qw(
@@ -30,45 +31,104 @@ use YTMusicAPI::Constants qw(
 use YTMusicAPI::Helpers;
 use YTMusicAPI::Parsers::Parser;
 use YTMusicAPI::Auth::AuthTypes;
+use YTMusicAPI::Auth::OAuth::OAuthCredentials;
+use YTMusicAPI::Auth::OAuth::OAuthToken;
+use YTMusicAPI::Auth::OAuth::RefreshingToken;
 
 sub new {
-    my ( $class, $args ) = @_;
-    my $self = {
-        auth              => $args->{auth}              // undef,
-        user              => $args->{user}              // undef,
-        requests_session  => $args->{requests_session}  // 1,
-        proxies           => $args->{proxies}           // undef,
-        language          => $args->{language}          // 'en',
-        location          => $args->{location}          // '',
-        oauth_credentials => $args->{oauth_credentials} // undef,
-        _base_headers     => undef,
-        _headers          => undef,
-        _input_dict       => undef,
-        _token            => undef,
-        _session          => undef,
-        _proxies          => undef,
-    };
+    my ( $class, $auth, $user, $requests_session, $proxies, $language,
+        $location, $oauth_credentials )
+      = @_;
 
+    $requests_session //= 1;
+    $language         //= 'en';
+    $location         //= '';
+
+    my $self = {};
     bless $self, $class;
 
+    $self->{_base_headers} =
+      undef;    #: for authless initializing requests during OAuth flow
+    $self->{_headers} = undef;    #: cache formed headers including auth
+
+    $self->{auth}        = $auth; #: raw auth
+    $self->{_input_dict} = undef; #: parsed auth arg value in dictionary format
+
     $self->{auth_type} = AuthType::UNAUTHORIZED;
 
-    if ( UNIVERSAL::isa( $self->{requests_session}, "LWP::UserAgent" ) ) {
-        $self->{_session} = $self->{requests_session};
+    $self->{_token}            = undef;    #: OAuth credential handler
+    $self->{oauth_credentials} = undef;    #: Client used for OAuth refreshing
+
+    $self->{_session} = undef;       #: request session for connection pooling
+    $self->{proxies}  = $proxies;    #: params for session modification
+
+    if ( UNIVERSAL::isa( $requests_session, "LWP::UserAgent" ) ) {
+        $self->{_session} = $requests_session;
     }
-    elsif ( $self->{requests_session} ) {
+    elsif ($requests_session) {      # Build a new session.
         $self->{_session} = LWP::UserAgent->new;
     }
 
+# see google cookie docs: https://policies.google.com/technologies/cookies
+# value from https://github.com/yt-dlp/yt-dlp/blob/master/yt_dlp/extractor/youtube.py#L502
     $self->{cookies} = "SOCS=CAI";
 
+    if ( $self->{auth} ) {
+        $self->{oauth_credentials} =
+            $oauth_credentials
+          ? $oauth_credentials
+          : YTMusicAPI::Auth::OAuth::OAuthCredentials->new();
+        my $auth_filepath = undef;
+        if ( !ref $self->{auth} ) {
+            my $auth_str = $self->{auth};
+            my $input_json;
+            if ( path($auth_str)->is_file() ) {
+                open( my $fh, '<', $auth_str );
+                my $json_file = do { local $/; <$fh> };
+                close($fh);
+                $auth_filepath = $auth_str;
+                $input_json    = decode_json($json_file);
+            }
+            else {
+                $input_json = decode_json($auth_str);
+            }
+            $self->{_input_dict} = $input_json;
+        }
+        else {
+            $self->{_input_dict} = $self->{auth};
+        }
+
+        if (
+            YTMusicAPI::Auth::OAuth::OAuthToken::is_oauth(
+                $self->{_input_dict}
+            )
+          )
+        {
+            $self->{_token} = YTMusicAPI::Auth::OAuth::RefreshingToken->new(
+                $self->{oauth_credentials},
+                $auth_filepath, $self->{_input_dict} );
+            $self->{auth_type} =
+              $oauth_credentials
+              ? AuthType::OAUTH_CUSTOM_CLIENT
+              : AuthType::OAUTH_DEFAULT;
+        }
+    }
+
+    # prepare context
     $self->{context} = initialize_context();
+
     $self->{context}{"context"}{"client"}{"hl"} = "en";
+    $self->{language} = $language;
 
     $self->{parser} = YTMusicAPI::Parsers::Parser->new();
 
-    if ( $self->{user} ) {
-        $self->{context}{'context'}{'user'}{'onBehalfOfUser'} = $self->{user};
+    if ($user) {
+        $self->{context}{'context'}{'user'}{'onBehalfOfUser'} = $user;
+    }
+
+    my $auth_headers = $self->{_input_dict}->{"authorization"};
+    if ($auth_headers) {
+
     }
 
     $self->{params} = YTM_PARAMS;
@@ -115,8 +175,7 @@ sub headers {
           get_authorization( $self->{sapisid} . ' ' . $self->{origin} );
     }
     elsif ( $self->{auth_type} != AuthType::OAUTH_CUSTOM_FULL ) {
-
-        # $self->{_headers}{'authorization'} = $self->{_token}->as_auth();
+        $self->{_headers}{'authorization'}       = $self->{_token}->as_auth();
         $self->{_headers}{'X-Goog-Request-Time'} = '' . time();
     }