Changeset 3413 for pykota/trunk/pykota/storages

Timestamp:

09/27/08 22:02:37 (16 years ago)

Author:

jerome

Message:

Removed unnecessary spaces at EOL.

Location:

pykota/trunk/pykota/storages

Files:

• __init__.py (modified) (1 diff)
• ldapstorage.py (modified) (126 diffs)
• mysqlstorage.py (modified) (7 diffs)
• pgstorage.py (modified) (6 diffs)
• sqlitestorage.py (modified) (6 diffs)
• sql.py (modified) (72 diffs)

pykota/trunk/pykota/storages/__init__.py

@@ -8 +8 @@
 # the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.

pykota/trunk/pykota/storages/ldapstorage.py

@@ -8 +8 @@
 # the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
@@ -23 +23 @@
 """This module defines a class to access to an LDAP database backend.
 
-My IANA assigned number, for 
-"Conseil Internet & Logiciels Libres, Jerome Alet" 
+My IANA assigned number, for
+"Conseil Internet & Logiciels Libres, Jerome Alet"
 is 16868. Use this as a base to extend the LDAP schema.
 """
@@ -42 +42 @@
                            StorageJob, StorageLastJob, StorageUserPQuota, \
                            StorageGroupPQuota, StorageBillingCode
-                           
-from pykota.utils import *                           
+
+from pykota.utils import *
 
 try :
     import ldap
     import ldap.modlist
-except ImportError :    
+except ImportError :
     raise PyKotaStorageError, "This python version (%s) doesn't seem to have the python-ldap module installed correctly." % sys.version.split()[0]
-else :    
+else :
     try :
         from ldap.cidict import cidict
-    except ImportError :    
+    except ImportError :
         import UserDict
         sys.stderr.write("ERROR: PyKota requires a newer version of python-ldap. Workaround activated. Please upgrade python-ldap !\n")
         class cidict(UserDict.UserDict) :
             pass # Fake it all, and don't care for case insensitivity : users who need it will have to upgrade.
-    
+
 class Storage(BaseStorage) :
     def __init__(self, pykotatool, host, dbname, user, passwd) :
@@ -68 +68 @@
         self.savedpasswd = passwd
         self.secondStageInit()
-        
-    def secondStageInit(self) :    
+
+    def secondStageInit(self) :
         """Second stage initialisation."""
         BaseStorage.__init__(self, self.savedtool)
@@ -77 +77 @@
             try :
                 self.tool.logdebug("Trying to open database (host=%s, dbname=%s, user=%s)..." % (self.savedhost, self.saveddbname, self.saveduser))
-                self.database = ldap.initialize(self.savedhost) 
+                self.database = ldap.initialize(self.savedhost)
                 if self.info["ldaptls"] :
                     # we want TLS
@@ -85 +85 @@
                 self.database.simple_bind_s(self.saveduser, self.savedpasswd)
                 self.basedn = self.saveddbname
-            except ldap.SERVER_DOWN :    
+            except ldap.SERVER_DOWN :
                 message = "LDAP backend for PyKota seems to be down !"
                 self.tool.printInfo("%s" % message, "error")
                 self.tool.printInfo("Trying again in 2 seconds...", "warn")
                 time.sleep(2)
-            except ldap.LDAPError :    
+            except ldap.LDAPError :
                 message = "Unable to connect to LDAP server %s as %s." % (self.savedhost, self.saveduser)
                 self.tool.printInfo("%s" % message, "error")
                 self.tool.printInfo("Trying again in 2 seconds...", "warn")
                 time.sleep(2)
-            else :    
+            else :
                 self.useldapcache = self.tool.config.getLDAPCache()
                 if self.useldapcache :
@@ -103 +103 @@
                 self.tool.logdebug("Database opened (host=%s, dbname=%s, user=%s)" % (self.savedhost, self.saveddbname, self.saveduser))
                 return # All is fine here.
-        raise PyKotaStorageError, message         
-            
-    def close(self) :    
+        raise PyKotaStorageError, message
+
+    def close(self) :
         """Closes the database connection."""
         if not self.closed :
@@ -111 +111 @@
             self.closed = 1
             self.tool.logdebug("Database closed.")
-        
-    def genUUID(self) :    
+
+    def genUUID(self) :
         """Generates an unique identifier.
-        
+
            TODO : this one is not unique accross several print servers, but should be sufficient for testing.
         """
         return md5.md5("%s-%s" % (time.time(), random.random())).hexdigest()
-        
-    def normalizeFields(self, fields) :    
+
+    def normalizeFields(self, fields) :
         """Ensure all items are lists."""
         for (k, v) in fields.items() :
@@ -125 +125 @@
                 if not v :
                     del fields[k]
-                else :    
+                else :
                     fields[k] = [ v ]
-        return fields        
-        
-    def beginTransaction(self) :    
+        return fields
+
+    def beginTransaction(self) :
         """Starts a transaction."""
         self.tool.logdebug("Transaction begins... WARNING : No transactions in LDAP !")
-        
-    def commitTransaction(self) :    
+
+    def commitTransaction(self) :
         """Commits a transaction."""
         self.tool.logdebug("Transaction committed. WARNING : No transactions in LDAP !")
-        
-    def rollbackTransaction(self) :     
+
+    def rollbackTransaction(self) :
         """Rollbacks a transaction."""
         self.tool.logdebug("Transaction aborted. WARNING : No transaction in LDAP !")
-        
+
     def doSearch(self, key, fields=None, base="", scope=ldap.SCOPE_SUBTREE, flushcache=0) :
         """Does an LDAP search query."""
@@ -151 +151 @@
                     # retrieve ALL user defined attributes ("*")
                     # + the createTimestamp attribute, needed by job history
-                    # 
+                    #
                     # This may not work with all LDAP servers
-                    # but works at least in OpenLDAP (2.1.25) 
+                    # but works at least in OpenLDAP (2.1.25)
                     # and iPlanet Directory Server (5.1 SP3)
-                    fields = ["*", "createTimestamp"]         
-                    
+                    fields = ["*", "createTimestamp"]
+
                 if self.useldapcache and (not flushcache) and (scope == ldap.SCOPE_BASE) and self.ldapcache.has_key(base) :
                     entry = self.ldapcache[base]
@@ -164 +164 @@
                     self.querydebug("QUERY : Filter : %s, BaseDN : %s, Scope : %s, Attributes : %s" % (key, base, scope, fields))
                     result = self.database.search_s(base, scope, key, fields)
-            except ldap.NO_SUCH_OBJECT, msg :        
+            except ldap.NO_SUCH_OBJECT, msg :
                 raise PyKotaStorageError, (_("Search base %s doesn't seem to exist. Probable misconfiguration. Please double check /etc/pykota/pykota.conf : %s") % (base, msg))
-            except ldap.LDAPError, msg :    
+            except ldap.LDAPError, msg :
                 message = (_("Search for %s(%s) from %s(scope=%s) returned no answer.") % (key, fields, base, scope)) + " : %s" % msg
                 self.tool.printInfo("LDAP error : %s" % message, "error")
@@ -172 +172 @@
                 self.close()
                 self.secondStageInit()
-            else :     
+            else :
                 self.querydebug("QUERY : Result : %s" % result)
                 result = [ (dn, cidict(attrs)) for (dn, attrs) in result ]
@@ -181 +181 @@
                 return result
         raise PyKotaStorageError, message
-            
+
     def doAdd(self, dn, fields) :
         """Adds an entry in the LDAP directory."""
@@ -192 +192 @@
                 self.querydebug("%s" % entry)
                 self.database.add_s(dn, entry)
-            except ldap.ALREADY_EXISTS, msg :        
+            except ldap.ALREADY_EXISTS, msg :
                 raise PyKotaStorageError, "Entry %s already exists : %s" % (dn, msg)
             except ldap.LDAPError, msg :
@@ -206 +206 @@
                 return dn
         raise PyKotaStorageError, message
-            
+
     def doDelete(self, dn) :
         """Deletes an entry from the LDAP directory."""
@@ -214 +214 @@
                 self.querydebug("QUERY : Delete(%s)" % dn)
                 self.database.delete_s(dn)
-            except ldap.NO_SUCH_OBJECT :    
+            except ldap.NO_SUCH_OBJECT :
                 self.tool.printInfo("Entry %s was already missing before we deleted it. This **MAY** be normal." % dn, "info")
             except ldap.LDAPError, msg :
@@ -222 +222 @@
                 self.close()
                 self.secondStageInit()
-            else :    
+            else :
                 if self.useldapcache :
                     try :
                         self.querydebug("LDAP cache del %s" % dn)
                         del self.ldapcache[dn]
-                    except KeyError :    
+                    except KeyError :
                         pass
-                return        
+                return
         raise PyKotaStorageError, message
-            
+
     def doModify(self, dn, fields, ignoreold=1, flushcache=0) :
         """Modifies an entry in the LDAP directory."""
@@ -246 +246 @@
                             if k != "createTimestamp" :
                                 oldentry[k] = v
-                    else :    
+                    else :
                         self.querydebug("LDAP cache miss %s" % dn)
                         oldentry = self.doSearch("objectClass=*", base=dn, scope=ldap.SCOPE_BASE)[0][1]
-                else :        
+                else :
                     oldentry = self.doSearch("objectClass=*", base=dn, scope=ldap.SCOPE_BASE, flushcache=flushcache)[0][1]
                 for (k, v) in fields.items() :
@@ -255 +255 @@
                         try :
                             oldvalue = v["convert"](oldentry.get(k, [0])[0])
-                        except ValueError :    
+                        except ValueError :
                             self.querydebug("Error converting %s with %s(%s)" % (oldentry.get(k), k, v))
                             oldvalue = 0
                         if v["operator"] == '+' :
                             newvalue = oldvalue + v["value"]
-                        else :    
+                        else :
                             newvalue = oldvalue - v["value"]
                         fields[k] = str(newvalue)
@@ -288 +288 @@
                             try :
                                 del cachedentry[mtyp]
-                            except KeyError :    
+                            except KeyError :
                                 pass
                     self.querydebug("LDAP cache update %s => %s" % (dn, cachedentry))
                 return dn
         raise PyKotaStorageError, message
-            
+
     def filterNames(self, records, attribute, patterns=None) :
         """Returns a list of 'attribute' from a list of records.
-        
+
            Logs any missing attribute.
-        """   
+        """
         result = []
         for (dn, record) in records :
@@ -309 +309 @@
                     if (not isinstance(patterns, type([]))) and (not isinstance(patterns, type(()))) :
                         patterns = [ patterns ]
-                    if self.tool.matchString(attrval, patterns) :   
+                    if self.tool.matchString(attrval, patterns) :
                         result.append(attrval)
-                else :    
+                else :
                     result.append(attrval)
-        return result        
-                
-    def getAllBillingCodes(self, billingcode=None) :    
+        return result
+
+    def getAllBillingCodes(self, billingcode=None) :
         """Extracts all billing codes or only the billing codes matching the optional parameter."""
         ldapfilter = "objectClass=pykotaBilling"
@@ -321 +321 @@
         if result :
             return self.filterNames(result, "pykotaBillingCode", billingcode)
-        else :    
+        else :
             return []
-        
-    def getAllPrintersNames(self, printername=None) :    
+
+    def getAllPrintersNames(self, printername=None) :
         """Extracts all printer names or only the printers' names matching the optional parameter."""
         ldapfilter = "objectClass=pykotaPrinter"
@@ -330 +330 @@
         if result :
             return self.filterNames(result, "pykotaPrinterName", printername)
-        else :    
+        else :
             return []
-        
-    def getAllUsersNames(self, username=None) :    
+
+    def getAllUsersNames(self, username=None) :
         """Extracts all user names or only the users' names matching the optional parameter."""
         ldapfilter = "objectClass=pykotaAccount"
@@ -339 +339 @@
         if result :
             return self.filterNames(result, "pykotaUserName", username)
-        else :    
+        else :
             return []
-        
-    def getAllGroupsNames(self, groupname=None) :    
+
+    def getAllGroupsNames(self, groupname=None) :
         """Extracts all group names or only the groups' names matching the optional parameter."""
         ldapfilter = "objectClass=pykotaGroup"
@@ -348 +348 @@
         if result :
             return self.filterNames(result, "pykotaGroupName", groupname)
-        else :    
+        else :
             return []
-        
+
     def getUserNbJobsFromHistory(self, user) :
         """Returns the number of jobs the user has in history."""
         result = self.doSearch("(&(pykotaUserName=%s)(objectClass=pykotaJob))" % unicodeToDatabase(user.Name), None, base=self.info["jobbase"])
         return len(result)
-        
-    def getUserFromBackend(self, username) :    
+
+    def getUserFromBackend(self, username) :
         """Extracts user information given its name."""
         user = StorageUser(self, username)
@@ -377 +377 @@
                     if user.AccountBalance[0].upper() == "NONE" :
                         user.AccountBalance = None
-                    else :    
+                    else :
                         user.AccountBalance = float(user.AccountBalance[0])
-                user.AccountBalance = user.AccountBalance or 0.0        
+                user.AccountBalance = user.AccountBalance or 0.0
                 user.LifeTimePaid = fields.get("pykotaLifeTimePaid")
                 user.OverCharge = float(fields.get("pykotaOverCharge", [1.0])[0])
@@ -385 +385 @@
                     if user.LifeTimePaid[0].upper() == "NONE" :
                         user.LifeTimePaid = None
-                    else :    
+                    else :
                         user.LifeTimePaid = float(user.LifeTimePaid[0])
-                user.LifeTimePaid = user.LifeTimePaid or 0.0        
+                user.LifeTimePaid = user.LifeTimePaid or 0.0
                 user.Payments = []
                 for payment in fields.get("pykotaPayments", []) :
@@ -396 +396 @@
                         (date, amount) = payment.split(" # ")
                         description = ""
-                    else :    
+                    else :
                         description = databaseToUnicode(base64.decodestring(description))
-                    if amount.endswith(" #") :    
+                    if amount.endswith(" #") :
                         amount = amount[:-2] # TODO : should be catched earlier, the bug is above I think
                     user.Payments.append((date, float(amount), description))
             user.Exists = True
         return user
-       
-    def getGroupFromBackend(self, groupname) :    
+
+    def getGroupFromBackend(self, groupname) :
         """Extracts group information given its name."""
         group = StorageGroup(self, groupname)
@@ -423 +423 @@
             group.Exists = True
         return group
-       
-    def getPrinterFromBackend(self, printername) :        
+
+    def getPrinterFromBackend(self, printername) :
         """Extracts printer information given its name : returns first matching printer."""
         printer = StoragePrinter(self, printername)
@@ -447 +447 @@
                 printer.PassThrough = 0
             printer.uniqueMember = fields.get("uniqueMember", [])
