root / pykota / trunk / bin / pkinvoice @ 2663

#! /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 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 PyKotaTool, PyKotaToolError, PyKotaCommandLineError, crashed, N_
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.
  
  -g | --groups        Generate invoices for users groups instead of users.
  
  -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.
                       
  -r | --reference v   Uses v as the initial reference value : an invoice
                       will be generated for any account balance's value
                       lower or equal to the reference value. The
                       default reference value is of course 0.0 credits.
                       
  -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.
                       
  user1 through userN and group1 through groupN can use wildcards if 
  needed. If no user argument is used, a wildcard of '*' is assumed, 
  meaning include all users or groups.
  
examples :                       

  $ pkinvoice --reference 15.0 --unit EURO --output invoices.pdf
  
  Will generate a PDF document containing invoices for all users whose
  account balance is below 15.0 credits. For each user the amount due
  will be (15.0 - AccountBalance) EURO when that value is positive. 
  No VAT information will be included.
""") 
        
class PKInvoice(PyKotaTool) :        
    """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 pagePDF(self, invoicenumber, name, amount, vatamount) :
        """Generates a new page in the PDF document."""
        sys.stderr.write("#%06i    %s     %.2f    %.2f\n" % (invoicenumber, name, amount, vatamount))
        self.canvas.doForm("background")
        self.canvas.showPage()
        
    def initPDF(self, pagesize, logo) :
        """Initializes the PDF document."""
        self.pdfDocument = cStringIO.StringIO()        
        self.canvas = c = canvas.Canvas(self.pdfDocument, pagesize=pagesize, pageCompression=1)
        
        c.setAuthor(pwd.getpwuid(os.geteuid())[0])
        c.setTitle("PyKota invoices")
        c.setSubject("This is an invoice generated with PyKota")
        
        xcenter = pagesize[0] / 2.0
        ycenter = pagesize[1] / 2.0
                    
        ypos = pagesize[1] - (2 * cm)            
        
        self.canvas.beginForm("background")
        self.canvas.saveState()
        
        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
                xpos = xcenter - (width / 2.0)
                ypos -= height
                c.drawImage(logo, xpos, ypos, width, height)
        
        # New top
        xpos = pagesize[0] / 5.0
        ypos -= (1 * cm) + 20
        
        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 :    
            reference = float(options["reference"])
        except :    
            raise PyKotaCommandLineError, _("Incorrect value '%s' for the --reference command line option") % options["reference"]
            
        try :    
            number = float(options["number"])
            if number <= 0 :
                raise ValueError
        except :    
            raise PyKotaCommandLineError, _("Incorrect value '%s' for the --number command line option") % options["number"]
            
        pagesize = self.getPageSize(options["pagesize"])
        if pagesize is None :
            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"))
            
        suffix = (options["groups"] and "Group") or "User"        
        entries = getattr(self.storage, "getMatching%ss" % suffix)(",".join(names))
        if entries :
            self.initPDF(pagesize, options["logo"].strip())
            nbtotal = len(entries)
            for i in range(nbtotal) :
                entry = entries[i]
                amount = reference - entry.AccountBalance
                if amount > 0.0 :
                    # There's something due !
                    ht = ((amount * 10000.0) / (100.0 + vat)) / 100.0
                    vatamount = amount - ht
                    self.pagePDF(number, entry.Name, amount, vatamount)
                    number += 1
                if outfname != "-" :
                    percent = 100.0 * float(i) / float(nbtotal)
                    self.display("\r%.02f%%" % percent)
                    
            self.endPDF(outfname)
            
        if outfname != "-" :
            self.display("\r100.00%%\r        ")
            self.display("\r%s\n" % _("Done."))
                     
if __name__ == "__main__" : 
    retcode = 0
    try :
        defaults = { "reference" : "0.0",
                     "vat" : "0.0",
                     "unit" : N_("Credits"),
                     "output" : "-",
                     "pagesize" : "a4", \
                     "logo" : "/usr/share/pykota/logos/pykota.jpeg",
                     "number" : "1",
                   }
        short_options = "vho:gr:u:V:p:l:n:"
        long_options = ["help", "version", \
                        "groups", "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["groups"] = options["g"] or options["groups"]
        options["reference"] = options["r"] or options["reference"] or defaults["reference"]
        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)