blogmop.py - blogmop - blogging system with Apache Python Module

Source path: svn/ trunk/ lib/ blogmop.py

‹r52

r54

# -*- coding: utf-8 -*-

import calendar
import datetime
import fcntl
import os
import os.path
import sqlite3
import time
import urllib
import xmlrpclib
import HTMLParser

try:
    import mod_python.apache
except ImportError:
    pass

def start_db(db_path):
    sqls = (
        '''CREATE TABLE entries
           (eid INTEGER PRIMARY KEY CHECK(eid > 0),
            year INTEGER CHECK(year > 1976),
            month INTEGER CHECK(month BETWEEN 1 AND 12),
            day INTEGER CHECK(day BETWEEN 1 AND 31),
            hour INTEGER CHECK(hour BETWEEN 0 AND 23),
            minute INTEGER CHECK(minute BETWEEN 0 AND 59),
            title TEXT, subtitle TEXT, body TEXT, extend TEXT,
            ymdhm INTEGER);''',
        '''CREATE TABLE tags
           (eid INTEGER CHECK(eid > 0), name TEXT, ymdhm INTEGER);''',
        '''CREATE TABLE comments
           (eid INTEGER CHECK(eid > 0), author TEXT, title TEXT, body TEXT,
            visible INTEGER,
            year INTEGER CHECK(year > 0),
            month INTEGER CHECK(month BETWEEN 1 AND 12),
            day INTEGER CHECK(day BETWEEN 1 AND 31),
            hour INTEGER CHECK(hour BETWEEN 0 AND 23),
            minute INTEGER CHECK(minute BETWEEN 0 AND 59),
            ymdhm INTEGER);''',
    )

    if not os.path.exists(db_path):
        db = sqlite3.connect(db_path)
        for sql in sqls:
            db.execute(sql)
        db.commit()
        db.close()

        os.chmod(db_path, 0666)
        os.chmod(os.path.dirname(db_path), 0777)


def update_entry(db_path, eid, column, val):
    if column in ('eid', 'year', 'month', 'day', 'hour', 'minute', 'ymdhm',
                  'title', 'subtitle', 'body', 'extend'):
        sql = 'UPDATE entries SET %s = ? WHERE eid = ?;' % column

        db = sqlite3.connect(db_path)
        db.execute(sql, (val, eid))
        db.commit()
        db.close()

def update_tagname(db_path, org_name, new_name):
    sql = 'UPDATE tags SET name = ? WHERE name = ?;'

    db = sqlite3.connect(db_path)
    db.execute(sql, (new_name, org_name))
    db.commit()
    db.close()

def update_tags(db_path, eid, tags, ymdhm):
    dsql = 'DELETE FROM tags WHERE eid = ?;'
    isql = 'INSERT INTO tags VALUES (?, ?, ?)'

    db = sqlite3.connect(db_path)
    db.execute(dsql, (eid,))
    for tag in tags:
        db.execute(isql, (eid, tag, ymdhm))
    db.commit()
    db.close()

def update_comment(db_path, cid, column, val):
    if column in ('eid', 'year', 'month', 'day', 'hour', 'minute', 'ymdhm',
                  'author', 'title', 'body', 'visible'):
        sql = 'UPDATE comments SET %s = ? WHERE rowid = ?;' % column

        db = sqlite3.connect(db_path)
        db.execute(sql, (val, cid))
        db.commit()
        db.close()

def delete_entry(db_path, eid):
    sqls = ('DELETE FROM entries WHERE eid = ?;',
            'DELETE FROM comments WHERE eid = ?;',
            'DELETE FROM tags WHERE eid = ?;')

    db = sqlite3.connect(db_path)
    for sql in sqls:
        db.execute(sql, (eid,))
    db.commit()
    db.close()

def delete_comment(db_path, cid):
    sql = 'DELETE FROM comments WHERE rowid = ?;'

    db = sqlite3.connect(db_path)
    db.execute(sql, (cid,))
    db.commit()
    db.close()

def all_tags_option(conf):
    sql = 'SELECT name FROM tags GROUP BY name ORDER BY name;'
    OPTION = u'<option value="%s">%s</option>'

    db = sqlite3.connect(conf['db_path'])
    rows = db.execute(sql).fetchall()
    db.close()

    return u''.join([OPTION % (row[0], row[0]) for row in rows])

def _symdhm(year, month, day, hour, minute):
    return u'%04d%02d%02d%02d%02d' % (year, month, day, hour, minute)

def _iymdhm(year, month, day, hour, minute):
    return int(_symdhm(year, month, day, hour, minute))

def entry_row(db_path, eid):
    sql = '''SELECT eid, year, month, day, hour, minute,
                    title, subtitle, body, extend, ymdhm
             FROM entries
             WHERE eid = ?;'''

    db = sqlite3.connect(db_path)
    row = db.execute(sql, (eid,)).fetchone()
    db.close()

    return row

def comment_row(db_path, cid):
    sql = '''SELECT eid, year, month, day, hour, minute, ymdhm, 
                    author, title, body, visible
             FROM comments WHERE rowid = ?;'''

    db = sqlite3.connect(db_path)
    row = db.execute(sql, (cid,)).fetchone()
    db.close()

    return row

