ds-convert 0.1.1

data/lib/ds/mapper/ds_mets_mapper.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module DS
+  module Mapper
+    class DSMetsMapper < DS::Mapper::BaseMapper
+      attr_reader :iiif_lookup
+      attr_reader :ia_url_lookup
+
+
+      def initialize(source_dir:, timestamp:)
+        super(
+          source_dir: source_dir,
+          timestamp: timestamp,
+          source: DS::Source::DSMetsXML.new
+        )
+      end
+
+      def extract_record entry
+        locator = DS::Extractor::XmlRecordLocator.new
+        source_file_path = File.join source_dir, entry.filename
+        xml   = source.load_source source_file_path
+
+        record = locator.locate_record xml, entry.institutional_id, entry.institutional_id_location_in_source
+        return record if record.present?
+
+        raise "Unable to locate record for #{entry.institutional_id} (errors: #{locator.errors.join(', ')})"
+      end
+
+      ##
+      # @param [DS::Manifest::Entry] entry entry instance for a manifest row
+      # @return [Hash] the mapped record
+      def map_record entry
+        record = extract_record entry
+
+        source_type                        = entry.source_type
+        source_file                        = entry.filename
+        ds_id                              = entry.ds_id
+        date_added                         = nil
+        date_last_updated                  = nil
+        cataloging_convention              = DS::Extractor::DsMetsXmlExtractor.extract_cataloging_convention(record)
+        holding_institution_ds_qid         = entry.institution_ds_qid
+        holding_institution_as_recorded    = entry.institution_wikidata_label
+        holding_institution_id_number      = entry.institutional_id
+        holding_institution_shelfmark      = entry.call_number
+        link_to_holding_institution_record = entry.link_to_institutional_record
+        iiif_manifest                      = entry.iiif_manifest_url
+        production_date_as_recorded        = DS::Extractor::DsMetsXmlExtractor.extract_production_date_as_recorded(record).join '|'
+        production_date                    = DS::Extractor::DsMetsXmlExtractor.extract_date_range(record, range_sep: '^').join '|'
+        century                            = DS.transform_dates_to_centuries production_date
+        century_aat                        = DS.transform_centuries_to_aat century
+        dated                              = DS::Extractor::DsMetsXmlExtractor.dated_by_scribe? record
+        physical_description               = DS::Extractor::DsMetsXmlExtractor.extract_physical_description(record).join '|'
+        note                               = DS::Extractor::DsMetsXmlExtractor.extract_notes(record).join '|'
+        acknowledgments                   = DS::Extractor::DsMetsXmlExtractor.extract_acknowledgments(record).join '|'
+        data_processed_at                  = timestamp
+        data_source_modified               = entry.record_last_updated
+
+        {
+          ds_id:                              ds_id,
+          date_added:                         date_added,
+          date_last_updated:                  date_last_updated,
+          dated:                              dated,
+          cataloging_convention:              cataloging_convention,
+          source_type:                        source_type,
+          holding_institution_ds_qid:         holding_institution_ds_qid,
+          holding_institution_as_recorded:    holding_institution_as_recorded,
+          holding_institution_id_number:      holding_institution_id_number,
+          holding_institution_shelfmark:      holding_institution_shelfmark,
+          link_to_holding_institution_record: link_to_holding_institution_record,
+          iiif_manifest:                      iiif_manifest,
+          production_date_as_recorded:        production_date_as_recorded,
+          production_date:                    production_date,
+          century:                            century,
+          century_aat:                        century_aat,
+          physical_description:               physical_description,
+          note:                               note,
+          acknowledgments:                   acknowledgments,
+          data_processed_at:                  data_processed_at,
+          data_source_modified:               data_source_modified,
+          source_file:                        source_file,
+        }.update build_term_maps DS::Extractor::DsMetsXmlExtractor, record
+      end
+    end
+  end
+end

