mamweb/seminar/admin.py

# -*- coding: utf-8 -*-
from django.contrib import admin
from django import forms
from django.forms import widgets
import reversion
from solo.admin import SingletonModelAdmin
from ckeditor.widgets import CKEditorWidget
from django.db.models import Count
from django.db import models

from seminar.models import Skola, Resitel, Rocnik, Cislo, Problem, Reseni, PrilohaReseni, Nastaveni, Soustredeni, Soustredeni_Ucastnici
import autocomplete_light


### Globální nastavení

admin.site.register(Nastaveni, SingletonModelAdmin)


### UTILS (pro verbose_name a help_text)

def field_labels(model, fieldname):
    f = [i for i in model._meta.fields if i.name == fieldname][0]
    return {'label': f.verbose_name.capitalize(), 'help_text': f.help_text, }

def create_modeladmin(modeladmin, model, name = None, verbose_name = None, verbose_name_plural = None):
    
    class  Meta:
        proxy = True
        app_label = model._meta.app_label
    Meta.verbose_name = verbose_name
    Meta.verbose_name_plural = verbose_name_plural

    attrs = {'__module__': '', 'Meta': Meta}
    newmodel = type(name, (model,), attrs)
    admin.site.register(newmodel, modeladmin)
    return modeladmin

### INLINES

class ResitelInline(admin.TabularInline):
    model = Resitel
    fields = ['jmeno', 'prijmeni', 'skola', 'mesto', 'rok_maturity', ]
    readonly_fields = ['jmeno', 'prijmeni', 'skola', 'mesto', 'rok_maturity', ]
    extra = 0

    def has_add_permission(self, req): return False


class CisloInline(admin.TabularInline):
    model = Cislo
    fields = ['cislo', 'datum_vydani', 'datum_deadline', 'verejne_db', 'poznamka']
    readonly_fields = ['cislo']
    extra = 0
    formfield_overrides = {
        models.TextField: {'widget': forms.TextInput},
    }

    def has_add_permission(self, req): return False


class PrilohaReseniInline(admin.StackedInline):
    model = PrilohaReseni
    fields = ['timestamp', 'soubor', 'poznamka']
    readonly_fields = ['timestamp']
    formfield_overrides = {
        models.TextField: {'widget': forms.TextInput},
    }

    extra = 0

class ReseniKProblemuInline(admin.TabularInline):
    form = autocomplete_light.modelform_factory(Reseni, autocomplete_fields=['resitel'], fields=['resitel'])
    model = Reseni
    fields = ['resitel', 'forma', 'body', 'cislo_body', 'timestamp', 'poznamka']
    readonly_fields = ['timestamp']
    extra = 0
    formfield_overrides = {
        models.TextField: {'widget': forms.TextInput},
    }

    def get_queryset(self, request):
        qs = super(ReseniKProblemuInline, self).get_queryset(request)
        return qs.select_related('problem', 'cislo_body', 'resitel')

    # Potenciální DB HOG (cislo_body se dotazovalo na cisla pri kazdem zobrazeni jejich selectu ...)
    def formfield_for_dbfield(self, db_field, **kwargs):
        formfield = super(ReseniKProblemuInline, self).formfield_for_dbfield(db_field, **kwargs)
        if db_field.name == 'cislo_body':
            # dirty trick so queryset is evaluated and cached in .choices
            formfield.choices = formfield.choices
        return formfield


class ReseniKResiteliInline(admin.TabularInline):
    model = Reseni
    fields = ['problem', 'forma', 'body', 'cislo_body', 'timestamp', 'poznamka']
    readonly_fields = ['timestamp', 'problem']
    extra = 0
    formfield_overrides = {
        models.TextField: {'widget': forms.TextInput},
    }

    def has_add_permission(self, req): return False

    def get_queryset(self, request):
        qs = super(ReseniKResiteliInline, self).get_queryset(request)
        return qs.select_related('problem', 'cislo_body', 'resitel')

    # Potenciální DB HOG (cislo_body se dotazovalo na cisla pri kazdem zobrazeni jejich selectu ...)
    def formfield_for_dbfield(self, db_field, **kwargs):
        formfield = super(ReseniKResiteliInline, self).formfield_for_dbfield(db_field, **kwargs)
        if db_field.name == 'cislo_body':
            # dirty trick so queryset is evaluated and cached in .choices
            formfield.choices = formfield.choices
        return formfield


