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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.17 and 1.53

version 1.17, 2004/05/17 15:41:39 version 1.53, 2005/01/12 19:13:34
Line 1 Line 1
 from OFS.Folder import Folder  from OFS.Folder import Folder
 from Globals import Persistent  from Globals import Persistent
 from Acquisition import Implicit  from Acquisition import Implicit
 from Globals import DTMLFile  from Globals import DTMLFile,package_home
 import urllib  import urllib
 import re  import re
 import string  import string
 from pyPgSQL import libpq  #from pyPgSQL import libpq
 from AccessControl import getSecurityManager  from AccessControl import getSecurityManager
 import os.path  import os.path
 from Products.PageTemplates.PageTemplateFile import PageTemplateFile  from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   
 def quoteString(name):  from Products.ZSQLMethods.SQL import SQLConnectionIDs
     #return re.sub(r'([\(\)\?])',"\\\1",name)  import Shared.DC.ZRDB.DA
     #return "Euklid"  
     return name  
   
   def analyseIntSearch(word):
       #analyse integer searches
   
       splitted=word.split("-")
   
 class ZSQLExtendFolder(Persistent, Implicit, Folder):      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=join(split(v,dkey),quote_dict[dkey])
       return "'%s'" % v
   
   def showSQLConnectionIDs(self):
       return SQLConnectionIDs(self)
   
   class ZSQLExtendFolder(Folder,Persistent, Implicit):
     """Folder"""      """Folder"""
     meta_type="ZSQLExtendFolder"      meta_type="ZSQLExtendFolder"
   
       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):      def content_html(self):
         """template fuer content"""          """template fuer content"""
                   
