ruby_psigate 0.7

data/lib/ruby_psigate/gateway.rb

@@ -0,0 +1,126 @@
+module RubyPsigate
+  
+  class InvalidOrder < RubyPsigateError; end
+  class InvalidAccount < RubyPsigateError; end
+  class InvalidGatewayMode < RubyPsigateError; end
+  class InvalidCredentials < RubyPsigateError; end
+  class InvalidCreditCard < RubyPsigateError; end
+  class IncompleteParameters < RubyPsigateError; end
+  
+  class Gateway
+    
+    # Class defaults to 
+    @env = :test
+    
+    def self.env
+      @env
+    end
+    
+    def self.live!
+      @env = :live
+    end
+    
+    def self.test!
+      @env = :test
+    end
+    
+    include ::RubyPsigate::TransactionMethods
+    # include RubyPsigate::AccountManagerMethods
+    
+    attr_reader :mode, :order, :options, :account
+    
+    def initialize(options={})
+      @options = options
+      set_mode(@options)
+    end
+        
+    def mode=(type)
+      valid_modes = %w( transaction account_manager )
+      raise InvalidGatewayMode unless valid_modes.include?(type.to_s)
+      @mode = type.to_sym
+    end
+    
+    def order=(order_object)
+      raise InvalidOrder unless order_object.is_a?(RubyPsigate::Order)
+      @order = order_object
+    end
+    
+    def account=(account_object)
+      raise InvalidAccount unless account_object.is_a?(RubyPsigate::Account)
+      @account = account_object
+    end
+    
+    TRANSACTION_LOOKUP = {
+      :sale => "0",
+      :preauth => "1",
+      :postauth => "2",
+      :credit => "3",
+      :force_postauth => "4",
+      :void => "9"
+    }
+    
+    def commit!
+      # 1) Check the mode
+      # 2) Ensure credentials are set
+      # 3) Check which action user is wanting to take
+      # 4) Ensure adequate minimum parameters for the given action
+      # 5) Parameterize and ensure it is properly formatted
+      # 6) Send!
+      
+      raise InvalidGatewayMode unless mode_set?
+      raise InvalidCredentials unless sufficient_login_credentials?
+
+      if mode == :transaction
+        raise InvalidOrder unless order.valid?
+
+        @params = {}
+        @params[:Order] = {}
+        @params[:Order] = { :StoreID => options[:store_id], :Passphrase => options[:passphrase] }
+        @params[:Order].merge!(order.to_hash(order.action))
+        
+        @endpoint = "https://dev.psigate.com:7989/Messenger/XMLMessenger"
+      end
+
+      if mode == :account_manager
+        # raise InvalidAccount unless account.valid?
+        
+        # Parameterize based on account manager
+        @params = {}
+        @params[:Request] = {}
+        @params[:Request] = { :CID => options[:cid], :UserID => options[:user_id], :Password => options[:password] }
+        @params[:Request].merge!(account.to_hash(account.action))
+        
+        @endpoint = "https://dev.psigate.com:8645/Messenger/AMMessenger"
+      end
+
+      # Serializes the parameters to xml      
+      @params = Serializer.new(@params, :header => true).to_xml
+      
+      @connection = Connection.new(@endpoint)
+      @response = @connection.post(@params)
+      Response.new(@response)
+    end
+    
+    private
+    
+    def set_mode(options)
+      self.mode = :account_manager if options[:cid] && options[:user_id] && options[:password]
+      self.mode = :transaction if options[:store_id] && options[:passphrase]
+    end
+    
+    def mode_set?
+      (mode == :account_manager || mode == :transaction) ? true : false
+    end
+    
+    def sufficient_login_credentials?
+      result = false
+      if mode == :account_manager
+        result = (options[:cid] && options[:user_id] && options[:password] ? true : false)
+      elsif mode == :transaction
+        result = (options[:store_id] && options[:passphrase] ? true : false)
+      end
+      result
+    end
+    
+  end
+end

data/lib/ruby_psigate/hash_variables.rb

