setsuzoku 0.10.1

data/lib/setsuzoku/service/web_service/auth_strategies/o_auth_strategy.rb

@@ -0,0 +1,173 @@
+# typed: false
+# frozen_string_literal: true
+
+module Setsuzoku
+  module Service
+    module WebService
+      module AuthStrategies
+        # The API OAuth Authentication Interface definition.
+        # Any Plugin that implements this must implement all methods required for OAuth.
+        #
+        # Defines all necessary methods for handling authentication for any authentication strategy.
+        class OAuthStrategy < WebService::AuthStrategy
+          extend T::Sig
+          extend T::Helpers
+
+          def self.required_instance_methods
+            []
+          end
+
+          def self.credential_class
+            Setsuzoku::Service::WebService::Credentials::OAuthCredential
+          end
+
+          def self.token_valid_for
+            24.hours
+          end
+
+          # Any api request headers that this service needs to set.
+          #
+          # @return [Hash]
+          sig { override.returns(T::Hash[Symbol, T.untyped]) }
+          def auth_headers
+            {
+                headers: {
+                    'Authorization': "Bearer #{self.credential.token}"
+                }
+            }
+          end
+
+          # Get a new credential.
+          # Exchanges code for token, refresh_token and expires_on.
+          #
+          # @param args [Hash] the code from the initial auth response { code: 'abcdefg' }.
+          #
+          # @return void
+          sig { override.params(args: T.untyped).void }
+          def new_credential!(**args)
+            # get a token object based on the code retrieved from login
+            get_token!(params(grant_type: 'authorization_code',
+                              code: args[:code]), :new_token)
+          end
+
+          # If the auth credentials are valid for this instance and auth_strategy.
+          #
+          # If the token is invalid we should refresh it. And verify that the credentials are now valid.
+          # Otherwise the credentials are already valid.
+          #
+          # @return [Boolean] true if the auth token is valid for the auth_strategy.
+          sig { override.returns(T::Boolean) }
+          def auth_credential_valid?
+            if token_is_invalid?
+              refresh_expired_token!
+              !token_is_invalid?
+            else
+              true
+            end
+          end
+
+          private
+
+          # Determine whether the token is no longer valid.
+          #
+          # @return [Boolean] true if the token is invalid.
+          sig { returns(T::Boolean) }
+          def token_is_invalid?
+            active = self.credential.respond_to?(:"status") ? self.credential.status != 'disabled' : true
+            active && !self.credential.expires_on.blank? &&
+                !self.credential.refresh_token.blank? &&
+                (self.credential.expires_on < refresh_before_expiration_time)
+          end
+
+          sig { returns(DateTime) }
+          def refresh_before_expiration_time
+            45.minutes.from_now.to_datetime
+          end
+
+          # Exchange refresh_token for a new token and expires_on.
+          #
+          # @return [Boolean] true if the credential was refreshed successfully
+          sig { void }
+          def refresh_expired_token!
+            get_token!(params(grant_type: 'refresh_token',
+                              refresh_token: self.credential.refresh_token), :refresh_token)
+          end
+
+          # Exchange code for token, refresh_token and expires_on
+          #
+          # @return void
+          sig { params(code: String, redirect_url: String).void }
+          def custom_token!(code: nil, redirect_url: nil)
+            get_token!(params(grant_type: 'authorization_code',
+                              code: code,
+                              redirect_uri: redirect_url), :refresh_token)
+          end
+
+          # Exchange code for a new token via POST request to API token url,
+          # and set token, expiry, and status on the integration
+          #
+          # @param [Hash] body the request body for the token POST request
+          #
+          # @return void
+          sig { params(body: T::Hash[Symbol, String], action: Symbol).void }
+          def get_token!(body, action)
+            success = false
+            request = self.api_strategy.request_class.new(action: action, body: body)
+
+            resp = self.api_strategy.call_external_api(request: request, strategy: :auth)
+
+            if resp.data && resp.data[:access_token]
+              self.credential.status = 'active' if self.credential.respond_to?(:"status=")
+              self.credential.token = resp.data[:access_token]
+              self.credential.refresh_token = resp.data[:refresh_token] if resp.data.key?(:refresh_token)
+              self.credential.expires_on = if resp.data[:expires_in]
+                                             resp.data[:expires_in].to_i.seconds.from_now
+                                           # elsif resp.data[:issued_at] && self.class.token_valid_for
+                                           #   Time.at(resp.data[:issued_at].to_i / 1000) + self.class.token_valid_for
+                                           end
+
+              self.plugin.set_credential_fields!(resp) if self.plugin.respond_to?(:set_credential_fields!)
+
+              #TODO: figure out a better way to do this  when we add other integrations...
+              #
+              # if self.is_a?(FacebookIntegration)
+              #   resp = self.exchange_for_long_lived_token
+              #   if resp && resp.data['access_token']
+              #     self.token = resp.data['access_token']
+              #     self.refresh_token = resp.data['access_token']
+              #     self.expires_on = 59.days.from_now
+              #   end
+              # end
+            else
+              self.credential.status = 'error' if self.credential.respond_to?(:"status=")
+            end
+
+            if self.credential.respond_to?(:"save")
+              self.credential.save && resp.success
+            else
+              resp.success
+            end
+          end
+
+          # Add some default params to the params hash.
+          #
+          # @param params [Hash] the original params hash.
+          #
+          # @return [Hash] the merged params hash.
+          sig { params(params: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
+          def params(params)
+            if params.key?(:redirect_uri)
+              params.merge(client_id: self.credential.client_id,
+                           client_secret: self.credential.client_secret)
+            else
+              params.merge(client_id: self.credential.client_id,
+                           client_secret: self.credential.client_secret,
+                           redirect_uri: self.credential.redirect_url_override.nil? ? self.credential.redirect_url : self.credential.redirect_url_override)
+
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/setsuzoku/service/web_service/auth_strategy.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Setsuzoku
+  module Service
+    # The Token-based API Authentication Interface definition.
+    # Any Plugin that implements this must implement all methods defined here.
+    #
+    # Defines all necessary methods for handling authentication for any token-based authentication.
+    module WebService
+
+      class AuthStrategy
+        include Setsuzoku::AuthStrategy
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        # The authorization headers that need to be defined for this authentication strategy.
+        #
+        # @return [Hash(String)] the authorization key/values needed for authentication.
+        sig { abstract.returns(T::Hash[Symbol, T.untyped]) }
+        def auth_headers;end
+
+        # These are interface methods that a plugin that implements this strategy must implement.
+        module InterfaceMethods
+          extend T::Sig
+          extend T::Helpers
+          abstract!
+
+          # All auth actions that are implemented.
+          #
+          # @return [Hash] all auth endpoint definitions for the API.
+          sig { abstract.returns(T::Hash[T.untyped, T.untyped]) }
+          def auth_actions; end
+
+          # The base auth url for the plugin.
+          #
+          # @return [String] the auth url.
+          sig { overridable.returns(String) }
+          def auth_base_url
+            self.plugin.api_base_url
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/setsuzoku/service/web_service/credentials/basic_auth_credential.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Setsuzoku
+  module Service
+    module WebService
+      module Credentials
+        module BasicAuthCredential
+          include Setsuzoku::Credential
+          extend T::Sig
+          extend T::Helpers
+          abstract!
+
+          # The username to use for the credential.
+          #
+          # @return [String] the credential's token.
+          sig{ abstract.returns(T.nilable(String)) }
+          def username; end
+
+          # The username to set for the credential.
+          #
+          # @return [String] the credential's token to set.
+          #
+          sig{ abstract.params(val: String).returns(T.nilable(String)) }
+          def username=(val); end
+
+          # The password to use for the credential.
+          #
+          # @return [String] the credential's token.
+          sig{ abstract.returns(T.nilable(String)) }
+          def password; end
+
+          # The password to set for the credential.
+          #
+          # @return [String] the credential's token to set.
+          #
+          sig{ abstract.params(val: String).returns(T.nilable(String)) }
+          def password=(val); end
+
+          # Stub a basic_auth_credential-like instance.
+          #
+          # @return [Struct] a stubbed basic_auth_credential-like struct.
+          sig { returns(Struct) }
+          def self.stub_credential
+            s = Struct.new(:username, :password)
+            s.new('stubbed_username', 'stubbed_password')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/setsuzoku/service/web_service/credentials/o_auth_credential.rb

@@ -0,0 +1,83 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'active_support/core_ext/numeric/time'
+
+module Setsuzoku
+  module Service
+    module WebService
+      module Credentials
+        module OAuthCredential
+          extend T::Sig
+          extend T::Helpers
+          abstract!
+
+          # The application's client_id to o_auth with.
+          #
+          # @return [String] the client_id for o_auth.
+          sig { abstract.returns(T.nilable(String)) }
+          def client_id; end
+
+          # The application's client_secret to o_auth with.
+          #
+          # @return [String] the client_secret for o_auth.
+          sig { abstract.returns(T.nilable(String)) }
+          def client_secret; end
+
+          # The application's redirect url to handle an o_auth redirect
+          #
+          # @return [String] the redirect url.
+          sig { abstract.returns(T.nilable(String)) }
+          def redirect_url; end
+
+          # The token to use for the credential.
+          #
+          # @return [String] the credential's token.
+          sig{ abstract.returns(T.nilable(String)) }
+          def token; end
+
+          # The token to set for the credential.
+          #
+          # @return [String] the credential's token to set.
+          #
+          sig{ abstract.params(val: String).returns(T.nilable(String)) }
+          def token=(val); end
+
+          # The refresh token to use for the credential.
+          #
+          # @return [String] the credential's refresh token.
+          sig{ abstract.returns(T.nilable(String)) }
+          def refresh_token; end
+
+          # The refresh token to set for the credential.
+          #
+          # @return [String] the credential's refresh token to set.
+          #
+          sig{ abstract.params(val: String).returns(T.nilable(String)) }
+          def refresh_token=(val); end
+
+          # The time the currently valid token expires on.
+          #
+          # @return [Datetime] the time the current token expires.
+          sig{ abstract.returns(T.nilable(DateTime)) }
+          def expires_on; end
+
+          # The time to set for when the token expires on.
+          #
+          # @return [Datetime] the time to set for the current token's expiry.
+          sig{ abstract.params(val: DateTime).returns(T.nilable(DateTime)) }
+          def expires_on=(val); end
+
+          # Stub an o_auth_credential-like instance.
+          #
+          # @return [Struct] a stubbed o_auth_credential-like struct.
+          sig { returns(Struct) }
+          def self.stub_credential
+            s = Struct.new(:client_id, :client_secret, :redirect_url, :token, :refresh_token, :expires_on, :settings)
+            s.new('stubbed_client_id', 'stubbed_client_secret', 'stubbed_redirect_url', 'stubbed_token', 'refresh_token', (Time.now + 30.days), 'extension': 'test')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/setsuzoku/service/web_service/service.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Setsuzoku
+  module Service
+    module WebService
+      # WebService's Service should define all available auth and api strategies.
+      class Service
+        extend T::Sig
+        extend T::Helpers
+        include Setsuzoku::Service
+
+        # The api and auth strategies available for WebService.
+        #
+        # @return [Hash(Hash(Class))] the available_strategies object for WebService.
+        sig { override.returns(T::Hash[Symbol, T::Hash[Symbol, Class]]) }
+        def self.available_strategies
+          {
+            auth: {
+                basic: Setsuzoku::Service::WebService::AuthStrategies::BasicAuthStrategy,
+                o_auth: Setsuzoku::Service::WebService::AuthStrategies::OAuthStrategy
+            },
+            api: {
+                rest:  ApiStrategies::RestStrategy
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/setsuzoku/utilities.rb

@@ -0,0 +1,7 @@
+# typed: strict
+
+module Setsuzoku
+  module Utilities
+    require 'setsuzoku/utilities/phone_utility'
+  end
+end

data/lib/setsuzoku/version.rb

@@ -0,0 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Setsuzoku
+  VERSION = '0.10.1'
+end

data/setsuzoku.gemspec

@@ -0,0 +1,50 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "setsuzoku/version"
+
+Gem::Specification.new do |spec|
+  spec.name        = 'setsuzoku'
+  spec.version     = Setsuzoku::VERSION
+  spec.authors     = ['Luke Stadtler']
+  spec.email       = ['luke@rocketreferrals.com']
+  spec.homepage    = 'https://github.com/rocketreferrals/setsuzoku'
+  spec.summary     = 'Extensible 3rd-party interface and functionality plugins'
+  spec.description = 'Easily build generic, reusable 3rd party SDK-like plugins (intended to share).
+                   Future functionality will include dynamic UIs and other functionality around the plugin.'
+  spec.license     = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  #
+  #   spec.metadata["homepage_uri"] = spec.homepage
+  #   spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  #   spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock", "~> 3.8"
+  spec.add_runtime_dependency "activesupport", "~> 5.0"
+  spec.add_development_dependency "sorbet", "~> 0.5"
+  spec.add_runtime_dependency "sorbet-runtime", "~> 0.5"
+  #TODO: we should remove httparty if we can just use faraday
+  spec.add_runtime_dependency "httparty", "~> 0.16.4"
+  spec.add_runtime_dependency "faraday", "~> 0.11"
+  spec.add_runtime_dependency "nokogiri", "~> 1.10"
+end