printreleaf 1.0.1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/printreleaf-console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'irb'
+require 'irb/completion'
+
+require "bundler/setup"
+require "printreleaf"
+
+IRB.conf[:PROMPT_MODE] = :SIMPLE
+IRB.conf[:AUTO_INDENT] = true
+IRB.conf[:SAVE_HISTORY] = 100
+
+IRB.start
+

data/lib/printreleaf.rb

@@ -0,0 +1,37 @@
+# stdlib
+require "date"
+require "forwardable"
+require "json"
+
+# dependencies
+require "hashie"
+require "restclient"
+
+# libs
+require "printreleaf/version"
+require "printreleaf/error"
+require "printreleaf/util"
+require "printreleaf/transforms"
+require "printreleaf/api"
+require "printreleaf/resource"
+require "printreleaf/relation"
+require "printreleaf/actions"
+
+require "printreleaf/forestry/project"
+require "printreleaf/paper/type"
+
+require "printreleaf/account"
+require "printreleaf/certificate"
+require "printreleaf/deposit"
+require "printreleaf/invitation"
+require "printreleaf/server"
+require "printreleaf/source"
+require "printreleaf/transaction_item"
+require "printreleaf/transaction"
+require "printreleaf/user"
+require "printreleaf/volume_period"
+
+module PrintReleaf
+  extend API
+end
+

data/lib/printreleaf/account.rb

@@ -0,0 +1,100 @@
+module PrintReleaf
+  class Account < Resource
+    path "/accounts"
+
+    action :find
+    action :list
+    action :create
+    action :update
+    action :activate
+    action :deactivate
+    action :delete
+
+    property :id
+    property :name
+    property :role
+    property :parent_id
+    property :status
+    property :created_at,     transform_with: Transforms::Date
+    property :activated_at,   transform_with: Transforms::Date
+    property :deactivated_at, transform_with: Transforms::Date
+    property :accounts_count, transform_with: Transforms::Integer
+    property :users_count,    transform_with: Transforms::Integer
+    property :mtd_pages,      transform_with: Transforms::Integer
+    property :qtd_pages,      transform_with: Transforms::Integer
+    property :ytd_pages,      transform_with: Transforms::Integer
+    property :lifetime_pages, transform_with: Transforms::Integer
+    property :mtd_trees,      transform_with: Transforms::Float
+    property :qtd_trees,      transform_with: Transforms::Float
+    property :ytd_trees,      transform_with: Transforms::Float
+    property :lifetime_trees, transform_with: Transforms::Float
+
+    def self.mine
+      response = PrintReleaf.get("/account")
+      self.new(response)
+    end
+
+    # Account URI is always root, even when it has an owner.
+    #   /accounts/456
+    # Instead of:
+    #   /accounts/123/accounts/456
+    def uri
+      Util.join_uri(self.class.uri, self.id)
+    end
+
+    def active?
+      status == "active"
+    end
+
+    def inactive?
+      status == "inactive"
+    end
+
+    def parent
+      return nil if parent_id.nil?
+      @parent ||= Account.find(parent_id)
+    end
+
+    # Alias
+    def children
+      accounts
+    end
+
+    def accounts
+      @accounts ||= Relation.new(self, Account)
+    end
+
+    def certificates
+      @certificates ||= Relation.new(self, Certificate)
+    end
+
+    def deposits
+      @deposits ||= Relation.new(self, Deposit)
+    end
+
+    def invitations
+      @invitations ||= Relation.new(self, Invitation)
+    end
+
+    def servers
+      @servers ||= Relation.new(self, Server)
+    end
+
+    def sources
+      @sources ||= Relation.new(self, Source)
+    end
+
+    def transactions
+      @transactions ||= Relation.new(self, Transaction)
+    end
+
+    def users
+      @users ||= Relation.new(self, User)
+    end
+
+    def volume
+      @volume ||= Relation.new(self, VolumePeriod)
+    end
+  end
+end
+

data/lib/printreleaf/actions.rb

@@ -0,0 +1,123 @@
+module PrintReleaf
+  module Actions
+    module Find
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
+      end
+
+      def self.extended(base)
+        base.extend(ClassMethods)
+        base.extend(InstanceMethods)
+      end
+
+      module ClassMethods
+        def find(id)
+          uri = Util.join_uri(self.uri, id)
+          response = PrintReleaf.get(uri)
+          self.new(response)
+        end
+      end
+
+      module InstanceMethods
+        def reload
+          response = PrintReleaf.get(self.uri)
+          self.reset(response)
+        end
+      end
+    end
+
+    module List
+      def self.included(base)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
+      end
+
+      def self.extended(base)
+        base.extend(InstanceMethods)
+      end
+
+      module ClassMethods
+        def list(params={})
+          PrintReleaf.get(self.uri, params).map do |response|
+            self.new(response)
+          end
+        end
+
+        def first
+          list.first
+        end
+
+        def last
+          list.last
+        end
+
+        def count
+          list.count
+        end
+
+        def length
+          list.length
+        end
+      end
+
+      module InstanceMethods
+        def list(params={})
+          PrintReleaf.get(self.uri, params).map do |response|
+            self.new(response)
+          end
+        end
+      end
+    end
+
+    module Create
+      def self.included(base)
+        base.extend(self)
+      end
+
+      def create(params)
+        response = PrintReleaf.post(self.uri, params)
+        self.new(response)
+      end
+    end
+
+    module Update
+      def save
+        if self.id.nil?
+          response = PrintReleaf.post(self.uri, self.to_hash)
+        else
+          response = PrintReleaf.patch(self.uri, changes)
+        end
+        reset(response)
+        return true
+      end
+    end
+
+    module Delete
+      def delete
+        response = PrintReleaf.delete(self.uri)
+        reset(response)
+        return true
+      end
+    end
+
+    module Activate
+      def activate
+        uri = Util.join_uri(self.uri, "activate")
+        response = PrintReleaf.post(uri)
+        reset(response)
+        return true
+      end
+    end
+
+    module Deactivate
+      def deactivate
+        uri = Util.join_uri(self.uri, "deactivate")
+        response = PrintReleaf.post(uri)
+        reset(response)
+        return true
+      end
+    end
+  end
+end
+

