paid 1.0.1 → 1.0.2

data/lib/paid/invoice.rb

@@ -1,26 +1,65 @@
 module Paid
   class Invoice < APIResource
-    # attributes :id and :object inherited from APIResource
-    attribute :summary
-    attribute :chase_schedule
-    attribute :next_chase_on
-    attribute :customer
-    attribute :issued_at
-    attribute :terms
-    attribute :url
+    attr_reader :id
+    attr_reader :object
+    attr_accessor :summary
+    attr_accessor :chase_schedule
+    attr_accessor :next_chase_on
+    attr_accessor :customer
+    attr_accessor :issued_at
+    attr_accessor :terms
+    attr_accessor :url
 
-    api_class_method :all, :get, :constructor => APIList.constructor(Invoice)
-    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
-    api_class_method :create, :post
+    def self.all(params={}, headers={})
+      method = APIMethod.new(:get, "/invoices", params, headers, self)
+      APIList.new(self, method.execute, method)
+    end
+
+    def self.retrieve(id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :id => id
+      })
+      method = APIMethod.new(:get, "/invoices/:id", params, headers, self)
+      self.new(method.execute, method)
+    end
+
+    def self.create(params={}, headers={})
+      method = APIMethod.new(:post, "/invoices", params, headers, self)
+      self.new(method.execute, method)
+    end
 
-    api_instance_method :issue, :post, ":path/issue"
-    api_instance_method :mark_as_paid, :post, ":path/mark_as_paid" # requires :via in params
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/invoices/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
 
+    def issue(params={}, headers={})
+      method = APIMethod.new(:post, "/invoices/:id/issue", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
 
-    def self.path
-      "/v0/invoices"
+    def mark_as_paid(params={}, headers={})
+      method = APIMethod.new(:post, "/invoices/:id/mark_as_paid", params, headers, self)
+      self.refresh_from(method.execute, method)
     end
 
-    APIClass.register_subclass(self, "invoice")
+    def void(params={}, headers={})
+      method = APIMethod.new(:post, "/invoices/:id/void", params, headers, self)
+      method.execute
+    end
+
+
+    APIResource.register_api_subclass(self, "invoice")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :summary => nil,
+      :chase_schedule => nil,
+      :next_chase_on => nil,
+      :customer => nil,
+      :issued_at => nil,
+      :terms => nil,
+      :url => nil
+    }
   end
 end

data/lib/paid/params_builder.rb

@@ -0,0 +1,26 @@
+module Paid
+  module ParamsBuilder
+
+    def self.clean(params)
+      Util.symbolize_keys(params || {})
+    end
+
+    # Clean the params, and the hash to_merge, and then merge them.
+    # This ensures that we dont get something like { "id" => 123, :id => 321 }.
+    def self.merge(params, to_merge)
+      params = clean(params)
+      to_merge = clean(to_merge)
+      params.merge(to_merge)
+    end
+
+    def self.build(params, api_key=nil, auth_key=nil)
+      clean(params)
+    end
+
+  end
+end
+
+
+
+
+

data/lib/paid/path_builder.rb

@@ -0,0 +1,38 @@
+module Paid
+  module PathBuilder
+
+    # Take a path like:
+    #   ":path/:id/dogs/:dog_id"
+    # and convert it to:
+    #   "#{object.path}/#{object.id}/dogs/#{params[:id]}" => "/objects/1/dogs/2"
+    #
+    # Path priority is:
+    #   1. Object - this will be a class or an instance of a class.
+    #   2. Params - this is a hash of key values. All keys *must* be symbolized.
+    def self.build(path, object, params)
+      ret = path.dup
+      if ret.include?(":")
+        matches = ret.scan(/:([^\/]*)/).flatten.map(&:to_sym)
+        missing = Set.new(matches)
+
+        matches.each do |match|
+          value = determine_value(match, object, params)
+          missing.delete(match) unless value.nil?
+          ret.sub!(match.inspect, "#{value}")
+        end
+
+        if missing.any?
+          raise ArgumentError.new("Could not determine the full URL. The following values of the path are missing: #{missing.to_a.join(', ')}. Try setting them in your params.")
+        end
+      end
+      ret
+    end
+
+    def self.determine_value(match, object, params)
+      value = object.send(match) if object && object.respond_to?(match)
+      value ||= params[match] if params && params.has_key?(match)
+      value
+    end
+
+  end
+end

data/lib/paid/plan.rb

@@ -1,22 +1,47 @@
 module Paid
   class Plan < APIResource
+    attr_reader :id
+    attr_reader :object
+    attr_reader :created_at
+    attr_accessor :name
+    attr_accessor :description
+    attr_accessor :interval
+    attr_accessor :interval_count
+    attr_accessor :amount
 