data/lib/ds/mapper/marc_mapper.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module DS
+  module Mapper
+
+    class MarcMapper < DS::Mapper::BaseMapper
+
+      def initialize(source_dir:, timestamp:)
+        super(
+          source_dir: source_dir,
+          timestamp: timestamp,
+          source: DS::Source::MarcXML.new
+        )
+      end
+      ##
+      # @param [DS::Manifest::Entry] entry +entry+ representing one
+      #     row in a manifest
+      def extract_record entry
+        record_locator = DS::Extractor::XmlRecordLocator.new(
+          namespaces: DS::Constants::XML_NAMESPACES
+        )
+
+        source_file_path = File.join source_dir, entry.filename
+        xml = source.load_source source_file_path
+        xpath = entry.institutional_id_location_in_source.gsub('ID_PLACEHOLDER', entry.institutional_id) # "//record[#{entry.institutional_id_location_in_source} = '#{entry.institutional_id}']"
+        record = record_locator.locate_record(xml, entry.institutional_id, xpath).first
+        return record if record.present?
+
+        raise "Unable to locate record for #{entry.institutional_id} (errors: #{record_locator.errors.join(', ')})"
+      end
+
+      ##
+      # @param [DS::Manifest::Entry] entry entry instance for a manifest row
+      # @return [Hash] the mapped record
+      def map_record entry
+        record = extract_record entry
+        source_type                        = 'marc-xml'
+        source_file                        = entry.filename
+        ds_id                              = entry.ds_id
+        date_added                         = ''
+        date_last_updated                  = ''
+        dated                              = entry.dated?
+        cataloging_convention              = DS::Extractor::MarcXmlExtractor.extract_cataloging_convention record
+        holding_institution_ds_qid         = entry.institution_ds_qid
+        holding_institution_as_recorded    = entry.institution_wikidata_label
+        holding_institution_id_number      = entry.institutional_id
+        holding_institution_shelfmark      = entry.call_number
+        link_to_holding_institution_record = entry.link_to_institutional_record
+        iiif_manifest                      = entry.iiif_manifest_url
+        production_date_as_recorded        = DS::Extractor::MarcXmlExtractor.extract_production_date_as_recorded(record).join '|'
+        production_date                    = DS::Extractor::MarcXmlExtractor.extract_date_range(record, range_sep: '^').join '|'
+        century                            = DS.transform_dates_to_centuries production_date
+        century_aat                        = DS.transform_centuries_to_aat century
+        physical_description               = DS::Extractor::MarcXmlExtractor.extract_physical_description(record).join('|')
+        note                               = DS::Extractor::MarcXmlExtractor.extract_notes(record).join '|'
+        data_processed_at                  = timestamp
+        data_source_modified               = entry.record_last_updated
+        acknowledgments                   = ''
+
+        {
+          ds_id:                              ds_id,
+          date_added:                         date_added,
+          date_last_updated:                  date_last_updated,
+          dated:                              dated,
+          source_type:                        source_type,
+          cataloging_convention:              cataloging_convention,
+          holding_institution_ds_qid:         holding_institution_ds_qid,
+          holding_institution_as_recorded:    holding_institution_as_recorded,
+          holding_institution_id_number:      holding_institution_id_number,
+          holding_institution_shelfmark:      holding_institution_shelfmark,
+          link_to_holding_institution_record: link_to_holding_institution_record,
+          iiif_manifest:                      iiif_manifest,
+          production_date:                    production_date,
+          century:                            century,
+          century_aat:                        century_aat,
+          production_date_as_recorded:        production_date_as_recorded,
+          physical_description:               physical_description,
+          note:                               note,
+          data_processed_at:                  data_processed_at,
+          data_source_modified:               data_source_modified,
+          source_file:                        source_file,
+          acknowledgments:                   acknowledgments,
+        }.update build_term_maps DS::Extractor::MarcXmlExtractor, record
+      end
+    end
+  end
+end

