paid 0.1.0 → 1.0.0

data/lib/paid/customer.rb

@@ -1,31 +1,46 @@
 module Paid
   class Customer < APIResource
-    include Paid::APIOperations::Create
-    include Paid::APIOperations::Delete
-    include Paid::APIOperations::Update
-    include Paid::APIOperations::List
+    # attributes :id and :object inherited from APIResource
+    attribute :name
+    attribute :email
+    attribute :description
+    attribute :external_id
+    attribute :aliases, APIList
+    attribute :phone
+    attribute :address_line1
+    attribute :address_line2
+    attribute :address_city
+    attribute :address_state
+    attribute :address_zip
+    attribute :allow_ach
+    attribute :allow_wire
+    attribute :allow_check
+    attribute :allow_credit_card
+    attribute :terms
+    attribute :billing_type
+    attribute :billing_cycle
+    attribute :stripe_customer_id
 
-    def generate_invoice(params={}, opts={})
-      api_key, headers = Util.parse_opts(opts)
-      response, api_key = Paid.request(
-        :post, generate_invoice_url, api_key || @api_key, params, headers)
-      # refresh_from(response, api_key)
-      refresh_from({ :invoice => response }, api_key, true)
-      invoice
-    end
+    api_class_method :all, :get, :constructor => APIList.constructor(Customer)
+    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+    api_class_method :create, :post
+    api_class_method :by_alias, :get, "/v0/aliases/:alias", :arguments => [:alias]
+    api_class_method :by_external_id, :get, ":path/by_external_id/:external_id", :arguments => [:external_id]
 
-    def invoices
-      Invoice.all({ :customer => id }, @api_key)
-    end
+    api_instance_method :save, :put, :default_params => :changed_attributes
+    api_instance_method :generate_invoice, :post, ":path/generate_invoice", :constructor => Invoice
 
-    def transactions
-      Transaction.all({ :customer => id }, @api_key)
-    end
+    api_instance_method :invoices, :get, Invoice.path, :default_params => :customer_id_hash, :constructor => APIList.constructor(Invoice)
+    api_instance_method :transactions, :get, Transaction.path, :default_params => :customer_id_hash, :constructor => APIList.constructor(Transaction)
 
-    private
+    def self.path
+      "/v0/customers"
+    end
 
-    def generate_invoice_url
-      api_url + '/generate_invoice'
+    def customer_id_hash
+      { :customer => self.id }
     end
+
+    APIClass.register_subclass(self, "customer")
   end
 end

data/lib/paid/errors/api_error.rb

@@ -1,4 +1,10 @@
 module Paid
   class APIError < PaidError
+
+    def self.generic(rcode, rbody)
+      self.new("Invalid response object from API: #{rbody.inspect} " +
+               "(HTTP response code was #{rcode})", rcode, rbody)
+    end
+
   end
 end

data/lib/paid/event.rb

@@ -1,5 +1,26 @@
 module Paid
   class Event < APIResource
-    include Paid::APIOperations::List
+    class Data
+      def self.construct(json={})
+        return nil if json.nil?
+        klass = APIClass.subclass_fetch(json[:object])
+        klass.construct(json)
+      end
+    end
+
+    # attributes :id and :object inherited from APIResource
+    attribute :created_at
+    attribute :type
+    attribute :data, Data
+
+    api_class_method :all, :get, :constructor => APIList.constructor(Event)
+    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+
+
+    def self.path
+      "/v0/events"
+    end
+
+    APIClass.register_subclass(self, "event")
   end
 end

data/lib/paid/invoice.rb

@@ -1,31 +1,26 @@
 module Paid
   class Invoice < APIResource
-    include Paid::APIOperations::List
-    include Paid::APIOperations::Update
-    include Paid::APIOperations::Create
+    # 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
 
-    def issue(params={}, opts={})
-      api_key, headers = Util.parse_opts(opts)
-      response, api_key = Paid.request(
-        :post, issue_url, api_key || @api_key, params, headers)
-      refresh_from(response, api_key)
-    end
+    api_class_method :all, :get, :constructor => APIList.constructor(Invoice)
+    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+    api_class_method :create, :post
 
