Class: Setting

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

Overview

Redmine - project management software Copyright (C) 2006-2016 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

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



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

def self.[](name)
  v = @cached_settings[name]
  v ? v : (@cached_settings[name] = find_or_default(name).value)
end

.[]=(name, v) ⇒ Object 



113
114
115
116
117
118
119
 
# File 'app/models/setting.rb', line 113

def self.[]=(name, v)
  setting = find_or_default(name)
  setting.value = (v ? 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



230
231
232
233
234
235
 
# File 'app/models/setting.rb', line 230

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



238
239
240
241
242
 
# File 'app/models/setting.rb', line 238

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



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

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”]



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

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 



244
245
246
247
248
249
 
# File 'app/models/setting.rb', line 244

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”



254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
 
# File 'app/models/setting.rb', line 254

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 



273
274
275
276
277
 
# File 'app/models/setting.rb', line 273

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 



279
280
281
282
283
 
# File 'app/models/setting.rb', line 279

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

.openid? ⇒ Boolean

Returns:

  • (Boolean) 


223
224
225
 
# File 'app/models/setting.rb', line 223

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



203
204
205
 
# File 'app/models/setting.rb', line 203

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



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'app/models/setting.rb', line 122

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.security_settings_updated(changes)
  end
  nil
end

.set_from_params(name, params) ⇒ Object

Sets a setting value from params



167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'app/models/setting.rb', line 167

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 



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'app/models/setting.rb', line 144

def self.validate_all_from_params(settings)
  messages = []

  if settings.key?(:mail_handler_body_delimiters) || settings.key?(:mail_handler_enable_regex_delimiters)
    regexp = Setting.mail_handler_enable_regex_delimiters?
    if settings.key?(:mail_handler_enable_regex_delimiters)
      regexp = settings[:mail_handler_enable_regex_delimiters].to_s != '0'
    end
    if regexp
      settings[:mail_handler_body_delimiters].to_s.split(/[\r\n]+/).each do |delimiter|
        begin
          Regexp.new(delimiter)
        rescue RegexpError => e
          messages << [:mail_handler_body_delimiters, "#{l('activerecord.errors.messages.not_a_regexp')} (#{e.message})"]
        end
      end
    end
  end

  messages
end

Instance Method Details

#value ⇒ Object 



91
92
93
94
95
96
97
98
99
100
 
# File 'app/models/setting.rb', line 91

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 



102
103
104
105
 
# File 'app/models/setting.rb', line 102

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