Context Navigation

ldapstorage.py @ 3419

Revision 3419, 98.5 kB (checked in by jerome, 16 years ago)
Improved debug output.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`

Line
1	# -- coding: utf-8 --*-
2	#
3	# PyKota : Print Quotas for CUPS
4	#
5	# (c) 2003, 2004, 2005, 2006, 2007, 2008 Jerome Alet <alet@librelogiciel.com>
6	# This program is free software: you can redistribute it and/or modify
7	# it under the terms of the GNU General Public License as published by
8	# the Free Software Foundation, either version 3 of the License, or
9	# (at your option) any later version.
10	#
11	# This program is distributed in the hope that it will be useful,
12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	# GNU General Public License for more details.
15	#
16	# You should have received a copy of the GNU General Public License
17	# along with this program. If not, see <http://www.gnu.org/licenses/>.
18	#
19	# $Id$
20	#
21	#
22
23	"""This module defines a class to access to an LDAP database backend.
24
25	My IANA assigned number, for
26	"Conseil Internet & Logiciels Libres, Jerome Alet"
27	is 16868. Use this as a base to extend the LDAP schema.
28	"""
29
30	import sys
31	import types
32	import time
33	import md5
34	import base64
35	import random
36
37	from mx import DateTime
38
39	from pykota.errors import PyKotaStorageError
40	from pykota.storage import BaseStorage, \
41	StorageUser, StorageGroup, StoragePrinter, \
42	StorageJob, StorageLastJob, StorageUserPQuota, \
43	StorageGroupPQuota, StorageBillingCode
44
45	from pykota.utils import *
46
47	try :
48	import ldap
49	import ldap.modlist
50	except ImportError :
51	raise PyKotaStorageError, "This python version (%s) doesn't seem to have the python-ldap module installed correctly." % sys.version.split()[0]
52	else :
53	try :
54	from ldap.cidict import cidict
55	except ImportError :
56	import UserDict
57	sys.stderr.write("ERROR: PyKota requires a newer version of python-ldap. Workaround activated. Please upgrade python-ldap !\n")
58	class cidict(UserDict.UserDict) :
59	pass # Fake it all, and don't care for case insensitivity : users who need it will have to upgrade.
60
61	class Storage(BaseStorage) :
62	def __init__(self, pykotatool, host, dbname, user, passwd) :
63	"""Opens the LDAP connection."""
64	self.savedtool = pykotatool
65	self.savedhost = host
66	self.saveddbname = dbname
67	self.saveduser = user
68	self.savedpasswd = passwd
69	self.secondStageInit()
70
71	def secondStageInit(self) :
72	"""Second stage initialisation."""
73	BaseStorage.__init__(self, self.savedtool)
74	self.info = self.tool.config.getLDAPInfo()
75	message = ""
76	for tryit in range(3) :
77	try :
78	self.tool.logdebug("Trying to open database (host=%s, dbname=%s, user=%s)..." \
79	% (repr(self.savedhost),
80	repr(self.saveddbname),
81	repr(self.saveduser)))
82	self.database = ldap.initialize(self.savedhost)
83	if self.info["ldaptls"] :
84	# we want TLS
85	ldap.set_option(ldap.OPT_X_TLS_CACERTFILE, self.info["cacert"])
86	self.database.set_option(ldap.OPT_X_TLS, ldap.OPT_X_TLS_DEMAND)
87	self.database.start_tls_s()
88	self.database.simple_bind_s(self.saveduser, self.savedpasswd)
89	self.basedn = self.saveddbname
90	except ldap.SERVER_DOWN :
91	message = "LDAP backend for PyKota seems to be down !"
92	self.tool.printInfo("%s" % message, "error")
93	self.tool.printInfo("Trying again in 2 seconds...", "warn")
94	time.sleep(2)
95	except ldap.LDAPError :
96	message = "Unable to connect to LDAP server %s as %s." \
97	% (repr(self.savedhost), repr(self.saveduser))
98	self.tool.printInfo("%s" % message, "error")
99	self.tool.printInfo("Trying again in 2 seconds...", "warn")
100	time.sleep(2)
101	else :
102	self.useldapcache = self.tool.config.getLDAPCache()
103	if self.useldapcache :
104	self.tool.logdebug("Low-Level LDAP Caching enabled.")
105	self.ldapcache = {} # low-level cache specific to LDAP backend
106	self.closed = False
107	self.tool.logdebug("Database opened (host=%s, dbname=%s, user=%s)" \
108	% (repr(self.savedhost),
109	repr(self.saveddbname),
110	repr(self.saveduser)))
111	return # All is fine here.
112	raise PyKotaStorageError, message
113
114	def close(self) :
115	"""Closes the database connection."""
116	if not self.closed :
117	self.database.unbind_s()
118	self.closed = True
119	self.tool.logdebug("Database closed.")
120
121	def genUUID(self) :
122	"""Generates an unique identifier.
123
124	TODO : this one is not unique accross several print servers, but should be sufficient for testing.
125	"""
126	return md5.md5("%s-%s" % (time.time(), random.random())).hexdigest()
127
128	def normalizeFields(self, fields) :
129	"""Ensure all items are lists."""
130	for (k, v) in fields.items() :
131	if type(v) not in (types.TupleType, types.ListType) :
132	if not v :
133	del fields[k]
134	else :
135	fields[k] = [ v ]
136	return fields
137
138	def beginTransaction(self) :
139	"""Starts a transaction."""
140	self.tool.logdebug("Transaction begins... WARNING : No transactions in LDAP !")
141
142	def commitTransaction(self) :
143	"""Commits a transaction."""
144	self.tool.logdebug("Transaction committed. WARNING : No transactions in LDAP !")
145
146	def rollbackTransaction(self) :
147	"""Rollbacks a transaction."""
148	self.tool.logdebug("Transaction aborted. WARNING : No transaction in LDAP !")
149
150	def doSearch(self, key, fields=None, base="", scope=ldap.SCOPE_SUBTREE, flushcache=0) :
151	"""Does an LDAP search query."""
152	message = ""
153	for tryit in range(3) :
154	try :
155	base = base or self.basedn
156	if self.useldapcache :
157	# Here we overwrite the fields the app want, to try and
158	# retrieve ALL user defined attributes ("*")
159	# + the createTimestamp attribute, needed by job history
160	#
161	# This may not work with all LDAP servers
162	# but works at least in OpenLDAP (2.1.25)
163	# and iPlanet Directory Server (5.1 SP3)
164	fields = ["*", "createTimestamp"]
165
166	if self.useldapcache and (not flushcache) and (scope == ldap.SCOPE_BASE) and self.ldapcache.has_key(base) :
167	entry = self.ldapcache[base]
168	self.tool.logdebug("LDAP cache hit %s => %s" % (base, entry))
169	result = [(base, entry)]
170	else :
171	self.querydebug("QUERY : Filter : %s, BaseDN : %s, Scope : %s, Attributes : %s" % (key, base, scope, fields))
172	result = self.database.search_s(base, scope, key, fields)
173	except ldap.NO_SUCH_OBJECT, msg :
174	raise PyKotaStorageError, (_("Search base %s doesn't seem to exist. Probable misconfiguration. Please double check /etc/pykota/pykota.conf : %s") % (base, msg))
175	except ldap.LDAPError, msg :
176	message = (_("Search for %s(%s) from %s(scope=%s) returned no answer.") % (key, fields, base, scope)) + " : %s" % msg
177	self.tool.printInfo("LDAP error : %s" % message, "error")
178	self.tool.printInfo("LDAP connection will be closed and reopened.", "warn")
179	self.close()
180	self.secondStageInit()
181	else :
182	self.querydebug("QUERY : Result : %s" % result)
183	result = [ (dn, cidict(attrs)) for (dn, attrs) in result ]
184	if self.useldapcache :
185	for (dn, attributes) in result :
186	self.querydebug("LDAP cache store %s => %s" % (dn, attributes))
187	self.ldapcache[dn] = attributes
188	return result
189	raise PyKotaStorageError, message
190
191	def doAdd(self, dn, fields) :
192	"""Adds an entry in the LDAP directory."""
193	fields = self.normalizeFields(cidict(fields))
194	message = ""
195	for tryit in range(3) :
196	try :
197	self.querydebug("QUERY : ADD(%s, %s)" % (dn, fields))
198	entry = ldap.modlist.addModlist(fields)
199	self.querydebug("%s" % entry)
200	self.database.add_s(dn, entry)
201	except ldap.ALREADY_EXISTS, msg :
202	raise PyKotaStorageError, "Entry %s already exists : %s" % (dn, msg)
203	except ldap.LDAPError, msg :
204	message = (_("Problem adding LDAP entry (%s, %s)") % (dn, str(fields))) + " : %s" % msg
205	self.tool.printInfo("LDAP error : %s" % message, "error")
206	self.tool.printInfo("LDAP connection will be closed and reopened.", "warn")
207	self.close()
208	self.secondStageInit()
209	else :
210	if self.useldapcache :
211	self.querydebug("LDAP cache add %s => %s" % (dn, fields))
212	self.ldapcache[dn] = fields
213	return dn
214	raise PyKotaStorageError, message
215
216	def doDelete(self, dn) :
217	"""Deletes an entry from the LDAP directory."""
218	message = ""
219	for tryit in range(3) :
220	try :
221	self.querydebug("QUERY : Delete(%s)" % dn)
222	self.database.delete_s(dn)
223	except ldap.NO_SUCH_OBJECT :
224	self.tool.printInfo("Entry %s was already missing before we deleted it. This MAY be normal." % dn, "info")
225	except ldap.LDAPError, msg :
226	message = (_("Problem deleting LDAP entry (%s)") % dn) + " : %s" % msg
227	self.tool.printInfo("LDAP error : %s" % message, "error")
228	self.tool.printInfo("LDAP connection will be closed and reopened.", "warn")
229	self.close()
230	self.secondStageInit()
231	else :
232	if self.useldapcache :
233	try :
234	self.querydebug("LDAP cache del %s" % dn)
235	del self.ldapcache[dn]
236	except KeyError :
237	pass
238	return
239	raise PyKotaStorageError, message
240
241	def doModify(self, dn, fields, ignoreold=1, flushcache=0) :
242	"""Modifies an entry in the LDAP directory."""
243	fields = cidict(fields)
244	for tryit in range(3) :
245	try :
246	# TODO : take care of, and update LDAP specific cache
247	if self.useldapcache and not flushcache :
248	if self.ldapcache.has_key(dn) :
249	old = self.ldapcache[dn]
250	self.querydebug("LDAP cache hit %s => %s" % (dn, old))
251	oldentry = {}
252	for (k, v) in old.items() :
253	if k != "createTimestamp" :
254	oldentry[k] = v
255	else :
256	self.querydebug("LDAP cache miss %s" % dn)
257	oldentry = self.doSearch("objectClass=*", base=dn, scope=ldap.SCOPE_BASE)[0][1]
258	else :
259	oldentry = self.doSearch("objectClass=*", base=dn, scope=ldap.SCOPE_BASE, flushcache=flushcache)[0][1]
260	for (k, v) in fields.items() :
261	if type(v) == type({}) :
262	try :
263	oldvalue = v["convert"](oldentry.get(k, [0])[0])
264	except ValueError :
265	self.querydebug("Error converting %s with %s(%s)" % (oldentry.get(k), k, v))
266	oldvalue = 0
267	if v["operator"] == '+' :
268	newvalue = oldvalue + v["value"]
269	else :
270	newvalue = oldvalue - v["value"]
271	fields[k] = str(newvalue)
272	fields = self.normalizeFields(fields)
273	self.querydebug("QUERY : Modify(%s, %s ==> %s)" % (dn, oldentry, fields))
274	entry = ldap.modlist.modifyModlist(oldentry, fields, ignore_oldexistent=ignoreold)
275	modentry = []
276	for (mop, mtyp, mval) in entry :
277	if mtyp and (mtyp.lower() != "createtimestamp") :
278	modentry.append((mop, mtyp, mval))
279	self.querydebug("MODIFY : %s ==> %s ==> %s" % (fields, entry, modentry))
280	if modentry :
281	self.database.modify_s(dn, modentry)
282	except ldap.LDAPError, msg :
283	message = (_("Problem modifying LDAP entry (%s, %s)") % (dn, fields)) + " : %s" % msg
284	self.tool.printInfo("LDAP error : %s" % message, "error")
285	self.tool.printInfo("LDAP connection will be closed and reopened.", "warn")
286	self.close()
287	self.secondStageInit()
288	else :
289	if self.useldapcache :
290	cachedentry = self.ldapcache[dn]
291	for (mop, mtyp, mval) in entry :
292	if mop in (ldap.MOD_ADD, ldap.MOD_REPLACE) :
293	cachedentry[mtyp] = mval
294	else :
295	try :
296	del cachedentry[mtyp]
297	except KeyError :
298	pass
299	self.querydebug("LDAP cache update %s => %s" % (dn, cachedentry))
300	return dn
301	raise PyKotaStorageError, message
302
303	def filterNames(self, records, attribute, patterns=None) :
304	"""Returns a list of 'attribute' from a list of records.
305
306	Logs any missing attribute.
307	"""
308	result = []
309	for (dn, record) in records :
310	attrval = record.get(attribute, [None])[0]
311	if attrval is None :
312	self.tool.printInfo("Object %s has no %s attribute !" % (dn, attribute), "error")
313	else :
314	attrval = databaseToUnicode(attrval)
315	if patterns :
316	if (not isinstance(patterns, type([]))) and (not isinstance(patterns, type(()))) :
317	patterns = [ patterns ]
318	if self.tool.matchString(attrval, patterns) :
319	result.append(attrval)
320	else :
321	result.append(attrval)
322	return result
323
324	def getAllBillingCodes(self, billingcode=None) :
325	"""Extracts all billing codes or only the billing codes matching the optional parameter."""
326	ldapfilter = "objectClass=pykotaBilling"
327	result = self.doSearch(ldapfilter, ["pykotaBillingCode"], base=self.info["billingcodebase"])
328	if result :
329	return self.filterNames(result, "pykotaBillingCode", billingcode)
330	else :
331	return []
332
333	def getAllPrintersNames(self, printername=None) :
334	"""Extracts all printer names or only the printers' names matching the optional parameter."""
335	ldapfilter = "objectClass=pykotaPrinter"
336	result = self.doSearch(ldapfilter, ["pykotaPrinterName"], base=self.info["printerbase"])
337	if result :
338	return self.filterNames(result, "pykotaPrinterName", printername)
339	else :
340	return []
341
342	def getAllUsersNames(self, username=None) :
343	"""Extracts all user names or only the users' names matching the optional parameter."""
344	ldapfilter = "objectClass=pykotaAccount"
345	result = self.doSearch(ldapfilter, ["pykotaUserName"], base=self.info["userbase"])
346	if result :
347	return self.filterNames(result, "pykotaUserName", username)
348	else :
349	return []
350
351	def getAllGroupsNames(self, groupname=None) :
352	"""Extracts all group names or only the groups' names matching the optional parameter."""
353	ldapfilter = "objectClass=pykotaGroup"
354	result = self.doSearch(ldapfilter, ["pykotaGroupName"], base=self.info["groupbase"])
355	if result :
356	return self.filterNames(result, "pykotaGroupName", groupname)
357	else :
358	return []
359
360	def getUserNbJobsFromHistory(self, user) :
361	"""Returns the number of jobs the user has in history."""
362	result = self.doSearch("(&(pykotaUserName=%s)(objectClass=pykotaJob))" % unicodeToDatabase(user.Name), None, base=self.info["jobbase"])
363	return len(result)
364
365	def getUserFromBackend(self, username) :
366	"""Extracts user information given its name."""
367	user = StorageUser(self, username)
368	username = unicodeToDatabase(username)
369	result = self.doSearch("(&(objectClass=pykotaAccount)(\|(pykotaUserName=%s)(%s=%s)))" % (username, self.info["userrdn"], username), ["pykotaUserName", "pykotaLimitBy", self.info["usermail"], "description"], base=self.info["userbase"])
370	if result :
371	fields = result[0][1]
372	user.ident = result[0][0]
373	user.Description = databaseToUnicode(fields.get("description", [None])[0])
374	user.Email = databaseToUnicode(fields.get(self.info["usermail"], [None])[0])
375	user.LimitBy = databaseToUnicode(fields.get("pykotaLimitBy", ["quota"])[0])
376	result = self.doSearch("(&(objectClass=pykotaAccountBalance)(\|(pykotaUserName=%s)(%s=%s)))" % (username, self.info["balancerdn"], username), ["pykotaBalance", "pykotaLifeTimePaid", "pykotaPayments", "pykotaOverCharge"], base=self.info["balancebase"])
377	if not result :
378	raise PyKotaStorageError, _("No pykotaAccountBalance object found for user %s. Did you create LDAP entries manually ?") % username
379	else :
380	fields = result[0][1]
381	user.idbalance = result[0][0]
382	user.AccountBalance = fields.get("pykotaBalance")
383	if user.AccountBalance is not None :
384	if user.AccountBalance[0].upper() == "NONE" :
385	user.AccountBalance = None
386	else :
387	user.AccountBalance = float(user.AccountBalance[0])
388	user.AccountBalance = user.AccountBalance or 0.0
389	user.LifeTimePaid = fields.get("pykotaLifeTimePaid")
390	user.OverCharge = float(fields.get("pykotaOverCharge", [1.0])[0])
391	if user.LifeTimePaid is not None :
392	if user.LifeTimePaid[0].upper() == "NONE" :
393	user.LifeTimePaid = None
394	else :
395	user.LifeTimePaid = float(user.LifeTimePaid[0])
396	user.LifeTimePaid = user.LifeTimePaid or 0.0
397	user.Payments = []
398	for payment in fields.get("pykotaPayments", []) :
399	try :
400	(date, amount, description) = payment.split(" # ")
401	except ValueError :
402	# Payment with no description (old Payment)
403	(date, amount) = payment.split(" # ")
404	description = ""
405	else :
406	description = databaseToUnicode(base64.decodestring(description))
407	if amount.endswith(" #") :
408	amount = amount[:-2] # TODO : should be catched earlier, the bug is above I think
409	user.Payments.append((date, float(amount), description))
410	user.Exists = True
411	return user
412
413	def getGroupFromBackend(self, groupname) :
414	"""Extracts group information given its name."""
415	group = StorageGroup(self, groupname)
416	groupname = unicodeToDatabase(groupname)
417	result = self.doSearch("(&(objectClass=pykotaGroup)(\|(pykotaGroupName=%s)(%s=%s)))" % (groupname, self.info["grouprdn"], groupname), ["pykotaGroupName", "pykotaLimitBy", "description"], base=self.info["groupbase"])
418	if result :
419	fields = result[0][1]
420	group.ident = result[0][0]
421	group.Name = databaseToUnicode(fields.get("pykotaGroupName", [groupname])[0])
422	group.Description = databaseToUnicode(fields.get("description", [None])[0])
423	group.LimitBy = databaseToUnicode(fields.get("pykotaLimitBy", ["quota"])[0])
424	group.AccountBalance = 0.0
425	group.LifeTimePaid = 0.0
426	for member in self.getGroupMembers(group) :
427	if member.Exists :
428	group.AccountBalance += member.AccountBalance
429	group.LifeTimePaid += member.LifeTimePaid
430	group.Exists = True
431	return group
432
433	def getPrinterFromBackend(self, printername) :
434	"""Extracts printer information given its name : returns first matching printer."""
435	printer = StoragePrinter(self, printername)
436	printername = unicodeToDatabase(printername)
437	result = self.doSearch("(&(objectClass=pykotaPrinter)(\|(pykotaPrinterName=%s)(%s=%s)))" \
438	% (printername, self.info["printerrdn"], printername), \
439	["pykotaPrinterName", "pykotaPricePerPage", \
440	"pykotaPricePerJob", "pykotaMaxJobSize", \
441	"pykotaPassThrough", "uniqueMember", "description"], \
442	base=self.info["printerbase"])
443	if result :
444	fields = result[0][1] # take only first matching printer, ignore the rest
445	printer.ident = result[0][0]
446	printer.Name = databaseToUnicode(fields.get("pykotaPrinterName", [printername])[0])
447	printer.PricePerJob = float(fields.get("pykotaPricePerJob", [0.0])[0])
448	printer.PricePerPage = float(fields.get("pykotaPricePerPage", [0.0])[0])
449	printer.MaxJobSize = int(fields.get("pykotaMaxJobSize", [0])[0])
450	printer.PassThrough = fields.get("pykotaPassThrough", [None])[0]
451	if printer.PassThrough in (1, "1", "t", "true", "TRUE", "True") :
452	printer.PassThrough = 1
453	else :
454	printer.PassThrough = 0
455	printer.uniqueMember = fields.get("uniqueMember", [])
456	printer.Description = databaseToUnicode(fields.get("description", [""])[0])
457	printer.Exists = True
458	return printer
459
460	def getUserPQuotaFromBackend(self, user, printer) :
461	"""Extracts a user print quota."""
462	userpquota = StorageUserPQuota(self, user, printer)
463	if printer.Exists and user.Exists :
464	if self.info["userquotabase"].lower() == "user" :
465	base = user.ident
466	else :
467	base = self.info["userquotabase"]
468	result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaUserName=%s)(pykotaPrinterName=%s))" % \
469	(unicodeToDatabase(user.Name), unicodeToDatabase(printer.Name)), \
470	["pykotaPageCounter", "pykotaLifePageCounter", "pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaWarnCount", "pykotaMaxJobSize"], \
471	base=base)
472	if result :
473	fields = result[0][1]
474	userpquota.ident = result[0][0]
475	userpquota.PageCounter = int(fields.get("pykotaPageCounter", [0])[0])
476	userpquota.LifePageCounter = int(fields.get("pykotaLifePageCounter", [0])[0])
477	userpquota.WarnCount = int(fields.get("pykotaWarnCount", [0])[0])
478	userpquota.SoftLimit = fields.get("pykotaSoftLimit")
479	if userpquota.SoftLimit is not None :
480	if userpquota.SoftLimit[0].upper() == "NONE" :
481	userpquota.SoftLimit = None
482	else :
483	userpquota.SoftLimit = int(userpquota.SoftLimit[0])
484	userpquota.HardLimit = fields.get("pykotaHardLimit")
485	if userpquota.HardLimit is not None :
486	if userpquota.HardLimit[0].upper() == "NONE" :
487	userpquota.HardLimit = None
488	elif userpquota.HardLimit is not None :
489	userpquota.HardLimit = int(userpquota.HardLimit[0])
490	userpquota.DateLimit = fields.get("pykotaDateLimit")
491	if userpquota.DateLimit is not None :
492	if userpquota.DateLimit[0].upper() == "NONE" :
493	userpquota.DateLimit = None
494	else :
495	userpquota.DateLimit = userpquota.DateLimit[0]
496	userpquota.MaxJobSize = fields.get("pykotaMaxJobSize")
497	if userpquota.MaxJobSize is not None :
498	if userpquota.MaxJobSize[0].upper() == "NONE" :
499	userpquota.MaxJobSize = None
500	else :
501	userpquota.MaxJobSize = int(userpquota.MaxJobSize[0])
502	userpquota.Exists = True
503	return userpquota
504
505	def getGroupPQuotaFromBackend(self, group, printer) :
506	"""Extracts a group print quota."""
507	grouppquota = StorageGroupPQuota(self, group, printer)
508	if group.Exists :
509	if self.info["groupquotabase"].lower() == "group" :
510	base = group.ident
511	else :
512	base = self.info["groupquotabase"]
513	result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaGroupName=%s)(pykotaPrinterName=%s))" % \
514	(unicodeToDatabase(group.Name), unicodeToDatabase(printer.Name)), \
515	["pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaMaxJobSize"], \
516	base=base)
517	if result :
518	fields = result[0][1]
519	grouppquota.ident = result[0][0]
520	grouppquota.SoftLimit = fields.get("pykotaSoftLimit")
521	if grouppquota.SoftLimit is not None :
522	if grouppquota.SoftLimit[0].upper() == "NONE" :
523	grouppquota.SoftLimit = None
524	else :
525	grouppquota.SoftLimit = int(grouppquota.SoftLimit[0])
526	grouppquota.HardLimit = fields.get("pykotaHardLimit")
527	if grouppquota.HardLimit is not None :
528	if grouppquota.HardLimit[0].upper() == "NONE" :
529	grouppquota.HardLimit = None
530	else :
531	grouppquota.HardLimit = int(grouppquota.HardLimit[0])
532	grouppquota.DateLimit = fields.get("pykotaDateLimit")
533	if grouppquota.DateLimit is not None :
534	if grouppquota.DateLimit[0].upper() == "NONE" :
535	grouppquota.DateLimit = None
536	else :
537	grouppquota.DateLimit = grouppquota.DateLimit[0]
538	grouppquota.MaxJobSize = fields.get("pykotaMaxJobSize")
539	if grouppquota.MaxJobSize is not None :
540	if grouppquota.MaxJobSize[0].upper() == "NONE" :
541	grouppquota.MaxJobSize = None
542	else :
543	grouppquota.MaxJobSize = int(grouppquota.MaxJobSize[0])
544	grouppquota.PageCounter = 0
545	grouppquota.LifePageCounter = 0
546	usernamesfilter = "".join(["(pykotaUserName=%s)" % unicodeToDatabase(member.Name) for member in self.getGroupMembers(group)])
547	if usernamesfilter :
548	usernamesfilter = "(\|%s)" % usernamesfilter
549	if self.info["userquotabase"].lower() == "user" :
550	base = self.info["userbase"]
551	else :
552	base = self.info["userquotabase"]
553	result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaPrinterName=%s)%s)" % \
554	(unicodeToDatabase(printer.Name), usernamesfilter), \
555	["pykotaPageCounter", "pykotaLifePageCounter"], base=base)
556	if result :
557	for userpquota in result :
558	grouppquota.PageCounter += int(userpquota[1].get("pykotaPageCounter", [0])[0] or 0)
559	grouppquota.LifePageCounter += int(userpquota[1].get("pykotaLifePageCounter", [0])[0] or 0)
560	grouppquota.Exists = True
561	return grouppquota
562
563	def getPrinterLastJobFromBackend(self, printer) :
564	"""Extracts a printer's last job information."""
565	lastjob = StorageLastJob(self, printer)
566	pname = unicodeToDatabase(printer.Name)
567	result = self.doSearch("(&(objectClass=pykotaLastjob)(\|(pykotaPrinterName=%s)(%s=%s)))" % \
568	(pname, self.info["printerrdn"], pname), \
569	["pykotaLastJobIdent"], \
570	base=self.info["lastjobbase"])
571	if result :
572	lastjob.lastjobident = result[0][0]
573	lastjobident = result[0][1]["pykotaLastJobIdent"][0]
574	result = None
575	try :
576	result = self.doSearch("objectClass=pykotaJob", [ "pykotaJobSizeBytes",
577	"pykotaHostName",
578	"pykotaUserName",
579	"pykotaPrinterName",
580	"pykotaJobId",
581	"pykotaPrinterPageCounter",
582	"pykotaJobSize",
583	"pykotaAction",
584	"pykotaJobPrice",
585	"pykotaFileName",
586	"pykotaTitle",
587	"pykotaCopies",
588	"pykotaOptions",
589	"pykotaBillingCode",
590	"pykotaPages",
591	"pykotaMD5Sum",
592	"pykotaPrecomputedJobSize",
593	"pykotaPrecomputedJobPrice",
594	"createTimestamp" ],
595	base="cn=%s,%s" % (lastjobident, self.info["jobbase"]), scope=ldap.SCOPE_BASE)
596	except PyKotaStorageError :
597	pass # Last job entry exists, but job probably doesn't exist anymore.
598	if result :
599	fields = result[0][1]
600	lastjob.ident = result[0][0]
601	lastjob.JobId = databaseToUnicode(fields.get("pykotaJobId")[0])
602	lastjob.UserName = databaseToUnicode(fields.get("pykotaUserName")[0])
603	lastjob.PrinterPageCounter = int(fields.get("pykotaPrinterPageCounter", [0])[0])
604	try :
605	lastjob.JobSize = int(fields.get("pykotaJobSize", [0])[0])
606	except ValueError :
607	lastjob.JobSize = None
608	try :
609	lastjob.JobPrice = float(fields.get("pykotaJobPrice", [0.0])[0])
610	except ValueError :
611	lastjob.JobPrice = None
612	lastjob.JobAction = databaseToUnicode(fields.get("pykotaAction", [""])[0])
613	lastjob.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0])
614	lastjob.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0])
615	lastjob.JobCopies = int(fields.get("pykotaCopies", [0])[0])
616	lastjob.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0])
617	lastjob.JobHostName = databaseToUnicode(fields.get("pykotaHostName", [""])[0])
618	lastjob.JobSizeBytes = fields.get("pykotaJobSizeBytes", [0L])[0]
619	lastjob.JobBillingCode = databaseToUnicode(fields.get("pykotaBillingCode", [None])[0])
620	lastjob.JobMD5Sum = databaseToUnicode(fields.get("pykotaMD5Sum", [None])[0])
621	lastjob.JobPages = fields.get("pykotaPages", [""])[0]
622	try :
623	lastjob.PrecomputedJobSize = int(fields.get("pykotaPrecomputedJobSize", [0])[0])
624	except ValueError :
625	lastjob.PrecomputedJobSize = None
626	try :
627	lastjob.PrecomputedJobPrice = float(fields.get("pykotaPrecomputedJobPrice", [0.0])[0])
628	except ValueError :
629	lastjob.PrecomputedJobPrice = None
630	if lastjob.JobTitle == lastjob.JobFileName == lastjob.JobOptions == u"hidden" :
631	(lastjob.JobTitle, lastjob.JobFileName, lastjob.JobOptions) = (_("Hidden because of privacy concerns"),) * 3
632	date = fields.get("createTimestamp", ["19700101000000Z"])[0] # It's in UTC !
633	mxtime = DateTime.strptime(date[:14], "%Y%m%d%H%M%S").localtime()
634	lastjob.JobDate = mxtime.strftime("%Y-%m-%d %H:%M:%S")
635	lastjob.Exists = True
636	return lastjob
637
638	def getGroupMembersFromBackend(self, group) :
639	"""Returns the group's members list."""
640	groupmembers = []
641	gname = unicodeToDatabase(group.Name)
642	result = self.doSearch("(&(objectClass=pykotaGroup)(\|(pykotaGroupName=%s)(%s=%s)))" % \
643	(gname, self.info["grouprdn"], gname), \
644	[self.info["groupmembers"]], \
645	base=self.info["groupbase"])
646	if result :
647	for username in result[0][1].get(self.info["groupmembers"], []) :
648	groupmembers.append(self.getUser(databaseToUnicode(username)))
649	return groupmembers
650
651	def getUserGroupsFromBackend(self, user) :
652	"""Returns the user's groups list."""
653	groups = []
654	uname = unicodeToDatabase(user.Name)
655	result = self.doSearch("(&(objectClass=pykotaGroup)(%s=%s))" % \
656	(self.info["groupmembers"], uname), \
657	[self.info["grouprdn"], "pykotaGroupName", "pykotaLimitBy"], \
658	base=self.info["groupbase"])
659	if result :
660	for (groupid, fields) in result :
661	groupname = databaseToUnicode((fields.get("pykotaGroupName", [None]) or fields.get(self.info["grouprdn"], [None]))[0])
662	group = self.getFromCache("GROUPS", groupname)
663	if group is None :
664	group = StorageGroup(self, groupname)
665	group.ident = groupid
666	group.LimitBy = fields.get("pykotaLimitBy")
667	if group.LimitBy is not None :
668	group.LimitBy = databaseToUnicode(group.LimitBy[0])
669	else :
670	group.LimitBy = u"quota"
671	group.AccountBalance = 0.0
672	group.LifeTimePaid = 0.0
673	for member in self.getGroupMembers(group) :
674	if member.Exists :
675	group.AccountBalance += member.AccountBalance
676	group.LifeTimePaid += member.LifeTimePaid
677	group.Exists = True
678	self.cacheEntry("GROUPS", group.Name, group)
679	groups.append(group)
680	return groups
681
682	def getParentPrintersFromBackend(self, printer) :
683	"""Get all the printer groups this printer is a member of."""
684	pgroups = []
685	result = self.doSearch("(&(objectClass=pykotaPrinter)(uniqueMember=%s))" % \
686	printer.ident, \
687	["pykotaPrinterName"], \
688	base=self.info["printerbase"])
689	if result :
690	for (printerid, fields) in result :
691	if printerid != printer.ident : # In case of integrity violation.
692	parentprinter = self.getPrinter(databaseToUnicode(fields.get("pykotaPrinterName")[0]))
693	if parentprinter.Exists :
694	pgroups.append(parentprinter)
695	return pgroups
696
697	def getMatchingPrinters(self, printerpattern) :
698	"""Returns the list of all printers for which name matches a certain pattern."""
699	printers = []
700	# see comment at the same place in pgstorage.py
701	result = self.doSearch("objectClass=pykotaPrinter", \
702	["pykotaPrinterName", "pykotaPricePerPage", "pykotaPricePerJob", "pykotaMaxJobSize", "pykotaPassThrough", "uniqueMember", "description"], \
703	base=self.info["printerbase"])
704	if result :
705	patterns = printerpattern.split(",")
706	try :
707	patdict = {}.fromkeys(patterns)
708	except AttributeError :
709	# Python v2.2 or earlier
710	patdict = {}
711	for p in patterns :
712	patdict[p] = None
713	for (printerid, fields) in result :
714	printername = databaseToUnicode(fields.get("pykotaPrinterName", [""])[0] or fields.get(self.info["printerrdn"], [""])[0])
715	if patdict.has_key(printername) or self.tool.matchString(printername, patterns) :
716	printer = StoragePrinter(self, printername)
717	printer.ident = printerid
718	printer.PricePerJob = float(fields.get("pykotaPricePerJob", [0.0])[0] or 0.0)
719	printer.PricePerPage = float(fields.get("pykotaPricePerPage", [0.0])[0] or 0.0)
720	printer.MaxJobSize = int(fields.get("pykotaMaxJobSize", [0])[0])
721	printer.PassThrough = fields.get("pykotaPassThrough", [None])[0]
722	if printer.PassThrough in (1, "1", "t", "true", "TRUE", "True") :
723	printer.PassThrough = 1
724	else :
725	printer.PassThrough = 0
726	printer.uniqueMember = fields.get("uniqueMember", [])
727	printer.Description = databaseToUnicode(fields.get("description", [""])[0])
728	printer.Exists = True
729	printers.append(printer)
730	self.cacheEntry("PRINTERS", printer.Name, printer)
731	return printers
732
733	def getMatchingUsers(self, userpattern) :
734	"""Returns the list of all users for which name matches a certain pattern."""
735	users = []
736	# see comment at the same place in pgstorage.py
737	result = self.doSearch("objectClass=pykotaAccount", \
738	["pykotaUserName", "pykotaLimitBy", self.info["usermail"], "description"], \
739	base=self.info["userbase"])
740	if result :
741	patterns = userpattern.split(",")
742	try :
743	patdict = {}.fromkeys(patterns)
744	except AttributeError :
745	# Python v2.2 or earlier
746	patdict = {}
747	for p in patterns :
748	patdict[p] = None
749	for (userid, fields) in result :
750	username = databaseToUnicode(fields.get("pykotaUserName", [""])[0] or fields.get(self.info["userrdn"], [""])[0])
751	if patdict.has_key(username) or self.tool.matchString(username, patterns) :
752	user = StorageUser(self, username)
753	user.ident = userid
754	user.Email = databaseToUnicode(fields.get(self.info["usermail"], [None])[0])
755	user.LimitBy = databaseToUnicode(fields.get("pykotaLimitBy", ["quota"])[0])
756	user.Description = databaseToUnicode(fields.get("description", [""])[0])
757	uname = unicodeToDatabase(username)
758	result = self.doSearch("(&(objectClass=pykotaAccountBalance)(\|(pykotaUserName=%s)(%s=%s)))" % \
759	(uname, self.info["balancerdn"], uname), \
760	["pykotaBalance", "pykotaLifeTimePaid", "pykotaPayments", "pykotaOverCharge"], \
761	base=self.info["balancebase"])
762	if not result :
763	raise PyKotaStorageError, _("No pykotaAccountBalance object found for user %s. Did you create LDAP entries manually ?") % username
764	else :
765	fields = result[0][1]
766	user.idbalance = result[0][0]
767	user.OverCharge = float(fields.get("pykotaOverCharge", [1.0])[0])
768	user.AccountBalance = fields.get("pykotaBalance")
769	if user.AccountBalance is not None :
770	if user.AccountBalance[0].upper() == "NONE" :
771	user.AccountBalance = None
772	else :
773	user.AccountBalance = float(user.AccountBalance[0])
774	user.AccountBalance = user.AccountBalance or 0.0
775	user.LifeTimePaid = fields.get("pykotaLifeTimePaid")
776	if user.LifeTimePaid is not None :
777	if user.LifeTimePaid[0].upper() == "NONE" :
778	user.LifeTimePaid = None
779	else :
780	user.LifeTimePaid = float(user.LifeTimePaid[0])
781	user.LifeTimePaid = user.LifeTimePaid or 0.0
782	user.Payments = []
783	for payment in fields.get("pykotaPayments", []) :
784	try :
785	(date, amount, description) = payment.split(" # ")
786	except ValueError :
787	# Payment with no description (old Payment)
788	(date, amount) = payment.split(" # ")
789	description = ""
790	else :
791	description = databaseToUnicode(base64.decodestring(description))
792	if amount.endswith(" #") :
793	amount = amount[:-2] # TODO : should be catched earlier, the bug is above I think
794	user.Payments.append((date, float(amount), description))
795	user.Exists = True
796	users.append(user)
797	self.cacheEntry("USERS", user.Name, user)
798	return users
799
800	def getMatchingGroups(self, grouppattern) :
801	"""Returns the list of all groups for which name matches a certain pattern."""
802	groups = []
803	# see comment at the same place in pgstorage.py
804	result = self.doSearch("objectClass=pykotaGroup", \
805	["pykotaGroupName", "pykotaLimitBy", "description"], \
806	base=self.info["groupbase"])
807	if result :
808	patterns = grouppattern.split(",")
809	try :
810	patdict = {}.fromkeys(patterns)
811	except AttributeError :
812	# Python v2.2 or earlier
813	patdict = {}
814	for p in patterns :
815	patdict[p] = None
816	for (groupid, fields) in result :
817	groupname = databaseToUnicode(fields.get("pykotaGroupName", [""])[0] or fields.get(self.info["grouprdn"], [""])[0])
818	if patdict.has_key(groupname) or self.tool.matchString(groupname, patterns) :
819	group = StorageGroup(self, groupname)
820	group.ident = groupid
821	group.Name = databaseToUnicode(fields.get("pykotaGroupName", [groupname])[0])
822	group.LimitBy = databaseToUnicode(fields.get("pykotaLimitBy", ["quota"])[0])
823	group.Description = databaseToUnicode(fields.get("description", [""])[0])
824	group.AccountBalance = 0.0
825	group.LifeTimePaid = 0.0
826	for member in self.getGroupMembers(group) :
827	if member.Exists :
828	group.AccountBalance += member.AccountBalance
829	group.LifeTimePaid += member.LifeTimePaid
830	group.Exists = True
831	groups.append(group)
832	self.cacheEntry("GROUPS", group.Name, group)
833	return groups
834
835	def getPrinterUsersAndQuotas(self, printer, names=["*"]) :
836	"""Returns the list of users who uses a given printer, along with their quotas."""
837	usersandquotas = []
838	pname = unicodeToDatabase(printer.Name)
839	names = [unicodeToDatabase(n) for n in names]
840	if self.info["userquotabase"].lower() == "user" :
841	base = self.info["userbase"]
842	else :
843	base = self.info["userquotabase"]
844	result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaPrinterName=%s)(\|%s))" % \
845	(pname, "".join(["(pykotaUserName=%s)" % uname for uname in names])), \
846	["pykotaUserName", "pykotaPageCounter", "pykotaLifePageCounter", "pykotaSoftLimit", "pykotaHardLimit", "pykotaDateLimit", "pykotaWarnCount"], \
847	base=base)
848	if result :
849	for (userquotaid, fields) in result :
850	user = self.getUser(databaseToUnicode(fields.get("pykotaUserName")[0]))
851	userpquota = StorageUserPQuota(self, user, printer)
852	userpquota.ident = userquotaid
853	userpquota.PageCounter = int(fields.get("pykotaPageCounter", [0])[0])
854	userpquota.LifePageCounter = int(fields.get("pykotaLifePageCounter", [0])[0])
855	userpquota.WarnCount = int(fields.get("pykotaWarnCount", [0])[0])
856	userpquota.SoftLimit = fields.get("pykotaSoftLimit")
857	if userpquota.SoftLimit is not None :
858	if userpquota.SoftLimit[0].upper() == "NONE" :
859	userpquota.SoftLimit = None
860	else :
861	userpquota.SoftLimit = int(userpquota.SoftLimit[0])
862	userpquota.HardLimit = fields.get("pykotaHardLimit")
863	if userpquota.HardLimit is not None :
864	if userpquota.HardLimit[0].upper() == "NONE" :
865	userpquota.HardLimit = None
866	elif userpquota.HardLimit is not None :
867	userpquota.HardLimit = int(userpquota.HardLimit[0])
868	userpquota.DateLimit = fields.get("pykotaDateLimit")
869	if userpquota.DateLimit is not None :
870	if userpquota.DateLimit[0].upper() == "NONE" :
871	userpquota.DateLimit = None
872	else :
873	userpquota.DateLimit = userpquota.DateLimit[0]
874	userpquota.Exists = True
875	usersandquotas.append((user, userpquota))
876	self.cacheEntry("USERPQUOTAS", "%s@%s" % (user.Name, printer.Name), userpquota)
877	usersandquotas.sort(lambda x, y : cmp(x[0].Name, y[0].Name))
878	return usersandquotas
879
880	def getPrinterGroupsAndQuotas(self, printer, names=["*"]) :
881	"""Returns the list of groups which uses a given printer, along with their quotas."""
882	groupsandquotas = []
883	pname = unicodeToDatabase(printer.Name)
884	names = [unicodeToDatabase(n) for n in names]
885	if self.info["groupquotabase"].lower() == "group" :
886	base = self.info["groupbase"]
887	else :
888	base = self.info["groupquotabase"]
889	result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaPrinterName=%s)(\|%s))" % \
890	(pname, "".join(["(pykotaGroupName=%s)" % gname for gname in names])), \
891	["pykotaGroupName"], \
892	base=base)
893	if result :
894	for (groupquotaid, fields) in result :
895	group = self.getGroup(databaseToUnicode(fields.get("pykotaGroupName")[0]))
896	grouppquota = self.getGroupPQuota(group, printer)
897	groupsandquotas.append((group, grouppquota))
898	groupsandquotas.sort(lambda x, y : cmp(x[0].Name, y[0].Name))
899	return groupsandquotas
900
901	def addPrinter(self, printer) :
902	"""Adds a printer to the quota storage, returns the old value if it already exists."""
903	oldentry = self.getPrinter(printer.Name)
904	if oldentry.Exists :
905	return oldentry # we return the existing entry
906	printername = unicodeToDatabase(printer.Name)
907	fields = { self.info["printerrdn"] : printername,
908	"objectClass" : ["pykotaObject", "pykotaPrinter"],
909	"cn" : printername,
910	"pykotaPrinterName" : printername,
911	"pykotaPassThrough" : (printer.PassThrough and "t") or "f",
912	"pykotaMaxJobSize" : str(printer.MaxJobSize or 0),
913	"description" : unicodeToDatabase(printer.Description or ""),
914	"pykotaPricePerPage" : str(printer.PricePerPage or 0.0),
915	"pykotaPricePerJob" : str(printer.PricePerJob or 0.0),
916	}
917	dn = "%s=%s,%s" % (self.info["printerrdn"], printername, self.info["printerbase"])
918	self.doAdd(dn, fields)
919	printer.isDirty = False
920	return None # the entry created doesn't need further modification
921
922	def addUser(self, user) :
923	"""Adds a user to the quota storage, returns the old value if it already exists."""
924	oldentry = self.getUser(user.Name)
925	if oldentry.Exists :
926	return oldentry # we return the existing entry
927	uname = unicodeToDatabase(user.Name)
928	newfields = {
929	"pykotaUserName" : uname,
930	"pykotaLimitBy" : unicodeToDatabase(user.LimitBy or u"quota"),
931	"description" : unicodeToDatabase(user.Description or ""),
932	self.info["usermail"] : unicodeToDatabase(user.Email or ""),
933	}
934
935	mustadd = 1
936	if self.info["newuser"].lower() != 'below' :
937	try :
938	(where, action) = [s.strip() for s in self.info["newuser"].split(",")]
939	except ValueError :
940	(where, action) = (self.info["newuser"].strip(), "fail")
941	result = self.doSearch("(&(objectClass=%s)(%s=%s))" % \
942	(where, self.info["userrdn"], uname), \
943	None, \
944	base=self.info["userbase"])
945	if result :
946	(dn, fields) = result[0]
947	oc = fields.get("objectClass", fields.get("objectclass", []))
948	oc.extend(["pykotaAccount", "pykotaAccountBalance"])
949	fields.update(newfields)
950	fields.update({ "pykotaBalance" : str(user.AccountBalance or 0.0),
951	"pykotaOverCharge" : str(user.OverCharge),
952	"pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0), })
953	self.doModify(dn, fields)
954	mustadd = 0
955	else :
956	message = _("Unable to find an existing objectClass %s entry with %s=%s to attach pykotaAccount objectClass") % (where, self.info["userrdn"], user.Name)
957	if action.lower() == "warn" :
958	self.tool.printInfo(_("%s. A new entry will be created instead.") % message, "warn")
959	else : # 'fail' or incorrect setting
960	raise PyKotaStorageError, "%s. Action aborted. Please check your configuration." % message
961
962	if mustadd :
963	if self.info["userbase"] == self.info["balancebase"] :
964	fields = { self.info["userrdn"] : uname,
965	"objectClass" : ["pykotaObject", "pykotaAccount", "pykotaAccountBalance"],
966	"cn" : uname,
967	"pykotaBalance" : str(user.AccountBalance or 0.0),
968	"pykotaOverCharge" : str(user.OverCharge),
969	"pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),
970	}
971	else :
972	fields = { self.info["userrdn"] : uname,
973	"objectClass" : ["pykotaObject", "pykotaAccount"],
974	"cn" : uname,
975	}
976	fields.update(newfields)
977	dn = "%s=%s,%s" % (self.info["userrdn"], uname, self.info["userbase"])
978	self.doAdd(dn, fields)
979	if self.info["userbase"] != self.info["balancebase"] :
980	fields = { self.info["balancerdn"] : uname,
981	"objectClass" : ["pykotaObject", "pykotaAccountBalance"],
982	"cn" : uname,
983	"pykotaBalance" : str(user.AccountBalance or 0.0),
984	"pykotaOverCharge" : str(user.OverCharge),
985	"pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),
986	}
987	dn = "%s=%s,%s" % (self.info["balancerdn"], uname, self.info["balancebase"])
988	self.doAdd(dn, fields)
989	user.idbalance = dn
990	if user.PaymentsBacklog :
991	for (value, comment) in user.PaymentsBacklog :
992	self.writeNewPayment(user, value, comment)
993	user.PaymentsBacklog = []
994	user.isDirty = False
995	return None # the entry created doesn't need further modification
996
997	def addGroup(self, group) :
998	"""Adds a group to the quota storage, returns the old value if it already exists."""
999	oldentry = self.getGroup(group.Name)
1000	if oldentry.Exists :
1001	return oldentry # we return the existing entry
1002	gname = unicodeToDatabase(group.Name)
1003	newfields = {
1004	"pykotaGroupName" : gname,
1005	"pykotaLimitBy" : unicodeToDatabase(group.LimitBy or u"quota"),
1006	"description" : unicodeToDatabase(group.Description or "")
1007	}
1008	mustadd = 1
1009	if self.info["newgroup"].lower() != 'below' :
1010	try :
1011	(where, action) = [s.strip() for s in self.info["newgroup"].split(",")]
1012	except ValueError :
1013	(where, action) = (self.info["newgroup"].strip(), "fail")
1014	result = self.doSearch("(&(objectClass=%s)(%s=%s))" % \
1015	(where, self.info["grouprdn"], gname), \
1016	None, \
1017	base=self.info["groupbase"])
1018	if result :
1019	(dn, fields) = result[0]
1020	oc = fields.get("objectClass", fields.get("objectclass", []))
1021	oc.extend(["pykotaGroup"])
1022	fields.update(newfields)
1023	self.doModify(dn, fields)
1024	mustadd = 0
1025	else :
1026	message = _("Unable to find an existing entry to attach pykotaGroup objectclass %s") % group.Name
1027	if action.lower() == "warn" :
1028	self.tool.printInfo("%s. A new entry will be created instead." % message, "warn")
1029	else : # 'fail' or incorrect setting
1030	raise PyKotaStorageError, "%s. Action aborted. Please check your configuration." % message
1031
1032	if mustadd :
1033	fields = { self.info["grouprdn"] : gname,
1034	"objectClass" : ["pykotaObject", "pykotaGroup"],
1035	"cn" : gname,
1036	}
1037	fields.update(newfields)
1038	dn = "%s=%s,%s" % (self.info["grouprdn"], gname, self.info["groupbase"])
1039	self.doAdd(dn, fields)
1040	group.isDirty = False
1041	return None # the entry created doesn't need further modification
1042
1043	def addUserToGroup(self, user, group) :
1044	"""Adds an user to a group."""
1045	if user.Name not in [u.Name for u in self.getGroupMembers(group)] :
1046	result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)
1047	if result :
1048	fields = result[0][1]
1049	if not fields.has_key(self.info["groupmembers"]) :
1050	fields[self.info["groupmembers"]] = []
1051	fields[self.info["groupmembers"]].append(unicodeToDatabase(user.Name))
1052	self.doModify(group.ident, fields)
1053	group.Members.append(user)
1054
1055	def delUserFromGroup(self, user, group) :
1056	"""Removes an user from a group."""
1057	if user.Name in [u.Name for u in self.getGroupMembers(group)] :
1058	result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)
1059	if result :
1060	fields = result[0][1]
1061	if not fields.has_key(self.info["groupmembers"]) :
1062	fields[self.info["groupmembers"]] = []
1063	try :
1064	fields[self.info["groupmembers"]].remove(unicodeToDatabase(user.Name))
1065	except ValueError :
1066	pass # TODO : Strange, shouldn't it be there ?
1067	else :
1068	self.doModify(group.ident, fields)
1069	group.Members.remove(user)
1070
1071	def addUserPQuota(self, upq) :
1072	"""Initializes a user print quota on a printer."""
1073	# first check if an entry already exists
1074	oldentry = self.getUserPQuota(upq.User, upq.Printer)
1075	if oldentry.Exists :
1076	return oldentry # we return the existing entry
1077	uuid = self.genUUID()
1078	uname = unicodeToDatabase(upq.User.Name)
1079	pname = unicodeToDatabase(upq.Printer.Name)
1080	fields = { "cn" : uuid,
1081	"objectClass" : ["pykotaObject", "pykotaUserPQuota"],
1082	"pykotaUserName" : uname,
1083	"pykotaPrinterName" : pname,
1084	"pykotaSoftLimit" : str(upq.SoftLimit),
1085	"pykotaHardLimit" : str(upq.HardLimit),
1086	"pykotaDateLimit" : str(upq.DateLimit),
1087	"pykotaPageCounter" : str(upq.PageCounter or 0),
1088	"pykotaLifePageCounter" : str(upq.LifePageCounter or 0),
1089	"pykotaWarnCount" : str(upq.WarnCount or 0),
1090	"pykotaMaxJobSize" : str(upq.MaxJobSize or 0),
1091	}
1092	if self.info["userquotabase"].lower() == "user" :
1093	dn = "cn=%s,%s" % (uuid, upq.User.ident)
1094	else :
1095	dn = "cn=%s,%s" % (uuid, self.info["userquotabase"])
1096	self.doAdd(dn, fields)
1097	upq.isDirty = False
1098	return None # the entry created doesn't need further modification
1099
1100	def addGroupPQuota(self, gpq) :
1101	"""Initializes a group print quota on a printer."""
1102	oldentry = self.getGroupPQuota(gpq.Group, gpq.Printer)
1103	if oldentry.Exists :
1104	return oldentry # we return the existing entry
1105	uuid = self.genUUID()
1106	gname = unicodeToDatabase(gpq.Group.Name)
1107	pname = unicodeToDatabase(gpq.Printer.Name)
1108	fields = { "cn" : uuid,
1109	"objectClass" : ["pykotaObject", "pykotaGroupPQuota"],
1110	"pykotaGroupName" : gname,
1111	"pykotaPrinterName" : pname,
1112	"pykotaDateLimit" : "None",
1113	}
1114	if self.info["groupquotabase"].lower() == "group" :
1115	dn = "cn=%s,%s" % (uuid, gpq.Group.ident)
1116	else :
1117	dn = "cn=%s,%s" % (uuid, self.info["groupquotabase"])
1118	self.doAdd(dn, fields)
1119	gpq.isDirty = False
1120	return None # the entry created doesn't need further modification
1121
1122	def savePrinter(self, printer) :
1123	"""Saves the printer to the database in a single operation."""
1124	fields = {
1125	"pykotaPassThrough" : (printer.PassThrough and "t") or "f",
1126	"pykotaMaxJobSize" : str(printer.MaxJobSize or 0),
1127	"description" : unicodeToDatabase(printer.Description or ""),
1128	"pykotaPricePerPage" : str(printer.PricePerPage or 0.0),
1129	"pykotaPricePerJob" : str(printer.PricePerJob or 0.0),
1130	}
1131	self.doModify(printer.ident, fields)
1132
1133	def saveUser(self, user) :
1134	"""Saves the user to the database in a single operation."""
1135	newfields = {
1136	"pykotaLimitBy" : unicodeToDatabase(user.LimitBy or u"quota"),
1137	"description" : unicodeToDatabase(user.Description or ""),
1138	self.info["usermail"] : user.Email or "",
1139	}
1140	self.doModify(user.ident, newfields)
1141
1142	newfields = { "pykotaBalance" : str(user.AccountBalance or 0.0),
1143	"pykotaLifeTimePaid" : str(user.LifeTimePaid or 0.0),
1144	"pykotaOverCharge" : str(user.OverCharge),
1145	}
1146	self.doModify(user.idbalance, newfields)
1147
1148	def saveGroup(self, group) :
1149	"""Saves the group to the database in a single operation."""
1150	newfields = {
1151	"pykotaLimitBy" : unicodeToDatabase(group.LimitBy or u"quota"),
1152	"description" : unicodeToDatabase(group.Description or ""),
1153	}
1154	self.doModify(group.ident, newfields)
1155
1156	def writeUserPQuotaDateLimit(self, userpquota, datelimit) :
1157	"""Sets the date limit permanently for a user print quota."""
1158	fields = {
1159	"pykotaDateLimit" : str(datelimit),
1160	}
1161	return self.doModify(userpquota.ident, fields)
1162
1163	def writeGroupPQuotaDateLimit(self, grouppquota, datelimit) :
1164	"""Sets the date limit permanently for a group print quota."""
1165	fields = {
1166	"pykotaDateLimit" : str(datelimit),
1167	}
1168	return self.doModify(grouppquota.ident, fields)
1169
1170	def increaseUserPQuotaPagesCounters(self, userpquota, nbpages) :
1171	"""Increase page counters for a user print quota."""
1172	fields = {
1173	"pykotaPageCounter" : { "operator" : "+", "value" : nbpages, "convert" : int },
1174	"pykotaLifePageCounter" : { "operator" : "+", "value" : nbpages, "convert" : int },
1175	}
1176	return self.doModify(userpquota.ident, fields)
1177
1178	def decreaseUserAccountBalance(self, user, amount) :
1179	"""Decreases user's account balance from an amount."""
1180	fields = {
1181	"pykotaBalance" : { "operator" : "-", "value" : amount, "convert" : float },
1182	}
1183	return self.doModify(user.idbalance, fields, flushcache=1)
1184
1185	def writeNewPayment(self, user, amount, comment="") :
1186	"""Adds a new payment to the payments history."""
1187	payments = []
1188	for payment in user.Payments :
1189	payments.append("%s # %s # %s" % (payment[0], str(payment[1]), base64.encodestring(unicodeToDatabase(payment[2])).strip()))
1190	payments.append("%s # %s # %s" % (str(DateTime.now()), str(amount), base64.encodestring(unicodeToDatabase(comment)).strip()))
1191	fields = {
1192	"pykotaPayments" : payments,
1193	}
1194	return self.doModify(user.idbalance, fields)
1195
1196	def writeLastJobSize(self, lastjob, jobsize, jobprice) :
1197	"""Sets the last job's size permanently."""
1198	fields = {
1199	"pykotaJobSize" : str(jobsize),
1200	"pykotaJobPrice" : str(jobprice),
1201	}
1202	self.doModify(lastjob.ident, fields)
1203
1204	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) :
1205	"""Adds a job in a printer's history."""
1206	uname = unicodeToDatabase(user.Name)
1207	pname = unicodeToDatabase(printer.Name)
1208	if (not self.disablehistory) or (not printer.LastJob.Exists) :
1209	uuid = self.genUUID()
1210	dn = "cn=%s,%s" % (uuid, self.info["jobbase"])
1211	else :
1212	uuid = printer.LastJob.ident[3:].split(",")[0]
1213	dn = printer.LastJob.ident
1214	if self.privacy :
1215	# For legal reasons, we want to hide the title, filename and options
1216	title = filename = options = u"hidden"
1217	fields = {
1218	"objectClass" : ["pykotaObject", "pykotaJob"],
1219	"cn" : uuid,
1220	"pykotaUserName" : uname,
1221	"pykotaPrinterName" : pname,
1222	"pykotaJobId" : unicodeToDatabase(jobid),
1223	"pykotaPrinterPageCounter" : str(pagecounter),
1224	"pykotaAction" : unicodeToDatabase(action),
1225	"pykotaFileName" : ((filename is None) and "None") or unicodeToDatabase(filename),
1226	"pykotaTitle" : ((title is None) and "None") or unicodeToDatabase(title),
1227	"pykotaCopies" : str(copies),
1228	"pykotaOptions" : ((options is None) and "None") or unicodeToDatabase(options),
1229	"pykotaHostName" : str(clienthost),
1230	"pykotaJobSizeBytes" : str(jobsizebytes),
1231	"pykotaMD5Sum" : unicodeToDatabase(jobmd5sum),
1232	"pykotaPages" : jobpages, # don't add this attribute if it is not set, so no string conversion
1233	"pykotaBillingCode" : unicodeToDatabase(jobbilling), # don't add this attribute if it is not set, so no string conversion
1234	"pykotaPrecomputedJobSize" : str(precomputedsize),
1235	"pykotaPrecomputedJobPrice" : str(precomputedprice),
1236	}
1237	if (not self.disablehistory) or (not printer.LastJob.Exists) :
1238	if jobsize is not None :
1239	fields.update({ "pykotaJobSize" : str(jobsize), "pykotaJobPrice" : str(jobprice) })
1240	self.doAdd(dn, fields)
1241	else :
1242	# here we explicitly want to reset jobsize to 'None' if needed
1243	fields.update({ "pykotaJobSize" : str(jobsize), "pykotaJobPrice" : str(jobprice) })
1244	self.doModify(dn, fields)
1245
1246	if printer.LastJob.Exists :
1247	fields = {
1248	"pykotaLastJobIdent" : uuid,
1249	}
1250	self.doModify(printer.LastJob.lastjobident, fields)
1251	else :
1252	lastjuuid = self.genUUID()
1253	lastjdn = "cn=%s,%s" % (lastjuuid, self.info["lastjobbase"])
1254	fields = {
1255	"objectClass" : ["pykotaObject", "pykotaLastJob"],
1256	"cn" : lastjuuid,
1257	"pykotaPrinterName" : pname,
1258	"pykotaLastJobIdent" : uuid,
1259	}
1260	self.doAdd(lastjdn, fields)
1261
1262	def saveUserPQuota(self, userpquota) :
1263	"""Saves an user print quota entry."""
1264	fields = {
1265	"pykotaSoftLimit" : str(userpquota.SoftLimit),
1266	"pykotaHardLimit" : str(userpquota.HardLimit),
1267	"pykotaDateLimit" : str(userpquota.DateLimit),
1268	"pykotaWarnCount" : str(userpquota.WarnCount or 0),
1269	"pykotaPageCounter" : str(userpquota.PageCounter or 0),
1270	"pykotaLifePageCounter" : str(userpquota.LifePageCounter or 0),
1271	"pykotaMaxJobSize" : str(userpquota.MaxJobSize or 0),
1272	}
1273	self.doModify(userpquota.ident, fields)
1274
1275	def writeUserPQuotaWarnCount(self, userpquota, warncount) :
1276	"""Sets the warn counter value for a user quota."""
1277	fields = {
1278	"pykotaWarnCount" : str(warncount or 0),
1279	}
1280	self.doModify(userpquota.ident, fields)
1281
1282	def increaseUserPQuotaWarnCount(self, userpquota) :
1283	"""Increases the warn counter value for a user quota."""
1284	fields = {
1285	"pykotaWarnCount" : { "operator" : "+", "value" : 1, "convert" : int },
1286	}
1287	return self.doModify(userpquota.ident, fields)
1288
1289	def saveGroupPQuota(self, grouppquota) :
1290	"""Saves a group print quota entry."""
1291	fields = {
1292	"pykotaSoftLimit" : str(grouppquota.SoftLimit),
1293	"pykotaHardLimit" : str(grouppquota.HardLimit),
1294	"pykotaDateLimit" : str(grouppquota.DateLimit),
1295	"pykotaMaxJobSize" : str(grouppquota.MaxJobSize or 0),
1296	}
1297	self.doModify(grouppquota.ident, fields)
1298
1299	def writePrinterToGroup(self, pgroup, printer) :
1300	"""Puts a printer into a printer group."""
1301	if printer.ident not in pgroup.uniqueMember :
1302	pgroup.uniqueMember.append(printer.ident)
1303	fields = {
1304	"uniqueMember" : pgroup.uniqueMember
1305	}
1306	self.doModify(pgroup.ident, fields)
1307
1308	def removePrinterFromGroup(self, pgroup, printer) :
1309	"""Removes a printer from a printer group."""
1310	try :
1311	pgroup.uniqueMember.remove(printer.ident)
1312	except ValueError :
1313	pass
1314	else :
1315	fields = {
1316	"uniqueMember" : pgroup.uniqueMember,
1317	}
1318	self.doModify(pgroup.ident, fields)
1319
1320	def retrieveHistory(self, user=None, printer=None, hostname=None, billingcode=None, jobid=None, limit=100, start=None, end=None) :
1321	"""Retrieves all print jobs for user on printer (or all) between start and end date, limited to first 100 results."""
1322	precond = "(objectClass=pykotaJob)"
1323	where = []
1324	if user is not None :
1325	where.append("(pykotaUserName=%s)" % unicodeToDatabase(user.Name))
1326	if printer is not None :
1327	where.append("(pykotaPrinterName=%s)" % unicodeToDatabase(printer.Name))
1328	if hostname is not None :
1329	where.append("(pykotaHostName=%s)" % hostname)
1330	if billingcode is not None :
1331	where.append("(pykotaBillingCode=%s)" % unicodeToDatabase(billingcode))
1332	if jobid is not None :
1333	where.append("(pykotaJobId=%s)" % jobid) # TODO : jobid is text, so unicodeToDatabase(jobid) but do all of them as well.
1334	if where :
1335	where = "(&%s)" % "".join([precond] + where)
1336	else :
1337	where = precond
1338	jobs = []
1339	result = self.doSearch(where, fields=[ "pykotaJobSizeBytes",
1340	"pykotaHostName",
1341	"pykotaUserName",
1342	"pykotaPrinterName",
1343	"pykotaJobId",
1344	"pykotaPrinterPageCounter",
1345	"pykotaAction",
1346	"pykotaJobSize",
1347	"pykotaJobPrice",
1348	"pykotaFileName",
1349	"pykotaTitle",
1350	"pykotaCopies",
1351	"pykotaOptions",
1352	"pykotaBillingCode",
1353	"pykotaPages",
1354	"pykotaMD5Sum",
1355	"pykotaPrecomputedJobSize",
1356	"pykotaPrecomputedJobPrice",
1357	"createTimestamp" ],
1358	base=self.info["jobbase"])
1359	if result :
1360	for (ident, fields) in result :
1361	job = StorageJob(self)
1362	job.ident = ident
1363	job.JobId = databaseToUnicode(fields.get("pykotaJobId")[0])
1364	job.PrinterPageCounter = int(fields.get("pykotaPrinterPageCounter", [0])[0] or 0)
1365	try :
1366	job.JobSize = int(fields.get("pykotaJobSize", [0])[0])
1367	except ValueError :
1368	job.JobSize = None
1369	try :
1370	job.JobPrice = float(fields.get("pykotaJobPrice", [0.0])[0])
1371	except ValueError :
1372	job.JobPrice = None
1373	job.JobAction = databaseToUnicode(fields.get("pykotaAction", [""])[0])
1374	job.JobFileName = databaseToUnicode(fields.get("pykotaFileName", [""])[0])
1375	job.JobTitle = databaseToUnicode(fields.get("pykotaTitle", [""])[0])
1376	job.JobCopies = int(fields.get("pykotaCopies", [0])[0])
1377	job.JobOptions = databaseToUnicode(fields.get("pykotaOptions", [""])[0])
1378	job.JobHostName = databaseToUnicode(fields.get("pykotaHostName", [""])[0])
1379	job.JobSizeBytes = fields.get("pykotaJobSizeBytes", [0L])[0]
1380	job.JobBillingCode = databaseToUnicode(fields.get("pykotaBillingCode", [None])[0])
1381	job.JobMD5Sum = databaseToUnicode(fields.get("pykotaMD5Sum", [None])[0])
1382	job.JobPages = fields.get("pykotaPages", [""])[0]
1383	try :
1384	job.PrecomputedJobSize = int(fields.get("pykotaPrecomputedJobSize", [0])[0])
1385	except ValueError :
1386	job.PrecomputedJobSize = None
1387	try :
1388	job.PrecomputedJobPrice = float(fields.get("pykotaPrecomputedJobPrice", [0.0])[0])
1389	except ValueError :
1390	job.PrecomputedJobPrice = None
1391	if job.JobTitle == job.JobFileName == job.JobOptions == u"hidden" :
1392	(job.JobTitle, job.JobFileName, job.JobOptions) = (_("Hidden because of privacy concerns"),) * 3
1393	date = fields.get("createTimestamp", ["19700101000000Z"])[0] # It's in UTC !
1394	mxtime = DateTime.strptime(date[:14], "%Y%m%d%H%M%S").localtime()
1395	job.JobDate = mxtime.strftime("%Y-%m-%d %H:%M:%S")
1396	if ((start is None) and (end is None)) or \
1397	((start is None) and (job.JobDate <= end)) or \
1398	((end is None) and (job.JobDate >= start)) or \
1399	((job.JobDate >= start) and (job.JobDate <= end)) :
1400	job.UserName = databaseToUnicode(fields.get("pykotaUserName")[0])
1401	job.PrinterName = databaseToUnicode(fields.get("pykotaPrinterName")[0])
1402	job.Exists = True
1403	jobs.append(job)
1404	jobs.sort(lambda x, y : cmp(y.JobDate, x.JobDate))
1405	if limit :
1406	jobs = jobs[:int(limit)]
1407	return jobs
1408
1409	def deleteUser(self, user) :
1410	"""Completely deletes an user from the Quota Storage."""
1411	uname = unicodeToDatabase(user.Name)
1412	todelete = []
1413	result = self.doSearch("(&(objectClass=pykotaJob)(pykotaUserName=%s))" % uname, base=self.info["jobbase"])
1414	for (ident, fields) in result :
1415	todelete.append(ident)
1416	if self.info["userquotabase"].lower() == "user" :
1417	base = self.info["userbase"]
1418	else :
1419	base = self.info["userquotabase"]
1420	result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaUserName=%s))" % uname, \
1421	["pykotaPrinterName", "pykotaUserName"], \
1422	base=base)
1423	for (ident, fields) in result :
1424	# ensure the user print quota entry will be deleted
1425	todelete.append(ident)
1426
1427	# if last job of current printer was printed by the user
1428	# to delete, we also need to delete the printer's last job entry.
1429	printer = self.getPrinter(databaseToUnicode(fields["pykotaPrinterName"][0]))
1430	if printer.LastJob.UserName == user.Name :
1431	todelete.append(printer.LastJob.lastjobident)
1432
1433	for ident in todelete :
1434	self.doDelete(ident)
1435
1436	result = self.doSearch("objectClass=pykotaAccount", None, base=user.ident, scope=ldap.SCOPE_BASE)
1437	if result :
1438	fields = result[0][1]
1439	for k in fields.keys() :
1440	if k.startswith("pykota") :
1441	del fields[k]
1442	elif k.lower() == "objectclass" :
1443	todelete = []
1444	for i in range(len(fields[k])) :
1445	if fields[k][i].startswith("pykota") :
1446	todelete.append(i)
1447	todelete.sort()
1448	todelete.reverse()
1449	for i in todelete :
1450	del fields[k][i]
1451	if fields.get("objectClass") or fields.get("objectclass") :
1452	self.doModify(user.ident, fields, ignoreold=0)
1453	else :
1454	self.doDelete(user.ident)
1455	result = self.doSearch("(&(objectClass=pykotaAccountBalance)(pykotaUserName=%s))" % \
1456	uname, \
1457	["pykotaUserName"], \
1458	base=self.info["balancebase"])
1459	for (ident, fields) in result :
1460	self.doDelete(ident)
1461
1462	def deleteGroup(self, group) :
1463	"""Completely deletes a group from the Quota Storage."""
1464	gname = unicodeToDatabase(group.Name)
1465	if self.info["groupquotabase"].lower() == "group" :
1466	base = self.info["groupbase"]
1467	else :
1468	base = self.info["groupquotabase"]
1469	result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaGroupName=%s))" % \
1470	gname, \
1471	["pykotaGroupName"], \
1472	base=base)
1473	for (ident, fields) in result :
1474	self.doDelete(ident)
1475	result = self.doSearch("objectClass=pykotaGroup", None, base=group.ident, scope=ldap.SCOPE_BASE)
1476	if result :
1477	fields = result[0][1]
1478	for k in fields.keys() :
1479	if k.startswith("pykota") :
1480	del fields[k]
1481	elif k.lower() == "objectclass" :
1482	todelete = []
1483	for i in range(len(fields[k])) :
1484	if fields[k][i].startswith("pykota") :
1485	todelete.append(i)
1486	todelete.sort()
1487	todelete.reverse()
1488	for i in todelete :
1489	del fields[k][i]
1490	if fields.get("objectClass") or fields.get("objectclass") :
1491	self.doModify(group.ident, fields, ignoreold=0)
1492	else :
1493	self.doDelete(group.ident)
1494
1495	def deleteManyBillingCodes(self, billingcodes) :
1496	"""Deletes many billing codes."""
1497	for bcode in billingcodes :
1498	bcode.delete()
1499
1500	def deleteManyUsers(self, users) :
1501	"""Deletes many users."""
1502	for user in users :
1503	user.delete()
1504
1505	def deleteManyGroups(self, groups) :
1506	"""Deletes many groups."""
1507	for group in groups :
1508	group.delete()
1509
1510	def deleteManyPrinters(self, printers) :
1511	"""Deletes many printers."""
1512	for printer in printers :
1513	printer.delete()
1514
1515	def deleteManyUserPQuotas(self, printers, users) :
1516	"""Deletes many user print quota entries."""
1517	# TODO : grab all with a single (possibly VERY huge) filter if possible (might depend on the LDAP server !)
1518	for printer in printers :
1519	for user in users :
1520	upq = self.getUserPQuota(user, printer)
1521	if upq.Exists :
1522	upq.delete()
1523
1524	def deleteManyGroupPQuotas(self, printers, groups) :
1525	"""Deletes many group print quota entries."""
1526	# TODO : grab all with a single (possibly VERY huge) filter if possible (might depend on the LDAP server !)
1527	for printer in printers :
1528	for group in groups :
1529	gpq = self.getGroupPQuota(group, printer)
1530	if gpq.Exists :
1531	gpq.delete()
1532
1533	def deleteUserPQuota(self, upquota) :
1534	"""Completely deletes an user print quota entry from the database."""
1535	uname = unicodeToDatabase(upquota.User.Name)
1536	pname = unicodeToDatabase(upquota.Printer.Name)
1537	result = self.doSearch("(&(objectClass=pykotaJob)(pykotaUserName=%s)(pykotaPrinterName=%s))" \
1538	% (uname, pname), \
1539	base=self.info["jobbase"])
1540	for (ident, fields) in result :
1541	self.doDelete(ident)
1542	if upquota.Printer.LastJob.UserName == upquota.User.Name :
1543	self.doDelete(upquota.Printer.LastJob.lastjobident)
1544	self.doDelete(upquota.ident)
1545
1546	def deleteGroupPQuota(self, gpquota) :
1547	"""Completely deletes a group print quota entry from the database."""
1548	self.doDelete(gpquota.ident)
1549
1550	def deletePrinter(self, printer) :
1551	"""Completely deletes a printer from the Quota Storage."""
1552	pname = unicodeToDatabase(printer.Name)
1553	result = self.doSearch("(&(objectClass=pykotaLastJob)(pykotaPrinterName=%s))" % pname, base=self.info["lastjobbase"])
1554	for (ident, fields) in result :
1555	self.doDelete(ident)
1556	result = self.doSearch("(&(objectClass=pykotaJob)(pykotaPrinterName=%s))" % pname, base=self.info["jobbase"])
1557	for (ident, fields) in result :
1558	self.doDelete(ident)
1559	if self.info["groupquotabase"].lower() == "group" :
1560	base = self.info["groupbase"]
1561	else :
1562	base = self.info["groupquotabase"]
1563	result = self.doSearch("(&(objectClass=pykotaGroupPQuota)(pykotaPrinterName=%s))" % pname, base=base)
1564	for (ident, fields) in result :
1565	self.doDelete(ident)
1566	if self.info["userquotabase"].lower() == "user" :
1567	base = self.info["userbase"]
1568	else :
1569	base = self.info["userquotabase"]
1570	result = self.doSearch("(&(objectClass=pykotaUserPQuota)(pykotaPrinterName=%s))" % pname, base=base)
1571	for (ident, fields) in result :
1572	self.doDelete(ident)
1573	for parent in self.getParentPrinters(printer) :
1574	try :
1575	parent.uniqueMember.remove(printer.ident)
1576	except ValueError :
1577	pass
1578	else :
1579	fields = {
1580	"uniqueMember" : parent.uniqueMember,
1581	}
1582	self.doModify(parent.ident, fields)
1583	self.doDelete(printer.ident)
1584
1585	def deleteBillingCode(self, code) :
1586	"""Deletes a billing code from the Quota Storage (no entries are deleted from the history)"""
1587	self.doDelete(code.ident)
1588
1589	def sortRecords(self, fields, records, default, ordering) :
1590	"""Sort records based on list of fields prefixed with '+' (ASC) or '-' (DESC)."""
1591	fieldindexes = {}
1592	for i in range(len(fields)) :
1593	fieldindexes[fields[i]] = i
1594	if not ordering :
1595	ordering = default
1596	orderby = []
1597	for orderkey in ordering :
1598	# Create ordering hints, ignoring unknown fields
1599	if orderkey.startswith("-") :
1600	index = fieldindexes.get(orderkey[1:])
1601	if index is not None :
1602	orderby.append((-1, index))
1603	elif orderkey.startswith("+") :
1604	index = fieldindexes.get(orderkey[1:])
1605	if index is not None :
1606	orderby.append((+1, index))
1607	else :
1608	index = fieldindexes.get(orderkey)
1609	if index is not None :
1610	orderby.append((+1, index))
1611
1612	def compare(x, y, orderby=orderby) :
1613	"""Compares two records."""
1614	i = 0
1615	nbkeys = len(orderby)
1616	while i < nbkeys :
1617	(sign, index) = orderby[i]
1618	result = cmp(x[i], y[i])
1619	if not result :
1620	i += 1
1621	else :
1622	return sign * result
1623	return 0 # identical keys
1624
1625	records.sort(compare)
1626	return records
1627
1628	def extractPrinters(self, extractonly={}, ordering=[]) :
1629	"""Extracts all printer records."""
1630	pname = extractonly.get("printername")
1631	entries = [p for p in [self.getPrinter(name) for name in self.getAllPrintersNames(pname)] if p.Exists]
1632	if entries :
1633	fields = ("dn", "printername", "priceperpage", "priceperjob", "description", "maxjobsize", "passthrough")
1634	result = []
1635	for entry in entries :
1636	if entry.PassThrough in (1, "1", "t", "true", "T", "TRUE", "True") :
1637	passthrough = "t"
1638	else :
1639	passthrough = "f"
1640	result.append((entry.ident, entry.Name, entry.PricePerPage, entry.PricePerJob, entry.Description, entry.MaxJobSize, passthrough))
1641	return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
1642
1643	def extractUsers(self, extractonly={}, ordering=[]) :
1644	"""Extracts all user records."""
1645	uname = extractonly.get("username")
1646	entries = [u for u in [self.getUser(name) for name in self.getAllUsersNames(uname)] if u.Exists]
1647	if entries :
1648	fields = ("dn", "username", "balance", "lifetimepaid", "limitby", "email", "description", "overcharge")
1649	result = []
1650	for entry in entries :
1651	result.append((entry.ident, entry.Name, entry.AccountBalance, entry.LifeTimePaid, entry.LimitBy, entry.Email, entry.Description, entry.OverCharge))
1652	return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
1653
1654	def extractBillingcodes(self, extractonly={}, ordering=[]) :
1655	"""Extracts all billing codes records."""
1656	billingcode = extractonly.get("billingcode")
1657	entries = [b for b in [self.getBillingCode(label) for label in self.getAllBillingCodes(billingcode)] if b.Exists]
1658	if entries :
1659	fields = ("dn", "billingcode", "balance", "pagecounter", "description")
1660	result = []
1661	for entry in entries :
1662	result.append((entry.ident, entry.BillingCode, entry.Balance, entry.PageCounter, entry.Description))
1663	return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
1664
1665	def extractGroups(self, extractonly={}, ordering=[]) :
1666	"""Extracts all group records."""
1667	gname = extractonly.get("groupname")
1668	entries = [g for g in [self.getGroup(name) for name in self.getAllGroupsNames(gname)] if g.Exists]
1669	if entries :
1670	fields = ("dn", "groupname", "limitby", "balance", "lifetimepaid", "description")
1671	result = []
1672	for entry in entries :
1673	result.append((entry.ident, entry.Name, entry.LimitBy, entry.AccountBalance, entry.LifeTimePaid, entry.Description))
1674	return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
1675
1676	def extractPayments(self, extractonly={}, ordering=[]) :
1677	"""Extracts all payment records."""
1678	startdate = extractonly.get("start")
1679	enddate = extractonly.get("end")
1680	(startdate, enddate) = self.cleanDates(startdate, enddate)
1681	uname = extractonly.get("username")
1682	entries = [u for u in [self.getUser(name) for name in self.getAllUsersNames(uname)] if u.Exists]
1683	if entries :
1684	fields = ("username", "amount", "date", "description")
1685	result = []
1686	for entry in entries :
1687	for (date, amount, description) in entry.Payments :
1688	if ((startdate is None) and (enddate is None)) or \
1689	((startdate is None) and (date <= enddate)) or \
1690	((enddate is None) and (date >= startdate)) or \
1691	((date >= startdate) and (date <= enddate)) :
1692	result.append((entry.Name, amount, date, description))
1693	return [fields] + self.sortRecords(fields, result, ["+date"], ordering)
1694
1695	def extractUpquotas(self, extractonly={}, ordering=[]) :
1696	"""Extracts all userpquota records."""
1697	pname = extractonly.get("printername")
1698	entries = [p for p in [self.getPrinter(name) for name in self.getAllPrintersNames(pname)] if p.Exists]
1699	if entries :
1700	fields = ("username", "printername", "dn", "userdn", "printerdn", "lifepagecounter", "pagecounter", "softlimit", "hardlimit", "datelimit")
1701	result = []
1702	uname = extractonly.get("username")
1703	for entry in entries :
1704	for (user, userpquota) in self.getPrinterUsersAndQuotas(entry, names=[uname or "*"]) :
1705	result.append((user.Name, entry.Name, userpquota.ident, user.ident, entry.ident, userpquota.LifePageCounter, userpquota.PageCounter, userpquota.SoftLimit, userpquota.HardLimit, userpquota.DateLimit))
1706	return [fields] + self.sortRecords(fields, result, ["+userdn"], ordering)
1707
1708	def extractGpquotas(self, extractonly={}, ordering=[]) :
1709	"""Extracts all grouppquota records."""
1710	pname = extractonly.get("printername")
1711	entries = [p for p in [self.getPrinter(name) for name in self.getAllPrintersNames(pname)] if p.Exists]
1712	if entries :
1713	fields = ("groupname", "printername", "dn", "groupdn", "printerdn", "lifepagecounter", "pagecounter", "softlimit", "hardlimit", "datelimit")
1714	result = []
1715	gname = extractonly.get("groupname")
1716	for entry in entries :
1717	for (group, grouppquota) in self.getPrinterGroupsAndQuotas(entry, names=[gname or "*"]) :
1718	result.append((group.Name, entry.Name, grouppquota.ident, group.ident, entry.ident, grouppquota.LifePageCounter, grouppquota.PageCounter, grouppquota.SoftLimit, grouppquota.HardLimit, grouppquota.DateLimit))
1719	return [fields] + self.sortRecords(fields, result, ["+groupdn"], ordering)
1720
1721	def extractUmembers(self, extractonly={}, ordering=[]) :
1722	"""Extracts all user groups members."""
1723	gname = extractonly.get("groupname")
1724	entries = [g for g in [self.getGroup(name) for name in self.getAllGroupsNames(gname)] if g.Exists]
1725	if entries :
1726	fields = ("groupname", "username", "groupdn", "userdn")
1727	result = []
1728	uname = extractonly.get("username")
1729	for entry in entries :
1730	for member in entry.Members :
1731	if (uname is None) or (member.Name == uname) :
1732	result.append((entry.Name, member.Name, entry.ident, member.ident))
1733	return [fields] + self.sortRecords(fields, result, ["+groupdn", "+userdn"], ordering)
1734
1735	def extractPmembers(self, extractonly={}, ordering=[]) :
1736	"""Extracts all printer groups members."""
1737	pname = extractonly.get("printername")
1738	entries = [p for p in [self.getPrinter(name) for name in self.getAllPrintersNames(pname)] if p.Exists]
1739	if entries :
1740	fields = ("pgroupname", "printername", "pgroupdn", "printerdn")
1741	result = []
1742	pgname = extractonly.get("pgroupname")
1743	for entry in entries :
1744	for parent in self.getParentPrinters(entry) :
1745	if (pgname is None) or (parent.Name == pgname) :
1746	result.append((parent.Name, entry.Name, parent.ident, entry.ident))
1747	return [fields] + self.sortRecords(fields, result, ["+pgroupdn", "+printerdn"], ordering)
1748
1749	def extractHistory(self, extractonly={}, ordering=[]) :
1750	"""Extracts all jobhistory records."""
1751	uname = extractonly.get("username")
1752	if uname :
1753	user = self.getUser(uname)
1754	else :
1755	user = None
1756	pname = extractonly.get("printername")
1757	if pname :
1758	printer = self.getPrinter(pname)
1759	else :
1760	printer = None
1761	startdate = extractonly.get("start")
1762	enddate = extractonly.get("end")
1763	(startdate, enddate) = self.cleanDates(startdate, enddate)
1764	entries = self.retrieveHistory(user, printer, hostname=extractonly.get("hostname"), billingcode=extractonly.get("billingcode"), jobid=extractonly.get("jobid"), limit=None, start=startdate, end=enddate)
1765	if entries :
1766	fields = ("username", "printername", "dn", "jobid", "pagecounter", "jobsize", "action", "jobdate", "filename", "title", "copies", "options", "jobprice", "hostname", "jobsizebytes", "md5sum", "pages", "billingcode", "precomputedjobsize", "precomputedjobprice")
1767	result = []
1768	for entry in entries :
1769	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))
1770	return [fields] + self.sortRecords(fields, result, ["+dn"], ordering)
1771
1772	def getBillingCodeFromBackend(self, label) :
1773	"""Extracts billing code information given its label : returns first matching billing code."""
1774	code = StorageBillingCode(self, label)
1775	ulabel = unicodeToDatabase(label)
1776	result = self.doSearch("(&(objectClass=pykotaBilling)(pykotaBillingCode=%s))" % \
1777	ulabel, \
1778	["pykotaBillingCode", "pykotaBalance", "pykotaPageCounter", "description"], \
1779	base=self.info["billingcodebase"])
1780	if result :
1781	fields = result[0][1] # take only first matching code, ignore the rest
1782	code.ident = result[0][0]
1783	code.BillingCode = databaseToUnicode(fields.get("pykotaBillingCode", [ulabel])[0])
1784	code.PageCounter = int(fields.get("pykotaPageCounter", [0])[0])
1785	code.Balance = float(fields.get("pykotaBalance", [0.0])[0])
1786	code.Description = databaseToUnicode(fields.get("description", [""])[0])
1787	code.Exists = True
1788	return code
1789
1790	def addBillingCode(self, bcode) :
1791	"""Adds a billing code to the quota storage, returns it."""
1792	oldentry = self.getBillingCode(bcode.BillingCode)
1793	if oldentry.Exists :
1794	return oldentry # we return the existing entry
1795	uuid = self.genUUID()
1796	dn = "cn=%s,%s" % (uuid, self.info["billingcodebase"])
1797	fields = { "objectClass" : ["pykotaObject", "pykotaBilling"],
1798	"cn" : uuid,
1799	"pykotaBillingCode" : unicodeToDatabase(bcode.BillingCode),
1800	"pykotaPageCounter" : str(bcode.PageCounter or 0),
1801	"pykotaBalance" : str(bcode.Balance or 0.0),
1802	"description" : unicodeToDatabase(bcode.Description or ""),
1803	}
1804	self.doAdd(dn, fields)
1805	bcode.isDirty = False
1806	return None # the entry created doesn't need further modification
1807
1808	def saveBillingCode(self, bcode) :
1809	"""Sets the new description for a billing code."""
1810	fields = {
1811	"description" : unicodeToDatabase(bcode.Description or ""),
1812	"pykotaPageCounter" : str(bcode.PageCounter or 0),
1813	"pykotaBalance" : str(bcode.Balance or 0.0),
1814	}
1815	self.doModify(bcode.ident, fields)
1816
1817	def getMatchingBillingCodes(self, billingcodepattern) :
1818	"""Returns the list of all billing codes which match a certain pattern."""
1819	codes = []
1820	result = self.doSearch("objectClass=pykotaBilling", \
1821	["pykotaBillingCode", "description", "pykotaPageCounter", "pykotaBalance"], \
1822	base=self.info["billingcodebase"])
1823	if result :
1824	patterns = billingcodepattern.split(",")
1825	try :
1826	patdict = {}.fromkeys(patterns)
1827	except AttributeError :
1828	# Python v2.2 or earlier
1829	patdict = {}
1830	for p in patterns :
1831	patdict[p] = None
1832	for (codeid, fields) in result :
1833	codename = databaseToUnicode(fields.get("pykotaBillingCode", [""])[0])
1834	if patdict.has_key(codename) or self.tool.matchString(codename, patterns) :
1835	code = StorageBillingCode(self, codename)
1836	code.ident = codeid
1837	code.PageCounter = int(fields.get("pykotaPageCounter", [0])[0])
1838	code.Balance = float(fields.get("pykotaBalance", [0.0])[0])
1839	code.Description = databaseToUnicode(fields.get("description", [""])[0])
1840	code.Exists = True
1841	codes.append(code)
1842	self.cacheEntry("BILLINGCODES", code.BillingCode, code)
1843	return codes
1844
1845	def consumeBillingCode(self, bcode, pagecounter, balance) :
1846	"""Consumes from a billing code."""
1847	fields = {
1848	"pykotaBalance" : { "operator" : "-", "value" : balance, "convert" : float },
1849	"pykotaPageCounter" : { "operator" : "+", "value" : pagecounter, "convert" : int },
1850	}
1851	return self.doModify(bcode.ident, fields)
1852
1853	def refundJob(self, jobident) :
1854	"""Marks a job as refunded in the history."""
1855	fields = {
1856	"pykotaAction" : "REFUND",
1857	}
1858	self.doModify(jobident, fields)
1859
1860	def storageUserFromRecord(self, username, record) :
1861	"""Returns a StorageUser instance from a database record."""
1862	user = StorageUser(self, username)
1863	user.Exists = True
1864	return user
1865
1866	def storageGroupFromRecord(self, groupname, record) :
1867	"""Returns a StorageGroup instance from a database record."""
1868	group = StorageGroup(self, groupname)
1869	group.Exists = True
1870	return group
1871
1872	def storagePrinterFromRecord(self, printername, record) :
1873	"""Returns a StoragePrinter instance from a database record."""
1874	printer = StoragePrinter(self, printername)
1875	printer.Exists = True
1876	return printer
1877
1878	def setJobAttributesFromRecord(self, job, record) :
1879	"""Sets the attributes of a job from a database record."""
1880	job.Exists = True
1881
1882	def storageJobFromRecord(self, record) :
1883	"""Returns a StorageJob instance from a database record."""
1884	job = StorageJob(self)
1885	self.setJobAttributesFromRecord(job, record)
1886	return job
1887
1888	def storageLastJobFromRecord(self, printer, record) :
1889	"""Returns a StorageLastJob instance from a database record."""
1890	lastjob = StorageLastJob(self, printer)
1891	self.setJobAttributesFromRecord(lastjob, record)
1892	return lastjob
1893
1894	def storageUserPQuotaFromRecord(self, user, printer, record) :
1895	"""Returns a StorageUserPQuota instance from a database record."""
1896	userpquota = StorageUserPQuota(self, user, printer)
1897	userpquota.Exists = True
1898	return userpquota
1899
1900	def storageGroupPQuotaFromRecord(self, group, printer, record) :
1901	"""Returns a StorageGroupPQuota instance from a database record."""
1902	grouppquota = StorageGroupPQuota(self, group, printer)
1903	grouppquota.Exists = True
1904	return grouppquota
1905
1906	def storageBillingCodeFromRecord(self, billingcode, record) :
1907	"""Returns a StorageBillingCode instance from a database record."""
1908	code = StorageBillingCode(self, billingcode)
1909	code.Exists = True
1910	return code

Note: See TracBrowser for help on using the browser.

Context Navigation

root / pykota / trunk / pykota / storages / ldapstorage.py @ 3419

Download in other formats: