openpay_copemx 3.0.0

data/lib/openpay/customers.rb

@@ -0,0 +1,200 @@
+require 'open_pay_resource'
+
+class Customers < OpenPayResource
+
+  #Bankaccount
+  def create_bank_account(customer, bank_account)
+    create(bank_account, "#{customer}/bankaccounts")
+  end
+
+  def get_bank_account(customer, bank_id)
+    get("#{customer}/bankaccounts/#{bank_id}")
+  end
+
+  def all_bank_accounts(customer)
+    get("#{customer}/bankaccounts/")
+  end
+
+  def list_bankaccounts(customer, search_params)
+    get("#{customer}/bankaccounts#{search_params.to_s}")
+  end
+
+  def each_bank_account(customer)
+    get("#{customer}/bankaccounts/").each do |account|
+      yield account
+    end
+  end
+
+  def delete_bank_account(customer, bank_id)
+    delete("#{customer}/bankaccounts/#{bank_id}")
+  end
+
+  def delete_all_bank_accounts(customer)
+    if env == :production
+      raise OpenpayException.new('This method is not supported on PRODUCTION', false)
+    end
+    each_bank_account(customer) do |account|
+      delete("#{customer}/bankaccounts/#{account['id']}")
+    end
+  end
+
+  #Charges
+  # customers.create_charge(customer_id,charge)
+  def create_charge(customer_id, charge)
+    create(charge, "#{customer_id}/charges")
+  end
+
+  #gets a charge_id for a given customer_id
+  def get_charge(customer_id, charge_id)
+    get("#{customer_id}/charges/#{charge_id}")
+  end
+
+  def list_charges(customer, search_params)
+    get("#{customer}/charges#{search_params.to_s}")
+  end
+
+  #return all charges for the given customer_id
+  def all_charges(customer_id)
+    get("#{customer_id}/charges/")
+  end
+
+  def cancel_charge(customer_id, charge_id)
+    post(charge_id, "#{customer_id}/charges/#{charge_id}/cancel")
+  end
+
+  def refund_charge(customer_id, charge_id, description)
+    post(description, "#{customer_id}/charges/#{charge_id}/refund")
+  end
+
+  def capture_charge(customer_id, charge_id)
+    post('', "#{customer_id}/charges/#{charge_id}/capture")
+  end
+
+  def confirm_customer_capture(customer_id, charge_id, amount)
+    post(amount, "#{customer_id}/charges/#{charge_id}/capture")
+  end
+
+  #Payouts
+  def create_payout(customer_id, payout)
+    post(payout, "#{customer_id}/payouts")
+  end
+
+  def all_payouts(customer_id)
+    get("#{customer_id}/payouts")
+  end
+
+  def get_payout(customer_id, payout_id)
+    get("#{customer_id}/payouts/#{payout_id}")
+  end
+
+  def each_payout(customer_id)
+    all_payouts(customer_id).each do |pay|
+      yield pay
+    end
+  end
+
+  def list_payouts(customer, search_params)
+    get("#{customer}/payouts#{search_params.to_s}")
+  end
+
+  #Transfers
+  def create_transfer(customer_id, transfer)
+    post(transfer, "#{customer_id}/transfers")
+  end
+
+  def all_transfers(customer_id)
+    get("#{customer_id}/transfers/")
+  end
+
+  def list_transfers(customer, search_params)
+    get("#{customer}/transfers#{search_params.to_s}")
+  end
+
+  def get_transfer(customer_id, transfer_id)
+    get("#{customer_id}/transfers/#{transfer_id}")
+  end
+
+  def each_transfer(customer_id)
+    all_transfers(customer_id).each do |trans|
+      yield trans
+    end
+  end
+
+  #Subscriptions
+  def create_subscription(subscription, customer_id)
+    #revisar la url
+    post(subscription, "#{customer_id}/subscriptions")
+  end
+
+  def delete_subscription(customer_id, subscription_id)
+    delete("#{customer_id}/subscriptions/#{subscription_id}")
+  end
+
+  def get_subscription(customer_id, subscription_id)
+    get("#{customer_id}/subscriptions/#{subscription_id}")
+  end
+
+  def all_subscriptions(customer_id)
+    get("#{customer_id}/subscriptions/")
+  end
+
+  def list_subscriptions(customer, search_params)
+    get("#{customer}/subscriptions#{search_params.to_s}")
+  end
+
+  def each_subscription(customer_id)
+    all_subscriptions(customer_id).each do |cust|
+      yield cust
+    end
+  end
+
+  def update_subscription(subscription, customer, params)
+    put(params, "#{customer}/subscriptions/#{subscription}")
+  end
+
+  def delete_all_subscriptions(customer_id)
+    if env == :production
+      raise OpenpayException.new('This method is not supported on PRODUCTION', false)
+    end
+    all_subscriptions(customer_id).each do |sub|
+      delete_subscription(customer_id, sub['id'])
+    end
+  end
+
+  #Card
+  def create_card(customer, card)
+    create(card, "#{customer}/cards")
+  end
+
+  def get_card(customer, card_id)
+    get("#{customer}/cards/#{card_id}")
+  end
+
+  def delete_card(customer, card_id)
+    delete("#{customer}/cards/#{card_id}")
+  end
+
+  def delete_all_cards(customer_id)
+    if env == :production
+      raise OpenpayException.new('This method is not supported on PRODUCTION', false)
+    end
+    each_card(customer_id) do |card|
+      delete_card(customer_id, card['id'])
+    end
+  end
+
+  def each_card(customer)
+    get("#{customer}/cards").each do |card|
+      yield card
+    end
+  end
+
+  def list_cards(customer, search_params)
+    get("#{customer}/cards#{search_params.to_s}")
+  end
+
+  def all_cards(customer)
+    get("#{customer}/cards")
+  end
+
+end

data/lib/openpay/errors/openpay_connection_exception.rb

@@ -0,0 +1,3 @@
+require 'openpay/errors/openpay_exception'
+class OpenpayConnectionException < OpenpayException
+end

data/lib/openpay/errors/openpay_exception.rb

@@ -0,0 +1,29 @@
+class OpenpayException < StandardError
+
+  attr_reader :description
+  attr_reader :http_code
+  attr_reader :http_body
+  attr_reader :json_body
+  attr_reader :error_code
+  attr_reader :category
+
+  def initialize(message=nil,json_message=true)
+  #openpay errors  have a json error string
+   if json_message
+      json= JSON.parse message
+      @description = json['description']
+      @http_code =   json['http_code']
+      @error_code = json['error_code']
+      @json_body = message
+     @category   = json['category']
+   #other errors may or not have a json error string, so this case is for them
+   else
+     @description = message
+     @http_code  =   ''
+     @http_body  =  ''
+     @json_body  =  ''
+     @error_code = ''
+    end
+  end
+
+end

data/lib/openpay/errors/openpay_exception_factory.rb

@@ -0,0 +1,56 @@
+class OpenpayExceptionFactory
+
+  def OpenpayExceptionFactory::create(exception)
+
+    LOG.warn("An exception has been raised (original exception class: #{exception.class})")
+
+    case exception
+
+      #resource not found
+      #malformed jason, invalid data, invalid request
+      when RestClient::BadRequest, RestClient::ResourceNotFound,
+          RestClient::Conflict, RestClient::PaymentRequired,
+          RestClient::UnprocessableEntity
+
+        oe=OpenpayTransactionException.new exception.http_body
+        LOG.warn "-OpenpayTransactionException: #{exception.http_body}"
+        @errors=true
+        raise oe
+
+      #connection, timeouts, network related errors
+      when Errno::EADDRINUSE, Errno::ETIMEDOUT, OpenSSL::SSL::SSLError
+        #since this exceptions are not based on the rest api exceptions
+        #we do not have the json message so we just build the exception
+        #with the original exception message set in e.description and e.message
+        oe=OpenpayConnectionException.new(exception.message,false)
+        LOG.warn exception.message
+        @errors=true
+        raise oe
+      #badgateway-connection error, invalid credentials
+      when  RestClient::BadGateway, RestClient::Unauthorized, RestClient::RequestTimeout
+            LOG.warn exception
+            if exception.http_body
+              oe=OpenpayConnectionException.new exception.http_body
+            else
+              oe=OpenpayConnectionException.new(exception.message, false)
+            end
+            @errors=true
+            raise oe
+
+      when  RestClient::Exception , RestClient::InternalServerError
+            LOG.warn exception
+            if exception.http_body
+              oe=OpenpayException.new exception.http_body
+            else
+              oe=OpenpayException.new(exception.message, false)
+            end
+            @errors=true
+            raise oe
+      else
+        #We won't hide unknown exceptions , those should be raised
+        LOG.warn exception.message
+        raise exception
+    end
+  end
+
+end

