' % (settings.MEDIA_URL, locked_until)
+ else:
+ return '
' % (settings.MEDIA_URL, locked_until)
+ else:
+ return ''
+ lock.allow_tags = True
+
+ list_display = ('lock', )
\ No newline at end of file
diff --git a/decorators.py b/decorators.py
new file mode 100644
index 0000000..24a4de7
--- /dev/null
+++ b/decorators.py
@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+from django.http import HttpResponse
+from django.contrib.contenttypes.models import ContentType
+
+from locking.models import LockableModel
+from locking import logging
+
+def user_may_change_model(fn):
+ def view(request, app, model, *vargs, **kwargs):
+ may_change = '%s.change_%s' % (app, model)
+ if not request.user.has_perm(may_change):
+ return HttpResponse(status=401)
+ else:
+ return fn(request, app, model, *vargs, **kwargs)
+
+ return view
+
+def is_lockable(fn):
+ def view(request, app, model, *vargs, **kwargs):
+ try:
+ cls = ContentType.objects.get(app_label=app, model=model).model_class()
+ if issubclass(cls, LockableModel):
+ lockable = True
+ except ContentType.DoesNotExist:
+ lockable = False
+
+ if lockable:
+ return fn(request, app, model, *vargs, **kwargs)
+ else:
+ return HttpResponse(status=404)
+ return view
+
+def log(view):
+ def decorated_view(*vargs, **kwargs):
+ response = view(*vargs, **kwargs)
+ logging.debug("Sending a request: \n\t%s" % (response.content))
+ return response
+
+ return decorated_view
\ No newline at end of file
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 0000000..6ea267d
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,89 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS =
+SPHINXBUILD = sphinx-build
+PAPER =
+BUILDDIR = _build
+
+# Internal variables.
+PAPEROPT_a4 = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: help clean html dirhtml pickle json htmlhelp qthelp latex changes linkcheck doctest
+
+help:
+ @echo "Please use \`make Dit artikel wordt momenteel door %(user)s aangepast. Je kan het lezen maar niet bewerken.
+ +Nog %s minuten gesloten voor %s \ No newline at end of file diff --git a/media/locking/css/locking.css b/media/locking/css/locking.css new file mode 100644 index 0000000..f0abc04 --- /dev/null +++ b/media/locking/css/locking.css @@ -0,0 +1,7 @@ +p.is_locked { + border: 2px solid #f00; + padding: 5px; + background: #fee; + display: inline-block; + font-weight: bold; +} \ No newline at end of file diff --git a/media/locking/img/lock.png b/media/locking/img/lock.png new file mode 100755 index 0000000..2ebc4f6 Binary files /dev/null and b/media/locking/img/lock.png differ diff --git a/media/locking/img/page_edit.png b/media/locking/img/page_edit.png new file mode 100755 index 0000000..046811e Binary files /dev/null and b/media/locking/img/page_edit.png differ diff --git a/media/locking/js/admin.locking.js b/media/locking/js/admin.locking.js new file mode 100644 index 0000000..e7d07f8 --- /dev/null +++ b/media/locking/js/admin.locking.js @@ -0,0 +1,48 @@ +/* +FUTURE REFACTOR: 1.2 makes it easy to make fields read-only with +the readonly_fields attribute on ModelAdmin. When 1.2 adoption is +more wide-spread, we could make a lot of this javascript superfluous +*/ + +var app = $.url.segment(1) +var model = $.url.segment(2) +var id = $.url.segment(3) +var base_url = locking.base_url + "/" + [app, model, id].join("/") + +function warning () { + var minutes = locking.timeout/60; + alert(interpolate(gettext("Your lock on this content will expire in a bit less than five minutes. Please save your content and navigate back to this edit page to close the content again for another %s minutes."), minutes)) +} + +function locking_mechanism () { + // locking is pointless when the user is adding a new piece of content + if (id == 'add') return + // we disable all input fields pre-emptively, and subsequently check if the content + // is or is not available for editing + $(":input").attr("disabled", "disabled") + $.getJSON(base_url + "/is_locked/", function(lock, status) { + if (lock.applies && status != '404') { + var notice = interpolate(gettext('This content is currently being edited by %(for_user)s. You can read it but not edit it.
'), lock, true) + $("#content-main").prepend(notice) + } else { + $(":input").removeAttr("disabled") + $.get(base_url + "/lock/") + $(window).unload(function(){ + // We have to assure that our unlock request actually gets + // through before the user leaves the page, so it shouldn't + // run asynchronously. + $.ajax({'url': base_url + "/unlock/", 'async': false}) + }) + } + }) + + // We give users a warning that their lock is about to expire, + // five minutes before it actually does. + setTimeout(1000*(locking.timeout-300), warning) +} + +$(document).ready(function(){ + if ($("body").hasClass("change-form")) { + locking_mechanism() + } +}) \ No newline at end of file diff --git a/media/locking/js/jquery.url.packed.js b/media/locking/js/jquery.url.packed.js new file mode 100644 index 0000000..14ae800 --- /dev/null +++ b/media/locking/js/jquery.url.packed.js @@ -0,0 +1 @@ +jQuery.url=function(){var segments={};var parsed={};var options={url:window.location,strictMode:false,key:["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],q:{name:"queryKey",parser:/(?:^|&)([^&=]*)=?([^&]*)/g},parser:{strict:/^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/,loose:/^(?:(?![^:@]+:[^:@\/]*@)([^:\/?#.]+):)?(?:\/\/)?((?:(([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?)(((\/(?:[^?#](?![^?#\/]*\.[^?#\/.]+(?:[?#]|$)))*\/?)?([^?#\/]*))(?:\?([^#]*))?(?:#(.*))?)/}};var parseUri=function(){str=decodeURI(options.url);var m=options.parser[options.strictMode?"strict":"loose"].exec(str);var uri={};var i=14;while(i--){uri[options.key[i]]=m[i]||""}uri[options.q.name]={};uri[options.key[12]].replace(options.q.parser,function($0,$1,$2){if($1){uri[options.q.name][$1]=$2}});return uri};var key=function(key){if(!parsed.length){setUp()}if(key=="base"){if(parsed.port!==null&&parsed.port!==""){return parsed.protocol+"://"+parsed.host+":"+parsed.port+"/"}else{return parsed.protocol+"://"+parsed.host+"/"}}return(parsed[key]==="")?null:parsed[key]};var param=function(item){if(!parsed.length){setUp()}return(parsed.queryKey[item]===null)?null:parsed.queryKey[item]};var setUp=function(){parsed=parseUri();getSegments()};var getSegments=function(){var p=parsed.path;segments=[];segments=parsed.path.length==1?{}:(p.charAt(p.length-1)=="/"?p.substring(1,p.length-1):path=p.substring(1)).split("/")};return{setMode:function(mode){strictMode=mode=="strict"?true:false;return this},setUrl:function(newUri){options.url=newUri===undefined?window.location:newUri;setUp();return this},segment:function(pos){if(!parsed.length){setUp()}if(pos===undefined){return segments.length}return(segments[pos]===""||segments[pos]===undefined)?null:segments[pos]},attr:key,param:param}}(); \ No newline at end of file diff --git a/models.py b/models.py new file mode 100644 index 0000000..4edc28f --- /dev/null +++ b/models.py @@ -0,0 +1,112 @@ +# encoding: utf-8 + +from datetime import datetime + +from django.db import models +from django.conf import settings +from django.contrib.auth import models as auth + +from locking import LOCK_TIMEOUT, logging + +class LockableModel(models.Model): + class Meta: + abstract = True + + # voorzieningen die concurrent editing onmogelijk maken + locked_at = models.DateTimeField(null=True, editable=False) + locked_by = models.ForeignKey(auth.User, related_name="working_on_%(class)s", null=True, editable=False) + + @property + def is_locked(self): + """ + docstring todo + """ + if isinstance(self.locked_at, datetime): + # artikels worden een half uur gesloten + if (datetime.today() - self.locked_at).seconds < LOCK_TIMEOUT: + return True + else: + return False + return False + + @property + def lock_seconds_remaining(self): + """ + docstring todo + """ + return LOCK_TIMEOUT - (datetime.today() - self.locked_at).seconds + + """ + test + """ + def lock_for(self, user=False, hard_lock=False): + """ + docstring todo + """ + logging.info("Attempting to initiate a lock for user `%s`" % user) + + # the save method unlocks the object, but of course + # it should keep things nicely locked when we're only + # saving to apply the lock! + self._initiate_lock = True + + # False om te openen, een geldige user om te sluiten + if isinstance(user, auth.User): + self.locked_at = datetime.today() + self.locked_by = user + logging.info("Initiated a lock for `%s` at %s" % (self.locked_by, self.locked_at)) + elif user is False: + logging.info("Freed lock on `%s`" % self) + # Eh, somewhat shoddy as far as exception handling goes. Should clean this up. + try: + self.locked_at = self.locked_by = None + except: + pass + + def unlock_for(self, user): + """ + docstring todo + """ + logging.info("Attempting to open up a lock on `%s` by user `%s`" % (self, user)) + + # refactor: should raise exceptions instead + if self.is_locked_by(user): + self.unlock() + return True + else: + return False + + def unlock(self): + """ + docstring todo + """ + # TO FIX: dit gaat niet werken, waar! + self.lock_for(False) + + def lock_applies_to(self, user): + """ + docstring todo + """ + logging.info("Checking if the lock on `%s` applies to user `%s`" % (self, user)) + # a lock does not apply to the person who initiated the lock + if self.is_locked and self.locked_by != user: + logging.info("Lock applies.") + return True + else: + logging.info("Lock does not apply.") + return False + + def is_locked_by(self, user): + """ + docstring todo + """ + return user == self.locked_by + + def save(self, *vargs, **kwargs): + # see _set_lock: we don't disengage the lock if the + # entire point of this save is to engage the lock + if getattr(self, '_initiate_lock', False) is False: + logging.info("Saving `%s` and disengaging any existing lock, if necessary." % self) + self.unlock() + + super(LockableModel, self).save(*vargs, **kwargs) \ No newline at end of file diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/admin.py b/tests/admin.py new file mode 100644 index 0000000..3e5ca3f --- /dev/null +++ b/tests/admin.py @@ -0,0 +1,11 @@ +# encoding: utf-8 + +from django.contrib import admin +from locking.tests import models +from locking.admin import LockableAdmin + +class StoryAdmin(LockableAdmin): + list_display = ('lock', 'content', ) + list_display_links = ('content', ) + +admin.site.register(models.Story, StoryAdmin) \ No newline at end of file diff --git a/tests/fixtures/locking_scenario.json b/tests/fixtures/locking_scenario.json new file mode 100644 index 0000000..93bb8f2 --- /dev/null +++ b/tests/fixtures/locking_scenario.json @@ -0,0 +1,163 @@ +[ + { + "pk": 5, + "model": "contenttypes.contenttype", + "fields": { + "model": "contenttype", + "name": "content type", + "app_label": "contenttypes" + } + }, + { + "pk": 2, + "model": "contenttypes.contenttype", + "fields": { + "model": "group", + "name": "group", + "app_label": "auth" + } + }, + { + "pk": 9, + "model": "contenttypes.contenttype", + "fields": { + "model": "logentry", + "name": "log entry", + "app_label": "admin" + } + }, + { + "pk": 4, + "model": "contenttypes.contenttype", + "fields": { + "model": "message", + "name": "message", + "app_label": "auth" + } + }, + { + "pk": 1, + "model": "contenttypes.contenttype", + "fields": { + "model": "permission", + "name": "permission", + "app_label": "auth" + } + }, + { + "pk": 6, + "model": "contenttypes.contenttype", + "fields": { + "model": "session", + "name": "session", + "app_label": "sessions" + } + }, + { + "pk": 7, + "model": "contenttypes.contenttype", + "fields": { + "model": "site", + "name": "site", + "app_label": "sites" + } + }, + { + "pk": 8, + "model": "contenttypes.contenttype", + "fields": { + "model": "story", + "name": "story", + "app_label": "tests" + } + }, + { + "pk": 3, + "model": "contenttypes.contenttype", + "fields": { + "model": "user", + "name": "user", + "app_label": "auth" + } + }, + { + "pk": 1, + "model": "sites.site", + "fields": { + "domain": "example.com", + "name": "example.com" + } + }, + { + "pk": 1, + "model": "tests.story", + "fields": { + "content": "This is a little story.", + "locked_at": "2010-05-28 11:10:05", + "locked_by": 2 + } + }, + { + "pk": 22, + "model": "auth.permission", + "fields": { + "codename": "add_story", + "name": "Can add story", + "content_type": 8 + } + }, + { + "pk": 23, + "model": "auth.permission", + "fields": { + "codename": "change_story", + "name": "Can change story", + "content_type": 8 + } + }, + { + "pk": 24, + "model": "auth.permission", + "fields": { + "codename": "delete_story", + "name": "Can delete story", + "content_type": 8 + } + }, + { + "pk": 1, + "model": "auth.user", + "fields": { + "username": "stdbrouw", + "first_name": "", + "last_name": "", + "is_active": true, + "is_superuser": true, + "is_staff": true, + "last_login": "2010-05-28 07:03:47", + "groups": [], + "user_permissions": [], + "password": "sha1$db580$7169260d47c8d33756c8ad6afedae4a8935b0d26", + "email": "stijn@typograaf.be", + "date_joined": "2010-05-28 04:54:28" + } + }, + { + "pk": 2, + "model": "auth.user", + "fields": { + "username": "blub", + "first_name": "", + "last_name": "", + "is_active": true, + "is_superuser": false, + "is_staff": false, + "last_login": "2010-05-28 10:22:49", + "groups": [], + "user_permissions": [], + "password": "", + "email": "", + "date_joined": "2010-05-28 10:22:49" + } + } +] \ No newline at end of file diff --git a/tests/models.py b/tests/models.py new file mode 100644 index 0000000..b905534 --- /dev/null +++ b/tests/models.py @@ -0,0 +1,14 @@ + +from django.db import models +from locking import models as locking + +class Story(locking.LockableModel): + content = models.TextField(blank=True) + + class Meta: + verbose_name_plural = 'stories' + +class Unlockable(models.Model): + # this model serves to test that utils.gather_lockable_models + # actually does what it's supposed to + content = models.TextField(blank=True) \ No newline at end of file diff --git a/tests/tests.py b/tests/tests.py new file mode 100644 index 0000000..7cdc546 --- /dev/null +++ b/tests/tests.py @@ -0,0 +1,168 @@ +import simplejson + +from django.core.urlresolvers import reverse +from django.test.client import Client +from django.contrib.auth.models import User + +from locking import models, views, LOCK_TIMEOUT +from locking.tests.utils import TestCase +from locking.tests.models import Story + + + +class AppTests(TestCase): + def setUp(self): + self.story = Story.objects.all()[0] + users = User.objects.all() + self.user = users[0] + self.alt_user = users[1] + + def tearDown(self): + pass + # flush & load fixtures opnieuw + + def test_decorator_user_may_change_model(self): + raise NotImplementedError + + def test_decorator_is_lockable(self): + raise NotImplementedError + + def test_lock_for(self): + self.story.lock_for(self.user) + self.assertTrue(self.story.is_locked) + self.story.save() + self.assertTrue(self.story.is_locked) + + def test_lock_for_overwrite(self): + # we shouldn't be able to overwrite a lock by another user + self.story.lock_for(self.alt_user) + self.story.lock_for(self.user) + self.assertTrue(self.locked_by, self.alt_user) + + def test_unlock_for_self(self): + self.story.lock_for(self.user) + unlocked = self.story.unlock_for(self.user) + # assertException? of met een catch zodat we de exception vangen? + self.assertTrue(unlocked) + + def test_unlock_for_disallowed(self): + self.story.lock_for(self.alt_user) + unlocked = self.story.unlock_for(self.user) + # assertException? of met een catch zodat we de exception vangen? + self.assertFalse(unlocked) + + def test_unlock(self): + raise NotImplementedError + + def test_lock_applies_to(self): + self.story.lock_for(self.alt_user) + applies = self.story.lock_applies_to(self.user) + self.assertTrue(applies) + + def test_lock_doesnt_apply_to(self): + self.story.lock_for(self.user) + applies = self.story.lock_applies_to(self.user) + self.assertFalse(applies) + + def test_is_locked_by(self): + self.story.lock_for(self.user) + self.assertEquals(self.story.locked_by, self.user) + + def test_is_unlocked(self): + self.assertFalse(self.story.is_locked) + + def test_unlock_upon_save(self): + self.story.lock_for(self.user) + self.story.save() + self.assertFalse(self.story.is_locked) + + def test_gather_lockable_models(self): + from locking import utils + from locking.tests import models + lockable_models = utils.gather_lockable_models() + self.assertTrue(models.Story in lockable_models) + self.assertTrue(models.Unlockable not in lockable_models) + +class BrowserTests(TestCase): + apps = ('locking.tests', 'django.contrib.auth', 'django.contrib.admin', ) + + def login(self): + self.c.post('/admin/login/', {}) + + def logout(self): + self.c.logout() + + def setUp(self): + self.c = Client() + self.c.post('/login/', {'name': 'fred', 'passwd': 'secret'}) + self.urls = { + "lock": reverse(views.lock), + "unlock": reverse(views.unlock), + "is_locked": reverse(views.is_locked), + "js_variables": reverse(views.js_variables), + } + + def tearDown(self): + pass + + def test_access_when_cannot_change_model(self): + raise NotImplementedError + + def test_lock_when_allowed(self): + + self.c.get(self.urls['js_variables']) + self.assertStatusCode(response) + + def test_lock_when_logged_out(self): + self.logout() + response = self.c.get(self.urls['lock']) + self.assertStatusCode(response, 401) + + def test_lock_when_disallowed(self): + self.assertStatusCode(response, 403) + + def test_unlock_when_allowed(self): + self.assertStatusCode(response, 200) + + def test_unlock_when_disallowed(self): + self.assertStatusCode(response, 403) + + def test_unlock_when_transpired(self): + self.assertStatusCode(response, 403) + + def test_is_locked_when_applies(self): + response = None + self.assertStatusCode(response, 200) + res = simplejson.loads(response) + self.assertTrue(res['applies']) + self.assertTrue(res['is_active']) + + def test_is_locked_when_self(self): + response = None + self.assertStatusCode(response, 200) + res = simplejson.loads(response) + self.assertFalse(res['applies']) + self.assertTrue(res['is_active']) + + def test_js_variables(self): + response = self.c.get(self.urls['js_variables']) + self.assertStatusCode(response, 200) + self.assertContains(response, LOCK_TIMEOUT) + + def test_admin_media(self): + res = self.get('todo') + self.assertContains(res, 'admin.locking.js') + + def test_admin_listedit_when_locked(self): + # testen dat de listedit een locking-icoontje & de andere + # boel weergeeft als een story op slot is + res = None + self.assertContains(res, 'locking/img/lock.png') + + def test_admin_listedit_when_locked_self(self): + res = None + self.assertContains(res, 'locking/img/page_edit.png') + + def test_admin_listedit_when_unlocked(self): + res = None + self.assertNotContains(res, 'locking/img') \ No newline at end of file diff --git a/tests/utils.py b/tests/utils.py new file mode 100644 index 0000000..118963d --- /dev/null +++ b/tests/utils.py @@ -0,0 +1,26 @@ +# encoding: utf-8 + +from django.conf import settings +from django.core.management import call_command +from django.db.models import loading +from django import test + +class TestCase(test.TestCase): + apps = () + + def _pre_setup(self): + # Add the models to the db. + self._original_installed_apps = list(settings.INSTALLED_APPS) + for app in self.apps: + settings.INSTALLED_APPS.append(app) + loading.cache.loaded = False + call_command('syncdb', interactive=False, verbosity=0) + # Call the original method that does the fixtures etc. + super(TestCase, self)._pre_setup() + + def _post_teardown(self): + # Call the original method. + super(TestCase, self)._post_teardown() + # Restore the settings. + settings.INSTALLED_APPS = self._original_installed_apps + loading.cache.loaded = False \ No newline at end of file diff --git a/urls.py b/urls.py new file mode 100644 index 0000000..f7388e8 --- /dev/null +++ b/urls.py @@ -0,0 +1,13 @@ +from django.conf.urls.defaults import * + +urlpatterns = patterns('locking.views', + # verwijst naar een ajax-view voor het lockingmechanisme + (r'(?P