zaala 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 23d2b71b2a1a767732f1e981ec456ee03d30dfa9aae6da0b331d7f19aee61050
+  data.tar.gz: 060b17d5d44dda277f3c463358f94083dc03e8f55ae75715ea13322b37298208
+SHA512:
+  metadata.gz: 91778343fc0ee1a12d34e217e72b6486330a4533d28fd0654a0a9ad900b12769731bcd88e453d49a48c17d7686201c148d1cb473abf46498ffb0d82186f1fa86
+  data.tar.gz: '085382d92b9b1e165d10e071fa1fe0fa5486c3024b8a8848b6074507ee5b775ed95e88437fda5b07e8dd34cc89a90bf58ff7aaf5f80e0b4de6c6b35cf1d02a4c'

data/lib/zaala/api/client.rb

@@ -0,0 +1,151 @@
+module Zaala::API
+  require 'savon'
+
+  require_relative "error"
+  require_relative "types"
+
+  class Client
+    # * *Args*    :
+    #   - +wsdl+ -> URL that points to the WSDL file
+    #   - +username+ -> Username (optional)
+    #   - +password+ -> Password (optional)
+    def initialize(wsdl:, username: '', password: '', log: false, proxy: nil)
+      symbolize_keys = lambda { |key| key.to_sym }
+      params = {
+        wsdl: wsdl,
+        open_timeout: 30, # in seconds
+        read_timeout: 30, # in seconds
+        convert_response_tags_to: symbolize_keys,
+        log: log,
+        proxy: proxy
+      }
+
+      @kar = if username != '' && password != ''
+        Savon.client(params.merge({
+          basic_auth: [username, password],
+        }))
+      else
+        Savon.client(params)
+      end
+    end
+
+    # Authenticate API calls
+    #
+    # * *Args*    :
+    #   - +username+ -> Username
+    #   - +password+ -> Password
+    def add_login_credentials(username, password)
+      @kar = Savon.client(wsdl: wsdl, basic_auth: [username, password])
+    end
+
+    # Authorizes a reservation of funds for a future purchase.
+    def pre_authorize(req)
+      ensure_operation_exists(:pre_authorize)
+      raise BadRequestError.new("pre_authorize operation requires an AuthorizationRequest parameter") unless req.is_a?(AuthorizationRequest)
+
+      @kar.call(:pre_authorize) do
+        message(authorizationRequest: req.to_message)
+      end
+    rescue Savon::SOAPFault => e
+      # IS0003
+      # TODO: Extract error code from response body
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Authorizes a purchase transaction.
+    def authorize(req)
+      ensure_operation_exists(:authorize)
+      raise BadRequestError.new("authorize operation requires an AuthorizationRequest parameter") unless req.is_a?(AuthorizationRequest)
+
+      res = @kar.call(:authorize) do
+        message(authorizationRequest: req.to_message)
+      end
+      AuthorizationResponse.from_message(res.body[:authorizeResponse][:return])
+    rescue Savon::SOAPFault => e
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Cancel a previous reservation of funds.
+    def cancel_authorization(req)
+      ensure_operation_exists(:cancel_authorization)
+      raise BadRequestError.new("cancel_authorization operation requires a CancellationRequest parameter") unless req.is_a?(CancellationRequest)
+
+      @kar.call(:cancel_authorization) do
+        message(cancellationRequest: req.to_message)
+      end
+    rescue Savon::SOAPFault => e
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Perform a solvency check.
+    def check(req)
+      ensure_operation_exists(:check)
+      raise BadRequestError.new("check operation requires a CheckRequest parameter") unless req.is_a?(CheckRequest)
+
+      @kar.call(:check) do
+        message(checkRequest: req.to_message)
+      end
+    rescue Savon::SOAPFault => e
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Returns available information about an authorization-ID.
+    def info(req)
+      ensure_operation_exists(:info)
+      raise BadRequestError.new("info operation requires an InfoRequest parameter") unless req.is_a?(InfoRequest)
+
+      @kar.call(:info) do
+        message(infoRequest: req.to_message)
+      end
+    rescue Savon::SOAPFault => e
+      # TODO: Extract error code from response body
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Verifies the given MTAN.
+    def verify(req)
+      ensure_operation_exists(:verify)
+      raise BadRequestError.new("info operation requires a VerifyRequest parameter") unless req.is_a?(VerifyRequest)
+
+      @kar.call(:verify) do
+        message(verifyRequest: req.to_message)
+      end
+    rescue Savon::SOAPFault => e
+      # TODO: Extract error code from response body
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Submits a purchase transaction with a previous authorization of funds.
+    def submit_authorization(req)
+      ensure_operation_exists(:submit_authorization)
+      raise BadRequestError.new("info operation requires a SubmissionRequest parameter") unless req.is_a?(SubmissionRequest)
+
+      res = @kar.call(:submit_authorization) do
+        message(submissionRequest: req.to_message)
+      end
+      SubmissionResponse.from_message(res.body[:submitAuthorizationResponse][:return])
+    rescue Savon::SOAPFault => e
+      # TODO: Extract error code from response body
+      # e.g. (The content of at least one field is invalid and did not pass the validation)
+      raise BadRequestError.new(e)
+    end
+
+    # Authorizes a credit transaction.
+    def credit_advice(req)
+      ensure_operation_exists(:credit_advice)
+      raise StandardError, 'unimplemented operation'
+    end
+
+    private
+
+    def ensure_operation_exists(op)
+      raise(UnsupportedServiceEndpoint, op) unless @kar.operations.include?(op)
+    end
+  end
+end