@@ -0,0 +1,58 @@
+module RubyPsigate
+  # In your class, you can define the instance variables you want to wrap in a hash output
+  #
+  # Usage:
+  # 
+  # hashable :billing, [:name, :address, :city, :state, :country, :zipcode]
+  #
+  # What this will do is create a hash like this when you call the class' instance #to_hash(:billing)
+  # { :name => "Bob", :address => "1234 West St", :city => "North York", :state => "NY", :country => "USA", zipcode => "12345"}
+  #
+  # If you don't specify a "name", you can simply call #to_hash:
+  #
+  # hashable [:name, :address, :city, :state, :country, :zipcode]
+  # instance#to_hash will yield the same output as above
+  #
+  module HashVariables
+    
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      def hashable(*args)
+        @hashable_attributes ||= {}
+        if args[0].is_a?(Symbol) && args[1].is_a?(Array)
+          @hashable_attributes[args[0]] = args[1]
+        elsif args[0].is_a?(Array)
+          @hashable_attributes[:default] = args[0]
+        else
+          raise ArgumentError
+        end
+      end
+      
+      def hashable_attributes
+        @hashable_attributes
+      end
+    end
+  
+    module InstanceMethods
+      def to_hash(name=nil)
+        return_hash = {}
+        if name.nil?
+          attributes = self.class.hashable_attributes[:default]
+        else
+          attributes = self.class.hashable_attributes[name.to_sym]
+        end
+        attributes.each do |a|
+          key                     = "#{a}"
+          value                   = self.send(a.downcase)
+          return_hash[key.to_sym] = value
+        end
+        return_hash
+      end
+    end
+  
+  end
+end

data/lib/ruby_psigate/item.rb

@@ -0,0 +1,65 @@
+module RubyPsigate
+  
+  class InvalidItemOption < RubyPsigateError; end
+  
+  class Item
+    include NumberValidationMethods
+    include HashVariables
+    
+    hashable %w( ItemID ItemDescription ItemQty ItemPrice )
+    
+    attr_reader :qty, :price
+    attr_accessor :unique_id, :desc
+    
+    # For hashable
+    alias_method :itemid, :unique_id
+    alias_method :itemdescription, :desc
+    alias_method :itemqty, :qty
+    alias_method :itemprice, :price
+    
+    def to_hash
+      @return_hash = super
+      unless options.count == 0
+        @return_hash[:Option] = {} 
+        options.each do |opt|
+          opt = opt.first
+          key = opt[0].to_sym
+          value = opt[1]
+          @return_hash[:Option][key] = value
+        end
+      end
+      @return_hash
+    end
+    # End hashable
+    
+    def initialize(parameters = {})
+      @options = []
+    end
+    
+    def qty=(x)
+      x = x.to_i
+      @qty = validate(x)
+    end
+    
+    def price=(x)
+      x = x.to_f
+      @price = Money.new(x*100)
+    end
+    
+    def << (item_option)
+      raise InvalidItemOption unless item_option.is_a?(RubyPsigate::ItemOption)
+      @options << item_option
+      return self
+    end
+    
+    def options
+      holder = []
+      @options.each do |opt|
+        holder << opt.instance_variable_get(:@option)
+      end
+      holder
+    end
+    
+  end
+  
+end

data/lib/ruby_psigate/item_option.rb

@@ -0,0 +1,10 @@
+module RubyPsigate
+  class ItemOption
+    
+    def initialize(option_hash={})
+      @option = option_hash
+      self.freeze
+    end
+    
+  end
+end

data/lib/ruby_psigate/number_validation_methods.rb

@@ -0,0 +1,12 @@
+module RubyPsigate
+  
+  class NumberLessThanZero < RubyPsigateError; end
+  
+  module NumberValidationMethods
+    def validate(number)
+      raise NumberLessThanZero if number < 0
+      return number
+    end  
+  end
+  
+end

data/lib/ruby_psigate/order.rb

