[BACK]Return to ZSQLExtend.py CVS log [TXT] [DIR] Up to [Repository] / ZSQLExtend

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.5 and 1.74

version 1.5, 2004/01/21 16:54:45 version 1.74, 2005/11/23 17:41:28
Line 1 Line 1
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Globals import Persistent  
 from Acquisition import Implicit  from Acquisition import Implicit
 from Globals import DTMLFile  from Globals import DTMLFile,package_home,Persistent
 import urllib  import urllib
 import re  import re
 import string  import string
 from pyPgSQL import libpq  import sys
   #from pyPgSQL import libpq
 from AccessControl import getSecurityManager  from AccessControl import getSecurityManager
   from Products.PageTemplates.ZopePageTemplate import ZopePageTemplate
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   
   from Products.ZSQLMethods.SQL import SQLConnectionIDs
   from xml.sax.saxutils import escape
   from types import *
   import Shared.DC.ZRDB.DA
   import zLOG
 import os.path  import os.path
   import os
   from OFS.SimpleItem import SimpleItem
   
   def analyseIntSearch(word):
       #analyse integer searches
   
       splitted=word.split("-")
   
       if len(splitted)==1:
           return "="+splitted[0]
       
       if splitted[0]=="":
           return "< "+splitted[1]
   
       if splitted[1]=='':
           return "> "+splitted[0]
       else:
           return "BETWEEN "+splitted[0]+" AND "+splitted[1]
   
           
   
   def sql_quote(v):
       # quote dictionary
       quote_dict = {"\'": "''", "\\": "\\\\"}
       for dkey in quote_dict.keys():
           if string.find(v, dkey) >= 0:
               v=string.join(string.split(v,dkey),quote_dict[dkey])
       return "'%s'" % v
   
   def showSQLConnectionIDs(self):
       return SQLConnectionIDs(self)
   
   class ZSQLIndex(SimpleItem):
       """index"""
       meta_type="ZSQLIndex"
       
       def __init__(self,index,id,table=''):
           self.index=[x for x in index]
           self.id=id
           self.table=table
           
       def setIndex(self,index):
           self.index=[x for x in index]
   
 def quoteString(name):      def getIndex(self):
     #return re.sub(r'([\(\)\?])',"\\\1",name)          return self.index
     #return "Euklid"  
     return name  
   
 class ZSQLExtendFolder(Persistent, Implicit, Folder):  class ZSQLExtendFolder(Folder,Persistent, Implicit):
     """Folder"""      """Folder"""
     meta_type="ZSQLExtendFolder"      meta_type="ZSQLExtendFolder"
           
       def importXMLFile(self,table,containerTagName,file,identify=None,RESPONSE=None):
           #TODO: finish importXMLFile
           '''
           Import XML file into the table
           @param table: name of the table the xml shall be imported into
           @param containerTagName: XML-Tag which describes a dataset
           @param file: xmlfile handle
           @param identify: (optional) field res. tag which identifies a entry uniquely for updating purposes.
           @param RESPONSE: (optional)
           '''
           from xml.dom.pulldom import parseString
   
           doc=parseString(file.read())
           while 1:
               node=doc.getEvent()
           
               if node is None:
                   break;
               else:
                   if node[1].nodeName==containerTagName:
                       doc.expandNode(node[1])
                   #fn=node[1].getAttribute("xml:id")
                   #nf=file("xtf/"+fn+".xtf",'w')
                   #nf.write("""<texts xmlns="http://emegir.info/xtf" xmlns:lem="http://emegir.info/lemma" >"""+node[1].toxml()+"</texts>")
                   #print "wrote: %s"%fn
                   
           
       def generateIndex(self,field,index_name,table,RESPONSE=None):
           """erzeuge index aus feld"""
           index={}
           founds=self.ZSQLSimpleSearch("""SELECT %s,oid FROM %s LIMIT 2000"""%(field,table))
   
           for found in founds:
               tmp=getattr(found,field,None)
               if tmp:
                   strings=tmp.split(" ")
                   for string in strings:
                       if index.get(string):
                           index[string].append(found.oid)
                       else:
                           index[string]=[found.oid]
                       RESPONSE.write(string+"\n")
               
           if not hasattr(self,index_name):
               obj=ZSQLIndex(index,index_name,table)
               self._setObject(index_name,obj)
                       
           self._getOb(index_name).setIndex(index)
           
       def getIndex(self,index_name):
           """getIndex"""
           founds=self.ZopeFind(self,obj_ids=[index_name])
           
           return founds[0][1].getIndex()
       
               
       def testneu(self):
           """test"""
           relStatement="""period like '%s%%'"""
           statement="select * from cdli_cat"
           wherePart="museum_no like 'VAT%'"
           classes=['Uruk III','Uruk IV']
           return self.searchRel(relStatement,statement,wherePart,classes)
   
       def URLquote(self,txt):
           """urlquote"""
           return urllib.quote(txt)
       
       def searchRel(self,relStatement,statement,wherePart,classes):
           """suche relative haufigkeiten"""
           ret={}
           allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
           
           for oneclass in classes:
               ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))
           
           return (ret,allRecords)
                     
       def content_html(self):
           """template fuer content"""
           
           try:
               obj=getattr(self,"ZSQLBibliography_template")
               return obj()
           except:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt'),content_type='text/html').__of__(self)
               pt.content_type="text/html"
               
               return pt()
   
           
       def getWeight(self):
           """getLabe"""
           try:
               return self.weight
           except:
               return ""
   
       def getLabel(self):
           """getLabe"""
           try:
               return self.label
           except:
               return ""
   
       def getDescription(self):
           """getLabe"""
           try:
               return self.description
           except:
               return ""
   
       manage_options=Folder.manage_options+(
           {'label':'Main Config','action':'changeZSQLExtendForm'},
          )
   
       def changeZSQLExtendForm(self):
           """change folder config"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLExtendForm.zpt')).__of__(self)
           return pt()
   
   
       def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
           """change it"""
           self.connection_id=connection_id
           self.weight=weight
           self.label=label
           self.description=description
           
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
   
       def formatAscii(self,str,url=None):
           """ersetze ascii umbrueche durch <br>"""
           #url=None
           str=str.rstrip().lstrip()
           
           if url and str:
               
               retStr=""
               words=str.split("\n")
               
               for word in words:
                   strUrl=url%word
                   #print "str",strUrl
                   retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
               str=retStr
           if str:
               return re.sub(r"[\n]","<br/>",str)
           else:
               return ""
           
       def getSAttribute(self,obj,atribute,pref=''):
           """get Attribute or emptystring"""
           
           #print "obj",obj
           try:
               return pref+getattr(obj,atribute)
           except:
               return ""
           
       def getS(self,str):
           """make none to empty string"""
           if str:
               return str
           else:
               return ""
   
       def actualPath(self,url=None):
       """path"""
   
           if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
               host=self.REQUEST['HTTP_HOST']
           else:
               host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
       if not url:
           return "http://"+host+self.REQUEST['PATH_TRANSLATED']
           else:
           temp=self.REQUEST[url].split("/")
           temp[2]=host
           return string.join(temp,"/")
   
       def getRequest(self):
       """request"""
       return self.REQUEST
   
     def lowerEnd(self,path):      def lowerEnd(self,path):
         """oinly for demo"""          """oinly for demo"""
Line 25  class ZSQLExtendFolder(Persistent, Impli Line 259  class ZSQLExtendFolder(Persistent, Impli
                   
     def ZSQLisEmpty(self,field):      def ZSQLisEmpty(self,field):
         """Teste ob Treffer leer"""          """Teste ob Treffer leer"""
         print "field",field          #print "field",field
         if not field:          if not field:
             return 1              return 1
         if field=="":          if field=="":
             return 1              return 1
         return 0          return 0
   
     def ZSQLsearchOptions(self):      def ZSQLsearchOptions(self,fieldname=""):
         """return HTML Fragment with search options"""          """return HTML Fragment with search options"""
         ret="""<select name="-op">      
           ret="""<select name="-op_%s">
     <option value="bw">begins with</option>             <!-- begins with / beginnt mit, "Wort*" -->      <option value="bw">begins with</option>             <!-- begins with / beginnt mit, "Wort*" -->
     <option value="ew">ends with</option>      <option value="ew">ends with</option>
     <option value="cn">contains</option>                <!-- contains / enthaellt, "Wort" -->      <option value="ct" selected>contains</option>               <!-- contains / enthaellt, "Wort" -->
     <option value="eq">equals</option>                  <!-- equals / ist, =Wort -->      <option value="eq">equals</option>                  <!-- equals / ist, =Wort -->
 </select>"""  </select>"""%fieldname
         return ret          return ret
           
       def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
           """generate select options from a cr seperated list"""
           fields=listField.split("\n")
           ret=""
           for field in fields:
               if checked and (field in checked.split("\n")):
                   ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
               else:
                   ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
           return ret
   
       def ZSQLSelectionFromSearchList(self,fieldname,results,fieldnameResult,boxType="checkbox",checked=None):
           """generate select options from a cr seperated list"""
   
           ret=""
           if not results: return ""
           
           for result in results:
               field=getattr(result,fieldnameResult)
               if field:
                   if checked and (getattr(result,fieldnameResult) in checked.split("\n")):
                       ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
                   else:
                       ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
           return ret
   
   
       def ZSQLOptionsFromCRList(self,fieldname,listField, multiple='',start=None,startValue=None,size=None,selected=None):
           """generate select oprions form a cr seperated list"""
           fields=listField.split("\n")
           if size:
               ret="""<select name="%s" %s size="%s" >
               """%(fieldname,multiple,size)
   
           else:
               ret="""<select name="%s" %s >
               """%(fieldname,multiple)
           if start:
           if start==' ':
           start=''
                   if not startValue:
                       startValue=start
                       
               ret+="""<option value="%s" >%s</option>"""%(startValue,start)
           for field in fields:
               if selected and (field in selected.split("\n")):
                    ret+="""<option selected value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
               else:
                    ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
           ret+="""</select>"""
           return ret
   
       def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None,additionalSelect="",size=None,linelen=None):
           """generate select options form a search list
           es wird
           <select name=fieldname mutiple>
           <option value=startValue>start</option>
           <option value=result.fieldName>result.fieldValue</option>
           erzeugt.
           
           @parameter fieldname: Name fuer name-wert im select-tag
           @results results: Resultobject einer SQL-suche
           @parameter fieldName: Name des Feldes, das als value in den option-tag geschrieben werden soll.
           @parameter valueName: (optional) Name des Feldes, dass als im option-tag ausgegeben wird, default wert ist valueName=fieldName
           @start: (optional) falls zusaetzliches option tag erzeugt werden soll, gibt start an was im option tag steht
           @startValue: gibt den entsprechenden Wert an.
           """
           if not valueName:
               valueName=fieldName
           if size:
               ret="""<select name="%s" %s size="%s" %s>
               """%(fieldname,multiple,size,additionalSelect)
           else:
               ret="""<select name="%s" %s %s>
               """%(fieldname,multiple,additionalSelect)
           if start:
               if start==' ':
                   start=''
               
               if not startValue:
                       startValue=start
                               
               ret+="""<option value="%s" >%s</option>"""%(startValue,start)
           for result in results:
               field=getattr(result,fieldName)
               fieldValue=getattr(result,valueName)
               if fieldValue:
                   if not linelen:
                       ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
                   else:
                       mist = """%s"""%(fieldValue)
                       if len(mist) > string.atoi(linelen):
                           mist = mist[:string.atoi(linelen)]
                       ret+="""<option value="%s">%s</option>"""%(field,mist)
           ret+="""</select>"""
           return ret
   
               
       def ZSQLInlineSearchU(self,storename=None,**argv):
           """one element if exists"""
           qs=[]
           if storename:
               """store"""
               storename=storename
           else:
               storename="foundCount"
               
       
   
           #print "INLINE:",argv
           for a in argv.keys():
               qs.append(a+"="+urllib.quote(str(argv[a])))
           #return []  
           ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
   
           try:
               return ret[0]
           except:
               return None
           
     def ZSQLInlineSearch(self,storename=None,**argv):      def ZSQLInlineSearch(self,storename=None,**argv):
         """inlinesearch"""          """inlinesearch"""
           
         qs=[]          qs=[]
         if storename:          if storename:
             """store"""              """store"""
