genesis_ruby 0.1.0

data/lib/genesis_ruby/api/requests/wpf/create.rb

@@ -0,0 +1,142 @@
+require 'genesis_ruby/utils/transactions/wpf_types'
+require 'genesis_ruby/api/constants/transactions/parameters/sca_exemptions'
+
+module GenesisRuby
+  module Api
+    module Requests
+      module Wpf
+        # Web-Payment Form Request
+        class Create < Request
+
+          include Mixins::Requests::RestrictedSetter
+          include Mixins::Requests::Financial::PaymentAttributes
+          include Mixins::Requests::AddressInfoAttributes
+          include Mixins::Requests::Financial::AsyncAttributes
+          include Mixins::Requests::Financial::NotificationAttributes
+          include Mixins::Requests::Financial::PendingPaymentAttributes
+          include Mixins::Requests::Financial::Threeds::Version2::WpfAttributes
+          include Mixins::Requests::Financial::Cards::Recurring::RecurringTypeAttributes
+          include Mixins::Requests::Financial::Cards::Recurring::RecurringCategoryAttributes
+          include Mixins::Requests::Financial::DynamicDescriptorAttributes
+          include Mixins::Requests::Financial::RiskAttributes
+          include Mixins::Requests::Financial::Business::BusinessAttributes
+
+          attr_reader   :locale, :sca_preference, :sca_exemption
+          attr_accessor :transaction_id, :usage, :description, :consumer_id, :return_cancel_url, :remember_card,
+                        :lifetime, :web_payment_form_id
+
+          # The transaction types that the merchant is willing to accept payments for
+          def add_transaction_type(name, custom_attributes = {})
+            unless GenesisRuby::Utils::Transactions::WpfTypes.valid? name
+              raise ParameterError, 'Invalid Transaction Type given.'
+            end
+
+            self.transaction_types = { transaction_type: {
+              '@attributes': { name: name.to_s.downcase }, **custom_attributes
+            } }
+          end
+
+          # Define ISO 639-1 language code to the URL
+          def locale=(value)
+            init_api_wpf_configuration(language: value.to_s.downcase)
+          end
+
+          # Signifies whether to perform SCA on the transaction. At least one 3DS transaction type has to be submitted.
+          def sca_preference=(value)
+            allowed_options attribute:      __method__,
+                            allowed:        [true, false],
+                            value:          value,
+                            allow_empty:    true,
+                            error_message: 'Accepts only boolean values'
+          end
+
+          # Exemption for the Strong Customer Authentication. The allowed options are low_value, low_risk
+          def sca_exemption=(value)
+            sca_exemptions = GenesisRuby::Api::Constants::Transactions::Parameters::ScaExemptions
+
+            allowed_options attribute:   __method__,
+                            allowed:     [sca_exemptions::LOW_VALUE, sca_exemptions::LOW_RISK],
+                            value:       value.to_s.empty? ? nil : value.to_s.downcase,
+                            allow_empty: true
+          end
+
+          # Specifies the recurring type of transaction
+          def recurring_type=(value)
+            allowed_values = [
+              GenesisRuby::Api::Constants::Transactions::Parameters::Recurring::Types::INITIAL,
+              GenesisRuby::Api::Constants::Transactions::Parameters::Recurring::Types::MANAGED
+            ]
+
+            allowed_options attribute: __method__, allowed: allowed_values, value: value, allow_empty: true
+          end
+
+          protected
+
+          # Load base configuration
+          def init_configuration
+            init_xml_configuration
+            init_api_wpf_configuration
+          end
+
+          # Perform validation over the defined parameters upon request execution
+          def check_requirements
+            unless GenesisRuby::Api::Constants::Currencies::Iso4217.valid?(currency)
+              raise ParameterError, "Invalid Currency given with value #{currency}"
+            end
+
+            super
+          end
+
+          # Define Web-Payment Form transaction request structure
+          def populate_structure # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            self.tree_structure = {
+              wpf_payment: {
+                transaction_id:            transaction_id,
+                amount:                    transform_amount(amount, currency),
+                currency:                  currency,
+                usage:                     usage,
+                description:               description,
+                consumer_id:               consumer_id,
+                customer_email:            customer_email,
+                customer_phone:            customer_phone,
+                notification_url:          notification_url,
+                return_success_url:        return_success_url,
+                return_failure_url:        return_failure_url,
+                return_cancel_url:         return_cancel_url,
+                return_pending_url:        return_pending_url,
+                billing_address:           billing_address_parameters_structure,
+                shipping_address:          shipping_address_parameters_structure,
+                transaction_types:         transaction_types,
+                business_attributes:       business_attributes_structure,
+                remember_card:             remember_card,
+                lifetime:                  lifetime,
+                sca_preference:            sca_preference,
+                sca_params:                {
+                  sca_exemption: sca_exemption
+                },
+                threeds_v2_params:         threeds_v2_wpf_attributes_structure,
+                web_payment_form_id:       web_payment_form_id,
+                recurring_type:            recurring_type,
+                recurring_category:        recurring_category,
+                dynamic_descriptor_params: dynamic_descriptor_structure,
+                risk_params:               risk_parameters_structure
+              }
+            }
+          end
+
+          private
+
+          attr_reader :transaction_types
+
+          # Add every transaction type to the transaction types structure
+          def transaction_types=(value)
+            @transaction_types ||= []
+
+            @transaction_types.push(value)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/genesis_ruby/api/response.rb

