93 

    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,

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

   223 

   224             Raises URLItem.DoesNotExist

   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

   255     def cache_key (cls, shorturl, item_id) :

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

   257