dpay 0.1.0

data/lib/dpay/blik/blik_recurring_status.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module DPay
+  class BlikRecurringStatus
+    ACTIVE = "ACTIVE"
+
+    attr_reader :alias_value, :alias_type, :status, :expiration_date, :registration, :raw
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @raw = data
+      @alias_value = Internal::Coerce.string(data["alias_value"]) || ""
+      @alias_type = Internal::Coerce.string(data["alias_type"]) || BlikAliasType::PAYID
+      @status = data["status"].is_a?(String) ? data["status"] : nil
+      @expiration_date = data["expiration_date"].is_a?(String) ? data["expiration_date"] : nil
+      registration = data["registration"]
+      @registration = registration.is_a?(Hash) ? BlikRecurringRegistrationInfo.from_api(registration) : nil
+      freeze
+    end
+
+    def active?
+      @status == ACTIVE
+    end
+  end
+end

data/lib/dpay/blik/blik_service.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module DPay
+  class BlikService
+    def initialize(api)
+      @api = api
+    end
+
+    def alias(alias_value, alias_type = BlikAliasType::UID)
+      data = @api.post_json(
+        Internal::BaseUrls::API_PAYMENTS,
+        "/api/v1_0/payments/blik/aliases",
+        alias_body(alias_value, alias_type)
+      )
+
+      BlikAlias.from_api(payload(data))
+    end
+
+    def unregister_alias(alias_value, alias_type = BlikAliasType::UID, reason = nil)
+      body = alias_body(alias_value, alias_type, reason)
+      @api.post_json(Internal::BaseUrls::API_PAYMENTS, "/api/v1_0/payments/blik/aliases/unregister", body)
+
+      nil
+    end
+
+    def recurring_status(alias_value)
+      body = { "service" => @api.service, "alias_value" => alias_value }
+      body["checksum"] = @api.checksum.secret_second(@api.service, [alias_value])
+
+      data = @api.post_json(Internal::BaseUrls::API_PAYMENTS, "/api/v1_0/payments/blik/recurring/status", body)
+
+      BlikRecurringStatus.from_api(payload(data))
+    end
+
+    private
+
+    def alias_body(alias_value, alias_type, reason = nil)
+      BlikAliasType.assert_valid(alias_type)
+
+      body = { "service" => @api.service, "alias_value" => alias_value, "alias_type" => alias_type }
+      body["reason"] = reason unless reason.nil?
+      body["checksum"] = @api.checksum.secret_second(@api.service, [alias_value])
+
+      body
+    end
+
+    def payload(data)
+      data["data"].is_a?(Hash) ? data["data"] : {}
+    end
+  end
+end

data/lib/dpay/card/apple_pay_request.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module DPay
+  class ApplePayRequest
+    INIT = "APPLE_PAY_INIT"
+    PAY = "APPLE_PAY"
+
+    def self.init(device_info)
+      new(INIT, nil, device_info)
+    end
+
+    def self.pay(token, device_info)
+      new(PAY, token, device_info)
+    end
+
+    def initialize(x_pay_type, token, device_info)
+      @x_pay_type = x_pay_type
+      @token = token
+      @device_info = device_info
+      @channel_id = nil
+    end
+
+    def with_channel_id(channel_id)
+      @channel_id = channel_id
+      self
+    end
+
+    def to_body
+      body = {}
+      body["channelId"] = @channel_id unless @channel_id.nil?
+      body["xPayType"] = @x_pay_type
+      body["xPayToken"] = @token unless @token.nil?
+      body["deviceInfo"] = @device_info.to_h
+
+      body
+    end
+  end
+end

