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

    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

        urlfeed = kwargs.get('instance')

    26

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

    27

    28

        publishing_date, publishing_time = URLAdmin.publish_scheduling(urlfeed)

    29

    30

        kwargs.update(initial=[

    31

                dict(published=publish) for publish in URLAdmin.publishing_schedule(

    32

                    publishing_date, publishing_time, count=extra)

    33

        ])

    34

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

    35

    36

class URLItemInline (admin.TabularInline) :

    37

    """

    38

        Inline set of URLItems for an URLFeed.

    39

    """

    40

    41

    model = URLItem

    42

    formset = URLItemFormset

    43

    44

class URLAdmin (admin.ModelAdmin) :

    45

    @classmethod

    46

    def publish_scheduling (cls, urlfeed) :

    47

        """Calculate initial URLItem.published values for feed, or defaults."""

    48

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

    49

        if urlfeed and isinstance(urlfeed, URL) :

    50

            # starting from the following day

    51

            return (

    52

                    urlfeed.last_item().published.date() + datetime.timedelta(days=1),

    53

                    urlfeed.publishing_time,

    54

            )

    55

        else:

    56

            # no data...

    57

            return datetime.date.today(), datetime.time()

    58

    59

    @classmethod

    60

    def publishing_schedule (cls, publishing_date, publishing_time, count) :

    61

        """Yield URLItem.published values."""

    62

        for days in xrange(0, count) :

    63

            yield datetime.datetime.combine(

    64

                    publishing_date + datetime.timedelta(days=days),

    65

                    publishing_time

    66

            )

    67

    68

    def timezone (self, obj) :

    69

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

    70

        tz = now.tzinfo

    71

        td = now.tzinfo.utcoffset(now)

    72

    73

        if td :

    74

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

    75

            hours, minutes = divmod(minutes, 60)

    76

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

    77

        else :

    78

            offset = ""

    79

    80

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

    81

    82

    def qrcode_url (self, obj) :

    83

        warn = None

    84

    85

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

    86

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

    87

    88

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

    89

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

    90

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

    91

        )

    92

    qrcode_url.allow_tags = True

    93

    94

    def qrcode_img (self, obj) :

    95

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

    96

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

    97

        )

    98

    qrcode_img.allow_tags = True

    99

   100

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

   101

    def active (self, obj) :

   102

        item = obj.active_item()

   103

        if item :

   104

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

   105

        else :

   106

            return ""

   107

   108

    def now (self, obj) :

   109

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

   110

   111

    def upcoming (self, obj) :

   112

        item = obj.upcoming_item()

   113

        if item :

   114

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

   115

        else :

   116

            return ""

   117

   118

    readonly_fields = (

   119

        'timezone',

   120

        'qrcode_url',

   121

        'qrcode_img',

   122

        'active_item',

   123

        'upcoming_item',

   124

        'active',

   125

        'now',

   126

        'upcoming',

   127

    )

   128

    list_display = (

   129

        'get_absolute_url',

   130

        'active_item',

   131

        'upcoming_item',

   132

    )

   133

    fieldsets = (

   134

        (None, {

   135

            'fields': (

   136

                'shorturl', 

   137

                'publishing_time', 

   138

                'timezone',

   139

                'title',

   140

            ),

   141

        }),

   142

        ("QRCode", {

   143

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

   144

        }),

   145

        ("Item publishing overview", {

   146

            'fields': (

   147

                'active',

   148

                'now',

   149

                'upcoming',

   150

            ),

   151

        }),

   152

    )

   153

    inlines = (URLItemInline, )

   154

   155

    ## Import

   156

    class ImportForm (forms.Form) :

   157

        shorturl = forms.ModelChoiceField(URL.objects)

   158

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

   159

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

   160

        image = forms.ImageField()

   161

   162

    def import_images_handler (self, url_feed, data) :

   163

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

   164

   165

        images = [data['image']]

   166

        publishing = self.publishing_schedule(data['publishing_date'], data['publishing_time'], len(images))

   167

   168

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

   169

            # XXX: move title default elsewhere

   170

            url_image = URLImage(image=image, title=image.name)

   171

            url_image.save()

   172

   173

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

   174

            url_item.save()

   175

   176

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

   177

   178

    def import_images (self, request, shorturl_id) :

   179

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

   180

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

   181

   182

        if request.method == 'POST' :

   183

            form = self.ImportForm(request.POST, request.FILES)

   184

   185

            if form.is_valid() :

   186

                return self.import_images_handler(url_feed, form.cleaned_data)

   187

        else :

   188

            publishing_date, publishing_time = self.publish_scheduling(url_feed)

   189

   190

            form = self.ImportForm(initial=dict(

   191

                shorturl        = url_feed.id,

   192

                publishing_date = publishing_date,

   193

                publishing_time = publishing_time,

   194

            ))

   195

   196

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

   197

            current_app     = self.admin_site.name,

   198

   199

            media           = self.media + form.media,

   200

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

   201

            form            = form,

   202

        ))

   203

   204

    def get_urls (self) :

   205

        return urls.patterns('',

   206

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

   207

                name='qrurls_import_images'),

   208

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

   209

   210

    def import_images_action (self, request, queryset) :

   211

        url_feed, = [url_feed for url_feed in queryset]

   212

        return http.HttpResponseRedirect(

   213

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

   214

        )

   215

    import_images_action.short_description = "Import images for selected feeds"

   216

   217

    actions = [import_images_action]

   218

   219

class URLItemAdmin (admin.ModelAdmin) :

   220

    list_display = (

   221

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

   222

    )

   223

    readonly_fields = ('published_state', 'published')

   224

    fieldsets = (

   225

        ("Publishing", {

   226

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

   227

        }),

   228

        ("Target", {

   229

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

   230

        }),

   231

    )

   232

   233

class URLImageAdmin (admin.ModelAdmin) :

   234

    list_display = (

   235

        'title',

   236

        'uploaded',

   237

    )

   238

    # hide the "uploaded" field

   239

    fields = (

   240

        'image',

   241

        'title',

   242

    )

   243

    readonly_fields = (

   244

        'uploaded',

   245

    )

   246

   247

    inlines = (URLItemInline, )

   248

   249

admin.site.register(URL, URLAdmin)

   250

admin.site.register(URLItem, URLItemAdmin)

   251

admin.site.register(URLImage, URLImageAdmin)