1

import datetime

     2

import urllib

     3

     4

from django import http, shortcuts, forms

     5

from django.conf import settings, urls

     6

from django.contrib import admin

     7

from django.core.urlresolvers import reverse

     8

from django.utils import timezone, formats

     9

import django.utils.html

    10

import django.forms.models

    11

    12

from qrurls.models import URL, URLItem, URLImage

    13

    14

"""

    15

    Private backend UI, using django-admin.

    16

"""

    17

    18

class URLItemFormset (django.forms.models.BaseInlineFormSet) :

    19

    """

    20

        Uses the existing URLItems for the URLFeed to determine the initial publishing

    21

        times for new items.

    22

    """

    23

    24

    def __init__ (self, *args, **kwargs) :

    25

        extra = kwargs.get('extra', 5)

    26

    27

        # hack to get at the URLFeed to determine our initial values..

    28

        urlfeed = kwargs.get('instance')

    29

        if not isinstance(urlfeed, URL) :

    30

            urlfeed = None

    31

    32

        # XXX: initial values must be stable across form GET/POST, or django will be confused and think the form has been filled out

    33

        kwargs.update(initial=[

    34

            # Either generic from today, or based on the actual urlfeed

    35

            dict(published=publish) for publish in URLAdmin.publishing_schedule(urlfeed, count=extra)

    36

        ])

    37

        super(URLItemFormset, self).__init__(*args, **kwargs)

    38

    39

class URLItemInline (admin.TabularInline) :

    40

    """

    41

        Inline set of URLItems for an URLFeed.

    42

    """

    43

    44

    model = URLItem

    45

    formset = URLItemFormset

    46

    47

