initial commit

Author: Aaron Madison

.gitignore

@@ -0,0 +1,8 @@
+.idea/*
+*.egg-info
+*.egg
+*.pyo
+*.pyc
+build/*
+dist/*
+example.db

LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2011, IMT Computer Services
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    1. Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in the
+       documentation and/or other materials provided with the distribution.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.txt

@@ -0,0 +1,44 @@
+
+Sometimes when you develop apps for other people, they like to
+define their own sets of "rules".
+
+For example, one customer might say the value of a certain field on
+a model might be valid when it is between 100 and 1000. Another customer
+might consider the same field valid only when the value is between
+500 and 1000.
+
+That kind of validation is extremely difficult to do in a modelform's
+clean method like you would if you knew beforehand what the valid values
+were supposed to be.
+
+This app lets you create some boundaries for various arbitrary parameters
+that are tied to some other arbitrary model. Each customer can then define
+what the rule parameters will be for their particular organization.
+
+
+Usage:
+First create a file called dynamic_actions.
+Inside dynamic actions, you must register your rule class
+with the dynamic_rules site.
+
+The rule class must have the following attributes:
+  key: a string to identify the rule class with the registry
+  display_name: a name to use for the admin_form to show a readable name
+  fields: a dictionary of field_names, and django form classes. This declares
+          the parameters available.
+
+Additionally, the rule class must accept a rule_model and model_to_check
+as initialization arguments, and have a run method that accepts
+*args and **kwargs.
+
+To see the dynamic rules in action, syncdb from this project and fire
+up the admin. Create a rule tied to group_object_id: 1 (i.e. customer 1)
+and content type: 'customer'
+
+Add a ModelToCheck model from the sample app that has a value that
+violates your rule. Check the runserver console and see that the
+violation printed.
+
+This is best used in conjunction with django-dynamic-validation which lets you
+track and store violations to the rules, or django-dynamic-manipulation
+which lets you manipulate other data because of a triggered rule.

dynamic_rules/__init__.py

@@ -0,0 +1,10 @@
+
+from dynamic_rules.sites import site
+
+__all__ = ('site',)
+
+VERSION = "0.1.0"
+
+def autodiscover():
+    from autoload import autodiscover as discover
+    discover("dynamic_actions")

dynamic_rules/admin.py

@@ -0,0 +1,12 @@
+
+from django.contrib import admin
+
+from djadmin_ext.helpers import  BaseAjaxModelAdmin
+
+from dynamic_rules import admin_forms, models
+
+class RuleAdmin(BaseAjaxModelAdmin):
+    form = admin_forms.RuleForm
+    list_display = ('name', 'group_object')
+
+admin.site.register(models.Rule, RuleAdmin)

dynamic_rules/admin_forms.py

@@ -0,0 +1,46 @@
+from django import forms
+
+from djadmin_ext.admin_forms import BaseAjaxModelForm
+
+from dynamic_rules import models, site
+
+__all__ = ('RuleForm',)
+
+class RuleForm(BaseAjaxModelForm):
+    ajax_change_field = 'key'
+
+    def __init__(self, *args, **kwargs):
+        super(RuleForm, self).__init__(*args, **kwargs)
+        rule_choices = [(k, v.display_name) for k, v in site.rules.items()]
+        self.fields['key'] = forms.ChoiceField(choices=[('', '---------')] + rule_choices)
+
+    @property
+    def dynamic_fields(self):
+        data = self.data or self.initial
+        if 'key' in data:
+            rule_class = site.get_rule_class(data['key'])
+            self.set_dynamic_field_initial(rule_class)
+            return rule_class.fields
+        return {}
+
+    def set_dynamic_field_initial(self, rule_class):
+        if self.instance.pk:
+            for field_name, field in rule_class.fields.items():
+                field.initial = self.instance.dynamic_fields[field_name]
+
+    def _get_dynamic_data_for_instance(self):
+        dynamic_data = {}
+        for field_name in self.dynamic_fields:
+            dynamic_data[field_name] = self.cleaned_data.get(field_name)
+        return dynamic_data
+
+    def save(self, commit=True):
+        obj = forms.ModelForm.save(self, False)
+        obj.dynamic_fields = self._get_dynamic_data_for_instance()
+        if commit:
+            obj.save()
+        return obj
+
+    class Meta(object):
+        model = models.Rule
+        fields = ('name', 'key', 'group_object_id', 'content_type')

dynamic_rules/models.py

@@ -0,0 +1,34 @@
+from django.db import models
+from django.contrib.contenttypes import generic
+from django.contrib.contenttypes.models import ContentType
+
+from django_fields import fields as helper_fields
+
+from dynamic_rules import site
+
+class RuleManager(models.Manager):
+
+    def get_by_group_object(self, obj):
+        content_type = ContentType.objects.get_for_model(obj)
+        return self.filter(content_type=content_type, group_object_id=obj.pk)
+
+    def get_by_key(self, group_object, key):
+        return self.get_by_group_object(group_object).filter(key=key)
+
+class Rule(models.Model):
+    content_type = models.ForeignKey('contenttypes.ContentType')
+    group_object_id = models.PositiveIntegerField(db_index=True)
+    group_object = generic.GenericForeignKey(fk_field='group_object_id')
+
+    name = models.CharField(max_length=100)
+    key = models.CharField(max_length=50)
+    dynamic_fields = helper_fields.PickleField()
+
+    objects = RuleManager()
+
+    def __unicode__(self):
+        return self.name
+
+    def run_action(self, validation_object, *args, **kwargs):
+        rule_class = site.get_rule_class(self.key)
+        rule_class(self, validation_object).run(*args, **kwargs)

dynamic_rules/sites.py

@@ -0,0 +1,38 @@
+
+__all__ = ('site',)
+
+class AlreadyRegistered(Exception):
+    pass
+
+class NotRegistered(Exception):
+    pass
+
+class Registry(object):
+
+    def __init__(self):
+        self._registry = {}
+        
+    def register(self, rule_class):
+        if rule_class.key in self._registry:
+            err_msg = "Rule key %s has already been registered as %s." % (rule_class.key, self._registry[rule_class.key])
+            raise AlreadyRegistered(err_msg)
+
+        self._registry[rule_class.key] = rule_class
+
+        return rule_class
+
+    def unregister(self, rule_class):
+        self._registry.pop(rule_class.key, None)
+
+    def get_rule_class(self, key):
+        if key not in self._registry:
+            raise NotRegistered("Rule key %s has not been registered." % key)
+        return self._registry[key]
+
+    @property
+    def rules(self):
+        return self._registry
+
+site = Registry()
+
+        

dynamic_rules/tests/__init__.py

@@ -0,0 +1,4 @@
+
+from dynamic_rules.tests.test_registry import *
+from dynamic_rules.tests.test_admin_forms import *
+from dynamic_rules.tests.test_models import *

dynamic_rules/tests/test_admin_forms.py

@@ -0,0 +1,127 @@
+
+import mock
+
+from django.utils import unittest
+from django import forms
+
+from djadmin_ext.admin_forms import BaseAjaxModelForm
+
+from dynamic_rules import admin_forms, models, site
+
+__all__ = ('AdminRuleFormTests', )
+
+class RuleOne(object):
+    fields = {
+        'field_one': forms.IntegerField(),
+    }
+    key = "rule_one"
+    display_name = "Rule One"
+
+class RuleTwo(object):
+    key = "rule_two"
+    display_name = "Rule Two"
+
+    fields = {
+        'field_two': forms.CharField(),
+        'field_three': forms.CharField(),
+    }
+
+class AdminRuleFormTests(unittest.TestCase):
+
+    def setUp(self):
+        self._original_registry = site._registry.copy()
+        site._registry = {}
+        site.register(RuleOne)
+        site.register(RuleTwo)
+
+    def tearDown(self):
+        site._registry = self._original_registry
+
+    def test_rule_form_is_a_subclass_of_base_ajax_model_form(self):
+        self.assertTrue(issubclass(admin_forms.RuleForm, BaseAjaxModelForm))
+
+    def test_sets_ajax_change_field_to_rule(self):
+        self.assertEqual('key', admin_forms.RuleForm.ajax_change_field)
+
+    def test_should_be_a_model_form_for_rule_model_and_limit_fields(self):
+        self.assertEqual(models.Rule, admin_forms.RuleForm._meta.model)
+        self.assertEqual(('name', 'key', 'group_object_id', 'content_type'), admin_forms.RuleForm._meta.fields)
+
+    def test_sets_rule_key_choices_to_registered_rules(self):
+        form = admin_forms.RuleForm()
+        self.assertItemsEqual([
+            ('', '---------'),
+            (RuleOne.key, RuleOne.display_name),
+            (RuleTwo.key, RuleTwo.display_name),
+        ], form.fields['key'].choices)
+
+    def test_return_empty_dict_when_no_rule_in_data_or_initial(self):
+        form = admin_forms.RuleForm()
+        self.assertEqual({}, form.dynamic_fields)
+
+    def test_returns_dict_of_rule_fields_from_dynamic_fields_property_when_rule_in_data(self):
+        form = admin_forms.RuleForm(data={'key':'rule_one'})
+        self.assertEqual(RuleOne.fields, form.dynamic_fields)
+
+    def test_returns_dict_of_rule_fields_from_dynamic_fields_property_when_rule_in_initial(self):
+        form = admin_forms.RuleForm(initial={'key':'rule_two'})
+        self.assertEqual(RuleTwo.fields, form.dynamic_fields)
+
+    def test_data_trumps_initial_when_getting_rule_class_in_dynamic_fields_property(self):
+        form = admin_forms.RuleForm(data={'key':'rule_one'}, initial={'key': 'rule_two'})
+        self.assertEqual(RuleOne.fields, form.dynamic_fields)
+
+    def test_sets_initial_data_on_form_field_to_matching_saved_instance_dynamic_fields_value(self):
+        expected_value = 'value_one'
+        instance = models.Rule(pk=1, key="rule_one", dynamic_fields={'field_one': expected_value})
+        form = admin_forms.RuleForm(instance=instance)
+        self.assertEqual(expected_value, form.fields['field_one'].initial)
+
+    def test_does_not_set_initial_data_on_form_fields_when_no_saved_instance(self):
+        instance = models.Rule(key="rule_one", dynamic_fields={'field_one': "value_one"})
+        form = admin_forms.RuleForm(instance=instance)
+        self.assertEqual(None, form.fields['field_one'].initial)
+
+    def test_sets_instance_dynamic_fields_to_dict_of_cleaned_data_dynamic_field_values(self):
+        dynamic_fields = {'field_two': "value_two", 'field_three': "value_three"}
+        form_data = dict(key="rule_two", name="my_rule", **dynamic_fields)
+
+        form = admin_forms.RuleForm(data=form_data)
+        form.cleaned_data = form_data
+
+        form_dynamic_data = form._get_dynamic_data_for_instance()
+        self.assertEqual(dynamic_fields, form_dynamic_data)
+
+    @mock.patch('dynamic_rules.admin_forms.RuleForm._get_dynamic_data_for_instance')
+    def test_sets_dynamic_fields_on_model_and_returns_model_in_save(self, _get_dynamic_data_for_instance):
+        form = admin_forms.RuleForm()
+        model_instance = mock.Mock(spec_set=models.Rule)
+
+        with mock.patch('django.forms.ModelForm.save') as modelform_save:
+            modelform_save.return_value = model_instance
+            saved_model = form.save(commit=False)
+
+        self.assertEqual(model_instance.dynamic_fields, _get_dynamic_data_for_instance.return_value)
+        self.assertEqual(model_instance, saved_model)
+
+    def test_calls_save_on_base_model_form_with_instance_and_commit_equals_false(self):
+        form = admin_forms.RuleForm()
+        model_instance = mock.Mock(spec_set=models.Rule)
+
+        with mock.patch('django.forms.ModelForm.save') as modelform_save:
+            modelform_save.return_value = model_instance
+            form.save(commit=False)
+
+        modelform_save.assert_called_once_with(form, False)
+        self.assertFalse(model_instance.save.called)
+
+    def test_saves_model_when_commit_is_true(self):
+        model_instance = mock.Mock(spec_set=models.Rule)
+        form = admin_forms.RuleForm()
+
+        with mock.patch('django.forms.ModelForm.save') as modelform_save:
+            modelform_save.return_value = model_instance
+            form.save()
+
+        modelform_save.assert_called_once_with(form, False)
+        model_instance.save.assert_called_once_with()