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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.21 and 1.39

version 1.21, 2004/07/12 17:01:55 version 1.39, 2004/10/05 17:48:50
Line 5  from Globals import DTMLFile Line 5  from Globals import DTMLFile
 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
   
   from Products.ZSQLMethods.SQL import SQLConnectionIDs
   import Shared.DC.ZRDB.DA
   
   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
   
 class ZSQLExtendFolder(Persistent, Implicit, Folder):  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 searchRel(self,relStatement,statement,wherePart,classes):
           """suche relative haufigkeiten"""
           ret={}
           allRecords=len(self.ZSQLSimpleSearch(statement + " where "+wherePart))
           print statement + " where "+wherePart
           for oneclass in classes:
               ret[oneclass]=len(self.ZSQLSimpleSearch(statement + " where ("+wherePart+") and "+ relStatement%oneclass))
               print statement + " where ("+wherePart+") and "+ relStatement%oneclass
           return (ret,allRecords)
                     
     def content_html(self):      def content_html(self):
         """template fuer content"""          """template fuer content"""
                   
Line 60  class ZSQLExtendFolder(Persistent, Impli Line 90  class ZSQLExtendFolder(Persistent, Impli
         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 158  class ZSQLExtendFolder(Persistent, Impli Line 188  class ZSQLExtendFolder(Persistent, Impli
         return ret          return ret
   
   
     def ZSQLOptionsFromCRList(self,fieldname,listField):      def ZSQLOptionsFromCRList(self,fieldname,listField, multiple=''):
         """generate select oprions form a cr seperated list"""          """generate select oprions form a cr seperated list"""
         fields=listField.split("\n")          fields=listField.split("\n")
         ret="""<select name="%s">          ret="""<select name="%s" %s>
             """%fieldname              """%(fieldname,multiple)
         for field in fields:          for field in fields:
             ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))              ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
         ret+="""</select>"""          ret+="""</select>"""
         return ret          return ret
   
     def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None):      def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None, multiple='',startValue=None):
         """generate select oprions form a cr seperated list"""          """generate select oprions form a search list seperated list"""
         if not valueName:          if not valueName:
             valueName=fieldName              valueName=fieldName
                           
         ret="""<select name="%s">          ret="""<select name="%s" %s>
             """%fieldname              """%(fieldname,multiple)
         if start:          if start:
         if start==' ':          if start==' ':
         start=''          start=''
             ret+="""<option value="%s">%s</option>"""%(start,start)                  if not startValue:
                       startValue=start
                       
               ret+="""<option value="%s">%s</option>"""%(startValue,start)
         for result in results:          for result in results:
             field=getattr(result,fieldName)              field=getattr(result,fieldName)
             fieldValue=getattr(result,valueName)              fieldValue=getattr(result,valueName)
