croatia 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91babeb96c8b99906844e087b9599ec530c4b972b6d1bdf2cded59dfbbb178d1
-  data.tar.gz: cd5b1dece16ed4f0d9ec3e2b8ceac8b2b44ad251f7eb2f07e119491bc638cb9f
+  metadata.gz: 950fcecdaee0439b153f3bccc88c0dcc1bd65707200d6f88b7c08729752d0384
+  data.tar.gz: 56d5d0073b5059d2a70767ff82be379c92183f16a37bfcbb318c576cccc3b797
 SHA512:
-  metadata.gz: f103227a100270c0d53c8bf45edb30532a852719866900fed949996e1afbfcb4fd3525c0e7ae4828bd8e16a1137357f3345810600b24cd3db174774ba2f4a5fd
-  data.tar.gz: cec02f409ded5d60f9535464669219314f4da1ab516ef5139b550d033552ac9393cd6105e37486427cfe6ee606c93636caa85c2a3f7994dc783cf9984643b110
+  metadata.gz: b6388cb5613f183c1bbea376ab1eb2975b9e6f90c00c98c1e272a94a69ca19819b509aadc86d27fd63f1bf194b9597b5d391598015366294dbf6c1cbebdea306
+  data.tar.gz: 8f27f7baabdbb619e7b3048fc34f204b7279137437e0983de40492b5e5af2c1b23ba80c03e01b3c471a035756bfc7d6cb5106a147534e4a372220b46328a3ca0

data/lib/croatia/config.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Croatia::Config
+  DEFAULT_TAX_RATES = {
+    value_added_tax: {
+      standard: 0.25,
+      lower_rate: 0.13,
+      exempt: 0.0,
+      zero_rated: 0.0,
+      outside_scope: 0.0,
+      reverse_charge: 0.0
+    },
+    consumption_tax: Hash.new(0.0),
+    other: Hash.new(0.0)
+  }
+  DEFAULT_FISCALIZATION = {}
+
+  attr_accessor :tax_rates, :fiscalization
+
+  def initialize(**options)
+    self.tax_rates = options.delete(:tax_rates) { deep_dup(DEFAULT_TAX_RATES) }
+    self.fiscalization = options.delete(:fiscalization) { deep_dup(DEFAULT_FISCALIZATION) }
+  end
+
+  private
+
+    def deep_dup(object)
+      Marshal.load(Marshal.dump(object))
+    end
+end

data/lib/croatia/fiscalizer/xml_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "rexml/document"
+
+module Croatia::Fiscalizer::XMLBuilder
+  TNS = "http://www.apis-it.hr/fin/2012/types/f73"
+  XSI = "http://www.w3.org/2001/XMLSchema-instance"
+  SEQUENCE_MARK = {
+    register: "N", # N - sequential by register
+    business_location: "P" # P - sequential by business location
+  }.freeze
+  PAYMENT_METHODS = {
+    cash: "G", # G - gotovina
+    card: "K", # K - kartica
+    check: "C", # C - ček
+    transfer: "T", # T - prijenos
+    other: "O" # O - ostalo
+  }.freeze
+
+  class << self
+    def invoice_request(invoice:, message_id:, specific_purpose: nil, subsequent_delivery: false, timezone: Croatia::Fiscalizer::TZ)
+      REXML::Document.new.tap do |doc|
+        envelope = doc.add_element("tns:RacunZahtjev", {
+          "xmlns:tns" => TNS,
+          "xmlns:xsi" => XSI
+        })
+
+        envelope.add_element("tns:Zaglavlje").tap do |header|
+          header.add_element("tns:IdPoruke").text = message_id
+          header.add_element("tns:DatumVrijemeSlanja").text = timezone.now.strftime("%d.%m.%YT%H:%M:%S")
+        end
+
+        envelope.add_element("tns:Racun").tap do |payload|
+          payload.add_element("tns:Oib").text = invoice.seller.pin
+          payload.add_element("tns:USustPdv").text = invoice.seller.pays_vat ? "true" : "false"
+          payload.add_element("tns:DatVrijeme").text = timezone.to_local(invoice.issue_date).strftime("%d.%m.%YT%H:%M:%S")
+          payload.add_element("tns:OznSlijed").text = SEQUENCE_MARK[invoice.sequential_by]
+
+          payload.add_element("tns:BrRac").tap do |invoice_number|
+            invoice_number.add_element("tns:BrOznRac").text = invoice.sequential_number.to_s
+            invoice_number.add_element("tns:OznPosPr").text = invoice.business_location_identifier.to_s
+            invoice_number.add_element("tns:OznNapUr").text = invoice.register_identifier.to_s
+          end
+
+          # TODO: Add taxes
+
+          payload.add_element("tns:IznosUkupno").text = invoice.total.to_f.to_s
+          payload.add_element("tns:NacinPlac").text = PAYMENT_METHODS[invoice.payment_method]
+          payload.add_element("tns:OibOper").text = invoice.issuer.pin
+          payload.add_element("tns:ZastKod").text = invoice.issuer_protection_code
+          payload.add_element("tns:NakDost").text = subsequent_delivery ? "true" : "false"
+          payload.add_element("tns:ParagonBrRac").text = invoice.number
+          payload.add_element("tns:SpecNamj").text = specific_purpose if specific_purpose
+        end
+      end
+    end
+  end
+end

