atpay_buttons 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc892b9c316fd7e96cc99f42ebe7a0bba1f53949
+  data.tar.gz: b8c61bd615e5e89262731cce90b096a188f7e0c7
+SHA512:
+  metadata.gz: edc1c99a639364a7ecd3cee17dfe41b2f92cb74174d224c9b3cd43d4e8bdcb21e5e4171b1b16cd66014a1f60a8dd0744f0c88211dab1a66090676ad0b6e7f276
+  data.tar.gz: ff483113e4bd40af28c2635c9c720daf2411da5c98a64ad140efbeef6aefa8ac4988ee8806e5f9b4f2adc31fa084b551e71e39215a3124fe5f736aa39367c1e2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in atpay-button-generator.gemspec
+gemspec
+
+gem 'liquid'
+gem 'atpay_tokens'
+gem 'activesupport', '4.0.0'
+gem 'trollop'
+
+# Test-specific gems
+group :test do
+  gem 'capybara', '~> 1.1.0'
+end
+
+group :development, :test do
+  gem 'pry'
+  gem 'minitest', '> 3.1.0'
+  gem 'minitest-reporters', '>= 0.5.0', :github => "atpay/minitest-reporters", :require => false
+  gem 'simplecov'
+  gem 'mocha'
+end

data/README.md