class Soustredeni_UcastniciInline(admin.TabularInline):
    form = autocomplete_light.modelform_factory(Soustredeni_Ucastnici, autocomplete_fields=['resitel'], fields=['resitel'])
    model = Soustredeni_Ucastnici
    fields = ['resitel', 'poznamka', ]
    extra = 0
    formfield_overrides = {
        models.TextField: {'widget': forms.TextInput},
    }

    def get_queryset(self, request):
        qs = super(Soustredeni_UcastniciInline, self).get_queryset(request)
        return qs.select_related('resitel', 'soustredeni')

### Resitel

class ResitelAdmin(reversion.VersionAdmin):
    form = autocomplete_light.modelform_factory(Resitel, autocomplete_fields=['skola'], fields=['skola'])
    fieldsets = [
        (None,              {'fields': ['jmeno', 'prijmeni', 'user']}),
        (u'Škola',          {'fields': ['skola', 'rok_maturity']}),
        (u'Seminář',        {'fields': ['datum_souhlasu_udaje', 'datum_souhlasu_zasilani', 'datum_prihlaseni', 'zasilat']}),
        (u'Osobní údaje',   {'fields': ['pohlavi_muz', 'datum_narozeni', 'email', 'telefon']}),
        (u'Adresa',         {'fields': ['ulice', 'mesto', 'psc', 'stat']}),
        ]
    list_display = ['jmeno', 'prijmeni', 'user', 'pohlavi_muz', 'skola', 'rok_maturity', 'pocet_reseni']
    list_filter = ['pohlavi_muz', 'rok_maturity', 'zasilat']
    search_fields = ['jmeno', 'prijmeni', 'ulice', 'user', 'mesto', 'email']
    inlines = [ReseniKResiteliInline]

    def get_queryset(self, request):
        qs = super(ResitelAdmin, self).get_queryset(request)
        return qs.select_related('skola', 'user').annotate(pocet_reseni=Count('reseni'))

    def pocet_reseni(self, obj):
        return obj.pocet_reseni


admin.site.register(Resitel, ResitelAdmin)


### Skola

class SkolaAdmin(reversion.VersionAdmin):
    fieldsets = [
        (None,              {'fields': ['nazev', 'kratky_nazev', 'je_zs', 'je_ss']}),
        (u'Interní ID',     {'fields': ['aesop_id', 'izo'], 'classes': ['collapse']}),
        (u'Adresa',         {'fields': ['ulice', 'mesto', 'psc', 'stat']}),
        (None,              {'fields': ['poznamka']}),
        ]
    list_display = ['nazev', 'aesop_id', 'mesto', 'ulice', 'stat', 'je_zs', 'je_ss']
    list_filter = ['stat', 'je_zs', 'je_ss']
    search_fields = ['nazev', 'mesto', 'ulice']
    inlines = [ResitelInline]

admin.site.register(Skola, SkolaAdmin)


### Cislo

class CisloAdmin(reversion.VersionAdmin):
    fieldsets = [
        (None,              {'fields': ['cislo', 'rocnik', 'verejne_db', 'poznamka']}),
        (u'Data',           {'fields': ['datum_vydani', 'datum_deadline']}),
        ]
    list_display = ['kod', 'rocnik', 'cislo', 'datum_vydani', 'datum_deadline', 'verejne']
    list_filter = ['rocnik']
    view_on_site = Cislo.verejne_url
    def get_queryset(self, request):
        qs = super(CisloAdmin, self).get_queryset(request)
        return qs.select_related('rocnik')

admin.site.register(Cislo, CisloAdmin)

### Rocnik

class RocnikAdmin(reversion.VersionAdmin):
    fieldsets = [
        (None,              {'fields': ['rocnik', 'prvni_rok']}),
        ]
    list_display = ['rocnik', 'prvni_rok', 'verejne']
    inlines = [CisloInline]
    view_on_site = Rocnik.verejne_url

admin.site.register(Rocnik, RocnikAdmin)


### PrilohaReseni
# NOTE: Nemá pravděpodobně smysl používat
# class PrilohaReseniAdmin(reversion.VersionAdmin):
#     readonly_fields = ['timestamp', 'reseni']
#     fieldsets = [
#         (None,              {'fields': ['reseni', 'soubor', 'timestamp']}),
#         (u'Poznámky',       {'fields': ['poznamka']}),
#         ]
#     list_display = ['reseni', 'soubor', 'timestamp']
#     list_filter = ['reseni', 'timestamp']
#     search_fields = []
# 
# admin.site.register(PrilohaReseni, PrilohaReseniAdmin)


### Reseni

