Changeset 2749 for pykota/trunk/pykota/storages

Timestamp:

02/23/06 11:58:05 (18 years ago)

Author:

jerome

Message:

Now manage print quota entries the way it should be done (c) (tm) !

Location:

pykota/trunk/pykota/storages

Files:

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

pykota/trunk/pykota/storages/ldapstorage.py

@@ -191 +191 @@
                 self.tool.logdebug("%s" % entry)
                 self.database.add_s(dn, entry)
+            except ldap.ALREADY_EXISTS, msg :        
+                raise PyKotaStorageError
             except ldap.LDAPError, msg :
                 message = (_("Problem adding LDAP entry (%s, %s)") % (dn, str(fields))) + " : %s" % str(msg)
@@ -454 +456 @@
             result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaUserName=%s)(pykotaPrinterName=%s))" % \
                                       (self.userCharsetToDatabase(user.Name), self.userCharsetToDatabase(printer.Name)), \
-                                      ["pykotaPageCounter", "pykotaLifePageCounter", "pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaWarnCount"], \
+                                      ["pykotaPageCounter", "pykotaLifePageCounter", "pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaWarnCount", "pykotaMaxJobSize"], \
                                       base=base)
             if result :
@@ -480 +482 @@
                     else :    
                         userpquota.DateLimit = userpquota.DateLimit[0]
+                userpquota.MaxJobSize = fields.get("pykotaMaxJobSize")
+                if userpquota.MaxJobSize is not None :
+                    if userpquota.MaxJobSize[0].upper() == "NONE" :
+                        userpquota.MaxJobSize = None
+                    else :    
+                        userpquota.MaxJobSize = int(userpquota.MaxJobSize[0])
                 userpquota.Exists = 1
         return userpquota
@@ -493 +501 @@
             result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaGroupName=%s)(pykotaPrinterName=%s))" % \
                                       (self.userCharsetToDatabase(group.Name), self.userCharsetToDatabase(printer.Name)), \
-                                      ["pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit"], \
+                                      ["pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaMaxJobSize"], \
                                       base=base)
             if result :
@@ -516 +524 @@
                     else :    
                         grouppquota.DateLimit = grouppquota.DateLimit[0]
+                grouppquota.MaxJobSize = fields.get("pykotaMaxJobSize")
+                if grouppquota.MaxJobSize is not None :
+                    if grouppquota.MaxJobSize[0].upper() == "NONE" :
+                        grouppquota.MaxJobSize = None
+                    else :    
+                        grouppquota.MaxJobSize = int(grouppquota.MaxJobSize[0])
                 grouppquota.PageCounter = 0
                 grouppquota.LifePageCounter = 0
@@ -1018 +1032 @@
         raise "Not Implemented !" # TODO !!!
                 
-    def addUserPQuota(self, user, printer) :
+    def addUserPQuota(self, upq) :
         """Initializes a user print quota on a printer."""
+        # first check if an entry already exists
+        oldentry = self.getUserPQuota(upq.User, upq.Printer)
+        if oldentry.Exists :
+            return oldentry # we return the existing entry
         uuid = self.genUUID()
-        uname = self.userCharsetToDatabase(user.Name)
-        pname = self.userCharsetToDatabase(printer.Name)
+        uname = self.userCharsetToDatabase(upq.User.Name)
+        pname = self.userCharsetToDatabase(upq.Printer.Name)
         fields = { "cn" : uuid,
                    "objectClass" : ["pykotaObject", "pykotaUserPQuota"],
                    "pykotaUserName" : uname,
                    "pykotaPrinterName" : pname,
-                   "pykotaDateLimit" : "None",
-                   "pykotaPageCounter" : "0",
-                   "pykotaLifePageCounter" : "0",
-                   "pykotaWarnCount" : "0",
+                   "pykotaSoftLimit" : str(upq.SoftLimit),
+                   "pykotaHardLimit" : str(upq.HardLimit),
+                   "pykotaDateLimit" : str(upq.DateLimit),
+                   "pykotaPageCounter" : str(upq.PageCounter or 0),
+                   "pykotaLifePageCounter" : str(upq.LifePageCounter or 0),
+                   "pykotaWarnCount" : str(upq.WarnCount or 0),
+                   "pykotaMaxJobSize" : str(upq.MaxJobSize or 0),
                  } 
         if self.info["userquotabase"].lower() == "user" :