data/lib/croatia/fiscalizer.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "digest/md5"
+require "openssl"
+require "securerandom"
+require "tzinfo"
+require "uri"
+
+class Croatia::Fiscalizer
+  autoload :XMLBuilder, "croatia/fiscalizer/xml_builder"
+
+  TZ = TZInfo::Timezone.get("Europe/Zagreb")
+  QR_CODE_BASE_URL = "https://porezna.gov.hr/rn"
+
+  attr_reader :certificate
+
+  def initialize(certificate: nil, password: nil)
+    certificate ||= Croatia.config.fiscalization[:certificate]
+    password ||= Croatia.config.fiscalization[:password]
+
+    @certificate = load_certificate(certificate, password)
+  end
+
+  def fiscalize(invoice:, message_id: SecureRandom.uuid)
+    _document = XMLBuilder.invoice_request(invoice: invoice, message_id: message_id, timezone: TZ)
+    raise NotImplementedError, "Fiscalization XML generation is not implemented yet"
+  end
+
+  def generate_issuer_protection_code(invoice)
+    buffer = []
+    buffer << invoice.issuer.pin
+    buffer << TZ.to_local(invoice.issue_date).strftime("%d.%m.%Y %H:%M:%S")
+    buffer << invoice.sequential_number
+    buffer << invoice.business_location_identifier
+    buffer << invoice.register_identifier
+    buffer << invoice.total.to_f
+
+    digest = OpenSSL::Digest::SHA1.new
+    signature = certificate.sign(digest, buffer.join)
+
+    Digest::MD5.hexdigest(signature).downcase
+  end
+
+  def generate_verification_qr_code(invoice)
+    Croatia::QRCode.ensure_supported!
+
+    params = {
+      datv: TZ.to_local(invoice.issue_date).strftime("%Y%m%d_%H%M"),
+      izn: invoice.total_cents.to_s
+    }
+
+    if params[:izn].length > 10
+      raise ArgumentError, "Total amount exceeds 10 digits: #{params[:izn]}"
+    end
+
+    if invoice.unique_invoice_identifier
+      params[:jir] = invoice.unique_invoice_identifier
+    else
+      params[:zki] = generate_issuer_protection_code(invoice)
+    end
+
+    if params[:jir].nil? && params[:zki].nil?
+      raise ArgumentError, "Either unique_invoice_identifier or issuer_protection_code must be provided"
+    end
+
+    query_string = URI.encode_www_form(params)
+    url = "#{QR_CODE_BASE_URL}?#{query_string}"
+
+    Croatia::QRCode.new(url)
+  end
+
+  private
+
+    def load_certificate(cert, password)
+      if cert.is_a?(OpenSSL::PKCS12)
+        cert.key
+      elsif cert.is_a?(OpenSSL::PKey::PKey)
+        cert
+      else
+        begin
+          cert = File.read(cert) if cert.respond_to?(:to_s) && File.exist?(cert.to_s)
+        rescue ArgumentError
+        end
+
+        begin
+          OpenSSL::PKey.read(cert)
+        rescue OpenSSL::PKey::PKeyError
+          OpenSSL::PKCS12.new(cert, password).key
+        end
+      end
+    end
+end

