mirror of
https://github.com/discourse/discourse.git
synced 2024-11-23 03:54:59 +08:00
b1f74ab59e
The strict-dynamic CSP directive is supported in all our target browsers, and makes for a much simpler configuration. Instead of allowlisting paths, we use a per-request nonce to authorize `<script>` tags, and then those scripts are allowed to load additional scripts (or add additional inline scripts) without restriction. This becomes especially useful when admins want to add external scripts like Google Tag Manager, or advertising scripts, which then go on to load a ton of other scripts. All script tags introduced via themes will automatically have the nonce attribute applied, so it should be zero-effort for theme developers. Plugins *may* need some changes if they are inserting their own script tags. This commit introduces a strict-dynamic-based CSP behind an experimental `content_security_policy_strict_dynamic` site setting.
1002 lines
28 KiB
Ruby
1002 lines
28 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "csv"
|
|
require "json_schemer"
|
|
|
|
class Theme < ActiveRecord::Base
|
|
include GlobalPath
|
|
|
|
BASE_COMPILER_VERSION = 80
|
|
|
|
class SettingsMigrationError < StandardError
|
|
end
|
|
|
|
attr_accessor :child_components
|
|
|
|
def self.cache
|
|
@cache ||= DistributedCache.new("theme:compiler:#{BASE_COMPILER_VERSION}")
|
|
end
|
|
|
|
belongs_to :user
|
|
belongs_to :color_scheme
|
|
has_many :theme_fields, dependent: :destroy, validate: false
|
|
has_many :theme_settings, dependent: :destroy
|
|
has_many :theme_translation_overrides, dependent: :destroy
|
|
has_many :child_theme_relation,
|
|
class_name: "ChildTheme",
|
|
foreign_key: "parent_theme_id",
|
|
dependent: :destroy
|
|
has_many :parent_theme_relation,
|
|
class_name: "ChildTheme",
|
|
foreign_key: "child_theme_id",
|
|
dependent: :destroy
|
|
has_many :child_themes, -> { order(:name) }, through: :child_theme_relation, source: :child_theme
|
|
has_many :parent_themes,
|
|
-> { order(:name) },
|
|
through: :parent_theme_relation,
|
|
source: :parent_theme
|
|
has_many :color_schemes
|
|
has_many :theme_settings_migrations
|
|
belongs_to :remote_theme, dependent: :destroy
|
|
has_one :theme_modifier_set, dependent: :destroy
|
|
has_one :theme_svg_sprite, dependent: :destroy
|
|
|
|
has_one :settings_field,
|
|
-> { where(target_id: Theme.targets[:settings], name: "yaml") },
|
|
class_name: "ThemeField"
|
|
has_one :javascript_cache, dependent: :destroy
|
|
has_many :locale_fields,
|
|
-> { filter_locale_fields(I18n.fallbacks[I18n.locale]) },
|
|
class_name: "ThemeField"
|
|
has_many :upload_fields,
|
|
-> { where(type_id: ThemeField.types[:theme_upload_var]).preload(:upload) },
|
|
class_name: "ThemeField"
|
|
has_many :extra_scss_fields,
|
|
-> { where(target_id: Theme.targets[:extra_scss]) },
|
|
class_name: "ThemeField"
|
|
has_many :yaml_theme_fields,
|
|
-> { where("name = 'yaml' AND type_id = ?", ThemeField.types[:yaml]) },
|
|
class_name: "ThemeField"
|
|
has_many :var_theme_fields,
|
|
-> { where("type_id IN (?)", ThemeField.theme_var_type_ids) },
|
|
class_name: "ThemeField"
|
|
has_many :builder_theme_fields,
|
|
-> { where("name IN (?)", ThemeField.scss_fields) },
|
|
class_name: "ThemeField"
|
|
has_many :migration_fields,
|
|
-> { where(target_id: Theme.targets[:migrations]) },
|
|
class_name: "ThemeField"
|
|
|
|
validate :component_validations
|
|
validate :validate_theme_fields
|
|
|
|
after_create :update_child_components
|
|
|
|
scope :user_selectable, -> { where("user_selectable OR id = ?", SiteSetting.default_theme_id) }
|
|
|
|
scope :include_relations,
|
|
-> do
|
|
includes(
|
|
:child_themes,
|
|
:parent_themes,
|
|
:remote_theme,
|
|
:theme_settings,
|
|
:settings_field,
|
|
:locale_fields,
|
|
:user,
|
|
:color_scheme,
|
|
:theme_translation_overrides,
|
|
theme_fields: %i[upload theme_settings_migration],
|
|
)
|
|
end
|
|
|
|
def notify_color_change(color, scheme: nil)
|
|
scheme ||= color.color_scheme
|
|
changed_colors << color if color
|
|
changed_schemes << scheme if scheme
|
|
end
|
|
|
|
def theme_modifier_set
|
|
super || build_theme_modifier_set
|
|
end
|
|
|
|
after_save do
|
|
changed_colors.each(&:save!)
|
|
changed_schemes.each(&:save!)
|
|
|
|
changed_colors.clear
|
|
changed_schemes.clear
|
|
|
|
any_non_css_fields_changed =
|
|
changed_fields.any? { |f| !(f.basic_scss_field? || f.extra_scss_field?) }
|
|
|
|
changed_fields.each(&:save!)
|
|
changed_fields.clear
|
|
|
|
theme_modifier_set.save!
|
|
|
|
theme_fields.select(&:basic_html_field?).each(&:invalidate_baked!) if saved_change_to_name?
|
|
|
|
if saved_change_to_color_scheme_id? || saved_change_to_user_selectable? || saved_change_to_name?
|
|
Theme.expire_site_cache!
|
|
end
|
|
notify_with_scheme = saved_change_to_color_scheme_id?
|
|
|
|
reload
|
|
settings_field&.ensure_baked! # Other fields require setting to be **baked**
|
|
theme_fields.each(&:ensure_baked!)
|
|
|
|
update_javascript_cache!
|
|
|
|
remove_from_cache!
|
|
ColorScheme.hex_cache.clear
|
|
|
|
notify_theme_change(with_scheme: notify_with_scheme)
|
|
|
|
if theme_setting_requests_refresh
|
|
DB.after_commit do
|
|
Discourse.request_refresh!
|
|
self.theme_setting_requests_refresh = false
|
|
end
|
|
end
|
|
|
|
if any_non_css_fields_changed && should_refresh_development_clients?
|
|
MessageBus.publish "/file-change", ["development-mode-theme-changed"]
|
|
end
|
|
end
|
|
|
|
def should_refresh_development_clients?
|
|
Rails.env.development?
|
|
end
|
|
|
|
def update_child_components
|
|
if !component? && child_components.present?
|
|
child_components.each do |url|
|
|
url = ThemeStore::GitImporter.new(url.strip).url
|
|
theme = RemoteTheme.find_by(remote_url: url)&.theme
|
|
theme ||= RemoteTheme.import_theme(url, user)
|
|
child_themes << theme
|
|
end
|
|
end
|
|
end
|
|
|
|
def update_javascript_cache!
|
|
all_extra_js =
|
|
theme_fields
|
|
.where(target_id: Theme.targets[:extra_js])
|
|
.order(:name, :id)
|
|
.pluck(:name, :value)
|
|
.to_h
|
|
|
|
if all_extra_js.present?
|
|
js_compiler = ThemeJavascriptCompiler.new(id, name)
|
|
js_compiler.append_tree(all_extra_js)
|
|
settings_hash = build_settings_hash
|
|
|
|
js_compiler.prepend_settings(settings_hash) if settings_hash.present?
|
|
|
|
javascript_cache || build_javascript_cache
|
|
javascript_cache.update!(content: js_compiler.content, source_map: js_compiler.source_map)
|
|
else
|
|
javascript_cache&.destroy!
|
|
end
|
|
end
|
|
|
|
after_destroy do
|
|
remove_from_cache!
|
|
Theme.clear_default! if SiteSetting.default_theme_id == self.id
|
|
|
|
if self.id
|
|
ColorScheme
|
|
.where(theme_id: self.id)
|
|
.where("id NOT IN (SELECT color_scheme_id FROM themes where color_scheme_id IS NOT NULL)")
|
|
.destroy_all
|
|
|
|
ColorScheme.where(theme_id: self.id).update_all(theme_id: nil)
|
|
end
|
|
|
|
Theme.expire_site_cache!
|
|
end
|
|
|
|
def self.compiler_version
|
|
get_set_cache "compiler_version" do
|
|
dependencies = [
|
|
BASE_COMPILER_VERSION,
|
|
EmberCli.ember_version,
|
|
GlobalSetting.cdn_url,
|
|
GlobalSetting.s3_cdn_url,
|
|
GlobalSetting.s3_endpoint,
|
|
GlobalSetting.s3_bucket,
|
|
Discourse.current_hostname,
|
|
]
|
|
Digest::SHA1.hexdigest(dependencies.join)
|
|
end
|
|
end
|
|
|
|
def self.get_set_cache(key, &blk)
|
|
cache.defer_get_set(key, &blk)
|
|
end
|
|
|
|
def self.theme_ids
|
|
get_set_cache "theme_ids" do
|
|
Theme.pluck(:id)
|
|
end
|
|
end
|
|
|
|
def self.parent_theme_ids
|
|
get_set_cache "parent_theme_ids" do
|
|
Theme.where(component: false).pluck(:id)
|
|
end
|
|
end
|
|
|
|
def self.is_parent_theme?(id)
|
|
self.parent_theme_ids.include?(id)
|
|
end
|
|
|
|
def self.user_theme_ids
|
|
get_set_cache "user_theme_ids" do
|
|
Theme.user_selectable.pluck(:id)
|
|
end
|
|
end
|
|
|
|
def self.allowed_remote_theme_ids
|
|
return nil if GlobalSetting.allowed_theme_repos.blank?
|
|
|
|
get_set_cache "allowed_remote_theme_ids" do
|
|
urls = GlobalSetting.allowed_theme_repos.split(",").map(&:strip)
|
|
Theme.joins(:remote_theme).where("remote_themes.remote_url in (?)", urls).pluck(:id)
|
|
end
|
|
end
|
|
|
|
def self.components_for(theme_id)
|
|
get_set_cache "theme_components_for_#{theme_id}" do
|
|
ChildTheme.where(parent_theme_id: theme_id).pluck(:child_theme_id)
|
|
end
|
|
end
|
|
|
|
def self.expire_site_cache!
|
|
Site.clear_anon_cache!
|
|
clear_cache!
|
|
ApplicationSerializer.expire_cache_fragment!("user_themes")
|
|
ColorScheme.hex_cache.clear
|
|
CSP::Extension.clear_theme_extensions_cache!
|
|
SvgSprite.expire_cache
|
|
end
|
|
|
|
def self.clear_default!
|
|
SiteSetting.default_theme_id = -1
|
|
expire_site_cache!
|
|
end
|
|
|
|
def self.transform_ids(id)
|
|
return [] if id.blank?
|
|
id = id.to_i
|
|
|
|
get_set_cache "transformed_ids_#{id}" do
|
|
all_ids =
|
|
if self.is_parent_theme?(id)
|
|
components = components_for(id).tap { |c| c.sort!.uniq! }
|
|
[id, *components]
|
|
else
|
|
[id]
|
|
end
|
|
|
|
disabled_ids =
|
|
Theme
|
|
.where(id: all_ids)
|
|
.includes(:remote_theme)
|
|
.select { |t| !t.supported? || !t.enabled? }
|
|
.map(&:id)
|
|
|
|
all_ids - disabled_ids
|
|
end
|
|
end
|
|
|
|
def set_default!
|
|
if component
|
|
raise Discourse::InvalidParameters.new(I18n.t("themes.errors.component_no_default"))
|
|
end
|
|
SiteSetting.default_theme_id = id
|
|
Theme.expire_site_cache!
|
|
end
|
|
|
|
def default?
|
|
SiteSetting.default_theme_id == id
|
|
end
|
|
|
|
def supported?
|
|
if minimum_version = remote_theme&.minimum_discourse_version
|
|
return false unless Discourse.has_needed_version?(Discourse::VERSION::STRING, minimum_version)
|
|
end
|
|
|
|
if maximum_version = remote_theme&.maximum_discourse_version
|
|
return false unless Discourse.has_needed_version?(maximum_version, Discourse::VERSION::STRING)
|
|
end
|
|
|
|
true
|
|
end
|
|
|
|
def component_validations
|
|
return unless component
|
|
|
|
errors.add(:base, I18n.t("themes.errors.component_no_color_scheme")) if color_scheme_id.present?
|
|
errors.add(:base, I18n.t("themes.errors.component_no_user_selectable")) if user_selectable
|
|
errors.add(:base, I18n.t("themes.errors.component_no_default")) if default?
|
|
end
|
|
|
|
def validate_theme_fields
|
|
theme_fields.each do |field|
|
|
field.errors.full_messages.each { |message| errors.add(:base, message) } unless field.valid?
|
|
end
|
|
end
|
|
|
|
def switch_to_component!
|
|
return if component
|
|
|
|
Theme.transaction do
|
|
self.component = true
|
|
|
|
self.color_scheme_id = nil
|
|
self.user_selectable = false
|
|
Theme.clear_default! if default?
|
|
|
|
ChildTheme.where("parent_theme_id = ?", id).destroy_all
|
|
self.save!
|
|
end
|
|
end
|
|
|
|
def switch_to_theme!
|
|
return unless component
|
|
|
|
Theme.transaction do
|
|
self.enabled = true
|
|
self.component = false
|
|
ChildTheme.where("child_theme_id = ?", id).destroy_all
|
|
self.save!
|
|
end
|
|
end
|
|
|
|
def self.lookup_field(theme_id, target, field, skip_transformation: false, csp_nonce: nil)
|
|
return "" if theme_id.blank?
|
|
|
|
theme_ids = !skip_transformation ? transform_ids(theme_id) : [theme_id]
|
|
resolved = (resolve_baked_field(theme_ids, target.to_sym, field) || "")
|
|
resolved = resolved.gsub(ThemeField::CSP_NONCE_PLACEHOLDER, csp_nonce) if csp_nonce
|
|
resolved.html_safe
|
|
end
|
|
|
|
def self.lookup_modifier(theme_ids, modifier_name)
|
|
theme_ids = [theme_ids] unless theme_ids.is_a?(Array)
|
|
|
|
get_set_cache("#{theme_ids.join(",")}:modifier:#{modifier_name}:#{Theme.compiler_version}") do
|
|
ThemeModifierSet.resolve_modifier_for_themes(theme_ids, modifier_name)
|
|
end
|
|
end
|
|
|
|
def self.remove_from_cache!
|
|
clear_cache!
|
|
end
|
|
|
|
def self.clear_cache!
|
|
cache.clear
|
|
end
|
|
|
|
def self.targets
|
|
@targets ||=
|
|
Enum.new(
|
|
common: 0,
|
|
desktop: 1,
|
|
mobile: 2,
|
|
settings: 3,
|
|
translations: 4,
|
|
extra_scss: 5,
|
|
extra_js: 6,
|
|
tests_js: 7,
|
|
migrations: 8,
|
|
)
|
|
end
|
|
|
|
def self.lookup_target(target_id)
|
|
self.targets.invert[target_id]
|
|
end
|
|
|
|
def self.notify_theme_change(
|
|
theme_ids,
|
|
with_scheme: false,
|
|
clear_manager_cache: true,
|
|
all_themes: false
|
|
)
|
|
Stylesheet::Manager.clear_theme_cache!
|
|
targets = %i[mobile_theme desktop_theme]
|
|
|
|
if with_scheme
|
|
targets.prepend(:desktop, :mobile, :admin)
|
|
targets.append(*Discourse.find_plugin_css_assets(mobile_view: true, desktop_view: true))
|
|
Stylesheet::Manager.cache.clear if clear_manager_cache
|
|
end
|
|
|
|
if all_themes
|
|
message = theme_ids.map { |id| refresh_message_for_targets(targets, id) }.flatten
|
|
else
|
|
message = refresh_message_for_targets(targets, theme_ids).flatten
|
|
end
|
|
|
|
MessageBus.publish("/file-change", message)
|
|
end
|
|
|
|
def notify_theme_change(with_scheme: false)
|
|
DB.after_commit do
|
|
theme_ids = Theme.transform_ids(id)
|
|
self.class.notify_theme_change(theme_ids, with_scheme: with_scheme)
|
|
end
|
|
end
|
|
|
|
def self.refresh_message_for_targets(targets, theme_ids)
|
|
theme_ids = [theme_ids] unless theme_ids.is_a?(Array)
|
|
|
|
targets.each_with_object([]) do |target, data|
|
|
theme_ids.each do |theme_id|
|
|
data << Stylesheet::Manager.new(theme_id: theme_id).stylesheet_data(target.to_sym)
|
|
end
|
|
end
|
|
end
|
|
|
|
def self.resolve_baked_field(theme_ids, target, name)
|
|
target = target.to_sym
|
|
name = name&.to_sym
|
|
|
|
target = :mobile if target == :mobile_theme
|
|
target = :desktop if target == :desktop_theme
|
|
|
|
case target
|
|
when :extra_js
|
|
get_set_cache("#{theme_ids.join(",")}:extra_js:#{Theme.compiler_version}") do
|
|
require_rebake =
|
|
ThemeField.where(theme_id: theme_ids, target_id: Theme.targets[:extra_js]).where(
|
|
"compiler_version <> ?",
|
|
Theme.compiler_version,
|
|
)
|
|
|
|
ActiveRecord::Base.transaction do
|
|
require_rebake.each { |tf| tf.ensure_baked! }
|
|
|
|
Theme.where(id: require_rebake.map(&:theme_id)).each(&:update_javascript_cache!)
|
|
end
|
|
|
|
caches =
|
|
JavascriptCache
|
|
.where(theme_id: theme_ids)
|
|
.index_by(&:theme_id)
|
|
.values_at(*theme_ids)
|
|
.compact
|
|
|
|
caches.map { |c| <<~HTML.html_safe }.join("\n")
|
|
<link rel="preload" href="#{c.url}" as="script" nonce="#{ThemeField::CSP_NONCE_PLACEHOLDER}">
|
|
<script defer src="#{c.url}" data-theme-id="#{c.theme_id}" nonce="#{ThemeField::CSP_NONCE_PLACEHOLDER}"></script>
|
|
HTML
|
|
end
|
|
when :translations
|
|
theme_field_values(theme_ids, :translations, I18n.fallbacks[name])
|
|
.to_a
|
|
.select(&:second)
|
|
.uniq { |((theme_id, _, _), _)| theme_id }
|
|
.flat_map(&:second)
|
|
.join("\n")
|
|
else
|
|
theme_field_values(theme_ids, [:common, target], name).values.compact.flatten.join("\n")
|
|
end
|
|
end
|
|
|
|
def self.theme_field_values(theme_ids, targets, names)
|
|
cache.defer_get_set_bulk(
|
|
Array(theme_ids).product(Array(targets), Array(names)),
|
|
lambda do |(theme_id, target, name)|
|
|
"#{theme_id}:#{target}:#{name}:#{Theme.compiler_version}"
|
|
end,
|
|
) do |keys|
|
|
keys = keys.map { |theme_id, target, name| [theme_id, Theme.targets[target], name.to_s] }
|
|
|
|
keys
|
|
.map do |theme_id, target_id, name|
|
|
ThemeField.where(theme_id: theme_id, target_id: target_id, name: name)
|
|
end
|
|
.inject { |a, b| a.or(b) }
|
|
.each(&:ensure_baked!)
|
|
.map { |tf| [[tf.theme_id, tf.target_id, tf.name], tf.value_baked || tf.value] }
|
|
.group_by(&:first)
|
|
.transform_values { |x| x.map(&:second) }
|
|
.values_at(*keys)
|
|
end
|
|
end
|
|
|
|
def self.list_baked_fields(theme_ids, target, name)
|
|
target = target.to_sym
|
|
name = name&.to_sym
|
|
|
|
if target == :translations
|
|
fields = ThemeField.find_first_locale_fields(theme_ids, I18n.fallbacks[name])
|
|
else
|
|
target = :mobile if target == :mobile_theme
|
|
target = :desktop if target == :desktop_theme
|
|
fields =
|
|
ThemeField.find_by_theme_ids(theme_ids).where(
|
|
target_id: [Theme.targets[target], Theme.targets[:common]],
|
|
)
|
|
fields = fields.where(name: name.to_s) unless name.nil?
|
|
fields = fields.order(:target_id)
|
|
end
|
|
|
|
fields.each(&:ensure_baked!)
|
|
fields
|
|
end
|
|
|
|
def resolve_baked_field(target, name)
|
|
list_baked_fields(target, name).map { |f| f.value_baked || f.value }.join("\n")
|
|
end
|
|
|
|
def list_baked_fields(target, name)
|
|
theme_ids = Theme.transform_ids(id)
|
|
theme_ids = [theme_ids.first] if name != :color_definitions
|
|
self.class.list_baked_fields(theme_ids, target, name)
|
|
end
|
|
|
|
def remove_from_cache!
|
|
self.class.remove_from_cache!
|
|
end
|
|
|
|
def changed_fields
|
|
@changed_fields ||= []
|
|
end
|
|
|
|
def changed_colors
|
|
@changed_colors ||= []
|
|
end
|
|
|
|
def changed_schemes
|
|
@changed_schemes ||= Set.new
|
|
end
|
|
|
|
def set_field(target:, name:, value: nil, type: nil, type_id: nil, upload_id: nil)
|
|
name = name.to_s
|
|
|
|
target_id = Theme.targets[target.to_sym]
|
|
raise "Unknown target #{target} passed to set field" unless target_id
|
|
|
|
type_id ||=
|
|
type ? ThemeField.types[type.to_sym] : ThemeField.guess_type(name: name, target: target)
|
|
raise "Unknown type #{type} passed to set field" unless type_id
|
|
|
|
value ||= ""
|
|
|
|
field = theme_fields.find_by(name: name, target_id: target_id, type_id: type_id)
|
|
|
|
if field
|
|
if value.blank? && !upload_id
|
|
field.destroy
|
|
else
|
|
if field.value != value || field.upload_id != upload_id
|
|
field.value = value
|
|
field.upload_id = upload_id
|
|
changed_fields << field
|
|
end
|
|
end
|
|
else
|
|
if value.present? || upload_id.present?
|
|
field =
|
|
theme_fields.build(
|
|
target_id: target_id,
|
|
value: value,
|
|
name: name,
|
|
type_id: type_id,
|
|
upload_id: upload_id,
|
|
)
|
|
changed_fields << field
|
|
end
|
|
end
|
|
field
|
|
end
|
|
|
|
def child_theme_ids=(theme_ids)
|
|
super(theme_ids)
|
|
Theme.clear_cache!
|
|
end
|
|
|
|
def parent_theme_ids=(theme_ids)
|
|
super(theme_ids)
|
|
Theme.clear_cache!
|
|
end
|
|
|
|
def add_relative_theme!(kind, theme)
|
|
new_relation =
|
|
if kind == :child
|
|
child_theme_relation.new(child_theme_id: theme.id)
|
|
else
|
|
parent_theme_relation.new(parent_theme_id: theme.id)
|
|
end
|
|
if new_relation.save
|
|
child_themes.reload
|
|
parent_themes.reload
|
|
save!
|
|
Theme.clear_cache!
|
|
else
|
|
raise Discourse::InvalidParameters.new(new_relation.errors.full_messages.join(", "))
|
|
end
|
|
end
|
|
|
|
def internal_translations
|
|
@internal_translations ||= translations(internal: true)
|
|
end
|
|
|
|
def translations(internal: false)
|
|
fallbacks = I18n.fallbacks[I18n.locale]
|
|
begin
|
|
data =
|
|
locale_fields.first&.translation_data(
|
|
with_overrides: false,
|
|
internal: internal,
|
|
fallback_fields: locale_fields,
|
|
)
|
|
return {} if data.nil?
|
|
best_translations = {}
|
|
fallbacks.reverse.each { |locale| best_translations.deep_merge! data[locale] if data[locale] }
|
|
ThemeTranslationManager.list_from_hash(
|
|
theme: self,
|
|
hash: best_translations,
|
|
locale: I18n.locale,
|
|
)
|
|
rescue ThemeTranslationParser::InvalidYaml
|
|
{}
|
|
end
|
|
end
|
|
|
|
def settings
|
|
field = settings_field
|
|
settings = {}
|
|
|
|
if field && field.error.nil?
|
|
ThemeSettingsParser
|
|
.new(field)
|
|
.load do |name, default, type, opts|
|
|
settings[name] = ThemeSettingsManager.create(name, default, type, self, opts)
|
|
end
|
|
end
|
|
|
|
settings
|
|
end
|
|
|
|
def cached_settings
|
|
Theme.get_set_cache "settings_for_theme_#{self.id}" do
|
|
build_settings_hash
|
|
end
|
|
end
|
|
|
|
def cached_default_settings
|
|
Theme.get_set_cache "default_settings_for_theme_#{self.id}" do
|
|
settings_hash = {}
|
|
self.settings.each { |name, setting| settings_hash[name] = setting.default }
|
|
|
|
theme_uploads = build_theme_uploads_hash
|
|
settings_hash["theme_uploads"] = theme_uploads if theme_uploads.present?
|
|
|
|
theme_uploads_local = build_local_theme_uploads_hash
|
|
settings_hash["theme_uploads_local"] = theme_uploads_local if theme_uploads_local.present?
|
|
|
|
settings_hash
|
|
end
|
|
end
|
|
|
|
def build_settings_hash
|
|
hash = {}
|
|
self.settings.each { |name, setting| hash[name] = setting.value }
|
|
|
|
theme_uploads = build_theme_uploads_hash
|
|
hash["theme_uploads"] = theme_uploads if theme_uploads.present?
|
|
|
|
theme_uploads_local = build_local_theme_uploads_hash
|
|
hash["theme_uploads_local"] = theme_uploads_local if theme_uploads_local.present?
|
|
|
|
hash
|
|
end
|
|
|
|
def build_theme_uploads_hash
|
|
hash = {}
|
|
upload_fields.each do |field|
|
|
hash[field.name] = Discourse.store.cdn_url(field.upload.url) if field.upload&.url
|
|
end
|
|
hash
|
|
end
|
|
|
|
def build_local_theme_uploads_hash
|
|
hash = {}
|
|
upload_fields.each do |field|
|
|
hash[field.name] = field.javascript_cache.local_url if field.javascript_cache
|
|
end
|
|
hash
|
|
end
|
|
|
|
# Retrieves a theme setting
|
|
#
|
|
# @param setting_name [String, Symbol] The name of the setting to retrieve.
|
|
#
|
|
# @return [Object] The value of the setting that matches the provided name.
|
|
#
|
|
# @raise [Discourse::NotFound] If no setting is found with the provided name.
|
|
#
|
|
# @example
|
|
# theme.get_setting("some_boolean") => True
|
|
# theme.get_setting("some_string") => "hello"
|
|
# theme.get_setting(:some_boolean) => True
|
|
# theme.get_setting(:some_string) => "hello"
|
|
#
|
|
def get_setting(setting_name)
|
|
target_setting = settings[setting_name.to_sym]
|
|
raise Discourse::NotFound unless target_setting
|
|
target_setting.value
|
|
end
|
|
|
|
def update_setting(setting_name, new_value)
|
|
target_setting = settings[setting_name.to_sym]
|
|
raise Discourse::NotFound unless target_setting
|
|
|
|
target_setting.value = new_value
|
|
|
|
self.theme_setting_requests_refresh = true if target_setting.requests_refresh?
|
|
end
|
|
|
|
def update_translation(translation_key, new_value)
|
|
target_translation = translations.find { |translation| translation.key == translation_key }
|
|
raise Discourse::NotFound unless target_translation
|
|
target_translation.value = new_value
|
|
end
|
|
|
|
def translation_override_hash
|
|
hash = {}
|
|
theme_translation_overrides.each do |override|
|
|
cursor = hash
|
|
path = [override.locale] + override.translation_key.split(".")
|
|
path[0..-2].each { |key| cursor = (cursor[key] ||= {}) }
|
|
cursor[path[-1]] = override.value
|
|
end
|
|
hash
|
|
end
|
|
|
|
def generate_metadata_hash
|
|
{}.tap do |meta|
|
|
meta[:name] = name
|
|
meta[:component] = component
|
|
|
|
RemoteTheme::METADATA_PROPERTIES.each do |property|
|
|
meta[property] = remote_theme&.public_send(property)
|
|
meta[property] = nil if meta[property] == "URL" # Clean up old discourse_theme CLI placeholders
|
|
end
|
|
|
|
meta[:assets] = {}.tap do |hash|
|
|
theme_fields
|
|
.where(type_id: ThemeField.types[:theme_upload_var])
|
|
.each { |field| hash[field.name] = field.file_path }
|
|
end
|
|
|
|
meta[:color_schemes] = {}.tap do |hash|
|
|
schemes = self.color_schemes
|
|
# The selected color scheme may not belong to the theme, so include it anyway
|
|
schemes = [self.color_scheme] + schemes if self.color_scheme
|
|
schemes.uniq.each do |scheme|
|
|
hash[scheme.name] = {}.tap do |colors|
|
|
scheme.colors.each { |color| colors[color.name] = color.hex }
|
|
end
|
|
end
|
|
end
|
|
|
|
meta[:modifiers] = {}.tap do |hash|
|
|
ThemeModifierSet.modifiers.keys.each do |modifier|
|
|
value = self.theme_modifier_set.public_send(modifier)
|
|
hash[modifier] = value if !value.nil?
|
|
end
|
|
end
|
|
|
|
meta[
|
|
:learn_more
|
|
] = "https://meta.discourse.org/t/beginners-guide-to-using-discourse-themes/91966"
|
|
end
|
|
end
|
|
|
|
def disabled_by
|
|
find_disable_action_log&.acting_user
|
|
end
|
|
|
|
def disabled_at
|
|
find_disable_action_log&.created_at
|
|
end
|
|
|
|
def with_scss_load_paths
|
|
return yield([]) if self.extra_scss_fields.empty?
|
|
|
|
ThemeStore::ZipExporter
|
|
.new(self)
|
|
.with_export_dir(extra_scss_only: true) { |dir| yield ["#{dir}/stylesheets"] }
|
|
end
|
|
|
|
def scss_variables
|
|
settings_hash = build_settings_hash
|
|
theme_variable_fields = var_theme_fields
|
|
|
|
return if theme_variable_fields.empty? && settings_hash.empty?
|
|
|
|
contents = +""
|
|
|
|
theme_variable_fields&.each do |field|
|
|
if field.type_id == ThemeField.types[:theme_upload_var]
|
|
if upload = field.upload
|
|
url = upload_cdn_path(upload.url)
|
|
contents << "$#{field.name}: unquote(\"#{url}\");"
|
|
end
|
|
else
|
|
contents << to_scss_variable(field.name, field.value)
|
|
end
|
|
end
|
|
|
|
settings_hash&.each do |name, value|
|
|
next if name == "theme_uploads" || name == "theme_uploads_local"
|
|
contents << to_scss_variable(name, value)
|
|
end
|
|
|
|
contents
|
|
end
|
|
|
|
def migrate_settings(start_transaction: true)
|
|
block = -> do
|
|
runner = ThemeSettingsMigrationsRunner.new(self)
|
|
results = runner.run
|
|
|
|
next if results.blank?
|
|
|
|
old_settings = self.theme_settings.pluck(:name)
|
|
self.theme_settings.destroy_all
|
|
|
|
final_result = results.last
|
|
|
|
final_result[:settings_after].each do |key, val|
|
|
self.update_setting(key.to_sym, val)
|
|
rescue Discourse::NotFound
|
|
if old_settings.include?(key)
|
|
final_result[:settings_after].delete(key)
|
|
else
|
|
raise Theme::SettingsMigrationError.new(
|
|
I18n.t(
|
|
"themes.import_error.migrations.unknown_setting_returned_by_migration",
|
|
name: final_result[:original_name],
|
|
setting_name: key,
|
|
),
|
|
)
|
|
end
|
|
end
|
|
|
|
results.each do |res|
|
|
record =
|
|
ThemeSettingsMigration.new(
|
|
theme_id: self.id,
|
|
version: res[:version],
|
|
name: res[:name],
|
|
theme_field_id: res[:theme_field_id],
|
|
)
|
|
record.calculate_diff(res[:settings_before], res[:settings_after])
|
|
record.save!
|
|
end
|
|
|
|
self.reload
|
|
self.update_javascript_cache!
|
|
end
|
|
|
|
if start_transaction
|
|
self.transaction(&block)
|
|
else
|
|
block.call
|
|
end
|
|
end
|
|
|
|
def convert_list_to_json_schema(setting_row, setting)
|
|
schema = setting.json_schema
|
|
return if !schema
|
|
keys = schema["items"]["properties"].keys
|
|
return if !keys
|
|
|
|
current_values = CSV.parse(setting_row.value, **{ col_sep: "|" }).flatten
|
|
|
|
new_values =
|
|
current_values.map do |item|
|
|
parts = CSV.parse(item, **{ col_sep: "," }).flatten
|
|
raise "Schema validation failed" if keys.size < parts.size
|
|
parts.zip(keys).map(&:reverse).to_h
|
|
end
|
|
|
|
schemer = JSONSchemer.schema(schema)
|
|
raise "Schema validation failed" if !schemer.valid?(new_values)
|
|
|
|
setting_row.value = new_values.to_json
|
|
setting_row.data_type = setting.type
|
|
setting_row.save!
|
|
end
|
|
|
|
def baked_js_tests_with_digest
|
|
tests_tree =
|
|
theme_fields_to_tree(
|
|
theme_fields.where(target_id: Theme.targets[:tests_js]).order(name: :asc),
|
|
)
|
|
|
|
return nil, nil if tests_tree.blank?
|
|
|
|
migrations_tree =
|
|
theme_fields_to_tree(
|
|
theme_fields.where(target_id: Theme.targets[:migrations]).order(name: :asc),
|
|
)
|
|
|
|
compiler = ThemeJavascriptCompiler.new(id, name, minify: false)
|
|
compiler.append_tree(migrations_tree, include_variables: false)
|
|
compiler.append_tree(tests_tree)
|
|
|
|
compiler.append_raw_script "test_setup.js", <<~JS
|
|
(function() {
|
|
require("discourse/lib/theme-settings-store").registerSettings(#{self.id}, #{cached_default_settings.to_json}, { force: true });
|
|
})();
|
|
JS
|
|
|
|
content = compiler.content
|
|
|
|
if compiler.source_map
|
|
content +=
|
|
"\n//# sourceMappingURL=data:application/json;base64,#{Base64.strict_encode64(compiler.source_map)}\n"
|
|
end
|
|
|
|
[content, Digest::SHA1.hexdigest(content)]
|
|
end
|
|
|
|
private
|
|
|
|
attr_accessor :theme_setting_requests_refresh
|
|
|
|
def theme_fields_to_tree(theme_fields_scope)
|
|
theme_fields_scope.reduce({}) do |tree, theme_field|
|
|
tree[theme_field.file_path] = theme_field.value
|
|
tree
|
|
end
|
|
end
|
|
|
|
def to_scss_variable(name, value)
|
|
escaped = SassC::Script::Value::String.quote(value.to_s, sass: true)
|
|
"$#{name}: unquote(#{escaped});"
|
|
end
|
|
|
|
def find_disable_action_log
|
|
if component? && !enabled?
|
|
@disable_log ||=
|
|
UserHistory
|
|
.where(context: id.to_s, action: UserHistory.actions[:disable_theme_component])
|
|
.order("created_at DESC")
|
|
.first
|
|
end
|
|
end
|
|
end
|
|
|
|
# == Schema Information
|
|
#
|
|
# Table name: themes
|
|
#
|
|
# id :integer not null, primary key
|
|
# name :string not null
|
|
# user_id :integer not null
|
|
# created_at :datetime not null
|
|
# updated_at :datetime not null
|
|
# compiler_version :integer default(0), not null
|
|
# user_selectable :boolean default(FALSE), not null
|
|
# hidden :boolean default(FALSE), not null
|
|
# color_scheme_id :integer
|
|
# remote_theme_id :integer
|
|
# component :boolean default(FALSE), not null
|
|
# enabled :boolean default(TRUE), not null
|
|
# auto_update :boolean default(TRUE), not null
|
|
#
|
|
# Indexes
|
|
#
|
|
# index_themes_on_remote_theme_id (remote_theme_id) UNIQUE
|
|
#
|