Class Index [+]

Quicksearch

ActiveMerchant::Billing::LinkpointGateway

Initialization Options :login Your store number :pem The text of your linkpoint PEM file. Note

                      this is not the path to file, but its
                      contents. If you are only using one PEM
                      file on your site you can declare it 
                      globally and then you won't need to
                      include this option

A valid store number is required. Unfortunately, with LinkPoint YOU CAN’T JUST USE ANY OLD STORE NUMBER. Also, you can’t just generate your own PEM file. You’ll need to use a special PEM file provided by LinkPoint.

Go to www.linkpoint.com/support/sup_teststore.asp to set up a test account and obtain your PEM file.

Declaring PEM file Globally ActiveMerchant::Billing::LinkpointGateway.pem_file = File.read( File.dirname(FILE) + ‘/../mycert.pem’ )

Valid Order Options :result =>

  LIVE                  Production mode
  GOOD                  Approved response in test mode
  DECLINE               Declined response in test mode
  DUPLICATE             Duplicate response in test mode
                    

:ponumber Order number

:transactionorigin => Source of the transaction

   ECI                  Email or Internet
   MAIL                 Mail order
   MOTO                 Mail order/Telephone
   TELEPHONE            Telephone
   RETAIL               Face-to-face

:ordertype =>

   SALE                 Real live sale
   PREAUTH              Authorize only
   POSTAUTH             Forced Ticket or Ticket Only transaction
   VOID             
   CREDIT           
   CALCSHIPPING         For shipping charges calculations
   CALCTAX              For sales tax calculations
                    

Recurring Options :action =>

   SUBMIT           
   MODIFY           
   CANCEL           
                    

:installments Identifies how many recurring payments to charge the customer :startdate Date to begin charging the recurring payments. Format: YYYYMMDD or “immediate” :periodicity =>

    MONTHLY         
    BIMONTHLY       
    WEEKLY          
    BIWEEKLY        
    YEARLY          
    DAILY           

:threshold Tells how many times to retry the transaction (if it fails) before contacting the merchant. :comments Uh… comments

For reference:

www.linkpointcentral.com/lpc/docs/Help/APIHelp/lpintguide.htm

 Entities = {
   :payment => [:subtotal, :tax, :vattax, :shipping, :chargetotal],
   :billing => [:name, :address1, :address2, :city, :state, :zip, :country, :email, :phone, :fax, :addrnum],
   :shipping => [:name, :address1, :address2, :city, :state, :zip, :country, :weight, :items, :carrier, :total],
   :creditcard => [:cardnumber, :cardexpmonth, :cardexpyear, :cvmvalue, :track],
   :telecheck => [:routing, :account, :checknumber, :bankname, :bankstate, :dl, :dlstate, :void, :accounttype, :ssn],
   :transactiondetails => [:transactionorigin, :oid, :ponumber, :taxexempt, :terminaltype, :ip, :reference_number, :recurring, :tdate],
   :periodic => [:action, :installments, :threshold, :startdate, :periodicity, :comments],
   :notes => [:comments, :referred]
   :items => [:item => [:price, :quantity, :description, :id, :options => [:option => [:name, :value]]]]
 }

LinkPoint’s Items entity is an optional entity that can be attached to orders. It is entered as :line_items to be consistent with the CyberSource implementation

The line_item hash goes in the options hash and should look like

        :line_items => [
          {
            :id => '123456',
            :description => 'Logo T-Shirt',
            :price => '12.00',
            :quantity => '1',
            :options => [
              {
                :name => 'Color',
                :value => 'Red'
              },
              {
                :name => 'Size',
                :value => 'XL'
              }
            ]
          },
          {
            :id => '111',
            :description => 'keychain',
            :price => '3.00',
            :quantity => '1'
          }
        ]

This functionality is only supported by this particular gateway may be changed at any time

Constants

TEST_URL
LIVE_URL

Public Class Methods

new(options = {}) click to toggle source
     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 141
141:       def initialize(options = {})
142:         requires!(options, :login)
143:         
144:         @options = {
145:           :result => 'LIVE',
146:           :pem => LinkpointGateway.pem_file
147:         }.update(options)
148:         
149:         raise ArgumentError, "You need to pass in your pem file using the :pem parameter or set it globally using ActiveMerchant::Billing::LinkpointGateway.pem_file = File.read( File.dirname(__FILE__) + '/../mycert.pem' ) or similar" if @options[:pem].blank?
150:       end

Public Instance Methods

authorize(money, creditcard, options = {}) click to toggle source

Authorize the transaction

Reserves the funds on the customer’s credit card, but does not charge the card.

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 200
200:       def authorize(money, creditcard, options = {})
201:         requires!(options, :order_id)
202:         options.update(
203:           :ordertype => "PREAUTH"
204:         )
205:         commit(money, creditcard, options)
206:       end
capture(money, authorization, options = {}) click to toggle source

Post an authorization.

Captures the funds from an authorized transaction. Order_id must be a valid order id from a prior authorized transaction.

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 214
214:       def capture(money, authorization, options = {})
215:         options.update(
216:           :order_id => authorization,
217:           :ordertype => "POSTAUTH"
218:         )
219:         commit(money, nil, options)  
220:       end
credit(money, identification, options = {}) click to toggle source
     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 244
244:       def credit(money, identification, options = {})
245:         deprecated CREDIT_DEPRECATION_MESSAGE
246:         refund(money, identification, options)
247:       end
purchase(money, creditcard, options={}) click to toggle source

Buy the thing

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 187
187:       def purchase(money, creditcard, options={})
188:         requires!(options, :order_id)
189:         options.update(
190:           :ordertype => "SALE"
191:         )
192:         commit(money, creditcard, options)
193:       end
recurring(money, creditcard, options={}) click to toggle source

Send a purchase request with periodic options Recurring Options :action =>

   SUBMIT           
   MODIFY           
   CANCEL           
                    

:installments Identifies how many recurring payments to charge the customer :startdate Date to begin charging the recurring payments. Format: YYYYMMDD or “immediate” :periodicity =>

    :monthly         
    :bimonthly       
    :weekly          
    :biweekly        
    :yearly          
    :daily           

:threshold Tells how many times to retry the transaction (if it fails) before contacting the merchant. :comments Uh… comments

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 171
171:       def recurring(money, creditcard, options={})
172:         requires!(options, [:periodicity, :bimonthly, :monthly, :biweekly, :weekly, :yearly, :daily], :installments, :order_id )
173:         
174:         options.update(
175:           :ordertype => "SALE",
176:           :action => options[:action] || "SUBMIT",
177:           :installments => options[:installments] || 12,
178:           :startdate => options[:startdate] || "immediate",
179:           :periodicity => options[:periodicity].to_s || "monthly",
180:           :comments => options[:comments] || nil,
181:           :threshold => options[:threshold] || 3
182:         )
183:         commit(money, creditcard, options)
184:       end
refund(money, identification, options = {}) click to toggle source

Refund an order

identification must be a valid order id previously submitted by SALE

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 236
236:       def refund(money, identification, options = {})
237:         options.update(
238:           :ordertype => "CREDIT",
239:           :order_id => identification
240:         )
241:         commit(money, nil, options)
242:       end
test?() click to toggle source
     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 249
249:       def test?
250:         @options[:test] || super
251:       end
void(identification, options = {}) click to toggle source

Void a previous transaction

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 223
223:       def void(identification, options = {})
224:         options.update(
225:           :order_id => identification,
226:           :ordertype => "VOID"
227:         )
228:         commit(nil, nil, options)
229:       end

Private Instance Methods

build_items(element, items) click to toggle source

adds LinkPoint’s Items entity to the XML. Called from post_data

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 298
298:       def build_items(element, items)
299:         for item in items
300:           item_element = element.add_element("item")
301:           for key, value in item
302:             if key == :options
303:               options_element = item_element.add_element("options")
304:               for option in value
305:                 opt_element = options_element.add_element("option")
306:                 opt_element.add_element("name").text =  option[:name]   unless option[:name].blank?
307:                 opt_element.add_element("value").text =  option[:value]   unless option[:value].blank?
308:               end
309:             else
310:               item_element.add_element(key.to_s).text =  item[key].to_s unless item[key].blank?
311:             end
312:           end
313:         end
314:       end
commit(money, creditcard, options = {}) click to toggle source

