ruby_psigate 0.7

data/lib/ruby_psigate/account.rb

@@ -0,0 +1,152 @@
+module RubyPsigate
+  
+  class InvalidRecurringCharge < RubyPsigateError; end
+  
+  class Account
+    
+    include AccountMethods
+    include CreditCardMethods
+    
+    # List of actions you can perform on an account and their associated constant codes
+    ACTIONS = {
+      :account => {
+        :summary => "AMA00",
+        :details => "AMA05",
+        :register => "AMA01",
+        :update => "AMA02",
+        :enable => "AMA08",
+        :disable => "AMA09"
+      },
+      :credit_card => {
+        :add => "AMA11",
+        :delete => "AMA14",
+        :enable => "AMA18",
+        :disable => "AMA19"
+      },
+      :charges => {
+        :summary => "RBC00",
+        :add => "RBC01",
+        :update => "RBC02",
+        :delete => "RBC04",
+        :details => "RBC05",
+        :enable => "RBC08",
+        :disable => "RBC09",
+        :immediate => "RBC99"
+      }
+    }
+    
+    def self.action_reverse_lookup(code)
+      result = nil
+      result_first = nil
+      result_second = nil
+      ACTIONS.each_pair do |section, actions|
+        break if result_second
+        result_second = actions.select { |k,v| v == code }
+        if result_second
+          result_first = section
+          result_second = result_second.keys[0]
+        end
+      end
+      result = "#{result_first}_#{result_second}".downcase.to_sym
+    end
+    
+    # include RubyPsigate::HashVariables
+    # hashable :account_register, %w( AccountID )
+    # hashable :account_update, %w( Condition Update )
+    
+    attr_writer :action
+    attr_reader :address, :rbcharge
+    attr_accessor :account_id, :comments, :email, :serial_no, :store_id
+    
+    # For hasahable
+    alias_method :accountid, :account_id
+    
+    def to_hash(type=nil)
+      type = self.class.action_reverse_lookup(type)
+      result = {}
+      result = process_hash(result, type)
+      result
+    end
+    
+    def action
+      ACTIONS[@action.first[0]][@action.first[1]]
+    end
+    
+    def process_hash(result, type)
+      result.merge!({:Action => action})
+            
+      if type == :account_register
+        result[:Account] = Hash.new
+        result[:Account].merge!({:AccountID => nil})
+        result[:Account].merge!(address.to_hash(:billing)) unless address.nil?
+        result[:Account].merge!({ :CardInfo => cc.to_hash(:card_info) })
+      end
+      
+      if type == :account_update
+        result.merge!({:Condition => { :AccountID => account_id }})
+        result[:Update] = {}
+        result[:Update].merge!(address.to_hash(:billing)) unless address.nil?
+        result[:Update].merge!(:Email => email) unless email.nil?
+        result[:Update].merge!(:Comments => comments) unless comments.nil?
+      end
+      
+      if type == :account_details || type == :account_enable || type == :account_disable
+        result.merge!({:Condition => { :AccountID => account_id }})
+      end
+
+      if type == :credit_card_add
+        result[:Account] = Hash.new
+        result[:Account].merge!({ :AccountID => account_id })
+        result[:Account].merge!({:CardInfo => cc.to_hash(:card_info)})
+      end
+      
+      if type == :credit_card_delete || type == :credit_card_enable || type == :credit_card_disable
+        result.merge!({:Condition => { :AccountID => account_id, :SerialNo => serial_no }})
+      end
+      
+      if type == :charges_summary
+        result[:Condition] = Hash.new
+        result.merge!({:Condition => { :AccountID => account_id, :StoreID => store_id }})
+        result[:Condition].merge!(rbcharge.to_hash)
+      end
+      
+      if type == :charges_add || type == :charges_immediate
+        result[:Charge] = Hash.new
+        result[:Charge].merge!({:AccountID => account_id, :SerialNo => serial_no})
+        result[:Charge].merge!(rbcharge.to_hash)
+      end
+      
+      if type == :charges_update
+        result.merge!({:Condition => { :RBCID => rbcharge.rbcid }})
+        result.merge!({:Update => { :RBTrigger => rbcharge.rbtrigger }})
+      end
+      
+      if type == :charges_delete || type == :charges_details || type == :charges_enable || type == :charges_disable
+        result.merge!({:Condition => { :RBCID => rbcharge.rbcid }})
+      end
+      
+      result
+    end
+    
+    # Method used to describe the query to cross reference the account on local and Psigate's servers
+    def condition
+      # AccountID, RBCID, RBTrigger, Type, InvoiceNo, Status, SerialNo
+      { :AccountID => "123" }
+    end
+    
+    def update
+      { :Shit => "Fuck" }
+    end
+    
+    def address=(input_address)
+      raise InvalidAddress unless input_address.is_a?(Address)
+      @address = input_address
+    end
+    
+    def rbcharge=(charge)
+      raise InvalidRecurringCharge unless charge.is_a?(RecurringCharge)
+      @rbcharge = charge
+    end
+    
+  end
+end

