sailplay 0.1.1

data/lib/sailplay/configuration.rb

@@ -0,0 +1,115 @@
+require 'logger'
+
+module Sailplay
+  class Configuration
+    OPTIONS = [:host, :port, :secure, :endpoint, :connection_options, :store_id, :store_key, :store_pin, :logger]
+
+
+    # The host to connect to (defaults to sailplay.ru).
+    attr_accessor :host
+
+    # The port on which Sailplay API server runs (defaults to 443 for secure
+    # connections, 80 for insecure connections).
+    attr_accessor :port
+
+    # Url prefix for API (defaults to /api/v1)
+    attr_accessor :endpoint
+
+    # +true+ for https connections, +false+ for http connections.
+    attr_accessor :secure
+
+    attr_accessor :connection_options
+    attr_accessor :store_id
+    attr_accessor :store_key
+    attr_accessor :store_pin
+
+    attr_accessor :logger
+
+    # JS client configuration
+    attr_accessor :js_api_path
+
+    # one of :top_left, :top_right, :center_left, :center_right, :bottom_left, :bottom_right
+    attr_accessor :js_position
+
+    # {
+    #   :buttonText => 'Text', :buttonBgGradient => ["#78bb44", "#367300"], :buttonFontSize => '9px',
+    #   :picUrl => "http://some.url", :bgColor => '#ffffff', :borderColor => '#ffffff', :textColor => '#300c2f',
+    #   :pointsColor => '#c81750', :buttonTextColor => '#ffffff'
+    # }
+    attr_accessor :skin
+
+
+    DEFAULT_CONNECTION_OPTIONS = {
+        :headers => {
+            :accept => 'application/json',
+            :user_agent => "Sailplay Ruby Gem (#{Sailplay::VERSION})"
+        }
+    }
+
+    alias_method :secure?, :secure
+
+    def initialize
+      @host =     'sailplay.ru'
+      @secure =   true
+      @endpoint = '/api/v1'
+
+      @js_api_path = 'static/js/sailplay.js'
+      @js_position = :top_right
+
+      @skin = {}
+
+      @connection_options = DEFAULT_CONNECTION_OPTIONS.dup
+    end
+
+    # Allows config options to be read like a hash
+    #
+    # @param [Symbol] option Key for a given attribute
+    def [](option)
+      send(option)
+    end
+
+    # Returns a hash of all configurable options
+    def to_hash
+      OPTIONS.inject({}) do |hash, option|
+        hash[option.to_sym] = self.send(option)
+        hash
+      end
+    end
+
+    def port
+      @port || default_port
+    end
+
+    # Determines whether protocol should be "http" or "https".
+    # @return [String] Returns +"http"+ if you've set secure to +false+ in
+    # configuration, and +"https"+ otherwise.
+    def protocol
+      if secure?
+        'https'
+      else
+        'http'
+      end
+    end
+
+    def logger
+      @logger ||= begin
+        log = Logger.new($stdout)
+        log.level = Logger::INFO
+        log
+      end
+    end
+
+    private
+
+    # Determines what port should we use for sending notices.
+    # @return [Fixnum] Returns 443 if you've set secure to true in your
+    # configuration, and 80 otherwise.
+    def default_port
+      if secure?
+        443
+      else
+        80
+      end
+    end
+  end
+end

data/lib/sailplay/error.rb

@@ -0,0 +1,27 @@
+module Sailplay
+  class APIConnectionError < StandardError; end
+  class ConfigurationError < StandardError; end
+
+  class Error < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message = nil, http_status = nil, http_body = nil, json_body = nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? '' : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+
+  class APIError < Error; end
+  class AuthenticationError < Error; end
+  class InvalidRequestError < Error; end
+end

data/lib/sailplay/rails.rb

@@ -0,0 +1,24 @@
+require 'sailplay'
+require 'sailplay/rails/client'
+
+module Sailplay
+  module Rails
+    def self.initialize
+      if defined?(::ActionController::Base)
+        ::ActionController::Base.send(:include, Sailplay::Rails::Client)
+      end
+
+      rails_logger = if defined?(::Rails.logger)
+        ::Rails.logger
+      elsif defined?(RAILS_DEFAULT_LOGGER)
+        RAILS_DEFAULT_LOGGER
+      end
+
+      Sailplay.configure do |config|
+        config.logger = rails_logger
+      end
+    end
+  end
+end
+
+Sailplay::Rails.initialize

data/lib/sailplay/rails/client.rb

