foundationapi 0.9.9

data/Rakefile

@@ -0,0 +1,37 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FoundationApi'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Dir.glob('lib/tasks/*.rake').each { |r| import r }
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/lib/foundation_api.rb

@@ -0,0 +1,9 @@
+require 'foundation_api/errors'
+module FoundationApi
+  autoload :JsonRPC,  'foundation_api/json_rpc'
+  autoload :Event,    'foundation_api/event'
+  autoload :Model,    'foundation_api/model'
+  autoload :Request,  'foundation_api/request'
+  autoload :Table,    'foundation_api/table'
+  autoload :Service,  'foundation_api/service'
+end

data/lib/foundation_api/errors.rb

@@ -0,0 +1,34 @@
+module FoundationApi
+  class FoundationApiError < StandardError
+  end
+  
+  class RecordNotUnique < FoundationApiError
+  end
+  
+  class RecordNotSaved < FoundationApiError
+  end
+
+  class RecordNotDeleted < FoundationApiError
+  end
+  
+  class RecordNotPersistent < FoundationApiError
+  end
+  
+  class TranslationError < FoundationApiError
+  end
+  
+  class PersistenceNotSupported < FoundationApiError
+  end
+  
+  class CreateNotSupported < PersistenceNotSupported
+  end
+  
+  class UpdateNotSupported < PersistenceNotSupported
+  end
+
+  class DestroyNotSupported < PersistenceNotSupported
+  end
+  
+  class RecordInvalid < FoundationApiError
+  end
+end

data/lib/foundation_api/event.rb

@@ -0,0 +1,6 @@
+module FoundationApi
+  module Event
+    autoload :Exceptions, 'foundation_api/event/exceptions'
+    autoload :Client,     'foundation_api/event/client'
+  end
+end

data/lib/foundation_api/event/client.rb

@@ -0,0 +1,105 @@
+require 'net/http'
+require 'addressable/uri'
+require 'json'
+require 'active_support/benchmarkable'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'exceptions'))
+
+module FoundationApi
+  module Event
+    class Client
+      class_attribute :uri
+      class_attribute :auth_token
+      class << self
+        include ActiveSupport::Benchmarkable 
+
+        def site=(url)
+          self.uri = Addressable::URI.parse(url)
+        end
+
+        def logger
+          ::Rails.logger
+        end
+
+        def authenticate
+          logger.debug "FoundationApi::Event::Client authenticating"
+          self.auth_token = FoundationApi::JsonRPC::Client.authenticate
+          logger.debug "auth_token: #{auth_token.inspect}"
+          self.auth_token
+        end
+
+        def request(interface, params = {})
+          interface = interface.to_s
+          tries = 0
+          begin
+            authenticate unless auth_token
+            post_request interface, params.merge(:apitoken => auth_token)
+          rescue => e
+            if (tries += 1) == 1
+              case e
+              when AuthenticationFailed
+                self.auth_token = nil
+                retry
+              when FoundationApi::JsonRPC::JsonRPCError
+                retry if e.response == :invalid_security_token
+              end
+            end
+            raise
+          end
+        end
+
+        # call to send an unauthenticated request
+        def post_request(interface, params = {})
+          result = {}
+          logger.info "Initiating FoundationApi::Event::Client POST #{uri.join(interface)} at #{Time.now}"
+          benchmark "Connection time", :level => :info do
+            connect do |connection|
+              message = params.to_json
+              logger.info "  Parameters: #{password_filter(message)}"
+              benchmark "  Request time", :level => :info do
+                result = JSON.parse(connection.post(uri.join(interface).path, message, {'Content-Type' => 'application/json', 'Accept' => '*/*'}).body)
+              end
+            end
+            handle_response result, interface
+            logger.info "  FoundationApi::Event::Client.post_request result: #{result.inspect}"
+          end
+          result['status']
+        end
+
+      protected
+        def connect(&block)
+          conn = http
+          logger.debug "  Using: #{uri.scheme}"
+          if uri.scheme == "https"
+            conn.use_ssl = true
+            conn.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+          conn.start(&block)
+        end
+        
+        def http
+          Net::HTTP.new(uri.host, uri.port)
+        end
+
+      private
+        def password_filter(str)
+          str.gsub(/"password":\s*".*?"/, '"password":"[FILTERED]"')
+        end
+        
+        def handle_response(result, interface)
+          unless result['status'] == "SUCCESS"
+            logger.error "  FoundationApi::Event::RequestError: #{interface} -> #{result.inspect}"
+            begin
+              e = "FoundationApi::Event::#{result['status'].downcase.classify}".constantize 
+            rescue 
+              logger.error "Unknown result from #{uri.join(interface)}"
+              raise FoundationApi::Event::UnknownResponseError, "Unknow response: #{result.inspect}"
+            end
+            raise e, "FoundationApi::Event::Client.post_request failed #{uri.join(interface)} returned #{result.inspect}"
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/foundation_api/event/exceptions.rb

