new "callback" conflict management policy

Author: saxix

concurrency/admin.py

@@ -6,14 +6,14 @@
 from django.db.models import Q
 from django.forms.formsets import (ManagementForm, TOTAL_FORM_COUNT, INITIAL_FORM_COUNT,
                                    MAX_NUM_FORM_COUNT)
-from django.forms.models import BaseModelFormSet, modelform_factory
+from django.forms.models import BaseModelFormSet
 from django.utils.safestring import mark_safe
 from django.contrib.admin import helpers
 from django.http import HttpResponse, HttpResponseRedirect
 from django.utils.translation import ugettext as _
 from concurrency import forms
-from concurrency.api import get_revision_of_object, get_version_fieldname
-from concurrency.config import conf, CONCURRENCY_POLICY_SILENT
+from concurrency.api import get_revision_of_object
+from concurrency.config import conf, CONCURRENCY_LIST_EDITABLE_POLICY_SILENT
 from concurrency.exceptions import RecordModifiedError
 from concurrency.forms import ConcurrentForm, VersionWidget
 
@@ -148,7 +148,7 @@ def _management_form(self):
 
 
 class ConcurrencyListEditableMixin(object):
-    list_editable_policy = conf.POLICY
+    list_editable_policy = conf.POLICY & CONCURRENCY_LIST_EDITABLE_POLICY_SILENT
 
     def get_changelist_formset(self, request, **kwargs):
         kwargs['formset'] = ConcurrentBaseModelFormSet
@@ -162,7 +162,7 @@ def save_model(self, request, obj, form, change):
                     obj.version = int(version)
             super(ConcurrencyListEditableMixin, self).save_model(request, obj, form, change)
         except RecordModifiedError:
-            if self.list_editable_policy == CONCURRENCY_POLICY_SILENT:
+            if self.list_editable_policy == CONCURRENCY_LIST_EDITABLE_POLICY_SILENT:
                 messages.error(request, _("Record with pk `{0.pk}` has been modified and was not updated").format(obj))
             else:
                 raise
@@ -172,4 +172,4 @@ class ConcurrentModelAdmin(ConcurrencyActionMixin,
                            ConcurrencyListEditableMixin,
                            admin.ModelAdmin):
     form = ConcurrentForm
-    formfield_overrides = {forms.VersionField: {'widget': VersionWidget},}
+    formfield_overrides = {forms.VersionField: {'widget': VersionWidget}}

concurrency/config.py

@@ -1,17 +1,22 @@
 from __future__ import absolute_import, unicode_literals
-from six import string_types
 from django.core.exceptions import ImproperlyConfigured
+from django.core.urlresolvers import get_callable
+from django.utils import six
 from django.test.signals import setting_changed
-from concurrency.utils import import_by_path
 
 
 # List Editable Policy
 # 0 do not save updated records, save others, show message to the user
 # 1 abort whole transaction
 