def tags_list(db_path, eid):
    sql = 'SELECT name FROM tags WHERE eid = ?;'

    db = sqlite3.connect(db_path)
    rows = db.execute(sql, (eid,)).fetchall()
    db.close()

    tags = [row[0] for row in rows]
    tags.sort()

    return tags

def get_entry(conf, eid, with_full = False):
    blog_root = conf['blog_root']
    row = entry_row(conf['db_path'], eid)

    if row:
        e = Entry(*row[:-1])
        e.tags = tags_list(conf['db_path'], eid)

        db = sqlite3.connect(conf['db_path'])
        e._set_comments(db)
        if with_full:
            e._set_prev(db)
            e._set_next(db)
            e._set_form()
        db.close()
    else:
        e = None

    return e

def get_conf(req):
    conf = req.get_options()
    conf['host_name'] = req.server.server_hostname
    conf['blog_root'] = conf['blog_root'].strip('/')
    conf['canonical'] = ''

    return conf

def get_cache(conf, cache_path):
    db_path = conf['db_path']
    blog_root = conf['blog_root']
    cache_full_path = os.path.normpath('/tmp/%(blog_root)s/%(cache_path)s' \
                                           % locals())

    if os.path.basename(db_path) == os.path.basename(cache_path) \
            or not os.path.exists(cache_full_path) \
            or os.path.getmtime(db_path) > os.path.getmtime(cache_full_path):
        return None
    else:
        f = open(cache_full_path)
        fcntl.lockf(f, fcntl.LOCK_SH)
        p = f.read()
        fcntl.lockf(f, fcntl.LOCK_UN)
        f.close()

        return p

def save_cache(conf, cache_path, content):
    blog_root = conf['blog_root']
    cache_full_path = os.path.normpath('/tmp/%(blog_root)s/%(cache_path)s' \
                                           % locals())

    if os.path.basename(conf['db_path']) == os.path.basename(cache_path):
        pass
    else:
        dname = os.path.dirname(cache_full_path)
        if not os.path.exists(dname):
            os.makedirs(dname)

        f = open(cache_full_path, 'w')
        fcntl.lockf(f, fcntl.LOCK_EX)
        f.write(content)
        fcntl.lockf(f, fcntl.LOCK_UN)
        f.close()

def _read_addon(addon_dir, name, codec = 'utf-8'):
    addon_path = '%(addon_dir)s/%(name)s.addon' % locals()
    if os.path.exists(addon_path):
        f = open(addon_path)
        p = unicode(f.read(), codec, 'ignore')
        f.close()
    else:
        p = u''

    return p

def _template_html(conf, etitle):
    HTML = u'''<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="%(lang)s" xmlns="http://www.w3.org/1999/xhtml" xml:lang="%(lang)s">
<head>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
  <meta http-equiv="content-script-type" content="text/javascript" />
  <meta http-equiv="content-style-type" content="text/css" />
  <meta name="author" content="%(author)s" />
  <meta name="description" content="%(introduction)s" />
  <meta name="generator" content="blogmop : Blog on Mod Python" />
  <link rel="alternate" type="application/rss+xml" title="RSS" href="http://%(host_name)s/%(blog_root)s/rss" />
  <link rel="alternate" type="text/html" media="handheld" href="http://%(host_name)s/%(blog_root)s/m/" />
  <link rel="index" href="/%(blog_root)s/" />
  <link rel="canonical" href="http://%(host_name)s/%(blog_root)s/%(canonical)s" />
  <link rel="stylesheet" href="/%(blog_root)s/css/screen.css" />
  <link rel="shortcut icon" href="/%(blog_root)s/image/favicon.ico" />
  <link rel="icon" href="/%(blog_root)s/image/favicon.ico" type="image/vnd.microsoft.icon" />
  <title>%(page_title)s</title>
  <script type="text/javascript">var blog_root = "/%(blog_root)s";</script>
</head>
<body>
  <div id="header">
    <h1><a href="/%(blog_root)s/"><span></span>%(blog_title)s</a></h1>
    <div id="introduction">%(introduction)s</div>
  </div>
  <div id="content">
    <div id="main">\
__MAIN__
      <div id="footer">
        <div>
          <span>Powered by <a href="http://code.google.com/p/blogmop/" target="_blank">blogmop</a></span>
        </div>
      </div>
    </div>
    <div id="sub">\
__SUB__
    </div>
  </div>
%(tracker)s
  <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.4.2/jquery.min.js"></script>
  <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jqueryui/1.8.0/jquery-ui.min.js"></script>
  <script type="text/javascript" src="/%(blog_root)s/js/jquery.cookie.js"></script>
  <script type="text/javascript" src="/%(blog_root)s/js/blogmop.js"></script>
</body>
</html>
'''
    lang = conf['lang']
    if etitle:
        page_title = conf['blog_title'] + u' : ' + etitle
    else:
        page_title = conf['blog_title']
    author = conf['author']
    host_name = conf['host_name']
    blog_root = conf['blog_root']
    canonical = conf['canonical']
    blog_title = conf['blog_title']
    introduction = conf.get('introduction', u'')
    tracker = _read_addon(conf['addon_dir'], 'tracker')

    html = HTML % locals()
    html = html.replace(u'__SUB__', _get_sub(conf))

    return html

def _template_mobile_html(conf, etitle):
    HTML = u'''<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html lang="%(lang)s" xmlns="http://www.w3.org/1999/xhtml" xml:lang="%(lang)s">
<head>
  <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
  <meta name="HandheldFriendly" content="true" />
  <meta name="viewport" content="width=device-width; initial-scale=1.0; maximum-scale=1.0; user-scalable=0;" />
  <meta http-equiv="content-style-type" content="text/css" />
  <meta name="author" content="%(author)s" />
  <meta name="description" content="%(introduction)s" />
  <meta name="generator" content="blogmop : Blog on Mod Python" />
  <link rel="index" href="/%(blog_root)s/m/" />
  <link rel="canonical" href="http://%(host_name)s/%(blog_root)s/m/%(canonical)s" />
  <link rel="stylesheet" href="/%(blog_root)s/css/handheld.css" />
  <link rel="shortcut icon" href="/%(blog_root)s/image/favicon.ico" />
  <link rel="icon" href="/%(blog_root)s/image/favicon.ico" type="image/vnd.microsoft.icon" />
  <title>%(page_title)s</title>
</head>
<body>
  <div id="header">
    <h1><a href="/%(blog_root)s/m/">
     <img src="/%(blog_root)s/image/logo.jpg" alt="%(blog_title)s" />
    </a></h1>
    <div id="introduction">%(introduction)s</div>
  </div>
  <div id="content">
    <div id="main">\
__MAIN__
    </div>
  <div id="footer">
    <span>Powered by <a href="http://code.google.com/p/blogmop/" target="_blank">blogmop</a></span>
  </div>
</body>
</html>
'''
    lang = conf['lang']
    if etitle:
        page_title = conf['blog_title'] + u' : ' + etitle
    else:
        page_title = conf['blog_title']
    author = conf['author']
    host_name = conf['host_name']
    blog_root = conf['blog_root']
    canonical = conf['canonical']
    blog_title = conf['blog_title']
    introduction = conf.get('introduction', u'')

    html = HTML % locals()

    return html

def template_html(conf, etitle = None, for_mobile = False):
    if for_mobile:
        return _template_mobile_html(conf, etitle)
    else:
        return _template_html(conf, etitle)

def template_rss(conf):
    RSS = u'''<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0"
 xmlns:dc="http://purl.org/dc/elements/1.1/"
 xmlns:atom="http://www.w3.org/2005/Atom"
 xmlns:xhtml="http://www.w3.org/1999/xhtml">
 <channel>
  <title>%(blog_title)s</title>
  <link>http://%(host_name)s/%(blog_root)s/</link>
  <description>%(introduction)s</description>
  <language>%(lang)s</language>
  <docs>http://blogs.law.harvard.edu/tech/rss</docs>
  <generator>blogmop : Blog on Mod Python</generator>
  <xhtml:link rel="alternate" media="handheld" type="text/html"
   href="http://%(host_name)s/%(blog_root)s/m/" />
  <atom:link rel="hub" href="http://pubsubhubbub.appspot.com" />
  <atom:link rel="self" type="application/rss+xml"
   href="http://%(host_name)s/%(blog_root)s/rss" />\
__ITEMS__
 </channel>
</rss>
'''
    blog_title = conf['blog_title']
    host_name = conf['host_name']
    blog_root = conf['blog_root']
    lang = conf['lang']
    introduction = conf['introduction']

    rss = RSS % locals()

    return rss

def month_abbr(num):
    return calendar.month_abbr[num]

def recent_eid_titles(db_path, counts):
    sql = 'SELECT eid, title FROM entries ORDER BY ymdhm DESC LIMIT ?;'

    if db_path:
        db = sqlite3.connect(db_path)
        rows = db.execute(sql, (counts,)).fetchall()
        db.close()
    else:
        rows = []

    return rows

def recent_comments(db_path, counts):
    sql = '''SELECT eid, rowid, 0, author, title, body,
                    year, month, day, hour, minute
             FROM comments WHERE visible = 1 ORDER BY ymdhm DESC LIMIT ?;'''

    o = []

    if db_path:
        db = sqlite3.connect(db_path)
        rows = db.execute(sql, (counts,)).fetchall()
        db.close()

        for row in rows:
            c = Comment(*row[:6])
            c.year, c.month, c.day, c.hour, c.minute = row[6:]
            o.append(c)

    return o

def ymd_entry_ids(db_path, year, month, day):
    SEL_YMD_ENTRY_IDS = '''SELECT eid FROM entries 
                           WHERE year = ? AND month = ? AND day = ?
                           ORDER BY ymdhm DESC;'''
    db = sqlite3.connect(db_path)
    rows = db.execute(SEL_YMD_ENTRY_IDS, (year, month, day)).fetchall()
    db.close()

    return [row[0] for row in rows]

def ym_entry_ids(db_path, year, month, limit, offset):
    SEL_YM_ENTRY_IDS = '''SELECT eid FROM entries
                          WHERE year = ? AND month = ? ORDER BY ymdhm DESC
                          LIMIT ? OFFSET ?;'''
    db = sqlite3.connect(db_path)
    rows = db.execute(SEL_YM_ENTRY_IDS, (year, month, limit, offset)).fetchall()
    db.close()

    return [row[0] for row in rows]