-            dn = "cn=%s,%s" % (uuid, user.ident)
+            dn = "cn=%s,%s" % (uuid, upq.User.ident)
         else :    
             dn = "cn=%s,%s" % (uuid, self.info["userquotabase"])
         self.doAdd(dn, fields)
-        return self.getUserPQuota(user, printer)
-        
-    def addGroupPQuota(self, group, printer) :
+        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."""
+        oldentry = self.getGroupPQuota(gpq.Group, gpq.Printer)
+        if oldentry.Exists :
+            return oldentry # we return the existing entry
         uuid = self.genUUID()
-        gname = self.userCharsetToDatabase(group.Name)
-        pname = self.userCharsetToDatabase(printer.Name)
+        gname = self.userCharsetToDatabase(gpq.Group.Name)
+        pname = self.userCharsetToDatabase(gpq.Printer.Name)
         fields = { "cn" : uuid,
                    "objectClass" : ["pykotaObject", "pykotaGroupPQuota"],
@@ -1051 +1076 @@
                  } 
         if self.info["groupquotabase"].lower() == "group" :
-            dn = "cn=%s,%s" % (uuid, group.ident)
+            dn = "cn=%s,%s" % (uuid, gpq.Group.ident)
         else :    
             dn = "cn=%s,%s" % (uuid, self.info["groupquotabase"])
         self.doAdd(dn, fields)
-        return self.getGroupPQuota(group, printer)
+        gpq.isDirty = False
+        return None # the entry created doesn't need further modification
         
     def savePrinter(self, printer) :    
@@ -1204 +1230 @@
                    "pykotaHardLimit" : str(userpquota.HardLimit),
                    "pykotaDateLimit" : str(userpquota.DateLimit),
-                   "pykotaWarnCount" : str(userpquota.WarnCount),
-                   "pykotaPageCounter" : str(userpquota.PageCounter),
-                   "pykotaLifePageCounter" : str(userpquota.LifePageCounter),
+                   "pykotaWarnCount" : str(userpquota.WarnCount or 0),
+                   "pykotaPageCounter" : str(userpquota.PageCounter or 0),
+                   "pykotaLifePageCounter" : str(userpquota.LifePageCounter or 0),
+                   "pykotaMaxJobSize" : str(userpquota.MaxJobSize or 0),
                  }
         self.doModify(userpquota.ident, fields)
@@ -1230 +1257 @@
                    "pykotaHardLimit" : str(grouppquota.HardLimit),
                    "pykotaDateLimit" : str(grouppquota.DateLimit),
+                   "pykotaMaxJobSize" : str(userpquota.MaxJobSize or 0),
                  }
         self.doModify(grouppquota.ident, fields)
@@ -1427 +1455 @@
                 self.doDelete(group.ident)
                 
+    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 !)
+        for printer in printers :
+            for user in users :
+                upq = self.getUserPQuota(user, printer)
+                if upq.Exists :
+                    upq.delete()
+            
+    def deleteManyGroupPQuotas(self, printers, groups) :
+        """Deletes many group print quota entries."""
+        # TODO : grab all with a single (possibly VERY huge) filter if possible (might depend on the LDAP server !)
+        for printer in printers :
+            for group in groups :
+                gpq = self.getGroupPQuota(group, printer)
+                if gpq.Exists :
+                    gpq.delete()
+                
     def deleteUserPQuota(self, upquota) :    
         """Completely deletes an user print quota entry from the database."""

pykota/trunk/pykota/storages/sql.py

@@ -644 +644 @@
                        (self.doQuote(group.ident), self.doQuote(user.ident)))
             
-    def addUserPQuota(self, user, printer) :
+    def addUserPQuota(self, upq) :
         """Initializes a user print quota on a printer."""
-        self.doModify("INSERT INTO userpquota (userid, printerid) VALUES (%s, %s)" % (self.doQuote(user.ident), self.doQuote(printer.ident)))
-        return self.getUserPQuota(user, printer)
-        
-    def addGroupPQuota(self, group, printer) :
+        try :
+            self.doModify("INSERT INTO userpquota (userid, printerid, softlimit, hardlimit, warncount, datelimit, pagecounter, lifepagecounter, maxjobsize) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)" \
+                              % (self.doQuote(upq.User.ident), \
+                                 self.doQuote(upq.Printer.ident), \
+                                 self.doQuote(upq.SoftLimit), \
+                                 self.doQuote(upq.HardLimit), \
+                                 self.doQuote(upq.WarnCount), \
+                                 self.doQuote(upq.DateLimit), \
+                                 self.doQuote(upq.PageCounter), \
+                                 self.doQuote(upq.LifePageCounter), \
+                                 self.doQuote(upq.MaxJobSize)))
+        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.getUserPQuota(upq.User, upq.Printer)
+        else :    
+            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."""
-        self.doModify("INSERT INTO grouppquota (groupid, printerid) VALUES (%s, %s)" % (self.doQuote(group.ident), self.doQuote(printer.ident)))
-        return self.getGroupPQuota(group, printer)
+        try :
+            self.doModify("INSERT INTO grouppquota (groupid, printerid, softlimit, hardlimit, datelimit, maxjobsize) VALUES (%s, %s, %s, %s, %s, %s)" \
+                              % (self.doQuote(gpq.Group.ident), \
+                                 self.doQuote(gpq.Printer.ident), \
+                                 self.doQuote(gpq.SoftLimit), \
+                                 self.doQuote(gpq.HardLimit), \
+                                 self.doQuote(gpq.DateLimit), \
+                                 self.doQuote(gpq.MaxJobSize)))
+        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.getGroupPQuota(gpq.Group, gpq.Printer)
+        else :    
+            gpq.isDirty = False
+            return None # the entry created doesn't need further modification
         
     def savePrinter(self, printer) :    
