dpay 0.1.0

data/lib/dpay/money.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module DPay
+  class Money
+    DECIMAL = /\A(-?)(\d+)(?:\.(\d{1,2}))?\z/
+
+    attr_reader :minor, :currency
+
+    def self.pln(minor)
+      new(minor, Currency::PLN)
+    end
+
+    def self.of(minor, currency)
+      Currency.assert_valid(currency)
+      new(minor, currency)
+    end
+
+    def self.from_decimal(decimal, currency)
+      Currency.assert_valid(currency)
+      parsed = parse_decimal(decimal)
+      raise InvalidArgumentError, %(Invalid money amount "#{decimal}") if parsed.nil?
+
+      new(parsed, currency)
+    end
+
+    def self.from_api_number(value, currency)
+      case value
+      when Integer then of(value * 100, currency)
+      when Float then of(Internal::PHP.round(value * 100), currency)
+      when String then from_decimal(value, currency)
+      else raise InvalidArgumentError, "Money value must be Integer, Float or String"
+      end
+    end
+
+    def self.try_from_api_number(value, currency)
+      return nil unless Currency.valid?(currency)
+
+      case value
+      when Integer then new(value * 100, currency)
+      when Float then new(Internal::PHP.round(value * 100), currency)
+      when String
+        parsed = parse_decimal(value)
+        parsed.nil? ? nil : new(parsed, currency)
+      end
+    end
+
+    def self.parse_decimal(decimal)
+      match = DECIMAL.match(decimal.to_s)
+      return nil if match.nil?
+
+      minor = (match[2].to_i * 100) + (match[3] || "").ljust(2, "0").to_i
+      match[1] == "-" ? -minor : minor
+    end
+    private_class_method :parse_decimal
+
+    def initialize(minor, currency)
+      @minor = minor
+      @currency = currency
+      freeze
+    end
+
+    def to_decimal
+      absolute = @minor.abs
+      sign = @minor.negative? ? "-" : ""
+      format("%<sign>s%<dollars>d.%<cents>02d", sign: sign, dollars: absolute / 100, cents: absolute % 100)
+    end
+
+    def negative?
+      @minor.negative?
+    end
+
+    def ==(other)
+      other.is_a?(Money) && other.minor == @minor && other.currency == @currency
+    end
+    alias eql? ==
+
+    def hash
+      [@minor, @currency].hash
+    end
+
+    def to_s
+      "#{to_decimal} #{@currency}"
+    end
+  end
+end

data/lib/dpay/payment/device_info.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DPay
+  class DeviceInfo
+    def self.create(browser_accept_header:, browser_language:, browser_color_depth:, browser_screen_height:,
+                    browser_screen_width:, browser_tz:, browser_user_agent:, system_family:, geo_localization:,
+                    device_id:, application_name:)
+      new(
+        { "browserAcceptHeader" => browser_accept_header, "browserLanguage" => browser_language,
+          "browserColorDepth" => browser_color_depth, "browserScreenHeight" => browser_screen_height,
+          "browserScreenWidth" => browser_screen_width, "browserTZ" => browser_tz,
+          "browserUserAgent" => browser_user_agent, "systemFamily" => system_family,
+          "geoLocalization" => geo_localization, "deviceID" => bounded(device_id, "Device ID"),
+          "applicationName" => bounded(application_name, "Application name") }
+      )
+    end
+
+    def self.bounded(value, label)
+      raise InvalidArgumentError, "#{label} must be 1-64 characters" unless value.is_a?(String) &&
+                                                                            !value.empty? && value.length <= 64
+
+      value
+    end
+    private_class_method :bounded
+
+    def initialize(fields)
+      @fields = fields
+      @browser_java_enabled = nil
+    end
+
+    def with_browser_java_enabled(enabled)
+      @browser_java_enabled = enabled
+      self
+    end
+
+    def to_h
+      data = @fields.dup
+      data["browserJavaEnabled"] = @browser_java_enabled ? "true" : "false" unless @browser_java_enabled.nil?
+      data
+    end
+  end
+end