def tag_entry_ids(db_path, name, limit, offset):
    SEL_TAG_ENTRY_IDS = '''SELECT eid FROM tags
                           WHERE name = ? ORDER BY ymdhm DESC
                           LIMIT ? OFFSET ?;'''

    db = sqlite3.connect(db_path)
    rows = db.execute(SEL_TAG_ENTRY_IDS, (name, limit, offset)).fetchall()
    db.close()

    return [row[0] for row in rows]

def cal_table(conf, y = '', m = ''):
    cal = MyHTMLCalendar(conf)
    try:
        year, month = int(y), int(m)
        table = cal.formatmonth(conf, year, month)
    except:
        today = datetime.date.today()
        year, month = today.year, today.month
        table = cal.formatmonth(conf['db_path'], year, month)

    return table

def valid_page_num(p):
    if p.isdigit():
        p = int(p)
        if p > 0:
            return p
    else:
        return 1

def get_paging(len_eids, limit, page):
    if len_eids > limit:
        opage = page + 1
        older = u'&laquo; <a href="./%(opage)d">Older</a>' % locals()
    else:
        older = u'<span class="disabled">Older</span>'

    if page == 1:
        newer = u'<span class="disabled">Newer</span>'
    elif page == 2:
        newer = u'<a href="./">Newer</a> &raquo;' % locals()
    else:
        npage = page - 1
        newer = u'<a href="./%(npage)d">Newer</a> &raquo;' % locals()

    paging = u'<div class="paging"><span class="older">' + older + u'</span>'\
        + '<span class="newer">' + newer +'</span></div>'

    return paging

def format_day(day):
    _ext = {1: 'st', 2: 'nd', 3: 'rd', 21: 'st', 22: 'nd', 23: 'rd', 31: 'st'}
    if _ext.has_key(day):
        return u'%d%s' % (day, _ext[day])
    else:
        return u'%dth' % day

def _recent_entries_ul(conf):
    LI = u'<li><a href="/%(blog_root)s/%(eid)d">%(etitle)s</a></li>'

    blog_root = conf['blog_root']
    eid_titles = recent_eid_titles(conf['db_path'], conf['sub_li_counts'])
    if eid_titles:
        lis = [LI % locals() for eid, etitle in eid_titles]
    else:
        lis = [u'No entries yet.']

    return u'<ul>%s</ul>' % u''.join(lis)

def _recent_comments_ul(conf):
    LI = u'<li><a href="/%(blog_root)s/%(eid)d#c%(cid)d" title="%(year)04d %(month_str)s %(day_str)s %(hour)02d:%(minute)02d">%(title)s by %(author)s</a></li>'

    blog_root = conf['blog_root']
    r_comments = recent_comments(conf['db_path'], int(conf['sub_li_counts']))
    if r_comments:
        lis = []
        for c in r_comments:
            eid, cid, title, author = c.eid, c.cid, c.title, c.author
            year, hour, minute = c.year, c.hour, c.minute
            month_str = month_abbr(c.month)
            day_str = format_day(c.day)
            lis.append(LI % locals())
    else:
        lis = [u'No comments yet.']

    return u'<ul>%s</ul>' % u''.join(lis)

def _tags_ul(conf):
    sql = '''SELECT name, cnt FROM (
              SELECT name, COUNT(*) as cnt FROM tags
              GROUP BY name ORDER BY COUNT(*) DESC LIMIT ?
             ) ORDER BY name;'''
    LI = (u'<li><a href="/%(blog_root)s/tag/%(qtag)s/" rel="tag"'
          u' title="%(tag)s (%(tag_count)d)">'
          u'<span>%(tag)s<em>%(tag_count)d</em></span>'
          u'</a></li>')
    EXPANDER = (u'<li class="expander">'
                u'<a href="javascript:expand_all_tags();" title="All Tags">'
                u'<span>&nbsp;<em>All Tags ...</em></span></a></li>')

    lis = []
    if conf['db_path']:
        db = sqlite3.connect(conf['db_path'])
        rows = db.execute(sql, (conf['sub_li_counts'],)).fetchall()
        db.close()

        blog_root = conf['blog_root']
        for tag, tag_count in rows:
            qtag = urllib.quote_plus(tag.encode('utf-8'))
            lis.append(LI % locals())
        lis.append(EXPANDER)
        
    if not lis:
        lis = [u'No tags yet.']

    return u'<ul>%s</ul>' % u'\n'.join(lis)

def all_tags_ul(conf):
    sql = 'SELECT name, COUNT(*) FROM tags GROUP BY name ORDER BY name;'
    LI = (u'<li><a href="/%(blog_root)s/tag/%(qtag)s/" rel="tag"'
          u' title="%(tag)s (%(tag_count)d)">'
          u'<span>%(tag)s<em>%(tag_count)d</em></span>'
          u'</a></li>')

    lis = []
    db = sqlite3.connect(conf['db_path'])
    rows = db.execute(sql).fetchall()
    db.close()

    blog_root = conf['blog_root']
    for tag, tag_count in rows:
        qtag = urllib.quote_plus(tag.encode('utf-8'))
        lis.append(LI % locals())
        
    return u'<ul class="tag_list">%s</ul>' % u'\n'.join(lis)

