pixelpay_sdk 1.0.0.pre.beta.1

data/lib/pixelpay_sdk/base/Helpers.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+# Helpers
+module Helpers
+  # Serialize object to JSON string without empties.
+  # Args:
+  #   value (hash): hash to serialize.
+  # Returns
+  #   string: JSON string.
+  def self.object_to_json(value)
+    verify_type(TypeError, Object, value.is_a?(Object))
+
+    hash = {}
+    value.instance_variables.each { |var| hash[var.to_s.delete("@")] = value.instance_variable_get(var) }
+
+    hash.each do |attr_name, attr_value|
+      if hash[attr_name].nil? || hash[attr_name].to_s.empty? || hash[attr_value].to_s == "[]" || hash[attr_value].to_s == "{}"
+        hash.delete(attr_name)
+      end
+    end
+
+    hash.to_json
+  rescue StandardError => e
+    warn("An exception occurred: #{e.message}")
+  end
+
+  # Hash of a given value using the specified algorithm.
+  # Args:
+  #   algorithm (string): algorithm to use (e.g. "MD5", "SHA-1", "SHA-256").
+  #   value (string): string to be hashed.
+  # Returns:
+  #   hash of the value parameter using the specified algorithm.
+  def self.hash(algorithm, value)
+    case algorithm.to_s
+    when "MD5"
+      Digest::MD5.hexdigest(value.to_s)
+    when "SHA-1"
+      Digest::SHA1.hexdigest(value.to_s)
+    when "SHA-256"
+      Digest::SHA256.hexdigest(value.to_s)
+    else
+      ""
+    end
+  end
+
+  # Trim a string/null value.
+  # Args:
+  #   value (string): input value.
+  # Returns:
+  #   string: trimmed value or empty string.
+  def self.trim_value(value)
+    !value.to_s.empty? ? value.to_s.strip : ""
+  end
+
+  # Clean whitespaces from string.
+  # Args:
+  #   value (string): input value.
+  # Returns:
+  #   string: trimmed value or empty string.
+  def self.clean_string(value)
+    !value.to_s.empty? ? value.to_s.sub(" ", "") : ""
+  end
+
+  # Parse or nullify amount data.
+  # Args:
+  #   amount (float): input amount.
+  # Returns:
+  #   string: parsed amount or empty string.
+  def self.parse_amount(amount)
+    amount.to_s.to_f.positive? ? format("%0.2f", amount.to_s.to_f) : ""
+  end
+
+  # Verify type of data.
+  # Args:
+  #   error_type: error type to raise.
+  #   expected: data type expected.
+  #   flag: condition.
+  # Returns:
+  #   throw an error if the condition is met
+  def self.verify_type(error_type, expected, flag)
+    case error_type.to_s
+    when "TypeError"
+      raise TypeError, "This function only accepts parameters of type #{expected}." unless flag
+    when "InvalidCredentialsException"
+      raise InvalidCredentialsException, "This function only accepts parameters of type #{expected}." unless flag
+    when "InvalidTransactionTypeException"
+      raise InvalidTransactionTypeException, "This function only accepts parameters of type #{expected}." unless flag
+    end
+  end
+end

data/lib/pixelpay_sdk/base/RequestBehaviour.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "i18n"
+require_relative "./Helpers"
+require_relative "../version"
+
+# RequestBehaviour defines the structure for the request behaviour.
+class RequestBehaviour
+  attr_accessor :env, :lang, :from, :sdk_version
+
+  # Initialize request
+  def initialize
+    # Environment identifier (live|test|sandbox)
+    @env = nil
+    # Transaction response messages language
+    @lang = I18n.locale.to_s
+    # SDK identifier type
+    @from = "sdk-ruby"
+    # SDK version
+    @sdk_version = PixelpaySdk::VERSION
+
+    @lang = "es" if @lang != "es" && @lang != "en"
+  end
+
+  # Serialize object to JSON string.
+  # Returns:
+  #   string: JSON string.
+  def object_to_json
+    Helpers.object_to_json(self)
+  end
+end

