stormpath-sdk 1.6.0 → 1.7.0

data/lib/stormpath-sdk/resource/account_overrides.rb

@@ -1,22 +1,26 @@
-module Stormpath::Resource::AccountOverrides
-  extend ActiveSupport::Concern
+module Stormpath
+  module Resource
+    module AccountOverrides
+      extend ActiveSupport::Concern
 
-  included do
-    def create_account account, registration_workflow_enabled=nil
-      href = accounts.href
-      if registration_workflow_enabled == false
-        href += "?registrationWorkflowEnabled=#{registration_workflow_enabled.to_s}"
-      end
+      included do
+        def create_account(account, registration_workflow_enabled = nil)
+          href = accounts.href
+          if registration_workflow_enabled == false
+            href += "?registrationWorkflowEnabled=#{registration_workflow_enabled}"
+          end
 
-      resource = case account
-      when Stormpath::Resource::Base
-        account
-      else
-        Stormpath::Resource::Account.new account, client
-      end
+          resource = case account
+                     when Stormpath::Resource::Base
+                       account
+                     else
+                       Stormpath::Resource::Account.new(account, client)
+                     end
 
-      resource.apply_custom_data_updates_if_necessary
-      data_store.create href, resource, Stormpath::Resource::Account
+          resource.apply_custom_data_updates_if_necessary
+          data_store.create(href, resource, Stormpath::Resource::Account)
+        end
+      end
     end
   end
 end

data/lib/stormpath-sdk/resource/account_store.rb

@@ -13,17 +13,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class Stormpath::Resource::AccountStore < Stormpath::Resource::Instance
-  def self.new(*args)
-    href = args.first[HREF_PROP_NAME]
-    if href =~ /directories/
-      Stormpath::Resource::Directory.new(*args)
-    elsif href =~ /group/
-      Stormpath::Resource::Group.new(*args)
-    elsif href =~ /organizations/
-      Stormpath::Resource::Organization.new(*args)
-    else
-      raise 'inappropriate type of an account store'
+module Stormpath
+  module Resource
+    class AccountStore < Stormpath::Resource::Instance
+      def self.new(*args)
+        href = args.first[HREF_PROP_NAME]
+        if href =~ /directories/
+          Stormpath::Resource::Directory.new(*args)
+        elsif href =~ /group/
+          Stormpath::Resource::Group.new(*args)
+        elsif href =~ /organizations/
+          Stormpath::Resource::Organization.new(*args)
+        else
+          raise 'inappropriate type of an account store'
+        end
+      end
     end
   end
 end

data/lib/stormpath-sdk/resource/account_store_mapping.rb

@@ -13,23 +13,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class Stormpath::Resource::AccountStoreMapping < Stormpath::Resource::Instance
+module Stormpath
+  module Resource
+    class AccountStoreMapping < Stormpath::Resource::Instance
+      prop_accessor :list_index, :is_default_account_store, :is_default_group_store
 
-  prop_accessor :list_index, :is_default_account_store, :is_default_group_store
+      belongs_to :application
 
-  belongs_to :application
+      has_one :account_store
 
-  has_one :account_store
+      alias default_account_store is_default_account_store
+      alias default_account_store? is_default_account_store
 
-  alias_method :default_account_store, :is_default_account_store
-  alias_method :default_account_store?, :is_default_account_store
+      alias default_account_store= is_default_account_store=
 
-  alias_method :default_account_store=, :is_default_account_store=
-
-  alias_method :default_group_store, :is_default_group_store
-  alias_method :default_group_store?, :is_default_group_store
-
-  alias_method :default_group_store=, :is_default_group_store=
+      alias default_group_store is_default_group_store
+      alias default_group_store? is_default_group_store
 
+      alias default_group_store= is_default_group_store=
+    end
+  end
 end
-

data/lib/stormpath-sdk/resource/application.rb