-            printer.Description = databaseToUnicode(fields.get("description", [""])[0]) 
+            printer.Description = databaseToUnicode(fields.get("description", [""])[0])
             printer.Exists = True
-        return printer    
-        
-    def getUserPQuotaFromBackend(self, user, printer) :        
+        return printer
+
+    def getUserPQuotaFromBackend(self, user, printer) :
         """Extracts a user print quota."""
         userpquota = StorageUserPQuota(self, user, printer)
@@ -457 +457 @@
             if self.info["userquotabase"].lower() == "user" :
                 base = user.ident
-            else :    
+            else :
                 base = self.info["userquotabase"]
             result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaUserName=%s)(pykotaPrinterName=%s))" % \
@@ -473 +473 @@
                     if userpquota.SoftLimit[0].upper() == "NONE" :
                         userpquota.SoftLimit = None
-                    else :    
+                    else :
                         userpquota.SoftLimit = int(userpquota.SoftLimit[0])
                 userpquota.HardLimit = fields.get("pykotaHardLimit")
@@ -479 +479 @@
                     if userpquota.HardLimit[0].upper() == "NONE" :
                         userpquota.HardLimit = None
-                    elif userpquota.HardLimit is not None :    
+                    elif userpquota.HardLimit is not None :
                         userpquota.HardLimit = int(userpquota.HardLimit[0])
                 userpquota.DateLimit = fields.get("pykotaDateLimit")
                 if userpquota.DateLimit is not None :
-                    if userpquota.DateLimit[0].upper() == "NONE" : 
+                    if userpquota.DateLimit[0].upper() == "NONE" :
                         userpquota.DateLimit = None
-                    else :    
+                    else :
                         userpquota.DateLimit = userpquota.DateLimit[0]
                 userpquota.MaxJobSize = fields.get("pykotaMaxJobSize")
@@ -491 +491 @@
                     if userpquota.MaxJobSize[0].upper() == "NONE" :
                         userpquota.MaxJobSize = None
-                    else :    
+                    else :
                         userpquota.MaxJobSize = int(userpquota.MaxJobSize[0])
                 userpquota.Exists = True
         return userpquota
-        
-    def getGroupPQuotaFromBackend(self, group, printer) :        
+
+    def getGroupPQuotaFromBackend(self, group, printer) :
         """Extracts a group print quota."""
         grouppquota = StorageGroupPQuota(self, group, printer)
@@ -502 +502 @@
             if self.info["groupquotabase"].lower() == "group" :
                 base = group.ident
-            else :    
+            else :
                 base = self.info["groupquotabase"]
             result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaGroupName=%s)(pykotaPrinterName=%s))" % \
@@ -515 +515 @@
                     if grouppquota.SoftLimit[0].upper() == "NONE" :
                         grouppquota.SoftLimit = None
-                    else :    
+                    else :
                         grouppquota.SoftLimit = int(grouppquota.SoftLimit[0])
                 grouppquota.HardLimit = fields.get("pykotaHardLimit")
@@ -521 +521 @@
                     if grouppquota.HardLimit[0].upper() == "NONE" :
                         grouppquota.HardLimit = None
-                    else :    
+                    else :
                         grouppquota.HardLimit = int(grouppquota.HardLimit[0])
                 grouppquota.DateLimit = fields.get("pykotaDateLimit")
                 if grouppquota.DateLimit is not None :
-                    if grouppquota.DateLimit[0].upper() == "NONE" : 
+                    if grouppquota.DateLimit[0].upper() == "NONE" :
                         grouppquota.DateLimit = None
-                    else :    
+                    else :
                         grouppquota.DateLimit = grouppquota.DateLimit[0]
                 grouppquota.MaxJobSize = fields.get("pykotaMaxJobSize")
@@ -533 +533 @@
                     if grouppquota.MaxJobSize[0].upper() == "NONE" :
                         grouppquota.MaxJobSize = None
-                    else :    
+                    else :
                         grouppquota.MaxJobSize = int(grouppquota.MaxJobSize[0])
                 grouppquota.PageCounter = 0
@@ -548 +548 @@
                                           ["pykotaPageCounter", "pykotaLifePageCounter"], base=base)
                 if result :
-                    for userpquota in result :    
+                    for userpquota in result :
                         grouppquota.PageCounter += int(userpquota[1].get("pykotaPageCounter", [0])[0] or 0)
                         grouppquota.LifePageCounter += int(userpquota[1].get("pykotaLifePageCounter", [0])[0] or 0)
                 grouppquota.Exists = True
         return grouppquota
-        
-    def getPrinterLastJobFromBackend(self, printer) :        
+
+    def getPrinterLastJobFromBackend(self, printer) :
         """Extracts a printer's last job information."""
         lastjob = StorageLastJob(self, printer)
@@ -567 +567 @@
             result = None
             try :
-                result = self.doSearch("objectClass=pykotaJob", [ "pykotaJobSizeBytes", 
-                                                                  "pykotaHostName", 
-                                                                  "pykotaUserName", 
-                                                                  "pykotaPrinterName", 
-                                                                  "pykotaJobId", 
-                                                                  "pykotaPrinterPageCounter", 
-                                                                  "pykotaJobSize", 
-                                                                  "pykotaAction", 
-                                                                  "pykotaJobPrice", 
-                                                                  "pykotaFileName", 
-                                                                  "pykotaTitle", 
-                                                                  "pykotaCopies", 
-                                                                  "pykotaOptions", 
-                                                                  "pykotaBillingCode", 
-                                                                  "pykotaPages", 
-                                                                  "pykotaMD5Sum", 
+                result = self.doSearch("objectClass=pykotaJob", [ "pykotaJobSizeBytes",
+                                                                  "pykotaHostName",
+                                                                  "pykotaUserName",
+                                                                  "pykotaPrinterName",
+                                                                  "pykotaJobId",
+                                                                  "pykotaPrinterPageCounter",
+                                                                  "pykotaJobSize",
+                                                                  "pykotaAction",
+                                                                  "pykotaJobPrice",
+                                                                  "pykotaFileName",
+                                                                  "pykotaTitle",
+                                                                  "pykotaCopies",
+                                                                  "pykotaOptions",
+                                                                  "pykotaBillingCode",
+                                                                  "pykotaPages",
+                                                                  "pykotaMD5Sum",
                                                                   "pykotaPrecomputedJobSize",
                                                                   "pykotaPrecomputedJobPrice",
-                                                                  "createTimestamp" ], 
+                                                                  "createTimestamp" ],
                                                                 base="cn=%s,%s" % (lastjobident, self.info["jobbase"]), scope=ldap.SCOPE_BASE)
-            except PyKotaStorageError :    
-                pass # Last job entry exists, but job probably doesn't exist anymore. 
+            except PyKotaStorageError :
+                pass # Last job entry exists, but job probably doesn't exist anymore.
             if result :
                 fields = result[0][1]
@@ -597 +597 @@
                 try :
                     lastjob.JobSize = int(fields.get("pykotaJobSize", [0])[0])
-                except ValueError :    
+                except ValueError :
                     lastjob.JobSize = None
-                try :    
+                try :
                     lastjob.JobPrice = float(fields.get("pykotaJobPrice", [0.0])[0])
-                except ValueError :    
+                except ValueError :
                     lastjob.JobPrice = None
                 lastjob.JobAction = databaseToUnicode(fields.get("pykotaAction", [""])[0])
-                lastjob.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0]) 
-                lastjob.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0]) 
+                lastjob.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0])
+                lastjob.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0])
                 lastjob.JobCopies = int(fields.get("pykotaCopies", [0])[0])
-                lastjob.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0]) 
+                lastjob.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0])
                 lastjob.JobHostName = databaseToUnicode(fields.get("pykotaHostName", [""])[0])
                 lastjob.JobSizeBytes = fields.get("pykotaJobSizeBytes", [0L])[0]
@@ -615 +615 @@
                 try :
                     lastjob.PrecomputedJobSize = int(fields.get("pykotaPrecomputedJobSize", [0])[0])
-                except ValueError :    
+                except ValueError :
                     lastjob.PrecomputedJobSize = None
-                try :    
+                try :
                     lastjob.PrecomputedJobPrice = float(fields.get("pykotaPrecomputedJobPrice", [0.0])[0])
-                except ValueError :    
+                except ValueError :
                     lastjob.PrecomputedJobPrice = None
                 if lastjob.JobTitle == lastjob.JobFileName == lastjob.JobOptions == u"hidden" :
@@ -628 +628 @@
                 lastjob.Exists = True
         return lastjob
-        
-    def getGroupMembersFromBackend(self, group) :        
+
+    def getGroupMembersFromBackend(self, group) :
         """Returns the group's members list."""
         groupmembers = []
@@ -640 +640 @@
             for username in result[0][1].get(self.info["groupmembers"], []) :
                 groupmembers.append(self.getUser(databaseToUnicode(username)))
-        return groupmembers        
-        
-    def getUserGroupsFromBackend(self, user) :        
+        return groupmembers
+
+    def getUserGroupsFromBackend(self, user) :
         """Returns the user's groups list."""
         groups = []
@@ -660 +660 @@
                     if group.LimitBy is not None :
                         group.LimitBy = databaseToUnicode(group.LimitBy[0])
-                    else :    
+                    else :
                         group.LimitBy = u"quota"
                     group.AccountBalance = 0.0
@@ -671 +671 @@
                     self.cacheEntry("GROUPS", group.Name, group)
                 groups.append(group)
-        return groups        
-        
-    def getParentPrintersFromBackend(self, printer) :    
+        return groups
+
+    def getParentPrintersFromBackend(self, printer) :
         """Get all the printer groups this printer is a member of."""
         pgroups = []
@@ -687 +687 @@
                         pgroups.append(parentprinter)
         return pgroups
-        
+
     def getMatchingPrinters(self, printerpattern) :
         """Returns the list of all printers for which name matches a certain pattern."""
@@ -699 +699 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -718 +718 @@
                         printer.PassThrough = 0
                     printer.uniqueMember = fields.get("uniqueMember", [])
-                    printer.Description = databaseToUnicode(fields.get("description", [""])[0]) 
+                    printer.Description = databaseToUnicode(fields.get("description", [""])[0])
                     printer.Exists = True
                     printers.append(printer)
                     self.cacheEntry("PRINTERS", printer.Name, printer)
-        return printers        
-        
+        return printers
+
     def getMatchingUsers(self, userpattern) :
         """Returns the list of all users for which name matches a certain pattern."""
@@ -735 +735 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -747 +747 @@
                     user.Email = databaseToUnicode(fields.get(self.info["usermail"], [None])[0])
                     user.LimitBy = databaseToUnicode(fields.get("pykotaLimitBy", ["quota"])[0])
-                    user.Description = databaseToUnicode(fields.get("description", [""])[0]) 
+                    user.Description = databaseToUnicode(fields.get("description", [""])[0])
                     uname = unicodeToDatabase(username)
                     result = self.doSearch("(&(objectClass=pykotaAccountBalance)(|(pykotaUserName=%s)(%s=%s)))" % \
@@ -763 +763 @@
                             if user.AccountBalance[0].upper() == "NONE" :
                                 user.AccountBalance = None
-                            else :    
+                            else :
                                 user.AccountBalance = float(user.AccountBalance[0])
-                        user.AccountBalance = user.AccountBalance or 0.0        
+                        user.AccountBalance = user.AccountBalance or 0.0
                         user.LifeTimePaid = fields.get("pykotaLifeTimePaid")
                         if user.LifeTimePaid is not None :
                             if user.LifeTimePaid[0].upper() == "NONE" :
                                 user.LifeTimePaid = None
-                            else :    
+                            else :
                                 user.LifeTimePaid = float(user.LifeTimePaid[0])
-                        user.LifeTimePaid = user.LifeTimePaid or 0.0        
+                        user.LifeTimePaid = user.LifeTimePaid or 0.0
                         user.Payments = []
                         for payment in fields.get("pykotaPayments", []) :
@@ -781 +781 @@
                                 (date, amount) = payment.split(" # ")
                                 description = ""
-                            else :    
+                            else :
                                 description = databaseToUnicode(base64.decodestring(description))
-                            if amount.endswith(" #") :    
+                            if amount.endswith(" #") :
                                 amount = amount[:-2] # TODO : should be catched earlier, the bug is above I think
                             user.Payments.append((date, float(amount), description))
@@ -789 +789 @@
                     users.append(user)
                     self.cacheEntry("USERS", user.Name, user)
-        return users       
-        
+        return users
+
     def getMatchingGroups(self, grouppattern) :
         """Returns the list of all groups for which name matches a certain pattern."""
@@ -802 +802 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -812 +812 @@
                     group = StorageGroup(self, groupname)
                     group.ident = groupid
-                    group.Name = databaseToUnicode(fields.get("pykotaGroupName", [groupname])[0]) 
+                    group.Name = databaseToUnicode(fields.get("pykotaGroupName", [groupname])[0])
                     group.LimitBy = databaseToUnicode(fields.get("pykotaLimitBy", ["quota"])[0])
-                    group.Description = databaseToUnicode(fields.get("description", [""])[0]) 
+                    group.Description = databaseToUnicode(fields.get("description", [""])[0])
                     group.AccountBalance = 0.0
                     group.LifeTimePaid = 0.0
@@ -825 +825 @@
                     self.cacheEntry("GROUPS", group.Name, group)
         return groups
-        
-    def getPrinterUsersAndQuotas(self, printer, names=["*"]) :        
+
+    def getPrinterUsersAndQuotas(self, printer, names=["*"]) :
         """Returns the list of users who uses a given printer, along with their quotas."""
         usersandquotas = []
@@ -851 +851 @@
                     if userpquota.SoftLimit[0].upper() == "NONE" :
                         userpquota.SoftLimit = None
-                    else :    
+                    else :
                         userpquota.SoftLimit = int(userpquota.SoftLimit[0])
                 userpquota.HardLimit = fields.get("pykotaHardLimit")
@@ -857 +857 @@
                     if userpquota.HardLimit[0].upper() == "NONE" :
                         userpquota.HardLimit = None
-                    elif userpquota.HardLimit is not None :    
+                    elif userpquota.HardLimit is not None :
                         userpquota.HardLimit = int(userpquota.HardLimit[0])
                 userpquota.DateLimit = fields.get("pykotaDateLimit")
                 if userpquota.DateLimit is not None :
-                    if userpquota.DateLimit[0].upper() == "NONE" : 
+                    if userpquota.DateLimit[0].upper() == "NONE" :
                         userpquota.DateLimit = None
-                    else :    
+                    else :
                         userpquota.DateLimit = userpquota.DateLimit[0]
                 userpquota.Exists = True
                 usersandquotas.append((user, userpquota))
                 self.cacheEntry("USERPQUOTAS", "%s@%s" % (user.Name, printer.Name), userpquota)
-        usersandquotas.sort(lambda x, y : cmp(x[0].Name, y[0].Name))            
+        usersandquotas.sort(lambda x, y : cmp(x[0].Name, y[0].Name))
         return usersandquotas
-                
-    def getPrinterGroupsAndQuotas(self, printer, names=["*"]) :        
+
+    def getPrinterGroupsAndQuotas(self, printer, names=["*"]) :
         """Returns the list of groups which uses a given printer, along with their quotas."""
         groupsandquotas = []
@@ -889 +889 @@
                 grouppquota = self.getGroupPQuota(group, printer)
                 groupsandquotas.append((group, grouppquota))
-        groupsandquotas.sort(lambda x, y : cmp(x[0].Name, y[0].Name))            
+        groupsandquotas.sort(lambda x, y : cmp(x[0].Name, y[0].Name))
         return groupsandquotas
-        
+
     def addPrinter(self, printer) :
         """Adds a printer to the quota storage, returns the old value if it already exists."""
@@ -907 +907 @@
                    "pykotaPricePerPage" : str(printer.PricePerPage or 0.0),
                    "pykotaPricePerJob" : str(printer.PricePerJob or 0.0),
-                 } 
+                 }
         dn = "%s=%s,%s" % (self.info["printerrdn"], printername, self.info["printerbase"])
         self.doAdd(dn, fields)
         printer.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def addUser(self, user) :        
