lpt-ruby 0.4.1

data/lib/lpt/api_operations/create.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lpt
+  module ApiOperations
+    module Create
+      def create(request, path: nil)
+        client = Lpt.client
+        resource = new
+        path ||= resource.resources_path
+        response = client.post(path, request.to_json)
+        handle_response resource, response
+        resource
+      end
+
+      protected
+
+      def post_request_failed?(response)
+        response.blank? || response.status > 201
+      end
+
+      def handle_response(resource, response)
+        return false if post_request_failed? response
+
+        resource.load_from_response(response.body)
+      end
+    end
+  end
+end

data/lib/lpt/api_operations/retrieve.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lpt
+  module ApiOperations
+    module Retrieve
+      def retrieve(id, _opts = {})
+        client = Lpt.client
+        resource = new(id: id)
+        response = client.get(resource.resource_path)
+        new(response.body)
+      end
+    end
+  end
+end

data/lib/lpt/api_operations/update.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lpt
+  module ApiOperations
+    module Update
+      def update(id, request)
+        client = Lpt.client
+        resource = new(id: id)
+        response = client.put(resource.resource_path, request.to_json)
+        resource.load_from_response(response.body)
+        resource
+      end
+    end
+  end
+end

data/lib/lpt/authentication.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Authentication
+    attr_accessor :api_username, :api_password, :merchant, :merchant_account,
+                  :entity
+
+    def client
+      assert_client_is_configured!
+      env = Lpt::Environment.factory(environment: environment)
+      Lpt::LptClient.factory(environment: env)
+    end
+
+    protected
+
+    def assert_client_is_configured!
+      assert_username!
+      assert_password!
+      assert_merchant!
+      assert_entity!
+    end
+
+    def assert_username!
+      msg = "Invalid API Username: #{api_username}"
+      raise ArgumentError, msg if api_username.blank?
+    end
+
+    def assert_password!
+      msg = "Invalid API Password"
+      raise ArgumentError, msg if api_password.blank?
+    end
+
+    def assert_merchant!
+      msg = "Invalid Merchant: #{merchant}"
+      raise ArgumentError, msg unless merchant.start_with? PREFIX_MERCHANT
+    end
+
+    def assert_entity!
+      msg = "Invalid Entity: #{entity}"
+      raise ArgumentError, msg unless entity.start_with? PREFIX_ENTITY
+    end
+  end
+end

data/lib/lpt/environment.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Lpt
+  class Environment
+    PRODUCTION = 90
+    DEMO = 80
+    STAGING = 60
+    SANDBOX = 50
+    NEXT = 40
+    IVV = 30
+    TEST = 20
+    DEV = 10
+
+    ENVIRONMENTS = {
+      "production" => PRODUCTION,
+      "demo" => DEMO,
+      "staging" => STAGING,
+      "sandbox" => SANDBOX,
+      "next" => NEXT,
+      "ivv" => IVV,
+      "test" => TEST,
+      "dev" => DEV
+    }.freeze
+
+    BASE_DOMAINS = {
+      PRODUCTION => "lacorepayments.com",
+      DEMO => "dmo.lacorepayments.com",
+      STAGING => "lacorepayments.com",
+      SANDBOX => "sbx.lacorepayments.com",
+      NEXT => "nxt.lacorepayments.com",
+      IVV => "ivv.lacorepayments.com",
+      TEST => "test.lpt.local",
+      DEV => "lpt.local"
+    }.freeze
+
+    attr_accessor :api_base, :cx_base, :cx_api_base, :base_domain
+
+    def initialize(api_base: "", cx_base: "", cx_api_base: "", base_domain: "")
+      @api_base = api_base
+      @cx_base = cx_base
+      @cx_api_base = cx_api_base
+      @base_domain = base_domain
+    end
+
+    def ==(other)
+      api_base == other.api_base && base_domain == other.base_domain &&
+        cx_base == other.cx_base && cx_api_base == other.cx_api_base
+    end
+
+    def api_base_url(with_protocol: true)
+      base_url(api_base, with_protocol: with_protocol)
+    end
+
+    def cx_base_url
+      base_url(cx_base)
+    end
+
+    def cx_api_base_url
+      base_url(cx_api_base)
+    end
+
+    class << self
+      def staging
+        factory(environment: STAGING)
+      end
+
+      def production
+        factory(environment: PRODUCTION)
+      end
+
+      def factory(environment: DEV)
+        args = Lpt.base_addresses(environment: environment)
+        args[:base_domain] = BASE_DOMAINS[environment]
+        new(**args)
+      end
+    end
+
+    protected
+
+    def base_url(cname, with_protocol: true)
+      protocol = "https://" if with_protocol
+      "#{protocol}#{cname}.#{base_domain}"
+    end
+  end
+end