@@ -0,0 +1,210 @@
+# @Pay Payment Button Generator
+
+The @Pay payment button generator creates @Pay two-click buttons that you can send
+to your mailing list to collect funds via email. 
+
+When using two-click buttons in emails, you want to make sure that they are compatible
+in as many environments (clients/browsers/devices) as possible. This can be a painstaking
+task because all environments render buttons differently. Buttons generated with this
+tool are cross-platform and cross-browser compatible. This means that the two-click
+experience can be enjoyed on over 93% of browser, platform, and device combinations.
+The generator uses domain targeting and outputs html from a specific template depending
+on the email parameter. These templates include two sets of buttons. A CSS rule set will
+determine which button will be displayed on the end users device and browser. For more
+information on cross compatibility, 
+visit https://www.atpay.com/cross-compatible-mailto-links-mobile-browsers.
+
+You can use this library directly from your Ruby-based application, or you can
+interface with it via the command line from most any language.
+
+The provided Liquid templates are customizable here, or can be used as
+a starting point for your own implementation.
+
+This library is a convenience wrapper around the [@Pay Client
+Library](https://github.com/atpay/atpay-client). You may use both together or
+each independently, though this library does internally depend on the client
+library.
+
+
+## Installation
+
+If your application is based on Ruby and you use Bundler, add the following line
+to your application's Gemfile:
+
+    gem 'atpay-button-generator'
+
+And then execute:
+
+    $ bundle
+
+If you'd like to use the command line interface, or are not using Bundler, you
+can install the gem on your system with:
+
+    $ gem install atpay-button-generator
+
+## Requirements
+
+Ruby >= 1.9
+
+## Command Line Usage
+
+You'll need a partner id, public key and private key from your @Pay signup. More
+advanced implementations may be using OAuth to collect this information from
+multiple partners and can generate buttons on behalf of merchants that use their
+system. 
+
+After installing the atpay-button-generator gem, you'll have
+`atpay-button-generator` script in your gem binpath. Run it with
+the help flag to get information on how to use it: 
+
+
+    $ atpay-button-generator --help
+
+The button generator requires a few flags up front:
+
+### Parameters
+
+<p><strong>amount (required): </strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The amount a user should be charged for transactions after clicking this button</i></p>
+ 
+<p><strong>private-key (required):</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The private key given to you by @Pay</i></p>
+
+<p><strong>public-key (required):</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; @Pay's public key, given to you by @Pay</i></p>
+
+<p><strong>partner-id (required):</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The partner ID given to you by @Pay</i></p>
+
+<p><strong>subject:</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The subject of the mailto: email <br/> &nbsp; &nbsp; &nbsp; (the message that a user will be sending to @Pay's servers after clicking the button)</i></p>
+
+<p><strong>image:</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The URL to a small thumbnail image to be used in the button <br /> &nbsp; &nbsp; &nbsp; Default: https://www.atpay.com/wp-content/themes/atpay/images/bttn_cart.png</i></p>
+
+<p><strong>color:</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The background color of the button <br /> &nbsp; &nbsp; &nbsp;  Default: #6dbe45</i></p>
+
+<p><strong>title:</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; The title for each button</i></p>
+
+<p><strong>wrap:</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; Will use wrapped (with a styled div container) version of template <br /> &nbsp; &nbsp; &nbsp; Default: false</i></p>
+
+<p><strong>templates:</strong> <br />
+<i> &nbsp; &nbsp; &nbsp; Location of button templates <br /> &nbsp; &nbsp; &nbsp; Default: ./lib/atpay/button/templates</i></p>
+
+<p><strong>env:</strong> <br /> 
+<i> &nbsp; &nbsp; &nbsp; The environment you want to generate buttons for; currently sandbox or production<br /> &nbsp; &nbsp; &nbsp; Default: production</i></p>
+
+<p><strong>user_data:</strong> <br /> 
+<i> &nbsp; &nbsp; &nbsp; Optional user data to be passed in as a string for your use </i></p>
+
+<p><strong>input: </strong> <br /> 
+<i> &nbsp; &nbsp; &nbsp; Input File
+<br />&nbsp; &nbsp; &nbsp;Default: $stdin<sup>*</sup></i></p>
+
+<sup>*</sup>Reads from STDIN a comma delimmited file with each line containing the
+email address you're sending the button to and the credit card token you've
+received from @Pay for that button:
+
+    test1@example.com,TL1UwJFXVN7e4p6+0B5N8hy4qQyqeNxVllmC663MLcMupuAWXdHJ9g8PRAnlIh+AMZBgpaIrfWStZ5/3hYi6vCAV7q6+3M6LLqxk
+    test2@example.com,XKCF2E9QZPwdOSwfTQJzZC7byLt3PH8Tr1KhmLkfRHwfNJD5XbDRMrxGYOiSnfrLEKNzm9+a4r++bpUG2hNrPyYLpNgph3BXAAfC
+    test3@example.com,iQOxdBV4KrFuPFgyywxytfbsD/rURrzmlADmg1QFP2VHd/kTnkXNpnp2Utv4RS0Zz2YeOloilMhljsOcRVA2YwSu9knwF1h6tNjE
+
+### Example
+
+    $ atpay-button-generator --title "Pay" --amount 50.00 --subject "Payment for fifty bucks" --private-key "" --public-key "" --partner-id 20 --input input.txt
+
+Where input.txt contains
+
+    test1@example.com,TL1UwJFXVN7e4p6+0B5N8hy4qQyqeNxVllmC663MLcMupuAWXdHJ9g8PRAnlIh+AMZBgpaIrfWStZ5/3hYi6vCAV7q6+3M6LLqxk
+    test2@example.com,XKCF2E9QZPwdOSwfTQJzZC7byLt3PH8Tr1KhmLkfRHwfNJD5XbDRMrxGYOiSnfrLEKNzm9+a4r++bpUG2hNrPyYLpNgph3BXAAfC
+    test3@example.com,iQOxdBV4KrFuPFgyywxytfbsD/rURrzmlADmg1QFP2VHd/kTnkXNpnp2Utv4RS0Zz2YeOloilMhljsOcRVA2YwSu9knwF1h6tNjE
+
+will output three buttons, one for each of the email addresses above, in HTML
+format, one per line. If you're sending out one offer per email, you'll simply
+include each line in the outgoing message to the recipient (one to
+test1@example.com, one to test2@example.com, and one to test3@example.com).
+
+A button from the example above looks like this:
+
+![Example Button](https://github.com/atpay/button-generator/blob/master/imgs/sample_button.png?raw=true)
+
+
+## Library Usage
+
+After following the installation instructions above, you'll have the @Pay button
+generator library loaded in your application. Let's create an array containing
+hashes with our users' email address and html code for a button to deliver to
+htem:
+
+```ruby
+  require 'rubygems'
+  require 'atpay-button-generator'
+
+  button_maker = AtPay::Button::Generator.new({
+    public_key: ATPAY_PUBLIC,
+    private_key: ATPAY_PRIVATE,
+    partner_id: ATPAY_PARTNER,
+    environment: :sandbox,
+    amount: 20
+  })
+
+  output = []
+
+  User.active.each do |user|
+    output << {
+      email: user.email,
+      button_html: button_maker.generate(user.email, user.source)
+    }
+  end
+
+  puts output.inspect
+```
+
+### ActionMailer Example
+
+Assume you have a model that represents an offer you'd like to send to a user:
+
+```ruby
+  class OfferMailer < ActionMailer::Base
+    default from: 'offers@example.com'
+
+    def offer_email(offer)
+      @button = generator.generate({
+        email: offer.recipient.email,
+        source: offer.recipient.card_token
+      })
+
+      mail({ 
+        to: offer.recipient.email,
+        subject: offer.name
+      })
+    end
+
+    private
+    def generator
+      AtPay::Button::Generator.new({
+        amount: offer.amount
+      }.update(atpay_config))
+    end
+
+    # NOTE: Just throw this in an initializer if you can
+    def atpay_config
+      {
+        public_key: ATPAY_PUBLIC,
+        private_key: ATPAY_PRIVATE,
+        partner_id: ATPAY_PARTNER,
+        environment: (Rails.env != "production") ? :sandbox : :production
+      }
+    end
+end
+```
+
+## Templates
+
+
+The generator uses a set of four default templates located in "lib/atpay/button/templates/". The yahoo.liquid template will be used for yahoo emails. The default.liquid template is for all other email providers. There are also versions prefixed with "wrap_" that will be used if the wrap parameter is set to "true". These "wrapped" templates are simply versions with a styled div that hold the buttons. 
+
+To use your own custom templates, you can download the provided default versions. After making the desired modifications, set the template parameter to the location of your modified templates.  

data/Rakefile

@@ -0,0 +1,21 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+require "rake/clean"
+require "rbnacl/rake_tasks"
+
+file "lib/libsodium.so" => :build_libsodium do
+  cp $LIBSODIUM_PATH, "lib/libsodium.so"
+end
+
+task "ci:sodium" => "lib/libsodium.so"
+
+task :ci => %w(ci:sodium spec)
+
+CLEAN.add "lib/libsodium.*"
+
+Rake::TestTask.new do |t|
+  t.libs << "spec"
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end

data/atpay_buttons.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "atpay_buttons"
+  spec.version       = '1.0.0'
+  spec.date          = '2013-08-02'
+  spec.authors       = ["Thomas Pastinsky", "Glen Holcomb", "James Kassemi", "Isaiah Baca"]
+  spec.email         = ["dev@atpay.com"]
+  spec.description   = 'Atpay button generator'
+  spec.summary       = 'Command line tool and Ruby library for generating @Pay 2 click email buttons'
+  spec.homepage      = "http://atpay.com"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "atpay_tokens"
+  spec.add_runtime_dependency "liquid"
+end

data/bin/atpay_buttons

@@ -0,0 +1,62 @@
+#!/usr/bin/env ruby
+
+require 'trollop'
+require_relative '../lib/atpay_buttons.rb'
+
+
+@opts = Trollop::options do
+  version "atpay-button-generator v0.1"
+  banner <<-USAGE
+      To generate an Atpay Button, follow these steps:
+      Create a text file, e.g. data.txt, containing an email address and the associated credit card token separated by a comma. Enter multiple lines for multiple buttons:
+
+      test1@example.com,TL1UwJFXVN7e4p6+0B5N8hy4qQyqeNxVllmC663MLcMupuAWXdHJ9g8PRAnlIh+AMZBgpaIrfWStZ5/3hYi6vCAV7q6+3M6LLqxk
+      test2@example.com,XKCF2E9QZPwdOSwfTQJzZC7byLt3PH8Tr1KhmLkfRHwfNJD5XbDRMrxGYOiSnfrLEKNzm9+a4r++bpUG2hNrPyYLpNgph3BXAAfC
+      test3@example.com,iQOxdBV4KrFuPFgyywxytfbsD/rURrzmlADmg1QFP2VHd/kTnkXNpnp2Utv4RS0Zz2YeOloilMhljsOcRVA2YwSu9knwF1h6tNjE
+
+      Then run the following from the console in the same location as the file you created:
+
+      $ atpay-button-generator --title "Pay" --amount 50.00 --subject "Payment for fifty bucks" --private-key "plBs9X+Zvr65z6iCa0oLNdAEGYZ85Dzf74Qy1yPTris=" --public-key "06zK82iu9NUUMmDiZsEvoUH25tbIE6R3R+zPnDK8YGQ=" --partner-id 20 --input data.txt
+    USAGE
+
+    opt :amount, "The amount a user should be charged for transactions after clicking the generated button", :default => 5.0, :required => true
+    opt :private_key, "The private key given to you by @Pay", :type => :string, :required => true
+    opt :public_key, "@Pay's public key, given to you by @Pay", :type => :string, :required => true
+    opt :partner_id, "The partner ID given to you by @Pay", :type => :integer, :required => true
+    opt :subject, "The subject of the mailto: email (the message that a user will be sending to @Pay's servers after clicking the button", :type => :string
+    opt :image_url, "The URL to a small thumbnail image to be used in the button. Default: https://www.atpay.com/wp-content/themes/atpay/images/bttn_cart.png", :type => :string, :default => "https://www.atpay.com/wp-content/themes/atpay/images/bttn_cart.png"
+    opt :color, "The background color of the button. Default: #6dbe45", :type => :string, :default => "#6dbe45"
+    opt :title, "The title for each button", :type => :string
+    opt :wrap, "Will use wrapped (with a styled div container) version of the template. Default: false", :type => :boolean, :default => false
+    opt :env, "The environment you want to generate buttons for. Currently sandbox or production", :default => 'production'
+    opt :templates, "Location of button templates.", :type => :string, :default => File.dirname(__FILE__) + '/../lib/atpay/button/templates'
+    opt :user_data, "Optional user data to be passed in for your use", :type => :string
+    opt :type, "Optional the default is payment", :type => :string
+    opt :input, "Input File", :default => $stdin
+end
+
+Trollop::die :amount, "must not be negative" if @opts[:amount] < 0
+Trollop::die :input, "must exist" unless File.exist?(@opts[:input]) if @opts[:input]
+
+def symbolize_values
+  @opts[:env] = @opts[:env].to_sym
+  @opts[:type] = @opts[:type].to_sym if @opts[:type]
+end
+
+def parse
+  @targets = []
+
+  symbolize_values
+  @generator = AtPay::Button::Generator.new @opts.dup
+
+  while !@opts[:input].eof?
+    data = @opts[:input].readline.strip.split(',')
+
+    @generator.build([[data[0], data[1]]]).each do |pair|
+      pair[1] = pair[1].gsub(/\s+/, " ")
+      puts pair.join(",")
+    end
+  end
+end
+
+parse

data/circle.yml

@@ -0,0 +1,17 @@
+dependencies:
+  pre:
+    - curl -O http://download.dnscrypt.org/libsodium/releases/libsodium-0.4.1.tar.gz
+    - tar -xvzf libsodium-0.4.1.tar.gz
+    - cd libsodium-0.4.1 && ./configure && make
+    - cp libsodium-0.4.1/src/libsodium/.libs/libsodium.so ./lib/
+
+test:
+  override:
+    - bundle exec rake test
+
+machine:
+  environment:
+    LD_LIBRARY_PATH: lib
+
+  ruby:
+    version: 2.0.0-p195

data/lib/atpay/button/generator.rb

@@ -0,0 +1,109 @@
+module AtPay
+  module Button
+    class LengthError < Exception
+    end
+
+    class Generator
+      # TODO:  This should really move to the underlying token library.
+      TOKEN_TYPES = {
+        payment: nil,
+        validation: 1
+      }
+
+      def initialize(options)
+        @options = { 
+          :title => "Pay",
+          :type => :payment,
+          :group => nil,
+          :user_data => nil,
+          :template => {}
+        }.update options
+
+        @options[:version] = TOKEN_TYPES[@options[:type]] if TOKEN_TYPES[@options[:type]]
+
+        validate_user_data
+        @options[:amount] = amount
+      end
+
+      def amount
+        @amount ||= @options[:amount].respond_to?(:gsub) ? @options[:amount].gsub(/[^0-9\.]/, "").to_f : @options[:amount]
+      end
+
+      # Custom data that is to be added to the token can't exceed 2,500 characters.
+      def validate_user_data
+        return unless @options[:user_data]
+
+        raise LengthError.new "user_data can't be longer than 2,500 characters, you provided #{@options[:user_data].length} characters" if @options[:user_data].length > 2500
+      end
+
+      # Builds an @Pay Payment token for injection into a mailto button.
+      #
+      # @param type [Symbol] The button type: :email, :card, :member
+      # @param source [String] The coresponding type value
+      #
+      # @return [String]
+      def token(type, source)
+        session.security_key(@options.merge({type => source})).email_token
+      end
+
+      # Instanciate a button template instance for a specific email address.  The email is necessary
+      # for selecting the correct template files.  There are some special cases depending on the
+      # environment that the button is being viewed in.
+      #
+      # @param email [String] the email address the button is intended for.
+      #
+      # @return [AtPay::Button::Template]
+      def template(email)
+        Template.new(@options.update(:email => email, :amount => amount))
+      end
+
+      def to_html(token, email)
+        @options.update({:token => token})
+        template(email).render(token: token, :email => email)
+      end
+
+      # Generate the actual button HTML.  There are three options available :source (the card token),
+      # :email (the email address the button is intended for), :type (the type of the source identifier)
+      # :type defaults to card.
+      #
+      # @param options [Hash] there are three options that matter: :source, :email and :type
+      #
+      # @return [String]
+      def generate(options)
+        options[:source] ? source = options[:source] : source = options[:email]
+        options[:type] ? type = options[:type] : type = :card
+        email = options[:email]
+
+        to_html token(type, source), email
+      end
+
+      # Build buttons for the provided collection.  build will accept an array of email addresses ['bob@bob', 'sue@sue'], 
+      # or any "paired" collection:  For example [['bob@bob', 'card_token'], ['sue@sue', 'card_token']] will work,
+      # as will 'bob@bob' => 'card_token', 'sue@sue' => 'card_token'.  If providing only a list of email
+      # addresses build will create email tokens.  Only use this behavior if you are sure it is what both you
+      # and your customer want.  An email token isn't ultra-specific about the card it charges.  It will charge
+      # the first card for that individual it finds that your @Pay account has permission to use.
+      #
+      # @param token_map [Enumerable]
+      #
+      # @return [Array] a list of tuples containing the email address and button code as [String]s
+      def build(token_map)
+        token_map.collect do |email, card|
+          card ? [email, generate(email: email, source: card)] : [email, generate(email: email, type: :email)]
+        end
+      end
+
+
+      private
+
+      def session
+        @session ||= AtPay::Session.new({
+          public_key: @options[:public_key],
+          private_key: @options[:private_key],
+          partner_id: @options[:partner_id],
+          environment: @options[:env]
+        })
+      end
+    end
+  end
+end