+
+    def addUser(self, user) :
         """Adds a user to the quota storage, returns the old value if it already exists."""
         oldentry = self.getUser(user.Name)
@@ -924 +924 @@
                        "description" : unicodeToDatabase(user.Description or ""),
                        self.info["usermail"] : unicodeToDatabase(user.Email or ""),
-                    }   
-                       
+                    }
+
         mustadd = 1
         if self.info["newuser"].lower() != 'below' :
@@ -943 +943 @@
                 fields.update({ "pykotaBalance" : str(user.AccountBalance or 0.0),
                                 "pykotaOverCharge" : str(user.OverCharge),
-                                "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0), })   
+                                "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0), })
                 self.doModify(dn, fields)
                 mustadd = 0
             else :
                 message = _("Unable to find an existing objectClass %s entry with %s=%s to attach pykotaAccount objectClass") % (where, self.info["userrdn"], user.Name)
-                if action.lower() == "warn" :    
+                if action.lower() == "warn" :
                     self.tool.printInfo(_("%s. A new entry will be created instead.") % message, "warn")
                 else : # 'fail' or incorrect setting
                     raise PyKotaStorageError, "%s. Action aborted. Please check your configuration." % message
-                
+
         if mustadd :
-            if self.info["userbase"] == self.info["balancebase"] :            
+            if self.info["userbase"] == self.info["balancebase"] :
                 fields = { self.info["userrdn"] : uname,
                            "objectClass" : ["pykotaObject", "pykotaAccount", "pykotaAccountBalance"],
@@ -960 +960 @@
                            "pykotaBalance" : str(user.AccountBalance or 0.0),
                            "pykotaOverCharge" : str(user.OverCharge),
-                           "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0), 
-                         } 
-            else :             
+                           "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),
+                         }
+            else :
                 fields = { self.info["userrdn"] : uname,
                            "objectClass" : ["pykotaObject", "pykotaAccount"],
                            "cn" : uname,
-                         } 
-            fields.update(newfields)         
+                         }
+            fields.update(newfields)
             dn = "%s=%s,%s" % (self.info["userrdn"], uname, self.info["userbase"])
             self.doAdd(dn, fields)
-            if self.info["userbase"] != self.info["balancebase"] :            
+            if self.info["userbase"] != self.info["balancebase"] :
                 fields = { self.info["balancerdn"] : uname,
                            "objectClass" : ["pykotaObject", "pykotaAccountBalance"],
@@ -976 +976 @@
                            "pykotaBalance" : str(user.AccountBalance or 0.0),
                            "pykotaOverCharge" : str(user.OverCharge),
-                           "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),  
-                         } 
+                           "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),
+                         }
                 dn = "%s=%s,%s" % (self.info["balancerdn"], uname, self.info["balancebase"])
                 self.doAdd(dn, fields)
@@ -987 +987 @@
         user.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def addGroup(self, group) :        
+
+    def addGroup(self, group) :
         """Adds a group to the quota storage, returns the old value if it already exists."""
         oldentry = self.getGroup(group.Name)
@@ -994 +994 @@
             return oldentry # we return the existing entry
         gname = unicodeToDatabase(group.Name)
-        newfields = { 
+        newfields = {
                       "pykotaGroupName" : gname,
                       "pykotaLimitBy" : unicodeToDatabase(group.LimitBy or u"quota"),
                       "description" : unicodeToDatabase(group.Description or "")
-                    } 
+                    }
         mustadd = 1
         if self.info["newgroup"].lower() != 'below' :
@@ -1018 +1018 @@
             else :
                 message = _("Unable to find an existing entry to attach pykotaGroup objectclass %s") % group.Name
-                if action.lower() == "warn" :    
+                if action.lower() == "warn" :
                     self.tool.printInfo("%s. A new entry will be created instead." % message, "warn")
                 else : # 'fail' or incorrect setting
                     raise PyKotaStorageError, "%s. Action aborted. Please check your configuration." % message
-                
+
         if mustadd :
             fields = { self.info["grouprdn"] : gname,
                        "objectClass" : ["pykotaObject", "pykotaGroup"],
                        "cn" : gname,
-                     } 
-            fields.update(newfields)         
+                     }
+            fields.update(newfields)
             dn = "%s=%s,%s" % (self.info["grouprdn"], gname, self.info["groupbase"])
             self.doAdd(dn, fields)
         group.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def addUserToGroup(self, user, group) :    
+
+    def addUserToGroup(self, user, group) :
         """Adds an user to a group."""
         if user.Name not in [u.Name for u in self.getGroupMembers(group)] :
-            result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)    
+            result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)
             if result :
                 fields = result[0][1]
@@ -1045 +1045 @@
                 self.doModify(group.ident, fields)
                 group.Members.append(user)
-                
-    def delUserFromGroup(self, user, group) :    
+
+    def delUserFromGroup(self, user, group) :
         """Removes an user from a group."""
         if user.Name in [u.Name for u in self.getGroupMembers(group)] :
@@ -1054 +1054 @@
                 if not fields.has_key(self.info["groupmembers"]) :
                     fields[self.info["groupmembers"]] = []
-                try :    
+                try :
                     fields[self.info["groupmembers"]].remove(unicodeToDatabase(user.Name))
                 except ValueError :
@@ -1061 +1061 @@
                     self.doModify(group.ident, fields)
                     group.Members.remove(user)
-                
+
     def addUserPQuota(self, upq) :
         """Initializes a user print quota on a printer."""
@@ -1082 +1082 @@
                    "pykotaWarnCount" : str(upq.WarnCount or 0),
                    "pykotaMaxJobSize" : str(upq.MaxJobSize or 0),
-                 } 
+                 }
         if self.info["userquotabase"].lower() == "user" :
             dn = "cn=%s,%s" % (uuid, upq.User.ident)
-        else :    
+        else :
             dn = "cn=%s,%s" % (uuid, self.info["userquotabase"])
         self.doAdd(dn, fields)
         upq.isDirty = False
         return None # the entry created doesn't need further modification
-        
+
     def addGroupPQuota(self, gpq) :
         """Initializes a group print quota on a printer."""
@@ -1104 +1104 @@
                    "pykotaPrinterName" : pname,
                    "pykotaDateLimit" : "None",
-                 } 
+                 }
         if self.info["groupquotabase"].lower() == "group" :
             dn = "cn=%s,%s" % (uuid, gpq.Group.ident)
-        else :    
+        else :
             dn = "cn=%s,%s" % (uuid, self.info["groupquotabase"])
         self.doAdd(dn, fields)
         gpq.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def savePrinter(self, printer) :    
+
+    def savePrinter(self, printer) :
         """Saves the printer to the database in a single operation."""
         fields = {
@@ -1123 +1123 @@
                  }
         self.doModify(printer.ident, fields)
-        
+
     def saveUser(self, user) :
         """Saves the user to the database in a single operation."""
         newfields = {
                        "pykotaLimitBy" : unicodeToDatabase(user.LimitBy or u"quota"),
-                       "description" : unicodeToDatabase(user.Description or ""), 
+                       "description" : unicodeToDatabase(user.Description or ""),
                        self.info["usermail"] : user.Email or "",
-                    }   
+                    }
         self.doModify(user.ident, newfields)
-        
+
         newfields = { "pykotaBalance" : str(user.AccountBalance or 0.0),
-                      "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0), 
+                      "pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),
                       "pykotaOverCharge" : str(user.OverCharge),
                     }
         self.doModify(user.idbalance, newfields)
-        
+
     def saveGroup(self, group) :
         """Saves the group to the database in a single operation."""
         newfields = {
                        "pykotaLimitBy" : unicodeToDatabase(group.LimitBy or u"quota"),
-                       "description" : unicodeToDatabase(group.Description or ""), 
-                    }   
+                       "description" : unicodeToDatabase(group.Description or ""),
+                    }
         self.doModify(group.ident, newfields)
-        
-    def writeUserPQuotaDateLimit(self, userpquota, datelimit) :    
+
+    def writeUserPQuotaDateLimit(self, userpquota, datelimit) :
         """Sets the date limit permanently for a user print quota."""
         fields = {
@@ -1153 +1153 @@
                  }
         return self.doModify(userpquota.ident, fields)
-            
-    def writeGroupPQuotaDateLimit(self, grouppquota, datelimit) :    
+
+    def writeGroupPQuotaDateLimit(self, grouppquota, datelimit) :
         """Sets the date limit permanently for a group print quota."""
         fields = {
@@ -1160 +1160 @@
                  }
         return self.doModify(grouppquota.ident, fields)
-        
-    def increaseUserPQuotaPagesCounters(self, userpquota, nbpages) :    
+
+    def increaseUserPQuotaPagesCounters(self, userpquota, nbpages) :
         """Increase page counters for a user print quota."""
         fields = {
@@ -1167 +1167 @@
                    "pykotaLifePageCounter" : { "operator" : "+", "value" : nbpages, "convert" : int },
                  }
-        return self.doModify(userpquota.ident, fields)         
-        
-    def decreaseUserAccountBalance(self, user, amount) :    
+        return self.doModify(userpquota.ident, fields)
+
+    def decreaseUserAccountBalance(self, user, amount) :
         """Decreases user's account balance from an amount."""
         fields = {
                    "pykotaBalance" : { "operator" : "-", "value" : amount, "convert" : float },
                  }
-        return self.doModify(user.idbalance, fields, flushcache=1)         
-       
+        return self.doModify(user.idbalance, fields, flushcache=1)
+
     def writeNewPayment(self, user, amount, comment="") :
         """Adds a new payment to the payments history."""
@@ -1185 +1185 @@
                    "pykotaPayments" : payments,
                  }
-        return self.doModify(user.idbalance, fields)         
-        
-    def writeLastJobSize(self, lastjob, jobsize, jobprice) :        
+        return self.doModify(user.idbalance, fields)
+
+    def writeLastJobSize(self, lastjob, jobsize, jobprice) :
         """Sets the last job's size permanently."""
         fields = {
@@ -1193 +1193 @@
                    "pykotaJobPrice" : str(jobprice),
                  }
-        self.doModify(lastjob.ident, fields)         
-        
+        self.doModify(lastjob.ident, fields)
+
     def writeJobNew(self, printer, user, jobid, pagecounter, action, jobsize=None, jobprice=None, filename=None, title=None, copies=None, options=None, clienthost=None, jobsizebytes=None, jobmd5sum=None, jobpages=None, jobbilling=None, precomputedsize=None, precomputedprice=None) :
         """Adds a job in a printer's history."""
@@ -1202 +1202 @@
             uuid = self.genUUID()
             dn = "cn=%s,%s" % (uuid, self.info["jobbase"])
-        else :    
+        else :
             uuid = printer.LastJob.ident[3:].split(",")[0]
             dn = printer.LastJob.ident
-        if self.privacy :    
+        if self.privacy :
             # For legal reasons, we want to hide the title, filename and options
             title = filename = options = u"hidden"
@@ -1216 +1216 @@
                    "pykotaPrinterPageCounter" : str(pagecounter),
                    "pykotaAction" : unicodeToDatabase(action),
-                   "pykotaFileName" : ((filename is None) and "None") or unicodeToDatabase(filename), 
-                   "pykotaTitle" : ((title is None) and "None") or unicodeToDatabase(title), 
-                   "pykotaCopies" : str(copies), 
-                   "pykotaOptions" : ((options is None) and "None") or unicodeToDatabase(options), 
-                   "pykotaHostName" : str(clienthost), 
+                   "pykotaFileName" : ((filename is None) and "None") or unicodeToDatabase(filename),
+                   "pykotaTitle" : ((title is None) and "None") or unicodeToDatabase(title),
+                   "pykotaCopies" : str(copies),
+                   "pykotaOptions" : ((options is None) and "None") or unicodeToDatabase(options),
+                   "pykotaHostName" : str(clienthost),
                    "pykotaJobSizeBytes" : str(jobsizebytes),
                    "pykotaMD5Sum" : unicodeToDatabase(jobmd5sum),
@@ -1229 +1229 @@
                  }
         if (not self.disablehistory) or (not printer.LastJob.Exists) :
-            if jobsize is not None :         
+            if jobsize is not None :
                 fields.update({ "pykotaJobSize" : str(jobsize), "pykotaJobPrice" : str(jobprice) })
             self.doAdd(dn, fields)
-        else :    
+        else :
             # here we explicitly want to reset jobsize to 'None' if needed
             fields.update({ "pykotaJobSize" : str(jobsize), "pykotaJobPrice" : str(jobprice) })
             self.doModify(dn, fields)
-            
+
         if printer.LastJob.Exists :
             fields = {
                        "pykotaLastJobIdent" : uuid,
                      }
-            self.doModify(printer.LastJob.lastjobident, fields)         
-        else :    
+            self.doModify(printer.LastJob.lastjobident, fields)
+        else :
             lastjuuid = self.genUUID()
             lastjdn = "cn=%s,%s" % (lastjuuid, self.info["lastjobbase"])
@@ -1250 +1250 @@
                        "pykotaPrinterName" : pname,
                        "pykotaLastJobIdent" : uuid,
-                     }  
-            self.doAdd(lastjdn, fields)          
-            
+                     }
+            self.doAdd(lastjdn, fields)
+
     def saveUserPQuota(self, userpquota) :
         """Saves an user print quota entry."""
