mxit-rails 0.2.5 → 0.2.6

data/app/helpers/mxit_rails_helper.rb

@@ -8,7 +8,7 @@ module MxitRailsHelper
     str = ''
     if @_mxit.has_table
       # Close the previous row if there is one
-      str += "</td></tr>"
+      str += "<br /></td></tr>"
     else
       # Start a new table
       str += '<table title="mxit:table:full" style="width:100%" name="main_table" cellspacing="0" cellpadding="0">'
@@ -17,7 +17,7 @@ module MxitRailsHelper
     @_mxit.has_table = true
 
     # Start the new row
-    style = mxit_style *styles
+    style = styles.empty? ? mxit_style(:body) : mxit_style(*styles)
     str += "<tr><td style=\"#{ style }\">"
     str.html_safe
   end
@@ -43,11 +43,11 @@ module MxitRailsHelper
   end
 
   def mxit_nav_link target, label
-    "<p style=\"#{ mxit_style :right }\">#{ mxit_link target, label }</p>".html_safe
+    "#{ mxit_link target, label }<br /><br />".html_safe
   end
 
   def mxit_proceed content
-    "<p><b style=\"#{ mxit_style :link }\">&gt; #{content}</b></p>".html_safe
+    "<br /><b style=\"#{ mxit_style :link }\"> &raquo; #{content}</b><br />".html_safe
   end
 
 end

data/app/views/layouts/mxit.html.erb

@@ -27,10 +27,16 @@
 
   <% if @_mxit.has_table %>
     <!-- Close the table if there is one -->
-      </td></tr>
+      <br /></td></tr>
     </table>
   <% end %>
 
+  <% if mxit_validation_message %>
+    <b><%= mxit_validation_message %></b><br />
+  <% elsif flash[:notice] %>
+    <b><%= flash[:notice] %></b><br />
+  <% end %>
+
   <% if @_mxit.input %>
     <%= mxit_proceed @_mxit.input_label %>
     <form method="POST" action="<%= request.path %>">

data/lib/mxit-rails.rb

@@ -10,3 +10,11 @@ require "mxit_rails/page"
 
 module MxitRails
 end
+
+require "mxit_rails/mxit_api/api_client"
+require "mxit_rails/mxit_api/auth_token"
+require "mxit_rails/mxit_api/mxit_api_exception"
+require "mxit_rails/mxit_api/request_exception"
+
+module MxitRails::MXitApi
+end

data/lib/mxit_rails/descriptor.rb

@@ -18,7 +18,7 @@ module MxitRails
     attr_accessor :action
     attr_accessor :type
 
-    descr_accessor :proceed
+    attr_accessor :proceed
 
     attr_accessor :input
     attr_accessor :input_label
@@ -29,6 +29,9 @@ module MxitRails
 
     attr_accessor :has_table
 
+    attr_accessor :validations_failed
+    attr_accessor :validated
+
     def initialize name, action, parent=nil
       @parent_descriptor = parent
       @name = name.to_sym

data/lib/mxit_rails/mxit_api/api_client.rb