data/lib/croatia/invoice/e_invoicable.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+module Croatia::Invoice::EInvoicable
+end

data/lib/croatia/invoice/fiscalizable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Croatia::Invoice::Fiscalizable
+  def self.included(base)
+    base.include InstanceMethods
+  end
+
+  module InstanceMethods
+    def fiscalize!(**options)
+      Croatia::Fiscalizer.new(**options).fiscalize(invoice: self)
+    end
+
+    def reverse!(**options)
+      line_items.each(&:reverse)
+      Croatia::Fiscalizer.new(**options).fiscalize(invoice: self)
+    end
+
+    def issuer_protection_code(**options)
+      Croatia::Fiscalizer
+        .new(**options)
+        .generate_issuer_protection_code(self)
+    end
+
+    def fiscalization_qr_code(**options)
+      Croatia::Fiscalizer
+        .new(**options)
+        .generate_verification_qr_code(self)
+    end
+  end
+end

data/lib/croatia/invoice/line_item.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class Croatia::Invoice::LineItem
+  include Croatia::Enum
+
+  attr_accessor :description, :unit, :taxes
+  attr_reader :quantity, :unit_price, :discount_rate
+
+  def initialize(**options)
+    self.description = options[:description]
+    self.quantity = options.fetch(:quantity, 1)
+    self.unit = options[:unit]
+    self.unit_price = options.fetch(:unit_price, 0.0)
+    self.taxes = options.fetch(:taxes, {})
+  end
+
+  def quantity=(value)
+    unless value.is_a?(Numeric)
+      raise ArgumentError, "Quantity must be a number"
+    end
+
+    @quantity = value.to_d
+  end
+
+  def unit_price=(value)
+    unless value.is_a?(Numeric) && value >= 0
+      raise ArgumentError, "Unit price must be a non-negative number"
+    end
+
+    @unit_price = value.to_d
+  end
+
+
+  def discount_rate=(value)
+    if value.nil?
+      @discount_rate = nil
+      return
+    end
+
+    unless value.is_a?(Numeric) && value >= 0 && value <= 1
+      raise ArgumentError, "Discount rate must be a non-negative number between 0 and 1"
+    end
+
+    @discount_rate = value.to_d
+  end
+
+  def discount=(value)
+    if value.nil?
+      @discount = nil
+      return
+    end
+
+    unless value.is_a?(Numeric) && value >= 0
+      raise ArgumentError, "Discount must be a non-negative number"
+    end
+
+    @discount = value.to_d.round(2, BigDecimal::ROUND_HALF_UP)
+  end
+
+  def discount
+    if @discount
+      @discount
+    elsif @discount_rate
+      (gross * @discount_rate).round(2, BigDecimal::ROUND_HALF_UP)
+    else
+      BigDecimal("0.0")
+    end
+  end
+
+  def reverse
+    self.quantity *= -1
+  end
+
+  def gross
+    (quantity * unit_price).round(2, BigDecimal::ROUND_HALF_UP)
+  end
+
+  def subtotal
+    gross - discount
+  end
+
+  def tax
+    taxes.values.sum { |tax_obj| (subtotal * tax_obj.rate).round(2, BigDecimal::ROUND_HALF_UP) }
+  end
+
+  def total
+    (subtotal + tax).round(2, BigDecimal::ROUND_HALF_UP)
+  end
+
+  def add_tax(tax = nil, **options, &block)
+    if tax.nil?
+      tax = Croatia::Invoice::Tax.new(**options)
+    end
+
+    tax.tap(&block) if block_given?
+
+    taxes[tax.type] = tax
+    tax
+  end
+end

data/lib/croatia/invoice/party.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Croatia::Invoice::Party
+  attr_accessor \
+    :address,
+    :city,
+    :country_code,
+    :einvoice_id,
+    :iban,
+    :name,
+    :pays_vat,
+    :pin,
+    :postal_code
+
+  def initialize(**options)
+    options.each do |key, value|
+      public_send("#{key}=", value)
+    end
+  end
+end