data/lib/ds/mapper/tei_xml_mapper.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module DS
+  module Mapper
+    class TeiXmlMapper < BaseMapper
+
+      def initialize source_dir:, timestamp:
+        super(
+          source_dir: source_dir,
+          timestamp: timestamp,
+          source: DS::Source::TeiXML.new
+        )
+      end
+
+      def extract_record entry
+        locator = DS::Extractor::XmlRecordLocator.new
+        source_file_path = File.join source_dir, entry.filename
+        xml = source.load_source source_file_path
+        record = locator.locate_record xml, entry.institutional_id, entry.institutional_id_location_in_source
+        return record if record.present?
+
+        raise "Unable to locate record for #{entry.institutional_id} (errors: #{record_locator.errors.join(', ')})"
+      end
+
+      def map_record entry
+        record                             = extract_record entry
+        source_type                        = 'tei-xml'
+        ds_id                              = entry.ds_id
+        date_added                         = ''
+        date_last_updated                  = ''
+        cataloging_convention              = DS::Extractor::TeiXml.extract_cataloging_convention(record)
+        dated                              = entry.dated?
+        holding_institution_ds_qid         = entry.institution_ds_qid
+        holding_institution_as_recorded    = entry.institution_wikidata_label
+        holding_institution_id_number      = entry.institutional_id
+        holding_institution_shelfmark      = entry.call_number
+        link_to_holding_institution_record = entry.link_to_institutional_record
+        iiif_manifest                      = entry.iiif_manifest_url
+        production_date_as_recorded        = DS::Extractor::TeiXml.extract_production_date_as_recorded(record, range_sep: '-').join('|')
+        production_date                    = DS::Extractor::TeiXml.extract_date_range(record, range_sep: '^').join('|')
+        century                            = DS.transform_dates_to_centuries production_date
+        century_aat                        = DS.transform_centuries_to_aat century
+        acknowledgments                    = DS::Extractor::TeiXml.extract_acknowledgments(record).join '|'
+        physical_description               = DS::Extractor::TeiXml.extract_physical_description(record).join '|'
+        note                               = DS::Extractor::TeiXml.extract_notes(record).join '|'
+        data_processed_at                  = timestamp
+        data_source_modified               = entry.record_last_updated
+
+
+        # TODO: BiblioPhilly MSS have keywords (not subjects, genre); include them?
+
+        {
+          ds_id:                              ds_id,
+          date_added:                         date_added,
+          date_last_updated:                  date_last_updated,
+          dated:                              dated,
+          cataloging_convention:              cataloging_convention,
+          source_type:                        source_type,
+          holding_institution_ds_qid:         holding_institution_ds_qid,
+          holding_institution_as_recorded:    holding_institution_as_recorded,
+          holding_institution_id_number:      holding_institution_id_number,
+          holding_institution_shelfmark:      holding_institution_shelfmark,
+          link_to_holding_institution_record: link_to_holding_institution_record,
+          iiif_manifest:                      iiif_manifest,
+          production_date_as_recorded:        production_date_as_recorded,
+          production_date:                    production_date,
+          century:                            century,
+          century_aat:                        century_aat,
+          physical_description:               physical_description,
+          acknowledgments:                    acknowledgments,
+          note:                               note,
+          data_processed_at:                  data_processed_at,
+          data_source_modified:               data_source_modified,
+          source_file:                        entry.filename
+        }.update build_term_maps DS::Extractor::TeiXml, record
+      end
+    end
+  end
+end

data/lib/ds/mapper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+require_relative 'mapper/base_mapper'
+require_relative 'mapper/ds_csv_mapper'
+require_relative 'mapper/ds_mets_mapper'
+require_relative 'mapper/marc_mapper'
+require_relative 'mapper/tei_xml_mapper'
+
+module DS
+  # The DS mapper namespace contains classes and methods for mapping
+  # DS data records DS imprort CSVs.
+  module Mapper
+  end
+end

data/lib/ds/recon/constants.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Recon
+  module Constants
+    GENRE_HEADERS = %w{
+      genre_as_recorded
+      vocab
+      source_authority_uri
+      authorized_label
+      structured_value
+    }.freeze
+
+   LANGUAGES_HEADERS = %w{
+      language_as_recorded
+      language_code
+      authorized_label
+      structured_value
+    }.freeze
+
+    MATERIALS_HEADERS = %w{
+      material_as_recorded authorized_label structured_value
+    }.freeze
+
+    NAMES_HEADERS = %w{
+      name_as_recorded
+      role
+      name_agr
+      source_authority_uri
+      instance_of
+      authorized_label
+      structured_value
+    }.freeze
+
+    PLACES_HEADERS = %w{
+      place_as_recorded authorized_label structured_value
+    }.freeze
+
+    SUBJECT_HEADERS = %w{
+      subject_as_recorded
+      subfield_codes
+      vocab
+      source_authority_uri
+      authorized_label
+      structured_value
+    }.freeze
+
+    TITLE_HEADERS = %w{
+      title_as_recorded
+      title_as_recorded_agr
+      uniform_title_as_recorded
+      uniform_title_as_recorded_agr
+      authorized_label
+    }.freeze
+
+  end
+end