data/lib/dpay/payment/invoice_details.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module DPay
+  class InvoiceDetails
+    DATE = /\A\d{4}-\d{2}-\d{2}\z/
+
+    def self.create
+      new
+    end
+
+    def initialize
+      @data = {}
+    end
+
+    def with_payer_nip(payer_nip)
+      @data["payer_nip"] = payer_nip
+      self
+    end
+
+    def with_payer_name(payer_name)
+      @data["payer_name"] = payer_name
+      self
+    end
+
+    def with_invoice_number(invoice_number)
+      @data["invoice_number"] = invoice_number
+      self
+    end
+
+    def with_payment_due_date(payment_due_date)
+      unless payment_due_date.is_a?(String) && DATE.match?(payment_due_date)
+        raise InvalidArgumentError, "Payment due date must be in YYYY-MM-DD format"
+      end
+
+      @data["payment_due_date"] = payment_due_date
+      self
+    end
+
+    def with_vat_amount(vat_amount)
+      @data["vat_amount"] = vat_amount.minor
+      self
+    end
+
+    def to_h
+      @data.dup
+    end
+  end
+end

data/lib/dpay/payment/payer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DPay
+  class Payer
+    EMAIL = /\A[^@\s]+@[^@\s]+\.[^@\s]+\z/
+
+    attr_reader :email, :first_name, :last_name
+
+    def self.create
+      new
+    end
+
+    def with_email(email)
+      raise InvalidArgumentError, %(Invalid email "#{email}") unless email.is_a?(String) && EMAIL.match?(email)
+
+      @email = email
+      self
+    end
+
+    def with_name(first_name, last_name)
+      @first_name = first_name
+      @last_name = last_name
+      self
+    end
+  end
+end

data/lib/dpay/payment/payment_service.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module DPay
+  class PaymentService
+    def initialize(api)
+      @api = api
+    end
+
+    def register(request)
+      body = request.to_body(@api.service)
+      body["checksum"] = @api.checksum.secret_second(
+        @api.service,
+        [body["value"], body["url_success"], body["url_fail"], body["url_ipn"]]
+      )
+
+      data = @api.post_json(Internal::BaseUrls::API_PAYMENTS, "/api/v1_0/payments/register", body)
+      raise PaymentRejectedError.from_api(data) if rejected?(data)
+
+      RegisteredPayment.from_api(data)
+    end
+
+    def details(transaction_id)
+      body = { "service" => @api.service, "transaction_id" => transaction_id }
+      body["checksum"] = @api.checksum.ordered_body(body.values)
+
+      Transaction.from_api(@api.post_json(Internal::BaseUrls::PANEL, "/api/v1/pbl/details", body))
+    end
+
+    private
+
+    def rejected?(data)
+      data["error"] == true || data["status"] == false
+    end
+  end
+end

data/lib/dpay/payment/payout_fee_mode.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DPay
+  module PayoutFeeMode
+    NET = "net"
+    GROSS = "gross"
+
+    ALL = [NET, GROSS].freeze
+
+    def self.valid?(value)
+      ALL.include?(value)
+    end
+
+    def self.assert_valid(value)
+      raise InvalidArgumentError, %(Invalid payout fee mode "#{value}") unless valid?(value)
+    end
+  end
+end

data/lib/dpay/payment/payout_instruction.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module DPay
+  class PayoutInstruction
+    def self.create(positions, fee_mode = PayoutFeeMode::NET)
+      new(positions, fee_mode)
+    end
+
+    def initialize(positions, fee_mode = PayoutFeeMode::NET)
+      raise InvalidArgumentError, "Payout instruction requires at least one position" if positions.empty?
+      unless positions.all?(PayoutPosition)
+        raise InvalidArgumentError, "Positions must be DPay::PayoutPosition instances"
+      end
+
+      PayoutFeeMode.assert_valid(fee_mode)
+
+      @positions = positions.dup.freeze
+      @fee_mode = fee_mode
+      freeze
+    end
+
+    def to_h
+      { "fee_mode" => @fee_mode, "positions" => @positions.map(&:to_h) }
+    end
+  end
+end