class URLAdmin (admin.ModelAdmin) :

    48

    @classmethod

    49

    def publishing_schedule (cls, urlfeed, count):

    50

        """Yield URLItem.published values for feed, or defaults."""

    51

        if urlfeed :

    52

            date, time, offset = urlfeed.publishing_schedule()

    53

    54

            return URL.apply_publishing_schedule(date, time, offset, count)

    55

        else:

    56

            # no data... no defaults

    57

            return []

    58

    59

    def timezone (self, obj) :

    60

        now = timezone.localtime(obj.now())

    61

        tz = now.tzinfo

    62

        td = now.tzinfo.utcoffset(now)

    63

    64

        if td :

    65

            minutes, seconds = divmod(td.total_seconds(), 60)

    66

            hours, minutes = divmod(minutes, 60)

    67

            offset = "(UTC%+03d:%02d)" % (hours, minutes)

    68

        else :

    69

            offset = ""

    70

    71

        return u"%s %s" % (tz, offset)

    72

    73

    def qrcode_url (self, obj) :

    74

        warn = None

    75

    76

        if obj.shorturl.upper() != obj.shorturl :

    77

            warn = "Shorturl should be UPPERCASE for most compact QR code"

    78

    79

        return '<a href="{url}">{url}</a>{warn}'.format(

    80

                url     = django.utils.html.escape(obj.qrcode_url()),

    81

                warn    = '<p class="errornote">{warn}</p>'.format(warn=warn) if warn else '',

    82

        )

    83

    qrcode_url.allow_tags = True

    84

    85

    def qrcode_img (self, obj) :

    86

        return '<img src="{img}" />'.format(

    87

                img=django.utils.html.escape(obj.qrcode_img()),

    88

        )

    89

    qrcode_img.allow_tags = True

    90

    91

    # XXX: a whole bunch of ugly datetime-formatting for display...

    92

    def active (self, obj) :

    93

        item = obj.active_item()

    94

        if item :

    95

            return "%s %s" % (formats.localize(timezone.localtime(item.published)), item)

    96

        else :

    97

            return ""

    98

    99

    def now (self, obj) :

   100

        return formats.localize(timezone.localtime(obj.now()))

   101

   102

    def upcoming (self, obj) :

   103

        item = obj.upcoming_item()

   104

        if item :

   105

            return "%s %s" % (formats.localize(timezone.localtime(item.published)), item)

   106

        else :

   107

            return ""

   108

   109

    readonly_fields = (

   110

        'timezone',

   111

        'qrcode_url',

   112

        'qrcode_img',

   113

        'active_item',

   114

        'upcoming_item',

   115

        'active',

   116

        'now',

   117

        'upcoming',

   118

    )

   119

    list_display = (

   120

        'get_absolute_url',

   121

        'active_item',

   122

        'upcoming_item',

   123

    )

   124

    fieldsets = (

   125

        (None, {

   126

            'fields': (

   127

                'shorturl',

   128

                'publishing_days',

   129

                'publishing_time', 

   130

                'timezone',

   131

                'title',

   132

            ),

   133

        }),

   134

        ("QRCode", {

   135

            'fields': ('qrcode_url', 'qrcode_img'),

   136

        }),

   137

        ("Item publishing overview", {

   138

            'fields': (

   139

                'active',

   140

                'now',

   141

                'upcoming',

   142

            ),

   143

        }),

   144

    )

   145

    inlines = (URLItemInline, )

   146

   147

    ## Import

   148

    class ImportForm (forms.Form) :

   149

        shorturl = forms.ModelChoiceField(URL.objects)

   150

        publishing_date = forms.DateField(widget=admin.widgets.AdminDateWidget)

   151

        publishing_time = forms.TimeField(widget=admin.widgets.AdminTimeWidget)

   152

        # Django forms doesn't really understand multi-value fields, so we just hack this ourselves.

   153

        #image = forms.ImageField()

   154

   155

    def import_images_handler (self, url_feed, data, images=()) :

   156

        """Custom for backend for mass-importing images into a feed."""

   157

   158

        # series of datetimes

   159

        publishing = url_feed.apply_publishing_schedule(

   160

            data['publishing_date'], data['publishing_time'], url_feed.publishing_offset, len(images))

   161

   162

        for image, publish in zip(images, publishing) :

   163

            url_image = URLImage(image=image)

   164

            url_image.save()

   165

   166

            url_item = URLItem(shorturl=url_feed, published=publish, image=url_image)

   167

            url_item.save()

   168

   169

        return http.HttpResponseRedirect(reverse('admin:qrurls_url_change', args=(url_feed.id, )))

   170

   171

    def import_images (self, request, shorturl_id) :

   172

        """Custom form frontend for mass-importing images into a feed."""

   173

        url_feed = URL.objects.get(id=int(shorturl_id))

   174

   175

        if request.method == 'POST' :

   176

            form = self.ImportForm(request.POST)

   177

            images = request.FILES.getlist('image')

   178

   179

            if form.is_valid() :

   180

                return self.import_images_handler(url_feed, form.cleaned_data, images)

   181

        else :

   182

            publishing_date, publishing_time, publishing_offset = url_feed.publishing_schedule()

   183

   184

            form = self.ImportForm(initial=dict(

   185

                shorturl        = url_feed.id,

   186

                publishing_date = publishing_date,

   187

                publishing_time = publishing_time,

   188

            ))

   189

   190

        return shortcuts.render(request, 'admin/qrurls_import_images.html', dict(

   191

            current_app     = self.admin_site.name,

   192

   193

            media           = self.media + form.media,

   194

            form_url        = reverse('admin:qrurls_import_images', kwargs=dict(shorturl_id=url_feed.id)),

   195

            form            = form,

   196

        ))

   197

   198

    def get_urls (self) :

   199

        return urls.patterns('',

   200

            urls.url(r'^(?P<shorturl_id>\d+)/import$', self.admin_site.admin_view(self.import_images),

   201

                name='qrurls_import_images'),

   202

        ) + super(URLAdmin, self).get_urls()

   203

   204

    def import_images_action (self, request, queryset) :

   205

        url_feed, = [url_feed for url_feed in queryset]

   206

        return http.HttpResponseRedirect(

   207

                reverse('admin:qrurls_import_images', kwargs=dict(shorturl_id=url_feed.id)) # ) + '?' + urllib.urlencode(qs, doseq=True)

   208

        )

   209

    import_images_action.short_description = "Import images for selected feeds"

   210

   211

    actions = [import_images_action]

   212

   213

class URLItemAdmin (admin.ModelAdmin) :

   214

    list_display = (

   215

        'shorturl', 'published_state', 'get_absolute_url', 'image', 'published',

   216

    )

   217

    readonly_fields = ('published_state', )

   218

    fieldsets = (

   219

        ("Publishing", {

   220

            'fields': ('shorturl', 'published', ),

   221

        }),

   222

        ("Target", {

   223

            'fields': ('url', 'image'),

   224

        }),

   225

    )

   226

   227

class URLImageAdmin (admin.ModelAdmin) :

   228

    def show_image(self, obj):

   229

        return """<img src="{url}" style="max-width: 480px"/>""".format(url=obj.get_absolute_url())

   230

    show_image.short_description = "Image"

   231

    show_image.allow_tags = True

   232

   233

    list_display = (

   234

        'name',

   235

        'uploaded',

   236

    )

   237

    # hide the "uploaded" field

   238

    fields = (

   239

        'image',

   240

        'name',

   241

        'uploaded',

   242

        'title',

   243

        'show_image',

   244

    )

   245

    readonly_fields = (

   246

        'name',

   247

        'uploaded',

   248

        'show_image',

   249

    )

   250

   251

    inlines = (URLItemInline, )

   252

   253

admin.site.register(URL, URLAdmin)

   254

admin.site.register(URLItem, URLItemAdmin)

   255

admin.site.register(URLImage, URLImageAdmin)