class Object

# File lib/FraudManagement/approve-or-decline-held-transaction.rb, line 8
def approve_or_decline_held_transaction(refTransId)
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = UpdateHeldTransactionRequest.new

  request.heldTransactionRequest = HeldTransactionRequestType.new()
  request.heldTransactionRequest.action = AfdsTransactionEnum::Approve
  request.heldTransactionRequest.refTransId = "60012148061"
  
  response = transaction.update_held_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully updated transaction: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Update Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to update transaction."
      end
    else
      puts "Update transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to update transaction."
    end
  else
    puts "Response is null"
    raise "Failed to update transaction."
  end
  
  return response
end

# File lib/PayPalExpressCheckout/authorization-and-capture.rb, line 8
def authorization_and_capture()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  # Define the PayPal specific parameters
  payPalType = PayPalType.new()
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  
  paymentType = PaymentType.new()
  paymentType.payPal = payPalType

  # Construct the request object
  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = paymentType
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && (response.transactionResponse.responseCode == "1" || response.transactionResponse.responseCode == "5")
        puts "Successfully created an authorize and capture transaction."
        puts "  Response Code: #{response.transactionResponse.responseCode}" 
        puts "  Transaction ID: #{response.transactionResponse.transId}"
        puts "  Secure Acceptance URL: #{response.transactionResponse.secureAcceptance.SecureAcceptanceUrl}"
        puts "  Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "  Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "  Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "PayPal authorize and capture transaction failed"
        if response.transactionResponse.errors != nil
          puts "  Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "  Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed PayPal Authorize Capture Transaction."
      end
    else
      puts "PayPal authorize and capture transaction failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed PayPal Authorize Capture Transaction."
    end
  else
    puts "Response is null"
    raise "Failed PayPal Authorize Capture Transaction."
  end
  
  return response

end

