Changeset 2735

Show
Ignore:
Timestamp:
02/21/06 16:43:18 (19 years ago)
Author:
jerome
Message:

Completely untested modification stuff...

Location:
pykota/trunk
Files:
4 modified

Legend:

Unmodified
Added
Removed
  • pykota/trunk/bin/edpykota

    r2731 r2735  
    166166            self.display("%s...\n" % _("Deletion")) 
    167167            nbtotal = len(pqentries) 
    168             for i in range(nbtotal) : 
    169                 (pqkey, pqentry) = pqentries.popitem() 
     168            i = 0 
     169            for (pqkey, pqentry) in pqentries.items() : 
    170170                if pqentry.Exists : 
    171171                    pqentry.delete() 
     172                i += 1     
    172173                percent = 100.0 * float(i) / float(nbtotal) 
    173174                self.display("\r%.02f%%" % percent) 
     
    197198                            else : 
    198199                                pqentries[pqkey] = newpqentry 
     200                        i += 1 
    199201                        percent = 100.0 * float(i) / float(nbtotal) 
    200202                        self.display("\r%.02f%%" % percent) 
    201                         i += 1 
    202203                self.display("\r100.00%%\r        \r%s\n" % _("Done.")) 
    203204                 
     
    220221            else : 
    221222                self.display("%s...\n" % _("Modification")) 
    222                 raise PyKotaCommandLineError, "Not implemented yet." 
    223                 softlimit = hardlimit = None 
    224223                 
    225224                used = options["used"] 
     
    238237                        raise PyKotaCommandLineError, _("Invalid increase value %s.") % increase 
    239238                 
    240                 if not options["noquota"] : 
     239                softlimit = hardlimit = None 
     240                noquota = options["noquota"] 
     241                if not noquota : 
    241242                    if options["softlimit"] : 
    242243                        try : 
     
    257258                        self.printInfo(_("Hard limit %i is less than soft limit %i, values will be exchanged.") % (hardlimit, softlimit)) 
    258259                        (softlimit, hardlimit) = (hardlimit, softlimit) 
     260                    if hardlimit is None :     
     261                        hardlimit = softlimit 
     262                        if hardlimit is not None : 
     263                            self.printInfo(_("Undefined hard limit set to soft limit (%s) on printer %s.") % (str(hardlimit), printer.Name)) 
     264                    if softlimit is None :     
     265                        softlimit = hardlimit 
     266                        if softlimit is not None : 
     267                            self.printInfo(_("Undefined soft limit set to hard limit (%s) on printer %s.") % (str(softlimit), printer.Name)) 
    259268                     
    260                 sys.stdout.write(_("Managing print quotas... (this may take a lot of time)")) 
    261                 sys.stdout.flush() 
    262                 missingusers = {} 
    263                 missinggroups = {}     
    264                 changed = {} # tracks changes made at the user/group level 
    265                 for printer in printers : 
    266                     if not options["noquota"] :     
    267                         if hardlimit is None :     
    268                             hardlimit = softlimit 
    269                             if hardlimit is not None : 
    270                                 self.printInfo(_("Undefined hard limit set to soft limit (%s) on printer %s.") % (str(hardlimit), printer.Name)) 
    271                         if softlimit is None :     
    272                             softlimit = hardlimit 
    273                             if softlimit is not None : 
    274                                 self.printInfo(_("Undefined soft limit set to hard limit (%s) on printer %s.") % (str(softlimit), printer.Name)) 
     269                nbtotal = len(pqentries)     
     270                i = 0 
     271                for pqentry in pqentries :     
     272                    ename = getattr(pqentry, suffix).Name 
     273                    pname = pqentry.Printer.Name 
     274                    if pqentry.Exists :      
     275                        if noquota or ((softlimit is not None) and (hardlimit is not None)) : 
     276                            pqentry.setLimits(softlimit, hardlimit) 
     277                             
     278                        if increase : 
     279                           if (pqentry.SoftLimit is None) \ 
     280                               or (pqentry.HardLimit is None) : 
     281                               self.printInfo(_("You can't increase limits by %s when no limit is set.") % increase, "error") 
     282                           else : 
     283                               newsoft = pqentry.SoftLimit + increase          
     284                               newhard = pqentry.HardLimit + increase          
     285                               if (newsoft >= 0) and (newhard >= 0) : 
     286                                   pqentry.setLimits(newsoft, newhard) 
     287                               else :     
     288                                   self.printInfo(_("You can't set negative limits."), "error") 
     289                         
     290                        if options["reset"] : 
     291                            pqentry.reset() 
     292                             
     293                        if options["hardreset"] :     
     294                            pqentry.hardreset() 
     295                             
     296                        if not options["groups"] : 
     297                            if used : 
     298                                pqentry.setUsage(used) 
    275299                                 
    276                     if options["add"] :     
    277                         allentries = []     
    278                         for name in names : 
    279                             email = "" 
    280                             if not options["groups"] : 
    281                                 splitname = name.split('/', 1)     # username/email 
    282                                 if len(splitname) == 1 : 
    283                                     splitname.append("") 
    284                                 (name, email) = splitname 
    285                                 if email and (email.count('@') != 1) : 
    286                                     self.printInfo(_("Invalid email address %s") % email) 
    287                                     email = "" 
    288                             entry = getattr(self.storage, "get%s" % suffix)(name) 
    289                             if email and not options["groups"] : 
    290                                 entry.Email = email 
    291                             entrypquota = getattr(self.storage, "get%sPQuota" % suffix)(entry, printer) 
    292                             allentries.append((entry, entrypquota)) 
    293                     else :    
    294                         allentries = getattr(self.storage, "getPrinter%ssAndQuotas" % suffix)(printer, names) 
    295                          
    296                     for (entry, entrypquota) in allentries : 
    297                         if not changed.has_key(entry.Name) : 
    298                             changed[entry.Name] = {} 
    299                             if not options["groups"] : 
    300                                 changed[entry.Name]["ingroups"] = [] 
    301                                  
    302                         if entry.Exists and (not entrypquota.Exists) : 
    303                             # not found 
    304                             if options["add"] : 
    305                                 entrypquota = getattr(self.storage, "add%sPQuota" % suffix)(entry, printer) 
    306                                  
    307                         if not entrypquota.Exists :      
    308                             self.printInfo(_("Quota not found for object %s on printer %s.") % (entry.Name, printer.Name)) 
    309                         else :     
    310                             if options["noquota"] \ 
    311                                or ((softlimit is not None) and (hardlimit is not None)) : 
    312                                 entrypquota.setLimits(softlimit, hardlimit) 
    313                                  
    314                             if increase : 
    315                                if (entrypquota.SoftLimit is None) \ 
    316                                    or (entrypquota.HardLimit is None) : 
    317                                    self.printInfo(_("You can't increase limits by %s when no limit is set.") % increase, "error") 
    318                                else : 
    319                                    newsoft = entrypquota.SoftLimit + increase          
    320                                    newhard = entrypquota.HardLimit + increase          
    321                                    if (newsoft >= 0) and (newhard >= 0) : 
    322                                        entrypquota.setLimits(newsoft, newhard) 
    323                                    else :     
    324                                        self.printInfo(_("You can't set negative limits."), "error") 
    325                              
    326                             if options["reset"] : 
    327                                 entrypquota.reset() 
    328                                  
    329                             if options["hardreset"] :     
    330                                 entrypquota.hardreset() 
    331                                  
    332                             if not options["groups"] : 
    333                                 if used : 
    334                                     entrypquota.setUsage(used) 
     300                        pqentry.save()         
     301                    i += 1             
     302                    percent = 100.0 * float(i) / float(nbtotal) 
     303                    self.display("\r%.02f%%" % percent) 
    335304                                 
    336305        if not options["list"] :                 
  • pykota/trunk/pykota/storage.py

    r2733 r2735  
    266266    def setLimits(self, softlimit, hardlimit) :     
    267267        """Sets the soft and hard limit for this quota.""" 
    268         self.parent.writeUserPQuotaLimits(self, softlimit, hardlimit) 
    269268        self.SoftLimit = softlimit 
    270269        self.HardLimit = hardlimit 
    271270        self.DateLimit = None 
    272271        self.WarnCount = 0 
     272        self.isDirty = True 
    273273         
    274274    def setUsage(self, used) : 
     
    276276        vused = int(used) 
    277277        if used.startswith("+") or used.startswith("-") : 
    278             self.parent.beginTransaction() 
    279             try : 
    280                 self.parent.increaseUserPQuotaPagesCounters(self, vused) 
    281                 self.parent.writeUserPQuotaDateLimit(self, None) 
    282                 self.parent.writeUserPQuotaWarnCount(self, 0) 
    283             except PyKotaStorageError, msg :     
    284                 self.parent.rollbackTransaction() 
    285                 raise PyKotaStorageError, msg 
    286             else : 
    287                 self.parent.commitTransaction() 
    288278            self.PageCounter += vused 
    289279            self.LifePageCounter += vused 
    290280        else : 
    291             self.parent.writeUserPQuotaPagesCounters(self, vused, vused) 
    292281            self.PageCounter = self.LifePageCounter = vused 
    293282        self.DateLimit = None 
    294283        self.WarnCount = 0 
     284        self.isDirty = 1 
    295285 
    296286    def incDenyBannerCounter(self) : 
     
    306296    def reset(self) :     
    307297        """Resets page counter to 0.""" 
    308         self.parent.writeUserPQuotaPagesCounters(self, 0, int(self.LifePageCounter or 0)) 
    309298        self.PageCounter = 0 
    310299        self.DateLimit = None 
     300        self.isDirty = True 
    311301         
    312302    def hardreset(self) :     
    313303        """Resets actual and life time page counters to 0.""" 
    314         self.parent.writeUserPQuotaPagesCounters(self, 0, 0) 
    315304        self.PageCounter = self.LifePageCounter = 0 
    316305        self.DateLimit = None 
     306        self.isDirty = True 
    317307         
    318308    def computeJobPrice(self, jobsize) :     
     
    385375                uq = self.parent.getUserPQuota(user, self.Printer) 
    386376                uq.reset() 
    387             self.parent.writeGroupPQuotaDateLimit(self, None) 
     377                uq.save() 
    388378        except PyKotaStorageError, msg :     
    389379            self.parent.rollbackTransaction() 
     
    393383        self.PageCounter = 0 
    394384        self.DateLimit = None 
     385        self.isDirty = True 
    395386         
    396387    def hardreset(self) :     
     
    401392                uq = self.parent.getUserPQuota(user, self.Printer) 
    402393                uq.hardreset() 
    403             self.parent.writeGroupPQuotaDateLimit(self, None) 
     394                uq.save() 
    404395        except PyKotaStorageError, msg :     
    405396            self.parent.rollbackTransaction() 
     
    409400        self.PageCounter = self.LifePageCounter = 0 
    410401        self.DateLimit = None 
     402        self.isDirty = True 
    411403         
    412404    def setDateLimit(self, datelimit) :     
     
    423415    def setLimits(self, softlimit, hardlimit) :     
    424416        """Sets the soft and hard limit for this quota.""" 
    425         self.parent.writeGroupPQuotaLimits(self, softlimit, hardlimit) 
    426417        self.SoftLimit = softlimit 
    427418        self.HardLimit = hardlimit 
    428419        self.DateLimit = None 
     420        self.isDirty = True 
    429421         
    430422    def delete(self) :     
  • pykota/trunk/pykota/storages/ldapstorage.py

    r2726 r2735  
    11141114        return self.doModify(userpquota.ident, fields)          
    11151115         
    1116     def writeUserPQuotaPagesCounters(self, userpquota, newpagecounter, newlifepagecounter) :     
    1117         """Sets the new page counters permanently for a user print quota.""" 
    1118         fields = { 
    1119                    "pykotaPageCounter" : str(newpagecounter), 
    1120                    "pykotaLifePageCounter" : str(newlifepagecounter), 
    1121                    "pykotaDateLimit" : None, 
    1122                    "pykotaWarnCount" : "0", 
    1123                  }   
    1124         return self.doModify(userpquota.ident, fields)          
    1125         
    11261116    def decreaseUserAccountBalance(self, user, amount) :     
    11271117        """Decreases user's account balance from an amount.""" 
     
    12081198            self.doAdd(lastjdn, fields)           
    12091199             
    1210     def writeUserPQuotaLimits(self, userpquota, softlimit, hardlimit) : 
    1211         """Sets soft and hard limits for a user quota.""" 
     1200    def saveUserPQuota(self, userpquota) : 
     1201        """Saves an user print quota entry.""" 
    12121202        fields = {  
    1213                    "pykotaSoftLimit" : str(softlimit), 
    1214                    "pykotaHardLimit" : str(hardlimit), 
    1215                    "pykotaDateLimit" : "None", 
    1216                    "pykotaWarnCount" : "0", 
     1203                   "pykotaSoftLimit" : str(userpquota.SoftLimit), 
     1204                   "pykotaHardLimit" : str(userpquota.HardLimit), 
     1205                   "pykotaDateLimit" : str(userpquota.DateLimit), 
     1206                   "pykotaWarnCount" : str(userpquota.WarnCount), 
     1207                   "pykotaPageCounter" : str(userpquota.PageCounter), 
     1208                   "pykotaLifePageCounter" : str(userpquota.LifePageCounter), 
    12171209                 } 
    12181210        self.doModify(userpquota.ident, fields) 
     
    12321224        return self.doModify(userpquota.ident, fields)          
    12331225         
    1234     def writeGroupPQuotaLimits(self, grouppquota, softlimit, hardlimit) : 
    1235         """Sets soft and hard limits for a group quota on a specific printer.""" 
     1226    def saveGroupPQuota(self, grouppquota) : 
     1227        """Saves a group print quota entry.""" 
    12361228        fields = {  
    1237                    "pykotaSoftLimit" : str(softlimit), 
    1238                    "pykotaHardLimit" : str(hardlimit), 
    1239                    "pykotaDateLimit" : "None", 
     1229                   "pykotaSoftLimit" : str(grouppquota.SoftLimit), 
     1230                   "pykotaHardLimit" : str(grouppquota.HardLimit), 
     1231                   "pykotaDateLimit" : str(grouppquota.DateLimit), 
    12401232                 } 
    12411233        self.doModify(grouppquota.ident, fields) 
  • pykota/trunk/pykota/storages/sql.py

    r2734 r2735  
    672672        self.doModify("UPDATE userpquota SET pagecounter=pagecounter + %s,lifepagecounter=lifepagecounter + %s WHERE id=%s" % (self.doQuote(nbpages), self.doQuote(nbpages), self.doQuote(userpquota.ident))) 
    673673        
    674     def writeUserPQuotaPagesCounters(self, userpquota, newpagecounter, newlifepagecounter) :     
    675         """Sets the new page counters permanently for a user print quota.""" 
    676         self.doModify("UPDATE userpquota SET pagecounter=%s, lifepagecounter=%s, warncount=0, datelimit=NULL WHERE id=%s" % (self.doQuote(newpagecounter), self.doQuote(newlifepagecounter), self.doQuote(userpquota.ident))) 
    677         
    678674    def saveBillingCode(self, code) :     
    679675        """Saves the billing code to the database.""" 
     
    718714            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))) 
    719715             
    720     def writeUserPQuotaLimits(self, userpquota, softlimit, hardlimit) : 
    721         """Sets soft and hard limits for a user quota.""" 
    722         self.doModify("UPDATE userpquota SET softlimit=%s, hardlimit=%s, warncount=0, datelimit=NULL WHERE id=%s" % (self.doQuote(softlimit), self.doQuote(hardlimit), self.doQuote(userpquota.ident))) 
     716    def saveUserPQuota(self, userpquota) : 
     717        """Saves an user print quota entry.""" 
     718        self.doModify("UPDATE userpquota SET softlimit=%s, hardlimit=%s, warncount=%s, datelimit=%s, pagecounter=%s, lifepagecounter=%s WHERE id=%s" \ 
     719                              % (self.doQuote(userpquota.SoftLimit), \ 
     720                                 self.doQuote(userpquota.HardLimit), \ 
     721                                 self.doQuote(userpquota.WarnCount), \ 
     722                                 self.doQuote(userpquota.DateLimit), \ 
     723                                 self.doQuote(userpquota.PageCounter), \ 
     724                                 self.doQuote(userpquota.LifePageCounter), \ 
     725                                 self.doQuote(userpquota.ident))) 
    723726         
    724727    def writeUserPQuotaWarnCount(self, userpquota, warncount) : 
     
    730733        self.doModify("UPDATE userpquota SET warncount=warncount+1 WHERE id=%s" % self.doQuote(userpquota.ident)) 
    731734         
    732     def writeGroupPQuotaLimits(self, grouppquota, softlimit, hardlimit) : 
    733         """Sets soft and hard limits for a group quota on a specific printer.""" 
    734         self.doModify("UPDATE grouppquota SET softlimit=%s, hardlimit=%s, datelimit=NULL WHERE id=%s" % (self.doQuote(softlimit), self.doQuote(hardlimit), self.doQuote(grouppquota.ident))) 
     735    def saveGroupPQuota(self, grouppquota) : 
     736        """Saves a group print quota entry.""" 
     737        self.doModify("UPDATE grouppquota SET softlimit=%s, hardlimit=%s, datelimit=%s WHERE id=%s" \ 
     738                              % (self.doQuote(grouppquota.SoftLimit), \ 
     739                                 self.doQuote(grouppquota.HardLimit), \ 
     740                                 self.doQuote(grouppquota.DateLimit), \ 
     741                                 self.doQuote(grouppquota.ident))) 
    735742 
    736743    def writePrinterToGroup(self, pgroup, printer) :