-        fields = { 
+        fields = {
                    "pykotaSoftLimit" : str(userpquota.SoftLimit),
                    "pykotaHardLimit" : str(userpquota.HardLimit),
@@ -1265 +1265 @@
                  }
         self.doModify(userpquota.ident, fields)
-        
+
     def writeUserPQuotaWarnCount(self, userpquota, warncount) :
         """Sets the warn counter value for a user quota."""
-        fields = { 
+        fields = {
                    "pykotaWarnCount" : str(warncount or 0),
                  }
         self.doModify(userpquota.ident, fields)
-        
+
     def increaseUserPQuotaWarnCount(self, userpquota) :
         """Increases the warn counter value for a user quota."""
@@ -1278 +1278 @@
                    "pykotaWarnCount" : { "operator" : "+", "value" : 1, "convert" : int },
                  }
-        return self.doModify(userpquota.ident, fields)         
-        
+        return self.doModify(userpquota.ident, fields)
+
     def saveGroupPQuota(self, grouppquota) :
         """Saves a group print quota entry."""
-        fields = { 
+        fields = {
                    "pykotaSoftLimit" : str(grouppquota.SoftLimit),
                    "pykotaHardLimit" : str(grouppquota.HardLimit),
@@ -1289 +1289 @@
                  }
         self.doModify(grouppquota.ident, fields)
-            
+
     def writePrinterToGroup(self, pgroup, printer) :
         """Puts a printer into a printer group."""
@@ -1296 +1296 @@
             fields = {
                        "uniqueMember" : pgroup.uniqueMember
-                     }  
-            self.doModify(pgroup.ident, fields)         
-            
+                     }
+            self.doModify(pgroup.ident, fields)
+
     def removePrinterFromGroup(self, pgroup, printer) :
         """Removes a printer from a printer group."""
         try :
             pgroup.uniqueMember.remove(printer.ident)
-        except ValueError :    
+        except ValueError :
             pass
-        else :    
+        else :
             fields = {
                        "uniqueMember" : pgroup.uniqueMember,
-                     }  
-            self.doModify(pgroup.ident, fields)         
-            
+                     }
+            self.doModify(pgroup.ident, fields)
+
     def retrieveHistory(self, user=None, printer=None, hostname=None, billingcode=None, jobid=None, limit=100, start=None, end=None) :
         """Retrieves all print jobs for user on printer (or all) between start and end date, limited to first 100 results."""
@@ -1325 +1325 @@
         if jobid is not None :
             where.append("(pykotaJobId=%s)" % jobid) # TODO : jobid is text, so unicodeToDatabase(jobid) but do all of them as well.
-        if where :    
+        if where :
             where = "(&%s)" % "".join([precond] + where)
-        else :    
+        else :
             where = precond
-        jobs = []    
-        result = self.doSearch(where, fields=[ "pykotaJobSizeBytes", 
-                                               "pykotaHostName", 
-                                               "pykotaUserName", 
-                                               "pykotaPrinterName", 
-                                               "pykotaJobId", 
-                                               "pykotaPrinterPageCounter", 
-                                               "pykotaAction", 
-                                               "pykotaJobSize", 
-                                               "pykotaJobPrice", 
-                                               "pykotaFileName", 
-                                               "pykotaTitle", 
-                                               "pykotaCopies", 
-                                               "pykotaOptions", 
-                                               "pykotaBillingCode", 
-                                               "pykotaPages", 
-                                               "pykotaMD5Sum", 
+        jobs = []
+        result = self.doSearch(where, fields=[ "pykotaJobSizeBytes",
+                                               "pykotaHostName",
+                                               "pykotaUserName",
+                                               "pykotaPrinterName",
+                                               "pykotaJobId",
+                                               "pykotaPrinterPageCounter",
+                                               "pykotaAction",
+                                               "pykotaJobSize",
+                                               "pykotaJobPrice",
+                                               "pykotaFileName",
+                                               "pykotaTitle",
+                                               "pykotaCopies",
+                                               "pykotaOptions",
+                                               "pykotaBillingCode",
+                                               "pykotaPages",
+                                               "pykotaMD5Sum",
                                                "pykotaPrecomputedJobSize",
                                                "pykotaPrecomputedJobPrice",
-                                               "createTimestamp" ], 
+                                               "createTimestamp" ],
                                       base=self.info["jobbase"])
         if result :
@@ -1358 +1358 @@
                 try :
                     job.JobSize = int(fields.get("pykotaJobSize", [0])[0])
-                except ValueError :    
+                except ValueError :
                     job.JobSize = None
-                try :    
+                try :
                     job.JobPrice = float(fields.get("pykotaJobPrice", [0.0])[0])
                 except ValueError :
                     job.JobPrice = None
                 job.JobAction = databaseToUnicode(fields.get("pykotaAction", [""])[0])
-                job.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0]) 
-                job.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0]) 
+                job.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0])
+                job.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0])
                 job.JobCopies = int(fields.get("pykotaCopies", [0])[0])
-                job.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0]) 
+                job.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0])
                 job.JobHostName = databaseToUnicode(fields.get("pykotaHostName", [""])[0])
                 job.JobSizeBytes = fields.get("pykotaJobSizeBytes", [0L])[0]
@@ -1376 +1376 @@
                 try :
                     job.PrecomputedJobSize = int(fields.get("pykotaPrecomputedJobSize", [0])[0])
-                except ValueError :    
+                except ValueError :
                     job.PrecomputedJobSize = None
-                try :    
+                try :
                     job.PrecomputedJobPrice = float(fields.get("pykotaPrecomputedJobPrice", [0.0])[0])
                 except ValueError :
@@ -1395 +1395 @@
                     job.Exists = True
                     jobs.append(job)
-            jobs.sort(lambda x, y : cmp(y.JobDate, x.JobDate))        
-            if limit :    
+            jobs.sort(lambda x, y : cmp(y.JobDate, x.JobDate))
+            if limit :
                 jobs = jobs[:int(limit)]
         return jobs
-        
-    def deleteUser(self, user) :    
+
+    def deleteUser(self, user) :
         """Completely deletes an user from the Quota Storage."""
         uname = unicodeToDatabase(user.Name)
-        todelete = []    
+        todelete = []
         result = self.doSearch("(&(objectClass=pykotaJob)(pykotaUserName=%s))" % uname, base=self.info["jobbase"])
         for (ident, fields) in result :
@@ -1417 +1417 @@
             # ensure the user print quota entry will be deleted
             todelete.append(ident)
-            
+
             # if last job of current printer was printed by the user
             # to delete, we also need to delete the printer's last job entry.
@@ -1423 +1423 @@
             if printer.LastJob.UserName == user.Name :
                 todelete.append(printer.LastJob.lastjobident)
-            
-        for ident in todelete :    
+
+        for ident in todelete :
             self.doDelete(ident)
-            
-        result = self.doSearch("objectClass=pykotaAccount", None, base=user.ident, scope=ldap.SCOPE_BASE)    
+
+        result = self.doSearch("objectClass=pykotaAccount", None, base=user.ident, scope=ldap.SCOPE_BASE)
         if result :
             fields = result[0][1]
@@ -1433 +1433 @@
                 if k.startswith("pykota") :
                     del fields[k]
-                elif k.lower() == "objectclass" :    
+                elif k.lower() == "objectclass" :
                     todelete = []
                     for i in range(len(fields[k])) :
-                        if fields[k][i].startswith("pykota") : 
+                        if fields[k][i].startswith("pykota") :
                             todelete.append(i)
-                    todelete.sort()        
+                    todelete.sort()
                     todelete.reverse()
                     for i in todelete :
                         del fields[k][i]
             if fields.get("objectClass") or fields.get("objectclass") :
-                self.doModify(user.ident, fields, ignoreold=0)        
-            else :    
+                self.doModify(user.ident, fields, ignoreold=0)
+            else :
                 self.doDelete(user.ident)
         result = self.doSearch("(&(objectClass=pykotaAccountBalance)(pykotaUserName=%s))" % \
@@ -1452 +1452 @@
         for (ident, fields) in result :
             self.doDelete(ident)
-        
-    def deleteGroup(self, group) :    
+
+    def deleteGroup(self, group) :
         """Completely deletes a group from the Quota Storage."""
         gname = unicodeToDatabase(group.Name)
@@ -1466 +1466 @@
         for (ident, fields) in result :
             self.doDelete(ident)
-        result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)    
+        result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)
         if result :
             fields = result[0][1]
@@ -1472 +1472 @@
                 if k.startswith("pykota") :
                     del fields[k]
-                elif k.lower() == "objectclass" :    
+                elif k.lower() == "objectclass" :
                     todelete = []
                     for i in range(len(fields[k])) :
-                        if fields[k][i].startswith("pykota") : 
+                        if fields[k][i].startswith("pykota") :
                             todelete.append(i)
-                    todelete.sort()        
+                    todelete.sort()
                     todelete.reverse()
                     for i in todelete :
                         del fields[k][i]
             if fields.get("objectClass") or fields.get("objectclass") :
-                self.doModify(group.ident, fields, ignoreold=0)        
-            else :    
+                self.doModify(group.ident, fields, ignoreold=0)
+            else :
                 self.doDelete(group.ident)
-                
+
     def deleteManyBillingCodes(self, billingcodes) :
         """Deletes many billing codes."""
         for bcode in billingcodes :
             bcode.delete()
-        
-    def deleteManyUsers(self, users) :        
+
+    def deleteManyUsers(self, users) :
         """Deletes many users."""
         for user in users :
             user.delete()
-            
-    def deleteManyGroups(self, groups) :        
+
+    def deleteManyGroups(self, groups) :
         """Deletes many groups."""
         for group in groups :
             group.delete()
-        
-    def deleteManyPrinters(self, printers) :        
+
+    def deleteManyPrinters(self, printers) :
         """Deletes many printers."""
         for printer in printers :
             printer.delete()
-        
-    def deleteManyUserPQuotas(self, printers, users) :        
+
+    def deleteManyUserPQuotas(self, printers, users) :
         """Deletes many user print quota entries."""
         # TODO : grab all with a single (possibly VERY huge) filter if possible (might depend on the LDAP server !)
@@ -1514 +1514 @@
                 if upq.Exists :
                     upq.delete()
-            
+
     def deleteManyGroupPQuotas(self, printers, groups) :
         """Deletes many group print quota entries."""
@@ -1523 +1523 @@
                 if gpq.Exists :
                     gpq.delete()
-                
-    def deleteUserPQuota(self, upquota) :    
+
+    def deleteUserPQuota(self, upquota) :
         """Completely deletes an user print quota entry from the database."""
         uname = unicodeToDatabase(upquota.User.Name)
@@ -1536 +1536 @@
             self.doDelete(upquota.Printer.LastJob.lastjobident)
         self.doDelete(upquota.ident)
-        
-    def deleteGroupPQuota(self, gpquota) :    
+
+    def deleteGroupPQuota(self, gpquota) :
         """Completely deletes a group print quota entry from the database."""
         self.doDelete(gpquota.ident)
-                
-    def deletePrinter(self, printer) :    
+
+    def deletePrinter(self, printer) :
         """Completely deletes a printer from the Quota Storage."""
         pname = unicodeToDatabase(printer.Name)
@@ -1564 +1564 @@
         for (ident, fields) in result :
             self.doDelete(ident)
-        for parent in self.getParentPrinters(printer) :  
+        for parent in self.getParentPrinters(printer) :
             try :
                 parent.uniqueMember.remove(printer.ident)
-            except ValueError :    
+            except ValueError :
                 pass
-            else :    
+            else :
                 fields = {
                            "uniqueMember" : parent.uniqueMember,
-                         }  
-                self.doModify(parent.ident, fields)         
-        self.doDelete(printer.ident)    
-        
+                         }
+                self.doModify(parent.ident, fields)
+        self.doDelete(printer.ident)
+
     def deleteBillingCode(self, code) :
         """Deletes a billing code from the Quota Storage (no entries are deleted from the history)"""
         self.doDelete(code.ident)
-        
-    def sortRecords(self, fields, records, default, ordering) :     
+
+    def sortRecords(self, fields, records, default, ordering) :
         """Sort records based on list of fields prefixed with '+' (ASC) or '-' (DESC)."""
         fieldindexes = {}
         for i in range(len(fields)) :
             fieldindexes[fields[i]] = i
-        if not ordering :    
+        if not ordering :
             ordering = default
-        orderby = []    
+        orderby = []
         for orderkey in ordering :
             # Create ordering hints, ignoring unknown fields
@@ -1598 +1598 @@
                 if index is not None :
                     orderby.append((+1, index))
-            else :    
+            else :
                 index = fieldindexes.get(orderkey)
                 if index is not None :
                     orderby.append((+1, index))
-                
-        def compare(x, y, orderby=orderby) :    
+
+        def compare(x, y, orderby=orderby) :
             """Compares two records."""
             i = 0
@@ -1612 +1612 @@
                 if not result :
                     i += 1
-                else :    
+                else :
                     return sign * result
-            return 0 # identical keys        
-            
+            return 0 # identical keys
+
         records.sort(compare)
         return records
-        
+
     def extractPrinters(self, extractonly={}, ordering=[]) :
         """Extracts all printer records."""
@@ -1629 +1629 @@
                 if entry.PassThrough in (1, "1", "t", "true", "T", "TRUE", "True") :
                     passthrough = "t"
-                else :    
+                else :
                     passthrough = "f"
                 result.append((entry.ident, entry.Name, entry.PricePerPage, entry.PricePerJob, entry.Description, entry.MaxJobSize, passthrough))
-            return [fields] + self.sortRecords(fields, result, ["+dn"], ordering) 
-        
+            return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
+
     def extractUsers(self, extractonly={}, ordering=[]) :
         """Extracts all user records."""
@@ -1644 +1644 @@
                 result.append((entry.ident, entry.Name, entry.AccountBalance, entry.LifeTimePaid, entry.LimitBy, entry.Email, entry.Description, entry.OverCharge))
             return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
-        
+
     def extractBillingcodes(self, extractonly={}, ordering=[]) :
         """Extracts all billing codes records."""
@@ -1655 +1655 @@
                 result.append((entry.ident, entry.BillingCode, entry.Balance, entry.PageCounter, entry.Description))
             return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
-        
+
     def extractGroups(self, extractonly={}, ordering=[]) :
         """Extracts all group records."""
@@ -1666 +1666 @@
                 result.append((entry.ident, entry.Name, entry.LimitBy, entry.AccountBalance, entry.LifeTimePaid, entry.Description))
             return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
-        
+
     def extractPayments(self, extractonly={}, ordering=[]) :
         """Extracts all payment records."""
@@ -1685 +1685 @@
                         result.append((entry.Name, amount, date, description))
             return [fields] + self.sortRecords(fields, result, ["+date"], ordering)
-        
+
     def extractUpquotas(self, extractonly={}, ordering=[]) :
         """Extracts all userpquota records."""
