#399

backend/app/services/post_import_previewer.rb

@@ -8,119 +8,15 @@ class PostImportPreviewer
     'tags',
     'parent_post_ids',
   ].freeze
-
-  def initialize parsed:, url_column:, mappings: { }, existing: 'skip'
-    @parsed = parsed
-    @url_column = url_column.to_i
-    @mappings = mappings.stringify_keys
+  def initialize existing: 'skip'
     @existing = existing == 'error' ? 'error' : 'skip'
   end
 
-  def preview
-    preview_rows(rows: @parsed[:rows])
-  end
-
   def preview_rows rows:, fetch_metadata: true, metadata_cache: { }
-    urls = { }
-    rows.map do |row|
-      row = row.symbolize_keys
-      values = row[:values] || []
-      attributes = row[:attributes]&.stringify_keys || FIELDS.to_h { |field|
-        [field, mapped_value(field, values)]
-      }
-      provenance = row[:provenance]&.stringify_keys || mapped_provenance(attributes)
-      tag_sources =
-        row[:tag_sources]&.stringify_keys || initial_tag_sources(attributes, provenance)
-      tag_sources['manual'] = attributes['tags'].to_s if provenance['tags'] == 'manual'
-      url = row[:url].presence || values[@url_column].to_s.strip
-      provenance['url'] ||= row[:url].present? ? 'manual' : 'mapped'
-      url_for_metadata = normalised_url(url) || url
-      existing_post = normalised_url(url).present? && Post.exists?(url: normalised_url(url))
-      if existing_post && @existing == 'skip'
-        next {
-          source_row: row[:source_row],
-          url: normalised_url(url) || url,
-          attributes:,
-          provenance:,
-          tag_sources:,
-          metadata_url: url_for_metadata,
-          fetch_warnings: [],
-          validation_warnings: ['既存投稿のためスキップします．'],
-          warnings: ['既存投稿のためスキップします．'],
-          validation_errors: { },
-          status: 'warning',
-          existing: true,
-        }
-      end
-      url_changed = row[:metadata_url].present? && row[:metadata_url] != url_for_metadata
-      clear_automatic_values!(attributes, provenance, tag_sources) if url_changed
-      attributes['url'] = url
-      fetch_warnings = Array(row[:fetch_warnings]).dup
-      should_fetch =
-          case fetch_metadata
-          when true then true
-          when Integer then fetch_metadata == row[:source_row].to_i
-          when false, nil then false
-          else raise ArgumentError, 'メタデータ取得対象が不正です．'
-          end
-      metadata, fetch_warnings =
-        metadata_for(url_for_metadata, should_fetch, metadata_cache, fetch_warnings)
-      metadata.each do |field, value|
-        if field == 'tags' && provenance[field] != 'manual'
-          tag_sources['automatic'] = value.to_s
-          attributes[field] = merged_tags(tag_sources)
-          next
-        end
-        next unless provenance[field] == 'automatic' || attributes[field].blank?
-
-        attributes[field] = value
-        provenance[field] = 'automatic'
-      end
-      normal_url = normalised_url(url)
-      errors = { }
-      errors[:url] = ['URL が不正です．'] if normal_url.blank?
-      validation_warnings = []
-      errors[:url] = ['URL が重複しています．'] if normal_url.present? && urls.key?(normal_url)
-      urls[normal_url] = true if normal_url.present?
-      if normal_url.present? && existing_post
-        if @existing == 'error'
-          errors[:url] = ['既存投稿です．']
-        else
-          validation_warnings << '既存投稿のためスキップします．'
-        end
-      end
-      validate_basic_data(attributes, errors)
-      validate_preview_tags(
-        merged_tags(tag_sources, provenance['tags']),
-        errors,
-        validation_warnings,
-      )
-      validate_parents(attributes['parent_post_ids'], errors)
-      attributes.delete('url')
-      attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
-      {
-        source_row: row[:source_row],
-        url: normal_url || url,
-        attributes:,
-        provenance:,
-        tag_sources:,
-        metadata_url: url_for_metadata,
-        fetch_warnings:,
-        validation_warnings:,
-        warnings: fetch_warnings + validation_warnings,
-        validation_errors: errors,
-        status: errors.present? \
-                  ? 'error' \
-                  : ((fetch_warnings + validation_warnings).present? ? 'warning' : 'ready'),
-        existing: normal_url.present? && Post.exists?(url: normal_url),
-      }
-    end
-  end
-
-  def metadata_for url, fetch_metadata, cache, previous_warnings
-    return [{ }, previous_warnings] unless fetch_metadata
-
-    cache[url] ||= fetch_metadata(url)
+    urls = {}
+    rows.map { |row|
+      preview_row(row, urls:, fetch_metadata:, metadata_cache:)
+    }
   end
 
   def normalised_url value