@@ -13,143 +13,154 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-class Stormpath::Resource::Application < Stormpath::Resource::Instance
-  include Stormpath::Resource::CustomDataStorage
-  include Stormpath::Resource::AccountOverrides
-  include UUIDTools
-
-  class LoadError < ArgumentError; end
-
-  prop_accessor :name, :description, :authorized_callback_uris, :status, :authorized_origin_uris
-  prop_reader :created_at, :modified_at
-
-  belongs_to :tenant
-
-  has_many :accounts, can: [:get, :create]
-  has_many :password_reset_tokens, can: [:get, :create]
-  has_many :account_store_mappings, can: [:get, :create]
-  has_many :groups, can: [:get, :create]
-  has_many :verification_emails, can: :create
-  has_many :api_keys
-
-  has_one :default_account_store_mapping, class_name: :accountStoreMapping
-  has_one :default_group_store_mapping, class_name: :accountStoreMapping
-  has_one :custom_data
-  has_one :o_auth_policy, class_name: :oauthPolicy
-  has_one :web_config, class_name: :applicationWebConfig
-  has_one :account_linking_policy
-
-  alias_method :oauth_policy, :o_auth_policy
-
-  def self.load(composite_url)
-    begin
-      builder = Stormpath::Util::UriBuilder.new(composite_url)
-      api_key_id, api_key_secret = builder.userinfo.split(':')
-
-      client = Stormpath::Client.new api_key: {
-        id: api_key_id,
-        secret: api_key_secret
-      }
-
-      application_path = builder.uri.path.slice(/\/applications(.)*$/)
-      client.applications.get(application_path)
-    rescue
-      raise LoadError
-    end
-  end
-
-  def create_id_site_url(options = {})
-    base = client.data_store.base_url.sub("v#{Stormpath::DataStore::DEFAULT_API_VERSION}", 'sso')
-    base += '/logout' if options[:logout]
-
-    raise Stormpath::Oauth::Error.new(:jwt_cb_uri_incorrect) if options[:callback_uri].empty?
-
-    token = JWT.encode(jwt_token_payload(options), client.data_store.api_key.secret, 'HS256')
-    base + '?jwtRequest=' + token
-  end
-
-  def handle_id_site_callback(response_url)
-    assert_not_nil response_url, 'No response provided. Please provide response object.'
-
-    uri = URI(response_url)
-    params = CGI::parse(uri.query)
-    token = params["jwtResponse"].first
-
-    begin
-      jwt_response, _header = JWT.decode(token, client.data_store.api_key.secret)
-    rescue JWT::ExpiredSignature => error
-      # JWT raises error if the signature expired, we need to capture this and
-      # rerase IdSite::Error
-      raise Stormpath::Oauth::Error.new(:jwt_expired)
-    end
-
-    id_site_result = Stormpath::IdSite::IdSiteResult.new(jwt_response)
-
-    if id_site_result.jwt_invalid?(api_key_id)
-      raise Stormpath::Oauth::Error.new(:jwt_invalid)
-    end
-
-    id_site_result
-  end
-
-  def send_password_reset_email(email, account_store: nil)
-    password_reset_token = create_password_reset_token(email, account_store: account_store)
-    password_reset_token.account
-  end
-
-  def verify_password_reset_token(token)
-    password_reset_tokens.get(token).account
-  end
-
-  def authenticate_account(request)
-    Stormpath::Authentication::BasicAuthenticator.new(data_store).authenticate(href, request)
-  end
-
-  def get_provider_account(request)
-    Stormpath::Provider::AccountResolver.new(data_store, href, request).resolve_provider_account
-  end
-
-  def authenticate_oauth(request)
-    Stormpath::Oauth::Authenticator.new(data_store).authenticate(href, request)
-  end
-
-  private
-
-  def jwt_token_payload(options)
-    {}.tap do |payload|
-      payload['iat'] = Time.now.to_i
-      payload['jti'] = UUID.method(:random_create).call.to_s
-      payload['iss'] = client.data_store.api_key.id
-      payload['sub'] = href
-      payload['cb_uri'] = options[:callback_uri]
-      payload['path'] = options[:path] || ''
-      payload['state'] = options[:state] || ''
-      payload['sof'] = options[:show_organization_field]
-      payload['onk'] = options[:organization_name_key]
-      payload['usd'] = options[:use_subdomain]
-    end.compact
-  end
-
-  def api_key_id
-    client.data_store.api_key.id
-  end
-
-  def create_password_reset_token(email, account_store: nil)
-    params = { email: email }
-    params[:account_store] = account_store_to_hash(account_store) if account_store
-    password_reset_tokens.create(params)
-  end
+module Stormpath
+  module Resource
+    class Application < Stormpath::Resource::Instance
+      include Stormpath::Resource::CustomDataStorage
+      include Stormpath::Resource::AccountOverrides
+
+      include UUIDTools
+
+      class LoadError < ArgumentError; end
 