Line 187  class ZSQLExtendFolder(Persistent, Impli Line 220  class ZSQLExtendFolder(Persistent, Impli
         return ret          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"""
Line 211  class ZSQLExtendFolder(Persistent, Impli Line 264  class ZSQLExtendFolder(Persistent, Impli
           
   
         #print "INLINE:",query          #print "INLINE:",query
           return self.ZSQLSimpleSearch(query)
           
                   
       def ZSQLSimpleSearch(self,query=None):
           """ returrn SQLSearch"""
           if not query:
               query=self.query
              
           if self.search.meta_type=="Z SQL Method":
         return self.search(var=query)          return self.search(var=query)
           else:
               if self.aq_parent.aq_parent.search.meta_type=="Z SQL Method":
                   return self.aq_parent.aq_parent.search(var=query)
               else:
                   return []
       
           
           
     def ZSQLAdd(self):      def ZSQLAdd(self):
         """Neuer Eintrag"""          """Neuer Eintrag"""
Line 234  class ZSQLExtendFolder(Persistent, Impli Line 302  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 267  class ZSQLExtendFolder(Persistent, Impli Line 335  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):      def ZSQLChange_old(self):
         """Ändern von Einträgen"""          """change entries"""
         qs=self.REQUEST['QUERY_STRING']          qs=self.REQUEST['QUERY_STRING']
         #print "CHANGE QS",self.REQUEST          #print "CHANGE QS",self.REQUEST
         #return self.REQUEST          #return self.REQUEST
Line 292  class ZSQLExtendFolder(Persistent, Impli Line 360  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 ZSQLFind(self,qs="",select="oid,*",storename=None,**argv):  
   
       def ZSQLFind2(self,qs="",select="oid,*",storename=None,tableList=['cdli_translit','cdli_cat'],**argv):
           """find2"""
           #search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_translit',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)
   
           
           #search2 = self.ZSQLFind(tableExt='cdli_cat',qs="",select="oid,*",storename=None,restrictConnect=('cdli_cat.id_text',search1),**argv)
   
           search1= self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt='cdli_cat',restrictField='id_text',NoQuery='yes',NoLimit='yes',**argv)
   
           search2 = self.ZSQLFind(tableExt='cdli_translit',qs="",select="oid,*",storename=None,restrictConnect=('cdli_translit.id_text',search1),**argv)
           return search2
       
           #return self.ZSQLFind(qs="",select="oid,*",storename=None,tableExt=None,NoQuery=None,**argv)
       
       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):          def delEmpty(list):
Line 313  class ZSQLExtendFolder(Persistent, Impli Line 397  class ZSQLExtendFolder(Persistent, Impli
                     ret.append(x)                      ret.append(x)
             return ret              return ret
                           
           #self.REQUEST.SESSION['come_from_search']="no" # zurücksetzen
         if qs=="":          if qs=="":
              
            if self.REQUEST['QUERY_STRING']:             if self.REQUEST['QUERY_STRING']:
                qs=self.REQUEST['QUERY_STRING']                 qs=self.REQUEST['QUERY_STRING']
                                 
Line 323  class ZSQLExtendFolder(Persistent, Impli Line 409  class ZSQLExtendFolder(Persistent, Impli
                for field in argv.keys():                 for field in argv.keys():
                                         
                    qs+=",-%s=%s"%(field,argv[field])                     qs+=",-%s=%s"%(field,argv[field])
                #print qs                     
            else:             else:
                                 
                qs=self.REQUEST.SESSION['query']                 qs=self.REQUEST.SESSION.get('query','')
                  
                  for field in argv.keys():
                      #print field
                      qs+=",-%s=%s"%(field,argv[field])
                                 
         else:          else:
             self.REQUEST['QUERY_STRING']=qs              self.REQUEST['QUERY_STRING']=qs
Line 345  class ZSQLExtendFolder(Persistent, Impli Line 435  class ZSQLExtendFolder(Persistent, Impli
             storename="foundCount"              storename="foundCount"
   
   
                   #print "calling Query with",repr(NoQuery)
         ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)          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"]
                   
                   
Line 403  class ZSQLExtendFolder(Persistent, Impli Line 493  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 parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):      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          #print "NO",nostore
         lop="AND" # standardsuche mit and          lop="AND" # standardsuche mit and
Line 415  class ZSQLExtendFolder(Persistent, Impli Line 505  class ZSQLExtendFolder(Persistent, Impli
         sort=""          sort=""
         op="bw"          op="bw"
         opfields={}          opfields={}
           lopfields={} #Verknüpfung bei mehrfachauswahl von einem feld
           sortfields={} #order of sortfields
         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 441  class ZSQLExtendFolder(Persistent, Impli Line 537  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
Line 455  class ZSQLExtendFolder(Persistent, Impli Line 569  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 473  class ZSQLExtendFolder(Persistent, Impli Line 590  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 487  class ZSQLExtendFolder(Persistent, Impli Line 617  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))
                   elif op=="all":
                       tmps=[]
                       for word in value.split(" "):
                           tmps.append(name+" LIKE "+sql_quote("%"+word+"%"))
                           
                       tmp=string.join(tmps,' AND ')
                       
                 op="ct"                  op="ct"
                           
             #except:                  if (not tableExt) or (namealt.split('.')[0]==tableExt):
             #    print "END",value,name,Exception                             if searchFields.has_key(name):
                           searchFields[name]+=lopfields.get(name,'OR')+" "+tmp
                           searchFieldsOnly[name]+=lopfields.get(name,'OR')+" "+value
                       else: 
                           searchFields[name]=tmp
                           searchFieldsOnly[name]=value
   
           whereList=["("+searchFields[x]+")" for x in searchFields.keys()]
   
         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 524  class ZSQLExtendFolder(Persistent, Impli Line 683  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]={}
             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 551  class ZSQLExtendFolder(Persistent, Impli Line 712  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
           #print "QS", query
           if not NoQuery:
                           
     #print "Q",query              
         return self.ZSQLQuery(query)          return self.ZSQLQuery(query)
           else:
   
               return query
   
     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"""
Line 573  class ZSQLExtendFolder(Persistent, Impli Line 739  class ZSQLExtendFolder(Persistent, Impli
             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 587  class ZSQLExtendFolder(Persistent, Impli Line 756  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"):
Line 603  class ZSQLExtendFolder(Persistent, Impli Line 773  class ZSQLExtendFolder(Persistent, Impli
                 limit="1"                  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 629  class ZSQLExtendFolder(Persistent, Impli Line 799  class ZSQLExtendFolder(Persistent, Impli
         skipFound=0          skipFound=0
                   
         for query in queries:          for query in queries:
             print query                          
             #print query.split("=")[0]              if query[0]=="_" : query="-"+query[1:]
             if query[0]=="_" : query[0]="-"  
   
             if query.split("=")[0].lower()=="-skip":              if query.split("=")[0].lower()=="-skip":
                 print "d", newRangeStart  
                 skipFound=1                  skipFound=1
                 query="-skip=%i"%newRangeStart                  query="-skip=%i"%newRangeStart
             newquery.append(query)              newquery.append(query)
Line 656  class ZSQLExtendFolder(Persistent, Impli Line 825  class ZSQLExtendFolder(Persistent, Impli
                 limit="1"                  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 766  manage_addZSQLExtendFolderForm=DTMLFile( Line 937  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 782  def manage_addZSQLExtendFolder(self, id, Line 954  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 887  class ZSQLBibliography(Folder,ZSQLExtend Line 1060  class ZSQLBibliography(Folder,ZSQLExtend
             bibdata['data']=referenceTypeF[1]              bibdata['data']=referenceTypeF[1]
             self.fields=bibdata[referenceType]              self.fields=bibdata[referenceType]
                         for field in fieldlist:                          for field in fieldlist:
                       if referenceTypeF[1].getValue(field)[0]==None:
                   retdata[field]=field
                   else:
                             retdata[field]=referenceTypeF[1].getValue(field)[0]                              retdata[field]=referenceTypeF[1].getValue(field)[0]
   
         return retdata,fieldlist          return retdata,fieldlist
Line 917  class ZSQLBibliography(Folder,ZSQLExtend Line 1093  class ZSQLBibliography(Folder,ZSQLExtend
         else:          else:
             return ""              return ""
           
       def getMetaDataXML2(self):
           """crate index meta"""
   
           fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
           self.REQUEST['fn']=fn
   
           pt=PageTemplateFile('Products/ZSQLExtend/zpt/record2.xml').__of__(self)
           pt.content_type="text/xml"
           return pt()
   
     def getMetaDataXML(self):      def getMetaDataXML(self):
         """crate index meta"""          """crate index meta"""
         pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)          pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)
Line 925  class ZSQLBibliography(Folder,ZSQLExtend Line 1111  class ZSQLBibliography(Folder,ZSQLExtend
   
     def getMetaDatasXML(self):      def getMetaDatasXML(self):
         """index"""          """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" ?>          ret="""<?xml version="1.0" ?>
                  <index>"""                   <index>"""
         for found in self.search(var="select oid from %s"%self.tableName):          for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
             link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid              base_url = self.absolute_url()
             metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid              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)              ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
                           
         return ret+"\n</index>"          return ret+"\n</index>"
           
       
 manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())  manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
   
 def manage_addZSQLBibliography(self, id, tableName,label,description,title='',  def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
Removed from v.1.21  
changed lines
  Added in v.1.39

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