slidepay 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea9149688f04b38ba2d7253f8805ebe167a518b9
+  data.tar.gz: 925a135adacc97d7f5c25d653a10e4b08da01996
+SHA512:
+  metadata.gz: 4c50c362f7d73afcd7da67a06a423affc13b1a4701041057af683a4b3c159e097aeaa91b3642fffb1871addd978b838fe7502845188fe6cd206fa94972f8d61f
+  data.tar.gz: 37ea01471930e0a3691a3904c8b17a21dc8584e0e2f0025841088f4c80e1d3a5fdbfa78a3634351d91d32173eb8d1c195d9d6fd3468c5cfd11478d300a5164a3

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+environment.rb

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+

data/.ruby-gemset

@@ -0,0 +1 @@
+slidepay-ruby-sdk

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0-p247

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+bundler_args: --without development
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+script: "bundle exec rake spec"
+addons:
+  code_climate:
+    repo_token: 9960cb8262e8d38cddff9d66fa7f2e64d1fd8227e78a8829b0eab43647a01903

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in slidepay-ruby-sdk.gemspec
+gemspec
+
+group :test do
+  gem "rspec", "~> 2.6"
+  gem "rake"
+  gem "codeclimate-test-reporter"
+end

data/Guardfile

@@ -0,0 +1,9 @@
+notification :growl
+
+ignore %r{^doc}
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/.+\.rb$})
+  watch(%r{^lib/slidepay/(.+)\.rb$})  { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^lib/slidepay/resources/(.+)\.rb$})  { |m| "spec/#{m[1]}_spec.rb" }
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 SlidePay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,135 @@
+
+
+# Slidepay Ruby Sdk
+
+[![Build Status](https://travis-ci.org/SlidePay/slidepay-ruby-sdk.png)](https://travis-ci.org/SlidePay/slidepay-ruby-sdk) [![Code Climate](https://codeclimate.com/repos/5236cb7013d6371e46004010/badges/f963bebb1565c5419c78/gpa.png)](https://codeclimate.com/repos/5236cb7013d6371e46004010/feed)
+
+First version of the SlidePay Ruby SDK
+
+## Dependencies
+
+We depend on these fantastic libraries:
+
+- [rest-client](https://github.com/rest-client/rest-client)
+- [multi_json](https://github.com/intridea/multi_json)
+- [json](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/json/rdoc/JSON.html)
+
+## Building the Gem
+
+From the root of the repository, run the ```gem build``` command:
+
+```bash
+$ gem build slidepay.gemspec
+```
+
+## How Does SlidePay's API Work?
+
+Check out our [main documentation](https://getcube.atlassian.net/wiki/display/CDP/Getting+Started) for detailed information about how the API works, as well as information about functionality not yet wrapped by this library.
+
+## The Ruby SDK Basics
+
+Requests can be made three ways:
+
+1. Using the SlidePay request methods directly with the desired API url and relevant request JSON
+2. [Coming Soon] Using an instance of the SlidePay::Client class to save an ApiResource, such as a payment, order, or item
+3. Using an instance of a SlidePay::ApiResource class, such as SlidePay::ApiKey or SlidePay::Payment
+
+## Authentication
+
+A request to SlidePay is considered authenticated if either an api_key or token are present in the request. Information about how those are sent, and how they are obtained, can be found on [the authentication page of the api documentation](https://getcube.atlassian.net/wiki/display/CDP/Making+your+first+API+call%3A+authentication).
+
+Both the api_key and token can be set in a global, instance, and request context. The order of precedence goes from most to least specific, and tokens are of greater significance than api_keys. This means that an api_key provided to an instance of an ApiResource would be used over a global token, but would be ignored in the face of a token set on that same object, and would yield to either provided to a single request method.
+
+Either of these fields can be set globally by assigning ```SlidePay.token``` or ```SlidePay.api_key```:
+
+```ruby
+SlidePay.token = "MY_TOKEN"
+```
+
+```ruby
+SlidePay.api_key = "MY_API_KEY"
+```
+
+The global token can also be set using the global SlidePay authentication method:
+
+```ruby
+SlidePay.authenticate(email, password)
+```
+
+You can retrieve a token for use in any context with the retrieve_token method, which is similar to SlidePay.authenticate except that it returns the token string and does not set a global token value.
+
+```ruby
+SlidePay.authenticate(email, password)
+```
+
+These fields can also be used on an instance or per-request level by either passing them into the SlidePay module request methods as a field in a hash, or by assigning instance variables on a SlidePay::Client.
+
+```ruby
+SlidePay.get(path: "payment/#{payment_id}", token: "MY_TOKEN")
+```
+or
+```ruby
+SlidePay.get(path: "payment/#{payment_id}", api_key: "MY_API_KEY")
+```
+
+## Resources
+
+SlidePay::ApiResources are classes that encapsulate RESTful API resources. API interaction relative to these resources is handled by the following descriptive methods:
+
+- ```save ```
+- ```destroy ```
+- ```retrieve ```
+
+The ```save``` method can handle both creation, via POST, and updating, via PUT, and determines which verb is appropriate by the ```ApiResource.is_new?``` method, which checks for the presence of an id in the resource.
+
+## Payments
+
+Payments are much like resources, except they cannot be updated or destroyed once created. Two more relevant instance methods for interacting with payments are provided.
+
+To process a payment, supply a JSON representation of a valid [simple_payment](https://getcube.atlassian.net/wiki/display/CDP/Processing+a+Simple+Payment) object on instantiation, and then call that instance's ```process``` method:
+
+```ruby
+p = SlidePay::Payment.new(simple_payment_json)
+p.process()
+```
+
+To refund a payment, call an existing payment's ```refund``` method, or POST to the ```payment/refund/:payment_id``` API path:
+
+```ruby
+# Refund from an object
+p.refund()
+
+# Refund using SlidePay.post
+SlidePay.post(path: 'payment/refund/#{payment_id}')
+```
+
+## Testing
+
+Test are in the spec directory, and can be run from the root of the repository:
+
+```bash
+$ rspec spec
+```
+
+Some tests will require that you have an active SlidePay account on the development server, and that you supply those credentials in an ```environment.rb``` file in the root of this repository.
+
+Your populated environment.rb should look something like this:
+
+```ruby
+# Environment variables for testing. This Should NOT be included in VCS
+ENV["email"]      = "email@example.com"
+ENV["password"]   = "really_secure_password"
+ENV["api_key"]    = "super-secret-api-key-that-you-never-share"
+```
+
+## Notes
+
+The SlidePay::Client class is largely untested and likely non-functional.
+
+Though this document rarely mentions authentication in most examples following the section above dedicated to it, an api_key or token, and an endpoint, may be supplied to any object or module that can perform an API request. This flexibility allows for interacting with a single instance of a single ApiResource class without having to use the SlidePay module methods directly, or having to use an instance of the SlidePay::Client class. It also accommodates those developers who may wish to authenticate many SlidePay accounts within a single thread, such as inside a request context of a Rails application, or in a scheduled task, without having to repeatedly set the SlidePay.token or SlidePay.api_key global values.
+
+## License
+
+The MIT License (MIT)
+
+Copyright (c) 2013 SlidePay

data/Rakefile

@@ -0,0 +1,10 @@
+require "rake"
+require "rspec/core/rake_task"
+require "bundler/gem_tasks"
+require 'rspec'
+
+desc "Run the spec suite"
+RSpec::Core::RakeTask.new(:spec) { |t| }
+
+desc "Default task to run the spec suite"
+task :default => [:spec]

data/lib/slidepay.rb

@@ -0,0 +1,145 @@
+# Dependencies
+require "rest-client"
+require "multi_json"
+require "json"
+
+# SlidePay Modules and
+require "slidepay/version"
+require "slidepay/config"
+require "slidepay/response"
+
+# Instance-Level API Interaction
+require "slidepay/client"
+
+# CRUD Capable Resources
+require "slidepay/resources/api_resource"
+require "slidepay/resources/api_key"
+require "slidepay/resources/payment"
+require "slidepay/resources/bank_account"
+
+module SlidePay
+  class << self
+    attr_accessor :token, :api_key, :endpoint
+
+    def get_endpoint_option(options)
+      if options[:endpoint]
+        options[:endpoint]
+      else
+        @endpoint
+      end
+    end
+
+    def get_auth_option(request_options_hash)
+      options = {}
+      if request_options_hash[:token]
+        options["x-cube-token"] = request_options_hash[:token]
+      elsif request_options_hash[:api_key]
+        options["x-cube-api-key"] = request_options_hash[:api_key]
+      elsif @token
+        options["x-cube-token"] = @token
+      elsif @api_key
+        options["x-cube-api-key"] = @api_key
+      end
+
+      options
+    end
+
+    def authenticate(email, password)
+      response = retrieve_token(email, password)
+      if response.was_successful?
+        @token = response.data
+        true
+      else
+        false
+      end
+    end
+
+    def retrieve_token(email, password)
+      get(path: "login", :email => email, :password => password)
+    end
+
+    def retrieve_endpoint(email)
+      get(path: "endpoint", :email => email)
+    end
+
+    def request(type, request_options_hash)
+      options = { "Content-Type" => "application/json" }
+      options.merge! get_auth_option request_options_hash
+
+      if request_options_hash[:email]
+        options["x-cube-email"] = request_options_hash[:email]
+      end
+
+      if request_options_hash[:password]
+        options["x-cube-password"] = request_options_hash[:password]
+      end
+
+      url = "#{get_endpoint_option(request_options_hash)}#{request_options_hash[:path]}"
+      data = request_options_hash[:data]
+
+      begin
+        case type
+        when "GET"
+          response = RestClient.get url, options
+        when "PUT"
+          response = RestClient.put url, data, options
+        when "POST"
+          response = RestClient.post url, data, options
+        when "DELETE"
+          response = RestClient.delete url, options
+        else
+          raise Exception.new("Invalid request type specified")
+        end
+      rescue => e
+        # raise Exception.new("Request to #{url} failed with status code: #{e}")
+        response = e.response
+      end
+
+      Response.new(response)
+    end
+
+    def get(request_options_hash)
+      if request_options_hash.is_a? String
+        request_options_hash = { :path => request_options_hash }
+      end
+
+      request("GET", request_options_hash)
+    end
+
+    def post(request_options_hash)
+      request("POST", request_options_hash)
+    end
+
+    def put(request_options_hash)
+      request("PUT", request_options_hash)
+    end
+
+    def delete(request_options_hash)
+      if request_options_hash.is_a? String
+        request_options_hash = { :path => request_options_hash }
+      end
+
+      request("DELETE", request_options_hash)
+    end
+
+    def configure(options_hash={})
+      if options_hash[:api_key]
+        @api_key = options_hash[:api_key]
+      end
+
+      if options_hash[:token]
+        @token = options_hash[:token]
+      end
+
+      if options_hash[:endpoint]
+        @endpoint = options_hash[:endpoint]
+      elsif options_hash[:development] == true
+        @endpoint = DEV_API_URL
+      else
+        @endpoint = SUPERVISOR_URL
+      end
+    end
+  end
+
+  self.configure
+end

data/lib/slidepay/client.rb

@@ -0,0 +1,99 @@
+module SlidePay
+  class Client
+    attr_accessor :endpoint, :email, :password, :token, :api_key
+
+    def initialize(options={})
+      if options[:endpoint]
+        @endpoint = options[:endpoint]
+      end
+      if options[:email]
+        @email = options[:email]
+      end
+      if options[:password]
+        @password = options[:password]
+      end
+      if options[:token]
+        @token = options[:token]
+      end
+      if options[:api_key]
+        @api_key = options[:api_key]
+      end
+    end
+
+    def is_authenticated?
+      @token != nil || @api_key != nil
+    end
+
+    def authenticate(email=nil, password=nil)
+      email = email || @email
+      password = password || @password
+
+      response = SlidePay.retrieve_token(email, password)
+
+      if response.was_successful?
+        @token = response.data
+        true
+      else
+        false
+      end
+    end
+
+    # Base Request Methods
+    def get(request_params)
+      if request_params.is_a? String
+        SlidePay.get(path: request_params, api_key: @api_key, token: @token, endpoint: @endpoint)
+      else
+        request_params.merge! api_key: @api_key, token: @token, endpoint: @endpoint
+        SlidePay.get(request_params)
+      end
+    end
+
+    def put(request_params)
+      request_params.merge! api_key: @api_key, token: @token, endpoint: @endpoint
+      SlidePay.put(request_params)
+    end
+
+    def post(request_params)
+      request_params.merge! api_key: @api_key, token: @token, endpoint: @endpoint
+      SlidePay.post(request_params)
+    end
+
+    def delete(request_params)
+      if request_params.is_a? String
+        SlidePay.delete(path: request_params, api_key: @api_key, token: @token, endpoint: @endpoint)
+      else
+        request_params.merge! api_key: @api_key, token: @token, endpoint: @endpoint
+        SlidePay.delete(request_params)
+      end
+    end
+
+
+    # Resource Methods
+    def list(resource)
+      response = SlidePay.get(path: resource.url_root, api_key: @api_key, token: @token, endpoint: @endpoint)
+      if response.was_successful?
+        resources = []
+        response.data.each do |resource_instance|
+          resources.push resource.class.new(resource_instance)
+        end
+      else
+        resources = []
+      end
+
+      resources
+    end
+
+    def retrieve(resource)
+      resource.retrieve(api_key: @api_key, token: @token, endpoint: @endpoint)
+    end
+
+    def save(resource)
+      resource.save(api_key: @api_key, token: @token, endpoint: @endpoint)
+    end
+
+    def destroy(resource)
+      resource.destroy(api_key: @api_key, token: @token, endpoint: @endpoint)
+    end
+
+  end
+end