-  def account_store_to_hash(account_store)
-    case account_store
-    when Stormpath::Resource::Organization
-      { name_key: account_store.name_key }
-    when Stormpath::Resource::Group, Stormpath::Resource::Directory
-      { href: account_store.href }
-    when Hash
-      account_store
-    else
-      raise ArgumentError, 'Account store has to be passed either as an resource or a hash'
+      prop_accessor :name, :description, :authorized_callback_uris, :status, :authorized_origin_uris
+      prop_reader :created_at, :modified_at
+
+      belongs_to :tenant
+
+      has_many :accounts, can: [:get, :create]
+      has_many :password_reset_tokens, can: [:get, :create]
+      has_many :account_store_mappings, can: [:get, :create]
+      has_many :groups, can: [:get, :create]
+      has_many :verification_emails, can: :create
+      has_many :api_keys
+
+      has_one :default_account_store_mapping, class_name: :accountStoreMapping
+      has_one :default_group_store_mapping, class_name: :accountStoreMapping
+      has_one :custom_data
+      has_one :o_auth_policy, class_name: :oauthPolicy
+      has_one :web_config, class_name: :applicationWebConfig
+      has_one :account_linking_policy
+      has_one :saml_policy
+
+      alias oauth_policy o_auth_policy
+
+      def self.load(composite_url)
+        builder = Stormpath::Util::UriBuilder.new(composite_url)
+        api_key_id, api_key_secret = builder.userinfo.split(':')
+
+        client = Stormpath::Client.new(
+          api_key: {
+            id: api_key_id,
+            secret: api_key_secret
+          }
+        )
+
+        application_path = builder.uri.path.slice(/\/applications(.)*$/)
+        client.applications.get(application_path)
+      rescue
+        raise LoadError
+      end
+
+      def create_id_site_url(options = {})
+        raise Stormpath::Oauth::Error, :jwt_cb_uri_incorrect if options[:callback_uri].blank?
+
+        base = client.data_store.base_url.sub("v#{Stormpath::DataStore::DEFAULT_API_VERSION}", 'sso')
+        base += '/logout' if options[:logout]
+
+        token = JWT.encode(jwt_token_payload(options), client.data_store.api_key.secret, 'HS256')
+        "#{base}?jwtRequest=#{token}"
+      end
+
+      def handle_id_site_callback(response_url)
+        assert_not_nil(response_url, 'No response provided. Please provide response object.')
+
+        uri = URI(response_url)
+        params = CGI.parse(uri.query)
+        token = params['jwtResponse'].first
+
+        begin
+          jwt_response, _header = JWT.decode(token, client.data_store.api_key.secret)
+        rescue JWT::ExpiredSignature => error
+          # JWT raises error if the signature expired, we need to capture this and
+          # reraise IdSite::Error
+          raise Stormpath::Oauth::Error, :jwt_expired
+        end
+
+        id_site_result = Stormpath::IdSite::IdSiteResult.new(jwt_response)
+
+        raise Stormpath::Oauth::Error, :jwt_invalid if id_site_result.jwt_invalid?(api_key_id)
+
+        id_site_result
+      end
+
+      def send_password_reset_email(email, account_store: nil)
+        password_reset_token = create_password_reset_token(email, account_store: account_store)
+        password_reset_token.account
+      end
+
+      def verify_password_reset_token(token)
+        password_reset_tokens.get(token).account
+      end
+
+      def authenticate_account(request)
+        Stormpath::Authentication::BasicAuthenticator.new(data_store).authenticate(href, request)
+      end
+
+      def get_provider_account(request)
+        Stormpath::Provider::AccountResolver.new(data_store, href, request).resolve_provider_account
+      end
+
+      def authenticate_oauth(request)
+        Stormpath::Oauth::Authenticator.new(data_store).authenticate(href, request)
+      end
+
+      def register_service_provider(options = {})
+        Stormpath::Authentication::RegisterServiceProvider.new(
+          saml_policy.identity_provider, options
+        ).call
+      end
+
+      private
+
+      def jwt_token_payload(options)
+        {}.tap do |payload|
+          payload[:jti] = UUID.method(:random_create).call.to_s
+          payload[:iat] = Time.now.to_i
+          payload[:iss] = client.data_store.api_key.id
+          payload[:sub] = href
+          payload[:state] = options[:state] || ''
+          payload[:path] = options[:path] || ''
+          payload[:cb_uri] = options[:callback_uri]
+          payload[:sof] = options[:show_organization_field]
+          payload[:onk] = options[:organization_name_key]
+          payload[:usd] = options[:use_subdomain]
+          payload[:require_mfa] = options[:require_mfa]
+        end.compact
+      end
+
+      def api_key_id
+        client.data_store.api_key.id
+      end
+
+      def create_password_reset_token(email, account_store: nil)
+        params = { email: email }
+        params[:account_store] = account_store_to_hash(account_store) if account_store
+        password_reset_tokens.create(params)
+      end
+
+      def account_store_to_hash(account_store)
+        case account_store
+        when Stormpath::Resource::Organization
+          { name_key: account_store.name_key }
+        when Stormpath::Resource::Group, Stormpath::Resource::Directory
+          { href: account_store.href }
+        when Hash
+          account_store
+        else
+          raise ArgumentError, 'Account store has to be passed either as an resource or a hash'
+        end
+      end
     end
   end
 end

data/lib/stormpath-sdk/resource/application_web_config.rb