data/lib/ruby_psigate/account_manager_api.rb

@@ -0,0 +1,137 @@
+module RubyPsigate
+  class AccountManagerApi
+  
+    include RubyPsigate::Utils
+    
+    TEST_URL = 'https://dev.psigate.com:8645/Messenger/AMMessenger'
+    LIVE_URL = nil # TODO
+    
+    attr_reader :action
+    attr_accessor :test
+
+    def initialize(options = {})
+      requires!(options, :cid, :login, :password)
+      @options = options
+      @live_url = @options[:live_url]
+    end
+    
+    def test?
+      @live_url.blank?
+    end
+  
+    # Registers a new account
+    #
+    # Options (* asterisk denotes required)
+    # => :name*
+    # => :company
+    # => :address1*
+    # => :address2
+    # => :city*
+    # => :province*
+    # => :postal_code*
+    # => :country*
+    # => :phone*
+    # => :fax
+    # => :email*
+    # => :comments
+    # => :card_holder*
+    # => :card_number*
+    # => :card_exp_month*
+    # => :card_exp_year*
+    #
+    def register(options = {})
+      requires!(options, 
+        :name, 
+        :address1, 
+        :city, 
+        :province, 
+        :postal_code, 
+        :country, 
+        :phone, 
+        :email, 
+        :card_holder, 
+        :card_number, 
+        :card_exp_month, 
+        :card_exp_year
+      )
+      @register_options = options
+      @action = "AMA01"
+    end
+  
+    # Updates an already registered account
+    def update(options = {})
+      @action = "AMA02"
+    end
+  
+    # Retrieves a summary of a registered account
+    def retrieve_summary(options = {})
+      requires!(options, :account_id)
+      @options.update(options)
+      @action = "AMA00"
+      
+      @params = {
+        :Request => {
+          :CID        => @options[:cid],
+          :UserID     => @options[:login],
+          :Password   => @options[:password],
+          :Action     => @action,
+          :Condition  => {
+            :AccountID  => @options[:account_id]
+          }
+        }
+      }
+      
+      @data         = data_to_be_posted(@params)
+      raw_response  = post_to_server(@data)
+      response      = Response.new(successful?(raw_response), message_from(raw_response), raw_response, :test => test?)
+    end
+  
+    def enable(options = {})
+      @action = "AMA08"
+    end
+  
+    def disable(options = {})
+      @action = "AMA09"
+    end
+  
+    def charge(options = {})
+    
+    end
+  
+    private
+    
+    def data_to_be_posted(params)
+      data = Serializer.new(params)
+      data.to_xml      
+    end
+    
+    def post_to_server(data)
+      endpoint = test? ? TEST_URL : @live_url
+      psigate = ActiveMerchant::Connection.new(endpoint)
+      
+      # Some configurations for ActiveMerchant::Connection instance object
+      psigate.verify_peer = true
+      psigate.retry_safe = false
+      psigate.open_timeout = 60
+      psigate.read_timeout = 60
+      
+      # Since all of Psigate's requests are POST requests, we will use only the following
+      psigate.request(:post, data)
+    end
+    
+    def successful?(response)
+      response[:approved] == "APPROVED"
+    end
+    
+    def message_from(response)
+      if response[:approved] == "APPROVED"
+        return SUCCESS_MESSAGE
+      else
+        return FAILURE_MESSAGE if response[:errmsg].blank?
+        return response[:errmsg].gsub(/[^\w]/, ' ').split.join(" ").capitalize
+      end
+    end
+    
+      
+  end
+end

data/lib/ruby_psigate/account_methods.rb

@@ -0,0 +1,5 @@
+module RubyPsigate
+  module AccountMethods
+    
+  end
+end

data/lib/ruby_psigate/address.rb

