paymill_ruby 1.0.2

data/lib/paymill/models/client.rb

@@ -0,0 +1,24 @@
+module Paymill
+  class Client < Base
+    include Restful::Update
+    include Restful::Delete
+
+    attr_accessor :email, :description
+    attr_reader :payments, :subscriptions
+
+    protected
+    def self.create_with?( incoming_arguments )
+      return false if mandatory_arguments.select { |a| incoming_arguments.include? a }.size < mandatory_arguments.size
+      allowed_arguments.size == ( allowed_arguments | incoming_arguments ).size
+    end
+
+    def self.allowed_arguments
+      [:email, :description]
+    end
+
+    def self.mandatory_arguments
+      []
+    end
+
+  end
+end

data/lib/paymill/models/fee.rb

@@ -0,0 +1,14 @@
+module Paymill
+  class Fee
+
+    attr_accessor :type, :application, :payment, :amount, :currency, :billed_at
+
+    def initialize( json )
+      json.each_pair do |key, value|
+        instance_variable_set( "@#{key}", ( Integer( value ) rescue value ) )
+      end
+      @billed_at &&= Time.at( @billed_at )
+    end
+
+  end
+end

data/lib/paymill/models/invoice.rb

@@ -0,0 +1,18 @@
+module Paymill
+  class Invoice
+
+    attr_accessor :invoice_nr, :netto, :brutto, :status, :period_from, :last_reminder_date,
+                  :period_until, :currency, :vat_rate, :billing_date, :invoice_type
+
+    def initialize( json )
+      json.each_pair do |key, value|
+        instance_variable_set( "@#{key}", ( Integer( value ) rescue value ) )
+      end
+      @period_from &&= Time.at( @period_from )
+      @period_until &&= Time.at( @period_until )
+      @billing_date &&= Time.at( @billing_date )
+      @last_reminder_date &&= Time.at( @last_reminder_date )
+    end
+
+  end
+end

data/lib/paymill/models/merchant.rb

@@ -0,0 +1,21 @@
+module Paymill
+  class Merchant
+
+    attr_accessor :identifier_key, :email, :locale, :country, :currencies, :methods
+
+    def initialize( json )
+      deserialize( json )
+    end
+
+    private
+    def deserialize( json )
+      case value.class.name
+      when 'Array'
+        instance_variable_set( "@#{key}s", value.map { |e| e } )
+      else
+        instance_variable_set( "@#{key}", (Integer( value ) rescue value) )
+      end
+    end
+
+  end
+end

data/lib/paymill/models/offer.rb

@@ -0,0 +1,27 @@
+module Paymill
+  class Offer < Base
+    include Restful::Update
+    include Restful::Delete
+
+    attr_reader :subscription_count
+    attr_accessor :name, :amount, :currency, :interval, :trial_period_days
+
+    def delete_with_subscriptions
+      delete( remove_with_subscriptions: true )
+    end
+
+    def delete_without_subscriptions
+      delete( remove_with_subscriptions: false )
+    end
+
+    protected
+    def self.allowed_arguments
+      [:amount, :currency, :interval, :name, :trial_period_days]
+    end
+
+    def self.mandatory_arguments
+      [:amount, :currency, :interval, :name]
+    end
+
+  end
+end

data/lib/paymill/models/payment.rb

@@ -0,0 +1,20 @@
+module Paymill
+  class Payment < Base
+    include Restful::Delete
+
+    attr_reader :type, :client, :card_type, :is_recurring, :is_usable_for_preauthorization,
+                :country, :expire_month, :expire_year, :card_holder, :last4,
+                :code, :holder, :account,
+                :iban, :bic
+
+    protected
+    def self.allowed_arguments
+      [:token, :client]
+    end
+
+    def self.mandatory_arguments
+      [:token]
+    end
+
+  end
+end

data/lib/paymill/models/payment_method.rb

@@ -0,0 +1,18 @@
+module Paymill
+  class PaymentMethod
+
+    attr_accessor :type, :currency, :acquirer
+
+    def initialize( json )
+      deserialize( json )
+    end
+
+    private
+    def deserialize( json )
+      json.each_pair do |key, value|
+        instance_variable_set( "@#{key}", ( Integer( value ) rescue value ) )
+      end
+    end
+
+  end
+end

