1

import datetime

     2

import hashlib

     4

import logging

     5

import os.path

     6

     7

import django.core.files.storage

     8

import django.utils.http

     9

from django import dispatch

    10

from django.contrib.sites.models import get_current_site

    11

from django.core.cache import cache

    12

from django.core.urlresolvers import reverse

    13

from django.db import models

    14

from django.utils import timezone

    15

    16

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

    17

    18

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

    19

IMAGES_MEDIA = 'qrurls-images'

    20

    21

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

    22

    """

    23

        Store files named by a sha1 hash of their contents.

    24

    """

    25

    26

    HASH = hashlib.sha1

    27

    28

    def _hash (self, content) :

    29

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

    30

        hash = self.HASH()

    31

    32

        for chunk in content.chunks() :

    33

            hash.update(chunk)

    34

    35

        return hash.hexdigest()

    36

    37

    def save (self, name, content) :

    38

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

    39

        if name is None:

    40

            name = content.name

    41

    42

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

    43

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

    44

    45

        # hash

    46

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

    47

    48

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

    49

    50

class URL(models.Model):

    51

    shorturl = models.SlugField(unique=True,

    52

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

    53

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

    54

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

    55

    publishing_days = models.IntegerField(default=1,

    56

            help_text="Default interval for publishing new URLItems")

    57

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

    58

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

    59

    60

    class Meta:

    61

        verbose_name = u"URL Feed"

    62

        verbose_name_plural = u"URL Feeds"

    63

    64

    @classmethod

    65

    def cache_key (self, shorturl) :

    66

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

    67

    68

    @classmethod

    69

    def get_url (cls, shorturl) :

    70

        """

    71

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

    72

    73

            Returns url:str, modified:datetime

    74

            Raises URLItem.DoesNotExist

    75

        """

    76

        key = cls.cache_key(shorturl)

    77

        get = cache.get(key)

    78

    79

        if get :

    80

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

    81

            return get

    82

        else:

    83

            # from db

    84

            url_item = URLItem.get(shorturl=shorturl)

    85

            set = (

    86

                url_item.get_absolute_url(),

    87

                url_item.last_modified()

    88

            )

    89

    90

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

    91

            cache.set(key, set)

    92

            return set

    93

    94

    95

    def qrcode_img (self, size=512) :

    96

        return QRCODE_API.format(

    97

                width=size, height=size,

    98

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

    99

        )

   100

   101

    def qrcode_url (self) :

   102

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

   103

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

   104

                url = self.get_absolute_url(),

   105

        )

   106

   107

    def get_absolute_url (self) :

   108

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

   109

   110

    def now (self, now=None) :

   111

        """

   112

            Return database-compatible concept of "now".

   113

   114

            All datetimes are strictly stored and compared as UTC. Any

   115

            timezone-aware logic should happen in the admin.

   116

        """

   117

        if now :

   118

            return now

   119

        else :

   120

            return timezone.now()

   121

   122

    def active_item (self, now=None) :

   123

        """Currently published URLItem."""

   124

        now = self.now(now)

   125

   126

        try :

   127

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

   128

        except IndexError :

   129

            return None

   130

   131

    def upcoming_item (self, now=None) :

   132

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

   133

        now = self.now(now)

   134

   135

        try :

   136

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

   137

        except IndexError :

   138

            return None

   139

   140

    def last_item (self) :

   141

        """The last URLItem available."""

   142

   143

        try :

   144

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

   145

        except IndexError :

   146

            return None

   147

   148

    @property

   149

    def publishing_timetz (self) :

   150

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

   151

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

   152

   153

    @property

   154

    def publishing_offset (self) :

   155

        return datetime.timedelta(days=self.publishing_days)

   156

   157

    def publishing_schedule (self) :

   158

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

   159

   160

        # following the last item in the queue

   161

        item = self.last_item()

   162

   163

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

   164

            # starting from the following day

   165

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

   166

        else :

   167

            # defaults to today

   168

            date = self.now().date()

   169

   170

        return date, self.publishing_timetz, self.publishing_offset

   171

   172

    @classmethod

   186

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

   187

   188

    def __unicode__ (self) :

   189

        return self.shorturl

   190

   191

