prismpay 0.0.0

data/lib/prism_credit_response.rb

@@ -0,0 +1,119 @@
+    class PrismCreditResponse
+      # this class will be responsible for handling the SOAP response
+      def initialize(prism_savon_result_obj)
+        # keys from successful response were :status, :result, :historyid,
+        # :orderid, :refcode, :authcode, :total, :merchantordernumber, 
+        # :transdate, :paytype, :duplicate
+        @result = prism_savon_result_obj
+      end
+
+      def active_merchant_response
+        params = options = { }
+
+        # options[:avs_result]
+        # options[:cvv_result]
+        message = @result.body[:multi_ref][:status]
+
+        if @result.body[:multi_ref][:status] =~ /Approved/
+          success = true
+        else
+          success = false
+        end
+
+        options[:authorization] = @result.body[:multi_ref][:historyid]
+        options[:external_identifier] = @result.body[:multi_ref][:orderid]
+
+        ActiveMerchant::Billing::Response.new(success, message, 
+                                              params, options)
+      end
+
+      def parse_auth(authstr)
+        # parses the authorization specification string returned by prismpay
+
+        trasaction_types = %w(SALE, AVSALE, AUTH, AVSAUTH, POST, AVSPOST, 
+                        VOICEPOST, VOID, CREDIT)
+        
+        approval_fields = [:transaction_type, :auth_code, :ref_number, 
+                           :batch_number, :transaction_id, :avs_code, 
+                           :auth_net_message, :cvv_code, :partial_auth]
+
+        decline_fields = [:result, :decline_code, :info]
+
+        # first digit of the decline code has these meanings
+        decline_code_map = {
+          '0' => "Authorizing network declined the transaction",
+          '1' => "Gateway declined the transaction",
+          '2' => "Authorizing network returned an error, forcing a decline",
+          '3' => "Gateway returned an error, forcing a decline"
+        }
+
+        # map cvv and avs response codes to meanings
+        avs_map = { 'A'=> "Street addresses matches, but the ZIP code does " +
+          "not. The first five numerical characters contained in the " +
+          "address match. However, the ZIP code does not match.",
+
+          'E' => "Ineligible transaction. The card issuing institution is " +
+          "not supporting AVS on the card in question. N Neither address " +
+          "nor ZIP matches. The first five numerical characters contained " +
+          "in the address do not match, and the ZIP code does not match. ",
+
+          'R'=> "Retry (system unavailable or timed out).",
+
+          'S' => "Card type not supported. The card type for this " +
+          "transaction is not supported by AVS. AVS can verify " +
+          "addresses for Visa cards, MasterCard, proprietary cards, and " +
+          "private label transactions.",
+
+          'U' => "Address information unavailable. The address information "+
+          "was not available at the issuer.",
+
+          'W' => "9 digit ZIP code match, address does not. The nine digit " +
+          "ZIP code matches that stored at the issuer. However, the first " +
+          "five numerical characters contained in the address do not match.",
+
+          'X' => "Exact match (9 digit zip and address) Both the nine digit " +
+          "postal ZIP code as well as the first five numerical characters " +
+          "contained in the address match.",
+
+          'Y' => "Address and 5 digits zip match. Both the five digit " +
+          "postal ZIP code as well as the first five numerical characters " +
+          "contained in the address match.",
+
+          'Z' => "5 digit ZIP matches, but the address does not. The five " +
+          "digit postal ZIP code matches that stored at the VIC or card " +
+          "issuer's center. However, the first five numerical characters " +
+          "contained in the address do not match.",
+
+          'B' => "Street address matches for international transaction. " +
+          "Postal Code not verified due to incompatible formats.",
+
+          'C' => "Street address and Postal Code not verified for " +
+          "international transaction due to incompatible format.",
+
+          'D' => "Street address and Postal Code match for international " +
+          "transaction.",
+
+          'P' => "Postal Code match for international transaction. Street " +
+          "address not verified due to incompatible formats."
+        } # end avs_map
+
+        cvv_map = { " "=> "cvv not requested", 
+          'M' => "cvv Match",
+          'N' => "cvv not matched", 
+          'P' => "Not processed", 
+          'S' => "cvv should be on card, but it indicated the value not present",
+          'U' => "Issuer doesn't support cvv2",
+          'X' => "Service provider did not respond"
+        }
+        
+        hash = {}
+        fields = authstr.split /:/
+        if fields.size > 3          # approval
+          approval_fields.each_index{|x| hash[approval_fields[x]] = fields[x]}
+        else 
+          decline_fields.each_index{|x| hash[decline_fields[x]] = fields[x] }
+        end
+        hash
+      end
+
+    end # PrismCreditResponse

