Show
Ignore:
Timestamp:
01/18/08 23:39:41 (16 years ago)
Author:
jerome
Message:

Added modules to store utility functions and application
intialization code, which has nothing to do in classes.
Modified tool.py accordingly (far from being finished)
Use these new modules where necessary.
Now converts all command line arguments to unicode before
beginning to work. Added a proper logging method for already
encoded query strings.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • pykota/trunk/pykota/storages/ldapstorage.py

    r3291 r3294  
    4242                           StorageJob, StorageLastJob, StorageUserPQuota, \ 
    4343                           StorageGroupPQuota, StorageBillingCode 
     44                            
     45from pykota.utils import *                            
    4446 
    4547try : 
     
    160162                    result = [(base, entry)] 
    161163                else : 
    162                     self.tool.logdebug("QUERY : Filter : %s, BaseDN : %s, Scope : %s, Attributes : %s" % (key, base, scope, fields)) 
     164                    self.querydebug("QUERY : Filter : %s, BaseDN : %s, Scope : %s, Attributes : %s" % (key, base, scope, fields)) 
    163165                    result = self.database.search_s(base, scope, key, fields) 
    164166            except ldap.NO_SUCH_OBJECT, msg :         
     
    171173                self.secondStageInit() 
    172174            else :      
    173                 self.tool.logdebug("QUERY : Result : %s" % result) 
     175                self.querydebug("QUERY : Result : %s" % result) 
    174176                result = [ (dn, cidict(attrs)) for (dn, attrs) in result ] 
    175177                if self.useldapcache : 
    176178                    for (dn, attributes) in result : 
    177                         self.tool.logdebug("LDAP cache store %s => %s" % (dn, attributes)) 
     179                        self.querydebug("LDAP cache store %s => %s" % (dn, attributes)) 
    178180                        self.ldapcache[dn] = attributes 
    179181                return result 
     
    186188        for tryit in range(3) : 
    187189            try : 
    188                 self.tool.logdebug("QUERY : ADD(%s, %s)" % (dn, str(fields))) 
     190                self.querydebug("QUERY : ADD(%s, %s)" % (dn, fields)) 
    189191                entry = ldap.modlist.addModlist(fields) 
    190                 self.tool.logdebug("%s" % entry) 
     192                self.querydebug("%s" % entry) 
    191193                self.database.add_s(dn, entry) 
    192194            except ldap.ALREADY_EXISTS, msg :         
     
    200202            else : 
    201203                if self.useldapcache : 
    202                     self.tool.logdebug("LDAP cache add %s => %s" % (dn, fields)) 
     204                    self.querydebug("LDAP cache add %s => %s" % (dn, fields)) 
    203205                    self.ldapcache[dn] = fields 
    204206                return dn 
     
    210212        for tryit in range(3) : 
    211213            try : 
    212                 self.tool.logdebug("QUERY : Delete(%s)" % dn) 
     214                self.querydebug("QUERY : Delete(%s)" % dn) 
    213215                self.database.delete_s(dn) 
    214216            except ldap.NO_SUCH_OBJECT :     
     
    223225                if self.useldapcache : 
    224226                    try : 
    225                         self.tool.logdebug("LDAP cache del %s" % dn) 
     227                        self.querydebug("LDAP cache del %s" % dn) 
    226228                        del self.ldapcache[dn] 
    227229                    except KeyError :     
     
    239241                    if self.ldapcache.has_key(dn) : 
    240242                        old = self.ldapcache[dn] 
    241                         self.tool.logdebug("LDAP cache hit %s => %s" % (dn, old)) 
     243                        self.querydebug("LDAP cache hit %s => %s" % (dn, old)) 
    242244                        oldentry = {} 
    243245                        for (k, v) in old.items() : 
     
    245247                                oldentry[k] = v 
    246248                    else :     
    247                         self.tool.logdebug("LDAP cache miss %s" % dn) 
     249                        self.querydebug("LDAP cache miss %s" % dn) 
    248250                        oldentry = self.doSearch("objectClass=*", base=dn, scope=ldap.SCOPE_BASE)[0][1] 
    249251                else :         
     
    254256                            oldvalue = v["convert"](oldentry.get(k, [0])[0]) 
    255257                        except ValueError :     
    256                             self.tool.logdebug("Error converting %s with %s(%s)" % (oldentry.get(k), k, v)) 
     258                            self.querydebug("Error converting %s with %s(%s)" % (oldentry.get(k), k, v)) 
    257259                            oldvalue = 0 
    258260                        if v["operator"] == '+' : 
     
    262264                        fields[k] = str(newvalue) 
    263265                fields = self.normalizeFields(fields) 
    264                 self.tool.logdebug("QUERY : Modify(%s, %s ==> %s)" % (dn, oldentry, fields)) 
     266                self.querydebug("QUERY : Modify(%s, %s ==> %s)" % (dn, oldentry, fields)) 
    265267                entry = ldap.modlist.modifyModlist(oldentry, fields, ignore_oldexistent=ignoreold) 
    266268                modentry = [] 
     
    268270                    if mtyp and (mtyp.lower() != "createtimestamp") : 
    269271                        modentry.append((mop, mtyp, mval)) 
    270                 self.tool.logdebug("MODIFY : %s ==> %s ==> %s" % (fields, entry, modentry)) 
     272                self.querydebug("MODIFY : %s ==> %s ==> %s" % (fields, entry, modentry)) 
    271273                if modentry : 
    272274                    self.database.modify_s(dn, modentry) 
     
    288290                            except KeyError :     
    289291                                pass 
    290                     self.tool.logdebug("LDAP cache update %s => %s" % (dn, cachedentry)) 
     292                    self.querydebug("LDAP cache update %s => %s" % (dn, cachedentry)) 
    291293                return dn 
    292294        raise PyKotaStorageError, message 
     
    303305                self.tool.printInfo("Object %s has no %s attribute !" % (dn, attribute), "error") 
    304306            else : 
    305                 attrval = self.databaseToUnicode(attrval) 
     307                attrval = databaseToUnicode(attrval) 
    306308                if patterns : 
    307309                    if (not isinstance(patterns, type([]))) and (not isinstance(patterns, type(()))) : 
     
    318320        result = self.doSearch(ldapfilter, ["pykotaBillingCode"], base=self.info["billingcodebase"]) 
    319321        if result : 
    320             return [self.databaseToUnicode(bc) for bc in self.filterNames(result, "pykotaBillingCode", billingcode)] 
     322            return [databaseToUnicode(bc) for bc in self.filterNames(result, "pykotaBillingCode", billingcode)] 
    321323        else :     
    322324            return [] 
     
    351353    def getUserNbJobsFromHistory(self, user) : 
    352354        """Returns the number of jobs the user has in history.""" 
    353         result = self.doSearch("(&(pykotaUserName=%s)(objectClass=pykotaJob))" % self.unicodeToDatabase(user.Name), None, base=self.info["jobbase"]) 
     355        result = self.doSearch("(&(pykotaUserName=%s)(objectClass=pykotaJob))" % unicodeToDatabase(user.Name), None, base=self.info["jobbase"]) 
    354356        return len(result) 
    355357         
     
    357359        """Extracts user information given its name.""" 
    358360        user = StorageUser(self, username) 
    359         username = self.unicodeToDatabase(username) 
     361        username = unicodeToDatabase(username) 
    360362        result = self.doSearch("(&(objectClass=pykotaAccount)(|(pykotaUserName=%s)(%s=%s)))" % (username, self.info["userrdn"], username), ["pykotaUserName", "pykotaLimitBy", self.info["usermail"], "description"], base=self.info["userbase"]) 
    361363        if result : 
    362364            fields = result[0][1] 
    363365            user.ident = result[0][0] 
    364             user.Description = self.databaseToUnicode(fields.get("description", [None])[0]) 
     366            user.Description = databaseToUnicode(fields.get("description", [None])[0]) 
    365367            user.Email = fields.get(self.info["usermail"], [None])[0] 
    366368            user.LimitBy = fields.get("pykotaLimitBy", ["quota"])[0] 
     
    395397                        description = "" 
    396398                    else :     
    397                         description = self.databaseToUnicode(base64.decodestring(description)) 
     399                        description = databaseToUnicode(base64.decodestring(description)) 
    398400                    if amount.endswith(" #") :     
    399401                        amount = amount[:-2] # TODO : should be catched earlier, the bug is above I think 
     
    405407        """Extracts group information given its name.""" 
    406408        group = StorageGroup(self, groupname) 
    407         groupname = self.unicodeToDatabase(groupname) 
     409        groupname = unicodeToDatabase(groupname) 
    408410        result = self.doSearch("(&(objectClass=pykotaGroup)(|(pykotaGroupName=%s)(%s=%s)))" % (groupname, self.info["grouprdn"], groupname), ["pykotaGroupName", "pykotaLimitBy", "description"], base=self.info["groupbase"]) 
    409411        if result : 
    410412            fields = result[0][1] 
    411413            group.ident = result[0][0] 
    412             group.Name = fields.get("pykotaGroupName", [self.databaseToUnicode(groupname)])[0]  
    413             group.Description = self.databaseToUnicode(fields.get("description", [None])[0]) 
     414            group.Name = fields.get("pykotaGroupName", [databaseToUnicode(groupname)])[0]  
     415            group.Description = databaseToUnicode(fields.get("description", [None])[0]) 
    414416            group.LimitBy = fields.get("pykotaLimitBy", ["quota"])[0] 
    415417            group.AccountBalance = 0.0 
     
    425427        """Extracts printer information given its name : returns first matching printer.""" 
    426428        printer = StoragePrinter(self, printername) 
    427         printername = self.unicodeToDatabase(printername) 
     429        printername = unicodeToDatabase(printername) 
    428430        result = self.doSearch("(&(objectClass=pykotaPrinter)(|(pykotaPrinterName=%s)(%s=%s)))" \ 
    429431                      % (printername, self.info["printerrdn"], printername), \ 
     
    435437            fields = result[0][1]       # take only first matching printer, ignore the rest 
    436438            printer.ident = result[0][0] 
    437             printer.Name = fields.get("pykotaPrinterName", [self.databaseToUnicode(printername)])[0]  
     439            printer.Name = fields.get("pykotaPrinterName", [databaseToUnicode(printername)])[0]  
    438440            printer.PricePerJob = float(fields.get("pykotaPricePerJob", [0.0])[0]) 
    439441            printer.PricePerPage = float(fields.get("pykotaPricePerPage", [0.0])[0]) 
     
    445447                printer.PassThrough = 0 
    446448            printer.uniqueMember = fields.get("uniqueMember", []) 
    447             printer.Description = self.databaseToUnicode(fields.get("description", [""])[0])  
     449            printer.Description = databaseToUnicode(fields.get("description", [""])[0])  
    448450            printer.Exists = True 
    449451        return printer     
     
    458460                base = self.info["userquotabase"] 
    459461            result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaUserName=%s)(pykotaPrinterName=%s))" % \ 
    460                                       (self.unicodeToDatabase(user.Name), self.unicodeToDatabase(printer.Name)), \ 
     462                                      (unicodeToDatabase(user.Name), unicodeToDatabase(printer.Name)), \ 
    461463                                      ["pykotaPageCounter", "pykotaLifePageCounter", "pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaWarnCount", "pykotaMaxJobSize"], \ 
    462464                                      base=base) 
     
    503505                base = self.info["groupquotabase"] 
    504506            result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaGroupName=%s)(pykotaPrinterName=%s))" % \ 
    505                                       (self.unicodeToDatabase(group.Name), self.unicodeToDatabase(printer.Name)), \ 
     507                                      (unicodeToDatabase(group.Name), unicodeToDatabase(printer.Name)), \ 
    506508                                      ["pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaMaxJobSize"], \ 
    507509                                      base=base) 
     
    535537                grouppquota.PageCounter = 0 
    536538                grouppquota.LifePageCounter = 0 
    537                 usernamesfilter = "".join(["(pykotaUserName=%s)" % self.unicodeToDatabase(member.Name) for member in self.getGroupMembers(group)]) 
     539                usernamesfilter = "".join(["(pykotaUserName=%s)" % unicodeToDatabase(member.Name) for member in self.getGroupMembers(group)]) 
    538540                if usernamesfilter : 
    539541                    usernamesfilter = "(|%s)" % usernamesfilter 
     
    543545                    base = self.info["userquotabase"] 
    544546                result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaPrinterName=%s)%s)" % \ 
    545                                           (self.unicodeToDatabase(printer.Name), usernamesfilter), \ 
     547                                          (unicodeToDatabase(printer.Name), usernamesfilter), \ 
    546548                                          ["pykotaPageCounter", "pykotaLifePageCounter"], base=base) 
    547549                if result : 
     
    555557        """Extracts a printer's last job information.""" 
    556558        lastjob = StorageLastJob(self, printer) 
    557         pname = self.unicodeToDatabase(printer.Name) 
     559        pname = unicodeToDatabase(printer.Name) 
    558560        result = self.doSearch("(&(objectClass=pykotaLastjob)(|(pykotaPrinterName=%s)(%s=%s)))" % \ 
    559561                                  (pname, self.info["printerrdn"], pname), \ 
     
    591593                lastjob.ident = result[0][0] 
    592594                lastjob.JobId = fields.get("pykotaJobId")[0] 
    593                 lastjob.UserName = self.databaseToUnicode(fields.get("pykotaUserName")[0]) 
     595                lastjob.UserName = databaseToUnicode(fields.get("pykotaUserName")[0]) 
    594596                lastjob.PrinterPageCounter = int(fields.get("pykotaPrinterPageCounter", [0])[0]) 
    595597                try : 
     
    602604                    lastjob.JobPrice = None 
    603605                lastjob.JobAction = fields.get("pykotaAction", [""])[0] 
    604                 lastjob.JobFileName = self.databaseToUnicode(fields.get("pykotaFileName", [""])[0])  
    605                 lastjob.JobTitle = self.databaseToUnicode(fields.get("pykotaTitle", [""])[0])  
     606                lastjob.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0])  
     607                lastjob.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0])  
    606608                lastjob.JobCopies = int(fields.get("pykotaCopies", [0])[0]) 
    607                 lastjob.JobOptions = self.databaseToUnicode(fields.get("pykotaOptions", [""])[0])  
     609                lastjob.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0])  
    608610                lastjob.JobHostName = fields.get("pykotaHostName", [""])[0] 
    609611                lastjob.JobSizeBytes = fields.get("pykotaJobSizeBytes", [0L])[0] 
    610                 lastjob.JobBillingCode = self.databaseToUnicode(fields.get("pykotaBillingCode", [None])[0]) 
     612                lastjob.JobBillingCode = databaseToUnicode(fields.get("pykotaBillingCode", [None])[0]) 
    611613                lastjob.JobMD5Sum = fields.get("pykotaMD5Sum", [None])[0] 
    612614                lastjob.JobPages = fields.get("pykotaPages", [""])[0] 
     
    630632        """Returns the group's members list.""" 
    631633        groupmembers = [] 
    632         gname = self.unicodeToDatabase(group.Name) 
     634        gname = unicodeToDatabase(group.Name) 
    633635        result = self.doSearch("(&(objectClass=pykotaGroup)(|(pykotaGroupName=%s)(%s=%s)))" % \ 
    634636                                  (gname, self.info["grouprdn"], gname), \ 
     
    637639        if result : 
    638640            for username in result[0][1].get(self.info["groupmembers"], []) : 
    639                 groupmembers.append(self.getUser(self.databaseToUnicode(username))) 
     641                groupmembers.append(self.getUser(databaseToUnicode(username))) 
    640642        return groupmembers         
    641643         
     
    643645        """Returns the user's groups list.""" 
    644646        groups = [] 
    645         uname = self.unicodeToDatabase(user.Name) 
     647        uname = unicodeToDatabase(user.Name) 
    646648        result = self.doSearch("(&(objectClass=pykotaGroup)(%s=%s))" % \ 
    647649                                  (self.info["groupmembers"], uname), \ 
     
    650652        if result : 
    651653            for (groupid, fields) in result : 
    652                 groupname = self.databaseToUnicode((fields.get("pykotaGroupName", [None]) or fields.get(self.info["grouprdn"], [None]))[0]) 
     654                groupname = databaseToUnicode((fields.get("pykotaGroupName", [None]) or fields.get(self.info["grouprdn"], [None]))[0]) 
    653655                group = self.getFromCache("GROUPS", groupname) 
    654656                if group is None : 
     
    681683            for (printerid, fields) in result : 
    682684                if printerid != printer.ident : # In case of integrity violation. 
    683                     parentprinter = self.getPrinter(self.databaseToUnicode(fields.get("pykotaPrinterName")[0])) 
     685                    parentprinter = self.getPrinter(databaseToUnicode(fields.get("pykotaPrinterName")[0])) 
    684686                    if parentprinter.Exists : 
    685687                        pgroups.append(parentprinter) 
     
    703705                    patdict[p] = None 
    704706            for (printerid, fields) in result : 
    705                 printername = self.databaseToUnicode(fields.get("pykotaPrinterName", [""])[0] or fields.get(self.info["printerrdn"], [""])[0]) 
     707                printername = databaseToUnicode(fields.get("pykotaPrinterName", [""])[0] or fields.get(self.info["printerrdn"], [""])[0]) 
    706708                if patdict.has_key(printername) or self.tool.matchString(printername, patterns) : 
    707709                    printer = StoragePrinter(self, printername) 
     
    716718                        printer.PassThrough = 0 
    717719                    printer.uniqueMember = fields.get("uniqueMember", []) 
    718                     printer.Description = self.databaseToUnicode(fields.get("description", [""])[0])  
     720                    printer.Description = databaseToUnicode(fields.get("description", [""])[0])  
    719721                    printer.Exists = True 
    720722                    printers.append(printer) 
     
    739741                    patdict[p] = None 
    740742            for (userid, fields) in result : 
    741                 username = self.databaseToUnicode(fields.get("pykotaUserName", [""])[0] or fields.get(self.info["userrdn"], [""])[0]) 
     743                username = databaseToUnicode(fields.get("pykotaUserName", [""])[0] or fields.get(self.info["userrdn"], [""])[0]) 
    742744                if patdict.has_key(username) or self.tool.matchString(username, patterns) : 
    743745                    user = StorageUser(self, username) 
     
    745747                    user.Email = fields.get(self.info["usermail"], [None])[0] 
    746748                    user.LimitBy = fields.get("pykotaLimitBy", ["quota"])[0] 
    747                     user.Description = self.databaseToUnicode(fields.get("description", [""])[0])  
    748                     uname = self.unicodeToDatabase(username) 
     749                    user.Description = databaseToUnicode(fields.get("description", [""])[0])  
     750                    uname = unicodeToDatabase(username) 
    749751                    result = self.doSearch("(&(objectClass=pykotaAccountBalance)(|(pykotaUserName=%s)(%s=%s)))" % \ 
    750752                                              (uname, self.info["balancerdn"], uname), \ 
     
    780782                                description = "" 
    781783                            else :     
    782                                 description = self.databaseToUnicode(base64.decodestring(description)) 
     784                                description = databaseToUnicode(base64.decodestring(description)) 
    783785                            if amount.endswith(" #") :     
    784786                                amount = amount[:-2] # TODO : should be catched earlier, the bug is above I think 
     
    806808                    patdict[p] = None 
    807809            for (groupid, fields) in result : 
    808                 groupname = self.databaseToUnicode(fields.get("pykotaGroupName", [""])[0] or fields.get(self.info["grouprdn"], [""])[0]) 
     810                groupname = databaseToUnicode(fields.get("pykotaGroupName", [""])[0] or fields.get(self.info["grouprdn"], [""])[0]) 
    809811                if patdict.has_key(groupname) or self.tool.matchString(groupname, patterns) : 
    810812                    group = StorageGroup(self, groupname) 
    811813                    group.ident = groupid 
    812                     group.Name = fields.get("pykotaGroupName", [self.databaseToUnicode(groupname)])[0]  
     814                    group.Name = fields.get("pykotaGroupName", [databaseToUnicode(groupname)])[0]  
    813815                    group.LimitBy = fields.get("pykotaLimitBy", ["quota"])[0] 
    814                     group.Description = self.databaseToUnicode(fields.get("description", [""])[0])  
     816                    group.Description = databaseToUnicode(fields.get("description", [""])[0])  
    815817                    group.AccountBalance = 0.0 
    816818                    group.LifeTimePaid = 0.0 
     
    827829        """Returns the list of users who uses a given printer, along with their quotas.""" 
    828830        usersandquotas = [] 
    829         pname = self.unicodeToDatabase(printer.Name) 
    830         names = [self.unicodeToDatabase(n) for n in names] 
     831        pname = unicodeToDatabase(printer.Name) 
     832        names = [unicodeToDatabase(n) for n in names] 
    831833        if self.info["userquotabase"].lower() == "user" : 
    832834            base = self.info["userbase"] 
     
    839841        if result : 
    840842            for (userquotaid, fields) in result : 
    841                 user = self.getUser(self.databaseToUnicode(fields.get("pykotaUserName")[0])) 
     843                user = self.getUser(databaseToUnicode(fields.get("pykotaUserName")[0])) 
    842844                userpquota = StorageUserPQuota(self, user, printer) 
    843845                userpquota.ident = userquotaid 
     
    872874        """Returns the list of groups which uses a given printer, along with their quotas.""" 
    873875        groupsandquotas = [] 
    874         pname = self.unicodeToDatabase(printer.Name) 
    875         names = [self.unicodeToDatabase(n) for n in names] 
     876        pname = unicodeToDatabase(printer.Name) 
     877        names = [unicodeToDatabase(n) for n in names] 
    876878        if self.info["groupquotabase"].lower() == "group" : 
    877879            base = self.info["groupbase"] 
     
    884886        if result : 
    885887            for (groupquotaid, fields) in result : 
    886                 group = self.getGroup(self.databaseToUnicode(fields.get("pykotaGroupName")[0])) 
     888                group = self.getGroup(databaseToUnicode(fields.get("pykotaGroupName")[0])) 
    887889                grouppquota = self.getGroupPQuota(group, printer) 
    888890                groupsandquotas.append((group, grouppquota)) 
     
    895897        if oldentry.Exists : 
    896898            return oldentry # we return the existing entry 
    897         printername = self.unicodeToDatabase(printer.Name) 
     899        printername = unicodeToDatabase(printer.Name) 
    898900        fields = { self.info["printerrdn"] : printername, 
    899901                   "objectClass" : ["pykotaObject", "pykotaPrinter"], 
     
    902904                   "pykotaPassThrough" : (printer.PassThrough and "t") or "f", 
    903905                   "pykotaMaxJobSize" : str(printer.MaxJobSize or 0), 
    904                    "description" : self.unicodeToDatabase(printer.Description or ""), 
     906                   "description" : unicodeToDatabase(printer.Description or ""), 
    905907                   "pykotaPricePerPage" : str(printer.PricePerPage or 0.0), 
    906908                   "pykotaPricePerJob" : str(printer.PricePerJob or 0.0), 
     
    916918        if oldentry.Exists : 
    917919            return oldentry # we return the existing entry 
    918         uname = self.unicodeToDatabase(user.Name) 
     920        uname = unicodeToDatabase(user.Name) 
    919921        newfields = { 
    920922                       "pykotaUserName" : uname, 
    921923                       "pykotaLimitBy" : (user.LimitBy or "quota"), 
    922                        "description" : self.unicodeToDatabase(user.Description or ""), 
     924                       "description" : unicodeToDatabase(user.Description or ""), 
    923925                       self.info["usermail"] : user.Email or "", 
    924926                    }    
     
    991993        if oldentry.Exists : 
    992994            return oldentry # we return the existing entry 
    993         gname = self.unicodeToDatabase(group.Name) 
     995        gname = unicodeToDatabase(group.Name) 
    994996        newfields = {  
    995997                      "pykotaGroupName" : gname, 
    996998                      "pykotaLimitBy" : (group.LimitBy or "quota"), 
    997                       "description" : self.unicodeToDatabase(group.Description or "") 
     999                      "description" : unicodeToDatabase(group.Description or "") 
    9981000                    }  
    9991001        mustadd = 1 
     
    10401042                if not fields.has_key(self.info["groupmembers"]) : 
    10411043                    fields[self.info["groupmembers"]] = [] 
    1042                 fields[self.info["groupmembers"]].append(self.unicodeToDatabase(user.Name)) 
     1044                fields[self.info["groupmembers"]].append(unicodeToDatabase(user.Name)) 
    10431045                self.doModify(group.ident, fields) 
    10441046                group.Members.append(user) 
     
    10531055                    fields[self.info["groupmembers"]] = [] 
    10541056                try :     
    1055                     fields[self.info["groupmembers"]].remove(self.unicodeToDatabase(user.Name)) 
     1057                    fields[self.info["groupmembers"]].remove(unicodeToDatabase(user.Name)) 
    10561058                except ValueError : 
    10571059                    pass # TODO : Strange, shouldn't it be there ? 
     
    10671069            return oldentry # we return the existing entry 
    10681070        uuid = self.genUUID() 
    1069         uname = self.unicodeToDatabase(upq.User.Name) 
    1070         pname = self.unicodeToDatabase(upq.Printer.Name) 
     1071        uname = unicodeToDatabase(upq.User.Name) 
     1072        pname = unicodeToDatabase(upq.Printer.Name) 
    10711073        fields = { "cn" : uuid, 
    10721074                   "objectClass" : ["pykotaObject", "pykotaUserPQuota"], 
     
    10951097            return oldentry # we return the existing entry 
    10961098        uuid = self.genUUID() 
    1097         gname = self.unicodeToDatabase(gpq.Group.Name) 
    1098         pname = self.unicodeToDatabase(gpq.Printer.Name) 
     1099        gname = unicodeToDatabase(gpq.Group.Name) 
     1100        pname = unicodeToDatabase(gpq.Printer.Name) 
    10991101        fields = { "cn" : uuid, 
    11001102                   "objectClass" : ["pykotaObject", "pykotaGroupPQuota"], 
     
    11161118                   "pykotaPassThrough" : (printer.PassThrough and "t") or "f", 
    11171119                   "pykotaMaxJobSize" : str(printer.MaxJobSize or 0), 
    1118                    "description" : self.unicodeToDatabase(printer.Description or ""), 
     1120                   "description" : unicodeToDatabase(printer.Description or ""), 
    11191121                   "pykotaPricePerPage" : str(printer.PricePerPage or 0.0), 
    11201122                   "pykotaPricePerJob" : str(printer.PricePerJob or 0.0), 
     
    11261128        newfields = { 
    11271129                       "pykotaLimitBy" : (user.LimitBy or "quota"), 
    1128                        "description" : self.unicodeToDatabase(user.Description or ""),  
     1130                       "description" : unicodeToDatabase(user.Description or ""),  
    11291131                       self.info["usermail"] : user.Email or "", 
    11301132                    }    
     
    11411143        newfields = { 
    11421144                       "pykotaLimitBy" : (group.LimitBy or "quota"), 
    1143                        "description" : self.unicodeToDatabase(group.Description or ""),  
     1145                       "description" : unicodeToDatabase(group.Description or ""),  
    11441146                    }    
    11451147        self.doModify(group.ident, newfields) 
     
    11781180        payments = [] 
    11791181        for payment in user.Payments : 
    1180             payments.append("%s # %s # %s" % (payment[0], str(payment[1]), base64.encodestring(self.unicodeToDatabase(payment[2])).strip())) 
    1181         payments.append("%s # %s # %s" % (str(DateTime.now()), str(amount), base64.encodestring(self.unicodeToDatabase(comment)).strip())) 
     1182            payments.append("%s # %s # %s" % (payment[0], str(payment[1]), base64.encodestring(unicodeToDatabase(payment[2])).strip())) 
     1183        payments.append("%s # %s # %s" % (str(DateTime.now()), str(amount), base64.encodestring(unicodeToDatabase(comment)).strip())) 
    11821184        fields = { 
    11831185                   "pykotaPayments" : payments, 
     
    11951197    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) : 
    11961198        """Adds a job in a printer's history.""" 
    1197         uname = self.unicodeToDatabase(user.Name) 
    1198         pname = self.unicodeToDatabase(printer.Name) 
     1199        uname = unicodeToDatabase(user.Name) 
     1200        pname = unicodeToDatabase(printer.Name) 
    11991201        if (not self.disablehistory) or (not printer.LastJob.Exists) : 
    12001202            uuid = self.genUUID() 
     
    12141216                   "pykotaPrinterPageCounter" : str(pagecounter), 
    12151217                   "pykotaAction" : action, 
    1216                    "pykotaFileName" : ((filename is None) and "None") or self.unicodeToDatabase(filename),  
    1217                    "pykotaTitle" : ((title is None) and "None") or self.unicodeToDatabase(title),  
     1218                   "pykotaFileName" : ((filename is None) and "None") or unicodeToDatabase(filename),  
     1219                   "pykotaTitle" : ((title is None) and "None") or unicodeToDatabase(title),  
    12181220                   "pykotaCopies" : str(copies),  
    1219                    "pykotaOptions" : ((options is None) and "None") or self.unicodeToDatabase(options),  
     1221                   "pykotaOptions" : ((options is None) and "None") or unicodeToDatabase(options),  
    12201222                   "pykotaHostName" : str(clienthost),  
    12211223                   "pykotaJobSizeBytes" : str(jobsizebytes), 
    12221224                   "pykotaMD5Sum" : str(jobmd5sum), 
    12231225                   "pykotaPages" : jobpages,            # don't add this attribute if it is not set, so no string conversion 
    1224                    "pykotaBillingCode" : self.unicodeToDatabase(jobbilling), # don't add this attribute if it is not set, so no string conversion 
     1226                   "pykotaBillingCode" : unicodeToDatabase(jobbilling), # don't add this attribute if it is not set, so no string conversion 
    12251227                   "pykotaPrecomputedJobSize" : str(precomputedsize), 
    12261228                   "pykotaPrecomputedJobPrice" : str(precomputedprice), 
     
    13141316        where = [] 
    13151317        if user is not None : 
    1316             where.append("(pykotaUserName=%s)" % self.unicodeToDatabase(user.Name)) 
     1318            where.append("(pykotaUserName=%s)" % unicodeToDatabase(user.Name)) 
    13171319        if printer is not None : 
    1318             where.append("(pykotaPrinterName=%s)" % self.unicodeToDatabase(printer.Name)) 
     1320            where.append("(pykotaPrinterName=%s)" % unicodeToDatabase(printer.Name)) 
    13191321        if hostname is not None : 
    13201322            where.append("(pykotaHostName=%s)" % hostname) 
    13211323        if billingcode is not None : 
    1322             where.append("(pykotaBillingCode=%s)" % self.unicodeToDatabase(billingcode)) 
     1324            where.append("(pykotaBillingCode=%s)" % unicodeToDatabase(billingcode)) 
    13231325        if jobid is not None : 
    1324             where.append("(pykotaJobId=%s)" % jobid) # TODO : jobid is text, so self.unicodeToDatabase(jobid) but do all of them as well. 
     1326            where.append("(pykotaJobId=%s)" % jobid) # TODO : jobid is text, so unicodeToDatabase(jobid) but do all of them as well. 
    13251327        if where :     
    13261328            where = "(&%s)" % "".join([precond] + where) 
     
    13631365                    job.JobPrice = None 
    13641366                job.JobAction = fields.get("pykotaAction", [""])[0] 
    1365                 job.JobFileName = self.databaseToUnicode(fields.get("pykotaFileName", [""])[0])  
    1366                 job.JobTitle = self.databaseToUnicode(fields.get("pykotaTitle", [""])[0])  
     1367                job.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0])  
     1368                job.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0])  
    13671369                job.JobCopies = int(fields.get("pykotaCopies", [0])[0]) 
    1368                 job.JobOptions = self.databaseToUnicode(fields.get("pykotaOptions", [""])[0])  
     1370                job.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0])  
    13691371                job.JobHostName = fields.get("pykotaHostName", [""])[0] 
    13701372                job.JobSizeBytes = fields.get("pykotaJobSizeBytes", [0L])[0] 
    1371                 job.JobBillingCode = self.databaseToUnicode(fields.get("pykotaBillingCode", [None])[0]) 
     1373                job.JobBillingCode = databaseToUnicode(fields.get("pykotaBillingCode", [None])[0]) 
    13721374                job.JobMD5Sum = fields.get("pykotaMD5Sum", [None])[0] 
    13731375                job.JobPages = fields.get("pykotaPages", [""])[0] 
     
    13891391                   ((end is None) and (job.JobDate >= start)) or \ 
    13901392                   ((job.JobDate >= start) and (job.JobDate <= end)) : 
    1391                     job.UserName = self.databaseToUnicode(fields.get("pykotaUserName")[0]) 
    1392                     job.PrinterName = self.databaseToUnicode(fields.get("pykotaPrinterName")[0]) 
     1393                    job.UserName = databaseToUnicode(fields.get("pykotaUserName")[0]) 
     1394                    job.PrinterName = databaseToUnicode(fields.get("pykotaPrinterName")[0]) 
    13931395                    job.Exists = True 
    13941396                    jobs.append(job) 
     
    14001402    def deleteUser(self, user) :     
    14011403        """Completely deletes an user from the Quota Storage.""" 
    1402         uname = self.unicodeToDatabase(user.Name) 
     1404        uname = unicodeToDatabase(user.Name) 
    14031405        todelete = []     
    14041406        result = self.doSearch("(&(objectClass=pykotaJob)(pykotaUserName=%s))" % uname, base=self.info["jobbase"]) 
     
    14181420            # if last job of current printer was printed by the user 
    14191421            # to delete, we also need to delete the printer's last job entry. 
    1420             printer = self.getPrinter(self.databaseToUnicode(fields["pykotaPrinterName"][0])) 
     1422            printer = self.getPrinter(databaseToUnicode(fields["pykotaPrinterName"][0])) 
    14211423            if printer.LastJob.UserName == user.Name : 
    14221424                todelete.append(printer.LastJob.lastjobident) 
     
    14531455    def deleteGroup(self, group) :     
    14541456        """Completely deletes a group from the Quota Storage.""" 
    1455         gname = self.unicodeToDatabase(group.Name) 
     1457        gname = unicodeToDatabase(group.Name) 
    14561458        if self.info["groupquotabase"].lower() == "group" : 
    14571459            base = self.info["groupbase"] 
     
    15241526    def deleteUserPQuota(self, upquota) :     
    15251527        """Completely deletes an user print quota entry from the database.""" 
    1526         uname = self.unicodeToDatabase(upquota.User.Name) 
    1527         pname = self.unicodeToDatabase(upquota.Printer.Name) 
     1528        uname = unicodeToDatabase(upquota.User.Name) 
     1529        pname = unicodeToDatabase(upquota.Printer.Name) 
    15281530        result = self.doSearch("(&(objectClass=pykotaJob)(pykotaUserName=%s)(pykotaPrinterName=%s))" \ 
    15291531                                   % (uname, pname), \ 
     
    15411543    def deletePrinter(self, printer) :     
    15421544        """Completely deletes a printer from the Quota Storage.""" 
    1543         pname = self.unicodeToDatabase(printer.Name) 
     1545        pname = unicodeToDatabase(printer.Name) 
    15441546        result = self.doSearch("(&(objectClass=pykotaLastJob)(pykotaPrinterName=%s))" % pname, base=self.info["lastjobbase"]) 
    15451547        for (ident, fields) in result : 
     
    17641766        """Extracts billing code information given its label : returns first matching billing code.""" 
    17651767        code = StorageBillingCode(self, label) 
    1766         ulabel = self.unicodeToDatabase(label) 
     1768        ulabel = unicodeToDatabase(label) 
    17671769        result = self.doSearch("(&(objectClass=pykotaBilling)(pykotaBillingCode=%s))" % \ 
    17681770                                  ulabel, \ 
     
    17721774            fields = result[0][1]       # take only first matching code, ignore the rest 
    17731775            code.ident = result[0][0] 
    1774             code.BillingCode = self.databaseToUnicode(fields.get("pykotaBillingCode", [ulabel])[0]) 
     1776            code.BillingCode = databaseToUnicode(fields.get("pykotaBillingCode", [ulabel])[0]) 
    17751777            code.PageCounter = int(fields.get("pykotaPageCounter", [0])[0]) 
    17761778            code.Balance = float(fields.get("pykotaBalance", [0.0])[0]) 
    1777             code.Description = self.databaseToUnicode(fields.get("description", [""])[0])  
     1779            code.Description = databaseToUnicode(fields.get("description", [""])[0])  
    17781780            code.Exists = True 
    17791781        return code     
     
    17881790        fields = { "objectClass" : ["pykotaObject", "pykotaBilling"], 
    17891791                   "cn" : uuid, 
    1790                    "pykotaBillingCode" : self.unicodeToDatabase(bcode.BillingCode), 
     1792                   "pykotaBillingCode" : unicodeToDatabase(bcode.BillingCode), 
    17911793                   "pykotaPageCounter" : str(bcode.PageCounter or 0), 
    17921794                   "pykotaBalance" : str(bcode.Balance or 0.0), 
    1793                    "description" : self.unicodeToDatabase(bcode.Description or ""),  
     1795                   "description" : unicodeToDatabase(bcode.Description or ""),  
    17941796                 }  
    17951797        self.doAdd(dn, fields) 
     
    18001802        """Sets the new description for a billing code.""" 
    18011803        fields = { 
    1802                    "description" : self.unicodeToDatabase(bcode.Description or ""),  
     1804                   "description" : unicodeToDatabase(bcode.Description or ""),  
    18031805                   "pykotaPageCounter" : str(bcode.PageCounter or 0), 
    18041806                   "pykotaBalance" : str(bcode.Balance or 0.0), 
     
    18221824                    patdict[p] = None 
    18231825            for (codeid, fields) in result : 
    1824                 codename = self.databaseToUnicode(fields.get("pykotaBillingCode", [""])[0]) 
     1826                codename = databaseToUnicode(fields.get("pykotaBillingCode", [""])[0]) 
    18251827                if patdict.has_key(codename) or self.tool.matchString(codename, patterns) : 
    18261828                    code = StorageBillingCode(self, codename) 
     
    18281830                    code.PageCounter = int(fields.get("pykotaPageCounter", [0])[0]) 
    18291831                    code.Balance = float(fields.get("pykotaBalance", [0.0])[0]) 
    1830                     code.Description = self.databaseToUnicode(fields.get("description", [""])[0])  
     1832                    code.Description = databaseToUnicode(fields.get("description", [""])[0])  
    18311833                    code.Exists = True 
    18321834                    codes.append(code)