Changeset 2765 for pykota/trunk/pykota/storages

Timestamp:

03/01/06 00:07:05 (18 years ago)

Author:

jerome

Message:

Optimized pkbcodes like edpykota.

Location:

pykota/trunk/pykota/storages

Files:

• ldapstorage.py (modified) (4 diffs)
• sql.py (modified) (3 diffs)

pykota/trunk/pykota/storages/ldapstorage.py

@@ -1462 +1462 @@
                 self.doDelete(group.ident)
                 
-    def deleteManyBillingCodesFromNames(self, billingcodes) :        
-        """Deletes many billing codes from their names."""
-        for bcode in self.getMatchingBillingCodes(",".join(billingcodes)) :
+    def deleteManyBillingCodes(self, billingcodes) :
+        """Deletes many billing codes."""
+        for bcode in billingcodes :
             bcode.delete()
         
-    def deleteManyUsersFromNames(self, usernames) :        
-        """Deletes many users from their names."""
-        for user in self.getMatchingUsers(",".join(usernames)) : 
+    def deleteManyUsers(self, users) :        
+        """Deletes many users."""
+        for user in users :
             user.delete()
             
-    def deleteManyGroupsFromNames(self, groupnames) :        
-        """Deletes many groups from their names."""
-        for group in self.getMatchingGroups(",".join(groupnames)) : 
+    def deleteManyGroups(self, groups) :        
+        """Deletes many groups."""
+        for group in groups :
             group.delete()
         
-    def deleteManyPrintersFromNames(self, printernames) :        
-        """Deletes many printers from their names."""
-        for printer in self.getMatchingPrinters(",".join(printernames)) :
+    def deleteManyPrinters(self, printers) :        
+        """Deletes many printers."""
+        for printer in printers :
             printer.delete()
         
@@ -1701 +1701 @@
         return code    
         
-    def addBillingCode(self, label) :
+    def addBillingCode(self, bcode) :
         """Adds a billing code to the quota storage, returns it."""
+        oldentry = self.getBillingCode(bcode.BillingCode)
+        if oldentry.Exists :
+            return oldentry # we return the existing entry
         uuid = self.genUUID()
         dn = "cn=%s,%s" % (uuid, self.info["billingcodebase"])
         fields = { "objectClass" : ["pykotaObject", "pykotaBilling"],
                    "cn" : uuid,
-                   "pykotaBillingCode" : self.userCharsetToDatabase(label),
-                   "pykotaPageCounter" : "0",
-                   "pykotaBalance" : "0.0",
+                   "pykotaBillingCode" : self.userCharsetToDatabase(bcode.BillingCode),
+                   "pykotaPageCounter" : str(bcode.PageCounter or 0),
+                   "pykotaBalance" : str(bcode.Balance or 0.0),
+                   "description" : self.userCharsetToDatabase(bcode.Description or ""), 
                  } 
         self.doAdd(dn, fields)
-        return self.getBillingCode(label)
-        
-    def saveBillingCode(self, code) :
+        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" : self.userCharsetToDatabase(code.Description or ""), 
-                   "pykotaPageCounter" : str(code.PageCounter),
-                   "pykotaBalance" : str(code.Balance),
+                   "description" : self.userCharsetToDatabase(bcode.Description or ""), 
+                   "pykotaPageCounter" : str(bcode.PageCounter or 0),
+                   "pykotaBalance" : str(bcode.Balance or 0.0),
                  }
-        self.doModify(code.ident, fields)
+        self.doModify(bcode.ident, fields)
             
     def getMatchingBillingCodes(self, billingcodepattern) :
@@ -1744 +1749 @@
         return codes        
         
-    def consumeBillingCode(self, code, pagecounter, balance) :
+    def consumeBillingCode(self, bcode, pagecounter, balance) :
         """Consumes from a billing code."""
         fields = {
@@ -1750 +1755 @@
                    "pykotaPageCounter" : { "operator" : "+", "value" : pagecounter, "convert" : int },
                  }
-        return self.doModify(code.ident, fields)         
+        return self.doModify(bcode.ident, fields)         
 

pykota/trunk/pykota/storages/sql.py

@@ -532 +532 @@
         return self.getPrinter(printername)
         