data/lib/lpt/lpt_client.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Lpt
+  class LptClient < ::SimpleDelegator
+    def initialize(api_client:)
+      super(api_client)
+    end
+
+    class << self
+      def factory(environment:)
+        options = { request: request_options }
+        client = initialize_client(api_base_url: environment.api_base_url,
+                                   options: options)
+        new(api_client: client)
+      end
+
+      protected
+
+      def request_options
+        { open_timeout: Lpt.open_timeout, read_timeout: Lpt.read_timeout,
+          write_timeout: Lpt.write_timeout }
+      end
+
+      def logging_options
+        { headers: true, bodies: true, log_level: Lpt.log_level }
+      end
+
+      def configure_request(config)
+        config.request :authorization, :basic, Lpt.api_username, Lpt.api_password
+        config.request :json
+      end
+
+      def configure_response(config)
+        config.response :json
+        config.response :raise_error
+      end
+
+      def configure_logging(config)
+        return if Lpt.log_level.negative?
+
+        config.response :logger, nil, **logging_options do |fmt|
+          fmt.filter(/^(Authorization: ).*$/i, '\1[REDACTED]')
+        end
+      end
+
+      def assign_adapter(config)
+        config.adapter :net_http
+      end
+
+      def initialize_client(api_base_url:, options:)
+        Faraday.new(url: api_base_url, **options) do |config|
+          configure_request config
+          configure_response config
+          configure_logging config
+          assign_adapter config
+        end
+      end
+    end
+  end
+end

data/lib/lpt/requests/api_request.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class ApiRequest
+      attr_accessor :entity
+
+      def initialize(attributes = {})
+        attributes.each_pair do |k, v|
+          setter = :"#{k}="
+          public_send(setter, v)
+        end
+        assign_default_entity
+      end
+
+      protected
+
+      def assign_default_entity
+        self.entity ||= Lpt.entity
+      end
+    end
+  end
+end

data/lib/lpt/requests/empty_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class EmptyRequest
+      def to_json(*)
+        nil
+      end
+    end
+  end
+end

data/lib/lpt/requests/instrument_request.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class InstrumentRequest < ApiRequest
+      attr_accessor :profile, :instrument_id, :reference_id, :category, :type,
+                    :name, :contact, :address, :account, :expiration,
+                    :security_code, :authentication, :token, :external_token,
+                    :network_token
+    end
+  end
+end

data/lib/lpt/requests/instrument_token_request.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class InstrumentTokenRequest < ApiRequest
+      attr_accessor :profile, :instrument_id, :reference_id, :name, :contact,
+                    :address, :expiration, :account, :security_code, :token
+    end
+  end
+end

data/lib/lpt/requests/payment_capture_request.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class PaymentCaptureRequest < ApiRequest
+      attr_accessor :invoice, :order, :payment_id, :reference_id, :amount,
+                    :session
+    end
+  end
+end

data/lib/lpt/requests/payment_refund_request.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class PaymentRefundRequest < ApiRequest
+      attr_accessor :reference_id, :amount, :session
+    end
+  end
+end