data/lib/printreleaf/api.rb

@@ -0,0 +1,162 @@
+module PrintReleaf
+  module API
+    extend self
+
+    ENDPOINT = "api.printreleaf.com/v1/"
+    PROTOCOL = "https"
+    MAX_RETRY_COUNT = 2
+    RETRY_DELAY_BASE = 1.5 # Base for exponential delay
+
+    NETWORK_EXCEPTIONS = [
+      SocketError,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ETIMEDOUT,
+      RestClient::RequestTimeout
+    ]
+
+    API_EXCEPTIONS = {
+      400 => BadRequest,
+      401 => Unauthorized,
+      403 => Forbidden,
+      404 => NotFound,
+      429 => RateLimitExceeded,
+      500 => ServerError
+    }
+
+    attr_writer :api_key
+    attr_writer :endpoint
+    attr_writer :protocol
+    attr_accessor :logger
+
+    def api_key
+      if @api_key.nil? or @api_key.strip.to_s.empty?
+        raise Error, "Missing API Key."
+      else
+        return @api_key
+      end
+    end
+
+    def endpoint
+      @endpoint || ENDPOINT
+    end
+
+    def protocol
+      @protocol || PROTOCOL
+    end
+
+    def get(uri="/", params={})
+      request :get, uri, params
+    end
+
+    def post(uri, data={})
+      request :post, uri, data
+    end
+
+    def patch(uri, data={})
+      request :patch, uri, data
+    end
+
+    def delete(uri)
+      request :delete, uri
+    end
+
+    def request(verb, uri, params={})
+      perform_request do
+        uri = Util.join_uri(endpoint, uri)
+        url = "#{protocol}://#{api_key}:@#{uri}"
+
+        unless logger.nil?
+          logger.info "[PrintReleaf] #{verb.upcase} #{uri}"
+        end
+
+        response = case verb
+        when :get;    RestClient.get url, params: params, accept: :json
+        when :post;   RestClient.post url, params.to_json, accept: :json, content_type: :json
+        when :patch;  RestClient.patch url, params.to_json, accept: :json, content_type: :json
+        when :delete; RestClient.delete url
+        end
+
+        JSON.parse(response.body)
+      end
+    end
+
+    private
+
+    def perform_request
+      retry_count = 0
+      begin
+        yield
+      rescue => e
+        if should_retry?(e, retry_count)
+          retry_count += 1
+          sleep retry_delay(retry_count)
+          retry
+        else
+          handle_error(e, retry_count)
+        end
+      end
+    end
+
+    def handle_error(e, retry_count)
+      case e
+      when RestClient::ExceptionWithResponse
+        if e.response
+          handle_api_error(e, retry_count)
+        else
+          handle_restclient_error(e, retry_count)
+        end
+      when JSON::ParserError
+        handle_json_error(e, retry_count)
+      when *NETWORK_EXCEPTIONS
+        handle_network_error(e, retry_count)
+      else
+        raise
+      end
+    end
+
+    def handle_api_error(e, retry_count=0)
+      # We likely got an http status code outside the 200-399 range.
+      # If this is a GET or DELETE request, it is likely the resource is not owned by the client.
+      # If this is a POST, PUT, or PATCH, the data might be invalid.
+      code = e.response.code
+      message = e.response ? JSON.parse(e.response.body)["error"] : "Something went wrong. Please try again."
+      message += " (code=#{code})"
+      message += " Request was retried #{retry_count} times." if retry_count > 0
+      exception = API_EXCEPTIONS[e.response.code] || Error
+      raise exception, message
+    end
+
+    def handle_json_error(e, retry_count=0)
+      # We received the data fine, but we're unable to parse it.
+      # Re-raise a generic error.
+      message = "Unable to parse response. Please try again."
+      message += " Request was retried #{retry_count} times." if retry_count > 0
+      message += " (#{e.class.name})"
+      raise ResponseError, message
+    end
+
+    def handle_network_error(e, retry_count=0)
+      message = "Unexpected error communicating when trying to connect to PrintReleaf."
+      message += " Request was retried #{retry_count} times." if retry_count > 0
+      message += " (#{e.class.name})"
+      raise NetworkError, message
+    end
+
+    def handle_restclient_error(e, retry_count=0)
+      message = "Something went wrong with the request. Please try again."
+      message += " Request was retried #{retry_count} times." if retry_count > 0
+      message += " (#{e.class.name})"
+      raise RequestError, message
+    end
+
+    def should_retry?(e, retry_count=0)
+      NETWORK_EXCEPTIONS.include?(e.class) && retry_count < MAX_RETRY_COUNT
+    end
+
+    def retry_delay(retry_count=0)
+      RETRY_DELAY_BASE ** retry_count
+    end
+  end
+end
+