-    def mark_as_paid(params={}, opts={})
-      api_key, headers = Util.parse_opts(opts)
-      response, api_key = Paid.request(
-        :post, mark_as_paid_url, api_key || @api_key, params, headers)
-      refresh_from(response, api_key)
-    end
+    api_instance_method :issue, :post, ":path/issue"
+    api_instance_method :mark_as_paid, :post, ":path/mark_as_paid" # requires :via in params
 
-    private
 
-    def issue_url
-      api_url + '/issue'
+    def self.path
+      "/v0/invoices"
     end
 
-    def mark_as_paid_url
-      api_url + '/mark_as_paid'
-    end
+    APIClass.register_subclass(self, "invoice")
   end
 end

data/lib/paid/plan.rb

@@ -1,6 +1,22 @@
 module Paid
   class Plan < APIResource
-    include Paid::APIOperations::List
-    include Paid::APIOperations::Create
+
+    # attributes :id and :object inherited from APIResource
+    attribute :name
+    attribute :description
+    attribute :interval
+    attribute :interval_count
+    attribute :amount
+    attribute :created_at
+
+    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.path
+      "/v0/plans"
+    end
+
+    APIClass.register_subclass(self, "plan")
   end
 end

data/lib/paid/subscription.rb

@@ -1,19 +1,25 @@
 module Paid
   class Subscription < APIResource
-    include Paid::APIOperations::List
-    include Paid::APIOperations::Create
+    # 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
 
-    def cancel(params={}, opts={})
-      api_key, headers = Util.parse_opts(opts)
-      response, api_key = Paid.request(
-        :post, cancel_url, api_key || @api_key, params, headers)
-      refresh_from(response, api_key)
-    end
+    api_class_method :all, :get, :constructor => APIList.constructor(Subscription)
+    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+    api_class_method :create, :post
 
-    private
+    api_instance_method :cancel, :post, ":path/cancel"
 
-    def cancel_url
-      api_url + '/cancel'
+    def self.path
+      "/v0/subscriptions"
     end
+
+    APIClass.register_subclass(self, "subscription")
   end
 end

data/lib/paid/transaction.rb

@@ -1,20 +1,27 @@
 module Paid
   class Transaction < APIResource
-    include Paid::APIOperations::List
-    include Paid::APIOperations::Create
-    include Paid::APIOperations::Update
+    # attributes :id and :object inherited from APIResource
+    attribute :amount # req for create
+    attribute :description # req for create
+    attribute :customer # optional for create
+    attribute :alias # optional for create
+    attribute :paid # invalid for create
+    attribute :paid_on # optional for create
+    attribute :properties # optional for create
+    attribute :invoice # invalid for create
 
-    def mark_as_paid(params={}, opts={})
-      api_key, headers = Util.parse_opts(opts)
-      response, api_key = Paid.request(
-        :post, mark_as_paid_url, api_key || @api_key, params, headers)
-      refresh_from(response, api_key)
-    end
+    api_class_method :create, :post
+    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+    api_class_method :all, :get, :constructor => APIList.constructor(Transaction)
+
+    api_instance_method :save, :put, :default_params => changed_lambda
+    api_instance_method :mark_as_paid, :post, ":path/mark_as_paid"
 
-    private
 
-    def mark_as_paid_url
-      api_url + '/mark_as_paid'
+    def self.path
+      "/v0/transactions"
     end
+
+    APIClass.register_subclass(self, "transaction")
   end
 end

data/lib/paid/util.rb

@@ -1,130 +1,77 @@
 module Paid
   module Util
-    def self.objects_to_ids(h)
-      case h
-      when APIResource
-        h.id
-      when Hash
-        res = {}
-        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
-        res
-      when Array
-        h.map { |v| objects_to_ids(v) }
-      else
-        h
-      end
-    end
-
-    def self.object_classes
-      @object_classes ||= {
-        # data structures
-        'list' => ListObject,
-
-        # business objects
-        'transaction' => Transaction,
-        'customer' => Customer,
-        'event' => Event,
-        'invoice' => Invoice,
-        'alias' => Alias,
-        'plan' => Plan,
-        'subscription' => Subscription
-      }
-    end
 
