root/trunk/blog/receivers.py

# vim: encoding=utf-8 :

import httplib
import re
import urllib
import urlparse
from threading import Thread
import xmlrpclib

from django.conf import settings
from django.contrib.sitemaps import ping_google
from django.contrib.sites.models import Site
from django.core.mail import mail_admins
from django.template import loader, Context
from django.utils.translation import ugettext as _
from django.template.defaultfilters import striptags
from markup.templatetags.markup import restructuredtext as rest

try:
    import twitter
    has_twitter = True
except ImportError:
    has_twitter = False

URL_PATTERN = re.compile(r'https?://[-_0-9a-zA-Z./?&;]+')


def run_ping_google():
    """
    send google ping.
    """
    try:
        ping_google('/sitemap.xml')
    except Exception, e:
        #mail_admins(_(u'[Google Sitemap] Caught exception.'), str(e))
        pass


def run_post_twitter(url):
    """
    post to twitter.
    """
    try:
        username = getattr(settings, 'TWITTER_USERNAME', None)
        password = getattr(settings, 'TWITTER_PASSWORD', None)
        api = twitter.Api(username=username, password=password)
        api.PostUpdate(_(u'Updated my blog!\n%s') % url)
    except Exception, e:
        #mail_admins(_(u'[Twitter] Caught exception.'), str(e))
        pass


def run_update_ping(server, title, url):
    """
    send update ping.
    """
    try:
        server.weblogUpdates.ping(title, url)
    except:
        pass


class TrackBackPingThread(Thread):
    """
    send track back ping.
    """
    def __init__(self, target, url, blog_name, title, excerpt):
        self.target = target
        self.url = url
        self.blog_name = blog_name
        self.title = title
        self.excerpt = excerpt
        super(TrackBackPingThread, self).__init__()

    def run(self):
        trackback_url = self.get_trackback_url()
        if trackback_url is None:
            return None
        params = urllib.urlencode({
            'url': self.url,
            'blog_name': self.blog_name,
            'title': self.title,
            'excerpt': self.excerpt,
        })
        headers = ({
            'Content-type': 'application/x-www-form-urlencoded',
        })
        parsed = urlparse.urlparse(trackback_url)
        host, path = parsed[1:3]
        conn = httplib.HTTPConnection(host)
        conn.request("POST", path, params, headers)
        conn.getresponse()
        conn.close()

    def get_trackback_url(self):
        parsed = urlparse.urlparse(self.target)
        host, path = parsed[1:3]
        try:
            conn = httplib.HTTPConnection(host)
            conn.request("GET", path)
            res = conn.getresponse().read()
        except:
            return None
        ptn1 = r'trackback:ping="(https?://%s.*?)"' % host
        if not path.endswith('/'):
            path += '/'
        ptn2 = r'(https?://%s%strackback/?)' % (host, path)
        for p in (ptn1, ptn2):
            try:
                return re.search(p, res).group(1)
            except:
                pass


def post_save_entry(instance, created, raw, **kwargs):
    """
    blog.models.Entry post save hook.
    """
    if settings.DEBUG or raw or not hasattr(instance, 'published_now'):
        return
    current_site = Site.objects.get_current()
    site_name = current_site.name
    site_url = u'http://%s/' % current_site.domain
    detail_url = u'http://%(domain)s%(path)s' % {
        'domain': current_site.domain,
        'path': instance.get_absolute_url(),
    }

    #   send google webmaster.
    Thread(target=run_ping_google).start()
    #   send twitter.
    if has_twitter:
        Thread(target=run_post_twitter, args=[detail_url]).start()
    #   send update ping.
    xmlrpclib.Transport.user_agent = current_site.domain
    from blog.models import PingServer
    for ping in PingServer.objects.filter(is_active__exact=True):
        server = xmlrpclib.Server(ping.get_absolute_url())
        Thread(target=run_update_ping, args=[server, site_name, site_url]).start()
    target_list = URL_PATTERN.findall(instance.description)
    if not len(target_list):
        return
    #   send track back ping
    blog_name = site_name.encode('utf-8')
    title = instance.title.encode('utf-8')
    excerpt = striptags(rest(instance.description))[:200].encode('utf-8')
    for target in target_list:
        TrackBackPingThread(target=target, url=detail_url, blog_name=blog_name,
                            title=title, excerpt=excerpt).start()


def post_save_comment(instance, created, raw, **kwargs):
    """
    blog.models.Comment post save hook.
    """
    #   increment parent comments count if created.
    if created:
        instance.entry.comments_count += 1
        instance.entry.save_base()

    #   nothing to do if raw save or updated.
    if raw or not created:
        return

    #   send mail to admins.
    c = Context({
        'obj': instance,
        'site': Site.objects.get_current(),
    })
    t = loader.get_template('blog/add_comment_mail.txt')
    mail_admins(_(u'new comment has been added.'), t.render(c))


def pre_delete_comment(instance):
    """
    blog.models.Comment pre delete hook.
    """
    entry = instance.entry
    if entry.comments_count > 0:
        entry.comments_count -= 1
        entry.save_base()


def post_save_trackback(instance, created, raw, **kwargs):
    """
    blog.models.TrackBack post save hook.
    """
    #   increment parent comments count if created.
    if created:
        instance.entry.trackbacks_count += 1
        instance.entry.save_base()

    #   nothing to do if raw save or updated.
    if raw or not created:
        return

    #   send mail to admins.
    c = Context({
        'obj': instance,
        'site': Site.objects.get_current(),
    })
    t = loader.get_template('blog/add_trackback_mail.txt')
    mail_admins(_(u'new track back has been added.'), t.render(c))


def pre_delete_trackback(instance):
    """
    blog.models.Comment pre delete hook.
    """
    entry = instance.entry
    if entry.trackbacks_count > 0:
        entry.trackbacks_count -= 1
        entry.save_base()