Line 28  class ZSQLExtendFolder(Persistent, Impli Line 74  class ZSQLExtendFolder(Persistent, Impli
             obj=getattr(self,"ZSQLBibliography_template")              obj=getattr(self,"ZSQLBibliography_template")
             return obj()              return obj()
         except:          except:
             pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt'),content_type='text/html').__of__(self)
             pt.content_type="text/html"              pt.content_type="text/html"
               
             return pt()              return pt()
   
                   
Line 60  class ZSQLExtendFolder(Persistent, Impli Line 107  class ZSQLExtendFolder(Persistent, Impli
   
     def changeZSQLExtendForm(self):      def changeZSQLExtendForm(self):
         """change folder config"""          """change folder config"""
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLExtendForm.zpt')).__of__(self)
         return pt()          return pt()
   
   
     def changeZSQLExtend(self,label,description,weight=0,REQUEST=None):      def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
         """change it"""          """change it"""
           self.connection_id=connection_id
         self.weight=weight          self.weight=weight
         self.label=label          self.label=label
         self.description=description          self.description=description
Line 150  class ZSQLExtendFolder(Persistent, Impli Line 197  class ZSQLExtendFolder(Persistent, Impli
 </select>"""%fieldname  </select>"""%fieldname
         return ret          return ret
           
       def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
           """generate select oprions form 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 ZSQLOptionsFromCRList(self,fieldname,listField, multiple=''):
           """generate select oprions form a cr seperated list"""
           fields=listField.split("\n")
           ret="""<select name="%s" %s>
               """%(fieldname,multiple)
           for field in fields:
               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=""):
           """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
               
           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:
                   ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
           ret+="""</select>"""
           return ret
   
               
       def ZSQLInlineSearchU(self,storename=None,**argv):
           """one element if exists"""
           qs=[]
           if storename:
               """store"""
           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 162  class ZSQLExtendFolder(Persistent, Impli Line 289  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 173  class ZSQLExtendFolder(Persistent, Impli Line 305  class ZSQLExtendFolder(Persistent, Impli
           
   
         #print "INLINE:",query          #print "INLINE:",query
           return self.ZSQLSimpleSearch(query)
           
   
       def ZSQLSimpleSearch(self,query=None):
           """ returrn SQLSearch"""
           #print "hi",query
           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):
         """Neuer Eintrag"""          """Neuer Eintrag"""
Line 196  class ZSQLExtendFolder(Persistent, Impli Line 354  class ZSQLExtendFolder(Persistent, Impli
         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)          self.ZSQLSimpleSearch(queryString)
         return self.REQUEST.RESPONSE.redirect(format)          return self.REQUEST.RESPONSE.redirect(format)
                   
     def ZSQLChange(self,**argv):      def ZSQLChange(self,**argv):
         """Ändern von Einträgen"""          """change entries"""
         #qs=self.REQUEST['QUERY_STRING']          #qs=self.REQUEST['QUERY_STRING']
         # very bad hack          # very bad hack
         qs_temp=[]          qs_temp=[]
Line 229  class ZSQLExtendFolder(Persistent, Impli Line 387  class ZSQLExtendFolder(Persistent, Impli
                 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]=="-") 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)          self.ZSQLSimpleSearch(queryString)
         return self.REQUEST.RESPONSE.redirect(format)          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=[]  
         for q in qs.split("&"):  
             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))  
             value=q.split("=")[1]  
             value=re.sub(r'\+'," ",value)  
         value=urllib.unquote(value)  
         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 ZSQLFind(self,qs="",select="oid,*",storename=None,**argv):  
       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):
         """Find"""          """Find"""
   
           def delEmpty(list):
               ret=[]
               for x in list:
                   splitted=x.split("=")
                   if (len(splitted)>1) and not (splitted[1]==' '):
                       ret.append(x)
               return ret
   
   
   
           #self.REQUEST.SESSION['come_from_search']="no" # zuruecksetzen
         if qs=="":          if qs=="":
              
            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():                 for field in argv.keys():
                    qs+=",-%s=%s"%(field,argv[field])                     if field[0]=="_":
                print qs                         fieldTmp="-"+field[1:]
            else:             else:
                          fieldTmp=field
                          
                      qs+=",%s=%s"%(fieldTmp,argv[field])
                      
              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])
   
            
                                 
                qs=self.REQUEST.SESSION['query']  
         else:          else:
             self.REQUEST['QUERY_STRING']=qs              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.          qs=re.sub("\\+"," ",qs)# 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"
         #print "QS",qs  
         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 330  class ZSQLExtendFolder(Persistent, Impli Line 513  class ZSQLExtendFolder(Persistent, Impli
         else:          else:
             storename="foundCount"              storename="foundCount"
                   
         return self.REQUEST.SESSION[storename]['rangeStart']+1          return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
           
     def ZSQLRangeSize(self,storename=None):      def ZSQLRangeSize(self,storename=None):
                   
Line 348  class ZSQLExtendFolder(Persistent, Impli Line 531  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          
           
         lop="AND" # standardsuche mit and          lop="AND" # standardsuche mit and
         max="ALL" #standard alle auswählen          max="ALL" #standard alle auswaehlen
         maxstr=""          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          limit=0
         searchFields={}          searchFields={}
                   searchFieldsOnly={}
         if not select:          if not select:
             select="oid,*"              select="oid,*"
         #print "Q",nostore,qs          #print "Q",nostore,qs
         #check for op in the case of inline search          #check for op 
   
   
   
                   
     splitted=qs.split(",")      splitted=qs.split(",")
           if tableExt:
               table=tableExt
           
           if restrictField:
                       select=restrictField
                           
         for q in splitted:          for q in splitted:
                                   
Line 386  class ZSQLExtendFolder(Persistent, Impli Line 631  class ZSQLExtendFolder(Persistent, Impli
   
                     field=name[4:]                      field=name[4:]
                     opfields[field]=op                      opfields[field]=op
   
                   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
                       
                     #print "HI",op,field                      #print "HI",op,field
     #print opfieldsa      #print opfieldsa
         #now analyse the querystring          #now analyse the querystring
          
         for q in qs.split(","):          for q in qs.split(","):
                           
                           
Line 400  class ZSQLExtendFolder(Persistent, Impli Line 664  class ZSQLExtendFolder(Persistent, Impli
             except:              except:
                 value=""                  value=""
                                   
             #value=libpq.PgQuoteString(value)              #value=sql_quote(value)
                           
                           
             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":
                   if not NoLimit:
                 maxstr="LIMIT "+str(value)                  maxstr="LIMIT "+str(value)
                 limit=str(value)                  limit=str(value)
             elif name==iCT+"skip":              elif name==iCT+"skip":
Line 418  class ZSQLExtendFolder(Persistent, Impli Line 685  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 432  class ZSQLExtendFolder(Persistent, Impli Line 712  class ZSQLExtendFolder(Persistent, Impli
                                   
         #print "OP",op,name          #print "OP",op,name
                 value=value.lower()                  value=value.lower()
                   tmp=""
                 searchFields[name]=value  
                   
                 if opfields.has_key(name):                  if opfields.has_key(name):
                     op=opfields[name]                      op=opfields[name]
         else:          else:
             op="ct"              op="ct"
                   namealt=name
         name="LOWER("+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()]
                           
             #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=""
         #print "QE",table  
                   
           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 (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,maxstr,skip)
                   
         if not nostore=="yes":          if not nostore=="yes":
Line 469  class ZSQLExtendFolder(Persistent, Impli Line 791  class ZSQLExtendFolder(Persistent, Impli
             self.REQUEST.SESSION['qs']=opfields              self.REQUEST.SESSION['qs']=opfields
         #print "IAMHERE again:", query          #print "IAMHERE again:", query
   
         if storename:          if storename and (not NoQuery):
             query2="SELECT count(*) FROM %s %s"%(table,where)              query2="SELECT count(*) FROM %s %s"%(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                      self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
   
                     #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                  self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
                 #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']                  #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
                           
                           
Line 496  class ZSQLExtendFolder(Persistent, Impli Line 823  class ZSQLExtendFolder(Persistent, Impli
                 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]['searchFields']=searchFields
               self.REQUEST.SESSION[storename]['searchFieldsOnly']=searchFieldsOnly
   
           if not NoQuery:
                           
     #print "Q",query              
         return self.ZSQLQuery(query)          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):      def ZSQLQuery(self,query):
         """query"""          """query"""
         return self.search(var=query)  
           return self.ZSQLSimpleSearch(query)
   
           
     def ZSQLSearch(self):      def ZSQLSearch(self):
         """To be done"""          """To be done"""
         rq=self.REQUEST['QUERY_STRING']          rq=self.REQUEST['QUERY_STRING']
   
         querys=rq.split("&")          querys=rq.split("&")
                   
   
           formatfile=self.REQUEST['URL1'] #generisch redirect zur gleichen url
           
         for querytemp in querys:          for querytemp in querys:
             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"""                  """nothing"""
   
                   
         #print formatfile                  #print formatfile        
           
           
         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 532  class ZSQLExtendFolder(Persistent, Impli Line 891  class ZSQLExtendFolder(Persistent, Impli
     def getZSQLSearchFieldsList(self,storename="foundCount"):      def getZSQLSearchFieldsList(self,storename="foundCount"):
         """get searchfieldList"""          """get searchfieldList"""
         #print self.REQUEST.SESSION[storename]['searchFields'].keys()          #print self.REQUEST.SESSION[storename]['searchFields'].keys()
         return  self.REQUEST.SESSION[storename]['searchFields'].keys()          return  self.REQUEST.SESSION[storename]['searchFieldsOnly'].keys()
   
     def getZSQLSearchFields(self,storename="foundCount"):      def getZSQLSearchFields(self,field,storename="foundCount"):
         """get searchfield"""          """get searchfield"""
         #print "SF",self.REQUEST.SESSION[storename]['searchFields']          #print "SF",self.REQUEST.SESSION[storename]['searchFields']
         return  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 572  class ZSQLExtendFolder(Persistent, Impli Line 935  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 585  class ZSQLExtendFolder(Persistent, Impli Line 949  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['URL']+"?"+newquerystring,html)
           
         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+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 607  class ZSQLExtendFolder(Persistent, Impli Line 976  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 638  class ZSQLExtendFolder(Persistent, Impli Line 1007  class ZSQLExtendFolder(Persistent, Impli
                           
         newquerystring=string.join(newquery,"&")          newquerystring=string.join(newquery,"&")
   
         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)          return "<a href='%s'>%s</a>"%(self.REQUEST['URL']+"?"+newquerystring,html)
   
   
           
Line 705  manage_addZSQLExtendFolderForm=DTMLFile( Line 1074  manage_addZSQLExtendFolderForm=DTMLFile(
 def manage_addZSQLExtendFolder(self, id, title='', label='', description='',  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 721  def manage_addZSQLExtendFolder(self, id, Line 1091  def manage_addZSQLExtendFolder(self, id,
     ob=self._getOb(id)      ob=self._getOb(id)
     setattr(ob,'label',label)      setattr(ob,'label',label)
     setattr(ob,'description',description)      setattr(ob,'description',description)
       setattr(ob,'connection_id',connection_id)
           
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
   
Line 761  class ZSQLBibliography(Folder,ZSQLExtend Line 1132  class ZSQLBibliography(Folder,ZSQLExtend
                           
     def changeZSQLBibliographyForm(self):      def changeZSQLBibliographyForm(self):
         """change folder config"""          """change folder config"""
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','changeZSQLBibliographyForm.zpt')).__of__(self)
         return pt()          return pt()
   
   
Line 772  class ZSQLBibliography(Folder,ZSQLExtend Line 1143  class ZSQLBibliography(Folder,ZSQLExtend
             obj=getattr(self,"ZSQLBibliography_template")              obj=getattr(self,"ZSQLBibliography_template")
             return obj()              return obj()
         except:          except:
             pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)              pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','ZSQLBibliography_template_standard.zpt')).__of__(self)
             pt.content_type="text/html"              pt.content_type="text/html"
             return pt()              return pt()
   
Line 811  class ZSQLBibliography(Folder,ZSQLExtend Line 1182  class ZSQLBibliography(Folder,ZSQLExtend
                 return ret                  return ret
         except:          except:
             return None              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):      def findLabelsFromMapping(self,referenceType):
         """gib hash mit label -> generic zurueck"""          """gib hash mit label -> generic zurueck"""
         self.referencetypes=self.ZopeFind(self.standardMD)          self.referencetypes=self.ZopeFind(self.standardMD)
Line 819  class ZSQLBibliography(Folder,ZSQLExtend Line 1212  class ZSQLBibliography(Folder,ZSQLExtend
         fieldlist=self.standardMD.fieldList          fieldlist=self.standardMD.fieldList
                   
     for referenceTypeF in self.referencetypes:      for referenceTypeF in self.referencetypes:
         print referenceType,referenceTypeF[1].title          #print referenceType,referenceTypeF[1].title
         if referenceTypeF[1].title == referenceType:           if referenceTypeF[1].title == referenceType: 
             bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields              bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
             bibdata['data']=referenceTypeF[1]              bibdata['data']=referenceTypeF[1]
Line 829  class ZSQLBibliography(Folder,ZSQLExtend Line 1222  class ZSQLBibliography(Folder,ZSQLExtend
   
         return retdata,fieldlist          return retdata,fieldlist
                   
       def createRDFTag(self,tag,content):
           """create RDF"""
           if content:
               ret=""" <cdli:%s>%s</cdli:%s>"""%(tag,content,tag)
               return ret.decode('latin-1')
           else:
               return ""
       
       def createIndexTag(self,tag,content):
           """create tag"""
           if content:
               ret="""<%s>%s</%s>"""%(tag,content,tag)
               return ret
           else:
               return ""
       
       def getMetaDataXML2(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 getMetaDataRDF(self):
           """crate index meta"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.rdf')).__of__(self)
           pt.content_type="text/xml"
           return pt()
   
       def getMetaDataXML(self):
           """crate index meta"""
           pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','record.xml')).__of__(self)
           pt.content_type="text/xml"
           return pt()
   
       def createVLMAtripels(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=""
           for found in self.ZSQLSimpleSearch("select id_text from %s limit ALL"%'cdli_cat'):
               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)
   
               #found2=self.ZSQLInlineSearchU(_table="cdli_imglist",id_text=found.id_text)
               #create collectionobject info
               subject="http://xserve02.mpiwg-berlin.mpg.de:8880/cdlineu/cdli_coll/cdli2/cdli_templates/cdli_templates/textdisplay.html?-table=cdli_cat&id_text=%s"%found.id_text
               object="http://xserve02:8880/cdlidata/images/getMetaDataRDF?id_text=%s"%found.id_text
               predicate="metadata"
               ret+="%s\t%s\t%s\n"%(subject,object,predicate)
               #create image
               subject="http://xserve02.mpiwg-berlin.mpg.de:8880/cdlineu/cdli_coll/cdli2/cdli_templates/cdli_templates/textdisplay.html?-table=cdli_cat&id_text=%s"%found.id_text
               object="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn=/experimental/cdli/dl/photo/%s&mo=rawfile"%found.id_text
               predicate="image"
               
               ret+="%s\t%s\t%s\n"%(subject,object,predicate)
   
               #create thumb
               subject="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn=/experimental/cdli/dl/photo/%s&mo=rawfile"%found.id_text
               object="http://nausikaa2.mpiwg-berlin.mpg.de/digitallibrary/servlet/Scaler?fn=/experimental/cdli/dl/photo/%s&dw=100&dh=100"%found.id_text
               predicate="thumb"
               
               ret+="%s\t%s\t%s\n"%(subject,object,predicate)
       
           return ret
   
   
       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())  manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
Removed from v.1.17  
changed lines
  Added in v.1.53

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