@@ -0,0 +1,120 @@
+module RubyPsigate
+  
+  class InvalidAction < RubyPsigateError; end
+  class InvalidItem < RubyPsigateError; end
+  class InvalidAmount < RubyPsigateError; end
+  class InvalidAddress < RubyPsigateError; end
+  
+  class Order
+    
+    include CreditCardMethods
+    include HashVariables
+    
+    hashable :sale, %w( Subtotal Email CardAction Comments Tax1 Tax2 Tax3 Tax4 Tax5 )
+    hashable :preauth, %w( Subtotal Email CardAction Comments Tax1 Tax2 Tax3 Tax4 Tax5 )
+    hashable :postauth, %w( Subtotal Email CardAction OrderID )
+    hashable :credit, %w( Subtotal Email CardAction OrderID )
+    hashable :force_postauth, %w( Subtotal Email CardAction CardAuthNumber)
+    hashable :void, %w( CardAction OrderID TransRefNumber )
+    
+    attr_reader :action, :items, :amount, :billing, :shipping, :tax1, :tax2, :tax3, :tax4, :tax5
+    attr_accessor :comment, :email, :order_id, :card_auth_number, :trans_ref_number
+    
+    alias_method :orderid, :order_id
+    alias_method :cardauthnumber, :card_auth_number
+    alias_method :transrefnumber, :trans_ref_number
+    
+    def initialize
+      @items = []
+    end
+    
+    def to_hash(type = nil)
+      result = super
+      result = result.merge(billing.to_hash(:billing)) unless billing.nil?  # Add billing address if present
+      result = result.merge(shipping.to_hash(:shipping)) unless shipping.nil?  # Add shipping address if present
+      
+      # Add items if present
+      if items.count > 0
+        result[:Item] = []
+        items.each do |item|
+          result[:Item] << item.to_hash
+        end
+      end
+      
+      result.merge!(cc.to_hash) if cc
+      
+      result = result.delete_if { |key, value| value.nil? }  # Delete empty hash values
+      result
+    end
+        
+    def << (new_item)
+      raise InvalidItem unless new_item.is_a?(RubyPsigate::Item)
+      @items << new_item
+      return self
+    end
+    
+    def action=(x)
+      x = x.downcase.to_sym
+      raise InvalidAction unless [:sale, :preauth, :postauth, :credit, :force_postauth, :void].include?(x)
+      @action = x
+    end
+
+    CARD_ACTION = {
+      :sale           => 0,
+      :preauth        => 1,
+      :postauth       => 2,
+      :credit         => 3,
+      :force_postauth => 4,
+      :void           => 9
+    }
+    
+    # Returns the Psigate format equivalent for the action method
+    def cardaction
+      CARD_ACTION[action]
+    end
+    
+    alias_method :subtotal, :amount
+    
+    def amount=(x)
+      raise InvalidAmount if x.to_f < 0
+      @amount = Money.new(x.to_f*100)
+    end
+    
+    def billing=(billing_address)
+      raise InvalidAddress unless billing_address.is_a?(RubyPsigate::Address)
+      @billing = billing_address
+    end
+    
+    def shipping=(shipping_address)
+      raise InvalidAddress unless shipping_address.is_a?(RubyPsigate::Address)
+      @shipping = shipping_address      
+    end
+    
+    alias_method :comments, :comment
+    
+    %w( tax1 tax2 tax3 tax4 tax5 ).each do |tax|
+      self.class_eval <<-EOF
+        def #{tax}=(tax_amount)
+          raise InvalidAmount if tax_amount.to_f < 0
+          @#{tax} = Money.new(tax_amount*100)
+        end
+      EOF
+    end
+    
+    # Used internally by the Gateway class to determine if minimal parameters are set to be processed
+    def valid?
+      errors = 0
+
+      if amount.zero?
+        errors += 1 unless action == :postauth || action == :void
+      end      
+      errors += 1 if action.nil?
+      errors += 1 if email.nil?
+      errors += 1 if ( action == :postauth && order_id.nil? ) || ( action == :credit && order_id.nil? ) || ( action == :void && order_id.nil? )
+      errors += 1 if ( action == :force_postauth && card_auth_number.nil? )
+      errors += 1 if ( action == :void && trans_ref_number.nil? )
+      errors > 0 ? false : true
+    end
+    
+  end
+end

data/lib/ruby_psigate/recurring_charge.rb