data/lib/dpay/card/card_data.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DPay
+  class CardData
+    PAN = /\A\d{12,19}\z/
+    CVV = /\A\d{3,4}\z/
+    EXPIRY = %r{\A(0[1-9]|1[0-2])/\d{2}\z}
+
+    attr_reader :pan, :cvv, :expiry
+
+    def initialize(pan, cvv, expiry)
+      normalized = pan.to_s.delete(" ")
+
+      raise InvalidArgumentError, "Card number must be 12-19 digits" unless PAN.match?(normalized)
+      raise InvalidArgumentError, "CVV must be 3-4 digits" unless CVV.match?(cvv.to_s)
+      raise InvalidArgumentError, "Expiry must be in MM/YY format" unless EXPIRY.match?(expiry.to_s)
+
+      @pan = normalized
+      @cvv = cvv
+      @expiry = expiry
+      freeze
+    end
+
+    def inspect
+      "#<DPay::CardData pan=[FILTERED] cvv=[FILTERED] expiry=[FILTERED]>"
+    end
+
+    alias to_s inspect
+  end
+end

data/lib/dpay/card/card_encryptor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "openssl"
+
+module DPay
+  class CardEncryptor
+    def encrypt(card, transaction_id, public_key_pem, timestamp: Time.now.to_i)
+      key = load_key(public_key_pem)
+      payload = Internal::PHP.json_encode(
+        { "PN" => card.pan, "SC" => card.cvv, "DT" => card.expiry, "ID" => transaction_id, "TX" => timestamp },
+        escape_slashes: true
+      )
+
+      [key.public_encrypt(payload, OpenSSL::PKey::RSA::PKCS1_PADDING)].pack("m0")
+    rescue OpenSSL::PKey::PKeyError => e
+      raise CardEncryptionError, "Card data encryption failed: #{e.message}"
+    end
+
+    private
+
+    def load_key(public_key_pem)
+      OpenSSL::PKey::RSA.new(public_key_pem.to_s)
+    rescue OpenSSL::PKey::PKeyError, ArgumentError, TypeError
+      raise CardEncryptionError, "Invalid RSA public key"
+    end
+  end
+end

data/lib/dpay/card/card_payment_request.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module DPay
+  class CardPaymentRequest
+    def self.create(device_info)
+      new(device_info)
+    end
+
+    def initialize(device_info)
+      @device_info = device_info
+      @leading = {}
+      @trailing = {}
+    end
+
+    def with_email(email)
+      @leading["email"] = email
+      self
+    end
+
+    def with_channel_id(channel_id)
+      @leading["channelId"] = channel_id
+      self
+    end
+
+    def with_card_holder(first_name, last_name)
+      @leading["cardHolderFirstName"] = first_name
+      @leading["cardHolderLastName"] = last_name
+      self
+    end
+
+    def with_encrypted_card_data(encrypted_card_data)
+      @leading["encryptedCardData"] = encrypted_card_data
+      self
+    end
+
+    def with_three_ds_confirmed(confirmed)
+      @trailing["threeDsConfirmed"] = confirmed
+      self
+    end
+
+    def with_dcc_decision(decision)
+      DccDecision.assert_valid(decision)
+      @trailing["dccDecision"] = decision
+      self
+    end
+
+    def to_body
+      body = {}
+
+      %w[email channelId cardHolderFirstName cardHolderLastName encryptedCardData].each do |key|
+        body[key] = @leading[key] if @leading.key?(key)
+      end
+      body["deviceInfo"] = @device_info.to_h
+      %w[threeDsConfirmed dccDecision].each { |key| body[key] = @trailing[key] if @trailing.key?(key) }
+
+      body
+    end
+  end
+end

