dpay 0.1.0

data/lib/dpay/errors.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module DPay
+  module Error; end
+
+  class InvalidArgumentError < ArgumentError
+    include Error
+  end
+
+  class TransportError < StandardError
+    include Error
+  end
+
+  class SignatureVerificationError < StandardError
+    include Error
+  end
+
+  class CardEncryptionError < StandardError
+    include Error
+  end
+
+  class ApiError < StandardError
+    include Error
+
+    attr_reader :http_status, :error_code, :field_errors, :raw_body
+
+    def initialize(message, http_status, error_code = nil, field_errors = {}, raw_body = "")
+      super(message)
+      @http_status = http_status
+      @error_code = error_code
+      @field_errors = field_errors
+      @raw_body = raw_body
+    end
+  end
+
+  class AuthenticationError < ApiError; end
+  class InvalidRequestError < ApiError; end
+  class AccessDeniedError < ApiError; end
+  class NotFoundError < ApiError; end
+  class ApiServerError < ApiError; end
+
+  class RateLimitError < ApiError
+    attr_reader :retry_after, :limit, :remaining
+
+    def initialize(message, http_status, retry_after = nil, limit = nil, remaining = nil, raw_body = "")
+      super(message, http_status, nil, {}, raw_body)
+      @retry_after = retry_after
+      @limit = limit
+      @remaining = remaining
+    end
+  end
+
+  class PaymentRejectedError < ApiError
+    attr_reader :transaction_id
+
+    def self.from_api(data)
+      message = %w[message msg].filter_map { |key| data[key] if data[key].is_a?(String) }.first || "Payment rejected"
+      error_code = data["errorcode"].is_a?(String) ? data["errorcode"] : nil
+      transaction_id = data["transactionId"].nil? ? nil : Internal::PHP.strval(data["transactionId"])
+
+      new(message, 200, error_code, {}, Internal::PHP.json_encode(data), transaction_id)
+    end
+
+    def initialize(message, http_status, error_code = nil, field_errors = {}, raw_body = "", transaction_id = nil)
+      super(message, http_status, error_code, field_errors, raw_body)
+      @transaction_id = transaction_id
+    end
+  end
+
+  class CardPaymentError < ApiError
+    def self.from_api(data)
+      message = data["message"].is_a?(String) && !data["message"].empty? ? data["message"] : "Card payment rejected"
+
+      new(message, 200, message, {}, Internal::PHP.json_encode(data))
+    end
+  end
+end

data/lib/dpay/http/client.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module DPay
+  module HTTP
+    class Client
+      def request(_api_request)
+        raise NotImplementedError, "#{self.class}#request must return a DPay::HTTP::Response"
+      end
+    end
+  end
+end