# File lib/PayPalExpressCheckout/authorization-and-capture-continued.rb, line 8
def authorization_and_capture_continued()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  
  puts "PayPal Authorization Capture-Continue Transaction"

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  payPalType = PayPalType.new
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.payerID = "M8R9JRNJ3R28Y"
  
  paymentType = PaymentType.new
  paymentType.payPal = payPalType
      
  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.refTransId = "2241762169"
  request.transactionRequest.amount = 15.00
  request.transactionRequest.payment = paymentType
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureContinueTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully created an Authorization Capture-Continue transaction (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to make purchase."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to make purchase."
    end
  else
    puts "Response is null"
    raise "Failed to make purchase."
  end

  return response

end

# File lib/PayPalExpressCheckout/authorization-only.rb, line 8
def authorization_only()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  # Define the PayPal specific parameters
  payPalType = PayPalType.new()
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  
  paymentType = PaymentType.new()
  paymentType.payPal = payPalType

  # Construct the request object
  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = paymentType
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthOnlyTransaction
  
  response = transaction.create_transaction(request)


  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && (response.transactionResponse.responseCode == "1" || response.transactionResponse.responseCode == "5")
        puts "Successfully created an authorize only transaction."
        puts "  Response Code: #{response.transactionResponse.responseCode}" 
        puts "  Transaction ID: #{response.transactionResponse.transId}"
        puts "  Secure Acceptance URL: #{response.transactionResponse.secureAcceptance.SecureAcceptanceUrl}"
        puts "  Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "  Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "  Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "PayPal authorize only transaction failed"
        if response.transactionResponse.errors != nil
          puts "  Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "  Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed PayPal Authorize Only Transaction."
      end
    else
      puts "PayPal authorize only transaction failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed PayPal Authorize Only Transaction."
    end
  else
    puts "Response is null"
    raise "Failed PayPal Authorize Only Transaction."
  end    
  
  return response

end

# File lib/PayPalExpressCheckout/authorization-only-continued.rb, line 8
def authorization_only_continued(transId)
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new
  
  payPalType = PayPalType.new()
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  #payerID should be taken from GetDetails
  payPalType.payerID = "S6D5ETGSVYX94"
  
  #standard api call to retrieve response
  paymentType = PaymentType.new()
  paymentType.payPal = payPalType
  
  request.transactionRequest = TransactionRequestType.new()
  #request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = paymentType
  #refTransId should be taken from the transId returned by AuthOnly
  request.transactionRequest.refTransId = transId
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthOnlyContinueTransaction 
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successful AuthOnly Transaction (Transaction response code: #{response.transactionResponse.responseCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        puts "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      puts "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end
    
  return response
  
end

# File lib/PaymentTransactions/authorize-credit-card.rb, line 8
def authorize_credit_card()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config["api_login_id"], config["api_transaction_key"], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new("4242424242424242","0728","123")
  request.transactionRequest.customer = CustomerDataType.new(CustomerTypeEnum::Individual,"CUST-1234","bmc@mail.com",DriversLicenseType.new("DrivLicenseNumber123","WA","05/05/1990"),"123456789")
  request.transactionRequest.billTo = CustomerAddressType.new("firstNameBT","lastNameBT","companyBT","addressBT","New York","NY",
        "10010","USA","2121111111","2121111111")
  request.transactionRequest.shipTo = NameAndAddressType.new("firstNameST","lastNameST","companyST","addressST","New York","NY",
        "10010","USA")
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthOnlyTransaction
  request.transactionRequest.order = OrderType.new("invoiceNumber#{(SecureRandom.random_number*1000000).round(0)}","Order Description")    
  
  # tax, duty, and shipping are all instances of ExtendedAmountType
  # Arguments for ExtendedAmountType.new are amount, name, description
  request.transactionRequest.tax = ExtendedAmountType.new("0.99","Sales tax","Local municipality sales tax")
  # Or, you can specify the components one at a time:
  request.transactionRequest.shipping = ExtendedAmountType.new
  request.transactionRequest.shipping.amount = "5.20"
  request.transactionRequest.shipping.name = "Shipping charges"
  request.transactionRequest.shipping.description = "Ultra-fast 3 day shipping"

  # Build an array of line items
  lineItemArr = Array.new
  # Arguments for LineItemType.new are itemId, name, description, quanitity, unitPrice, taxable
  lineItem = LineItemType.new("SampleItemId","SampleName","SampleDescription","1","10.00","true")
  lineItemArr.push(lineItem)
  # Or, you can specify the components one at a time:
  lineItem = LineItemType.new
  lineItem.itemId = "1234"
  lineItem.name = "Line Item 2"
  lineItem.description = "another line item"
  lineItem.quantity = "2"
  lineItem.unitPrice = "2.95"
  lineItem.taxable = "false"
  lineItemArr.push(lineItem)
  request.transactionRequest.lineItems = LineItems.new(lineItemArr)

  # Build an array of user fields
  userFieldArr = Array.new
  requestUserField = UserField.new("userFieldName","userFieldvalue")
  userFieldArr.push(requestUserField)
  requestUserField = UserField.new("userFieldName1","userFieldvalue1")
  userFieldArr.push(requestUserField)
  request.transactionRequest.userFields = UserFields.new(userFieldArr)

  response = transaction.create_transaction(request)
  
  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully created an AuthOnly Transaction (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction ID: #{response.transactionResponse.transId}"
        puts "Transaction Response Code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
        puts "User Fields: "
        response.transactionResponse.userFields.userFields.each do |userField|
          puts userField.value
        end
      else
        puts "Transaction Failed" 
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end

  return response
end

# File lib/RecurringBilling/cancel-subscription.rb, line 8
def cancel_subscription(subscriptionId = '2790501',refId = '2238251168')
     config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
     transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
    #subscription = Subscription.new(config['api_login_id'], config['api_subscription_key'], :gateway => :sandbox)
    
      request = ARBCancelSubscriptionRequest.new
      request.refId = refId
      request.subscriptionId = subscriptionId
    
      response = transaction.cancel_subscription(request)
    
    if response != nil
      if response.messages.resultCode == MessageTypeEnum::Ok
        puts "Successfully cancelled a subscription."
        puts "  Response code: #{response.messages.messages[0].code}"
        puts "  Response message: #{response.messages.messages[0].text}"
      end
    
    else
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to cancel a subscription"
    end
    return response
end

# File lib/PaymentTransactions/capture-funds-authorized-through-another-channel.rb, line 8
def capture_funds_authorized_through_another_channel()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new('4111111111111111','0728') 
  request.transactionRequest.transactionType = TransactionTypeEnum::CaptureOnlyTransaction
  request.transactionRequest.authCode = "ROHNFQ"
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully created an AuthOnly Transaction (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end
  
  return response
end

# File lib/PaymentTransactions/capture-previously-authorized-amount.rb, line 8
def capture_previously_authorized_amount()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  # Do an AuthOnly Transaction first, so we can capture it separately
  request.transactionRequest = TransactionRequestType.new()
  random_amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.amount = random_amount
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new('4242424242424242','0728','123') 
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthOnlyTransaction
  
  response = transaction.create_transaction(request)

  authTransId = response.transactionResponse.transId

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully created an AuthOnly Transaction (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
        puts "Transaction ID: #{response.transactionResponse.transId} (for later capture)"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = random_amount
  request.transactionRequest.refTransId = authTransId
  request.transactionRequest.transactionType = TransactionTypeEnum::PriorAuthCaptureTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully captured the authorized amount (Transaction ID: #{response.transactionResponse.transId})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to capture."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to capture."
    end
  else
    puts "Response is null"
    raise "Failed to capture."
  end
  
  return response
end

# File lib/PaymentTransactions/charge-credit-card.rb, line 8
def charge_credit_card()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config["api_login_id"], config["api_transaction_key"], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new("4242424242424242","0728","123") 
  request.transactionRequest.customer = CustomerDataType.new(CustomerTypeEnum::Individual,"CUST-1234","bmc@mail.com",DriversLicenseType.new("DrivLicenseNumber123","WA","05/05/1990"),"123456789")
  request.transactionRequest.billTo = CustomerAddressType.new("firstNameBT","lastNameBT","companyBT","addressBT","New York","NY",
        "10010","USA","2121111111","2121111111")
  request.transactionRequest.shipTo = NameAndAddressType.new("firstNameST","lastNameST","companyST","addressST","New York","NY",
        "10010","USA")
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  request.transactionRequest.order = OrderType.new("invoiceNumber#{(SecureRandom.random_number*1000000).round(0)}","Order Description")    
  
  # tax, duty, and shipping are all instances of ExtendedAmountType
  # Arguments for ExtendedAmountType.new are amount, name, description
  request.transactionRequest.tax = ExtendedAmountType.new("0.99","Sales tax","Local municipality sales tax")
  # Or, you can specify the components one at a time:
  request.transactionRequest.shipping = ExtendedAmountType.new
  request.transactionRequest.shipping.amount = "5.20"
  request.transactionRequest.shipping.name = "Shipping charges"
  request.transactionRequest.shipping.description = "Ultra-fast 3 day shipping"

  # Build an array of line items
  lineItemArr = Array.new
  # Arguments for LineItemType.new are itemId, name, description, quanitity, unitPrice, taxable
  lineItem = LineItemType.new("SampleItemId","SampleName","SampleDescription","1","10.00","true")
  lineItemArr.push(lineItem)
  # Or, you can specify the components one at a time:
  lineItem = LineItemType.new
  lineItem.itemId = "1234"
  lineItem.name = "Line Item 2"
  lineItem.description = "another line item"
  lineItem.quantity = "2"
  lineItem.unitPrice = "2.95"
  lineItem.taxable = "false"
  lineItemArr.push(lineItem)
  request.transactionRequest.lineItems = LineItems.new(lineItemArr)

  # Build an array of user fields
  userFieldArr = Array.new
  requestUserField = UserField.new("userFieldName","userFieldvalue")
  userFieldArr.push(requestUserField)
  requestUserField = UserField.new("userFieldName1","userFieldvalue1")
  userFieldArr.push(requestUserField)
  request.transactionRequest.userFields = UserFields.new(userFieldArr)


  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successful charge (auth + capture) (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction ID: #{response.transactionResponse.transId}"
        puts "Transaction Response Code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
        puts "User Fields: "
        response.transactionResponse.userFields.userFields.each do |userField|
          puts userField.value
        end
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to charge card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to charge card."
    end
  else
    puts "Response is null"
    raise "Failed to charge card."
  end
  
  return response
end

# File lib/PaymentTransactions/charge-customer-profile.rb, line 8
def charge_customer_profile(customerProfileId = '36731856', customerPaymentProfileId = '33211899')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  request.transactionRequest.order = OrderType.new("invoiceNumber#{(SecureRandom.random_number*1000000).round(0)}","Order Description")    
  request.transactionRequest.profile = CustomerProfilePaymentType.new
  request.transactionRequest.profile.customerProfileId = customerProfileId
  request.transactionRequest.profile.paymentProfile = PaymentProfile.new(customerPaymentProfileId)

  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Success, Auth Code: #{response.transactionResponse.authCode}"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to charge customer profile."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to charge customer profile."
    end
  else
    puts "Response is null"
    raise "Failed to charge customer profile."
  end

  return response
end

# File lib/PaymentTransactions/charge-tokenized-credit-card.rb, line 8
def charge_tokenized_credit_card()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new('4242424242424242','0728','123',nil,"EjRWeJASNFZ4kBI0VniQEjRWeJA=") 
  request.transactionRequest.order = OrderType.new("invoiceNumber#{(SecureRandom.random_number*1000000).round(0)}","Order Description")    
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully charged tokenized credit card (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to charge tokenized credit card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to charge tokenized credit card."
    end
  else
    puts "Response is null"
    raise "Failed to charge tokenized credit card."
  end
      
  return response
end

# File lib/RecurringBilling/create-subscription.rb, line 8
def create_Subscription()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  #subscription = Subscription.new(config['api_login_id'], config['api_subscription_key'], :gateway => :sandbox)

  request = ARBCreateSubscriptionRequest.new
  request.refId = DateTime.now.to_s[-8]
  request.subscription = ARBSubscriptionType.new
  request.subscription.name = "Jane Doe"
  request.subscription.paymentSchedule = PaymentScheduleType.new
  request.subscription.paymentSchedule.interval = PaymentScheduleType::Interval.new("3","months")
  request.subscription.paymentSchedule.startDate = (DateTime.now).to_s[0...10]
  request.subscription.paymentSchedule.totalOccurrences ='12'
  request.subscription.paymentSchedule.trialOccurrences ='1'

  random_amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.subscription.amount = random_amount
  request.subscription.trialAmount = 0.00
  request.subscription.payment = PaymentType.new
  request.subscription.payment.creditCard = CreditCardType.new('4111111111111111','0728','123')

  request.subscription.order = OrderType.new('invoiceNumber123','description123')
  request.subscription.customer = CustomerType.new(CustomerTypeEnum::Individual,'custId1','a@a.com')
  request.subscription.billTo = NameAndAddressType.new('John','Doe','xyt','10800 Blue St','New York','NY','10010','USA')
  request.subscription.shipTo = NameAndAddressType.new('John','Doe','xyt','10800 Blue St','New York','NY','10010','USA')

  response = transaction.create_subscription(request)
   
  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully created a subscription with ID #{response.subscriptionId}."
  
    else
      #puts response.transactionResponse.errors.errors[0].errorCode
      #puts response.transactionResponse.errors.errors[0].errorText
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to create a subscription."
    end
  end
  return response
end

# File lib/PaymentTransactions/create-an-accept-payment-transaction.rb, line 8
def create_an_accept_payment_transaction()
  puts File.dirname(__FILE__)
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.opaqueData = OpaqueDataType.new('COMMON.ACCEPT.INAPP.PAYMENT','eyJjb2RlIjoiNTBfMl8wNjAwMDUzQTczNERGMDY0MUMyMzUxMkIyQTM2MUE3QTBFQUQ4NTIxQ0EzQjM3MUU1REMyMjlEQkYwMjRERjI5QzdFOTJBMDIzNzJGRDVDQkI0ODRDMTQ2NDYyQ0U4NkFCRjA0Q0Y3IiwidG9rZW4iOiI5NTM5MzYyNzY1NjM2NTgyODA0NjA0IiwidiI6IjEuMSJ9') 
  request.transactionRequest.customer = CustomerDataType.new(nil,nil,'bmc@mail.com')
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  request.transactionRequest.order = OrderType.new("invoiceNumber#{(SecureRandom.random_number*1000000).round(0)}","Order Description")    
  
  response = transaction.create_transaction(request)

  # if response != nil
  #   if response.messages.resultCode == MessageTypeEnum::Ok
  #     if response.transactionResponse != nil && response.transactionResponse.messages != nil
  #       puts "Successful charge (auth + capture) (authorization code: #{response.transactionResponse.authCode})"
  #       puts "Transaction Response code: #{response.transactionResponse.responseCode}"
  #       puts "Code: #{response.transactionResponse.messages.messages[0].code}"
              #       puts "Description: #{response.transactionResponse.messages.messages[0].description}"
  #     else
  #       puts "Transaction Failed"
  #       if response.transactionResponse.errors != nil
  #         puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
  #         puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
  #       end
  #       raise "Failed to charge card."
  #     end
  #   else
  #     puts "Transaction Failed"
  #     if response.transactionResponse != nil && response.transactionResponse.errors != nil
  #       puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
  #       puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
  #     else
  #       puts "Error Code: #{response.messages.messages[0].code}"
  #       puts "Error Message: #{response.messages.messages[0].text}"
  #     end
  #     raise "Failed to charge card."
  #   end
  # else
  #   puts "Response is null"
  #   raise "Failed to charge card."
  # end
  
  return response
end

# File lib/MobileInAppTransactions/create-an-accept-transaction.rb, line 8
def create_an_accept_transaction()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.opaqueData  = OpaqueDataType.new('COMMON.ACCEPT.INAPP.PAYMENT','9479246682350209005001',nil)

  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction

  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully made a purchase (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to make a purchase."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to make a purchase."
    end
  else
    puts "Response is null"
    raise "Failed to make a purchase."
  end

  return response
end

# File lib/MobileInAppTransactions/create-an-android-pay-transaction.rb, line 8
def create_an_android_pay_transaction()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.opaqueData  = OpaqueDataType.new('COMMON.ANDROID.INAPP.PAYMENT','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',nil)

  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction

  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully made a purchase (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to make purchase."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to make purchase."
    end
  else
    puts "Response is null"
    raise "Failed to make purchase."
  end

  return response
end

# File lib/MobileInAppTransactions/create-an-apple-pay-transaction.rb, line 8
def create_an_apple_pay_transaction()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.opaqueData  = OpaqueDataType.new('COMMON.APPLE.INAPP.PAYMENT','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',nil)
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction

  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully made a purchase (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to make purchase."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to make purchase."
    end
  else
    puts "Response is null"
    raise "Failed to make purchase."
  end

  return response
end

# File lib/CustomerProfiles/create-customer-payment-profile.rb, line 8
def create_customer_payment_profile(customerProfileId = '1813343337')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  # Build the payment object
  payment = PaymentType.new(CreditCardType.new)
  payment.creditCard.cardNumber = '4111111111111111'
  payment.creditCard.expirationDate = '2022-05'

  # Build an address object
  billTo = CustomerAddressType.new
  billTo.firstName = "Jerry"
  billTo.lastName = "Johnson"
  billTo.company = "Souveniropolis"
  billTo.address = "14 Main Street"
  billTo.city = "Pecan Springs"
  billTo.state = "TX"
  billTo.zip = "44628"
  billTo.country = "US"
  billTo.phoneNumber = "999-999-9999"
  billTo.faxNumber = "999-999-9999"

  # Use the previously defined payment and billTo objects to
  # build a payment profile to send with the request
  paymentProfile = CustomerPaymentProfileType.new
  paymentProfile.payment = payment
  paymentProfile.billTo = billTo
  paymentProfile.defaultPaymentProfile = true

  # Build the request object
  request = CreateCustomerPaymentProfileRequest.new
  request.paymentProfile = paymentProfile
  request.customerProfileId = customerProfileId
  request.validationMode = ValidationModeEnum::LiveMode        

  response = transaction.create_customer_payment_profile(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully created a customer payment profile with id: #{response.customerPaymentProfileId}."
    else
      puts response.messages.messages[0].code        
      puts response.messages.messages[0].text
      puts "Failed to create a new customer payment profile."
    end
  else
    puts "Response is null"
    raise "Failed to create a new customer payment profile."
  end
  return response
end

# File lib/CustomerProfiles/create-customer-profile.rb, line 8
def create_customer_profile()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  # Build the payment object
  payment = PaymentType.new(CreditCardType.new)
  payment.creditCard.cardNumber = '4111111111111111'
  payment.creditCard.expirationDate = '2020-05'

  # Build an address object
  billTo = CustomerAddressType.new
  billTo.firstName = "Ellen"
  billTo.lastName = "Johnson"
  billTo.company = "Souveniropolis"
  billTo.address = "14 Main Street"
  billTo.city = "Pecan Springs"
  billTo.state = "TX"
  billTo.zip = "44628"
  billTo.country = "US"
  billTo.phoneNumber = "999-999-9999"
  billTo.faxNumber = "999-999-9999"

  # Use the previously defined payment and billTo objects to
  # build a payment profile to send with the request
  paymentProfile = CustomerPaymentProfileType.new
  paymentProfile.payment = payment
  paymentProfile.billTo = billTo
  paymentProfile.defaultPaymentProfile = true

  # Build a shipping address  to send with the request
  shippingAddress = CustomerAddressType.new
  shippingAddress.firstName = "John"
  shippingAddress.lastName = "Snow"
  shippingAddress.company = "Night's Watch, Inc."
  shippingAddress.address = "Castle Black"
  shippingAddress.city = "The Wall"
  shippingAddress.state = "North Westeros"
  shippingAddress.zip = "99499"
  shippingAddress.country = "Westeros"
  shippingAddress.phoneNumber = "999-999-9999"
  shippingAddress.faxNumber = "999-999-9999"

  # Build the request object
  request = CreateCustomerProfileRequest.new
  # Build the profile object containing the main information about the customer profile
  request.profile = CustomerProfileType.new
  request.profile.merchantCustomerId = 'jdoe' + rand(10000).to_s
  request.profile.description = 'John2 Doe'
  request.profile.email = rand(10000).to_s + '@mail.com'
  # Add the payment profile and shipping profile defined previously
  request.profile.paymentProfiles = [paymentProfile]
  request.profile.shipToList = [shippingAddress]    
  request.validationMode = ValidationModeEnum::LiveMode    

  response = transaction.create_customer_profile(request)
  puts response.messages.resultCode

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully created a customer profile with id: #{response.customerProfileId}"
      puts "  Customer Payment Profile Id List:"
      response.customerPaymentProfileIdList.numericString.each do |id|
        puts "    #{id}"
      end
      puts "  Customer Shipping Address Id List:"
      response.customerShippingAddressIdList.numericString.each do |id|
        puts "    #{id}"
      end
      puts 
    else
      puts response.messages.messages[0].code        
      puts response.messages.messages[0].text
      raise "Failed to create a new customer profile."
    end
  else
    puts "Response is null"
    raise "Failed to create a new customer profile."
  end

  return response
end

# File lib/CustomerProfiles/create-customer-profile-from-transaction.rb, line 8
def create_customer_profile_from_a_transaction(transId = 60031516226)
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = CreateCustomerProfileFromTransactionRequest.new
  request.transId = transId
      
  # You can either specify the customer information to create a new customer profile
  # or, specify an existing customer profile ID to create a new customer payment profile
  # attached to the existing customer profile. If no profile information is specified,
  # a new profile will still be created as long as either an ID or email exists in the
  # original transaction that can be used to identify a new profile.
  #
  # To create a new customer profile containing a payment profile with this transaction's
  # payment information, submit the new profile information in the form of a
  # customerProfileBaseType object
  request.customer = CustomerProfileBaseType.new
  request.customer.merchantCustomerId = "1231232"
  request.customer.description = "This is a sample customer profile"
  request.customer.email = "johnsnow@castleblack.com"
  # -OR- to create a payment profile under an existing customer profile,
  # just provide the customer Profile ID
  # customerProfileId = "123343"
      
  response = transaction.create_customer_profile_from_transaction(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully created a customer profile from transaction ID #{transId}"
    puts "Customer profile ID: #{response.customerProfileId}"
    puts "New customer payment profile ID: #{response.customerPaymentProfileIdList.numericString[0]}"
    puts "New customer shipping profile ID (if created): #{response.customerShippingAddressIdList.numericString[0]}"
  else
    puts response.messages.messages[0].text
    raise "Failed to create a customer profile from an existing transaction."
  end
  return response
end

# File lib/CustomerProfiles/create-customer-shipping-address.rb, line 8
def create_customer_shipping_address(customerProfileId = '1813343337')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = CreateCustomerShippingAddressRequest.new
  
  request.address = CustomerAddressType.new('John','Doe')
  request.customerProfileId = customerProfileId
  response = transaction.create_customer_shipping_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully created a customer shipping address with id:  #{response.customerAddressId}."
  else
    puts "Failed to create a new customer shipping address: #{response.messages.messages[0].text}"      
  end
  return response
end

# File lib/RecurringBilling/create-subscription-from-customer-profile.rb, line 8
def create_subscription_from_customer_profile(profileId = "123213", paymentProfileId = "123213", addressId = "123213")
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  #subscription = Subscription.new(config['api_login_id'], config['api_subscription_key'], :gateway => :sandbox)

  request = ARBCreateSubscriptionRequest.new
  request.refId = DateTime.now.to_s[-8]
  request.subscription = ARBSubscriptionType.new
  request.subscription.name = "Jane Doe"
  request.subscription.paymentSchedule = PaymentScheduleType.new
  request.subscription.paymentSchedule.interval = PaymentScheduleType::Interval.new("3","months")
  request.subscription.paymentSchedule.startDate = (DateTime.now).to_s[0...10]
  request.subscription.paymentSchedule.totalOccurrences ='12'
  request.subscription.paymentSchedule.trialOccurrences ='1'

  random_amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.subscription.amount = random_amount
  request.subscription.trialAmount = 0.00

      request.subscription.profile = CustomerProfileIdType.new
      request.subscription.profile.customerProfileId = profileId
  request.subscription.profile.customerPaymentProfileId = paymentProfileId
  request.subscription.profile.customerAddressId = addressId
      
  response = transaction.create_subscription(request)
      
  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully created a subscription with ID #{response.subscriptionId}."
    else
      # puts response.transactionResponse.errors.errors[0].errorCode
      # puts response.transactionResponse.errors.errors[0].errorText
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to create a subscription"
    end
  end
  return response
end

# File lib/VisaCheckout/create-visa-checkout-transaction.rb, line 8
def create_visa_checkout_transaction()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = 16.00
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.opaqueData = OpaqueDataType.new('COMMON.VCO.ONLINE.PAYMENT','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','nxmC7ZfWoAOHx2luMPW+G8xnXMkvDJcRgoAbBOuQrAfG+OnEmgzht3B7AzhjegzmqjtYpVYhjoCNzEjwZv+5AyaeNhAeny9mkx4h5Dc+XIrCT2GB4Q8BBI9AO7XtTd2V')
  request.transactionRequest.callId = '2751969838440085201'
  
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction

  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully made a purchase (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to make purchase."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to make purchase."
    end
  else
    puts "Response is null"
    raise "Failed to make purchase."
  end
    
  return response
end

# File lib/PayPalExpressCheckout/credit.rb, line 8
def credit()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  request = CreateTransactionRequest.new
  
  payPalType = PayPalType.new()
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  
  #standard api call to retrieve response
  paymentType = PaymentType.new()
  paymentType.payPal = payPalType
  
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = paymentType
  #refTransId for which credit has to happen
  request.transactionRequest.refTransId = "2241762126"
  request.transactionRequest.transactionType = TransactionTypeEnum::RefundTransaction 
  response = transaction.create_transaction(request)
  
  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successful Credit Transaction (Transaction response code: #{response.transactionResponse.responseCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end    
  
  return response
end

# File lib/PaymentTransactions/credit-bank-account.rb, line 8
def credit_bank_account()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 15 ).round(2)
  request.transactionRequest.payment = PaymentType.new
      #Generate random bank account number
      randomAccountNumber= Random.rand(100000000..9999999999).to_s;
  request.transactionRequest.payment.bankAccount = BankAccountType.new('checking', '122000661', "'#{randomAccountNumber}'", 'John Doe','PPD','Wells Fargo Bank NA','101') 
  request.transactionRequest.transactionType = TransactionTypeEnum::RefundTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && (response.transactionResponse.messages != nil)
        puts "Successfully credited (Transaction ID: #{response.transactionResponse.transId})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        puts "Failed to credit bank account."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      puts "Failed to credit bank account."
    end
  else
    puts "Response is null"
    raise "Failed to credit bank account."
  end
      
  return response
end

# File lib/PaymentTransactions/debit-bank-account.rb, line 8
def debit_bank_account()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 15 ).round(2)
  request.transactionRequest.payment = PaymentType.new
      #Generate random bank account number
      randomAccountNumber= Random.rand(100000000..9999999999).to_s;
  request.transactionRequest.payment.bankAccount = BankAccountType.new('checking','122000661',"'#{randomAccountNumber}'", 'John Doe','WEB','Wells Fargo Bank NA','101') 
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  request.transactionRequest.order = OrderType.new("invoiceNumber#{(SecureRandom.random_number*1000000).round(0)}","Order Description")    

  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && (response.transactionResponse.messages != nil)
        puts "Successfully debited bank account."
        puts "  Transaction ID: #{response.transactionResponse.transId}"
        puts "  Transaction response code: #{response.transactionResponse.responseCode}"
        puts "  Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "  Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        puts "Transaction response code: #{response.transactionResponse.responseCode}"          
        if response.transactionResponse.errors != nil
          puts "  Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "  Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        puts "Failed to debit bank account."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "  Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "  Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "  Error Code: #{response.messages.messages[0].code}"
        puts "  Error Message: #{response.messages.messages[0].text}"
      end
      puts "Failed to debit bank account."
    end
  else
    puts "Response is null"
    raise "Failed to debit bank account."
  end

  return response
end

# File lib/VisaCheckout/decrypt-visa-checkout-data.rb, line 8
def decrypt_visa_checkout_data()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = DecryptPaymentDataRequest.new
  request.opaqueData =  OpaqueDataType.new('COMMON.VCO.ONLINE.PAYMENT','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','KCSJeIab7wwH7mFcPM/YL+V9xBCDe4CmSjJ0MPHEodpWz4rmz78U8bR4Qqs1ipLBqH9mrfvLF4pytIcLOjKUtXvAII/xCze84INFMdtsVBgtEp5bZ4leehRQhNM+3/NH')
  request.callId = '1238408836021304101'

  response = transaction.decrypt_payment_data(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully decrypted data (Card Number: #{response.cardInfo.cardNumber})"
    puts "Billing Last Name #{response.billingInfo.lastName}"
    puts "Shipping Last Name #{response.shippingInfo.lastName}"
    puts "Amount #{response.paymentDetails.amount}"
  else
    puts response.messages.messages[0].code
    puts response.messages.messages[0].text
    raise "Failed to decrypt."
  end
  
  return response

end

# File lib/CustomerProfiles/delete-customer-payment-profile.rb, line 8
def delete_customer_payment_profile(customerProfileId='35894174', customerPaymentProfileId='33604709')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = DeleteCustomerPaymentProfileRequest.new
  request.customerProfileId = customerProfileId
  request.customerPaymentProfileId = customerPaymentProfileId

  response = transaction.delete_customer_payment_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully deleted payment profile with customer payment profile ID #{request.customerPaymentProfileId}."
  else
    puts "Failed to delete payment profile with profile ID #{request.customerPaymentProfileId}: #{response.messages.messages[0].text}"
  end
  return response
end

# File lib/CustomerProfiles/delete-customer-profile.rb, line 8
def delete_customer_profile(customerProfileId = '36551110')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = DeleteCustomerProfileRequest.new
  request.customerProfileId = customerProfileId

  response = transaction.delete_customer_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully deleted customer with customer profile ID #{request.customerProfileId}."
  else
    puts response.messages.messages[0].text
    raise "Failed to delete customer with customer profile ID #{request.customerProfileId}."
  end
  return response
end

# File lib/CustomerProfiles/delete-customer-shipping-address.rb, line 8
def delete_customer_shipping_address(customerProfileId = '36551110', customerAddressId = '35894174')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = DeleteCustomerShippingAddressRequest.new
  request.customerProfileId = customerProfileId
  request.customerAddressId = customerAddressId

  response = transaction.delete_customer_shipping_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully deleted shipping address with customer shipping profile ID #{request.customerAddressId}."
  else
    puts response.messages.messages[0].text
    raise "Failed to delete payment profile with profile ID #{request.customerAddressId}."
  end
  return response
end

# File lib/TransactionReporting/get-customer-profile-transaction-list.rb, line 8
def get_Transaction_List_For_Customer(customerProfileId = '40036377')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction1 = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = AuthorizeNet::API::GetTransactionListForCustomerRequest.new
  request.customerProfileId = customerProfileId
  request.paging = Paging.new;
  request.paging.limit = 10;
  request.paging.offset = 1;

  request.sorting = TransactionListSorting.new;
  request.sorting.orderBy = "id";
  request.sorting.orderDescending = true;

  response = transaction1.get_transaction_list_for_customer(request)
  
  if response.messages.resultCode == MessageTypeEnum::Ok
      transactions = response.transactions
      if transactions == nil
              puts "#{response.messages.messages[0].text}"
      else
      response.transactions.transaction.each do |trans|
                   puts "\nTransaction ID :  #{trans.transId} "
                   puts "Submitted on (Local) :  %s " % [trans.submitTimeUTC]
                   puts "Status :  #{trans.transactionStatus} "
                   puts "Settle Amount :  %.2f " % [trans.settleAmount]
           end
      end
  else
      puts "Error: Failed to get Transaction List for customer\n"
      puts "Error Text :  #{response.messages.messages[0].text} \n"
      puts "Error Code :  #{response.messages.messages[0].code} "
  end
  return response

end

# File lib/CustomerProfiles/get-accept-customer-profile-page.rb, line 8
def get_accept_customer_profile_page(customerProfileId = '37696245')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  setting = SettingType.new
  setting.settingName = SettingNameEnum::HostedProfileReturnUrl
  setting.settingValue = "https://returnurl.com/return/"
  
  settings = Settings.new([setting])
  
  
  request = GetHostedProfilePageRequest.new
  request.customerProfileId = customerProfileId
  request.refId = ""
  request.hostedProfileSettings = settings
  
  response = transaction.get_hosted_profile_page(request)
  
  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully got Accept Customer page token."
    puts "  Response code: #{response.messages.messages[0].code}"
    puts "  Response message: #{response.messages.messages[0].text}"
    puts "  Token: #{response.token}"
  else
    puts "#{response.messages.messages[0].code}"
    puts "#{response.messages.messages[0].text}"
    raise "Failed to get hosted profile page with customer profile ID #{request.customerProfileId}"
  end
  return response
end

# File lib/PaymentTransactions/get-an-accept-payment-page.rb, line 8
def get_an_accept_payment_page()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  transactionRequest = TransactionRequestType.new
  transactionRequest.amount = 12.12
  transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  
  setting1 = SettingType.new
  setting1.settingName = SettingNameEnum::HostedPaymentButtonOptions
  setting1.settingValue = "{\"text\": \"Pay\"}"

  setting2 = SettingType.new
  setting2.settingName = SettingNameEnum::HostedPaymentOrderOptions
  setting2.settingValue = "{\"show\": false}"
  
  settings = Settings.new([ setting1, setting2])
  
  request = GetHostedPaymentPageRequest.new
  request.transactionRequest = transactionRequest
  request.hostedPaymentSettings = settings
  
  response = transaction.get_hosted_payment_page(request)
  
  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "#{response.messages.messages[0].code}"
    puts "#{response.messages.messages[0].text}"
    puts "#{response.token}"
  else
    puts "#{response.messages.messages[0].code}"
    puts "#{response.messages.messages[0].text}"
    raise "Failed to get hosted payment page"
  end
  return response
end

# File lib/TransactionReporting/get-batch-statistics.rb, line 8
def get_batch_Statistics(batchId = "7889547")
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  
  transaction = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  request = GetBatchStatisticsRequest.new
  request.batchId = batchId
  
  #standard api call to retrieve response
  response = transaction.get_batch_statistics(request)
  
  
if response != nil
  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully got the list of batch statistics."
    puts response.messages.messages[0].code
    puts response.messages.messages[0].text
    puts response.batch.batchId
    puts response.batch.settlementTimeUTC
    puts response.batch.settlementTimeLocal
    puts response.batch.settlementState
    puts response.batch.paymentMethod
    for i in 0..response.batch.statistics.length-1
      puts "Statistic Details::"
      puts "Account Type: " + response.batch.statistics[i].accountType.to_s
      puts "Charge Amount: " + response.batch.statistics[i].chargeAmount.to_s
      puts "Charge Count: " + response.batch.statistics[i].chargeCount.to_s
      puts "Refund Amount: " + response.batch.statistics[i].refundAmount.to_s
      puts "Refund Count: " + response.batch.statistics[i].refundCount.to_s
      puts "Void Count: " + response.batch.statistics[i].voidCount.to_s
      puts "Decline Count: " + response.batch.statistics[i].declineCount.to_s
      puts "Error Count: " + response.batch.statistics[i].errorCount.to_s
    end
    

  else

    puts response.messages.messages[0].code
    puts response.messages.messages[0].text
    raise "Failed to get the batch statistics"
  end
end

return response

end

# File lib/CustomerProfiles/get-customer-payment-profile.rb, line 8
def get_customer_payment_profile(customerProfileId = '40036377', customerPaymentProfileId = '36315992')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = GetCustomerPaymentProfileRequest.new
  request.customerProfileId = customerProfileId
  request.customerPaymentProfileId = customerPaymentProfileId

  response = transaction.get_customer_payment_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully retrieved a payment profile with profile ID #{request.customerPaymentProfileId} and whose customer ID is #{request.customerProfileId}."

    if response.paymentProfile.subscriptionIds != nil && response.paymentProfile.subscriptionIds.subscriptionId != nil
      puts "  List of subscriptions: "
      response.paymentProfile.subscriptionIds.subscriptionId.each do |subscriptionId|
        puts "#{subscriptionId}"
      end
    end

  else
    puts response.messages.messages[0].text
    raise "Failed to get payment profile information with ID #{request.customerPaymentProfileId}."
  end 
  return response
end

# File lib/CustomerProfiles/get-customer-payment-profile-list.rb, line 8
  def get_customer_payment_profile_list()
    config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

    transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
    
    searchTypeEnum = CustomerPaymentProfileSearchTypeEnum::CardsExpiringInMonth
    sorting = CustomerPaymentProfileSorting.new
    orderByEnum = CustomerPaymentProfileOrderFieldEnum::Id
    sorting.orderBy = orderByEnum
    sorting.orderDescending = false
    
    paging = Paging.new
    paging.limit = 1000
    paging.offset = 1
    
    
    request = GetCustomerPaymentProfileListRequest.new

    request.searchType = searchTypeEnum
    request.month = "2020-12"
    request.sorting = sorting
    request.paging = paging
    
    response = transaction.get_customer_payment_profile_list(request)
    
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully got customer payment profile list."
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      puts "  Total number in result set: #{response.totalNumInResultSet}"
#      response.paymentProfiles.paymentProfile.each do |paymentProfile|
#        puts "Payment profile ID = #{paymentProfile.customerPaymentProfileId}"
#        puts "First Name in Billing Address = #{paymentProfile.billTo.firstName}"
#        puts "Credit Card Number = #{paymentProfile.payment.creditCard.cardNumber}"
#      end
    else
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to get customer payment profile list"
    end
    return response
  end

# File lib/CustomerProfiles/get-customer-profile.rb, line 8
def get_customer_profile(customerProfileId = '40036377')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = GetCustomerProfileRequest.new
  request.customerProfileId = customerProfileId

  response = transaction.get_customer_profile(request)

  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully retrieved a customer with profile ID is #{request.customerProfileId} and whose customer ID is #{response.profile.merchantCustomerId}."
    response.profile.paymentProfiles.each do |paymentProfile|
      puts "  Payment Profile ID #{paymentProfile.customerPaymentProfileId}" 
      puts "  Payment Details:"
      if paymentProfile.billTo != nil
        puts "    Last Name: #{paymentProfile.billTo.lastName}"
        puts "    Address: #{paymentProfile.billTo.address}"    
      end
    end
    response.profile.shipToList.each do |ship|
      puts "  Shipping Address ID #{ship.customerAddressId}"
      puts "  Shipping Details:"
      puts "    First Name: #{ship.firstName}"
      puts "    Last Name: #{ship.lastName}"
      puts "    Address: #{ship.address}"
    end

    if response.subscriptionIds != nil && response.subscriptionIds.subscriptionId != nil
      puts "  List of subscriptions: "
      response.subscriptionIds.subscriptionId.each do |subscriptionId|
        puts "    #{subscriptionId}"
      end
    end

  else
    puts response.messages.messages[0].text
    raise "Failed to get customer profile information with ID #{request.customerProfileId}"
  end
  return response
end

# File lib/CustomerProfiles/get-customer-profile-ids.rb, line 8
def get_customer_profile_ids()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = GetCustomerProfileIdsRequest.new

  response = transaction.get_customer_profile_ids(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully retrieved customer IDs."
    puts "  Number of IDs returned: #{response.ids.numericString.count}"
    # There's no paging options in this API request; the full list is returned every call.
    # If the result set is going to be large, for this sample we'll break it down into smaller
    # chunks so that we don't put 72,000 lines into a log file
    puts "  First 20 results:"
    for profileId in 0..19 do
      puts "    #{response.ids.numericString[profileId]}"
    end
    # If we wanted to just return the whole list, we'd do something like this:
    #
    # response.ids.numericString.each do |id|
    #   puts id
    # end

  else
    puts response.messages.messages[0].text
    raise "Failed to get customer IDs."
  end
  return response
end

# File lib/CustomerProfiles/get-customer-shipping-address.rb, line 8
def get_customer_shipping_address(customerProfileId = '40036377', customerAddressId = '37808097')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = GetCustomerShippingAddressRequest.new
  request.customerProfileId = customerProfileId
  request.customerAddressId = customerAddressId

  response = transaction.get_customer_shipping_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully retrieved a shipping address with profile ID #{request.customerAddressId} and whose customer ID is #{request.customerProfileId}."

    if response.subscriptionIds != nil && response.subscriptionIds.subscriptionId != nil
      puts "  List of subscriptions: "
      response.subscriptionIds.subscriptionId.each do |subscriptionId|
        puts "    #{subscriptionId}"
      end
    end

  else
    puts response.messages.messages[0].text
    raise "Failed to get payment profile information with ID #{request.customerProfileId}"
  end
  return response
end

# File lib/PayPalExpressCheckout/get-details.rb, line 8
def get_details(transId)
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new
  
  payPalType = PayPalType.new()
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  
  #standard api call to retrieve response
  paymentType = PaymentType.new()
  paymentType.payPal = payPalType
  
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.payment = paymentType
  request.transactionRequest.refTransId = transId
  request.transactionRequest.transactionType = TransactionTypeEnum::GetDetailsTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && (response.transactionResponse.messages != nil)
        puts "Paypal Get Details successful."
        puts "Response Code: #{response.transactionResponse.responseCode}"
        puts "Shipping address: #{response.transactionResponse.shipTo.address}, #{response.transactionResponse.shipTo.city}, #{response.transactionResponse.shipTo.state}, #{response.transactionResponse.shipTo.country}"
        if response.transactionResponse.secureAcceptance != nil
          puts "Payer ID: #{response.transactionResponse.secureAcceptance.PayerID}"
        end
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
    end
  else
    puts "Response is null"
  end
  
  return response

end

# File lib/FraudManagement/get-held-transaction-list.rb, line 8
def get_held_transaction_List()
  
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
    #merchant information
    transaction = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
    
    request = GetUnsettledTransactionListRequest.new

    request.status  = TransactionGroupStatusEnum::PENDINGAPPROVAL;
    request.paging = Paging.new;
    request.paging.limit = 10;
    request.paging.offset = 1;

    request.sorting = TransactionListSorting.new;
    request.sorting.orderBy = TransactionListOrderFieldEnum::Id;
    request.sorting.orderDescending = true;
    
    response = transaction.get_unsettled_transaction_list(request)
    
    if response.messages.resultCode == MessageTypeEnum::Ok
      unsettled_transactions = response.transactions
    
      response.transactions.transaction.each do |unsettled_transaction|
        puts "Transaction #{unsettled_transaction.transId} was submitted at #{unsettled_transaction.submitTimeUTC}"
        
      end
      puts "Total transaction received #{unsettled_transactions.transaction.length}"
    else
      puts "ERROR message: #{response.messages.messages[0].text}"
      puts "ERROR code: #{response.messages.messages[0].code}"
      raise "Failed to get unsettled transaction list."
    end
  
  return response
end

# File lib/RecurringBilling/get-list-of-subscriptions.rb, line 8
def get_list_of_subscriptions()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  request = ARBGetSubscriptionListRequest.new
  request.refId = '2238251168'
  
  request.searchType = ARBGetSubscriptionListSearchTypeEnum::SubscriptionActive
  request.sorting = ARBGetSubscriptionListSorting.new
  request.sorting.orderBy = 'id'
  request.sorting.orderDescending = 'false'
  
  request.paging = Paging.new
  # Paging limit can be up to 1000
  request.paging.limit = '20'
  request.paging.offset = '1'


  response = transaction.get_subscription_list(request)
  

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully got the list of subscriptions."
      puts "  Response code: #{response.messages.messages[0].code}"
      puts "  Response message: #{response.messages.messages[0].text}"

      response.subscriptionDetails.subscriptionDetail.each do |sub|
        puts "  Subscription #{sub.id} #{sub.name} - Status: #{sub.status}"
        
      end
  
    else
  
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to get the list of subscriptions."
    end
  end
  return response
end

# File lib/TransactionReporting/get-merchant-details.rb, line 8
def get_merchant_details()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  
    transaction = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
    
    request = GetMerchantDetailsRequest.new
    
    #standard api call to retrieve response
    response = transaction.get_merchant_details(request)
    
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Get Merchant Details Successful " 
      puts "Gateway Id:   #{response.gatewayId}"
      puts "Merchant Name:   #{response.merchantName}"
      response.processors.processor.each do |processor|
        puts "Processor Name: #{processor.name}"
      end
      response.marketTypes.each do |marketType|
        puts "MarketType: #{marketType}"
      end
      response.productCodes.each do |productCode|
        puts "Product Code: #{productCode}"
      end
      response.paymentMethods.each do |paymentMethod|
        puts "Payment Method: #{paymentMethod}"
      end
      response.currencies.each do |currency|
        puts "Currency: #{currency}"
      end

    else
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to get transaction Details."
    end
  
  return response
end

# File lib/TransactionReporting/get-settled-batch-list.rb, line 9
def get_settled_batch_List()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  firstSettlementDate = DateTime.now()-(1 * 7)
  lastSettlementDate = DateTime.now()

  puts "First settlement date: #{firstSettlementDate} Last settlement date: #{lastSettlementDate}"
  
  request = GetSettledBatchListRequest.new
  request.firstSettlementDate = firstSettlementDate
  request.lastSettlementDate = lastSettlementDate
  request.includeStatistics = true

  response = transaction.get_settled_batch_list(request)
    
  if response.messages.resultCode == MessageTypeEnum::Ok
    
    response.batchList.batch.each do |batch|
      puts "Transaction Id: #{batch.batchId}"
      puts "Settlement Date: #{batch.settlementTimeUTC}"
      puts "State: #{batch.settlementState}"
      puts "Account Type: #{batch.statistics[0].accountType}"
      puts ""
    end
  else
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
    raise "Failed to fetch settled batch list"
  end
  
  return response

end

# File lib/RecurringBilling/get-subscription.rb, line 8
def get_subscription(subscriptionId = '2930242')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  request = ARBGetSubscriptionRequest.new

  request.refId = 'Sample'
  request.subscriptionId = subscriptionId
   
  response = transaction.arb_get_subscription_request(request)
  
  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully got subscription details."
    puts "  Response code: #{response.messages.messages[0].code}"
    puts "  Response message: #{response.messages.messages[0].text}"
    puts "  Subscription name: #{response.subscription.name}"
    puts "  Payment schedule start date: #{response.subscription.paymentSchedule.startDate}"
    puts "  Payment schedule Total Occurrences: #{response.subscription.paymentSchedule.totalOccurrences}"
    puts "  Subscription amount: %.2f " % [response.subscription.amount]
    puts "  Subscription profile description: #{response.subscription.profile.description}"
    puts "  First Name in Billing Address: #{response.subscription.profile.paymentProfile.billTo.firstName}"
   
  else
    puts response.messages.messages[0].code
    puts response.messages.messages[0].text
    raise "Failed to get subscription details."
  end
  
  return response
end

# File lib/RecurringBilling/get-subscription-status.rb, line 8
def get_subscription_status(subscriptionId = '4792732')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  #subscription = Subscription.new(config['api_login_id'], config['api_subscription_key'], :gateway => :sandbox)

  request = ARBGetSubscriptionStatusRequest.new
  request.refId = '2238251168'
  request.subscriptionId = subscriptionId

  response = transaction.get_subscription_status(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully got subscription status."
      puts "  Status: #{response.status}"
  
    else
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to get a subscriptions status"
    end
  end
  
  return response
end

# File lib/PayPalExpressCheckout/void.rb, line 8
def get_transId()
  # Before we can void a transaction, we must first create a transaction,
  # so that we have something to void.
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new('4242424242424242','0220','123') 
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthCaptureTransaction
  
  response = transaction.create_transaction(request)
  authTransId = 0

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successful AuthCapture Transaction (authorization code: #{response.transactionResponse.authCode})"
        authTransId = response.transactionResponse.transId
        puts "  Transaction ID (for later void: #{authTransId})"
        puts "  Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "  Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "  Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end
  return authTransId
end

# File lib/TransactionReporting/get-transaction-details.rb, line 8
def get_transaction_Details()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  
    transaction = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
    
    transId = "60032208160"
    request = GetTransactionDetailsRequest.new
    request.transId = transId
    
    #standard api call to retrieve response
    response = transaction.get_transaction_details(request)
    
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Get Transaction Details Successful " 
      puts "Transaction Id:   #{response.transaction.transId}"
      puts "Transaction Type:   #{response.transaction.transactionType}"
      puts "Transaction Status:   #{response.transaction.transactionStatus}"
      puts "Description: #{response.transaction.order.description}"
      printf("Auth Amount:  %.2f\n", response.transaction.authAmount)
      printf("Settle Amount:  %.2f\n", response.transaction.settleAmount)
    else
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to get transaction Details."
    end
  
  return response
end

# File lib/TransactionReporting/get-transaction-list.rb, line 8
def get_transaction_List()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction1 = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  batchId = "7590305"
  request = AuthorizeNet::API::GetTransactionListRequest.new
  request.batchId = batchId
  request.paging = Paging.new;
  # Paging limit can be up to 1000 for this request
  request.paging.limit = '20'
  request.paging.offset = 1;

  request.sorting = TransactionListSorting.new;
  request.sorting.orderBy = TransactionListOrderFieldEnum::Id;
  request.sorting.orderDescending = true;

  response = transaction1.get_transaction_list(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactions == nil
        puts "#{response.messages.messages[0].text}"
      else
        puts "Successfully got the list of transactions for batch " + batchId + "."          
        response.transactions.transaction.each do |trans|
          puts "Transaction ID: #{trans.transId} "
          puts "  Submitted on (Local): %s " % [trans.submitTimeUTC]
          puts "  Status: #{trans.transactionStatus} "
          puts "  Settle Amount: %.2f " % [trans.settleAmount]
        end
      end
    else
      puts "Error: Failed to get Transaction List."
      puts "Error Text: #{response.messages.messages[0].text}"
      puts "Error Code: #{response.messages.messages[0].code}"
    end
  else
    puts "Error: Failed to get Transaction List."
    puts "Error Text: #{response.messages.messages[0].text}"
    puts "Error Code: #{response.messages.messages[0].code}"
  end

  return response

end

# File lib/TransactionReporting/get-unsettled-transaction-list.rb, line 8
def get_unsettled_transaction_List()
  
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
    #merchant information
    transaction = AuthorizeNet::API::Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
    
    request = GetUnsettledTransactionListRequest.new

    request.status  = TransactionGroupStatusEnum::ANY;
    request.paging = Paging.new;
    # Paging limit can be up to 1000
    request.paging.limit = '20'
    request.paging.offset = 1;

    request.sorting = TransactionListSorting.new;
    request.sorting.orderBy = TransactionListOrderFieldEnum::Id;
    request.sorting.orderDescending = true;
    
    response = transaction.get_unsettled_transaction_list(request)
    
    if response.messages.resultCode == MessageTypeEnum::Ok
      unsettled_transactions = response.transactions
    
      response.transactions.transaction.each do |unsettled_transaction|
        puts "Transaction #{unsettled_transaction.transId} was submitted at #{unsettled_transaction.submitTimeUTC}"
        
      end
      puts "Total transaction received #{unsettled_transactions.transaction.length}"
    else
      puts "ERROR message: #{response.messages.messages[0].text}"
      puts "ERROR code: #{response.messages.messages[0].code}"
      raise "Failed to get unsettled transaction list."
    end
  
  return response
end

# File lib/PayPalExpressCheckout/prior-authorization-capture.rb, line 8
def prior_authorization_capture()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  
  puts "PayPal Prior Authorization Transaction"
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  random_amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.amount = random_amount
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new('4242424242424242','0220','123') 
  request.transactionRequest.transactionType = TransactionTypeEnum::AuthOnlyTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successful AuthOnly Transaction (authorization code: #{response.transactionResponse.authCode})"
        refTransId =  response.transactionResponse.transId
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to authorize card."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to authorize card."
    end
  else
    puts "Response is null"
    raise "Failed to authorize card."
  end

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  payPalType = PayPalType.new
  payPalType.successUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  payPalType.cancelUrl = "http://www.merchanteCommerceSite.com/Success/TC25262"
  
  paymentType = PaymentType.new
  paymentType.payPal = payPalType
    
  request = CreateTransactionRequest.new
  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.refTransId = refTransId
  random_amount = random_amount
  request.transactionRequest.amount = random_amount
  request.transactionRequest.payment = paymentType
  request.transactionRequest.transactionType = TransactionTypeEnum::PriorAuthCaptureTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully created a Prior Authorization capture transaction (authorization code: #{response.transactionResponse.authCode})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to make purchase."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to make purchase."
    end
  else
    puts "Response is null"
    raise "Failed to make purchase."
  end

  return response  
end

# File lib/PaymentTransactions/refund-transaction.rb, line 8
def refund_transaction()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  request = CreateTransactionRequest.new

  request.transactionRequest = TransactionRequestType.new()
  request.transactionRequest.amount = ((SecureRandom.random_number + 1 ) * 150 ).round(2)
  request.transactionRequest.payment = PaymentType.new
  request.transactionRequest.payment.creditCard = CreditCardType.new('0015','XXXX') 
  request.transactionRequest.refTransId = 2233511297
  request.transactionRequest.transactionType = TransactionTypeEnum::RefundTransaction
  
  response = transaction.create_transaction(request)

  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      if response.transactionResponse != nil && response.transactionResponse.messages != nil
        puts "Successfully refunded a transaction (Transaction ID #{response.transactionResponse.transId})"
        puts "Transaction Response code: #{response.transactionResponse.responseCode}"
        puts "Code: #{response.transactionResponse.messages.messages[0].code}"
                    puts "Description: #{response.transactionResponse.messages.messages[0].description}"
      else
        puts "Transaction Failed"
        if response.transactionResponse.errors != nil
          puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
          puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
        end
        raise "Failed to refund a transaction."
      end
    else
      puts "Transaction Failed"
      if response.transactionResponse != nil && response.transactionResponse.errors != nil
        puts "Error Code: #{response.transactionResponse.errors.errors[0].errorCode}"
        puts "Error Message: #{response.transactionResponse.errors.errors[0].errorText}"
      else
        puts "Error Code: #{response.messages.messages[0].code}"
        puts "Error Message: #{response.messages.messages[0].text}"
      end
      raise "Failed to refund a transaction."
    end
  else
    puts "Response is null"
    raise "Failed to refund a transaction."
  end
  
  return response
end

# File lib/CustomerProfiles/update-customer-payment-profile.rb, line 8
def update_customer_payment_profile(customerProfileId = '35894174', customerPaymentProfileId = '33605803')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  request = UpdateCustomerPaymentProfileRequest.new

  payment = PaymentType.new(CreditCardType.new('4111111111111111','2025-05'))
  profile = CustomerPaymentProfileExType.new(nil,nil,payment,nil,nil)

  request.paymentProfile = profile
  request.customerProfileId = customerProfileId
  profile.customerPaymentProfileId = customerPaymentProfileId

  response = transaction.update_customer_payment_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully updated customer payment profile with  ID #{request.paymentProfile.customerPaymentProfileId}."
  else
    puts response.messages.messages[0].text
    raise "Failed to update customer with customer payment profile ID #{request.paymentProfile.customerPaymentProfileId}."
  end
  return response
end

# File lib/CustomerProfiles/update-customer-profile.rb, line 8
def update_customer_profile(customerProfileId = '35704713')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = UpdateCustomerProfileRequest.new
  request.profile = CustomerProfileExType.new

  #Edit this part to select a specific customer
  request.profile.customerProfileId = customerProfileId
  request.profile.merchantCustomerId = "mycustomer"
  request.profile.description = "john doe"
  request.profile.email = "email@email.com"
  response = transaction.update_customer_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully updated customer with customer profile ID #{request.profile.customerProfileId}."
  else
    puts response.messages.messages[0].text
    raise "Failed to update customer with customer profile ID #{request.profile.customerProfileId}."
  end
  return response
end

# File lib/CustomerProfiles/update-customer-shipping-address.rb, line 8
def update_customer_shipping_address(customerProfileId = '35894174', customerAddressId = '35745790')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)

  
  request = UpdateCustomerShippingAddressRequest.new

  
  request.address = CustomerAddressExType.new('John','Doe','Anet','800 N 106th')
  
  #Edit this part to select a specific customer
  request.address.customerAddressId = customerAddressId
  request.customerProfileId = customerProfileId

  response = transaction.update_customer_shipping_profile(request)


  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successfully updated customer with customer profile ID #{request.address.customerAddressId}."
  else
    puts response.messages.messages[0].text
    raise "Failed to update customer with customer profile ID #{request.address.customerAddressId}."
  end
  return response
end

# File lib/PaymentTransactions/update-split-tender-group.rb, line 8
def update_split_tender_group()
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")

  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  
  #set the split tender ID here
  splitTenderId = "115901"
  #set the split tender status here.
  #SplitTenderStatusEnum::Completed
  #SplitTenderStatusEnum::Held
  #SplitTenderStatusEnum::Voided
  splitTenderStatus = SplitTenderStatusEnum::Voided
  
  request = UpdateSplitTenderGroupRequest.new

  request.splitTenderId = splitTenderId
  request.splitTenderStatus = splitTenderStatus
  
  response = transaction.update_split_tender_group(request)

  if response.messages.resultCode == MessageTypeEnum::Ok
    puts "Successful Update Split Tender Group"
    puts response.messages.messages[0].code
    puts response.messages.messages[0].text

  else
    puts response.messages.messages[0].code
    puts response.messages.messages[0].text
    raise "Failed to update split tender group."
  end
  
  return response
end

# File lib/RecurringBilling/update-subscription.rb, line 8
def update_subscription(subscriptionId = '3095800')
  config = YAML.load_file(File.dirname(__FILE__) + "/../credentials.yml")
  transaction = Transaction.new(config['api_login_id'], config['api_transaction_key'], :gateway => :sandbox)
  #subscription = Subscription.new(config['api_login_id'], config['api_subscription_key'], :gateway => :sandbox)

  request = ARBUpdateSubscriptionRequest.new
  request.refId = '2238251168'
  request.subscriptionId = subscriptionId
  request.subscription = ARBSubscriptionType.new
  
  request.subscription.payment = PaymentType.new
  request.subscription.payment.creditCard = CreditCardType.new('4111111111111111','0125','123')

  response = transaction.update_subscription(request)
   
  # You can pass a customer profile to update subscription
  #request.subscription.profile = CustomerProfileIdType.new
  #request.subscription.profile.customerProfileId = "123213"
  #request.subscription.profile.customerPaymentProfileId = "2132321"
  #request.subscription.profile.customerAddressId = "2131232"

  #validate the transaction was created
  #expect(response.transactionResponse.transId).not_to eq("0")
  #{request.customerProfileId}


  if response != nil
    if response.messages.resultCode == MessageTypeEnum::Ok
      puts "Successfully updated a subscription."
      puts "  Response code: #{response.messages.messages[0].code}"
      puts "  Response message: #{response.messages.messages[0].text}"
  
    else
      #puts response.transactionResponse.errors.errors[0].errorCode
      #puts response.transactionResponse.errors.errors[0].errorText
      puts response.messages.messages[0].code
      puts response.messages.messages[0].text
      raise "Failed to get a subscriptions status"
    end
  end

  return response
end