ksef-client-rails 0.1.0 → 1.0.0

data/lib/ksef/invoices/builder.rb

@@ -0,0 +1,251 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "date"
+require "nokogiri"
+require "ksef/invoices/builder/checks"
+require "ksef/invoices/builder/number"
+
+module Ksef
+  module Invoices
+    # Builds an FA(3) invoice: parties, lines with their VAT rates, payment, annotations, a correction,
+    # footer. Elements follow the schema sequence; the summary per rate is computed from the lines, and
+    # input the builder cannot render correctly is refused with ConfigurationError rather than guessed.
+    class Builder
+      include Checks
+
+      # Rate (the `P_12` value) → its summary fields and percentage, in schema order. Rates without VAT
+      # have no `P_14_x` field.
+      RATES = {
+        "23" => { net: "P_13_1", vat: "P_14_1", percent: 23 },
+        "8" => { net: "P_13_2", vat: "P_14_2", percent: 8 },
+        "5" => { net: "P_13_3", vat: "P_14_3", percent: 5 },
+        "0 KR" => { net: "P_13_6_1", percent: 0 },
+        "0 WDT" => { net: "P_13_6_2", percent: 0 },
+        "0 EX" => { net: "P_13_6_3", percent: 0 },
+        "zw" => { net: "P_13_7", percent: 0 },
+        "np I" => { net: "P_13_8", percent: 0 },
+        "np II" => { net: "P_13_9", percent: 0 },
+        "oo" => { net: "P_13_10", percent: 0 }
+      }.freeze
+
+      # `FormaPlatnosci` codes; a symbol may stand for the code.
+      PAYMENT_METHODS = { cash: "1", card: "2", voucher: "3", cheque: "4", credit: "5", transfer: "6",
+                          mobile: "7" }.freeze
+
+      # `Adnotacje` flags set to 1 by {#annotations}; every other one is 2. `reverse_charge` is also set
+      # by an `oo` or `np II` line, and `P_19` (exemption) by a `zw` line.
+      ANNOTATIONS = { cash_method: "P_16", self_billing: "P_17", reverse_charge: "P_18", split_payment: "P_18A",
+                      triangular: "P_23" }.freeze
+
+      # Rates whose tax the buyer settles (`P_18` = 1).
+      REVERSE_CHARGE_RATES = ["oo", "np II"].freeze
+
+      INVOICE_TYPES = %w[VAT KOR].freeze
+      CORRECTION_TYPES = %w[1 2 3].freeze
+      GTU_CODES = (1..13).map { |i| format("GTU_%02d", i) }.freeze
+
+      # Code formats; the schema's enumerations are checked when the XML is validated.
+      COUNTRY = /\A[A-Z]{2}\z/
+      CURRENCY = /\A[A-Z]{3}\z/
+      # Characters XML 1.0 does not allow.
+      XML_DISALLOWED = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\uFFFE\uFFFF]/
+
+      # `Podmiot2/DaneIdentyfikacyjne`: a Polish NIP, an EU VAT number, another tax ID, or none (a consumer).
+      BUYER_ID_TYPES = %w[nip eu other none].freeze
+
+      PARTY_FIELDS = %i[nip name address country email phone id_type eu_code vat_eu id_number].freeze
+      LINE_FIELDS = %i[name unit quantity unit_price rate index gtin pkwiu cn gtu discount].freeze
+
+      # A seller or buyer. `id_type` (one of {BUYER_ID_TYPES}) applies to the buyer; without it a party
+      # with a NIP is identified by it, one without by none.
+      Party = Struct.new(*PARTY_FIELDS, keyword_init: true) do
+        # @return [String] one of {BUYER_ID_TYPES}
+        def identification
+          return id_type.to_s if BUYER_ID_TYPES.include?(id_type.to_s)
+
+          nip.to_s.strip.empty? ? "none" : "nip"
+        end
+      end
+
+      # An invoice line. `quantity` and `unit_price` are required; numbers are Integers, BigDecimals or
+      # Strings with a comma or a dot ("1234,56", "1 234,56"). Prices and discounts take at most 2 decimal
+      # places, quantities 6; anything else raises ConfigurationError.
+      Line = Struct.new(*LINE_FIELDS, keyword_init: true) do
+        # @return [BigDecimal] quantity × net price, minus a discount not already in the price (`P_10`)
+        # @raise [Ksef::ConfigurationError] for a missing or malformed number
+        def net
+          value = number(:quantity) * number(:unit_price)
+          value -= number(:discount) if discount?
+          value.round(2, BigDecimal::ROUND_HALF_UP)
+        end
+
+        # @return [Boolean] whether the line has a discount (`P_10`)
+        def discount?
+          !discount.nil? && !discount.to_s.strip.empty?
+        end
+
+        # @api private
+        # @param field [Symbol] :quantity, :unit_price or :discount
+        # @return [BigDecimal]
+        # @raise [Ksef::ConfigurationError]
+        def number(field)
+          Number.parse(public_send(field), field.to_s, places: field == :quantity ? 6 : 2)
+        end
+      end
+
+      ATTRIBUTES = %i[number issue_date sale_date place currency seller buyer lines payment_method due_date
+                      bank_account bank_name paid paid_date exemption_reason invoice_type correction_reason
+                      correction_type corrected_date corrected_number corrected_ksef_number annotations footer
+                      krs regon bdo system_info].freeze
+
+      # @!attribute [rw] number
+      #   @return [String] invoice number (`P_2`); KSeF refuses a second invoice with the same seller NIP,
+      #   invoice type and number
+      # @!attribute [rw] seller
+      #   @return [Party] `Podmiot1` — the session's context needs the permission to invoice for its NIP
+      # @!attribute [rw] lines
+      #   @return [Array<Line>]
+      attr_accessor(*(ATTRIBUTES - %i[seller buyer lines]))
+      attr_reader :seller, :buyer, :lines
+
+      # @param attributes [Hash] any of {ATTRIBUTES}: `seller:`/`buyer:` as a Hash or {Party}, `lines:` as
+      #   Hashes or {Line}s, dates as Date or "YYYY-MM-DD", `annotations:` as keys of {ANNOTATIONS},
+      #   `payment_method:` as a code or a key of {PAYMENT_METHODS}, `invoice_type:` "VAT" (default) or "KOR".
+      #   A KOR's lines are the change: the totals are summed from them, so give difference rows (e.g.
+      #   quantity 2 at -10.00 for a 20.00 reduction) or the original row negated plus the corrected row.
+      # @raise [Ksef::ConfigurationError] for an unknown attribute
+      def initialize(**attributes)
+        unknown = attributes.keys - ATTRIBUTES
+        raise ConfigurationError, "Unknown invoice attribute(s): #{unknown.join(', ')}" unless unknown.empty?
+
+        attributes.each { |name, value| public_send(:"#{name}=", value) }
+        self.currency = "PLN" if blank?(currency)
+        self.lines ||= []
+        self.annotations ||= []
+        self.invoice_type = "VAT" if blank?(invoice_type)
+        self.system_info ||= "ksef-client-rails"
+      end
+
+      # @param value [Hash, Party]
+      def seller=(value)
+        @seller = party(value)
+      end
+
+      # @param value [Hash, Party]
+      def buyer=(value)
+        @buyer = party(value)
+      end
+
+      # @param value [Array<Hash, Line>]
+      def lines=(value)
+        @lines = Array(value).map { |line| line.is_a?(Line) ? line : line(line) }
+      end
+
+      # @return [Hash{String=>Hash}] rate => { net:, vat: } for the rates in use
+      def totals_by_rate
+        lines.group_by(&:rate).to_h do |rate, group|
+          net = group.sum(BigDecimal("0"), &:net)
+          [rate, { net: net, vat: (net * rate_fields(rate)[:percent] / 100).round(2, BigDecimal::ROUND_HALF_UP) }]
+        end
+      end
+
+      # @return [BigDecimal]
+      def net_total = totals_by_rate.values.sum(BigDecimal("0")) { |t| t[:net] }
+      # @return [BigDecimal]
+      def vat_total = totals_by_rate.values.sum(BigDecimal("0")) { |t| t[:vat] }
+      # @return [BigDecimal]
+      def gross_total = net_total + vat_total
+
+      # @return [Boolean]
+      def correction? = invoice_type == "KOR"
+
+      # @param key [Symbol, String] a key of {ANNOTATIONS}
+      # @return [Boolean] whether the flag is 1 — given in {#annotations}, or `reverse_charge` implied by a line
+      def annotation?(key)
+        return true if annotations.map(&:to_sym).include?(key.to_sym)
+
+        key.to_sym == :reverse_charge && lines.any? { |line| REVERSE_CHARGE_RATES.include?(line.rate.to_s) }
+      end
+
+      # @return [Boolean] whether a line is VAT-exempt (`zw`), which sets `P_19`
+      def exempt?
+        lines.any? { |line| line.rate == "zw" }
+      end
+
+      # @return [Hash{Symbol=>Object}] every attribute, e.g. to start another invoice from this one
+      def to_h
+        ATTRIBUTES.to_h { |name| [name, public_send(name)] }
+      end
+
+      # @param created_at [Time] `DataWytworzeniaFa`
+      # @return [String] FA(3) XML
+      # @raise [Ksef::ConfigurationError] for a missing required value, a malformed number, an unknown code
+      #   (NIP, rate, GTU, country, currency, payment method, buyer identification, annotation, invoice or
+      #   correction type), a date that is not a Date / "YYYY-MM-DD", text KSeF refuses, or an invoice the
+      #   builder cannot express (foreign-currency VAT, a `zw` line without `exemption_reason`)
+      # @raise [Ksef::SchemaValidationError] when the result still does not match the FA(3) schema (e.g. a
+      #   value over its length limit)
+      def to_xml(created_at: Time.now)
+        check!
+        xml = Xml.new(self).render(created_at)
+        Validator.new(form_code: FormCode::FA3).validate!(xml)
+        xml
+      end
+
+      # @api private
+      # @return [String, nil] the `FormaPlatnosci` code
+      # @raise [Ksef::ConfigurationError] for an unknown method
+      def payment_code
+        return nil if blank?(payment_method)
+
+        code = PAYMENT_METHODS.fetch(payment_method.to_s.to_sym, payment_method.to_s)
+        raise ConfigurationError, "Unknown payment_method: #{payment_method}" unless PAYMENT_METHODS.value?(code)
+
+        code
+      end
+
+      # @api private
+      # @return [Boolean, nil] the `paid` flag: true, false, or nil when not given
+      # @raise [Ksef::ConfigurationError] for a value that is not a boolean, "1"/"0" or "true"/"false"
+      def paid_flag
+        return nil if blank?(paid)
+        return paid if [true, false].include?(paid)
+
+        { "1" => true, "true" => true, "0" => false, "false" => false }.fetch(paid.to_s.strip.downcase) do
+          raise ConfigurationError, "paid must be true or false, not #{paid.inspect}"
+        end
+      end
+
+      private
+
+      def party(value)
+        return value if value.nil? || value.is_a?(Party)
+
+        attrs = value.to_h.transform_keys(&:to_sym)
+        unknown = attrs.keys - PARTY_FIELDS
+        raise ConfigurationError, "Unknown party field(s): #{unknown.join(', ')}" unless unknown.empty?
+
+        Party.new(**attrs)
+      end
+
+      def line(value)
+        attrs = value.to_h.transform_keys(&:to_sym)
+        unknown = attrs.keys - LINE_FIELDS
+        raise ConfigurationError, "Unknown line field(s): #{unknown.join(', ')}" unless unknown.empty?
+
+        Line.new(**attrs)
+      end
+
+      def rate_fields(rate)
+        RATES.fetch(rate.to_s) { raise ConfigurationError, "Unknown VAT rate: #{rate}" }
+      end
+
+      def blank?(value)
+        value.to_s.strip.empty?
+      end
+    end
+  end
+end
+
+require "ksef/invoices/builder/xml"