def all_tags_div(conf):
    sql = 'SELECT name, COUNT(*) FROM tags GROUP BY name ORDER BY name;'
    ANC = (u'<a href="/%(blog_root)s/tag/%(qtag)s/" rel="tag"'
           u' title="%(tag)s (%(tag_count)d)">'
           u'%(tag)s</a>')

    ancs = []
    db = sqlite3.connect(conf['db_path'])
    rows = db.execute(sql).fetchall()
    db.close()

    blog_root = conf['blog_root']
    for tag, tag_count in rows:
        qtag = urllib.quote_plus(tag.encode('utf-8'))
        ancs.append(ANC % locals())
        
    return u'<div class="tag_list">%s</div>' % u' | '.join(ancs)

def _archives_ul(db_path, blog_root):
    if db_path:
        sql = '''SELECT year, month, COUNT(*) FROM entries
                 GROUP BY year, month ORDER BY ymdhm;'''
        MONTH_LINK = u'''<a href="/%(blog_root)s/month/%(year)d-%(month)d/"\
 title="%(year)d-%(month)d (%(month_count)d)">%(month)d</a>'''
        LI = u'<li>%d:&nbsp;%s</li>'

        db = sqlite3.connect(db_path)
        rows = db.execute(sql).fetchall()
        db.close()

        ancs = {}
        for year, month, month_count in rows:
            if ancs.has_key(year):
                ancs[year].append(MONTH_LINK % locals())
            else:
                ancs[year] = [MONTH_LINK % locals()]

        lis = [LI % (year, u'&nbsp;'.join(ancs[year]))
               for year in sorted(ancs.keys())]
    else:
        lis = [u'No archives yet.']

    return u'<ul>%s</ul>' % u''.join(lis)

def _sub_content(block_title, block_id, block_content):
    SUB_BLOCK_DIV = u'''
      <div class="subBlock">
        <div class="title">%(block_title)s</div>
        <div id="%(block_id)s">%(block_content)s</div>
      </div>'''

    return SUB_BLOCK_DIV % locals()

def _get_sub(conf):
    blocks = []
    blocks.append(_sub_content(u'search', u'search_div',
                               u'<input id="search" type="search" />'))
    blocks.append(_sub_content(u'calendar', u'calendar', cal_table(conf)))
    blocks.append(_sub_content(u'recent entries', u'recentEntries',
                               _recent_entries_ul(conf)))
    blocks.append(_sub_content(u'recent comments', u'recentComments',
                               _recent_comments_ul(conf)))
    blocks.append(_sub_content(u'tags', u'allTags', _tags_ul(conf)))
    blocks.append(_sub_content(u'archives', u'archives',
                               _archives_ul(conf['db_path'], conf['blog_root'])))
    ## Additional
    blocks.append(_sub_content(u'photos on flickr', u'flickr', 
                               _read_addon(conf['addon_dir'], 'flickr')))
    blocks.append(_sub_content(u'bookmarks on delicious', u'delicious',
                               _read_addon(conf['addon_dir'], 'delicious')))
    
    return u''.join(blocks)

class MyHTMLCalendar(calendar.HTMLCalendar):
    def __init__(self, conf):
        super(MyHTMLCalendar, self).__init__(calendar.SUNDAY)
        self.db_path = conf['db_path']
        self.blog_root = conf['blog_root']

    def formatday(self, year, month, day, weekday):
        if day == 0 or self.db_path == '':
            return super(MyHTMLCalendar, self).formatday(day, weekday)

        SEL_DAY_ENTRY = '''SELECT title FROM entries
                           WHERE year = ? AND month = ? AND day = ?
                           ORDER BY ymdhm DESC'''
        db = sqlite3.connect(self.db_path)
        rows = db.execute(SEL_DAY_ENTRY, (year, month, day)).fetchall()
        db.close()

        if rows:
            blog_root, css_class = self.blog_root, self.cssclasses[weekday]
            titles = u',\n'.join((r[0] for r in rows))
            td = '''<td class="%(css_class)s">\
<a href="/%(blog_root)s/day/%(year)d-%(month)d-%(day)d" title="%(titles)s">\
%(day)d</a></td>''' % locals()
            return td
        else:
            return super(MyHTMLCalendar, self).formatday(day, weekday)

    def formatweek(self, year, month, theweek):
        s = ''.join(self.formatday(year, month, d, wd) for (d, wd) in theweek)
        return '<tr>%s</tr>' % s

    def formatmonthname(self, theyear, themonth):
        s = u'''<tr>\
<th><a href="javascript:cal_table(%(theyear)d,%(themonth)d, 'prev');" title="Previous Month">&lArr;</a></th>\
<th colspan="5" class="month">\
<a href="/%(blog_root)s/month/%(theyear)d-%(themonth)d/">%(smonth)s %(theyear)d</a>\
</th>\
<th><a href="javascript:cal_table(%(theyear)d,%(themonth)d, 'next');" title="Next Month">&rArr;</a></th>\
</tr>'''
        smonth = month_abbr(themonth)
        blog_root = self.blog_root

        return s % locals()

    def formatmonth(self, var, theyear, themonth):
        v = []
        a = v.append
        a('<table border="0" cellpadding="0" cellspacing="0" class="month">')
        a('\n')
        a(self.formatmonthname(theyear, themonth))
        a('\n')
        a(self.formatweekheader())
        a('\n')
        for week in self.monthdays2calendar(theyear, themonth):
            a(self.formatweek(theyear, themonth, week))
            a('\n')
        a('</table>')
        a('\n')

        return ''.join(v)