data/lib/pixelpay_sdk/base/Response.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "../base/Helpers"
+
+# Response provides a specific structure for a base response coming from a transaction.
+class Response
+  attr_accessor :status, :action, :exception, :success, :message, :data, :errors
+
+  # Initialize base
+  def initialize
+    # HTTP response status code
+    @status = nil
+
+    # Response 'action to' format
+    @action = nil
+
+    # Exception response details
+    @exception = nil
+
+    # Response status success
+    @success = nil
+
+    # Response friendly message
+    @message = nil
+
+    # Response data payload
+    @data = nil
+
+    # Response input validation fields errors
+    @errors = nil
+  end
+
+  # Define HTTP status code response.
+  # Args:
+  #   status(int): status code.
+  # Returns:
+  #   Response: self.
+  def set_status(status)
+    @status = status.to_s.to_i
+    self
+  end
+
+  # Get HTTP status code.
+  # Returns:
+  #   int: status code.
+  def get_status
+    status
+  end
+
+  # Verify input has error.
+  # Args:
+  #   key (string): input key to check.
+  # Returns:
+  #   boolean: input on key has errors or not.
+  def input_has_error(key)
+    return false if @errors.nil?
+
+    @errors.key?(key.to_s)
+  end
+
+  # Get data payload by key.
+  # Args:
+  #   key (string): input key to check.
+  # Returns:
+  #   Any: data or nil.
+  def get_data(key)
+    return nil if @data.nil? && @data.key?(key.to_s)
+
+    @data[key.to_s]
+  end
+
+  # Serialize object to JSON string.
+  # Returns:
+  #   string: JSON string.
+  # def object_to_json
+  #   Helpers.object_to_json(self)
+  # end
+end