@@ -129,43 +25,97 @@ class PostImportPreviewer
 
   private
 
-  def mapped_value field, values
-    mapping = @mappings[field]
-    return '' if mapping.blank?
-    return mapping['value'].to_s if mapping['kind'] == 'fixed'
+  def preview_row row, urls:, fetch_metadata:, metadata_cache:
+    row = row.symbolize_keys
+    attributes = initial_attributes(row)
+    provenance = initial_provenance(row)
+    tag_sources = initial_tag_sources(row, attributes, provenance)
+    url = row[:url].to_s.strip
+    provenance['url'] = 'manual'
+    normal_url = normalised_url(url)
+    url_for_metadata = normal_url || url
+    existing_post = normal_url.present? && Post.exists?(url: normal_url)
 
-    Array(mapping['columns']).filter_map { |index|
-      values[index.to_i].to_s.presence
-    }.join(field == 'tags' ? ' ' : '')
-  end
+    validation_warnings = []
+    validation_errors = {}
+    validation_errors[:url] = ['URL が不正です．'] if normal_url.blank?
+    validation_errors[:url] = ['URL が重複しています．'] if normal_url.present? && urls.key?(normal_url)
+    urls[normal_url] = true if normal_url.present?
+    if normal_url.present? && existing_post
+      if @existing == 'error'
+        validation_errors[:url] = ['既存投稿です．']
+      else
+        validation_warnings << '既存投稿のためスキップします．'
+      end
+    end
 
