bulkrax 9.3.5 → 9.4.1

data/app/services/bulkrax/csv_template/field_analyzer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Analyzes model fields and schemas
+    class FieldAnalyzer
+      attr_reader :field_list
+
+      def initialize(mappings, admin_set_id = nil)
+        @mappings = mappings
+        @field_list = []
+        @schema = nil
+        @admin_set_id = admin_set_id
+      end
+
+      def find_or_create_field_list_for(model_name:)
+        existing = @field_list.find { |entry| entry.key?(model_name) }
+        return existing if existing.present?
+
+        klass = CsvTemplate::ModelLoader.determine_klass_for(model_name)
+        return {} if klass.nil?
+
+        model_entry = build_field_list_entry(model_name, klass)
+        @field_list << model_entry
+        model_entry
+      end
+
+      def controlled_vocab_terms
+        @field_list.flat_map do |hash|
+          hash.values.flat_map { |data| data["controlled_vocab_terms"] || [] }
+        end.uniq
+      end
+
+      private
+
+      def build_field_list_entry(model_name, klass)
+        schema_analyzer = CsvTemplate::SchemaAnalyzer.new(klass: klass, admin_set_id: @admin_set_id)
+        {
+          model_name => {
+            'properties' => extract_properties(klass),
+            'required_terms' => schema_analyzer.required_terms,
+            'controlled_vocab_terms' => schema_analyzer.controlled_vocab_terms
+          }
+        }
+      end
+
+      def extract_properties(klass)
+        if klass.respond_to?(:schema)
+          Bulkrax::ValkyrieObjectFactory.schema_properties(klass: klass, admin_set_id: @admin_set_id).map(&:to_s)
+        else
+          klass.properties.keys.map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/file_path_generator.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Utility class for generating template file paths
+    class FilePathGenerator
+      TEMPLATE_PREFIX = 'import_template'
+
+      def self.default_path(admin_set_id)
+        context = load_context(admin_set_id)
+        tenant = load_tenant
+        filename = build_filename(context, tenant)
+        path = Rails.root.join('tmp', 'imports', filename)
+        FileUtils.mkdir_p(path.dirname.to_s)
+        path
+      end
+
+      def self.load_context(admin_set_id)
+        return nil if admin_set_id.blank?
+
+        admin_set = Bulkrax.object_factory.find(admin_set_id)
+        admin_set.respond_to?(:contexts) ? admin_set.contexts.first : nil
+      end
+
+      def self.load_tenant
+        return nil unless defined?(Apartment::Tenant) && defined?(Account)
+
+        tenant_id = Apartment::Tenant.current
+        return nil if tenant_id.blank?
+
+        Account.find_by(tenant: tenant_id)&.name
+      end
+
+      def self.build_filename(context, tenant)
+        parts = [TEMPLATE_PREFIX]
+        parts << "context-#{context}" if context.present?
+        parts << "tenant-#{tenant}" if tenant.present?
+        parts << timestamp
+        "#{parts.join('_')}.csv"
+      end
+
+      def self.timestamp
+        Time.current.utc.strftime('%Y%m%d_%H%M%S')
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/file_validator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    ##
+    # Validates file references in CSV against zip archive contents
+    class FileValidator
+      attr_reader :csv_data, :zip_file
+
+      def initialize(csv_data, zip_file = nil, admin_set_id = nil)
+        @csv_data = csv_data
+        @zip_file = zip_file
+        @admin_set_id = admin_set_id
+      end
+
+      def count_references
+        @csv_data.count { |item| item[:file].present? }
+      end
+
+      def missing_files
+        return [] unless @zip_file
+
+        referenced_files - zip_file_list
+      end
+
+      def found_files_count
+        return 0 unless @zip_file
+
+        (referenced_files & zip_file_list).count
+      end
+
+      def zip_included?
+        @zip_file.present?
+      end
+
+      def possible_missing_files?
+        return false unless referenced_files.any?
+        return true if @zip_file.blank?
+
+        false
+      end
+
+      private
+
+      def referenced_files
+        @referenced_files ||= @csv_data.flat_map do |item|
+          next [] if item[:file].blank?
+
+          item[:file].split(Bulkrax.multi_value_element_split_on).map { |f| File.basename(f.strip) }
+        end.compact
+      end
+
+      def zip_file_list
+        @zip_file_list ||= begin
+          return [] unless @zip_file
+
+          zip_path = @zip_file.respond_to?(:path) ? @zip_file.path : @zip_file
+          Zip::File.open(zip_path) do |zip|
+            zip.entries.select(&:file?).map { |entry| File.basename(entry.name) }
+          end
+                           rescue StandardError => e
+                             Rails.logger.error("Error reading zip file: #{e.message}")
+                             []
+        end
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/mapping_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Handles loading and filtering of Bulkrax field mappings
+    class MappingManager
+      attr_reader :mappings
+
+      def initialize
+        @mappings = load_mappings
+      end
+
+      def mapped_to_key(column_str)
+        @mappings.find { |_k, v| v["from"].include?(column_str) }&.first || column_str
+      end
+
+      def key_to_mapped_column(key)
+        @mappings.dig(key, "from")&.first || key
+      end
+
+      def find_by_flag(field_name, default)
+        @mappings.find { |_k, v| v[field_name] == true }&.first || default
+      end
+
+      def split_value_for(mapping_key)
+        @mappings.dig(mapping_key, "split")
+      end
+
+      def resolve_column_name(key: nil, flag: nil, default: nil)
+        if flag
+          mapped_key = find_by_flag(flag, nil)
+          if mapped_key
+            mapped_options = @mappings.dig(mapped_key, "from") || []
+            return mapped_options if mapped_options.any?
+          end
+        end
+
+        if key
+          mapped_options = @mappings.dig(key, "from") || []
+          return mapped_options if mapped_options.any?
+        end
+
+        default ? [default] : []
+      end
+
+      private
+
+      def load_mappings
+        Bulkrax.field_mappings["Bulkrax::CsvParser"].reject do |_key, value|
+          value["generated"] == true
+        end
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/model_loader.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Handles model loading based on configuration
+    class ModelLoader
+      attr_reader :models
+
+      def initialize(models)
+        @models = load_models(models)
+      end
+
+      def self.determine_klass_for(model_name)
+        if Bulkrax.config.object_factory == Bulkrax::ValkyrieObjectFactory
+          Valkyrie.config.resource_class_resolver.call(model_name)
+        else
+          model_name.constantize
+        end
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def load_models(models)
+        case models
+        when Array
+          return all_available_models if models.empty?
+          return all_available_models if models.include?('all')
+          models.filter_map { |model| safe_constantize(model) }
+        else
+          all_available_models
+        end
+      rescue StandardError
+        []
+      end
+
+      def safe_constantize(model_name)
+        model_name.constantize && model_name
+      rescue NameError
+        nil
+      end
+
+      def all_available_models
+        Hyrax.config.curation_concerns.map(&:name) +
+          [Bulkrax.collection_model_class&.name, Bulkrax.file_model_class&.name].compact
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/row_builder.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Builds CSV rows (explanations and model data)
+    class RowBuilder
+      def initialize(service)
+        @service = service
+        @explanation_builder = CsvTemplate::ExplanationBuilder.new(service)
+        @value_determiner = CsvTemplate::ValueDeterminer.new(service)
+      end
+
+      def build_explanation_row(header_row)
+        @explanation_builder.build_explanations(header_row).map { |prop| prop.values.join(" ") }
+      end
+
+      def build_model_rows(header_row)
+        @service.all_models.map { |m| model_breakdown(m, header_row) }
+      end
+
+      private
+
+      def model_breakdown(model_name, header_row)
+        klass = CsvTemplate::ModelLoader.determine_klass_for(model_name)
+        return [] if klass.nil?
+
+        field_list = @service.field_analyzer.find_or_create_field_list_for(model_name: model_name)
+
+        header_row.map do |column|
+          @value_determiner.determine_value(column, model_name, field_list)
+        end
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/schema_analyzer.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Analyzes model schemas for required and controlled vocabulary fields
+    class SchemaAnalyzer
+      def initialize(klass:, admin_set_id: nil)
+        @klass = klass
+        @admin_set_id = admin_set_id
+        @schema = load_schema
+      end
+
+      def required_terms
+        return [] if @schema.blank?
+
+        @schema.select do |field|
+          field.respond_to?(:meta) &&
+            field.meta["form"].is_a?(Hash) &&
+            field.meta["form"]["required"] == true
+        end.map(&:name).map(&:to_s)
+      rescue StandardError
+        []
+      end
+
+      def controlled_vocab_terms
+        return [] unless @schema
+
+        controlled_properties = extract_controlled_properties
+        controlled_properties.empty? ? registered_controlled_vocab_fields : controlled_properties
+      rescue StandardError
+        []
+      end
+
+      private
+
+      def load_schema
+        return nil unless @klass.respond_to?(:schema)
+
+        if @admin_set_id.present? && defined?(Hyrax) && Hyrax.respond_to?(:schema_for)
+          Hyrax.schema_for(klass: @klass, admin_set_id: @admin_set_id)
+        else
+          @klass.new.singleton_class.schema || @klass.schema
+        end
+      rescue StandardError
+        nil
+      end
+
+      def extract_controlled_properties
+        return [] unless @schema
+
+        @schema.filter_map do |property|
+          next unless property.respond_to?(:meta)
+          sources = property.meta&.dig('controlled_values', 'sources')
+          next if sources.nil? || sources == ['null'] || sources == 'null'
+          property.name.to_s
+        end
+      end
+
+      def registered_controlled_vocab_fields
+        qa_registry.filter_map do |k, v|
+          k.singularize if v.klass == Qa::Authorities::Local::FileBasedAuthority
+        end
+      end
+
+      def qa_registry
+        @qa_registry ||= Qa::Authorities::Local.registry.instance_variable_get('@hash')
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/split_formatter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Formats split pattern descriptions
+    class SplitFormatter
+      def format(split_value)
+        return "Property does not split." if split_value.nil?
+
+        if split_value == true
+          parse_pattern(Bulkrax.multi_value_element_split_on.source)
+        elsif split_value.is_a?(String)
+          parse_pattern(split_value)
+        else
+          split_value
+        end
+      end
+
+      private
+
+      def parse_pattern(pattern)
+        chars = extract_characters(pattern)
+        format_message(chars)
+      end
+
+      def extract_characters(pattern)
+        if (match = pattern.match(/\[([^\]]+)\]/))
+          match[1]
+        elsif (single = pattern.match(/\\(.)/))
+          single[1]
+        else
+          pattern
+        end
+      end
+
+      def format_message(chars)
+        formatted = chars.chars.then do |c|
+          c.length > 1 ? "#{c[0..-2].join(' ')}, or #{c.last}" : c.first
+        end
+        "Split multiple values with #{formatted}"
+      end
+    end
+  end
+end

