Esempio n. 1
0
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)
Esempio n. 2
0
    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)
Esempio n. 3
0
    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 - askbot.deps.livesettings db is disabled',self.group.key, self.key)

        return False
Esempio n. 4
0
    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)
Esempio n. 5
0
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)

    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)
    elif 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)
Esempio n. 6
0
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)

    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)
    elif 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)
Esempio n. 7
0
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()

    settings = mgr[group]
    if settings is None:
        raise Http404()
    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:
                        request.user.message_set.create(message=e.message)

                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,
            'form': form,
            'use_db': use_db
        })
Esempio n. 8
0
    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 = apply(self.update_callback,
                                      (current_value, new_value))

                db_value = self.get_db_prep_save(new_value)

                try:
                    s = self.get_setting(language_code)
                    s.value = db_value

                except SettingNotSet:
                    s = self.make_setting(db_value,
                                          language_code=language_code)

                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()

                if self.localized:
                    try:
                        unlocalized_setting = find_setting(
                            self.group.key, self.key)
                        unlocalized_setting.delete()
                    except SettingNotSet:
                        pass

                signals.configuration_value_changed.send(
                    self,
                    old_value=current_value,
                    new_value=new_value,
                    setting=self,
                    language_code=language_code)

                if self.clear_cache:
                    cache.clear()

                return True
        else:
            log.debug(
                'not updating setting %s.%s - askbot.deps.livesettings db is disabled',
                self.group.key, self.key)

        return False
Esempio n. 9
0
def spaces_settings(request, template='livesettings/space_settings.html'):
    use_db, overrides = get_overrides();
    print request.GET, request.POST
    mgr = ConfigurationSettings()
    settings = mgr['SPACE']

    if use_db:
        if request.method=='GET' and request.GET.get('Create_or_Edit_Space'):
            
            try :
                instance=Space.objects.get(pk=request.GET['Create_or_Edit_Space'])
                selectform=SelectForm(initial = {'Create_or_Edit_Space': instance.pk })
                thisform=SpaceForm(instance=instance)

            except KeyError:
                selectform=SelectForm(initial = {'Create_or_Edit_Space': 0 })
                thisform=SpaceForm()
        
        elif request.method=='POST':
            try:
#                request.GET['Create_or_Edit_Space']

                instance=Space.objects.get(pk=request.GET['Create_or_Edit_Space'])
                selectform=SelectForm(initial={'Create_or_Edit_Space': instance.pk })
                if request.POST['Delete']:
                    instance.delete()
                    instance=None
                    selectform=SelectForm(initial={'Create_or_Edit_Space': 0 })
                    thisform=SpaceForm(instance=instance)
                else:
                    selectform=SelectForm(initial={'Create_or_Edit_Space': instance.pk })
                    thisform=SpaceForm(request.POST,request.FILES,instance=instance)
            except :
                instance=None
                selectform=SelectForm(initial = {'Create_or_Edit_Space': 0 })
                thisform=SpaceForm(request.POST,request.FILES,instance=instance)
            
            

                
            if thisform.is_valid():
                thisform.save()
        else:
            thisform=SpaceForm()
            selectform=SelectForm()
                            
    else:
        form = None

    return render_to_response(template, {
                              'all_super_groups': mgr.get_super_groups(),
                              'group' : settings,
                              'select':selectform,
                              'form': thisform,
                              'use_db' : use_db
                              }, context_instance=RequestContext(request))
Esempio n. 10
0
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()

    settings = mgr[group]
    if settings is None:
        raise Http404()
    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:
                        request.user.message_set.create(message=e.message)

                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,
        'form': form,
        'use_db': use_db
    })
Esempio n. 11
0
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()

    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 = 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

                    if cfg.update(value):
                        # Give user feedback as to which settings were changed
                        message = 'Updated %s on %s' % (cfg.key, cfg.group.key)
                        request.user.message_set.create(message=message)

                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, {
        'all_super_groups': mgr.get_super_groups(),
        'title': title,
        'group': settings,
        'form': form,
        'use_db': use_db
    },
                              context_instance=RequestContext(request))
Esempio n. 12
0
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()

    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 = 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

                    if cfg.update(value):
                        # Give user feedback as to which settings were changed
                        message='Updated %s on %s' % (cfg.key, cfg.group.key)
                        request.user.message_set.create(message = message)

                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, {
        'all_super_groups': mgr.get_super_groups(),
        'title': title,
        'group' : settings,
        'form': form,
        'use_db' : use_db
    }, context_instance=RequestContext(request))
Esempio n. 13
0
    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, sns:

                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 grp.has_key(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", key, self.setting)
                raise (ae)
Esempio n. 14
0
    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 = apply(self.update_callback, (current_value, new_value))

                db_value = self.get_db_prep_save(new_value)

                try:
                    s = self.get_setting(language_code)
                    s.value = db_value

                except SettingNotSet:
                    s = self.make_setting(db_value, language_code=language_code)

                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()

                if self.localized:
                    try:
                        unlocalized_setting = find_setting(self.group.key, self.key)
                        unlocalized_setting.delete()
                    except SettingNotSet:
                        pass

                signals.configuration_value_changed.send(
                    self, old_value=current_value, new_value=new_value, setting=self, language_code=language_code
                )

                if self.clear_cache:
                    cache.clear()

                return True
        else:
            log.debug("not updating setting %s.%s - askbot.deps.livesettings db is disabled", self.group.key, self.key)

        return False
Esempio n. 15
0
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()

    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 = 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:
                        if cfg.update(value):
                            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, e:
                        messages.error(request, e.message)

                return HttpResponseRedirect(request.path)
        else:
            # Leave the form populated with current setting values
            #form = editor()
            form = forms.SettingsEditor(settings=settings)
Esempio n. 16
0
    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, sns:

                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 grp.has_key(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", key, self.setting)
                raise(ae)
Esempio n. 17
0
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()

    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 = 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:
                        if cfg.update(value):
                            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, e:
                        messages.error(request, e.message)

                return HttpResponseRedirect(request.path)
        else:
            # Leave the form populated with current setting values
            #form = editor()
            form = forms.SettingsEditor(settings=settings)
Esempio n. 18
0
    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 as sns:

                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 grp.has_key(key):
                            val = grp[self.key]
                else:
                    val = NOTSET

            except AttributeError as ae:
                log.error("Attribute error: %s", ae)
                log.error("%s: Could not get _value of %s", key, self.setting)
                raise (ae)

            except Exception as e:
                global _WARN
                log.error(e)
                if str(e).find("configuration_setting") > -1:
                    if not _WARN.has_key('configuration_setting'):
                        log.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:
                    import traceback
                    traceback.print_exc()
                    log.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
Esempio n. 19
0
    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 as sns:

                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 grp.has_key(key):
                            val = grp[self.key]
                else:
                    val = NOTSET

            except AttributeError as ae:
                log.error("Attribute error: %s", ae)
                log.error("%s: Could not get _value of %s", key, self.setting)
                raise(ae)

            except Exception as e:
                global _WARN
                log.error(e)
                if str(e).find("configuration_setting") > -1:
                    if not _WARN.has_key('configuration_setting'):
                        log.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:
                    import traceback
                    traceback.print_exc()
                    log.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