source: main/waeup.kofa/branches/uli-async-update/src/waeup/kofa/browser/pdf.py @ 9169

## $Id: pdf.py 9169 2012-09-10 11:05:07Z uli $
##
## Copyright (C) 2012 Uli Fouquet & Henrik Bettermann
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
## 
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
## 
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
"""
Reusable components for pdf generation.
"""
import grok
import os
from cStringIO import StringIO
from datetime import datetime
from reportlab.lib.units import cm, inch, mm
from reportlab.lib.pagesizes import A4, landscape, portrait
from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
from reportlab.pdfgen.canvas import Canvas
from reportlab.platypus import (
    SimpleDocTemplate, Spacer, Paragraph, Image, Table)
from zope.formlib.form import setUpEditWidgets
from zope.i18n import translate
from zope.publisher.browser import TestRequest
from zope.component import getUtility
from waeup.kofa.browser.interfaces import IPDFCreator
from waeup.kofa.utils.helpers import now
from waeup.kofa.interfaces import IKofaUtils
from waeup.kofa.interfaces import MessageFactory as _

#: A reportlab paragraph style for 'normal' output.
NORMAL_STYLE = getSampleStyleSheet()['Normal']

#: A reportlab paragraph style for output of 'code'.
CODE_STYLE = ParagraphStyle(
    name='Code',
    parent=NORMAL_STYLE,
    fontName='Courier',
    fontSize=10,
    )

#: A reportlab paragraph style for regular form output.
ENTRY1_STYLE = ParagraphStyle(
    name='Entry1',
    parent=NORMAL_STYLE,
    fontSize=12,
    )

#: A reportlab paragraph style for smaller form output.
SMALL_PARA_STYLE = ParagraphStyle(
    name='Small1',
    parent=NORMAL_STYLE,
    fontSize=10,
    )

#: A reportlab paragraph style for headlines or bold text in form output.
HEADLINE1_STYLE = ParagraphStyle(
    name='Header1',
    parent=NORMAL_STYLE,
    fontName='Helvetica-Bold',
    fontSize=12,
    )

#: A reportlab paragraph style for notes output at end of documents.
NOTE_STYLE = ParagraphStyle(
    name='Note',
    parent=NORMAL_STYLE,
    fontName='Helvetica',
    fontSize=12,
    )

def format_html(html):
    """Make HTML code usable for use in reportlab paragraphs.

    Main things fixed here:
    If html code:
    - remove newlines (not visible in HTML but visible in PDF)
    - add <br> tags after <div> (as divs break lines in HTML but not in PDF)
    If not html code:
    - just replace newlines by <br> tags
    """
    if '</' in html:
        # Add br tag if widgets contain div tags
        # which are not supported by reportlab
        html = html.replace('</div>', '</div><br />')
        html = html.replace('\n', '')
    else:
        html = html.replace('\n', '<br />')
    return html

class NumberedCanvas(Canvas):
    """A reportlab canvas for numbering pages after all docs are processed.

    Taken from
    http://code.activestate.com/recipes/546511-page-x-of-y-with-reportlab/
    http://code.activestate.com/recipes/576832/
    """

    def __init__(self, *args, **kw):
        Canvas.__init__(self, *args, **kw)
        self._saved_page_states = []
        return

    def showPage(self):
        self._saved_page_states.append(dict(self.__dict__))
        self._startPage()
        return

    def save(self):
        """add page info to each page (page x of y)"""
        num_pages = len(self._saved_page_states)
        for state in self._saved_page_states:
            self.__dict__.update(state)
            self.draw_page_number(num_pages)
            Canvas.showPage(self)
        Canvas.save(self)
        return

    def draw_page_number(self, page_count):
        """draw string at bottom right with 'page x of y'.

        Location of the string is determined by canvas attributes
        `kofa_footer_x_pos` and `kofa_footer_y_pos` that have to be
        set manually.

        If this canvas also provides an attribute `kofa_footer_text`,
        the contained text is rendered left of the ``page x of y``
        string.
        """
        self.setFont("Helvetica", 9)
        right_footer_text = _(
            '${footer_text} Page ${num1} of ${num2}',
            mapping = {'footer_text': self.kofa_footer_text,
                       'num1':self._pageNumber, 'num2':page_count})
        self.drawRightString(
            self.kofa_footer_x_pos, self.kofa_footer_y_pos,
             translate(right_footer_text))
        return

