1: from OFS.Folder import Folder
2: from Acquisition import Implicit
3: from Globals import DTMLFile,package_home,Persistent
4: import urllib
5: import re
6: import string
7: import sys
8: #from pyPgSQL import libpq
9: from AccessControl import getSecurityManager
10: from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
11: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
12:
13: from Products.ZSQLMethods.SQL import SQLConnectionIDs
14: from xml.sax.saxutils import escape
15: from types import *
16: import Shared.DC.ZRDB.DA
17: import zLOG
18: import os.path
19: import os
20: import copy
21: import unicodedata
22:
23: from OFS.SimpleItem import SimpleItem
24:
25: def getTextFromNode(nodename):
26: """get the cdata content of a node"""
27: if nodename is None:
28: return ""
29: nodelist=nodename.childNodes
30: rc = ""
31: for node in nodelist:
32: if node.nodeType == node.TEXT_NODE:
33: rc = rc + node.data
34: return rc
35:
36: def analyseIntSearch(word):
37: #analyse integer searches
38:
39: splitted=word.split("-")
40:
41: if len(splitted)==1:
42: return "="+splitted[0]
43:
44: if splitted[0]=="":
45: return "< "+splitted[1]
46:
47: if splitted[1]=='':
48: return "> "+splitted[0]
49: else:
50: return "BETWEEN "+splitted[0]+" AND "+splitted[1]
51:
52:
53:
54: def sql_quote(v):
55: # quote dictionary
56: quote_dict = {"\'": "''", "\\": "\\\\"}
57: for dkey in quote_dict.keys():
58: if string.find(v, dkey) >= 0:
59: v=string.join(string.split(v,dkey),quote_dict[dkey])
60: return "'%s'" % v
61:
62: def showSQLConnectionIDs(self):
63: return SQLConnectionIDs(self)
64:
65: class ZSQLIndex(SimpleItem):
66: """index"""
67: meta_type="ZSQLIndex"
68:
69: def __init__(self,index,id,table=''):
70: self.index=[x for x in index]
71: self.id=id
72: self.table=table
73:
74: def setIndex(self,index):
75: self.index=[x for x in index]
76:
77: def getIndex(self):
78: return self.index
79:
80: class ZSQLExtendFolder(Folder,Persistent, Implicit):
81: """Folder"""
82: meta_type="ZSQLExtendFolder"
83:
84: def ZSQLQuote(self,str):
85: """quote str for sql"""
86: return sql_quote(str)
87:
88:
89: def normalizeField(self,table,fieldname, newFieldName=None,mode="alter", RESPONSE=None):
90: """normalize a field"""
91: import unicodedata
92:
93: if not newFieldName:
94: newFieldName=fieldname+"_normal"
95:
96: def normal(str):
97: if str:
98: return unicodedata.normalize('NFKD', str.decode('utf-8')).encode('ASCII', 'ignore')
99: else:
100: return ""
101: if mode=="create": # create the field
102: qstr="""alter table %s add %s %s"""
103: self.ZSQLSimpleSearch(qstr%(table,newFieldName,'text'))
104:
105: qstr="select oid,%s from %s"%(fieldname,table)
106: for result in self.ZSQLSimpleSearch(qstr):
107: qstr="update %s set %s = %s where oid = %s"
108:
109: self.ZSQLSimpleSearch(qstr%(table,newFieldName,self.ZSQLQuote(normal(getattr(result,fieldname))),result.oid))
110:
111: def importAccessModell(self,configFileName,RESPONSE=None):
112: """import tables from access
113: @param configFileName: xml-configfile
114: """
115: from Ft.Xml import Parse
116: fh=file(configFileName)
117:
118: doc=Parse(fh)
119:
120: x=doc.xpath("//pathToFolder/@path")
121:
122:
123: if not (len(x)==1): # tag ist nich eineindeutig
124: return False
125:
126: pathToFolder=x[0].value
127:
128: for db in doc.xpath("//db"):
129:
130: containers=db.xpath("./@container")
131: identifiers=db.xpath("./@identify")
132:
133:
134: if not (len(containers)==1):
135: return False
136: else:
137: container=containers[0].value
138:
139: if not (len(identifiers)==1):
140: identifier=None
141: else:
142: identifier=identifiers[0].value
143:
144: self.xsdToTable(container.lower(),container,modus="drop",filename=os.path.join(pathToFolder,container.lower()+".xsd"))
145: self.importXMLFileAccess(container.lower(),container,filename=os.path.join(pathToFolder,container.lower()+".xml"),identify=identifier)
146:
147: return "<html><body>DONE</body></html>"
148:
149: def xsdToTable(self,table,elementNameForTable,modus="update", filename=None,data=None,RESPONSE=None):
150: """reads an xsd file an creates the columns of a table out of its structure
151: @param table: name of the table the xml shall be imported into
152: @param elementNameForTable: must be a element of type complex type. the element of the sequence in the complex type
153: define the columns of the table >table<
154: @param data (optional): data to be imported
155:
156: @param filename (optional) or filename
157: @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
158: @param RESPONSE: (optional)
159:
160: """
161: #from xml.dom.minidom import parseString,parse
162:
163: from Ft.Xml import Parse
164: zLOG.LOG("import xsd",zLOG.INFO,"called")
165: #fh=file("/tmp/fmpxml.xml")
166: import bz2
167: import base64
168:
169:
170: ret=""
171: if data:
172: data=bz2.decompress(base64.decodestring(data))
173:
174: #zLOG.LOG("import xsd",zLOG.INFO,"received file")
175: doc=Parse(data)
176: #zLOG.LOG("import xsd",zLOG.INFO,"parsed file")
177:
178: elif filename:
179: fh=file(filename)
180: txt=fh.read()
181:
182: doc=Parse(txt)
183: #zLOG.LOG("import xsd",zLOG.INFO,"parsed file")
184:
185:
186: Nss={'xsd':'http://www.w3.org/2001/XMLSchema'}
187: definingSequence=doc.xpath("""//xsd:element[@name='%s']/xsd:complexType/xsd:sequence/xsd:element/@name"""%elementNameForTable,explicitNss=Nss)
188:
189: fieldNames=[x.value for x in definingSequence]
190:
191:
192:
193: #check if table exists
194:
195: qstr="""select relname from pg_class where relname = '%s'"""%table
196: if not(self.ZSQLSimpleSearch(qstr)) or (len (self.ZSQLSimpleSearch(qstr))<1): # if not the create the table
197: columns=[]
198: create=True
199: else:
200: create=False
201:
202: zLOG.LOG("update xsd: fieldnames",zLOG.INFO,repr(fieldNames))
203: qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """
204: columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
205:
206:
207: if (modus=="drop") and (not create): #table shall be deleted, therefore it should exist (not create)
208: print "drop"
209: qstr="""DROP TABLE %s """
210: self.ZSQLSimpleSearch(qstr%table)
211: columns=[]
212: create=True
213:
214: for fieldName in fieldNames:
215: if type(fieldName) is UnicodeType:
216: fieldName=fieldName.encode('utf-8')
217: zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))
218: if fieldName.lower() not in columns:
219:
220: if create:# table does not exist therefore create with one column
221: qstr="""create table %s (%s %s)"""
222: create=False
223: else:# otherwise add the field
224: qstr="""alter table %s add %s %s"""
225:
226: self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
227: zLOG.LOG("update xsd: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))
228:
229:
230: def importXMLFileAccess(self,table,container,data=None,identify=None,filename=None,RESPONSE=None):
231: '''
232: Import XML file in access format into the table
233: @param table: name of the table the xml shall be imported into
234: @param containerTagName: XML-Tag which describes a dataset
235: @param data: data to be imported
236: @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
237: @param RESPONSE: (optional)
238: '''
239: from xml.dom.pulldom import parseString,parse
240:
241: zLOG.LOG("import xml",zLOG.INFO,"called")
242: #fh=file("/tmp/fmpxml.xml")
243: import bz2
244: import base64
245:
246: ret=""
247: if data:
248: data=bz2.decompress(base64.decodestring(data))
249:
250: zLOG.LOG("import xml",zLOG.INFO,"received file")
251: doc=parseString(data)
252: zLOG.LOG("import xml",zLOG.INFO,"parsed file")
253:
254: elif filename:
255: fh=file(filename)
256: doc=parse(fh)
257: zLOG.LOG("import xml",zLOG.INFO,"parsed file")
258: while 1:
259: node=doc.getEvent()
260:
261: if node is None:
262: break;
263: else:
264: if node[1].nodeName.lower()==container.lower(): # make everything case insensitive
265: doc.expandNode(node[1])
266:
267: dataSet={}
268: for col in node[1].childNodes:
269: if col.nodeType is col.ELEMENT_NODE:
270: data=col.nodeName
271: dataSet[data]=getTextFromNode(col)
272:
273: update=False
274:
275: if identify:
276:
277: field=dataSet[identify]
278:
279: searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
280: zLOG.LOG("import xml",zLOG.INFO,searchStr)
281: search=self.ZSQLSimpleSearch(searchStr)
282: if search:
283: update=True
284:
285: if update:
286: tmp=[]
287: for fieldName in dataSet.keys():
288: tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
289: setStr=",".join(tmp)
290:
291: field=dataSet[identify]
292:
293: queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
294: zLOG.LOG("update xml",zLOG.INFO,queryStr)
295: self.ZSQLSimpleSearch(queryStr)
296: ret+="ud: %s \n"%field
297: else:
298:
299:
300: fields=",".join(dataSet.keys())
301: values=",".join([""" %s """%self.ZSQLQuote(dataSet[x]) for x in dataSet.keys()])
302:
303:
304: queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
305: self.ZSQLSimpleSearch(queryStr)
306: zLOG.LOG("update xml",zLOG.INFO,queryStr)
307:
308:
309:
310:
311: return ret
312:
313:
314: def importXMLFile(self,table,data=None,identify=None,filename=None,RESPONSE=None):
315: #TODO: finish importXMLFile
316: '''
317: Import XML file into the table
318: @param table: name of the table the xml shall be imported into
319: @param containerTagName: XML-Tag which describes a dataset
320: @param file: xmlfile handle
321: @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
322: @param RESPONSE: (optional)
323: '''
324: from xml.dom.pulldom import parseString
325:
326: doc=parseString(file.read())
327: while 1:
328: node=doc.getEvent()
329:
330: if node is None:
331: break;
332: else:
333: if node[1].nodeName==containerTagName:
334: doc.expandNode(node[1])
335: cols=node[1].getElementsByTagName('COL')
336: dataSet=[]
337: for col in cols:
338: data=col.getElementsByTagName('DATA')
339: dataSet.append(getTextFromNode(data[0]))
340: update=False
341: if identify:
342:
343: nr=fieldNames.index(identify)
344: field=dataSet[nr]
345:
346: searchStr="""select %s from %s where %s = '%s'"""%(identify,table,identify,field)
347: zLOG.LOG("import xml",zLOG.INFO,searchStr)
348: search=self.ZSQLSimpleSearch(searchStr)
349: if search:
350: update=True
351:
352: if update:
353: tmp=[]
354: for fieldName in fieldNames:
355: tmp.append("""%s = %s"""%(fieldName,self.ZSQLQuote(dataSet[fieldNames.index(fieldName)])))
356: setStr=",".join(tmp)
357: nr=fieldNames.index(identify)
358: field=dataSet[nr]
359:
360: queryStr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,identify,field)
361: zLOG.LOG("update xml",zLOG.INFO,queryStr)
362: self.ZSQLSimpleSearch(queryStr)
363: ret+="ud: %s \n"%field
364: else:
365:
366:
367: fields=",".join(fieldNames)
368: values=",".join([""" %s """%self.ZSQLQuote(x) for x in dataSet])
369:
370:
371: queryStr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
372: self.ZSQLSimpleSearch(queryStr)
373: zLOG.LOG("update xml",zLOG.INFO,queryStr)
374: ret+="ad: %s \n"%field
375:
376: elif node[1].nodeName=="METADATA":
377: fieldNames=[]
378: doc.expandNode(node[1])
379:
380: names=node[1].getElementsByTagName('FIELD')
381:
382: for name in names:
383: fieldNames.append(name.getAttribute('NAME'))
384:
385: zLOG.LOG("update xml: fieldnames",zLOG.INFO,repr(fieldNames))
386: qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s' """
387: columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
388:
389: for fieldName in fieldNames:
390: zLOG.LOG("update xml: fieldname",zLOG.INFO,repr(fieldName))
391: if fieldName not in columns:
392: qstr="""alter table %s add %s %s"""
393: self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
394: zLOG.LOG("update xml: fieldname add",zLOG.INFO,qstr%(table,fieldName,'text'))
395: #fn=node[1].getAttribute("xml:id")
396: #nf=file("xtf/"+fn+".xtf",'w')
397: #nf.write("""<texts xmlns="http://emegir.info/xtf" xmlns:lem="http://emegir.info/lemma" >"""+node[1].toxml()+"</texts>")
398: #print "wrote: %s"%fn
399:
400:
401: def importXMLFileFMP(self,table,data=None,filename=None,update_fields=None,id_field=None,sync_mode=False,RESPONSE=None):
402: '''
403: Import FileMaker XML file (FMPXMLRESULT format) into the table.
404: @param table: name of the table the xml shall be imported into
405: @param data: xml data as bz2 string
406: @param filename: xmlfile filename
407: @param update_fields: (optional) list of fields to update; default is to create all fields
408: @param id_field: (optional) field which uniquely identifies an entry for updating purposes.
409: @param sync_mode: (optional) really synchronise, i.e. delete entries not in XML file
410: @param RESPONSE: (optional)
411: '''
412: from xml.dom.pulldom import parseString,parse
413: import transaction
414:
415: ret = ""
416:
417: if data:
418: data=bz2.decompress(base64.decodestring(data))
419: zLOG.LOG("fmpxml",zLOG.INFO,"received file")
420: doc=parseString(data)
421: zLOG.LOG("fmpxml",zLOG.INFO,"parsed file")
422:
423: elif filename:
424: fh=file(filename)
425: zLOG.LOG("fmpxml",zLOG.INFO,"reading file")
426: doc=parse(fh)
427: zLOG.LOG("fmpxml",zLOG.INFO,"parsed file")
428:
429: dbIDs = {}
430: rowcnt = 0
431:
432: if id_field is not None:
433: # prepare a list of ids for sync mode
434: qstr="select %s from %s"%(id_field,table)
435: for id in self.ZSQLSimpleSearch(qstr):
436: # value 0: not updated
437: dbIDs[id[0]] = 0;
438: rowcnt += 1
439:
440: zLOG.LOG("fmpxml",zLOG.INFO,"%d entries in DB to sync"%rowcnt)
441:
442: fieldNames = []
443: rowcnt = 0
444: id_val = ''
445:
446: while 1:
447: node=doc.getEvent()
448:
449: if node is None:
450: break;
451:
452: # METADATA tag defines number and names of fields in FMPXMLRESULT
453: if node[1].nodeName == 'METADATA':
454: doc.expandNode(node[1])
455:
456: names=node[1].getElementsByTagName('FIELD')
457:
458: for name in names:
459: fn = name.getAttribute('NAME')
460: fieldNames.append(fn)
461:
462: if update_fields is None:
463: # update all fields
464: update_fields = fieldNames
465:
466: zLOG.LOG("fmpxml fieldnames:",zLOG.INFO,repr(fieldNames))
467: # get list of fields in db table
468: qstr="""select attname from pg_attribute, pg_class where attrelid = pg_class.oid and relname = '%s'"""
469: columns=[x.attname for x in self.ZSQLSimpleSearch(qstr%table)]
470:
471: # adjust db table to fields in XML and fieldlist
472: for fieldName in fieldNames:
473: zLOG.LOG("fmpxml fieldname:",zLOG.INFO,repr(fieldName))
474: if (fieldName not in columns) and (fieldName in update_fields):
475: qstr="""alter table %s add %s %s"""
476: self.ZSQLSimpleSearch(qstr%(table,fieldName,'text'))
477: zLOG.LOG("fmpxml add field:",zLOG.INFO,qstr%(table,fieldName,'text'))
478:
479: # ROW tags (in RESULTSET tag) hold data
480: elif node[1].nodeName == 'ROW':
481: rowcnt += 1
482:
483: doc.expandNode(node[1])
484: cols=node[1].getElementsByTagName('COL')
485: dataSet={}
486: i = 0
487: # populate with data
488: for col in cols:
489: data=col.getElementsByTagName('DATA')
490: dataSet[fieldNames[i]] = getTextFromNode(data[0])
491: i += 1
492:
493: update=False
494:
495: # synchronize by id_field
496: if id_field:
497: id_val=dataSet[id_field]
498: if id_val in dbIDs:
499: dbIDs[id_val] += 1
500: update=True
501:
502: if update:
503: # update existing row (by id_field)
504: setvals=[]
505: for fieldName in update_fields:
506: setvals.append("%s = %s"%(fieldName,self.ZSQLQuote(dataSet[fieldName])))
507: setStr=string.join(setvals, ',')
508: id_val=dataSet[id_field]
509: qstr="""UPDATE %s SET %s WHERE %s = '%s' """%(table,setStr,id_field,id_val)
510: #zLOG.LOG("fmpxml update:",zLOG.INFO,queryStr)
511: self.ZSQLSimpleSearch(qstr)
512: ret+="up: %s \n"%id_val
513: else:
514: # create new row
515: fields=string.join(update_fields, ',')
516: values=string.join([" %s "%self.ZSQLQuote(dataSet[x]) for x in update_fields], ',')
517: qstr="""INSERT INTO %s (%s) VALUES (%s)"""%(table,fields,values)
518: self.ZSQLSimpleSearch(qstr)
519: #zLOG.LOG("fmpxml: insert",zLOG.INFO,queryStr)
520: ret+="ad: %s \n"%dataSet.get(id_field, rowcnt)
521:
522: #zLOG.LOG("fmpxml row:",zLOG.INFO,"%d (%s)"%(rowcnt,id_val))
523: if (rowcnt % 10) == 0:
524: zLOG.LOG("fmpxml row:",zLOG.INFO,"%d (%s)"%(rowcnt,id_val))
525: transaction.commit()
526:
527: transaction.commit()
528: if sync_mode:
529: # delete unmatched entries in db
530: for id in dbIDs.keys():
531: # find all not-updated fields
532: if dbIDs[id] == 0:
533: zLOG.LOG("fmpxml delete:",zLOG.INFO,id)
534: qstr = "DELETE FROM %s WHERE %s = '%s'"
535: self.ZSQLSimpleSearch(qstr%(table,id_field,id))
536:
537: elif dbIDs[id] > 1:
538: zLOG.LOG("fmpxml sync:",zLOG.INFO,"id used more than once?"+id)
539:
540: transaction.commit()
541:
542: return ret
543:
544: def generateIndex(self,field,index_name,table,RESPONSE=None):
545: """erzeuge index aus feld"""
546: index={}
547: founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))
548:
549: for found in founds:
550: tmp=getattr(found,field,None)
551: if tmp:
552: strings=tmp.split(" ")
553: for string in strings:
554: if index.get(string):
555: index[string].append(found.oid)
556: else:
557: index[string]=[found.oid]
558: RESPONSE.write(string+"\n")
559:
560: if not hasattr(self,index_name):
561: obj=ZSQLIndex(index,index_name,table)
562: self._setObject(index_name,obj)
563:
564: self._getOb(index_name).setIndex(index)
565:
566: def getIndex(self,index_name):
567: """getIndex"""
568: founds=self.ZopeFind(self,obj_ids=[index_name])
569:
570: return founds[0][1].getIndex()
571:
572:
573: def testneu(self):
574: """test"""
575: relStatement="""period like '%s%%'"""
576: statement="select * from cdli_cat"
577: wherePart="museum_no like 'VAT%'"
578: classes=['Uruk III','Uruk IV']
579: return self.searchRel(relStatement,statement,wherePart,classes)
580:
581: def URLquote(self,txt):
582: """urlquote"""
583: return urllib.quote(txt)
584:
585: def searchRel(self,relStatement,statement,wherePart,classes):
586: """suche relative haufigkeiten"""
587: ret={}
588: allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
589:
590: for oneclass in classes:
591: ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))
592:
593: return (ret,allRecords)
594:
595: def content_html(self):
596: """template fuer content"""
597:
598: try:
599: obj=getattr(self,"ZSQLBibliography_template")
600: return obj()
601: except:
602: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt'),content_type='text/html').__of__(self)
603: pt.content_type="text/html"
604:
605: return pt()
606:
607:
608: def getWeight(self):
609: """getLabe"""
610: try:
611: return self.weight
612: except:
613: return ""
614:
615: def getLabel(self):
616: """getLabe"""
617: try:
618: return self.label
619: except:
620: return ""
621:
622: def getDescription(self):
623: """getLabe"""
624: try:
625: return self.description
626: except:
627: return ""
628:
629: manage_options=Folder.manage_options+(
630: {'label':'Main Config','action':'changeZSQLExtendForm'},
631: )
632:
633: def changeZSQLExtendForm(self):
634: """change folder config"""
635: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLExtendForm.zpt')).__of__(self)
636: return pt()
637:
638:
639: def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
640: """change it"""
641: self.connection_id=connection_id
642: self.weight=weight
643: self.label=label
644: self.description=description
645:
646: if REQUEST is not None:
647: return self.manage_main(self, REQUEST)
648:
649: def formatAscii(self,str,url=None):
650: """ersetze ascii umbrueche durch <br>"""
651: #url=None
652: str=str.rstrip().lstrip()
653:
654: if url and str:
655:
656: retStr=""
657: words=str.split("\n")
658:
659: for word in words:
660: strUrl=url%word
661: #print "str",strUrl
662: retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
663: str=retStr
664: if str:
665: return re.sub(r"[\n]","<br/>",str)
666: else:
667: return ""
668:
669: def getSAttribute(self,obj,atribute,pref=''):
670: """get Attribute or emptystring"""
671:
672: #print "obj",obj
673: try:
674: return pref+getattr(obj,atribute)
675: except:
676: return ""
677:
678: def getS(self,str):
679: """make none to empty string"""
680: if str:
681: return str
682: else:
683: return ""
684:
685: def actualPath(self,url=None):
686: """path"""
687:
688: if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
689: host=self.REQUEST['HTTP_HOST']
690: else:
691: host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
692: if not url:
693: return "http://"+host+self.REQUEST['PATH_TRANSLATED']
694: else:
695: temp=self.REQUEST[url].split("/")
696: temp[2]=host
697: return string.join(temp,"/")
698:
699: def getRequest(self):
700: """request"""
701: return self.REQUEST
702:
703: def lowerEnd(self,path):
704: """oinly for demo"""
705: return os.path.splitext(path)[0]+".jpg"
706:
707: def ZSQLisEmpty(self,field):
708: """Teste ob Treffer leer"""
709: #print "field",field
710: if not field:
711: return 1
712: if field=="":
713: return 1
714: return 0
715:
716: def ZSQLsearchOptions(self,fieldname=""):
717: """return HTML Fragment with search options"""
718:
719: ret="""<select name="-op_%s">
720: <option value="bw">begins with</option> <!-- begins with / beginnt mit, "Wort*" -->
721: <option value="ew">ends with</option>
722: <option value="ct" selected>contains</option> <!-- contains / enthaellt, "Wort" -->
723: <option value="eq">equals</option> <!-- equals / ist, =Wort -->
724: </select>"""%fieldname
725: return ret
726:
727: def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
728: """generate select options from a cr seperated list"""
729: fields=listField.split("\n")
730: ret=""
731: for field in fields:
732: if checked and (field in checked.split("\n")):
733: ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
734: else:
735: ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
736: return ret
737:
738: def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):
739: """generate select options from a cr seperated list"""
740:
741: ret=""
742: if not results: return ""
743:
744: for result in results:
745: field=getattr(result,fieldnameResult)
746: if field:
747: if checked and (getattr(result,fieldnameResult) in checked.split("\n")):
748: ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
749: else:
750: ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
751: return ret
752:
753:
754: def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None,selected=None):
755: """generate select oprions form a cr seperated list"""
756: fields=listField.split("\n")
757: if size:
758: ret="""<select name="%s" %s size="%s" >
759: """%(fieldname,multiple,size)
760:
761: else:
762: ret="""<select name="%s" %s >
763: """%(fieldname,multiple)
764: if start:
765: if start==' ':
766: start=''
767: if not startValue:
768: startValue=start
769:
770: ret+="""<option value="%s" >%s</option>"""%(startValue,start)
771: for field in fields:
772: if selected and (field in selected.split("\n")):
773: ret+="""<option selected value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
774: else:
775: ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
776: ret+="""</select>"""
777: return ret
778:
779: def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect="",size=None,linelen=None,selected=None):
780: """generate select options form a search list
781: es wird
782: <select name=fieldname mutiple>
783: <option value=startValue>start</option>
784: <option value=result.fieldName>result.fieldValue</option>
785: erzeugt.
786:
787: @parameter fieldname: Name fuer name-wert im select-tag
788: @results results: Resultobject einer SQL-suche
789: @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.
790: @parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName
791: @start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
792: @startValue: gibt den entsprechenden Wert an.
793: """
794: if not valueName:
795: valueName=fieldName
796: if size:
797: ret="""<select name="%s" %s size="%s" %s>
798: """%(fieldname,multiple,size,additionalSelect)
799: else:
800: ret="""<select name="%s" %s %s>
801: """%(fieldname,multiple,additionalSelect)
802: if start:
803: if start==' ':
804: start=''
805:
806: if not startValue:
807: startValue=start
808:
809: ret+="""<option value="%s" >%s</option>"""%(startValue,start)
810: for result in results:
811: field=getattr(result,fieldName)
812: fieldValue=getattr(result,valueName)
813: if fieldValue:
814:
815: if not linelen:
816:
817:
818: if field == selected:
819:
820: ret+="""<option value="%s" selected>%s</option>"""%(field,fieldValue)
821: else:
822: ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
823:
824: else:
825: mist = """%s"""%(fieldValue)
826: if len(mist) > string.atoi(linelen):
827: mist = mist[:string.atoi(linelen)]
828: ret+="""<option value="%s">%s</option>"""%(field,mist)
829: ret+="""</select>"""
830: return ret
831:
832:
833: def ZSQLInlineSearchU(self,storename=None,args=None,**argv):
834: """one element if exists"""
835: qs=[]
836: if storename:
837: """store"""
838: storename=storename
839: else:
840: storename="foundCount"
841:
842: if args:
843: argTmp=args
844: else:
845: argTmp=argv
846:
847:
848: #print "INLINE:",argv
849: for a in argTmp.keys():
850: aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
851: qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
852: #return []
853: ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
854:
855: try:
856: return ret[0]
857: except:
858: return None
859:
860:
861: def ZSQLSequentialSearch(self,_fieldlist,_searchTerm,storename=None,args=None,**argv):
862: """get a list of tuples (fields,searchoptions,table) to search the searchTerm in, returns dictionary. """
863: #print "do search with:",_fieldlist,_searchTerm,storename,args,argv
864: ret={}
865: if args:
866: argTmp=args
867: else:
868: argTmp=argv
869:
870: for field in _fieldlist:
871:
872: argTmp2=copy.deepcopy(argTmp)
873: argTmp2[field[0]]=_searchTerm
874: argTmp2['_op_'+field[0]]=field[1]
875: argTmp2['_table']=field[2]
876:
877: ret[field[0]]=(self.ZSQLInlineSearch(storename=storename,args=argTmp2),field[3],field[4],field[5],field[6])
878:
879: return ret
880:
881:
882: def ZSQLInlineSearch(self,storename=None,args=None,**argv):
883: """inlinesearch"""
884:
885: qs=[]
886: if storename:
887: """store"""
888: else:
889: storename="foundCount"
890:
891:
892:
893: if args:
894: argTmp=args
895: else:
896: argTmp=argv
897:
898:
899: #print "INLINE:",argv
900: for a in argTmp.keys():
901: aFiltered=re.sub(r"^-","_",a) # beginning of a command should always be "_"
902: qs.append(aFiltered+"="+urllib.quote(str(argTmp[a])))
903:
904:
905: #return []
906:
907: return self.parseQueryString(string.join(qs,","),"_",storename=storename)
908:
909: def ZSQLInlineSearch2(self,query):
910: """inlinesearch"""
911: qs=[]
912:
913: #print "INLINE:",query
914: return self.ZSQLSimpleSearch(query)
915:
916:
917: def ZSQLResetConnection(self):
918: """reset the connectione"""
919: try:
920: self.getConnectionObj().manage_close_connection()
921: except:
922: zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
923: try:
924: self.getConnectionObj().manage_open_connection()
925: except:
926: zLOG.LOG("ZSQLResetConnection",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
927:
928: def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
929: """simple search"""
930:
931: #print query
932: if not query:
933: query=self.query
934:
935:
936: if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):
937:
938: self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")
939:
940: self._v_searchSQL.max_rows_=max_rows
941: try:
942: return self._v_searchSQL.__call__(var=query)
943: except :
944:
945: if sys.exc_info()[0]=="Database Error":
946: try:
947: self.getConnectionObj().manage_open_connection()
948: except:
949: zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
950: else:
951: try:
952:
953: self._v_searchSQL.max_rows_=max_rows
954:
955: return self._v_searchSQL.__call__(var=query)
956: except :
957:
958: if sys.exc_info()[0]=="Database Error":
959: try:
960: self.getConnectionObj().manage_open_connection()
961: except:
962: zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
963:
964: def getConnectionObj(self):
965: if hasattr(self,'connection_id'):
966: return getattr(self,self.connection_id)
967:
968:
969: def ZSQLSimpleSearch2(self,query=None):
970: """ returrn SQLSearch"""
971:
972: if not query:
973: query=self.query
974: if getattr(self,'_v_search',None):
975:
976: return self._v_search(var=query)
977:
978: if hasattr(self,'search') and (self.search.meta_type=="Z SQL Method"):
979: self._v_search=self.search
980: return self.search(var=query)
981: else:
982: if hasattr(self.aq_parent.aq_parent,'search') and (self.aq_parent.aq_parent.search.meta_type=="Z SQL Method"):
983: self._v_search=self.aq_parent.aq_parent.search
984: return self.aq_parent.aq_parent.search(var=query)
985: else:
986: search=self.ZopeFind(self,obj_metatypes=["Z SQL Method"],search_sub=1)
987: if search:
988: self._v_search=search[0][1]
989: return search[0][1](var=query)
990: else:
991: return []
992:
993:
994:
995: def ZSQLAdd(self,format=None,RESPONSE=None,args=None,**argv):
996: """Neuer Eintrag"""
997:
998: if args:
999: argTmp=args
1000: else:
1001: argTmp=argv
1002:
1003: qs_temp=[]
1004:
1005: for a in self.REQUEST.form.keys():
1006: qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
1007:
1008: qs=string.join(qs_temp,",")
1009:
1010: for field in argTmp.keys():
1011: if field[0]=="_":
1012: fieldTmp="-"+field[1:]
1013: else:
1014: fieldTmp=field
1015:
1016: qs+=",%s=%s"%(fieldTmp,argTmp[field])
1017:
1018:
1019: addList={}
1020: for q in qs.split(","):
1021: name=re.sub("r'+'"," ",q.split("=")[0].lower())
1022: value=q.split("=")[1]
1023: value=re.sub(r'\+'," ",value)
1024: value=urllib.unquote(value)
1025: if name=="-table":
1026: table=urllib.unquote(value)
1027: elif name=="-format":
1028: format=urllib.unquote(value)
1029: elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
1030: addList[urllib.unquote(name)]=urllib.unquote(value)
1031:
1032: keyList=[]
1033: valueList=[]
1034: for x in addList.keys():
1035: keyList.append("\""+x+"\"")
1036: valueList.append(sql_quote(addList[x]))
1037:
1038: keyString=string.join(keyList,",")
1039: valueString=string.join(valueList,",")
1040:
1041: queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
1042:
1043: self.ZSQLSimpleSearch(queryString)
1044:
1045: if RESPONSE and format:
1046: return RESPONSE.redirect(format)
1047: else:
1048: return True
1049:
1050: def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,**argv):
1051: """change entries"""
1052: #qs=self.REQUEST['QUERY_STRING']
1053: # very bad hack
1054:
1055: qs_temp=[]
1056: if USE_FORM or RESPONSE:
1057: for a in self.REQUEST.form.keys():
1058:
1059: qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
1060:
1061:
1062:
1063: for field in argv.keys():
1064:
1065: if field[0]=="_":
1066: fieldTmp="-"+field[1:]
1067: else:
1068: fieldTmp=field
1069:
1070: qs_temp.append("%s=%s"%(fieldTmp,argv[field]))
1071:
1072:
1073: changeList=[]
1074:
1075: for q in qs_temp:
1076:
1077: name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
1078: value="=".join(q.split("=")[1:])
1079: value=re.sub(r'\+'," ",value)
1080: value=urllib.unquote(value)
1081:
1082: if name=="-table":
1083: table=urllib.unquote(value)
1084: elif name=="-identify":
1085: identify=urllib.unquote(value)
1086: identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])
1087: elif name=="-format":
1088: format=urllib.unquote(value)
1089: #elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
1090: elif (not (name[0]=="-" or name[0]=="_")):
1091:
1092: if value=="":
1093: changeList.append("\""+name+"\"=null")
1094: else:
1095: changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))
1096:
1097: changeString=string.join(changeList,",")
1098:
1099: queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
1100: zLOG.LOG("ZSQLExtend",zLOG.INFO,"CHANGE: "+queryString)
1101:
1102: self.ZSQLSimpleSearch(queryString)
1103:
1104:
1105: if RESPONSE and format:
1106: return RESPONSE.redirect(format)
1107: else:
1108: return True
1109:
1110:
1111: def ZSQLFindIndexed(self,qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
1112: """find2"""
1113:
1114: for index in self.ZopeFind(self,obj_ids=indexedFields):
1115: txt=argv.get(index[0],None)
1116: if txt:
1117: oids=index[1].getIndex()[txt]
1118:
1119: search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
1120:
1121: search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
1122: return search2
1123:
1124: def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):
1125: """find2"""
1126:
1127: search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
1128:
1129: search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
1130: return search2
1131:
1132:
1133:
1134: def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
1135: """search in database"""
1136:
1137: def delEmpty(list):
1138: """"loesche leere elemente aus der liste"""
1139: ret=[]
1140: for x in list:
1141: splitted=x.split("=")
1142: if (len(splitted)>1) and not (splitted[1]==' '):
1143: ret.append(x)
1144: return ret
1145:
1146: if qs=="":
1147: #kein querystring ubergeben
1148: if self.REQUEST['QUERY_STRING']:
1149: qs=self.REQUEST['QUERY_STRING']
1150:
1151: qs=string.join(qs.split("&"),",")
1152:
1153: for field in argv.keys():
1154: if field[0]=="_":
1155: fieldTmp="-"+field[1:]
1156: else:
1157: fieldTmp=field
1158:
1159: qs+=",%s=%s"%(fieldTmp,argv[field])
1160:
1161: else:
1162:
1163: qs=self.REQUEST.SESSION.get('query','')
1164:
1165: for field in argv.keys():
1166: if field[0]=="_":
1167: fieldTmp="-"+field[1:]
1168: else:
1169: fieldTmp=field
1170:
1171: qs+=",%s=%s"%(fieldTmp,argv[field])
1172:
1173:
1174:
1175: else:
1176: self.REQUEST['QUERY_STRING']=qs
1177:
1178: qs=string.join(qs.split("&"),",")
1179:
1180:
1181:
1182: qs=re.sub("\\+"," ",qs)#TODO: Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
1183:
1184: qs=string.join(delEmpty(qs.split(",")),",")
1185:
1186: if storename:
1187: """store"""
1188: else:
1189: storename="foundCount"
1190:
1191: #store query for further usage
1192: self.REQUEST.SESSION['query']=qs
1193:
1194: #print "calling Query with",repr(NoQuery)
1195: ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect,filter=filter)
1196: #print self.REQUEST.SESSION["foundCount"]
1197:
1198:
1199:
1200: return ret
1201:
1202: def ZSQLFoundCountLen(self,var):
1203: return len(var)
1204:
1205: def ZSQLFoundCount(self,qs="",select="*",storename=None):
1206:
1207: ## if qs=="":
1208:
1209: ## if self.REQUEST['QUERY_STRING']:
1210:
1211: ## qs=self.REQUEST['QUERY_STRING']
1212: ## qs=string.join(qs.split("&"),",")
1213: ## else:
1214:
1215: ## qs=self.REQUEST.SESSION['query']
1216: ## else:
1217: ## qs=string.join(qs.split("&"),",")
1218:
1219:
1220: ## temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
1221: if storename:
1222: """store"""
1223: else:
1224: storename="foundCount"
1225:
1226: return self.REQUEST.SESSION[storename]['count']
1227:
1228: def ZSQLRangeStart(self,storename=None):
1229:
1230: if storename:
1231: """store"""
1232: else:
1233: storename="foundCount"
1234:
1235: return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
1236:
1237: def ZSQLRangeSize(self,storename=None):
1238:
1239: if storename:
1240: """store"""
1241: else:
1242: storename="foundCount"
1243:
1244: return self.REQUEST.SESSION[storename]['rangeSize']
1245:
1246: def ZSQLRangeEnd(self,storename=None):
1247:
1248: if storename:
1249: """store"""
1250: else:
1251: storename="foundCount"
1252:
1253: return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
1254:
1255: def ZSQLNewQuery(self,linkText,storename=None,**argv):
1256: """suche neu"""
1257: return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)
1258:
1259: def ZSQLNewSearch(self,linkText,storename=None,url=None,args=None,**argv):
1260: """suche mit alten parametern bis auf die in argv getauschten"""
1261: str = self.ZSQLNewSearchURL(storename, url, args, **argv)
1262: return """<a href="%s"> %s</a>"""%(str,linkText)
1263:
1264:
1265: def ZSQLNewSearchURL(self, storename=None,url=None,args=None,**argv):
1266: """suche mit alten parametern bis auf die in argv getauschten"""
1267:
1268: if storename:
1269: """store"""
1270: else:
1271: storename="foundCount"
1272: qs=self.REQUEST.SESSION[storename]['qs']
1273:
1274: if args:
1275: argv=args
1276:
1277: querys=qs.split(",")
1278: argList=[]
1279: arg=""
1280: queryList=[x.split("=")[0] for x in querys]
1281:
1282: for argTmp in argv.keys():
1283:
1284:
1285: arg=argTmp[0:]
1286: if arg[0]=="_":arg="-"+argTmp[1:] # aender _ in - als standard
1287:
1288: if arg not in queryList: # noch nicht drin
1289: querys.append("%s=%s"%(arg,argv[argTmp]))
1290: argList.append(arg)
1291:
1292:
1293:
1294: newquery=[]
1295: for query in querys:
1296: queryArg=query.split("=")[0]
1297: qarg=queryArg[0:]
1298: if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard
1299:
1300: if queryArg in argList:
1301: newquery.append("%s=%s"%(queryArg,argv[qarg]))
1302: else:
1303: newquery.append(query)
1304:
1305: if url:
1306: str=url+"?"+"&".join(newquery)
1307: else:
1308: str="ZSQLSearch?"+"&".join(newquery)
1309:
1310: return str
1311:
1312: def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None):
1313: """analysieren den QueryString"""
1314:
1315:
1316: #setzte generische werte
1317:
1318: lop="AND" # standardsuche mit and
1319: max="ALL" #standard alle auswaehlen
1320: maxstr=""
1321: whereList=[]
1322: sort=""
1323: op="bw"
1324: opfields={}
1325: lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld
1326: sortfields={} #order of sortfields
1327: diacritics={} #diacritische zeichen, falls "no", dann werden diese fuer das feld gefiltert.
1328: sortAllFields=None
1329: skip=""
1330: rangeStart=0
1331: limit=0
1332: searchFields={}
1333: searchFieldsOnly={}
1334: queryTemplate=[]
1335:
1336: if not select:
1337: select="oid,*"
1338:
1339: #check for op
1340: splitted=qs.split(",")
1341:
1342: if tableExt:
1343: table=tableExt
1344:
1345: if restrictField:
1346: select=restrictField
1347:
1348:
1349: #erster durchgang suche operatoren
1350: for q in splitted:
1351:
1352: name=re.sub("r'+'"," ",q.split("=")[0].lower())
1353: try:
1354: value=urllib.unquote(q.split("=",1)[1])
1355: except:
1356: value=""
1357: #print "Hi",name[0:3],q
1358: if name[0:3]==iCT+"op":
1359: op=value
1360:
1361: field=name[4:]
1362: opfields[field]=op
1363:
1364: if name[0:4]==iCT+"lop":
1365: lop=value
1366:
1367: field=name[5:]
1368: lopfields[field]=lop
1369:
1370: if name[0:11]==iCT+"diacritics":
1371: field=name[12:]
1372: diacritics[field]=value
1373:
1374: if name[0:10]==iCT+"sortorder":
1375: #sort=value
1376:
1377: field=name[11:]
1378: sortAllFields=None
1379: #no field selected
1380: if field=="":
1381: sortAllFields=value
1382: else:
1383: sortfields[field]=value
1384:
1385: #zweiter durchgang analysiere felder
1386: for q in qs.split(","):
1387:
1388:
1389:
1390: name=re.sub("r'+'"," ",q.split("=")[0].lower())
1391: try:
1392: value=urllib.unquote(q.split("=",1)[1])
1393: except:
1394: value=""
1395:
1396: punktsplit=name.split(".") #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:
1397:
1398: #analysiere alle anderen faelle
1399:
1400: if diacritics.get(name,'yes')=='no':
1401: """filter diacritische zeichen"""
1402: value=unicodedata.normalize('NFKD', value.decode('utf-8')).encode('ASCII', 'ignore')
1403:
1404: if name==iCT+"lop":
1405: lop=value
1406: elif name==iCT+"table":
1407: if not tableExt:
1408: table=value
1409: elif name==iCT+"select":
1410: if not restrictField:
1411: select=value
1412: elif name==iCT+"max":
1413: if not NoLimit:
1414: maxstr="LIMIT "+str(value)
1415: limit=str(value)
1416: elif name==iCT+"skip":
1417: skip="OFFSET "+str(value)
1418: rangeStart=str(value)
1419: elif name==iCT+"join":
1420: whereList.append(value)
1421: elif name==iCT+"sort":
1422: sortstrs=[]
1423: for word in value.split(','):
1424: wordstr=word.lstrip().rstrip()
1425: if sortAllFields:
1426: order=sortAllFields
1427: else:
1428: order=sortfields.get(wordstr,'ASC')
1429:
1430: if not (wordstr == ""):
1431: sortstrs.append(wordstr+" "+order)
1432: if len(sortstrs)>0:
1433: sort="ORDER BY "+string.join(sortstrs,',')
1434:
1435:
1436: elif name==iCT+"token":
1437: if not nostore=="yes":
1438: self.REQUEST.SESSION['token']=value
1439:
1440: elif name==iCT+"op":
1441: op=value
1442:
1443:
1444: #sonderfall Name hat das Format:
1445: #TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE_-table
1446: #i.e. erzeugt wird
1447: #das Statement
1448: #WHERE IDENTIFIER_IN_TABELLE in (select * from SELECT_FIELD
1449: #where LOWER(SUCHFELD_IN_DIESER_TABELLE) something value)
1450: #something is defined by _op_TABELLE.SUCHFELD_IN_DIESER_TABELLE.SELECT_FIELD.IDENTIFIER_IN_TABELLE
1451:
1452: elif (not name[0]==iCT) and len(punktsplit)==4:
1453: if opfields.has_key(name):
1454: op=opfields[name]
1455: else:
1456: op="ct"
1457: namealt=name
1458: name="LOWER("+punktsplit[1]+")"
1459: value=value.lower()
1460: if op=="ct":
1461: tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
1462: elif op=="gt":
1463: tmp=(name+">"+sql_quote(value))
1464: elif op=="lt":
1465: tmp=(name+"<"+sql_quote(value))
1466: elif op=="eq":
1467: tmp=(name+"="+sql_quote(value))
1468: elif op=="bw":
1469: tmp=(name+" LIKE "+sql_quote(value+"%"))
1470: elif op=="ew":
1471: tmp=(name+" LIKE "+sql_quote("%"+value))
1472: elif op=="all":
1473: tmps=[]
1474: for word in value.split(" "):
1475: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1476:
1477: tmp=string.join(tmps,' AND ')
1478:
1479: elif op=="numerical":
1480: term=analyseIntSearch(value)
1481: tmp=(name+" "+term)
1482: elif op=="grep":
1483: tmp=(name+" ~* "+sql_quote(value))
1484: elif op=="one":
1485: tmps=[]
1486: for word in value.split(" "):
1487: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1488:
1489: tmp=string.join(tmps,' OR ')
1490:
1491: op="all"
1492:
1493:
1494: searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)
1495:
1496: queryTemplate.append(searchTmp)
1497:
1498: elif (not name[0]==iCT) and (not len(value)==0):
1499:
1500: #print "OP",op,name
1501: value=value.lower()
1502: tmp=""
1503: if opfields.has_key(name):
1504: op=opfields[name]
1505: else:
1506: op="ct"
1507: namealt=name
1508: name="LOWER("+name+")"
1509: if op=="ct":
1510: tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
1511: elif op=="gt":
1512: tmp=(name+">"+sql_quote(value))
1513: elif op=="lt":
1514: tmp=(name+"<"+sql_quote(value))
1515: elif op=="eq":
1516: tmp=(name+"="+sql_quote(value))
1517: elif op=="bw":
1518: tmp=(name+" LIKE "+sql_quote(value+"%"))
1519: elif op=="ew":
1520: tmp=(name+" LIKE "+sql_quote("%"+value))
1521: elif op=="all":
1522: tmps=[]
1523: for word in value.split(" "):
1524: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1525:
1526: tmp=string.join(tmps,' AND ')
1527:
1528: elif op=="numerical":
1529: term=analyseIntSearch(value)
1530: tmp=(name+" "+term)
1531: elif op=="grep":
1532: tmp=(name+" ~* "+sql_quote(value))
1533: elif op=="one":
1534: tmps=[]
1535: for word in value.split(" "):
1536: tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
1537:
1538: tmp=string.join(tmps,' OR ')
1539:
1540: op="all"
1541:
1542: if (not tableExt) or (namealt.split('.')[0]==tableExt):
1543: if searchFields.has_key(namealt):
1544: searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
1545: searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
1546: else:
1547: searchFields[namealt]=tmp
1548: searchFieldsOnly[namealt]=value
1549:
1550:
1551: whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
1552: whereList+=queryTemplate
1553:
1554: if len(whereList)>0:
1555: if filter:
1556: whereStr="("+string.join(whereList," "+lop+" ")+") AND "+filter
1557: else:
1558: whereStr=string.join(whereList," "+lop+" ")
1559: where="WHERE "+whereStr
1560: else:
1561: if filter:
1562: where="WHERE "+filter
1563: else:
1564: where=""
1565:
1566: if restrictConnect:
1567:
1568: if len(where)==0:
1569: where="WHERE "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
1570: else:
1571: where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
1572:
1573: #print "QE",table
1574: #print (select,table,where,sort,maxstr,skip)
1575: query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
1576:
1577: if not nostore=="yes":
1578:
1579: self.REQUEST.SESSION['qs']=opfields
1580: #print "IAMHERE again:", query
1581:
1582: if storename and (not NoQuery):
1583:
1584: query2="SELECT count(*) FROM %s %s"%(table,where)
1585:
1586: #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
1587: if not self.REQUEST.SESSION.has_key(storename):
1588: self.REQUEST.SESSION[storename]={}
1589:
1590: self.REQUEST.SESSION[storename]['qs']=qs #sichere Querystring
1591:
1592: if self.REQUEST.SESSION[storename].has_key('queryString2'):
1593:
1594: if not self.REQUEST.SESSION[storename]['queryString2']==query2:
1595: #print "HOOOOO",storename
1596: self.REQUEST.SESSION[storename]['queryString2']=query2
1597: try:
1598: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
1599: except:
1600: self.REQUEST.SESSION[storename]['count']=0
1601: #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
1602:
1603: else:
1604:
1605: self.REQUEST.SESSION[storename]['queryString2']=query2
1606: if self.ZSQLSimpleSearch(query2):
1607: self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
1608: else:
1609: self.REQUEST.SESSION[storename]['count']=0
1610: #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
1611:
1612:
1613: self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
1614: if limit=="all":
1615: self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
1616: else:
1617: self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
1618: self.REQUEST.SESSION[storename]['rangeSize']=limit
1619: self.REQUEST.SESSION[storename]['searchFields']=searchFields
1620:
1621: self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
1622:
1623: if not NoQuery:
1624:
1625: return self.ZSQLQuery(query)
1626: else:
1627:
1628: return query
1629:
1630: def ZSQLUniqueQuery(self,value,returns):
1631: """unique relation"""
1632: if returns:
1633: statement="""select %s from %s where %s = '%s' """%(returns[1],returns[0],returns[2],value)
1634: founds=self.ZSQLSimpleSearch(statement)
1635: if founds:
1636: return getattr(founds[0],returns[1])
1637: else:
1638: return value
1639: else:
1640: return value
1641:
1642: def ZSQLQuery(self,query,debug=None):
1643: """query"""
1644: if debug:
1645: zLOG.LOG("ZSQLQuery", zLOG.INFO, query)
1646:
1647: return self.ZSQLSimpleSearch(query)
1648:
1649:
1650: def ZSQLSearch(self):
1651: """To be done"""
1652:
1653: formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url
1654:
1655: #zerlege querystring in key value paare
1656: #TODO: check if this is really necessary, use argv**
1657:
1658: rq=self.REQUEST['QUERY_STRING']
1659: querys=rq.split("&")
1660: for querytemp in querys: #zerg
1661: query=querytemp.split("=")
1662:
1663: try:
1664: if query[0].lower()=="-format":
1665: formatfile=query[1]
1666: except:
1667: pass
1668:
1669: #sichern
1670: self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
1671: self.REQUEST.SESSION['come_from_search']="yes"
1672:
1673: return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))
1674:
1675:
1676: def ZSQLint(self,string):
1677: try:
1678:
1679: return(int(string))
1680: except:
1681: return 0
1682:
1683: def getZSQLSearchFieldsList(self,storename="foundCount"):
1684: """get searchfieldList"""
1685: #print self.REQUEST.SESSION[storename]['searchFields'].keys()
1686: return self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()
1687:
1688: def getZSQLSearchFields(self,field,storename="foundCount"):
1689: """get searchfield"""
1690: #print "SF",self.REQUEST.SESSION[storename]['searchFields']
1691:
1692: return self.REQUEST.SESSION[storename]['searchFieldsOnly'][field]
1693:
1694:
1695: def nextLink(self,html,storename="foundCount"):
1696: """nextLink"""
1697:
1698: try:
1699: limit=self.REQUEST.SESSION[storename]['rangeSize']
1700: if int(limit)==0 :
1701: limit="1"
1702: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
1703: except:
1704: limit=1
1705: newRangeStart=0
1706:
1707: if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
1708: #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
1709: return ""
1710:
1711: #create new query string
1712:
1713: if self.REQUEST['QUERY_STRING']=="":
1714: qs=self.REQUEST.SESSION['query']
1715:
1716: queries=string.split(qs,",")[0:]
1717:
1718:
1719: else:
1720: qs=self.REQUEST['QUERY_STRING']
1721: queries=string.split(qs,"&")[0:]
1722:
1723:
1724:
1725: newquery=[]
1726:
1727: skipFound=0
1728:
1729: for query in queries:
1730:
1731: if query[0]=="_" : query="-"+query[1:]
1732:
1733: if query.split("=")[0].lower()=="-skip":
1734:
1735: skipFound=1
1736: query="-skip=%i"%newRangeStart
1737: newquery.append(query)
1738:
1739: if skipFound==0 :
1740: query="-skip=%i"%newRangeStart
1741: newquery.append(query)
1742:
1743: newquerystring=string.join(newquery,"&")
1744: return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
1745:
1746:
1747:
1748: def prevLink(self,html,storename="foundCount"):
1749: """prev link"""
1750:
1751: try:
1752: limit=self.REQUEST.SESSION[storename]['rangeSize']
1753: if int(limit)==0 :
1754: limit="1"
1755: newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
1756: except:
1757: limit=1
1758: newRangeStart=0
1759: if newRangeStart <0:
1760: return ""
1761:
1762: #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
1763:
1764: if newRangeStart<0:
1765: newRangeStart=0
1766:
1767: #create new query string
1768:
1769: if self.REQUEST['QUERY_STRING']=="":
1770: qs=self.REQUEST.SESSION['query']
1771: #qs=re.sub(r'_','-',qs) #aendern fuer query
1772: queries=string.split(qs,",")
1773:
1774:
1775: else:
1776: qs=self.REQUEST['QUERY_STRING']
1777: queries=string.split(qs,"&")
1778:
1779:
1780:
1781: newquery=[]
1782:
1783: skipFound=0
1784:
1785: for query in queries:
1786: #print query.split("=")[0]
1787:
1788: if query[0]=="_" : query[0]="-"
1789:
1790: if query.split("=")[0].lower()=="-skip":
1791: #print"HI"
1792: query="-skip=%i"%newRangeStart
1793: skipFound=1
1794: newquery.append(query)
1795:
1796: if skipFound==0 :
1797: query="-skip=%i"%newRangeStart
1798: newquery.append(query)
1799:
1800: newquerystring=string.join(newquery,"&")
1801:
1802: return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
1803:
1804:
1805:
1806: def prevLink_old(self,html):
1807: """prev link"""
1808: if self.REQUEST['QUERY_STRING']=="":
1809: qs=self.REQUEST.SESSION['query']
1810: else:
1811: qs=self.REQUEST['QUERY_STRING']
1812: max=re.search(r'max\=(.*)\,',qs.lower())
1813: offset=re.search(r'offset\=(.*)\,',qs.lower())
1814: if not offset:
1815: offsetnew=0
1816: else:
1817: offsetnew=int(offset)-max
1818: if offsetnew<0:
1819: offsetnew=0
1820: queries=string.split(qs,",")
1821: newquery=[]
1822: if offset:
1823: for query in queries:
1824: if query.split("=")[0].lower()=="offset":
1825: query="-offset=%i"%offsetnew
1826: newquery.append(query)
1827: newquerystring=string.join(newquery,"&")
1828: else:
1829: queries.append("-offset=%i"%offsetnew)
1830: newquerystring=string.join(queries,"&")
1831: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
1832:
1833: def nextLink_old(self,html):
1834: """prev link"""
1835: if self.REQUEST['QUERY_STRING']=="":
1836: qs=self.REQUEST.SESSION['query']
1837: else:
1838: qs=self.REQUEST['QUERY_STRING']
1839: max=re.search(r'max\=(.*)\,',qs.lower())
1840:
1841: offset=re.search(r'offset\=(.*)\,',qs.lower())
1842: if not offset:
1843: offsetnew=1
1844: else:
1845: offsetnew=int(offset)+int(max)
1846: if offsetnew<0:
1847: offsetnew=0
1848: queries=string.split(qs,",")
1849: newquery=[]
1850: if offset:
1851: for query in queries:
1852:
1853: if query.split("=")[0].lower()=="-offset":
1854: query="-offset=%i"%offsetnew
1855: newquery.append(query)
1856: newquerystring=string.join(newquery,"&")
1857: else:
1858: queries.append("-offset=%i"%offsetnew)
1859: newquerystring=string.join(queries,"&")
1860:
1861: return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
1862:
1863:
1864: manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
1865:
1866: def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
1867: createPublic=0,
1868: createUserF=0,
1869: connection_id=None,
1870: REQUEST=None):
1871: """Add a new Folder object with id *id*.
1872:
1873: If the 'createPublic' and 'createUserF' parameters are set to any true
1874: value, an 'index_html' and a 'UserFolder' objects are created respectively
1875: in the new folder.
1876: """
1877:
1878:
1879: ob=ZSQLExtendFolder()
1880: ob.id=str(id)
1881: ob.title=title
1882: self._setObject(id, ob)
1883: ob=self._getOb(id)
1884: setattr(ob,'label',label)
1885: setattr(ob,'description',description)
1886: setattr(ob,'connection_id',connection_id)
1887:
1888: checkPermission=getSecurityManager().checkPermission
1889:
1890: if createUserF:
1891: if not checkPermission('Add User Folders', ob):
1892: raise Unauthorized, (
1893: 'You are not authorized to add User Folders.'
1894: )
1895: ob.manage_addUserFolder()
1896:
1897: if createPublic:
1898: if not checkPermission('Add Page Templates', ob):
1899: raise Unauthorized, (
1900: 'You are not authorized to add Page Templates.'
1901: )
1902: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
1903: id='index_html', title='')
1904:
1905: if REQUEST is not None:
1906: return self.manage_main(self, REQUEST, update_menu=1)
1907:
1908:
1909:
1910: class ZSQLBibliography(Folder,ZSQLExtendFolder):
1911: """Bibliography"""
1912: meta_type="ZSQLBibliography"
1913: def getLabel(self):
1914: try:
1915: return self.label
1916: except:
1917: return ""
1918:
1919: def getDescription(self):
1920: try:
1921: return self.description
1922: except:
1923: return ""
1924:
1925: def changeZSQLBibliographyForm(self):
1926: """change folder config"""
1927: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLBibliographyForm.zpt')).__of__(self)
1928: return pt()
1929:
1930:
1931: def content_html(self):
1932: """template fuer content"""
1933:
1934: try:
1935: obj=getattr(self,"ZSQLBibliography_template")
1936: return obj()
1937: except:
1938: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt')).__of__(self)
1939: pt.content_type="text/html"
1940: return pt()
1941:
1942: def changeZSQLBibliography(self,tableName,label,description,connection_id=None,REQUEST=None):
1943: """change it"""
1944: self.connection_id=connection_id
1945: self.tableName=tableName
1946: self.label=label
1947: self.description=description
1948:
1949: if REQUEST is not None:
1950: return self.manage_main(self, REQUEST)
1951:
1952: manage_options=Folder.manage_options+(
1953: {'label':'Main Config','action':'changeZSQLBibliographyForm'},
1954: {'label':'Generate RDF Template','action':'generateRDFTemplate'},
1955: {'label':'Generate XML Template','action':'generateXMLTemplate'},
1956: )
1957:
1958:
1959: def getFieldLabel(self,fields,field):
1960: """get labels"""
1961: try:
1962: ret =fields[0][field]
1963: if ret == "":
1964: return field
1965: else:
1966: return ret
1967: except:
1968: return field
1969:
1970: def getFieldValue(self,found,field):
1971: """get value"""
1972: try:
1973: ret=getattr(found,field)
1974: if ret == "":
1975: return None
1976: else:
1977: return ret
1978: except:
1979: return None
1980:
1981: def findTagsFromMapping(self,referenceType):
1982: """gib hash mit label -> generic zurueck"""
1983: self.referencetypes=self.ZopeFind(self.standardMD)
1984: bibdata={}
1985: retdata={}
1986: fieldlist=self.standardMD.fieldList
1987:
1988: for referenceTypeF in self.referencetypes:
1989: #print referenceType,referenceTypeF[1].title
1990: if referenceTypeF[1].title == referenceType:
1991: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
1992: bibdata['data']=referenceTypeF[1]
1993: self.fields=bibdata[referenceType]
1994: for field in fieldlist:
1995: if referenceTypeF[1].getValue(field)[0]==None:
1996: retdata[field]=field
1997: else:
1998: retdata[field]=referenceTypeF[1].getValue(field)[0]
1999:
2000: return retdata,fieldlist
2001:
2002: def findLabelsFromMapping(self,referenceType):
2003: """gib hash mit label -> generic zurueck"""
2004: self.referencetypes=self.ZopeFind(self.standardMD)
2005: bibdata={}
2006: retdata={}
2007: fieldlist=self.standardMD.fieldList
2008:
2009: for referenceTypeF in self.referencetypes:
2010: #print referenceType,referenceTypeF[1].title
2011: if referenceTypeF[1].title == referenceType:
2012: bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
2013: bibdata['data']=referenceTypeF[1]
2014: self.fields=bibdata[referenceType]
2015: for field in fieldlist:
2016: retdata[field]=referenceTypeF[1].getValue(field)[1]
2017:
2018: return retdata,fieldlist
2019:
2020: def createRDFTag(self,tag,content,namespace="cdli"):
2021: """create RDF"""
2022: if content:
2023: tag=namespace+":"+tag
2024: if (type(content) is StringType) or (type(content) is UnicodeType):
2025: ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
2026: else:
2027: ret=""" <%s>%s</%s>"""%(tag,content,tag)
2028: return ret.decode('latin-1')
2029: else:
2030: return ""
2031:
2032: def createIndexTag(self,tag,content):
2033: """create tag"""
2034:
2035: if content:
2036: if (type(content) is StringType) or (type(content) is UnicodeType):
2037: ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
2038: else:
2039: ret=""" <%s>%s</%s>"""%(tag,content,tag)
2040: return ret.decode('latin-1')
2041:
2042: else:
2043: return ""
2044:
2045: def getXML2(self):
2046: """crate index meta"""
2047:
2048: fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
2049: self.REQUEST['fn']=fn
2050:
2051: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record2.xml')).__of__(self)
2052: pt.content_type="text/xml"
2053: return pt()
2054:
2055:
2056: def generateRDFTemplate(self,REQUEST=None):
2057: """generateRDFtemplate"""
2058: zt=ZopePageTemplate('record.rdf')
2059: self._setObject('record.rdf',zt)
2060: default_content_fn = os.path.join(package_home(globals()),
2061: 'zpt','record.rdf')
2062: text = open(default_content_fn).read()
2063: zt.pt_edit(text, 'text/xml')
2064:
2065:
2066: if REQUEST is not None:
2067: return self.manage_main(self, REQUEST)
2068:
2069: def generateXMLTemplate(self,REQUEST=None):
2070: """generateXMLtemplate"""
2071: zt=ZopePageTemplate('record.xml')
2072: self._setObject('record.xml',zt)
2073: default_content_fn = os.path.join(package_home(globals()),
2074: 'zpt','record.xml')
2075: text = open(default_content_fn).read()
2076: zt.pt_edit(text, 'text/xml')
2077:
2078:
2079: if REQUEST is not None:
2080: return self.manage_main(self, REQUEST)
2081: def getMetaDataRDF(self):
2082: """crate index meta"""
2083: find=self.ZopeFind(self,obj_ids=["record.rdf"])
2084: if not find:
2085: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.rdf')).__of__(self)
2086: pt.content_type="text/xml"
2087: return pt()
2088: else:
2089: return find[0][1]()
2090:
2091: def getMetaDataXML(self):
2092: """crate index meta"""
2093: find=self.ZopeFind(self,obj_ids=["record.xml"])
2094: if not find:
2095: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.xml')).__of__(self)
2096: pt.content_type="text/xml"
2097: return pt()
2098: else:
2099: return find[0][1]()
2100:
2101:
2102: def getMetaDatasXML(self):
2103: """index"""
2104: # check if the request's host part was OK
2105: http_host = self.REQUEST['HTTP_HOST']
2106: host_port = self.REQUEST['SERVER_PORT']
2107: fix_host = None
2108: if http_host and http_host.rfind(host_port) == -1:
2109: #print "HTTP_HOST needs fixing!"
2110: fix_host = http_host + ":" + host_port
2111:
2112: ret="""<?xml version="1.0" ?>
2113: <index>"""
2114: for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
2115: base_url = self.absolute_url()
2116: if fix_host:
2117: #print "replacing ", http_host, " by ", fix_host
2118: base_url = string.replace(base_url, http_host, fix_host, 1)
2119:
2120: link=base_url+"/"+"record.html?oid=%i"%found.oid
2121: metalink=base_url+"/"+"getMetaDataXML?oid=%i"%found.oid
2122:
2123: ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
2124:
2125: return ret+"\n</index>"
2126:
2127:
2128: manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
2129:
2130: def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
2131: createPublic=0,
2132: createUserF=0,
2133: connection_id=None,
2134: REQUEST=None):
2135: """Add a new Folder object with id *id*.
2136:
2137: If the 'createPublic' and 'createUserF' parameters are set to any true
2138: value, an 'index_html' and a 'UserFolder' objects are created respectively
2139: in the new folder.
2140: """
2141:
2142:
2143: ob=ZSQLBibliography()
2144: ob.id=str(id)
2145: ob.title=title
2146: self._setObject(id, ob)
2147: ob=self._getOb(id)
2148: setattr(ob,'tableName',tableName)
2149: setattr(ob,'label',label)
2150: setattr(ob,'description',description)
2151: setattr(ob,'connection_id',connection_id)
2152:
2153: checkPermission=getSecurityManager().checkPermission
2154:
2155: if createUserF:
2156: if not checkPermission('Add User Folders', ob):
2157: raise Unauthorized, (
2158: 'You are not authorized to add User Folders.'
2159: )
2160: ob.manage_addUserFolder()
2161:
2162: if createPublic:
2163: if not checkPermission('Add Page Templates', ob):
2164: raise Unauthorized, (
2165: 'You are not authorized to add Page Templates.'
2166: )
2167: ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
2168: id='index_html', title='')
2169:
2170: if REQUEST is not None:
2171: return self.manage_main(self, REQUEST, update_menu=1)
2172:
2173:
2174:
2175:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ZSQLExtend.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ZSQLExtend