root / pykota / trunk / bin / pkprinters @ 2720

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

# PyKota Printers Manager
#
# 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 os
import sys
import pwd

from pykota.tool import PyKotaTool, PyKotaToolError, PyKotaCommandLineError, crashed, N_

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

A Printers Manager for PyKota.

command line usage :

  pkprinters [options] printer1 printer2 printer3 ... printerN

options :

  -v | --version       Prints pkprinters's version number then exits.
  -h | --help          Prints this message then exits.
  
  -a | --add           Adds printers if they don't exist on the Quota 
                       Storage Server. If they exist, they are modified
                       unless -s|--skipexisting is also used.
                       
  -d | --delete        Deletes printers from the quota storage.
  
  -D | --description d Adds a textual description to printers.
                       
  -c | --charge p[,j]  Sets the price per page and per job to charge.
                       Job price is optional.
                       If both are to be set, separate them with a comma.
                       Floating point and negative values are allowed.
  
  -g | --groups pg1[,pg2...] Adds or Remove the printer(s) to the printer 
                       groups pg1, pg2, etc... which must already exist.
                       A printer group is just like a normal printer,
                       only that it is usually unknown from the printing
                       system. Create printer groups exactly the same
                       way that you create printers, then add other 
                       printers to them with this option.
                       Accounting is done on a printer and on all
                       the printer groups it belongs to, quota checking
                       is done on a printer and on all the printer groups
                       it belongs to.
                       If the --remove option below is not used, the 
                       default action is to add printers to the specified
                       printer groups.
                       
  -l | --list          List informations about the printer(s) and the
                       printers groups it is a member of.
                       
  -r | --remove        In combination with the --groups option above,                       
                       remove printers from the specified printers groups.
                       
  -s | --skipexisting  In combination with the --add option above, tells
                       pkprinters to not modify existing printers.
                       
  -m | --maxjobsize s  Sets the maximum job size allowed on the printer
                       to s pages.
                       
  -p | --passthrough   Activate passthrough mode for the printer. In this
                       mode, users are allowed to print without any impact
                       on their quota or account balance.
                       
  -n | --nopassthrough Deactivate passthrough mode for the printer.
                       Without -p or -n, printers are created in 
                       normal mode, i.e. no passthrough.
  
  printer1 through printerN can contain wildcards if the --add option 
  is not set.
  
examples :                              

  $ pkprinters --add -D "HP Printer" --charge 0.05,0.1 hp2100 hp2200 hp8000
  
  Will create three printers named hp2100, hp2200 and hp8000.
  Their price per page will be set at 0.05 unit, and their price
  per job will be set at 0.1 unit. Units are in your own currency,
  or whatever you want them to mean.
  All of their descriptions will be set to the string "HP Printer".
  If any of these printers already exists, it will also be modified 
  unless the -s|--skipexisting command line option is also used.
            
  $ pkprinters --delete "*"
  
  This will completely delete all printers and associated quota information,
  as well as their job history. USE WITH CARE !
  
  $ pkprinters --groups Laser,HP "hp*"
  
  This will put all printers which name matches "hp*" into printers groups 
  Laser and HP, which MUST already exist.
  
  $ pkprinters --groups LexMark --remove hp2200
  
  This will remove the hp2200 printer from the LexMark printer group.