-    # attributes :id and :object inherited from APIResource
-    attribute :name
-    attribute :description
-    attribute :interval
-    attribute :interval_count
-    attribute :amount
-    attribute :created_at
+    def self.all(params={}, headers={})
+      method = APIMethod.new(:get, "/plans", params, headers, self)
+      APIList.new(self, method.execute, method)
+    end
+
+    def self.retrieve(id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :id => id
+      })
+      method = APIMethod.new(:get, "/plans/:id", params, headers, self)
+      self.new(method.execute, method)
+    end
 
-    api_class_method :all, :get, :constructor => APIList.constructor(Plan)
-    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
-    api_class_method :create, :post
+    def self.create(params={}, headers={})
+      method = APIMethod.new(:post, "/plans", params, headers, self)
+      self.new(method.execute, method)
+    end
 
-    def self.path
-      "/v0/plans"
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/plans/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
     end
 
-    APIClass.register_subclass(self, "plan")
+    APIResource.register_api_subclass(self, "plan")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :created_at => { :readonly => true },
+      :name => nil,
+      :description => nil,
+      :interval => nil,
+      :interval_count => nil,
+      :amount => nil,
+    }
   end
 end

data/lib/paid/refund_list.rb

@@ -0,0 +1,26 @@
+module Paid
+  class RefundList < APIList
+    attr_accessor :parent_id
+
+    def initialize(json={}, api_method=nil, parent_id=nil)
+      @klass = Util.constantize(:Transaction)
+      @parent_id = parent_id
+      refresh_from(json, api_method)
+    end
+
+    # Not live on the server yet.
+    # def all(params={}, headers={})
+    #   method = APIMethod.new(:get, "/transactions/:parent_id/refunds", params, headers, self)
+    #   APIList.new(:Transaction, method.execute, method)
+    # end
+
+    def create(params={}, headers={})
+      method = APIMethod.new(:post, "/transactions/:parent_id/refunds", params, headers, self)
+      Util.constantize(:Transaction).new(method.execute, method)
+    end
+
+    @api_attributes = {
+      :data => { :readonly => true }
+    }
+  end
+end

data/lib/paid/requester.rb

@@ -0,0 +1,97 @@
+module Paid
+  module Requester
+
+    def self.request(method, url, params, headers)
+      method = method.to_sym
+      url, params = prepare_params(url, params, method)
+      request_opts = {
+        :method => method,
+        :url => url,
+        :headers => headers,
+        :payload => params,
+
+        :verify_ssl => false,
+        :open_timeout => 30,
+        :timeout => 60
+      }
+
+      execute_request(request_opts)
+    end
+
+    def self.execute_request(opts)
+      RestClient::Request.execute(opts)
+    end
+
+    def self.get(url, params, headers)
+      self.request(:get, url, params, headers)
+    end
+
+    def self.delete(url, params, headers)
+      self.request(:delete, url, params, headers)
+    end
+
+    def self.put(url, params, headers)
+      self.request(:put, url, params, headers)
+    end
+
+    def self.post(url, params, headers)
+      self.request(:post, url, params, headers)
+    end
+
+    def self.prepare_params(url, params, method)
+      if [:get, :head, :delete].include?(method)
+        unless params.empty?
+          url += URI.parse(url).query ? '&' : '?' + query_string(params)
+        end
+        params = nil
+      else
+        if !RestClient::Payload.has_file?(params)
+          params = query_string(params)
+        end
+      end
+      [url, params]
+    end
+
+    def self.query_string(params)
+      params ||= {}
+      if params.any?
+        query_array(params).join('&')
+      else
+        ""
+      end
+    end
+
+    # Three major use cases (and nesting of them needs to be supported):
+    #   { :a => { :b => "bvalue" } }  => ["a[b]=bvalue"]
+    #   { :a => [1, 2] }           => ["a[]=1", "a[]=2"]
+    #   { :a => "value" }          => ["a=value"]
+    def self.query_array(params, key_prefix=nil)
+      ret = []
+      params.each do |key, value|
+        if params.is_a?(Array)
+          value = key
+          key = ''
+        end
+        key_suffix = escape(key)
+        full_key = key_prefix ? "#{key_prefix}[#{key_suffix}]" : key_suffix
+
+        if value.is_a?(Hash) || value.is_a?(Array)
+          # Handles the following cases:
+          #   { :a => { :b => "bvalue" } }  => ["a[b]=bvalue"]
+          #   { :a => [1, 2] }           => ["a[]=1", "a[]=2"]
+          ret += query_array(value, full_key)
+        else
+          # Handles the base case with just key and value:
+          #   { :a => "value" } => ["a=value"]
+          ret << "#{full_key}=#{escape(value)}"
+        end
+      end
+      ret
+    end
+
+    def self.escape(val)
+      URI.escape(val.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+  end
+end

data/lib/paid/subscription.rb

@@ -1,25 +1,56 @@
 module Paid
   class Subscription < APIResource
-    # attributes :id and :object inherited from APIResource
-    attribute :created_at
-    attribute :starts_on
-    attribute :next_transaction_on
-    attribute :plan, Plan
-    attribute :customer
-    attribute :started_at
-    attribute :ended_at
-    attribute :cancelled_at
+    attr_reader :id
+    attr_reader :object
+    attr_reader :created_at
+    attr_accessor :starts_on
+    attr_accessor :next_transaction_on
+    attr_accessor :plan
+    attr_accessor :customer
+    attr_accessor :started_at
+    attr_accessor :ended_at
+    attr_accessor :cancelled_at
 
-    api_class_method :all, :get, :constructor => APIList.constructor(Subscription)
-    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
-    api_class_method :create, :post
+    def self.all(params={}, headers={})
+      method = APIMethod.new(:get, "/subscriptions", params, headers, self)
+      APIList.new(self, method.execute, method)
+    end
+
+    def self.retrieve(id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :id => id
+      })
+      method = APIMethod.new(:get, "/subscriptions/:id", params, headers, self)
+      self.new(method.execute, method)
+    end
 