data/lib/dpay/card/card_payment_result.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module DPay
+  class CardPaymentResult
+    attr_reader :redirect_type, :redirect_text, :dcc_offer, :raw
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @raw = data
+      message = data["message"].is_a?(Hash) ? data["message"] : {}
+
+      @redirect_type = message["redirectType"].is_a?(String) ? message["redirectType"] : nil
+      text = message["redirectText"]
+      @redirect_text = text.is_a?(String) && !text.empty? ? text : nil
+      @dcc_offer = message["dccOffer"].is_a?(Hash) ? DccOffer.from_api(message["dccOffer"]) : nil
+      freeze
+    end
+
+    def success?
+      @redirect_type == RedirectType::SUCCESS
+    end
+
+    def three_ds_form?
+      @redirect_type == RedirectType::FORM
+    end
+
+    def requires_redirect?
+      @redirect_type == RedirectType::URL
+    end
+
+    def dcc_offer?
+      @redirect_type == RedirectType::DCC_OFFER
+    end
+
+    def three_ds_form_html
+      three_ds_form? ? decode : nil
+    end
+
+    def redirect_url
+      requires_redirect? ? decode : nil
+    end
+
+    private
+
+    def decode
+      text = @redirect_text
+      return nil if text.nil?
+
+      decoded = text.unpack1("m0")
+      decoded.is_a?(String) ? decoded : nil
+    rescue ArgumentError
+      nil
+    end
+  end
+end

data/lib/dpay/card/card_recurring_frequency.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DPay
+  module CardRecurringFrequency
+    DAILY = "DAILY"
+    WEEKLY = "WEEKLY"
+    BIWEEKLY = "BIWEEKLY"
+    MONTHLY = "MONTHLY"
+    QUARTERLY = "QUARTERLY"
+    SEMIANNUAL = "SEMIANNUAL"
+    ANNUAL = "ANNUAL"
+
+    ALL = [DAILY, WEEKLY, BIWEEKLY, MONTHLY, QUARTERLY, SEMIANNUAL, ANNUAL].freeze
+
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+
+    def self.assert_valid(value)
+      raise InvalidArgumentError, %(Invalid card recurring frequency "#{value}") unless valid?(value)
+    end
+  end
+end

data/lib/dpay/card/card_recurring_operation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DPay
+  module CardRecurringOperation
+    ADD_CARD = "add_card"
+    COF_INITIAL = "cof_initial"
+    CHARGE = "charge"
+
+    ALL = [ADD_CARD, COF_INITIAL, CHARGE].freeze
+
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+
+    def self.assert_valid(value)
+      raise InvalidArgumentError, %(Invalid card recurring operation "#{value}") unless valid?(value)
+    end
+  end
+end

data/lib/dpay/card/card_recurring_registration.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module DPay
+  class CardRecurringRegistration
+    DATE = /\A\d{4}-\d{2}-\d{2}\z/
+
+    def self.create(label)
+      new(label)
+    end
+
+    def initialize(label)
+      unless label.is_a?(String) && !label.empty? && label.length <= 50
+        raise InvalidArgumentError, "Mandate label must be 1-50 characters"
+      end
+
+      @label = label
+      @optional = {}
+    end
+
+    def with_frequency(frequency)
+      CardRecurringFrequency.assert_valid(frequency)
+      @optional["frequency"] = frequency
+      self
+    end
+
+    def with_limit_amt(limit_amt)
+      @optional["limit_amt"] = limit_amt.minor
+      self
+    end
+
+    def with_tot_limit_amt(tot_limit_amt)
+      @optional["tot_limit_amt"] = tot_limit_amt.minor
+      self
+    end
+
+    def with_limit_amt_fixed(fixed)
+      @optional["is_limit_amt_fixed"] = fixed
+      self
+    end
+
+    def with_expiration_date(expiration_date)
+      @optional["expiration_date"] = assert_date(expiration_date)
+      self
+    end
+
+    def with_init_date(init_date)
+      @optional["init_date"] = assert_date(init_date)
+      self
+    end
+
+    def to_h
+      base = { "label" => @label }
+
+      %w[frequency limit_amt tot_limit_amt is_limit_amt_fixed expiration_date init_date].each do |key|
+        base[key] = @optional[key] if @optional.key?(key)
+      end
+
+      base
+    end
+
+    private
+
+    def assert_date(date)
+      raise InvalidArgumentError, %(Date "#{date}" must be in YYYY-MM-DD format) unless DATE.match?(date.to_s)
+
+      date
+    end
+  end
+end

