root / pykota / trunk / bin / pkusers @ 2725

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

# PyKota Users 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
import grp

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

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

An Users and Groups Manager for PyKota.

command line usage :

  pkusers [options] user1 user2 user3 ... userN
  
or :  

  pkusers --groups [options] group1 group2 group3 ... groupN

options :

  -v | --version       Prints pkusers's version number then exits.
  -h | --help          Prints this message then exits.
  
  -a | --add           Adds users if they don't exist on the database.
                       If they exist, they are modified unless
                       -s|--skipexisting is also used.
                       
  -d | --delete        Deletes users from the quota storage.
  
  -D | --description d Adds a textual description to users or groups.
                       
  -g | --groups        Edit users groups instead of users.
                          
  -o | --overcharge f  Sets the overcharging factor applied to the user 
                       when computing the cost of a print job. Positive or 
                       negative floating point values are allowed,
                       this allows you to do some really creative
                       things like giving money to an user whenever
                       he prints. The number of pages in a print job
                       is not modified by this coefficient, only the
                       cost of the job for a particular user.
                       Only users have such a coefficient.
  
  -i | --ingroups g1[,g2...]  Puts the users into each of the groups
                              listed, separated by commas. The groups
                              must already exist in the Quota Storage.
                       
  -L | --list          Lists users or groups.
  
  -l | --limitby l     Choose if the user/group is limited in printing                     
                       by its account balance or by its page quota.
                       The default value is 'quota'. Allowed values
                       are 'quota' 'balance' 'noquota' 'noprint' 
                       and 'nochange' :
                       
                         - quota : limit by number of pages per printer.
                         - balance : limit by number of credits in account.
                         - noquota : no limit, accounting still done.
                         - nochange : no limit, accounting not done. 
                         - noprint : printing is denied. 
                       NB : nochange and noprint are not supported for groups.
                       
  -b | --balance b     Sets the user's account balance to b.                     
                       Account balance may be increase or decreased
                       if b is prefixed with + or -.
                       WARNING : when decreasing account balance,
                       the total paid so far by the user is decreased
                       too.
                       Groups don't have a real balance, but the
                       sum of their users' account balance.
                       
  -C | --comment txt   Defines some informational text to be associated
                       with a change to an user's account balance.
                       Only meaningful if -b | --balance is also used.
                       
                       
  -r | --remove        In combination with the --groups option above,                       
                       remove users from the specified users groups.
                       
  -s | --skipexisting  In combination with the --add option above, tells
                       pkusers to not modify existing users.
                       
  user1 through userN and group1 through groupN can use wildcards
  if the --add option is not set.
  
examples :                              

  $ pkusers --add john paul george ringo/ringo@example.com
  
  This will add users john, paul, george and ringo to the quota
  database. User ringo's email address will also be set to 
  'ringo@example.com'
  
  $ pkusers --ingroups coders,it jerome
  
  User jerome is put into the groups "coders" and "it" which must
  already exist in the quota database.
            
  $ pkusers --limitby balance jerome
  
  This will tell PyKota to limit jerome by his account's balance
  when printing.
  
  $ pkusers --balance +10.0 --comment "He paid with his blood !" jerome
  
  This will increase jerome's account balance by 10.0 (in your
  own currency). You can decrease the account balance with a
  dash prefix, and set it to a fixed amount with no prefix.
  A comment will be stored for this balance change.
  
  $ pkusers --delete jerome rachel
  
  This will completely delete jerome and rachel from the quota
  database. All their quotas and jobs will be deleted too.
  
  $ pkusers --overcharge 2.5 poorstudent
  
  This will overcharge the poorstudent user by a factor of 2.5.
  
  $ pkusers --overcharge -1 jerome
  
  User jerome will actually earn money whenever he prints.
  
  $ pkusers --overcharge 0 boss
  
  User boss can print at will, it won't cost him anything because the
  cost of each print job will be multiplied by zero before charging
  his account.
