root / pykota / trunk / bin / pkinvoice @ 2670

#! /usr/bin/env python
# -*- coding: ISO-8859-15 -*-

# PyKota Invoice generator
#
# PyKota - Print Quotas for CUPS and LPRng
#
# (c) 2003, 2004, 2005, 2006 Jerome Alet <alet@librelogiciel.com>
# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# $Id$
#
#

import sys
import os
import pwd
import time
import cStringIO

try :
    from reportlab.pdfgen import canvas
    from reportlab.lib import pagesizes
    from reportlab.lib.units import cm
except ImportError :    
    hasRL = 0
else :    
    hasRL = 1
    
try :
    import PIL.Image 
except ImportError :    
    hasPIL = 0
else :    
    hasPIL = 1

from pykota.tool import PyKotaToolError, PyKotaCommandLineError, crashed, N_
from pykota.dumper import DumPyKota
from pykota.config import PyKotaConfigError
from pykota.storage import PyKotaStorageError

__doc__ = N_("""pkinvoice v%(__version__)s (c) %(__years__)s %(__author__)s

An invoice generator for PyKota.

command line usage :

  pkinvoice [options] user1 user2 ... userN

options :

  -v | --version       Prints edpykota's version number then exits.
  -h | --help          Prints this message then exits.
  
  -l | --logo img      Use the image as the banner's logo. The logo will
                       be drawn at the center top of the page. The default
                       logo is /usr/share/pykota/logos/pykota.jpeg
                       
  -p | --pagesize sz   Sets sz as the page size. Most well known
                       page sizes are recognized, like 'A4' or 'Letter'
                       to name a few. The default size is A4.
                       
  -n | --number N      Sets the number of the first invoice. This number
                       will automatically be incremented for each invoice.
                       
  -o | --output f.pdf  Defines the name of the invoice file which will
                       be generated as a PDF document. If not set or
                       set to '-', the PDF document is sent to standard
                       output. 
                       
  -u | --unit u        Defines the name of the unit to use on the invoice.                       
                       The default unit is 'Credits', optionally translated
                       to your native language if it is supported by PyKota.
  
  -V | --vat p         Sets the percent value of the applicable VAT to be
                       exposed. The default is 0.0, meaning no VAT
                       information will be included.
                       
  -s | --start date    Sets the starting date for the print jobs invoiced.
  
  -e | --end date      Sets the ending date for the print jobs invoiced.
                       
  user1 through userN can use wildcards if needed. If no user argument is
  used, a wildcard of '*' is assumed, meaning include all users.
  
  Dates formating with --start and --end :
  
    YYYY : year boundaries
    YYYYMM : month boundaries
    YYYYMMDD : day boundaries
    YYYYMMDDhh : hour boundaries
    YYYYMMDDhhmm : minute boundaries
    YYYYMMDDhhmmss : second boundaries
    yesterday[+-NbDays] : yesterday more or less N days (e.g. : yesterday-15)
    today[+-NbDays] : today more or less N days (e.g. : today-15)
    tomorrow[+-NbDays] : tomorrow more or less N days (e.g. : tomorrow-15)
    now[+-NbDays] : now more or less N days (e.g. now-15)

  'now' and 'today' are not exactly the same since today represents the first
  or last second of the day depending on if it's used in a start= or end=
  date expression. The utility to be able to specify dates in the future is
  a question which remains to be answered :-)
                                        
examples :                       

  $ pkinvoice --unit EURO --output invoices.pdf --start=now-30
  
  Will generate a PDF document containing invoices for all users
  who have spent some credits last month. Invoices will be done in
  EURO.  No VAT information will be included.
""") 
        