data/lib/croatia/invoice/payable.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Croatia::Invoice::Payable
+  def self.included(base)
+    base.include InstanceMethods
+  end
+
+  module InstanceMethods
+    def payment_barcode(description: nil, model: nil, reference_number: nil, payment_purpose_code: nil)
+      if buyer.nil? || seller.nil?
+        raise ArgumentError, "Both buyer and seller must be set before generating a payment barcode"
+      end
+
+      description ||= "Račun #{number}"
+
+      options = {
+        currency: currency,
+        total_cents: total_cents,
+        buyer_name: buyer.name,
+        buyer_address: buyer.address,
+        buyer_postal_code: buyer.postal_code,
+        buyer_city: buyer.city,
+        seller_name: seller.name,
+        seller_address: seller.address,
+        seller_postal_code: seller.postal_code,
+        seller_city: seller.city,
+        seller_iban: seller.iban,
+        model: model,
+        reference_number: reference_number,
+        payment_purpose_code: payment_purpose_code,
+        description: description
+      }
+
+      Croatia::PaymentBarcode.new(**options)
+    end
+  end
+end

data/lib/croatia/invoice/tax.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class Croatia::Invoice::Tax
+  include Croatia::Enum
+
+  attr_reader :rate
+
+  enum :type, %i[ value_added_tax consumption_tax other ]
+  enum :category, %i[ standard lower_rate exempt zero_rated outside_scope reverse_charge ]
+
+  def initialize(rate: nil, type: :value_added_tax, category: :standard)
+    self.type = type
+    self.category = category
+    self.rate = rate ? rate : Croatia.config.tax_rates[type][category]
+  end
+
+  def rate=(value)
+    if !value.is_a?(Numeric) || value < 0 || value > 1
+      raise ArgumentError, "Tax rate must be a number between 0 and 1"
+    end
+
+    @rate = value.to_d
+  end
+end

data/lib/croatia/invoice.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+require "bigdecimal/util"
+
+class Croatia::Invoice
+  autoload :Fiscalizable, "croatia/invoice/fiscalizable"
+  autoload :EInvoicable, "croatia/invoice/e_invoicable"
+  autoload :Payable, "croatia/invoice/payable"
+  autoload :Party, "croatia/invoice/party"
+  autoload :Tax, "croatia/invoice/tax"
+  autoload :LineItem, "croatia/invoice/line_item"
+
+  include Croatia::Enum
+  include Fiscalizable
+  include EInvoicable
+  include Payable
+
+  attr_reader :issue_date, :due_date
+  attr_writer :issuer, :seller, :buyer
+  attr_accessor \
+    :business_location_identifier, # oznaka poslovnog prostora
+    :currency,
+    :line_items,
+    :register_identifier, # oznaka naplatnog uredaja
+    :sequential_number, # redni broj racuna
+    :unique_invoice_identifier # jir
+
+  enum :payment_method, %i[ cash card check transfer other ].freeze, allow_nil: true, prefix: :payment_method
+  enum :sequential_by, %i[ register business_location ].freeze, allow_nil: true, prefix: :sequential_by
+
+  def initialize(**options)
+    self.line_items = options.delete(:line_items) { [] }
+    self.payment_method = :card
+    self.sequential_by = :register
+
+    options.each do |key, value|
+      public_send("#{key}=", value)
+    end
+  end
+
+  def number
+    [ sequential_number, business_location_identifier, register_identifier ].join("/")
+  end
+
+  def subtotal
+    line_items.sum(&:subtotal).to_d
+  end
+
+  def tax
+    line_items.sum(&:tax).to_d
+  end
+
+  def total
+    line_items.sum(&:total).to_d
+  end
+
+  def total_cents
+    (total * 100).to_i
+  end
+
+  def add_line_item(line_item = nil, &block)
+    if line_item.nil? && block.nil?
+      raise ArgumentError, "You must provide a line item or a block"
+    end
+
+    line_item ||= LineItem.new.tap(&block)
+
+    self.line_items ||= []
+    line_items << line_item
+
+    line_item
+  end
+
+  def issuer(&block)
+    if block_given?
+      self.issuer = Party.new.tap(&block)
+    else
+      @issuer
+    end
+  end
+
+  def buyer(&block)
+    if block_given?
+      self.buyer = Party.new.tap(&block)
+    else
+      @buyer
+    end
+  end
+
+  def seller(&block)
+    if block_given?
+      self.seller = Party.new.tap(&block)
+    else
+      @seller
+    end
+  end
+
+  def issue_date=(value)
+    @issue_date = value.nil? ? nil : parse_date(value)
+  end
+
+  def due_date=(value)
+    @due_date = value.nil? ? nil : parse_date(value)
+  end
+
+  private
+
+    def parse_date(value)
+      case value
+      when Date, DateTime
+        value
+      else
+        DateTime.parse(value.to_s)
+      end
+    end
+end