Line 54  class ZSQLExtendFolder(Persistent, Impli Line 410  class ZSQLExtendFolder(Persistent, Impli
   
         #print "INLINE:",argv          #print "INLINE:",argv
         for a in argv.keys():          for a in argv.keys():
               try:
                   qs.append(a+"="+urllib.quote(str(argv[a])))
               except:
                   import urllib
             qs.append(a+"="+urllib.quote(str(argv[a])))              qs.append(a+"="+urllib.quote(str(argv[a])))
                   
         #return []            #return []  
         return self.parseQueryString(string.join(qs,","),"_",storename=storename)          return self.parseQueryString(string.join(qs,","),"_",storename=storename)
   
Line 62  class ZSQLExtendFolder(Persistent, Impli Line 423  class ZSQLExtendFolder(Persistent, Impli
         """inlinesearch"""          """inlinesearch"""
         qs=[]          qs=[]
                   
           #print "INLINE:",query
           return self.ZSQLSimpleSearch(query)
           
   
         #print "INLINE:",query      def ZSQLSimpleSearch(self,query=None,max_rows=1000000):
           """simple search"""
           
           if not query:
               query=self.query
           
           if (hasattr(self,"_v_searchSQL") and (self._v_searchSQL == None)) or (not hasattr(self,"_v_searchSQL")):
               
               self._v_searchSQL=Shared.DC.ZRDB.DA.DA("_v_searchSQL","_v_searchSQL",self.getConnectionObj().getId(),"var","<dtml-var var>")
                   
               self._v_searchSQL.max_rows_=max_rows
               try:
                   
                   return self._v_searchSQL.__call__(var=query)
               except :
                   if sys.exc_info()[0]=="Database Error":
                       try:
                           self.getConnectionObj().manage_open_connection()
                       except:
                           zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
           else:
               try:
                   self._v_searchSQL.max_rows_=max_rows
                   
                   return self._v_searchSQL.__call__(var=query)
               except :
                   if sys.exc_info()[0]=="Database Error":
                       try:
                           self.getConnectionObj().manage_open_connection()
                       except:
                           zLOG.LOG("ZSQLSimpleSearch",zLOG.ERROR, '%s %s'%sys.exc_info()[:2])
   
       def getConnectionObj(self):
           if hasattr(self,'connection_id'):
               return getattr(self,self.connection_id)
          
                       
       def ZSQLSimpleSearch2(self,query=None):
           """ returrn SQLSearch"""
          
           if not query:
               query=self.query
           if getattr(self,'_v_search',None):
               
               return self._v_search(var=query)
           
           if hasattr(self,'search') and (self.search.meta_type=="Z SQL Method"):
               self._v_search=self.search
         return self.search(var=query)          return self.search(var=query)
           else:
               if hasattr(self.aq_parent.aq_parent,'search') and (self.aq_parent.aq_parent.search.meta_type=="Z SQL Method"):
                   self._v_search=self.aq_parent.aq_parent.search
                   return self.aq_parent.aq_parent.search(var=query)
               else:
                   search=self.ZopeFind(self,obj_metatypes=["Z SQL Method"],search_sub=1)
                   if search:
                       self._v_search=search[0][1]
                       return search[0][1](var=query)
                   else:
                       return []
       
           
     def ZSQLAdd(self):          
       def ZSQLAdd(self,format=None,RESPONSE=None,**argv):
         """Neuer Eintrag"""          """Neuer Eintrag"""
         qs=self.REQUEST['QUERY_STRING']              
           qs_temp=[]
       
           for a in self.REQUEST.form.keys():
               qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
   
           qs=string.join(qs_temp,",")
           
           for field in argv.keys():
                      if field[0]=="_":
                          fieldTmp="-"+field[1:]
                      else:
                          fieldTmp=field
                          
                      qs+=",%s=%s"%(fieldTmp,argv[field])
           
           
         addList={}          addList={}
         for q in qs.split("&"):          for q in qs.split(","):
             name=re.sub("r'+'"," ",q.split("=")[0].lower())              name=re.sub("r'+'"," ",q.split("=")[0].lower())
             value=q.split("=")[1]              value=q.split("=")[1]
         value=re.sub(r'\+'," ",value)          value=re.sub(r'\+'," ",value)
Line 81  class ZSQLExtendFolder(Persistent, Impli Line 519  class ZSQLExtendFolder(Persistent, Impli
                 table=urllib.unquote(value)                  table=urllib.unquote(value)
             elif name=="-format":              elif name=="-format":
                 format=urllib.unquote(value)                  format=urllib.unquote(value)
             elif (not name[0]=="-") and (not len(value)==0):              elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
                 addList[urllib.unquote(name)]=urllib.unquote(value)                  addList[urllib.unquote(name)]=urllib.unquote(value)
   
         keyList=[]          keyList=[]
         valueList=[]          valueList=[]
         for x in addList.keys():          for x in addList.keys():
             keyList.append("\""+x+"\"")              keyList.append("\""+x+"\"")
             valueList.append(libpq.PgQuoteString(addList[x]))              valueList.append(sql_quote(addList[x]))
   
         keyString=string.join(keyList,",")          keyString=string.join(keyList,",")
         valueString=string.join(valueList,",")          valueString=string.join(valueList,",")
                   
         queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)          queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
         self.search(var=queryString)  
         return self.REQUEST.RESPONSE.redirect(format)  
                   
     def ZSQLChange(self,**argv):          self.ZSQLSimpleSearch(queryString)
         """Ändern von Einträgen"""          
           if RESPONSE and format:
               return RESPONSE.redirect(format)
           else:
               return True
           
       def ZSQLChange(self,format=None,RESPONSE=None,USE_FORM=None,**argv):
           """change entries"""
         #qs=self.REQUEST['QUERY_STRING']          #qs=self.REQUEST['QUERY_STRING']
         # very bad hack          # very bad hack
         qs_temp=[]  
           
           qs_temp=[]
           if USE_FORM or RESPONSE:
         for a in self.REQUEST.form.keys():          for a in self.REQUEST.form.keys():
             qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))              qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
   
         qs=string.join(qs_temp,"&")  
   
           
         #print "CHANGE QS",self.REQUEST          for field in argv.keys():
         #return self.REQUEST                  
         changeList=[]                     if field[0]=="_":
         for q in qs.split("&"):                         fieldTmp="-"+field[1:]
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))                     else:
             value=q.split("=")[1]                         fieldTmp=field
             value=re.sub(r'\+'," ",value)                         
         value=urllib.unquote(value)                     qs_temp.append("%s=%s"%(fieldTmp,argv[field]))
         if name=="-table":          
                 table=urllib.unquote(value)  
             elif name=="-identify":  
                 identify=urllib.unquote(value)  
                 identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])  
             elif name=="-format":  
                 format=urllib.unquote(value)  
             elif (not name[0]=="-") and (not len(value)==0):  
                 changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))  
         changeString=string.join(changeList,",")  
         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)  
         self.search(var=queryString)  
         return self.REQUEST.RESPONSE.redirect(format)  
   
     def ZSQLChange_old(self):  
         """Ändern von Einträgen"""  
         qs=self.REQUEST['QUERY_STRING']  
         #print "CHANGE QS",self.REQUEST  
         #return self.REQUEST  
         changeList=[]          changeList=[]
         for q in qs.split("&"):          
           for q in qs_temp:
               
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))              name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
             value=q.split("=")[1]              value="=".join(q.split("=")[1:])
             value=re.sub(r'\+'," ",value)              value=re.sub(r'\+'," ",value)
         value=urllib.unquote(value)          value=urllib.unquote(value)
           
         if name=="-table":          if name=="-table":
                 table=urllib.unquote(value)                  table=urllib.unquote(value)
             elif name=="-identify":              elif name=="-identify":
                 identify=urllib.unquote(value)                  identify=urllib.unquote(value)
                 identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])                  identify=identify.split("=")[0]+"="+sql_quote(identify.split("=")[1])
             elif name=="-format":              elif name=="-format":
                 format=urllib.unquote(value)                  format=urllib.unquote(value)
             elif (not name[0]=="-") and (not len(value)==0):              elif (not (name[0]=="-" or name[0]=="_")) and (not len(value)==0):
                 changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))                  changeList.append("\""+name+"\"="+sql_quote(urllib.unquote(value)))
                   
         changeString=string.join(changeList,",")          changeString=string.join(changeList,",")
         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)          queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
         self.search(var=queryString)  
         return self.REQUEST.RESPONSE.redirect(format)  
           
     def ZSQLFind(self,qs="",select="*",storename=None):          self.ZSQLSimpleSearch(queryString)
         """Find"""          
           
           if RESPONSE and format:
               return RESPONSE.redirect(format)
           else:
               return True
      
   
       def ZSQLFindIndexed(self,qs="",select="oid,*",storename=None,indexedFields=['data_line'],restrictField='id_text',**argv):
           """find2"""
           
           for index in self.ZopeFind(self,obj_ids=indexedFields):
               txt=argv.get(index[0],None)
               if txt:
                   oids=index[1].getIndex()[txt]
   
           search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
        
           search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
           return search2
       
       def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],restrictField='id_text',**argv):
           """find2"""
   
           search1= self.ZSQLFind(qs=qs,select=select,storename=storename,tableExt=tableList[1],restrictField=restrictField,NoQuery='yes',NoLimit='yes',**argv)
        
           search2 = self.ZSQLFind(tableExt=tableList[0],qs=qs,select=select,storename=storename,restrictConnect=(tableList[0]+"."+restrictField,search1),**argv)
           return search2
       
         
       
       def ZSQLFind(self,qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,NoLimit=None,restrictField=None,restrictConnect=None,filter=None,**argv):
           """search in database"""
   
           def delEmpty(list):
               """"loesche leere elemente aus der liste"""
               ret=[]
               for x in list:
                   splitted=x.split("=")
                   if (len(splitted)>1) and not (splitted[1]==' '):
                       ret.append(x)
               return ret
   
         if qs=="":          if qs=="":
              #kein querystring ubergeben 
            if self.REQUEST['QUERY_STRING']:             if self.REQUEST['QUERY_STRING']:
                qs=self.REQUEST['QUERY_STRING']                 qs=self.REQUEST['QUERY_STRING']
                                 
                  
                qs=string.join(qs.split("&"),",")                 qs=string.join(qs.split("&"),",")
   
                  for field in argv.keys():
                      if field[0]=="_":
                          fieldTmp="-"+field[1:]
            else:             else:
                          fieldTmp=field
                          
                      qs+=",%s=%s"%(fieldTmp,argv[field])
                                 
                qs=self.REQUEST.SESSION['query']  
         else:          else:
   
                  qs=self.REQUEST.SESSION.get('query','')
                  
                  for field in argv.keys():
                      if field[0]=="_":
                          fieldTmp="-"+field[1:]
                      else:
                          fieldTmp=field
                      
                      qs+=",%s=%s"%(fieldTmp,argv[field])
   
            
   
           else:
               self.REQUEST['QUERY_STRING']=qs
   
             qs=string.join(qs.split("&"),",")              qs=string.join(qs.split("&"),",")
   
         qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.          
         #print "QS",qs          
           qs=re.sub("\\+"," ",qs)#TODO: Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
   
           qs=string.join(delEmpty(qs.split(",")),",")
   
         if storename:          if storename:
             """store"""              """store"""
         else:          else:
             storename="foundCount"              storename="foundCount"
                   
         ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)          #store query for further usage
           self.REQUEST.SESSION['query']=qs
   
           #print "calling Query with",repr(NoQuery)
           ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename,tableExt=tableExt,NoQuery=NoQuery,NoLimit=NoLimit,restrictField=restrictField,restrictConnect=restrictConnect,filter=filter)
         #print self.REQUEST.SESSION["foundCount"]          #print self.REQUEST.SESSION["foundCount"]
                   
           
   
         return ret          return ret
   
     def ZSQLFoundCountLen(self,var):      def ZSQLFoundCountLen(self,var):
