invoice_extractor_arca 0.2.0

data/lib/invoice_extractor_arca/text/invoice_parser.rb

@@ -0,0 +1,517 @@
+# frozen_string_literal: true
+
+require "date"
+
+require_relative "../catalogs"
+require_relative "layout_table_parser"
+require_relative "locale_value_normalizer"
+require_relative "../error_record"
+
+module InvoiceExtractorArca
+  module Text
+    class InvoiceParser
+      SCALAR_FIELDS = %i[
+        copy_type
+        voucher_type_code
+        trade_name
+        biller_address
+        biller_iva_condition
+        selling_point
+        invoice_number
+        emission_date
+        biller_cuit
+        gross_income_number
+        operations_start_date
+        billing_date_from
+        billing_date_to
+        billing_due_date
+        recipient_document_type
+        recipient_document_number
+        recipient_iva_condition
+        payment_method
+        recipient_name
+        recipient_address
+        general_subtotal
+        other_taxes
+        total
+        authorization_code
+        authorization_due_date
+      ].freeze
+
+      def initialize(
+        value_normalizer: LocaleValueNormalizer.new,
+        table_parser: nil
+      )
+        @value_normalizer = value_normalizer
+        @table_parser =
+          table_parser ||
+          LayoutTableParser.new(value_normalizer: value_normalizer)
+      end
+
+      def parse(raw:, normalized:, voucher:)
+        text = normalized.to_s.strip
+        text = raw.to_s if text.empty?
+
+        document_regions = regions(text)
+        table_result = @table_parser.parse(raw)
+        diagnostics = Array(table_result[:diagnostics])
+        enrichment = {}
+
+        set_field(enrichment, :copy_type, copy_type(text))
+        set_field(enrichment, :voucher_type_code, voucher_type_code(text))
+        set_field(enrichment, :selling_point, selling_point(text))
+        set_field(enrichment, :invoice_number, invoice_number(text))
+        set_field(enrichment, :emission_date, emission_date(text))
+        set_field(enrichment, :biller_cuit, biller_cuit(text))
+        set_field(
+          enrichment,
+          :recipient_document_type,
+          recipient_document_type(document_regions[:recipient], voucher)
+        )
+        set_field(enrichment, :recipient_document_number, recipient_document_number(text))
+        set_field(enrichment, :total, total(text))
+        set_field(enrichment, :authorization_code, authorization_code(text))
+        set_field(
+          enrichment,
+          :biller_cuit,
+          biller_cuit(document_regions[:header])
+        )
+
+        set_field(
+          enrichment,
+          :recipient_document_number,
+          recipient_document_number(document_regions[:recipient])
+        )
+        set_field(enrichment, :trade_name, trade_name(document_regions[:header]))
+        set_field(enrichment, :biller_address, biller_address(document_regions[:header]))
+        set_field(enrichment, :biller_iva_condition, biller_iva_condition(document_regions[:header]))
+        set_field(enrichment, :gross_income_number, gross_income_number(document_regions[:header]))
+        set_field(enrichment, :operations_start_date, operations_start_date(document_regions[:header]))
+
+        set_field(enrichment, :billing_date_from, billing_date_from(document_regions[:billing]))
+        set_field(enrichment, :billing_date_to, billing_date_to(document_regions[:billing]))
+        set_field(enrichment, :billing_due_date, billing_due_date(document_regions[:billing]))
+
+        set_field(enrichment, :recipient_iva_condition, recipient_iva_condition(document_regions[:recipient]))
+        set_field(enrichment, :payment_method, payment_method(document_regions[:recipient]))
+        set_field(enrichment, :recipient_name, recipient_name(document_regions[:recipient]))
+        set_field(enrichment, :recipient_address, recipient_address(document_regions[:recipient]))
+
+        set_field(enrichment, :general_subtotal, general_subtotal(document_regions[:totals]))
+        set_field(enrichment, :other_taxes, other_taxes(document_regions[:totals]))
+        set_field(enrichment, :authorization_due_date, authorization_due_date(document_regions[:authorization]))
+
+        SCALAR_FIELDS.each do |name|
+          next if enrichment.key?(name)
+
+          enrichment[name] = missing_field
+          diagnostics << missing_field_diagnostic(name)
+        end
+
+        enrichment[:service_rows] = table_result[:rows]
+
+        {
+          enrichment: enrichment,
+          diagnostics: diagnostics
+        }
+      end
+
+      def regions(text)
+        {
+          header: bounded_region(
+            text,
+            /\A/,
+            /Per[ií]odo\s+Facturado\s+Desde/i
+          ),
+          billing: bounded_region(
+            text,
+            /Per[ií]odo\s+Facturado\s+Desde/i,
+            /^CUIT\s*:/i
+          ),
+          recipient: bounded_region(
+            text,
+            /^CUIT\s*:/i,
+            /^C[oó]digo\s+Producto\s*\/\s*Servicio/i
+          ),
+          totals: bounded_region(
+            text,
+            /Subtotal\s*:\s*\$/i,
+            /CAE(?:A)?\s+N[°ºo]?/i
+          ),
+          authorization: bounded_region(
+            text,
+            /CAE(?:A)?\s+N[°ºo]?/i,
+            /\z/
+          )
+        }
+      end
+
+      def bounded_region(text, start_pattern, end_pattern)
+        start_match = text.match(start_pattern)
+        return "" unless start_match
+
+        remainder = text[start_match.begin(0)..]
+        end_match = remainder.match(end_pattern)
+
+        if end_match&.begin(0)&.positive?
+          remainder[0...end_match.begin(0)]
+        else
+          remainder
+        end
+      end
+
+      def trade_name(text)
+        match = text.match(
+          /Raz[oó]n\s+Social\s*:\s*([^\n]{1,100}?)(?=\s{2,}Fecha\s+de\s+Emisi[oó]n|\n|\z)/i
+        )
+        return nil unless match
+
+        field(match[1])
+      end
+
+      def biller_address(text)
+        labeled_wrapped_value(
+          text,
+          /Domicilio\s+Comercial\s*:/i,
+          /CUIT\s*:|Condici[oó]n\s+frente\s+al\s+IVA/i
+        )
+      end
+
+      def biller_iva_condition(text)
+        catalog_value_after_label(
+          text,
+          /Condici[oó]n\s+frente\s+al\s+IVA\s*:/i,
+          Catalogs::IVA_TYPES
+        )
+      end
+
+      def gross_income_number(text)
+        digits_field(text, /Ingresos\s+Brutos\s*:/i)
+      end
+
+      def operations_start_date(text)
+        date_field(text, /Fecha\s+de\s+Inicio\s+de\s+Actividades\s*:/i)
+      end
+
+      def billing_date_from(text)
+        date_field(text, /Per[ií]odo\s+Facturado\s+Desde\s*:/i)
+      end
+
+      def billing_date_to(text)
+        date_field(text, /\bHasta\s*:/i)
+      end
+
+      def billing_due_date(text)
+        date_field(text, /Fecha\s+de\s+Vto\.\s+para\s+el\s+pago\s*:/i)
+      end
+
+      def recipient_iva_condition(text)
+        catalog_value_after_label(
+          text,
+          /Condici[oó]n\s+frente\s+al\s+IVA\s*:/i,
+          Catalogs::IVA_TYPES
+        )
+      end
+
+      def payment_method(text)
+        catalog_field(
+          labeled_value(
+            text,
+            /Condici[oó]n\s+de\s+venta\s*:/i
+          ),
+          Catalogs::PAYMENT_METHODS
+        )
+      end
+
+      def recipient_name(text)
+        labeled_value_field(
+          text,
+          /Apellido\s+y\s+Nombre\s*\/\s*Raz[oó]n\s+Social\s*:/i
+        )
+      end
+
+      def recipient_address(text)
+        labeled_wrapped_value(
+          text,
+          /Domicilio\s*:/i,
+          /Condici[oó]n\s+de\s+venta/i
+        )
+      end
+
+      def general_subtotal(text)
+        money_field(text, /Subtotal\s*:\s*\$/i)
+      end
+
+      def other_taxes(text)
+        money_field(text, /Importe\s+Otros\s+Tributos\s*:\s*\$/i)
+      end
+
+      def authorization_due_date(text)
+        date_field(text, /Fecha\s+de\s+Vto\.\s+de\s+CAE(?:A)?\s*:/i)
+      end
+
+      private
+
+      def set_field(enrichment, name, value)
+        return if value.nil?
+
+        enrichment[name] = value
+      end
+
+      def field(
+        raw,
+        normalized: nil,
+        source: "pdf_text",
+        method: "label_regex",
+        confidence: "high",
+        description: nil
+      )
+        cleaned = raw.to_s.strip
+        normalized = cleaned if normalized.nil?
+
+        result = {
+          raw: cleaned,
+          normalized: normalized,
+          source: source,
+          method: method,
+          confidence: confidence
+        }
+
+        result[:description] = description if description
+        result
+      end
+
+      def copy_type(text)
+        catalog = Catalogs::COPY_TYPES.values.sort_by { |value| -value.length }
+        match = catalog.find { |value| text.match?(/\b#{Regexp.escape(value)}\b/i) }
+        return nil unless match
+
+        field(match, normalized: match.upcase)
+      end
+
+      def voucher_type_code(text)
+        match = text.match(/(?:COD\.?|C[oó]d\.?)\s*(\d{3})/i)
+        return nil unless match
+
+        code = match[1]
+
+        field(
+          code,
+          normalized: code,
+          method: "label_regex",
+          description: Catalogs::VOUCHER_TYPES[code]
+        )
+      end
+
+      def selling_point(text)
+        match = text.match(
+          /Punto\s+de\s+Venta\s*:\s*(\d{1,5})/i
+        )
+        return nil unless match
+
+        field(
+          match[1],
+          normalized: @value_normalizer.code(match[1], 5)
+        )
+      end
+
+      def invoice_number(text)
+        match = text.match(/Comp\.?\s*Nro:\s*(\d+)/i)
+        return nil unless match
+
+        normalized = match[1].to_i.to_s.rjust(8, "0")
+        field(match[1], normalized: normalized)
+      end
+
+      def emission_date(text)
+        match = text.match(/Fecha de Emisi[oó]n:\s*(\d{2}\/\d{2}\/\d{4})/i)
+        return nil unless match
+
+        normalized = Date.strptime(match[1], "%d/%m/%Y").iso8601
+        field(match[1], normalized: normalized)
+      rescue Date::Error
+        nil
+      end
+
+      def biller_cuit(text)
+        matches = text.scan(/\bCUIT:\s*(\d{11})\b/i)
+        return nil if matches.empty?
+
+        field(matches.first.first, normalized: matches.first.first)
+      end
+
+      def recipient_document_type(text, voucher)
+        expected =
+          voucher[:recipient_document_type_description]
+
+        return nil unless expected
+
+        pattern = /(?:#{Regexp.escape(expected)})\s*:/i
+        match = text.match(pattern)
+        return nil unless match
+
+        field(
+          match[0].sub(/:\s*\z/, ""),
+          normalized: expected
+        )
+      end
+
+      def recipient_document_number(text)
+        matches = text.scan(/\bCUIT:\s*(\d{11})\b/i)
+        return nil if matches.length < 2
+
+        field(matches[1].first, normalized: matches[1].first)
+      end
+
+      def total(text)
+        match = text.match(/Importe Total:\s*\$\s*([\d.,]+)/i)
+        match ||= text.match(/Subtotal:\s*\$\s*([\d.,]+)/i)
+        return nil unless match
+
+        normalized = @value_normalizer.decimal(match[1])
+        field(match[1], normalized: normalized)
+      end
+
+      def authorization_code(text)
+        match = text.match(/CAE(?:A)?\s*N[°ºo]?:\s*(\d{14})/i)
+        return nil unless match
+
+        field(match[1], normalized: match[1])
+      end
+
+      def labeled_value(text, label)
+        match = text.match(/#{label.source}\s*([^\n]{1,160})/i)
+        match && match[1].strip
+      end
+
+      def labeled_value_field(text, label)
+        value = labeled_value(text, label)
+        value && field(value)
+      end
+
+      def date_field(text, label)
+        match = text.match(
+          /#{label.source}\s*(\d{2}\/\d{2}\/\d{4})/i
+        )
+        return nil unless match
+
+        field(
+          match[1],
+          normalized: @value_normalizer.date(match[1])
+        )
+      end
+
+      def digits_field(text, label)
+        match = text.match(
+          /#{label.source}\s*(\d[\d.\-\s]{1,20})/i
+        )
+        return nil unless match
+
+        field(
+          match[1],
+          normalized: @value_normalizer.digits(match[1])
+        )
+      end
+
+      def money_field(text, label)
+        match = text.match(
+          /#{label.source}\s*([\d.]+,\d{2})/i
+        )
+        return nil unless match
+
+        field(
+          match[1],
+          normalized: @value_normalizer.decimal(match[1])
+        )
+      end
+
+      def labeled_wrapped_value(text, label, terminator)
+        match = text.match(
+          /#{label.source}\s*(.{1,240}?)(?=#{terminator.source}|\z)/im
+        )
+        return nil unless match
+
+        raw = match[1].strip
+        normalized = raw.lines.map(&:strip).reject(&:empty?).join(" ")
+
+        field(raw, normalized: normalized)
+      end
+
+      def catalog_field(raw, catalog)
+        return nil if raw.nil? || raw.empty?
+
+        canonical = catalog.values.find do |candidate|
+          comparable_text(candidate) == comparable_text(raw)
+        end
+
+        return field(raw, normalized: canonical) if canonical
+
+        field(
+          raw,
+          normalized: nil,
+          confidence: "low"
+        )
+      end
+
+      def comparable_text(value)
+        value
+          .to_s
+          .unicode_normalize(:nfd)
+          .gsub(/\p{Mn}/, "")
+          .downcase
+          .gsub(/[[:punct:]]/, " ")
+          .gsub(/\s+/, " ")
+          .strip
+      end
+
+      def missing_field
+        {
+          raw: nil,
+          normalized: nil,
+          source: "pdf_text",
+          method: "heuristic",
+          confidence: "low"
+        }
+      end
+
+      def missing_field_diagnostic(name)
+        ErrorRecord.new(
+          code: "enrichment_field_not_found",
+          message: "Enrichment field was not found",
+          severity: "warning",
+          component: "enrichment",
+          details: {field: name}
+        )
+      end
+
+      def catalog_value_after_label(text, label, catalog)
+        match = text.match(label)
+        return nil unless match
+
+        remainder = text[match.end(0)..].to_s.lstrip
+
+        canonical =
+          catalog.values
+            .sort_by { |value| -value.length }
+            .find do |value|
+              remainder.match?(
+                /\A#{Regexp.escape(value)}(?:\s{2,}|\n|\z)/i
+              )
+            end
+
+        return nil unless canonical
+
+        raw = remainder.match(
+          /\A#{Regexp.escape(canonical)}/i
+        )[0]
+
+        field(
+          raw,
+          normalized: canonical,
+          method: "label_regex",
+          confidence: "high"
+        )
+      end
+    end
+  end
+end