data/lib/dpay/http/net_http_client.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+module DPay
+  module HTTP
+    class NetHTTPClient < Client
+      CONNECT_TIMEOUT = 10
+
+      NETWORK_ERRORS = [
+        Timeout::Error, SocketError, IOError, SystemCallError, OpenSSL::SSL::SSLError, Net::HTTPBadResponse
+      ].freeze
+
+      def initialize(timeout = 30)
+        super()
+        @timeout = timeout
+      end
+
+      def request(api_request)
+        uri = URI.parse(api_request.url)
+        raise TransportError, "Unsupported URL scheme: #{api_request.url}" unless uri.is_a?(URI::HTTP)
+
+        host = uri.host
+        raise TransportError, "URL has no host: #{api_request.url}" if host.nil?
+
+        http = Net::HTTP.new(host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = CONNECT_TIMEOUT
+        http.read_timeout = @timeout
+        http.write_timeout = @timeout
+
+        response = http.request(build_request(uri, api_request))
+
+        Response.new(response.code.to_i, response.each_header.to_h, response.body.to_s)
+      rescue *NETWORK_ERRORS => e
+        raise TransportError, "HTTP transport error: #{e.class}: #{e.message}"
+      end
+
+      private
+
+      def build_request(uri, api_request)
+        klass = Net::HTTP.const_get(api_request.method.to_s.capitalize)
+        request = klass.new(uri.request_uri)
+        api_request.headers.each { |name, value| request[name] = value }
+        request.body = api_request.body unless api_request.body.nil?
+        request
+      end
+    end
+  end
+end

data/lib/dpay/http/request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module DPay
+  module HTTP
+    class Request
+      attr_reader :method, :url, :headers, :body
+
+      def initialize(method, url, headers = {}, body = nil)
+        @method = method
+        @url = url
+        @headers = headers.freeze
+        @body = body
+        freeze
+      end
+    end
+  end
+end

data/lib/dpay/http/response.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "json"
+
+module DPay
+  module HTTP
+    class Response
+      attr_reader :status, :headers, :body
+
+      def initialize(status, headers, body)
+        @status = status
+        @headers = headers.each_with_object({}) { |(name, value), result| result[name.to_s.downcase] = value }.freeze
+        @body = body
+        freeze
+      end
+
+      def header(name)
+        @headers[name.to_s.downcase]
+      end
+
+      def decode_json
+        decoded = JSON.parse(@body.to_s)
+        decoded.is_a?(Hash) || decoded.is_a?(Array) ? decoded : nil
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/dpay/internal/api_requestor.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module DPay
+  module Internal
+    class ApiRequestor
+      USER_AGENT = "dpay-ruby-sdk/#{VERSION} ruby/#{RUBY_VERSION}".freeze
+
+      attr_reader :config, :checksum
+
+      def initialize(config, http_client)
+        @config = config
+        @http_client = http_client
+        @checksum = ChecksumCalculator.new(config.secret_hash)
+      end
+
+      def service
+        @config.service
+      end
+
+      def post_json(host, path, body)
+        decode(send_request("POST", host, path, body))
+      end
+
+      def get_json(host, path)
+        decode(send_request("GET", host, path, nil))
+      end
+
+      def get_text(host, path)
+        send_request("GET", host, path, nil).body
+      end
+
+      def send_request(method, host, path, body)
+        response = send_raw(method, host, path, body)
+        raise map_error(response) if response.status >= 400
+
+        response
+      end
+
+      def send_raw(method, host, path, body)
+        headers = { "Accept" => "application/json", "User-Agent" => USER_AGENT }
+        encoded = nil
+
+        unless body.nil?
+          headers["Content-Type"] = "application/json"
+          encoded = PHP.json_encode(body)
+        end
+
+        @http_client.request(HTTP::Request.new(method, @config.base_urls.resolve(host) + path, headers, encoded))
+      end
+
+      def map_error(response)
+        ErrorMapper.map(response)
+      end
+
+      private
+
+      def decode(response)
+        decoded = response.decode_json
+        return decoded unless decoded.nil?
+
+        raise ApiServerError.new("Invalid JSON in API response", response.status, nil, {}, response.body)
+      end
+    end
+  end
+end

data/lib/dpay/internal/base_urls.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DPay
+  module Internal
+    class BaseUrls
+      API_PAYMENTS = :api_payments
+      PANEL = :panel
+      GATEWAY = :gateway
+
+      DEFAULTS = {
+        API_PAYMENTS => "https://api-payments.dpay.pl",
+        PANEL => "https://panel.dpay.pl",
+        GATEWAY => "https://secure.dpay.pl"
+      }.freeze
+
+      def initialize(overrides = {})
+        urls = DEFAULTS.dup
+
+        overrides.each do |host, url|
+          key = host.to_sym
+          raise InvalidArgumentError, %(Unknown base URL key "#{host}") unless DEFAULTS.key?(key)
+
+          urls[key] = url.to_s.sub(%r{/+\z}, "")
+        end
+
+        @urls = urls.freeze
+        freeze
+      end
+
+      def resolve(host)
+        key = host.to_sym
+        raise InvalidArgumentError, %(Unknown API host "#{host}") unless @urls.key?(key)
+
+        @urls[key]
+      end
+    end
+  end
+end

data/lib/dpay/internal/checksum_calculator.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module DPay
+  module Internal
+    class ChecksumCalculator
+      def initialize(secret_hash)
+        @secret_hash = secret_hash
+        freeze
+      end
+
+      def secret_second(service, fields)
+        parts = [service, @secret_hash] + fields.map { |field| PHP.strval(field) }
+
+        Digest::SHA256.hexdigest(parts.join("|"))
+      end
+
+      def ordered_body(values)
+        joined = values.map { |value| PHP.strval(value) }.join("|")
+
+        Digest::SHA256.hexdigest("#{joined}|#{@secret_hash}")
+      end
+    end
+  end
+end

data/lib/dpay/internal/coerce.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module DPay
+  module Internal
+    module Coerce
+      module_function
+
+      def string(value)
+        return nil unless value.is_a?(String) || value.is_a?(Numeric) ||
+                          value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+        PHP.strval(value)
+      end
+
+      def money(value, currency = Currency::PLN)
+        Money.try_from_api_number(value.nil? ? 0 : value, currency) || Money.pln(0)
+      end
+
+      def boolean(value)
+        return value if value.is_a?(TrueClass) || value.is_a?(FalseClass)
+        return value != 0 if value.is_a?(Numeric)
+        return !value.empty? && value != "0" if value.is_a?(String)
+
+        false
+      end
+
+      def integer(value)
+        return value.to_i if value.is_a?(Numeric)
+        return value.to_i if value.is_a?(String) && /\A\s*[+-]?\d+/.match?(value)
+
+        0
+      end
+
+      def optional_integer(value)
+        return value.to_i if value.is_a?(Numeric)
+        return value.to_i if value.is_a?(String) && /\A\s*[+-]?\d+\z/.match?(value)
+
+        nil
+      end
+
+      def list(value)
+        value.is_a?(Array) ? value.grep(Hash) : []
+      end
+    end
+  end
+end

data/lib/dpay/internal/error_mapper.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module DPay
+  module Internal
+    module ErrorMapper
+      DEFAULT_MESSAGE = "Unexpected API error"
+
+      module_function
+
+      def map(response)
+        decoded = response.decode_json
+        data = decoded.is_a?(Hash) ? decoded : {}
+        message = extract_message(data)
+
+        return rate_limit(response, message) if response.status == 429
+
+        error_class(response.status).new(
+          message,
+          response.status,
+          data["errorcode"].is_a?(String) ? data["errorcode"] : nil,
+          normalize_field_errors(data["errors"]),
+          response.body
+        )
+      end
+
+      def error_class(status)
+        case status
+        when 401 then AuthenticationError
+        when 403 then AccessDeniedError
+        when 404 then NotFoundError
+        when 400, 422 then InvalidRequestError
+        else status >= 500 ? ApiServerError : ApiError
+        end
+      end
+
+      def extract_message(data)
+        return data["message"] if data["message"].is_a?(String)
+        return data["msg"] if data["msg"].is_a?(String)
+
+        DEFAULT_MESSAGE
+      end
+
+      def rate_limit(response, message)
+        RateLimitError.new(
+          message,
+          response.status,
+          int_header(response, "Retry-After"),
+          int_header(response, "X-RateLimit-Limit"),
+          int_header(response, "X-RateLimit-Remaining"),
+          response.body
+        )
+      end
+
+      def normalize_field_errors(errors)
+        pairs = case errors
+                when Array then errors.each_with_index.map { |messages, index| [index, messages] }
+                when Hash then errors.to_a
+                else return {}
+                end
+
+        pairs.each_with_object({}) do |(field, messages), result|
+          normalized = normalize_messages(messages)
+          result[PHP.strval(field)] = normalized unless normalized.nil?
+        end
+      end
+
+      def normalize_messages(messages)
+        case messages
+        when String then [messages]
+        when Array then messages.select { |message| scalar?(message) }.map { |message| PHP.strval(message) }
+        end
+      end
+
+      def scalar?(value)
+        value.is_a?(String) || value.is_a?(Numeric) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+      end
+
+      def int_header(response, name)
+        value = response.header(name)
+        return nil if value.nil?
+
+        match = /\A\s*[+-]?\d+/.match(value.to_s)
+        return 0 if match.nil?
+
+        digits = match[0]
+        digits.nil? ? 0 : digits.strip.to_i
+      end
+    end
+  end
+end

data/lib/dpay/internal/php.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+module DPay
+  module Internal
+    module PHP
+      SAFE_INTEGRAL_FLOAT = 2**53
+      NON_UNRESERVED = /[^A-Za-z0-9\-_.~]/n
+
+      module_function
+
+      def strval(value)
+        case value
+        when nil, false then ""
+        when true then "1"
+        when Float then float_to_string(value)
+        when String then value
+        else value.to_s
+        end
+      end
+
+      def round(value)
+        value >= 0 ? (value + 0.5).floor : (value - 0.5).ceil
+      end
+
+      def json_encode(data, escape_slashes: false)
+        encoded = JSON.generate(normalize_floats(data))
+        escape_slashes ? encoded.gsub("/") { "\\/" } : encoded
+      end
+
+      def raw_url_encode(value)
+        value.to_s.b.gsub(NON_UNRESERVED) { |byte| format("%%%02X", byte.ord) }
+      end
+
+      def float_to_string(value)
+        return "NAN" if value.nan?
+        return value.positive? ? "INF" : "-INF" if value.infinite?
+
+        formatted = format("%.14G", value)
+        return formatted unless formatted.include?("E")
+
+        parts = formatted.split("E")
+        mantissa = parts.fetch(0)
+        exponent = parts.fetch(1)
+        mantissa += ".0" unless mantissa.include?(".")
+        sign = exponent.start_with?("-") ? "-" : "+"
+        digits = exponent.sub(/\A[+-]/, "").sub(/\A0+/, "")
+        digits = "0" if digits.empty?
+        "#{mantissa}E#{sign}#{digits}"
+      end
+
+      def normalize_floats(value)
+        case value
+        when Float
+          integral_float?(value) ? value.to_i : value
+        when Hash
+          value.each_with_object({}) { |(key, item), result| result[key] = normalize_floats(item) }
+        when Array
+          value.map { |item| normalize_floats(item) }
+        else
+          value
+        end
+      end
+
+      def integral_float?(value)
+        value.finite? && value.abs < SAFE_INTEGRAL_FLOAT && value.to_i == value
+      end
+    end
+  end
+end

data/lib/dpay/ipn/ipn_event.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module DPay
+  class IpnEvent
+    ACK = "OK"
+
+    attr_reader :raw
+
+    def self.from_verified_payload(payload)
+      new(payload)
+    end
+
+    def initialize(payload)
+      @raw = payload
+      freeze
+    end
+
+    def id
+      scalar("id") || ""
+    end
+
+    def amount
+      scalar("amount") || ""
+    end
+
+    def type
+      scalar("type") || ""
+    end
+
+    def signature
+      scalar("signature") || ""
+    end
+
+    def email
+      scalar("email")
+    end
+
+    def custom
+      scalar("custom")
+    end
+
+    def capture_payment_id
+      scalar("capture_payment_id")
+    end
+
+    def attempt
+      integer("attempt")
+    end
+
+    def version
+      integer("version")
+    end
+
+    def transfer?
+      type == IpnType::TRANSFER
+    end
+
+    def capture?
+      type == IpnType::CAPTURE
+    end
+
+    def dcb?
+      type == IpnType::DCB
+    end
+
+    private
+
+    def scalar(key)
+      value = @raw[key]
+      return nil unless value.is_a?(String) || value.is_a?(Numeric) ||
+                        value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+      Internal::PHP.strval(value)
+    end
+
+    def integer(key)
+      value = @raw[key]
+      return value.to_i if value.is_a?(Integer) || value.is_a?(Float)
+      return value.to_i if value.is_a?(String) && /\A[+-]?\d+\z/.match?(value)
+
+      0
+    end
+  end
+end

data/lib/dpay/ipn/ipn_type.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DPay
+  module IpnType
+    TRANSFER = "transfer"
+    CAPTURE = "capture"
+    DCB = "dcb"
+
+    ALL = [TRANSFER, CAPTURE, DCB].freeze
+
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+
+    def self.assert_valid(value)
+      raise InvalidArgumentError, %(Invalid IPN type "#{value}") unless valid?(value)
+    end
+  end
+end

data/lib/dpay/ipn/ipn_verifier.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "openssl"
+
+module DPay
+  module IpnVerifier
+    REQUIRED_FIELDS = %w[id amount type attempt version signature].freeze
+    INVALID_PAYLOAD = "Invalid IPN payload"
+
+    module_function
+
+    def construct_event(raw_body, secret_hash)
+      payload = parse(raw_body)
+      signature = payload["signature"]
+      raise SignatureVerificationError, INVALID_PAYLOAD unless signature.is_a?(String)
+
+      expected = expected_signature(payload, secret_hash)
+      raise SignatureVerificationError, "Invalid IPN signature" unless secure_compare(expected, signature)
+
+      IpnEvent.from_verified_payload(payload)
+    end
+
+    def parse(raw_body)
+      payload = begin
+        JSON.parse(raw_body.to_s)
+      rescue JSON::ParserError
+        raise SignatureVerificationError, INVALID_PAYLOAD
+      end
+
+      raise SignatureVerificationError, INVALID_PAYLOAD unless payload.is_a?(Hash)
+      raise SignatureVerificationError, INVALID_PAYLOAD unless REQUIRED_FIELDS.all? { |f| !payload[f].nil? }
+
+      payload
+    end
+
+    def expected_signature(payload, secret_hash)
+      type = Internal::PHP.strval(payload["type"])
+
+      parts = [Internal::PHP.strval(payload["id"]), secret_hash, Internal::PHP.strval(payload["amount"])]
+      parts << Internal::PHP.strval(payload["email"]) unless type == IpnType::DCB
+      parts << type
+      parts << Internal::PHP.strval(payload["attempt"])
+      parts << Internal::PHP.strval(payload["version"])
+      parts << Internal::PHP.strval(payload["custom"])
+
+      Digest::SHA256.hexdigest(parts.join)
+    end
+
+    def secure_compare(expected, actual)
+      expected.bytesize == actual.bytesize && OpenSSL.fixed_length_secure_compare(expected, actual)
+    end
+
+    private_class_method :parse, :expected_signature, :secure_compare
+  end
+end