stormpath-sdk 0.4.0 → 1.0.0.beta

data/lib/stormpath-sdk/http/http_client_request_executor.rb

@@ -22,11 +22,10 @@ module Stormpath
       include Stormpath::Http::Authc
       include Stormpath::Util::Assert
 
-      def initialize(api_key)
+      def initialize(api_key, options = {})
         @signer = Sauthc1Signer.new
         @api_key = api_key
-        @http_client = HTTPClient.new
-
+        @http_client = HTTPClient.new options[:proxy]
       end
 
       def execute_request(request)
@@ -35,18 +34,20 @@ module Stormpath
 
         @signer.sign_request request, @api_key
 
-        domain = request.href
+        domain = if request.query_string.present?
+          [request.href, request.to_s_query_string(true)].join '?'
+        else
+          request.href
+        end
 
         method = @http_client.method(request.http_method.downcase)
 
         if request.body.nil?
 
-          response = method.call domain, request.query_string, request.http_headers
+          response = method.call domain, nil, request.http_headers
 
         else
 
-          add_query_string domain, request.query_string
-
           response = method.call domain, request.body, request.http_headers
 
         end

data/lib/stormpath-sdk/http/request.rb

@@ -14,12 +14,9 @@
 # limitations under the License.
 #
 module Stormpath
-
   module Http
-
     class Request
-
-      include Stormpath::Util
+      include Stormpath::Http::Utils
 
       attr_accessor :http_method, :href, :query_string, :http_headers, :body
 
@@ -72,11 +69,10 @@ module Stormpath
         result = ''
 
         if !@query_string.empty?
+          Hash[@query_string.sort].each do |key, value|
 
-          @query_string.each do |key, value|
-
-            enc_key = RequestUtils.encode_url key, false, canonical
-            enc_value = RequestUtils.encode_url value, false, canonical
+            enc_key = encode_url key, false, canonical
+            enc_value = encode_url value, false, canonical
 
             if !result.empty?
               result << '&'

data/lib/stormpath-sdk/{util/request_utils.rb → http/utils.rb}

@@ -14,59 +14,38 @@
 # limitations under the License.
 #
 module Stormpath
+  module Http
+    module Utils
 
-  module Util
-
-    class RequestUtils
-
-      ##
-      # Returns true if the specified URI uses a standard port (i.e. http == 80 or https == 443),
-      # false otherwise.
-      #
-      # param uri
-      # return true if the specified URI is using a non-standard port, false otherwise
-      #
-      def self.default_port? uri
+      def default_port?(uri)
         scheme = uri.scheme.downcase
         port = uri.port
         port <= 0 || (port == 80 && scheme.eql?("http")) || (port == 443 && scheme.eql?("https"))
       end
 
-      def self.encode_url value, path, canonical
-
-        encoded = URI.escape value
-
-        if canonical
+      def encode_url(value, path, canonical)
+        URI.escape(value.to_s).tap do |encoded|
+          if canonical
+            str_map = {'+' => '%20', '*' => '%2A', '%7E' => '~'}
 
-          str_map = {'+' => '%20', '*' => '%2A', '%7E' => '~'}
-
-          str_map.each do |key, str_value|
-
-            if encoded.include? key
-              encoded[key] = str_value
+            str_map.each do |key, str_value|
+              if encoded.include? key
+                encoded[key] = str_value
+              end
             end
 
-          end
-
-          # encoded['%7E'] = '~'  --> yes, this is reversed (compared to the other two) intentionally
+            # encoded['%7E'] = '~'  --> yes, this is reversed (compared to the other two) intentionally
 
-          if path
-
-            str = '%2F'
-            if encoded.include? str
-              encoded[str] = '/'
+            if path
+              str = '%2F'
+              if encoded.include? str
+                encoded[str] = '/'
+              end
             end
-
           end
-
         end
-
-        encoded
-
       end
 
     end
-
   end
-
 end

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

@@ -13,117 +13,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-module Stormpath
+class  Stormpath::Resource::Account < Stormpath::Resource::Instance
+  include Stormpath::Resource::Status
 
-  module Resource
+  prop_accessor :username, :email, :given_name, :middle_name,
+    :surname
+  prop_writer :password
+  prop_non_printable :password
 
-    class Account < InstanceResource
+  belongs_to :directory
+  has_one :email_verification_token
 