@@ -1698 +1698 @@
                     result.append((user.Name, entry.Name, userpquota.ident, user.ident, entry.ident, userpquota.LifePageCounter, userpquota.PageCounter, userpquota.SoftLimit, userpquota.HardLimit, userpquota.DateLimit))
             return [fields] + self.sortRecords(fields, result, ["+userdn"], ordering)
-        
+
     def extractGpquotas(self, extractonly={}, ordering=[]) :
         """Extracts all grouppquota records."""
@@ -1711 +1711 @@
                     result.append((group.Name, entry.Name, grouppquota.ident, group.ident, entry.ident, grouppquota.LifePageCounter, grouppquota.PageCounter, grouppquota.SoftLimit, grouppquota.HardLimit, grouppquota.DateLimit))
             return [fields] + self.sortRecords(fields, result, ["+groupdn"], ordering)
-        
+
     def extractUmembers(self, extractonly={}, ordering=[]) :
         """Extracts all user groups members."""
@@ -1725 +1725 @@
                         result.append((entry.Name, member.Name, entry.ident, member.ident))
             return [fields] + self.sortRecords(fields, result, ["+groupdn", "+userdn"], ordering)
-                
+
     def extractPmembers(self, extractonly={}, ordering=[]) :
         """Extracts all printer groups members."""
@@ -1739 +1739 @@
                         result.append((parent.Name, entry.Name, parent.ident, entry.ident))
             return [fields] + self.sortRecords(fields, result, ["+pgroupdn", "+printerdn"], ordering)
-        
+
     def extractHistory(self, extractonly={}, ordering=[]) :
         """Extracts all jobhistory records."""
@@ -1745 +1745 @@
         if uname :
             user = self.getUser(uname)
-        else :    
+        else :
             user = None
         pname = extractonly.get("printername")
         if pname :
             printer = self.getPrinter(pname)
-        else :    
+        else :
             printer = None
         startdate = extractonly.get("start")
@@ -1760 +1760 @@
             result = []
             for entry in entries :
-                result.append((entry.UserName, entry.PrinterName, entry.ident, entry.JobId, entry.PrinterPageCounter, entry.JobSize, entry.JobAction, entry.JobDate, entry.JobFileName, entry.JobTitle, entry.JobCopies, entry.JobOptions, entry.JobPrice, entry.JobHostName, entry.JobSizeBytes, entry.JobMD5Sum, entry.JobPages, entry.JobBillingCode, entry.PrecomputedJobSize, entry.PrecomputedJobPrice)) 
+                result.append((entry.UserName, entry.PrinterName, entry.ident, entry.JobId, entry.PrinterPageCounter, entry.JobSize, entry.JobAction, entry.JobDate, entry.JobFileName, entry.JobTitle, entry.JobCopies, entry.JobOptions, entry.JobPrice, entry.JobHostName, entry.JobSizeBytes, entry.JobMD5Sum, entry.JobPages, entry.JobBillingCode, entry.PrecomputedJobSize, entry.PrecomputedJobPrice))
             return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
-            
+
     def getBillingCodeFromBackend(self, label) :
         """Extracts billing code information given its label : returns first matching billing code."""
@@ -1777 +1777 @@
             code.PageCounter = int(fields.get("pykotaPageCounter", [0])[0])
             code.Balance = float(fields.get("pykotaBalance", [0.0])[0])
-            code.Description = databaseToUnicode(fields.get("description", [""])[0]) 
+            code.Description = databaseToUnicode(fields.get("description", [""])[0])
             code.Exists = True
-        return code    
-        
+        return code
+
     def addBillingCode(self, bcode) :
         """Adds a billing code to the quota storage, returns it."""
@@ -1793 +1793 @@
                    "pykotaPageCounter" : str(bcode.PageCounter or 0),
                    "pykotaBalance" : str(bcode.Balance or 0.0),
-                   "description" : unicodeToDatabase(bcode.Description or ""), 
-                 } 
+                   "description" : unicodeToDatabase(bcode.Description or ""),
+                 }
         self.doAdd(dn, fields)
         bcode.isDirty = False
         return None # the entry created doesn't need further modification
-        
+
     def saveBillingCode(self, bcode) :
         """Sets the new description for a billing code."""
         fields = {
-                   "description" : unicodeToDatabase(bcode.Description or ""), 
+                   "description" : unicodeToDatabase(bcode.Description or ""),
                    "pykotaPageCounter" : str(bcode.PageCounter or 0),
                    "pykotaBalance" : str(bcode.Balance or 0.0),
                  }
         self.doModify(bcode.ident, fields)
-            
+
     def getMatchingBillingCodes(self, billingcodepattern) :
         """Returns the list of all billing codes which match a certain pattern."""
@@ -1818 +1818 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -1830 +1830 @@
                     code.PageCounter = int(fields.get("pykotaPageCounter", [0])[0])
                     code.Balance = float(fields.get("pykotaBalance", [0.0])[0])
-                    code.Description = databaseToUnicode(fields.get("description", [""])[0]) 
+                    code.Description = databaseToUnicode(fields.get("description", [""])[0])
                     code.Exists = True
                     codes.append(code)
                     self.cacheEntry("BILLINGCODES", code.BillingCode, code)
-        return codes        
-        
+        return codes
+
     def consumeBillingCode(self, bcode, pagecounter, balance) :
         """Consumes from a billing code."""
@@ -1842 +1842 @@
                    "pykotaPageCounter" : { "operator" : "+", "value" : pagecounter, "convert" : int },
                  }
-        return self.doModify(bcode.ident, fields)         
-
-    def refundJob(self, jobident) :   
+        return self.doModify(bcode.ident, fields)
+
+    def refundJob(self, jobident) :
         """Marks a job as refunded in the history."""
         fields = {
                      "pykotaAction" : "REFUND",
-                 }    
-        self.doModify(jobident, fields)         
-        
+                 }
+        self.doModify(jobident, fields)
+
     def storageUserFromRecord(self, username, record) :
         """Returns a StorageUser instance from a database record."""
@@ -1856 +1856 @@
         user.Exists = True
         return user
-        
+
     def storageGroupFromRecord(self, groupname, record) :
         """Returns a StorageGroup instance from a database record."""
@@ -1862 +1862 @@
         group.Exists = True
         return group
-        
+
     def storagePrinterFromRecord(self, printername, record) :
         """Returns a StoragePrinter instance from a database record."""
@@ -1868 +1868 @@
         printer.Exists = True
         return printer
-        
-    def setJobAttributesFromRecord(self, job, record) :    
+
+    def setJobAttributesFromRecord(self, job, record) :
         """Sets the attributes of a job from a database record."""
         job.Exists = True
-        
+
     def storageJobFromRecord(self, record) :
         """Returns a StorageJob instance from a database record."""
@@ -1878 +1878 @@
         self.setJobAttributesFromRecord(job, record)
         return job
-        
+
     def storageLastJobFromRecord(self, printer, record) :
         """Returns a StorageLastJob instance from a database record."""
@@ -1884 +1884 @@
         self.setJobAttributesFromRecord(lastjob, record)
         return lastjob
-        
+
     def storageUserPQuotaFromRecord(self, user, printer, record) :
         """Returns a StorageUserPQuota instance from a database record."""
@@ -1890 +1890 @@
         userpquota.Exists = True
         return userpquota
-        
+
     def storageGroupPQuotaFromRecord(self, group, printer, record) :
         """Returns a StorageGroupPQuota instance from a database record."""
@@ -1896 +1896 @@
         grouppquota.Exists = True
         return grouppquota
-        
+
     def storageBillingCodeFromRecord(self, billingcode, record) :
         """Returns a StorageBillingCode instance from a database record."""

pykota/trunk/pykota/storages/mysqlstorage.py

@@ -8 +8 @@
 # the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
@@ -29 +29 @@
 try :
     import MySQLdb
-except ImportError :    
+except ImportError :
     import sys
     # TODO : to translate or not to translate ?
@@ -41 +41 @@
             (host, port) = host.split(":")
             port = int(port)
-        except ValueError :    
+        except ValueError :
             port = 3306           # Use the default MySQL port
-        
+
         self.tool.logdebug("Trying to open database (host=%s, port=%s, dbname=%s, user=%s)..." % (host, port, dbname, user))
         try :
             self.database = MySQLdb.connect(host=host, port=port, db=dbname, user=user, passwd=passwd, charset="utf8")
-        except TypeError :    
+        except TypeError :
             self.tool.logdebug("'charset' argument not allowed with this version of python-mysqldb, retrying without...")
             self.database = MySQLdb.connect(host=host, port=port, db=dbname, user=user, passwd=passwd)
-            
+
         try :
             self.database.autocommit(1)
-        except AttributeError :    
+        except AttributeError :
             raise PyKotaStorageError, _("Your version of python-mysqldb is too old. Please install a newer release.")
         self.cursor = self.database.cursor()
@@ -62 +62 @@
         try :
             # Here we try to select a string (an &eacute;) which is
-            # already encoded in UTF-8. If python-mysqldb suffers from 
+            # already encoded in UTF-8. If python-mysqldb suffers from
             # the double encoding problem, we will catch the exception
             # and activate a workaround.
             self.cursor.execute("SELECT '%s';" % (chr(0xc3) + chr(0xa9))) # &eacute; in UTF-8
             self.cursor.fetchall()
-        except UnicodeDecodeError :    
+        except UnicodeDecodeError :
             self.needsworkaround = True
             self.tool.logdebug("Database needs encoding workaround.")
@@ -73 +73 @@
             self.needsworkaround = False
             self.tool.logdebug("Database doesn't need encoding workaround.")
-            
-    def close(self) :    
+
+    def close(self) :
         """Closes the database connection."""
         if not self.closed :
@@ -81 +81 @@
             self.closed = True
             self.tool.logdebug("Database closed.")
-        
-    def beginTransaction(self) :    
+
+    def beginTransaction(self) :
         """Starts a transaction."""
         self.cursor.execute("BEGIN;")
         self.tool.logdebug("Transaction begins...")
-        
-    def commitTransaction(self) :    
+
+    def commitTransaction(self) :
         """Commits a transaction."""
         self.database.commit()
         self.tool.logdebug("Transaction committed.")
-        
-    def rollbackTransaction(self) :     
+
+    def rollbackTransaction(self) :
         """Rollbacks a transaction."""
         self.database.rollback()
         self.tool.logdebug("Transaction aborted.")
-        
+
     def doRawSearch(self, query) :
         """Does a raw search query."""
-        query = query.strip()    
-        if not query.endswith(';') :    
+        query = query.strip()
+        if not query.endswith(';') :
             query += ';'
         self.querydebug("QUERY : %s" % query)
-        if self.needsworkaround :    
+        if self.needsworkaround :
             query = query.decode("UTF-8")
         try :
             self.cursor.execute(query)
-        except self.database.Error, msg :    
+        except self.database.Error, msg :
             raise PyKotaStorageError, repr(msg)
-        else :    
+        else :
             # This returns a list of lists. Integers are returned as longs.
             return self.cursor.fetchall()
-            
-    def doSearch(self, query) :        
+
+    def doSearch(self, query) :
         """Does a search query."""
         result = self.doRawSearch(query)
@@ -131 +131 @@
     def doModify(self, query) :
         """Does a (possibly multiple) modify query."""
-        query = query.strip()    
-        if not query.endswith(';') :    
+        query = query.strip()
+        if not query.endswith(';') :
             query += ';'
         self.querydebug("QUERY : %s" % query)
-        if self.needsworkaround :    
+        if self.needsworkaround :
             query = query.decode("UTF-8")
         try :
             self.cursor.execute(query)
-        except self.database.Error, msg :    
+        except self.database.Error, msg :
             self.tool.logdebug("Query failed : %s" % repr(msg))
             raise PyKotaStorageError, repr(msg)
-            
+
     def doQuote(self, field) :
         """Quotes a field for use as a string in SQL queries."""

pykota/trunk/pykota/storages/pgstorage.py

@@ -8 +8 @@
 # the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
@@ -29 +29 @@
 from pykota.storages.sql import SQLStorage
 
-from pykota.utils import *                           
+from pykota.utils import *
 
 try :
     import pg
-except ImportError :    
+except ImportError :
     import sys
     # TODO : to translate or not to translate ?
     raise PyKotaStorageError, "This python version (%s) doesn't seem to have the PygreSQL module installed correctly." % sys.version.split()[0]
-else :    
+else :
     try :
         PGError = pg.Error
-    except AttributeError :    
+    except AttributeError :
         PGError = pg.error
 
@@ -50 +50 @@
             (host, port) = host.split(":")
             port = int(port)
-        except ValueError :    
+        except ValueError :
             port = 5432         # Use PostgreSQL's default tcp/ip port (5432).
-        
+
         self.tool.logdebug("Trying to open database (host=%s, port=%s, dbname=%s, user=%s)..." % (host, port, dbname, user))
         try :
             self.database = pg.connect(host=host, port=port, dbname=dbname, user=user, passwd=passwd)
-        except PGError, msg :    
+        except PGError, msg :
             msg = "%(msg)s --- the most probable cause of your problem is that PostgreSQL is down, or doesn't accept incoming connections because you didn't configure it as explained in PyKota's documentation." % locals()
             raise PGError, msg
@@ -62 +62 @@
         try :
             self.database.query("SET CLIENT_ENCODING TO 'UTF-8';")
-        except PGError, msg :    
+        except PGError, msg :
             self.tool.logdebug("Impossible to set database client encoding to UTF-8 : %s" % msg)
         self.tool.logdebug("Database opened (host=%s, port=%s, dbname=%s, user=%s)" % (host, port, dbname, user))
-            
-    def close(self) :    
+
+    def close(self) :
         """Closes the database connection."""
         if not self.closed :
@@ -72 +72 @@
             self.closed = 1
             self.tool.logdebug("Database closed.")
-        
-    def beginTransaction(self) :    
+
+    def beginTransaction(self) :
         """Starts a transaction."""
         self.database.query("BEGIN;")
         self.tool.logdebug("Transaction begins...")
-        
-    def commitTransaction(self) :    
+
+    def commitTransaction(self) :
         """Commits a transaction."""
         self.database.query("COMMIT;")
         self.tool.logdebug("Transaction committed.")
-        
-    def rollbackTransaction(self) :     
+
+    def rollbackTransaction(self) :
         """Rollbacks a transaction."""
         self.database.query("ROLLBACK;")
         self.tool.logdebug("Transaction aborted.")
-        
+
     def doRawSearch(self, query) :
         """Does a raw search query."""
-        query = query.strip()    
-        if not query.endswith(';') :    
+        query = query.strip()
+        if not query.endswith(';') :
             query += ';'
         try :
             self.querydebug("QUERY : %s" % query)
             return self.database.query(query)
