pboling-remit 0.0.8 → 0.2.1

data/lib/remit/data_types.rb

@@ -1,170 +0,0 @@
-require 'rubygems'
-require 'relax'
-
-require 'remit/common'
-
-module Remit
-  class Amount < BaseResponse
-    parameter :currency_code
-    parameter :value, :type => :float
-  end
-
-  class DescriptorPolicy < BaseResponse
-    parameter :soft_descriptor_type
-    parameter :CS_number_of
-  end
-
-  class ChargeFeeTo
-    CALLER = 'Caller'
-    RECIPIENT = 'Recipient'
-  end
-
-  class Error < BaseResponse
-    parameter :code
-    parameter :message
-  end
-
-  class InstrumentStatus
-    ALL = 'ALL'
-    ACTIVE = 'Active'
-    INACTIVE = 'Inactive'
-  end
-
-  class PaymentMethods
-    BALANCE_TRANSFER = 'abt'
-    BANK_ACCOUNT = 'ach'
-    CREDIT_CARD = 'credit card'
-    PREPAID = 'prepaid'
-    DEBT = 'Debt'
-  end
-
-  class ServiceError < BaseResponse
-    parameter :error_type
-    parameter :is_retriable
-    parameter :error_code
-    parameter :reason_text
-
-    class ErrorType
-      SYSTEM = 'System'
-      BUSINESS = 'Business'
-    end
-  end
-
-  class ResponseStatus
-    SUCCESS = 'Success'
-    FAILURE = 'Failure'
-  end
-
-  class Token < BaseResponse
-    parameter :token_id
-    parameter :friendly_name
-    parameter :status
-    parameter :date_installed, :type => :time
-    parameter :caller_installed
-    parameter :caller_reference
-    parameter :token_type
-    parameter :old_token_id
-    parameter :payment_reason
-
-    class TokenStatus
-      ACTIVE = 'Active'
-      INACTIVE = 'Inactive'
-    end
-  end
-
-  class TokenUsageLimit < BaseResponse
-    parameter :count
-    parameter :limit
-    parameter :last_reset_amount
-    parameter :last_reset_count
-    parameter :last_reset_time_stamp
-  end
-
-  class TransactionResponse < BaseResponse
-    parameter :transaction_id
-    parameter :transaction_status
-
-    %w(reserved success failure pending cancelled).each do |status_name|
-      define_method("#{status_name}?") do
-        self.transaction_status == Remit::TransactionStatus.const_get(status_name.sub('_', '').upcase)
-      end
-    end
-  end
-
-  class TransactionStatus
-    RESERVED          = 'Reserved'
-    SUCCESS           = 'Success'
-    FAILURE           = 'Failure'
-    PENDING           = 'Pending'
-    CANCELLED         = 'Cancelled'
-  end
-
-  class TokenType
-    SINGLE_USE = 'SingleUse'
-    MULTI_USE = 'MultiUse'
-    RECURRING = 'Recurring'
-    UNRESTRICTED = 'Unrestricted'
-  end
-
-  class PipelineName
-    SINGLE_USE = 'SingleUse'
-    MULTI_USE = 'MultiUse'
-    RECURRING = 'Recurring'
-    RECIPIENT = 'Recipient'
-    SETUP_PREPAID = 'SetupPrepaid'
-    SETUP_POSTPAID = 'SetupPostpaid'
-    EDIT_TOKEN = 'EditToken'
-  end
-
-  class PipelineStatusCode
-    CALLER_EXCEPTION  = 'CE'  # problem with your code
-    SYSTEM_ERROR      = 'SE'  # system error, try again
-    SUCCESS_ABT       = 'SA'  # successful payment with Amazon balance
-    SUCCESS_ACH       = 'SB'  # successful payment with bank transfer
-    SUCCESS_CC        = 'SC'  # successful payment with credit card
-    ABORTED           = 'A'   # user aborted payment
-    PAYMENT_METHOD_MISMATCH     = 'PE'  # user does not have payment method requested
-    PAYMENT_METHOD_UNSUPPORTED  = 'NP'  # account doesn't support requested payment method
-    INVALID_CALLER    = 'NM'  # you are not a valid 3rd party caller to the transaction
-    SUCCESS_RECIPIENT_TOKEN_INSTALLED = 'SR'
-    SUCCESS_NO_CHANGE = 'SU'  # the existing token was not changed
-  end
-
-  module RequestTypes
-    class Amount < Remit::Request
-      parameter :value
-      parameter :currency_code
-    end
-
-    class DescriptorPolicy < Remit::Request
-      parameter :soft_descriptor_type
-      parameter :CS_number_of
-    end
-    
-    #Amazon Docs list MarketplaceRefundPolicy as a ComplexDataType, but it is not.
-    #It really should be listed under Enumerated DataTypes
-    #MarketplaceTxnOnly      Caller refunds his fee to the recipient.             String
-    #MasterAndMarketplaceTxn Caller and Amazon FPS refund their fees to the       String
-    #                        sender, and the recipient refunds his amount
-    #MasterTxnOnly           Caller does not refund his fee. Amazon FPS           String
-    #                        refunds its fee and the recipient refunds his amount
-    #                        plus the caller's fee to the sender.
-    class MarketplaceRefundPolicy < Remit::Request
-      POLICY = {
-        :marketplace_txn_only => 'MarketplaceTxnOnly',
-        :master_and_marketplace_txn => 'MasterAndMarketplaceTxn',
-        :master_txn_only => 'MasterTxnOnly'
-      }
-    end
-
-  end
-
-  class Operation
-    PAY             = "Pay"
-    REFUND          = "Refund"
-    SETTLE          = "Settle"
-    SETTLE_DEBT     = "SettleDebt"
-    WRITE_OFF_DEBT  = "WriteOffDebt"
-    FUND_PREPAID    = "FundPrepaid"
-  end
-end