@@ -1,9 +1,13 @@
-class Stormpath::Resource::ApplicationWebConfig < Stormpath::Resource::Instance
-  ENDPOINTS = [:oauth2, :register, :login, :verify_email, :forgot_password, :change_password, :me].freeze
-  prop_accessor :dns_label, :status, *ENDPOINTS
-  prop_reader :domain_name, :created_at, :modified_at
+module Stormpath
+  module Resource
+    class ApplicationWebConfig < Stormpath::Resource::Instance
+      ENDPOINTS = [:oauth2, :register, :login, :verify_email, :forgot_password, :change_password, :me].freeze
+      prop_accessor :dns_label, :status, *ENDPOINTS
+      prop_reader :domain_name, :created_at, :modified_at
 
-  has_one :signing_api_key, class_name: :api_key
-  belongs_to :application
-  belongs_to :tenant
+      has_one :signing_api_key, class_name: :api_key
+      belongs_to :application
+      belongs_to :tenant
+    end
+  end
 end

data/lib/stormpath-sdk/resource/associations.rb

@@ -19,8 +19,7 @@ module Stormpath
       extend ActiveSupport::Concern
 
       module ClassMethods
-
-        def resource_prop_reader(name, options={})
+        def resource_prop_reader(name, options = {})
           options[:class_name] ||= name
           resource_class = "Stormpath::Resource::#{options[:class_name].to_s.camelize}".constantize
           property_name = name.to_s.camelize :lower
@@ -29,10 +28,10 @@ module Stormpath
           end
         end
 
-        alias_method :has_one, :resource_prop_reader
-        alias_method :belongs_to, :resource_prop_reader
+        alias has_one resource_prop_reader
+        alias belongs_to resource_prop_reader
 
-        def has_many(name, options={}, &block)
+        def has_many(name, options = {}, &block)
           options[:class_name] ||= name.to_s.singularize
           item_class = "Stormpath::Resource::#{options[:class_name].to_s.camelize}".constantize
           property_name = name.to_s.camelize :lower
@@ -42,53 +41,52 @@ module Stormpath
             href = options[:href] || get_resource_href_property(property_name)
             collection_href = "#{tenant.send(name).href}" if options[:delegate]
 
-            Stormpath::Resource::Collection.new(href, item_class, client,
-              collection_href: collection_href).tap do |collection|
+            Stormpath::Resource::Collection.new(
+              href, item_class, client, collection_href: collection_href
+            ).tap do |collection|
 
               collection.class_eval do
-                if can.include? :create
+                if can.include?(:create)
                   def create(properties_or_resource, options = {})
                     resource = case properties_or_resource
-                      when Stormpath::Resource::Base
-                        properties_or_resource
-                      else
-                        item_class.new properties_or_resource, client
-                      end
-                    data_store.create href, resource, item_class, options
+                               when Stormpath::Resource::Base
+                                 properties_or_resource
+                               else
+                                 item_class.new(properties_or_resource, client)
+                               end
+                    data_store.create(href, resource, item_class, options)
                   end
-                end#can.include? :create
+                end # can.include? :create
 
                 if can.include? :get
-                  def get(id_or_href, expansion=nil)
+                  def get(id_or_href, expansion = nil)
                     item_href = if id_or_href.index '/'
-                      id_or_href
-                    else
-                      "#{href}/#{id_or_href}"
-                    end
-                    data_store.get_resource item_href, item_class, (expansion ? expansion.to_query : nil)
+                                  id_or_href
+                                else
+                                  "#{href}/#{id_or_href}"
+                                end
+                    data_store.get_resource(
+                      item_href, item_class, (expansion ? expansion.to_query : nil)
+                    )
                   end
-                end#can.include? :get
-              end#collection.class_eval do
+                end # can.include? :get
+              end # collection.class_eval do
 
               collection.class_eval(&block) if block
-            end#Stormpath::Resource::Collection.new
-          end#define_method(name)
-        end#def has_many
-
-      end#module Class Methods
+            end # Stormpath::Resource::Collection.new
+          end # define_method(name)
+        end # def has_many
+      end # module Class Methods
 
       included do
-
         private
 
           def get_resource_property(key, clazz)
             value = get_property key
 
-            return nil if value.nil? and clazz != Stormpath::Resource::CustomData
+            return nil if value.nil? && (clazz != Stormpath::Resource::CustomData)
 
-            if value.is_a? Hash
-              resource_href = get_href_from_hash value
-            end
+            resource_href = get_href_from_hash value if value.is_a? Hash
 
             key_name = "@_#{key.underscore}"
 
@@ -105,14 +103,9 @@ module Stormpath
           def get_resource_href_property(key)
             value = get_property key
 
-            if value.is_a? Hash
-              get_href_from_hash value
-            else
-              nil
-            end
+            get_href_from_hash value if value.is_a? Hash
           end
-
-      end#included do
-    end#Associations
-  end#Resource
-end#Stormpath
+      end # included do
+    end # Associations
+  end # Resource
+end # Stormpath