Line 217  class ZSQLExtendFolder(Persistent, Impli Line 717  class ZSQLExtendFolder(Persistent, Impli
         else:          else:
             storename="foundCount"              storename="foundCount"
                   
         return self.REQUEST.SESSION[storename]['rangeStart']          return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
           
     def ZSQLRangeSize(self,storename=None):      def ZSQLRangeSize(self,storename=None):
                   
Line 235  class ZSQLExtendFolder(Persistent, Impli Line 735  class ZSQLExtendFolder(Persistent, Impli
         else:          else:
             storename="foundCount"              storename="foundCount"
                   
         return self.REQUEST.SESSION[storename]['rangeEnd']          return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
   
       def ZSQLNewQuery(self,linkText,storename=None,**argv):
           """suche neu"""
           return self.ZSQLNewSearch(linkText,storename,url=self.REQUEST['URL'],args=argv)
       
       def ZSQLNewSearch(self,linkText,storename=None,url=None,args=None,**argv):
           """suche mit alten parametern bis auf die in argv getauschten"""
   
           if storename: 
               """store"""  
           else:
               storename="foundCount"
           qs=self.REQUEST.SESSION[storename]['qs']
   
           if args:
               argv=args
               
           querys=qs.split(",")
           argList=[]
           arg=""
           queryList=[x.split("=")[0] for x in querys]
           
           for argTmp in argv.keys():
               
           
     def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):              arg=argTmp[0:]
               if arg[0]=="_":arg="-"+argTmp[1:] # aender _ in - als standard
   
               if arg not in queryList: # noch nicht drin
                   querys.append("%s=%s"%(arg,argv[argTmp]))
               argList.append(arg)
   
   
           
           newquery=[]
           for query in querys:
               queryArg=query.split("=")[0]
               qarg=queryArg[0:]
               if qarg[0]=="-":qarg="_"+queryArg[1:] # aender _ in - als standard
               
               if  queryArg in argList:
                   newquery.append("%s=%s"%(queryArg,argv[qarg]))
               else:
                   newquery.append(query)
   
           if url:
               str=url+"?"+"&".join(newquery)
           else:
               str="ZSQLSearch?"+"&".join(newquery)
           
           return """<a href="%s"> %s</a>"""%(str,linkText)
       
       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):
         """analysieren den QueryString"""          """analysieren den QueryString"""
         #print "NO",nostore          
           
           #setzte generische werte
           
         lop="AND" # standardsuche mit and          lop="AND" # standardsuche mit and
         max="ALL" #standard alle auswählen          max="ALL" #standard alle auswaehlen
           maxstr=""
         whereList=[]          whereList=[]
         sort=""          sort=""
         op="bw"          op="bw"
         opfields={}          opfields={}
           lopfields={} #Verknuepfung bei mehrfachauswahl von einem feld
           sortfields={} #order of sortfields
           sortAllFields=None
         skip=""          skip=""
         rangeStart=0          rangeStart=0
           limit=0
           searchFields={}
           searchFieldsOnly={}
           queryTemplate=[]
                   
         if not select:          if not select:
             select="*"              select="oid,*"
         #print "Q",nostore,qs  
         #check for op in the case of inline search          #check for op 
         if iCT=="_":                      splitted=qs.split(",")
             for q in qs.split(","):  
           if tableExt:
               table=tableExt
   
           if restrictField:
                       select=restrictField
                                   
                 name=re.sub("r'+'"," ",q.split("=")[0].lower())  
                 value=urllib.unquote(q.split("=")[1])  
   
           #erster durchgang suche operatoren    
           for q in splitted:
                   
                   name=re.sub("r'+'"," ",q.split("=")[0].lower())
                   try:
                       value=urllib.unquote(q.split("=",1)[1])
                   except:
                       value=""
                   #print "Hi",name[0:3],q
                 if name[0:3]==iCT+"op":                  if name[0:3]==iCT+"op":
                     op=value                      op=value
   
                     field=name[4:]                      field=name[4:]
                     opfields[field]=op                      opfields[field]=op
   
         #now analyse the querystring                  if name[0:4]==iCT+"lop":
                       lop=value
   
                       field=name[5:]
                       lopfields[field]=lop
                       
                   if name[0:10]==iCT+"sortorder":
                       #sort=value
                       
                       field=name[11:]
                       sortAllFields=None
                       #no field selected
                       if field=="":
                           sortAllFields=value
                       else:
                           sortfields[field]=value
                           
           #zweiter durchgang analysiere felder
         for q in qs.split(","):          for q in qs.split(","):
                           
                           
             #try:  
   
             name=re.sub("r'+'"," ",q.split("=")[0].lower())              name=re.sub("r'+'"," ",q.split("=")[0].lower())
             value=urllib.unquote(q.split("=")[1])              try:
             #value=libpq.PgQuoteString(value)                  value=urllib.unquote(q.split("=",1)[1])
               except:
                   value=""
                           
               punktsplit=name.split(".")   #sonderfall feld mit punkten(tabelle.suchFeld.ausgewaehltesFeld,feldinoriginal), d.h. suche in anderer tabelle:                      
                           
               #analysiere alle anderen faelle
             if name==iCT+"lop":              if name==iCT+"lop":
                 lop=value                  lop=value
             elif name==iCT+"table":              elif name==iCT+"table":
                   if not tableExt: 
                 table=value                  table=value
             elif name==iCT+"select":              elif name==iCT+"select":
                   if not restrictField:
                 select=value                  select=value
             elif name==iCT+"max":              elif name==iCT+"max":
                 max="LIMIT "+str(value)                  if not NoLimit:
                       maxstr="LIMIT "+str(value)
                 limit=str(value)                  limit=str(value)
             elif name==iCT+"skip":              elif name==iCT+"skip":
                 skip="OFFSET "+str(value)                  skip="OFFSET "+str(value)
Line 290  class ZSQLExtendFolder(Persistent, Impli Line 888  class ZSQLExtendFolder(Persistent, Impli
             elif name==iCT+"join":              elif name==iCT+"join":
                 whereList.append(value)                  whereList.append(value)
             elif name==iCT+"sort":              elif name==iCT+"sort":
                 sort="ORDER BY "+value                  sortstrs=[]
                   for word in value.split(','):
                       wordstr=word.lstrip().rstrip()
                       if sortAllFields:
                           order=sortAllFields
                       else:
                           order=sortfields.get(wordstr,'ASC')
                           
                       if not (wordstr == ""):
                           sortstrs.append(wordstr+" "+order)
                   if len(sortstrs)>0:
                       sort="ORDER BY "+string.join(sortstrs,',')
                       
                       
             elif name==iCT+"token":              elif name==iCT+"token":
                 if not nostore=="yes":                  if not nostore=="yes":
                     self.REQUEST.SESSION['token']=value                      self.REQUEST.SESSION['token']=value
Line 300  class ZSQLExtendFolder(Persistent, Impli Line 911  class ZSQLExtendFolder(Persistent, Impli
   
   
   
               elif (not name[0]==iCT) and len(punktsplit)==4:
                   if opfields.has_key(name):
                       op=opfields[name]
                   else:
                       op="ct"
                   namealt=name
                   name="LOWER("+punktsplit[1]+")" 
   
                   if op=="ct":
                       tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
                   elif op=="gt":
                       tmp=(name+">"+sql_quote(value))
                   elif op=="lt":
                       tmp=(name+"<"+sql_quote(value))
                   elif op=="eq":
                       tmp=(name+"="+sql_quote(value))
                   elif op=="bw":
                       tmp=(name+" LIKE "+sql_quote(value+"%"))
                   elif op=="ew":
                       tmp=(name+" LIKE "+sql_quote("%"+value))
                   elif op=="all":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' AND ')
   
                   elif op=="numerical":
                       term=analyseIntSearch(value)
                       tmp=(name+" "+term)
                   elif op=="grep":
                       tmp=(name+" ~* "+sql_quote(value))
                   elif op=="one":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' OR ')
   
                   op="all"
   
   
                   searchTmp="""%s in (select %s from %s where %s)"""%(punktsplit[3],punktsplit[2],punktsplit[0],tmp)
   
                   queryTemplate.append(searchTmp)
                   
             elif (not name[0]==iCT) and (not len(value)==0):              elif (not name[0]==iCT) and (not len(value)==0):
                 name="LOWER("+name+")"  
           #print "OP",op,name
                 value=value.lower()                  value=value.lower()
                   tmp=""
                 if opfields.has_key(name):                  if opfields.has_key(name):
                     op=opfields[name]                      op=opfields[name]
                   else:
                       op="ct"
                   namealt=name
                   name="LOWER("+name+")"    
                 if op=="ct":                  if op=="ct":
                     whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))                      tmp=(name+" LIKE "+sql_quote("%"+value+"%"))
                 elif op=="gt":                  elif op=="gt":
                     whereList.append(name+">"+libpq.PgQuoteString(value))                      tmp=(name+">"+sql_quote(value))
                 elif op=="lt":                  elif op=="lt":
                     whereList.append(name+"<"+libpq.PgQuoteString(value))                      tmp=(name+"<"+sql_quote(value))
                 elif op=="eq":                  elif op=="eq":
                     whereList.append(name+"="+libpq.PgQuoteString(value))                      tmp=(name+"="+sql_quote(value))
                 elif op=="bw":                  elif op=="bw":
                     whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))                      tmp=(name+" LIKE "+sql_quote(value+"%"))
                 elif op=="ew":                  elif op=="ew":
                     whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))                      tmp=(name+" LIKE "+sql_quote("%"+value))
                     op="ct"                  elif op=="all":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' AND ')
   
                   elif op=="numerical":
                       term=analyseIntSearch(value)
                       tmp=(name+" "+term)
                   elif op=="grep":
                       tmp=(name+" ~* "+sql_quote(value))
                   elif op=="one":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' OR ')
   
                   op="all"
   
                   if (not tableExt) or (namealt.split('.')[0]==tableExt):
                       if searchFields.has_key(namealt):
                           searchFields[namealt]+=lopfields.get(name,'OR')+" "+tmp
                           searchFieldsOnly[namealt]+=lopfields.get(name,'OR')+" "+value
                       else: 
                           searchFields[namealt]=tmp
                           searchFieldsOnly[namealt]=value
   
   
           whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
           whereList+=queryTemplate
                           
             #except:  
             #    print "END",value,name,Exception         
         if len(whereList)>0:          if len(whereList)>0:
             where="WHERE "+string.join(whereList," "+lop+" ")              if filter:
                   whereStr="("+string.join(whereList," "+lop+" ")+") AND "+filter
               else:
                   whereStr=string.join(whereList," "+lop+" ")
               where="WHERE "+whereStr
           else:
               if filter:
                   where="WHERE "+filter
         else:          else:
             where=""              where=""
   
           if restrictConnect:
   
               if len(where)==0:
                   where="WHERE "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
               else:
                   where+="and "+restrictConnect[0]+" in ("+restrictConnect[1]+")"
                   
         #print "QE",table          #print "QE",table
           #print (select,table,where,sort,maxstr,skip)
           query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
                   
         query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,max,skip)  
         if not nostore=="yes":          if not nostore=="yes":
                           
             self.REQUEST.SESSION['qs']=opfields              self.REQUEST.SESSION['qs']=opfields
         print "IAMHERE again:", query          #print "IAMHERE again:", query
   
           if storename and (not NoQuery):
   
               query2="SELECT count(*) FROM %s %s"%(table,where)
   
         if storename:  
             query2="SELECT count(%s) FROM %s %s"%(select,table,where)  
             #print "storing",query2  
             #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']              #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
             if not self.REQUEST.SESSION.has_key(storename):              if not self.REQUEST.SESSION.has_key(storename):
                 self.REQUEST.SESSION[storename]={}                  self.REQUEST.SESSION[storename]={}
   
               self.REQUEST.SESSION[storename]['qs']=qs #sichere Querystring
   
             if self.REQUEST.SESSION[storename].has_key('queryString2'):              if self.REQUEST.SESSION[storename].has_key('queryString2'):
                 #print "HI",storename  
                 if not self.REQUEST.SESSION[storename]['queryString2']==query2:                  if not self.REQUEST.SESSION[storename]['queryString2']==query2:
                     #print "HOOOOO",storename                      #print "HOOOOO",storename
                     self.REQUEST.SESSION[storename]['queryString2']=query2                      self.REQUEST.SESSION[storename]['queryString2']=query2
                     self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count                      try:
                           self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
                       except:
                           self.REQUEST.SESSION[storename]['count']=0
                     #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']                      #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
                                   
             else:              else:
   
                 self.REQUEST.SESSION[storename]['queryString2']=query2                  self.REQUEST.SESSION[storename]['queryString2']=query2
                 self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count                  if self.ZSQLSimpleSearch(query2):
                       self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
                   else:
                       self.REQUEST.SESSION[storename]['count']=0
                 #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']                  #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
                           
                           