data/lib/prismpay.rb

@@ -0,0 +1,352 @@
+require 'savon'
+require 'activemerchant'
+require 'prism_credit_response'
+require 'builder'
+
+
+class PrismPay 
+  # this class will manage the connection to the gateway and handle
+  # transactions
+
+  #  WSDL = "https://trans.myprismpay.com/MPWeb/services/TransactionService?wsdl"
+  WSDL = File.expand_path("../TransactionService.xml", __FILE__)
+
+  attr_accessor :acctid, :password
+  attr_reader :client
+
+  def initialize(options = {})
+    merchant_info = options
+    merchant_info = {:login => 'TEST0'} unless merchant_info[:login]
+
+    if merchant_info.respond_to?("has_key?")
+      @acctid = merchant_info[:login] if merchant_info.has_key?(:login)
+      @password = merchant_info[:password] if merchant_info.has_key?(:password)
+    end
+
+    @client = Savon::Client.new(WSDL) # initialize savon client
+
+  end
+
+  def build_address(addr, type= "bill")
+    # receives a hash that contains the keys for active_merchant 
+    # address and type which should be 'bill' or 'ship'
+    # returns a str to be eval and included in xml builder block
+    
+    if type != "bill" && type != "ship"
+      type = "bill" 
+    end
+    
+    retstr = 
+      "xml.#{type}address('xsi:type' => 'urn:address'){ 
+          xml.addr1 '#{addr[:address1]}'
+          xml.addr2 '#{addr[:address2]}'
+          xml.city '#{addr[:city]}'
+          xml.state '#{addr[:state]}'
+          xml.zip '#{addr[:zip]}'
+          xml.country '#{addr[:country]}'
+        }"
+  end
+
+  def build_credit(amount, id, options)
+    xml_block = Proc.new { |xml|
+      xml.miscprocess("xsi:type" => "urn:VoidCreditPost"){ 
+        xml.acctid @acctid
+        xml.amount amount
+        xml.orderid options[:orderid]
+        xml.historyid id
+        xml.ipaddress
+      }
+    }
+
+    return xml_block
+  end
+
+  def build_cc_void(auth, options)
+    # needs to have orderid and amount in options
+    xml_block = Proc.new {|xml|
+      xml.miscprocess("xsi:type" => "urn:VoidCreditPost"){ 
+        xml.acctid @acctid
+        xml.amount options[:amount]
+        xml.orderid options[:orderid]
+        # xml.customizedfields{
+        #   xml.custom1
+        #   xml.custom2
+        #   xml.custom3
+        #   xml.custom4
+        #   xml.custom5
+        #   xml.custom6
+        # }
+        xml.historyid auth
+        xml.ipaddress
+      }
+    }
+
+    return xml_block
+  end
+
+  def build_cc_capture(amount, auth, options)
+    # as of now auth is historyid and we need :orderid set in options
+    xml_block = Proc.new {|xml|
+      xml.miscprocess("xsi:type" => "urn:VoidCreditPost"){ 
+        xml.acctid @acctid
+        xml.amount amount
+        xml.orderid options[:orderid]
+        xml.historyid auth
+        xml.merchantordernumber auth
+        xml.merchantpin auth
+        xml.ipaddress
+      }
+    }
+    return xml_block
+  end
+
+  def build_cc_sale_auth(amount, credit_card, options)
+    # return a proc object to be used as a block for builder 
+    # passed to response.body {|xml| my xml block}
+
+    missing_fields_for_options = {
+      :acctid => '', 
+      :accountkey => '', 
+      :subid => '' 
+    }
+
+    # to map the active_merchant option keys to prismpay
+    active_merchant_credit_card = {
+      :first_name => '', 
+      :last_name => '',
+      :month => '', 
+      :number => '',
+      :type => '',
+      :verification_value => '', 
+      :year => ''
+    }
+
+    active_merchant_option_map = {
+      :order_id => :merchantordernumber,
+      :ip => :ipaddress,
+      :customer => '',      # customer info
+      :invoice => '',       # invoice
+      :merchant => '',      # name of merchant offering the product
+      :description => '',   # A description of the transaction
+      :email => :email,     # The email address of the customer
+      :currency => :currencycode, 
+      :address => '',  # if this is set it is both billing and shipping
+      :billing_address => {
+        :name => '',
+        :company => '',
+        :address1 => '',
+        :address2 => '',
+        :city => '',
+        :state => '',
+        :country => '',
+        :zip => '',
+        :phone => ''
+      },
+      :shipping_address => {
+        :name => '',
+        :company => '',
+        :address1 => '',
+        :address2 => '',
+        :city => '',
+        :state => '',
+        :country => '',
+        :zip => '',
+        :phone => ''
+      }
+    }
+
+    if options.has_key?(:address)
+      bill_address = ship_address = options[:address]
+    else
+      # assigns nil to variables if keys aren't present 
+      bill_address = options[:billing_address] 
+      ship_address = options[:shipping_address]
+    end
+
+    xml_block  = Proc.new{ |xml| 
+      xml.ccinfo("xsi:type" => "urn:CreditCardInfo") { 
+        xml.acctid @acctid
+        xml.accountkey options[:password] if options.has_key?(:password)
+        # xml.subid "xsi:nil" => "true"
+        xml.ccname "#{credit_card.first_name} #{credit_card.last_name}"
+        # xml.swipedata "xsi:nil" => "true"
+        # xml.cardpresent "xsi;nil" => "true"
+        # xml.cardreaderpresent "xsi:nil" => "true"
+        # xml.voiceauth "xsi:nil" => "true"
+        # xml.track1 "xsi:nil" => "true"
+        # xml.track2 "xsi:nil" => "true"
+        xml.ccnum credit_card.number
+        xml.cctype credit_card.type
+        xml.expmon credit_card.month
+        xml.expyear credit_card.year
+        xml.cvv2 credit_card.verification_value
+        xml.amount amount
+        xml.merchantordernumber options[:order_id] if options.has_key?(:order_id) # or invoice?
+        # xml.companyname  # says its our companyname 
+        eval(build_address(bill_address)) if bill_address 
+        eval(build_address(ship_address, "ship")) if ship_address
+        xml.email options[:email] if options.has_key?(:email)
+        # xml.dlnum 
+        # xml.ssnum 
+        xml.phone bill_address[:phone] if bill_address
+        # xml.dobday
+        # xml.dobmonth
+        # xml.dobyear 
+        # xml.memo 
+        # xml.customizedemail("xsi:type" => "urn:customEmail"){ #method
+        #   xml.emailto "vpat@comcast.net"
+        #   xml.emailfrom "null@atsbank.com"
+        #   xml.emailsubject "Transaction Service Test"
+        #   xml.emailtext "This is just a test"
+        # }
+        # xml.recurring("xsi:type" => "urn:Recur") { #nees method
+        #   xml.create 0
+        #   xml.billingcycle 0
+        #   xml.billingmax 0
+        #   xml.start 0
+        #   xml.amount 0
+        # }
+        xml.ipaddress options[:ip]  # req field ... nil if !(exists?)
+        # xml.accttype ---> #have no clue
+        # xml.merchantpin ----> #believe this is password
+        # xml.currencycode 
+        # xml.industrycode ----> # no clue
+        # xml.dynamicdescriptor ---> carries onto receipt for VITAL auths
+        # xml.profileactiontype # no clue
+        # xml.manualrecurring #number 1 if manual recurring
+      }
+    }
+
+    return xml_block
+  end
+
+  def cc_purchase(amount, creditcard, options ={})                
+    # process a credit card sale and right now return the savon response
+    # The savon response needs to be mapped back into the proper response 
+    # fields 
+    
+    # need to merge the gateway instance options with the options
+
+    response = @client.request :process_cc_sale do 
+      soap.body &build_cc_sale_auth(amount, creditcard, options)
+    end
+
+    PrismCreditResponse.new(response)
+
+  end
+
+  def cc_authorize(amount, creditcard, options = {}) 
+    # reserve funds for future captures
+    response = @client.request :process_cc_auth do 
+      soap.body &build_cc_sale_auth(amount, creditcard, options)
+    end
+  end
+
+  def cc_capture(amount, authorization, options = {})
+    # Captures reservered funds from previous auths
+    # need to put some validation into these methods before 
+    # making the call to the build methods
+
+    response = @client.request :process_cc_post do
+      soap.body &build_cc_capture(amount, authorization, options)
+    end
+  end
+
+  def cc_void(identification, options = {})
+    # voids previous transactions
+    response = @client.request :process_cc_void do 
+      soap.body &build_cc_void(identification, options)
+    end
+  end
+
+  def credit(amount, identification, options = {})
+    # applies credit back against previous transaction
+    response = @client.request :process_credit do 
+      soap.body &build_credit(amount, identification, options)
+    end
+  end
+
+end # PrismPay
+
+
+
+# class CreditCard
+#   # credit card information... mimic ActiveMerchant
+#   attr_accessor :number, :month, :year, :first_name, 
+#   :verification_value, :type, :last_name
+
+#   def [](method)
+#     eval ("self.#{method}")
+#   end
+
+#   def name
+#     join(@first_name, @last_name)
+#   end
+
+#   def name=(n)
+#     names = n.split(' ')
+#     @first_name = names[0]
+#     @last_name = names[1]
+#   end
+
+#   def []=(method, rval)
+#     eval ("self.#{method} = rval")
+#   end
+
+#   def initialize(ccinfo)
+#     if ccinfo.respond_to?("has_key?")
+#       @number = ccinfo[:number] if ccinfo.has_key?(:number)
+#       @month = ccinfo[:month] if ccinfo.has_key?(:month)
+#       @year = ccinfo[:year] if ccinfo.has_key?(:year)
+#       @name = ccinfo[:name] if ccinfo.has_key?(:name)
+#       @verification_value = ccinfo[:verification_value] if ccinfo.has_key?(:verification_value)
+#       @type = ccinfo[:type] if ccinfo.has_key?(:type)
+#     end
+#   end
+# end # CreditCard
+
+
+# #####################
+# # Demo driver 
+# #####################
+
+# cc = CreditCard.new({})
+# cc.number = 5454545454545454
+# cc.month = 7
+# cc.year = 14
+# cc.name = "JohnDoe Soap"
+# cc.verification_value = 123
+# cc.type = "Visa"
+
+# addr2 = { 
+#   :name => "Fathead Don",
+#   :address1 => "1501 S Delany Ave",
+#   :city => "Orlando",
+#   :state => "FL",
+#   :zip => "32806",
+#   :country => "US"
+# }
+
+# options = {
+#   :login => "TEST0",
+#   :order_id => Time.now.strftime("%y%m%d%H%M%S"),
+#   :address => addr2
+# }
+
+# gateway = PrismPay.new(options)
+
+# purchase_amount = "23.32"
+
+# response = gateway.cc_purchase(purchase_amount, cc, options)
+
+# ########################################
+# # NOTE
+# ########################################
+# # as of now the cc_purchase and cc_auth method will return the soap
+# # response object from the client that objects meaningful values are
+# # accessible from response.body[:multi_ref].keys()
+
+# response = gateway.credit_sale(purchase_amount, credit_card)
+
+# puts "The unparsed authcode is #{response.body[:multi_ref][:authcode]}"
+