-  def mapped_provenance attributes
-    attributes.to_h.to_h { |field, value|
-      mapping = @mappings[field.to_s]
-      origin =
-          if value.present? && mapping&.[]('kind') == 'fixed'
-            'fixed'
-          elsif value.present?
-            'mapped'
-          else
-            'automatic'
-          end
-      [field.to_s, origin]
+    if row[:metadata_url].present? && row[:metadata_url] != url_for_metadata
+      clear_automatic_values!(attributes, provenance, tag_sources)
+    end
+
+    fetch_warnings = Array(row[:fetch_warnings]).dup
+    should_fetch = should_fetch_metadata?(fetch_metadata, row[:source_row].to_i)
+    if should_fetch && !(existing_post && @existing == 'skip')
+      metadata, fetch_warnings =
+        metadata_for(url_for_metadata, metadata_cache, fetch_warnings)
+      apply_metadata!(attributes, provenance, tag_sources, metadata)
+    end
+
+    attributes['url'] = url
+    validate_basic_data(attributes, validation_errors)
+    validate_preview_tags(
+      merged_tags(tag_sources, provenance['tags']),
+      validation_errors,
+      validation_warnings,
+    )
+    validate_parents(attributes['parent_post_ids'], validation_errors)
+    attributes.delete('url')
+    attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
+
+    {
+      source_row: row[:source_row],
+      url: normal_url || url,
+      attributes:,
+      provenance:,
+      tag_sources:,
+      metadata_url: url_for_metadata,
+      fetch_warnings:,
+      validation_warnings:,
+      warnings: fetch_warnings + validation_warnings,
+      validation_errors:,
+      status: validation_errors.present? \
+                ? 'error' \
+                : ((fetch_warnings + validation_warnings).present? ? 'warning' : 'ready'),
+      existing: existing_post,
     }
   end
 
-  def initial_tag_sources attributes, provenance
-    origin = provenance['tags'] == 'fixed' ? 'fixed' : 'mapped'
-    { 'automatic' => '', 'mapped' => origin == 'mapped' ? attributes['tags'].to_s : '',
-      'fixed' => origin == 'fixed' ? attributes['tags'].to_s : '', 'manual' => '' }
+  def should_fetch_metadata? fetch_metadata, source_row
+    case fetch_metadata
+    when true then true
+    when Integer then fetch_metadata == source_row
+    when false, nil then false
+    else raise ArgumentError, 'メタデータ取得対象が不正です．'
+    end
   end
 
-  def merged_tags sources, origin = nil
-    return sources['manual'].to_s if origin == 'manual'
+  def initial_attributes row
+    attributes = row[:attributes]&.stringify_keys || {}
+    FIELDS.to_h { |field| [field, attributes[field].to_s] }
+  end
 
-    ['automatic', 'mapped', 'fixed', 'manual'].flat_map {
-      sources[_1].to_s.split
-    }.uniq.join(' ')
+  def initial_provenance row
+    provenance = row[:provenance]&.stringify_keys || {}
+    FIELDS.to_h { |field| [field, provenance[field].presence || 'automatic'] }
+      .merge('url' => 'manual')
+  end
+
+  def initial_tag_sources row, attributes, provenance
+    sources = row[:tag_sources]&.stringify_keys || { 'automatic' => '', 'manual' => '' }
+    sources['automatic'] = sources['automatic'].to_s
+    sources['manual'] =
+      provenance['tags'] == 'manual' ? attributes['tags'].to_s : sources['manual'].to_s
+    sources
   end
 
   def clear_automatic_values! attributes, provenance, tag_sources
@@ -174,10 +124,15 @@ class PostImportPreviewer
       attributes[field] = '' if provenance[field] == 'automatic'
     end
     tag_sources['automatic'] = ''
+    attributes['tags'] = merged_tags(tag_sources, provenance['tags'])
+  end
+
+  def metadata_for url, cache, previous_warnings
+    cache[url] ||= fetch_metadata(url)
   end
 
   def fetch_metadata url
-    return [{ }, ['URL が空です．']] if url.blank?
+    return [{}, ['URL が空です．']] if url.blank?
 
     data = PostMetadataFetcher.fetch(url).stringify_keys
     warnings = []
@@ -191,7 +146,29 @@ class PostImportPreviewer
       "post_import_metadata_fetch_failure "\
       "#{ { error: e.class.name, message: e.message }.to_json }",
     )
-    [{ }, ['メタデータを取得できませんでした．']]
+    [{}, ['メタデータを取得できませんでした．']]
+  end
+
+  def apply_metadata! attributes, provenance, tag_sources, metadata
+    metadata.each do |field, value|
+      if field == 'tags'
+        next if provenance['tags'] == 'manual'
+
+        tag_sources['automatic'] = value.to_s
+        attributes['tags'] = merged_tags(tag_sources)
+        next
+      end
+      next unless provenance[field] == 'automatic' || attributes[field].blank?
+
+      attributes[field] = value
+      provenance[field] = 'automatic'
+    end
+  end
+
+  def merged_tags sources, origin = nil
+    return sources['manual'].to_s if origin == 'manual'
+
+    sources['automatic'].to_s
   end
 
   def validate_preview_tags raw, errors, warnings
@@ -201,6 +178,7 @@ class PostImportPreviewer
       errors[:tags] = ['ニコニコ・タグは直接指定できません．']
       return
     end
+
     parsed = names.map { |name| TagName.canonicalise(name.sub(/\[.*\]\z/, '')).first }
     existing = Tag.joins(:tag_name).where(tag_names: { name: parsed }).includes(:tag_name).to_a
     deprecated = existing.select(&:deprecated?).map(&:name)