class PKInvoice(DumPyKota) :        
    """A class for pkinvoice."""
    def getPageSize(self, pgsize) :
        """Returns the correct page size or None if not found."""
        try :
            return getattr(pagesizes, pgsize.upper())
        except AttributeError :    
            try :
                return getattr(pagesizes, pgsize.lower())
            except AttributeError :
                pass
                
    def printVar(self, label, value, size) :
        """Outputs a variable onto the PDF canvas.
        
           Returns the number of points to substract to current Y coordinate.
        """   
        xcenter = (self.pagesize[0] / 2.0) - 1*cm
        self.canvas.saveState()
        self.canvas.setFont("Helvetica-Bold", size)
        self.canvas.setFillColorRGB(0, 0, 0)
        self.canvas.drawRightString(xcenter, self.ypos, "%s :" % label)
        self.canvas.setFont("Courier-Bold", size)
        self.canvas.setFillColorRGB(0, 0, 1)
        self.canvas.drawString(xcenter + 0.5*cm, self.ypos, value)
        self.canvas.restoreState()
        self.ypos -= (size + 4)
        
    def pagePDF(self, invoicenumber, entry, vat, start, end, unitname) :
        """Generates a new page in the PDF document."""
        extractonly = { "username" : entry.Name }
        if start :
            extractonly["start"] = start
        if end :    
            extractonly["end"] = end
        records = self.storage.extractHistory(extractonly)
        amount = vatamount = 0.0
        vatamount = 0.0
        if records :
            self.canvas.doForm("background")
            self.ypos = self.yorigine - (cm + 20)
            records = self.summarizeDatas(records, "history", extractonly, True)
            fieldnames = records[0]
            fields = {}
            for i in range(len(fieldnames)) :
                fields[fieldnames[i]] = i
            numberofbytes = records[1][fields["jobsizebytes"]]
            numberofpages = records[1][fields["jobsize"]]
            amount = records[1][fields["jobprice"]]
            if amount > 0.0 :
                # There's something due !
                ht = ((amount * 10000.0) / (100.0 + vat)) / 100.0
                vatamount = amount - ht
            self.printVar(_("Invoice"), "#%s" % invoicenumber, 22)
            self.printVar(_("Username"), entry.Name, 22)
            self.ypos -= 20
            if start : 
                self.printVar(_("Since"), start, 14)
            if end :
                self.printVar(_("Until"), end, 14)
            self.printVar(_("Edited on"), time.strftime("%c", time.localtime()), 14)
                
            self.ypos -= 20
            # self.printVar(_("Number of bytes"), str(numberofbytes), 14)
            self.printVar(_("Number of pages printed"), str(numberofpages), 14)
            self.ypos -= 20
            self.printVar(_("Amount due"), "%.2f %s" % (amount, unitname), 22)
            if vat :
                self.ypos += 8
                self.printVar("%s (%.2f%%)" % (_("Included VAT"), vat), "%.2f %s" % (vatamount, unitname), 14)
            self.canvas.showPage()
            return 1
        return 0    
        
    def initPDF(self, logo) :
        """Initializes the PDF document."""
        self.pdfDocument = cStringIO.StringIO()        
        self.canvas = c = canvas.Canvas(self.pdfDocument, \
                                        pagesize=self.pagesize, \
                                        pageCompression=1)
        
        c.setAuthor(pwd.getpwuid(os.geteuid())[0])
        c.setTitle("PyKota invoices")
        c.setSubject("Invoices generated with PyKota")
        
        
        self.canvas.beginForm("background")
        self.canvas.saveState()
        
        self.ypos = self.pagesize[1] - (2 * cm)            
        
        xcenter = self.pagesize[0] / 2.0
        if logo :
            try :    
                imglogo = PIL.Image.open(logo)
            except :    
                self.printInfo("Unable to open image %s" % logo, "warn")
            else :
                (width, height) = imglogo.size
                multi = float(width) / (8 * cm) 
                width = float(width) / multi
                height = float(height) / multi
                self.ypos -= height
                c.drawImage(logo, xcenter - (width / 2.0), \
                                  self.ypos, \
                                  width, height)
        
        self.ypos -= (cm + 20)
        self.canvas.setFont("Helvetica-Bold", 14)
        self.canvas.setFillColorRGB(0, 0, 0)
        self.canvas.drawCentredString(xcenter, self.ypos, "%s :" % _("Here's the invoice for your printouts"))
        
        self.yorigine = self.ypos
        self.canvas.restoreState()
        self.canvas.endForm()
        
    def endPDF(self, fname) :    
        """Flushes the PDF generator."""
        self.canvas.save()
        if fname != "-" :        
            outfile = open(fname, "w")
            outfile.write(self.pdfDocument.getvalue())
            outfile.close()
        else :    
            sys.stdout.write(self.pdfDocument.getvalue())
            sys.stdout.flush()
        
    def main(self, names, options) :
        """Generate invoices."""
        if not hasRL :
            raise PyKotaToolError, "The ReportLab module is missing. Download it from http://www.reportlab.org"
        if not hasPIL :
            raise PyKotaToolError, "The Python Imaging Library is missing. Download it from http://www.pythonware.com/downloads"
            
        if not self.config.isAdmin :
            raise PyKotaCommandLineError, "%s : %s" % (pwd.getpwuid(os.geteuid())[0], _("You're not allowed to use this command."))
        
        try :    
            vat = float(options["vat"])
            if not (0.0 <= vat < 100.0) :
                raise ValueError
        except :    
            raise PyKotaCommandLineError, _("Incorrect value '%s' for the --vat command line option") % options["vat"]
            
        try :    
            firstnumber = number = int(options["number"])
            if number <= 0 :
                raise ValueError
        except :    
            raise PyKotaCommandLineError, _("Incorrect value '%s' for the --number command line option") % options["number"]
            
        self.pagesize = self.getPageSize(options["pagesize"])
        if self.pagesize is None :
            self.pagesize = self.getPageSize("a4")
            self.printInfo(_("Invalid 'pagesize' option %s, defaulting to A4.") % options["pagesize"], "warn")
            
        if not names :
            names = [ "*" ]
            
        outfname = options["output"]    
        if outfname != "-" :
            self.display("%s...\n" % _("Processing"))
            
        entries = self.storage.getMatchingUsers(",".join(names))
        if entries :
            self.initPDF(options["logo"].strip())
            nbtotal = len(entries)
            for i in range(nbtotal) :
                entry = entries[i]
                number += self.pagePDF(number, entry, vat, options["start"], options["end"], options["unit"])
                if outfname != "-" :
                    percent = 100.0 * float(i) / float(nbtotal)
                    self.display("\r%.02f%%" % percent)
                    
            if number > firstnumber :
                self.endPDF(outfname)
            
        if outfname != "-" :
            self.display("\r100.00%%\r        ")
            self.display("\r%s\n" % _("Done."))
                     