@@ -0,0 +1,91 @@
+require 'genesis_ruby/errors/response_error'
+require 'genesis_ruby/parser'
+require 'genesis_ruby/api/constants/states'
+require 'genesis_ruby/api/constants/states/state'
+require 'genesis_ruby/utils/object_formatter'
+require 'genesis_ruby/utils/formatters/response/loader'
+
+module GenesisRuby
+  module Api
+    # Response - process/format an incoming Genesis response
+    class Response
+
+      def initialize(configuration)
+        @configuration      = configuration
+        @object_formatter   = GenesisRuby::Utils::ObjectFormatter.new
+        @response_formatter = GenesisRuby::Utils::Formatters::Response::Loader.new
+      end
+
+      # Default Response Object initialization
+      def response_object
+        @response_object ||= {}
+      end
+
+      # Default Response Raw initialization
+      def response_raw
+        @response_raw ||= ''
+      end
+
+      # Parse the response from the given Network
+      def parse_response(network)
+        @network_context = network
+        @response_raw    = @network_context.response_body
+        @response_object = load_parser(@network_context).parse_document(@response_raw)
+
+        process_response_object
+      end
+
+      # Dynamic Helper Methods
+      def method_missing(symbol)
+        super unless GenesisRuby::Api::Constants::States::State.handle_respond_to_states(symbol)
+
+        handle_method_missing_states(symbol)
+      end
+
+      # Respond to missing implementation
+      def respond_to_missing?(symbol, include_private = false)
+        GenesisRuby::Api::Constants::States::State.handle_respond_to_states(symbol) || super
+      end
+
+      protected
+
+      attr_reader :network_context, :parser, :configuration, :object_formatter, :response_formatter
+
+      # Load the corresponding parser based on the Network header
+      def load_parser(network)
+        @parser = GenesisRuby::Parsers.new(GenesisRuby::Parser::JSON) if network.json?
+
+        if network.xml?
+          @parser = GenesisRuby::Parser.new(GenesisRuby::Parser::XML)
+          @parser.skip_root_node
+        end
+
+        @parser
+      end
+
+      # Add dynamic Sate handling
+      def handle_method_missing_states(symbol)
+        method = symbol.to_s.downcase
+
+        state = GenesisRuby::Api::Constants::States::State.new(response_object[:status])
+
+        return state.public_send(method) if state.respond_to?(method)
+
+        false
+      end
+
+      # Format the Response object
+      def process_response_object
+        GenesisRuby::Utils::Common.deep_compact_empty!(@response_object) if configuration.sanitize_response
+
+        if configuration.format_response
+          object_formatter.formats = @response_formatter.formats
+          @response_object = object_formatter.format_structure(@response_object)
+        end
+
+        @response_object
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/builder.rb

@@ -0,0 +1,42 @@
+require 'genesis_ruby/builders/xml'
+require 'genesis_ruby/errors/builder_error'
+
+module GenesisRuby
+  # Builder handler
+  class Builder
+
+    # Builder XML
+    XML  = 'xml'.freeze
+
+    # Builder JSON
+    JSON = 'json'.freeze
+
+    # Builder FORM
+    FORM = 'form'.freeze
+
+    # Initialize the Builder Interface based on the Request requirements
+    def initialize(request_interface)
+      case request_interface
+      when XML
+        @builder_context = GenesisRuby::Builders::Xml.new
+      else
+        raise GenesisRuby::BuilderError, 'Invalid Builder interface!'
+      end
+    end
+
+    # Get built document
+    def document
+      builder_context.output
+    end
+
+    # Parse tree-structure into Builder document
+    def parse_structure(structure)
+      builder_context.populate_nodes(structure)
+    end
+
+    private
+
+    attr_accessor :builder_context
+
+  end
+end

data/lib/genesis_ruby/builders/base.rb

@@ -0,0 +1,18 @@
+module GenesisRuby
+  module Builders
+    # Contract for every builder abstraction
+    class Base
+
+      # Get the Generated Builder Output
+      def output
+        raise NotImplementedError, 'Output must be implemented'
+      end
+
+      # Tree-structured hash representing the request structure
+      def populate_nodes(structure)
+        raise NotImplementedError, 'Populate Nodes must be implemented'
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/builders/xml.rb

@@ -0,0 +1,95 @@
+require 'genesis_ruby/builders/base'
+require 'nokogiri'
+
+module GenesisRuby
+  module Builders
+    # XML, Nokogiri Builder Implementation
+    class Xml < Base
+
+      # Initialize Nokogiri XML Builder
+      def initialize
+        @builder = Nokogiri::XML::Builder.new(encoding: 'UTF-8')
+        super
+      end
+
+      # Generated XMl Document
+      def output
+        builder.to_xml
+      end
+
+      def populate_nodes(structure)
+        root_element, data = if structure.length == 1
+                               [structure.keys.first, structure.values.first]
+                             else
+                               ['root', structure.values.first]
+                             end
+
+        builder.method_missing(root_element, fetch_attributes(data)) { |xml| generate(data) } unless data.nil? # rubocop:disable Lint/UnusedBlockArgument
+      end
+
+      private
+
+      attr_reader :builder
+
+      # Loop the Hash and build the XML Document
+      def generate(data)
+        data.each do |element_name, element_value|
+          if element_name.is_a?(Hash)
+            populate_nodes(element_name)
+          elsif element_value.is_a?(Array) || element_value.is_a?(Hash)
+            add_node element_name, element_value, fetch_attributes(element_value)
+          else
+            add_element element_name, element_value
+          end
+        end
+      end
+
+      # Add node
+      # Every node can be
+      #   - Hash
+      #   - Array of hashes
+      def add_node(node_name, node_data, attributes = {})
+        builder.method_missing(node_name, attributes) do
+          node_data.each do |element_name, element_value|
+            fetch_node element_name, element_value
+          end
+        end
+      end
+
+      # Check current node and execute build step
+      def fetch_node(element_name, element_value)
+        if element_name.is_a?(Hash)
+          populate_nodes element_name
+        elsif element_value.is_a?(Hash)
+          add_node element_name, element_value, fetch_attributes(element_value)
+        elsif element_value.is_a?(Array)
+          build_array element_name, element_value
+        else
+          add_element element_name, element_value
+        end
+      end
+
+      # Add a single element/tag to the XML Document
+      def add_element(name, value, attributes = {})
+        builder.method_missing(name, attributes, value)
+      end
+
+      # Fetch the attributes stored under the @attributes key
+      def fetch_attributes(element_value)
+        attributes = {}
+        attributes = element_value.fetch('@attributes'.to_sym, {}) if element_value.is_a?(Hash)
+        element_value.delete('@attributes'.to_sym)
+
+        attributes
+      end
+
+      # Build XMl Document part from Array
+      def build_array(element_name, element_value)
+        element_value.each do |tag_value|
+          add_element element_name, tag_value
+        end
+      end
+
+    end
+  end
+end