Commit the transaction by posting the XML file to the LinkPoint server

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 255
255:       def commit(money, creditcard, options = {})
256:         response = parse(ssl_post(test? ? TEST_URL : LIVE_URL, post_data(money, creditcard, options)))
257:         
258:         Response.new(successful?(response), response[:message], response, 
259:           :test => test?,
260:           :authorization => response[:ordernum],
261:           :avs_result => { :code => response[:avs].to_s[2,1] },
262:           :cvv_result => response[:avs].to_s[3,1]
263:         )
264:       end
format_creditcard_expiry_year(year) click to toggle source
     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 449
449:       def format_creditcard_expiry_year(year)
450:         sprintf("%.4i", year)[2..1]
451:       end
normalize(field) click to toggle source

Make a ruby type out of the response string

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 439
439:       def normalize(field)
440:         case field
441:         when "true"   then true
442:         when "false"  then false
443:         when ""       then nil
444:         when "null"   then nil
445:         else field
446:         end        
447:       end
parameters(money, creditcard, options = {}) click to toggle source

Set up the parameters hash just once so we don’t have to do it for every action.

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 318
318:       def parameters(money, creditcard, options = {})
319:         
320:         params = {
321:           :payment => {
322:             :subtotal => amount(options[:subtotal]),
323:             :tax => amount(options[:tax]),
324:             :vattax => amount(options[:vattax]),
325:             :shipping => amount(options[:shipping]),
326:             :chargetotal => amount(money)
327:           },
328:           :transactiondetails => {
329:             :transactionorigin => options[:transactionorigin] || "ECI",
330:             :oid => options[:order_id],
331:             :ponumber => options[:ponumber],
332:             :taxexempt => options[:taxexempt],
333:             :terminaltype => options[:terminaltype],
334:             :ip => options[:ip],
335:             :reference_number => options[:reference_number],
336:             :recurring => options[:recurring] || "NO",  #DO NOT USE if you are using the periodic billing option. 
337:             :tdate => options[:tdate]
338:           },
339:           :orderoptions => {
340:             :ordertype => options[:ordertype],
341:             :result => @options[:result]
342:           },
343:           :periodic => {
344:             :action => options[:action],
345:             :installments => options[:installments], 
346:             :threshold => options[:threshold], 
347:             :startdate => options[:startdate], 
348:             :periodicity => options[:periodicity], 
349:             :comments => options[:comments]
350:           },
351:           :telecheck => {
352:             :routing => options[:telecheck_routing],
353:             :account => options[:telecheck_account],
354:             :checknumber => options[:telecheck_checknumber],
355:             :bankname => options[:telecheck_bankname],
356:             :dl => options[:telecheck_dl],
357:             :dlstate => options[:telecheck_dlstate],
358:             :void => options[:telecheck_void],
359:             :accounttype => options[:telecheck_accounttype],
360:             :ssn => options[:telecheck_ssn],
361:           }
362:         }
363:       
364:         if creditcard
365:           params[:creditcard] = {
366:             :cardnumber => creditcard.number,
367:             :cardexpmonth => creditcard.month,
368:             :cardexpyear => format_creditcard_expiry_year(creditcard.year),
369:             :track => nil
370:           }
371:           
372:           if creditcard.verification_value?
373:             params[:creditcard][:cvmvalue] = creditcard.verification_value
374:             params[:creditcard][:cvmindicator] = 'provided'
375:           else
376:             params[:creditcard][:cvmindicator] = 'not_provided'
377:           end          
378:         end
379:         
380:         if billing_address = options[:billing_address] || options[:address]          
381:           
382:           params[:billing] = {}        
383:           params[:billing][:name]      = billing_address[:name] || (creditcard ? creditcard.name : nil)
384:           params[:billing][:address1]  = billing_address[:address1] unless billing_address[:address1].blank?
385:           params[:billing][:address2]  = billing_address[:address2] unless billing_address[:address2].blank?
386:           params[:billing][:city]      = billing_address[:city]     unless billing_address[:city].blank?
387:           params[:billing][:state]     = billing_address[:state]    unless billing_address[:state].blank?
388:           params[:billing][:zip]       = billing_address[:zip]      unless billing_address[:zip].blank?
389:           params[:billing][:country]   = billing_address[:country]  unless billing_address[:country].blank?
390:           params[:billing][:company]   = billing_address[:company]  unless billing_address[:company].blank?
391:           params[:billing][:phone]     = billing_address[:phone]  unless billing_address[:phone].blank?
392:           params[:billing][:email]     = options[:email] unless options[:email].blank?
393:         end                
394: 
395:         if shipping_address = options[:shipping_address] 
396: 
397:           params[:shipping] = {}
398:           params[:shipping][:name]      = shipping_address[:name] || creditcard ? creditcard.name : nil
399:           params[:shipping][:address1]  = shipping_address[:address1] unless shipping_address[:address1].blank?
400:           params[:shipping][:address2]  = shipping_address[:address2] unless shipping_address[:address2].blank?
401:           params[:shipping][:city]      = shipping_address[:city]     unless shipping_address[:city].blank?
402:           params[:shipping][:state]     = shipping_address[:state]    unless shipping_address[:state].blank?
403:           params[:shipping][:zip]       = shipping_address[:zip]      unless shipping_address[:zip].blank?
404:           params[:shipping][:country]   = shipping_address[:country]  unless shipping_address[:country].blank?
405:         end        
406: 
407:         params[:items] = options[:line_items] if options[:line_items]
408:         
409:         return params
410:       end
parse(xml) click to toggle source
     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 412
