authorize_net_reporting 0.0.1

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+doc/*
+.yardoc/*
+pkg/*
+.yardopts

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in authorize_net_reporting.gemspec
+gemspec

data/README.md

@@ -0,0 +1,74 @@
+# WORK IN PROGRESS!!!! 
+# AuhtorizeNetReporting
+
+AuthorizeNetReporting allows you to retrieve Authorize.net transaction details through the [Transaction Details API](http://developer.authorize.net/api/transaction_details/)
+
+# Sample Usage
+**Go to [Authorize.net](http://authorize.net) to obtain your key/login**
+
+````ruby
+require 'rubygems'
+
+require 'authorize_net_reporting'
+
+report = AuthorizeNetReporting::Report.new({ :mode => ['test'|'live'], :key => 'your_api_key', :login => 'your_api_login' })  
+````
+
+**All settled batched with a date range**
+
+
+````ruby
+#It will default to the last 12 hours if no date range is provided
+report.settled_batch_list({ :first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20", :include_statistics => true })
+````
+
+**Statistics for a specific batch**
+
+````ruby
+report.batch_statistics(1049686)
+````
+
+**Data for all transactions in a specified batch**
+
+````ruby
+report.transaction_list(1049686)
+````
+
+**Unsettled Transactions**
+
+````ruby
+    report.unsettled_transaction_list
+````
+
+**Detailed information about one specific transaction**
+
+````ruby
+report.transaction_details(2157585857)
+````
+  
+# LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2011:
+
+[Jazmin Schroeder](http://jazminschroeder.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sub license, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/authorize_net_reporting.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "authorize_net_reporting/version"
+
+Gem::Specification.new do |s|
+  s.name        = "authorize_net_reporting"
+  s.version     = AuthorizeNetReporting::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jazmin Schroeder"]
+  s.email       = ["jazminschroeder@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Authorize.net Transaction Details API }
+  s.description = %q{Retrieve transaction details through the Authorize.net Transaction Details API }
+
+  s.rubyforge_project = "authorize_net_reporting"
+  s.add_dependency 'httparty'
+  s.add_dependency 'builder'
+  s.add_development_dependency "rspec"  
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/authorize_net_reporting/common.rb

@@ -0,0 +1,12 @@
+# Helper methods   
+module Common
+  # Converts string to underscore
+  def underscore(str)
+    str.gsub(/(.)([A-Z])/,'\1_\2').downcase
+  end
+  # Converts string to camelCase format
+  def camelize(str)
+    str.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+end
+

data/lib/authorize_net_reporting/gateway.rb

@@ -0,0 +1,41 @@
+require 'builder'
+require 'httparty'
+require 'date'
+module AuthorizeNetReporting
+  # Gateway to connect to Authorize.net web services in order to interact with Reporting API
+  class Gateway
+    include HTTParty
+    headers 'Content-Type' => 'text/xml'
+    format :xml
+    
+    # Authorize.net Developer TEST API 
+    # Note: Authorize.net requires the use of a developer test payment gateway account, you may have to request one from Authorize.net Developer Center
+    TEST_URL = "https://apitest.authorize.net/xml/v1/request.api"
+    
+    # Authorize.net Production API
+    LIVE_URL = "https://api.authorize.net/xml/v1/request.api"
+    
+    # Authorize.net XML schema
+    XMLNS    = "AnetApi/xml/v1/schema/AnetApiSchema.xsd"
+    
+    # Make Http request
+    # param[String] xml api request     
+    def send_xml(xml)
+      begin
+        Gateway.post(api_url, :body => xml)
+      rescue
+        nil
+      end    
+    end
+    
+    # Using test or live mode?
+    def mode 
+      @mode 
+    end
+    
+    # AuthorizeNet API Url test/live
+    def api_url
+      mode.eql?('test') ? TEST_URL : LIVE_URL
+    end
+  end
+end  

data/lib/authorize_net_reporting/report.rb

@@ -0,0 +1,145 @@
+# AuthorizeNetReporting::Report
+module AuthorizeNetReporting
+  # Initialize AuthorizeNetReporting::Report class
+  #
+  # report = AuthorizeNetReporting::Report.new({ :mode => ['test'|'live'], :key => 'your api key', :login => 'your api_login' })  
+  class Report < Gateway
+    include Common
+    # Set API login, password and mode(live/test)
+    #
+    # AuthorizeNetReporting::Report.new({ :mode => ['test'|'live'], :key => 'your api key', :login => 'your api_login' })    
+    # @param [Hash] { :mode => ['test'|'live'], :key => 'your api key', :login => 'your api_login' }    
+    def initialize(options = {})
+      requires!(options, :mode, :key, :login)
+      @mode, @key, @login = options[:mode], options[:key], options[:login]
+    end
+  
+    # Authorize.net API function: getSettledBatchListRequest 
+    # 
+    # This function returns Batch ID, Settlement Time, & Settlement State for all settled batches with a range of dates. 
+    # optionally you can include __:include_statistics => true__ to receive batch statistics by payment type and batch totals. 
+    # 
+    # If no dates are specified, then the default is the last 24 hours.
+    # @param [Hash] options { :first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20", :include_statistics => true }
+    def settled_batch_list(options = {})
+      process_request(__method__, options)
+    end
+  
+    # Authorize.net API function getBatchStatisticsRequest
+    #    
+    # Returns statistics for a single batch, specified by the batch ID.
+    # @param [Integer] batch_id
+    def batch_statistics(batch_id)
+      process_request(__method__, {:batch_id => batch_id})
+    end  
+  
+    # Authorize.net API function getTransactionListRequest
+    #    
+    # Returns data for all transactions in a specified batch.
+    # @param [Integer] batch_id
+    def transaction_list(batch_id)
+      process_request(__method__, {:batch_id => batch_id})
+    end
+  
+    # Authorize.net API function getUnsettledTransactionListRequest
+    #     
+    # Returns data for unsettled transactions. This API function return data for up to 1000 of the most recent transactions
+    def unsettled_transaction_list
+      process_request(__method__)
+    end
+  
+    # Authorize.net API function getTransactionDetailsRequest
+    #     
+    # Get detailed information about one specific transaction
+    # @param [Integer] transaction_id, The transaction ID
+    def transaction_details(transaction_id)
+      process_request(__method__, {:transaction_id => transaction_id})
+    end  
+
+    private
+    # Process request
+    # @param [Symbol] api_function requested, ':settled_batch_list', ':batch_statistics', ':transaction_details', ':transactions_list' 
+    # @param [Hash] options, options to be passed to API request, '{:batch_id => 12345}'  
+    def process_request(api_function, options = {})
+      xml = build_request(api_function, options)
+      response = send_xml(xml)
+      handle_response(api_function,response)
+    end
+  
+    # Validates that required parameters are present
+    # @param [Hash] hash 
+    # @param [Symbol] params required :mode, :key
+    def requires!(hash, *params)
+      params.each do |param|
+        raise ArgumentError, "Missing Required Parameter #{param}" unless hash.has_key?(param) 
+      end
+    end
+  
+    # Build xml request file for specified API function and options requested
+    # @param[String], api_fundtion requested ':settled_batch_list', 'batch_statistics', ':transaction_details', ':transactions_list'
+    # @param [Hash] options, options to be passed to API request, '{:batch_id => 12345}' 
+    def build_request(api_function, options = {})
+      api_request = "get#{camelize(api_function.to_s)}Request"
+      xml = Builder::XmlMarkup.new(:indent => 2)
+      xml.instruct!(:xml, :version => '1.0', :encoding => 'utf-8')
+      xml.tag!(api_request, :xmlns => XMLNS) do 
+        xml.tag!('merchantAuthentication') do
+          xml.tag!('name', @login)
+          xml.tag!('transactionKey', @key)
+        end
+        send("build_#{underscore(api_request)}", xml, options)
+      end  
+    end
+  
+    def build_get_settled_batch_list_request(xml, options) #:nodoc:
+      xml.tag!("includeStatistics", true) if options[:include_statistics]
+      if options[:first_settlement_date] and options[:last_settlement_date]
+        xml.tag!("firstSettlementDate", Date.parse(options[:first_settlement_date]).strftime("%Y-%m-%dT00:00:00Z"))
+        xml.tag!("lastSettlementDate", Date.parse(options[:last_settlement_date]).strftime("%Y-%m-%dT00:00:00Z"))
+      end  
+      xml.target!
+    end
+  
+    def build_get_batch_statistics_request(xml, options) #:nodoc:
+      xml.tag!("batchId", options[:batch_id])
+      xml.target!
+    end
+  
+    def build_get_transaction_list_request(xml, options) #:nodoc:
+      xml.tag!("batchId", options[:batch_id])
+      xml.target!
+    end
+
+    def build_get_unsettled_transaction_list_request(xml, options) #:nodoc:
+      xml.target!
+    end
+  
+    def build_get_transaction_details_request(xml, options) #:nodoc:
+      xml.tag!('transId', options[:transaction_id])
+      xml.target!
+    end
+  
+    # Call to Response.parse to handle response if transaction is successful, otherwise raise StandardError  
+    def handle_response(api_function, response) 
+      response_message = get_response_message(api_function, response)
+      if response_message =~ /successful/
+        eval("AuthorizeNetReporting::Response.parse_#{api_function}(#{response.parsed_response})")
+      elsif response_message =~ /found/
+        ["transaction_details", "batch_statistics"].include?(api_function.to_s) ? nil : []
+      else
+        raise StandardError, response_message
+      end
+    end
+  
+    # Extract response message from response for specified api_function
+    def get_response_message(api_function, response)
+      api_response = "get#{camelize(api_function.to_s)}Response"
+      if response.parsed_response[api_response] 
+        message = response.parsed_response[api_response]["messages"]["message"]["text"]
+      else
+        message = response.parsed_response["ErrorResponse"]["messages"]["message"]["text"] rescue "Unable to execute transaction"
+      end    
+      message.downcase
+    end
+  end
+end

data/lib/authorize_net_reporting/response.rb

@@ -0,0 +1,100 @@
+module AuthorizeNetReporting
+  # AuthorizeNetReporting::Response parses the response from Authorize.net API and turns results into objects setting attributes for easy integration
+  
+  class Response 
+    extend Common
+    # Parse response for settled_batch_list 
+    def self.parse_settled_batch_list(response)
+      batch_list = response["getSettledBatchListResponse"]["batchList"]["batch"]
+      batches = []
+      batch_list.each do |batch|
+        statistics = extract_batch_statistics(batch)
+        params = to_single_hash(batch)
+        params.merge!("statistics" => statistics) unless statistics.blank?
+        batches << create_class("Batch", params)
+      end
+      batches
+    end
+    
+    # Parse response for batch_statistics
+    def self.parse_batch_statistics(response)
+      batch = response["getBatchStatisticsResponse"]["batch"]
+      statistics = extract_batch_statistics(batch)
+      params = to_single_hash(batch)
+      params.merge!("statistics" => statistics) unless statistics.blank?
+      create_class("Batch", params)
+    end
+     
+    # Parse response for transaction_list 
+    def self.parse_transaction_list(response)
+      transactions = [response["getTransactionListResponse"]["transactions"]["transaction"]].flatten
+      transaction_list = []
+      transactions.each do |transaction|
+        transaction_list << create_class("AuthorizeNetTransaction", to_single_hash(transaction))
+      end
+      transaction_list
+    end
+
+     
+    # Parse response unsettled_transaction 
+    def self.parse_unsettled_transaction_list(response)
+      unsettled_transactions = [response["getUnsettledTransactionListResponse"]["transactions"]["transaction"]]
+      transactions = []
+      unsettled_transactions.each do |transaction|
+        transactions << create_class("AuthorizeNetTransaction", to_single_hash(transaction))
+      end
+      transactions
+    end
+    
+    
+    # Parse response transaction_details 
+    def self.parse_transaction_details(response)
+      params = response["getTransactionDetailsResponse"]["transaction"]
+      create_class("AuthorizeNetTransaction", to_single_hash(params))
+    end
+    
+    # Handle batch statistics
+    def self.extract_batch_statistics(batch)
+      statistics = []
+      if batch["statistics"]
+        batch_statistics = [batch["statistics"]["statistic"]].flatten
+        batch_statistics.each do |statistic|   
+          statistic = statistic.inject({}) {|h, (key,value)| h[underscore(key)] = value; h}
+          statistics << statistic 
+        end
+      end
+        statistics
+    end
+             
+    # Convert response nested hash into a single hash
+    # param[Hash] hash
+    def self.to_single_hash(hash)
+      hash.each do |key, value|
+        case value       
+          when Hash then to_single_hash(value)
+          when String, Integer then   (@temp_hash||={})[underscore(key)] = value          
+        end  
+      end
+      @temp_hash
+    end
+    
+    #Create objects dinamicaly 
+    def self.create_class(class_name, params)
+        if AuthorizeNetReporting.const_defined?(class_name)
+          klass = AuthorizeNetReporting.const_get(class_name)
+        else  
+          klass = AuthorizeNetReporting.const_set(class_name, Class.new) 
+          klass.class_eval do
+            define_method(:initialize) do |params|
+              params.each do |key, value| 
+                self.class.__send__(:attr_accessor, key)
+                instance_variable_set("@#{key}", value) 
+              end  
+            end  
+          end
+        end   
+        klass.new(params)
+    end
+  end  
+end  
+

data/lib/authorize_net_reporting/version.rb

@@ -0,0 +1,3 @@
+module AuthorizeNetReporting
+  VERSION = "0.0.1" #:nodoc:
+end

data/lib/authorize_net_reporting.rb

@@ -0,0 +1,7 @@
+# @author: Jazmin Schroeder
+# July/20011
+require 'authorize_net_reporting/common'
+require 'authorize_net_reporting/gateway'
+require 'authorize_net_reporting/report'
+require 'authorize_net_reporting/response'
+

data/spec/authorize_net_reporting_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+describe AuthorizeNetReporting::Report do
+  let(:test_mode) do
+     #TEST API LOGIN: 3vk59E5BgM - API KEY:4c8FeAW7ebq5U733
+    { :mode => "test", :login=>"3vk59E5BgM", :key => "4c8FeAW7ebq5U733" }
+  end
+  
+  let(:live_mode) do
+    { :mode => "live", :key=>"key", :login => "login" }
+  end  
+  context "missing requirements" do
+    it "should raise exception" do
+      lambda { AuthorizeNetReporting::Report.new }.should raise_error(ArgumentError)
+    end
+  end
+  describe "API URL in live mode" do
+    subject { AuthorizeNetReporting::Report.new(live_mode) }
+    it "should be live url" do
+      subject.api_url.should eql(AuthorizeNetReporting::Report::LIVE_URL)
+    end
+  end
+  
+  before(:each) do
+    @authorize_net_reporting = AuthorizeNetReporting::Report.new(test_mode)
+  end  
+  
+  describe "API URL in test mode" do 
+    it 'should be test url' do
+      @authorize_net_reporting.api_url.should eql(AuthorizeNetReporting::Report::TEST_URL)
+    end
+  end
+
+  describe "settled_batch_list" do
+    context "when there are not batches settled" do
+      it "should return an empty array" do
+        @authorize_net_reporting.settled_batch_list.should be_empty
+      end
+    end
+    context "when there are settled batches" do
+      it "should return batches" do
+        batches = @authorize_net_reporting.settled_batch_list({:first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20"})
+        batches.size.should eql(4)    
+      end
+    end
+    context "when request include statistics" do
+      it "should return statistis as an Array" do 
+        batches = @authorize_net_reporting.settled_batch_list({:first_settlement_date => "2011/04/20", :last_settlement_date => "2011/05/20", :include_statistics => true})
+        batches.first.statistics.should be_an_instance_of(Array)
+      end  
+    end  
+  end
+  
+  describe "batch_statistics" do
+    it "should return an array statistics for given batch" do
+      @authorize_net_reporting.batch_statistics(1049686).statistics.should be_an_instance_of(Array)
+    end
+  end
+  
+  describe "transactions_list" do
+    it "should return all transactions in a specified batch" do
+      transactions = @authorize_net_reporting.transaction_list(1049686)
+      transactions.size.should eql(4)
+    end
+  end  
+
+  describe "unsettled_transaction_list" do
+    it "should return unsettled transactions" do
+      transactions = @authorize_net_reporting.unsettled_transaction_list
+      transactions.should be_an_instance_of(Array)
+    end  
+  end  
+  
+  describe "transaction_details" do
+    it "should return transaction if transaction_exists" do
+      transaction = @authorize_net_reporting.transaction_details(2157585857)
+      transaction.should be_an_instance_of(AuthorizeNetReporting::AuthorizeNetTransaction)
+    end
+    it "should return nil if transaction doesn't exist" do
+      @authorize_net_reporting.transaction_details(0).should be_nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'authorize_net_reporting'

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: authorize_net_reporting
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jazmin Schroeder
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-04 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: httparty
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: "Retrieve transaction details through the Authorize.net Transaction Details API "
+email: 
+- jazminschroeder@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- README.md
+- Rakefile
+- authorize_net_reporting.gemspec
+- lib/authorize_net_reporting.rb
+- lib/authorize_net_reporting/common.rb
+- lib/authorize_net_reporting/gateway.rb
+- lib/authorize_net_reporting/report.rb
+- lib/authorize_net_reporting/response.rb
+- lib/authorize_net_reporting/version.rb
+- spec/authorize_net_reporting_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: authorize_net_reporting
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Authorize.net Transaction Details API
+test_files: []
+