data/lib/ksef/invoices/export.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require "base64"
+require "digest"
+require "json"
+require "stringio"
+
+module Ksef
+  module Invoices
+    # Invoice package export orchestrator: init → polling → download parts from presigned URLs
+    # (hash-checked while ENCRYPTED) → decrypt each part separately → a ZIP or tar.gz package.
+    # An expired ready package comes back as code `210`, not 410.
+    class Export
+      # Export status: "finished and ready to download".
+      STATUS_COMPLETED = 200
+      # Error code for an expired ready package (distinct from 410).
+      CODE_PACKAGE_EXPIRED = 210
+      # Package compression types (`compressionType`).
+      COMPRESSION_TYPES = %w[Zip TarGz].freeze
+      # The package file holding `{"invoices": [InvoiceMetadata…]}`; invoices are `{ksefNumber}.xml`.
+      METADATA_FILE = "_metadata.json"
+      # `package.compressionType` → the format of the decrypted package.
+      FORMATS = { "Zip" => :zip, "TarGz" => :tar_gz }.freeze
+      # Largest file the package may hold once unpacked, in bytes (`_metadata.json` of 10,000 invoices
+      # included); a larger one is refused rather than inflated.
+      MAX_ENTRY_SIZE = 100_000_000
+
+      # Export result: the decrypted package bytes + the package description from the status.
+      Result = Struct.new(:bytes, :package, keyword_init: true) do
+        # The package size and counts — never its bytes or the presigned part URLs.
+        # @return [String]
+        def inspect
+          info = package || {}
+          "#<#{self.class.name} bytes=#{bytes.to_s.bytesize} invoiceCount=#{info['invoiceCount'].inspect} " \
+            "parts=#{Array(info['parts']).size} isTruncated=#{info['isTruncated'].inspect}>"
+        end
+        alias_method :to_s, :inspect
+
+        # `pp` and IRB print through #pretty_print, which Struct implements without calling #inspect.
+        def pretty_print(printer)
+          printer.text(inspect)
+        end
+
+        # Read from the leading bytes and checked against the status's `package.compressionType`.
+        # @return [Symbol, nil] :zip, :tar_gz, or nil for an empty package
+        # @raise [Ksef::Error] for an unknown format, or one other than the status declares
+        def compression
+          return nil if bytes.empty?
+
+          detected = if bytes.start_with?("\x1F\x8B".b) then :tar_gz
+                     elsif bytes.start_with?("PK".b) then :zip
+                     else raise Error, "Unrecognized export package format (neither ZIP nor gzip)"
+                     end
+          declared = FORMATS[(package || {})["compressionType"]]
+          return detected if declared.nil? || declared == detected
+
+          raise Error, "Export package is #{detected}, the status declares #{declared}"
+        end
+
+        # Streams the package one file at a time (only the current file is held in memory). Names are
+        # given without a leading "./", whichever tool built the archive.
+        # @yieldparam name [String] file name inside the package — never absolute, never with a ".." segment
+        # @yieldparam content [String] file bytes
+        # @return [Enumerator, nil] an Enumerator without a block
+        # @raise [Ksef::Error] for an absolute or climbing name, a file over {MAX_ENTRY_SIZE}, or a package
+        #   that cannot be read
+        def each_entry(&block)
+          return enum_for(:each_entry) unless block
+
+          case compression
+          when :zip then each_zip_entry(&block)
+          when :tar_gz then each_tar_entry(&block)
+          end
+          nil
+        end
+
+        # @return [Hash{String=>String}] every file in the package, including `_metadata.json`
+        def entries
+          each_entry.to_h
+        end
+
+        # @return [Array<Hash>] the InvoiceMetadata entries of `_metadata.json` (empty when absent)
+        def metadata
+          json = read(METADATA_FILE)
+          return [] unless json
+
+          data = JSON.parse(json)
+          data.is_a?(Array) ? data : Array(data["invoices"])
+        rescue JSON::ParserError => e
+          raise Error, "#{METADATA_FILE} is not valid JSON: #{e.message}"
+        end
+
+        # @param name [String] file name inside the package
+        # @return [String, nil] that file's bytes (a ZIP is read through its central directory)
+        def read(name)
+          if compression == :zip
+            entry = zip.find_entry(name) || zip.find_entry("./#{name}")
+            return zip.read(entry) if entry
+            return nil if name.ascii_only? # a non-ASCII name may be stored without its UTF-8 flag
+          end
+          each_entry { |entry_name, content| return content if entry_name == name }
+          nil
+        end
+
+        private
+
+        def zip
+          require "zip"
+          @zip ||= Zip::File.open_buffer(StringIO.new(bytes))
+        end
+
+        def each_zip_entry
+          zip.each do |entry|
+            next unless entry.file?
+
+            name = entry_name(entry.name)
+            content = zip.get_input_stream(entry) { |io| io.read(MAX_ENTRY_SIZE + 1) } || "".b
+            yield(name, checked_size(name, content.bytesize) && content)
+          end
+        rescue Zip::Error => e
+          raise Error, "the export package is not a readable ZIP: #{e.message}"
+        end
+
+        # Archive names arrive as bytes; KSeF's are ASCII, a batch package's may be UTF-8.
+        def entry_name(raw)
+          name = raw.dup.force_encoding(Encoding::UTF_8)
+          name = (name.valid_encoding? ? name : raw).delete_prefix("./")
+          return name unless name.start_with?("/", "\\") || name.split(%r{[/\\]}).include?("..")
+
+          raise Error, "unexpected file name in the export package: #{name.inspect}"
+        end
+
+        def checked_size(name, size)
+          return true if size <= MAX_ENTRY_SIZE
+
+          raise Error, "#{name} in the export package is over #{MAX_ENTRY_SIZE} bytes"
+        end
+
+        def each_tar_entry
+          Ksef.require_optional("minitar", "Unpacking a tar.gz package")
+          require "zlib"
+          Zlib::GzipReader.wrap(StringIO.new(bytes)) do |gz|
+            Minitar::Reader.open(gz) do |tar|
+              tar.each_entry do |entry|
+                next unless entry.file?
+
+                name = entry_name(entry.full_name)
+                checked_size(name, entry.size)
+                # GzipReader yields binary data; an empty file reads as nil.
+                yield(name, entry.read || "".b)
+              end
+            end
+          end
+        rescue Zlib::Error => e
+          raise Error, "the export package is not a readable tar.gz: #{e.message}"
+        end
+      end
+
+      # @param client [Ksef::Client]
+      def initialize(client)
+        @client = client
+      end
+
+      # Runs the full export and returns the assembled package.
+      #
+      # @param filters [Hash] query filters
+      # @param only_metadata [Boolean] the package then holds `_metadata.json` alone
+      # @param compression_type [String, nil] "Zip" or "TarGz" (tar.gz needs the `minitar` gem to unpack);
+      #   nil leaves it to the API (Zip)
+      # @param poll [Hash] polling options
+      # @return [Result]
+      def call(filters:, only_metadata: false, compression_type: "Zip", poll: {})
+        unless compression_type.nil? || COMPRESSION_TYPES.include?(compression_type)
+          raise ConfigurationError, "compression_type must be one of #{COMPRESSION_TYPES.join('/')}"
+        end
+
+        encryption = @client.crypto.encryption_data
+        init = @client.public_keys.with_rotation_retry do |retrying|
+          encryption = @client.crypto.rewrap(encryption) if retrying
+          @client.exports.create(encryption_info: encryption.encryption_info, filters: filters,
+                                 only_metadata: only_metadata, compression_type: compression_type)
+        end
+        status = wait_for_package(init["referenceNumber"], poll)
+        package = status["package"]
+        Result.new(bytes: assemble(package, encryption), package: package)
+      end
+
+      private
+
+      def wait_for_package(reference_number, poll)
+        Polling.run(description: "export #{reference_number}", logger: @client.config.logger, **poll) do
+          response = @client.exports.status(reference_number)
+          interpret_status(response)
+        end
+      end
+
+      def interpret_status(response)
+        status = response["status"] || {}
+        case status["code"]
+        when STATUS_COMPLETED
+          response["package"] ? response : Polling.pending
+        when CODE_PACKAGE_EXPIRED
+          raise Gone.new("Export package expired", codes: [CODE_PACKAGE_EXPIRED], body: response)
+        when nil, 100, 150
+          Polling.pending
+        else
+          raise ApiError.new(status["description"] || "Export error", codes: [status["code"]].compact, body: response)
+        end
+      end
+
+      # Downloads parts in order, verifies each ciphertext hash, decrypts each part separately and
+      # appends the plaintext to one buffer (no second copy of the package).
+      def assemble(package, encryption)
+        parts = Array(package["parts"]).sort_by { |p| p["ordinalNumber"] }
+        parts.each_with_object(String.new(encoding: Encoding::BINARY)) do |part, buffer|
+          buffer << download_and_decrypt(part, encryption)
+        end
+      end
+
+      def download_and_decrypt(part, encryption)
+        method = part["method"] || "GET"
+        response = @client.connection.presigned_transfer(method, part["url"])
+        verify_encrypted_part!(response.raw_body, part)
+        @client.crypto.decrypt_aes(response.raw_body, encryption.key, encryption.iv)
+      end
+
+      # Verifies the integrity of the ENCRYPTED part: SHA-256 of the downloaded bytes ==
+      # encryptedPartHash. A part without a hash is refused rather than trusted.
+      def verify_encrypted_part!(bytes, part)
+        expected = part["encryptedPartHash"].to_s
+        raise CryptoError, "Export part #{part['ordinalNumber']} has no encryptedPartHash" if expected.empty?
+
+        actual = Base64.strict_encode64(Digest::SHA256.digest(bytes))
+        return if actual == expected
+
+        raise CryptoError,
+              "Export part digest mismatch #{part['ordinalNumber']}: expected #{expected}, got #{actual}"
+      end
+    end
+  end
+end