data/lib/paymill/models/preauthorization.rb

@@ -0,0 +1,25 @@
+module Paymill
+  class Preauthorization < Base
+    include Restful::Delete
+
+    attr_reader :amount, :currency, :description, :status, :livemode, :payment, :client, :transaction
+
+    protected
+    def self.create_with?( incoming_arguments )
+      raise ArgumentError unless incoming_arguments.any? { |e| mutual_excluded_arguments.include? e } && ( incoming_arguments & mutual_excluded_arguments ).size == 1
+      super( incoming_arguments - mutual_excluded_arguments )
+    end
+
+    def self.mandatory_arguments
+      [:amount, :currency]
+    end
+
+    def self.allowed_arguments
+      [:amount, :currency, :description]
+    end
+
+    def self.mutual_excluded_arguments
+      [:token, :payment]
+    end
+  end
+end

data/lib/paymill/models/refund.rb

@@ -0,0 +1,22 @@
+module Paymill
+  class Refund < Base
+
+    attr_reader :amount, :description, :transaction, :status, :livemode, :response_code
+
+    def self.create( transaction, attributes = {} )
+      raise ArgumentError unless create_with?( attributes.keys )
+      response = Paymill.request( Http.post( name.demodulize.tableize, transaction.id, Restful.normalize( attributes ) ) )
+      new( response['data'] )
+    end
+
+    protected
+    def self.mandatory_arguments
+      [:amount]
+    end
+
+    def self.allowed_arguments
+      [:amount, :description]
+    end
+
+  end
+end

data/lib/paymill/models/shopping_cart_item.rb

@@ -0,0 +1,13 @@
+module Paymill
+  class ShoppingCartItem
+    attr_accessor :name, :amount, :quantity, :item_number, :url, :description
+
+    def initialize( arguments = {} )
+      arguments.each do |key, value|
+        raise ArgumentError.new( "parameter #{key} is not allowed" ) unless ShoppingCartItem.instance_methods( false ).include? key
+        instance_variable_set( "@#{key}", ( Integer( value ) rescue value ) )
+      end
+    end
+
+  end
+end

data/lib/paymill/models/subscription.rb

@@ -0,0 +1,143 @@
+module Paymill
+  class Subscription < Base
+    include Restful::Update
+    include Restful::Delete
+
+    attr_reader :livemode, :temp_amount, :trial_start, :end_of_period, :next_capture_at, :canceled_at, :currency,
+                :is_canceled, :is_deleted, :status, :client, :interval, :payment, :name, :mandate_reference
+    attr_accessor :amount, :offer, :trial_end, :period_of_validity
+
+    def currency=( currency )
+      @offer = nil
+      @amount = nil
+      @currency = currency
+    end
+
+    def name=( name )
+      @offer = nil
+      @amount = nil
+      @name = name
+    end
+
+    def interval=( interval )
+      @offer = nil
+      @amount = nil
+      @interval = interval
+    end
+
+    def payment=( payment )
+      @offer = nil
+      @amount = nil
+      @payment = payment
+    end
+
+    def update_amount_once( amount )
+      update_amount( amount, 0 )
+    end
+
+    def update_amount_permanently( amount )
+      update_amount( amount, 1 )
+    end
+
+    def update_offer_without_changes( offer )
+      update_offer( offer, 0 )
+    end
+
+    def update_offer_with_refund( offer )
+      update_offer( offer, 1 )
+    end
+
+    def update_offer_with_refund_and_capture_date( offer )
+      update_offer( offer, 1 )
+    end
+
+    def stop_trial_period()
+      @offer = nil
+      @amount = nil
+      @trial_end = nil
+      update( trial_end: false )
+    end
+
+    def unlimit()
+      @offer = nil
+      @amount = nil
+      @period_of_validity = 'remove'
+      update()
+    end
+
+    def limit( limit )
+      @offer = nil
+      @amount = nil
+      @period_of_validity = limit
+      update()
+    end
+
+    def pause()
+      @offer = nil
+      @amount = nil
+      update( pause: true )
+    end
+
+    def play()
+      @offer = nil
+      @amount = nil
+      update( pause: false )
+    end
+
+    def cancel()
+      delete( remove: false )
+    end
+
+    def remove()
+      delete( remove: true )
+    end
+
+    protected
+    def self.create_with?( incoming_arguments )
+      raise ArgumentError unless incoming_arguments.include?( :offer ) || (mutual_excluded_arguments.last - incoming_arguments).empty?
+      super( incoming_arguments - mutual_excluded_arguments.flatten )
+    end
+
+    def self.mandatory_arguments
+      [:payment]
+    end
+
+    def self.allowed_arguments
+      [:offer, :payment, :client, :amount, :currency, :interval, :name, :period_of_validity, :start_at, :mandate_reference]
+    end
+
+    def parse_timestamps
+      @trial_end        &&= Time.at( @trial_end )
+      @canceled_at      &&= Time.at( @canceled_at )
+      @trial_start      &&= Time.at( @trial_start)
+      @canceled_at      &&= Time.at( @canceled_at )
+      @end_of_period    &&= Time.at( @end_of_period )
+      @next_capture_at  &&= Time.at( @next_capture_at )
+      super
+    end
+
+    def self.mutual_excluded_arguments
+      [[:offer], [:amount, :currency, :interval]]
+    end
+
+    private
+    def update_amount( amount, flag)
+      raise ArgumentError( 'amount_change_type should be 0 or 1' ) unless [0, 1].include?( flag )
+      @offer = nil
+      @amount = amount
+      update( amount_change_type: flag )
+    end
+
+    def update_offer( offer, flag )
+      raise ArgumentError( 'offer_change_type should be between 0 and 2' ) unless (0..2).include?( flag )
+      @currency = nil
+      @name = nil
+      @interval = nil
+      @amount = nil
+      @payment = nil
+      @offer = offer
+      update( offer_change_type: 1 )
+    end
+
+  end
+end