class MyHTMLParser(HTMLParser.HTMLParser):
    ok_tags = [u'a', u'b', u'blockquote', u'em', u'font', u'i', u'img', u'li',
               u'ol', u'pre', u'span', u'strike', u'strong', u'u', u'ul']
    ok_entrefs = {u'quot': u'"', u'amp': u'&', u'nbsp': u' ',
                  u'lt': u'<', u'gt': u'>'}

    def __init__(self):
        HTMLParser.HTMLParser.__init__(self)
        self._html = []
        self._plain = []

    def reset(self):
        HTMLParser.HTMLParser.reset(self)
        self._html = []
        self._plain = []

    def html(self, html = u''):
        if html:
            self.reset()
            self.feed(html)

        h = u''.join(self._html)
        return h.replace(u'\n', u'<br />')

    def plain(self, html = u''):
        if html:
            self.reset()
            self.feed(html)
        return u''.join(self._plain)

    def handle_starttag(self, tag, attr):
        if tag in self.ok_tags:
            self._html.append(u'<%s' % tag)

            for a, v in attr:
                if not v or \
                        v[0:2].lower() == u'on' or \
                        v[0:10].lower() == u'javascript': 
                    continue
                else:
                    self._html.append(u' %s="%s"' % (a, v))
            if tag == u'img':
                self._html.append(u' />')
            else:
                self._html.append(u'>')

    def handle_endtag(self, tag):
        if tag in self.ok_tags and tag != u'img':
            self._html.append(u'</%s>' % tag)

    def handle_data(self, data):
        if data:
            self._html.append(data)
            self._plain.append(data)

    def handle_entityref(self, name):
        if name in self.ok_entrefs:
            self._html.append(u'&%s;' % name)
            self._plain.append(self.ok_entrefs[name])

class Entry(object):
    def __init__(self, eid = u'',
                 year = 0, month = 0, day = 0, hour = 0, minute = 0,
                 title = u'', subtitle = u'', body = u'', extend = u'', 
                 tags = []):
        self.eid = eid
        self.year = year
        self.month = month
        self.day = day
        self.hour = hour
        self.minute = minute
        self.title = title if title else u'No Title'
        self.subtitle = subtitle
        self.body = body
        self.extend = extend
        self.tags = tags
        self.iymdhm = _iymdhm(self.year, self.month, self.day,
                              self.hour, self.minute)

    def _set_prev(self, db):
        sql = '''SELECT eid, title FROM entries
                 WHERE ymdhm < ? ORDER BY ymdhm DESC;'''

        row = db.execute(sql, (self.iymdhm,)).fetchone()
        if row:
            eid, etitle = row
            etitle = etitle if etitle else u'No Title'

            self.prev = u'<span class="older">&laquo; <a href="./%(eid)d">%(etitle)s</a></span>' % locals()
        else:
            self.prev = u''

    def _set_next(self, db):
        sql = 'SELECT eid, title FROM entries WHERE ymdhm > ? ORDER BY ymdhm;'

        row = db.execute(sql, (self.iymdhm,)).fetchone()
        if row:
            eid, etitle = row
            etitle = etitle if etitle else u'No Title'

            self.next = u'<span class="newer"><a href="./%(eid)d">%(etitle)s</a> &raquo;</span>' % locals()
        else:
            self.next = u''

    def _set_comments(self, db):
        sql = '''SELECT eid, rowid, 0, author, title, body,
                        year, month, day, hour, minute 
                 FROM comments WHERE eid = ? AND visible = 1 ORDER BY ymdhm;'''

        o = []
        for row in db.execute(sql, (self.eid,)).fetchall():
            c = Comment(*row[:6])
            c.year, c.month, c.day, c.hour, c.minute = row[6:]
            o.append(c)

        self.comments = [c.format_div() for c in o]

    def _set_form(self):
        self.form = u'''
          <div class="commentForm">
            <form id="comm_form" method="post">
              <fieldset id="comm_field">
                <legend>Leave a comment</legend>
                <div class="req">Required fields are marked with <em>*</em></div>
                <noscript>
                  <div class="req">Please turn JavaScript on to leave a comment.</div>
                </noscript>
                <div>
                  <label for="comm_author">Name <em>*</em></label>
                  <input type="text" size="50" id="comm_author" name="comm_author" />
                </div>
                <div>
                  <label for="comm_title">Title</label>
                  <input type="text" size="50" name="comm_title"
                   id="comm_title" />
                </div>
                <div>
                  <label for="comm_body">Comment  <em>*</em></label>
                  <textarea cols="50" rows="8" id="comm_body" name="comm_body"></textarea>
                </div>
                <div id="comm_append"><label>&nbsp;</label></div>
              </fieldset>
            </form>
          </div>'''

    def post(self, db_path):
        esql = 'INSERT INTO entries VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);'
        tsql = 'INSERT INTO tags VALUES (?, ?, ?);'

        _msg = ['[blogmop] : posting %s :' % self.eid]
        db = sqlite3.connect(db_path)
        try:
            db.execute(esql, (self.eid, self.year, self.month, self.day,
                              self.hour, self.minute,
                              self.title, self.subtitle, self.body, self.extend,
                              self.iymdhm))
            for tag in self.tags:
                db.execute(tsql, (self.eid, tag, self.iymdhm))
            db.commit()
        except sqlite3.IntegrityError, e:
            _msg.append(str(e))
            _lvl = mod_python.apache.APLOG_ERR
        else:
            _msg.append('Succeeded.')
            _lvl = mod_python.apache.APLOG_NOTICE
        db.close()
        mod_python.apache.log_error(' '.join(_msg), _lvl)

    def ping(self, blog_title, host_name, blog_root, ping_servers):
        blog_url = 'http://%(host_name)s/%(blog_root)s/' % locals()
        rss_url = 'http://%(host_name)s/%(blog_root)s/rss' % locals()

        for ping_server in ping_servers.split():
            _msg = ['[blogmop] : ping to %s :' % ping_server]
            try:
                s = xmlrpclib.ServerProxy(ping_server)
                s.weblogUpdates.ping(blog_title, blog_url, rss_url)
            except Exception, e:
                _msg.append(str(e))
                _lvl = mod_python.apache.APLOG_ERR
            else:
                _msg.append('Succeeded.')
                _lvl = mod_python.apache.APLOG_NOTICE
            mod_python.apache.log_error(' '.join(_msg), _lvl)

    def _tag_links(self, blog_root):
        o = []
        for tag in self.tags:
            qtag = urllib.quote_plus(tag.encode('utf-8'))
            o.append(u'<a href="/%(blog_root)s/tag/%(qtag)s/" rel="tag">%(tag)s</a>' % locals())

        return u' | '.join(o)

    def _format_div(self, conf, with_full):
        div = u'''
      <div class="entry">
        <div class="entryHeader">
          <div class="date">
            <span class="year">%(year)d</span>
            <span class="month">%(month_str)s</span>
            <span class="day">%(day_str)s</span>
          </div>
          <div class="entryTitle">
            <h2><a href="/%(blog_root)s/%(eid)d">%(etitle)s</a></h2>
            <h3>%(subtitle)s</h3>
          </div>
        </div>
        <div class="entryBody">
          <div class="body">%(body)s</div>
          <div class="extend">%(extend)s</div>
          <div class="tag">%(tag)s</div>
          <div class="posted">
            Posted by %(author)s at %(hour)02d:%(minute)02d |
            <a href="/%(blog_root)s/%(eid)d#comments">Comments: %(comm_count)d</a>
          </div>
%(neighbors)s\
%(entry_ad)s\
%(comments)s\
%(form)s\
        </div>
%(js)s\
      </div>'''

        eid, year, month, day, hour, minute = \
            self.eid, self.year, self.month, self.day, self.hour, self.minute
        etitle, subtitle, body, extend, = \
            self.title, self.subtitle, self.body, self.extend

        blog_root = conf['blog_root']

        month_str = month_abbr(month)
        day_str = format_day(day)
        author = conf['author']
        tag = self._tag_links(blog_root)
        comm_count = len(self.comments)

        if with_full:
            neighbors = u'          <div class="paging">' +  self.prev \
                + u'<a href="./">Main</a>' +  self.next + u'</div>'
            entry_ad = u'<div class="entryAd">' \
                + _read_addon(conf['addon_dir'], 'entryad') + u'</div>'

            if self.comments:
                comments = u'          <div id="comments">' \
                    + u'<a name="comments"></a>' \
                    + u'\n'.join(self.comments) + u'</div>'
            else:
                comments = u''
            form = self.form
            js = u'        <script type="text/javascript">var eid = %(eid)d; var previewed = false;</script>' % locals()
        else:
            if extend:
                extend = u'<a href="/%(blog_root)s/%(eid)d">More ...</a>' \
                    % locals()
            neighbors, entry_ad, comments, form, js = (u'', ) * 5

        return div % locals()

    def _format_mobile_div(self, conf, with_full):
        div = u'''
      <div class="entry">
        <div class="entryHeader">
          <div class="entryTitle">
            <h2><a href="/%(blog_root)s/m/%(eid)d">%(etitle)s</a></h2>
            <h3>%(subtitle)s</h3>
            <h4>%(year)d/%(month_str)s/%(day_str)s %(hour)02d:%(minute)02d</h4>
          </div>
        </div>
        <div class="entryBody">
          <div class="body">%(body)s</div>
          <div class="extend">%(extend)s</div>
          <div class="comm_count">
            <a href="/%(blog_root)s/m/%(eid)d">C: %(comm_count)d</a>
          </div>
%(comments)s
          <div class="paging">%(prev)s %(next)s</div>
        </div>
      </div>'''

        eid, year, month, day, hour, minute = \
            self.eid, self.year, self.month, self.day, self.hour, self.minute
        etitle, subtitle, body, extend = \
            self.title, self.subtitle, self.body, self.extend

        blog_root = conf['blog_root']

        month_str = month_abbr(month)
        day_str = format_day(day)
        author = conf['author']
        comm_count = len(self.comments)
        prev, next, comments = u'', u'', u''
        
        if with_full:
            prev, next = self.prev, self.next
            if self.comments:
                comments = u'          <div id="comments">' \
                    + u'<a name="comments"></a>' \
                    + u'\n'.join(self.comments) + u'</div>'

        else:
            if extend:
                extend = u'<a href="/%(blog_root)s/m/%(eid)d">More ...</a>' \
                    % locals()

        return div % locals()

    def format_div(self, conf, with_full = False, for_mobile = False):
        if for_mobile:
            return self._format_mobile_div(conf, with_full)
        else:
            return self._format_div(conf, with_full)

    def format_item(self, conf):
        item = u'''
  <item>
   <title>%(etitle)s</title>
   <link>http://%(host_name)s/%(blog_root)s/%(eid)d</link>
   <guid isPermaLink="true">http://%(host_name)s/%(blog_root)s/%(eid)d</guid>
   <description><![CDATA[%(body)s %(extend)s]]></description>
   <pubDate>%(pubdate)s</pubDate>
   <dc:creator>%(author)s</dc:creator>
   <xhtml:link rel="alternate" media="handheld" type="text/html"
               href="http://%(host_name)s/%(blog_root)s/m/%(eid)d" />
  </item>'''

        eid, year, month, day, hour, minute = \
            self.eid, self.year, self.month, self.day, self.hour, self.minute
        etitle, body, extend, = self.title, self.body, self.extend

        host_name = conf['host_name']
        blog_root = conf['blog_root']
        author = conf['author']

        ptime = datetime.datetime(year, month, day, hour, minute) \
            + datetime.timedelta(seconds = time.timezone)
        pubdate = ptime.strftime("%a, %d %b %Y %H:%M:%S +0000")

        return item % locals()