data/lib/remit/error_codes.rb

@@ -1,118 +0,0 @@
-# Scraped and categorized from http://docs.amazonwebservices.com/AmazonFPS/\
-# 2007-01-08/FPSDeveloperGuide/index.html?ErrorCodesTable.html. You can use
-# these categories to specify default error handling in your application such
-# as asking users to retry or sending an exception email.
-module Remit::ErrorCodes
-  class << self
-    def sender_error?(code)
-      SENDER.include? code.to_sym
-    end
-
-    def recipient_error?(code)
-      RECIPIENT.include? code.to_sym
-    end
-
-    def caller_error?(code)
-      CALLER.include?(code.to_sym)
-    end
-
-    def amazon_error?(code)
-      AMAZON.include? code.to_sym
-    end
-
-    def api_error?(code)
-      API.include? code.to_sym
-    end
-
-    def unknown_error?(code)
-      UNKNOWN.include? code.to_sym
-    end
-  end
-
-  SENDER = [
-    :InactiveAccount_Sender, # The sender's account is in suspended or closed state.
-    :InactiveInstrument, # The payment instrument used for this transaction is no longer active.
-    :InstrumentExpired, # The prepaid or the postpaid instrument has expired.
-    :InstrumentNotActive, # The prepaid or postpaid instrument used in the transaction is not active.
-    :InvalidAccountState_Sender, # Sender account cannot participate in the transaction.
-    :InvalidInstrumentForAccountType, # The sender account can use only credit cards
-    :InvalidInstrumentState, # The prepaid or credit instrument should be active
-    :InvalidTokenId_Sender, # The send token specified is either invalid or canceled or the token is not active.
-    :PaymentInstrumentNotCC, # The payment method specified in the transaction is not a credit card. You can only use a credit card for this transaction.
-    :PaymentInstrumentMissing, # There needs to be a payment instrument defined in the token which defines the payment method.
-    :TokenNotActive_Sender, # The sender token is canceled.
-    :UnverifiedAccount_Sender, # The sender's account must have a verified U.S. credit card or a verified U.S bank account before this transaction can be initiated
-    :UnverifiedBankAccount, # A verified bank account should be used for this transaction
-    :UnverifiedEmailAddress_Sender, # The sender account must have a verified e-mail address for this payment
-  ]
-
-  RECIPIENT = [
-    :InactiveAccount_Recipient, # The recipient's account is in suspended or closed state.
-    :InvalidAccountState_Recipient, # Recipient account cannot participate in the transaction
-    :InvalidRecipientRoleForAccountType, # The recipient account is not allowed to receive payments
-    :InvalidRecipientForCCTransaction, # This account cannot receive credit card payments.
-    :InvalidTokenId_Recipient, # The recipient token specified is either invalid or canceled.
-    :TokenNotActive_Recipient, # The recipient token is canceled.
-    :UnverifiedAccount_Recipient, # The recipient's account must have a verified bank account or a credit card before this transaction can be initiated.
-    :UnverifiedEmailAddress_Recipient, # The recipient account must have a verified e-mail address for receiving payments.
-  ]
-
-  CALLER = [
-    :InactiveAccount_Caller, # The caller's account is in suspended or closed state.
-    :InvalidAccountState_Caller, # The caller account cannot participate in the transaction
-    :InvalidTokenId_Caller, # The caller token specified is either invalid or canceled or the specified token is not active.
-    :TokenNotActive_Caller, # The caller token is canceled.
-    :UnverifiedEmailAddress_Caller, # The caller account must have a verified e-mail address
-  ]
-
-  AMAZON = [
-    :InternalError # A retriable error that happens due to some transient problem in the system.
-  ]
-
-  # bad syntax or logic
-  API = [
-    :AmountOutOfRange, # The transaction amount is more than the allowed range.
-    :BadRule, # One of the GK constructs is not well defined
-    :CannotSpecifyUsageForSingleUseToken, # Token usages cannot be specified for a single use token.
-    :ConcurrentModification, # A retriable error can happen due to concurrent modification of data by two processes.
-    :DuplicateRequest, # A different request associated with this caller reference already exists.
-    :IncompatibleTokens, # The transaction could not be completed because the tokens have incompatible payment instructions.
-    :InstrumentAccessDenied, # The external calling application is not the recipient for this postpaid or prepaid instrument. The caller should be the liability holder
-    :InvalidCallerReference, # The CallerReferece does not have a token associated with it.
-    :InvalidDateRange, # The end date specified is before the start date or the start date is in the future.
-    :InvalidEvent, # The event specified was not subscribed using the SubscribeForCallerNotification operation.
-    :InvalidParams, # One or more parameters in the request is invalid.
-    :InvalidPaymentInstrument, # The payment method used in the transaction is invalid.
-    :InvalidPaymentMethod, # Payment method specified in the GK construct is invalid.
-    :InvalidSenderRoleForAccountType, # This token cannot be used for this operation.
-    :InvalidTokenId, # The token that you are trying to cancel was not installed by you.
-    :InvalidTokenType, # Invalid operation performed on the token. Example, getting the token usage information on a single use token.
-    :InvalidTransactionId, # The specified transaction could not be found or the caller did not execute the transaction or this is not a Pay or Reserve call.
-    :InvalidTransactionState, # The transaction is not completed or it has been temporarily failed.
-    :InvalidUsageDuration, # The duration cannot be less than one hour.
-    :InvalidUsageLimitCount, # The usage count is null or empty.
-    :InvalidUsageStartTime, # The start time specified for the token is not valid.
-    :InvalidUsageType, # The usage type specified is invalid.
-    :OriginalTransactionIncomplete, # The original transaction is still in progress.
-    :OriginalTransactionFailed, # The original transaction has failed
-    :PaymentMethodNotDefined, # Payment method is not defined in the transaction.
-    :RefundAmountExceeded, # The refund amount is more than the refundable amount.
-    :SameTokenIdUsedMultipleTimes, # This token is already used in earlier transactions.
-    :SenderNotOriginalRecipient, # The sender in the refund transaction is not the recipient of the original transaction.
-    :SettleAmountGreaterThanReserveAmount, # The amount being settled is greater than the reserved amount.
-    :TransactionDenied, # This transaction is not allowed.
-    :TransactionExpired, # Returned when the Caller attempts to explicitly retry a transaction that is temporarily declined and is in queue for implicit retry.
-    :TransactionFullyRefundedAlready, # The complete refund for this transaction is already completed
-    :TransactionTypeNotRefundable, # You cannot refund this transaction.
-    :TokenAccessDenied, # Permission is denied to cancel the token.
-    :TokenUsageError, # The token usage limit is exceeded.
-    :UsageNotDefined, # For a multi-use token or a recurring token the usage limits are not specified in the GateKeeper text.
-  ]
-
-  # these errors don't specify who is at fault
-  UNKNOWN = [
-    :InvalidAccountState, # The account is either suspended or closed. Payment instructions cannot be installed on this account.
-    :InsufficientBalance, # The sender, caller, or recipient's account balance has insufficient funds to complete the transaction.
-    :AccountLimitsExceeded, # The spending or the receiving limit on the account is exceeded
-  ]
-end