-    def addBillingCode(self, label) :        
-        """Adds a billing code to the quota storage, returns it."""
-        self.doModify("INSERT INTO billingcodes (billingcode) VALUES (%s)" % self.doQuote(self.userCharsetToDatabase(label)))
-        return self.getBillingCode(label)
+    def addBillingCode(self, bcode) :
+        """Adds a billing code to the quota storage, returns the old value if it already exists."""
+        try :
+            self.doModify("INSERT INTO billingcodes (billingcode, balance, pagecounter, description) VALUES (%s, %s, %s, %s)" \
+                               % (self.doQuote(self.userCharsetToDatabase(bcode.BillingCode)), 
+                                  self.doQuote(bcode.Balance or 0.0), \
+                                  self.doQuote(bcode.PageCounter or 0), \
+                                  self.doQuote(self.userCharsetToDatabase(bcode.Description))))
+        except PyKotaStorageError :    
+            # TODO : check if this is an error different from a duplicate insert
+            # return the existing entry which has to be modified
+            return self.getBillingCode(bcode.BillingCode)
+        else :    
+            bcode.isDirty = False
+            return None # the entry created doesn't need further modification
         
     def addUser(self, user) :        
@@ -651 +662 @@
         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, code) :    
+    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" \
-                            % (self.doQuote(code.Balance or 0.0), \
-                               self.doQuote(code.PageCounter or 0), \
-                               self.doQuote(self.userCharsetToDatabase(code.Description)), \
-                               self.doQuote(code.ident)))
+                            % (self.doQuote(bcode.Balance or 0.0), \
+                               self.doQuote(bcode.PageCounter or 0), \
+                               self.doQuote(self.userCharsetToDatabase(bcode.Description)), \
+                               self.doQuote(bcode.ident)))
        
-    def consumeBillingCode(self, code, pagecounter, balance) :
+    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(code.ident)))
+        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 decreaseUserAccountBalance(self, user, amount) :    
@@ -813 +824 @@
             self.commitTransaction()
             
-    def deleteManyBillingCodesFromNames(self, billingcodes) :        
-        """Deletes many billing codes from their names."""
-        codelabels = ", ".join(["%s" % self.doQuote(b) for b in billingcodes])
+    def deleteManyBillingCodes(self, billingcodes) :        
+        """Deletes many billing codes."""
+        codeids = ", ".join(["%s" % self.doQuote(b.ident) for b in billingcodes])
         self.deleteInTransaction([ 
-                    "DELETE FROM billingcodes WHERE billingcode IN (%s)" % codelabels,])
-            
-    def deleteManyUsersFromNames(self, usernames) :        
-        """Deletes many users from their names."""
-        usernames = ", ".join(["%s" % self.doQuote(u) for u in usernames])
+                    "DELETE FROM billingcodes WHERE id IN (%s)" % codeids,])
+            
+    def deleteManyUsers(self, users) :        
+        """Deletes many users."""
+        userids = ", ".join(["%s" % self.doQuote(u.ident) for u in users])
         self.deleteInTransaction([ 
-                    "DELETE FROM payments WHERE userid IN (SELECT id FROM users WHERE username IN %s)" % usernames,
-                    "DELETE FROM groupsmembers WHERE userid IN (SELECT id FROM users WHERE username IN %s)" % usernames,
-                    "DELETE FROM jobhistory WHERE userid IN (SELECT id FROM users WHERE username IN %s)" % usernames,
-                    "DELETE FROM userpquota WHERE userid IN (SELECT id FROM users WHERE username IN %s)" % usernames,
-                    "DELETE FROM users WHERE username IN %s" % usernames,])
-        
-    def deleteManyPrintersFromNames(self, printernames) :        
-        """Deletes many printers from their names."""
-        printernames = ", ".join(["%s" % self.doQuote(p) for p in printernames])
+                    "DELETE FROM payments WHERE userid IN (%s)" % userids,
+                    "DELETE FROM groupsmembers WHERE userid IN (%s)" % userids,
+                    "DELETE FROM jobhistory WHERE userid IN (%s)" % userids,
+                    "DELETE FROM userpquota WHERE userid IN (%s)" % userids,
+                    "DELETE FROM users WHERE id IN (%s)" % userids,])
+                    
+    def deleteManyGroups(self, groups) :        
+        """Deletes many groups."""
+        groupids = ", ".join(["%s" % self.doQuote(g.ident) for g in groups])
         self.deleteInTransaction([ 
-                    "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),
-                    "DELETE FROM grouppquota WHERE printerid=%s" % self.doQuote(printer.ident),
-                    "DELETE FROM userpquota WHERE printerid=%s" % self.doQuote(printer.ident),
-                    "DELETE FROM printers WHERE id=%s" % self.doQuote(printer.ident),])
+                    "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])
+        self.deleteInTransaction([ 
+                    "DELETE FROM printergroupsmembers WHERE groupid IN (%s) OR printerid IN (%s)" % printerids,
+                    "DELETE FROM jobhistory WHERE printerid IN (%s)" % printerids,
+                    "DELETE FROM grouppquota WHERE printerid IN (%s)" % printerids,
+                    "DELETE FROM userpquota WHERE printerid IN (%s)" % printerids,
+                    "DELETE FROM printers WHERE id IN (%s)" % printerids,])
         
     def deleteManyUserPQuotas(self, printers, users) :