Announcing django-moderation

• Opublikowano Marzec 11, 2010
• komentarze 11
• Tagi: django models moderation

django-moderation is reusable application for Django framework, that allows to moderate any model objects.

Code can be found at http://github.com/dominno/django-moderation

Possible use cases:

• User creates his profile, profile is not visible on site. It will be visible on site when moderator approves it.
• User changes his profile, old profile data is visible on site. New data will be visible on site when moderator approves it.

Features:

• configurable admin integration(data changed in admin can be visible on site when moderator approves it)
• moderation queue in admin
• html differences of changes between versions of objects
• configurable email notifications
• custom model form that allows to edit changed data of object
• 100% PEP8 correct code
• test coverage > 80%

Requirements

python >= 2.4

django >= 1.1

Installation

Download source code from http://github.com/dominno/django-moderation and run installation script:

$> python setup.py install

Configuration

1. Add to your INSTALLED_APPS in your settings.py:

   moderation

2. Run command manage.py syncdb

3. Register Models with moderation

   from django.db import models
   from moderation import moderation
   
   
   class YourModel(models.Model):
       pass
   
   moderation.register(YourModel)
   

4. Register admin class with your Model

   from django.contrib import admin
   from moderation.admin import ModerationAdmin
   
   
   class YourModelAdmin(ModerationAdmin):
       """Admin settings go here."""
   
   admin.site.register(YourModel, YourModelAdmin)
   

If you want to disable integration of moderation in admin, add admin_intergration_enabled = False to your admin class:

class YourModelAdmin(ModerationAdmin):
    admin_intergration_enabled = False

admin.site.register(YourModel, YourModelAdmin)

How django-moderation works

When you change existing object or create new one, it will not be publicly available until moderator approves it. It will be stored in ModeratedObject model.

your_model = YourModel(description='test')
your_model.save()

YourModel.objects.get(pk=your_model.pk)
Traceback (most recent call last):
DoesNotExist: YourModel matching query does not exist.

When you will approve object, then it will be publicly available.

your_model.moderated_object.approve(moderatated_by=user,
                                   reason='Reason for approve')

YourModel.objects.get(pk=1)
<YourModel: YourModel object>

You can access changed object by calling changed_object on moderated_object:

your_model.moderated_object.changed_object
<YourModel: YourModel object>

This is deserialized version of object that was changed.

Now when you will change an object, old version of it will be available publicly, new version will be saved in moderated_object

your_model.description = 'New description'
your_model.save()

your_model = YourModel.objects.get(pk=1)
your_model.__dict__
{'id': 1, 'description': 'test'}

your_model.moderated_object.changed_object.__dict__
{'id': 1, 'description': 'New description'}

your_model.moderated_object.approve(moderatated_by=user,
                                   reason='Reason for approve')

your_model = YourModel.objects.get(pk=1)
your_model.__dict__
{'id': 1, 'description': 'New description'}

Email notifications

By default when user change object that is under moderation, e-mail notification is send to moderator. It will inform him that object was changed and need to be moderated.

When moderator approves or reject object changes then e-mail notification is send to user that changed this object. It will inform user if his changes were accepted or rejected and inform him why it was rejected or approved.

How to overwrite email notification templates

E-mail notifications use following templates:

• moderation/notification_subject_moderator.txt
• moderation/notification_message_moderator.txt
• moderation/notification_subject_user.txt
• moderation/notification_message_user.txt

Default context:

content_type - content type object of moderated object

moderated_object - ModeratedObject instance

site - current Site instance

How to pass extra context to email notification templates

If you want to pass extra context to email notification methods you new need to create new class that subclass BaseModerationNotification class.

class CustomModerationNotification(BaseModerationNotification):
    def inform_moderator(self,
                     subject_template='moderation/notification_subject_moderator.txt',
                     message_template='moderation/notification_message_moderator.txt',
                     extra_context=None):
        '''Send notification to moderator'''
        extra_context={'test':'test'}
        super(CustomModerationNotification, self).inform_moderator(subject_template,
                                                                   message_template,
                                                                   extra_context)

    def inform_user(self, user,
                    subject_template='moderation/notification_subject_user.txt',
                    message_template='moderation/notification_message_user.txt',
                    extra_context=None)
        '''Send notification to user when object is approved or rejected'''
        extra_context={'test':'test'}
        super(CustomModerationNotification, self).inform_user(user,
                                                              subject_template,
                                                              message_template,
                                                              extra_context)

Next register it with moderation as notification_class:

moderation.register(YourModel, notification_class=CustomModerationNotification)

Signals

moderation.signals.pre_moderation - signal send before object is approved or rejected

Arguments sent with this signal:

sender - The model class.

instance - Instance of model class that is moderated

status - Moderation status, 0 - rejected, 1 - approved

moderation.signals.post_moderation - signal send after object is approved or rejected

Arguments sent with this signal:

sender - The model class.

instance - Instance of model class that is moderated

status - Moderation status, 0 - rejected, 1 - approved

Forms

When creating ModelForms for models that are under moderation use BaseModeratedObjectForm class as ModelForm class. Thanks to that form will initialized with data from changed_object.

