lightrail_stripe 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '0870e939ca6c8301e58b197d60406d893ebcc04a'
+  data.tar.gz: 48214fff42bd21c8a8067c38e198b219a7ec73bc
+SHA512:
+  metadata.gz: 97aede42f3020b5cd3ba135b96f8848c510f6a36965d459490686260a11869323f8031da5112d80e1e8eeb0d238171bf859b4504ec9574b408b4c44c00554069
+  data.tar.gz: 6249dbb30a3e91c2f13eff5efdede46be2aa258722523e8e1bc467cececce57141c936d4bcc933b9a9c3c799dfa86b4049c20d7f2edd3fa2a4881de304797cd0

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+# environment variables
+.env

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.15.1

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Giftbit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,277 @@
+# Lightrail Stripe Integration Gem
+
+Lightrail is a modern platform for digital account credits, gift cards, promotions, and points (to learn more, visit [Lightrail](https://www.lightrail.com/)). The Lightrail Stripe gem provides a client library for developers to easily use Lightrail alongside [Stripe](https://stripe.com/).
+
+If you are looking for specific use cases or other languages, check out [related projects](https://github.com/Giftbit/lightrail-stripe-ruby#related-projects). For a complete list of all Lightrail libraries and integrations, check out the [Lightrail Integration page](https://github.com/Giftbit/Lightrail-API-Docs/blob/usecases/Integrations.md).
+
+## Features
+
+- Simple order checkout which supports Lightrail gift card redemption alongside a Stripe payment
+- Convenient wrappers for making common calls to the Lightrail API using a similar interface to Stripe
+
+This gem depends on the [Lightrail Client Gem](https://github.com/Giftbit/lightrail-client-ruby) for communicating with the Lightrail API. It offers convenient wrappers for common API calls for those who are already using [Stripe's Ruby gem](https://github.com/stripe/stripe-ruby) and are familiar with that interface: `Lightrail::LightrailCharge.create`,  `Lightrail::Refund.create`, etc. These calls will return class instance objects instead of hashes, with convenience methods and properties that can be accessed with dot notation (for a more detailed example, see the [balance check](#balance-check) code in the following section):
+
+```ruby
+gift_value = Lightrail::LightrailValue.retrieve_by_card_id(<CARD ID>)
+gift_value.maximum_value #=> 3500
+```
+
+## Related Projects
+
+- [Lightrail Client Gem](https://github.com/Giftbit/lightrail-client-ruby)
+- [Lightrail-Stripe Java Integration](https://github.com/Giftbit/lightrail-stripe-java)
+- [Lightrail Java Client](https://github.com/Giftbit/lightrail-client-java)
+
+## Usage
+
+Before using any parts of the library, you need to set up your Lightrail API key, and if you have not already done so, you will also need to set up your Stripe API key:
+
+```ruby
+Lightrail.api_key = '<your lightrail API key>'
+Stripe.api_key = '<your stripe API key>'
+```
+
+*A note on sample code snippets: for reasons of legibility, the output for most calls has been simplified. Attributes of response objects that are not relevant here have been omitted.*
+
+### Order Checkout Using `StripeLightrailSplitTenderCharge`
+
+`StripeLightrailSplitTenderCharge` is a class designed to resemble the interface of a Stripe `Charge` class which transparently splits the transaction between Lightrail and Stripe. The Lightrail parameter could be one of the following:
+
+- `code`, specifying a gift card by its code, or
+- `cardId`, specifying a gift card by its card ID
+- `contactId`, specifying a customer by their contact ID (generated by Lightrail)
+- `shopperId`, specifying a customer by their shopper ID (generated by your ecommerce system)
+
+The Stripe parameter could be:
+
+- `source`, indicating a Stripe token, or
+- `customer`, indicating a Stripe customer ID
+
+You must also pass in the amount to charge to Lightrail. 
+
+Here is a simple example:
+
+```ruby
+split_tender_charge_params = {
+  amount: 1000,
+  currency: 'USD',
+  code: '<GIFT CODE>',
+  source: '<STRIPE TOKEN>',
+}
+lightrail_amount = 450
+
+split_tender_charge = Lightrail::StripeLightrailSplitTenderCharge.create(split_tender_charge_params, lightrail_amount)
+```
+
+If you don't provide any Lightrail payment parameters and set the `lightrail_amount` to 0, the entire transaction will be charged to Stripe. Similarly, if you don't provide any Stripe payment parameters and set the `lightrail_amount` to the full amount, the library will attempt to charge the entire transaction to Lightrail. If the value of the gift card is not enough to cover the entire transaction amount and no Stripe payment method is included, you will receive a `BadParameterError` asking you to provide a Stripe parameter.
+
+There is also a wrapper method that can determine the Stripe/Lightrail split automatically: `Lightrail::StripeLightrailSplitTenderCharge.create_with_automatic_split`. This method accepts the same `charge_params` as the default `.create`, but does not expect a `stripe_amount` or `lightrail_amount`. When both a Lightrail and a Stripe payment method are provided to this method, the library will try to split the payment in such a way that Lightrail contributes to the payment as much as possible. This usually means:
+
+- If the Lightrail value is sufficient, the entire transaction will be charged to the gift card.
+- If the transaction amount is larger than the Lightrail value, the remainder will be charged to Stripe.
+
+## Managing Lightrail Gift Cards and Accounts
+
+A Lightrail Gift Card is a virtual device for issuing gift values. Each gift card has a specific `currency`, a `cardId`, and a `fullCode`, which is a unique unguessable alphanumeric string, usually released to the gift recipient in confidence. The recipient of the gift card can present the `fullCode` to redeem the gift value. For further explanation of cards and codes see the [Lightrail API documentation](https://www.lightrail.com/docs/).
+
+Customer Accounts are values attached to a customer and are commonly used for customer rewards and account credit programs. For further explanation of this concept check out the [Lightrail API documentation](https://www.lightrail.com/docs/).
+
+### Balance Check
+
+Use the `Lightrail::LightrailValue` class to check the balance of gift cards or customer accounts.
+
+For **gift cards**, use `.retrieve_by_card` or `.retrieve_by_code`:
+
+```ruby
+gift_balance_details = Lightrail::LightrailValue.retrieve_card_details("<GIFT CARD ID>")
+# or use the fullCode:
+# gift_balance_details = Lightrail::LightrailValue.retrieve_code_details("<GIFT CODE>")
+
+#=>  <Lightrail::LightrailValue:0x007fe24b16f500
+         @principal=
+            {
+            'currentValue' => 3000,
+            'state' => 'ACTIVE',
+            'expires' => nil,
+            'startDate' => nil,
+            'programId' => 'program-123456',
+            'valueStoreId' => 'value-123456'},
+         @attached=[{'currentValue' => 500,
+            'state' => 'ACTIVE',
+            #...},
+          {'currentValue' => 250,
+            'state' => 'EXPIRED',
+            #...}],
+         @currency="USD",
+         @cardType="GIFT_CARD",
+         @balanceDate="2017-05-29T13:37:02.756Z",
+         @cardId="card-123456>
+
+gift_maximum_value = gift_balance_details.maximum_value
+#=>  3500
+```
+
+For **accounts**, use `.retrieve_by_contact_id` or `.retrieve_by_shopper_id`. Note that because a single contact can hold account value in several different currencies, it is also necessary to specify the account currency to perform a balance check:
+
+```ruby
+account_balance_details = Lightrail::Value.retrieve_by_contact_id({
+    contact_id: '<CONTACT ID>',
+    currency: 'USD'
+  })
+
+# or use a customer's shopper_id:
+# account_balance_details = Lightrail::Value.retrieve_by_shopper_id({
+#     shopper_id: '<CONTACT ID>',
+#     currency: 'USD'
+#   })
+
+#=>  <Lightrail::LightrailValue:0x007fe24b16f500
+         @principal = {'currentValue' => 3000, ...}>
+```
+
+### Charging a Gift Card or Customer Account
+
+Use`Lightrail::LightrailCharge.create` to charge a gift card or a customer account. The minimum required parameters are either the gift card's `fullCode` or `cardId` OR the customer's `contactId` or `shopperId`, the `currency`, and the `amount` of the transaction (a positive integer in the smallest currency unit, e.g., 500 cents is 5 USD):
+
+```ruby
+gift_charge = Lightrail::LightrailCharge.create({
+                                      amount: 1850,
+                                      currency: 'USD',
+                                      code: '<GIFT CODE>' # or card_id/contact_id/shopper_id
+                                    })
+#=> <Lightrail::LightrailCharge:0x007fdb62206e68
+       @value=-1850,
+       @userSuppliedId="17223eff",
+       @transactionType="DRAWDOWN",
+       @currency="USD",
+       @transactionId="transaction-cd245",
+       #...>
+```
+
+**A note on idempotency:** All calls to create or act on transactions (refund, void, capture) can optionally take a `userSuppliedId` parameter. The `userSuppliedId` is a client-side identifier (unique string) which is used to ensure idempotency (for more details, see the  [API documentation](https://www.lightrail.com/docs/)). If you do not provide a `userSuppliedId`, the gem will create one for you for any calls that require one.
+
+```ruby
+gift_charge = Lightrail::LightrailCharge.create({
+                                      amount: 1850,
+                                      currency: 'USD',
+                                      code: '<GIFT CODE>',
+                                      userSuppliedId: 'order-13jg9s0era9023-u9a-0ea'
+                                    })
+```
+
+Note that Lightrail does not support currency exchange and the currency provided in this method must match the currency of the gift card or the customer's account.
+
+For more details on the parameters that you can pass in for a charge request and the response that you will get back, see the [Lightrail API documentation](https://www.lightrail.com/docs/).
+
+### Authorize-Capture Flow
+
+You can create a pending charge for a Lightrail gift card or customer account the same way you would with Stripe for a credit card — simply by adding `capture: false` to your charge parameters. The pending charge object returned from this method call will also have convenience methods to directly `#capture!` or `#cancel!` that charge:
+
+```ruby
+gift_charge = Lightrail::LightrailCharge.create({
+                                      amount: 1850,
+                                      currency: 'USD',
+                                      code: '<GIFT CODE>', # or card_id/contact_id/shopper_id
+                                      capture: false,
+                                    })
+# later on
+gift_charge.capture!
+#=> <Lightrail::LightrailCharge:0x007fdb633531d0
+       @value=-1850,
+       @userSuppliedId="17223eff",
+       @dateCreated="2017-05-29T13:37:02.756Z",
+       @transactionType="DRAWDOWN",
+       @transactionAccessMethod="RAWCODE",
+       @cardId="<GIFT CARD ID>",
+       @currency="USD",
+       @transactionId="transaction-cd245",
+       @parentTransactionId="transaction-b9d4444">
+
+# or
+gift_charge.cancel!
+#=> <Lightrail::LightrailCharge:0x007fdb62854018
+       @value=-1850,
+       @userSuppliedId="17223eff",
+       @dateCreated="2017-05-29T13:37:02.756Z",
+       @transactionType="PENDING_VOID",
+       @transactionAccessMethod="RAWCODE",
+       @cardId="<GIFT CARD ID>",
+       @currency="USD",
+       @transactionId="transaction-0ce6f05",
+       @parentTransactionId="transaction-b9d4444">
+```
+
+Note that `#capture!` and `#cancel!` will each return a **new transaction** and will not modify the instance they are called on. These new transactions will have their own `transactionId`. If you need to record the transaction ID of the captured or canceled charge, you can get it from the object returned by these methods (a new instance of `LightrailCharge`).
+
+### Refunding a Charge
+
+You can undo a charge by using the `Lightrail::Refund` class and passing in the transaction instance you wish to refund. This will create a new `refund` transaction which will return the charged amount back to the card or account. The return object will be an instance of `Lightrail::Refund`. If you need the transaction ID of the refund transaction, you can find it on this object.
+
+```ruby
+gift_charge = Lightrail::LightrailCharge.create(<CHARGE PARAMS>)
+
+# later on
+Lightrail::Refund.create(gift_charge)
+#=> <Lightrail::Refund:0x007fdb62854018
+       @value=1850,
+       @userSuppliedId="873b08ab",
+       @dateCreated="2017-05-29T13:37:02.756Z",
+       @transactionType="DRAWDOWN_REFUND",
+       @transactionAccessMethod="CARDID",
+       @cardId="<GIFT CARD ID>",
+       @currency="USD",
+       @transactionId="transaction-0f2a67",
+       @parentTransactionId="transaction-2271e3">
+```
+
+Note that this does not necessarily mean that the refunded amount is available for a re-charge. In the edge case where the funds for the original charge came from a promotion which has now expired, refunding will return those funds back to the now-expired value store and therefore the value will not be available for re-charge. To learn more about using value stores for temporary promotions, see the [Lightrail API docs](https://github.com/Giftbit/Lightrail-API-Docs/blob/master/use-cases/promotions.md).
+
+### Funding a Gift Card or Customer Account
+
+To add funds to a card or account, you can use the `Lightrail::LightrailFund` class. Note that the Lightrail API does not permit funding a gift card by its `code` and the only way to fund a card is by providing its `cardId`. Customer accounts can be funded by supplying either their `contact_id` or their `shopper_id` along with the `currency` of the account.
+
+```ruby
+gift_fund = Lightrail::LightrailFund.create({
+                                      amount: 500,
+                                      currency: 'USD',
+                                      card_id: '<GIFT CARD ID>' # or contact_id/shopper_id
+                                    })
+#=> <Lightrail::LightrailFund:0x007fb7b18b96b8
+       @value=500,
+       @userSuppliedId="4f86a1be",
+       @dateCreated="2017-05-29T13:37:02.756Z",
+       @transactionType="FUND",
+       @transactionAccessMethod="CARDID",
+       @cardId="<GIFT CARD ID>",
+       @currency="USD",
+       @transactionId="transaction-240eca6">
+```
+
+
+## Installation
+
+This gem is available on RubyGems.org. To use it in your project, add this line to your application's Gemfile:
+
+```ruby
+gem 'lightrail_stripe'
+```
+
+And then execute:
+
+```
+$ bundle
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Giftbit/lightrail-stripe-ruby.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies, then run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-slate

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "lightrail_stripe"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/lightrail_stripe/split_tender_validator.rb

@@ -0,0 +1,28 @@
+module Lightrail
+  class SplitTenderValidator < Lightrail::Validator
+
+    def self.validate_split_tender_charge_params! (split_tender_charge_params)
+      begin
+        return true if ((split_tender_charge_params.is_a? Hash) &&
+            Lightrail::Validator.validate_amount!(split_tender_charge_params[:amount]) &&
+            Lightrail::Validator.validate_currency!(split_tender_charge_params[:currency]) &&
+            (self.has_lightrail_payment_option?(split_tender_charge_params) ||
+                self.has_stripe_payment_option?(split_tender_charge_params)))
+      rescue Lightrail::LightrailArgumentError
+      end
+      raise Lightrail::LightrailArgumentError.new("Invalid split_tender_charge_params: #{split_tender_charge_params.inspect}")
+    end
+
+    def self.has_stripe_payment_option?(charge_params)
+      charge_params.has_key?(:source) || charge_params.has_key?(:customer)
+    end
+
+    def self.has_lightrail_payment_option?(charge_params)
+      Lightrail::Validator.has_valid_code?(charge_params) ||
+          Lightrail::Validator.has_valid_card_id?(charge_params) ||
+          Lightrail::Validator.has_valid_contact_id?(charge_params) ||
+          Lightrail::Validator.has_valid_shopper_id?(charge_params)
+    end
+
+  end
+end

data/lib/lightrail_stripe/stripe_lightrail_split_tender_charge.rb

@@ -0,0 +1,133 @@
+module Lightrail
+  class StripeLightrailSplitTenderCharge < Lightrail::LightrailObject
+    attr_accessor :lightrail_charge, :stripe_charge, :payment_summary
+
+    def self.create (charge_params, lr_share)
+      # Convert to Translator.translate_split_tender_charge_params!()
+      Lightrail::SplitTenderValidator.validate_split_tender_charge_params!(charge_params)
+
+      total_amount = charge_params[:amount]
+      currency = charge_params[:currency]
+
+      stripe_share = total_amount - lr_share
+
+      if lr_share > 0 # start with lightrail charge first
+        lightrail_charge_params = Lightrail::Translator.construct_lightrail_pending_charge_params_from_split_tender(charge_params, lr_share)
+
+        lightrail_pending_transaction = Lightrail::LightrailCharge.create(lightrail_charge_params)
+
+        if stripe_share > 0 # continue to stripe charge
+          begin
+            stripe_params = Lightrail::Translator.charge_params_split_tender_to_stripe(charge_params, stripe_share)
+            stripe_transaction = Stripe::Charge.create(stripe_params)
+            lightrail_metadata = Lightrail::Translator.construct_lightrail_metadata_for_split_tender_charge(stripe_transaction)
+          rescue
+            lightrail_pending_transaction.cancel!
+            raise $!, "Stripe payment failed: #{$!}", $!.backtrace
+          end
+        end
+
+        lightrail_captured_transaction = lightrail_pending_transaction.capture!(lightrail_metadata)
+
+      else # all to stripe
+        stripe_params = Lightrail::Translator.charge_params_split_tender_to_stripe(charge_params, stripe_share)
+        stripe_transaction = Stripe::Charge.create(stripe_params)
+
+      end
+
+
+      split_tender_charge_payment_summary = {
+          total_amount: total_amount,
+          currency: currency,
+          lightrail_amount: lightrail_captured_transaction ? lightrail_captured_transaction.value : 0,
+          stripe_amount: stripe_transaction ? stripe_transaction.amount : 0,
+      }
+
+      self.new({lightrail_charge: lightrail_captured_transaction, stripe_charge: stripe_transaction, payment_summary: split_tender_charge_payment_summary})
+    end
+
+    def self.create_with_automatic_split (charge_params)
+      Lightrail::SplitTenderValidator.validate_split_tender_charge_params!(charge_params)
+
+      split_amounts = self.determine_split!(charge_params)
+      lr_share = split_amounts[:lightrail_amount]
+      self.create(charge_params, lr_share)
+    end
+
+    def self.simulate (charge_params, lr_share)
+      Lightrail::SplitTenderValidator.validate_split_tender_charge_params!(charge_params)
+
+      total_amount = charge_params[:amount]
+      currency = charge_params[:currency]
+
+      stripe_share = total_amount - lr_share
+
+      if lr_share > 0 # only need to simulate Lightrail transaction
+        lightrail_charge_params = Lightrail::Translator.construct_lightrail_charge_params_from_split_tender(charge_params, lr_share)
+
+        lightrail_simulated_transaction = Lightrail::LightrailCharge.simulate(lightrail_charge_params)
+
+        lr_final_share = lightrail_simulated_transaction.value
+      end
+
+      split_tender_charge_payment_summary = {
+          total_amount: total_amount,
+          currency: currency,
+          lightrail_amount: lr_final_share ? lr_final_share : 0,
+          stripe_amount: lr_final_share ? total_amount - lr_final_share.abs : total_amount
+      }
+
+      self.new({lightrail_charge: lightrail_simulated_transaction, stripe_charge: nil, payment_summary: split_tender_charge_payment_summary})
+    end
+
+    def self.simulate_with_automatic_split (charge_params)
+      Lightrail::SplitTenderValidator.validate_split_tender_charge_params!(charge_params)
+
+      split_amounts = self.determine_split!(charge_params)
+      lr_share = split_amounts[:lightrail_amount]
+      self.simulate(charge_params, lr_share)
+    end
+
+
+    private
+
+    def self.determine_split!(charge_params)
+      total_amount = charge_params[:amount]
+      contact_id = Lightrail::Contact.get_contact_id_from_id_or_shopper_id(charge_params)
+      code = Lightrail::Validator.get_code(charge_params)
+      card_id = Lightrail::Validator.get_card_id(charge_params)
+
+      lr_share = if contact_id || code || card_id
+                   charge_params_for_simulate = charge_params.clone
+                   charge_params_for_simulate[:value] = -charge_params[:amount] || -charge_params['amount']
+
+                   if contact_id
+                     Lightrail::Account.simulate_charge(charge_params_for_simulate)['value'].abs
+                   elsif code
+                     Lightrail::Code.simulate_charge(charge_params_for_simulate)['value'].abs
+                   elsif card_id
+                     Lightrail::Card.simulate_charge(charge_params_for_simulate)['value'].abs
+                   end
+
+                 else
+                   nil
+                 end
+
+      if lr_share && (lr_share < total_amount) && (Lightrail::SplitTenderValidator.has_stripe_payment_option?(charge_params))
+        stripe_share = total_amount - lr_share
+        lr_share = stripe_share < 50 ? lr_share - (50-stripe_share) : lr_share
+        stripe_share = total_amount - lr_share
+      elsif lr_share && (lr_share < total_amount)
+        raise Lightrail::BadParameterError.new('Please provide a Stripe payment method to complete the transaction.')
+      else
+        stripe_share = charge_params[:amount]
+      end
+
+      {
+          lightrail_amount: lr_share || 0,
+          stripe_amount: stripe_share
+      }
+    end
+
+  end
+end

data/lib/lightrail_stripe/translator.rb

@@ -0,0 +1,86 @@
+module Lightrail
+  class Translator
+
+    def self.charge_params_stripe_to_lightrail(stripe_style_params)
+      self.stripe_params_to_lightrail!(stripe_style_params, true)
+    end
+
+    def self.charge_instance_to_hash!(charge_instance)
+      if charge_instance.is_a? Lightrail::LightrailCharge
+        charge_hash = {}
+        charge_instance.instance_variables.each {|instance_variable| charge_hash[instance_variable.to_s.delete('@')] = charge_instance.instance_variable_get(instance_variable)}
+        charge_hash
+      else
+        raise Lightrail::LightrailArgumentError.new("Translator.charge_instance_to_hash! received #{charge_instance.inspect}")
+      end
+    end
+
+    def self.fund_params_stripe_to_lightrail(stripe_style_params)
+      self.stripe_params_to_lightrail!(stripe_style_params, false)
+    end
+
+    def self.construct_lightrail_charge_params_from_split_tender(split_tender_charge_params, lr_share)
+      lightrail_params = split_tender_charge_params.clone
+
+      lightrail_params[:pending] ||= lightrail_params[:capture] === nil ? false : !lightrail_params.delete(:capture)
+      lightrail_params[:value] = -lr_share
+      lightrail_params.delete(:amount)
+
+      lightrail_params[:contact_id] ||= Lightrail::Validator.get_contact_id(lightrail_params)
+      lightrail_params[:shopper_id] ||= Lightrail::Validator.get_shopper_id(lightrail_params)
+      if (lightrail_params[:contact_id] || lightrail_params[:shopper_id])
+        lightrail_params = Lightrail::Account.replace_contact_id_or_shopper_id_with_card_id(lightrail_params)
+      end
+
+      lightrail_params[:code] ||= Lightrail::Validator.get_code(lightrail_params)
+      lightrail_params[:cardId] ||= Lightrail::Validator.get_card_id(lightrail_params)
+
+      lightrail_params[:userSuppliedId] ||= Lightrail::Validator.get_or_create_user_supplied_id(lightrail_params)
+
+      lightrail_params
+    end
+
+    def self.construct_lightrail_pending_charge_params_from_split_tender(split_tender_charge_params, lr_share)
+      lightrail_params = self.construct_lightrail_charge_params_from_split_tender(split_tender_charge_params, lr_share)
+      lightrail_params[:pending] = true
+
+      lightrail_params
+    end
+
+    def self.charge_params_split_tender_to_stripe(split_tender_charge_params, stripe_share)
+      stripe_params = split_tender_charge_params.clone
+      stripe_params[:amount] = stripe_share
+
+      Lightrail::Constants::LIGHTRAIL_PAYMENT_METHODS.each {|charge_param_key| stripe_params.delete(charge_param_key)}
+      Lightrail::Constants::LIGHTRAIL_USER_SUPPLIED_ID_KEYS.each {|supplied_id_key| stripe_params.delete(supplied_id_key)}
+
+      stripe_params
+    end
+
+    def self.construct_lightrail_metadata_for_split_tender_charge(stripe_transaction)
+      {
+          metadata: {
+              splitTenderChargeDetails: {
+                  stripeTransactionId: stripe_transaction.id
+              }
+          }
+      }
+    end
+
+    private
+
+    def self.stripe_params_to_lightrail!(transaction_params, convert_amount_to_negative_value)
+      lr_transaction_params = transaction_params.clone
+      lr_transaction_params[:pending] ||= lr_transaction_params[:capture] === nil ? false : !lr_transaction_params.delete(:capture)
+      lr_transaction_params[:userSuppliedId] ||= Lightrail::Validator.get_or_create_user_supplied_id(lr_transaction_params)
+      lr_transaction_params[:value] ||= convert_amount_to_negative_value ? -(lr_transaction_params[:amount].abs) : lr_transaction_params[:amount].abs
+
+      if (Lightrail::Validator.has_valid_contact_id?(lr_transaction_params) || Lightrail::Validator.has_valid_shopper_id?(lr_transaction_params))
+        lr_transaction_params = Lightrail::Account.replace_contact_id_or_shopper_id_with_card_id(lr_transaction_params)
+      end
+
+      lr_transaction_params
+    end
+
+  end
+end

data/lib/lightrail_stripe/version.rb

@@ -0,0 +1,3 @@
+module LightrailStripe
+  VERSION = "1.0.0"
+end

data/lib/lightrail_stripe/wrappers/lightrail_charge.rb

@@ -0,0 +1,59 @@
+module Lightrail
+  class LightrailCharge < Lightrail::LightrailObject
+    attr_accessor :transactionId, :value, :userSuppliedId, :dateCreated, :transactionType, :transactionAccessMethod, :giftbitUserId, :cardId, :currency, :codeLastFour, :metadata
+
+    def self.create (charge_params)
+      Lightrail::Validator.validate_charge_object! (charge_params)
+      charge_params_to_send_to_lightrail = Lightrail::Translator.charge_params_stripe_to_lightrail(charge_params)
+
+      charge_method = charge_params_to_send_to_lightrail[:code] ? 'code' : 'cardId'
+
+      response = (charge_method == 'code') ?
+          Lightrail::Code.charge(charge_params_to_send_to_lightrail) :
+          Lightrail::Card.charge(charge_params_to_send_to_lightrail)
+
+      self.new(response)
+    end
+
+    def self.simulate (charge_params)
+      Lightrail::Validator.validate_charge_object! (charge_params)
+      charge_params_to_send_to_lightrail = Lightrail::Translator.charge_params_stripe_to_lightrail(charge_params)
+
+      charge_method = charge_params_to_send_to_lightrail[:code] ? 'code' : 'cardId'
+
+      response = (charge_method == 'code') ?
+          Lightrail::Code.simulate_charge(charge_params_to_send_to_lightrail) :
+          Lightrail::Card.simulate_charge(charge_params_to_send_to_lightrail)
+
+      self.new(response)
+    end
+
+    def cancel! (new_request_body=nil)
+      handle_pending(self, 'void', new_request_body)
+    end
+
+    def capture! (new_request_body=nil)
+      handle_pending(self, 'capture', new_request_body)
+    end
+
+    private
+
+    def handle_pending (original_transaction_response, void_or_capture, new_request_body=nil)
+
+      hash_of_original_transaction_response = original_transaction_response.clone
+      hash_of_original_transaction_response = Lightrail::Translator.charge_instance_to_hash!(hash_of_original_transaction_response)
+
+      Lightrail::Validator.validate_transaction_response!(hash_of_original_transaction_response)
+
+      transaction_id = Lightrail::Validator.get_transaction_id(hash_of_original_transaction_response)
+
+      body = new_request_body || {}
+      body[:userSuppliedId] ||= Lightrail::Validator.get_or_create_user_supplied_id_with_action_suffix(body, transaction_id, void_or_capture)
+
+      response = Lightrail::Transaction.handle_transaction(hash_of_original_transaction_response, void_or_capture, body)
+
+      Lightrail::LightrailCharge.new(response)
+    end
+
+  end
+end

data/lib/lightrail_stripe/wrappers/lightrail_fund.rb

@@ -0,0 +1,15 @@
+module Lightrail
+  class LightrailFund < Lightrail::LightrailObject
+    attr_accessor :transactionId, :value, :userSuppliedId, :dateCreated, :transactionType, :transactionAccessMethod, :giftbitUserId, :cardId, :currency, :codeLastFour
+
+    def self.create(fund_object)
+      Lightrail::Validator.validate_fund_object!(fund_object)
+
+      fund_object_to_send_to_lightrail = Lightrail::Translator.fund_params_stripe_to_lightrail(fund_object)
+
+      response = Lightrail::Card.fund(fund_object_to_send_to_lightrail)
+
+      self.new(response)
+    end
+  end
+end

data/lib/lightrail_stripe/wrappers/lightrail_value.rb

@@ -0,0 +1,43 @@
+module Lightrail
+  class LightrailValue < Lightrail::LightrailObject
+    attr_accessor :valueStores, :currency, :cardType, :asAtDate, :cardId
+
+    def self.retrieve_code_details (code)
+      Lightrail::Validator.validate_code! (code)
+      response = Lightrail::Code.get_details(code)
+      self.new(response)
+    end
+
+    def self.retrieve_card_details (card_id)
+      Lightrail::Validator.validate_card_id!(card_id)
+      response = Lightrail::Card.get_details(card_id)
+      self.new(response)
+    end
+
+    def self.retrieve_contact_account_details (contact_id, currency)
+      Lightrail::Validator.validate_contact_id!(contact_id)
+      Lightrail::Validator.validate_currency!(currency)
+      response = Lightrail::Account.get_account_details({contact_id: contact_id, currency: currency})
+      self.new(response)
+    end
+
+    def self.retrieve_by_shopper_id (shopper_id, currency)
+      Lightrail::Validator.validate_shopper_id!(shopper_id)
+      Lightrail::Validator.validate_currency!(currency)
+      response = Lightrail::Account.get_account_balance_details({shopper_id: shopper_id, currency: currency})
+      self.new(response)
+    end
+
+
+    def maximum_value
+      maximum_value = 0
+      self.valueStores.each do |valueStore|
+        if valueStore['state'] == 'ACTIVE'
+          maximum_value += valueStore['value']
+        end
+      end
+      maximum_value
+    end
+
+  end
+end

data/lib/lightrail_stripe/wrappers/refund.rb

@@ -0,0 +1,22 @@
+module Lightrail
+  class Refund < Lightrail::LightrailObject
+    attr_accessor :transactionId, :value, :userSuppliedId, :dateCreated, :transactionType, :transactionAccessMethod, :giftbitUserId, :cardId, :currency, :parentTransactionId, :metadata, :codeLastFour
+
+    def self.create(original_transaction_response, new_request_body = {})
+      hash_of_original_transaction_response = original_transaction_response.clone
+      hash_of_original_transaction_response = Lightrail::Translator.charge_instance_to_hash!(hash_of_original_transaction_response)
+
+      Lightrail::Validator.validate_transaction_response! (hash_of_original_transaction_response)
+
+      transaction_id = Lightrail::Validator.get_transaction_id(hash_of_original_transaction_response)
+
+      body = new_request_body
+      body[:userSuppliedId] ||= Lightrail::Validator.get_or_create_user_supplied_id_with_action_suffix(body, transaction_id, 'refund')
+
+      response = Lightrail::Transaction.handle_transaction(hash_of_original_transaction_response, :refund, body)
+
+      self.new(response)
+    end
+
+  end
+end

data/lib/lightrail_stripe.rb

@@ -0,0 +1,26 @@
+require "faraday"
+require "openssl"
+require "json"
+require "securerandom"
+
+require "lightrail_client"
+require "stripe"
+
+require "lightrail_stripe/version"
+
+require "lightrail_stripe/translator"
+require "lightrail_stripe/split_tender_validator"
+
+require "lightrail_stripe/wrappers/lightrail_charge"
+require "lightrail_stripe/wrappers/lightrail_fund"
+require "lightrail_stripe/wrappers/lightrail_value"
+require "lightrail_stripe/wrappers/refund"
+
+require "lightrail_stripe/stripe_lightrail_split_tender_charge"
+
+module Lightrail
+  class << self
+    attr_accessor :api_base, :api_key
+  end
+  @api_base = 'https://api.lightrail.com/v1'
+end

data/lightrail_stripe.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "lightrail_stripe/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "lightrail_stripe"
+  spec.version       = LightrailStripe::VERSION
+  spec.authors       = ["Lightrail"]
+  spec.email         = ["tana.j@lightrail.com"]
+
+  spec.summary       = "A integration gem to use Stripe and Lightrail for payment processing"
+  spec.description   = "Acquire and retain customers using account credits, gift cards, promotions, and points."
+  spec.homepage      = "https://www.lightrail.com/"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '~> 2.3'
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry-byebug", "~>3.4"
+
+  spec.add_runtime_dependency "lightrail_client", "~>1.0"
+  spec.add_runtime_dependency "stripe", "~>3.0"
+  spec.add_runtime_dependency "faraday", "~>0.12"
+  spec.add_runtime_dependency "json", "~>1.7"
+  spec.add_runtime_dependency "openssl", "~>2.0"
+end

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: lightrail_stripe
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Lightrail
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: lightrail_client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: stripe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Acquire and retain customers using account credits, gift cards, promotions,
+  and points.
+email:
+- tana.j@lightrail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- _config.yml
+- bin/console
+- bin/setup
+- lib/lightrail_stripe.rb
+- lib/lightrail_stripe/split_tender_validator.rb
+- lib/lightrail_stripe/stripe_lightrail_split_tender_charge.rb
+- lib/lightrail_stripe/translator.rb
+- lib/lightrail_stripe/version.rb
+- lib/lightrail_stripe/wrappers/lightrail_charge.rb
+- lib/lightrail_stripe/wrappers/lightrail_fund.rb
+- lib/lightrail_stripe/wrappers/lightrail_value.rb
+- lib/lightrail_stripe/wrappers/refund.rb
+- lightrail_stripe.gemspec
+homepage: https://www.lightrail.com/
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: A integration gem to use Stripe and Lightrail for payment processing
+test_files: []
+has_rdoc: