path: root/app/jrnl/models.py

import datetime
import os
import re

from django.contrib.gis.db import models
from django.utils.html import format_html
from django.core.urlresolvers import reverse
from django.template.loader import render_to_string
from django.conf import settings
from django.template import Context
from django.contrib.syndication.views import Feed
from django.contrib.sitemaps import Sitemap
from django import forms
from django.template.defaultfilters import slugify

# http://freewisdom.org/projects/python-markdown/
import markdown
from bs4 import BeautifulSoup

from photos.models import PhotoGallery, LuxImage
from locations.models import Location

from utils.widgets import parse_image, parse_video
from utils.widgets import markdown_to_html


def get_upload_path(self, filename):
    return "images/post-images/%s/%s" % (datetime.datetime.today().strftime("%Y"), filename)


def get_tn_path(self, filename):
    return "images/post-thumbnail/%s/%s" % (datetime.datetime.today().strftime("%Y"), filename)


def image_url_replace(s):
    s = s.replace('[[base_url]]', settings.IMAGES_URL)
    return s


def render_images(s):
    s = re.sub('<img(.*)/>', parse_image, s)
    return s


def extract_images(s):
    soup = BeautifulSoup(s, "lxml")
    imgs = []
    for img in soup.find_all('img'):
        try:
            imgs.append(img['src'])
        except:
            pass
    return imgs


class Entry(models.Model):
    title = models.CharField(max_length=200)
    slug = models.SlugField(unique_for_date='pub_date')
    body_html = models.TextField(blank=True)
    body_markdown = models.TextField()
    dek = models.TextField(null=True, blank=True)
    pub_date = models.DateTimeField('Date published')
    enable_comments = models.BooleanField(default=False)
    point = models.PointField(null=True, blank=True)
    location = models.ForeignKey(Location, null=True, blank=True)
    PUB_STATUS = (
        (0, 'Draft'),
        (1, 'Published'),
    )
    status = models.IntegerField(choices=PUB_STATUS, default=0)
    photo_gallery = models.ForeignKey(PhotoGallery, blank=True, null=True, verbose_name='photo set')
    image = models.FileField(upload_to=get_upload_path, null=True, blank=True, help_text="should be 520 by 290")
    thumbnail = models.FileField(upload_to=get_tn_path, null=True, blank=True, help_text="should be 160 wide")
    meta_description = models.CharField(max_length=256, null=True, blank=True)
    TEMPLATES = (
        (0, 'single'),
        (1, 'double'),
        (2, 'single-dark'),
        (3, 'double-dark'),
        (4, 'single-black'),
        (5, 'double-black'),
    )
    template_name = models.IntegerField(choices=TEMPLATES, default=0)
    featured_image = models.ForeignKey(LuxImage, null=True, blank=True)
    has_video = models.BooleanField(blank=True, default=False)

    class Meta:
        ordering = ('-pub_date',)
        get_latest_by = 'pub_date'
        verbose_name_plural = 'entries'

    def __str__(self):
        return self.title

    def get_absolute_url(self):
        # return "/jrnl/%s/%s" % (self.pub_date.strftime("%Y/%m").lower(), self.slug)
        return reverse("jrnl:detail", kwargs={"year": self.pub_date.year, "month": self.pub_date.strftime("%m"), "slug": self.slug})

    def get_absolute_url_old(self):
        return "/%s/%s/" % (self.pub_date.strftime("%Y/%b/%d").lower(), self.slug)

    def comment_period_open(self):
        return self.enable_comments and datetime.datetime.today() - datetime.timedelta(30) <= self.pub_date

    def get_thumbnail_url(self):
        image_dir, img = self.thumbnail.url.split('post-thumbnail/')[1].split('/')
        return '%spost-thumbnail/%s/%s' % (settings.IMAGES_URL, image_dir, img)

    def get_image_url(self):
        image_dir, img = self.image.url.split('post-images/')[1].split('/')
        return '%spost-images/%s/%s' % (settings.IMAGES_URL, image_dir, img)

    def get_image_wide_url(self):
        img = self.image.url.split('post-images/')[1].split('/')[1]
        # return '%shome-images/%s' % (settings.IMAGES_URL, img)
        return '%shome-images/%s' % (settings.IMAGES_URL, img)

    def get_image_hero_url(self):
        img = self.image.url.split('post-images/')[1].split('/')[1]
        return '/media/images/home-images/hero%s' % (img)

    def get_image_hero_url_sm(self):
        img = self.image.url.split('post-images/')[1].split('/')[1]
        img = os.path.splitext(img)[0]
        return '/media/images/home-images/hero%s_sm.jpg' % (img)

    def get_images(self):
        return extract_images(self.body_html)

    @property
    def state(self):
        return self.location.state

    @property
    def country(self):
        return self.location.state.country

    @property
    def region(self):
        return self.location.state.country.lux_region

    @property
    def longitude(self):
        '''Get the site's longitude.'''
        return self.point.x

    @property
    def latitude(self):
        '''Get the site's latitude.'''
        return self.point.y

    @property
    def get_previous_published(self):
        return self.get_previous_by_pub_date(status__exact=1)
    
    @property
    def get_previous_admin_url(self):
        n = self.get_previous_by_pub_date()
        return "/admin/jrnl/entry/%s/change/" % n.pk


    @property
    def get_next_published(self):
        return self.get_next_by_pub_date(status__exact=1)

    @property
    def get_next_admin_url(self):
        n = self.get_next_by_pub_date()
        return "/admin/jrnl/entry/%s/change/" % n.pk

    def save(self):
        if self.pk:
            md = render_images(self.body_markdown)
            self.body_html = markdown_to_html(md)
        self.has_video = parse_video(self.body_html)
        try:
            self.location = Location.objects.filter(geometry__contains=self.point).get()
        except Location.DoesNotExist:
            raise forms.ValidationError("There is no location associated with that point, add it:  %sadmin/locations/location/add/" % (settings.BASE_URL))

        super(Entry, self).save()



