work hard on this

aircox/admin/__init__.py

@@ -0,0 +1,5 @@
+from .base import *
+from .diffusion import DiffusionAdmin
+# from .playlist import PlaylistAdmin
+from .sound import SoundAdmin
+

aircox/admin/base.py

@@ -0,0 +1,94 @@
+from django import forms
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.translation import ugettext as _, ugettext_lazy
+from django.utils.safestring import mark_safe
+
+from adminsortable2.admin import SortableInlineAdminMixin
+
+from aircox.models import *
+
+
+class ScheduleInline(admin.TabularInline):
+    model = Schedule
+    extra = 1
+
+class StreamInline(admin.TabularInline):
+    fields = ['delay', 'begin', 'end']
+    model = Stream
+    extra = 1
+
+class NameableAdmin(admin.ModelAdmin):
+    fields = [ 'name' ]
+
+    list_display = ['id', 'name']
+    list_filter = []
+    search_fields = ['name',]
+
+
+@admin.register(Stream)
+class StreamAdmin(admin.ModelAdmin):
+    list_display = ('id', 'program', 'delay', 'begin', 'end')
+
+
+@admin.register(Program)
+class ProgramAdmin(NameableAdmin):
+    def schedule(self, obj):
+        return Schedule.objects.filter(program = obj).count() > 0
+    schedule.boolean = True
+    schedule.short_description = _("Schedule")
+
+    list_display = ('id', 'name', 'active', 'schedule', 'sync', 'station')
+    fields = NameableAdmin.fields + [ 'active', 'station','sync' ]
+    inlines = [ ScheduleInline, StreamInline ]
+
+
+@admin.register(Schedule)
+class ScheduleAdmin(admin.ModelAdmin):
+    def program_name(self, obj):
+        return obj.program.name
+    program_name.short_description = _('Program')
+
+    def day(self, obj):
+        return '' # obj.date.strftime('%A')
+    day.short_description = _('Day')
+
+    def rerun(self, obj):
+        return obj.initial is not None
+    rerun.short_description = _('Rerun')
+    rerun.boolean = True
+
+
+    list_filter = ['frequency', 'program']
+    list_display = ['id', 'program_name', 'frequency', 'day', 'date',
+                    'time', 'duration', 'timezone', 'rerun']
+    list_editable = ['time', 'timezone', 'duration']
+
+
+    def get_readonly_fields(self, request, obj=None):
+        if obj:
+            return ['program', 'date', 'frequency']
+        else:
+            return []
+
+# TODO: sort & redo
+class PortInline(admin.StackedInline):
+    model = Port
+    extra = 0
+
+
+@admin.register(Station)
+class StationAdmin(admin.ModelAdmin):
+    inlines = [PortInline]
+
+
+@admin.register(Log)
+class LogAdmin(admin.ModelAdmin):
+    list_display = ['id', 'date', 'station', 'source', 'type', 'comment', 'diffusion', 'sound', 'track']
+    list_filter = ['date', 'source', 'diffusion', 'sound', 'track']
+
+admin.site.register(Port)
+
+
+
+

aircox/admin/diffusion.py

@@ -0,0 +1,81 @@
+from django.contrib import admin
+from django.utils.translation import ugettext as _, ugettext_lazy
+
+from aircox.models import Diffusion, Sound, Track
+
+from .playlist import TracksInline
+
+
+class SoundInline(admin.TabularInline):
+    model = Sound
+    fk_name = 'diffusion'
+    fields = ['type', 'path', 'duration','public']
+    readonly_fields = ['type']
+    extra = 0
+
+
+class RediffusionInline(admin.StackedInline):
+    model = Diffusion
+    fk_name = 'initial'
+    extra = 0
+    fields = ['type', 'start', 'end']
+
+
+@admin.register(Diffusion)
+class DiffusionAdmin(admin.ModelAdmin):
+    def archives(self, obj):
+        sounds = [str(s) for s in obj.get_sounds(archive=True)]
+        return ', '.join(sounds) if sounds else ''
+
+    def conflicts_count(self, obj):
+        if obj.conflicts.count():
+            return obj.conflicts.count()
+        return ''
+    conflicts_count.short_description = _('Conflicts')
+
+    def start_date(self, obj):
+        return obj.local_date.strftime('%Y/%m/%d %H:%M')
+    start_date.short_description = _('start')
+
+    def end_date(self, obj):
+        return obj.local_end.strftime('%H:%M')
+    end_date.short_description = _('end')
+
+    def first(self, obj):
+        return obj.initial.start if obj.initial else ''
+
+    list_display = ('id', 'program', 'start_date', 'end_date', 'type', 'first', 'archives', 'conflicts_count')
+    list_filter = ('type', 'start', 'program')
+    list_editable = ('type',)
+    ordering = ('-start', 'id')
+
+    fields = ['type', 'start', 'end', 'initial', 'program', 'conflicts']
+    readonly_fields = ('conflicts',)
+    inlines = [TracksInline, RediffusionInline, SoundInline]
+
+    def get_playlist(self, request, obj=None):
+        return obj and getattr(obj, 'playlist', None)
+
+    def get_form(self, request, obj=None, **kwargs):
+        if request.user.has_perm('aircox_program.programming'):
+            self.readonly_fields = []
+        else:
+            self.readonly_fields = ['program', 'start', 'end']
+        return super().get_form(request, obj, **kwargs)
+
+    def get_object(self, *args, **kwargs):
+        """
+        We want rerun to redirect to the given object.
+        """
+        obj = super().get_object(*args, **kwargs)
+        if obj and obj.initial:
+            obj = obj.initial
+        return obj
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        if request.GET and len(request.GET):
+            return qs
+        return qs.exclude(type=Diffusion.Type.unconfirmed)
+
+

