1

import datetime

     2

     3

from django.db import models

     4

from django.core.urlresolvers import reverse

     5

import django.utils.http

     6

from django.contrib.sites.models import get_current_site

     7

from django.utils import timezone

     8

     9

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

    10

    11

class URL(models.Model):

    12

    shorturl = models.SlugField(unique=True)

    13

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

    14

            help_text="Default time to publish new URLItems")

    15

    16

    class Meta:

    17

        verbose_name = u"URL Feed"

    18

        verbose_name_plural = u"URL Feeds"

    19

    20

    def qrcode_img (self, size=512) :

    21

        return QRCODE_API.format(

    22

                width=size, height=size,

    23

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

    24

        )

    25

    26

    def qrcode_url (self) :

    27

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

    28

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

    29

                url = self.get_absolute_url(),

    30

        )

    31

    32

    def get_absolute_url (self) :

    33

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

    34

    35

    def active_item(self, now=None) :

    36

        """Currently published URLItem."""

    37

        if now is None :

    38

            now = timezone.now()

    39

    40

        try :

    41

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

    42

        except IndexError :

    43

            return None

    44

    45

    def upcoming_item (self, now=None) :

    46

        """Following published URLItem."""

    47

        if now is None :

    48

            now = timezone.now()

    49

    50

        try :

    51

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

    52

        except IndexError :

    53

            return None

    54

    55

    def last_item (self) :

    56

        """The last URLItem available."""

    57

    58

        try :

    59

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

    60

        except IndexError :

    61

            return None

    62

    63

    def __unicode__ (self) :

    64

        return self.shorturl

    65

    66

class URLImage(models.Model):

    67

    image = models.ImageField(upload_to='qrurls-images')

    77

    78

class URLItem(models.Model):

    79

    shorturl = models.ForeignKey(URL)

    80

    published = models.DateTimeField()

    81

    url = models.URLField()

    82

    83

    class Meta:

    84

        verbose_name = u"URL Item"

    85

        verbose_name_plural = u"URL Items"

    86

        ordering = ['published']

    87

    88

    def get_absolute_url (self) :

    89

        return self.url

    90

    91

    def published_age (self) :

    92

        now = timezone.now()

    93

    94

        if now > self.published:

    95

            td = now - self.published

    96

        else :

    97

            td = self.published - now

    98

    99

        days, seconds = td.days, td.seconds

   100

        m, s = divmod(seconds, 60)

   101

        h, m = divmod(m, 60)

   102

   103

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

   104

   105

    def published_state (self) :

   106

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

   107

        published, days, age = self.published_age()

   108

   109

        if published and days :

   110

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

   111

        elif published :

   112

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

   113

        elif days :

   114

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

   115

        else :

   116

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

   117

   118

    def __unicode__ (self) :

   119

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

   120

                published_state=self.published_state(),

   121

                url=self.get_absolute_url(),

   122

        )