if __name__ == "__main__" : 
    retcode = 0
    try :
        defaults = { "vat" : "0.0",
                     "unit" : N_("Credits"),
                     "output" : "-",
                     "pagesize" : "a4", \
                     "logo" : "/usr/share/pykota/logos/pykota.jpeg",
                     "number" : "1",
                   }
        short_options = "vho:r:u:V:p:l:n:s:e:"
        long_options = ["help", "version", "start=", "end=", \
                        "reference=", "unit=", "output=", \
                        "pagesize=", "logo=", "vat=", "number="]
        
        # Initializes the command line tool
        invoiceGenerator = PKInvoice(doc=__doc__)
        invoiceGenerator.deferredInit()
        
        # parse and checks the command line
        (options, args) = invoiceGenerator.parseCommandline(sys.argv[1:], short_options, long_options, allownothing=True)
        
        # sets long options
        options["help"] = options["h"] or options["help"]
        options["version"] = options["v"] or options["version"]
        
        options["start"] = options["s"] or options["start"]
        options["end"] = options["e"] or options["end"]
        options["vat"] = options["V"] or options["vat"] or defaults["vat"]
        options["unit"] = options["u"] or options["unit"] or defaults["unit"]
        options["output"] = options["o"] or options["output"] or defaults["output"]
        options["pagesize"] = options["p"] or options["pagesize"] or defaults["pagesize"]
        options["number"] = options["n"] or options["number"] or defaults["number"]
        options["logo"] = options["l"] or options["logo"]
        if options["logo"] is None : # Allows --logo="" to disable the logo entirely
            options["logo"] = defaults["logo"]  
        
        if options["help"] :
            invoiceGenerator.display_usage_and_quit()
        elif options["version"] :
            invoiceGenerator.display_version_and_quit()
        else :
            retcode = invoiceGenerator.main(args, options)
    except KeyboardInterrupt :        
        sys.stderr.write("\nInterrupted with Ctrl+C !\n")
        retcode = -3
    except PyKotaCommandLineError, msg :     
        sys.stderr.write("%s : %s\n" % (sys.argv[0], msg))
        retcode = -2
    except SystemExit :        
        pass
    except :
        try :
            invoiceGenerator.crashed("pkinvoice failed")
        except :    
            crashed("pkinvoice failed")
        retcode = -1

    try :
        invoiceGenerator.storage.close()
    except (TypeError, NameError, AttributeError) :    
        pass
        
    sys.exit(retcode)