payu_payments 0.0.1

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/.rspec

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

data/.ruby-gemset

@@ -0,0 +1 @@
+payu_payments

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p194

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/payu_payments/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 CristianV
+
+MIT License
+
+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,178 @@
+# PayuPayments
+
+A wrapper for the [PayuLatam.com](http://www.payulatam.com/) payment gateway, it include the
+managment of clients, plans, subscriptions and creditCards.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'payu_payments'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install payu_payments
+
+## Usage
+
+All the clases work as a simple CRUD objects, the models also have a
+basic attributes validations.
+
+## Configuration
+
+To use the gem you need to set the keys available on your account
+
+
+```ruby
+  PayuPayments.config do |config|
+    config.api_key = "xxxxxxxxxxxxxx"
+    config.api_login = "xxxxxxx"
+    config.merchant_id = "123456"
+    config.account = "7890"
+    config.mode = "development" # or production to point to production end-point
+  end
+
+```
+
+
+### Clients
+
+To perform transactions with the API an entity representing the
+custormer needs to be created, this entity is de Client and can be
+created and updated using the PayuPayments::Client class.
+
+```ruby
+  @client = PayuPayments::Client.new(:fullName => "john Doe", :email => "johndoe@gmail.com")
+
+  # or
+  
+  @client = PayuPayments::Client.new
+  @client.fullName = "john Doe"
+  @client.email = "johndoe@gmail.com"
+
+  @client.save
+```
+You can also retrieve clients from the API if you know it's id
+
+```ruby
+
+  @client = PayuPayments::Client.find(123)
+  @client.fullName = "New name"
+  @client.save
+
+```
+
+
+### Credit Cards
+
+You can store a tokenized credit card on the gateway tekenization
+service by adding it to a client, in that way the credit card will be
+stored directly in the PCI compliant gateway and can be used to charge the
+client in future transactiosn without requiring to fill the credit card
+form again.
+
+```ruby
+  @client = PayuPayments::Client.find(123)
+
+  creditCard: {
+      name: "Sample User Name",
+      document: "1020304050",
+      number: "4242424242424242",
+      expMonth: "01",
+      expYear: "2020",
+      type: "VISA",
+      address: {
+                line1: "Address Name",
+                line2: "17 25",
+                line3: "Of 301",
+                postalCode: "00000",
+                city: "City Name",
+                state: "State Name",
+                country: "CO",
+                phone: "300300300"
+      }
+  }
+
+  credit_card = @client.add_credit_card(creditCard)
+
+  ### To list the credit cards from a client
+  
+  @client.credit_cards
+```
+
+### Plans
+
+To create a recurring payment model you need to create plans, plans
+describe the different ways that you can sell your suscription based
+products, here you describe the product how much you will charge for it an
+how you want to charge for it
+
+```ruby
+  planParams = {
+          plan: {
+                planCode: "sample-plan-code-001",
+                description: "Sample Plan 001",
+                accountId: "1",
+                intervalCount: "1",
+                interval: "MONTH",
+                maxPaymentsAllowed: "12",
+                maxPaymentAttempts: "3",
+                paymentAttemptsDelay: "1",
+                maxPendingPayments: "0",
+                trialDays: "30",
+                additionalValues: {
+                        additionalValue: [{ name: "PLAN_VALUE",
+                                            value: "20000",
+                                            currency: "COP"
+                                          },
+                                          {
+                                            name: "PLAN_TAX",
+                                            value: "1600",
+                                            currency: "COP"
+                                          }]
+                }
+          }
+  }
+  plan = PayuPayments::Plan.new(planParams)
+  plan.save
+  
+  # or
+  plan = PayuPayments::Plan.create(planParams)
+```
+### Subscriptions
+
+Subscription will glue all together to create a subscription based
+products, with a suscription you will bind a
+client with a tokenized credit card with a plan,
+
+```ruby
+  PayuPayments::Subscription.create(subscription: {
+                                        quantity: "1",
+                                        installments: "1",
+                                        trialDays: "15",
+                                        customer: {
+                                            id: @client.id,
+                                            creditCards: {
+                                                creditCard: { "token": credit_card.token }
+                                        }
+                                        },
+                                        plan: { "planCode": plan.planCode }
+                                    })
+
+  # to check a client susbscriptions
+  @client.subscriptions
+
+```
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/payu_payments/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,24 @@
+#!/usr/bin/env rake
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+Dir.chdir(File.expand_path("..", __FILE__))
+
+require 'payu_payments'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+desc "Payupayments console"
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'payu_payments'
+  require 'pry'
+
+  ARGV.clear
+  IRB.start
+end
+
+
+# If you want to make this the default task
+task :default => :spec

data/lib/payu_payments.rb

@@ -0,0 +1,34 @@
+require "payu_payments/version"
+
+%w{ model caller client plan credit_card subscription recurring_bill_item }.each do |f|
+  require "payu_payments/#{f}"
+end
+
+
+module PayuPayments
+
+  def self.config(&block)
+      @configuration ||= Configuration.new
+
+      unless block.nil?
+        yield @configuration
+      else
+        @configuration.config
+      end
+  end
+
+  class Configuration
+        attr_accessor :api_key, :api_login, :merchant_id, :account, :mode, :show_log
+        def initialize
+            @show_log = false
+        end
+        def config
+            {:api_key => @api_key,
+             :api_login => @api_login,
+             :merchant_id => @merchant_id,
+             :account => @account,
+             :show_log => @show_log,
+             :mode => @mode}
+        end
+  end
+end

data/lib/payu_payments/caller.rb

@@ -0,0 +1,60 @@
+require 'httparty'
+require "base64"
+require 'ostruct'
+
+module PayuPayments
+  class Caller
+    include ::HTTParty
+    include Model
+ 
+    API = "https://api.payulatam.com"
+    API_SANDBOX = "https://stg.api.payulatam.com"
+
+    attr_accessor :access, :base, :resource, :errors
+    format :json
+    alias :attr :base
+
+    def set_base_uri
+        self.class.base_uri(PayuPayments.config[:mode] == "production" ? API : API_SANDBOX)
+    end
+
+    def initialize(params={})
+        @access = PayuPayments.config
+        self.set_base_uri
+        self.class.debug_output $stdout if @access[:show_log]
+
+        @base = OpenStruct.new
+        base.marshal_load params
+        @errors = []
+    end
+ 
+    def http_call(type, url, params={})
+        if ["post", "put"].include? type
+            headers = { 'Accept' => "application/json", 
+                        'Content-Type' => 'application/json; charset=UTF-8',
+                        'Authorization' => "Basic #{basic_auth}"}
+            resp = self.class.send(type, url, :body => params.to_json, :verify => (access[:mode] == "production"), :headers => headers)
+        else
+            headers = { 'Accept' => "application/json", 
+                        'Authorization' => "Basic #{basic_auth}"}
+            resp = self.class.send(type, url, :query => params, :verify => (access[:mode] == "production"), :headers => headers)
+        end
+
+        respond_with = (resp == "" or resp.nil?) ? {} : resp.inject({ }) { |h, (k,v)| h[k.to_sym] = v; h }
+
+        if resp.code.to_s.match(/2\d\d/)
+           respond_with
+        else
+           {"type" => respond_with[:type], "description" => respond_with[:description]}
+        end
+    end
+
+
+private
+
+    def basic_auth
+        Base64.encode64("#{access[:api_login]}:#{access[:api_key]}")
+    end
+
+  end
+end

data/lib/payu_payments/client.rb

@@ -0,0 +1,42 @@
+module PayuPayments
+  class Client < Caller
+
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    # Client attributes from Payu documentation
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    #
+    # id
+    # ullName
+    # emai
+    # creditCards
+    # subscriptions
+
+    def initialize(params={})
+        super
+        @resource = "customers"
+    end
+
+    def add_credit_card(params)
+        cc = CreditCard.new(params)
+        cc.attr.customerId = self.base.id
+        cc.save
+    end
+
+    def subscriptions
+        self.base.subscriptions.map do |sub|
+            subscription =  Subscription.new
+            subscription.base.marshal_load(sub)
+            subscription
+        end
+    end
+
+    def credit_cards
+        self.base.creditCards.each.map do |sub|
+            cc =  CreditCard.new
+            cc.base.marshal_load(sub)
+            cc
+        end
+    end
+  end
+
+end

data/lib/payu_payments/credit_card.rb

@@ -0,0 +1,78 @@
+module PayuPayments
+
+  class CreditCard < Caller
+
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    # Credit Card attributes from Payu documentation
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    #
+    # Token	Longitud = [0,36]	String	Token asociado a una tarjeta de crédito.
+    # customerId	Longitud = #[0,64]	String	Código de identificación del cliente al cual pertenece la tarjeta de crédito
+    # Number	Longitud = [13,20] # Patrón = [0-9]*{13,20}	String	Número de la tarjeta de crédito
+    # expMonth	Min = 1,#Máx = 12	Integer	Mes de expiración de la tarjeta de crédito.
+    # expYear	Min= 0, 
+    # Max = 2999	Integer	Año de expiración de la tarjeta de crédito.
+    #             Si el valor es de dos dígitos corresponde al año comprendido entre 2000 (00) y 2099 (99).
+    #             Si el valor es de más de dos dígitos se toma literal, siendo el año 2000 como mínimo posible.
+    # Type		Enumeration	Corresponde a la franquicia o tipo de tarjeta de crédito. Los posibles valores son:
+    #         VISA, AMEX, DINERS, MASTERCARD, ELO, SHOPPING, NARANJA, CABAL y ARGENCARD.
+    # Name	255	String	Nombre del tarjeta habiente.
+    # document	Longitud = #[5, 30]	String	Número del documento de identificad del tarjeta habiente.
+    # address	-	Address	Dirección de correspondencia del tarjeta habiente asociado con la tarjeta de crédito.
+    # issuerBank	255	String	Nombre del banco emisor de la tarjeta de crédito.
+    #
+    # City	      Longitud = [0, 50]	String	Nombre de la ciudad.
+    # country	    Longitud = [2, 2]	String	Código ISO 3166 (2 letras – Alpha 2) del país de la dirección.
+                             #Ver países soportados
+    # linea1	    Longitud = [0, 100]	String	Primera línea de la dirección.
+    # linea2	    Longitud = [0, 100]	String	Segunda línea de la dirección o número de la dirección.
+    # linea3	    Longitud = [0, 100]	String	Tercera línea de la dirección o complemento de la dirección.
+    # phone	      Longitud = [0, 20]	String	Teléfono asociado a la dirección.
+    # postalCode	Longitud = [0, 20]	String	Código postal de la dirección.
+    # State	      Longitud = [0, 40]	String	Nombre del estado de la dirección.
+
+    def initialize(params={})
+        super
+        @resource = "creditCards"
+    end
+
+    def save
+        if valid?
+          @url = new? ? "#{API_PATH}/customers/#{attr.customerId}/#{@resource}" : "#{API_PATH}/#{@resource}/#{base.id}"
+          super
+        else
+          false
+        end
+    end
+
+    def self.create(customer_id, params)
+        url = "#{API_PATH}/customers/#{attr.customerId}/#{@resource}"
+        self.base.marshal_load params
+        resp = http_call("post", url, attr.marshal_dump) 
+        base.marshal_load resp
+    end
+
+    def destroy(customer_id, id)
+        customer_id = self.attr.customerId
+        id = self.attr.id
+        @url = "#{API_PATH}/customers/#{customer_id}/#{@resource}/#{id}}"
+        super
+    end
+
+    def valid?
+        self.validate
+        self.errors.count == 0
+    end
+
+    def validate
+        self.errors = []
+        [:customerId, :number, :expMonth, :expYear, :type, :document, :address, :name].each do |field|
+          validate_presence_of(field)
+        end
+
+        validate_lenght_of(:expYear, 4)
+    end
+
+  end
+
+end

data/lib/payu_payments/model.rb

@@ -0,0 +1,88 @@
+module Model
+    API_PATH = "/payments-api/rest/v4.3"
+
+    def self.included(base)
+        base.send :extend, ClassMethods
+    end
+
+    def save 
+        verb = new? ? "post" : "put"
+        @url ||= new? ? "#{API_PATH}/#{@resource}" : "#{API_PATH}/#{@resource}/#{base.id}"
+        resp = http_call(verb, @url, base.marshal_dump)
+
+        if resp.is_a?(Array)
+          error = {field: resp[0], message: resp[1]}
+          self.errors << error
+          false
+        else
+          base.marshal_load resp
+          true
+        end
+    end
+
+    def load
+        resp = http_call("get", "#{API_PATH}/#{@resource}/#{self.attr.id}")
+        base.marshal_load resp
+    end
+
+    def destroy
+        @id ||= self.attr.id
+        @url ||= "#{API_PATH}/#{@resource}/#{@id}"
+        resp = http_call("delete", @url)
+        base.marshal_load resp unless resp.is_a? Array
+        resp
+    end
+
+    def new?
+        base.id.nil?
+    end
+
+    def method_missing(method_name, *arguments, &block)
+        if base.marshal_dump.include?(method_name.to_s.strip.to_sym) || method_name.match(/.*=$/)
+           base.send(method_name.to_s.strip, *arguments, &block)
+        else
+           super
+        end
+    end
+
+
+    # xxxxxxxxxxxxxxxxx validations xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+    def validate_presence_of(field)
+        if (self.attr.send(field.to_s).nil? or self.attr.send(field.to_s) == "")
+            error = {}
+            error[:field] = field
+            error[:message] = "#{field} can't be blank"
+            self.errors << error
+        end
+    end
+
+    def validate_lenght_of(field, lenght)
+        unless self.attr.send(field.to_s).nil?
+          if self.attr.send(field.to_s).length != lenght
+              error = {}
+              error[:field] = field
+              error[:message] = "lenght of #{field} should be #{lenght}"
+              self.errors << error
+          end
+        end
+    end
+
+    # Class Methods
+    module ClassMethods
+        def find(id)
+            resp = self.new
+            json = resp.http_call("get", "#{API_PATH}/#{resp.resource}/#{id}")
+
+            unless json["type"] == "NOT_FOUND"
+              self.new json
+            else
+              nil
+            end
+        end
+
+        def create(params)
+            http_call("post", "#{API_PATH}/#{@resource}", base.marshal_dump)
+        end
+    end
+end

data/lib/payu_payments/plan.rb

@@ -0,0 +1,72 @@
+module PayuPayments
+  class Plan < Caller
+
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    # Plan attributes from Payu documentation
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    #
+    # id                        36	String  Identificador del plan en la plataforma de PayU.
+    # planCode                  255	String  Código único que el comercio le asigna al plan para su posterior identificación. Este código de plan no se puede volver a repetir aun cuando el plan sea borrado.
+    # description               255	String  Descripción del plan.
+    # accountId                     Integer Identificador de la cuenta del comercio al cual se asocia el plan.
+    # interval                  5   String  Intervalo que define cada cuanto se realiza el cobro de la suscripción. Los valores posibles son:
+    #                                        DAY, WEEK, MONTH y YEAR.
+    # intervalCount                 Integer Cantidad del intervalo que define cada cuanto se realiza el cobro de la suscripción.
+    # additionalValue.currency  3   String  Código ISO 4217 de la moneda del valor asociado al plan.
+    # additionalValue.name      255 String  Nombre del campo del valor asociado al plan. Los valores posibles son:
+    #                                       PLAN_VALUE: valor total de plan. 
+    #                                       PLAN_TAX_VALUE: valor de los impuestos asociados al valor del plan. 
+    #                                       PLAN_TAX_RETURN_BASE: valor base para el retorno de impuestos asociados al plan.
+    # additionalValue.value         Decimal Valor del plan, impuesto o base de retorno de acuerdo a plan.additionalValue.name.
+    # trialDays                     Integer Cantidad de días de prueba de la suscripción.
+    # maxPaymentAttempts        Máx. 3      Integer	Cantidad total de reintentos para cada pago rechazado de la suscripción.
+    # maxPaymentsAllowed            Integer Cantidad total de pagos de la suscripción.
+    # maxPendingPayments            Integer Cantidad máxima de pagos pendientes que puede tener una suscripción antes de ser cancelada.
+    # paymentAttemptsDelay          Integer Cantidad de días de espera entre los reintentos de pago de la suscripción.
+
+    def initialize(params={})
+        super
+        @resource = "plans"
+    end
+
+    def save
+        verb = new? ? "post" : "put"
+        url = new? ? "#{API_PATH}/#{@resource}" : "#{API_PATH}/#{@resource}/#{base.planCode}"
+        not_allowed_for_update = [:maxPaymentsAllowed, :trialDays, :id, :intervalCount, :interval, :accountId]
+
+        params = base.marshal_dump
+        not_allowed_for_update.each {|x| params.delete(x) } unless new?
+        resp = http_call(verb, url, params)
+
+        base.marshal_load resp
+    end
+
+    def self.create_base_month_plan(name, value, custom_options={})
+        params = {
+            planCode: name,
+            description: "#{name} plan",
+            accountId: PayuPayments.config[:account],
+            intervalCount: 1,
+            interval: "MONTH",
+            maxPaymentsAllowed: 2000,
+            maxPaymentAttempts: 3,
+            paymentAttemptsDelay: 5,
+            maxPendingPayments: 0,
+            trialDays: 0,
+            additionalValues: [{
+                                name: "PLAN_VALUE",
+                                value: value,
+                                currency: "COP"
+                                }]
+        }
+        params.merge!(custom_options)
+        self.new params
+    end
+
+
+    def destroy
+        @id = self.attr.planCode
+        super
+    end
+  end
+end

data/lib/payu_payments/recurring_bill_item.rb

@@ -0,0 +1,30 @@
+module PayuPayments
+
+  class RecurringBillItem < Caller
+    def initialize(params={})
+        super
+        @resource = "recurringBillItems"
+    end
+
+    def save 
+        verb = new? ? "post" : "put"
+        url = new? ? "#{API_PATH}/subscriptions/#{base.subscription_id}/#{@resource}" : "#{API_PATH}/#{@resource}/#{base.id}"
+        resp = http_call(verb, url, base.marshal_dump) 
+        base.marshal_load resp
+    end
+
+    def create(params)
+        url = "#{API_PATH}/subscriptions/#{attr.subscription_id}/#{@resource}"
+        resp = http_call(verb, url, base.marshal_dump) 
+        base.marshal_load resp
+    end
+
+    def get_recurring_bill_items
+        url = "#{API_PATH}/#{@resource}/params"
+        resp = http_call(verb, url, base.marshal_dump) 
+        base.marshal_load resp
+    end
+
+  end
+
+end

data/lib/payu_payments/subscription.rb

@@ -0,0 +1,28 @@
+module PayuPayments
+
+  class Subscription < Caller
+
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    # Subscription attributes from Payu documentation
+    # xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+    #
+    # id	36	String	Identificador de la suscripción en la plataforma PayU.
+    # quantity	-	Integer	Cantidad de planes a adquirir con la suscripción.
+    # installments	-	Integer	Número de cuotas en las que se diferirá cada cobro de la suscripción.
+    # trialDays	-	Integer	Días de prueba que téndra la suscripción sin generar cobros.
+    # customer	-	Customer	Cliente asociado a la suscripción. 
+    # customer.credidcards	-	CreditCard	Tarjeta de crédito asociada al cliente. 
+    # plan	-	Plan	Plan asociado a la suscripción.
+
+    def initialize(params={})
+        super
+        @resource = "subscriptions"
+    end
+
+    def add_extra_charges(params={})
+        url = "#{API_PATH}/#{self.attr.id}/recurringBillItems"
+        http_call("put", url, params)
+    end
+  end
+
+end

data/lib/payu_payments/version.rb

@@ -0,0 +1,3 @@
+module PayuPayments
+  VERSION = "0.0.1"
+end

data/payu_payments.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'payu_payments/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "payu_payments"
+  spec.version       = PayuPayments::VERSION
+  spec.authors       = ["CristianV"]
+  spec.email         = ["cristian@kommit.co"]
+  spec.summary       = %q{Payulatam payments gatewat API gem}
+  spec.description   = %q{Payulatam payments gatewat API gem}
+  spec.homepage      = "https://github.com/kommitters/payu_payments"
+  spec.license       = "MIT"
+
+  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.require_paths = ["lib"]
+
+  # Dependency
+  spec.add_dependency "httparty"
+
+  # Development
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "pry"
+end

data/spec/caller_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+module PayuPayments
+
+  describe Caller do
+
+    it "Should set a base container to hold attributes" do
+        call = Caller.new
+        expect(call.base).to be_an_instance_of(OpenStruct)
+    end
+
+    it "should get access credentials from config" do
+        ::PayuPayments.config do |config|
+          config.api_key = "6u39nqhq8ftd0hlvnjfs66eh8c"
+          config.api_login = "11959c415b33d0c"
+          config.merchant_id = "500238"
+          config.account = "5009"
+          config.mode = "development"
+        end
+
+        call = Caller.new
+        expect(call.access[:api_key]).to eq("6u39nqhq8ftd0hlvnjfs66eh8c")
+        expect(call.access[:api_login]).to eq("11959c415b33d0c")
+        expect(call.access[:merchant_id]).to eq("500238")
+        expect(call.access[:account]).to eq("5009")
+        expect(call.access[:mode]).to eq("development")
+    end
+
+    it "Should construct a base object with the initial params" do
+        call = Caller.new(:name => "jhon", :last_name => "Doe", :number => 123)
+        expect(call.base.name).to eq("jhon")
+        expect(call.base.last_name).to eq("Doe")
+        expect(call.base.number).to eq(123)
+    end
+
+    context "validations" do
+
+      it "should be able to validate the lenght of a fiekd" do
+        call = Caller.new(:name => "jhon")
+        call.validate_lenght_of(:name, 5)
+        expect(call.errors.count).to eq(1)
+        expect(call.errors.first[:message]).to eq("lenght of name should be 5")
+      end
+
+    end
+
+
+
+    context "performing http calls" do
+      let (:resp) {a = {"valor1" => "hola"}; a.stub(:code => "200"); a}
+      before :each do
+        ::PayuPayments.config do |config|
+          config.api_key = "6u39nqhq8ftd0hlvnjfs66eh8c"
+          config.api_login = "11959c415b33d0c"
+          config.merchant_id = "500238"
+          config.account = "5009"
+          config.mode = "development"
+        end
+      end
+
+      it "should be able to perform POST calls" do
+        attr = {fullName: "john doe", email: "jhon@doe.com"}
+        call = Caller.new(attr)
+        call.stub(:basic_auth => "abc123")
+        headers = { 'Accept' => "application/json", 
+                    'Content-Type' => 'application/json; charset=UTF-8',
+                    'Authorization' => "Basic abc123"}
+        Caller.should_receive(:send).with("post", "/someurl", :body => attr.to_json, :verify => false, :headers => headers).and_return(resp)
+        call.http_call("post", "/someurl", attr)
+      end
+
+      it "should be able to perform PUT calls" do
+        attr = {fullName: "john doe", email: "jhon@doe.com"}
+        call = Caller.new(attr)
+        call.stub(:basic_auth => "abc123")
+        headers = { 'Accept' => "application/json", 
+                    'Content-Type' => 'application/json; charset=UTF-8',
+                    'Authorization' => "Basic abc123"}
+        Caller.should_receive(:send).with("put", "/someurl", :body => attr.to_json, :verify => false, :headers => headers).and_return(resp)
+        call.http_call("put", "/someurl", attr)
+      end
+
+
+      it "should be able to perform GET calls" do
+        attr = {fullName: "john doe", email: "jhon@doe.com"}
+        call = Caller.new(attr)
+        call.stub(:basic_auth => "abc123")
+        headers = { 'Accept' => "application/json", 
+                    'Authorization' => "Basic abc123"}
+        Caller.should_receive(:send).with("get", "/someurl", :query => attr, :verify => false, :headers => headers).and_return(resp)
+        call.http_call("get", "/someurl", attr)
+      end
+
+      it "should be able to perform DELETE calls" do
+        attr = {fullName: "john doe", email: "jhon@doe.com"}
+        call = Caller.new(attr)
+        call.stub(:basic_auth => "abc123")
+        headers = { 'Accept' => "application/json", 
+                    'Authorization' => "Basic abc123"}
+        Caller.should_receive(:send).with("delete", "/someurl", :query => attr, :verify => false, :headers => headers).and_return(resp)
+        call.http_call("delete", "/someurl", attr)
+      end
+    end
+
+  end
+
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+module PayuPayments
+
+  describe Client do
+     it "should be able to create a client" do
+       client = Client.new(:fullName => "John Doe", :email => "johndoe@gmail.com")
+       client.should_receive(:http_call).with("post", "/payments-api/rest/v4.3/customers", {:fullName => "John Doe", :email => "johndoe@gmail.com"}).and_return(:fullName => "John Doe", :email => "johndoe@gmail.com")
+       client.save
+     end
+
+     it "should be able to find a client with its id" do
+        call = Client.new
+        call.should_receive(:http_call).with("get","/payments-api/rest/v4.3/customers/1").and_return(:fullName => "John Doe", :email => "johndoe@gmail.com", :id => 1)
+        Client.should_receive(:new).twice.and_return(call)
+        client = Client.find(1) 
+        expect(client).to be_an_instance_of(Client)
+     end
+
+     it "should save a credit card related to the client" do
+       client = Client.new(:id => "123", :fullName => "John Doe", :email => "johndoe@gmail.com")
+       cc = CreditCard.new
+       CreditCard.should_receive(:new).and_return(cc)
+       cc.stub(:save => true)
+       client.add_credit_card({number: "1234", :name => "John Doe"})
+     end
+
+     it "should be able to load credit cards" do
+       response = {
+                  id: "2mkls9xekm",
+                  fullName: "Pedro Perez",
+                  email: "pperez@payulatam.com",
+                  creditCards: [
+                                  {
+                                  token: "da2224a9-58b7-482a-9866-199de911c23f",
+                                  customerId: "2mkls9xekm",
+                                  number: "************4242",
+                                  name: "Usuario Prueba",
+                                  type: "VISA",
+                                  address: {
+                                              line1: "Street 93B",
+                                              line2: "17 25",
+                                              line3: "Office 301",
+                                              city: "Bogota",
+                                              country: "CO",
+                                              postalCode: "00000",
+                                              phone: "300300300"
+                                              }
+                                  }
+                  ]
+                  }
+        Client.should_receive(:find).and_return(Client.new(response))
+        client = Client.find("2mkls9xekm")
+        expect(client.base.id).to eq("2mkls9xekm")
+        expect(client.credit_cards[0].attr.number).to eql("************4242")
+     end
+
+     it "should be able to load subscriptions" do
+       response = {
+                  id: "2mkls9xekm",
+                  fullName: "Pedro Perez",
+                  email: "pperez@payulatam.com",
+                  subscriptions: [
+                                    {
+                                    id: "2mlhk3qxji",
+                                    quantity: "1",
+                                    installments: "1",
+                                    currentPeriodStart: "2013-08-30T10:46:41.477-05:00",
+                                    currentPeriodEnd: "2013-09-29T10:46:41.477-05:00",
+                                    plan: {
+                                              id: "414215a2-c990-4525-ba84-072181988d09",
+                                              planCode: "PLAN-REST-16",
+                                              description: "Plan rest test",
+                                              accountId: "1",
+                                              intervalCount: "1",
+                                              interval: "MONTH",
+                                              additionalValues: [
+                                                                  {
+                                                                  name: "PLAN_VALUE",
+                                                                  value: "20000",
+                                                                  currency: "COP"
+                                                                  }]
+                                            }
+                                      }
+                  ]
+                  }
+        Client.should_receive(:find).and_return(Client.new(response))
+        client = Client.find("2mkls9xekm")
+        expect(client.base.id).to eq("2mkls9xekm")
+        expect(client.subscriptions[0].attr.id).to eql("2mlhk3qxji")
+     end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+describe PayuPayments  do
+
+  context "Configuration" do
+    it "should be able to set configuration keys" do
+        PayuPayments.config do |config|
+          config.api_key = "xxx"
+          config.merchant_id = "123"
+          config.account = "abc123"
+        end
+    end
+
+    it "should be able to read configuration keys" do
+        PayuPayments.config[:api_key].should == "xxx"
+    end
+  end
+end

data/spec/credit_card_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module PayuPayments
+
+  describe CreditCard do
+     it "should be able to validate a credit card" do
+        cc = CreditCard.new
+        expect(cc.valid?).to eq(false)
+     end
+
+     it "should tell me where the errors are" do
+        cc = CreditCard.new
+        cc.valid?
+        expect(cc.errors.count).to be > 0
+        expect(cc.errors.first[:field]).to eql(:customerId)
+        expect(cc.errors.first[:message]).to eql("customerId can't be blank")
+     end
+
+     it "should not allow to save a credit card with erros" do
+        expect(CreditCard.new.save).to be(false)
+     end
+  end
+end

data/spec/plan_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module PayuPayments
+  describe Plan do
+
+    it "should be able to create a plan" do
+        plan = {
+                plan: {
+                      planCode: "sample-plan-code-001",
+                      description: "Sample Plan 001",
+                      accountId: "1",
+                      intervalCount: "1",
+                      interval: "MONTH",
+                      maxPaymentsAllowed: "12",
+                      maxPaymentAttempts: "3",
+                      paymentAttemptsDelay: "1",
+                      maxPendingPayments: "0",
+                      trialDays: "30",
+                      additionalValues: {
+                              additionalValue: [{ name: "PLAN_VALUE",
+                                                  value: "20000",
+                                                  currency: "COP"
+                                                },
+                                                {
+                                                  name: "PLAN_TAX",
+                                                  value: "1600",
+                                                  currency: "COP"
+                                                }]
+                      }
+                }
+        }
+        my_plan = Plan.new(plan)
+        my_plan.should_receive(:http_call).with("post", "/payments-api/rest/v4.3/plans", plan).and_return(plan)
+        my_plan.save
+
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'payu_payments'
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: payu_payments
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- CristianV
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Payulatam payments gatewat API gem
+email:
+- cristian@kommit.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/payu_payments.rb
+- lib/payu_payments/caller.rb
+- lib/payu_payments/client.rb
+- lib/payu_payments/credit_card.rb
+- lib/payu_payments/model.rb
+- lib/payu_payments/plan.rb
+- lib/payu_payments/recurring_bill_item.rb
+- lib/payu_payments/subscription.rb
+- lib/payu_payments/version.rb
+- payu_payments.gemspec
+- spec/caller_spec.rb
+- spec/client_spec.rb
+- spec/config_spec.rb
+- spec/credit_card_spec.rb
+- spec/plan_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kommitters/payu_payments
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Payulatam payments gatewat API gem
+test_files:
+- spec/caller_spec.rb
+- spec/client_spec.rb
+- spec/config_spec.rb
+- spec/credit_card_spec.rb
+- spec/plan_spec.rb
+- spec/spec_helper.rb