@@ -0,0 +1,118 @@
+module Sailplay
+  module Rails
+    module Client
+      def self.included(base)
+        base.send :around_filter, :prepare_sailplay_options
+
+        base.send :helper_method, :render_sailplay_client
+      end
+
+      protected
+
+      def assign_sailplay_user(user)
+        sailplay_options(:origin_user_id => user.sailplay_user_id) if user.respond_to?(:sailplay_user_id)
+        sailplay_options(:probable_user_phone => user.sailplay_phone) if user.respond_to?(:sailplay_user_id)
+      end
+
+      def render_sailplay_client(options = {})
+        @_sailplay_client_fired = true
+        result = sailplay_compile_template(sailplay_options.merge(options))
+
+        if result.respond_to?(:html_safe)
+          result.html_safe
+        else
+          result
+        end
+      end
+
+      def authenticate_sailplay_user(phone, force_reload = false)
+        return if phone.nil?
+
+        if force_reload || (session[:sailplay] && session[:sailplay][:auth_expires] < Time.now)
+          session[:sailplay] = nil
+        end
+
+        unless session[:sailplay]
+          user = begin
+            Sailplay.find_user(phone, :auth => true)
+          rescue Sailplay::APIError
+            Sailplay.create_user(phone, :auth => true) rescue nil
+          end
+
+          if user
+            sailplay_options :auth_hash => user.auth_hash, :auth_expires => 3.days.from_now
+          end
+        end
+      end
+
+      def report_sailplay_purchase(user_id, order_id, price)
+        purchase = Sailplay.create_purchase(user_id, price, :order_id => order_id)
+        sailplay_options :transaction_key => purchase.public_key
+        purchase
+      rescue Sailplay::Error => e
+        logger.error "Error reporting purchase to Sailplay: #{e.message}"
+      end
+
+
+      def sailplay_options(options = {})
+        (@_sailplay_options ||= {}).merge! options
+      end
+
+      private
+
+      def prepare_sailplay_options
+        load_sailplay_options
+        yield
+        if @_sailplay_client_fired
+          reset_sailplay_options
+        end
+        save_sailplay_options
+      end
+
+      def save_sailplay_options
+        (session[:sailplay] ||= {}).merge! @_sailplay_options if @_sailplay_options
+      end
+
+      def load_sailplay_options
+        @_sailplay_options = session.delete :sailplay
+      end
+
+      def reset_sailplay_options
+        @_sailplay_options = nil
+        session[:sailplay] = nil
+      end
+
+
+      def sailplay_compile_template(options)
+        template_options = {
+          :file          => File.join(File.dirname(__FILE__), '..', '..', 'templates', 'sailplay_client'),
+          :layout        => false,
+          :use_full_path => false,
+          :handlers      => [:erb],
+          :locals        => {
+            :host           => Sailplay.configuration.host,
+            :api_path       => Sailplay.configuration.js_api_path,
+            :store_id       => Sailplay.configuration.store_id,
+            :position       => Sailplay.configuration.js_position.to_s.split('_'),
+            :skin           => Sailplay.configuration.skin,
+            :origin_user_id => '',
+            :user_phone     => '',
+            :auth_hash      => '',
+            :public_key     => 'none',
+            :link           => '',
+            :pic            => ''
+          }
+        }
+
+        template_options[:locals].merge!(options)
+
+        case @template
+          when ActionView::Template
+            @template.render template_options
+          else
+            render_to_string template_options
+        end
+      end
+    end
+  end
+end

data/lib/sailplay/response.rb

@@ -0,0 +1,25 @@
+module Sailplay
+  class Response
+    attr_reader :raw_data, :data, :error_message
+
+    def initialize(json_body)
+      @raw_data = json_body
+
+      if @raw_data && @raw_data[:status] == 'ok'
+        @success = true
+        @data = @raw_data.reject {|k, v| k == :status}
+      else
+        @success = false
+        @error_message = @raw_data[:message]
+      end
+    end
+
+    def success?
+      @success
+    end
+
+    def error?
+      !success?
+    end
+  end
+end

data/lib/sailplay/version.rb

@@ -0,0 +1,3 @@
+module Sailplay
+  VERSION = '0.1.1'
+end

data/lib/templates/sailplay_client

@@ -0,0 +1,19 @@
+<%= javascript_tag %Q{
+  var _sp_options = {
+    depId: #{store_id.to_json},
+    position: #{position.to_json},
+    authHash: #{auth_hash.to_json},
+    publicKey: #{public_key.to_json},
+    originUserId: #{origin_user_id.to_json},
+    probableUserPhone: #{user_phone.to_json},
+    pic: #{pic.to_json},
+    link: #{link.to_json},
+    skin: #{skin.to_json}
+  };
+
+  (function() {
+    var sp = document.createElement('script'); sp.type = 'text/javascript'; sp.async = false; sp.charset = 'utf-8';
+    sp.src = ('https:' == document.location.protocol ? 'https://' : 'http://') + '#{host}/#{api_path}';
+    var scr = document.getElementsByTagName('script')[0]; scr.parentNode.insertBefore(sp, scr);
+  })();
+}%>

data/rails/init.rb

@@ -0,0 +1 @@
+require 'sailplay/rails'

data/sailplay.gemspec