@@ -0,0 +1,20 @@
+module FoundationApi
+  module Event
+    
+    class RequestError < StandardError
+    end
+    
+    class AuthenticationFailed < RequestError
+    end
+    class InvalidArgument < RequestError
+    end
+    class MalformedRequest < RequestError
+    end
+    class OperationError < RequestError
+    end
+    class Timeout < RequestError
+    end
+    class UnknownResponseError < RequestError
+    end
+  end
+end

data/lib/foundation_api/json_rpc.rb

@@ -0,0 +1,6 @@
+module FoundationApi
+  module JsonRPC
+    autoload :JsonRPCError, 'foundation_api/json_rpc/exceptions'
+    autoload :Client,     'foundation_api/json_rpc/client'
+  end
+end

data/lib/foundation_api/json_rpc/client.rb

@@ -0,0 +1,80 @@
+require 'net/http'
+require 'addressable/uri'
+require 'json'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'exceptions'))
+
+module FoundationApi
+  module JsonRPC
+    class Client
+      
+      class_attribute :uri
+      class_attribute :auth_token
+
+      class << self
+        include ActiveSupport::Benchmarkable 
+
+        def site=(url)
+          self.uri = Addressable::URI.parse(url)
+        end
+
+        def logger
+          ::Rails.logger
+        end
+
+        def authenticate
+          self.auth_token = nil
+          self.auth_token = post_request('APIAuthenticate', :username => uri.user, :password => uri.password)
+        end
+
+        def request(method, params = {})
+          tries = 0
+          begin
+            authenticate unless auth_token
+            post_request method, params.merge(:authorization => auth_token)
+          rescue JsonRPCError => e
+            tries += 1
+            if e.response == :invalid_security_token && tries == 1
+              self.auth_token = nil
+              retry
+            end
+            raise
+          end
+        end
+
+        # call to send an unauthenticated request
+        def post_request(method, params = {})
+          result = {}
+          Net::HTTP.start(uri.host, uri.port) do |connection|
+            logger.debug "Started JsonRPC POST #{uri.path} at #{Time.now}"
+            message = {:method => method.to_s, :id => 'jsonrpc', :params => [params]}.to_json
+            logger.debug "Parameters: #{password_filter(message)}"
+            benchmark "Request time", :level => :info do        
+              result = JSON.parse(connection.post(uri.path, message).body)
+            end
+          end
+          if error = result["error"]
+            logger.error "FoundationApi::JsonRPC::JsonRPCError: #{method} -> #{result.inspect}"
+            raise JsonRPCError.new(error['code']), error["message"]
+          else
+            logger.debug "FoundationApi::JsonRPC::Client.post_request result: #{result.inspect}"
+          end
+          result['result']
+        end
+
+        def unique_id(seed)
+          "#{Time.now.to_f}.#{seed}"
+        end
+
+        def key_value_array(attributes = {})
+          attributes.stringify_keys.sort
+        end
+      private
+        def password_filter(str)
+          str.gsub(/\["password",".*?"\]/, '["password","[FILTERED]"]')
+        end
+      end
+      
+    end
+  end
+end

data/lib/foundation_api/json_rpc/exceptions.rb

