1

import datetime

     2

import random

     3

import urllib

     4

     5

from django import http, shortcuts, forms

     6

from django.conf import settings, urls

     7

from django.contrib import admin

     8

from django.core.urlresolvers import reverse

     9

from django.utils import timezone, formats

    10

import django.utils.html

    11

import django.forms.models

    12

    13

from qrurls.models import URL, URLItem, URLImage

    14

    15

"""

    16

    Private backend UI, using django-admin.

    17

"""

    18

    19

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

    20

    """

    21

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

    22

        times for new items.

    23

    """

    24

    25

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

    26

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

    27

    28

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

    29

        urlfeed = kwargs.get('instance')

    30

        if not isinstance(urlfeed, URL) :

    31

            urlfeed = None

    32

    33

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

    34

        kwargs.update(initial=[

    35

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

    36

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

    37

        ])

    38

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

    39

    40

class URLItemInline (admin.TabularInline) :

    41

    """

    42

        Inline set of URLItems for an URLFeed.

    43

    """

    44

    45

    model = URLItem

    46

    formset = URLItemFormset

    47

    48

class URLAdmin (admin.ModelAdmin) :

    49

    @classmethod

    50

    def publishing_schedule (cls, urlfeed, count):

    51

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

    52

        if urlfeed :

    53

            date, time, offset = urlfeed.publishing_schedule()

    54

    55

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

    56

        else:

    57

            # no data... no defaults

    58

            return []

    59

    60

    def timezone (self, obj) :

    61

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

    62

        tz = now.tzinfo

    63

        td = now.tzinfo.utcoffset(now)

    64

    65

        if td :

    66

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

    67

            hours, minutes = divmod(minutes, 60)

    68

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

    69

        else :

    70

            offset = ""

    71

    72

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

    73

    74

    def qrcode_url (self, obj) :

    75

        warn = None

    76

    77

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

    78

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

    79

    80

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

    81

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

    82

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

    83

        )

    84

    qrcode_url.allow_tags = True

    85

    86

    def qrcode_img (self, obj) :

    87

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

    88

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

    89

        )

    90

    qrcode_img.allow_tags = True

    91

    92

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

    93

    def active (self, obj) :

    94

        item = obj.active_item()

    95

        if item :

    96

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

    97

        else :

    98

            return ""

    99

   100

    def now (self, obj) :

   101

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

   102

   103

    def upcoming (self, obj) :

   104

        item = obj.upcoming_item()

   105

        if item :

   106

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

   107

        else :

   108

            return ""

   109

   110

    readonly_fields = (

   111

        'timezone',

   112

        'qrcode_url',

   113

        'qrcode_img',

   114

        'active_item',

   115

        'upcoming_item',

   116

        'active',

   117

        'now',

   118

        'upcoming',

   119

    )

   120

    list_display = (

   121

        'get_absolute_url',

   122

        'active_item',

   123

        'upcoming_item',

   124

    )

   125

    fieldsets = (

   126

        (None, {

   127

            'fields': (

   128

                'shorturl',

   129

                'publishing_days',

   130

                'publishing_time', 

   131

                'timezone',

   132

                'title',

   133

            ),

   134

        }),

   135

        ("QRCode", {

   136

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

   137

        }),

   138

        ("Item publishing overview", {

   139

            'fields': (

   140

                'active',

   141

                'now',

   142

                'upcoming',

   143

            ),

   144

        }),

   145

    )

   146

    inlines = (URLItemInline, )

   147

   148

    ## Import

   149

    class ImportForm (forms.Form) :

   150

        shorturl = forms.ModelChoiceField(URL.objects)

   151

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

   152

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

   153

   154

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

   155

        #image = forms.ImageField()

   156

   157

        # Existing URLImages

   161

   162

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

   163

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

   164

   165

        # series of datetimes

   166

        publishing = url_feed.apply_publishing_schedule(

   167

            data['publishing_date'], data['publishing_time'], url_feed.publishing_offset)

   168

   169

        url_images = list(data['url_images'])

   170

   171

        for image in images:

   172

            url_image = URLImage(image=image)

   173

            url_image.save()

   174

   175

            url_images.append(url_image)

   176

   177

        # randomize

   178

        random.shuffle(url_images)

   179

   180

        for url_image, publish in zip(url_images, publishing) :

   181

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

   182

            url_item.save()

   183

   184

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

   185

   186

    def import_images (self, request, shorturl_id) :

   187

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

   188

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

   189

   190

        if request.method == 'POST' :

   191

            form = self.ImportForm(request.POST)

   192

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

   193

   194

            if form.is_valid() :

   195

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

   196

        else :

   197

            publishing_date, publishing_time, publishing_offset = url_feed.publishing_schedule()

   198

   199

            form = self.ImportForm(initial=dict(

   200

                shorturl        = url_feed.id,

   201

                publishing_date = publishing_date,

   202

                publishing_time = publishing_time,

   203

            ))

   204

   205

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

   206

            current_app     = self.admin_site.name,

   207

   208

            media           = self.media + form.media,

   209

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

   210

            form            = form,

   211

        ))

   212

   213

    def get_urls (self) :

   214

        return urls.patterns('',

   215

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

   216

                name='qrurls_import_images'),

   217

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

   218

   219

    def import_images_action (self, request, queryset) :

   220

        url_feed, = [url_feed for url_feed in queryset]

   221

        return http.HttpResponseRedirect(

   222

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

   223

        )

   224

    import_images_action.short_description = "Import images for selected feeds"

   225

   226

    actions = [import_images_action]

   227

   228

class URLItemAdmin (admin.ModelAdmin) :

   229

    list_display = (

   230

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

   231

    )

   232

    readonly_fields = ('published_state', )

   233

    fieldsets = (

   234

        ("Publishing", {

   235

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

   236

        }),

   237

        ("Target", {

   238

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

   239

        }),

   240

    )

   241

   242

class URLImageAdmin (admin.ModelAdmin) :

   243

    def show_image(self, obj):

   244

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

   245

    show_image.short_description = "Image"

   246

    show_image.allow_tags = True

   247

   248

    list_display = (

   249

        'name',

   250

        'uploaded',

   251

    )

   252

    # hide the "uploaded" field

   253

    fields = (

   254

        'image',

   255

        'name',

   256

        'uploaded',

   257

        'title',

   258

        'show_image',

   259

    )

   260

    readonly_fields = (

   261

        'name',

   262

        'uploaded',

   263

        'show_image',

   264

    )

   265

   266

    inlines = (URLItemInline, )

   267

   268

admin.site.register(URL, URLAdmin)

   269

admin.site.register(URLItem, URLItemAdmin)

   270

admin.site.register(URLImage, URLImageAdmin)