def _value(self):
global is_setting_initializing
use_db, overrides = get_overrides()
if not use_db:
try:
val = overrides[self.group.key][self.key]
except KeyError:
if self.use_default:
val = self.default
else:
raise SettingNotSet('%s.%s is not in your LIVESETTINGS_OPTIONS' % (self.group.key, self.key))
else:
try:
val = self.setting.value
except SettingNotSet:
is_setting_initializing = False
if self.use_default:
val = self.default
if overrides:
# maybe override the default
grp = overrides.get(self.group.key, {})
if self.key in grp:
val = grp[self.key]
else:
val = NOTSET
except AttributeError as ae:
is_setting_initializing = False
log.error("Attribute error: %s", ae)
log.error("%s: Could not get _value of %s", self.key, self.setting)
raise(ae)
except Exception as e:
global _WARN
if is_setting_initializing and isinstance(e, DatabaseError) and str(e).find("livesettings_setting") > -1:
if not 'livesettings_setting' in _WARN:
log.warn(str(e).strip())
_WARN['livesettings_setting'] = True
log.warn('Error loading livesettings from table, OK if you are in syncdb or before it. ROLLBACK')
connection._rollback()
if self.use_default:
val = self.default
else:
raise ImproperlyConfigured("All settings used in startup must have defaults, %s.%s does not", self.group.key, self.key)
else:
is_setting_initializing = False
import traceback
traceback.print_exc()
log.error("Problem finding settings %s.%s, %s", self.group.key, self.key, e)
raise SettingNotSet("Startup error, couldn't load %s.%s" % (self.group.key, self.key))
else:
is_setting_initializing = False
return val
def get_config(self, group, key):
try:
if isinstance(group, values.ConfigurationGroup):
group = group.key
cg = self.settings.get(group, None)
if not cg:
raise SettingNotSet('%s config group does not exist' %
group)
else:
return cg[key]
except KeyError:
raise SettingNotSet('%s.%s' % (group, key))
def load_module(self, module):
"""Load a child module"""
value = self._value()
if value == NOTSET:
raise SettingNotSet(f"{self.group.key}.{self.key}")
else:
return load_module("%s.%s" % (value, module))
def config_collect_values(group,
groupkey,
key,
unique=True,
skip_missing=True):
"""Look up (group, groupkey) from config, then take the values returned and
use them as groups for a second-stage lookup.
For example:
config_collect_values(PAYMENT, MODULES, CREDITCHOICES)
Stage 1: ['PAYMENT_GOOGLE', 'PAYMENT_AUTHORIZENET']
Stage 2: config_value('PAYMENT_GOOGLE', 'CREDITCHOICES')
+ config_value('PAYMENT_AUTHORIZENET', 'CREDITCHOICES')
Stage 3: (if unique is true) remove dupes
"""
groups = config_value(group, groupkey)
ret = []
for g in groups:
try:
ret.append(config_value(g, key))
except KeyError, ke:
if not skip_missing:
raise SettingNotSet('No config %s.%s' % (g, key))
def _value(self):
use_db, overrides = get_overrides()
if not use_db:
try:
val = overrides[self.group.key][self.key]
except KeyError:
if self.use_default:
val = self.default
else:
raise SettingNotSet('%s.%s is not in your LIVESETTINGS_OPTIONS' % (self.group.key, self.key))
else:
try:
val = self.setting.value
except SettingNotSet, sns:
if self.use_default:
val = self.default
if overrides:
# maybe override the default
grp = overrides.get(self.group.key, {})
if grp.has_key(self.key):
val = grp[self.key]
else:
val = NOTSET
except AttributeError, ae:
log.error("Attribute error: %s", ae)
log.error("%s: Could not get _value of %s", self.key, self.setting)
raise(ae)
def load_module(self, module):
"""Load a child module"""
value = self._value()
if value == NOTSET:
raise SettingNotSet("{}.{}".format(
self.group.key,
self.key,
))
else:
return load_module("%s.%s" % (value, module))
def config_choice_values(group, key, skip_missing=True, translate=False):
"""Get pairs of key, label from the setting."""
try:
cfg = config_get(group, key)
choices = cfg.choice_values
except SettingNotSet:
if skip_missing:
return []
else:
raise SettingNotSet('%s.%s' % (group, key))
if translate:
choices = [(k, ugettext(v)) for k, v in choices]
return choices
def _value(self):
use_db, overrides = get_overrides()
lang = get_language()
key = self.key
if self.localized:
key += '_' + format_setting_name(lang)
if not use_db:
try:
val = overrides[self.group.key][key]
except KeyError:
if self.use_default:
val = self.default
else:
raise SettingNotSet('%s.%s is not in your LIVESETTINGS_OPTIONS' % (self.group.key, key))
else:
try:
val = self.setting.value
except SettingNotSet:
if self.localized and lang == django_settings.LANGUAGE_CODE:
try:
unlocalized_setting = find_setting(self.group.key, self.key)
return unlocalized_setting.value
except SettingNotSet:
pass
if self.use_default:
val = self.default
if overrides:
# maybe override the default
grp = overrides.get(self.group.key, {})
if key in grp:
val = grp[self.key]
else:
val = NOTSET
except AttributeError as ae:
logger.error("Attribute error: %s", ae)
logger.error("%s: Could not get _value of %s", key, self.setting)
raise(ae)
except Exception as e:
global _WARN
logger.error(e)
if str(e).find("configuration_setting") > -1:
if 'configuration_setting' not in _WARN:
logger.warn('Error loading setting %s.%s from table, OK if you are in syncdb', self.group.key, key)
_WARN['configuration_setting'] = True
if self.use_default:
val = self.default
else:
raise ImproperlyConfigured("All settings used in startup must have defaults, %s.%s does not",
self.group.key, key)
else:
traceback.print_exc()
logger.warn("Problem finding settings %s.%s, %s", self.group.key, key, e)
raise SettingNotSet("Startup error, couldn't load %s.%s" % (self.group.key, key))
return val
class Value(object):
creation_counter = 0
def __init__(self, group, key, **kwargs):
"""
Create a new Value object for configuration.
Args:
- `ConfigurationGroup`
- key - a string key
Named arguments:
- `description` - Will be passed to the field for form usage. Should be a translation proxy. Ex: _('example')
- `help_text` - Will be passed to the field for form usage.
- `choices` - If given, then the form field will use a select box
- `ordering` - Defaults to alphabetical by key if not given.
- `requires` - If given as a `Value`, then this field will only be rendered if that Value evaluates true (for Boolean requires) or the proper key is in the associated value.
- `requiresvalue` - If set, then this field will only be rendered if that value is in the list returned by self.value. Defaults to self.key.
- `hidden` - If true, then render a hidden field.
- `default` - If given, then this Value will return that default whenever it has no associated `Setting`.
- `update_callback` - if given, then this value will call the callback whenever updated
"""
self.group = group
self.key = key
self.description = kwargs.get('description', None)
self.help_text = kwargs.get('help_text')
self.choices = kwargs.get('choices', [])
self.ordering = kwargs.pop('ordering', 0)
self.hidden = kwargs.pop('hidden', False)
self.update_callback = kwargs.pop('update_callback', None)
self.requires = kwargs.pop('requires', None)
if self.requires:
reqval = kwargs.pop('requiresvalue', key)
if not is_list_or_tuple(reqval):
reqval = (reqval, reqval)
self.requires_value = reqval[0]
self.requires.add_choice(reqval)
elif group.requires:
self.requires = group.requires
self.requires_value = group.requires_value
if kwargs.has_key('default'):
self.default = kwargs.pop('default')
self.use_default = True
else:
self.use_default = False
self.creation_counter = Value.creation_counter
Value.creation_counter += 1
def __cmp__(self, other):
return cmp((self.ordering, self.description, self.creation_counter),
(other.ordering, other.description, other.creation_counter))
def __eq__(self, other):
if type(self) == type(other):
return self.value == other.value
else:
return self.value == other
def __iter__(self):
return iter(self.value)
def __unicode__(self):
return unicode(self.value)
def __str__(self):
return str(self.value)
def add_choice(self, choice):
"""Add a choice if it doesn't already exist."""
if not is_list_or_tuple(choice):
choice = (choice, choice)
skip = False
for k, v in self.choices:
if k == choice[0]:
skip = True
break
if not skip:
self.choices += (choice, )
def choice_field(self, **kwargs):
if self.hidden:
kwargs['widget'] = forms.MultipleHiddenInput()
return forms.ChoiceField(choices=self.choices, **kwargs)
def _choice_values(self):
choices = self.choices
vals = self.value
return [x for x in choices if x[0] in vals]
choice_values = property(fget=_choice_values)
def copy(self):
new_value = self.__class__(self.key)
new_value.__dict__ = self.__dict__.copy()
return new_value
def _default_text(self):
if not self.use_default:
note = ""
else:
if self.default == "":
note = _('Default value: ""')
elif self.choices:
work = []
for x in self.choices:
try:
if x[0] == self.default or x[0] in self.default:
work.append('%s' % unicode(smart_str(x[1])))
except TypeError:
continue
note = gettext('Default value: ') + ", ".join(work)
else:
note = _("Default value: %s") % unicode(self.default)
return note
default_text = property(fget=_default_text)
def enabled(self):
enabled = False
try:
if not self.requires:
enabled = True
else:
v = self.requires.value
if self.requires.choices:
enabled = self.requires_value == v or self.requires_value in v
elif v:
enabled = True
except SettingNotSet:
pass
return enabled
def make_field(self, **kwargs):
if self.choices:
if self.hidden:
kwargs['widget'] = forms.MultipleHiddenInput()
field = self.choice_field(**kwargs)
else:
if self.hidden:
kwargs['widget'] = forms.HiddenInput()
field = self.field(**kwargs)
field.group = self.group
field.default_text = self.default_text
return field
def make_setting(self, db_value):
log.debug('new setting %s.%s', self.group.key, self.key)
try:
version = Setting.objects.latest('version').version
except Setting.DoesNotExist:
version = 1
return Setting(group=self.group.key,
key=self.key,
value=db_value,
version=version)
def _setting(self):
return find_setting(self.group.key, self.key)
setting = property(fget=_setting)
def _value(self):
global is_setting_initializing
use_db, overrides = get_overrides()
if not use_db:
try:
val = overrides[self.group.key][self.key]
except KeyError:
if self.use_default:
val = self.default
else:
raise SettingNotSet(
'%s.%s is not in your LIVESETTINGS_OPTIONS' %
(self.group.key, self.key))
else:
try:
val = self.setting.value
except SettingNotSet, sns:
is_setting_initializing = False
if self.use_default:
val = self.default
if overrides:
# maybe override the default
grp = overrides.get(self.group.key, {})
if grp.has_key(self.key):
val = grp[self.key]
else:
val = NOTSET
except AttributeError, ae:
is_setting_initializing = False
log.error("Attribute error: %s", ae)
log.error("%s: Could not get _value of %s", self.key,
self.setting)
raise (ae)
except Exception, e:
global _WARN
if is_setting_initializing and isinstance(
e, DatabaseError
) and str(e).find("livesettings_setting") > -1:
if not _WARN.has_key('livesettings_setting'):
log.warn(str(e).strip())
_WARN['livesettings_setting'] = True
log.warn(
'Error loading livesettings from table, OK if you are in syncdb or before it. ROLLBACK'
)
connection._rollback()
if self.use_default:
val = self.default
else:
raise ImproperlyConfigured(
"All settings used in startup must have defaults, %s.%s does not",
self.group.key, self.key)
else:
is_setting_initializing = False
import traceback
traceback.print_exc()
log.error("Problem finding settings %s.%s, %s",
self.group.key, self.key, e)
raise SettingNotSet("Startup error, couldn't load %s.%s" %
(self.group.key, self.key))