@@ -0,0 +1,260 @@
+require 'net/http'
+require 'uri'
+
+module MxitRails::MxitApi
+  class Client
+    MXIT_AUTH_BASE_URI = 'https://auth.mxit.com'
+    MXIT_AUTH_TOKEN_URI = MXIT_AUTH_BASE_URI + '/token'
+    MXIT_AUTH_CODE_URI = MXIT_AUTH_BASE_URI + '/authorize'
+
+    MXIT_API_URI = 'http://api.mxit.com'
+
+    attr_accessor :app_name, :client_id, :client_secret
+    attr_accessor :auth_token
+
+    def initialize(app_name, client_id, client_secret)
+      @app_name = app_name
+      @client_id = client_id
+      @client_secret = client_secret
+    end
+
+    def request_app_auth(scopes)
+      if scopes.empty?
+        raise MxitRails::MxitApi::Exception.new("No scopes were provided.")
+      end
+
+      response = http_client(MXIT_AUTH_TOKEN_URI) do |http, path|
+
+        request = new_post_request(path, {
+          "grant_type" => "client_credentials",
+          "scope" => scopes.join(" ")
+        })
+
+        http.request(request)
+      end
+
+      case response
+      when Net::HTTPSuccess then
+        @auth_token = AuthToken.new(JSON.parse(response.body))
+
+      else
+        raise MxitRails::MxitApi::RequestException.new(response.message, response.code)
+      end
+    end
+
+    # The user's response to the authorisation code request will be redirected to `redirect_uri`. If
+    # the request was successful there will be a `code` request parameter; otherwise `error`.
+    #
+    # redirect_uri - absolute URI to which the user will be redirected after authorisation
+    # state - passed back to `redirect_uri` as a request parameter
+    # scopes - list of scopes to which access is required
+    def user_code_request_uri(redirect_uri, state, scopes)
+      if scopes.empty?
+        raise MxitRails::MxitApi::Exception.new("No scopes were provided.")
+      end
+
+      # build parameters
+      parameters = {
+        :response_type => "code",
+        :client_id => @client_id,
+        :redirect_uri => redirect_uri,
+        :state => state,
+        :scope => scopes.join(' ')
+      }
+
+      path = MXIT_AUTH_CODE_URI + "?#{URI.encode_www_form(parameters)}"
+    end
+
+    # NOTE: `user_code_request_uri` must be used before `request_user_auth` because it provides the
+    # `code` argument. `redirect_uri` must match the one used in the `user_code_request_uri` call
+    def request_user_auth(code, redirect_uri)
+      response = http_client(MXIT_AUTH_TOKEN_URI) do |http, path|
+
+        request = new_post_request(path, {
+          "grant_type" => "authorization_code",
+          "code" => code,
+          "redirect_uri" => redirect_uri
+        })
+
+        http.request(request)
+      end
+
+      case response
+      when Net::HTTPSuccess then
+        @auth_token = AuthToken.new(JSON.parse(response.body))
+
+      else
+        raise MxitRails::MxitApi::RequestException.new(response.message, response.code)
+      end
+    end
+
+    def revoke_token(auth_token)
+      response = http_client(MXIT_AUTH_BASE_URI + "/revoke") do |http, path|
+
+        request = new_post_request(path, {
+          "token" => auth_token.access_token
+        })
+
+        http.request(request)
+      end
+
+      if response.code != '200'
+        raise MxitRails::MxitApi::RequestException.new(response.message, response.code)
+      end
+    end
+
+    def refresh_token(auth_token)
+      if auth_token.refresh_token.nil?
+        raise MxitRails::MxitApi::Exception.new("The provided auth token doesn't have a refresh " +
+          "token.")
+      end
+
+      response = http_client(MXIT_AUTH_TOKEN_URI) do |http, path|
+
+        request = new_post_request(path, {
+          "grant_type" => "refresh_token",
+          "refresh_token" => auth_token.refresh_token
+        })
+
+        http.request(request)
+      end
+
+      case response
+      when Net::HTTPSuccess then
+        auth_token = AuthToken.new(JSON.parse(response.body))
+
+      else
+        raise MxitRails::MxitApi::RequestException.new(response.message, response.code)
+      end
+    end
+
+    ### API methods requiring authorisation.
+
+    # When sending as the app the `message/send` scope is required otherwise `message/user`
+    def send_message(from, to, body, contains_markup, auth_token=nil)
+      auth_token = auth_token || @auth_token
+
+      if from == @app_name
+        check_auth_token(auth_token, ["message/send"])
+      else
+        check_auth_token(auth_token, ["message/user"])
+      end
+
+      response = http_client(MXIT_API_URI + "/message/send/") do |http, path|
+
+        request = Net::HTTP::Post.new(path)
+        set_api_headers(request, auth_token.access_token)
+
+        request.body = {
+          "Body" => body,
+          "ContainsMarkup" => contains_markup,
+          "From" => from,
+          "To" => to
+          # "Spool" => default(true)
+          # "SpoolTimeOut" => default(60*60*24*7)
+        }.to_json
+
+        http.request(request)
+      end
+
+      if response.code != '200'
+        raise MxitRails::MxitApi::RequestException.new(response.message, response.code)
+      end
+    end
+
+    # The following filter parameters are available (only one can be specified at a time):
+    #   @All - Return all roster entries
+    #   @Friends - Return only friends
+    #   @Apps - Return only applications
+    #   @Invites  - Return all entries that is in an invite state
+    #   @Connections  - Return all entries that has been accepted
+    #   @Rejected - Return all entries that has been rejected
+    #   @Pending - Return all entries that is waiting to be accepted by the other party
+    #   @Deleted - Return all entries that was deleted
+    #   @Blocked - Return all entries that was blocked
+    def get_contact_list(filter, options={ :skip => nil, :count => nil, :auth_token => nil })
+      auth_token = options[:auth_token] || @auth_token
+      check_auth_token(auth_token, ["graph/read"])
+
+      response = http_client(MXIT_API_URI + "/user/socialgraph/contactlist") do |http, path|
+
+        parameters = { :filter => filter }
+        # skip and count are optional
+        parameters[:skip] = skip if options[:skip]
+        parameters[:count] = count if options[:count]
+
+        request = Net::HTTP::Get.new(path + "?#{URI.encode_www_form(parameters)}")
+        set_api_headers(request, auth_token.access_token)
+
+        http.request(request)
+      end
+
+      case response
+      when Net::HTTPSuccess then
+        data = JSON.parse(response.body)
+
+      else
+        raise MxitRails::MxitApi::RequestException.new(response.message, response.code)
+      end
+    end
+
+    def batch_notify_users(mxit_ids, message, contains_markup)
+      Rails.logger.info('Requesting MXit API auth...')
+      request_app_auth(["message/send"])
+      Rails.logger.info('Finished MXit API auth.')
+
+      batch_size = 50
+      Rails.logger.info('Starting to notify users in batches of ' + batch_size.to_s + '...')
+      i = 0
+      while i < mxit_ids.count
+        current_batch = mxit_ids[i, batch_size]
+        i += batch_size
+
+        to = current_batch.join(',')
+        send_message(@app_name, to, message, contains_markup)
+
+        Rails.logger.info("Total users notified: " + current_batch.count.to_s)
+      end
+      Rails.logger.info('Finished notifying!')
+    end
+
+    private
+
+      def http_client(url)
+        uri = URI(url)
+
+        use_ssl = uri.scheme == 'https'
+        response = Net::HTTP.start(uri.host, uri.port, :use_ssl => use_ssl) do |http|
+          yield(http, uri.path)
+        end
+      end
+
+      def new_post_request(path, form_data)
+        request = Net::HTTP::Post.new(path)
+        request.basic_auth(@client_id, @client_secret)
+        request.set_form_data(form_data)
+        return request
+      end
+
+      def set_request_auth(request, access_token)
+        request["Authorization"] = "Bearer " + access_token
+      end
+
+      def set_api_headers(request, access_token, format="application/json")
+        set_request_auth(request, access_token)
+        request["Accept"] = format
+        request.content_type = format
+      end
+
+      def check_auth_token(auth_token, scopes)
+        if auth_token.nil?
+          raise MxitRails::MxitApi::Exception.new("No auth token has been set/provided.")
+        elsif not auth_token.has_scopes? scopes
+          raise MxitRails::MxitApi::Exception.new("The auth token doesn't have the required " +
+            "scope(s).")
+        end
+      end
+
+  end
+
+end

data/lib/mxit_rails/mxit_api/auth_token.rb

@@ -0,0 +1,35 @@
+module MxitRails::MxitApi
+  class AuthToken
+    attr_reader :access_token, :type, :expires_in, :refresh_token, :expires_at,
+      :refresh_token_expires_at
+
+    def initialize(token_response)
+      @access_token = token_response['access_token']
+      @type = token_response['type']
+      @expires_in = token_response['expires_in']
+      @refresh_token = token_response['refresh_token']
+      @scope = token_response['scope'].split
+
+      @expires_at = Time.now + expires_in.seconds
+      # If there isn't a refresh token `has_refresh_token_expired?` must always return true.
+      @refresh_token_expires_at = @refresh_token ? Time.now + 24.hours : Time.now
+    end
+
+    def scope
+      @scope.join(' ')
+    end
+
+    def has_expired?
+      # For extreme latency check within 3 seconds.
+      @expires_at - Time.now <= 3.0
+    end
+
+    def has_refresh_token_expired?
+      @refresh_token_expires_at - Time.now <= 3.0
+    end
+
+    def has_scopes?(scopes)
+      (scopes - @scope).empty?
+    end
+  end
+end

data/lib/mxit_rails/mxit_api/mxit_api_exception.rb

@@ -0,0 +1,8 @@
+module MxitRails::MxitApi
+  class Exception < Exception
+    attr_reader :message
+    def initialize(message)
+      @message = message
+    end
+  end
+end