412:       def parse(xml)
413:         
414:         # For reference, a typical response...
415:         # <r_csp></r_csp>
416:         # <r_time></r_time>
417:         # <r_ref></r_ref>
418:         # <r_error></r_error>
419:         # <r_ordernum></r_ordernum>
420:         # <r_message>This is a test transaction and will not show up in the Reports</r_message>
421:         # <r_code></r_code>
422:         # <r_tdate>Thu Feb 2 15:40:21 2006</r_tdate>
423:         # <r_score></r_score>
424:         # <r_authresponse></r_authresponse>
425:         # <r_approved>APPROVED</r_approved>
426:         # <r_avs></r_avs>
427:         
428:         response = {:message => "Global Error Receipt", :complete => false}
429:         
430:         xml = REXML::Document.new("<response>#{xml}</response>")
431:         xml.root.elements.each do |node|
432:           response[node.name.downcase.sub(/^r_/, '').to_sym] = normalize(node.text)
433:         end unless xml.root.nil?
434:         
435:         response
436:       end
post_data(money, creditcard, options) click to toggle source

Build the XML file

     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 271
271:       def post_data(money, creditcard, options)
272:         params = parameters(money, creditcard, options)
273:         
274:         xml = REXML::Document.new
275:         order = xml.add_element("order")
276:         
277:         # Merchant Info
278:         merchantinfo = order.add_element("merchantinfo")
279:         merchantinfo.add_element("configfile").text = @options[:login]
280:         
281:         # Loop over the params hash to construct the XML string
282:         for key, value in params
283:           elem = order.add_element(key.to_s)
284:           if key == :items
285:             build_items(elem, value)
286:           else
287:             for k, v in params[key]
288:               elem.add_element(k.to_s).text = params[key][k].to_s if params[key][k]
289:             end
290:           end
291:           # Linkpoint doesn't understand empty elements: 
292:           order.delete(elem) if elem.size == 0
293:         end
294:         return xml.to_s
295:       end
successful?(response) click to toggle source
     # File lib/active_merchant/billing/gateways/linkpoint.rb, line 266
266:       def successful?(response)
267:         response[:approved] == "APPROVED"
268:       end

Disabled; run with --debug to generate this.

[Validate]

Generated with the Darkfish Rdoc Generator 1.1.6.