File:  [Repository] / ZSQLExtend / ZSQLExtend.py
Revision 1.124: download - view: text, annotated - select for diffs - revision graph
Fri Feb 15 13:05:41 2008 UTC (16 years, 3 months ago) by cmielack
Branches: MAIN
CVS tags: HEAD
Added support for lists of tables instead of single tables only.

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

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>