data/lib/mxit_rails/mxit_api/request_exception.rb

@@ -0,0 +1,9 @@
+module MxitRails::MxitApi
+  class RequestException < MxitRails::MxitApi::Exception
+    attr_reader :code
+    def initialize(message, code)
+      super(message)
+      @code = code
+    end
+  end
+end

data/lib/mxit_rails/page.rb

@@ -70,6 +70,7 @@ module MxitRails
 
       @_mxit = descriptor
       @_mxit_validated = true
+      @_mxit_validation_types = []
       @_mxit_validation_messages = []
 
       clean_session
@@ -118,6 +119,7 @@ module MxitRails
 
       valid = true
       input = descriptor.input.to_sym
+      validation_type = arguments.first
 
       if block.nil?
         parameter = arguments[1..-2][0] # Will return nil if there isn't an argument
@@ -127,30 +129,36 @@ module MxitRails
         end
 
       else
+        validation_type = :custom
         valid = yield(params[input])
       end
 
       if !valid
         @_mxit_validated = false
+        @_mxit_validation_types << validation_type
         @_mxit_validation_messages << arguments.last
       end
 
     end
 
+    def validations_failed &block
+      descriptor.validations_failed = block
+    end
+    def validated &block
+      descriptor.validated = block
+    end
+
     def submit &block
       set_descriptor :default
 
       if descriptor.form? && next_step?
         yield
 
-      elsif params.include?(:_mxit_rails_submit)
-        if @_mxit_validated
-          yield
-        end
+      elsif (params.include?(:_mxit_rails_submit) && @_mxit_validated) || (self.current_step == :_submit)
+        yield
       end
     end
 
-
     def current_step
       return nil if session[:_mxit_rails_step].nil?
       session[:_mxit_rails_step].to_sym
@@ -176,6 +184,12 @@ module MxitRails
 
         if params.include?(:_mxit_rails_submit)
           if @_mxit_validated
+            # Validated hook
+            unless descriptor.validated.nil?
+              descriptor.validated.call
+            end
+
+            # Store input in session
             if descriptor.input
               input = descriptor.input.to_sym
               mxit_form_session[input] = params[input]
@@ -185,9 +199,15 @@ module MxitRails
               mxit_form_session[select] = params[select]
             end
 
+            # Clear submission flag from params and go to next step
             params.delete :_mxit_rails_submit
             @next_step = true
             return
+          else
+            # Validations_failed hook
+            unless descriptor.validations_failed.nil?
+              descriptor.validations_failed.call(@_mxit_validation_types, @_mxit_validation_messages)
+            end
           end
         end
 
@@ -203,6 +223,12 @@ module MxitRails
       redirect_to request.path
     end
 
+    def submit!
+      self.current_step = :_submit
+      # A redirect might not be absolutely required, but it makes things much simpler
+      redirect_to request.path
+    end
+
     def form &block
       descriptor.type = :form
       session[:_mxit_rails_params] ||= {}