data/lib/openpay/errors/openpay_transaction_exception.rb

@@ -0,0 +1,5 @@
+require 'openpay/errors/openpay_exception'
+
+class OpenpayTransactionException < OpenpayException
+
+end

data/lib/openpay/fees.rb

@@ -0,0 +1,5 @@
+require 'open_pay_resource'
+
+class Fees < OpenPayResource
+
+end

data/lib/openpay/open_pay_resource.rb

@@ -0,0 +1,295 @@
+#This class is the abstract base class for other Openpay resources
+#This class defines the basic rest verbs making use of the rest-api gem.
+#Method aliases are created to provide friendly names.
+class OpenPayResource
+
+  attr_accessor :api_hook
+
+  def initialize(merchant_id, private_key, production = false, timeout = 90, country)
+    @merchant_id = merchant_id
+    @private_key = private_key
+    #assigns base url depending the requested env
+    @country = country
+    @base_url = OpenpayApi::base_url(production, country)
+    @errors = false
+    @production = production
+    @timeout = timeout
+    #created resources should have a hook with the base class to keep control of created resources
+    @api_hook = nil
+  end
+
+  #returns the env set
+  def env
+    if @production
+      :production
+    else
+      :test
+    end
+  end
+
+  #errors on last call
+  def errors?
+    @errors
+  end
+
+  def list(search_params)
+    get(search_params.to_s)
+  end
+
+  def each
+    all.each do |line|
+      yield line
+    end
+  end
+
+  def delete_all
+
+    if env == :production
+      raise OpenpayException.new('delete_all method cannot be used on production', false)
+    end
+
+    each do |res|
+      self.delete(res['id'])
+    end
+
+  end
+
+  def get(args = '')
+    @errors = false
+    terminated = true
+    if is_filter_string?(args)
+      terminated = false
+    end
+    strUrl = url(args, terminated)
+    strUrlAux = delete_ending_slash(strUrl)
+    LOG.debug("#{resource_name}:")
+    LOG.debug("   GET Resource URL:#{url(args, terminated)}")
+    res = RestClient::Request.new(
+      :method => :get,
+      :url => strUrlAux,
+      :user => @private_key,
+      :timeout => @timeout,
+      :ssl_version => :TLSv1_2,
+      :headers => { :accept => :json,
+                    :content_type => :json,
+                    :user_agent => 'Openpay/v1  Ruby-API',
+      }
+    )
+    json_out = nil
+    begin
+      json_out = res.execute
+      #exceptions
+    rescue Exception => e
+      @errors = true
+      #will raise the appropriate exception and return
+      OpenpayExceptionFactory::create(e)
+    end
+    JSON[json_out]
+  end
+
+  def get_with_custom_url(url = '')
+    @errors = false
+    res = RestClient::Request.new(
+      :method => :get,
+      :url => url,
+      :user => @private_key,
+      :timeout => @timeout,
+      :ssl_version => :TLSv1_2,
+      :headers => { :accept => :json,
+                    :content_type => :json,
+                    :user_agent => 'Openpay/v1  Ruby-API',
+      }
+    )
+    json_out = nil
+    begin
+      json_out = res.execute
+      #exceptions
+    rescue Exception => e
+      @errors = true
+      #will raise the appropriate exception and return
+      OpenpayExceptionFactory::create(e)
+    end
+    JSON[json_out]
+  end
+
+  def delete(args)
+
+    @errors = false
+
+    strUrl = url(args)
+    strUrlAux = delete_ending_slash(strUrl)
+
+    LOG.debug("#{self.class.name.downcase}:")
+    LOG.debug("    DELETE  URL:#{strUrlAux}")
+
+    res = ''
+    req = RestClient::Request.new(
+      :method => :delete,
+      :url => strUrlAux,
+      :user => @private_key,
+      :timeout => @timeout,
+      :ssl_version => :TLSv1_2,
+      :headers => { :accept => :json,
+                    :content_type => :json,
+                    :user_agent => 'Openpay/v1  Ruby-API',
+      }
+    )
+
+    begin
+      res = req.execute
+      #exceptions
+    rescue Exception => e
+      @errors = true
+      #will raise the appropriate exception and return
+      OpenpayExceptionFactory::create(e)
+    end
+    #returns a hash
+    JSON[res] if not res.empty?
+  end
+
+  def post(message, args = '')
+
+    @errors = false
+
+    if message.is_a?(Hash)
+      return_hash = true
+      json = hash2json message
+    else
+      json = message
+      return_hash = false
+    end
+
+    strUrl = url(args)
+    strUrlAux = delete_ending_slash(strUrl)
+
+    # LOG.debug("#{self.class.name.downcase}:")
+    LOG.debug "   POST URL:#{strUrlAux}"
+    LOG.debug "   json: #{json}"
+
+    begin
+      #request
+      res = RestClient::Request.new(
+        :method => :post,
+        :url => strUrlAux,
+        :user => @private_key,
+        :timeout => @timeout,
+        :ssl_version => :TLSv1_2,
+        :payload => json,
+        :headers => { :accept => :json,
+                      :content_type => :json,
+                      :user_agent => 'Openpay/v1  Ruby-API',
+                      :json => json }
+      ).execute
+
+      #exceptions
+    rescue Exception => e
+      @errors = true
+      #will raise the appropriate exception and return
+      OpenpayExceptionFactory::create(e)
+    end
+
+    #return
+    if return_hash
+      JSON.parse res
+    else
+      res
+    end
+
+  end
+
+  def put(message, args = '')
+
+    return_hash = false
+
+    if message.is_a?(Hash)
+      return_hash = true
+      json = hash2json message
+    else
+      json = message
+      return_hash = false
+    end
+
+    strUrl = url(args)
+    strUrlAux = delete_ending_slash(strUrl)
+
+    LOG.info "PUT URL:#{strUrlAux}"
+    #LOG.info "   json: #{json}"
+
+    begin
+      res = RestClient::Request.new(
+        :method => :put,
+        :url => strUrlAux,
+        :user => @private_key,
+        :timeout => @timeout,
+        :ssl_version => :TLSv1_2,
+        :payload => json,
+        :headers => { :accept => :json,
+                      :content_type => :json,
+                      :user_agent => 'Openpay/v1  Ruby-API',
+                      :json => json }
+      ).execute
+    rescue RestClient::BadRequest => e
+      warn e.http_body
+      @errors = true
+      return JSON.parse e.http_body
+    end
+
+    if return_hash
+      JSON.parse res
+    else
+      res
+    end
+
+  end
+
+  #aliases for rest verbs
+  alias_method :all, :get
+  alias_method :update, :put
+  alias_method :create, :post
+
+  def hash2json(jash)
+    JSON.generate(jash)
+  end
+
+  def json2hash(json)
+    JSON[json]
+  end
+
+  private
+
+  def url(args = '', terminated = true)
+    if args.nil? || args.empty?
+      terminated = false
+    end
+    termination = terminated ? '/' : ''
+    @base_url + "#{@merchant_id}/" + resource_name + termination + args
+  end
+
+  def resource_name
+    if self.class.name.downcase.gsub(@country, "") == "pse"
+      'charges'
+    else
+      self.class.name.downcase.gsub(@country, "")
+    end
+  end
+
+  def delete_ending_slash(url)
+    slash = '/'
+    strUrl = url
+    strUrlAux = url
+    ending = strUrl.to_s[-1, 1]
+    if ending == slash
+      strUrlAux = strUrl.to_s[0, strUrl.length - 1]
+    end
+    strUrlAux
+  end
+
+  def is_filter_string?(args)
+    is_filter = false
+    if args =~ /^\?/
+      is_filter = true
+    end
+    is_filter
+  end
+
+end