data/lib/croatia/payment_barcode.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class Croatia::PaymentBarcode
+  HEADER = "HRVHUB30"
+  EXACT_LENGTH_FIELDS = %i[ header currency total_cents model payment_purpose_code ].freeze
+  FIELD_MAX_LENGTHS = {
+    header: 8,
+    currency: 3,
+    total_cents: 15,
+    buyer_name: 30,
+    buyer_address: 27,
+    buyer_postal_code_and_city: 27,
+    seller_name: 25,
+    seller_address: 25,
+    seller_postal_code_and_city: 27,
+    seller_iban: 21,
+    model: 4,
+    reference_number: 22,
+    payment_purpose_code: 4,
+    description: 35
+  }.freeze
+
+  attr_accessor \
+    :buyer_address,
+    :buyer_city,
+    :buyer_name,
+    :buyer_postal_code,
+    :currency,
+    :description,
+    :model,
+    :payment_purpose_code,
+    :reference_number,
+    :seller_address,
+    :seller_city,
+    :seller_iban,
+    :seller_name,
+    :seller_postal_code,
+    :total_cents
+
+  def initialize(**options)
+    options.each do |key, value|
+      public_send("#{key}=", value)
+    end
+  end
+
+  def data
+    data = {
+      header: HEADER,
+      currency: currency,
+      total_cents: total_cents.to_s.rjust(FIELD_MAX_LENGTHS[:total_cents], "0"),
+      buyer_name: buyer_name,
+      buyer_address: buyer_address,
+      buyer_postal_code_and_city: "#{buyer_postal_code} #{buyer_city}".strip,
+      seller_name: seller_name,
+      seller_address: seller_address,
+      seller_postal_code_and_city: "#{seller_postal_code} #{seller_city}".strip,
+      seller_iban: seller_iban,
+      model: model,
+      reference_number: reference_number,
+      payment_purpose_code: payment_purpose_code,
+      description: description
+    }
+
+    data.each do |key, value|
+      next if value.nil?
+
+      max_length = FIELD_MAX_LENGTHS[key]
+
+      if EXACT_LENGTH_FIELDS.include?(key) && value.length != max_length
+        raise ArgumentError, "Value '#{value}' of field '#{key}' must be exactly #{max_length} characters long"
+      elsif value.length > max_length
+        raise ArgumentError, "Value '#{value}' of field '#{key}' exceeds maximum length of #{max_length} characters"
+      end
+    end
+
+    if data[:seller_iban] && (!data[:seller_iban].match?(/\A[a-z]{2}\d{19}\Z/i) && !data[:seller_iban].match?(/\A\d{7}-\d{10}\Z/i))
+      raise ArgumentError, "Invalid IBAN format '#{data[:seller_iban]}' expected IBAN or account number"
+    end
+
+    data.values.join("\n")
+  end
+
+  def barcode
+    Croatia::PDF417.ensure_supported!
+    Croatia::PDF417.new(data)
+  end
+
+  def to_png(...)
+    barcode.to_png(...)
+  end
+
+  def to_svg(...)
+    barcode.to_svg(...)
+  end
+end

data/lib/croatia/pdf417.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+class Croatia::PDF417
+  def self.ensure_supported!
+    return if supported?
+
+    raise LoadError, "Zint library is not loaded. Please ensure you have the ruby-zint gem installed and required."
+  end
+
+  def self.supported?
+    defined?(Zint)
+  end
+
+  attr_reader :data, :options
+
+  def initialize(data, **options)
+    @data = data
+    @options = options
+  end
+
+  def to_svg(**options)
+    vec = barcode.to_vector
+
+    foreground_color = options[:foreground_color] || "black"
+    background_color = options[:background_color] || "white"
+
+    svg = []
+    svg << %Q(<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="#{vec.width.to_i}" height="#{vec.height.to_i}" viewBox="0 0 #{vec.width.to_i} #{vec.height.to_i}">)
+    svg << %Q(<rect width="#{vec.width.to_i}" height="#{vec.height.to_i}" fill="#{background_color}" />)
+
+    vec.each_rectangle do |rect|
+      svg << %Q(<rect x="#{rect.x.to_i}" y="#{rect.y.to_i}" width="#{rect.width.to_i}" height="#{rect.height.to_i}" fill="#{foreground_color}" />)
+    end
+
+    svg << "</svg>"
+    svg.join("\n")
+  end
+
+  def to_png(**options)
+    barcode.to_memory_file(extension: ".png")
+  end
+
+  private
+
+    def barcode
+      @barcode ||= Zint::Barcode.new(**options, value: data, symbology: Zint::BARCODE_PDF417)
+    end
+end

data/lib/croatia/pin.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# OIB - Osobni Identifikacijski Broj
+# PIN - Personal Identification Number
 module Croatia::PIN
   def self.valid?(pin)
     return false unless pin

data/lib/croatia/qr_code.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Croatia::QRCode
+  def self.ensure_supported!
+    return if supported?
+
+    raise LoadError, "RQRCode library is not loaded. Please ensure you have the rqrcode gem installed and required."
+  end
+
+  def self.supported?
+    defined?(RQRCode)
+  end
+
+  attr_reader :data, :options
+
+  def initialize(data, **options)
+    @data = data
+    @options = options
+  end
+
+  def to_svg(**options)
+    qr_code.as_svg(**options)
+  end
+
+  def to_png(**options)
+    qr_code.as_png(**options)
+  end
+
+  private
+
+    def qr_code
+      @qr_code ||= RQRCode::QRCode.new(data, **options)
+    end
+end