@@ -0,0 +1,34 @@
+# encoding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sailplay/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sailplay'
+  spec.version       = Sailplay::VERSION
+
+  spec.authors       = ['Sergey Nebolsin']
+  spec.email         = ['nebolsin@gmail.com']
+
+  spec.summary       = %q{Sailplay API client}
+  spec.description   = %q{Wrapper for sailplay.ru REST api}
+  spec.homepage      = 'https://github.com/nebolsin/sailplay'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '>= 1.8.7'
+
+  spec.add_runtime_dependency 'multi_json'
+  spec.add_runtime_dependency 'rest-client'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 2.0'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'coveralls'
+
+end

data/spec/sailplay/client_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Sailplay::Client do
+
+  describe 'configuration' do
+    it 'should set the defaults' do
+      Sailplay.reset!
+      Sailplay.client.host.should eq('sailplay.ru')
+      Sailplay.client.port.should eq(443)
+      Sailplay.client.secure.should be_true
+      Sailplay.client.endpoint.should eq('/api/v1')
+    end
+
+    it 'should set the options' do
+      Sailplay.configure do |c|
+        c.host = 'test.me'
+        c.endpoint = 'megaapi'
+        c.store_id = 'test_id'
+        c.store_key = 'test_key'
+        c.store_pin = 'test_pin'
+      end
+
+
+      Sailplay.client.host.should eq('test.me')
+      Sailplay.client.endpoint.should eq('megaapi')
+      Sailplay.client.store_id.should eq('test_id')
+      Sailplay.client.store_key.should eq('test_key')
+      Sailplay.client.store_pin.should eq('test_pin')
+    end
+  end
+
+  describe '.request' do
+    let(:config) do
+      Sailplay::Configuration.new.tap do |c|
+        c.store_id = 'id'
+        c.store_key = 'key'
+        c.store_pin = '1111'
+      end
+    end
+
+    context 'with invalid client configuration' do
+      it 'should raise if store_id is not configured' do
+        config.store_id = nil
+        client = Sailplay::Client.new(config)
+        lambda { client.request(:get, 'call') }.should raise_error(Sailplay::ConfigurationError)
+      end
+
+      it 'should raise if store_key is not configured' do
+        config.store_key = nil
+        client = Sailplay::Client.new(config)
+        lambda { client.request(:get, 'call') }.should raise_error(Sailplay::ConfigurationError)
+      end
+
+      it 'should raise if store_pin is not configured' do
+        config.store_pin = nil
+        client = Sailplay::Client.new(config)
+        lambda { client.request(:get, 'call') }.should raise_error(Sailplay::ConfigurationError)
+      end
+    end
+
+    context 'when authentication is required' do
+      before do
+        @client = Sailplay::Client.new(config)
+        stub_http_request(:get, %r{/action\d?}).to_return(:body => '{"status":"ok"}')
+      end
+
+      let(:login_url) {
+        stub_http_request(:get, 'https://sailplay.ru/api/v1/login').
+            with(:query => {:store_department_id => 'id', :store_department_key => 'key', :pin_code => '1111'})
+      }
+
+      it 'should request the token' do
+        login_url.to_return(:body => '{"status":"ok","token":"some_new_token"}')
+        @client.request(:get, 'action')
+        login_url.should have_been_requested
+      end
+
+      it 'should cache the recieved token' do
+        login_url.to_return(:body => '{"status":"ok","token":"some_new_token"}')
+        @client.request(:get, 'action')
+        @client.request(:get, 'action1')
+        login_url.should have_been_requested.once
+      end
+    end
+
+
+    context 'error handling' do
+      let(:login) do
+        stub_http_request(:any, %r{https://sailplay.ru/api/v1/login})
+      end
+
+      before do
+        @client = Sailplay::Client.new(config)
+      end
+
+      it 'should raise when cannot connect to server' do
+        login.to_raise(SocketError)
+
+        lambda { @client.request(:get, 'call') }.should raise_error(Sailplay::APIConnectionError) do |e|
+          e.message.should match("Unexpected error communicating when trying to connect to Sailplay.  HINT: You may be seeing this message because your DNS is not working.  To check, try running 'host sailplay.ru' from the command line.")
+        end
+      end
+
+      it 'should raise when cannot connect to server due timeout' do
+        login.to_timeout
+
+        lambda { @client.request(:get, 'call') }.should raise_error(Sailplay::APIConnectionError) do |e|
+          e.message.should match("Unexpected error communicating when trying to connect to Sailplay.  HINT: You may be seeing this message because your DNS is not working.  To check, try running 'host sailplay.ru' from the command line.")
+        end
+      end
+
+      it 'should raise when response is not a valid JSON' do
+        login.to_return(:body => '{123')
+
+        lambda { @client.request(:get, 'call') }.should raise_error(Sailplay::APIError) do |e|
+          e.http_status.should eq(200)
+          e.http_body.should eq('{123')
+          e.message.should match('Invalid response object from API')
+        end
+      end
+    end
+  end
+end