class Comment(object):
    def __init__(self, eid, cid = None, ptime = 0,
                 author = u'', title = u'', body = u''):
        self.eid = eid
        self.cid = cid
        self.ptime = ptime
        self.author = author
        self.title = title if title else u'No Title'
        self.body = body
        self.year, self.month, self.day, self.hour, self.minute = 0, 0, 0, 0, 0
        
    def is_visible(self):
        AVAILABLE_HREFS = 10

        if self.body.count(u'href') > AVAILABLE_HREFS:
            return 0
        else:
            return 1

    def post(self, db_path):
        csql = 'INSERT INTO comments VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);'

        self.year, self.month, self.day, self.hour, self.minute \
            = time.localtime(self.ptime)[:5]
        iymdhm = _iymdhm(self.year, self.month, self.day, self.hour, self.minute)

        db = sqlite3.connect(db_path)
        db.execute(csql, (self.eid, self.author, self.title, self.body,
                          self.is_visible(), self.year, self.month, self.day,
                          self.hour, self.minute, iymdhm))
        db.commit()
        db.close()

    def format_div(self):
        div = u'''
            <div class="comment" id="c%(cid)d">
              <div class="commentTitle"><a name="c%(cid)d"></a>%(title)s</div>
              <div class="commentBody">%(body)s</div>
              <div class="posted">
                Posted by %(author)s at %(hour)02d:%(minute)02d
                on %(year)4d %(month_str)s %(day_str)s
              </div>
            </div>'''

        cid, title, body, author, year, hour, minute \
            = (self.cid, self.title, self.body, self.author,
               self.year, self.hour, self.minute)

        month_str = month_abbr(self.month)
        day_str = format_day(self.day)

        return div % locals()

    def format_item(self, conf):
        item = u'''
  <item>
   <title>%(title)s</title>
   <link>http://%(host_name)s/%(blog_root)s/%(eid)d#c%(cid)d</link>
   <guid isPermaLink="true">http://%(host_name)s/%(blog_root)s/%(eid)d#c%(cid)d</guid>
   <description><![CDATA[%(body)s]]></description>
   <pubDate>%(pubdate)s</pubDate>
   <dc:creator>%(author)s</dc:creator>
  </item>'''

        eid, cid, title, body, author, year, month, day, hour, minute \
            = (self.eid, self.cid, self.title, self.body, self.author,
               self.year, self.month, self.day, self.hour, self.minute)

        host_name = conf['host_name']
        blog_root = conf['blog_root']

        ptime = datetime.datetime(year, month, day, hour, minute) \
            + datetime.timedelta(seconds = time.timezone)
        pubdate = ptime.strftime("%a, %d %b %Y %H:%M:%S +0000")

        return item % locals()

def _main():
    import sys
    start_db(sys.argv[1])

if __name__ == '__main__':
    _main()

Show details Hide details

Change log

r54 by setomits on Oct 26, 2011 Diff

Modified to enable to change entry id of
comment

Go to:

Project members, sign in to write a code review

Older revisions

r52 by setomits on Jun 6, 2010 Diff

add rel="tag" for anchor tags for tags

r51 by setomits on Jun 6, 2010 Diff

- move javascript loading part fro
head to tail.
- add rel="tag" for anchor tags for
tags

r50 by setomits on Mar 25, 2010 Diff

fix the path of jquery ui

All revisions of this file

File info

Size: 38898 bytes, 1142 lines

View raw file