244 行
9.0 KiB
Ruby
244 行
9.0 KiB
Ruby
class PostImportsController < ApplicationController
|
|
MAPPING_PROPERTIES = ['kind', 'value', 'columns'].freeze
|
|
MAPPING_KINDS = ['columns', 'fixed'].freeze
|
|
|
|
before_action :require_member!
|
|
|
|
def parse
|
|
source =
|
|
if params[:format] == 'google_sheets'
|
|
PostImportGoogleSheetsFetcher.fetch!(params[:source],
|
|
rate_key: current_user.id)
|
|
else
|
|
params[:source]
|
|
end
|
|
format = params[:format] == 'google_sheets' ? 'csv' : params[:format]
|
|
parsed = PostImportSourceParser.new(
|
|
source:,
|
|
format:,
|
|
has_header: params[:has_header],
|
|
json_path: params[:json_path]).parse
|
|
render json: parsed
|
|
rescue ArgumentError => e
|
|
render_bad_request(e.message)
|
|
end
|
|
|
|
def preview
|
|
parsed = parsed_params
|
|
raw_url_column = params[:url_column].presence || (parsed[:columns].length == 1 ? 0 : nil)
|
|
return render_bad_request('URL 列を選択してください．') if raw_url_column.nil?
|
|
|
|
url_column = Integer(raw_url_column, exception: false)
|
|
if url_column.nil? || url_column.negative? || url_column >= parsed[:columns].length
|
|
return render_bad_request('URL 列が不正です．')
|
|
end
|
|
|
|
rows = PostImportPreviewer.new(
|
|
parsed:,
|
|
url_column:,
|
|
mappings: mappings_params(parsed[:columns].length),
|
|
existing: params[:existing]).preview
|
|
render json: parsed.slice(:columns).merge(rows:)
|
|
rescue ArgumentError => e
|
|
render_bad_request(e.message)
|
|
end
|
|
|
|
def validate
|
|
rows = validate_rows_params
|
|
changed_row = Integer(params[:changed_row], exception: false)
|
|
result =
|
|
PostImportPreviewer.new(
|
|
parsed: { columns: [], rows: [] },
|
|
url_column: 0,
|
|
mappings: {},
|
|
existing: params[:existing])
|
|
.preview_rows(rows:, fetch_metadata: changed_row, metadata_cache: {})
|
|
render json: { rows: result }
|
|
rescue ArgumentError => e
|
|
render_bad_request(e.message)
|
|
end
|
|
|
|
def create
|
|
result = PostImportRunner.new(
|
|
actor: current_user,
|
|
rows: create_rows_params,
|
|
existing: params[:existing]).run
|
|
render json: result, status: result[:created].positive? ? :created : :ok
|
|
rescue ArgumentError => e
|
|
render_bad_request(e.message)
|
|
end
|
|
|
|
private
|
|
|
|
def require_member!
|
|
return head :unauthorized unless current_user
|
|
return if current_user.gte_member?
|
|
|
|
head :forbidden
|
|
end
|
|
|
|
def parsed_params
|
|
value = params.require(:parsed).to_unsafe_h.deep_transform_keys { _1.to_s.underscore }
|
|
columns = Array(value['columns'])
|
|
rows = Array(value['rows'])
|
|
unless columns.all?(Hash) && rows.all?(Hash)
|
|
raise ArgumentError, '解析結果の形式が不正です．'
|
|
end
|
|
raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportSourceParser::MAX_ROWS
|
|
raise ArgumentError, '列数が多すぎます．' if columns.length > 50
|
|
raise ArgumentError, '解析結果のセルが不正です．' unless rows.all? { |row|
|
|
values = Array(row['values'])
|
|
values.length <= columns.length && values.all? { |value|
|
|
value.is_a?(String) && value.bytesize <= PostImportSourceParser::MAX_CELL_BYTES
|
|
}
|
|
}
|
|
if rows.sum { Array(_1['values']).sum(&:bytesize) } > PostImportSourceParser::MAX_BYTES
|
|
raise ArgumentError, '解析結果が大きすぎます．'
|
|
end
|
|
|
|
parsed_rows = rows.map do |row|
|
|
source_row = Integer(row['source_row'], exception: false)
|
|
raise ArgumentError, '元行番号が不正です．' if source_row.nil? || source_row <= 0
|
|
|
|
{ source_row:, values: Array(row['values']) }
|
|
end
|
|
if parsed_rows.map { _1[:source_row] }.uniq.length != parsed_rows.length
|
|
raise ArgumentError, '元行番号が重複しています．'
|
|
end
|
|
|
|
{ columns: columns.map { |column| column.slice('key', 'label') }, rows: parsed_rows }
|
|
end
|
|
|
|
def mappings_params column_count
|
|
mappings = params[:mappings]
|
|
return { } if mappings.blank?
|
|
raise ArgumentError, '列割当ての形式が不正です．' unless mappings.is_a?(ActionController::Parameters)
|
|
|
|
raw = mappings.to_unsafe_h
|
|
unknown_fields = raw.keys - PostImportPreviewer::FIELDS
|
|
raise ArgumentError, '列割当て先が不正です．' if unknown_fields.present?
|
|
|
|
permitted =
|
|
mappings.permit(*PostImportPreviewer::FIELDS.map { |field|
|
|
{ field => [:kind, :value, { columns: [] }] }
|
|
}).to_h
|
|
|
|
raw.each_with_object({ }) do |(field, value), result|
|
|
raise ArgumentError, '列割当ての形式が不正です．' unless value.is_a?(Hash)
|
|
unless (value.keys - MAPPING_PROPERTIES).empty?
|
|
raise ArgumentError, '列割当ての項目が不正です．'
|
|
end
|
|
|
|
value = permitted.fetch(field)
|
|
kind = value['kind'].presence || 'columns'
|
|
raise ArgumentError, '列割当ての種別が不正です．' unless kind.in?(MAPPING_KINDS)
|
|
columns = value['columns']
|
|
raise ArgumentError, '列番号が不正です．' unless (
|
|
columns.nil? || (columns.is_a?(Array) && columns.all? { |index|
|
|
parsed = Integer(index, exception: false)
|
|
parsed && parsed >= 0 && parsed < column_count
|
|
})
|
|
)
|
|
raise ArgumentError, '列番号が重複しています．' if Array(columns).uniq.length != Array(columns).length
|
|
raise ArgumentError, '固定値が不正です．' if kind == 'fixed' && !value['value'].is_a?(String)
|
|
|
|
result[field] = {
|
|
'kind' => kind,
|
|
'value' => value['value'].to_s,
|
|
'columns' => Array(columns).map { Integer(_1) } }
|
|
end
|
|
end
|
|
|
|
def validate_rows_params
|
|
rows = params[:rows]
|
|
raise ArgumentError, '取込件数が多すぎます．' unless rows.is_a?(Array)
|
|
raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportSourceParser::MAX_ROWS
|
|
|
|
normalised_rows = rows.map do |row|
|
|
unless row.is_a?(Hash) || row.is_a?(ActionController::Parameters)
|
|
raise ArgumentError, '行の形式が不正です．'
|
|
end
|
|
|
|
value = ActionController::Parameters.new(row).permit(
|
|
:source_row,
|
|
:sourceRow,
|
|
:url,
|
|
:metadata_url,
|
|
:metadataUrl,
|
|
attributes: {},
|
|
provenance: {},
|
|
tag_sources: {},
|
|
tagSources: {},
|
|
fetch_warnings: [],
|
|
fetchWarnings: [],
|
|
validation_warnings: [],
|
|
validationWarnings: [])
|
|
normalised = value.to_h.deep_transform_keys { _1.to_s.underscore }
|
|
attributes = normalised.fetch('attributes', { })
|
|
provenance = normalised.fetch('provenance', { })
|
|
allowed = PostImportPreviewer::FIELDS
|
|
unless attributes.is_a?(Hash) && provenance.is_a?(Hash) &&
|
|
(attributes.keys - allowed).empty? &&
|
|
(provenance.keys - (allowed + ['url'])).empty?
|
|
raise ArgumentError, '行の形式が不正です．'
|
|
end
|
|
unless provenance.values.all? { _1.in?(['automatic', 'mapped', 'fixed', 'manual']) }
|
|
raise ArgumentError, '値の由来が不正です．'
|
|
end
|
|
raise ArgumentError, 'セルが大きすぎます．' if [normalised['url'], *attributes.values].any? { |value|
|
|
value.to_s.bytesize > PostImportSourceParser::MAX_CELL_BYTES
|
|
}
|
|
if normalised['tag_sources'].present? &&
|
|
(!normalised['tag_sources'].is_a?(Hash) ||
|
|
(normalised['tag_sources'].keys - ['automatic', 'mapped', 'fixed', 'manual']).present?)
|
|
raise ArgumentError, 'タグ由来の形式が不正です．'
|
|
end
|
|
if (normalised['tag_sources'].present? &&
|
|
(!normalised['tag_sources'].values.all?(String) ||
|
|
normalised['tag_sources'].values.any? { |value|
|
|
value.bytesize > PostImportSourceParser::MAX_CELL_BYTES
|
|
} ||
|
|
(normalised['tag_sources'].values.sum(&:bytesize) >
|
|
PostImportSourceParser::MAX_CELL_BYTES)))
|
|
raise ArgumentError, 'タグ由来が大きすぎます．'
|
|
end
|
|
|
|
source_row = Integer(normalised['source_row'], exception: false)
|
|
raise ArgumentError, '元行番号が不正です．' if source_row.nil? || source_row <= 0
|
|
|
|
normalised['source_row'] = source_row
|
|
normalised.symbolize_keys
|
|
end
|
|
source_rows = normalised_rows.map { _1[:source_row] }
|
|
if source_rows.uniq.length != source_rows.length
|
|
raise ArgumentError, '元行番号が不正です．'
|
|
end
|
|
|
|
normalised_rows
|
|
end
|
|
|
|
def create_rows_params
|
|
rows = params[:rows]
|
|
raise ArgumentError, '取込行の形式が不正です．' unless rows.is_a?(Array)
|
|
|
|
rows.map do |row|
|
|
unless row.is_a?(Hash) || row.is_a?(ActionController::Parameters)
|
|
raise ArgumentError, '取込行の形式が不正です．'
|
|
end
|
|
|
|
parameters =
|
|
row.is_a?(ActionController::Parameters) ? row : ActionController::Parameters.new(row)
|
|
parameters.permit(
|
|
:source_row,
|
|
:sourceRow,
|
|
:url,
|
|
:metadata_url,
|
|
:metadataUrl,
|
|
attributes: {},
|
|
provenance: {},
|
|
tag_sources: {},
|
|
tagSources: {}).to_h
|
|
end
|
|
end
|
|
end
|