-CONCURRENCY_POLICY_SILENT = 0
-CONCURRENCY_POLICY_ABORT_ALL = 1
-CONCURRENCY_POLICY_RAISE = 2
+CONCURRENCY_LIST_EDITABLE_POLICY_SILENT = 1
+CONCURRENCY_LIST_EDITABLE_POLICY_ABORT_ALL = 2
+CONCURRENCY_POLICY_RAISE = 4
+CONCURRENCY_POLICY_CALLBACK = 8
+
+CONFLICTS_POLICIES = [CONCURRENCY_POLICY_RAISE, CONCURRENCY_POLICY_CALLBACK]
+LIST_EDITABLE_POLICIES = [CONCURRENCY_LIST_EDITABLE_POLICY_SILENT, CONCURRENCY_LIST_EDITABLE_POLICY_ABORT_ALL]
+
 
 class AppSettings(object):
     """
@@ -43,7 +48,8 @@ class AppSettings(object):
     defaults = {
         'SANITY_CHECK': True,
         'FIELD_SIGNER': 'concurrency.forms.VersionFieldSigner',
-        'POLICY': CONCURRENCY_POLICY_SILENT,
+        'POLICY': CONCURRENCY_LIST_EDITABLE_POLICY_SILENT | CONCURRENCY_POLICY_RAISE,
+        'CALLBACK': 'concurrency.views.callback',
         'HANDLER409': 'concurrency.views.conflict'}
 
     def __init__(self, prefix):
@@ -63,8 +69,28 @@ def __init__(self, prefix):
 
         setting_changed.connect(self._handler)
 
+    def _check_config(self):
+        list_editable_policy = self.POLICY | sum(LIST_EDITABLE_POLICIES)
+        if list_editable_policy == sum(LIST_EDITABLE_POLICIES):
+            raise ImproperlyConfigured("Invalid value for `CONCURRENCY_POLICY`: "
+                                       "Use only one of `CONCURRENCY_LIST_EDITABLE_*` flags")
+
+        conflict_policy = self.POLICY | sum(CONFLICTS_POLICIES)
+        if conflict_policy == sum(CONFLICTS_POLICIES):
+            raise ImproperlyConfigured("Invalid value for `CONCURRENCY_POLICY`: "
+                                       "Use only one of `CONCURRENCY_POLICY_*` flags")
+
     def _set_attr(self, prefix_name, value):
         name = prefix_name[len(self.prefix) + 1:]
+        if name == 'CALLBACK':
+            if isinstance(value, six.string_types):
+                func = get_callable(value)
+            elif callable(value):
+                func = value
+            else:
+                raise ImproperlyConfigured("`CALLBACK` must be a callable or a fullpath to callable")
+            self._callback = func
+
         setattr(self, name, value)
 
     def _handler(self, sender, setting, value, **kwargs):
@@ -76,19 +102,5 @@ def _handler(self, sender, setting, value, **kwargs):
         if setting.startswith(self.prefix):
             self._set_attr(setting, value)
 
-    def _import_by_path(self, attrname, value):
-        processed = None
-        if isinstance(value, (list, tuple)):
-            processed = []
-            for entry in value:
-                processed.append(import_by_path(entry))
-        elif isinstance(value, string_types):
-            processed = import_by_path(value)
-
-        if processed is not None:
-            setattr(self, attrname, processed)
-        else:
-            raise ImproperlyConfigured('Cannot import by path `%s`' % value)
-
 
 conf = AppSettings('CONCURRENCY')

concurrency/core.py

@@ -3,7 +3,7 @@
 from functools import update_wrapper
 from django.db import connections, router
 from django.utils.translation import ugettext as _
-from concurrency.config import conf
+from concurrency.config import conf, CONCURRENCY_POLICY_CALLBACK
 from concurrency.exceptions import RecordModifiedError, InconsistencyError
 
 # Set default logging handler to avoid "No handler found" warnings.
@@ -33,8 +33,11 @@ def _select_lock(model_instance, version_value=None):
         if not entry:
             logger.debug("Conflict detected on `{0}` pk:`{0.pk}`, "
                          "version `{1}` not found".format(model_instance, value))
-            raise RecordModifiedError(_('Record has been modified or no version value passed'),
-                                      target=model_instance)
+            if conf.POLICY & CONCURRENCY_POLICY_CALLBACK:
+                conf._callback(model_instance)
+            else:
+                raise RecordModifiedError(_('Record has been modified or no version value passed'),
+                                          target=model_instance)
 
     elif is_versioned and conf.SANITY_CHECK and model_instance._revisionmetainfo.sanity_check:
         raise InconsistencyError(_('Version field is set (%s) but record has not `pk`.' % value))

concurrency/tests/__init__.py

@@ -3,6 +3,7 @@
 from concurrency.tests.middleware import ConcurrencyMiddlewareTest  # NOQA
 from concurrency.tests.conf import SettingsTest  # NOQA
 from concurrency.tests.api import ConcurrencyTestApi  # NOQA
+from concurrency.tests.policy import TestPolicy  # NOQA
 
 from concurrency.tests.admin_edit import TestAdminEdit, TestConcurrentModelAdmin  # NOQA
 from concurrency.tests.admin_list_editable import TestListEditable, TestListEditableWithNoActions  # NOQA

concurrency/tests/policy.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from mock import Mock
+from concurrency.config import CONCURRENCY_POLICY_CALLBACK, CONCURRENCY_POLICY_RAISE
+from concurrency.exceptions import RecordModifiedError
+from concurrency.tests.models import TestModel0
+from concurrency.tests.base import AdminTestCase
+
+
+class TestPolicy(AdminTestCase):
+
+    def test_policy_callback(self):
+        callback = Mock()
+
+        with self.settings(CONCURRENCY_POLICY=CONCURRENCY_POLICY_CALLBACK,
+                           CONCURRENCY_CALLBACK=callback):
+            obj1, __ = TestModel0.objects.get_or_create(username='123')
+            obj2 = TestModel0.objects.get(username='123')
+
+            obj2.save()
+            self.assertEqual(callback.call_count, 0)
+
+            obj1.save()
+            self.assertEqual(callback.call_count, 1)
+
+    def test_policy_raise(self):
+        with self.settings(CONCURRENCY_POLICY=CONCURRENCY_POLICY_RAISE):
+
+            obj1, __ = TestModel0.objects.get_or_create(username='123')
+            obj2 = TestModel0.objects.get(username='123')
+            obj2.save()
+            self.assertRaises(RecordModifiedError, obj1.save)

concurrency/views.py

@@ -11,6 +11,10 @@ class ConflictResponse(HttpResponse):
 handler409 = 'concurrency.views.conflict'
 
 
+def callback(target, *args, **kwargs):
+    pass
+
+
 def conflict(request, target=None, template_name='409.html'):
     """
     409 error handler.

demo/demoproject/demoapp/admin.py

@@ -1,13 +1,28 @@
 from concurrency.admin import ConcurrentModelAdmin
-try:
-    from import_export.admin import ImportExportMixin
-except:
-    class ImportExportMixin(object):
-        pass
+from demoproject.demoapp.models import DemoModel, proxy_factory
 
-class DemoModelAdmin(ImportExportMixin, ConcurrentModelAdmin):
+
+class DemoModelAdmin(ConcurrentModelAdmin):
     # list_display = [f.name for f in DemoModel._meta.fields]
     list_display = ('id', 'char', 'integer')
     list_display_links = ('id', )
     list_editable = ('char', 'integer')
     actions = None
+
+
+try:
+    from import_export.admin import ImportExportMixin
+
+    class ImportExportDemoModelAdmin(ImportExportMixin, ConcurrentModelAdmin):
+        # list_display = [f.name for f in DemoModel._meta.fields]
+        list_display = ('id', 'char', 'integer')
+        list_display_links = ('id', )
+        list_editable = ('char', 'integer')
+        actions = None
+
+except:
+    pass
+
+def register(site):
+    site.register(DemoModel, DemoModelAdmin)
+    site.register(proxy_factory("ImportExport"), ImportExportDemoModelAdmin)

demo/demoproject/demoapp/models.py

@@ -9,3 +9,14 @@ class DemoModel(models.Model):
 
     class Meta:
         app_label = 'demoapp'
+
+class ProxyDemoModel(DemoModel):
+
+    class Meta:
+        app_label = 'demoapp'
+        proxy = True
+
+def proxy_factory(name):
+    return type(name, (ProxyDemoModel,), {'__module__':ProxyDemoModel.__module__,
+    'Meta': type('Meta', (object,), {'proxy': True, 'app_label': 'demoapp'}, )
+    })

demo/demoproject/urls.py

@@ -1,23 +1,30 @@
 from django.conf.urls import patterns, include
 # from django.contrib.admin import ModelAdmin
-import django.contrib.admin.sites
+from django.contrib import admin
 from django.contrib import admin
 from django.contrib.auth.models import User, Group
-from demoproject.demoapp.admin import DemoModelAdmin
-from demoproject.demoapp.models import DemoModel
+import demoproject.demoapp.admin
+from demoproject.demoapp.admin import DemoModelAdmin, ImportExportDemoModelAdmin
+from demoproject.demoapp.models import DemoModel, proxy_factory
 
 admin.autodiscover()
 
 
-class PublicAdminSite(django.contrib.admin.sites.AdminSite):
+class PublicAdminSite(admin.AdminSite):
     def has_permission(self, request):
         request.user = User.objects.get_or_create(username='sax')[0]
         return True
 
 public_site = PublicAdminSite()
-django.contrib.admin.autodiscover()
+admin.autodiscover()
 public_site.register([User, Group])
+for e,v in admin.site._registry.items():
+    public_site._registry[e] = v
+
+# demoproject.demoapp.admin.site = public_site
+
 public_site.register(DemoModel, DemoModelAdmin)
+public_site.register(proxy_factory("ImportExport"), ImportExportDemoModelAdmin)
 
 urlpatterns = patterns('',
                        (r'^admin/', include(include(public_site.urls))),

docs/admin.rst

@@ -17,6 +17,8 @@ Handle ``list_editable``
 
 Extend your ModelAdmin with :ref:`ConcurrencyListEditableMixin` or use :ref:`ConcurrentModelAdmin`
 
+.. seealso:: :ref:`list_editable_policies`
+
 
 .. _admin_action: