177 行
8.0 KiB
Ruby
177 行
8.0 KiB
Ruby
class PostImportsController < ApplicationController
|
|
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
|
|
url_column = params[:url_column].presence || (parsed[:columns].length == 1 ? 0 : nil)
|
|
return render_bad_request('URL 列を選択してください．') if url_column.nil?
|
|
|
|
rows = PostImportPreviewer.new(parsed:, url_column:, mappings: mappings_params,
|
|
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'])
|
|
raise ArgumentError, '解析結果の形式が不正です．' unless columns.all?(Hash) && rows.all?(Hash)
|
|
raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportSourceParser::MAX_ROWS
|
|
raise ArgumentError, '列数が多すぎます．' if columns.length > 50
|
|
unless rows.all? { |row| Array(row['values']).length <= columns.length &&
|
|
Array(row['values']).all? { _1.is_a?(String) && _1.bytesize <= PostImportSourceParser::MAX_CELL_BYTES } }
|
|
raise ArgumentError, '解析結果のセルが不正です．'
|
|
end
|
|
raise ArgumentError, '解析結果が大きすぎます．' if rows.sum { Array(_1['values']).sum(&:bytesize) } > PostImportSourceParser::MAX_BYTES
|
|
|
|
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
|
|
raise ArgumentError, '元行番号が重複しています．' if parsed_rows.map { _1[:source_row] }.uniq.length != parsed_rows.length
|
|
|
|
{ columns: columns.map { |column| column.slice('key', 'label') }, rows: parsed_rows }
|
|
end
|
|
|
|
def mappings_params
|
|
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)
|
|
raise ArgumentError, '列割当ての項目が不正です．' unless (value.keys - ['kind', 'value', 'columns']).empty?
|
|
|
|
value = permitted.fetch(field)
|
|
kind = value['kind'].presence || 'columns'
|
|
raise ArgumentError, '列割当ての種別が不正です．' unless kind.in?(['columns', 'fixed'])
|
|
columns = value['columns']
|
|
unless columns.nil? || (columns.is_a?(Array) && columns.all? { |index| Integer(index, exception: false)&.>= 0 })
|
|
raise ArgumentError, '列番号が不正です．'
|
|
end
|
|
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 = Array(params[:rows])
|
|
raise ArgumentError, '取込件数が多すぎます．' if rows.length > PostImportSourceParser::MAX_ROWS
|
|
|
|
normalised_rows = rows.map do |row|
|
|
value = ActionController::Parameters.new(row).permit(:source_row, :sourceRow, :url, :metadata_url, :metadataUrl,
|
|
attributes: {}, provenance: {}, tag_sources: {},
|
|
fetch_warnings: [], validation_warnings: [])
|
|
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? { _1.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? { _1.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
|