data/lib/genesis_ruby/configuration.rb

@@ -0,0 +1,177 @@
+require 'genesis_ruby/api/constants/environments'
+require 'genesis_ruby/api/constants/endpoints'
+require 'genesis_ruby/errors/invalid_argument_error'
+
+module GenesisRuby
+  # Class Configuration
+  #
+  # Store/Retrieve configuration key/values across the Genesis library
+  class Configuration # rubocop:disable Metrics/ClassLength
+
+    # Default Network Timeout
+    DEFAULT_TIMEOUT = 60
+
+    # Supported Network Connections
+    NETWORK_INTERFACE_NET_HTTP = 'net-http'.freeze
+
+    # Default Format Response
+    DEFAULT_FORMAT_RESPONSE = true
+
+    # Default sanitize Response
+    DEFAULT_SANITIZE_RESPONSE = true
+
+    # Genesis basic configuration - credentials, endpoint, environment, token
+    attr_writer :username, :password, :token, :interface, :format_response, :sanitize_response
+
+    # Configuration constructor
+    def initialize
+      @environment = GenesisRuby::Api::Constants::Environments::STAGING
+      @sub_domains = available_sub_domains
+    end
+
+    # Genesis Username
+    def username
+      @username ||= ''
+    end
+
+    # Genesis Password
+    def password
+      @password ||= ''
+    end
+
+    # Genesis Token required from some of the requests
+    def token
+      @token ||= ''
+    end
+
+    # Genesis Environment
+    def environment
+      @environment ||= ''
+    end
+
+    # Genesis endpoint
+    def endpoint
+      @endpoint ||= ''
+    end
+
+    # Genesis Request Timeout
+    def timeout
+      @timeout ||= DEFAULT_TIMEOUT
+    end
+
+    # Genesis Request Timeout
+    def timeout=(value)
+      timeout = value.to_i
+
+      @timeout = timeout <= 0 ? DEFAULT_TIMEOUT : timeout
+    end
+
+    # Network Interface used for executing requests
+    def interface
+      @interface ||= NETWORK_INTERFACE_NET_HTTP
+    end
+
+    # Get a sub-domain host based on the environment
+    def sub_domain(sub)
+      return @sub_domains[sub.to_sym][@environment] if @sub_domains.key?(sub.to_sym)
+
+      nil
+    end
+
+    # Environment setter
+    def environment=(environment)
+      environment_argument = environment.downcase
+      parsed_env           = nil
+
+      environment_aliases.each do |available_env, env_alias|
+        parsed_env = available_env if env_alias.include? environment_argument
+      end
+
+      raise InvalidArgumentError, 'Invalid Environment' if parsed_env.nil?
+
+      @environment = parsed_env
+    end
+
+    # Endpoint setter
+    def endpoint=(endpoint)
+      endpoint_argument = endpoint.downcase
+      parsed_endpoint   = nil
+
+      endpoint_aliases.each do |available_end, endpoint_alias|
+        parsed_endpoint = available_end if endpoint_alias.include? endpoint_argument
+      end
+
+      raise InvalidArgumentError, 'Invalid Endpoint' if parsed_endpoint.nil?
+
+      @endpoint = parsed_endpoint
+    end
+
+    # Indicates if the parsed Response from Genesis should be formatted
+    def format_response
+      return @format_response = DEFAULT_FORMAT_RESPONSE if @format_response.nil?
+
+      @format_response
+    end
+
+    # Indicates if the parsed Response from Genesis should be sanitized
+    def sanitize_response
+      return @sanitize_response = DEFAULT_SANITIZE_RESPONSE if @sanitize_response.nil?
+
+      @sanitize_response
+    end
+
+    private
+
+    # Various definitions for environment
+    # rubocop:disable Metrics/MethodLength
+    def environment_aliases
+      {
+        GenesisRuby::Api::Constants::Environments::STAGING    => [
+          'test',
+          'testing',
+          'staging',
+          GenesisRuby::Api::Constants::Environments::STAGING
+        ],
+        GenesisRuby::Api::Constants::Environments::PRODUCTION => [
+          'live',
+          'prod',
+          'production',
+          GenesisRuby::Api::Constants::Environments::PRODUCTION
+        ]
+      }
+    end
+
+    # Various definitions for Genesis endpoint
+    def endpoint_aliases
+      {
+        GenesisRuby::Api::Constants::Endpoints::EMERCHANTPAY   => [
+          'emp',
+          'emerchantpay',
+          GenesisRuby::Api::Constants::Endpoints::EMERCHANTPAY
+        ],
+        GenesisRuby::Api::Constants::Endpoints::ECOMPROCESSING => [
+          'ecp',
+          'ecomprocessing',
+          'e-comprocessing',
+          GenesisRuby::Api::Constants::Endpoints::ECOMPROCESSING
+        ]
+      }
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Available Genesis subdomains
+    def available_sub_domains
+      {
+        gateway: {
+          GenesisRuby::Api::Constants::Environments::PRODUCTION => 'gate.',
+          GenesisRuby::Api::Constants::Environments::STAGING    => 'staging.gate.'
+        },
+        wpf:     {
+          GenesisRuby::Api::Constants::Environments::PRODUCTION => 'wpf.',
+          GenesisRuby::Api::Constants::Environments::STAGING    => 'staging.wpf.'
+        }
+      }
+    end
+
+  end
+end