data/lib/paymill/models/subscription_count.rb

@@ -0,0 +1,18 @@
+module Paymill
+  class SubscriptionCount
+
+    attr_accessor :active, :inactive
+
+    def initialize( json )
+      deserialize( json )
+    end
+
+    private
+    def deserialize( json )
+      json.each_pair do |key, value|
+        instance_variable_set( "@#{key}", ( Integer( value ) rescue value ) )
+      end
+    end
+
+  end
+end

data/lib/paymill/models/transaction.rb

@@ -0,0 +1,27 @@
+module Paymill
+  class Transaction < Base
+    include Restful::Update
+
+    attr_accessor :description
+    attr_reader :amount, :client, :currency, :origin_amount, :status, :livemode, :refunds,
+                :response_code, :is_fraud, :short_id, :fees, :invoices, :payment, :preauthorization, :mandate_reference
+
+    protected
+    def self.create_with?( incoming_arguments )
+      raise ArgumentError unless incoming_arguments.any? { |e| mutual_excluded_arguments.include? e } && ( incoming_arguments & mutual_excluded_arguments ).size == 1
+      super( incoming_arguments - mutual_excluded_arguments )
+    end
+
+    def self.mandatory_arguments
+      [:amount, :currency]
+    end
+
+    def self.allowed_arguments
+      [:amount, :client, :currency, :description, :preauthorization, :fee_amount, :fee_payment, :fee_currency, :mandate_reference]
+    end
+
+    def self.mutual_excluded_arguments
+      [:token, :payment, :preauthorization]
+    end
+  end
+end

data/lib/paymill/models/webhook.rb

@@ -0,0 +1,37 @@
+module Paymill
+  class Webhook < Base
+    include Restful::Update
+    include Restful::Delete
+
+    attr_reader :url, :email, :livemode
+    attr_accessor :event_types, :active
+
+    def email=( email )
+      @url = nil
+      @email = email
+    end
+
+    def url=( url )
+      @url = url
+      @email = nil
+    end
+
+    protected
+    def self.create_with?( incoming_arguments )
+      raise ArgumentError unless incoming_arguments.any? { |e| mutual_excluded_arguments.include? e } && ( incoming_arguments & mutual_excluded_arguments ).size == 1
+      super( incoming_arguments - mutual_excluded_arguments )
+    end
+
+    def self.mandatory_arguments
+      [:event_types]
+    end
+
+    def self.allowed_arguments
+      [:event_types, :active]
+    end
+
+    def self.mutual_excluded_arguments
+      [:email, :url]
+    end
+  end
+end