data/lib/lpt/requests/payment_request.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class PaymentRequest < ApiRequest
+      INITIATION_CUSTOMER = "CUSTOMER"
+      INITIATION_MERCHANT = "MERCHANT"
+
+      WORKFLOW_SALE = "SALE"
+      WORKFLOW_AUTH_CAPTURE = "AUTH_CAPTURE"
+
+      attr_accessor :merchant, :merchant_account, :instrument, :invoice, :order,
+                    :payment_id, :reference_id, :amount, :currency, :session,
+                    :initiation, :url, :recurring, :workflow
+
+      def initialize(*)
+        super
+        assign_merchant
+      end
+
+      def as_auth_capture
+        self.workflow = WORKFLOW_AUTH_CAPTURE
+        self
+      end
+
+      def as_sale
+        self.workflow = WORKFLOW_SALE
+        self
+      end
+
+      def as_recurring_payment
+        self.initiation = INITIATION_MERCHANT
+        self
+      end
+
+      protected
+
+      def assign_merchant
+        self.merchant ||= Lpt.merchant
+      end
+    end
+  end
+end

data/lib/lpt/requests/payment_reversal_request.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class PaymentReversalRequest < ApiRequest
+      attr_accessor :reference_id, :amount, :session
+    end
+  end
+end

data/lib/lpt/requests/profile_request.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class ProfileRequest < ApiRequest
+      attr_accessor :metadata, :profile_id, :reference_id, :name, :contact,
+                    :address
+    end
+  end
+end

data/lib/lpt/requests/verification_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Requests
+    class VerificationRequest < ApiRequest
+      attr_accessor :metadata, :verification_id, :reference_id, :category,
+                    :type, :instrument, :profile, :subject, :merchant,
+                    :merchant_account, :url
+    end
+  end
+end

data/lib/lpt/resources/api_resource.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Resources
+    class ApiResource
+      attr_accessor :id, :entity, :metadata, :created, :updated, :status,
+                    :created_at, :updated_at
+
+      def initialize(attributes = {})
+        hydrate_attributes attributes
+        assign_object_name
+      end
+
+      def object_name
+        assert_object_name_implemented!
+        @object_name
+      end
+
+      def base_path
+        "/#{Lpt.api_version}"
+      end
+
+      def resources_path
+        assert_concrete_class_used!
+        # Namespaces are separated in object names with periods (.) and in URLs
+        # with forward slashes (/), so replace the former with the latter.
+        "#{base_path}/#{object_name.downcase.tr('.', '/')}s"
+      end
+
+      def resource_path
+        assert_concrete_class_used!
+        assert_valid_id_exists!
+        "#{resources_path}/#{CGI.escape(id)}"
+      end
+
+      def load_from_response(response)
+        return if response.blank?
+
+        hydrate_attributes response
+      end
+
+      protected
+
+      def assign_object_name; end
+
+      def assert_concrete_class_used!
+        return unless instance_of? ApiResource
+
+        msg = <<~MSG
+          APIResource is an abstract class. You should perform actions on its
+          subclasses (Payment, Instrument, etc.)
+        MSG
+        raise NotImplementedError, msg
+      end
+
+      def assert_object_name_implemented!
+        return unless @object_name.blank?
+
+        msg = "Resources must implement #object_name"
+        raise NotImplementedError, msg
+      end
+
+      def assert_valid_id_exists!
+        return unless id.blank?
+
+        msg = <<~MSG
+          Could not determine which URL to request: #{self.class} instance has
+          an invalid ID: #{id.inspect}
+        MSG
+        raise ArgumentError, msg
+      end
+
+      def hydrate_attributes(attributes)
+        return unless attributes.respond_to? :each_pair
+
+        attributes.each_pair do |k, v|
+          setter = :"#{k}="
+          public_send(setter, v)
+        rescue NoMethodError
+          # noop
+        end
+      end
+    end
+  end
+end

data/lib/lpt/resources/instrument.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Resources
+    class Instrument < ApiResource
+      extend Lpt::ApiOperations::Retrieve
+      extend Lpt::ApiOperations::Create
+      extend Lpt::ApiOperations::Update
+
+      attr_accessor :profile, :metadata, :instrument_id, :reference_id,
+                    :category, :type, :account_type, :name, :contact,
+                    :address, :identifier, :brand, :network, :issuer_identifier,
+                    :issuer, :expiration, :fingerprint, :token
+
+      def id_prefix
+        Lpt::PREFIX_INSTRUMENT
+      end
+
+      def expiration_month
+        return false unless expiration.respond_to? :with_indifferent_access
+
+        expiration.with_indifferent_access["month"]
+      end
+
+      def expiration_year
+        return false unless expiration.respond_to? :with_indifferent_access
+
+        expiration.with_indifferent_access["year"]
+      end
+
+      def auth(payment_request)
+        assert_valid_id_exists!
+        payment_request.instrument = id
+        Lpt::Resources::Payment.auth(payment_request)
+      rescue ArgumentError
+        false
+      end
+
+      def charge(payment_request)
+        assert_valid_id_exists!
+        payment_request.instrument = id
+        Lpt::Resources::Payment.sale(payment_request)
+      rescue ArgumentError
+        false
+      end
+
+      def self.tokenize(instrument_token_request)
+        path = token_path
+        Lpt::Resources::Instrument.create(instrument_token_request, path: path)
+      end
+
+      def self.token_path(entity: nil)
+        resource = new
+        [resource.resources_path, "token", entity].compact.join("/")
+      end
+
+      protected
+
+      def assign_object_name
+        @object_name = "instrument"
+      end
+
+      def assert_valid_id_exists!
+        return if id.present?
+
+        raise ArgumentError, "An instrument ID is required"
+      end
+    end
+  end
+end

data/lib/lpt/resources/payment.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Resources
+    class Payment < ApiResource
+      extend Lpt::ApiOperations::Retrieve
+      extend Lpt::ApiOperations::Create
+      extend Lpt::ApiOperations::Update
+
+      attr_accessor :payment_id, :reference_id, :instrument,
+                    :instrument_identifier, :initiation, :merchant,
+                    :merchant_account, :workflow, :amount, :currency, :order,
+                    :invoice, :session, :profile, :authorization, :presentment,
+                    :reversal, :refunds, :amount_refundable, :result, :url
+
+      def approved?
+        return false unless result.respond_to? :with_indifferent_access
+
+        result.with_indifferent_access["approved"] == true
+      end
+
+      def id_prefix
+        Lpt::PREFIX_PAYMENT
+      end
+
+      def capture(request = Lpt::Requests::EmptyRequest.new)
+        path = "#{resource_path}/capture"
+        Lpt::Resources::Payment.create(request, path: path)
+      end
+
+      def refund(request = Lpt::Requests::EmptyRequest.new)
+        path = "#{resource_path}/refund"
+        Lpt::Resources::Payment.create(request, path: path)
+      end
+
+      def reverse(request = Lpt::Requests::EmptyRequest.new)
+        path = "#{resource_path}/reverse"
+        Lpt::Resources::Payment.create(request, path: path)
+      end
+
+      def void(request = Lpt::Requests::EmptyRequest.new)
+        path = "#{resource_path}/void"
+        Lpt::Resources::Payment.create(request, path: path)
+      end
+
+      def self.auth(payment_request)
+        payment_request.as_auth_capture
+        Lpt::Resources::Payment.create(payment_request)
+      end
+
+      def self.sale(payment_request)
+        payment_request.as_sale
+        Lpt::Resources::Payment.create(payment_request)
+      end
+
+      protected
+
+      def assign_object_name
+        @object_name = "payment"
+      end
+    end
+  end
+end

data/lib/lpt/resources/profile.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lpt
+  module Resources
+    class Profile < ApiResource
+      extend Lpt::ApiOperations::Retrieve
+      extend Lpt::ApiOperations::Create
+      extend Lpt::ApiOperations::Update
+
+      attr_accessor :profile_id, :reference_id, :name, :contact, :address
+
+      def id_prefix
+        Lpt::PREFIX_PROFILE
+      end
+
+      def associate_instrument(instrument_token_request)
+        assert_valid_id_exists!
+        assert_token_exists! instrument_token_request
+        instrument_token_request.profile = id
+        Lpt::Resources::Instrument.create(instrument_token_request)
+      rescue ArgumentError
+        false
+      end
+
+      protected
+
+      def assign_object_name
+        @object_name = "profile"
+      end
+
+      def assert_valid_id_exists!
+        return if id.present?
+
+        raise ArgumentError, "A profile ID is required"
+      end
+
+      def assert_token_exists!(request)
+        return if request.token.present?
+
+        raise ArgumentError, "An instrument token is required"
+      end
+    end
+  end
+end