class URLImage(models.Model):

   192

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

   193

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

   194

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

   195

    uploaded = models.DateTimeField(auto_now_add=True)

   196

   197

    class Meta:

   198

        verbose_name = u"URL Image"

   199

        verbose_name_plural = u"URL Images"

   200

        ordering = ['uploaded']

   201

   202

    def save (self) :

   203

        # keep real filename before saving with hash

   204

        # but not when updating!

   205

        if not self.name:

   206

            self.name = self.image.name

   207

   208

        super(URLImage, self).save()

   209

   210

    def get_absolute_url (self) :

   211

        return self.image.url

   212

   213

    def __unicode__ (self) :

   214

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

   215

   216

class URLItem(models.Model):

   217

    shorturl = models.ForeignKey(URL)

   218

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

   219

   220

    # either-or

   221

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

   222

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

   223

   224

    class Meta:

   225

        verbose_name = u"URL Item"

   226

        verbose_name_plural = u"URL Items"

   227

        ordering = ['published']

   228

   229

    @classmethod

   230

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

   231

        """

   232

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

   233

            or the latest, from the database in one SQL query.

   234

   235

            Raises URLItem.DoesNotExist

   236

        """

   237

        # JOIN against shorturl, urlimage

   238

        url_item = cls.objects.select_related(*related)

   239

   240

        if not shorturl:

   241

            raise cls.DoesNotExist()

   242

        elif shorturl.isdigit():

   243

            shorturl_id = int(shorturl)

   244

            url_item = url_item.filter(shorturl__id=shorturl_id)

   245

        else:

   246

            url_item = url_item.filter(shorturl__shorturl=shorturl)

   247

   248

        # match for published items

   249

        now = timezone.now()

   250

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

   251

   252

        if item_id :

   253

            # specific, but still the published on

   254

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

   255

   256

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

   257

        else :

   258

            # most recent

   259

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

   260

            try:

   261

                return url_item[0]

   262

            except IndexError:

   263

                raise cls.DoesNotExist()

   264

   265

    @classmethod

   266

    def cache_key (cls, shorturl, item_id) :

   267

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

   268

   269

    @classmethod

   270

    def get_item (cls, shorturl, item_id) :

   271

        """

   272

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

   273

   274

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

   275

            Raises URLItem.DoesNotExist

   276

        """

   277

   278

        key = cls.cache_key(shorturl, item_id)

   279

        get = cache.get(key)

   280

   281

        if get:

   282

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

   283

            return get

   284

        else:

   285

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

   286

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

   287

            )

   288

            set = dict(

   289

                    url             = url_item.url,

   290

                    title           = url_item.title(),

   291

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

   292

                    last_modified   = url_item.last_modified(),

   293

            )

   294

   295

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

   296

            cache.set(key, set)

   297

            return set

   298

   299

    def get_absolute_url (self) :

   300

        if self.url :

   301

            return self.url

   302

        elif self.shorturl and self.id :

   303

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

   304

        else :

   305

            return None

   306

   307

    def published_age (self) :

   308

        now = self.shorturl.now() # UTC

   309

   310

        if now > self.published:

   311

            td = now - self.published

   312

        else :

   313

            td = self.published - now

   314

   315

        days, seconds = td.days, td.seconds

   316

        m, s = divmod(seconds, 60)

   317

        h, m = divmod(m, 60)

   318

   319

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

   320

   321

    def published_state (self) :

   322

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

   323

        published, days, age = self.published_age()

   324

   325

        if published and days :

   326

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

   327

        elif published :

   328

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

   329

        elif days :

   330

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

   331

        else :

   332

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

   333

   334

    def last_modified (self) :

   335

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

   336

        return self.published

   337

   338

    def title (self) :

   339

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

   340

            return self.image.title

   341

        else :

   342

            return self.shorturl.title

   343

   344

    def __unicode__ (self) :

   345

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

   346

                published_state=self.published_state(),

   347

                url=self.get_absolute_url(),

   348

        )

   349

   350

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

   351

def urlitem_save(instance, **kwargs) :

   352

    # invalidate cache

   353

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

   354

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

   355

    cache.delete(key)

   356

   357

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

   358

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

   359

    cache.delete(key)

   360