data/lib/pixelpay_sdk/base/ServiceBehaviour.rb

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+require_relative "../base/Helpers"
+require_relative "../exceptions/InvalidCredentialsException"
+require_relative "../responses/ErrorResponse"
+require_relative "../responses/FailureResponse"
+require_relative "../responses/InputErrorResponse"
+require_relative "../responses/NetworkFailureResponse"
+require_relative "../responses/NoAccessResponse"
+require_relative "../responses/NotFoundResponse"
+require_relative "../responses/PayloadResponse"
+require_relative "../responses/PaymentDeclinedResponse"
+require_relative "../responses/PreconditionalResponse"
+require_relative "../responses/SuccessResponse"
+require_relative "../responses/TimeoutResponse"
+
+# ServiceBehaviour defines the structure for the service behaviour.
+class ServiceBehaviour
+  attr_accessor :settings
+
+  # Initialize service.
+  def initialize(settings)
+    Helpers.verify_type(TypeError, Settings, settings.instance_of?(Settings))
+
+    @settings = settings
+  rescue StandardError => e
+    warn("An exception occurred: #{e.message}")
+  end
+
+  # Mapping and cast HTTP response.
+  # Args:
+  #   response: Response object from request.
+  # Returns:
+  #   Response: parsed Reponse.
+  def parse_response(response)
+    status = response.code.to_i
+
+    bag = case status
+          when 200
+            SuccessResponse.new
+          when 202
+            PayloadResponse.new
+          when 400
+            ErrorResponse.new
+          when 401, 403
+            NoAccessResponse.new
+          when 402
+            PaymentDeclinedResponse.new
+          when 404, 405, 406
+            NotFoundResponse.new
+          when 408
+            TimeoutResponse.new
+          when 412, 418
+            PreconditionalResponse.new
+          when 422
+            InputErrorResponse.new
+          when 500
+            FailureResponse.new
+          else
+            NetworkFailureResponse.new if status > 500
+          end
+
+    data = JSON.parse(response.body)
+
+    bag.set_status(status)
+    bag.success = data.key?("success") ? data["success"] : false
+    bag.message = data.key?("message") ? data["message"] : nil
+    bag.data = data.key?("data") ? data["data"] : nil
+    bag.errors = data.key?("errors") ? data["errors"] : nil
+
+    bag
+  end
+
+  # Process the exception to Response object.
+  # Args:
+  #   exception (InvalidCredentialsException): thrown exception.
+  # Returns:
+  #   Response: processed response.
+  def exception_response(exception)
+    return exception if exception.instance_of?(InvalidCredentialsException)
+
+    response = FailureResponse.new
+    response.success = false
+    response.message = exception.to_s
+
+    response
+  end
+
+  # Build HTTP request to API.
+  # Args:
+  #   uri (string): request url.
+  #   method (string): HTTP method.
+  #   transaction (RequestBehaviour): body object.
+  # Raises:
+  #   InvalidCredentialsException: raised if no credentials found.
+  # Returns:
+  #   req: prepared request.
+  def build_request(uri, method, transaction)
+    Helpers.verify_type(TypeError, RequestBehaviour, transaction.is_a?(RequestBehaviour))
+
+    if settings.auth_key.nil? || settings.auth_hash.nil?
+      raise InvalidCredentialsException, "The merchant credentials are not definied (key/hash)."
+    end
+
+    transaction.env = settings.environment if settings.environment
+
+    transaction.lang = settings.lang if settings.lang
+
+    body = transaction.object_to_json
+
+    request = case method.to_s.upcase
+              when "GET"
+                Net::HTTP::Get.new(uri)
+              when "POST"
+                Net::HTTP::Post.new(uri)
+              when "DELETE"
+                Net::HTTP::Delete.new(uri)
+              when "PUT"
+                Net::HTTP::Put.new(uri)
+              end
+
+    request.body = body
+
+    request["Accept"] = "application/json"
+    request["Content-Type"] = "application/json"
+    request["-Agent"] = "PixelPay HTTP/3 SDK Ruby"
+    request["x-auth-key"] = @settings.auth_key
+    request["x-auth-hash"] = @settings.auth_hash
+
+    request["x-auth-user"] = @settings.auth_user if @settings.auth_user != ""
+
+    request
+  rescue StandardError => e
+    exception_response(e)
+  end
+
+  # Get API route.
+  # Args:
+  #   route(string): input route.
+  # Returns:
+  #   (uri): Api route.
+  def get_route(route)
+    URI.parse("#{@settings.endpoint}/#{route}")
+  end
+
+  # API POST request.
+  # Args:
+  #   url (string): input url.
+  #   body (RequestBehaviour): input body object.
+  # Returns:
+  #   response: parsed response.
+  def post(url, body)
+    unless body.is_a?(RequestBehaviour)
+      raise TypeError, "This function only accepts parameters of type RequestBehaviour."
+    end
+
+    uri = get_route(url)
+    req = build_request(uri, "POST", body)
+
+    raise InvalidCredentialsException, req.message if req.instance_of?(InvalidCredentialsException)
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(req)
+    end
+
+    parse_response(response)
+  rescue StandardError => e
+    exception_response(e)
+  end
+
+  # API PUT request.
+  # Args:
+  #   url (string): input url.
+  #   body (RequestBehaviour): input body object.
+  # Returns:
+  #   response: parsed response.
+  def put(url, body)
+    Helpers.verify_type(TypeError, RequestBehaviour, body.is_a?(RequestBehaviour))
+
+    uri = get_route(url)
+    req = build_request(uri, "PUT", body)
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(req)
+    end
+
+    parse_response(response)
+  rescue StandardError => e
+    exception_response(e)
+  end
+
+  # API DELETE request.
+  # Args:
+  #   url (string): input url.
+  #   body (RequestBehaviour): input body object.
+  # Returns:
+  #   response: parsed response.
+  def delete(url, body)
+    Helpers.verify_type(TypeError, RequestBehaviour, body.is_a?(RequestBehaviour))
+
+    uri = get_route(url)
+    req = build_request(uri, "DELETE", body)
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(req)
+    end
+
+    parse_response(response)
+  rescue StandardError => e
+    exception_response(e)
+  end
+
+  # API GET request.
+  # Args:
+  #   url (string): input url.
+  #   body (RequestBehaviour): input body object.
+  # Returns:
+  #   response: parsed response.
+  def get(url, body)
+    Helpers.verify_type(TypeError, RequestBehaviour, body.is_a?(RequestBehaviour))
+
+    uri = get_route(url)
+    req = build_request(uri, "GET", body)
+
+    response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) do |http|
+      http.request(req)
+    end
+
+    parse_response(response)
+  rescue StandardError => e
+    exception_response(e)
+  end
+end