data/lib/ds/recon/ds_csv_enumerator.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Recon
+  class DsCsvEnumerator < SourceEnumerator
+
+    # Iterates over each row in the CSV files and yields it to the provided block.
+    # @yield [row] yields each row in the CSV file
+    def each &block
+      files.each do |file|
+        CSV.foreach file, headers: true do |row|
+          yield row
+        end
+      end
+    end
+  end
+end

data/lib/ds/recon/ds_mets_xml_enumerator.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Recon
+  class DsMetsXmlEnumerator < SourceEnumerator
+
+    # Iterates over each row in the CSV files and yields it to the provided block.
+    # @yield [row] yields the parsed METS XML record
+    def each &block
+      process_xml files do |record|
+        yield record
+      end
+    end
+  end
+end

data/lib/ds/recon/marc_xml_enumerator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Recon
+  class MarcXmlEnumerator < SourceEnumerator
+
+    def each &block
+      process_xml files, remove_namespaces: true do |xml|
+        xml.xpath('//record').each do |record|
+          yield record
+        end
+      end
+    end
+
+  end
+end

data/lib/ds/recon/recon_builder.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+# require_relative 'recon_config'
+require_relative 'type/recon_type'
+
+module Recon
+
+  ##
+  # A class to build recon CSV rows from DS data sources.#
+
+  class ReconBuilder
+    attr_reader :source_type
+    attr_reader :files
+    attr_reader :out_dir
+
+    # A hash mapping DS data source types to their corresponding enumerator classes
+    #
+    # Keys:
+    # - DS::Constants::DS_CSV
+    # - DS::Constants::MARC_XML
+    # - DS::Constants::TEI_XML
+    # - DS::Constants::DS_METS
+    #
+    # Values:
+    # - Recon::DsCsvEnumerator
+    # - Recon::MarcXmlEnumerator
+    # - Recon::TeiXmlEnumerator
+    # - Recon::DsMetsXmlEnumerator
+    SOURCE_TYPE_ENUMERATORS = {
+      DS::Constants::DS_CSV => Recon::DsCsvEnumerator,
+      DS::Constants::MARC_XML => Recon::MarcXmlEnumerator,
+      DS::Constants::TEI_XML => Recon::TeiXmlEnumerator,
+      DS::Constants::DS_METS => Recon::DsMetsXmlEnumerator,
+    }
+
+    # A hash mapping DS data source types to their corresponding extractor classes
+    #
+    # Keys:
+    # - DS::Constants::DS_CSV
+    # - DS::Constants::MARC_XML
+    # - DS::Constants::TEI_XML
+    # - DS::Constants::DS_METS
+    #
+    # Values:
+    # - DS::Extractor::DsCsv
+    # - DS::Extractor::MarcXml
+    # - DS::Extractor::TeiXml
+    # - DS::Extractor::DsMetsXml
+    SOURCE_TYPE_EXTRACTORS = {
+      DS::Constants::MARC_XML => DS::Extractor::MarcXmlExtractor,
+      DS::Constants::DS_CSV   => DS::Extractor::DsCsvExtractor,
+      DS::Constants::DS_METS  => DS::Extractor::DsMetsXmlExtractor,
+      DS::Constants::TEI_XML  => DS::Extractor::TeiXml
+    }
+
+    # @param [Symbol] source_type a valid DS data source type; e.g., DS::Constants::MARC_XML
+    # @param [Array] files an array of source file paths;e.g., +marc1.xml+, +marc2.xml+, etc.
+    # @param [String] out_dir a path to an output directory
+    def initialize source_type:, files:, out_dir:
+      @source_type = source_type
+      @files       = files
+      @out_dir     = out_dir
+    end
+
+    # @return [Recon::SourceEnumerator] an source enumerator type; e.g., Recon::MarcXmlEnumerator
+    def enumerator
+      return @enumerator if @enumerator.present?
+      klass = SOURCE_TYPE_ENUMERATORS[source_type]
+      raise "Unknown source type: #{source_type}" unless klass
+      @enumerator = klass.new files
+    end
+
+    # @return [DS::Extractor::MarcXml,DS::Extractor::DsCsvExtractor,DS::Extractor::DsMetsXml,DS::Extractor::TeiXml] an extractor type; e.g., DS::Extractor::MarcXml
+    def extractor
+      @extractor ||= SOURCE_TYPE_EXTRACTORS[source_type]
+    end
+
+    ##
+    # For each extracted term in of the given set type (like :places)
+    # yield the corresponding recon CSV row.
+    #
+    # Example:
+    #
+    #     # for a ReconBuilder for set of TEI files
+    #     CSV headers: true do |csv|
+    #       csv << Recon::Type::Places.csv_headers
+    #       recon_builder.each_recon(:places) do |recon|
+    #         csv << recon
+    #       end
+    #     end
+    #
+    # @param [Symbol] set_name a recon set name, like :places
+    # @yield [Hash<Symbol, String>] a block that yields recon rows
+    def each_recon set_name, &block
+      items = Set.new
+      recon_type = Recon.find_recon_type set_name
+
+      enumerator.each do |record|
+        [recon_type.method_name].flatten.each do |name|
+          next unless extractor.respond_to? name.to_sym
+          extractor.send(name.to_sym, record).each do |item|
+            next if items.include? item
+            items << item
+            yield build_recon recon_type: recon_type, item: item
+          end
+        end
+      end
+    end
+
+    # Find a recon type configuration by name
+    #
+    # @param [String] name the name of the recon type to find
+    # @return [Recon::Type::ReconType, nil] the recon type configuration if found, nil otherwise
+    def find_recon_type name
+      Recon::RECON_TYPES.find { |config| config.set_name == name.to_s }
+    end
+
+    # A function that replaces delimiters in a value based on a given
+    # delimiter map.
+    #
+    # @param value [String] the value to be processed
+    # @param delimiter_map [Hash] a hash containing the old and new
+    #   delimiters, e.g., for <tt>{ "|" => ";" }</tt> all +|+s will be
+    #   replaced with +;+s
+    # @return [String] the processed value with delimiters replaced
+    def fix_delimiters value, delimiter_map = {}
+      return value if delimiter_map.blank?
+      val = ''
+      delimiter_map.each  { |old, new| val = value.to_s.gsub old, new }
+      val
+    end
+
+    # Builds an array of recon CSV rows for each term in the given terms array
+    # using the given recon type configuration.
+    #
+    # @param terms [Array<DS::Extractor::BaseTerm>] an array of terms to build recon rows for
+    # @param recon_type [Recon::Type::ReconType] a recon type configuration
+    # @return [Array<Hash<Symbol,String>>] an array of recon CSV rows
+    def build_all_recons terms, recon_type
+      terms.map { |term| build_recon item: term, recon_type: recon_type }
+    end
+
+    # Build a single recon CSV row; e.g.,
+    #
+    #    { :language_as_recorded => "Arabic",
+    #      :language_code => "",
+    #      :authorized_label => "Arabic",
+    #      :structured_value => "Q13955" }
+    #
+    # @param [DS::Extractor::BaseTerm] item a term like a DS::Extractor::Place
+    # @param [Recon::Type::ReconType] recon_type a recon type configuration like Recon::Type::Places
+    # @return [Hash<Symbol,String>] a recon CSV row
+    def build_recon item:, recon_type:
+      recon_hash = item.to_h
+      key_values = recon_type.get_key_values recon_hash
+      recon_type.lookup_columns.each do |col|
+        val = Recon.lookup_single(recon_type.set_name, key_values: key_values, column: col)
+        recon_hash[col] = fix_delimiters val, recon_type.delimiter_map
+      end
+      recon_hash
+    end
+
+    private
+
+    ##
+    # Transform the recon hash
+    #
+    # Currently, we just replace the +as_recorded+ header with the type-specific
+    # +ReconType#as_recorded_column+, e.g., +language_as_recorded+
+    #
+    #
+    # @param recon_hash [Hash<Symbol,Object>] a hash of the CSV row
+    # @param recon_type [Recon::Type::ReconType] a ReconType like, ReconPlaces
+    # @return [Hash<Symbol,Object>]
+    def prep_row recon_hash:, recon_type:
+      row = recon_hash.dup
+      ar_value = row.delete :as_recorded
+      row[recon_type.as_recorded_column] = ar_value
+      row
+    end
+
+  end
+end

