psn-client 0.1.0

data/docs/andshrew/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 andshrew
+
+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/lib/psn/client/auth.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+require 'oauth2'
+require 'json'
+
+module PSN
+  module Client
+    # Handles acquiring PSN access tokens by exchanging an NPSSO cookie
+    # for an authorization code and then exchanging that code for a token.
+    class Auth
+      AUTH_URL = 'https://ca.account.sony.com/api/authz/v3/'
+      BASIC_TOKEN = ENV.fetch('PSN_BASIC_TOKEN', nil)
+
+      class << self
+        def authenticate
+          new.authenticate
+        end
+      end
+
+      def authenticate
+        PSN.logger.info('Getting new PSN access token')
+
+        code = fetch_auth_code
+        PSN.logger.debug { "Fetched authorisation code: #{code}" }
+
+        access_token = fetch_token(code)
+        PSN.logger.debug { "Fetched access token which expires in: #{access_token.expires_in / 60} minutes" }
+        PSN.logger.info('Acquired new PSN access token')
+
+        access_token.token
+      end
+
+      private
+
+      def fetch_auth_code
+        uri = URI(auth_url)
+
+        response = http_for(uri).request(request_for(uri))
+        if response['location'].nil?
+          message = extract_error_message(response)
+          PSN.logger.error(message)
+          raise message
+        end
+
+        parse_code(response['location'])
+      end
+
+      def http_for(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        http
+      end
+
+      def request_for(uri)
+        request = Net::HTTP::Get.new(uri)
+        request['Cookie'] = npsso_cookie
+        request
+      end
+
+      def fetch_token(code)
+        client.auth_code.get_token(code,
+                                   redirect_uri: 'com.scee.psxandroid.scecompcall://redirect',
+                                   token_format: 'jwt',
+                                   headers: { Authorization: "Basic #{BASIC_TOKEN}" })
+      end
+
+      def parse_code(location)
+        params = URI.decode_www_form(URI(location).query.to_s).to_h
+        code = params['code']
+
+        return code if code
+
+        raise_auth_error(params)
+      end
+
+      def raise_auth_error(params)
+        message = get_error_message(params['error'], params['error_description'])
+        PSN.logger.error(message)
+        raise message
+      end
+
+      def extract_error_message(response)
+        error_description = JSON.parse(response.body).fetch('error_description', nil)
+
+        error_description || 'Failed to fetch PSN auth code, location header missing'
+      rescue JSON::ParserError, NoMethodError, TypeError
+        'Failed to fetch PSN auth code, location header missing'
+      end
+
+      def get_error_message(error, error_description = nil)
+        return error_description if error_description
+
+        if error == 'login_required'
+          'PSN authorisation failed, NPSSO code has expired'
+        else
+          "Unhandled PSN auth error (#{error})"
+        end
+      end
+
+      def client
+        @client ||= OAuth2::Client.new(ENV.fetch('PSN_CLIENT_ID', nil), '', site: AUTH_URL)
+      end
+
+      def auth_url
+        client.auth_code.authorize_url(access_type: 'offline',
+                                       redirect_uri: 'com.scee.psxandroid.scecompcall://redirect',
+                                       scope: 'psn:mobile.v2.core psn:clientapp')
+      end
+
+      def npsso_cookie
+        "npsso=#{ENV.fetch('PSN_NPSSO', nil)}"
+      end
+    end
+  end
+end

data/lib/psn/client/request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module PSN
+  module Client
+    # Handles HTTP requests to the PSN API
+    class Request
+      BASE_URL = 'https://m.np.playstation.com/api'
+
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def get(path)
+        uri = URI("#{BASE_URL}#{path}")
+
+        response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+          request = Net::HTTP::Get.new(uri)
+          request['Authorization'] = "Bearer #{@access_token}"
+          http.request(request)
+        end
+
+        parse_response(response)
+      end
+
+      private
+
+      def parse_response(response)
+        case response
+        when Net::HTTPSuccess
+          JSON.parse(response.body)
+        else
+          raise Error, "Request failed: #{response.code} #{response.message} - #{response.body}"
+        end
+      end
+    end
+  end
+end

data/lib/psn/client/trophies.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'request'
+
+module PSN
+  module Client
+    # Handles trophy-related API requests
+    class Trophies
+      def initialize(access_token)
+        @request = Request.new(access_token)
+      end
+
+      def trophy_titles(user_id: 'me', limit: 800, offset: 0)
+        path = "/trophy/v1/users/#{user_id}/trophyTitles?limit=#{limit}&offset=#{offset}"
+        @request.get(path)
+      end
+
+      def trophy_summary(user_id: 'me')
+        path = "/trophy/v1/users/#{user_id}/trophySummary"
+        @request.get(path)
+      end
+
+      def title_trophy_groups(np_communication_id:, np_service_name: nil, platform: nil)
+        query_string = build_query_string(npServiceName: resolve_service_name(np_service_name, platform))
+
+        path = "/trophy/v1/npCommunicationIds/#{np_communication_id}/trophyGroups?#{query_string}"
+        @request.get(path)
+      end
+
+      def earned_trophy_groups(np_communication_id:, user_id: 'me', np_service_name: nil, platform: nil)
+        query_string = build_query_string(npServiceName: resolve_service_name(np_service_name, platform))
+
+        path = "/trophy/v1/users/#{user_id}/npCommunicationIds/#{np_communication_id}/trophyGroups?#{query_string}"
+        @request.get(path)
+      end
+
+      def title_trophies(np_communication_id:, trophy_group_id: 'all', np_service_name: nil, platform: nil, **options)
+        query_string = build_query_string(
+          npServiceName: resolve_service_name(np_service_name, platform),
+          limit: options[:limit],
+          offset: options[:offset]
+        )
+
+        path = "/trophy/v1/npCommunicationIds/#{np_communication_id}/trophyGroups/#{trophy_group_id}/trophies"
+        path += "?#{query_string}"
+        @request.get(path)
+      end
+
+      def earned_trophies(np_communication_id:, user_id: 'me', trophy_group_id: 'all', np_service_name: nil,
+                          platform: nil, **options)
+        query_string = build_query_string(
+          npServiceName: resolve_service_name(np_service_name, platform),
+          limit: options[:limit],
+          offset: options[:offset]
+        )
+
+        path = "/trophy/v1/users/#{user_id}/npCommunicationIds/#{np_communication_id}" \
+               "/trophyGroups/#{trophy_group_id}/trophies"
+        path += "?#{query_string}"
+        @request.get(path)
+      end
+
+      private
+
+      def resolve_service_name(service_name, platform)
+        raise ArgumentError, 'Provide either np_service_name or platform, not both' if service_name && platform
+
+        return service_name if service_name
+
+        if %w[PS3 PS4 PSVita].include?(platform)
+          'trophy'
+        elsif %w[PS5 PC].include?(platform)
+          'trophy2'
+        end
+      end
+
+      def build_query_string(**query_params)
+        query_params.compact.map { |key, value| "#{key}=#{value}" }.join('&')
+      end
+    end
+  end
+end

data/lib/psn/client/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module PSN
+  module Client
+    VERSION = '0.1.0'
+  end
+end

data/lib/psn/client.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require_relative 'client/auth'
+require_relative 'client/request'
+require_relative 'client/trophies'
+require_relative 'client/version'
+require_relative 'logger'
+require 'net/http'
+
+module PSN
+  module Client
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/lib/psn/logger.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+# Get/Set logger for the gem
+module PSN
+  # defaults to Rails.logger if in a Rails environment, otherwise logs to STDOUT
+  def self.logger
+    @logger ||= defined?(Rails) ? Rails.logger : Logger.new($stdout)
+  end
+
+  def self.logger=(logger)
+    @logger = logger
+  end
+end

data/sig/psn/client/auth.rbs

@@ -0,0 +1,25 @@
+module PSN
+  module Client
+    class Auth
+      AUTH_URL: String
+      BASIC_TOKEN: String?
+
+      def self.authenticate: () -> String
+      def authenticate: () -> String
+
+      private
+
+      def fetch_auth_code: () -> String
+      def http_for: (URI) -> Net::HTTP
+      def request_for: (URI) -> Net::HTTP::Get
+      def fetch_token: (String) -> OAuth2::AccessToken
+      def parse_code: (String) -> String
+      def raise_auth_error: (Hash[String, String]) -> void
+      def extract_error_message: (untyped) -> String
+      def get_error_message: (String?, ?String) -> String
+      def client: () -> OAuth2::Client
+      def auth_url: () -> String
+      def npsso_cookie: () -> String
+    end
+  end
+end

data/sig/psn/client/request.rbs

@@ -0,0 +1,14 @@
+module PSN
+  module Client
+    class Request
+      BASE_URL: String
+
+      def initialize: (String access_token) -> void
+      def get: (String path) -> untyped
+
+      private
+
+      def parse_response: (Net::HTTPResponse response) -> untyped
+    end
+  end
+end

data/sig/psn/client/trophies.rbs

@@ -0,0 +1,20 @@
+module PSN
+  module Client
+    class Trophies
+      @request: Request
+
+      def initialize: (String access_token) -> void
+      def trophy_titles: (?user_id: String, ?limit: Integer, ?offset: Integer) -> untyped
+      def trophy_summary: (?user_id: String) -> untyped
+      def title_trophy_groups: (np_communication_id: String, ?np_service_name: String?, ?platform: String?) -> untyped
+      def earned_trophy_groups: (?user_id: String, np_communication_id: String, ?np_service_name: String?, ?platform: String?) -> untyped
+      def title_trophies: (np_communication_id: String, ?trophy_group_id: String, ?np_service_name: String?, ?platform: String?, **untyped options) -> untyped
+      def earned_trophies: (?user_id: String, np_communication_id: String, ?trophy_group_id: String, ?np_service_name: String?, ?platform: String?, **untyped options) -> untyped
+      
+      private
+
+      def resolve_service_name: (String? service_name, String? platform) -> String?
+      def build_query_string: (**untyped query_params) -> String
+    end
+  end
+end

data/sig/psn/client.rbs

@@ -0,0 +1,6 @@
+module PSN
+  module Client
+    VERSION: String
+    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+  end
+end

data/sig/psn/logger.rbs

@@ -0,0 +1,4 @@
+module PSN
+  def self.logger: () -> (Logger | untyped)
+  def self.logger=: (Logger | untyped) -> (Logger | untyped)
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: psn-client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Matthew Jacques
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A Ruby client for the PlayStation Network API that handles authentication
+  via NPSSO cookie and provides access to user trophy data.
+email:
+- matty.jacques@proton.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- docs/andshrew/APIv2.md
+- docs/andshrew/LICENSE
+- lib/psn/client.rb
+- lib/psn/client/auth.rb
+- lib/psn/client/request.rb
+- lib/psn/client/trophies.rb
+- lib/psn/client/version.rb
+- lib/psn/logger.rb
+- sig/psn/client.rbs
+- sig/psn/client/auth.rbs
+- sig/psn/client/request.rbs
+- sig/psn/client/trophies.rbs
+- sig/psn/logger.rbs
+homepage: https://github.com/MattyJacques/psn-client
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/MattyJacques/psn-client
+  source_code_uri: https://github.com/MattyJacques/psn-client
+  changelog_uri: https://github.com/MattyJacques/psn-client/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.3
+specification_version: 4
+summary: A Ruby client for the PlayStation Network API
+test_files: []