data/lib/croatia/umcn.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+# JMBG - Jedinstveni Matični Broj Građana
+# UMCN - Unique Master Citizen Number
+class Croatia::UMCN
+  WEIGHTS = [ 7, 6, 5, 4, 3, 2, 7, 6, 5, 4, 3, 2 ]
+  REGION_CODES = {
+    # Special / Foreign
+    0 => "Yugoslavia",
+    1 => "Foreigner in BiH",
+    2 => "Foreigner in Montenegro",
+    3 => "Foreigner in Croatia",
+    4 => "Foreigner in North Macedonia",
+    5 => "Foreigner in Slovenia",
+    6 => "Foreigner in Serbia",
+    7 => "Foreigner in Vojvodina",
+    8 => "Foreigner in Kosovo",
+    9 => "Yugoslavia",
+
+    # Bosnia and Herzegovina (10–19)
+    10 => "Banja Luka",
+    11 => "Bihac",
+    12 => "Doboj",
+    13 => "Gorazde",
+    14 => "Livno",
+    15 => "Mostar",
+    16 => "Prijedor",
+    17 => "Sarajevo",
+    18 => "Tuzla",
+    19 => "Zenica",
+
+    # Montenegro (21–29)
+    21 => "Podgorica",
+    22 => "Bar",
+    23 => "Budva",
+    24 => "Herceg Novi",
+    25 => "Cetinje",
+    26 => "Niksic",
+    27 => "Berane",
+    28 => "Bijelo Polje",
+    29 => "Pljevlja",
+
+    # Croatia (30–39)
+    30 => "Slavonia",
+    31 => "Podravina",
+    32 => "Medimurje",
+    33 => "Zagreb",
+    34 => "Kordun",
+    35 => "Lika",
+    36 => "Istria",
+    37 => "Banovina",
+    38 => "Dalmatia",
+    39 => "Zagorje",
+
+    # North Macedonia (41–49)
+    41 => "Bitola",
+    42 => "Kumanovo",
+    43 => "Ohrid",
+    44 => "Prilep",
+    45 => "Skopje",
+    46 => "Strumica",
+    47 => "Tetovo",
+    48 => "Veles",
+    49 => "Stip",
+
+    # Slovenia (50)
+    50 => "Slovenia",
+
+    # Serbia (70–79)
+    70 => "Serbia Abroad",
+    71 => "Belgrade",
+    72 => "Sumadija",
+    73 => "Nis",
+    74 => "Morava",
+    75 => "Zajecar",
+    76 => "Podunavlje",
+    77 => "Kolubara",
+    78 => "Kraljevo",
+    79 => "Uzice",
+
+    # Vojvodina (80–89)
+    80 => "Novi Sad",
+    81 => "Sombor",
+    82 => "Subotica",
+    83 => "Zrenjanin",
+    84 => "Kikinda",
+    85 => "Pancevo",
+    86 => "Vrbas",
+    87 => "Sremska Mitrovica",
+    88 => "Ruma",
+    89 => "Backa Topola",
+
+    # Kosovo (90–99)
+    90 => "Pristina",
+    91 => "Prizren",
+    92 => "Pec",
+    93 => "Djakovica",
+    94 => "Mitrovica",
+    95 => "Gnjilane",
+    96 => "Ferizaj",
+    97 => "Decan",
+    98 => "Klina",
+    99 => "Malisevo"
+  }.freeze
+
+
+  attr_accessor :birthday, :region_code, :sequence_number, :checkusm
+
+  def self.valid?(umcn)
+    return false if umcn.nil?
+    return false unless umcn.match?(/\A\d{13}\Z/)
+
+    parse(umcn).checksum == umcn.strip[-1].to_i
+  rescue Date::Error, ArgumentError
+    false
+  end
+
+  def self.parse(umcn)
+    digits = umcn.chars.map(&:to_i)
+
+    day = digits[0..1].join.to_i
+    month = digits[2..3].join.to_i
+    year = digits[4..6].join.to_i
+    millenium = case digits[4]
+    when 0 then 2000
+    else 1000
+    end
+    full_year = millenium + year
+
+    birthday = Date.new(full_year, month, day)
+    region_code = digits[7..8].join.to_i
+    sequence_number = digits[9..11].join.to_i
+
+    new(birthday: birthday, region_code: region_code, sequence_number: sequence_number)
+  end
+
+  def initialize(birthday:, region_code:, sequence_number:)
+    @birthday = birthday
+    @region_code = region_code
+    @sequence_number = sequence_number
+  end
+
+  def region_code=(value)
+    value = value.to_i
+
+    if REGION_CODES.key?(value)
+      @region_code = value
+    else
+      raise ArgumentError, "Invalid region code: #{value}"
+    end
+  end
+
+  def sequence_number=(value)
+    value = value.to_i
+
+    if value < 0 || value > 999
+      raise ArgumentError, "Sequence number must be between 0 and 999"
+    end
+
+    @sequence_number = value
+  end
+
+  def sex
+    sequence_number <= 499 ? :male : :female
+  end
+
+  def region_of_birth
+    REGION_CODES[region_code]
+  end
+
+  def to_s
+    parts = []
+    parts << birthday.strftime("%d%m")
+    parts << format("%03d", birthday.year % 1000)
+    parts << format("%02d", region_code)
+    parts << format("%03d", sequence_number)
+
+    digits = parts.join.chars.map(&:to_i)
+    sum = digits.each_with_index.sum { |digit, i| digit * WEIGHTS[i] }
+    mod = sum % 11
+
+    checksum = (mod == 0 || mod == 1) ? 0 : (11 - mod)
+
+    parts << checksum.to_s
+    parts.join
+  end
+
+  def checksum
+    to_s[-1].to_i
+  end
+end