aircox/admin/mixins.py

@@ -0,0 +1,42 @@
+class UnrelatedInlineMixin:
+    """
+    Inline class that can be included in an admin change view whose model
+    is not directly related to inline's model.
+    """
+    view_model = None
+    parent_model = None
+    parent_fk = ''
+
+    def __init__(self, parent_model, admin_site):
+        self.view_model = parent_model
+        super().__init__(self.parent_model, admin_site)
+
+    def get_parent(self, view_obj):
+        """ Get formset's instance from `obj` of AdminSite's change form. """
+        field = self.parent_model._meta.get_field(self.parent_fk).remote_field
+        return getattr(view_obj, field.name, None)
+
+    def save_parent(self, parent, view_obj):
+        """ Save formset's instance. """
+        setattr(parent, self.parent_fk, view_obj)
+        parent.save()
+        return parent
+
+    def get_formset(self, request, obj):
+        ParentFormSet = super().get_formset(request, obj)
+        inline = self
+        class FormSet(ParentFormSet):
+            view_obj = None
+
+            def __init__(self, *args, instance=None, **kwargs):
+                self.view_obj = instance
+                instance = inline.get_parent(instance)
+                self.instance = instance
+                super().__init__(*args, instance=instance, **kwargs)
+
+            def save(self):
+                inline.save_parent(self.instance, self.view_obj)
+                return super().save()
+        return FormSet
+
+

aircox/admin/playlist.py

@@ -0,0 +1,41 @@
+from django.contrib import admin
+from django.utils.translation import ugettext as _, ugettext_lazy
+
+from adminsortable2.admin import SortableInlineAdminMixin
+
+from aircox.models import Track
+
+
+class TracksInline(SortableInlineAdminMixin, admin.TabularInline):
+    template = 'admin/aircox/playlist_inline.html'
+    model = Track
+    extra = 0
+    fields = ('position', 'artist', 'title', 'info', 'timestamp', 'tags')
+
+    list_display = ['artist', 'title', 'tags', 'related']
+    list_filter = ['artist', 'title', 'tags']
+
+
+@admin.register(Track)
+class TrackAdmin(admin.ModelAdmin):
+    # TODO: url to filter by tag
+    def tag_list(self, obj):
+        return u", ".join(o.name for o in obj.tags.all())
+
+    list_display = ['pk', 'artist', 'title', 'tag_list', 'diffusion', 'sound']
+    list_editable = ['artist', 'title']
+    list_filter = ['sound', 'diffusion', 'artist', 'title', 'tags']
+    fieldsets = [
+        (_('Playlist'), {'fields': ['diffusion', 'sound', 'position', 'timestamp']}),
+        (_('Info'), {'fields': ['artist', 'title', 'info', 'tags']}),
+    ]
+
+    # TODO on edit: readonly_fields = ['diffusion', 'sound']
+
+#@admin.register(Playlist)
+#class PlaylistAdmin(admin.ModelAdmin):
+#    fields = ['diffusion', 'sound']
+#    inlines = [TracksInline]
+#    # TODO: dynamic read only fields
+
+

aircox/admin/sound.py

@@ -0,0 +1,24 @@
+from django.contrib import admin
+from django.utils.translation import ugettext as _, ugettext_lazy
+
+from aircox.models import Sound
+from .base import NameableAdmin
+from .playlist import TracksInline
+
+
+@admin.register(Sound)
+class SoundAdmin(NameableAdmin):
+    fields = None
+    list_display = ['id', 'name', 'program', 'type', 'duration', 'mtime',
+                    'public', 'good_quality', 'path']
+    list_filter = ('program', 'type', 'good_quality', 'public')
+    fieldsets = [
+        (None, {'fields': NameableAdmin.fields +
+                          ['path', 'type', 'program', 'diffusion']}),
+        (None, {'fields': ['embed', 'duration', 'public', 'mtime']}),
+        (None, {'fields': ['good_quality']})
+    ]
+    readonly_fields = ('path', 'duration',)
+    inlines = [TracksInline]
+
+