data/lib/ds/recon/recon_data.rb

@@ -0,0 +1,37 @@
+require 'git'
+require 'logger'
+
+module Recon
+  module ReconData
+    def self.update!
+      repo_name = Settings.recon.git_local_name
+      url       = Settings.recon.git_repo
+      branch    = Settings.recon.git_branch || 'main'
+      logger    = DS.logger
+
+      Dir.chdir local_dir do
+        unless File.exist? repo_name
+          puts Git.clone url, repo_name, branch: branch, remote: 'origin', log: logger
+        end
+        g = Git.open repo_name, log: logger
+        begin
+          puts g.fetch 'origin'
+          puts g.checkout branch
+          puts g.pull 'origin', branch
+        rescue Git::GitExecuteError => e
+          logger.warn { "Error executing git command" }
+          logger.warn { e.message }
+          STDERR.puts e.backtrace if ENV['DS_VERBOSE']
+        end
+      end
+    end
+
+    def self.local_dir
+      Settings.recon.local_dir
+    end
+    def self.repo_dir
+      File.join DS.root, Settings.recon.git_local_name
+    end
+
+  end
+end

data/lib/ds/recon/recon_manager.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Recon
+  class ReconManager
+
+    attr_reader :out_dir
+    attr_reader :source_type
+    attr_reader :files
+
+    # Initialize the ReconManager.
+    #
+    # @param source_type [Symbol] a valid DS data source type; e.g., DS::Constants::MARC_XML
+    # @param out_dir [String] the output directory path
+    # @param files [Array<String>] an array of source file paths; e.g., +marc1.xml+, +marc2.xml+, etc.
+    # @return [void]
+    def initialize source_type:, out_dir:, files:
+      @source_type   = source_type
+      @out_dir       = out_dir
+      @files         = files
+      @errors        = {}
+    end
+
+    # Write all recon CSV files.
+    #
+    # @return [Array<String>] the list of output files
+    def write_all_csvs
+      outfiles = []
+      Recon::RECON_TYPES.each do |recon_type|
+        outfiles << write_csv(recon_type)
+      end
+      outfiles
+    end
+
+    # Write a CSV file for a specific recon type.
+    #
+    # @param recon_type [Recon::Type::ReconType] the type of reconciliation data
+    # @return [String] the path to the output CSV file
+    def write_csv recon_type
+      outfile = File.join out_dir, "#{recon_type.set_name}.csv"
+      CSV.open(outfile, 'w+', headers: true) do |csv|
+        row_num = 0
+        csv << recon_type.recon_csv_headers
+        recon_builder.each_recon(recon_type.set_name) do |recon|
+          errors = Recon.validate_row(recon_type, recon, row_num: row_num += 1)
+          add_errors recon_type, errors unless errors.blank?
+          csv << recon
+        end
+      end
+      if has_errors?(recon_type)
+        raise DSError, "Error writing #{outfile}:\n#{errors_for_type(recon_type).join("\n")}"
+      end
+      outfile
+    end
+
+    # Initializes and returns a new instance of the Recon::ReconBuilder class with the specified output directory, source type, and files.
+    #
+    # @return [Recon::ReconBuilder] A new instance of the Recon::ReconBuilder class.
+    def recon_builder
+      @recon_builder ||= Recon::ReconBuilder.new(
+        out_dir: out_dir, source_type: source_type, files: files
+      )
+    end
+
+    # Adds errors to the specified recon type.
+    #
+    # @param recon_type [ReconType] the recon type to add errors to
+    # @param messages [Array<String>] the errors to add
+    # @return [void]
+    def add_errors recon_type, messages
+      @errors[recon_type.set_name] ||= []
+      @errors[recon_type.set_name] += messages
+      nil
+    end
+
+    # Returns true if errors exist for the specified recon type.
+    #
+    # @param recon_type [ReconType] the recon type
+    # @return [Boolean] true if errors exist
+    def has_errors? recon_type
+      errors_for_type(recon_type).present?
+    end
+
+    # Returns the list of errors for the specified recon type.
+    #
+    # @param recon_type [ReconType] the recon type
+    # @return [Array<String>] the list of errors
+    def errors_for_type recon_type
+      @errors[recon_type.set_name]
+    end
+
+  end
+end