Line 359  class ZSQLExtendFolder(Persistent, Impli Line 1078  class ZSQLExtendFolder(Persistent, Impli
             else:              else:
                 self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)                  self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
             self.REQUEST.SESSION[storename]['rangeSize']=limit              self.REQUEST.SESSION[storename]['rangeSize']=limit
               self.REQUEST.SESSION[storename]['searchFields']=searchFields
               self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
                           
           if not NoQuery:
   
               return self.ZSQLQuery(query)
           else:
   
               return query
   
       def ZSQLUniqueQuery(self,value,returns):
           """unique relation"""
           if returns:
               statement="""select %s from %s where %s = '%s' """%(returns[1],returns[0],returns[2],value)
               founds=self.ZSQLSimpleSearch(statement)
               if founds:
                   return getattr(founds[0],returns[1])
               else:
                   return value
           else:
               return value
           
       def ZSQLQuery(self,query,debug=None):
           """query"""
           if debug:
               zLOG.LOG("ZSQLQuery", zLOG.INFO, query)
               
           return self.ZSQLSimpleSearch(query)
                           
         return self.search(var=query)  
           
     def ZSQLSearch(self):      def ZSQLSearch(self):
         """To be done"""          """To be done"""
         rq=self.REQUEST['QUERY_STRING']  
         querys=rq.split("&")  
                   
           formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url
         
           #zerlege querystring in key value paare
           #TODO: check if this is really necessary, use argv**
   
         for querytemp in querys:          rq=self.REQUEST['QUERY_STRING']
           querys=rq.split("&")
           for querytemp in querys: #zerg
             query=querytemp.split("=")              query=querytemp.split("=")
               
             try:              try:
                 if query[0].lower()=="-format":                  if query[0].lower()=="-format":
                     formatfile=query[1]                      formatfile=query[1]
             except:              except:
                 """nothing"""                  pass
         #print formatfile          
           #sichern
         self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")          self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
           self.REQUEST.SESSION['come_from_search']="yes"
           
         return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))          return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))
   
           
