1

import datetime

     2

import hashlib

     3

import os.path

     4

     5

from django.db import models

     6

import django.core.files.storage

     7

from django.core.urlresolvers import reverse

     8

import django.utils.http

     9

from django.contrib.sites.models import get_current_site

    10

from django.utils import timezone

    11

    12

QRCODE_API = 'https://chart.googleapis.com/chart?cht=qr&chs={width}x{height}&chl={url}&chld=H'

    13

IMAGES_MEDIA = 'qrurls-images'

    14

    15

class SecretFileSystemStorage (django.core.files.storage.FileSystemStorage) :

    16

    """

    17

        Store files named by a sha1 hash of their contents.

    18

    """

    19

    20

    HASH = hashlib.sha1

    21

    22

    def _hash (self, content) :

    23

        """Compute hash for given UploadedFile (as a hex string)."""

    24

        hash = self.HASH()

    25

    26

        for chunk in content.chunks() :

    27

            hash.update(chunk)

    28

    29

        return hash.hexdigest()

    30

    31

    def save (self, name, content) :

    32

        """Convert uploaded filename to a hash of the contents for storage."""

    33

        if name is None:

    34

            name = content.name

    35

    36

        dirname, filename = os.path.split(name)

    37

        basename, fileext = os.path.splitext(filename)

    38

    39

        # hash

    40

        name = "%s/%s%s" % (dirname, self._hash(content), fileext)

    41

    42

        return super(SecretFileSystemStorage, self).save(name, content)

    43

    44

class URL(models.Model):

    45

    shorturl = models.SlugField(unique=True,

    46

            help_text="Changing this will break existing QR-codes!")

    47

    publishing_time = models.TimeField(default=datetime.time(),

    48

            help_text="Default time to publish new URLItems (in timezone)")

    49

    publishing_days = models.IntegerField(default=1,

    50

            help_text="Default interval for publishing new URLItems")

    51

    title = models.CharField(max_length=1024, blank=True, null=True,

    52

            help_text="Text to display together with images.")

    53

    54

    class Meta:

    55

        verbose_name = u"URL Feed"

    56

        verbose_name_plural = u"URL Feeds"

    57

    58

    def qrcode_img (self, size=512) :

    59

        return QRCODE_API.format(

    60

                width=size, height=size,

    61

                url=django.utils.http.urlquote(self.qrcode_url()),

    62

        )

    63

    64

    def qrcode_url (self) :

    65

        return 'HTTP://{domain}{url}'.format(

    66

                domain = get_current_site(None).domain.upper(),

    67

                url = self.get_absolute_url(),

    68

        )

    69

    70

    def get_absolute_url (self) :

    71

        return reverse('shorturl', args=[self.shorturl])

    72

    73

    def now (self, now=None) :

    74

        """

    75

            Return database-compatible concept of "now".

    76

    77

            All datetimes are strictly stored and compared as UTC. Any

    78

            timezone-aware logic should happen in the admin.

    79

        """

    80

        if now :

    81

            return now

    82

        else :

    83

            return timezone.now()

    84

    85

    def active_item (self, now=None) :

    86

        """Currently published URLItem."""

    87

        now = self.now(now)

    88

    89

        try :

    90

            return self.urlitem_set.filter(published__lt=now).order_by('-published')[0]

    91

        except IndexError :

    92

            return None

    93

    94

    def upcoming_item (self, now=None) :

    95

        """Next-up to-be-published URLItem."""

    96

        now = self.now(now)

    97

    98

        try :

    99

            return self.urlitem_set.filter(published__gt=now).order_by('published')[0]

   100

        except IndexError :

   101

            return None

   102

   103

    def last_item (self) :

   104

        """The last URLItem available."""

   105

   106

        try :

   107

            return self.urlitem_set.order_by('-published')[0]

   108

        except IndexError :

   109

            return None

   110

   111

    @property

   112

    def publishing_timetz (self) :

   113

        """publishing_time, with tzinfo on the correct timezone."""

   114

        return self.publishing_time.replace(tzinfo=timezone.get_current_timezone())

   115

   116

    @property

   117

    def publishing_offset (self) :

   118

        return datetime.timedelta(days=self.publishing_days)

   119

   120

    def publishing_schedule (self) :

   121

        """Calculate initial URLItem.published values for feed."""

   122

   123

        # following the last item in the queue

   124

        item = self.last_item()

   125

   126

        if item and item.published > self.now():

   127

            # starting from the following day

   128

            date = item.published.date() + self.publishing_offset

   129

        else :

   130

            # defaults to today

   131

            date = self.now().date()

   132

   133

        return date, self.publishing_timetz, self.publishing_offset

   134

   135

    @classmethod

   136

    def apply_publishing_schedule (self, date, time, offset, count) :

   137

        """Yield publishing times off given date/time to offset * count."""

   138

        for index in xrange(0, count) :

   139

            yield datetime.datetime.combine(date + offset * index, time)

   140

   141

    def __unicode__ (self) :

   142

        return self.shorturl

   143

   144

class URLImage(models.Model):

   145

    image = models.ImageField(upload_to=IMAGES_MEDIA, storage=SecretFileSystemStorage())

   146

    name = models.CharField(max_length=512, blank=False)

   147

    title = models.CharField(max_length=1024, blank=True)

   148

    uploaded = models.DateTimeField(auto_now_add=True)

   149

   150

    class Meta:

   151

        verbose_name = u"URL Image"

   152

        verbose_name_plural = u"URL Images"

   153

        ordering = ['uploaded']

   154

   155

    def save (self) :

   156

        # keep real filename before saving with hash

   157

        # but not when updating!

   158

        if not self.name:

   159

            self.name = self.image.name

   160

   161

        super(URLImage, self).save()

   162

   163

    def get_absolute_url (self) :

   164

        return self.image.url

   165

   166

    def __unicode__ (self) :

   167

        return "[%s] %s" % (self.uploaded.strftime("%Y-%m-%d"), self.name)

   168

   169

class URLItem(models.Model):

   170

    shorturl = models.ForeignKey(URL)

   171

    published = models.DateTimeField(db_index=True) # UTC

   172

   173

    # either-or

   174

    url = models.URLField(blank=True) # populated from image

   175

    image = models.ForeignKey(URLImage, null=True, blank=True)

   176

   177

    class Meta:

   178

        verbose_name = u"URL Item"

   179

        verbose_name_plural = u"URL Items"

   180

        ordering = ['published']

   181

   182

    def get_absolute_url (self) :

   183

        if self.url :

   184

            return self.url

   185

        elif self.shorturl and self.id :

   186

            return reverse('shorturl_item', kwargs=dict(shorturl=self.shorturl, item_id=self.id))

   187

        else :

   188

            return None

   189

   190

    def published_age (self) :

   191

        now = self.shorturl.now() # UTC

   192

   193

        if now > self.published:

   194

            td = now - self.published

   195

        else :

   196

            td = self.published - now

   197

   198

        days, seconds = td.days, td.seconds

   199

        m, s = divmod(seconds, 60)

   200

        h, m = divmod(m, 60)

   201

   202

        return (self.published < now), days, "{h}h {m}m {s}s".format(h=h, m=m, s=s)

   203

   204

    def published_state (self) :

   205

        date = self.published.strftime("%Y-%m-%d")

   206

        published, days, age = self.published_age()

   207

   208

        if published and days :

   209

            return "[{date}]".format(date=date)

   210

        elif published :

   211

            return "[{age}]".format(age=age)

   212

        elif days :

   213

            return "({when})".format(when=date)

   214

        else :

   215

            return "({age})".format(age=age)

   216

   217

    def last_modified (self) :

   218

        # XXX: this asumes that URLImage is never changed after publishing..

   219

        return self.published

   220

   227

    def __unicode__ (self) :

   228

        return u"{published_state} {url}".format(

   229

                published_state=self.published_state(),

   230

                url=self.get_absolute_url(),

   231

        )

   232