data/lib/croatia/utils/enum.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Croatia::Enum
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def enum(name, values, **options)
+      name = name.to_s.to_sym unless name.is_a?(Symbol)
+      values = values.zip(values) if values.is_a?(Array)
+
+      unless values.respond_to?(:to_h)
+        raise ArgumentError, "Enum values must be defined as a Hash or as an Array"
+      end
+
+      values = values.to_h.freeze
+      values_method_name = "#{name}_values".to_sym
+
+      define_singleton_method(values_method_name) do
+        values
+      end
+
+      define_method("#{name}=") do |value|
+        values = self.class.public_send(values_method_name)
+
+        enum_value = values[value]
+        enum_value = value if enum_value.nil? && values.has_value?(value)
+
+        if enum_value.nil? && !options[:allow_nil]
+          raise ArgumentError, "Invalid value for enum #{name}: #{value.inspect}"
+        end
+
+        instance_variable_set("@#{name}", enum_value)
+      end
+
+      define_method(name) do
+        instance_variable_get("@#{name}")
+      end
+
+      prefix = options[:prefix] ? "#{options[:prefix]}_" : ""
+      suffix = options[:suffix] ? "_#{options[:suffix]}" : ""
+
+      values.each do |key, value|
+        value_method_name = "#{prefix}#{key}#{suffix}"
+
+        define_method("#{value_method_name}?") do
+          instance_variable_get("@#{name}") == value
+        end
+
+        define_method("#{value_method_name}!") do
+          public_send("#{name}=", value)
+        end
+      end
+    end
+  end
+end

data/lib/croatia/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Croatia
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/lib/croatia.rb

@@ -4,4 +4,39 @@ require_relative "croatia/version"
 
 module Croatia
   class Error < StandardError; end
+
+  autoload :Config, "croatia/config"
+  autoload :Enum, "croatia/utils/enum"
+  autoload :QRCode, "croatia/qr_code"
+  autoload :PDF417, "croatia/pdf417"
+  autoload :PIN, "croatia/pin"
+  autoload :UMCN, "croatia/umcn"
+  autoload :PaymentBarcode, "croatia/payment_barcode"
+  autoload :Fiscalizer, "croatia/fiscalizer"
+  autoload :Invoice, "croatia/invoice"
+
+  class << self
+    def with_config(config = nil, &block)
+      Thread.current[:tmp_croatia_config] = config
+      block.call
+    ensure
+      Thread.current[:tmp_croatia_config] = nil
+    end
+
+    def config
+      return Thread.current[:tmp_croatia_config] if Thread.current[:tmp_croatia_config]
+
+      @config ||= Croatia::Config.new
+    end
+
+    def configure(config = nil, &block)
+      if config.is_a?(Croatia::Config)
+        @config = config
+      elsif block
+        self.config.tap(&block)
+      else
+        raise ArgumentError, "Either a Croatia::Config instance or a block is required"
+      end
+    end
+  end
 end

metadata

@@ -1,29 +1,84 @@
 --- !ruby/object:Gem::Specification
 name: croatia
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Stanko K.R.
 bindir: exe
 cert_chain: []
-date: 2025-05-29 00:00:00.000000000 Z
-dependencies: []
-description: 'Croatia is a gem that contains various utilities for performing Croatia-specific
-  actions - like PIN/OIB validation
-
-  '
+date: 2025-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rexml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tzinfo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Croatia is a gem that contains various utilities for performing Croatia-specific actions like:
+  - PIN/OIB validation
 email:
 - hey@stanko.io
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rubocop.yml"
 - LICENSE.txt
 - Rakefile
 - lib/croatia.rb
+- lib/croatia/config.rb
+- lib/croatia/fiscalizer.rb
+- lib/croatia/fiscalizer/xml_builder.rb
+- lib/croatia/invoice.rb
+- lib/croatia/invoice/e_invoicable.rb
+- lib/croatia/invoice/fiscalizable.rb
+- lib/croatia/invoice/line_item.rb
+- lib/croatia/invoice/party.rb
+- lib/croatia/invoice/payable.rb
+- lib/croatia/invoice/tax.rb
+- lib/croatia/payment_barcode.rb
+- lib/croatia/pdf417.rb
 - lib/croatia/pin.rb
+- lib/croatia/qr_code.rb
+- lib/croatia/umcn.rb
+- lib/croatia/utils/enum.rb
 - lib/croatia/version.rb
 - sig/croatia.rbs
 homepage: https://github.com/monorkin/croatia

data/.rubocop.yml

@@ -1,5 +0,0 @@
-inherit_gem:
-  rubocop-rails-omakase: rubocop.yml
-
-AllCops:
-  TargetRubyVersion: 3.1