def update(self, value):
use_db, overrides = get_overrides()
if use_db:
current_value = self.value
new_value = self.to_python(value)
if current_value != new_value:
if self.update_callback:
new_value = apply(self.update_callback, (current_value, new_value))
db_value = self.get_db_prep_save(new_value)
try:
s = self.setting
s.value = db_value
except SettingNotSet:
s = self.make_setting(db_value)
if self.use_default and self.default == new_value:
if s.id:
log.info("Deleted setting %s.%s", self.group.key, self.key)
s.delete()
else:
log.info("Updated setting %s.%s = %s", self.group.key, self.key, value)
s.save()
signals.configuration_value_changed.send(self, old_value=current_value, new_value=new_value, setting=self)
return True
else:
log.debug('not updating setting %s.%s - livesettings db is disabled',self.group.key, self.key)
return False
def update(self, value):
use_db, overrides = get_overrides()
if use_db:
current_value = self.value
new_value = self.to_python(value)
if current_value != new_value:
if self.update_callback:
new_value = apply(self.update_callback, (current_value, new_value))
db_value = self.get_db_prep_save(new_value)
try:
s = self.setting
s.value = db_value
except SettingNotSet:
s = self.make_setting(db_value)
if self.use_default and self.default == new_value:
if s.id:
log.info("Deleted setting %s.%s", self.group.key, self.key)
s.delete()
else:
log.info("Updated setting %s.%s = %s", self.group.key, self.key, value)
s.save()
signals.configuration_value_changed.send(self, old_value=current_value, new_value=new_value, setting=self)
return True
else:
log.debug('not updating setting %s.%s - livesettings db is disabled',self.group.key, self.key)
return False
def group_settings(request, group, template='livesettings/group_settings.html'):
# Determine what set of settings this editor is used for
use_db, overrides = get_overrides();
mgr = ConfigurationSettings()
if group is None:
settings = mgr
title = 'Site settings'
else:
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
if use_db:
# Create an editor customized for the current user
# editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
form = forms.SettingsEditor(data, settings=settings)
if form.is_valid():
form.full_clean()
for name, value in list(form.cleaned_data.items()):
group, key = name.split('__')
cfg = mgr.get_config(group, key)
from livesettings.values import ImageValue
if isinstance(cfg, ImageValue):
if request.FILES and name in request.FILES:
value = request.FILES[name]
else:
continue
try:
if cfg.update(value):
# Give user feedback as to which settings were changed
messages.add_message(request, messages.INFO,
'Updated %s on %s' % (cfg.key, cfg.group.key))
except Exception as e:
log.exception(f'failed to save setting {name}:={value}')
request.user.message_set.create(message=str(e))
return HttpResponseRedirect(request.path)
else:
# Leave the form populated with current setting values
# form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
return render(request, template, {
'all_super_groups': mgr.get_super_groups(),
'page_class': 'settings',
'title': title,
'settings_group': settings,
'group': group,
'form': form,
'use_db': use_db,
})
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
setting = None
use_db, overrides = get_overrides(siteid)
ck = cache_key('Setting', siteid, group, key)
if use_db:
try:
setting = cache_get(ck)
except NotCachedError, nce:
if loading.app_cache_ready():
try:
setting = Setting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except Setting.DoesNotExist:
# maybe it is a "long setting"
try:
setting = LongSetting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except LongSetting.DoesNotExist:
pass
cache_set(ck, value=setting)
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
setting = None
use_db, overrides = get_overrides(siteid)
ck = cache_key('Setting', siteid, group, key)
if use_db:
try:
setting = cache_get(ck)
except NotCachedError, nce:
if loading.app_cache_ready():
try:
setting = Setting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except Setting.DoesNotExist:
# maybe it is a "long setting"
try:
setting = LongSetting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except LongSetting.DoesNotExist:
pass
cache_set(ck, value=setting)
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 _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 as 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 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 'livesettings_setting' not 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 _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 group_settings(request,
group,
template='livesettings/group_settings.jinja'):
# Determine what set of settings this editor is used for
use_db, overrides = get_overrides()
mgr = ConfigurationSettings()
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
if use_db:
# Create an editor customized for the current user
# editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
form = forms.SettingsEditor(data, request.FILES, settings=settings)
if form.is_valid():
for name, value in form.cleaned_data.items():
group, key, lang = name.split('__')
cfg = mgr.get_config(group, key)
if isinstance(cfg, ImageValue):
if request.FILES and name in request.FILES:
value = request.FILES[name]
else:
continue
try:
cfg.update(value, lang)
# message='Updated %s on %s' % (cfg.key, cfg.group.key)
# messages.success(request, message)
# the else if for the settings that are not updated.
except Exception as e:
traceback.print_exc()
request.user.message_set.create(
message=six.text_type(e))
return redirect(request.path)
else:
# Leave the form populated with current setting values
# form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
return render(
request, template, {
'all_super_groups': mgr.get_super_groups(),
'title': title,
'settings_group': settings,
'form': form,
'use_db': use_db
})
def group_settings(request, group, template='livesettings/group_settings.jinja'):
# Determine what set of settings this editor is used for
use_db, overrides = get_overrides()
mgr = ConfigurationSettings()
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
if use_db:
# Create an editor customized for the current user
# editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
form = forms.SettingsEditor(data, request.FILES, settings=settings)
if form.is_valid():
for name, value in form.cleaned_data.items():
group, key, lang = name.split('__')
cfg = mgr.get_config(group, key)
if isinstance(cfg, ImageValue):
if request.FILES and name in request.FILES:
value = request.FILES[name]
else:
continue
try:
cfg.update(value, lang)
# message='Updated %s on %s' % (cfg.key, cfg.group.key)
# messages.success(request, message)
# the else if for the settings that are not updated.
except Exception as e:
traceback.print_exc()
request.user.message_set.create(message=six.text_type(e))
return redirect(request.path)
else:
# Leave the form populated with current setting values
# form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
return render(request, template, {
'all_super_groups': mgr.get_super_groups(),
'title': title,
'settings_group': settings,
'form': form,
'use_db': use_db
})
def group_settings(request, group, template='livesettings/group_settings.html'):
# Determine what set of settings this editor is used for
use_db, overrides = get_overrides();
mgr = ConfigurationSettings()
if group is None:
settings = mgr
title = 'Site settings'
else:
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
if use_db:
# Create an editor customized for the current user
#editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
form = forms.SettingsEditor(data, settings=settings)
if form.is_valid():
form.full_clean()
for name, value in form.cleaned_data.items():
group, key = name.split('__')
cfg = mgr.get_config(group, key)
if cfg.update(value):
# Give user feedback as to which settings were changed
messages.add_message(request, messages.INFO, 'Updated %s on %s' % (cfg.key, cfg.group.key))
return HttpResponseRedirect(request.path)
else:
# Leave the form populated with current setting values
#form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
if django.VERSION < (1, 4):
ADMIN_MEDIA_PREFIX = djangosettings.ADMIN_MEDIA_PREFIX
else:
ADMIN_MEDIA_PREFIX = djangosettings.STATIC_URL + 'admin/'
return render_to_response(template, {
'title': title,
'group' : group,
'form': form,
'use_db' : use_db,
'ADMIN_MEDIA_PREFIX' : ADMIN_MEDIA_PREFIX,
'DJANGO_PRE_12' : _pre_12()
}, context_instance=RequestContext(request))
def group_settings(request, group, template='livesettings/group_settings.html'):
# Determine what set of settings this editor is used for
try:
message = request.session['message']
del request.session['message']
except:
message = None
use_db, overrides = get_overrides();
mgr = ConfigurationSettings()
if group is None:
settings = mgr
title = 'Site settings'
else:
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
if use_db:
# Create an editor customized for the current user
#editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
form = forms.SettingsEditor(data, settings=settings)
if form.is_valid():
form.full_clean()
for name, value in form.cleaned_data.items():
group, key = name.split('__')
cfg = mgr.get_config(group, key)
if cfg.update(value):
request.session['message'] = 'Contents Has Been Updated'
pass
# Give user feedback as to which settings were changed
#request.user.message_set.create(message='Updated %s on %s' % (cfg.key, cfg.group.key))
return HttpResponseRedirect(request.path)
else:
# Leave the form populated with current setting values
#form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
return render_to_response(template, {
'title': title,
'group' : group,
'form': form,
'use_db' : use_db,
'message':message,
}, context_instance=RequestContext(request))
def group_settings(request,
group,
template='livesettings/group_settings.html'):
# Determine what set of settings this editor is used for
use_db, overrides = get_overrides()
mgr = ConfigurationSettings()
if group is None:
settings = mgr
title = 'Site settings'
else:
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
if use_db:
# Create an editor customized for the current user
#editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
form = forms.SettingsEditor(data, settings=settings)
if form.is_valid():
form.full_clean()
for name, value in form.cleaned_data.items():
group, key = name.split('__')
cfg = mgr.get_config(group, key)
if cfg.update(value):
# Give user feedback as to which settings were changed
messages.add_message(
request, messages.INFO,
'Updated %s on %s' % (cfg.key, cfg.group.key))
return HttpResponseRedirect(request.path)
else:
# Leave the form populated with current setting values
#form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
return render_to_response(template, {
'title': title,
'group': group,
'form': form,
'use_db': use_db,
'DJANGO_PRE_12': _pre_12()
},
context_instance=RequestContext(request))
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
setting = None
use_db, overrides = get_overrides(siteid)
ck = cache_key('Setting', siteid, group, key)
if use_db:
try:
setting = cache_get(ck)
except NotCachedError as nce:
if hasattr(apps, 'ready'):
app_cache_ready = apps.ready
else:
app_cache_ready = apps.app_cache_ready()
if app_cache_ready:
try:
setting = Setting.objects.get(site__id__exact=siteid,
key__exact=key,
group__exact=group)
except Setting.DoesNotExist:
# maybe it is a "long setting"
try:
setting = LongSetting.objects.get(
site__id__exact=siteid,
key__exact=key,
group__exact=group)
except LongSetting.DoesNotExist:
pass
cache_set(ck, value=setting)
else:
grp = overrides.get(group, None)
if grp and key in grp:
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
log.debug('Returning overridden: %s', setting)
if not setting:
raise SettingNotSet(key, cachekey=ck)
return setting
def update(self, value, language_code=None):
use_db, overrides = get_overrides()
if use_db:
current_value = self.value
new_value = self.to_python(value)
if current_value != new_value:
if self.update_callback:
new_value = self.update_callback(current_value, new_value)
db_value = self.get_db_prep_save(new_value)
try:
settings_ = self.get_setting(language_code)
settings_.value = db_value
except SettingNotSet:
settings_ = self.make_setting(db_value, language_code=language_code)
if self.use_default and self.default == new_value:
if settings_.id:
logger.info("Deleted setting %s.%s", self.group.key, self.key)
settings_.delete()
else:
logger.info("Updated setting(id=%s) %s.%s = %s", settings_.id, self.group.key, self.key, value)
settings_.save()
if self.localized:
try:
unlocalized_setting = find_setting(self.group.key, self.key)
unlocalized_setting.delete()
except SettingNotSet:
pass
configuration_value_changed.send(
None, old_value=current_value, new_value=new_value, setting=self, language_code=language_code
)
if self.clear_cache:
cache.clear()
return True
else:
logger.debug("not updating setting %s.%s - livesettings db is disabled", self.group.key, self.key)
return False
def update(self, value, language_code=None):
use_db, overrides = get_overrides()
if use_db:
current_value = self.value
new_value = self.to_python(value)
if current_value != new_value:
if self.update_callback:
new_value = self.update_callback(current_value, new_value)
db_value = self.get_db_prep_save(new_value)
try:
settings_ = self.get_setting(language_code)
settings_.value = db_value
except SettingNotSet:
settings_ = self.make_setting(db_value, language_code=language_code)
if self.use_default and self.default == new_value:
if settings_.id:
logger.info("Deleted setting %s.%s", self.group.key, self.key)
settings_.delete()
else:
logger.info("Updated setting(id=%s) %s.%s = %s", settings_.id, self.group.key, self.key, value)
settings_.save()
if self.localized:
try:
unlocalized_setting = find_setting(self.group.key, self.key)
unlocalized_setting.delete()
except SettingNotSet:
pass
configuration_value_changed.send(None, old_value=current_value, new_value=new_value,
setting=self, language_code=language_code)
if self.clear_cache:
cache.clear()
return True
else:
logger.debug('not updating setting %s.%s - livesettings db is disabled', self.group.key, self.key)
return False
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
setting = None
use_db, overrides = get_overrides(siteid)
ck = cache_key('Setting', siteid, group, key)
if use_db:
try:
setting = cache_get(ck)
except NotCachedError as nce:
if hasattr(apps, 'ready'):
app_cache_ready = apps.ready
else:
app_cache_ready = apps.app_cache_ready()
if app_cache_ready:
try:
setting = Setting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except Setting.DoesNotExist:
# maybe it is a "long setting"
try:
setting = LongSetting.objects.get(site__id__exact=siteid, key__exact=key, group__exact=group)
except LongSetting.DoesNotExist:
pass
cache_set(ck, value=setting)
else:
grp = overrides.get(group, None)
if grp and key in grp:
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
log.debug('Returning overridden: %s', setting)
if not setting:
raise SettingNotSet(key, cachekey=ck)
return setting
def find_setting(group, key, site=None):
'Get a setting or longsetting by group and key, cache and return it.'
site_id = _safe_get_site_id(site)
setting = None
use_db, overrides = get_overrides(site_id)
ck = cache_key_get('Setting', site_id, group, key)
grp = overrides.get(group, None)
if grp and (key in grp):
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
logger.debug('Returning overridden: %s', setting)
elif use_db:
try:
setting = cache_get(ck)
except NotCachedError:
model_classes = (Setting, LongSetting)
for model_cls in model_classes:
try:
setting = model_cls.objects.get(site__id=site_id, key=key, group=group)
break
except model_cls.DoesNotExist:
pass
cache_set(ck, value=setting)
else:
grp = overrides.get(group, None)
if grp and key in grp:
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
logger.debug('Returning overridden: %s', setting)
if setting is None:
raise SettingNotSet(key, cachekey=ck)
return setting
def find_setting(group, key, site=None):
"Get a setting or longsetting by group and key, cache and return it."
site_id = _safe_get_site_id(site)
setting = None
use_db, overrides = get_overrides(site_id)
ck = cache_key_get("Setting", site_id, group, key)
grp = overrides.get(group, None)
if grp and (key in grp):
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
logger.debug("Returning overridden: %s", setting)
elif use_db:
try:
setting = cache_get(ck)
except NotCachedError:
model_classes = (Setting, LongSetting)
for model_cls in model_classes:
try:
setting = model_cls.objects.get(site__id=site_id, key=key, group=group)
break
except model_cls.DoesNotExist:
pass
cache_set(ck, value=setting)
else:
grp = overrides.get(group, None)
if grp and key in grp:
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
logger.debug("Returning overridden: %s", setting)
if setting is None:
raise SettingNotSet(key, cachekey=ck)
return setting
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
setting = None
backend = get_overrides(siteid)
ck = cache_key('Setting', siteid, group, key)
if backend.is_editable:
setting = backend.get_value(group, key)
else:
grp = overrides.get(group, None)
if grp and grp.has_key(key):
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
log.debug('Returning overridden: %s', setting)
if not setting:
raise SettingNotSet(key, cachekey=ck)
return setting
def find_setting(group, key, site=None):
"""Get a setting or longsetting by group and key, cache and return it."""
siteid = _safe_get_siteid(site)
setting = None
backend = get_overrides(siteid)
ck = cache_key('Setting', siteid, group, key)
if backend.is_editable:
setting = backend.get_value(group, key)
else:
grp = overrides.get(group, None)
if grp and grp.has_key(key):
val = grp[key]
setting = ImmutableSetting(key=key, group=group, value=val)
log.debug('Returning overridden: %s', setting)
if not setting:
raise SettingNotSet(key, cachekey=ck)
return setting
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
def group_settings(request, group, template='livesettings/group_settings.html'):
# Determine what set of settings this editor is used for
use_db, overrides = get_overrides();
mgr = ConfigurationSettings()
if group is None:
settings = mgr
title = 'Site settings'
else:
settings = mgr[group]
title = settings.name
log.debug('title: %s', title)
try:
setting_version = Setting.objects.latest('version').version
except Setting.DoesNotExist:
setting_version = 1
try:
long_setting_version = LongSetting.objects.latest('version').version
except LongSetting.DoesNotExist:
long_setting_version = 1
current_version = max(setting_version, long_setting_version)
if use_db:
# Create an editor customized for the current user
# editor = forms.customized_editor(settings)
if request.method == 'POST':
# Populate the form with user-submitted data
data = request.POST.copy()
version = int(data.pop('version')[0])
form = forms.SettingsEditor(data, settings=settings)
if version == current_version:
if form.is_valid():
form.full_clean()
with transaction.atomic():
for name, value in form.cleaned_data.items():
group, key = name.split('__')
cfg = mgr.get_config(group, key)
if cfg.update(value):
# Give user feedback as to which settings were changed
messages.add_message(request, messages.INFO, 'Updated %s on %s' % (cfg.key, cfg.group.key))
Setting.objects.update(version=current_version + 1)
LongSetting.objects.update(version=current_version + 1)
return HttpResponseRedirect(request.path)
else:
messages.add_message(
request, messages.ERROR,
'You are on incorrect version of settings. Please refresh the page before updating settings.'
)
current_version = version
else:
# Leave the form populated with current setting values
# form = editor()
form = forms.SettingsEditor(settings=settings)
else:
form = None
context = {
'title': title,
'group' : group,
'form': form,
'use_db' : use_db,
'version': current_version,
}
return render(request, template, context=context)
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