from moderation.forms import BaseModeratedObjectForm


class ModeratedObjectForm(BaseModeratedObjectForm):

    class Meta:
        model = MyModel

Any comments ? Feedback ? Feature requests ?

Automatyczne sprawdzanie zgodności kodu Pythona z PEP8

• Opublikowano Luty 15, 2010
• komentarze 4
• Tagi: pep8 python

Jakiś czas temu pisałem o skrypcie który sprawdza zgodność kodu Pythona z PEP8. Jednak podczas pracy nad kilkoma projektami zauważyłem, że nie chciało mi się za każdym razem ręcznie uruchamiać tego skryptu na całym projekcie. Sprowadzało się do tego że uruchamiałem go gdy projekt był już skończony. Prowadziło do tego że nie byłem w stanie czasowo wprowadzić wszystkich poprawek, bo było ich bardzo dużo.

Niby wydawało by się że wystarczy raz czy dwa przeczytać dokument PEP8 i przy pisaniu kodu stosować się do zaleceń, jednak potem gdy pisze się kod to się o wszystkim zapomina. Wydaje mi się że z pisaniem kodu jest jak z ładnym odręcznym pisaniem, to nawyk którego się nie da się nauczyć czytając jakieś poradniki. Tak samo jest ze stylem pisania kodu.

Skrypt do sprawdzania poprawności stylu kodu sprawdza się tutaj znakomicie, pozwala w szybki sposób na wyuczenie nawyku pisania kodu zgodnego z PEP8. Aby ułatwić sprawę, dodałem do testów danego projektu, przypadek testowy który uruchamia skrypt i sprawdza kod całego projektu. Jeżeli kod nie jest zgody z PEP8, to wyrzuca wyjątek i pokazuje dokładnie co trzeba poprawić.

from StringIO import StringIO

import sys

import unittest

import pep8


class PEP8TestCase(unittest.TestCase):

    def test_pep8_rules(self):  
        sys.argv[1:] = ['--filename=*.py', '--show-source', '--show-pep8', 
                               my_project.__path__[0]]  
        buf = StringIO()         
        sys.stdout = buf
        pep8._main()            
        sys.stdout = sys.__stdout__   
        result = buf.getvalue()

        self.assertEqual("", result,
                     "Code messages should be empty but was:\n" + result)

Wystarczy teraz na bieżąco podczas pisania kodu uruchamiać testy i mamy pewność że powstały kod jest zgodny z PEP8. Bardzo fajnie sprawdza się to także z pisaniem kodu wykorzystując Test Driven Development. Podczas pisania i uruchamiania testów od razu mamy sprawdzony cały powstały kod.

Po paru poprawkach pisanie kodu zgodnego z PEP8 wejdzie nam tak w krew że podczas pisania kodu od razu zacznie się pisać poprawny kod. Przydaje się tutaj włączenie w edytorze pokazywanie białych znaków aby od razu wykrywać miejsca gdzie znajdują się nadmiarowe białe znaki.

Zauważyłem także, że dbając o styl kodu, wykrywa się też miejsca które można zrefaktoryzować i uprościć.

Jak sprawdzać zgodność kodu Pythona z PEP8

• Opublikowano Lipiec 9, 2009
• komentarze 13
• Tagi: django narzędzia pep8 python

Znalazłem ostatnio bardzo fajne narzędzie do sprawdzania czy kod Pythona jest zgodny z zalecanym stylem pisania kodu w Pythonie(PEP8). Jest to skrypt uruchamiany z konsoli który sprawdza czy wskazany moduł jest zgodny z PEP8.

Przykład użycia:

$ pep8.py --filename=*.py --show-source --show-pep8 /sciezka/do/projektu/
parts/djangopl/sitemaps.py:14:5: E301 expected 1 blank line, found 0
def changefreq(self, obj):
^
Separate top-level function and class definitions with two blank lines.

Method definitions inside a class are separated by a single blank line.

Extra blank lines may be used (sparingly) to separate groups of related
functions.  Blank lines may be omitted between a bunch of related
one-liners (e.g. a set of dummy implementations).

Use blank lines in functions, sparingly, to indicate logical sections.
...

parametry:

• filename - wzorzec jakie pliki mają być brane pod uwagę
• show-source - przy każdym błędzie będzie wypisany kawałek kodu i wskazane w którym miejscu jest błąd
• show-pep8 - do każdego błędu będzie podane wyjaśnienie z dokumentu PEP8

Wynik działania prezentuje się bardzo ładnie i można szybko wychwycić gdzie jest błąd i zobaczyć dlaczego tak nie powinno się pisać kodu w Pythonie.

Znalazłem też opis jak zintegrować sprawdzanie zgodności z PEP8 z testami wykorzystywanymi w systemie typu continuous integration:

http://www.ajaxline.com/continuous-integration-in-django-project

Przydatne linki związane z PEP8:

• Dokument zalecanego stylu pisania kodu w Pythonie
• Ściąga z pep8 część 1
• Ściąga z pep8 część 2
• Ściąga z pep8 część 3