moonclerk 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93079434871ea140ae8925cb37243440f8462638
+  data.tar.gz: 3d8609c53bbf2fe1a9d40f420da14e5cd3c51455
+SHA512:
+  metadata.gz: ed0e29fd060f41e5a43fcaa5baedbb58fe794a3b434857ca70e69c7fb22f78a00bc7dd52429fce2395e8752c0736f32899816bcf230ad5cdd4046c692fd08e1d
+  data.tar.gz: 7cb7b79a8bbd4168bc505be6e5b65309fe78b76424f22fff4898c9b44238dfc003a15f9b2f304db0de5b4c5ffae9956ff3c7d49baad095b50a39166bb943adc7

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in moonclerk.gemspec
+gemspec

data/README.md

@@ -0,0 +1,118 @@
+# Moonclerk
+
+Moonclerk is a Ruby wrapper around Moonclerk's read-only REST API. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'moonclerk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install moonclerk
+
+## Usage
+
+Set your API key in an initializer (e.g. `config/initializers/moonclerk.rb`):
+
+```ruby
+ Moonclerk.api_key = "<API-KEY>"
+```
+
+### All
+
+All objects have `find` and `list`, and some have `where` which allows filtering on certain attributes. For any `list` or `where` call, `next_page` and `previous_page` can be used to traverse the results returned from the API:
+
+```ruby
+Moonclerk::Customer.list.next_page
+```
+
+### Customers (known as "Plans" in the MoonClerk UI)
+
+To retrieve a customer:
+
+```ruby
+Moonclerk::Customer.retrieve(id) # or Moonclerk::Customer.find(id)
+```
+
+To list customers:
+
+```ruby
+Moonclerk::Customer.list # or Moonclerk::Customer.all
+
+# Options include count and offset
+# NOTE: Count defaults to 10 (max is 100), and offset defaults to 0
+```
+
+To filter customers:
+
+```ruby
+Moonclerk::Customer.where(status: "active")
+
+# Options include form_id, checkout_from, checkout_to, next_payment_from, next_payment_to, status, count, offset
+# NOTE: Any parameter ending in _from or _to is expected to be a Date, Time or DateTime
+# NOTE: Count defaults to 10 (max is 100), and offset defaults to 0
+```
+
+### Forms
+
+To retrieve a form:
+
+```ruby
+Moonclerk::Form.retrieve(id) # or Moonclerk::Form.find(id)
+```
+
+To list forms:
+
+```ruby
+Moonclerk::Form.list # or Moonclerk::Form.all
+
+# Options include count and offset
+# NOTE: Count defaults to 10 (max is 100), and offset defaults to 0
+```
+
+### Payments
+
+To retrieve a payment:
+
+```ruby
+Moonclerk::Payment.retrieve(id) # or Moonclerk::Payment.find(id)
+```
+
+To list payments:
+
+```ruby
+Moonclerk::Payment.list # or Moonclerk::Payment.all
+
+# Options include count and offset
+# NOTE: Count defaults to 10 (max is 100), and offset defaults to 0
+```
+
+To filter payments:
+
+```ruby
+Moonclerk::Payment.where(status: "active")
+
+# Options include form_id, customer_id, date_from, date_to, status, count, offset
+# NOTE: Any parameter ending in _from or _to is expected to be a Date, Time or DateTime
+# NOTE: Count defaults to 10 (max is 100), and offset defaults to 0
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/moonclerk/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "moonclerk"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/moonclerk.rb

@@ -0,0 +1,110 @@
+require "faraday"
+require "json"
+
+# Version
+require "moonclerk/version"
+
+# API Operations
+require "moonclerk/api_operations/list"
+require "moonclerk/api_operations/request"
+
+# Resources
+require "moonclerk/moonclerk_object"
+require "moonclerk/api_resource"
+require "moonclerk/list_object"
+require "moonclerk/customer"
+require "moonclerk/form"
+require "moonclerk/payment"
+require "moonclerk/util"
+
+# Errors
+require "moonclerk/errors/moonclerk_error"
+require "moonclerk/errors/api_error"
+require "moonclerk/errors/authentication_error"
+require "moonclerk/errors/invalid_request_error"
+
+module Moonclerk
+  API_BASE = "https://api.moonclerk.com"
+  API_VERSION = 1
+
+  class << self
+    attr_accessor :api_key
+  end
+
+  def self.request(method, url, params = {})
+    unless api_key
+      raise AuthenticationError.new('No API key provided. ' \
+        'Set your API key using "Moonclerk.api_key = <API-KEY>". ' \
+        'You can generate API keys from the Moonclerk web interface' \
+        'by logging in at moonclerk.com.')
+    end
+
+    if api_key =~ /\s/
+      raise AuthenticationError.new('Your API key is invalid, as it contains ' \
+        'whitespace. (HINT: You can double-check your API key from the ' \
+        'MoonClerk web interface by logging in at moonclerk.com.)')
+    end
+
+    connection = Faraday.new
+    response = connection.send(method, url, params, headers)
+    parsed_response = JSON.parse(response.body)
+    symbolized_response = Util.symbolize_names(parsed_response)
+
+    if symbolized_response[:error]
+      handle_api_error(response)
+    else
+      symbolized_response[symbolized_response.keys.first]
+    end
+  end
+
+  def self.headers
+    {
+      "Authorization" => "Token token=#{api_key}",
+      "Accept" => "application/vnd.moonclerk+json;version=#{API_VERSION}"
+    }
+  end
+
+  def self.default_param_keys
+    [:count, :offset]
+  end
+
+  def self.general_api_error(status, response_body)
+    APIError.new("Invalid response object from API: #{response_body.inspect} " +
+                 "(HTTP response code was #{status})", status, response_body)
+  end
+
+  def self.handle_api_error(response)
+    begin
+      error_obj = JSON.parse(response.body)
+      error_obj = Util.symbolize_names(error_obj)
+      error = error_obj[:error]
+      raise MoonclerkError.new unless error && error.is_a?(Hash)
+
+    rescue JSON::ParserError, StripeError
+      raise general_api_error(response.status, response.body)
+    end
+
+    case response.status
+    when 400, 404
+      raise invalid_request_error(error, response, error_obj)
+    when 401
+      raise authentication_error(error, response, error_obj)
+    else
+      raise api_error(error, response, error_obj)
+    end
+  end
+
+  def self.invalid_request_error(error, response, error_obj)
+    InvalidRequestError.new(error[:message], response.status, response.body, error_obj, 
+                            response.headers)
+  end
+
+  def self.authentication_error(error, response, error_obj)
+    AuthenticationError.new(error[:message], response.status, response.body, error_obj,
+                            response.headers)
+  end
+
+  def self.api_error(error, response, error_obj)
+    APIError.new(error[:message], response.status, response.body, error_obj, response.headers)
+  end
+end

data/lib/moonclerk/api_operations/list.rb

@@ -0,0 +1,40 @@
+module Moonclerk
+  module APIOperations
+    module List
+      def list(params = {})
+        response = request(:get, url, params)
+
+        klass = self.is_a?(Moonclerk::ListObject) ? self[:object] : self.class_name.downcase
+        obj = ListObject.construct_from({ data: response, object: klass })
+        
+        # Set a count and offset so that we can fetch the same number when accessing the
+        # next and previous pages
+        obj.count = params[:count]
+        obj.offset = params[:offset]
+
+        obj
+      end
+
+      # This method returns a page of objects, so #all
+      # is not an appropriate method name, but it is
+      # aliased for convenience.
+      alias :all :list
+
+      def where(options = {})
+        options = Util.symbolize_names(options)
+        params = {}
+        (@permitted_attributes + default_param_keys).each do |key|
+          if options[key]
+            if key.to_s.split("_").last =~ /from|to/
+              params[key] = CGI.escape(options[key].strftime("%Y-%m-%d"))
+            else
+              params[key] = CGI.escape(options[key].to_s)
+            end
+          end
+        end
+
+        list(params)
+      end
+    end
+  end
+end

data/lib/moonclerk/api_operations/request.rb

@@ -0,0 +1,30 @@
+module Moonclerk
+  module APIOperations
+    module Request
+      module ClassMethods
+
+        def request(method, url, params = {})
+          Moonclerk.request(method, url, params)
+        end
+
+        def default_param_keys
+          Moonclerk.default_param_keys
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      protected
+
+      def request(method, url, params = {})
+        self.class.request(method, url, params)
+      end
+
+      def default_param_keys
+        self.class.default_param_keys
+      end
+    end
+  end
+end

data/lib/moonclerk/api_resource.rb

@@ -0,0 +1,42 @@
+module Moonclerk
+  class APIResource < MoonclerkObject
+    include Moonclerk::APIOperations::Request
+
+    def self.class_name
+      self.name.split('::')[-1]
+    end
+
+    def self.url
+      if self == APIResource
+        raise NotImplementedError.new('APIResource is an abstract class.  You should perform actions on its subclasses (Customer, Payment, etc.)')
+      end
+      "#{API_BASE}/#{CGI.escape(class_name.downcase)}s"
+    end
+
+    def url
+      if self.is_a?(Moonclerk::ListObject)
+        return "#{API_BASE}/#{CGI.escape(self[:object])}s"
+      end
+
+      unless id = self['id']
+        raise InvalidRequestError.new("Could not determine which URL to request: #{self.class} instance has invalid ID: #{id.inspect}", 'id')
+      end
+      "#{self.class.url}/#{CGI.escape(id)}"
+    end
+
+    def refresh
+      response = request(:get, url, @retrieve_params)
+      refresh_from(response)
+    end
+
+    def self.retrieve(id)
+      instance = self.new(id.to_s)
+      instance.refresh
+      instance
+    end
+
+    def self.find(id)
+      self.retrieve(id)
+    end
+  end
+end

data/lib/moonclerk/customer.rb

@@ -0,0 +1,11 @@
+module Moonclerk
+  class Customer < APIResource
+    extend Moonclerk::APIOperations::List
+    @permitted_attributes = [:form_id,
+                             :checkout_from, 
+                             :checkout_to, 
+                             :next_payment_from, 
+                             :next_payment_to, 
+                             :status]
+  end
+end

data/lib/moonclerk/errors/api_error.rb

@@ -0,0 +1,4 @@
+module Moonclerk
+  class APIError < MoonclerkError
+  end
+end

data/lib/moonclerk/errors/authentication_error.rb

@@ -0,0 +1,4 @@
+module Moonclerk
+  class AuthenticationError < MoonclerkError
+  end
+end

data/lib/moonclerk/errors/invalid_request_error.rb

@@ -0,0 +1,10 @@
+module Moonclerk
+  class InvalidRequestError < MoonclerkError
+    attr_accessor :param
+
+    def initialize(message, http_status=nil, http_body=nil, json_body=nil,
+                   http_headers=nil)
+      super(message, http_status, http_body, json_body, http_headers)
+    end
+  end
+end

data/lib/moonclerk/errors/moonclerk_error.rb

@@ -0,0 +1,26 @@
+module Moonclerk
+  class MoonclerkError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :http_headers
+    attr_reader :request_id
+    attr_reader :json_body
+
+    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil,
+                   http_headers=nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @http_headers = http_headers || {}
+      @json_body = json_body
+      @request_id = @http_headers["x-request-id"]
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      id_string = @request_id.nil? ? "" : "(Request #{@request_id}) "
+      "#{status_string}#{id_string}#{@message}"
+    end
+  end
+end