1

import datetime

     2

import hashlib

     3

import logging

     4

import os.path

     5

     6

from django.db import models

     7

import django.core.files.storage

     8

from django.core.urlresolvers import reverse

     9

import django.utils.http

    10

from django.contrib.sites.models import get_current_site

    11

from django.utils import timezone

    12

    13

log = logging.getLogger('qrurls.models')

    14

    15

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

    16

IMAGES_MEDIA = 'qrurls-images'

    17

    18

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

    19

    """

    20

        Store files named by a sha1 hash of their contents.

    21

    """

    22

    23

    HASH = hashlib.sha1

    24

    25

    def _hash (self, content) :

    26

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

    27

        hash = self.HASH()

    28

    29

        for chunk in content.chunks() :

    30

            hash.update(chunk)

    31

    32

        return hash.hexdigest()

    33

    34

    def save (self, name, content) :

    35

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

    36

        if name is None:

    37

            name = content.name

    38

    39

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

    40

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

    41

    42

        # hash

    43

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

    44

    45

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

    46

    47

class URL(models.Model):

    48

    shorturl = models.SlugField(unique=True,

    49

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

    50

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

    51

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

    52

    publishing_days = models.IntegerField(default=1,

    53

            help_text="Default interval for publishing new URLItems")

    54

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

    55

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

    56

    57

    class Meta:

    58

        verbose_name = u"URL Feed"

    59

        verbose_name_plural = u"URL Feeds"

    60

    61

    def qrcode_img (self, size=512) :

    62

        return QRCODE_API.format(

    63

                width=size, height=size,

    64

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

    65

        )

    66

    67

    def qrcode_url (self) :

    68

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

    69

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

    70

                url = self.get_absolute_url(),

    71

        )

    72

    73

    def get_absolute_url (self) :

    74

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

    75

    76

    def now (self, now=None) :

    77

        """

    78

            Return database-compatible concept of "now".

    79

    80

            All datetimes are strictly stored and compared as UTC. Any

    81

            timezone-aware logic should happen in the admin.

    82

        """

    83

        if now :

    84

            return now

    85

        else :

    86

            return timezone.now()

    87

    88

    def active_item (self, now=None) :

    89

        """Currently published URLItem."""

    90

        now = self.now(now)

    91

    92

        try :

    93

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

    94

        except IndexError :

    95

            return None

    96

    97

    def upcoming_item (self, now=None) :

    98

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

    99

        now = self.now(now)

   100

   101

        try :

   102

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

   103

        except IndexError :

   104

            return None

   105

   106

    def last_item (self) :

   107

        """The last URLItem available."""

   108

   109

        try :

   110

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

   111

        except IndexError :

   112

            return None

   113

   114

    @property

   115

    def publishing_timetz (self) :

   116

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

   117

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

   118

   119

    @property

   120

    def publishing_offset (self) :

   121

        return datetime.timedelta(days=self.publishing_days)

   122

   123

    def publishing_schedule (self) :

   124

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

   125

   126

        # following the last item in the queue

   127

        item = self.last_item()

   128

   129

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

   130

            # starting from the following day

   131

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

   132

        else :

   133

            # defaults to today

   134

            date = self.now().date()

   135

   136

        return date, self.publishing_timetz, self.publishing_offset

   137

   138

    @classmethod

   139

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

   140

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

   141

        for index in xrange(0, count) :

   142

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

   143

   144

    def __unicode__ (self) :

   145

        return self.shorturl

   146

   147

class URLImage(models.Model):

   148

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

   149

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

   150

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

   151

    uploaded = models.DateTimeField(auto_now_add=True)

   152

   153

    class Meta:

   154

        verbose_name = u"URL Image"

   155

        verbose_name_plural = u"URL Images"

   156

        ordering = ['uploaded']

   157

   158

    def save (self) :

   159

        # keep real filename before saving with hash

   160

        # but not when updating!

   161

        if not self.name:

   162

            self.name = self.image.name

   163

   164

        super(URLImage, self).save()

   165

   166

    def get_absolute_url (self) :

   167

        return self.image.url

   168

   169

    def __unicode__ (self) :

   170

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

   171

   172

class URLItem(models.Model):

   173

    shorturl = models.ForeignKey(URL)

   174

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

   175

   176

    # either-or

   177

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

   178

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

   179

   180

    class Meta:

   181

        verbose_name = u"URL Item"

   182

        verbose_name_plural = u"URL Items"

   183

        ordering = ['published']

   184

   185

    @classmethod

   187

        """

   188

            Return the URLItem for a given shorturl, either the given specific one,

   189

            or the latest, from the database.

   190

   191

            Raises URLItem.NotFound

   192

        """

   193

        # JOIN against shorturl, urlimage

   194

        url_item = cls.objects.select_related(*related)

   195

   200

            url_item = url_item.filter(shorturl__id=shorturl_id)

   201

        else:

   203

   204

        # match for published items

   205

        now = timezone.now()

   206

        url_item = url_item.filter(published__lt=now).order_by('-published')

   207

   208

        log.info("Search URLItem @ %s", now)

   209

   210

        if item_id :

   211

            # specific, but still the published on

   212

            return url_item.get(id=int(item_id)) # raises DoesNotExist

   213

        else :

   214

            # most recent

   215

            try:

   216

                return url_item[0]

   217

            except IndexError:

   218

                raise DoesNotExist()

   219

   220

    def get_absolute_url (self) :

   221

        if self.url :

   222

            return self.url

   223

        elif self.shorturl and self.id :

   224

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

   225

        else :

   226

            return None

   227

   228

    def published_age (self) :

   229

        now = self.shorturl.now() # UTC

   230

   231

        if now > self.published:

   232

            td = now - self.published

   233

        else :

   234

            td = self.published - now

   235

   236

        days, seconds = td.days, td.seconds

   237

        m, s = divmod(seconds, 60)

   238

        h, m = divmod(m, 60)

   239

   240

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

   241

   242

    def published_state (self) :

   243

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

   244

        published, days, age = self.published_age()

   245

   246

        if published and days :

   247

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

   248

        elif published :

   249

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

   250

        elif days :

   251

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

   252

        else :

   253

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

   254

   255

    def last_modified (self) :

   256

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

   257

        return self.published

   258

   259

    def title (self) :

   260

        if self.image and self.image.title.strip() :

   261

            return self.image.title

   262

        else :

   263

            return self.shorturl.title

   264

   265

    def __unicode__ (self) :

   266

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

   267

                published_state=self.published_state(),

   268

                url=self.get_absolute_url(),

   269

        )

   270