@@ -738 +767 @@
     def saveUserPQuota(self, userpquota) :
         """Saves an user print quota entry."""
-        self.doModify("UPDATE userpquota SET softlimit=%s, hardlimit=%s, warncount=%s, datelimit=%s, pagecounter=%s, lifepagecounter=%s WHERE id=%s" \
+        self.doModify("UPDATE userpquota SET softlimit=%s, hardlimit=%s, warncount=%s, datelimit=%s, pagecounter=%s, lifepagecounter=%s, maxjobsize=%s WHERE id=%s" \
                               % (self.doQuote(userpquota.SoftLimit), \
                                  self.doQuote(userpquota.HardLimit), \
@@ -745 +774 @@
                                  self.doQuote(userpquota.PageCounter), \
                                  self.doQuote(userpquota.LifePageCounter), \
+                                 self.doQuote(userpquota.MaxJobSize), \
                                  self.doQuote(userpquota.ident)))
         
@@ -843 +873 @@
             self.doModify(q)
             
+    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])
+        for q in [ 
+                    "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),
+                  ] :
+            self.doModify(q)
+            
+    def deleteManyGroupPQuotas(self, printers, groups) :
+        """Deletes many group print quota entries."""
+        printerids = ", ".join(["%s" % self.doQuote(p.ident) for p in printers])
+        groupids = ", ".join(["%s" % self.doQuote(g.ident) for g in groups])
+        for q in [ 
+                    "DELETE FROM grouppquota WHERE groupid IN (%s) AND printerid IN (%s)" \
+                                 % (groupids, printerids),
+                  ] :
+            self.doModify(q)
+        
     def deleteUserPQuota(self, upquota) :    
         """Completely deletes an user print quota entry from the database."""