@@ -0,0 +1,54 @@
+module RubyPsigate
+  # DOC - TODO
+  class Address
+
+    include RubyPsigate::HashVariables
+    
+    hashable :billing, %w( Bname Bcompany Baddress1 Baddress2 Bcity Bprovince Bpostalcode Bcountry Phone Fax )
+    hashable :shipping, %w( Sname Scompany Saddress1 Saddress2 Scity Sprovince Spostalcode Scountry )
+        
+    attr_accessor :firstname, :lastname, :line1, :line2, :city, :state, :country, :zipcode, :telephone, :fax, :company
+
+    alias_method :province, :state
+    alias_method :province=, :state=
+
+    alias_method :postalcode, :zipcode
+    alias_method :postalcode=, :zipcode=
+    
+    alias_method :address1, :line1
+    alias_method :address2, :line2
+    
+    alias_method :phone, :telephone
+    
+    def name
+      "#{firstname} #{lastname}".strip
+    end
+    
+    def to_hash(type = nil)
+      result = super
+      result = result.delete_if { |key, value| value.nil? }  # Delete empty hash values
+      result
+    end
+
+    # For billing
+    alias_method :bname, :name
+    alias_method :bcompany, :company
+    alias_method :baddress1, :address1
+    alias_method :baddress2, :address2
+    alias_method :bcity, :city
+    alias_method :bprovince, :province
+    alias_method :bpostalcode, :postalcode
+    alias_method :bcountry, :country
+    
+    # For shipping
+    alias_method :sname, :name
+    alias_method :scompany, :company
+    alias_method :saddress1, :address1
+    alias_method :saddress2, :address2
+    alias_method :scity, :city
+    alias_method :sprovince, :province
+    alias_method :spostalcode, :postalcode
+    alias_method :scountry, :country
+    
+  end
+end

data/lib/ruby_psigate/connection.rb

@@ -0,0 +1,96 @@
+module RubyPsigate
+    
+  class Connection
+    
+    MAX_RETRIES = 3
+    RETRY_SAFE = true
+    
+    # => Values in seconds
+    READ_TIMEOUT = 60
+    OPEN_TIMEOUT = 30
+    VERIFY_PEER = true
+    
+    def initialize(endpoint)
+      @endpoint = endpoint.is_a?(URI) ? endpoint : URI.parse(endpoint)
+      @retry_safe   = RETRY_SAFE
+      @read_timeout = READ_TIMEOUT
+      @open_timeout = OPEN_TIMEOUT
+      @verify_peer  = VERIFY_PEER
+    end
+    
+    attr_reader :endpoint
+    attr_accessor :retry_safe
+    attr_accessor :read_timeout
+    attr_accessor :open_timeout
+    attr_accessor :verify_peer
+    
+    def post(params)
+      retry_exceptions do
+        begin
+
+          uri = @endpoint
+          psigate = Net::HTTP.new(uri.host, uri.port)
+
+          # Configure Timeouts
+          psigate.open_timeout = open_timeout
+          psigate.read_timeout = read_timeout 
+
+          # Configure SSL
+          psigate.use_ssl = true
+          if verify_peer
+            psigate.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            psigate.ca_file     = ca_file
+          else
+            psigate.verify_mode = OpenSSL::SSL::VERIFY_NONE
+          end
+
+          raw_response = psigate.post(uri.path, params)
+          response = handle_response(raw_response)
+          response
+        rescue EOFError => e
+          raise ConnectionError, "The remote server dropped the connection"
+        rescue Errno::ECONNRESET => e
+          raise ConnectionError, "The remote server reset the connection"
+        rescue Errno::ECONNREFUSED => e
+          raise RetriableConnectionError, "The remote server refused the connection"
+        rescue Timeout::Error, Errno::ETIMEDOUT => e
+          raise ConnectionError, "The connection to the remote server timed out"
+          
+        end # begin
+      end # retry_exceptions
+    end
+    
+    private
+    
+    def ca_file
+      ca_file = File.dirname(__FILE__) + '/../certs/cacert.pem'
+      raise CertVerificationFileMissingError unless File.exists?(ca_file)
+      ca_file
+    end
+    
+    def handle_response(raw_response)
+      case raw_response.code.to_i
+      when 200..300
+        raw_response.body
+      else
+        raise ResponseError.new(raw_response)
+      end
+    end
+    
+    def retry_exceptions(&block)
+      retries = MAX_RETRIES
+      begin
+        yield
+      rescue RetriableConnectionError => e
+        retries -= 1
+        retry unless retries.zero?
+        raise ConnectionError, e.message
+      rescue ConnectionError
+        retries -= 1
+        retry if retry_safe && !retries.zero?
+        raise
+      end
+    end
+    
+  end
+end