class PDFCreator(grok.GlobalUtility):
    """A utility to help with generating PDF docs.
    """
    grok.implements(IPDFCreator)

    watermark_path = None
    header_logo_path = None
    watermark_pos = [0, 0]
    logo_pos = [0, 0, 0]

    @classmethod
    def _setUpWidgets(cls, form_fields, context):
        """Setup simple display widgets.

        Returns the list of widgets.
        """
        request = TestRequest()
        return setUpEditWidgets(
            form_fields, 'form', context, request, {},
            for_display=True, ignore_request=True
            )

    @classmethod
    def _addCourse(cls, table_data, row_num, course_label, course_link,
                   lang, domain):
        """Add course data to `table_data`.
        """
        if not course_label or not course_link:
            return table_data, row_num
        f_label= translate(
            _(course_label), domain, target_language=lang)
        f_label = Paragraph(f_label, ENTRY1_STYLE)
        f_text = Paragraph(course_link, ENTRY1_STYLE)
        table_data.append([f_label, f_text])
        row_num += 1
        return table_data, row_num

    @classmethod
    def _addDeptAndFaculty(cls, table_data, row_num, dept, faculty,
                           lang, domain):
        """Add `dept` and `faculty` as table rows to `table_data`.

        `dept` and `faculty` are expected to be strings or None. In
        latter case they are not put into the table.
        """
        for label, text in (('Department:', dept), ('Faculty:', faculty)):
            if text is None:
                continue
            label = translate(_(label), domain, target_language=lang)
            table_data.append([
                Paragraph(label, ENTRY1_STYLE),
                Paragraph(text, ENTRY1_STYLE)])
            row_num += 1
        return table_data, row_num

    @classmethod
    def fromStringList(cls, string_list):
        """Generate a list of reportlab paragraphs out of a list of strings.

        Strings are formatted with :data:`CODE_STYLE` and a spacer is
        appended at end.
        """
        result = []
        for msg in string_list:
            result.append(Paragraph(msg, CODE_STYLE))
        result.append(Spacer(1, 20))
        return result

    @classmethod
    def getImage(cls, image_path, orientation='LEFT'):
        """Get an image located at `image_path` as reportlab flowable.
        """
        img = Image(image_path, width=4*cm, height=3*cm, kind='bound')
        img.hAlign=orientation
        return img

    def getWidgetsTable(self, form_fields, context, view, lang='en',
                        domain='waeup.kofa', separators=None,
                        course_label=None, course_link=None, dept=None,
                        faculty=None):
        """Return a reportlab `Table` instance, created from widgets
        determined by `form_fields` and `context`.

        - `form_fields`
           is a list of schema fields as created by grok.AutoFields.
        - `context`
           is some object whose content is rendered here.
        - `view`
           is currently not used but supposed to be a view which is
           actually rendering a PDF document.
        - `lang`
           the portal language. Used for translations of strings.
        - `domain`
           the translation domain used for translations of strings.
        - `separators`
           a list of separators.
        - `course_label` and `course_link`
           if a course should be added to the table, `course_label`
           and `course_link` can be given, both being strings. They
           will be rendered in an extra-row.
        - `dept` and `faculty`
           if these are given, we render extra rows with faculty and
           department.
        """
        table_data = []
        table_style = [#('LEFTPADDING', (0,0), (0,-1), 0), # indentation
                       ('VALIGN', (0,0), (-1,-1), 'TOP'),
                       ]
        row_num = 0
        widgets = self._setUpWidgets(form_fields, context)
        for widget in widgets:
            if separators and separators.get(widget.name):
                f_headline = translate(
                    separators[widget.name], domain, target_language=lang)
                f_headline = Paragraph(f_headline, HEADLINE1_STYLE)
                table_data.append([f_headline ])
                table_style.append(('SPAN', (0,row_num), (-1,row_num)),)
                table_style.append(
                    ('TOPPADDING', (0,row_num), (-1,row_num), 12),)
                row_num += 1
            f_label = translate(widget.label.strip(), domain,
                                target_language=lang)
            f_label = Paragraph(f_label, ENTRY1_STYLE)
            f_text = translate(widget(), domain, target_language=lang)
            f_text = format_html(f_text)
            if f_text:
                hint = ' <font size=9>' + widget.hint + '</font>'
                f_text = f_text + hint
            f_text = Paragraph(f_text, ENTRY1_STYLE)
            table_data.append([f_label,f_text])
            row_num += 1

        # Add course (admitted, etc.) if applicable
        table_data, row_num = self._addCourse(
            table_data, row_num, course_label, course_link, lang, domain,)

        ## Add dept. and faculty if applicable
        table_data, row_num = self._addDeptAndFaculty(
            table_data, row_num, dept, faculty, lang, domain)

        # Create table
        table = Table(table_data,style=table_style)
        table.hAlign = 'LEFT'
        return table


    def paint_background(self, canvas, doc):
        """Paint background of a PDF, including watermark, title, etc.

        The `doc` is expected to be some reportlab SimpleDocTemplate
        or similar object.

        Text of headerline is extracted from doc.kofa_headtitle, the
        document title (under the head) from doc.kofa_title.

        This is a callback method that will be called from reportlab
        when creating PDFs with :meth:`create_pdf`.
        """
        canvas.saveState()
        width, height = doc.width, doc.height
        width += doc.leftMargin + doc.rightMargin
        height += doc.topMargin + doc.bottomMargin

        # Watermark
        if self.watermark_path is not None:
            canvas.saveState()
            canvas.drawImage(self.watermark_path,
                self.watermark_pos[0], self.watermark_pos[1])
            canvas.restoreState()

        # Header
        head_title = getattr(
            doc, 'kofa_headtitle', getattr(
                grok.getSite()['configuration'], 'name',
                u'Sample University'))
        canvas.setFont("Helvetica-Bold", 18)
        canvas.drawString(1.5*cm, height-1.7*cm, head_title)
        canvas.line(1.5*cm,height-1.9*cm,width-1.5*cm,height-1.9*cm)
        if self.header_logo_path is not None:
            canvas.drawImage(self.header_logo_path,
                self.logo_pos[0], self.logo_pos[1], width=self.logo_pos[2],
                preserveAspectRatio=True, anchor='ne')

        # Title
        canvas.saveState()
        canvas.setFont("Helvetica-Bold", 14)
        title = getattr(doc, 'kofa_title', '')
        if '\n' in title:
            title_lines = title.split('\n')
            for num, line in enumerate(title_lines):
                canvas.drawCentredString(
                    width/2.0, height-2.8*cm-(num*0.7*cm), line)
        elif title:
            canvas.drawCentredString(width/2.0, height-2.8*cm, title)
        canvas.restoreState()

        # Footer
        canvas.saveState()
        canvas.line(2.2*cm, 0.62*inch, width-2.2*cm, 0.62*inch)
        canvas.setFont("Helvetica", 9)
        if not getattr(doc, 'kofa_nodate', False):
            tz = getUtility(IKofaUtils).tzinfo
            today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
            canvas.drawString(2.2*cm, 0.5 * inch,
                translate(_(u'Date: ${a}', mapping = {'a': today})))
        # set canves attributes needed to render `page x of y`
        canvas.kofa_footer_x_pos = width-2.2*cm
        canvas.kofa_footer_y_pos = 0.5 * inch
        canvas.kofa_footer_text =  doc.kofa_footer
        canvas.restoreState()
        canvas.restoreState()

        # Metadata
        canvas.setAuthor(getattr(doc, 'kofa_author', 'Unknown'))
        canvas.setSubject(title)
        canvas.setCreator(u'WAeUP Kofa')
        return

    def create_pdf(self, data, headerline=None, title=None, author=None,
                   footer='', note=None):
        """Returns a binary data stream which is a PDF document.
        """
        pdf_stream = StringIO()
        doc = SimpleDocTemplate(
            pdf_stream,
            bottomMargin=1.1*inch,
            topMargin=1.6*inch,
            title=title,
            pagesize=portrait(A4),
            showBoundary=False,
            )
        # Set some attributes that are needed when rendering the background.
        if headerline is not None:
            doc.kofa_headtitle = headerline
        doc.kofa_title = title
        doc.kofa_author = author
        doc.kofa_footer = footer
        if note is not None:
            html = format_html(note)
            data.append(Paragraph(html, NOTE_STYLE))
        doc.build(data, onFirstPage=self.paint_background,
                  onLaterPages=self.paint_background,
                  canvasmaker=NumberedCanvas
                  )
        result = pdf_stream.getvalue()
        pdf_stream.close()
        return result