181 行
7.2 KiB
Ruby
181 行
7.2 KiB
Ruby
# Counts uses recorded values only; history/diff endpoints retain their own contract.
|
|
class CountsVersionRepr
|
|
# language_code remains a compatibility argument; it never selects recorded values.
|
|
def self.many(rows, resource:, language_code:, at: nil, inclusive: true, history_flg: false)
|
|
new(rows.to_a, resource:, language_code:, at:, inclusive:, history_flg:).serialise
|
|
end
|
|
|
|
def initialize(rows, resource:, language_code:, at:, inclusive:, history_flg:)
|
|
@rows = rows
|
|
HistoryAccess.require_many!(rows)
|
|
@at = at
|
|
@inclusive = inclusive
|
|
@resource = resource
|
|
@history_flg = history_flg
|
|
@users = User.where(id: rows.map(&:created_by_user_id).compact).pluck(:id, :name).to_h
|
|
@languages = master_names(Language)
|
|
@scripts = master_names(Script)
|
|
@name_columns = CountsResourceDefinition.new('tags').name_columns
|
|
@tag_versions = {}
|
|
if resource == 'posts'
|
|
load_tag_versions
|
|
requests = @rows.flat_map do |row|
|
|
Array(json(row.tags_json)).filter_map do |entry|
|
|
[entry['external_tag_id'], parent_point(row)] if entry['external_tag_id']
|
|
end
|
|
end.uniq
|
|
@external_versions = load_related_versions(NicoTagVersion, requests)
|
|
end
|
|
load_parent_versions if resource == 'tags'
|
|
end
|
|
|
|
def serialise
|
|
@rows.map do |row|
|
|
resource_id = row.public_send(@resource == 'posts' ? :post_id : :tag_id)
|
|
common = { id: row.id, resource_id:,
|
|
version_no: row.version_no, latest: row.attributes['counts_latest'].to_i == 1,
|
|
created_at: row.created_at.iso8601,
|
|
created_by_user: row.created_by_user_id &&
|
|
{ id: row.created_by_user_id, name: @users[row.created_by_user_id] } }
|
|
common.merge(@resource == 'posts' ? post(row) : tag(row))
|
|
end
|
|
end
|
|
|
|
private
|
|
|
|
def master_names(model)
|
|
model.select('code AS counts_code', :name).to_h do |record|
|
|
[record.attributes['counts_code'], record.name]
|
|
end
|
|
end
|
|
|
|
def json(value)
|
|
value.is_a?(String) ? JSON.parse(value) : value
|
|
end
|
|
|
|
def load_tag_versions
|
|
pairs = @rows.flat_map { Array(json(_1.tags_json)) }
|
|
.filter_map { |entry| [entry['tag_id'], entry['version_no']] if entry['tag_id'] }
|
|
.uniq
|
|
pairs.each_slice(500) do |batch|
|
|
placeholders = batch.map { '(?, ?)' }.join(', ')
|
|
scope = HistoryAccess.visible(TagVersion.all)
|
|
if @at
|
|
scope = scope.where("created_at #{ @inclusive ? '<=' : '<' } ?", @at)
|
|
end
|
|
scope.where(["(tag_id, version_no) IN (#{ placeholders })", *batch.flatten])
|
|
.select(:tag_id, :version_no, :name, :category, :names, :created_at).each do |version|
|
|
@tag_versions[[version.tag_id, version.version_no]] = version
|
|
end
|
|
end
|
|
end
|
|
|
|
def names(value)
|
|
(json(value) || {}).sort.map do |language, entry|
|
|
aliases = entry.fetch('aliases', []).map do |alias_entry|
|
|
alias_entry.merge('script_name' => @scripts[alias_entry['script_code']])
|
|
end
|
|
{ language_code: language, language_name: @languages[language],
|
|
script_code: entry['script_code'], script_name: @scripts[entry['script_code']],
|
|
name: entry['name'], auto_generated: entry['auto_generated'], aliases: }
|
|
end
|
|
end
|
|
|
|
def locale_names(values)
|
|
@name_columns.to_h do |field|
|
|
locale = field.fetch(:name_locale)
|
|
if field[:multiple_values]
|
|
entries = values.select { _1[:language_code] == locale[:language_code] }
|
|
aliases = entries.flat_map do |entry|
|
|
entry[:aliases].map { _1.merge('language_code' => entry[:language_code]) }
|
|
end
|
|
next [field.fetch(:key).to_sym, aliases]
|
|
end
|
|
entry = values.find do |value|
|
|
value[:language_code] == locale[:language_code]
|
|
end
|
|
[field.fetch(:key).to_sym, entry && entry[:name]]
|
|
end
|
|
end
|
|
|
|
def post(row)
|
|
snapshots = Array(json(row.tags_json)).map do |entry|
|
|
version = @tag_versions[[entry['tag_id'], entry['version_no']]]
|
|
version = nil if version && version.created_at > parent_point(row)
|
|
external = @external_versions[[entry['external_tag_id'], parent_point(row).iso8601(6)]]
|
|
recorded_names = version ? names(version.names) : []
|
|
aliases = recorded_names.flat_map do |value|
|
|
value[:aliases].map { _1.merge('language_code' => value[:language_code],
|
|
'language_name' => value[:language_name]) }
|
|
end
|
|
{ id: entry['tag_id'] || entry['external_tag_id'],
|
|
kind: entry['tag_id'] ? 'internal' : 'external',
|
|
tag_id: entry['tag_id'], external_tag_id: entry['external_tag_id'],
|
|
version_no: entry['version_no'],
|
|
name: entry['name'] || version&.name || external&.fetch('name'),
|
|
category: entry['category'] || version&.category,
|
|
sections: entry.fetch('sections', []), names: recorded_names, aliases: }
|
|
.merge(locale_names(recorded_names))
|
|
end
|
|
{ title: row.title, url: row.url, thumbnail_base: row.thumbnail_base,
|
|
tags: snapshots, parents: row.parent_post_ids.to_s.split.map { { id: _1.to_i } },
|
|
video_ms: row.video_ms,
|
|
original_created_from: row.original_created_from&.iso8601,
|
|
original_created_before: row.original_created_before&.iso8601 }
|
|
end
|
|
|
|
def parent_point(row)
|
|
@history_flg ? [@at, row.created_at].compact.min : @at || row.created_at
|
|
end
|
|
|
|
def load_parent_versions
|
|
requests = @rows.flat_map do |row|
|
|
row.parent_tag_ids.to_s.split.map { [_1.to_i, parent_point(row)] }
|
|
end.uniq
|
|
@parent_versions = load_related_versions(TagVersion, requests)
|
|
end
|
|
|
|
def load_related_versions(model, requests)
|
|
result = {}
|
|
table = model.table_name
|
|
comparison = @inclusive ? '<=' : '<'
|
|
requests.each_slice(100) do |batch|
|
|
queries = batch.map do |id, point|
|
|
scope = HistoryAccess.visible(model.where(tag_id: id))
|
|
.where("created_at #{ comparison } ?", point)
|
|
.where("NOT EXISTS (SELECT 1 FROM #{ table } newer " +
|
|
"WHERE newer.tag_id = #{ table }.tag_id AND newer.created_at #{ comparison } ? " +
|
|
"AND newer.version_no > #{ table }.version_no)", point)
|
|
quoted = model.connection.quote(point.iso8601(6))
|
|
names = model == TagVersion ? 'names' : 'JSON_OBJECT() AS names'
|
|
scope.select("tag_id, name, #{ names }, #{ quoted } AS reference_point").to_sql
|
|
end
|
|
next if queries.empty?
|
|
|
|
model.connection.select_all(queries.map { "(#{ _1 })" }.join(' UNION ALL ')).each do |value|
|
|
result[[value['tag_id'], value['reference_point']]] = value
|
|
end
|
|
end
|
|
result
|
|
end
|
|
|
|
def tag(row)
|
|
recorded_names = names(row.names)
|
|
aliases = recorded_names.flat_map do |entry|
|
|
entry[:aliases].map {
|
|
_1.merge('language_code' => entry[:language_code],
|
|
'language_name' => entry[:language_name])
|
|
}
|
|
end
|
|
{ name: row.name, names: recorded_names,
|
|
category: row.category, aliases:,
|
|
parents: row.parent_tag_ids.to_s.split.map do |id|
|
|
value = @parent_versions[[id.to_i, parent_point(row).iso8601(6)]]
|
|
snapshots = value && json(value['names'])
|
|
recorded = names(snapshots)
|
|
{ id: id.to_i, name: value&.fetch('name'), names: recorded }.merge(locale_names(recorded))
|
|
end,
|
|
deprecated: row.deprecated_at&.iso8601 }.merge(locale_names(recorded_names))
|
|
end
|
|
end
|