1

import datetime

     2

import hashlib

     3

import logging

     4

import os.path

     5

     6

import django.core.files.storage

     7

import django.utils.http

     8

from django import dispatch

     9

from django.contrib.sites.models import get_current_site

    10

from django.core.cache import cache

    11

from django.core.urlresolvers import reverse

    12

from django.db import models

    13

from django.utils import timezone

    14

    15

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

    16

    17

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

    18

IMAGES_MEDIA = 'qrurls-images'

    19

    20

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

    21

    """

    22

        Store files named by a sha1 hash of their contents.

    23

    """

    24

    25

    HASH = hashlib.sha1

    26

    27

    def _hash (self, content) :

    28

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

    29

        hash = self.HASH()

    30

    31

        for chunk in content.chunks() :

    32

            hash.update(chunk)

    33

    34

        return hash.hexdigest()

    35

    36

    def save (self, name, content) :

    37

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

    38

        if name is None:

    39

            name = content.name

    40

    41

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

    42

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

    43

    44

        # hash

    45

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

    46

    47

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

    48

    49

class URL(models.Model):

    50

    shorturl = models.SlugField(unique=True,

    51

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

    52

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

    53

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

    54

    publishing_days = models.IntegerField(default=1,

    55

            help_text="Default interval for publishing new URLItems")

    56

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

    57

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

    58

    59

    class Meta:

    60

        verbose_name = u"URL Feed"

    61

        verbose_name_plural = u"URL Feeds"

    62

    63

    @classmethod

    64

    def cache_key (self, shorturl) :

    65

        return 'qrurls/url/{shorturl}'.format(shorturl=shorturl)

    66

    67

    def qrcode_img (self, size=512) :

    68

        return QRCODE_API.format(

    69

                width=size, height=size,

    70

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

    71

        )

    72

    73

    def qrcode_url (self) :

    74

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

    75

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

    76

                url = self.get_absolute_url(),

    77

        )

    78

    79

    def get_absolute_url (self) :

    80

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

    81

    82

    def now (self, now=None) :

    83

        """

    84

            Return database-compatible concept of "now".

    85

    86

            All datetimes are strictly stored and compared as UTC. Any

    87

            timezone-aware logic should happen in the admin.

    88

        """

    89

        if now :

    90

            return now

    91

        else :

    92

            return timezone.now()

    93

    94

    def active_item (self, now=None) :

    95

        """Currently published URLItem."""

    96

        now = self.now(now)

    97

    98

        try :

    99

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

   100

        except IndexError :

   101

            return None

   102

   103

    def upcoming_item (self, now=None) :

   104

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

   105

        now = self.now(now)

   106

   107

        try :

   108

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

   109

        except IndexError :

   110

            return None

   111

   112

    def last_item (self) :

   113

        """The last URLItem available."""

   114

   115

        try :

   116

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

   117

        except IndexError :

   118

            return None

   119

   120

    @property

   121

    def publishing_timetz (self) :

   122

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

   123

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

   124

   125

    @property

   126

    def publishing_offset (self) :

   127

        return datetime.timedelta(days=self.publishing_days)

   128

   129

    def publishing_schedule (self) :

   130

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

   131

   132

        # following the last item in the queue

   133

        item = self.last_item()

   134

   135

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

   136

            # starting from the following day

   137

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

   138

        else :

   139

            # defaults to today

   140

            date = self.now().date()

   141

   142

        return date, self.publishing_timetz, self.publishing_offset

   143

   144

    @classmethod

   145

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

   146

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

   147

        for index in xrange(0, count) :

   148

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

   149

   150

    def __unicode__ (self) :

   151

        return self.shorturl

   152

   153

class URLImage(models.Model):

   154

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

   155

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

   156

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

   157

    uploaded = models.DateTimeField(auto_now_add=True)

   158

   159

    class Meta:

   160

        verbose_name = u"URL Image"

   161

        verbose_name_plural = u"URL Images"

   162

        ordering = ['uploaded']

   163

   164

    def save (self) :

   165

        # keep real filename before saving with hash

   166

        # but not when updating!

   167

        if not self.name:

   168

            self.name = self.image.name

   169

   170

        super(URLImage, self).save()

   171

   172

    def get_absolute_url (self) :

   173

        return self.image.url

   174

   175

    def __unicode__ (self) :

   176

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

   177

   178

class URLItem(models.Model):

   179

    shorturl = models.ForeignKey(URL)

   180

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

   181

   182

    # either-or

   183

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

   184

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

   185

   186

    class Meta:

   187

        verbose_name = u"URL Item"

   188

        verbose_name_plural = u"URL Items"

   189

        ordering = ['published']

   190

   191

    @classmethod

   192

    def get_item (cls, shorturl, item_id=None, related=()) :

   193

        """

   194

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

   195

            or the latest, from the database.

   196

   197

            Raises URLItem.NotFound

   198

        """

   199

        # JOIN against shorturl, urlimage

   200

        url_item = cls.objects.select_related(*related)

   201

   202

        if not shorturl:

   203

            raise cls.DoesNotExist()

   204

        elif shorturl.isdigit():

   205

            shorturl_id = int(shorturl)

   206

            url_item = url_item.filter(shorturl__id=shorturl_id)

   207

        else:

   208

            url_item = url_item.filter(shorturl__shorturl=shorturl)

   209

   210

        # match for published items

   211

        now = timezone.now()

   212

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

   213

   214

        if item_id :

   215

            # specific, but still the published on

   216

            item_id = int(item_id)

   217

            log.debug("search @ %d", item_id)

   218

   219

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

   220

        else :

   221

            # most recent

   222

            log.debug("search @ %s", now)

   223

            try:

   224

                return url_item[0]

   225

            except IndexError:

   227

   228

    @classmethod

   229

    def get_url (cls, shorturl) :

   230

        """

   231

            Return the current URL for a given shorturl, from cache or DB.

   232

   233

            Returns url:str, modified:datetime

   234

            Raises URLItem.NotFound

   235

        """

   236

        key = URL.cache_key(shorturl)

   237

        get = cache.get(key)

   238

   239

        if get :

   240

            url, modified = get

   241

            log.debug("get cache: %s: %s", key, url)

   242

        else:

   243

            # from db

   244

            url_item = cls.get_item(shorturl=shorturl)

   245

   246

            url = url_item.get_absolute_url()

   247

            modified = url_item.last_modified()

   248

   249

            log.debug("set cache: %s: %s", key, url)

   250

            cache.set(key, (url, modified)) # XXX: expiry

   251

   252

        return url, modified

   253

   254

    def get_absolute_url (self) :

   255

        if self.url :

   256

            return self.url

   257

        elif self.shorturl and self.id :

   258

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

   259

        else :

   260

            return None

   261

   262

    def published_age (self) :

   263

        now = self.shorturl.now() # UTC

   264

   265

        if now > self.published:

   266

            td = now - self.published

   267

        else :

   268

            td = self.published - now

   269

   270

        days, seconds = td.days, td.seconds

   271

        m, s = divmod(seconds, 60)

   272

        h, m = divmod(m, 60)

   273

   274

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

   275

   276

    def published_state (self) :

   277

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

   278

        published, days, age = self.published_age()

   279

   280

        if published and days :

   281

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

   282

        elif published :

   283

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

   284

        elif days :

   285

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

   286

        else :

   287

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

   288

   289

    def last_modified (self) :

   290

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

   291

        return self.published

   292

   293

    def title (self) :

   294

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

   295

            return self.image.title

   296

        else :

   297

            return self.shorturl.title

   298

   299

    def __unicode__ (self) :

   300

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

   301

                published_state=self.published_state(),

   302

                url=self.get_absolute_url(),

   303

        )

   304

   305

@dispatch.receiver(models.signals.post_save, sender=URLItem)

   306

def urlitem_save(instance, **kwargs) :

   307

    # invalidate cache

   308

    key = URL.cache_key(instance.shorturl.shorturl)

   309

    log.info("clear cache: %s: %s", instance, key)

   310

    cache.delete(key)

   311

   312