-    def self.convert_to_paid_object(resp, api_key)
-      case resp
-      when Array
-        resp.map { |i| convert_to_paid_object(i, api_key) }
-      when Hash
-        # Try converting to a known object class.  If none available, fall back to generic PaidObject
-        object_classes.fetch(resp[:object], PaidObject).construct_from(resp, api_key)
+    def self.query_string(params)
+      if params && params.any?
+        return query_array(params).join('&')
       else
-        resp
+        return ""
       end
     end
 
-    def self.file_readable(file)
-      # This is nominally equivalent to File.readable?, but that can
-      # report incorrect results on some more oddball filesystems
-      # (such as AFS)
-      begin
-        File.open(file) { |f| }
-      rescue
-        false
-      else
-        true
-      end
-    end
-
-    def self.symbolize_names(object)
-      case object
-      when Hash
-        new_hash = {}
-        object.each do |key, value|
-          key = (key.to_sym rescue key) || key
-          new_hash[key] = symbolize_names(value)
+    # 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
-        new_hash
-      when Array
-        object.map { |value| symbolize_names(value) }
-      else
-        object
-      end
-    end
-
-    def self.url_encode(key)
-      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
-    end
+        key_suffix = escape(key)
+        full_key = key_prefix ? "#{key_prefix}[#{key_suffix}]" : key_suffix
 
-    def self.flatten_params(params, parent_key=nil)
-      result = []
-      params.each do |key, value|
-        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
-        if value.is_a?(Hash)
-          result += flatten_params(value, calculated_key)
-        elsif value.is_a?(Array)
-          result += flatten_params_array(value, calculated_key)
+        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
-          result << [calculated_key, value]
+          # Handles the base case with just key and value:
+          #   { :a => "value" } => ["a=value"]
+          ret << "#{full_key}=#{escape(value)}"
         end
       end
-      result
+      ret
     end
 
-    def self.flatten_params_array(value, calculated_key)
-      result = []
-      value.each do |elem|
-        if elem.is_a?(Hash)
-          result += flatten_params(elem, calculated_key)
-        elsif elem.is_a?(Array)
-          result += flatten_params_array(elem, calculated_key)
-        else
-          result << ["#{calculated_key}[]", elem]
+    def self.escape(val)
+      URI.escape(val.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def self.symbolize_keys(obj)
+      if obj.is_a?(Hash)
+        ret = {}
+        obj.each do |key, value|
+          ret[(key.to_sym rescue key) || key] = symbolize_keys(value)
         end
+        return ret
+      elsif obj.is_a?(Array)
+        return obj.map{ |value| symbolize_keys(value) }
+      else
+        return obj
       end
-      result
     end
 
-    # The secondary opts argument can either be a string or hash
-    # Turn this value into an api_key and a set of headers
-    def self.parse_opts(opts)
-      case opts
-      when NilClass
-        return nil, {}
-      when String
-        return opts, {}
-      when Hash
-        headers = {}
-        if opts[:idempotency_key]
-          headers[:idempotency_key] = opts[:idempotency_key]
+    def self.sorta_deep_clone(json)
+      if json.is_a?(Hash)
+        ret = {}
+        json.each do |k, v|
+          ret[k] = sorta_deep_clone(v)
         end
-        if opts[:paid_account]
-          headers[:paid_account] = opts[:paid_account]
-        end
-        return opts[:api_key], headers
+        ret
+      elsif json.is_a?(Array)
+        json.map{ |j| sorta_deep_clone(j) }
       else
-        raise TypeError.new("parse_opts expects a string or a hash")
+        begin
+          json.dup
+        rescue
+          json
+        end
       end
     end
+
   end
 end

data/lib/paid/version.rb

@@ -1,3 +1,3 @@
 module Paid
-  VERSION = "0.1.0"
+  VERSION = File.open(File.expand_path("../../../VERSION", __FILE__)).read()
 end