Line 388  class ZSQLExtendFolder(Persistent, Impli Line 1141  class ZSQLExtendFolder(Persistent, Impli
         except:          except:
             return 0              return 0
   
       def getZSQLSearchFieldsList(self,storename="foundCount"):
           """get searchfieldList"""
           #print self.REQUEST.SESSION[storename]['searchFields'].keys()
           return  self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()
   
       def getZSQLSearchFields(self,field,storename="foundCount"):
           """get searchfield"""
           #print "SF",self.REQUEST.SESSION[storename]['searchFields']
           
           return  self.REQUEST.SESSION[storename]['searchFieldsOnly'][field]
   
                                                   
     def nextLink(self,html,storename="foundCount"):      def nextLink(self,html,storename="foundCount"):
         """nextLink"""          """nextLink"""
   
         try:          try:
             limit=self.REQUEST.SESSION[storename]['rangeSize']              limit=self.REQUEST.SESSION[storename]['rangeSize']
               if int(limit)==0 :
                   limit="1"
             newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)              newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
         except:          except:
             limit=0              limit=1
             newRangeStart=0              newRangeStart=0
                           
         if newRangeStart>self.REQUEST.SESSION[storename]['count']:          if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
             newRangeStart=self.REQUEST.SESSION[storename]['count']-10              #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
               return ""
                   
         #create new query string          #create new query string
                   
         if self.REQUEST['QUERY_STRING']=="":          if self.REQUEST['QUERY_STRING']=="":
             qs=self.REQUEST.SESSION['query']              qs=self.REQUEST.SESSION['query']
                           
             queries=string.split(qs,",")              queries=string.split(qs,",")[0:]
                           
                           
         else:          else:
             qs=self.REQUEST['QUERY_STRING']              qs=self.REQUEST['QUERY_STRING']
             queries=string.split(qs,"&")              queries=string.split(qs,"&")[0:]
                           
                           
                           
Line 420  class ZSQLExtendFolder(Persistent, Impli Line 1188  class ZSQLExtendFolder(Persistent, Impli
         skipFound=0          skipFound=0
                   
         for query in queries:          for query in queries:
             #print query.split("=")[0]                          
             if query[0]=="_" : query[0]="-"              if query[0]=="_" : query="-"+query[1:]
   
             if query.split("=")[0].lower()=="-skip":              if query.split("=")[0].lower()=="-skip":
   
                 skipFound=1                  skipFound=1
                 query="-skip=%i"%newRangeStart                  query="-skip=%i"%newRangeStart
             newquery.append(query)              newquery.append(query)
Line 433  class ZSQLExtendFolder(Persistent, Impli Line 1202  class ZSQLExtendFolder(Persistent, Impli
             newquery.append(query)              newquery.append(query)
                                   
         newquerystring=string.join(newquery,"&")          newquerystring=string.join(newquery,"&")
         return "<a href='%s'>%s</a>"%(self.REQUEST['URL0']+"?"+newquerystring,html)      return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
   
                           
                   
     def prevLink(self,html,storename="foundCount"):      def prevLink(self,html,storename="foundCount"):
         """prev link"""          """prev link"""
   
         try:          try:
             limit=self.REQUEST.SESSION[storename]['rangeSize']              limit=self.REQUEST.SESSION[storename]['rangeSize']
               if int(limit)==0 :
                   limit="1"
             newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)              newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
         except:          except:
             limit=0              limit=1
             newRangeStart=0              newRangeStart=0
           if newRangeStart <0:
               return ""
   
         #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])          #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
                   
Line 454  class ZSQLExtendFolder(Persistent, Impli Line 1229  class ZSQLExtendFolder(Persistent, Impli
                   
         if self.REQUEST['QUERY_STRING']=="":          if self.REQUEST['QUERY_STRING']=="":
             qs=self.REQUEST.SESSION['query']              qs=self.REQUEST.SESSION['query']
             #qs=re.sub(r'_','-',qs) #aendern für query              #qs=re.sub(r'_','-',qs) #aendern fuer query
             queries=string.split(qs,",")              queries=string.split(qs,",")
                           
                           
Line 484  class ZSQLExtendFolder(Persistent, Impli Line 1259  class ZSQLExtendFolder(Persistent, Impli
             newquery.append(query)              newquery.append(query)
                           
         newquerystring=string.join(newquery,"&")          newquerystring=string.join(newquery,"&")
         return "<a href='%s'>%s</a>"%(self.REQUEST['URL0']+"?"+newquerystring,html)  
           return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
   
   
           
     def prevLink_old(self,html):      def prevLink_old(self,html):
         """prev link"""          """prev link"""
Line 511  class ZSQLExtendFolder(Persistent, Impli Line 1289  class ZSQLExtendFolder(Persistent, Impli
         else:          else:
             queries.append("-offset=%i"%offsetnew)              queries.append("-offset=%i"%offsetnew)
             newquerystring=string.join(queries,"&")              newquerystring=string.join(queries,"&")
         return "<a href='%s'>%s</a>"%(self.REQUEST['URL0']+"?"+newquerystring,html)          return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
                   
     def nextLink_old(self,html):      def nextLink_old(self,html):
         """prev link"""          """prev link"""
Line 541  class ZSQLExtendFolder(Persistent, Impli Line 1319  class ZSQLExtendFolder(Persistent, Impli
             queries.append("-offset=%i"%offsetnew)              queries.append("-offset=%i"%offsetnew)
             newquerystring=string.join(queries,"&")              newquerystring=string.join(queries,"&")
                   
         return "<a href='%s'>%s</a>"%(self.REQUEST['URL0']+"?"+newquerystring,html)          return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
                   
           
 manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())  manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
   
 def manage_addZSQLExtendFolder(self, id, title='',  def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                        connection_id=None,
                      REQUEST=None):                       REQUEST=None):
     """Add a new Folder object with id *id*.      """Add a new Folder object with id *id*.
   
Line 563  def manage_addZSQLExtendFolder(self, id, Line 1342  def manage_addZSQLExtendFolder(self, id,
     ob.title=title      ob.title=title
     self._setObject(id, ob)      self._setObject(id, ob)
     ob=self._getOb(id)      ob=self._getOb(id)
       setattr(ob,'label',label)
       setattr(ob,'description',description)
       setattr(ob,'connection_id',connection_id)
   
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
   
Line 585  def manage_addZSQLExtendFolder(self, id, Line 1367  def manage_addZSQLExtendFolder(self, id,
         return self.manage_main(self, REQUEST, update_menu=1)          return self.manage_main(self, REQUEST, update_menu=1)
   
           
   
   class ZSQLBibliography(Folder,ZSQLExtendFolder):
       """Bibliography"""
       meta_type="ZSQLBibliography"
       def getLabel(self):
           try:
               return self.label
           except:
               return ""
   
       def getDescription(self):
           try:
               return self.description
           except:
               return ""
               
       def changeZSQLBibliographyForm(self):
           """change folder config"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLBibliographyForm.zpt')).__of__(self)
           return pt()
   
   
       def content_html(self):
           """template fuer content"""
           
           try:
               obj=getattr(self,"ZSQLBibliography_template")
               return obj()
           except:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt')).__of__(self)
               pt.content_type="text/html"
               return pt()
   
       def changeZSQLBibliography(self,tableName,label,description,connection_id=None,REQUEST=None):
           """change it"""
           self.connection_id=connection_id
           self.tableName=tableName
           self.label=label
           self.description=description
           
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
   
       manage_options=Folder.manage_options+(
           {'label':'Main Config','action':'changeZSQLBibliographyForm'},
           {'label':'Generate RDF Template','action':'generateRDFTemplate'},
           {'label':'Generate XML Template','action':'generateXMLTemplate'},
          )
   
   
       def getFieldLabel(self,fields,field):
           """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
               else:
                   return ret
           except:
               return field
           
       def getFieldValue(self,found,field):
           """get value"""
           try:
               ret=getattr(found,field)
               if ret == "":
                   return None
               else:
                   return ret
           except:
               return None
   
       def findTagsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
           #print referenceType,referenceTypeF[1].title
           if referenceTypeF[1].title == referenceType: 
               bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                       if referenceTypeF[1].getValue(field)[0]==None:
                   retdata[field]=field
                   else:
                                   retdata[field]=referenceTypeF[1].getValue(field)[0]
   
           return retdata,fieldlist
           
       def findLabelsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
           #print referenceType,referenceTypeF[1].title
           if referenceTypeF[1].title == referenceType: 
               bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[1]
   
           return retdata,fieldlist
   
       def createRDFTag(self,tag,content,namespace="cdli"):
           """create RDF"""
           if content:
               tag=namespace+":"+tag
               if (type(content) is StringType) or (type(content) is UnicodeType):
                   ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
               else:
                   ret=""" <%s>%s</%s>"""%(tag,content,tag)
               return ret.decode('latin-1')
           else:
               return ""
       
       def createIndexTag(self,tag,content):
           """create tag"""
           
           if content:
               if (type(content) is StringType) or (type(content) is UnicodeType):
                   ret=""" <%s>%s</%s>"""%(tag,escape(content),tag)
               else:
                   ret=""" <%s>%s</%s>"""%(tag,content,tag)
               return ret.decode('latin-1')
   
           else:
               return ""
       
       def getXML2(self):
           """crate index meta"""
   
           fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
           self.REQUEST['fn']=fn
   
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record2.xml')).__of__(self)
           pt.content_type="text/xml"
           return pt()
   
   
       def generateRDFTemplate(self,REQUEST=None):
           """generateRDFtemplate"""
           zt=ZopePageTemplate('record.rdf')
           self._setObject('record.rdf',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                             'zpt','record.rdf')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/xml')
   
   
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
   
       def generateXMLTemplate(self,REQUEST=None):
           """generateXMLtemplate"""
           zt=ZopePageTemplate('record.xml')
           self._setObject('record.xml',zt)
           default_content_fn = os.path.join(package_home(globals()),
                                             'zpt','record.xml')
           text = open(default_content_fn).read()
           zt.pt_edit(text, 'text/xml')
   
   
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
       def getMetaDataRDF(self):
           """crate index meta"""
           find=self.ZopeFind(self,obj_ids=["record.rdf"])
           if not find:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.rdf')).__of__(self)
               pt.content_type="text/xml"
               return pt()
           else:
               return find[0][1]()
   
       def getMetaDataXML(self):
           """crate index meta"""
           find=self.ZopeFind(self,obj_ids=["record.xml"])
           if not find:
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.xml')).__of__(self)
               pt.content_type="text/xml"
               return pt()
           else:
               return find[0][1]()
   
   
       def getMetaDatasXML(self):
           """index"""
           # check if the request's host part was OK
           http_host = self.REQUEST['HTTP_HOST']
           host_port = self.REQUEST['SERVER_PORT']
           fix_host = None
           if http_host and http_host.rfind(host_port) == -1:
               print "HTTP_HOST needs fixing!"
               fix_host = http_host + ":" + host_port
           
           ret="""<?xml version="1.0" ?>
                    <index>"""
           for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
               base_url = self.absolute_url()
               if fix_host:
                   #print "replacing ", http_host, " by ", fix_host
                   base_url = string.replace(base_url, http_host, fix_host, 1)
                   
               link=base_url+"/"+"record.html?oid=%i"%found.oid
               metalink=base_url+"/"+"getMetaDataXML?oid=%i"%found.oid
               
               ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
               
           return ret+"\n</index>"
   
       
   manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
   
   def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
                        createPublic=0,
                        createUserF=0,
                        connection_id=None,
                        REQUEST=None):
       """Add a new Folder object with id *id*.
   
       If the 'createPublic' and 'createUserF' parameters are set to any true
       value, an 'index_html' and a 'UserFolder' objects are created respectively
       in the new folder.
       """
       
       
       ob=ZSQLBibliography()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
       setattr(ob,'tableName',tableName)
       setattr(ob,'label',label)
       setattr(ob,'description',description)
       setattr(ob,'connection_id',connection_id)
       
       checkPermission=getSecurityManager().checkPermission
   
       if createUserF:
           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
   
       if createPublic:
           if not checkPermission('Add Page Templates', ob):
               raise Unauthorized, (
                     'You are not authorized to add Page Templates.'
                     )
           ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
               id='index_html', title='')
   
       if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
   
       
   
       
Removed from v.1.5  
changed lines
  Added in v.1.74

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