1254 lines
44 KiB
Ruby
1254 lines
44 KiB
Ruby
require "unicode_utils/casefold"
|
||
|
||
class Tag < ApplicationRecord
|
||
include Searchable
|
||
include StringCleaner
|
||
include WorksOwner
|
||
include Wrangleable
|
||
include Rails.application.routes.url_helpers
|
||
|
||
NAME = "Tag"
|
||
|
||
# Note: the order of this array is important.
|
||
# It is the order that tags are shown in the header of a work
|
||
# (banned tags are not shown)
|
||
TYPES = ['Rating', 'ArchiveWarning', 'Category', 'Media', 'Fandom', 'Relationship', 'Character', 'Freeform', 'Banned' ]
|
||
|
||
# these tags can be filtered on
|
||
FILTERS = TYPES - ['Banned', 'Media']
|
||
|
||
# these tags show up on works
|
||
VISIBLE = TYPES - ['Media', 'Banned']
|
||
|
||
# these are tags which have been created by users
|
||
# the order is important, and it is the order in which they appear in the tag wrangling interface
|
||
USER_DEFINED = ['Fandom', 'Character', 'Relationship', 'Freeform']
|
||
|
||
def self.label_name
|
||
to_s.pluralize
|
||
end
|
||
|
||
delegate :document_type, to: :class
|
||
|
||
def document_json
|
||
TagIndexer.new({}).document(self)
|
||
end
|
||
|
||
def self.taggings_count_expiry(count)
|
||
# What we are trying to do here is work out a resonable amount of time for a work to be cached for
|
||
# This should take the number of taggings and divide it by TAGGINGS_COUNT_CACHE_DIVISOR ( defaults to 1500 )
|
||
# such that for example 1500, would be naturally be tagged for one minute while 105,000 would be cached for
|
||
# 70 minutes. However we then apply a filter such that the minimum amount of time we will cache something for
|
||
# would be TAGGINGS_COUNT_MIN_TIME ( defaults to 3 minutes ) and the maximum amount of time would be
|
||
# TAGGINGS_COUNT_MAX_TIME ( defaulting to an hour ).
|
||
expiry_time = count / (ArchiveConfig.TAGGINGS_COUNT_CACHE_DIVISOR || 1500)
|
||
[[expiry_time, (ArchiveConfig.TAGGINGS_COUNT_MIN_TIME || 3)].max, (ArchiveConfig.TAGGINGS_COUNT_MAX_TIME || 50) + count % 20 ].min
|
||
end
|
||
|
||
def taggings_count_cache_key
|
||
"/v1/taggings_count/#{id}"
|
||
end
|
||
|
||
def write_taggings_to_redis(value)
|
||
# Atomically set the value while extracting the old value.
|
||
old_redis_value = REDIS_GENERAL.getset("tag_update_#{id}_value", value).to_i
|
||
|
||
# If the value hasn't changed from the saved version or the REDIS version,
|
||
# there's no need to write an update to the database, so let's just bail
|
||
# out.
|
||
return value if value == old_redis_value && value == taggings_count_cache
|
||
|
||
# If we've reached here, then the value has changed, and we need to make
|
||
# sure that the new value is written to the database.
|
||
REDIS_GENERAL.sadd("tag_update", id)
|
||
value
|
||
end
|
||
|
||
def taggings_count=(value)
|
||
expiry_time = Tag.taggings_count_expiry(value)
|
||
# Only write to the cache if there are more than a number of uses.
|
||
Rails.cache.write(taggings_count_cache_key, value, race_condition_ttl: 10, expires_in: expiry_time.minutes) if value >= ArchiveConfig.TAGGINGS_COUNT_MIN_CACHE_COUNT
|
||
write_taggings_to_redis(value)
|
||
end
|
||
|
||
def taggings_count
|
||
cache_read = Rails.cache.read(taggings_count_cache_key)
|
||
return cache_read unless cache_read.nil?
|
||
real_value = taggings.count
|
||
self.taggings_count = real_value
|
||
real_value
|
||
end
|
||
|
||
def update_tag_cache
|
||
cache_read = Rails.cache.read(taggings_count_cache_key)
|
||
taggings_count if cache_read.nil? || (cache_read < ArchiveConfig.TAGGINGS_COUNT_MIN_CACHE_COUNT)
|
||
end
|
||
|
||
def update_counts_cache(id)
|
||
tag = Tag.find(id)
|
||
tag.taggings_count = tag.taggings.count
|
||
end
|
||
|
||
acts_as_commentable
|
||
def commentable_name
|
||
self.name
|
||
end
|
||
|
||
# For a tag, the commentable owners are the wranglers of the fandom(s)
|
||
def commentable_owners
|
||
# if the tag is a fandom, grab its wranglers or the wranglers of its canonical merger
|
||
if self.is_a?(Fandom)
|
||
self.canonical? ? self.wranglers : (self.merger_id ? self.merger.wranglers : [])
|
||
# if the tag is any other tag, try to grab all the wranglers of all its parent fandoms, if applicable
|
||
else
|
||
begin
|
||
self.fandoms.collect {|f| f.wranglers}.compact.flatten.uniq
|
||
rescue
|
||
[]
|
||
end
|
||
end
|
||
end
|
||
|
||
has_many :mergers, foreign_key: 'merger_id', class_name: 'Tag'
|
||
belongs_to :merger, class_name: "Tag"
|
||
belongs_to :fandom
|
||
belongs_to :media
|
||
belongs_to :last_wrangler, polymorphic: true
|
||
|
||
has_many :filter_taggings, foreign_key: 'filter_id', dependent: :destroy
|
||
has_many :filtered_works, through: :filter_taggings, source: :filterable, source_type: 'Work'
|
||
has_many :filtered_external_works, through: :filter_taggings, source: :filterable, source_type: "ExternalWork"
|
||
has_many :filtered_collections, through: :filter_taggings, source: :filterable, source_type: "Collection"
|
||
|
||
has_one :filter_count, foreign_key: 'filter_id'
|
||
has_many :direct_filter_taggings,
|
||
-> { where(inherited: 0) },
|
||
class_name: "FilterTagging",
|
||
foreign_key: 'filter_id'
|
||
|
||
# not used anymore? has_many :direct_filtered_works, through: :direct_filter_taggings, source: :filterable, source_type: 'Work'
|
||
|
||
has_many :common_taggings, foreign_key: 'common_tag_id', dependent: :destroy
|
||
has_many :child_taggings, class_name: 'CommonTagging', as: :filterable
|
||
has_many :children, through: :child_taggings, source: :common_tag
|
||
has_many :parents,
|
||
through: :common_taggings,
|
||
source: :filterable,
|
||
source_type: 'Tag',
|
||
before_remove: :destroy_common_tagging,
|
||
after_remove: :update_wrangler
|
||
|
||
has_many :meta_taggings, foreign_key: 'sub_tag_id', dependent: :destroy
|
||
has_many :meta_tags, through: :meta_taggings, source: :meta_tag, before_remove: :destroy_meta_tagging
|
||
has_many :sub_taggings, class_name: 'MetaTagging', foreign_key: 'meta_tag_id', dependent: :destroy
|
||
has_many :sub_tags, through: :sub_taggings, source: :sub_tag, before_remove: :destroy_sub_tagging
|
||
has_many :direct_meta_tags, -> { where('meta_taggings.direct = 1') }, through: :meta_taggings, source: :meta_tag
|
||
has_many :direct_sub_tags, -> { where('meta_taggings.direct = 1') }, through: :sub_taggings, source: :sub_tag
|
||
has_many :taggings, as: :tagger
|
||
has_many :works, through: :taggings, source: :taggable, source_type: 'Work'
|
||
has_many :collections, through: :taggings, source: :taggable, source_type: "Collection"
|
||
|
||
has_many :bookmarks, through: :taggings, source: :taggable, source_type: 'Bookmark'
|
||
has_many :external_works, through: :taggings, source: :taggable, source_type: 'ExternalWork'
|
||
has_many :approved_collections, through: :filtered_works
|
||
|
||
has_many :favorite_tags, dependent: :destroy
|
||
|
||
has_many :set_taggings, dependent: :destroy
|
||
has_many :tag_sets, through: :set_taggings
|
||
has_many :owned_tag_sets, through: :tag_sets
|
||
|
||
has_many :tag_set_associations, dependent: :destroy
|
||
has_many :parent_tag_set_associations, class_name: 'TagSetAssociation', foreign_key: 'parent_tag_id', dependent: :destroy
|
||
|
||
validates :name, presence: true
|
||
validates :name, uniqueness: true
|
||
validates :name,
|
||
length: { minimum: 1,
|
||
message: "cannot be blank." }
|
||
validates :name,
|
||
length: { maximum: ArchiveConfig.TAG_MAX,
|
||
message: "^Tag name '%{value}' is too long -- try using less than %{count} characters or using commas to separate your tags." }
|
||
validates :name,
|
||
format: { with: /\A[^,，、*<>^{}=`\\%]+\z/,
|
||
message: "^Tag name '%{value}' cannot include the following restricted characters: , ^ * < > { } = ` ， 、 \\ %" }
|
||
validates :name,
|
||
format: { without: /\A\p{Cf}+\z/,
|
||
message: "^Tag name cannot be blank." }
|
||
validates :sortable_name, presence: true
|
||
|
||
validate :unwrangleable_status
|
||
def unwrangleable_status
|
||
return unless unwrangleable?
|
||
|
||
self.errors.add(:unwrangleable, "can't be set on a canonical or synonymized tag.") if canonical? || merger_id.present?
|
||
self.errors.add(:unwrangleable, "can't be set on an unsorted tag.") if is_a?(UnsortedTag)
|
||
end
|
||
|
||
before_validation :check_synonym
|
||
def check_synonym
|
||
if !self.new_record? && self.name_changed?
|
||
# ordinary wranglers can change case and accents but not punctuation or the actual letters in the name
|
||
# admins can change tags with no restriction
|
||
unless User.current_user.is_a?(Admin) || only_case_changed?
|
||
self.errors.add(:name, "can only be changed by an admin.")
|
||
end
|
||
end
|
||
if self.merger_id
|
||
if self.canonical?
|
||
self.errors.add(:base, "A canonical can't be a synonym")
|
||
end
|
||
if self.merger_id == self.id
|
||
self.errors.add(:base, "A tag can't be a synonym of itself.")
|
||
end
|
||
unless self.merger.class == self.class
|
||
self.errors.add(:base, "A tag can only be a synonym of a tag in the same category as itself.")
|
||
end
|
||
end
|
||
end
|
||
|
||
before_validation :squish_name
|
||
def squish_name
|
||
self.name = name.squish if self.name
|
||
end
|
||
|
||
before_validation :set_sortable_name
|
||
def set_sortable_name
|
||
if sortable_name.blank?
|
||
self.sortable_name = remove_articles_from_string(self.name)
|
||
end
|
||
end
|
||
|
||
after_update :queue_flush_work_cache
|
||
def queue_flush_work_cache
|
||
async_after_commit(:flush_work_cache) if saved_change_to_name? || saved_change_to_type?
|
||
end
|
||
|
||
def flush_work_cache
|
||
self.work_ids.each do |work|
|
||
Work.expire_work_blurb_version(work)
|
||
end
|
||
end
|
||
|
||
# queue_flush_work_cache will update the cached work (bookmarkable) info for
|
||
# bookmarks, but we still need to expire the portion of bookmark blurbs that
|
||
# contains the bookmarker's tags.
|
||
after_update :queue_flush_bookmark_cache
|
||
def queue_flush_bookmark_cache
|
||
async_after_commit(:flush_bookmark_cache) if saved_change_to_name?
|
||
end
|
||
|
||
def flush_bookmark_cache
|
||
self.bookmarks.each do |bookmark|
|
||
ActionController::Base.new.expire_fragment("bookmark-owner-blurb-#{bookmark.cache_key}-v3")
|
||
ActionController::Base.new.expire_fragment("bookmark-blurb-#{bookmark.cache_key}-v3")
|
||
end
|
||
end
|
||
|
||
before_save :set_last_wrangler
|
||
def set_last_wrangler
|
||
unless User.current_user.nil?
|
||
self.last_wrangler = User.current_user
|
||
end
|
||
end
|
||
def update_wrangler(tag)
|
||
unless User.current_user.nil?
|
||
self.update(last_wrangler: User.current_user)
|
||
end
|
||
end
|
||
|
||
after_save :check_type_changes, if: :saved_change_to_type?
|
||
def check_type_changes
|
||
return if type_before_last_save.nil?
|
||
|
||
retyped = Tag.find(self.id)
|
||
|
||
# Clean up invalid CommonTaggings.
|
||
retyped.common_taggings.destroy_invalid
|
||
retyped.child_taggings.destroy_invalid
|
||
|
||
# If the tag has just become a Fandom, it needs the Uncategorized media
|
||
# added to it manually (the after_save hook on Fandom won't take effect,
|
||
# since it's not a Fandom yet)
|
||
retyped.add_media_for_uncategorized if retyped.is_a?(Fandom)
|
||
end
|
||
|
||
# Callback for has_many :parents.
|
||
# Destroy the common tagging so we trigger CommonTagging's callbacks when a
|
||
# parent is removed. We're specifically interested in the update_search
|
||
# callback that will reindex the tag and return it to the unwrangled bin.
|
||
def destroy_common_tagging(parent)
|
||
self.common_taggings.find_by(filterable_id: parent.id).try(:destroy)
|
||
end
|
||
|
||
scope :id_only, -> { select("tags.id") }
|
||
|
||
scope :canonical, -> { where(canonical: true) }
|
||
scope :noncanonical, -> { where(canonical: false) }
|
||
scope :nonsynonymous, -> { noncanonical.where(merger_id: nil) }
|
||
scope :synonymous, -> { noncanonical.where("merger_id IS NOT NULL") }
|
||
scope :unfilterable, -> { nonsynonymous.where(unwrangleable: false) }
|
||
scope :unwrangleable, -> { where(unwrangleable: true) }
|
||
|
||
scope :in_use, -> { where("canonical = 1 OR taggings_count_cache > 0") }
|
||
scope :first_class, -> { joins("LEFT JOIN `meta_taggings` ON meta_taggings.sub_tag_id = tags.id").where("meta_taggings.id IS NULL") }
|
||
|
||
# Tags that have sub tags
|
||
scope :meta_tag, -> { joins(:sub_taggings).where("meta_taggings.id IS NOT NULL").group("tags.id") }
|
||
# Tags that don't have sub tags
|
||
scope :non_meta_tag, -> { joins(:sub_taggings).where("meta_taggings.id IS NULL").group("tags.id") }
|
||
|
||
scope :by_popularity, -> { order('taggings_count_cache DESC') }
|
||
scope :by_name, -> { order('sortable_name ASC') }
|
||
scope :by_date, -> { order('created_at DESC') }
|
||
scope :visible, -> { where('type in (?)', VISIBLE).by_name }
|
||
|
||
scope :by_pseud, lambda {|pseud|
|
||
joins(works: :pseuds).
|
||
where(pseuds: {id: pseud.id})
|
||
}
|
||
|
||
scope :by_type, lambda {|*types| where(types.first.blank? ? "" : {type: types.first})}
|
||
scope :with_type, lambda {|type| where({type: type}) }
|
||
|
||
# This will return all tags that have one of the given tags as a parent
|
||
scope :with_parents, lambda {|parents|
|
||
joins(:common_taggings).where("filterable_id in (?)", parents.first.is_a?(Integer) ? parents : (parents.respond_to?(:pluck) ? parents.pluck(:id) : parents.collect(&:id)))
|
||
}
|
||
|
||
scope :with_no_parents, -> {
|
||
joins("LEFT JOIN common_taggings ON common_taggings.common_tag_id = tags.id").
|
||
where("filterable_id IS NULL")
|
||
}
|
||
|
||
scope :starting_with, lambda {|letter| where('SUBSTR(name,1,1) = ?', letter)}
|
||
|
||
scope :visible_to_all_with_count, -> {
|
||
joins(:filter_count).
|
||
select("tags.*, filter_counts.public_works_count as count").
|
||
where('filter_counts.public_works_count > 0 AND tags.canonical = 1')
|
||
}
|
||
|
||
scope :visible_to_registered_user_with_count, -> {
|
||
joins(:filter_count).
|
||
select("tags.*, filter_counts.unhidden_works_count as count").
|
||
where('filter_counts.unhidden_works_count > 0 AND tags.canonical = 1')
|
||
}
|
||
|
||
scope :public_top, lambda { |tag_count|
|
||
visible_to_all_with_count.
|
||
limit(tag_count).
|
||
order('filter_counts.public_works_count DESC')
|
||
}
|
||
|
||
scope :unhidden_top, lambda { |tag_count|
|
||
visible_to_registered_user_with_count.
|
||
limit(tag_count).
|
||
order('filter_counts.unhidden_works_count DESC')
|
||
}
|
||
|
||
scope :popular, -> {
|
||
(User.current_user.is_a?(Admin) || User.current_user.is_a?(User)) ?
|
||
visible_to_registered_user_with_count.order('filter_counts.unhidden_works_count DESC') :
|
||
visible_to_all_with_count.order('filter_counts.public_works_count DESC')
|
||
}
|
||
|
||
scope :random, -> {
|
||
(User.current_user.is_a?(Admin) || User.current_user.is_a?(User)) ?
|
||
visible_to_registered_user_with_count.random_order :
|
||
visible_to_all_with_count.random_order
|
||
}
|
||
|
||
scope :with_count, -> {
|
||
(User.current_user.is_a?(Admin) || User.current_user.is_a?(User)) ?
|
||
visible_to_registered_user_with_count : visible_to_all_with_count
|
||
}
|
||
|
||
scope :for_collections, lambda { |collections|
|
||
joins(filtered_works: :approved_collection_items).merge(Work.posted)
|
||
.where("collection_items.collection_id IN (?)", collections.collect(&:id))
|
||
}
|
||
|
||
scope :for_collection, lambda { |collection| for_collections([collection]) }
|
||
|
||
scope :for_collections_with_count, lambda { |collections|
|
||
for_collections(collections).
|
||
select("tags.*, count(tags.id) as count").
|
||
group(:id).
|
||
order(:name)
|
||
}
|
||
|
||
scope :with_scoped_count, lambda {
|
||
select("tags.*, count(tags.id) as count").
|
||
group(:id)
|
||
}
|
||
|
||
scope :by_relationships, lambda {|relationships|
|
||
select("DISTINCT tags.*").
|
||
joins(:children).
|
||
where('children_tags.id IN (?)', relationships.collect(&:id))
|
||
}
|
||
|
||
# Get the tags for a challenge's signups, checking both the main tag set
|
||
# and the optional tag set for each prompt
|
||
def self.in_challenge(collection, prompt_type=nil)
|
||
['', 'optional_'].map { |tag_set_type|
|
||
join = "INNER JOIN set_taggings ON (tags.id = set_taggings.tag_id)
|
||
INNER JOIN tag_sets ON (set_taggings.tag_set_id = tag_sets.id)
|
||
INNER JOIN prompts ON (prompts.#{tag_set_type}tag_set_id = tag_sets.id)
|
||
INNER JOIN challenge_signups ON (prompts.challenge_signup_id = challenge_signups.id)"
|
||
|
||
tags = self.joins(join).where("challenge_signups.collection_id = ?", collection.id)
|
||
tags = tags.where("prompts.type = ?", prompt_type) if prompt_type.present?
|
||
tags
|
||
}.flatten.compact.uniq
|
||
end
|
||
|
||
scope :requested_in_challenge, lambda {|collection|
|
||
in_challenge(collection, 'Request')
|
||
}
|
||
|
||
scope :offered_in_challenge, lambda {|collection|
|
||
in_challenge(collection, 'Offer')
|
||
}
|
||
|
||
# Code for delayed jobs:
|
||
include AsyncWithActiveJob
|
||
self.async_job_class = TagMethodJob
|
||
|
||
# Class methods
|
||
|
||
|
||
def self.in_prompt_restriction(restriction)
|
||
joins("INNER JOIN set_taggings ON set_taggings.tag_id = tags.id
|
||
INNER JOIN tag_sets ON tag_sets.id = set_taggings.tag_set_id
|
||
INNER JOIN owned_tag_sets ON owned_tag_sets.tag_set_id = tag_sets.id
|
||
INNER JOIN owned_set_taggings ON owned_set_taggings.owned_tag_set_id = owned_tag_sets.id
|
||
INNER JOIN prompt_restrictions ON (prompt_restrictions.id = owned_set_taggings.set_taggable_id AND owned_set_taggings.set_taggable_type = 'PromptRestriction')").
|
||
where("prompt_restrictions.id = ?", restriction.id)
|
||
end
|
||
|
||
def self.by_name_without_articles(fieldname = "name")
|
||
fieldname = "name" unless fieldname.match(/^([\w]+\.)?[\w]+$/)
|
||
order(Arel.sql("case when lower(substring(#{fieldname} from 1 for 4)) = 'the ' then substring(#{fieldname} from 5)
|
||
when lower(substring(#{fieldname} from 1 for 2)) = 'a ' then substring(#{fieldname} from 3)
|
||
when lower(substring(#{fieldname} from 1 for 3)) = 'an ' then substring(#{fieldname} from 4)
|
||
else #{fieldname}
|
||
end"))
|
||
end
|
||
|
||
def self.in_tag_set(tag_set)
|
||
if tag_set.is_a?(OwnedTagSet)
|
||
joins(:set_taggings).where("set_taggings.tag_set_id = ?", tag_set.tag_set_id)
|
||
else
|
||
joins(:set_taggings).where("set_taggings.tag_set_id = ?", tag_set.id)
|
||
end
|
||
end
|
||
|
||
# gives you [parent_name, child_name], [parent_name, child_name], ...
|
||
def self.parent_names(parent_type = 'fandom')
|
||
joins(:parents).where("parents_tags.type = ?", parent_type.capitalize).
|
||
select("parents_tags.name as parent_name, tags.name as child_name").
|
||
by_name_without_articles("parent_name").
|
||
by_name_without_articles("child_name")
|
||
end
|
||
|
||
# Because this can be called by a gigantor tag set and all we need are names not objects,
|
||
# we do an end-run around ActiveRecord and just get the results straight from the db, but
|
||
# we borrow the sql from parent_names above
|
||
# returns a hash[parent_name] = child_names
|
||
def self.names_by_parent(child_relation, parent_type = 'fandom')
|
||
hash = {}
|
||
results = ActiveRecord::Base.connection.execute(child_relation.parent_names(parent_type).to_sql)
|
||
results.each {|row| hash[row.first] ||= Array.new; hash[row.first] << row.second}
|
||
hash
|
||
end
|
||
|
||
# Used for associations, such as work.fandoms.string
|
||
# Yields a comma-separated list of tag names
|
||
def self.string
|
||
all.map{|tag| tag.name}.join(ArchiveConfig.DELIMITER_FOR_OUTPUT)
|
||
end
|
||
|
||
# Use the tag name in urls and escape url-unfriendly characters
|
||
def to_param
|
||
# can't find a tag with a name that hasn't been saved yet
|
||
saved_name = self.name_changed? ? self.name_was : self.name
|
||
saved_name.gsub('/', '*s*').gsub('&', '*a*').gsub('.', '*d*').gsub('?', '*q*').gsub('#', '*h*')
|
||
end
|
||
|
||
def display_name
|
||
name
|
||
end
|
||
|
||
# Make sure that the global ID doesn't depend on the type, so that we don't
|
||
# experience errors when switching types:
|
||
def to_global_id(options = {})
|
||
GlobalID.create(becomes(Tag), options)
|
||
end
|
||
|
||
## AUTOCOMPLETE
|
||
# set up autocomplete and override some methods
|
||
include AutocompleteSource
|
||
def autocomplete_prefixes
|
||
prefixes = [ "autocomplete_tag_#{type.downcase}", "autocomplete_tag_all" ]
|
||
prefixes
|
||
end
|
||
|
||
def add_to_autocomplete(score = nil)
|
||
if eligible_for_fandom_autocomplete?
|
||
parents.each do |parent|
|
||
add_to_fandom_autocomplete(parent, score) if parent.is_a?(Fandom)
|
||
end
|
||
end
|
||
super
|
||
end
|
||
|
||
def add_to_fandom_autocomplete(fandom, score = nil)
|
||
score ||= autocomplete_score
|
||
REDIS_AUTOCOMPLETE.zadd(self.transliterate("autocomplete_fandom_#{fandom.name.downcase}_#{type.downcase}"), score, autocomplete_value)
|
||
end
|
||
|
||
def remove_from_autocomplete
|
||
super
|
||
|
||
return unless was_eligible_for_fandom_autocomplete?
|
||
|
||
parents.each do |parent|
|
||
remove_from_fandom_autocomplete(parent) if parent.is_a?(Fandom)
|
||
end
|
||
end
|
||
|
||
def remove_from_fandom_autocomplete(fandom)
|
||
REDIS_AUTOCOMPLETE.zrem(self.transliterate("autocomplete_fandom_#{fandom.name.downcase}_#{type.downcase}"), autocomplete_value)
|
||
end
|
||
|
||
def eligible_for_fandom_autocomplete?
|
||
(self.is_a?(Character) || self.is_a?(Relationship)) && canonical
|
||
end
|
||
|
||
def was_eligible_for_fandom_autocomplete?
|
||
(self.is_a?(Character) || self.is_a?(Relationship)) && (canonical || canonical_before_last_save)
|
||
end
|
||
|
||
def remove_stale_from_autocomplete
|
||
super
|
||
|
||
return unless was_eligible_for_fandom_autocomplete?
|
||
|
||
parents.each do |parent|
|
||
REDIS_AUTOCOMPLETE.zrem(self.transliterate("autocomplete_fandom_#{parent.name.downcase}_#{type.downcase}"), autocomplete_value_before_last_save) if parent.is_a?(Fandom)
|
||
end
|
||
end
|
||
|
||
def self.parse_autocomplete_value(current_autocomplete_value)
|
||
current_autocomplete_value.split(AUTOCOMPLETE_DELIMITER, 2)
|
||
end
|
||
|
||
|
||
def autocomplete_score
|
||
taggings_count_cache
|
||
end
|
||
|
||
# look up tags that have been wrangled into a given fandom
|
||
def self.autocomplete_fandom_lookup(options = {})
|
||
options.reverse_merge!({term: "", tag_type: "character", fandom: "", fallback: true})
|
||
search_param = options[:term]
|
||
tag_type = options[:tag_type]
|
||
fandoms = Tag.get_search_terms(options[:fandom])
|
||
|
||
# fandom sets are too small to bother breaking up
|
||
# we're just getting ALL the tags in the set(s) for the fandom(s) and then manually matching
|
||
results = []
|
||
fandoms.each do |single_fandom|
|
||
if search_param.blank?
|
||
# just return ALL the characters
|
||
results += REDIS_AUTOCOMPLETE.zrevrange(self.transliterate("autocomplete_fandom_#{single_fandom}_#{tag_type}"), 0, -1)
|
||
else
|
||
search_regex = Tag.get_search_regex(search_param)
|
||
results += REDIS_AUTOCOMPLETE.zrevrange(self.transliterate("autocomplete_fandom_#{single_fandom}_#{tag_type}"), 0, -1).select { |tag| tag.match(search_regex) }
|
||
end
|
||
end
|
||
if options[:fallback] && results.empty? && search_param.length > 0
|
||
# do a standard tag lookup instead
|
||
Tag.autocomplete_lookup(search_param: search_param, autocomplete_prefix: "autocomplete_tag_#{tag_type}")
|
||
else
|
||
results
|
||
end
|
||
end
|
||
|
||
## END AUTOCOMPLETE
|
||
|
||
# Substitute characters that are particularly prone to cause trouble in urls
|
||
def self.find_by_name(string)
|
||
return unless string.is_a? String
|
||
|
||
self.find_by(name: from_param(string))
|
||
end
|
||
|
||
def self.find_by_name!(string)
|
||
return unless string.is_a? String
|
||
|
||
self.find_by!(name: from_param(string))
|
||
end
|
||
|
||
def self.from_param(string)
|
||
string.gsub(
|
||
/\*[sadqh]\*/,
|
||
'*s*' => '/',
|
||
'*a*' => '&',
|
||
'*d*' => '.',
|
||
'*q*' => '?',
|
||
'*h*' => '#'
|
||
)
|
||
end
|
||
|
||
# If a tag by this name exists in another class, add a suffix to disambiguate them
|
||
def self.find_or_create_by_name(new_name)
|
||
if new_name && new_name.is_a?(String)
|
||
new_name.squish!
|
||
tag = Tag.find_by_name(new_name)
|
||
# if the tag exists and has the proper class, or it is an unsorted tag and it can be sorted to the self class
|
||
if tag && (tag.class == self || tag.class == UnsortedTag && tag = tag.recategorize(self.to_s))
|
||
tag
|
||
elsif tag
|
||
self.find_or_create_by_name(new_name + " - " + self.to_s)
|
||
else
|
||
self.create(name: new_name, type: self.to_s)
|
||
end
|
||
end
|
||
end
|
||
|
||
def self.create_canonical(name, adult=false)
|
||
tag = self.find_or_create_by_name(name)
|
||
raise "how did this happen?" unless tag
|
||
tag.update_attribute(:canonical,true)
|
||
tag.update_attribute(:adult, adult)
|
||
raise "how did this happen?" unless tag.canonical?
|
||
return tag
|
||
end
|
||
|
||
# Inherited tag classes can set this to indicate types of tags with which they may have a parent/child
|
||
# relationship (ie. media: parent, fandom: child; fandom: parent, character: child)
|
||
def parent_types
|
||
[]
|
||
end
|
||
def child_types
|
||
[]
|
||
end
|
||
|
||
# Instance methods that are common to all subclasses (may be overridden in the subclass)
|
||
|
||
def unfilterable?
|
||
!(self.canonical? || self.unwrangleable? || self.merger_id.present? || self.mergers.any?)
|
||
end
|
||
|
||
# Returns true if a tag has been used in posted works that are revealed and not hidden
|
||
def has_posted_works? # rubocop:disable Naming/PredicateName
|
||
self.works.posted.revealed.unhidden.any?
|
||
end
|
||
|
||
# sort tags by name
|
||
def <=>(another_tag)
|
||
name.downcase <=> another_tag.name.downcase
|
||
end
|
||
|
||
# only allow changing the tag type for unwrangled tags not used in any tag sets or on any works
|
||
def can_change_type?
|
||
self.unfilterable? && self.set_taggings.count == 0 && self.works.count == 0
|
||
end
|
||
|
||
# tags having their type changed need to be reloaded to be seen as an instance of the proper subclass
|
||
def recategorize(new_type)
|
||
self.update_attribute(:type, new_type)
|
||
# return a new instance of the tag, with the correct class
|
||
Tag.find(self.id)
|
||
end
|
||
|
||
#### FILTERING ####
|
||
|
||
before_update :reindex_associated_for_name_or_type_change
|
||
def reindex_associated_for_name_or_type_change
|
||
return unless name_changed? || type_changed?
|
||
|
||
reindex_pseuds = (type == "Fandom") || (type_was == "Fandom")
|
||
async_after_commit(:reindex_associated, reindex_pseuds)
|
||
end
|
||
|
||
# Reindex anything even remotely related to this tag. This is overkill in
|
||
# most cases, but necessary when something fundamental like the name or type
|
||
# of a tag has changed.
|
||
def reindex_associated(reindex_pseuds = false)
|
||
works.reindex_all
|
||
external_works.reindex_all
|
||
bookmarks.reindex_all
|
||
|
||
filtered_works.reindex_all
|
||
filtered_external_works.reindex_all
|
||
|
||
Series.joins(works: :taggings)
|
||
.merge(self.taggings).reindex_all
|
||
Series.joins(works: :filter_taggings)
|
||
.merge(self.filter_taggings).reindex_all
|
||
|
||
# We only want to reindex pseuds if this tag is a Fandom. Unfortunately, we
|
||
# can't just check the current type, because tags can change type, and we'd
|
||
# still need to reindex if the old type was Fandom. So we have an option to
|
||
# control it.
|
||
if reindex_pseuds
|
||
Pseud.joins(works: :filter_taggings)
|
||
.merge(self.direct_filter_taggings).reindex_all
|
||
end
|
||
end
|
||
|
||
# The version of the tag that should be used for filtering, if any
|
||
def filter
|
||
self.canonical? ? self : ((self.merger && self.merger.canonical?) ? self.merger : nil)
|
||
end
|
||
|
||
# Update filters for all works and external works directly tagged with this
|
||
# tag.
|
||
def update_filters_for_taggables
|
||
works.update_filters
|
||
external_works.update_filters
|
||
collections.update_filters
|
||
end
|
||
|
||
# Update filters for all works and external works that already have this tag
|
||
# as one of their filters.
|
||
def update_filters_for_filterables
|
||
filtered_works.update_filters
|
||
filtered_external_works.update_filters
|
||
filtered_collections.update_filters
|
||
end
|
||
|
||
# When canonical or merger_id changes, only the items directly tagged with
|
||
# this tag need their filters updated, so we queue up a call to
|
||
# update_filters_for_taggables after commit.
|
||
#
|
||
# Note that when a tag becomes non-canonical, all of its filter-taggings need
|
||
# to be deleted. But when a tag becomes non-canonical, all of its mergers and
|
||
# sub-tags will be deleted, which will result in the necessary items having
|
||
# their filters fixed.
|
||
after_update :update_filters_for_canonical_or_merger_change
|
||
def update_filters_for_canonical_or_merger_change
|
||
return unless saved_change_to_canonical? || saved_change_to_merger_id?
|
||
|
||
async_after_commit(:update_filters_for_taggables)
|
||
end
|
||
|
||
# Recalculate the inherited metatags for this tag, and once those changes
|
||
# are committed, update the filters for every work or external work that's
|
||
# filter-tagged with this tag.
|
||
def update_inherited_meta_tags
|
||
MetaTagging.transaction do
|
||
InheritedMetaTagUpdater.new(self).update
|
||
|
||
sub_tags.find_each do |sub_tag|
|
||
InheritedMetaTagUpdater.new(sub_tag).update
|
||
end
|
||
end
|
||
|
||
async_after_commit(:update_filters_for_filterables)
|
||
end
|
||
|
||
# When deleting a metatag, we destroy the meta-tagging first to trigger the
|
||
# appropriate destroy callback.
|
||
def destroy_meta_tagging(meta_tag)
|
||
meta_taggings.find_by(meta_tag: meta_tag)&.destroy
|
||
end
|
||
|
||
# When deleting a subtag, we destroy the sub-tagging first to trigger the
|
||
# appropriate destroy callback.
|
||
def destroy_sub_tagging(sub_tag)
|
||
sub_taggings.find_by(sub_tag: sub_tag)&.destroy
|
||
end
|
||
|
||
def reset_filter_count
|
||
FilterCount.enqueue_filter(filter)
|
||
end
|
||
|
||
#### END FILTERING ####
|
||
|
||
# methods for counting visible
|
||
|
||
def visible_works_count
|
||
User.current_user.nil? ? self.works.posted.unhidden.unrestricted.count : self.works.posted.unhidden.count
|
||
end
|
||
|
||
def visible_bookmarks_count
|
||
self.bookmarks.is_public.count
|
||
end
|
||
|
||
def visible_external_works_count
|
||
self.external_works.where(hidden_by_admin: false).count
|
||
end
|
||
|
||
def banned
|
||
self.is_a?(Banned)
|
||
end
|
||
|
||
def synonyms
|
||
self.canonical? ? self.mergers : [self.merger] + self.merger.mergers - [self]
|
||
end
|
||
|
||
# Add a common tagging association
|
||
def add_association(tag)
|
||
build_association(tag).save
|
||
end
|
||
|
||
def has_parent?(tag)
|
||
self.common_taggings.where(filterable_id: tag.id).count > 0
|
||
end
|
||
|
||
def has_child?(tag)
|
||
self.child_taggings.where(common_tag_id: tag.id).count > 0
|
||
end
|
||
|
||
def associations_to_remove; @associations_to_remove ? @associations_to_remove : []; end
|
||
def associations_to_remove=(taglist)
|
||
taglist.reject {|tid| tid.blank?}.each do |tag_id|
|
||
remove_association(tag_id)
|
||
end
|
||
end
|
||
|
||
# Determine how two tags are related and divorce them from each other
|
||
def remove_association(tag_id)
|
||
tag = Tag.find(tag_id)
|
||
|
||
if tag.class == self.class
|
||
tag.update(merger: nil) if tag.merger == self
|
||
meta_taggings.where(direct: true, meta_tag: tag).destroy_all
|
||
sub_taggings.where(direct: true, sub_tag: tag).destroy_all
|
||
else
|
||
common_taggings.where(filterable: tag).destroy_all
|
||
child_taggings.where(common_tag: tag).destroy_all
|
||
end
|
||
|
||
tag.touch
|
||
self.touch
|
||
end
|
||
|
||
# When canonical or merger is changed, we need to make sure that the
|
||
# associations (parents, children, metatags, mergers) are fixed. Note that
|
||
# these are all async calls, so we use async_after_commit to reduce the
|
||
# likelihood of issues with stale data.
|
||
before_update :update_associations_for_canonical_or_merger_change
|
||
def update_associations_for_canonical_or_merger_change
|
||
if (merger_id_changed? && merger_id.present?) ||
|
||
(canonical_changed? && !canonical?)
|
||
async_after_commit(:transfer_or_remove_favorite_tags)
|
||
async_after_commit(:transfer_or_remove_associations)
|
||
end
|
||
end
|
||
|
||
# Make it possible to go from a synonym to a canonical in one step.
|
||
before_validation :reset_merger_when_becoming_canonical
|
||
def reset_merger_when_becoming_canonical
|
||
return unless self.canonical_changed? && self.canonical?
|
||
|
||
self.merger_id = nil
|
||
end
|
||
|
||
# If this tag has a canonical merger, transfer associations to the merger.
|
||
# Then, regardless of whether it has a merger, delete all canonical
|
||
# associations (i.e. meta taggings, and associations where this tag is the
|
||
# parent).
|
||
def transfer_or_remove_associations
|
||
transaction do
|
||
# Try to prevent some concurrency issues.
|
||
lock!
|
||
|
||
# Abort if the tag has changed back to being canonical between the time
|
||
# this was enqueued and the time it ran.
|
||
return if self.canonical?
|
||
|
||
add_associations_to_merger if self.merger&.canonical?
|
||
|
||
self.mergers.find_each { |tag| tag.update(merger_id: nil) }
|
||
self.child_taggings.destroy_all
|
||
self.sub_taggings.destroy_all
|
||
self.meta_taggings.destroy_all
|
||
end
|
||
end
|
||
|
||
# When we make this tag a synonym of another canonical tag, we want to move
|
||
# all the associations this tag has (subtags, metatags, etc) over to that
|
||
# canonical tag.
|
||
#
|
||
# The callbacks that occur when changing the associations will trigger the
|
||
# necessary reindexing, so we don't need to call extra reindexing code here.
|
||
def add_associations_to_merger
|
||
self.parents.find_each do |tag|
|
||
self.merger.add_association(tag)
|
||
end
|
||
|
||
self.children.find_each do |tag|
|
||
self.merger.add_association(tag)
|
||
end
|
||
|
||
self.mergers.find_each { |tag| tag.update(merger: self.merger) }
|
||
|
||
merger.parents.where(type: %w[Media Fandom]).find_each do |tag|
|
||
self.add_association(tag)
|
||
end
|
||
|
||
self.direct_meta_tags.find_each do |tag|
|
||
meta_tagging = self.merger.meta_taggings.find_or_initialize_by(meta_tag: tag)
|
||
meta_tagging.update(direct: true)
|
||
end
|
||
|
||
self.direct_sub_tags.find_each do |tag|
|
||
sub_tagging = self.merger.sub_taggings.find_or_initialize_by(sub_tag: tag)
|
||
sub_tagging.update(direct: true)
|
||
end
|
||
end
|
||
|
||
# If this tag has a canonical merger, move all favorite tags to the merger.
|
||
# Otherwise, delete all favorite tags.
|
||
def transfer_or_remove_favorite_tags
|
||
if merger&.canonical
|
||
favorite_tags.find_each do |ft|
|
||
ft.update(tag_id: merger_id)
|
||
end
|
||
end
|
||
|
||
# We perform this after the if (instead of as a separate branch) because
|
||
# updating the tag_id can fail if the user has both this tag and its merger
|
||
# as favorite tags. So we want to clean up any failures, which just so
|
||
# happens to be exactly the same thing we need to do if there's no
|
||
# canonical merger to transfer the favorite tags to.
|
||
favorite_tags.find_each(&:destroy)
|
||
end
|
||
|
||
attr_reader :meta_tag_string, :sub_tag_string, :merger_string
|
||
|
||
# Uses the value of parent_types to determine whether the passed-in tag
|
||
# should be added as a parent or a child, and then generates the association
|
||
# (if it doesn't already exist). If it does already exist, returns the
|
||
# existing CommonTagging object.
|
||
def build_association(tag)
|
||
if parent_types.include?(tag&.type)
|
||
common_taggings.find_or_initialize_by(filterable: tag)
|
||
else
|
||
child_taggings.find_or_initialize_by(common_tag: tag)
|
||
end
|
||
end
|
||
|
||
# Splits up the passed-in string into a sequence of individual tag names,
|
||
# then finds (and yields) the tag for each. Used by add_association_string,
|
||
# meta_tag_string=, and sub_tag_string=.
|
||
def parse_tag_string(tag_string)
|
||
tag_string.split(",").map(&:squish).each do |name|
|
||
yield name, Tag.find_by_name(name)
|
||
end
|
||
end
|
||
|
||
# Try to create new associations with the tags of type tag_type whose names
|
||
# are listed in tag_string.
|
||
def add_association_string(tag_type, tag_string)
|
||
parse_tag_string(tag_string) do |name, parent|
|
||
prefix = "Cannot add association to '#{name}':"
|
||
if parent && parent.type != tag_type
|
||
errors.add(:base, "#{prefix} #{parent.type} added in #{tag_type} field.")
|
||
else
|
||
association = build_association(parent)
|
||
save_and_gather_errors(association, prefix)
|
||
end
|
||
end
|
||
end
|
||
|
||
# Save an item to the database, if it's valid. If it's invalid, read in the
|
||
# error messages from the item and copy them over to this tag.
|
||
def save_and_gather_errors(item, prefix)
|
||
return unless item.new_record? || item.changed?
|
||
return if item.valid? && item.save
|
||
|
||
item.errors.full_messages.each do |message|
|
||
errors.add(:base, "#{prefix} #{message}")
|
||
end
|
||
end
|
||
|
||
# Find and destroy all invalid CommonTaggings and MetaTaggings associated
|
||
# with this tag.
|
||
def destroy_invalid_associations
|
||
common_taggings.destroy_invalid
|
||
child_taggings.destroy_invalid
|
||
meta_taggings.destroy_invalid
|
||
sub_taggings.destroy_invalid
|
||
end
|
||
|
||
# defines fandom_string=, media_string=, character_string=, relationship_string=, freeform_string=
|
||
%w(Fandom Media Character Relationship Freeform).each do |tag_type|
|
||
attr_reader "#{tag_type.downcase}_string"
|
||
|
||
define_method("#{tag_type.downcase}_string=") do |tag_string|
|
||
add_association_string(tag_type, tag_string)
|
||
end
|
||
end
|
||
|
||
def meta_tag_string=(tag_string)
|
||
parse_tag_string(tag_string) do |name, parent|
|
||
meta_tagging = meta_taggings.find_or_initialize_by(meta_tag: parent)
|
||
meta_tagging.direct = true
|
||
save_and_gather_errors(meta_tagging, "Invalid metatag '#{name}':")
|
||
end
|
||
end
|
||
|
||
def sub_tag_string=(tag_string)
|
||
parse_tag_string(tag_string) do |name, sub|
|
||
sub_tagging = sub_taggings.find_or_initialize_by(sub_tag: sub)
|
||
sub_tagging.direct = true
|
||
save_and_gather_errors(sub_tagging, "Invalid subtag '#{name}':")
|
||
end
|
||
end
|
||
|
||
def syn_string
|
||
self.merger.name if self.merger
|
||
end
|
||
|
||
# Make this tag a synonym of another tag -- tag_string is the name of the other tag (which should be canonical)
|
||
# NOTE for potential confusion
|
||
# "merger" is the canonical tag of which this one will be a synonym
|
||
# "mergers" are the tags which are (currently) synonyms of THIS one
|
||
def syn_string=(tag_string)
|
||
# If the tag_string is blank, our tag should be given no merger
|
||
if tag_string.blank?
|
||
self.merger_id = nil
|
||
return
|
||
end
|
||
|
||
new_merger = Tag.find_by(name: tag_string)
|
||
|
||
# Bail out if the new merger is the same as the current merger
|
||
return if new_merger && new_merger == self.merger
|
||
|
||
# Return an error if a non-admin tries to make a canonical into a synonym
|
||
if self.canonical? && !User.current_user.is_a?(Admin)
|
||
self.errors.add(:base, "Only an admin can make a canonical tag into a synonym of another tag.")
|
||
return
|
||
end
|
||
|
||
if new_merger && new_merger == self
|
||
self.errors.add(:base, tag_string + " is considered the same as " + self.name + " by the database.")
|
||
elsif new_merger && !new_merger.canonical?
|
||
self.errors.add(:base, "<a href=\"#{edit_tag_path(new_merger)}\">#{new_merger.name}</a> is not a canonical tag. Please make it canonical before adding synonyms to it.")
|
||
elsif new_merger && new_merger.class != self.class
|
||
self.errors.add(:base, new_merger.name + " is a #{new_merger.type.to_s.downcase}. Synonyms must belong to the same category.")
|
||
elsif !new_merger
|
||
new_merger = self.class.new(name: tag_string, canonical: true)
|
||
unless new_merger.save
|
||
self.errors.add(:base, tag_string + " could not be saved. Please make sure that it's a valid tag name.")
|
||
end
|
||
end
|
||
|
||
# If we don't have any errors, update the tag to add the new merger
|
||
if new_merger && self.errors.empty?
|
||
self.canonical = false
|
||
self.merger_id = new_merger.id
|
||
end
|
||
end
|
||
|
||
def merger_string=(tag_string)
|
||
names = tag_string.split(',').map(&:squish)
|
||
names.each do |name|
|
||
syn = Tag.find_by_name(name)
|
||
if syn && !syn.canonical?
|
||
syn.update(merger_id: self.id)
|
||
end
|
||
end
|
||
end
|
||
|
||
# unwrangleable:
|
||
# - A boolean stored in the tags table
|
||
# - Default false
|
||
# - Set to true by wranglers on tags that should be excluded from the wrangling process altogether. Example: freeform tags like "idk how to explain it but trust me"
|
||
#
|
||
# unwrangled:
|
||
# - A computed value
|
||
# - True for "orphan" tags yet to be tied to something (fandom, character, etc.) by wranglers
|
||
# - Exact meaning may change depending on the nature of the tag (search for definitions of unwrangled? overriding this one)
|
||
#
|
||
def unwrangled?
|
||
common_taggings.empty?
|
||
end
|
||
|
||
#################################
|
||
## SEARCH #######################
|
||
#################################
|
||
|
||
def unwrangled_query(tag_type, options = {})
|
||
self_type = %w[Character Fandom Media].include?(self.type) ? self.type.downcase : "fandom"
|
||
TagQuery.new(options.merge(
|
||
type: tag_type,
|
||
unwrangleable: false,
|
||
wrangled: false,
|
||
has_posted_works: true,
|
||
"pre_#{self_type}_ids": [self.id],
|
||
per_page: Tag.per_page
|
||
))
|
||
end
|
||
|
||
def unwrangled_tags(tag_type, options = {})
|
||
unwrangled_query(tag_type, options).search_results
|
||
end
|
||
|
||
def unwrangled_tag_count(tag_type)
|
||
key = "unwrangled_#{tag_type}_#{self.id}_#{self.updated_at}"
|
||
Rails.cache.fetch(key, expires_in: 4.hours) do
|
||
unwrangled_query(tag_type).count
|
||
end
|
||
end
|
||
|
||
def suggested_parent_tags(parent_type, options = {})
|
||
limit = options[:limit] || 50
|
||
work_ids = works.limit(limit).pluck(:id)
|
||
Tag.distinct.joins(:taggings).where(
|
||
"tags.type" => parent_type,
|
||
taggings: {
|
||
taggable_type: 'Work',
|
||
taggable_id: work_ids
|
||
}
|
||
)
|
||
end
|
||
|
||
# For works that haven't been wrangled yet, get the fandom/character tags
|
||
# that are used on their works as a place to start
|
||
def suggested_parent_ids(parent_type)
|
||
return [] if !parent_types.include?(parent_type) ||
|
||
unwrangleable? ||
|
||
parents.by_type(parent_type).exists?
|
||
|
||
suggested_parent_tags(parent_type).pluck(:id, :merger_id).
|
||
flatten.compact.uniq
|
||
end
|
||
|
||
def queue_child_tags_for_reindex
|
||
all_with_child_type = Tag.where(type: child_types & Tag::USER_DEFINED)
|
||
works.select(:id).find_in_batches do |batch|
|
||
relevant_taggings = Tagging.where(taggable: batch)
|
||
tag_ids = all_with_child_type.joins(:taggings).merge(relevant_taggings).distinct.pluck(:id)
|
||
IndexQueue.enqueue_ids(Tag, tag_ids, :background)
|
||
end
|
||
end
|
||
|
||
after_create :after_create
|
||
def after_create
|
||
tag = self
|
||
if tag.canonical
|
||
tag.add_to_autocomplete
|
||
end
|
||
end
|
||
|
||
after_update :after_update
|
||
def after_update
|
||
tag = self
|
||
if tag.saved_change_to_canonical?
|
||
if tag.canonical
|
||
# newly canonical tag
|
||
tag.add_to_autocomplete
|
||
else
|
||
# decanonicalised tag
|
||
tag.remove_from_autocomplete
|
||
end
|
||
else
|
||
tag.refresh_autocomplete
|
||
end
|
||
|
||
# Expire caching when a merger is added or removed
|
||
if tag.saved_change_to_merger_id?
|
||
if tag.merger_id_before_last_save.present?
|
||
old = Tag.find(tag.merger_id_before_last_save)
|
||
old.update_works_index_timestamp!
|
||
end
|
||
if tag.merger_id.present?
|
||
tag.merger.update_works_index_timestamp!
|
||
end
|
||
async_after_commit(:queue_child_tags_for_reindex)
|
||
end
|
||
|
||
# if type has changed, expire the tag's parents' children cache (it stores the children's type)
|
||
if tag.saved_change_to_type?
|
||
tag.parents.each do |parent_tag|
|
||
ActionController::Base.new.expire_fragment("views/tags/#{parent_tag.id}/children")
|
||
end
|
||
end
|
||
|
||
# Reindex immediately to update the unwrangled bin.
|
||
if tag.saved_change_to_unwrangleable?
|
||
tag.reindex_document
|
||
end
|
||
end
|
||
|
||
def refresh_autocomplete
|
||
return unless canonical
|
||
|
||
remove_stale_from_autocomplete
|
||
add_to_autocomplete
|
||
end
|
||
|
||
before_destroy :before_destroy
|
||
def before_destroy
|
||
tag = self
|
||
if Tag::USER_DEFINED.include?(tag.type) && tag.canonical
|
||
tag.remove_from_autocomplete
|
||
end
|
||
end
|
||
|
||
private
|
||
|
||
after_save :update_tag_nominations
|
||
def update_tag_nominations
|
||
TagNomination.where(tagname: name).update_all(
|
||
canonical: canonical,
|
||
synonym: merger.nil? ? nil : merger.name,
|
||
parented: false, # we'll fix this later in the callback
|
||
exists: true
|
||
)
|
||
|
||
if canonical?
|
||
# Calculate the fandoms associated with this tag, because we'll set any
|
||
# TagNominations with a matching parent_tagname to have parented: true.
|
||
parent_names = parents.where(type: "Fandom").pluck(:name)
|
||
|
||
# If this tag has any fandoms at all, we also want to count it as parented
|
||
# for nominations with a blank parent_tagname. See the set_parented
|
||
# function in TagNominations for the calculation that we're trying to mimic
|
||
# here.
|
||
parent_names << "" if parent_names.present?
|
||
|
||
TagNomination.where(tagname: name, parent_tagname: parent_names).update_all(parented: true)
|
||
end
|
||
|
||
return unless saved_change_to_name? && name_before_last_save.present?
|
||
|
||
# Act as if the tag with the previous name was deleted and mirror clear_tag_nominations
|
||
TagNomination.where(tagname: name_before_last_save).update_all(
|
||
canonical: false,
|
||
exists: false,
|
||
parented: false,
|
||
synonym: nil
|
||
)
|
||
end
|
||
|
||
before_destroy :clear_tag_nominations
|
||
def clear_tag_nominations
|
||
TagNomination.where(tagname: name).update_all(
|
||
canonical: false,
|
||
exists: false,
|
||
parented: false,
|
||
synonym: nil
|
||
)
|
||
end
|
||
|
||
def only_case_changed?
|
||
new_normalized_name = normalize_for_tag_comparison(self.name)
|
||
old_normalized_name = normalize_for_tag_comparison(self.name_was)
|
||
(self.name.downcase == self.name_was.downcase) ||
|
||
(new_normalized_name == old_normalized_name)
|
||
end
|
||
|
||
def normalize_for_tag_comparison(string)
|
||
UnicodeUtils.casefold(string).mb_chars.unicode_normalize(:nfkd).gsub(/[\u0300-\u036F]/u, "")
|
||
end
|
||
end
|