""")
        
class PKPrinters(PyKotaTool) :        
    """A class for a printers manager."""
    def main(self, names, options) :
        """Manage printers."""
        if (not self.config.isAdmin) and (not options["list"]) :
            raise PyKotaCommandLineError, "%s : %s" % (pwd.getpwuid(os.geteuid())[0], _("You're not allowed to use this command."))
            
        if options["delete"] :    
            self.display("%s...\n" % _("Deletion"))
            todelete = self.storage.getMatchingPrinters(",".join(names))
            nbtotal = len(todelete)
            for i in range(nbtotal) :
                todelete[i].delete()
                percent = 100.0 * float(i) / float(nbtotal)
                self.display("\r%.02f%%" % percent)
        else :
            if options["add"] :    
                self.display("%s...\n" % _("Creation"))
                printers = []
                nbtotal = len(names)
                for i in range(nbtotal) :
                    pname = names[i]
                    printer = self.storage.getPrinter(pname)
                    if printer.Exists :
                        if options["skipexisting"] :
                            self.printInfo(_("Printer %s already exists, skipping.") % printer.Name)
                        else :    
                            self.printInfo(_("Printer %s already exists, will be modified.") % printer.Name)
                            printers.append(printer)
                    else :
                        if self.isValidName(pname) :
                            printer = self.storage.addPrinter(pname)
                            if not printer.Exists :
                                raise PyKotaToolError, _("Impossible to add printer %s") % pname
                            else :    
                                printers.append(printer)
                        else :    
                            raise PyKotaCommandLineError, _("Invalid printer name %s") % pname
                    percent = 100.0 * float(i) / float(nbtotal)
                    self.display("\r%.02f%%" % percent)
                self.display("\r100.00%%\r        \r%s\n" % _("Done."))
            else :        
                if not names :
                    names = ["*"]
                printers = self.storage.getMatchingPrinters(",".join(names))
                if not printers :
                    raise PyKotaCommandLineError, _("There's no printer matching %s") % " ".join(names)
                        
            if options["list"] :
                for printer in printers :
                    parents = ", ".join([p.Name for p in self.storage.getParentPrinters(printer)])
                    if parents : 
                        parents = "%s %s" % (_("in"), parents)
                    print "%s [%s] (%s + #*%s)" % \
                          (printer.Name, printer.Description, printer.PricePerJob, \
                           printer.PricePerPage)
                    print "    %s" % (_("Passthrough mode : %s") % ((printer.PassThrough and _("ON")) or _("OFF")))
                    print "    %s" % (_("Maximum job size : %s") % ((printer.MaxJobSize and (_("%s pages") % printer.MaxJobSize)) or _("Unlimited")))
                    if parents :       
                        print "    %s" % parents
            else :
                self.display("%s...\n" % _("Modification"))
                
                if options["groups"] :        
                    printersgroups = self.storage.getMatchingPrinters(options["groups"])
                    if not printersgroups :
                        raise PyKotaCommandLineError, _("There's no printer matching %s") % " ".join(options["groups"].split(','))
                else :         
                    printersgroups = []
                        
                if options["charge"] :
                    try :
                        charges = [float(part) for part in options["charge"].split(',', 1)]
                    except ValueError :    
                        raise PyKotaCommandLineError, _("Invalid charge amount value %s") % options["charge"]
                    else :    
                        if len(charges) > 2 :
                            charges = charges[:2]
                        if len(charges) != 2 :
                            charges = [charges[0], None]
                        (perpage, perjob) = charges
                        
                if options["maxjobsize"] :        
                    try :
                        maxjobsize = int(options["maxjobsize"])
                        if maxjobsize < 0 :
                            raise ValueError
                    except ValueError :    
                        raise PyKotaCommandLineError, _("Invalid maximum job size value %s") % options["maxjobsize"]
                else :        
                    maxjobsize = None
                        
                description = options["description"]
                if description :
                    description = description.strip()
                    
                nopassthrough = options["nopassthrough"]    
                passthrough = options["passthrough"]
                nbtotal = len(printers)
                for i in range(nbtotal) :        
                    printer = printers[i]
                    if options["charge"] :
                        printer.setPrices(perpage, perjob)    
                    if description is not None :        # NB : "" is allowed !
                        printer.setDescription(description)
                    if nopassthrough and printer.PassThrough :    
                        printer.setPassThrough(False)
                    if passthrough and not printer.PassThrough :    
                        printer.setPassThrough(True)
                    if (maxjobsize is not None) and (printer.MaxJobSize != maxjobsize) :    
                        printer.setMaxJobSize(maxjobsize)
                    printer.save()    
                    for pgroup in printersgroups :
                        if options["remove"] :
                            pgroup.delPrinterFromGroup(printer)
                        else :
                            pgroup.addPrinterToGroup(printer)    
                    percent = 100.0 * float(i) / float(nbtotal)
                    self.display("\r%.02f%%" % percent)
                                
        if not options["list"] :                
            self.display("\r100.00%%\r        \r%s\n" % _("Done."))
                     
if __name__ == "__main__" : 
    retcode = 0
    try :
        short_options = "hvac:D:dg:lrsnpm:"
        long_options = ["help", "version", "add", "charge=", "description=", \
                        "delete", "groups=", "list", "remove", \
                        "skipexisting", "passthrough", "nopassthrough", \
                        "maxjobsize="]
        
        # Initializes the command line tool
        manager = PKPrinters(doc=__doc__)
        manager.deferredInit()
        
        # parse and checks the command line
        (options, args) = manager.parseCommandline(sys.argv[1:], short_options, long_options)
        
        # sets long options
        options["help"] = options["h"] or options["help"]
        options["version"] = options["v"] or options["version"]
        options["add"] = options["a"] or options["add"]
        options["charge"] = options["c"] or options["charge"]
        options["description"] = options["D"] or options["description"]
        options["delete"] = options["d"] or options["delete"] 
        options["groups"] = options["g"] or options["groups"]
        options["list"] = options["l"] or options["list"]
        options["remove"] = options["r"] or options["remove"]
        options["skipexisting"] = options["s"] or options["skipexisting"]
        options["maxjobsize"] = options["m"] or options["maxjobsize"]
        options["passthrough"] = options["p"] or options["passthrough"]
        options["nopassthrough"] = options["n"] or options["nopassthrough"]
        
        if options["help"] :
            manager.display_usage_and_quit()
        elif options["version"] :
            manager.display_version_and_quit()
        elif (options["delete"] and (options["add"] or options["groups"] or options["charge"] or options["remove"] or options["description"])) \
           or (options["skipexisting"] and not options["add"]) \
           or (options["list"] and (options["add"] or options["delete"] or options["groups"] or options["charge"] or options["remove"] or options["description"])) \
           or (options["passthrough"] and options["nopassthrough"]) :
            raise PyKotaCommandLineError, _("incompatible options, see help.")
        elif options["remove"] and not options["groups"] :    
            raise PyKotaCommandLineError, _("You have to pass printer groups names on the command line")
        elif (not args) and (not options["list"]) :    
            raise PyKotaCommandLineError, _("You have to pass printer names on the command line")
        else :
            retcode = manager.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 :
            manager.crashed("pkprinters failed")
        except :    
            crashed("pkprinters failed")
        retcode = -1

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