-        except PGError, msg :    
+        except PGError, msg :
             raise PyKotaStorageError, repr(msg)
-            
-    def doSearch(self, query) :        
+
+    def doSearch(self, query) :
         """Does a search query."""
         result = self.doRawSearch(query)
-        if (result is not None) and (result.ntuples() > 0) : 
+        if (result is not None) and (result.ntuples() > 0) :
             return result.dictresult()
-        
+
     def doModify(self, query) :
         """Does a (possibly multiple) modify query."""
-        query = query.strip()    
-        if not query.endswith(';') :    
+        query = query.strip()
+        if not query.endswith(';') :
             query += ';'
         try :
             self.querydebug("QUERY : %s" % query)
             return self.database.query(query)
-        except PGError, msg :    
+        except PGError, msg :
             self.tool.logdebug("Query failed : %s" % repr(msg))
             raise PyKotaStorageError, repr(msg)
-            
+
     def doQuote(self, field) :
         """Quotes a field for use as a string in SQL queries."""
-        if type(field) == type(0.0) : 
+        if type(field) == type(0.0) :
             typ = "decimal"
-        elif type(field) == type(0) :    
+        elif type(field) == type(0) :
             typ = "int"
-        elif type(field) == type(0L) :    
+        elif type(field) == type(0L) :
             typ = "int"
-        else :    
+        else :
             typ = "text"
         return pg._quote(field, typ)
-        
+
     def prepareRawResult(self, result) :
         """Prepares a raw result by including the headers."""
@@ -140 +140 @@
                     field = fields[j]
                     if type(field) == StringType :
-                        fields[j] = databaseToUnicode(field) 
-                entries[i] = tuple(fields)    
+                        fields[j] = databaseToUnicode(field)
+                entries[i] = tuple(fields)
             return entries
-        
+

pykota/trunk/pykota/storages/sqlitestorage.py

@@ -8 +8 @@
 # the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
@@ -29 +29 @@
 try :
     from pysqlite2 import dbapi2 as sqlite
-except ImportError :    
+except ImportError :
     import sys
     # TODO : to translate or not to translate ?
     raise PyKotaStorageError, "This python version (%s) doesn't seem to have the PySQLite module installed correctly." % sys.version.split()[0]
-    
+
 class Storage(BaseStorage, SQLStorage) :
     def __init__(self, pykotatool, host, dbname, user, passwd) :
         """Opens the SQLite database connection."""
         BaseStorage.__init__(self, pykotatool)
-        
+
         self.tool.logdebug("Trying to open database (dbname=%s)..." % dbname)
         self.database = sqlite.connect(dbname, isolation_level=None)
@@ -44 +44 @@
         self.closed = 0
         self.tool.logdebug("Database opened (dbname=%s)" % dbname)
-            
-    def close(self) :    
+
+    def close(self) :
         """Closes the database connection."""
         if not self.closed :
@@ -52 +52 @@
             self.closed = 1
             self.tool.logdebug("Database closed.")
-        
-    def beginTransaction(self) :    
+
+    def beginTransaction(self) :
         """Starts a transaction."""
         self.cursor.execute("BEGIN;")
         self.tool.logdebug("Transaction begins...")
-        
-    def commitTransaction(self) :    
+
+    def commitTransaction(self) :
         """Commits a transaction."""
         self.cursor.execute("COMMIT;")
         self.tool.logdebug("Transaction committed.")
-        
-    def rollbackTransaction(self) :     
+
+    def rollbackTransaction(self) :
         """Rollbacks a transaction."""
         self.cursor.execute("ROLLBACK;")
         self.tool.logdebug("Transaction aborted.")
-        
+
     def doRawSearch(self, query) :
         """Does a raw search query."""
-        query = query.strip()    
-        if not query.endswith(';') :    
+        query = query.strip()
+        if not query.endswith(';') :
             query += ';'
         try :
             self.querydebug("QUERY : %s" % query)
             self.cursor.execute(query)
-        except self.database.Error, msg :    
+        except self.database.Error, msg :
             raise PyKotaStorageError, repr(msg)
-        else :    
+        else :
             result = self.cursor.fetchall()
             return result
-            
-    def doSearch(self, query) :        
+
+    def doSearch(self, query) :
         """Does a search query."""
         result = self.doRawSearch(query)
-        if result : 
+        if result :
             rows = []
             fields = {}
             for i in range(len(self.cursor.description)) :
                 fields[i] = self.cursor.description[i][0]
-            for row in result :    
+            for row in result :
                 rowdict = {}
                 for field in fields.keys() :
@@ -99 +99 @@
                         pass
                     rowdict[fields[field]] = value
-                rows.append(rowdict)    
-            return rows    
-        
+                rows.append(rowdict)
+            return rows
+
     def doModify(self, query) :
         """Does a (possibly multiple) modify query."""
-        query = query.strip()    
-        if not query.endswith(';') :    
+        query = query.strip()
+        if not query.endswith(';') :
             query += ';'
         try :
             self.querydebug("QUERY : %s" % query)
             self.cursor.execute(query)
-        except self.database.Error, msg :    
+        except self.database.Error, msg :
             self.tool.logdebug("Query failed : %s" % repr(msg))
             raise PyKotaStorageError, repr(msg)
-            
+
     def doQuote(self, field) :
         """Quotes a field for use as a string in SQL queries."""
-        if type(field) == type(0.0) : 
+        if type(field) == type(0.0) :
             return field
-        elif type(field) == type(0) :    
+        elif type(field) == type(0) :
             return field
-        elif type(field) == type(0L) :    
+        elif type(field) == type(0L) :
             return field
         elif field is not None :
             return ("'%s'" % field.replace("'", "''")).decode("UTF-8")
-        else :     
+        else :
             return "NULL"
-            
+
     def prepareRawResult(self, result) :
         """Prepares a raw result by including the headers."""
         if result :
             entries = [tuple([f[0] for f in self.cursor.description])]
-            for entry in result :    
+            for entry in result :
                 row = []
                 for value in entry :
@@ -139 +139 @@
                         pass
                     row.append(value)
-                entries.append(tuple(row))    
-            return entries   
-        
+                entries.append(tuple(row))
+            return entries
+

pykota/trunk/pykota/storages/sql.py

@@ -8 +8 @@
 # the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
@@ -26 +26 @@
                            StorageJob, StorageLastJob, StorageUserPQuota, \
                            StorageGroupPQuota, StorageBillingCode
-                           
-from pykota.utils import *                           
+
+from pykota.utils import *
 
 class SQLStorage :
@@ -42 +42 @@
         user.Exists = True
         return user
-        
+
     def storageGroupFromRecord(self, groupname, record) :
         """Returns a StorageGroup instance from a database record."""
@@ -53 +53 @@
         group.Exists = True
         return group
-        
+
     def storagePrinterFromRecord(self, printername, record) :
         """Returns a StoragePrinter instance from a database record."""
@@ -69 +69 @@
         printer.Exists = True
         return printer
-        
-    def setJobAttributesFromRecord(self, job, record) :    
+
+    def setJobAttributesFromRecord(self, job, record) :
         """Sets the attributes of a job from a database record."""
         job.ident = record.get("id")
@@ -78 +78 @@
         job.JobPrice = record.get("jobprice")
         job.JobAction = record.get("action")
-        job.JobFileName = databaseToUnicode(record.get("filename") or "") 
-        job.JobTitle = databaseToUnicode(record.get("title") or "") 
+        job.JobFileName = databaseToUnicode(record.get("filename") or "")
+        job.JobTitle = databaseToUnicode(record.get("title") or "")
         job.JobCopies = record.get("copies")
-        job.JobOptions = databaseToUnicode(record.get("options") or "") 
+        job.JobOptions = databaseToUnicode(record.get("options") or "")
         job.JobDate = record.get("jobdate")
         job.JobHostName = record.get("hostname")
@@ -95 +95 @@
             (job.JobTitle, job.JobFileName, job.JobOptions) = (_("Hidden because of privacy concerns"),) * 3
         job.Exists = True
-        
+
     def storageJobFromRecord(self, record) :
         """Returns a StorageJob instance from a database record."""
@@ -101 +101 @@
         self.setJobAttributesFromRecord(job, record)
         return job
-        
+
     def storageLastJobFromRecord(self, printer, record) :
         """Returns a StorageLastJob instance from a database record."""
@@ -107 +107 @@
         self.setJobAttributesFromRecord(lastjob, record)
         return lastjob
-        
+
     def storageUserPQuotaFromRecord(self, user, printer, record) :
         """Returns a StorageUserPQuota instance from a database record."""
@@ -120 +120 @@
         userpquota.Exists = True
         return userpquota
-        
+
     def storageGroupPQuotaFromRecord(self, group, printer, record) :
         """Returns a StorageGroupPQuota instance from a database record."""
@@ -135 +135 @@
         grouppquota.Exists = True
         return grouppquota
-        
+
     def storageBillingCodeFromRecord(self, billingcode, record) :
         """Returns a StorageBillingCode instance from a database record."""
@@ -145 +145 @@
         code.Exists = True
         return code
-        
-    def createFilter(self, only) :    
+
+    def createFilter(self, only) :
         """Returns the appropriate SQL filter."""
         if only :
@@ -152 +152 @@
             for (k, v) in only.items() :
                 expressions.append("%s=%s" % (k, self.doQuote(unicodeToDatabase(v))))
-            return " AND ".join(expressions)     
-        return ""        
-        
-    def createOrderBy(self, default, ordering) :    
+            return " AND ".join(expressions)
+        return ""
+
+    def createOrderBy(self, default, ordering) :
         """Creates a suitable ORDER BY statement based on a list of fieldnames prefixed with '+' (ASC) or '-' (DESC)."""
         statements = []
         if not ordering :
             ordering = default
-        for field in ordering :    
-            if field.startswith("-") :    
+        for field in ordering :
+            if field.startswith("-") :
                 statements.append("%s DESC" % field[1:])
             elif field.startswith("+") :
                 statements.append("%s ASC" % field[1:])
-            else :    
+            else :
                 statements.append("%s ASC" % field)
-        return ", ".join(statements)    
-        
+        return ", ".join(statements)
+
     def extractPrinters(self, extractonly={}, ordering=[]) :
         """Extracts all printer records."""
