Class: Setting

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/setting.rb

Overview

Redmine - project management software Copyright (C) 2006-2020 Jean-Philippe Lang

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

Constant Summary collapse

PASSWORD_CHAR_CLASSES = 
{
  'uppercase'     => /[A-Z]/,
  'lowercase'     => /[a-z]/,
  'digits'        => /[0-9]/,
  'special_chars' => /[[:ascii:]&&[:graph:]&&[:^alnum:]]/
}
DATE_FORMATS = 
[
  '%Y-%m-%d',
  '%d/%m/%Y',
  '%d.%m.%Y',
  '%d-%m-%Y',
  '%m/%d/%Y',
  '%d %b %Y',
  '%d %B %Y',
  '%b %d, %Y',
  '%B %d, %Y'
]
TIME_FORMATS = 
[
  '%H:%M',
  '%I:%M %p'
]
ENCODINGS = 
%w(US-ASCII
windows-1250
windows-1251
windows-1252
windows-1253
windows-1254
windows-1255
windows-1256
windows-1257
windows-1258
windows-31j
ISO-2022-JP
ISO-2022-KR
ISO-8859-1
ISO-8859-2
ISO-8859-3
ISO-8859-4
ISO-8859-5
ISO-8859-6
ISO-8859-7
ISO-8859-8
ISO-8859-9
ISO-8859-13
ISO-8859-15
KOI8-R
UTF-8
UTF-16
UTF-16BE
UTF-16LE
EUC-JP
Shift_JIS
CP932
GB18030
GBK
ISCII91
EUC-KR
Big5
Big5-HKSCS
TIS-620)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.[](name) ⇒ Object

Returns the value of the setting named name


115
116
117
 
# File 'app/models/setting.rb', line 115

def self.[](name)
  @cached_settings[name] ||= find_or_default(name).value
end

.[]=(name, v) ⇒ Object 


119
120
121
122
123
124
125
 
# File 'app/models/setting.rb', line 119

def self.[]=(name, v)
  setting = find_or_default(name)
  setting.value = v || ''
  @cached_settings[name] = nil
  setting.save
  setting.value
end

.check_cache ⇒ Object

Checks if settings have changed since the values were read and clears the cache hash if it's the case Called once per request


256
257
258
259
260
261
 
# File 'app/models/setting.rb', line 256

def self.check_cache
  settings_updated_on = Setting.maximum(:updated_on)
  if settings_updated_on && @cached_cleared_on <= settings_updated_on
    clear_cache
  end
end

.clear_cache ⇒ Object

Clears the settings cache


264
265
266
267
268
 
# File 'app/models/setting.rb', line 264

def self.clear_cache
  @cached_settings.clear
  @cached_cleared_on = Time.now
  logger.info "Settings cache cleared." if logger
end

.commit_update_keywords_array ⇒ Object

Helper that returns a Hash with single update keywords as keys


232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'app/models/setting.rb', line 232

def self.commit_update_keywords_array
  a = []
  if commit_update_keywords.is_a?(Array)
    commit_update_keywords.each do |rule|
      next unless rule.is_a?(Hash)

      rule = rule.dup
      rule.delete_if {|k, v| v.blank?}
      keywords = rule['keywords'].to_s.downcase.split(",").map(&:strip).reject(&:blank?)
      next if keywords.empty?

      a << rule.merge('keywords' => keywords)
    end
  end
  a
end

.commit_update_keywords_from_params(params) ⇒ Object

Returns a hash suitable for commit_update_keywords setting

Example: params = => ['fixes', 'closes'], :status_id => [“3”, “5”], :done_ratio => [“”, “100”] Setting.commit_update_keywords_from_params(params) # => [=> 'fixes', 'status_id' => “3”, => 'closes', 'status_id' => “5”, 'done_ratio' => “100”]


209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'app/models/setting.rb', line 209

def self.commit_update_keywords_from_params(params)
  s = []
  if params.is_a?(Hash) && params.key?(:keywords) && params.values.all? {|v| v.is_a? Array}
    attributes = params.except(:keywords).keys
    params[:keywords].each_with_index do |keywords, i|
      next if keywords.blank?

      s << attributes.inject({}) {|h, a|
        value = params[a][i].to_s
        h[a.to_s] = value if value.present?
        h
      }.merge('keywords' => keywords)
    end
  end
  s
end

.define_plugin_setting(plugin) ⇒ Object 


270
271
272
273
274
275
 
# File 'app/models/setting.rb', line 270

def self.define_plugin_setting(plugin)
  if plugin.settings
    name = "plugin_#{plugin.id}"
    define_setting name, {'default' => plugin.settings[:default], 'serialized' => true}
  end
end

.define_setting(name, options = {}) ⇒ Object

Defines getter and setter for each setting Then setting values can be read using: Setting.some_setting_name or set using Setting.some_setting_name = “some value”