@@ -0,0 +1,53 @@
+module RubyPsigate
+  
+  class InvalidRecurringItem < RubyPsigateError; end
+  
+  # This class encapsulates the recurring charge elements for use in the Account Class
+  class RecurringCharge
+    
+    include HashVariables
+    hashable %w( RBCID RBName Interval RBTrigger ProcessType Status StartTime EndTime )    
+
+    attr_accessor :rbcid, :rbname, :interval, :rbtrigger, :status, :starttime, :endtime, :processtype
+    
+    def initialize(attributes = {})
+      @rbcid        = attributes[:rbcid]
+      @rbname       = attributes[:rbname]
+      @interval     = attributes[:interval]
+      @rbtrigger    = attributes[:rbtrigger]
+      @status       = attributes[:status]
+      @starttime    = attributes[:starttime]
+      @endtime      = attributes[:endtime]
+      @processtype  = attributes[:processtype]
+      @items        = []
+    end
+    
+    def to_hash
+      @return_hash = super
+      unless items.count == 0
+        @return_hash[:ItemInfo] = []
+        items.each do |item|
+          @return_hash[:ItemInfo] << item.to_hash
+        end
+      end
+      
+      @return_hash = @return_hash.delete_if { |key, value| value.nil? }  # Delete empty hash values
+      @return_hash
+    end
+    
+    def << (item)
+      raise InvalidRecurringItem unless item.is_a?(RecurringItem)
+      @items << item
+      return self
+    end
+    
+    def items
+      holder = []
+      @items.each do |item|
+        holder << item.to_hash
+      end
+      holder
+    end
+    
+  end
+end

data/lib/ruby_psigate/recurring_item.rb

@@ -0,0 +1,26 @@
+module RubyPsigate
+  class RecurringItem
+    
+    include HashVariables
+    hashable %w( ProductID Description Quantity Price Tax1 Tax2 )
+    
+    attr_accessor :product_id, :description, :quantity, :price, :tax1, :tax2, :cost
+    alias_method :productid, :product_id
+    
+    def initialize(attributes = {})
+      @product_id = attributes[:product_id]
+      @description = attributes[:description]
+      @quantity = attributes[:quantity]
+      @price = attributes[:price]
+      @tax1 = attributes[:tax1]
+      @tax2 = attributes[:tax2]
+    end
+    
+    def to_hash
+      result = super
+      result = result.delete_if { |key, value| value.nil? }  # Delete empty hash values
+      result
+    end
+    
+  end
+end

data/lib/ruby_psigate/response.rb

@@ -0,0 +1,109 @@
+module RubyPsigate
+  
+  # The Response class deals with the XML responses from Psigate's servers
+  #
+  class Response
+    
+    ACCOUNT_SUCCESS_CODES = %w(
+      RPA-0000
+      RPA-0001
+      RPA-0010
+      RPA-0015
+      RPA-0020
+      RPA-0022
+      RPA-0025
+      RPA-0040
+      RPA-0042
+      RPA-0046
+      RPA-0048
+      RPA-0058
+      PSI-0000
+      RRC-0000
+      RRC-0005
+      RRC-0050
+      RRC-0060
+      RRC-0065
+      RRC-0072
+      RRC-0075
+      RRC-0082
+      RRC-0090
+      RRC-0092
+      RRC-0095
+      RRC-0098
+      RRC-0190
+      CTL-0000
+      CTL-0005
+      CTL-0050
+      CTL-0060
+      CTL-0065
+      CTL-0072
+      CTL-0075
+      CTL-0082
+      CTL-0090
+      CTL-0092
+      CTL-0098
+      CTL-0190
+      CTL-0192
+      RIV-0050
+      RIV-0060
+      RIV-0072
+      RIV-0090
+      RIV-0190
+      RIV-0197
+      RIV-0198
+      EMR-0000
+      EMR-0005
+      EMR-0050
+      EMR-0060
+      EMR-0072
+      EMR-0082
+      EMR-0090
+      EMR-0190
+    )
+    
+    # The Response object is initialized with the response output from the response body of the HTTP request to Psigate's servers
+    # The expected format of the raw_response is a properly formed XML document
+    # Please refer to Psigate's technical documents (XML Interface PDF and Account Manager API PDF)
+    # 
+    # Once the raw_resposne is received, we use nokogiri to parse and format the output to a usable hash
+    def initialize(raw_response)
+      @response = Crack::XML.parse(raw_response)
+    end
+    
+    def hash
+      @response
+    end
+    
+    def parsed
+      return @parsed if @parsed
+      @parsed = @response["Result"] || @response["Response"]
+    end
+    
+    def success?
+      parsed["Approved"] == "APPROVED" || ACCOUNT_SUCCESS_CODES.include?(self.returncode)
+    end
+    
+    def method_missing(name, *args, &block)
+      @result = nil
+      name = name.downcase.to_sym
+      @result = find_value_in_hash(name, parsed)
+      @result
+    end
+    
+    def find_value_in_hash(input_key, hash)
+      result = nil
+      hash.each_pair do |key, value|
+        if value.is_a? Hash
+          result = find_value_in_hash(input_key, value)
+        else
+          key = key.downcase.to_sym
+          result = value if input_key == key
+        end
+        
+        break unless result.nil?
+      end
+      result
+    end
+    
+  end
+end