data/lib/genesis_ruby/connection.rb

@@ -0,0 +1,20 @@
+require 'genesis_ruby/network/net_http'
+require 'genesis_ruby/errors/network_error'
+require 'genesis_ruby/configuration'
+
+module GenesisRuby
+  # Prepare the Network connection used for sending the current request
+  class Connection
+
+    # Initialize Network Factory based on the Configuration
+    def self.for(configuration)
+      case configuration.interface
+      when GenesisRuby::Configuration::NETWORK_INTERFACE_NET_HTTP
+        GenesisRuby::Network::NetHttp.new(configuration)
+      else
+        raise GenesisRuby::NetworkError, 'Invalid network interface given.'
+      end
+    end
+
+  end
+end

data/lib/genesis_ruby/dependencies.rb

@@ -0,0 +1,19 @@
+# =================================
+# Transaction Request Requirements
+# =================================
+require 'genesis_ruby/api/request'
+require 'genesis_ruby/api/mixins/constants/common'
+require 'genesis_ruby/api/mixins/requests/restricted_setter'
+
+# =================================
+# Transaction Requests Definitions
+# =================================
+
+# Load API Attributes
+Dir["#{File.dirname(__FILE__)}/api/mixins/**/*_attributes.rb"].sort.each { |file| require file }
+
+# Load Financial and Non Financial API Requests
+Dir["#{File.dirname(__FILE__)}/api/requests/*financial/**/*.rb"].sort.each { |file| require file }
+
+# Load WPF API Requests
+Dir["#{File.dirname(__FILE__)}/api/requests/wpf/**/*.rb"].sort.each { |file| require file }

data/lib/genesis_ruby/errors/builder_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class BuilderError < Error
+
+    def custom_message
+      return 'Unknown error during building the request!' unless @message
+
+      @message
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/endpoint_not_set_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class EndpointNotSetError < Error
+
+    def custom_message
+      return 'No working endpoint has been set, please choose between emp/ecp endpoint!' unless @message
+
+      @message
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/error.rb

@@ -0,0 +1,18 @@
+module GenesisRuby
+  # Base Genesis Ruby Error
+  class Error < StandardError
+
+    # Predefined error message
+    def custom_message
+      @message
+    end
+
+    # Customer errors constructor
+    def initialize(msg = nil)
+      @message = msg
+
+      super(custom_message)
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/invalid_argument_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class InvalidArgumentError < Error
+
+    def custom_message
+      return 'The supplied argument is invalid for this method!' unless @message
+
+      @message
+    end
+
+  end
+end

data/lib/genesis_ruby/errors/network_error.rb

@@ -0,0 +1,14 @@
+require 'genesis_ruby/errors/error'
+
+module GenesisRuby
+  # Invalid Argument Custom Error
+  class NetworkError < Error
+
+    def custom_message
+      return 'Unknown error during network request!' unless @message
+
+      @message
+    end
+
+  end
+end