280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
 
# File 'app/models/setting.rb', line 280

def self.define_setting(name, options={})
  available_settings[name.to_s] = options

  src = <<~END_SRC
    def self.#{name}
      self[:#{name}]
    end

    def self.#{name}?
      self[:#{name}].to_i > 0
    end

    def self.#{name}=(value)
      self[:#{name}] = value
    end
  END_SRC
  class_eval src, __FILE__, __LINE__
end

.load_available_settings ⇒ Object 


299
300
301
302
303
 
# File 'app/models/setting.rb', line 299

def self.load_available_settings
  YAML::load(File.open("#{Rails.root}/config/settings.yml")).each do |name, options|
    define_setting name, options
  end
end

.load_plugin_settings ⇒ Object 


305
306
307
308
309
 
# File 'app/models/setting.rb', line 305

def self.load_plugin_settings
  Redmine::Plugin.all.each do |plugin|
    define_plugin_setting(plugin)
  end
end

.openid? ⇒ Boolean

Returns:

  • (Boolean) 

249
250
251
 
# File 'app/models/setting.rb', line 249

def self.openid?
  Object.const_defined?(:OpenID) && self[:openid].to_i > 0
end

.per_page_options_array ⇒ Object

Helper that returns an array based on per_page_options setting


227
228
229
 
# File 'app/models/setting.rb', line 227

def self.per_page_options_array
  per_page_options.split(%r{[\s,]}).collect(&:to_i).select {|n| n > 0}.sort
end

.set_all_from_params(settings) ⇒ Object

Updates multiple settings from params and sends a security notification if needed


128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
 
# File 'app/models/setting.rb', line 128

def self.set_all_from_params(settings)
  return nil unless settings.is_a?(Hash)

  settings = settings.dup.symbolize_keys

  errors = validate_all_from_params(settings)
  return errors if errors.present?

  changes = []
  settings.each do |name, value|
    next unless available_settings[name.to_s]

    previous_value = Setting[name]
    set_from_params name, value
    if available_settings[name.to_s]['security_notifications'] && Setting[name] != previous_value
      changes << name
    end
  end
  if changes.any?
    Mailer.deliver_settings_updated(User.current, changes)
  end
  nil
end

.set_from_params(name, params) ⇒ Object

Sets a setting value from params


190
191
192
193
194
195
196
197
198
199
200
201
 
# File 'app/models/setting.rb', line 190

def self.set_from_params(name, params)
  params = params.dup
  params.delete_if {|v| v.blank? } if params.is_a?(Array)
  params.symbolize_keys! if params.is_a?(Hash)

  m = "#{name}_from_params"
  if respond_to? m
    self[name.to_sym] = send m, params
  else
    self[name.to_sym] = params
  end
end

.validate_all_from_params(settings) ⇒ Object 


152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
 
# File 'app/models/setting.rb', line 152

def self.validate_all_from_params(settings)
  messages = []
  [
    [:mail_handler_enable_regex_delimiters,
     :mail_handler_body_delimiters,
     /[\r\n]+/],
    [:mail_handler_enable_regex_excluded_filenames,
     :mail_handler_excluded_filenames,
     /\s*,\s*/]
  ].each do |enable_regex, regex_field, delimiter|
    if settings.key?(regex_field) || settings.key?(enable_regex)
      regexp = Setting.send("#{enable_regex}?")
      if settings.key?(enable_regex)
        regexp = settings[enable_regex].to_s != '0'
      end
      if regexp
        settings[regex_field].to_s.split(delimiter).each do |value|
          begin
            Regexp.new(value)
          rescue RegexpError => e
            messages << [regex_field, "#{l('activerecord.errors.messages.not_a_regexp')} (#{e.message})"]
          end
        end
      end
    end
  end
  if settings.key?(:mail_from)
    begin
      mail_from = Mail::Address.new(settings[:mail_from])
      raise unless mail_from.address =~ EmailAddress::EMAIL_REGEXP
    rescue
      messages << [:mail_from, l('activerecord.errors.messages.invalid')]
    end
  end
  messages
end

Instance Method Details

#value ⇒ Object 


98
99
100
101
102
103
104
105
106
107
 
# File 'app/models/setting.rb', line 98

def value
  v = read_attribute(:value)
  # Unserialize serialized settings
  if available_settings[name]['serialized'] && v.is_a?(String)
    v = YAML::load(v)
    v = force_utf8_strings(v)
  end
  v = v.to_sym if available_settings[name]['format'] == 'symbol' && !v.blank?
  v
end

#value=(v) ⇒ Object 


109
110
111
112
 
# File 'app/models/setting.rb', line 109

def value=(v)
  v = v.to_yaml if v && available_settings[name] && available_settings[name]['serialized']
  write_attribute(:value, v.to_s)
end