data/app/services/bulkrax/csv_template/value_determiner.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Bulkrax
+  module CsvTemplate
+    # Determines values for CSV cells
+    class ValueDeterminer
+      def initialize(service)
+        @service = service
+        @column_builder = CsvTemplate::ColumnBuilder.new(service)
+      end
+
+      def determine_value(column, model_name, field_list)
+        key = @service.mapping_manager.mapped_to_key(column)
+        required_terms = field_list.dig(model_name, 'required_terms')
+
+        if field_list.dig(model_name, "properties")&.include?(key)
+          mark_required_or_optional(key, required_terms)
+        elsif special_column?(column, key)
+          special_value(column, key, model_name, required_terms)
+        end
+      end
+
+      private
+
+      def special_column?(column, key)
+        descriptor = CsvTemplate::ColumnDescriptor.new
+        visibility_cols = descriptor.send(:extract_column_names, :visibility)
+
+        key.in?(['model', 'work_type']) ||
+          column.in?(visibility_cols) ||
+          column == 'source_identifier' ||
+          column == 'rights_statement' ||
+          relationship_column?(column) ||
+          file_column?(column)
+      end
+
+      def special_value(column, key, model_name, required_terms)
+        return CsvTemplate::ModelLoader.determine_klass_for(model_name).to_s if key.in?(['model', 'work_type'])
+        return 'Required' if column == 'source_identifier'
+        return mark_required_or_optional(key, required_terms) if column == 'rights_statement'
+        return nil if file_column?(column) && model_name.in?([Bulkrax.collection_model_class].compact.map(&:to_s))
+        'Optional'
+      end
+
+      def mark_required_or_optional(field, required_terms)
+        return 'Unknown' unless required_terms
+        required_terms.include?(field) ? 'Required' : 'Optional'
+      end
+
+      def relationship_column?(column)
+        relationships = [
+          @service.mapping_manager.find_by_flag("related_children_field_mapping", 'children'),
+          @service.mapping_manager.find_by_flag("related_parents_field_mapping", 'parents')
+        ]
+        column.in?(relationships)
+      end
+
+      def file_column?(column)
+        file_cols = CsvTemplate::ColumnDescriptor::COLUMN_DESCRIPTIONS[:files].flat_map do |property_hash|
+          property_hash.keys.filter_map do |key|
+            @service.mappings.dig(key, "from")&.first
+          end
+        end
+        column.in?(file_cols)
+      end
+    end
+  end
+end