-    api_instance_method :cancel, :post, ":path/cancel"
+    def self.create(params={}, headers={})
+      method = APIMethod.new(:post, "/subscriptions", params, headers, self)
+      self.new(method.execute, method)
+    end
+
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/subscriptions/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
 
-    def self.path
-      "/v0/subscriptions"
+    def cancel(params={}, headers={})
+      method = APIMethod.new(:post, "/subscriptions/:id/cancel", params, headers, self)
+      self.refresh_from(method.execute, method)
     end
 
-    APIClass.register_subclass(self, "subscription")
+    APIResource.register_api_subclass(self, "subscription")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :created_at => { :readonly => true },
+      :starts_on => nil,
+      :next_transaction_on => nil,
+      :plan => { :constructor => :Plan },
+      :customer => nil,
+      :started_at => nil,
+      :ended_at => nil,
+      :cancelled_at => nil
+    }
   end
 end

data/lib/paid/transaction.rb

@@ -1,26 +1,74 @@
 module Paid
   class Transaction < APIResource
-    # attributes :id and :object inherited from APIResource
-    attribute :amount
-    attribute :description
-    attribute :customer
-    attribute :paid
-    attribute :paid_on
-    attribute :properties
-    attribute :invoice
+    attr_reader :id
+    attr_reader :object
+    attr_accessor :amount
+    attr_accessor :description
+    attr_accessor :customer
+    attr_accessor :paid
+    attr_accessor :paid_on
+    attr_accessor :properties
+    attr_accessor :invoice
+    attr_accessor :refunds
 
-    api_class_method :create, :post
-    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
-    api_class_method :all, :get, :constructor => APIList.constructor(Transaction)
+    def refresh_from(json={}, api_method=nil)
+      super(json, api_method)
+      json = { :id => json } unless json.is_a?(Hash)
+      @refunds = RefundList.new(json[:refunds], nil, id)
+      self
+    end
+
+    def self.all(params={}, headers={})
+      method = APIMethod.new(:get, "/transactions", params, headers, self)
+      APIList.new(self, method.execute, method)
+    end
 
-    api_instance_method :save, :put, :default_params => changed_lambda
-    api_instance_method :mark_as_paid, :post, ":path/mark_as_paid"
+    def self.retrieve(id, params={}, headers={})
+      params = ParamsBuilder.merge(params, {
+        :id => id
+      })
+      method = APIMethod.new(:get, "/transactions/:id", params, headers, self)
+      self.new(method.execute, method)
+    end
+
+    def self.create(params={}, headers={})
+      method = APIMethod.new(:post, "/transactions", params, headers, self)
+      self.new(method.execute, method)
+    end
 
+    def refresh(params={}, headers={})
+      method = APIMethod.new(:get, "/transactions/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
+
+    def save(params={}, headers={})
+      params = ParamsBuilder.merge(params, changed_api_attributes)
+      method = APIMethod.new(:put, "/transactions/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
+
+    def delete(params={}, headers={})
+      method = APIMethod.new(:delete, "/transactions/:id", params, headers, self)
+      self.refresh_from(method.execute, method)
+    end
 
-    def self.path
-      "/v0/transactions"
+    def mark_as_paid(params={}, headers={})
+      method = APIMethod.new(:post, "/transactions/:id/mark_as_paid", params, headers, self)
+      self.refresh_from(method.execute, method)
     end
 
-    APIClass.register_subclass(self, "transaction")
+    APIResource.register_api_subclass(self, "transaction")
+    @api_attributes = {
+      :id => { :readonly => true },
+      :object => { :readonly => true },
+      :amount => nil,
+      :description => nil,
+      :customer => nil,
+      :paid => nil,
+      :paid_on => nil,
+      :properties => nil,
+      :invoice => nil,
+      :refunds => { :constructor => :RefundList, :provide_parent => true }
+    }
   end
 end