data/lib/ksef/invoices/sample.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Ksef
+  module Invoices
+    # Three FA(3) invoices built with {Builder}, each accepted on KSeF TEST: a starting point to copy or
+    # to adapt. `examples/fa3_{minimal,typical,full}.xml` are their XML.
+    module Sample
+      # Placeholder parties; the buyer's NIP is valid but belongs to no one in particular.
+      SELLER = { name: "Seller Ltd.", address: "1 Test Street, 00-001 Warsaw", country: "PL" }.freeze
+      BUYER = { nip: "1111111111", name: "Buyer Inc.", address: "2 Example Street, 00-002 Warsaw",
+                country: "PL" }.freeze
+
+      module_function
+
+      # One 23% line — the fields every invoice needs.
+      # @param seller_nip [String] the session's context NIP
+      # @param invoice_number [String] `P_2`, unique per seller
+      # @param issue_date [Date] `P_1`, the calendar day in Poland: KSeF refuses a later day and marks an
+      #   earlier one as issued offline
+      # @return [Builder]
+      def minimal(seller_nip:, invoice_number:, issue_date: PolishTime.today)
+        Builder.new(
+          number: invoice_number, issue_date: issue_date, currency: "PLN",
+          seller: SELLER.merge(nip: seller_nip), buyer: BUYER,
+          lines: [{ name: "Demo service", unit: "szt.", quantity: "1", unit_price: "100.00", rate: "23" }]
+        )
+      end
+
+      # {minimal} plus the sale date, the place of issue and a bank transfer due in 14 days.
+      # @param (see minimal)
+      # @return [Builder]
+      def typical(seller_nip:, invoice_number:, issue_date: PolishTime.today)
+        minimal(seller_nip: seller_nip, invoice_number: invoice_number, issue_date: issue_date).tap do |invoice|
+          invoice.sale_date = issue_date
+          invoice.place = "Warsaw"
+          invoice.payment_method = :transfer
+          invoice.due_date = issue_date + 14
+          invoice.bank_account = "17100000000000000000000001"
+        end
+      end
+
+      # A VAT invoice with most fields {Builder} supports: contact data, five rates (23, 8, 5, 0 domestic,
+      # exempt), line details and a discount, a transfer with the bank's name, the footer and registers.
+      # Not shown: a payment already made, a buyer identified other than by NIP, a correction, annotations
+      # and the other five rates.
+      # @param (see minimal)
+      # @return [Builder]
+      def full(seller_nip:, invoice_number:, issue_date: PolishTime.today)
+        typical(seller_nip: seller_nip, invoice_number: invoice_number, issue_date: issue_date).tap do |invoice|
+          invoice.seller = SELLER.merge(nip: seller_nip, email: "invoices@seller.example", phone: "+48 22 000 00 00")
+          invoice.buyer = BUYER.merge(email: "accounts@buyer.example")
+          invoice.lines = full_lines
+          invoice.exemption_reason = "Art. 43 ust. 1 pkt 37 ustawy o VAT"
+          invoice.bank_name = "Example Bank"
+          invoice.footer = "Thank you for your business."
+          invoice.krs = "0000123456"
+          invoice.regon = "123456785"
+          invoice.bdo = "000012345"
+        end
+      end
+
+      def full_lines
+        [
+          { name: "Software licence", unit: "szt.", quantity: "2", unit_price: "1000.00", rate: "23",
+            index: "LIC-01", gtin: "5901234123457", pkwiu: "58.29.50.0", cn: "8523", gtu: "GTU_12",
+            discount: "100.00" },
+          { name: "Printed manual", unit: "szt.", quantity: "1", unit_price: "50.00", rate: "5" },
+          { name: "Catering", unit: "szt.", quantity: "3", unit_price: "40.00", rate: "8" },
+          { name: "Zero-rated supply", unit: "szt.", quantity: "1", unit_price: "20.00", rate: "0 KR" },
+          { name: "Insurance", unit: "szt.", quantity: "1", unit_price: "30.00", rate: "zw" }
+        ]
+      end
+      private_class_method :full_lines
+    end
+  end
+end