data/lib/ruby_psigate/serializer.rb

@@ -0,0 +1,59 @@
+module RubyPsigate
+  
+  class InvalidHashError < ArgumentError; end;
+  
+  class Serializer
+    # Initializes a new object with an inputted hash
+    #
+    # my_hash = { :something => "special" }
+    # Serializer.new(my_hash)
+    def initialize(input_hash, options = { :header => false })
+      raise InvalidHashError, "Input parameters does not contain a hash!" unless input_hash.is_a?(Hash)
+      @input_hash = input_hash
+      @header = options[:header]
+    end
+    
+    # Converts from a hash to a hierarchical XML
+    #
+    # An example:
+    #
+    # Converts
+    # => { :Something => "Hello World" }
+    # to this:
+    # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Something>Hello World</Something>"
+    #
+    # Can also handle nested hashes
+    def to_xml
+      @builder = Builder::XmlMarkup.new
+      @builder.instruct! if @header
+      build_level(@input_hash)
+      @builder.target!
+    end
+    
+    def build_level(hash_level)
+      raise InvalidHashError, "Need hash to build XML" unless hash_level.is_a?(Hash)
+      for key, value in hash_level
+        
+        # If the element at this level is :Item, then we know that it will be an array
+        unless key == :Item
+          @builder.tag!(key) { |level| value.is_a?(Hash) ? build_level(value) : level.text!(value.to_s) }
+        else
+          build_level_from_array_element(value)
+        end
+        
+      end
+    end
+    
+    def build_level_from_array_element(input_array)
+      input_array.each do |element|
+        @builder.tag!(:Item) {
+          element.each_pair do |key, value|
+            # @builder.tag!(key) { |level| level.text!(value) }
+            @builder.tag!(key) { |level| value.is_a?(Hash) ? build_level(value) : level.text!(value) }
+          end
+        }
+      end
+    end
+  end
+  
+end

data/lib/ruby_psigate/transaction_methods.rb

@@ -0,0 +1,21 @@
+module RubyPsigate
+  
+  module TransactionMethods
+    
+    # URL for test environment
+    TRANSACTION_TEST_URL = 'https://dev.psigate.com:7989/Messenger/XMLMessenger'
+    
+    # URL for live environment is not specified
+    # It must be obtained from Psigate's tech support and be specified
+
+    def amount
+      @amount
+    end
+    
+    def amount=(x)
+      raise InvalidAmount if x.to_f < 0
+      @amount = x
+    end
+    
+  end
+end

data/lib/ruby_psigate/utils.rb

@@ -0,0 +1,18 @@
+module RubyPsigate
+  module Utils
+
+    def requires!(hash, *params)
+      params.each do |param| 
+        if param.is_a?(Array)
+          raise ArgumentError.new("Missing required parameter: #{param.first}") unless hash.has_key?(param.first) 
+
+          valid_options = param[1..-1]
+          raise ArgumentError.new("Parameter: #{param.first} must be one of #{valid_options.to_sentence(:words_connector => 'or')}") unless valid_options.include?(hash[param.first])
+        else
+          raise ArgumentError.new("Missing required parameter: #{param}") unless hash.has_key?(param) 
+        end
+      end
+    end
+    
+  end
+end