@@ -0,0 +1,47 @@
+module FoundationApi
+  module JsonRPC
+    
+    class JsonRPCError < StandardError
+      RESPONSES = 
+      [:no_error                     ,
+      :invalid_security_token        ,
+      :invalid_user_or_pass          ,
+      :exception_thrown              ,
+      :not_implemented               ,
+      :incorrect_parameter_list      ,
+      :missing_player_session        ,
+      :unable_to_get_session_lock    ,
+      :session_server_fault          ,
+      :insufficient_privileges       ,
+      :incorrect_account_format      ,
+      :invalid_parameter             ,  # 11
+      :unknown_player_attribute      ,  # 12
+      :cannot_set_readonly_attribute ,  # 13
+      :duplicate_attribute_value     ,  # 14
+      :unknown_player_flag           ,  # 15
+      :cannot_set_readonly_flag      ,  # 16
+      :nothing_to_update             ,  # 17
+      :unknown_error                 ,  # 18
+      :mismatching_transactions      ,  # 19
+      :db_error                      ,  # 20
+      :un_identified_error_21        ,  # 21
+      :un_identified_error_22        ,  # 22
+      :un_identified_error_23        ,  # 23
+      :insufficient_funds            
+      ]
+      
+      attr_reader :code
+      def initialize(code = nil)
+        @code = code.to_i if code
+      end
+      
+      def response
+        RESPONSES[code]
+      end
+    end
+  end
+  
+  
+  
+  
+end

data/lib/foundation_api/model.rb

@@ -0,0 +1,7 @@
+module FoundationApi
+  module Model
+    autoload :AttributeMethods, 'foundation_api/model/attribute_methods'
+    autoload :Cached, 'foundation_api/model/cached'
+    autoload :Mapping, 'foundation_api/model/mapping'
+  end
+end

data/lib/foundation_api/model/attribute_methods.rb

@@ -0,0 +1,85 @@
+require 'active_support/hash_with_indifferent_access.rb'
+module FoundationApi
+  module Model
+    module AttributeMethods
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :attribute_aliases
+        self.attribute_aliases = {}
+        attr_accessor :attributes
+      end
+
+      module ClassMethods
+        def alias_attribute(new_name, old_name)
+          self.attribute_aliases = attribute_aliases.merge(new_name.to_s => old_name.to_s)
+        end
+
+        def map_attribute(attr)
+          attribute_aliases[attr.to_s] || attr.to_s
+        end
+        def reverse_map_attribute(attr)
+          if v = attribute_aliases.rassoc(attr.to_s)
+            v[0].to_s
+          else
+            attr.to_s
+          end
+        end
+        def translate_attributes(attrs)
+          HashWithIndifferentAccess[attrs.collect { |attr,value| [map_attribute(attr), value] }]
+        end
+      end
+
+      # TODO: change when on rails 4
+      # delegate :map_attribute, :reverse_map_attribute, to: :class
+      delegate :map_attribute, :reverse_map_attribute, :translate_attributes, to: 'self.class'
+
+      def method_missing(method, *args)
+        if method =~ /([_a-zA-Z]\w*)([=?]*)/
+          name, call = $1, $2
+          if attribute = matching_attribute(name)
+            case call
+            when "="
+              src = <<-end_src
+                def #{name}=(value)
+                  attributes[:#{attribute}] = value 
+                end
+              end_src
+              class_eval src, __FILE__, __LINE__
+            when "?"
+              src = <<-end_src
+                def #{name}?
+                  !!attributes[:#{attribute}] 
+                end
+              end_src
+              class_eval src, __FILE__, __LINE__
+            else
+              src = <<-end_src
+                def #{name}
+                  attributes[:#{attribute}]
+                end
+              end_src
+              class_eval src, __FILE__, __LINE__
+            end
+            return self.send(method, *args)
+          end
+        end
+        super
+      end
+      
+      def [](attribute)
+        attributes[map_attribute(attribute)]
+      end
+
+      def []=(attribute, value)
+        attributes[map_attribute(attribute)] = value
+      end
+
+    private
+      def matching_attribute(attr)
+        attributes.has_key?( attr) ? attr : attribute_aliases[attr.to_s]
+      end
+
+    end
+  end
+end