data/lib/dpay/card/card_service.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module DPay
+  class CardService
+    def initialize(api)
+      @api = api
+    end
+
+    def public_key
+      @api.get_text(Internal::BaseUrls::API_PAYMENTS, "/api/v1_0/cards/public-key").strip
+    end
+
+    def pay_otp(transaction_id, request)
+      post(transaction_id, "/pay/card-otp", request.to_body)
+    end
+
+    def pre_auth(transaction_id, request)
+      post(transaction_id, "/pay/card-pre-auth", request.to_body)
+    end
+
+    def capture(transaction_id, amount)
+      post(transaction_id, "/capture", { "amount" => amount.to_decimal.to_f })
+    end
+
+    def cancel(transaction_id, amount = nil)
+      post(transaction_id, "/cancellation", amount.nil? ? {} : { "amount" => amount.to_decimal.to_f })
+    end
+
+    def google_pay(transaction_id, request)
+      post(transaction_id, "/pay/google-pay", request.to_body)
+    end
+
+    def apple_pay(transaction_id, request)
+      post(transaction_id, "/pay/apple-pay", request.to_body)
+    end
+
+    private
+
+    def post(transaction_id, suffix, body)
+      path = "/api/v1_0/cards/payment/#{Internal::PHP.raw_url_encode(transaction_id)}#{suffix}"
+      data = @api.post_json(Internal::BaseUrls::API_PAYMENTS, path, body)
+      raise CardPaymentError.from_api(data) unless data["success"] == true
+
+      CardPaymentResult.from_api(data)
+    end
+  end
+end

data/lib/dpay/card/dcc_decision.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DPay
+  module DccDecision
+    ACCEPT = "accept"
+    REJECT = "reject"
+
+    ALL = [ACCEPT, REJECT].freeze
+
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+
+    def self.assert_valid(value)
+      raise InvalidArgumentError, %(Invalid DCC decision "#{value}") unless valid?(value)
+    end
+  end
+end

data/lib/dpay/card/dcc_markup.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DPay
+  class DccMarkup
+    attr_reader :rate, :additional_info
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      rate = data["rate"]
+      @rate = rate.is_a?(Integer) || rate.is_a?(Float) ? rate.to_f : 0.0
+      @additional_info = data["additionalInfo"].is_a?(String) ? data["additionalInfo"] : nil
+      freeze
+    end
+  end
+end

data/lib/dpay/card/dcc_offer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DPay
+  class DccOffer
+    attr_reader :currency_conversion_id, :original_amount, :converted_amount, :exchange_rate,
+                :valid_until, :declaration_text, :markup, :raw
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @raw = data
+      @currency_conversion_id = Internal::Coerce.string(data["currencyConversionId"]) || ""
+      @original_amount = Internal::Coerce.money(data["originalAmount"], currency(data["originalCurrency"]))
+      @converted_amount = Internal::Coerce.money(data["convertedAmount"], currency(data["convertedCurrency"]))
+      exchange_rate = data["exchangeRate"]
+      @exchange_rate = exchange_rate.is_a?(Integer) || exchange_rate.is_a?(Float) ? exchange_rate.to_f : 0.0
+      @valid_until = Internal::Coerce.string(data["validUntil"]) || ""
+      @declaration_text = Internal::Coerce.string(data["declarationText"]) || ""
+      @european_economic_area = Internal::Coerce.boolean(data["europeanEconomicArea"])
+      @markup = Internal::Coerce.list(data["markup"]).map { |markup| DccMarkup.from_api(markup) }
+      freeze
+    end
+
+    def european_economic_area?
+      @european_economic_area
+    end
+
+    private
+
+    def currency(value)
+      Currency.valid?(value) ? value : Currency::PLN
+    end
+  end
+end