data/lib/openpay/open_pay_resource_factory.rb

@@ -0,0 +1,17 @@
+class OpenPayResourceFactory
+  def OpenPayResourceFactory::create(resource, merchant_id, private_key, production, timeout, country)
+    begin
+      resource = resource.capitalize
+      if country == "co"
+        resource = "#{resource}Co".to_sym
+      end
+      if country == "pe"
+        resource = "#{resource}Pe".to_sym
+      end
+      Object.const_get(resource).new(merchant_id, private_key, production, timeout, country)
+    rescue NameError
+      raise OpenpayException.new("Invalid resource name:#{resource}", false)
+    end
+  end
+end
+

data/lib/openpay/openpay_api.rb

@@ -0,0 +1,72 @@
+require 'logger'
+require 'base64'
+require 'rest-client'
+require 'uri'
+
+require 'openpay/open_pay_resource_factory'
+require 'errors/openpay_exception'
+
+LOG = Logger.new(STDOUT)
+#change to Logger::DEBUG if need trace information
+#due the nature of the information, we recommend to never use a log file when in debug
+LOG.level = Logger::FATAL
+
+class OpenpayApi
+  #API Endpoints
+  API_DEV = 'https://sandbox-api.openpay.mx/v1/'
+  API_PROD = 'https://api.openpay.mx/v1/'
+  API_DEV_CO = 'https://sandbox-api.openpay.co/v1/'
+  API_PROD_CO = 'https://api.openpay.co/v1/'
+  API_DEV_PE = 'https://sandbox-api.openpay.pe/v1/'
+  API_PROD_PE = 'https://api.openpay.pe/v1/'
+
+  # by default testing environment is used
+  # country can take value 'mx' (Mexico) or 'co' Colombia
+  def initialize(merchant_id, private_key, country = "mx", production = false, timeout = 90)
+    @merchant_id = merchant_id
+    @private_key = private_key
+    @production = production
+    @timeout = timeout
+    @country = country
+  end
+
+  def create(resource)
+    klass = OpenPayResourceFactory::create(resource, @merchant_id, @private_key, @production, @timeout, @country)
+    klass.api_hook = self
+    klass
+  end
+
+  def OpenpayApi::base_url(production, country)
+    if country == "mx"
+      if production
+        API_PROD
+      else
+        API_DEV
+      end
+    elsif country == "co"
+      if production
+        API_PROD_CO
+      else
+        API_DEV_CO
+      end
+    elsif country == "pe"
+      if production
+        API_PROD_PE
+      else
+        API_DEV_PE
+      end
+    else
+      LOG.error "Country not found, only mx (México) or co (Colombia)"
+      raise OpenpayException.new "Country not found, only 'mx' (México) or 'co' (Colombia)", false
+    end
+  end
+
+  def env
+    if @production
+      :production
+    else
+      :test
+    end
+  end
+
+end