def test_index_view_staff(self):
     logged_in = self.client.login(username=self.staff['username'], password=self.staff['password'])
     self.assertTrue(logged_in)
     response = self.client.get('/')
     self.assertEqual(response.status_code, 200)
     self.assertTrue('dynamic_settings' in response.context)
     self.assertTrue('STATIC_URL' in response.context)
     self.assertTrue('settings_form_rendered' in response.context)
     #check against a couple random settings which should be present
     for setting_dict in response.context['dynamic_settings']:
         self.assertEqual(setting_dict['type'], type(dynamic_settings.__getattr__(setting_dict['key'])).__name__, msg=setting_dict['key'])
         self.assertEqual(setting_dict['in_db'], False, msg=setting_dict['key']) #should be False at this moment
         self.assertEqual(setting_dict['can_change'], dynamic_settings.can_change(setting_dict['key']), msg=setting_dict['key'])
     self.client.logout()
示例#2
0
def dynamicsettings_index(request):
    """Renders a template in the admin to show a list of settings. 
    
    Params:
        - ``request``: a django http request object
        
    Returns:
        - a rendered template with the following variables
          defined in its response dict
              - ``dynamic_settings``: a list of settings represented
              as dict's with:
                  -  ``key`` - the name of the setting
                  - ``value`` - the value of the setting
                  - ``is_db`` - a boolean indicating if the setting is saved in the db or not
                  - ``type`` - the (Python) type of the setting as its string representation
                  - ``can_change`` - a boolean indicating if the setting can be saved in the database or not
            - ``settings_form_rendered``: rendered html of ``forms.SettingsForm``
    """
    keys = [key for key in settings.dict()]
    keys.sort()
    res = []
    for key in keys:  
        value = settings.get(key)
        if isinstance(value, (list, tuple, dict)):
            try:
                value = simplejson.dumps(value, indent=4)
            except TypeError:
                value = 'Not a serializable object'
        res.append({
            'key': key,
            'value': value,
            'in_db': settings.is_in_db(key),
            'type': type(settings.get(key)).__name__,
            'can_change': settings.can_change(key),
        })
    res.sort(key=lambda e: e['can_change'], reverse=True)
    form_dict =  {'settings_form': forms.SettingsForm()}
    form_dict.update(csrf_processor(request))
    settings_form_rendered = template.loader.render_to_string('dynamicsettings/settings_form.html', form_dict)
    content_dict = {
        'dynamic_settings': res,
        'settings_form_rendered': settings_form_rendered,
    }
    return shortcuts.render_to_response('dynamicsettings/settings.html', content_dict,
                                        context_instance=template.RequestContext(request))
示例#3
0
 def clean(self):
     """
     a) Check if the setting was originally from the submitted type.
     Used to avoid abuse of the form by enabling disabled form 
     fields via firebug or similiar.
     b) Try to convert the value according to submitted type.
     Raises ValidiationError when type and value are not fitting
     each other (eg. value can;t be converted to type).
     c) check if the resulting value was actually changed  (and
     not yet in the database)
     """
     error_message_tmpl = 'A setting from type %s must be set to %s.'
     key = self.cleaned_data['key']
     value = self.cleaned_data['value']
     value_type = self.cleaned_data['type']
     if settings.can_change(key) is False:
         raise forms.ValidationError(_("This setting can not be changed."))
     #a)
     original_type = type(settings.__getattr__(key)).__name__
     if original_type!='NoneType' and value_type!=original_type:
         raise forms.ValidationError(_("You can not change the type of a setting which was not NoneType before."))
     #b)
     if value_type == 'NoneType':
         if value!='None':
             raise forms.ValidationError(_(error_message_tmpl % ('NoneType', '"None"')))
         self.cleaned_data['value'] = None
     elif value_type == 'bool':
         if value!='True' and value!='False':
             raise forms.ValidationError(_(error_message_tmpl % ('bool', '"True" or "False"')))
         if value!='True':
             self.cleaned_data['value'] = True
         elif value!='False':
             self.cleaned_data['value'] = False
     elif value_type == 'int':
         try:
             self.cleaned_data['value'] = int(value)
         except ValueError:
             raise forms.ValidationError(_(error_message_tmpl % ('int or long', 'a number')))
     elif value_type == 'int':
         try:
             self.cleaned_data['value'] = float(value)
         except ValueError:
             raise forms.ValidationError(_(error_message_tmpl % ('float', 'a number')))
     elif value_type == 'str':
         self.cleaned_data['value'] = value
     elif value_type == 'unicode':
         self.cleaned_data['value'] = unicode(value)
     elif value_type in ['tuple', 'list', 'dict']:
         try:
             self.cleaned_data['value'] = value = simplejson.loads(value)
         except ValueError:
             raise forms.ValidationError(_(error_message_tmpl % ('tuple, list or dict', 'a valid JSON string')))
         if value_type == 'tuple' and type(value).__name__!='tuple':
             try:
                 if type(value).__name__ == 'dict':
                     raise TypeError
                 self.cleaned_data['value'] = tuple(value)
             except (ValueError, TypeError):
                 raise forms.ValidationError(_(error_message_tmpl % ('tuple', 'a valid JSON string representing an Array (leading "["and traling "]")')))
         elif value_type == 'list' and type(value).__name__!='list':
             try:
                 if type(value).__name__ == 'dict':
                     raise TypeError
                 self.cleaned_data['value'] = list(value)
             except (ValueError, TypeError):
                 raise forms.ValidationError(_(error_message_tmpl % ('list', 'a valid JSON string representing an Array (leading "["and traling "]")')))
         elif value_type == 'dict' and type(value).__name__!='dict':
             try:
                 if type(value).__name__ == 'list':
                     raise TypeError
                 self.cleaned_data['value'] = dict(value)
             except (ValueError, TypeError):
                 raise forms.ValidationError(_(error_message_tmpl % ('dict', 'a valid JSON string representing an Object (leading "{"and traling "}")')))
     #c)
     value = self.cleaned_data['value']
     if not settings.is_in_db(key) and value==settings.__getattr__(key):
         raise forms.ValidationError(_('To save a setting in the database the value must have been changed from its original value.'))
     
     return self.cleaned_data