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

    94

    def qrcode_img (self, size=512) :

    95

        return QRCODE_API.format(

    96

                width=size, height=size,

    97

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

    98

        )

    99

   100

    def qrcode_url (self) :

   101

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

   102

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

   103

                url = self.get_absolute_url(),

   104

        )

   105

   106

    def get_absolute_url (self) :

   107

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

   108

   109

    def now (self, now=None) :

   110

        """

   111

            Return database-compatible concept of "now".

   112

   113

            All datetimes are strictly stored and compared as UTC. Any

   114

            timezone-aware logic should happen in the admin.

   115

        """

   116

        if now :

   117

            return now

   118

        else :

   119

            return timezone.now()

   120

   121

    def active_item (self, now=None) :

   122

        """Currently published URLItem."""

   123

        now = self.now(now)

   124

   125

        try :

   126

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

   127

        except IndexError :

   128

            return None

   129

   130

    def upcoming_item (self, now=None) :

   131

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

   132

        now = self.now(now)

   133

   134

        try :

   135

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

   136

        except IndexError :

   137

            return None

   138

   139

    def last_item (self) :

   140

        """The last URLItem available."""

   141

   142

        try :

   143

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

   144

        except IndexError :

   145

            return None

   146

   147

    @property

   148

    def publishing_timetz (self) :

   149

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

   150

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

   151

   152

    @property

   153

    def publishing_offset (self) :

   154

        return datetime.timedelta(days=self.publishing_days)

   155

   156

    def publishing_schedule (self) :

   157

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

   158

   159

        # following the last item in the queue

   160

        item = self.last_item()

   161

   162

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

   163

            # starting from the following day

   164

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

   165

        else :

   166

            # defaults to today

   167

            date = self.now().date()

   168

   169

        return date, self.publishing_timetz, self.publishing_offset

   170

   171

    @classmethod

   172

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

   173

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

   174

        for index in xrange(0, count) :

   175

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

   176

   177

    def __unicode__ (self) :

   178

        return self.shorturl

   179

   180

class URLImage(models.Model):

   181

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

   182

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

   183

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

   184

    uploaded = models.DateTimeField(auto_now_add=True)

   185

   186

    class Meta:

   187

        verbose_name = u"URL Image"

   188

        verbose_name_plural = u"URL Images"

   189

        ordering = ['uploaded']

   190

   191

    def save (self) :

   192

        # keep real filename before saving with hash

   193

        # but not when updating!

   194

        if not self.name:

   195

            self.name = self.image.name

   196

   197

        super(URLImage, self).save()

   198

   199

    def get_absolute_url (self) :

   200

        return self.image.url

   201

   202

    def __unicode__ (self) :

   203

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

   204

   205

class URLItem(models.Model):

   206

    shorturl = models.ForeignKey(URL)

   207

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

   208

   209

    # either-or

   210

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

   211

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

   212

   213

    class Meta:

   214

        verbose_name = u"URL Item"

   215

        verbose_name_plural = u"URL Items"

   216

        ordering = ['published']

   217

   218

    @classmethod

   219

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

   220

        """

   221

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

   223

   225

        """

   226

        # JOIN against shorturl, urlimage

   227

        url_item = cls.objects.select_related(*related)

   228

   229

        if not shorturl:

   230

            raise cls.DoesNotExist()

   231

        elif shorturl.isdigit():

   232

            shorturl_id = int(shorturl)

   233

            url_item = url_item.filter(shorturl__id=shorturl_id)

   234

        else:

   235

            url_item = url_item.filter(shorturl__shorturl=shorturl)

   236

   237

        # match for published items

   238

        now = timezone.now()

   239

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

   240

   241

        if item_id :

   242

            # specific, but still the published on

   243

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

   244

   245

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

   246

        else :

   247

            # most recent

   248

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

   249

            try:

   250

                return url_item[0]

   251

            except IndexError:

   252

                raise cls.DoesNotExist()

   253

   254

    @classmethod

   257

   258

    @classmethod

   259

    def get_item (cls, shorturl, item_id) :

   260

        """

   261

            Return a data dict for the given URLItem, from cache or DB.

   262

   263

            Returns { url: str, title: str, image: str, last_modified: datetime }

   265

        """

   266

   267

        key = cls.cache_key(shorturl, item_id)

   268

        get = cache.get(key)

   269

   270

        if get:

   271

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

   272

            return get

   273

        else:

   274

            url_item = URLItem.get(shorturl, item_id=item_id,

   275

                related=('shorturl', 'image'),

   276

            )

   277

            set = dict(

   278

                    url             = url_item.url,

   279

                    title           = url_item.title(),

   280

                    image           = url_item.image.get_absolute_url() if url_item.image else None,

   281

                    last_modified   = url_item.last_modified(),

   282

            )

   283

   284

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

   285

            cache.set(key, set)

   286

            return set

   287

   288

    def get_absolute_url (self) :

   289

        if self.url :

   290

            return self.url

   291

        elif self.shorturl and self.id :

   292

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

   293

        else :

   294

            return None

   295

   296

    def published_age (self) :

   297

        now = self.shorturl.now() # UTC

   298

   299

        if now > self.published:

   300

            td = now - self.published

   301

        else :

   302

            td = self.published - now

   303

   304

        days, seconds = td.days, td.seconds

   305

        m, s = divmod(seconds, 60)

   306

        h, m = divmod(m, 60)

   307

   308

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

   309

   310

    def published_state (self) :

   311

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

   312

        published, days, age = self.published_age()

   313

   314

        if published and days :

   315

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

   316

        elif published :

   317

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

   318

        elif days :

   319

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

   320

        else :

   321

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

   322

   323

    def last_modified (self) :

   324

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

   325

        return self.published

   326

   327

    def title (self) :

   328

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

   329

            return self.image.title

   330

        else :

   331

            return self.shorturl.title

   332

   333

    def __unicode__ (self) :

   334

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

   335

                published_state=self.published_state(),

   336

                url=self.get_absolute_url(),

   337

        )

   338

   339

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

   340

def urlitem_save(instance, **kwargs) :

   341

    # invalidate cache

   342

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

   343

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

   344

    cache.delete(key)

   345

   346

    key = URLItem.cache_key(instance.shorturl.shorturl, instance.id)

   347

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

   348

    cache.delete(key)

   349