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.contrib.sites.models import get_current_site

    12

from django.utils import timezone

    13

    14

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

    15

    16

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

    17

IMAGES_MEDIA = 'qrurls-images'

    18

    19

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

    20

    """

    21

        Store files named by a sha1 hash of their contents.

    22

    """

    23

    24

    HASH = hashlib.sha1

    25

    26

    def _hash (self, content) :

    27

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

    28

        hash = self.HASH()

    29

    30

        for chunk in content.chunks() :

    31

            hash.update(chunk)

    32

    33

        return hash.hexdigest()

    34

    35

    def save (self, name, content) :

    36

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

    37

        if name is None:

    38

            name = content.name

    39

    40

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

    41

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

    42

    43

        # hash

    44

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

    45

    46

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

    47

    48

class URL(models.Model):

    49

    shorturl = models.SlugField(unique=True,

    50

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

    51

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

    52

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

    53

    publishing_days = models.IntegerField(default=1,

    54

            help_text="Default interval for publishing new URLItems")

    55

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

    56

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

    57

    58

    class Meta:

    59

        verbose_name = u"URL Feed"

    60

        verbose_name_plural = u"URL Feeds"

    61

    62

    def qrcode_img (self, size=512) :

    63

        return QRCODE_API.format(

    64

                width=size, height=size,

    65

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

    66

        )

    67

    68

    def qrcode_url (self) :

    69

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

    70

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

    71

                url = self.get_absolute_url(),

    72

        )

    73

    74

    def get_absolute_url (self) :

    75

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

    76

    77

    def now (self, now=None) :

    78

        """

    79

            Return database-compatible concept of "now".

    80

    81

            All datetimes are strictly stored and compared as UTC. Any

    82

            timezone-aware logic should happen in the admin.

    83

        """

    84

        if now :

    85

            return now

    86

        else :

    87

            return timezone.now()

    88

    89

    def active_item (self, now=None) :

    90

        """Currently published URLItem."""

    91

        now = self.now(now)

    92

    93

        try :

    94

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

    95

        except IndexError :

    96

            return None

    97

    98

    def upcoming_item (self, now=None) :

    99

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

   100

        now = self.now(now)

   101

   102

        try :

   103

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

   104

        except IndexError :

   105

            return None

   106

   107

    def last_item (self) :

   108

        """The last URLItem available."""

   109

   110

        try :

   111

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

   112

        except IndexError :

   113

            return None

   114

   115

    @property

   116

    def publishing_timetz (self) :

   117

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

   118

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

   119

   120

    @property

   121

    def publishing_offset (self) :

   122

        return datetime.timedelta(days=self.publishing_days)

   123

   124

    def publishing_schedule (self) :

   125

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

   126

   127

        # following the last item in the queue

   128

        item = self.last_item()

   129

   130

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

   131

            # starting from the following day

   132

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

   133

        else :

   134

            # defaults to today

   135

            date = self.now().date()

   136

   137

        return date, self.publishing_timetz, self.publishing_offset

   138

   139

    @classmethod

   140

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

   141

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

   142

        for index in xrange(0, count) :

   143

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

   144

   145

    def __unicode__ (self) :

   146

        return self.shorturl

   147

   148

class URLImage(models.Model):

   149

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

   150

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

   151

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

   152

    uploaded = models.DateTimeField(auto_now_add=True)

   153

   154

    class Meta:

   155

        verbose_name = u"URL Image"

   156

        verbose_name_plural = u"URL Images"

   157

        ordering = ['uploaded']

   158

   159

    def save (self) :

   160

        # keep real filename before saving with hash

   161

        # but not when updating!

   162

        if not self.name:

   163

            self.name = self.image.name

   164

   165

        super(URLImage, self).save()

   166

   167

    def get_absolute_url (self) :

   168

        return self.image.url

   169

   170

    def __unicode__ (self) :

   171

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

   172

   173

class URLItem(models.Model):

   174

    shorturl = models.ForeignKey(URL)

   175

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

   176

   177

    # either-or

   178

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

   179

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

   180

   181

    class Meta:

   182

        verbose_name = u"URL Item"

   183

        verbose_name_plural = u"URL Items"

   184

        ordering = ['published']

   185

   186

    @classmethod

   188

        """

   189

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

   190

            or the latest, from the database.

   191

   192

            Raises URLItem.NotFound

   193

        """

   194

        # JOIN against shorturl, urlimage

   195

        url_item = cls.objects.select_related(*related)

   196

   197

        if not shorturl:

   198

            raise cls.DoesNotExist()

   199

        elif shorturl.isdigit():

   200

            shorturl_id = int(shorturl)

   201

            url_item = url_item.filter(shorturl__id=shorturl_id)

   202

        else:

   203

            url_item = url_item.filter(shorturl__shorturl=shorturl)

   204

   205

        # match for published items

   206

        now = timezone.now()

   207

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

   208

   209

        if item_id :

   210

            # specific, but still the published on

   215

        else :

   216

            # most recent

   218

            try:

   219

                return url_item[0]

   220

            except IndexError:

   221

                raise DoesNotExist()

   222

   250

    def get_absolute_url (self) :

   251

        if self.url :

   252

            return self.url

   253

        elif self.shorturl and self.id :

   254

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

   255

        else :

   256

            return None

   257

   258

    def published_age (self) :

   259

        now = self.shorturl.now() # UTC

   260

   261

        if now > self.published:

   262

            td = now - self.published

   263

        else :

   264

            td = self.published - now

   265

   266

        days, seconds = td.days, td.seconds

   267

        m, s = divmod(seconds, 60)

   268

        h, m = divmod(m, 60)

   269

   270

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

   271

   272

    def published_state (self) :

   273

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

   274

        published, days, age = self.published_age()

   275

   276

        if published and days :

   277

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

   278

        elif published :

   279

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

   280

        elif days :

   281

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

   282

        else :

   283

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

   284

   285

    def last_modified (self) :

   286

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

   287

        return self.published

   288

   289

    def title (self) :

   290

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

   291

            return self.image.title

   292

        else :

   293

            return self.shorturl.title

   294

   295

    def __unicode__ (self) :

   296

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

   297

                published_state=self.published_state(),

   298

                url=self.get_absolute_url(),

   299

        )

   300