data/lib/dpay/payment/payout_position.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DPay
+  class PayoutPosition
+    attr_reader :iban, :title, :amount
+
+    def initialize(iban, title, amount)
+      raise InvalidArgumentError, "Payout IBAN must not be empty" unless iban.is_a?(String) && !iban.empty?
+      unless title.is_a?(String) && !title.empty? && title.length <= 255
+        raise InvalidArgumentError, "Payout title must be 1-255 characters"
+      end
+
+      @iban = iban
+      @title = title
+      @amount = amount
+      freeze
+    end
+
+    def to_h
+      { "iban" => @iban, "title" => @title, "amount" => @amount.to_decimal.to_f }
+    end
+  end
+end

data/lib/dpay/payment/register_payment_request.rb

@@ -0,0 +1,246 @@
+# frozen_string_literal: true
+
+module DPay
+  class RegisterPaymentRequest
+    BLIK_CODE = /\A\d{6}\z/
+    PARTNER_PLATFORM = /\A[A-Z0-9]{1,64}\z/
+    HTTP_URL = %r{\Ahttps?://[^\s]+\z}
+    TOGGLES = { "creditcard" => :@credit_card, "paysafecard" => :@paysafecard, "blik" => :@blik,
+                "installment" => :@installment, "paypal" => :@paypal, "nobanks" => :@no_banks }.freeze
+
+    attr_reader :amount
+
+    def self.create(amount, transaction_type, urls)
+      new(amount, transaction_type, urls)
+    end
+
+    def initialize(amount, transaction_type, urls)
+      TransactionType.assert_valid(transaction_type)
+
+      @amount = amount
+      @transaction_type = transaction_type
+      @urls = urls
+      @optional = {}
+    end
+
+    def with_description(description)
+      set("description", description)
+    end
+
+    def with_custom(custom)
+      set("custom", custom)
+    end
+
+    def with_payer(payer)
+      @payer = payer
+      self
+    end
+
+    def with_accept_tos(accept_tos)
+      set("accept_tos", accept_tos)
+    end
+
+    def with_channel(channel)
+      set("channel", channel)
+    end
+
+    def with_credit_card(enabled)
+      @credit_card = enabled
+      self
+    end
+
+    def with_paysafecard(enabled)
+      @paysafecard = enabled
+      self
+    end
+
+    def with_blik(enabled)
+      @blik = enabled
+      self
+    end
+
+    def with_installment(enabled)
+      @installment = enabled
+      self
+    end
+
+    def with_paypal(enabled)
+      @paypal = enabled
+      self
+    end
+
+    def with_no_banks(disabled)
+      @no_banks = disabled
+      self
+    end
+
+    def with_phone_number(phone_number, currency_code)
+      Currency.assert_valid(currency_code)
+      set("phone_number", phone_number)
+      set("currency_code", currency_code)
+    end
+
+    def with_currency_code(currency_code)
+      Currency.assert_valid(currency_code)
+      set("currency_code", currency_code)
+    end
+
+    def with_partner_platform(partner_platform)
+      unless partner_platform.is_a?(String) && PARTNER_PLATFORM.match?(partner_platform)
+        raise InvalidArgumentError, "Partner platform must match ^[A-Z0-9]{1,64}$"
+      end
+
+      set("partner_platform", partner_platform)
+    end
+
+    def with_blik_code(blik_code, user_agent, user_ip)
+      raise InvalidArgumentError, "BLIK code must be exactly 6 digits" unless BLIK_CODE.match?(blik_code.to_s)
+      raise InvalidArgumentError, "blik_code cannot be combined with blik_alias" if @optional.key?("blik_alias")
+
+      set("blik_code", blik_code)
+      set("user_agent", user_agent)
+      set("user_ip", user_ip)
+    end
+
+    def with_blik_alias(alias_value, user_agent, user_ip)
+      if @optional.key?("blik_code") || @optional.key?("register_blik_alias") ||
+         @optional.key?("register_blik_recurring_alias")
+        raise InvalidArgumentError, "blik_alias cannot be combined with blik_code or alias registration"
+      end
+
+      set("blik_alias", alias_value)
+      set("user_agent", user_agent)
+      set("user_ip", user_ip)
+    end
+
+    def with_register_blik_alias(registration)
+      if @optional.key?("blik_alias")
+        raise InvalidArgumentError, "register_blik_alias cannot be combined with blik_alias"
+      end
+
+      set("register_blik_alias", registration.to_h)
+    end
+
+    def with_register_blik_recurring_alias(registration)
+      if @optional.key?("blik_alias")
+        raise InvalidArgumentError, "register_blik_recurring_alias cannot be combined with blik_alias"
+      end
+
+      set("register_blik_recurring_alias", registration.to_h)
+    end
+
+    def with_alias_ipn_url(url)
+      raise InvalidArgumentError, %(Invalid alias IPN URL "#{url}") unless url.is_a?(String) && HTTP_URL.match?(url)
+
+      set("alias_ipn_url", url)
+    end
+
+    def with_no_delay(no_delay)
+      set("no_delay", no_delay)
+    end
+
+    def with_card_recurring(registration)
+      if @optional.key?("card_recurring_alias")
+        raise InvalidArgumentError, "register_card_recurring cannot be combined with card_recurring_alias"
+      end
+
+      set("register_card_recurring", registration.to_h)
+    end
+
+    def with_card_recurring_alias(alias_value)
+      if @optional.key?("register_card_recurring")
+        raise InvalidArgumentError, "card_recurring_alias cannot be combined with register_card_recurring"
+      end
+
+      set("card_recurring_alias", alias_value)
+    end
+
+    def with_authorize_only(authorize_only)
+      set("authorize_only", authorize_only)
+    end
+
+    def with_card_recurring_operation(operation)
+      CardRecurringOperation.assert_valid(operation)
+      set("card_recurring_operation", operation)
+    end
+
+    def with_payout(payout)
+      set("payout", payout.to_h)
+    end
+
+    def with_billing_address(billing_address)
+      set("billing_address", billing_address)
+    end
+
+    def with_shipping_address(shipping_address)
+      set("shipping_address", shipping_address)
+    end
+
+    def with_device_info(device_info)
+      set("device_info", device_info.to_h)
+    end
+
+    def with_products(products)
+      set("products", products)
+    end
+
+    def with_efaktura(invoice = nil)
+      unless @transaction_type == TransactionType::TRANSFERS
+        raise InvalidArgumentError, %(efaktura is allowed only for transactionType "transfers")
+      end
+
+      set("efaktura", true)
+      invoice.nil? ? self : set("invoice", invoice.to_h)
+    end
+
+    def to_body(service)
+      body = {
+        "service" => service,
+        "value" => @amount.to_decimal,
+        "transactionType" => @transaction_type,
+        "url_success" => @urls.success,
+        "url_fail" => @urls.fail,
+        "url_ipn" => @urls.ipn
+      }
+
+      append(body, "description")
+      append(body, "custom")
+      append_payer(body)
+      append(body, "accept_tos")
+      append(body, "channel")
+      append_toggles(body)
+      %w[phone_number currency_code partner_platform user_agent user_ip blik_code blik_alias register_blik_alias
+         register_blik_recurring_alias alias_ipn_url no_delay register_card_recurring card_recurring_alias
+         authorize_only card_recurring_operation payout billing_address shipping_address device_info products
+         efaktura invoice].each { |key| append(body, key) }
+
+      body
+    end
+
+    private
+
+    def set(key, value)
+      @optional[key] = value
+      self
+    end
+
+    def append(body, key)
+      body[key] = @optional[key] if @optional.key?(key)
+    end
+
+    def append_payer(body)
+      return if @payer.nil?
+
+      body["email"] = @payer.email unless @payer.email.nil?
+      body["client_name"] = @payer.first_name unless @payer.first_name.nil?
+      body["client_surname"] = @payer.last_name unless @payer.last_name.nil?
+    end
+
+    def append_toggles(body)
+      TOGGLES.each do |key, variable|
+        flag = instance_variable_defined?(variable) ? instance_variable_get(variable) : nil
+        body[key] = flag ? 1 : 0 unless flag.nil?
+      end
+    end
+  end
+end

data/lib/dpay/payment/registered_payment.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module DPay
+  class RegisteredPayment
+    REDIRECT = %r{\Ahttps?://}
+    PAID = "Transaction paid"
+    INTERNAL_PROCESSING = "Internal processing"
+
+    attr_reader :transaction_id, :message, :ipksef, :raw
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @raw = data
+      @transaction_id = Internal::Coerce.string(data["transactionId"]) || ""
+      @message = Internal::Coerce.string(data["msg"]) || ""
+      @ipksef = data["ipksef"].is_a?(String) ? data["ipksef"] : nil
+      freeze
+    end
+
+    def redirect_url
+      REDIRECT.match?(@message) ? @message : nil
+    end
+
+    def paid?
+      @message == PAID
+    end
+
+    def internal_processing?
+      @message == INTERNAL_PROCESSING
+    end
+
+    def card_recurring_alias
+      additional = @raw["additionalInfo"]
+      return nil unless additional.is_a?(Hash) && additional["card_recurring_alias"].is_a?(String)
+
+      additional["card_recurring_alias"]
+    end
+  end
+end

data/lib/dpay/payment/return_urls.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DPay
+  class ReturnUrls
+    HTTP_URL = %r{\Ahttps?://[^\s]+\z}
+
+    attr_reader :success, :fail, :ipn
+
+    def initialize(success, fail, ipn)
+      { "success" => success, "fail" => fail, "ipn" => ipn }.each do |name, url|
+        raise InvalidArgumentError, %(Invalid #{name} URL "#{url}") unless url.is_a?(String) && HTTP_URL.match?(url)
+      end
+
+      @success = success
+      @fail = fail
+      @ipn = ipn
+      freeze
+    end
+  end
+end

data/lib/dpay/payment/transaction.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module DPay
+  class Transaction
+    attr_reader :id, :value, :status, :payment_method, :creation_date, :payment_date,
+                :refunded_amount, :available_refund_amount, :gateway_id, :payer, :refunds, :raw
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @raw = data
+      tx = data["transaction"].is_a?(Hash) ? data["transaction"] : {}
+
+      @id = Internal::Coerce.string(tx["id"]) || ""
+      @value = Internal::Coerce.money(tx["value"])
+      @status = Internal::Coerce.string(tx["status"]) || ""
+      @payment_method = Internal::Coerce.string(tx["payment_method"])
+      @creation_date = Internal::Coerce.string(tx["creation_date"])
+      @payment_date = tx["payment_date"].is_a?(String) ? tx["payment_date"] : nil
+      @settled = Internal::Coerce.boolean(tx["settled"])
+      @refunded = Internal::Coerce.boolean(tx["refunded"])
+      @refunded_amount = Internal::Coerce.money(tx["refunded_amount"])
+      @available_refund_amount = Internal::Coerce.money(tx["available_refund_amount"])
+      @fully_refunded = Internal::Coerce.boolean(tx["fully_refunded"])
+      @direct = Internal::Coerce.boolean(tx["direct"])
+      @gateway_id = tx["gateway_id"].is_a?(String) ? tx["gateway_id"] : nil
+      @payer = data["payer"].is_a?(Hash) ? data["payer"] : {}
+      @refunds = Internal::Coerce.list(data["refunds"]).map { |refund| TransactionRefund.from_api(refund) }
+      freeze
+    end
+
+    def paid?
+      @status == TransactionStatus::PAID || @status == TransactionStatus::CAPTURED
+    end
+
+    def settled?
+      @settled
+    end
+
+    def refunded?
+      @refunded
+    end
+
+    def fully_refunded?
+      @fully_refunded
+    end
+
+    def direct?
+      @direct
+    end
+  end
+end

data/lib/dpay/payment/transaction_refund.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module DPay
+  class TransactionRefund
+    attr_reader :payment_id, :value, :status, :creation_date, :payment_date, :raw
+
+    def self.from_api(data)
+      new(data)
+    end
+
+    def initialize(data)
+      @raw = data
+      @payment_id = Internal::Coerce.string(data["payment_id"]) || ""
+      @value = Internal::Coerce.money(data["value"])
+      @status = Internal::Coerce.string(data["status"]) || TransactionStatus::PAID
+      @creation_date = Internal::Coerce.string(data["creation_date"])
+      @payment_date = Internal::Coerce.string(data["payment_date"])
+      freeze
+    end
+  end
+end