-      include Status
-
-      USERNAME = "username"
-      EMAIL = "email"
-      PASSWORD = "password"
-      GIVEN_NAME = "givenName"
-      MIDDLE_NAME = "middleName"
-      SURNAME = "surname"
-      STATUS = "status"
-      GROUPS = "groups"
-      DIRECTORY = "directory"
-      EMAIL_VERIFICATION_TOKEN = "emailVerificationToken"
-      GROUP_MEMBERSHIPS = "groupMemberships"
-
-      def get_username
-        get_property USERNAME
-      end
-
-      def set_username username
-        set_property USERNAME, username
-      end
-
-      def get_email
-        get_property EMAIL
-      end
-
-      def set_email email
-        set_property EMAIL, email
-      end
-
-      def set_password password
-        set_property PASSWORD, password
-      end
-
-      def get_given_name
-        get_property GIVEN_NAME
-      end
-
-      def set_given_name given_name
-        set_property GIVEN_NAME, given_name
-      end
-
-      def get_middle_name
-        get_property MIDDLE_NAME
-      end
-
-      def set_middle_name middle_name
-        set_property MIDDLE_NAME, middle_name
-      end
-
-      def get_surname
-        get_property SURNAME
-      end
-
-      def set_surname surname
-        set_property SURNAME, surname
-      end
-
-      def get_status
-        value = get_property STATUS
-
-        if !value.nil?
-          value = value.upcase
-        end
-
-        value
-      end
-
-      def set_status status
-
-        if get_status_hash.has_key? status
-          set_property STATUS, get_status_hash[status]
-        end
-
-      end
-
-      def get_groups
-        get_resource_property GROUPS, GroupList
-      end
-
-      def get_directory
-        get_resource_property DIRECTORY, Directory
-      end
-
-      def get_email_verification_token
-        get_resource_property EMAIL_VERIFICATION_TOKEN, EmailVerificationToken
-      end
-
-      def add_group group
-
-        GroupMembership::_create self, group, data_store
-
-      end
-
-      def get_group_memberships
-        get_resource_property GROUP_MEMBERSHIPS, GroupMembershipList
-      end
-
-      protected
-      def printable_property? property_name
-        PASSWORD != property_name
-      end
-
-    end
+  has_many :groups
+  has_many :group_memberships
 
+  def add_group group
+    client.group_memberships.create group: group, account: self
   end
-
 end

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

@@ -13,187 +13,51 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-module Stormpath
+class Stormpath::Resource::Application < Stormpath::Resource::Instance
+  include Stormpath::Resource::Status
 
-  module Resource
+  class LoadError < Stormpath::Error; end
 
-    class Application < InstanceResource
+  prop_accessor :name, :description
 
-      include Status
+  belongs_to :tenant
+  has_many :accounts, can: [:create]
+  has_many :password_reset_tokens, can: [:get, :create]
 
-      NAME = "name"
-      DESCRIPTION = "description"
-      STATUS = "status"
-      TENANT = "tenant"
-      ACCOUNTS = "accounts"
-      PASSWORD_RESET_TOKENS = "passwordResetTokens"
+  def self.load composite_url
+    begin
+      uri = URI(composite_url)
+      api_key_id, api_key_secret = uri.userinfo.split(':')
 
-      def get_name
-        get_property NAME
-      end
+      client = Stormpath::Client.new api_key: {
+        id: api_key_id,
+        secret: api_key_secret
+      }
 
