Produits Entr'ouvert » Corbo

import os

import io

import hashlib

from time import mktime

from datetime import datetime

import logging

import urlparse

from html2text import HTML2Text

from emails.django import Message

from lxml import etree

import requests

import feedparser

from django.utils import timezone

from django.conf import settings

from django.db import models

from django.core.files.storage import DefaultStorage

from django.utils.translation import ugettext_lazy as _

from django.core import signing

from django.template import loader, Context

from django.core.urlresolvers import reverse

from django.utils.translation import activate

from ckeditor.fields import RichTextField

channel_choices = (

    ('mailto', _('Email')),

)

UNSUBSCRIBE_LINK_PLACEHOLDER = '##UNSUBSCRIBE_LINK_PLACEHOLDER##'

logger = logging.getLogger(__name__)

def transform_image_src(src, **kwargs):

    basename = os.path.basename(src)

    if basename == src:

        return src

    name, ext = os.path.splitext(src)

    hash = hashlib.sha256(name)

    return '%s_%s%s' % (os.path.basename(name), hash.hexdigest()[:8], ext)

class Category(models.Model):

    name = models.CharField(_('Name'), max_length=64, blank=False, null=False)

    rss_feed_url = models.URLField(_('Feed URL'), blank=True, null=True,

                help_text=_('if defined, announces will be automatically created from rss items'))

    ctime = models.DateTimeField(auto_now_add=True)

    def __unicode__(self):

        return self.name

    def get_announces_count(self):

        return self.announce_set.all().count()

    def get_subscriptions_count(self):

        return self.subscription_set.all().count()

    def save(self, *args, **kwargs):

        super(Category, self).save(*args, **kwargs)

        if not self.rss_feed_url:

            return

        feed_response = requests.get(self.rss_feed_url)

        if feed_response.ok:

            content = feedparser.parse(feed_response.content)

            for entry in content.get('entries', []):

                published = datetime.fromtimestamp(mktime(entry.published_parsed))

                html_tree = etree.HTML(entry['summary'])

                storage = DefaultStorage()

                for img in html_tree.xpath('//img'):

                    image_name = os.path.basename(img.attrib['src'])

                    r = requests.get(img.attrib['src'])

                    new_content = r.content

                    if storage.exists(image_name):

                        old_content = storage.open(image_name).read()

                        old_hash = hashlib.md5(old_content).hexdigest()

                        new_hash = hashlib.md5(new_content).hexdigest()

                        img.attrib['src'] = storage.url(image_name)

                        if new_hash == old_hash:

                            continue

                    new_image_name = storage.save(image_name, io.BytesIO(new_content))

                    img.attrib['src'] = storage.url(new_image_name)

                announce, created = Announce.objects.get_or_create(identifier=entry['id'],

                                                                   category=self)

                announce.title = entry['title']

                announce.text = etree.tostring(html_tree)

                announce.publication_time = published

                announce.save()

                if created:

                    Broadcast.objects.get_or_create(announce=announce)

class Announce(models.Model):

    category = models.ForeignKey('Category', verbose_name=_('category'))

    title = models.CharField(_('title'), max_length=256,

                             help_text=_('maximum 256 characters'))

    identifier = models.CharField(max_length=256, null=True, blank=True)

    text = RichTextField(_('Content'))

    publication_time = models.DateTimeField(_('publication time'), blank=True,

                                            null=True)

    expiration_time = models.DateTimeField(_('Expires on'), blank=True,

                                           null=True)

    ctime = models.DateTimeField(_('creation time'), auto_now_add=True)

    mtime = models.DateTimeField(_('modification time'), auto_now=True)

    def __unicode__(self):

        return u'{title} ({id}) at {mtime}'.format(

            title=self.title, id=self.id, mtime=self.mtime)

    def is_expired(self):

        if self.expiration_time:

            return self.expiration_time < timezone.now()

        return False

    def is_published(self):

        if self.publication_time:

            return self.publication_time <= timezone.now()

        return False

    class Meta:

        verbose_name = _('announce')

        ordering = ('-mtime',)

class Broadcast(models.Model):

    announce = models.ForeignKey(Announce, verbose_name=_('announce'))

    deliver_time = models.DateTimeField(_('Deliver time'), null=True)

    result = models.TextField(_('result'), blank=True)

    def __unicode__(self):

        if self.deliver_time:

            return u'announce {id} delivered via at {time}'.format(

                id=self.announce.id, time=self.deliver_time)

        return u'announce {id} to deliver'.format(id=self.announce.id)

    def send(self):

        subscriptions = self.announce.category.subscription_set.all()

        total_sent = 0

        handler = HTML2Text()

        activate(settings.LANGUAGE_CODE)

        template = loader.get_template('corbo/announce.html')

        message = Message(subject=self.announce.title, mail_from=settings.DEFAULT_FROM_EMAIL,

                          html=template.render(

                              Context({'content': self.announce.text,

                                      'unsubscribe_link_placeholder': UNSUBSCRIBE_LINK_PLACEHOLDER})))

        html_tree = etree.HTML(self.announce.text)

        storage = DefaultStorage()

        for img in html_tree.xpath('//img/@src'):

            img_path = img.lstrip(storage.base_url)

            message.attach(filename=transform_image_src(img), data=storage.open(img_path))

        message.transformer.apply_to_images(func=transform_image_src)

        # perform transformations in message html, like inline css parsing

        message.transformer.load_and_transform()

        # mark all attached images as inline

        message.transformer.make_all_images_inline()

        message.transformer.save()

        for s in subscriptions:

            if not s.identifier:

                continue

            unsubscribe_token = signing.dumps({'category': self.announce.category.pk,

                                               'identifier': s.identifier})

            unsubscribe_link = urlparse.urljoin(settings.SITE_BASE_URL, reverse(

                'unsubscribe', kwargs={'unsubscription_token': unsubscribe_token}))

            message.html = message.html.replace(UNSUBSCRIBE_LINK_PLACEHOLDER, unsubscribe_link)

            handler.body_width = 0

            message.text = handler.handle(message.html)

            sent = message.send(to=s.identifier)

            if sent:

                total_sent += 1

                logger.info('Announce "%s" sent to %s', self.announce.title, s.identifier)

            else:

                logger.warning('Error occured while sending announce "%s" to %s.',

                               self.announce.title, s.identifier)

        self.result = total_sent

        self.deliver_time = timezone.now()

        self.save()

    class Meta:

        verbose_name = _('sent')

        ordering = ('-deliver_time',)

class Subscription(models.Model):

    category = models.ForeignKey('Category', verbose_name=_('Category'))

    uuid = models.CharField(_('User identifier'), max_length=128, blank=True)

    identifier = models.CharField(_('identifier'), max_length=128, blank=True,

                                  help_text=_('ex.: mailto, ...'))

    def get_identifier_display(self):

        try:

            scheme, identifier = self.identifier.split(':')

            return identifier

        except ValueError:

            return self.identifier

    class Meta:

        unique_together = ('category', 'identifier', 'uuid')