@@ -177 +177 @@
         result = self.doRawSearch("SELECT * FROM printers %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractUsers(self, extractonly={}, ordering=[]) :
         """Extracts all user records."""
@@ -186 +186 @@
         result = self.doRawSearch("SELECT * FROM users %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractBillingcodes(self, extractonly={}, ordering=[]) :
         """Extracts all billing codes records."""
@@ -195 +195 @@
         result = self.doRawSearch("SELECT * FROM billingcodes %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractGroups(self, extractonly={}, ordering=[]) :
         """Extracts all group records."""
@@ -204 +204 @@
         result = self.doRawSearch("SELECT groups.*,COALESCE(SUM(balance), 0) AS balance, COALESCE(SUM(lifetimepaid), 0) as lifetimepaid FROM groups LEFT OUTER JOIN users ON users.id IN (SELECT userid FROM groupsmembers WHERE groupid=groups.id) %(thefilter)s GROUP BY groups.id,groups.groupname,groups.limitby,groups.description ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractPayments(self, extractonly={}, ordering=[]) :
         """Extracts all payment records."""
@@ -212 +212 @@
             try :
                 del extractonly[limit]
-            except KeyError :    
+            except KeyError :
                 pass
         thefilter = self.createFilter(extractonly)
@@ -218 +218 @@
             thefilter = "AND %s" % thefilter
         (startdate, enddate) = self.cleanDates(startdate, enddate)
-        if startdate : 
+        if startdate :
             thefilter = "%s AND date>=%s" % (thefilter, self.doQuote(startdate))
-        if enddate : 
+        if enddate :
             thefilter = "%s AND date<=%s" % (thefilter, self.doQuote(enddate))
         orderby = self.createOrderBy(["+payments.id"], ordering)
         result = self.doRawSearch("SELECT username,payments.* FROM users,payments WHERE users.id=payments.userid %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractUpquotas(self, extractonly={}, ordering=[]) :
         """Extracts all userpquota records."""
@@ -234 +234 @@
         result = self.doRawSearch("SELECT users.username,printers.printername,userpquota.* FROM users,printers,userpquota WHERE users.id=userpquota.userid AND printers.id=userpquota.printerid %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractGpquotas(self, extractonly={}, ordering=[]) :
         """Extracts all grouppquota records."""
@@ -243 +243 @@
         result = self.doRawSearch("SELECT groups.groupname,printers.printername,grouppquota.*,coalesce(sum(pagecounter), 0) AS pagecounter,coalesce(sum(lifepagecounter), 0) AS lifepagecounter FROM groups,printers,grouppquota,userpquota WHERE groups.id=grouppquota.groupid AND printers.id=grouppquota.printerid AND userpquota.printerid=grouppquota.printerid AND userpquota.userid IN (SELECT userid FROM groupsmembers WHERE groupsmembers.groupid=grouppquota.groupid) %(thefilter)s GROUP BY grouppquota.id,grouppquota.groupid,grouppquota.printerid,grouppquota.softlimit,grouppquota.hardlimit,grouppquota.datelimit,grouppquota.maxjobsize,groups.groupname,printers.printername ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractUmembers(self, extractonly={}, ordering=[]) :
         """Extracts all user groups members."""
@@ -252 +252 @@
         result = self.doRawSearch("SELECT groups.groupname, users.username, groupsmembers.* FROM groups,users,groupsmembers WHERE users.id=groupsmembers.userid AND groups.id=groupsmembers.groupid %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractPmembers(self, extractonly={}, ordering=[]) :
         """Extracts all printer groups members."""
@@ -268 +268 @@
         result = self.doRawSearch("SELECT p1.printername as pgroupname, p2.printername as printername, printergroupsmembers.* FROM printers p1, printers p2, printergroupsmembers WHERE p1.id=printergroupsmembers.groupid AND p2.id=printergroupsmembers.printerid %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-        
+
     def extractHistory(self, extractonly={}, ordering=[]) :
         """Extracts all jobhistory records."""
@@ -276 +276 @@
             try :
                 del extractonly[limit]
-            except KeyError :    
+            except KeyError :
                 pass
         thefilter = self.createFilter(extractonly)
@@ -282 +282 @@
             thefilter = "AND %s" % thefilter
         (startdate, enddate) = self.cleanDates(startdate, enddate)
-        if startdate : 
+        if startdate :
             thefilter = "%s AND jobdate>=%s" % (thefilter, self.doQuote(startdate))
-        if enddate : 
+        if enddate :
             thefilter = "%s AND jobdate<=%s" % (thefilter, self.doQuote(enddate))
         orderby = self.createOrderBy(["+jobhistory.id"], ordering)
         result = self.doRawSearch("SELECT users.username,printers.printername,jobhistory.* FROM users,printers,jobhistory WHERE users.id=jobhistory.userid AND printers.id=jobhistory.printerid %(thefilter)s ORDER BY %(orderby)s" % locals())
         return self.prepareRawResult(result)
-            
+
     def filterNames(self, records, attribute, patterns=None) :
         """Returns a list of 'attribute' from a list of records.
-        
+
            Logs any missing attribute.
-        """   
+        """
         result = []
         for record in records :
@@ -307 +307 @@
                     if self.tool.matchString(attrval, patterns) :
                         result.append(attrval)
-                else :    
+                else :
                     result.append(attrval)
-        return result   
-                
-    def getAllBillingCodes(self, billingcode=None) :    
+        return result
+
+    def getAllBillingCodes(self, billingcode=None) :
         """Extracts all billing codes or only the billing codes matching the optional parameter."""
         result = self.doSearch("SELECT billingcode FROM billingcodes")
         if result :
             return self.filterNames(result, "billingcode", billingcode)
-        else :    
+        else :
             return []
-        
-    def getAllPrintersNames(self, printername=None) :    
+
+    def getAllPrintersNames(self, printername=None) :
         """Extracts all printer names or only the printers' names matching the optional parameter."""
         result = self.doSearch("SELECT printername FROM printers")
         if result :
             return self.filterNames(result, "printername", printername)
-        else :    
+        else :
             return []
-    
-    def getAllUsersNames(self, username=None) :    
+
+    def getAllUsersNames(self, username=None) :
         """Extracts all user names."""
         result = self.doSearch("SELECT username FROM users")
         if result :
             return self.filterNames(result, "username", username)
-        else :    
+        else :
             return []
-        
-    def getAllGroupsNames(self, groupname=None) :    
+
+    def getAllGroupsNames(self, groupname=None) :
         """Extracts all group names."""
         result = self.doSearch("SELECT groupname FROM groups")
@@ -342 +342 @@
         else :
             return []
-        
+
     def getUserNbJobsFromHistory(self, user) :
         """Returns the number of jobs the user has in history."""
@@ -349 +349 @@
             return result[0]["count"]
         return 0
-        
-    def getUserFromBackend(self, username) :    
+
+    def getUserFromBackend(self, username) :
         """Extracts user information given its name."""
         result = self.doSearch("SELECT * FROM users WHERE username=%s"\
@@ -356 +356 @@
         if result :
             return self.storageUserFromRecord(username, result[0])
-        else :    
+        else :
             return StorageUser(self, username)
-       
-    def getGroupFromBackend(self, groupname) :    
+
+    def getGroupFromBackend(self, groupname) :
         """Extracts group information given its name."""
         result = self.doSearch("SELECT groups.*,COALESCE(SUM(balance), 0.0) AS balance, COALESCE(SUM(lifetimepaid), 0.0) AS lifetimepaid FROM groups LEFT OUTER JOIN users ON users.id IN (SELECT userid FROM groupsmembers WHERE groupid=groups.id) WHERE groupname=%s GROUP BY groups.id,groups.groupname,groups.limitby,groups.description" \
@@ -365 +365 @@
         if result :
             return self.storageGroupFromRecord(groupname, result[0])
-        else :    
+        else :
             return StorageGroup(self, groupname)
-       
-    def getPrinterFromBackend(self, printername) :        
+
+    def getPrinterFromBackend(self, printername) :
         """Extracts printer information given its name."""
         result = self.doSearch("SELECT * FROM printers WHERE printername=%s" \
@@ -374 +374 @@
         if result :
             return self.storagePrinterFromRecord(printername, result[0])
-        else :    
+        else :
             return StoragePrinter(self, printername)
-        
-    def getBillingCodeFromBackend(self, label) :        
+
+    def getBillingCodeFromBackend(self, label) :
         """Extracts a billing code information given its name."""
         result = self.doSearch("SELECT * FROM billingcodes WHERE billingcode=%s" \
@@ -383 +383 @@
         if result :
             return self.storageBillingCodeFromRecord(label, result[0])
-        else :    
+        else :
             return StorageBillingCode(self, label)
-        
-    def getUserPQuotaFromBackend(self, user, printer) :        
+
+    def getUserPQuotaFromBackend(self, user, printer) :
         """Extracts a user print quota."""
         if printer.Exists and user.Exists :
@@ -394 +394 @@
                 return self.storageUserPQuotaFromRecord(user, printer, result[0])
         return StorageUserPQuota(self, user, printer)
-        
-    def getGroupPQuotaFromBackend(self, group, printer) :        
+
+    def getGroupPQuotaFromBackend(self, group, printer) :
         """Extracts a group print quota."""
         if printer.Exists and group.Exists :
@@ -403 +403 @@
                 return self.storageGroupPQuotaFromRecord(group, printer, result[0])
         return StorageGroupPQuota(self, group, printer)
-        
-    def getPrinterLastJobFromBackend(self, printer) :        
+
+    def getPrinterLastJobFromBackend(self, printer) :
         """Extracts a printer's last job information."""
         result = self.doSearch("SELECT jobhistory.id, jobid, userid, username, pagecounter, jobsize, jobprice, filename, title, copies, options, hostname, jobdate, md5sum, pages, billingcode, precomputedjobsize, precomputedjobprice FROM jobhistory, users WHERE userid=users.id AND jobhistory.id IN (SELECT max(id) FROM jobhistory WHERE printerid=%s)" % self.doQuote(printer.ident))
         if result :
             return self.storageLastJobFromRecord(printer, result[0])
-        else :    
+        else :
             return StorageLastJob(self, printer)
-            
-    def getGroupMembersFromBackend(self, group) :        
+
+    def getGroupMembersFromBackend(self, group) :
         """Returns the group's members list."""
         groupmembers = []
@@ -422 +422 @@
                 groupmembers.append(user)
                 self.cacheEntry("USERS", user.Name, user)
-        return groupmembers        
-        
-    def getUserGroupsFromBackend(self, user) :        
+        return groupmembers
+
+    def getUserGroupsFromBackend(self, user) :
         """Returns the user's groups list."""
         groups = []
@@ -431 +431 @@
             for record in result :
                 groups.append(self.getGroup(databaseToUnicode(record.get("groupname"))))
-        return groups        
-        
-    def getParentPrintersFromBackend(self, printer) :    
+        return groups
+
+    def getParentPrintersFromBackend(self, printer) :
         """Get all the printer groups this printer is a member of."""
         pgroups = []
@@ -444 +444 @@
                         pgroups.append(parentprinter)
         return pgroups
-        
+
     def getMatchingPrinters(self, printerpattern) :
         """Returns the list of all printers for which name matches a certain pattern."""
@@ -456 +456 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -467 +467 @@
                     printers.append(printer)
                     self.cacheEntry("PRINTERS", printer.Name, printer)
-        return printers        
-        
+        return printers
+
     def getMatchingUsers(self, userpattern) :
         """Returns the list of all users for which name matches a certain pattern."""
@@ -480 +480 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -491 +491 @@
                     users.append(user)
                     self.cacheEntry("USERS", user.Name, user)
-        return users        
-        
+        return users
+
     def getMatchingGroups(self, grouppattern) :
         """Returns the list of all groups for which name matches a certain pattern."""
@@ -504 +504 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -515 +515 @@
                     groups.append(group)
                     self.cacheEntry("GROUPS", group.Name, group)
-        return groups        
-        
+        return groups
+
     def getMatchingBillingCodes(self, billingcodepattern) :
         """Returns the list of all billing codes for which the label matches a certain pattern."""
@@ -525 +525 @@
             try :
                 patdict = {}.fromkeys(patterns)
-            except AttributeError :    
+            except AttributeError :
                 # Python v2.2 or earlier
                 patdict = {}
@@ -536 +536 @@
                     codes.append(code)
                     self.cacheEntry("BILLINGCODES", code.BillingCode, code)
-        return codes        
-        
-    def getPrinterUsersAndQuotas(self, printer, names=["*"]) :        
+        return codes
+
+    def getPrinterUsersAndQuotas(self, printer, names=["*"]) :
         """Returns the list of users who uses a given printer, along with their quotas."""
         usersandquotas = []
@@ -552 +552 @@
                     self.cacheEntry("USERPQUOTAS", "%s@%s" % (user.Name, printer.Name), userpquota)
         return usersandquotas
-                
-    def getPrinterGroupsAndQuotas(self, printer, names=["*"]) :        
+
+    def getPrinterGroupsAndQuotas(self, printer, names=["*"]) :
         """Returns the list of groups which uses a given printer, along with their quotas."""
         groupsandquotas = []
@@ -565 +565 @@
                     groupsandquotas.append((group, grouppquota))
         return groupsandquotas
-        
-    def addPrinter(self, printer) :        
+
+    def addPrinter(self, printer) :
         """Adds a printer to the quota storage, returns the old value if it already exists."""
         oldentry = self.getPrinter(printer.Name)
@@ -580 +580 @@
         printer.isDirty = False
         return None # the entry created doesn't need further modification
-        
+
     def addBillingCode(self, bcode) :
         """Adds a billing code to the quota storage, returns the old value if it already exists."""
@@ -587 +587 @@
             return oldentry
         self.doModify("INSERT INTO billingcodes (billingcode, balance, pagecounter, description) VALUES (%s, %s, %s, %s)" \
-                           % (self.doQuote(unicodeToDatabase(bcode.BillingCode)), 
+                           % (self.doQuote(unicodeToDatabase(bcode.BillingCode)),
                               self.doQuote(bcode.Balance or 0.0), \
                               self.doQuote(bcode.PageCounter or 0), \
@@ -593 +593 @@
         bcode.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def addUser(self, user) :        
+
+    def addUser(self, user) :
         """Adds a user to the quota storage, returns the old value if it already exists."""
         oldentry = self.getUser(user.Name)
@@ -613 +613 @@
         user.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def addGroup(self, group) :        
+
+    def addGroup(self, group) :
         """Adds a group to the quota storage, returns the old value if it already exists."""
         oldentry = self.getGroup(group.Name)
@@ -626 +626 @@
         return None # the entry created doesn't need further modification
 
-    def addUserToGroup(self, user, group) :    
+    def addUserToGroup(self, user, group) :
         """Adds an user to a group."""
         result = self.doSearch("SELECT COUNT(*) AS mexists FROM groupsmembers WHERE groupid=%s AND userid=%s" % (self.doQuote(group.ident), self.doQuote(user.ident)))
         try :
             mexists = int(result[0].get("mexists"))
-        except (IndexError, TypeError) :    
+        except (IndexError, TypeError) :
             mexists = 0
-        if not mexists :    
+        if not mexists :
             self.doModify("INSERT INTO groupsmembers (groupid, userid) VALUES (%s, %s)" % (self.doQuote(group.ident), self.doQuote(user.ident)))
-            
-    def delUserFromGroup(self, user, group) :    
+
+    def delUserFromGroup(self, user, group) :
         """Removes an user from a group."""
         self.doModify("DELETE FROM groupsmembers WHERE groupid=%s AND userid=%s" % \
                        (self.doQuote(group.ident), self.doQuote(user.ident)))
-            
+
     def addUserPQuota(self, upq) :
         """Initializes a user print quota on a printer."""
@@ -658 +658 @@
         upq.isDirty = False
         return None # the entry created doesn't need further modification
-        
+
     def addGroupPQuota(self, gpq) :
         """Initializes a group print quota on a printer."""
@@ -673 +673 @@
         gpq.isDirty = False
         return None # the entry created doesn't need further modification
-        
-    def savePrinter(self, printer) :    
+
+    def savePrinter(self, printer) :
         """Saves the printer to the database in a single operation."""
         self.doModify("UPDATE printers SET passthrough=%s, maxjobsize=%s, description=%s, priceperpage=%s, priceperjob=%s WHERE id=%s" \
@@ -683 +683 @@
                                  self.doQuote(printer.PricePerJob or 0.0), \
                                  self.doQuote(printer.ident)))
-                                 
-    def saveUser(self, user) :        
+
+    def saveUser(self, user) :
         """Saves the user to the database in a single operation."""
         self.doModify("UPDATE users SET limitby=%s, balance=%s, lifetimepaid=%s, email=%s, overcharge=%s, description=%s WHERE id=%s" \
@@ -694 +694 @@
                                   self.doQuote(unicodeToDatabase(user.Description)), \
                                   self.doQuote(user.ident)))
-                                  
-    def saveGroup(self, group) :        
+
+    def saveGroup(self, group) :
         """Saves the group to the database in a single operation."""
         self.doModify("UPDATE groups SET limitby=%s, description=%s WHERE id=%s" \
@@ -701 +701 @@
                                   self.doQuote(unicodeToDatabase(group.Description)), \
                                   self.doQuote(group.ident)))
-        
-    def writeUserPQuotaDateLimit(self, userpquota, datelimit) :    
+
+    def writeUserPQuotaDateLimit(self, userpquota, datelimit) :
         """Sets the date limit permanently for a user print quota."""
         self.doModify("UPDATE userpquota SET datelimit=%s WHERE id=%s" % (self.doQuote(datelimit), self.doQuote(userpquota.ident)))
-            
-    def writeGroupPQuotaDateLimit(self, grouppquota, datelimit) :    
+
+    def writeGroupPQuotaDateLimit(self, grouppquota, datelimit) :
         """Sets the date limit permanently for a group print quota."""
         self.doModify("UPDATE grouppquota SET datelimit=%s WHERE id=%s" % (self.doQuote(datelimit), self.doQuote(grouppquota.ident)))
-        
-    def increaseUserPQuotaPagesCounters(self, userpquota, nbpages) :    
+
+    def increaseUserPQuotaPagesCounters(self, userpquota, nbpages) :
         """Increase page counters for a user print quota."""
         self.doModify("UPDATE userpquota SET pagecounter=pagecounter + %s,lifepagecounter=lifepagecounter + %s WHERE id=%s" % (self.doQuote(nbpages), self.doQuote(nbpages), self.doQuote(userpquota.ident)))
-       
-    def saveBillingCode(self, bcode) :    
+
+    def saveBillingCode(self, bcode) :
         """Saves the billing code to the database."""
         self.doModify("UPDATE billingcodes SET balance=%s, pagecounter=%s, description=%s WHERE id=%s" \
@@ -721 +721 @@
                                self.doQuote(unicodeToDatabase(bcode.Description)), \
                                self.doQuote(bcode.ident)))
-       
+
     def consumeBillingCode(self, bcode, pagecounter, balance) :
         """Consumes from a billing code."""
         self.doModify("UPDATE billingcodes SET balance=balance + %s, pagecounter=pagecounter + %s WHERE id=%s" % (self.doQuote(balance), self.doQuote(pagecounter), self.doQuote(bcode.ident)))
-       
-    def refundJob(self, jobident) :   
+
+    def refundJob(self, jobident) :
         """Marks a job as refunded in the history."""
         self.doModify("UPDATE jobhistory SET action='REFUND' WHERE id=%s;" % self.doQuote(jobident))
-        
-    def decreaseUserAccountBalance(self, user, amount) :    
+
+    def decreaseUserAccountBalance(self, user, amount) :
         """Decreases user's account balance from an amount."""
         self.doModify("UPDATE users SET balance=balance - %s WHERE id=%s" % (self.doQuote(amount), self.doQuote(user.ident)))
-       
+
     def writeNewPayment(self, user, amount, comment="") :
         """Adds a new payment to the payments history."""
         if user.ident is not None :
             self.doModify("INSERT INTO payments (userid, amount, description) VALUES (%s, %s, %s)" % (self.doQuote(user.ident), self.doQuote(amount), self.doQuote(unicodeToDatabase(comment))))
-        else :    
+        else :
             self.doModify("INSERT INTO payments (userid, amount, description) VALUES ((SELECT id FROM users WHERE username=%s), %s, %s)" % (self.doQuote(unicodeToDatabase(user.Name)), self.doQuote(amount), self.doQuote(unicodeToDatabase(comment))))
-        
-    def writeLastJobSize(self, lastjob, jobsize, jobprice) :        
+
+    def writeLastJobSize(self, lastjob, jobsize, jobprice) :
         """Sets the last job's size permanently."""
         self.doModify("UPDATE jobhistory SET jobsize=%s, jobprice=%s WHERE id=%s" % (self.doQuote(jobsize), self.doQuote(jobprice), self.doQuote(lastjob.ident)))
-        
+
     def writeJobNew(self, printer, user, jobid, pagecounter, action, jobsize=None, jobprice=None, filename=None, title=None, copies=None, options=None, clienthost=None, jobsizebytes=None, jobmd5sum=None, jobpages=None, jobbilling=None, precomputedsize=None, precomputedprice=None) :
         """Adds a job in a printer's history."""
-        if self.privacy :    
+        if self.privacy :
             # For legal reasons, we want to hide the title, filename and options
             title = filename = options = "hidden"
@@ -757 +757 @@
             if jobsize is not None :
                 self.doModify("INSERT INTO jobhistory (userid, printerid, jobid, pagecounter, action, jobsize, jobprice, filename, title, copies, options, hostname, jobsizebytes, md5sum, pages, billingcode, precomputedjobsize, precomputedjobprice) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)" % (self.doQuote(user.ident), self.doQuote(printer.ident), self.doQuote(jobid), self.doQuote(pagecounter), self.doQuote(action), self.doQuote(jobsize), self.doQuote(jobprice), self.doQuote(filename), self.doQuote(title), self.doQuote(copies), self.doQuote(options), self.doQuote(clienthost), self.doQuote(jobsizebytes), self.doQuote(jobmd5sum), self.doQuote(jobpages), self.doQuote(jobbilling), self.doQuote(precomputedsize), self.doQuote(precomputedprice)))
-            else :    
+            else :
                 self.doModify("INSERT INTO jobhistory (userid, printerid, jobid, pagecounter, action, filename, title, copies, options, hostname, jobsizebytes, md5sum, pages, billingcode, precomputedjobsize, precomputedjobprice) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)" % (self.doQuote(user.ident), self.doQuote(printer.ident), self.doQuote(jobid), self.doQuote(pagecounter), self.doQuote(action), self.doQuote(filename), self.doQuote(title), self.doQuote(copies), self.doQuote(options), self.doQuote(clienthost), self.doQuote(jobsizebytes), self.doQuote(jobmd5sum), self.doQuote(jobpages), self.doQuote(jobbilling), self.doQuote(precomputedsize), self.doQuote(precomputedprice)))
-        else :        
+        else :
             # here we explicitly want to reset jobsize to NULL if needed
             self.doModify("UPDATE jobhistory SET userid=%s, jobid=%s, pagecounter=%s, action=%s, jobsize=%s, jobprice=%s, filename=%s, title=%s, copies=%s, options=%s, hostname=%s, jobsizebytes=%s, md5sum=%s, pages=%s, billingcode=%s, precomputedjobsize=%s, precomputedjobprice=%s, jobdate=now() WHERE id=%s" % (self.doQuote(user.ident), self.doQuote(jobid), self.doQuote(pagecounter), self.doQuote(action), self.doQuote(jobsize), self.doQuote(jobprice), self.doQuote(filename), self.doQuote(title), self.doQuote(copies), self.doQuote(options), self.doQuote(clienthost), self.doQuote(jobsizebytes), self.doQuote(jobmd5sum), self.doQuote(jobpages), self.doQuote(jobbilling), self.doQuote(precomputedsize), self.doQuote(precomputedprice), self.doQuote(printer.LastJob.ident)))
-            
+
     def saveUserPQuota(self, userpquota) :
         """Saves an user print quota entry."""
@@ -774 +774 @@
                                  self.doQuote(userpquota.MaxJobSize), \
                                  self.doQuote(userpquota.ident)))
-        
+
     def writeUserPQuotaWarnCount(self, userpquota, warncount) :
         """Sets the warn counter value for a user quota."""
         self.doModify("UPDATE userpquota SET warncount=%s WHERE id=%s" % (self.doQuote(warncount), self.doQuote(userpquota.ident)))
-        
+
     def increaseUserPQuotaWarnCount(self, userpquota) :
         """Increases the warn counter value for a user quota."""
         self.doModify("UPDATE userpquota SET warncount=warncount+1 WHERE id=%s" % self.doQuote(userpquota.ident))
-        
+
     def saveGroupPQuota(self, grouppquota) :
         """Saves a group print quota entry."""
@@ -798 +798 @@
             for record in result :
                 children.append(record.get("printerid")) # TODO : put this into the database integrity rules
-        if printer.ident not in children :        
+        if printer.ident not in children :
             self.doModify("INSERT INTO printergroupsmembers (groupid, printerid) VALUES (%s, %s)" % (self.doQuote(pgroup.ident), self.doQuote(printer.ident)))
-        
+
     def removePrinterFromGroup(self, pgroup, printer) :
         """Removes a printer from a printer group."""
         self.doModify("DELETE FROM printergroupsmembers WHERE groupid=%s AND printerid=%s" % (self.doQuote(pgroup.ident), self.doQuote(printer.ident)))
-        
+
     def retrieveHistory(self, user=None, printer=None, hostname=None, billingcode=None, jobid=None, limit=100, start=None, end=None) :
         """Retrieves all print jobs for user on printer (or all) between start and end date, limited to first 100 results."""
@@ -813 +813 @@
         if printer is not None : # printer.ident is None anyway if printer doesn't exist
             where.append("printerid=%s" % self.doQuote(printer.ident))
-        if hostname is not None :    
+        if hostname is not None :
             where.append("hostname=%s" % self.doQuote(hostname))
-        if billingcode is not None :    
+        if billingcode is not None :
             where.append("billingcode=%s" % self.doQuote(unicodeToDatabase(billingcode)))
-        if jobid is not None :    
+        if jobid is not None :
             where.append("jobid=%s" % self.doQuote(jobid)) # TODO : jobid is text, so unicodeToDatabase(jobid) but do all of them as well.
-        if start is not None :    
+        if start is not None :
             where.append("jobdate>=%s" % self.doQuote(start))
-        if end is not None :    
+        if end is not None :
             where.append("jobdate<=%s" % self.doQuote(end))
-        if where :    
+        if where :
             query += " AND %s" % " AND ".join(where)
         query += " ORDER BY jobhistory.id DESC"
@@ -829 +829 @@
             # TODO : LIMIT is not supported under DB2.
             # TODO : so we must use something like " FETCH FIRST %s ROWS ONLY" % self.doQuote(int(limit))
-            query += " LIMIT %s" % self.doQuote(int(limit)) 
-        jobs = []    
-        result = self.doSearch(query)    
+            query += " LIMIT %s" % self.doQuote(int(limit))
+        jobs = []
+        result = self.doSearch(query)
         if result :
             for fields in result :
@@ -837 +837 @@
                 jobs.append(job)
         return jobs
-        
-    def deleteUser(self, user) :    
+
+    def deleteUser(self, user) :
         """Completely deletes an user from the database."""
         # TODO : What should we do if we delete the last person who used a given printer ?
         # TODO : we can't reassign the last job to the previous one, because next user would be
         # TODO : incorrectly charged (overcharged).
-        for q in [ 
+        for q in [
                     "DELETE FROM payments WHERE userid=%s" % self.doQuote(user.ident),
                     "DELETE FROM groupsmembers WHERE userid=%s" % self.doQuote(user.ident),
@@ -851 +851 @@
                   ] :
             self.doModify(q)
-            
-    def multipleQueriesInTransaction(self, queries) :        
+
+    def multipleQueriesInTransaction(self, queries) :
         """Does many modifications in a single transaction."""
         self.beginTransaction()
@@ -858 +858 @@
             for q in queries :
                 self.doModify(q)
-        except :    
+        except :
             self.rollbackTransaction()
             raise
-        else :    
+        else :
             self.commitTransaction()
-            
-    def deleteManyBillingCodes(self, billingcodes) :        
+
+    def deleteManyBillingCodes(self, billingcodes) :
         """Deletes many billing codes."""
         codeids = ", ".join(["%s" % self.doQuote(b.ident) for b in billingcodes])
         if codeids :
-            self.multipleQueriesInTransaction([ 
+            self.multipleQueriesInTransaction([
                     "DELETE FROM billingcodes WHERE id IN (%s)" % codeids,])
-            
-    def deleteManyUsers(self, users) :        
+
+    def deleteManyUsers(self, users) :
         """Deletes many users."""
         userids = ", ".join(["%s" % self.doQuote(u.ident) for u in users])
         if userids :
-            self.multipleQueriesInTransaction([ 
+            self.multipleQueriesInTransaction([
                     "DELETE FROM payments WHERE userid IN (%s)" % userids,
                     "DELETE FROM groupsmembers WHERE userid IN (%s)" % userids,
@@ -881 +881 @@
                     "DELETE FROM userpquota WHERE userid IN (%s)" % userids,
                     "DELETE FROM users WHERE id IN (%s)" % userids,])
-                    
-    def deleteManyGroups(self, groups) :        
+
+    def deleteManyGroups(self, groups) :
         """Deletes many groups."""
         groupids = ", ".join(["%s" % self.doQuote(g.ident) for g in groups])
         if groupids :
-            self.multipleQueriesInTransaction([ 
+            self.multipleQueriesInTransaction([
                     "DELETE FROM groupsmembers WHERE groupid IN (%s)" % groupids,
                     "DELETE FROM grouppquota WHERE groupid IN (%s)" % groupids,
                     "DELETE FROM groups WHERE id IN (%s)" % groupids,])
-        
+
     def deleteManyPrinters(self, printers) :
         """Deletes many printers."""
         printerids = ", ".join(["%s" % self.doQuote(p.ident) for p in printers])
         if printerids :
-            self.multipleQueriesInTransaction([ 
+            self.multipleQueriesInTransaction([
                     "DELETE FROM printergroupsmembers WHERE groupid IN (%s) OR printerid IN (%s)" % (printerids, printerids),
                     "DELETE FROM jobhistory WHERE printerid IN (%s)" % printerids,
@@ -901 +901 @@
                     "DELETE FROM userpquota WHERE printerid IN (%s)" % printerids,
                     "DELETE FROM printers WHERE id IN (%s)" % printerids,])
-        
-    def deleteManyUserPQuotas(self, printers, users) :        
+
+    def deleteManyUserPQuotas(self, printers, users) :
         """Deletes many user print quota entries."""
         printerids = ", ".join(["%s" % self.doQuote(p.ident) for p in printers])
         userids = ", ".join(["%s" % self.doQuote(u.ident) for u in users])
         if userids and printerids :
-            self.multipleQueriesInTransaction([ 
+            self.multipleQueriesInTransaction([
                     "DELETE FROM jobhistory WHERE userid IN (%s) AND printerid IN (%s)" \
                                  % (userids, printerids),
                     "DELETE FROM userpquota WHERE userid IN (%s) AND printerid IN (%s)" \
                                  % (userids, printerids),])
-            
+
     def deleteManyGroupPQuotas(self, printers, groups) :
         """Deletes many group print quota entries."""
@@ -918 +918 @@
         groupids = ", ".join(["%s" % self.doQuote(g.ident) for g in groups])
         if groupids and printerids :
-            self.multipleQueriesInTransaction([ 
+            self.multipleQueriesInTransaction([
                     "DELETE FROM grouppquota WHERE groupid IN (%s) AND printerid IN (%s)" \
                                  % (groupids, printerids),])
-        
-    def deleteUserPQuota(self, upquota) :    
+
+    def deleteUserPQuota(self, upquota) :
         """Completely deletes an user print quota entry from the database."""
-        for q in [ 
+        for q in [
                     "DELETE FROM jobhistory WHERE userid=%s AND printerid=%s" \
                                  % (self.doQuote(upquota.User.ident), self.doQuote(upquota.Printer.ident)),
@@ -930 +930 @@
                   ] :
             self.doModify(q)
-        
-    def deleteGroupPQuota(self, gpquota) :    
+
+    def deleteGroupPQuota(self, gpquota) :
         """Completely deletes a group print quota entry from the database."""
-        for q in [ 
+        for q in [
                     "DELETE FROM grouppquota WHERE id=%s" % self.doQuote(gpquota.ident),
                   ] :
             self.doModify(q)
-        
-    def deleteGroup(self, group) :    
+
+    def deleteGroup(self, group) :
         """Completely deletes a group from the database."""
         for q in [
@@ -944 +944 @@
                    "DELETE FROM grouppquota WHERE groupid=%s" % self.doQuote(group.ident),
                    "DELETE FROM groups WHERE id=%s" % self.doQuote(group.ident),
-                 ] :  
+                 ] :
             self.doModify(q)
-            
-    def deletePrinter(self, printer) :    
+
+    def deletePrinter(self, printer) :
         """Completely deletes a printer from the database."""
-        for q in [ 
+        for q in [
                     "DELETE FROM printergroupsmembers WHERE groupid=%s OR printerid=%s" % (self.doQuote(printer.ident), self.doQuote(printer.ident)),
                     "DELETE FROM jobhistory WHERE printerid=%s" % self.doQuote(printer.ident),
@@ -957 +957 @@
                   ] :
             self.doModify(q)
-            
-    def deleteBillingCode(self, code) :    
+
+    def deleteBillingCode(self, code) :
         """Completely deletes a billing code from the database."""
         for q in [
                    "DELETE FROM billingcodes WHERE id=%s" % self.doQuote(code.ident),
-                 ] :  
+                 ] :
             self.doModify(q)
-        
+