class ReseniAdmin(reversion.VersionAdmin):
    form = autocomplete_light.modelform_factory(Reseni, autocomplete_fields=['problem', 'resitel'], fields=['problem', 'resitel'])
    fieldsets = [
        (None,              {'fields': ['problem', 'resitel', 'forma', 'body', 'cislo_body', 'timestamp']}),
        (u'Poznámky',       {'fields': ['poznamka']}),
        ]
    readonly_fields = ['timestamp']
    list_display = ['problem', 'resitel', 'forma', 'body', 'timestamp', 'cislo_body']
    list_filter = ['body', 'timestamp', 'forma']
    search_fields = []
    inlines = [PrilohaReseniInline]

    def get_queryset(self, request):
        qs = super(ReseniAdmin, self).get_queryset(request)
        return qs.select_related('resitel', 'problem', 'cislo_body')

admin.site.register(Reseni, ReseniAdmin)


### Problem

from autocomplete_light.contrib.taggit_field import TaggitField, TaggitWidget

#TODO: Autocomplete autor/opravovatel

class ProblemAdminForm(forms.ModelForm):
    text_zadani = forms.CharField(widget=CKEditorWidget(), required=False, **field_labels(Problem, 'text_zadani'))
    text_reseni = forms.CharField(widget=CKEditorWidget(), required=False, **field_labels(Problem, 'text_reseni'))
    text_org = forms.CharField(widget=CKEditorWidget(), required=False, **field_labels(Problem, 'text_org'))
    zamereni = TaggitField(widget=TaggitWidget('TagAutocomplete'), required=False)
    class Meta:
        model = Problem
        exclude = []

class ProblemAdmin(reversion.VersionAdmin):
    form = ProblemAdminForm
    fieldsets = [
        (None,              {'fields': ['nazev', 'typ', 'stav', 'autor', 'zamereni', 'body', 'timestamp', 'import_dakos_id']}),
        (u'Vydání',         {'fields': ['cislo_zadani', 'kod', 'cislo_reseni', 'opravovatel',]}),
        (None,              {'fields': ['text_zadani', 'text_reseni', 'text_org',]}),
        ]
    readonly_fields = ['timestamp', 'import_dakos_id']
    list_select_related = True
    search_fields = ['nazev', 'text_zadani', 'text_reseni', 'text_org']
    view_on_site = Problem.verejne_url

    def get_queryset(self, request):
        qs = super(ProblemAdmin, self).get_queryset(request)
        return qs.select_related('autor', 'opravovatel', 'cislo_zadani', 'cislo_reseni')

    def pocet_reseni(self, obj):
        return obj.pocet_reseni

class ProblemNavrhAdmin(ProblemAdmin):
    list_display = ['nazev', 'typ', 'stav', 'autor', 'timestamp']
    list_filter = ['typ', 'stav', 'timestamp']

    def get_queryset(self, request):
        qs = super(ProblemNavrhAdmin, self).get_queryset(request)
        return qs.filter(stav__in=[Problem.STAV_NAVRH, Problem.STAV_SMAZANY])

create_modeladmin(ProblemNavrhAdmin, Problem, 'ProblemNavrh', verbose_name=u'Problém (návrh)', verbose_name_plural=u'Problémy (návrhy)')

class ProblemZadanyAdmin(ProblemAdmin):
    list_display = ['nazev', 'typ', 'autor', 'opravovatel', 'kod', 'cislo_zadani', 'pocet_reseni', 'verejne']
    list_filter = ['typ', 'cislo_zadani__rocnik']
    inlines = [ReseniKProblemuInline]

    def get_queryset(self, request):
        qs = super(ProblemZadanyAdmin, self).get_queryset(request)
        return qs.filter(stav=Problem.STAV_ZADANY).annotate(pocet_reseni=Count('reseni'))

create_modeladmin(ProblemZadanyAdmin, Problem, 'ProblemZadany', verbose_name=u'Problém (zadaný)', verbose_name_plural=u'Problémy (zadané)')

#admin.site.register(Problem, ProblemAdmin)

### Soustredeni

class SoustredeniAdminForm(forms.ModelForm):
    text = forms.CharField(widget=CKEditorWidget(), required=False, **field_labels(Soustredeni, 'text'))
    class Meta:
        model = Soustredeni
        exclude = []

class SoustredeniAdmin(reversion.VersionAdmin):
    form = SoustredeniAdminForm
    fieldsets = [
        (None,              {'fields': ['rocnik', 'misto', 'verejne_db', 'text']}),
        (u'Data',           {'fields': ['datum_zacatku', 'datum_konce']}),
        ]
    list_display = ['rocnik', 'misto', 'datum_zacatku', 'verejne']
    inlines = [Soustredeni_UcastniciInline]
    list_filter = ['rocnik']
    view_on_site = Soustredeni.verejne_url

admin.site.register(Soustredeni, SoustredeniAdmin)