1

import datetime

     2

import hashlib

     3

import os.path

     4

     5

from django.db import models

     6

import django.core.files.storage

     7

from django.core.urlresolvers import reverse

     8

import django.utils.http

     9

from django.contrib.sites.models import get_current_site

    10

from django.utils import timezone

    11

    12

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

    13

IMAGES_MEDIA = 'qrurls-images'

    14

    15

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

    16

    """

    17

        Store files named by a sha1 hash of their contents.

    18

    """

    19

    20

    HASH = hashlib.sha1

    21

    22

    def _hash (self, content) :

    23

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

    24

        hash = self.HASH()

    25

    26

        for chunk in content.chunks() :

    27

            hash.update(chunk)

    28

    29

        return hash.hexdigest()

    30

    31

    def save (self, name, content) :

    32

        # Get the proper name for the file, as it will actually be saved.

    33

        if name is None:

    34

            name = content.name

    35

    36

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

    37

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

    38

    39

        # hash

    40

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

    41

    42

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

    43

    44

class URL(models.Model):

    45

    shorturl = models.SlugField(unique=True)

    46

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

    47

            help_text="Default time to publish new URLItems")

    48

    49

    class Meta:

    50

        verbose_name = u"URL Feed"

    51

        verbose_name_plural = u"URL Feeds"

    52

    53

    def qrcode_img (self, size=512) :

    54

        return QRCODE_API.format(

    55

                width=size, height=size,

    56

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

    57

        )

    58

    59

    def qrcode_url (self) :

    60

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

    61

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

    62

                url = self.get_absolute_url(),

    63

        )

    64

    65

    def get_absolute_url (self) :

    66

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

    67

    68

    def active_item(self, now=None) :

    69

        """Currently published URLItem."""

    70

        if now is None :

    71

            now = timezone.now()

    72

    73

        try :

    74

            return URLItem.objects.filter(shorturl=self, published__lt=now).order_by('-published')[0]

    75

        except IndexError :

    76

            return None

    77

    78

    def upcoming_item (self, now=None) :

    79

        """Following published URLItem."""

    80

        if now is None :

    81

            now = timezone.now()

    82

    83

        try :

    84

            return URLItem.objects.filter(shorturl=self, published__gt=now).order_by('published')[0]

    85

        except IndexError :

    86

            return None

    87

    88

    def last_item (self) :

    89

        """The last URLItem available."""

    90

    91

        try :

    92

            return URLItem.objects.filter(shorturl=self).order_by('-published')[0]

    93

        except IndexError :

    94

            return None

    95

    96

    def __unicode__ (self) :

    97

        return self.shorturl

    98

    99

class URLImage(models.Model):

   100

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

   101

    title = models.CharField(max_length=1024)

   102

    uploaded = models.DateTimeField(auto_now_add=True)

   103

   104

    class Meta:

   105

        verbose_name = u"URL Image"

   106

        verbose_name_plural = u"URL Images"

   107

        ordering = ['uploaded']

   108

   109

    def get_absolute_url (self) :

   110

        return self.image.url

   111

   112

    def __unicode__ (self) :

   113

        return self.image.name

   114

   115

class URLItem(models.Model):

   116

    shorturl = models.ForeignKey(URL)

   117

    published = models.DateTimeField()

   118

   119

    # either-or

   120

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

   121

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

   122

   123

    class Meta:

   124

        verbose_name = u"URL Item"

   125

        verbose_name_plural = u"URL Items"

   126

        ordering = ['published']

   127

   128

    def get_absolute_url (self) :

   131

        else :

   133

   134

    def published_age (self) :

   135

        now = timezone.now()

   136

   137

        if now > self.published:

   138

            td = now - self.published

   139

        else :

   140

            td = self.published - now

   141

   142

        days, seconds = td.days, td.seconds

   143

        m, s = divmod(seconds, 60)

   144

        h, m = divmod(m, 60)

   145

   146

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

   147

   148

    def published_state (self) :

   149

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

   150

        published, days, age = self.published_age()

   151

   152

        if published and days :

   153

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

   154

        elif published :

   155

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

   156

        elif days :

   157

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

   158

        else :

   159

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

   160

   161

    def __unicode__ (self) :

   162

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

   163

                published_state=self.published_state(),

   164

                url=self.get_absolute_url(),

   165

        )

   166