data/lib/dpay/card/google_pay_request.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DPay
+  class GooglePayRequest
+    def self.create(token, device_info)
+      new(token, device_info)
+    end
+
+    def initialize(token, device_info)
+      @token = token
+      @device_info = device_info
+      @leading = {}
+    end
+
+    def with_email(email)
+      @leading["email"] = email
+      self
+    end
+
+    def with_channel_id(channel_id)
+      @leading["channelId"] = channel_id
+      self
+    end
+
+    def to_body
+      body = {}
+      %w[email channelId].each { |key| body[key] = @leading[key] if @leading.key?(key) }
+      body["xPayType"] = "GOOGLE_PAY"
+      body["xPayToken"] = @token
+      body["deviceInfo"] = @device_info.to_h
+
+      body
+    end
+  end
+end

data/lib/dpay/card/redirect_type.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DPay
+  module RedirectType
+    SUCCESS = "SUCCESS"
+    FORM = "FORM"
+    URL = "URL"
+    DCC_OFFER = "DCC_OFFER"
+
+    ALL = [SUCCESS, FORM, URL, DCC_OFFER].freeze
+
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+
+    def self.assert_valid(value)
+      raise InvalidArgumentError, %(Invalid redirect type "#{value}") unless valid?(value)
+    end
+  end
+end

data/lib/dpay/client.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DPay
+  class Client
+    VERSION = DPay::VERSION
+
+    attr_reader :config, :payments, :refunds, :banks, :blik, :cards, :payouts
+
+    def initialize(service:, secret_hash:, timeout: Config::DEFAULT_TIMEOUT, http_client: nil, base_urls: nil)
+      @config = Config.new(
+        service: service, secret_hash: secret_hash, timeout: timeout,
+        http_client: http_client, base_urls: base_urls
+      )
+
+      api = Internal::ApiRequestor.new(@config, @config.http_client || HTTP::NetHTTPClient.new(@config.timeout))
+
+      @payments = PaymentService.new(api)
+      @refunds = RefundService.new(api)
+      @banks = BankService.new(api)
+      @blik = BlikService.new(api)
+      @cards = CardService.new(api)
+      @payouts = PayoutService.new(api)
+      freeze
+    end
+  end
+end

data/lib/dpay/config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module DPay
+  class Config
+    DEFAULT_TIMEOUT = 30
+
+    attr_reader :service, :secret_hash, :timeout, :http_client, :base_urls
+
+    def initialize(service:, secret_hash:, timeout: DEFAULT_TIMEOUT, http_client: nil, base_urls: nil)
+      @service = non_empty_string(service, "service")
+      @secret_hash = non_empty_string(secret_hash, "secret_hash")
+      @timeout = positive_integer(timeout)
+      @http_client = transport(http_client)
+      @base_urls = Internal::BaseUrls.new(base_urls || {})
+      freeze
+    end
+
+    private
+
+    def non_empty_string(value, name)
+      raise InvalidArgumentError, "#{name} must be a non-empty String" unless value.is_a?(String) && !value.empty?
+
+      value
+    end
+
+    def positive_integer(value)
+      raise InvalidArgumentError, "timeout must be an Integer >= 1" unless value.is_a?(Integer) && value >= 1
+
+      value
+    end
+
+    def transport(value)
+      return nil if value.nil?
+      raise InvalidArgumentError, "http_client must respond to #request" unless value.respond_to?(:request)
+
+      value
+    end
+  end
+end

data/lib/dpay/currency.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DPay
+  module Currency
+    PLN = "PLN"
+    EUR = "EUR"
+    CZK = "CZK"
+
+    CODE = /\A[A-Z]{3}\z/
+
+    def self.valid?(code)
+      code.is_a?(String) && CODE.match?(code)
+    end
+
+    def self.assert_valid(code)
+      raise InvalidArgumentError, %(Invalid currency code "#{code}") unless valid?(code)
+    end
+  end
+end