data/lib/zaala/api/error.rb

@@ -0,0 +1,19 @@
+module Zaala::API
+  class MissingError < StandardError
+  end
+  class BadRequestError < StandardError
+  end
+  class PermissionError < StandardError
+  end
+  class UnauthenticatedError < StandardError
+  end
+  class ConflictError < StandardError
+    # TODO: Add resource
+  end
+
+  class UnsupportedServiceEndpoint < StandardError
+    def initialize(op)
+      super("unsupported \"#{op}\" operation. Is it the correct WSDL file? This client supports KarApiV50.")
+    end
+  end
+end

data/lib/zaala/api/types.rb

@@ -0,0 +1,833 @@
+module Zaala::API
+  require 'dry-types'
+  require 'dry-struct'
+
+  module Types
+    include Dry.Types()
+  end
+
+  # The class ClientInfoEntry represents a key-value pair holding information of the service's client (e.g. IPv4 address).
+  class ClientInfo < Dry::Struct
+    # the IP v4 address of the end customer doing the ckeckout, if available
+    attribute :ipv4, Types::Strict::String.optional.default(nil)
+    # the IP v6 address of the end customer doing the ckeckout, if available
+    attribute :ipv6, Types::Strict::String.optional.default(nil)
+    # set to true if the integration supports the verification process
+    attribute :feature_mtan, Types::Strict::Bool.optional.default(nil)
+    # set to true if the integration supports the verification process
+    attribute :spec_version, Types::Strict::String.optional.default(nil)
+    # name of the implementor / integrator, e.g. Customweb, Datatrans, Manor, ...
+    attribute :impl_vendor, Types::Strict::String.optional.default(nil)
+    # version of the KaR API client implementation, e.g. "Magento/1.25.32"
+    attribute :impl_version, Types::Strict::String.optional.default(nil)
+  end
+
+  # The class RequestIdentifier contains data to determine the origin of a web service call.
+  class RequestIdentifier < Dry::Struct
+    # ID of the web shop. Min. value: 1
+    attribute :web_shop_id, Types::Strict::Integer
+    # Authorization type of the request. Field can't be null.
+    attribute :authorization_type, Types::Strict::String
+
+    # ID of a previous preAuthorization. Mandatory for the following transaction request types (IF0003):
+    # SubmissionRequest
+    # CreditRequest
+    # CancellationRequest
+    # InfoRequest
+    # VerifyRequest
+    attribute :authorization_id, Types::Strict::Integer.optional.default(nil)
+    # Unique identifier of the POS (Point Of Sale) within the web shop. Mandatory in case of a POS sale. (IF0004)
+    attribute :pos_id, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      RequestIdentifier.new({
+        web_shop_id: h[:webShopId],
+        authorization_type: h[:authorizationType],
+        authorization_id: h[:authorizationId],
+        pos_id: h[:posId],
+      })
+    end
+
+    def to_message
+      m = {
+        webShopId: web_shop_id,
+        authorizationType: authorization_type
+      }
+      m[:authorizationId] = authorization_id unless authorization_id.nil?
+      m[:posId] = pos_id unless pos_id.nil?
+      m
+    end
+  end
+
+  # The class PersonalData represents the detail information about the customer.
+  class PersonalData < Dry::Struct
+    # Type of the customer.
+    attribute :customer_type, Types::Strict::String
+    # Language of the customer.
+    attribute :language, Types::Strict::String
+
+    # The gender of the customer. Mandatory for country 'Private'. (IF0025)
+    attribute :gender, Types::Strict::String.optional.default(nil)
+    # Title of the customer.
+    attribute :title, Types::Strict::String.optional.default(nil)
+    # ID of the customer within the web shop.
+    attribute :customer_id, Types::Strict::String.optional.default(nil)
+    # First name of the customer. Mandatory for CustomerType 'Private'. (IF0020)
+    attribute :first_name, Types::Strict::String.optional.default(nil)
+    # Last name of the customer. Mandatory for CustomerType 'Private'. (IF0021)
+    attribute :name, Types::Strict::String.optional.default(nil)
+    # Customer's date of birth. Mandatory for CustomerType 'Private'.
+    # (IF0022) If so, it must contain a date between 12 and 120 years in the past. (IF0023)
+    attribute :date_of_birth, Types::Strict::Date.optional.default(nil)
+    # Fixnet phone number of the customer.
+    attribute :fixnet_phone_number, Types::Strict::String.optional.default(nil)
+    # Mobile phone number of the customer.
+    attribute :mobile_phone_number, Types::Strict::String.optional.default(nil)
+    # EMail address of the customer. Field must contain a valid email address.
+    attribute :email, Types::Strict::String.optional.default(nil)
+    # Company name. Mandatory for CustomerType 'Company'. (IF0018)
+    attribute :company_name, Types::Strict::String.optional.default(nil)
+    # Company account number.
+    attribute :company_number, Types::Strict::String.optional.default(nil)
+    # Company UID (https://www.uid.admin.ch).
+    attribute :company_uid, Types::Strict::String.optional.default(nil)
+    # Company legal form. Mandatory for CustomerType 'Company'. (IF0019)
+    attribute :company_legal_form, Types::Strict::String.optional.default(nil)
+    # Company legal form. Has to contain a value if member companyLegalForm equals 'other'.
+    # (IF0002) Mandatory for CustomerType 'Company'.
+    attribute :company_legal_form_other, Types::Strict::String.optional.default(nil)
+    # Company foundation date.
+    attribute :company_foundation_date, Types::Strict::Date.optional.default(nil)
+
+    def self.from_message(h)
+      PersonalData.new({
+        customer_type: h[:customerType],
+        language: h[:language],
+        gender: h[:gender],
+        title: h[:title],
+        customer_id: h[:customerID],
+        first_name: h[:firstName],
+        name: h[:name],
+        date_of_birth: h[:dateOfBirth],
+        fixnet_phone_number: h[:fixnetPhoneNumber],
+        mobile_phone_number: h[:mobilePhoneNumber],
+        email: h[:eMail],
+        company_name: h[:companyName],
+        company_number: h[:companyNumber],
+        company_uid: h[:companyUid],
+        company_legal_form: h[:companyLegalForm],
+        company_legal_form_other: h[:companyLegalFormOther],
+        company_foundation_date: h[:companyFoundationDate],
+      })
+    end
+
+    def to_message
+      m = {
+        customerType: customer_type,
+        language: language
+      }
+      m[:gender] = gender unless gender.nil?
+      m[:title] = title unless title.nil?
+      m[:customerID] = customer_id unless customer_id.nil?
+      m[:firstName] = first_name unless first_name.nil?
+      m[:name] = name unless name.nil?
+      m[:dateOfBirth] = date_of_birth unless date_of_birth.nil?
+      m[:fixnetPhoneNumber] = fixnet_phone_number unless fixnet_phone_number.nil?
+      m[:mobilePhoneNumber] = mobile_phone_number unless mobile_phone_number.nil?
+      m[:eMail] = email unless email.nil?
+      m[:companyName] = company_name unless company_name.nil?
+      m[:companyNumber] = company_number unless company_number.nil?
+      m[:companyUid] = company_uid unless company_uid.nil?
+      m[:companyLegalForm] = company_legal_form unless company_legal_form.nil?
+      m[:companyLegalFormOther] = company_legal_form_other unless company_legal_form_other.nil?
+      m[:companyFoundationDate] = company_foundation_date unless company_foundation_date.nil?
+      m
+    end
+  end
+
+  # The class InvoiceAddress represents the invoice address of a purchase.
+  class InvoiceAddress < Dry::Struct
+    # Country code according to [ISO3166-1_alpha-2] Field can't be blank.
+    attribute :country, Types::Strict::String
+    # City Field can't be blank.
+    attribute :city, Types::Strict::String
+    # ZipCode Field can't be blank.
+    attribute :zip_code, Types::Strict::String
+
+    # Additional address information (contact person or division).
+    attribute :address_add_on, Types::Strict::String.optional.default(nil)
+    # House number
+    attribute :house_number, Types::Strict::String.optional.default(nil)
+    # Street
+    attribute :street, Types::Strict::String.optional.default(nil)
+    # Additional street information.
+    attribute :street_extension, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      InvoiceAddress.new({
+        country: h[:country],
+        city: h[:city],
+        zip_code: h[:zipCode],
+        address_add_on: h[:addressAddOn],
+        house_number: h[:houseNumber],
+        street: h[:street],
+        street_extension: h[:streetExtension],
+      })
+    end
+
+    def to_message
+      m = {
+        country: country,
+        city: city,
+        zipCode: zip_code
+      }
+      m[:addressAddOn] = address_add_on unless address_add_on.nil?
+      m[:houseNumber] = house_number unless house_number.nil?
+      m[:street] = street unless street.nil?
+      m[:streetExtension] = street_extension unless street_extension.nil?
+      m
+    end
+  end
+
+  # The class DeliveryAddress represents the delivery address of a purchase.
+  class DeliveryAddress < Dry::Struct
+    # Country code according to [ISO3166-1_alpha-2] Field can't be blank.
+    attribute :country, Types::Strict::String
+    # City Field can't be blank.
+    attribute :city, Types::Strict::String
+    # ZipCode Field can't be blank.
+    attribute :zip_code, Types::Strict::String
+
+    # Additional address information (contact person or division).
+    attribute :address_add_on, Types::Strict::String.optional.default(nil)
+    # House number
+    attribute :house_number, Types::Strict::String.optional.default(nil)
+    # Street
+    attribute :street, Types::Strict::String.optional.default(nil)
+    # Additional street information.
+    attribute :street_extension, Types::Strict::String.optional.default(nil)
+    # Name of the company.
+    attribute :company_name, Types::Strict::String.optional.default(nil)
+    # Title of the goods receiving customer.
+    attribute :title, Types::Strict::String.optional.default(nil)
+    # First name of the goods receiving customer.
+    attribute :first_name, Types::Strict::String.optional.default(nil)
+    # Last name of the goods receiving customer.
+    attribute :name, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      DeliveryAddress.new({
+        country: h[:country],
+        city: h[:city],
+        zip_code: h[:zipCode],
+        address_add_on: h[:addressAddOn],
+        house_number: h[:houseNumber],
+        street: h[:street],
+        street_extension: h[:streetExtension],
+        company_name: h[:companyName],
+        title: h[:title],
+        first_name: h[:firstName],
+        name: h[:name],
+      })
+    end
+
+    def to_message
+      m = {
+        country: country,
+        city: city,
+        zipCode: zip_code
+      }
+      m[:addressAddOn] = address_add_on unless address_add_on.nil?
+      m[:houseNumber] = house_number unless house_number.nil?
+      m[:street] = street unless street.nil?
+      m[:streetExtension] = street_extension unless street_extension.nil?
+      m[:companyName] = company_name unless company_name.nil?
+      m[:title] = title unless title.nil?
+      m[:firstName] = first_name unless first_name.nil?
+      m[:name] = name unless name.nil?
+      m
+    end
+  end
+
+  class DetailRecord < Dry::Struct
+    # Quantity ordered. Decimal places: max. = 6
+    attribute :quantity, Types::Strict::Float
+    # Total amount of the product charged to the customer.
+    # This amount has to consider rebatePercentage, if given.
+    # Amount = AmountWithoutVat + VatAmount(IF0009)
+    # Amount = SingleArticleAmount * Quantity * (100% - RebatePercentage) (IF0026) Decimal places: max. = 2
+    attribute :amount, Types::Strict::Float
+    # Percentage value of the VAT. Allowed values: 0, 2.5, 3.7, 3.8, 7,7 and 8 (IF0012)
+    attribute :vat_percent, Types::Strict::Float
+    # Amount of the VAT. Decimal places: max. = 2
+    attribute :vat_amount, Types::Strict::Float
+    # Total amount of the product without VAT.
+    # AmountWithoutVat = SingleArticleAmountWithoutVat * Quantity * (100% - RebatePercentage) (IF0008)
+    # AmountWithoutVat ~= Amount / (100 + VatPercent) * 100
+    # VatAmount ~= Amount / (100 + VatPercent) * VatPercent(IF0011) Decimal places: max. = 2
+    attribute :amount_without_vat, Types::Strict::Float
+    # Product description. Field can't be blank.
+    attribute :product_text, Types::Strict::String
+
+    # Unique identifier of the product (e.g. Article number).
+    attribute :product_id, Types::Strict::String.optional.default(nil)
+    # Product category.
+    attribute :product_category, Types::Strict::String.optional.default(nil)
+    # Percentage value of the rebate given for this line item.
+    # This percentage is already reflected in amount.
+    # If given, and also singleArticleAmountWithoutVat is given, the following formula
+    # has to apply: AmountWithoutVat = SingleArticleAmountWithoutVat * Quantity * (100% - RebatePercentage) (IF0008)
+    # If given, and also singleArticleAmount is given, the following formula has to apply:
+    # Amount = SingleArticleAmount * Quantity * (100% - RebatePercentage) (IF0026) Range: min. = 0, max. = 100
+    attribute :rebate_percentage, Types::Strict::Float.optional.default(nil)
+    # Amount of a single product including VAT. Decimal places: max. = 6
+    attribute :single_article_amount, Types::Strict::Float.optional.default(nil)
+    # Amount of a single product without VAT. Decimal places: max. = 6
+    attribute :single_article_amount_without_vat, Types::Strict::Float.optional.default(nil)
+    # Identifies the type of the detail record line. Allows to distinguish between goods, fees, other payment means etc.
+    attribute :type, Types::Strict::String.optional.default(nil)
+    # Quantity related unit of the product (Pieces, Meters, Liters etc.).
+    attribute :quantity_unit, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      DetailRecord.new({
+        quantity: h[:quantity],
+        amount: h[:amount],
+        vat_percent: h[:vatPercent],
+        vat_amount: h[:vatAmount],
+        amount_without_vat: h[:amountWithoutVat],
+        product_text: h[:productText],
+        product_id: h[:productId],
+        product_category: h[:productCategory],
+        rebate_percentage: h[:rebatePercentage],
+        single_article_amount: h[:singleArticleAmount],
+        single_article_amount_without_vat: h[:singleArticleAmountWithoutVat],
+        type: h[:type],
+        quantity_unit: h[:quantityUnit],
+      })
+    end
+
+    def to_message
+      m = {
+        quantity: quantity,
+        amount: amount,
+        vatPercent: vat_percent,
+        vatAmount: vat_amount,
+        amountWithoutVat: amount_without_vat,
+        productText: product_text
+      }
+      m[:productId] = product_id unless product_id.nil?
+      m[:productCategory] = product_category unless product_category.nil?
+      m[:rebatePercentage] = rebate_percentage unless rebate_percentage.nil?
+      m[:singleArticleAmount] = single_article_amount unless single_article_amount.nil?
+      m[:singleArticleAmountWithoutVat] = single_article_amount_without_vat unless single_article_amount_without_vat.nil?
+      m[:type] = type unless type.nil?
+      m[:quantityUnit] = quantity_unit unless quantity_unit.nil?
+      m
+    end
+  end
+
+  # The Basket class contains all financial amounts and information about its products.
+  class Basket < Dry::Struct
+    # Goods total value minus other payment amounts.
+    # This amount is billed towards the end customer.
+    # If the basket has detailRecords, the sum of their amount fields has to be
+    # equal to the basket's amount + otherPaymentMeansAmount, and thus also equal
+    # to the basket's grossAmount. (IF0006) Decimal places: max. = 2
+    attribute :amount, Types::Strict::Float
+    # Currency of all amounts in the basket.
+    attribute :currency, Types::Strict::String.default('CHF'.freeze)
+    # Collection of the basket's records with detail information.
+    # At least one DetailRecord is mandatory for the following transaction request types (IF0024):
+    #  * SubmissionRequest
+    #  * CreditRequest
+    attribute :detail_records, Types::Strict::Array.of(DetailRecord)
+
+    # Total value of the purchase including otherPaymentMeansAmount.
+    # Field is optional, if otherPaymentMeansAmount is zero or left out.
+    # Consequently, if otherPaymentMeansAmount is set to any non-zero value,
+    # grossAmount is mandatory. grossAmount = amount + otherPaymentMeansAmount(IF0007) Decimal places: max. = 2
+    attribute :gross_amount, Types::Strict::Float.optional.default(nil)
+    # Already payed amount e.g. via gift card. If not set, assumed to be 0.
+    # If set to any other value than zero, then also grossAmount must be set correctly. Decimal places: max. = 2
+    attribute :other_payment_means_amount, Types::Strict::Float.optional.default(nil)
+    # Order number defined by the end customer.
+    # Can be useful e.g. for B2B customers in order to provide a reference number to
+    # theorder in the customer's finance department, for easier correlation.
+    # Length limited to 64 chars, rest will be truncated.
+    attribute :customer_order_number, Types::Strict::String.optional.default(nil)
+    # Order number. ID of the order on merchant side. Will be printed on the invoice t othe customer,
+    # and reported on the merchant statement. Length limited to 30 chars, rest will be truncated.
+    attribute :order_number, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      Basket.new({
+        amount: h[:amount],
+        currency: h[:amountCurrency],
+        detail_records: h[:detailRecords].map { |r| DetailRecord.from_message(r) },
+        gross_amount: h[:grossAmount],
+        other_payment_means_amount: h[:otherPaymentMeansAmount],
+        customer_order_number: h[:customerOrderNumber],
+        order_number: h[:orderNumber],
+      })
+    end
+
+    def to_message
+      m = {
+        amount: amount,
+        amountCurrency: currency,
+        detailRecords: detail_records.map(&:to_message)
+      }
+      m[:grossAmount] = gross_amount unless gross_amount.nil?
+      m[:otherPaymentMeansAmount] = other_payment_means_amount unless other_payment_means_amount.nil?
+      m[:customerOrderNumber] = customer_order_number unless customer_order_number.nil?
+      m[:orderNumber] = order_number unless order_number.nil?
+      m
+    end
+  end
+
+  class AdditionalData < Dry::Struct
+    # Describes requested method of payment. Field can't be null.
+    attribute :requested_payment_method, Types::Strict::String
+
+    # Describes the distribution channel of a purchase.
+    attribute :sales_channel, Types::Strict::String.optional.default(nil)
+    # Date of invoice (Submission date + X days).
+    attribute :invoice_date, Types::Strict::Integer.optional.default(nil)
+    # Free text field 1.
+    attribute :free_text1, Types::Strict::String.optional.default(nil)
+    # Free text field 2.
+    attribute :free_text2, Types::Strict::String.optional.default(nil)
+    # The preferred rate model, e.g. "3x3" or "4x12".
+    attribute :preferred_rate_model, Types::Strict::String.optional.default(nil)
+    # Allows to influence the behaviour of an authorization concerning risk taker shift.
+    attribute :risk_taker_shift, Types::Strict::String.optional.default(nil)
+    # Determines the delivery channel for the invoice. Replaces physicalInvoice flag.
+    # If invoiceChannel is set, physicalInvoice flag will be ignored, i.e. invoiceChannel takes precedence.
+    attribute :invoice_channel, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      AdditionalData.new({
+        requested_payment_method: h[:requestedPaymentMethod],
+        sales_channel: h[:salesChannel],
+        invoice_date: h[:invoiceDate],
+        free_text1: h[:freeText1],
+        free_text2: h[:freeText2],
+        preferred_rate_model: h[:preferredRateModel],
+        risk_taker_shift: h[:riskTakerShift],
+        invoice_channel: h[:invoiceChannel],
+      })
+    end
+
+    def to_message
+      m = {
+        requestedPaymentMethod: requested_payment_method,
+      }
+      m[:salesChannel] = sales_channel unless sales_channel.nil?
+      m[:invoiceDate] = invoice_date  unless invoice_date.nil?
+      m[:freeText1] = free_text1 unless free_text1.nil?
+      m[:freeText2] = free_text2 unless free_text2.nil?
+      m[:preferredRateModel] = preferred_rate_model unless preferred_rate_model.nil?
+      m[:riskTakerShift] = risk_taker_shift unless risk_taker_shift.nil?
+      m[:invoiceChannel] = invoice_channel unless invoice_channel.nil?
+      m
+    end
+  end
+
+  # Contains token information for authorizations with payment method ONACCOUNT.
+  class Token < Dry::Struct
+    # ID of the token. Field can't be blank.
+    attribute :id, Types::Strict::String
+    # Secret of the token. Also know as CVV. Field can't be blank.
+    attribute :secret, Types::Strict::String
+
+    # Expiration date of the token, in format 'YYYYMM'.
+    attribute :expiry_date, Types::Strict::String.optional.default(nil)
+
+    def self.from_message(h)
+      Token.new({
+        id: h[:tokenId],
+        secret: h[:tokenSecret],
+        expiry_date: h[:tokenExpiryDate],
+      })
+    end
+
+    def to_message
+      m = {
+        tokenId: id,
+        tokenSecret: secret,
+      }
+      m[:tokenExpiryDate] = expiry_date unless expiry_date.nil?
+      m
+    end
+  end
+
+  class Attachment < Dry::Struct
+    # Name of the attachment.
+    attribute :name, Types::Strict::String
+    # The mime type of the attachment.
+    attribute :mime_type, Types::Strict::String
+    # The content of the attachment (base64 encoded).
+    attribute :value, Types::Strict::String
+
+    def from_file
+    end
+
+    def self.from_message(h)
+      Attachment.new({
+        name: h[:name],
+        mime_type: h[:mimeType],
+        value: h[:value],
+      })
+    end
+
+    def to_message
+      {
+        name: name,
+        mimeType: mime_type,
+        value: value
+      }
+    end
+  end
+
+  class ResponseIdentifier < Dry::Struct
+    # Unique transaction id provided by the KaR system.
+    # With this id a specific request-response pair can be identified.
+    # This id is a valuable information for the KaR support team in case of a technical problem.
+    # Field can't be blank.
+    attribute :guardean_order_id, Types::Coercible::String
+    # Authorization id. Max. length of value is 30
+    attribute :authorization_id, Types::Coercible::Integer.optional.default(nil)
+
+    def self.from_message(h)
+      ResponseIdentifier.new({
+        guardean_order_id: h[:guardeanOrderId],
+        authorization_id: h[:authorizationId],
+      })
+    end
+  end
+
+  class Rate < Dry::Struct
+    # Amount of an installment.
+    attribute :amount, Types::Coercible::String
+    # Due date of the rate.
+    attribute :date, Types::Coercible::String
+    # Amount of interest.
+    attribute :interest_amount, Types::Coercible::String
+
+    def self.from_message(h)
+      Rate.new({
+        amount: h[:rateAmount],
+        date: h[:rateDate],
+        interest_amount: h[:interestAmount],
+      })
+    end
+  end
+
+  class InstallmentPlan < Dry::Struct
+    # Total amount of the installments including fees.
+    attribute :total_rate_amount, Types::Coercible::String
+    # Interest per annum.
+    attribute :interest_rate, Types::Coercible::String
+    # Date of the invoice.
+    attribute :billing_date, Types::Coercible::String
+    # Rate plan model, e.g. "3x3" or "4x12".
+    attribute :rate_model, Types::Coercible::String.optional.default(nil)
+    # Collection of the rates for the installments.
+    attribute :rates, Types::Coercible::Array.of(Rate).optional.default([].freeze)
+
+    def self.from_message(h)
+      InstallmentPlan.new({
+        total_rate_amount: h[:totalRateAmount],
+        interest_rate: h[:interestRate],
+        billing_date: h[:billingDate],
+        rate_model: h[:rateModel],
+        rates: h[:rates] ? h[:rates].map { |r| Rate.from_message(r) } : [],
+      })
+    end
+  end
+
+  class Info < Dry::Struct
+    # Current status of the transaction.
+    attribute :status, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :requested, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :valid_until, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :is_suitable_for_delivery, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :invoice_status, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :payment_status, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :dunning_level, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :current_balance, Types::Coercible::String.optional.default(nil)
+    # Current status of the transaction.
+    attribute :attachments, Types::Coercible::Array.of(Attachment).optional.default([].freeze)
+
+    # TODO: Enum?
+
+    def self.from_message(h)
+      Info.new({
+        status: h[:status],
+        requested: h[:requested],
+        valid_until: h[:validUntil],
+        is_suitable_for_delivery: h[:isSuitableForDelivery],
+        invoice_status: h[:invoiceStatus],
+        payment_status: h[:paymentStatus],
+        dunning_level: h[:dunningLevel],
+        current_balance: h[:currentBalance],
+        attachments: h[:attachments],
+      })
+    end
+  end
+
+  class Decision < Dry::Struct
+    # Indicates if the customer is allowed to pay its purchase by invoice.
+    attribute :invoice, Types::Coercible::String.optional.default(nil)
+    # Indicates if the customer is allowed to pay its purchase in installments.
+    attribute :installment, Types::Coercible::String.optional.default(nil)
+    # Indicates if the customer is allowed to pay its purchase by revolving account.
+    attribute :on_account, Types::Coercible::String.optional.default(nil)
+    # Indicates, who will take the financial risk of this transaction (see RiskTaker)
+    attribute :risk_taker, Types::Coercible::String.optional.default(nil)
+    # Only present in response of check operation. Indicates the result of the check.
+    attribute :traffic_light, Types::Coercible::String.optional.default(nil)
+
+    # TODO: Enum?
+
+    def self.from_message(h)
+      Decision.new({
+        invoice: h[:decisionInvoice],
+        installment: h[:decisionInstallment],
+        on_account: h[:decisionOnAccount],
+        risk_taker: h[:riskTaker],
+        traffic_light: h[:trafficLight],
+      })
+    end
+  end
+
+  # The AuthorizationRequest class represents the request parameter of the PreAuthorize and the Authorize service call.
+  # It contains all information needed to make a preauthorization/authorization.
+  class AuthorizationRequest < Dry::Struct
+    # Environment parameters and information to identify the caller.
+    attribute :identifier, Zaala::API::RequestIdentifier
+    # Personal data of the customer.
+    attribute :personal_data, Zaala::API::PersonalData
+    # Invoice address of the purchase.
+    attribute :invoice_address, Zaala::API::InvoiceAddress
+    # Additional purchase related information.
+    attribute :additional_data, Zaala::API::AdditionalData
+
+    # Key-value pairs holding information of the service's client (e.g. IPv4 address).
+    # attribute :client_info, Zaala::API::ClientInfo
+    # Requested amount of the preauthorization/authorization.
+    # It corresponds to the total amount, which has to be authorized.
+    # Mandatory if no Basket is provided in the request.
+    # (IF0001) If a Basket is provided in the request, this value is ignored.
+    attribute :requested_amount, Types::Strict::Float.optional.default(nil)
+    # Delivery address of the purchase.
+    attribute :delivery_address, Zaala::API::DeliveryAddress.optional.default(nil)
+    # Basket of the purchase. Mandatory if the requestdAmount is not provided in the request. (IF0001)
+    attribute :basket, Zaala::API::Basket.optional.default(nil)
+    #	Token for authorizations with payment method ONACCOUNT.
+    # Mandatory if the the requested PaymentMethod equals ONACCOUNT. (IF0033)
+    attribute :token, Zaala::API::Token.optional.default(nil)
+    # Allows to provide additional information for the KaR process.
+    attribute :attachments, Types::Strict::Array.of(Zaala::API::Attachment).optional.default([].freeze)
+
+    def to_message
+      m = {
+        identifier: identifier.to_message,
+        personalData: personal_data.to_message,
+        invoiceAddress: invoice_address.to_message,
+        additionalData: additional_data.to_message,
+      }
+      m[:requestedAmount] = requested_amount unless requested_amount.nil?
+      m[:deliveryAddress] = delivery_address unless delivery_address.nil?
+      m[:basket] = basket unless basket.nil?
+      m[:token] = token unless token.nil?
+      m[:attachments] = attachments.map(&:to_message) unless attachments.nil?
+      m
+    end
+  end
+
+  class AuthorizationResponse < Dry::Struct
+    # Contains information to identify the authorization in a future request.
+    attribute :identifier, Zaala::API::ResponseIdentifier
+    # Contains additional information concerning the authorization.
+    attribute :decision, Zaala::API::Decision
+
+    # Contains the details of the payment by installments.
+    attribute :installment_plan, Zaala::API::InstallmentPlan.optional.default(nil)
+    # Contains additional information concerning the authorization.
+    attribute :info, Zaala::API::Info.optional.default(nil)
+
+    def self.from_message(h)
+      AuthorizationResponse.new({
+        identifier: Zaala::API::ResponseIdentifier.from_message(h[:identifier]),
+        decision: Zaala::API::Decision.from_message(h[:decision]),
+        installment_plan: h[:installmentPlan] ? Zaala::API::InstallmentPlan.from_message(h[:installmentPlan]) : nil,
+        info: h[:info] ? Zaala::API::Info.from_message(h[:info]) : nil,
+      })
+    end
+  end
+
+  # The SubmissionRequest class represents the request parameter of the SubmitAuthorization service call.
+  # It contains all information needed to submit a previous authorization and triggering the issuing of the invoice.
+  class SubmissionRequest < Dry::Struct
+    # Key-value pairs holding information of the service's client (e.g. IPv4 address).
+    # attribute :client_info, []ClientInfo
+
+    # Environment parameters and information to identify the caller.
+    attribute :identifier, Zaala::API::RequestIdentifier
+    # Basket of the purchase. Mandatory if the requestdAmount is not provided in the request. (IF0001)
+    attribute :basket, Zaala::API::Basket
+    # Additional purchase related information.
+    attribute :additional_data, Zaala::API::AdditionalData
+    # Allows to provide additional information for the KaR process.
+    attribute :attachments, Types::Strict::Array.of(Zaala::API::Attachment).optional.default([].freeze)
+
+    def to_message
+      {
+        identifier: identifier.to_message,
+        basket: basket.to_message,
+        additionalData: additional_data.to_message,
+        attachments: attachments.map(&:to_message),
+      }
+    end
+  end
+
+  class SubmissionResponse < Dry::Struct
+    # Contains information to identify the authorization in a future request.
+    attribute :identifier, Zaala::API::ResponseIdentifier
+    # Contains additional information concerning the authorization.
+    attribute :decision, Zaala::API::Decision
+
+    # Contains the details of the payment by installments.
+    attribute :installment_plan, Zaala::API::InstallmentPlan.optional.default(nil)
+    # Contains additional information concerning the authorization.
+    attribute :info, Zaala::API::Info.optional.default(nil)
+
+    def self.from_message(h)
+      SubmissionResponse.new({
+        identifier: Zaala::API::ResponseIdentifier.from_message(h[:identifier]),
+        decision: Zaala::API::Decision.from_message(h[:decision]),
+        installment_plan: h[:installmentPlan] ? Zaala::API::InstallmentPlan.from_message(h[:installmentPlan]) : nil,
+        info: h[:info] ? Zaala::API::Info.from_message(h[:info]) : nil,
+      })
+    end
+  end
+
+  # The CancellationRequest class represents the request parameter of the CancelAuthorization service call.
+  # It contains all information needed to cancel an previous authorization.
+  class CancellationRequest < Dry::Struct
+    # Key-value pairs holding information of the service's client (e.g. IPv4 address).
+    # attribute :client_info, []ClientInfo
+    # Environment parameters and information to identify the caller.
+    attribute :identifier, Zaala::API::RequestIdentifier
+
+    def to_message
+      {
+        identifier: identifier.to_message,
+      }
+    end
+  end
+
+  class CancellationResponse < Dry::Struct
+    # Contains information to identify the authorization in a future request.
+    attribute :identifier, Zaala::API::ResponseIdentifier
+
+    # Contains additional information concerning the authorization.
+    attribute :info, Zaala::API::Info.optional.default(nil)
+
+    def self.from_message(h)
+      CancellationResponse.new({
+        identifier: Zaala::API::ResponseIdentifier.from_message(h[:identifier]),
+        info: h[:info] ? Zaala::API::Info.from_message(h[:info]) : nil,
+      })
+    end
+  end
+
+  # The InfoRequest class represents the request parameter of the Info service call.
+  # It contains all information needed to retrieve all available information about an authorization-id.
+  class InfoRequest < Dry::Struct
+    # Key-value pairs holding information of the service's client (e.g. IPv4 address).
+    # attribute :client_info, []ClientInfo
+    # Environment parameters and information to identify the caller.
+    attribute :identifier, Zaala::API::RequestIdentifier
+
+    def to_message
+      {
+        identifier: identifier.to_message,
+      }
+    end
+  end
+
+  # The class InfoResponse represents the response of the Info service call.
+  class InfoResponse < Dry::Struct
+    # Contains information to identify the authorization in a future request.
+    attribute :identifier, Zaala::API::ResponseIdentifier
+    # Contains additional information concerning the authorization.
+    attribute :decision, Zaala::API::Decision
+
+    # Contains additional information concerning the authorization.
+    attribute :info, Zaala::API::Info.optional.default(nil)
+    # Contains the details of the payment by installments.
+    attribute :installment_plan, Zaala::API::InstallmentPlan.optional.default(nil)
+
+    def self.from_message(h)
+      InfoResponse.new({
+        identifier: Zaala::API::ResponseIdentifier.from_message(h[:identifier]),
+        decision: Zaala::API::Decision.from_message(h[:decision]),
+        installment_plan: h[:installmentPlan] ? Zaala::API::InstallmentPlan.from_message(h[:installmentPlan]) : nil,
+        info: h[:info] ? Zaala::API::Info.from_message(h[:info]) : nil,
+      })
+    end
+  end
+
+  # The VerifyRequest class represents the request parameter of the Verify service call.
+  # It contains all information needed to verify an authorization with an MTAN.
+  class VerifyRequest < Dry::Struct
+    # Key-value pairs holding information of the service's client (e.g. IPv4 address).
+    # attribute :client_info, []ClientInfo
+    # Environment parameters and information to identify the caller.
+    attribute :identifier, Zaala::API::RequestIdentifier
+    # Additional purchase related information.
+    attribute :additional_data, Zaala::API::AdditionalData
+    # The verificationCode value to check against.
+    attribute :verification_code, Types::Strict::String
+
+    def to_message
+      {
+        identifier: identifier.to_message,
+        additionalData: additional_data.to_message,
+        verificationCode: verification_code,
+      }
+    end
+  end
+
+  # The class VerifyResponse represents the response of the Verify service call.
+  class VerifyResponse < Dry::Struct
+    # Contains information to identify the authorization in a future request.
+    attribute :identifier, Zaala::API::ResponseIdentifier
+    # Contains additional information concerning the authorization.
+    attribute :decision, Zaala::API::Decision
+
+    # Contains additional information concerning the authorization.
+    attribute :info, Zaala::API::Info.optional.default(nil)
+    # Contains the details of the payment by installments.
+    attribute :installment_plan, Zaala::API::InstallmentPlan.optional.default(nil)
+
+    def self.from_message(h)
+      VerifyResponse.new({
+        identifier: Zaala::API::ResponseIdentifier.from_message(h[:identifier]),
+        decision: Zaala::API::Decision.from_message(h[:decision]),
+        installment_plan: h[:installmentPlan] ? Zaala::API::InstallmentPlan.from_message(h[:installmentPlan]) : nil,
+        info: h[:info] ? Zaala::API::Info.from_message(h[:info]) : nil,
+      })
+    end
+  end
+end

data/lib/zaala/api.rb

@@ -0,0 +1,5 @@
+module Zaala::API
+  require 'zaala/api/error'
+  require 'zaala/api/types'
+  require 'zaala/api/client'
+end

data/lib/zaala.rb

@@ -0,0 +1,3 @@
+module Zaala
+  require 'zaala/api'
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: zaala
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Denteo AG
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: savon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+description: Ruby client interacting with Zaala
+email: simon@denteo.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/zaala.rb
+- lib/zaala/api.rb
+- lib/zaala/api/client.rb
+- lib/zaala/api/error.rb
+- lib/zaala/api/types.rb
+homepage: https://rubygems.org/gems/zaala
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Ruby client interacting with Zaala
+test_files: []