data/lib/remit/get_pipeline.rb

@@ -1,212 +0,0 @@
-require 'erb'
-
-require 'remit/common'
-
-module Remit
-  module GetPipeline
-    class Pipeline
-      @parameters = []
-      attr_reader :parameters
-      
-      class << self
-        # Create the parameters hash for the subclass.
-        def inherited(subclass) #:nodoc:
-          subclass.instance_variable_set('@parameters', [])
-        end
-        
-        def parameter(name)
-          attr_accessor name
-          @parameters << name
-        end
-        
-        def convert_key(key)
-          key.to_s.gsub(/_(.)/) { $1.upcase }.to_sym
-        end
-        
-        # Returns a hash of all of the parameters for this request, including
-        # those that are inherited.
-        def parameters #:nodoc:
-          (superclass.respond_to?(:parameters) ? superclass.parameters : []) + @parameters
-        end
-      end
-      
-      attr_reader :api
-      
-      parameter :pipeline_name
-      parameter :return_url
-      parameter :caller_key
-      parameter :version
-      parameter :address_name
-      parameter :address_line_1
-      parameter :address_line_2
-      parameter :city
-      parameter :state
-      parameter :zip
-      parameter :country
-      parameter :phone_number
-
-      def initialize(api, options)
-        @api = api
-        
-        options.each do |k,v|
-          self.send("#{k}=", v)
-        end
-      end
-
-      def url
-        uri = URI.parse(@api.pipeline_url)
-        
-        query = {}
-        self.class.parameters.each do |p|
-          val = self.send(p)
-          
-          # Convert Time values to seconds from Epoch
-          val = val.to_i if val.is_a?(Time)
-          
-          query[self.class.convert_key(p.to_s)] = val
-        end
-
-        # Remove any unused optional parameters
-        query.reject! { |key, value| value.nil? || (value.is_a?(String) && value.empty?) }
-
-        uri.query = SignedQuery.new(@api.pipeline_url, @api.secret_key, query).to_s
-        uri.to_s
-      end
-      
-      def method_missing(method, *args)
-        if self.class.parameters.include?(method.to_sym)
-          self.send(method.to_sym)
-        else
-          super
-        end
-      end
-      
-    end
-    
-    class SingleUsePipeline < Pipeline
-      parameter :caller_reference
-      parameter :payment_reason
-      parameter :payment_method
-      parameter :transaction_amount
-      parameter :recipient_token
-      
-      def pipeline_name
-        Remit::PipelineName::SINGLE_USE
-      end
-    end
-    
-    class MultiUsePipeline < Pipeline
-      parameter :caller_reference
-      parameter :payment_reason
-      parameter :recipient_token_list
-      parameter :amount_type
-      parameter :transaction_amount
-      parameter :validity_start
-      parameter :validity_expiry
-      parameter :payment_method
-      parameter :global_amount_limit
-      parameter :usage_limit_type_1
-      parameter :usage_limit_period_1
-      parameter :usage_limit_value_1
-      parameter :usage_limit_type_2
-      parameter :usage_limit_period_2
-      parameter :usage_limit_value_2
-      parameter :is_recipient_cobranding
-      
-      def pipeline_name
-        Remit::PipelineName::MULTI_USE
-      end
-    end
-    
-    class RecipientPipeline < Pipeline
-      parameter :caller_reference
-      parameter :validity_start # Time or seconds from Epoch
-      parameter :validity_expiry # Time or seconds from Epoch
-      parameter :payment_method
-      parameter :recipient_pays_fee
-      parameter :caller_reference_refund
-      parameter :max_variable_fee
-      parameter :max_fixed_fee
-      
-      def pipeline_name
-        Remit::PipelineName::RECIPIENT
-      end
-    end
-
-    class RecurringUsePipeline < Pipeline
-      parameter :caller_reference
-      parameter :payment_reason
-      parameter :recipient_token
-      parameter :transaction_amount
-      parameter :validity_start # Time or seconds from Epoch
-      parameter :validity_expiry # Time or seconds from Epoch
-      parameter :payment_method
-      parameter :recurring_period  
-      
-      def pipeline_name
-        Remit::PipelineName::RECURRING
-      end 
-    end
-    
-    class PostpaidPipeline < Pipeline
-      parameter :caller_reference_sender
-      parameter :caller_reference_settlement
-      parameter :payment_reason
-      parameter :payment_method
-      parameter :validity_start # Time or seconds from Epoch
-      parameter :validity_expiry # Time or seconds from Epoch
-      parameter :credit_limit
-      parameter :global_amount_limit
-      parameter :usage_limit_type1
-      parameter :usage_limit_period1
-      parameter :usage_limit_value1
-      parameter :usage_limit_type2
-      parameter :usage_limit_period2
-      parameter :usage_limit_value2
-      
-      def pipeline_name
-        Remit::PipelineName::SETUP_POSTPAID
-      end
-    end
-    
-    class EditTokenPipeline < Pipeline
-      parameter :caller_reference
-      parameter :payment_method
-      parameter :token_id
-
-      def pipeline_name
-        Remit::PipelineName::EDIT_TOKEN
-      end
-    end
-    
-    def get_single_use_pipeline(options)
-      self.get_pipeline(SingleUsePipeline, options)
-    end
-
-    def get_multi_use_pipeline(options)
-      self.get_pipeline(MultiUsePipeline, {:version => Date.new(2009, 1, 9).to_s}.merge(options))
-    end
-
-    def get_recipient_pipeline(options)
-      self.get_pipeline(RecipientPipeline, {:version => Date.new(2009, 1, 9).to_s}.merge(options))
-    end
-    
-    def get_recurring_use_pipeline(options)
-      self.get_pipeline(RecurringUsePipeline, options)
-    end
-    
-    def get_postpaid_pipeline(options)
-      self.get_pipeline(PostpaidPipeline, options)
-    end
-
-    def get_edit_token_pipeline(options)
-      self.get_pipeline(EditTokenPipeline, options)
-    end
-    
-    def get_pipeline(pipeline_subclass, options)
-      pipeline = pipeline_subclass.new(self, {
-        :caller_key => @access_key
-      }.merge(options))
-    end
-  end
-end