class HomepageCurrator(models.Model):
    image_offset_vertical = models.CharField(max_length=20, help_text="add negative top margin to shift image (include css unit)")
    images = models.ManyToManyField(LuxImage)
    tag_line = models.CharField(max_length=200)
    featured = models.ForeignKey(Entry, related_name="banner")
    popular = models.ManyToManyField(Entry)
    template_name = models.CharField(max_length=200, help_text="full path")


class BlogSitemap(Sitemap):
    changefreq = "never"
    priority = 1.0
    protocol = "https"

    def items(self):
        return Entry.objects.filter(status=1)

    def lastmod(self, obj):
        return obj.pub_date


import urllib.request
import urllib.parse
import urllib.error
from django_gravatar.helpers import get_gravatar_url, has_gravatar, calculate_gravatar_hash
from django.dispatch import receiver
from django_comments.signals import comment_was_posted
from django_comments.models import Comment
from django_comments.moderation import CommentModerator, moderator


class EntryModerator(CommentModerator):
    '''
    Moderate everything except people with multiple approvals
    '''
    email_notification = True

    def moderate(self, comment, content_object, request):
        previous_approvals = Comment.objects.filter(user_email=comment.email, is_public=True)
        for approval in previous_approvals:
            if approval.submit_date <= datetime.datetime.today() - datetime.timedelta(21):
                approve = True
        if previous_approvals.count() > 2 and approve:
            return False
            # do entry build right here so it goes to live site
        return True

moderator.register(Entry, EntryModerator)

# from django_comments.signals import comment_will_be_posted
# from django_comments import akismet


# @receiver(comment_will_be_posted, sender=Comment)
# def spam_check(sender, comment, request, **kwargs):
#     akismet.USERAGENT = "David Lynch's Python library/1.0"
#     try:
#         real_key = akismet.verify_key(settings.AKISMET_KEY, "https://luxagraf.net/")
#         if real_key:
#             is_spam = akismet.comment_check(settings.AKISMET_KEY, "https://luxagraf.net/", request.META['REMOTE_ADDR'], request.META['HTTP_USER_AGENT'], comment_content=comment.comment)
#             if is_spam:
#                 return False
#             else:
#                 return True
#     except akismet.AkismetError as e:
#         print('Something went wrong, allowing comment')
#         print(e.response, e.statuscode)
#         return True


@receiver(comment_was_posted, sender=Comment)
def cache_gravatar(sender, comment, **kwargs):
    gravatar_exists = has_gravatar(comment.email)
    grav_dir = settings.IMAGES_ROOT + '/gravcache/'
    if gravatar_exists:
        url = get_gravatar_url(comment.email, size=60)
        if not os.path.isdir(grav_dir):
            os.makedirs(grav_dir)
        local_grav = '%s/%s.jpg' % (grav_dir, calculate_gravatar_hash(comment.email))
        urllib.request.urlretrieve(url, local_grav)