""")
        
class PKUsers(PyKotaTool) :        
    """A class for a users and users groups manager."""
    def main(self, names, options) :
        """Manage users or groups."""
        if not self.config.isAdmin :
            raise PyKotaCommandLineError, "%s : %s" % (pwd.getpwuid(os.geteuid())[0], _("You're not allowed to use this command."))
            
        suffix = (options["groups"] and "Group") or "User"        
        
        if options["delete"] :    
            self.display("%s...\n" % _("Deletion"))
            todelete = getattr(self.storage, "getMatching%ss" % suffix)(",".join(names))
            nbtotal = len(todelete)
            for i in range(nbtotal) :
                entry = todelete[i]
                if entry.Exists :
                    entry.delete()
                percent = 100.0 * float(i) / float(nbtotal)
                self.display("\r%.02f%%" % percent)
        else :
            if options["add"] :    
                self.display("%s...\n" % _("Creation"))
                rejectunknown = self.config.getRejectUnknown()    
                entries = []
                nbtotal = len(names)
                for i in range(nbtotal) :
                    ename = names[i]
                    email = ""
                    if not options["groups"] :
                        splitname = ename.split('/', 1)     # username/email
                        if len(splitname) == 1 :
                            splitname.append("")
                        (ename, email) = splitname
                        if email and (email.count('@') != 1) :
                            self.printInfo(_("Invalid email address %s") % email)
                            email = ""
                    entry = getattr(self.storage, "get%s" % suffix)(ename)
                    if entry.Exists :
                        if options["skipexisting"] :
                            self.printInfo(_("%s %s already exists, skipping.") % (suffix, entry.Name))
                        else :    
                            self.printInfo(_("%s %s already exists, will be modified.") % (suffix, entry.Name))
                            entries.append(entry)
                    else :
                        if self.isValidName(entry.Name) :
                            reject = 0
                            if rejectunknown :
                                if options["groups"] :
                                    try :
                                        grp.getgrnam(entry.Name)
                                    except KeyError :    
                                        self.printInfo(_("Unknown group %s") % entry.Name, "error")
                                        reject = 1
                                else :    
                                    try :
                                        pwd.getpwnam(entry.Name)
                                    except KeyError :    
                                        self.printInfo(_("Unknown user %s") % entry.Name, "error")
                                        reject = 1
                            if not reject :        
                                if email :
                                    entry.Email = email
                                entry = getattr(self.storage, "add%s" % suffix)(entry)
                                entries.append(entry)
                        else :    
                            if options["groups"] :
                                self.printInfo(_("Invalid group name %s") % entry.Name)
                            else :    
                                self.printInfo(_("Invalid user name %s") % entry.Name)
                                
                    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 = ["*"]
                entries = getattr(self.storage, "getMatching%ss" % suffix)(",".join(names))
                if not entries :
                    raise PyKotaCommandLineError, _("There's no %s matching %s") % (suffix.lower(), " ".join(names))
                        
            if options["list"] :
                if suffix == "User" :
                    maildomain = self.config.getMailDomain()
                    smtpserver = self.config.getSMTPServer()
                    for entry in entries :
                        if entry.Exists :
                            email = entry.Email
                            if not email :
                                if maildomain :     
                                    email = "%s@%s" % (entry.Name, maildomain)
                                elif smtpserver :    
                                    email = "%s@%s" % (entry.Name, smtpserver)
                                else :    
                                    email = "%s@%s" % (entry.Name, "localhost")
                            msg = "%s - <%s>" % (entry.Name, email)
                            if entry.Description :
                                msg += " - %s" % entry.Description
                            print msg    
                            print "    %s" % (_("Limited by : %s") % entry.LimitBy)
                            print "    %s" % (_("Account balance : %.2f") % (entry.AccountBalance or 0.0))
                            print "    %s" % (_("Total paid so far : %.2f") % (entry.LifeTimePaid or 0.0))
                            print "    %s" % (_("Overcharging factor : %.2f") % entry.OverCharge)
                            print
                else :    
                    for entry in entries :
                        if entry.Exists :
                            msg = "%s" % entry.Name
                            if entry.Description :
                                msg += " - %s" % entry.Description
                            print msg    
                            print "    %s" % (_("Limited by : %s") % entry.LimitBy)
                            print "    %s" % (_("Group balance : %.2f") % (entry.AccountBalance or 0.0))
                            print "    %s" % (_("Total paid so far : %.2f") % (entry.LifeTimePaid or 0.0))
                            print
            else :
                self.display("%s...\n" % _("Modification"))
                
                limitby = options["limitby"]
                if limitby :
                    limitby = limitby.strip().lower()
                if limitby :
                    if limitby not in ('quota', 'balance', 'noquota', \
                                                'noprint', 'nochange') :
                        raise PyKotaCommandLineError, _("Invalid limitby value %s") % options["limitby"]
                    if (limitby in ('nochange', 'noprint')) and options["groups"] :    
                        raise PyKotaCommandLineError, _("Invalid limitby value %s") % options["limitby"]
                    
                overcharge = options["overcharge"]
                if overcharge :
                    try :
                        overcharge = float(overcharge.strip())
                    except (ValueError, AttributeError) :    
                        raise PyKotaCommandLineError, _("Invalid overcharge value %s") % options["overcharge"]
                        
                balance = options["balance"]
                if balance :
                    balance = balance.strip()
                    try :
                        balancevalue = float(balance)
                    except ValueError :    
                        raise PyKotaCommandLineError, _("Invalid balance value %s") % options["balance"]
                    
                if options["ingroups"] :
                    usersgroups = self.storage.getMatchingGroups(options["ingroups"])
                    if not usersgroups :
                        raise PyKotaCommandLineError, _("There's no users group matching %s") % " ".join(options["ingroups"].split(','))
                else :         
                    usersgroups = []
                        
                description = options["description"]
                if description :
                    description = options["description"].strip()
                    
                comment = options["comment"]
                if comment :
                    comment = options["comment"].strip()
                    
                nbtotal = len(entries)
                for i in range(nbtotal) :        
                    entry = entries[i]
                    
                    # We need a transaction because we may have to create a record
                    # in the payments' table at the same time we modify the user's balance.
                    self.storage.beginTransaction()
                    try :
                        if description is not None : # NB : "" is allowed !
                            entry.setDescription(description)
                        if limitby :    
                            entry.setLimitBy(limitby)
                            
                        if suffix == "User" :    
                            if overcharge is not None : # NB : 0 is allowed !     
                                entry.setOverChargeFactor(overcharge)
                        
                        if suffix == "User" :
                            if balance :
                                if balance.startswith("+") or balance.startswith("-") :
                                    newbalance = float(entry.AccountBalance or 0.0) + balancevalue
                                    newlifetimepaid = float(entry.LifeTimePaid or 0.0) + balancevalue
                                    entry.setAccountBalance(newbalance, newlifetimepaid, comment)
                                else :
                                    diff = balancevalue - float(entry.AccountBalance or 0.0)
                                    newlifetimepaid = float(entry.LifeTimePaid or 0.0) + diff
                                    entry.setAccountBalance(balancevalue, newlifetimepaid, comment)
                                            
                            for ugroup in usersgroups :
                                if options["remove"] :
                                    ugroup.delUserFromGroup(entry)
                                else :
                                    ugroup.addUserToGroup(entry)
                        entry.save()    
                    except :
                        self.storage.rollbackTransaction()
                        raise
                    else :    
                        self.storage.commitTransaction()

                    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 :
        defaults = { \
                     "comment" : "", \
                   }
        short_options = "hvaD:dgl:rso:i:b:C:L"
        long_options = ["help", "version", "add", "description=", \
                        "delete", "groups", "list", "remove", \
                        "skipexisting", "overcharge=", \
                        "ingroups=", "limitby=", "balance=", "comment=", \
                       ]
                        
        
        # Initializes the command line tool
        manager = PKUsers(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["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["limitby"] = options["l"] or options["limitby"]
        options["balance"] = options["b"] or options["balance"] 
        options["ingroups"] = options["i"] or options["ingroups"]
        options["overcharge"] = options["o"] or options["overcharge"]
        options["comment"] = options["C"] or options["comment"] or defaults["comment"]
        
        if options["help"] :
            manager.display_usage_and_quit()
        elif options["version"] :
            manager.display_version_and_quit()
        elif (options["delete"] and (options["add"] or options["remove"] or options["description"])) \
           or (options["skipexisting"] and not options["add"]) \
           or (options["list"] and (options["add"] or options["delete"] or options["remove"] or options["description"])) \
           or (options["groups"] and (options["balance"] or options["ingroups"] or options["overcharge"])) :
            raise PyKotaCommandLineError, _("incompatible options, see help.")
        elif options["remove"] and not options["ingroups"] :    
            raise PyKotaCommandLineError, _("You have to pass user groups names on the command line")
        elif (not args) and options["add"] :
            raise PyKotaCommandLineError, _("You have to pass user or group 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("pkusers failed")
        except :    
            crashed("pkusers failed")
        retcode = -1

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