data/lib/ruby_psigate/credit_card.rb

@@ -0,0 +1,104 @@
+module RubyPsigate
+  # This class acts as a standalone object to verify that the credit card number is valid
+  # If the credit card number is not valid, RubyPsigate::CreditCardInvalidError will be raised
+  #
+  #
+  
+  class CreditCardNumberInvalid < RubyPsigateError; end
+  class CreditCardExpired < RubyPsigateError; end
+  class CreditCardExpiryInvalid < RubyPsigateError; end
+  class CreditCardOwnerNameMissing < RubyPsigateError; end
+  class CreditCardNotSupported < RubyPsigateError; end
+  
+  class CreditCard
+    
+    include RubyPsigate::Utils
+    include RubyPsigate::HashVariables
+    
+    hashable %w( PaymentType CardNumber CardExpMonth CardExpYear CardIDNumber )
+    hashable :card_info, %w( CardHolder CardNumber CardExpMonth CardExpYear )
+    
+    attr_accessor :number, :month, :year, :verification_value, :name
+    attr_reader :type
+    
+    # Psigate only supports these three types of cards
+    VALID_TYPES = %w( visa mastercard american_express )
+    
+    def initialize(options={})
+      requires!(options, :number, :month, :year, :name)
+      @number = options[:number]
+      @month  = options[:month]
+      @year   = options[:year]
+      @verification_value = options[:verification_value]
+      @name   = options[:name]
+      
+      validate_credit_card!
+    end
+
+    # For hashable
+    def paymenttype
+      "CC"
+    end
+    
+    # Returns the last 2 digits of the expiry year
+    def cardexpyear
+      year[2..3]
+    end
+    
+    alias_method :cardnumber, :number
+    alias_method :cardexpmonth, :month
+    alias_method :cardidnumber, :verification_value
+    alias_method :cardholder, :name
+    # End for hashable
+    
+    private
+    
+    def validate_credit_card!
+      validate_number
+      validate_type
+      validate_name
+      validate_date
+    end
+        
+    def validate_number
+      raise CreditCardNumberInvalid unless @number.to_s.creditcard?
+    end
+    
+    def validate_type
+      type = @number.to_s.creditcard_type
+      raise CreditCardNotSupported unless VALID_TYPES.include?(type)      
+    end
+    
+    def validate_name
+      raise CreditCardOwnerNameMissing if @name.nil?
+    end
+    
+    def validate_date
+      raise CreditCardExpiryInvalid unless (valid_month?(@month) && valid_expiry_year?(@year))
+      raise CreditCardExpired if expired?
+    end
+    
+    def valid_month?(month)
+      (1..12).include?(month.to_i)
+    end
+    
+    def valid_expiry_year?(year)
+      (Time.now.year..Time.now.year + 20).include?(year.to_i)
+    end
+    
+    def expired?
+      today   = Time.now
+      expiry  = Time.new(@year, @month, days_in_a_month(@year, @month))
+      today > expiry
+    end
+    
+    def days_in_a_month(year, month)
+      if month == 12
+        year += 1 
+        next_month = 1
+      end
+      days = (Time.new(year, next_month)-1).day
+    end
+    
+  end
+end

data/lib/ruby_psigate/credit_card_methods.rb

@@ -0,0 +1,12 @@
+module RubyPsigate
+  module CreditCardMethods
+    
+    attr_reader :cc
+    
+    def cc=(credit_card)
+      raise InvalidCreditCard unless credit_card.is_a?(RubyPsigate::CreditCard)
+      @cc = credit_card
+    end
+    
+  end
+end

data/lib/ruby_psigate/error.rb

@@ -0,0 +1,33 @@
+module RubyPsigate
+  
+  class RubyPsigateError < StandardError
+  end
+  
+  class ConnectionError < RubyPsigateError
+  end
+  
+  class RetriableConnectionError < RubyPsigateError
+  end
+  
+  class CertVerificationFileMissingError < RubyPsigateError
+  end
+  
+  class ResponseError < RubyPsigateError
+    attr_reader :response
+
+    def initialize(response, message = nil)
+      @response = response
+      @message  = message
+    end
+
+    def to_s
+      "Failed with #{response.code} #{response.message if response.respond_to?(:message)}"
+    end
+  end
+  
+  class LiveURLMissingError < RubyPsigateError
+  end
+  
+  class InvalidHashType < RubyPsigateError; end
+  
+end