-      def set_name name
-        set_property NAME, name
-      end
-
-      def get_description
-        get_property DESCRIPTION
-      end
-
-      def set_description description
-        set_property DESCRIPTION, description
-      end
-
-      def get_status
-        value = get_property STATUS
-
-        if !value.nil?
-          value = value.upcase
-        end
-
-        value
-      end
-
-      def set_status status
-
-        if get_status_hash.has_key? status
-          set_property STATUS, get_status_hash[status]
-        end
-
-      end
-
-      def get_tenant
-        get_resource_property TENANT, Tenant
-      end
-
-      def get_accounts
-
-        get_resource_property ACCOUNTS, AccountList
-      end
-
-
-      #
-      # Sends a password reset email for the specified account username or email address.  The email will contain
-      # a password reset link that the user can click or copy into their browser address bar.
-      # <p/>
-      # This method merely sends the password reset email that contains the link and nothing else.  You will need to
-      # handle the link requests and then reset the account's password as described in the
-      # {@link #verify_password_reset_token} RDoc.
-      #
-      # @param account_username_or_email a username or email address of an Account that may login to the application.
-      # @return the account corresponding to the specified username or email address.
-      # @see #account_username_or_email
-      #
-      def send_password_reset_email account_username_or_email
-
-        password_reset_token = create_password_reset_token account_username_or_email;
-        password_reset_token.get_account
-
-      end
-
-      # Verifies a password reset token in a user-clicked link within an email.
-      # <p/>
-      # <h2>Base Link Configuration</h2>
-      # You need to define the <em>Base</em> link that will process HTTP requests when users click the link in the
-      # email as part of your Application's Workflow Configuration within the Stormpath UI Console.  It must be a URL
-      # served by your application's web servers.  For example:
-      # <pre>
-      # https://www.myApplication.com/passwordReset
-      # </pre>
-      # <h2>Runtime Link Processing</h2>
-      # When an application user clicks on the link in the email at runtime, your web server needs to process the request
-      # and look for an {@code spToken} request parameter.  You can then verify the {@code spToken}, and then finally
-      # change the Account's password.
-      # <p/>
-      # Usage Example:
-      # <p/>
-      # Browser:
-      # {@code GET https://www.myApplication/passwordReset?spToken=someTokenValueHere}
-      # <p/>
-      # Your code:
-      # <pre>
-      # token = #get the spToken query parameter
-      #
-      # account = application.verify_password_reset_token token
-      #
-      # //token has been verified - now set the new password with what the end-user submits:
-      # account.set_password user_submitted_new_password
-      # account.save
-      # </pre>
-      #
-      # @param token the verification token, usually obtained as a request parameter by your application.
-      # @return the Account matching the specified token.
-      def verify_password_reset_token token
-
-        href = get_password_reset_token_href
-        href += '/' + token
-
-        password_reset_props = Hash.new
-        password_reset_props.store HREF_PROP_NAME, href
-
-        password_reset_token = data_store.instantiate PasswordResetToken, password_reset_props
-
-        password_reset_token.get_account
-
-      end
-
-      #
-      # Authenticates an account's submitted principals and credentials (e.g. username and password).  The account must
-      # be in one of the Application's
-      # <a href="http://www.stormpath.com/docs/managing-applications-login-sources">assigned Login Sources</a>.  If not
-      # in an assigned login source, the authentication attempt will fail.
-      # <h2>Example</h2>
-      # Consider the following username/password-based example:
-      # <p/>
-      # <pre>
-      # request = UsernamePasswordRequest.new username, submittedRawPlaintextPassword, nil
-      # account = appToTest.authenticate_account(request).get_account
-      # </pre>
-      #
-      # @param request the authentication request representing an account's principals and credentials (e.g.
-      #                username/password) used to verify their identity.
-      # @return the result of the authentication.  The authenticated account can be obtained from
-      #         {@code result.}{@link Stormpath::Authentication::AuthenticationResult#get_account}.
-      # @throws ResourceError if the authentication attempt fails.
-      #
-      def authenticate_account request
-        response = Stormpath::Authentication::BasicAuthenticator.new data_store
-        response.authenticate get_href, request
-      end
-
-      private
-
-      def create_password_reset_token email
-
-        href = get_password_reset_token_href
-
-        password_reset_props = Hash.new
-        password_reset_props.store 'email', email
-
-        password_reset_token = data_store.instantiate PasswordResetToken, password_reset_props
-
-        data_store.create href, password_reset_token, PasswordResetToken
-
-      end
-
-      def get_password_reset_token_href
-
-        password_reset_tokens_href = get_property PASSWORD_RESET_TOKENS
-
-        if !password_reset_tokens_href.nil? and
-            password_reset_tokens_href.respond_to? 'empty?' and
-            !password_reset_tokens_href.empty?
+      application_path = uri.path.slice(/\/applications(.)*$/)
+      client.applications.get(application_path)
+    rescue
+      raise LoadError
+    end
+  end
 
-          return password_reset_tokens_href[HREF_PROP_NAME]
-        end
+  def send_password_reset_email email
+    password_reset_token = create_password_reset_token email;
+    password_reset_token.account
+  end
 
-        nil
+  def verify_password_reset_token token
+    password_reset_tokens.get(token).account
+  end
 
-      end
+  def authenticate_account request
+    response = Stormpath::Authentication::BasicAuthenticator.new data_store
+    response.authenticate href, request
+  end
 
-    end
+  private
 
+  def create_password_reset_token email
+    password_reset_tokens.create email: email
   end
-
 end
-