data/lib/pixelpay_sdk/entities/CardResult.rb

@@ -0,0 +1,79 @@
+require_relative "../base/Response"
+require_relative "../responses/SuccessResponse"
+
+# CardResult provides a specific structure for a response coming from a transaction with a tokenized card.
+class CardResult
+  attr_accessor :status, :mask, :network, :type, :bin, :last, :hash, :address, :country, :state, :city,
+                :zip, :email, :phone
+
+  # Initialize entity.
+  def initialize
+    # Card status
+    @status = nil
+
+    # Card number masked
+    @mask = nil
+
+    # Card network brand
+    @network = nil
+
+    # Card type (debit/credit)
+    @type = nil
+
+    # Car bin number
+    @bin = nil
+
+    # Card last 4 numbers
+    @last = nil
+
+    # Card unique hash number
+    @hash = nil
+
+    # Billing address
+    @address = nil
+
+    # Billing country
+    @country = nil
+
+    # Billing state
+    @state = nil
+
+    # Billing city
+    @city = nil
+
+    # Billing postal code
+    @zip = nil
+
+    # Billing customer email
+    @email = nil
+
+    # Billing phone
+    @phone = nil
+  end
+
+  # Validate if response type is valid for parse.
+  # Args:
+  #   response (Reponse): Response to validate.
+  # Returns:
+  #   bool: is valid response.
+  def validate_response(response)
+    response.instance_of?(SuccessResponse)
+  end
+
+  # Convert success response to card entity.
+  # Args:
+  #   response (Reponse): Input response.
+  # Returns:
+  #   CardResult: mapped result.
+  def from_response(response)
+    entity = CardResult.new
+
+    entity.instance_variables.each do |var_name|
+      if response.data.key?(var_name.to_s.delete("@"))
+        entity.instance_variable_set(var_name, response.data[var_name.to_s.delete("@")])
+      end
+    end
+
+    entity
+  end
+end

data/lib/pixelpay_sdk/entities/TransactionResult.rb

@@ -0,0 +1,104 @@
+require "json"
+
+require_relative "../base/Response"
+require_relative "../responses/InputErrorResponse"
+require_relative "../responses/PaymentDeclinedResponse"
+require_relative "../responses/SuccessResponse"
+require_relative "../responses/TimeoutResponse"
+
+# TransactionResult provides a specific structure for a response coming from a transaction.
+class TransactionResult
+  attr_accessor :transaction_type, :transaction_approved_amount, :transaction_amount, :transaction_auth,
+                :transaction_terminal, :transaction_merchant, :response_cvn, :response_avs, :response_cavv,
+                :transaction_id, :transaction_reference, :transaction_time, :transaction_date, :response_approved,
+                :response_incomplete, :response_code, :response_time, :response_reason, :payment_uuid, :payment_hash
+
+  # Initialize enitity.
+  def initialize
+    # Transaction response type
+    @transaction_type = nil
+
+    # Approved amount on capture/sale
+    @transaction_approved_amount = nil
+
+    # Initial or registered transaction amount
+    @transaction_amount = nil
+
+    # Transaction AUTH reference code
+    @transaction_auth = nil
+
+    # Transacction network terminal ID
+    @transaction_terminal = nil
+
+    # Transaction network merchant ID
+    @transaction_merchant = nil
+
+    # CVV2 result response code
+    @response_cvn = nil
+
+    # Address verification code response
+    @response_avs = nil
+
+    # CAVV network evaluation result code
+    @response_cavv = nil
+
+    # Transaction identifier
+    @transaction_id = nil
+
+    # Transaction STAN, proccesor transacction identifier or transaction reference
+    @transaction_reference = nil
+
+    # Transaction result time
+    @transaction_time = nil
+
+    # Transaction result date
+    @transaction_date = nil
+
+    # Response is financial approved
+    @response_approved = nil
+
+    # Response fatal not completed or excecution interrupted
+    @response_incomplete = nil
+
+    # Proccesor response code
+    @response_code = nil
+
+    # Network response time
+    @response_time = nil
+
+    # Proccesor response message
+    @response_reason = nil
+
+    # Payment unique identifier
+    @payment_uuid = nil
+
+    # Payment integrity validation hash
+    @payment_hash = nil
+  end
+
+  # Validate if response type is valid for parse.
+  # Args:
+  #   response (Reponse): Response to validate.
+  # Returns:
+  #   bool: is valid response.
+  def validate_response(response)
+    response.instance_of?(SuccessResponse) || response.instance_of?(PaymentDeclinedResponse) || response.instance_of?(InputErrorResponse) || response.instance_of?(TimeoutResponse)
+  end
+
+  # Convert success response to transaction entity.
+  # Args:
+  #   response (Reponse): Input response.
+  # Returns:
+  #   TransactionResult: mapped result.
+  def from_response(response)
+    entity = TransactionResult.new
+
+    entity.instance_variables.each do |var_name|
+      if response.data.key?(var_name.to_s.delete("@"))
+        entity.instance_variable_set(var_name, response.data[var_name.to_s.delete("@")])
+      end
+    end
+
+    entity
+  end
+end

data/lib/pixelpay_sdk/exceptions/InvalidCredentialsException.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# InvalidCredentialsException provides the possibility to create an exception of
+# it's type
+class InvalidCredentialsException < StandardError
+end

data/lib/pixelpay_sdk/exceptions/InvalidTransactionTypeException.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# InvalidTransactionTypeException provides the possibility to create an exception of
+# it's type
+class InvalidTransactionTypeException < StandardError
+end

data/lib/pixelpay_sdk/models/Billing.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Billing represents the billing information for a request.
+class Billing
+  attr_accessor :address, :country, :state, :city, :zip, :phone
+
+  # Initialize model
+  def initialize
+    # Customer billing address
+    @address = nil
+
+    # Customer billing country alpha-2 code (ISO 3166-1)
+    @country = nil
+
+    # Customer billing state alpha code (ISO 3166-2)
+    @state = nil
+
+    # Customer billing city
+    @city = nil
+
+    # Customer billing postal code
+    @zip = nil
+
+    # Customer billing phone
+    @phone = nil
+  end
+end

data/lib/pixelpay_sdk/models/Card.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../base/Helpers"
+
+# Card represents the card information for a request.
+class Card
+  attr_accessor :number, :cvv2, :expire_month, :expire_year, :cardholder
+
+  # Initialize model
+  def initialize
+    # Card number or PAN
+    @number = nil
+
+    # Card security code
+    @cvv2 = nil
+
+    # Card expire month date (MM)
+    @expire_month = 00
+
+    # Card expire year date (YYYY)
+    @expire_year = 0000
+
+    # Cardholder name
+    @cardholder = nil
+  end
+
+  # Get expire ISO format (YYMM).
+  # Returns:
+  #   string: formatted expire.
+  def get_expire_format
+    year = @expire_year != 0 ? @expire_year.to_s : "    "
+    month = format("%02d", @expire_month)
+
+    Helpers.trim_value(year.slice(-2..) + month)
+  end
+end