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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.1.1.1 and 1.14

version 1.1.1.1, 2003/11/28 15:03:10 version 1.14, 2004/03/11 14:50:47
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 AccessControl import getSecurityManager  from AccessControl import getSecurityManager
   import os.path
   
   def quoteString(name):
       #return re.sub(r'([\(\)\?])',"\\\1",name)
       #return "Euklid"
       return name
   
 class ZSQLExtendFolder(Persistent, Implicit, Folder):  class ZSQLExtendFolder(Persistent, Implicit, Folder):
     """Folder"""      """Folder"""
     meta_type="ZSQLExtendFolder"      meta_type="ZSQLExtendFolder"
           
     def ZSQLInlineSearch(self,**argv):      def formatAscii(self,str,url=None):
           """ersetze ascii umbrueche durch <br>"""
           #url=None
           if url:
               
               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):
           """oinly for demo"""
           return os.path.splitext(path)[0]+".jpg"
           
       def ZSQLisEmpty(self,field):
           """Teste ob Treffer leer"""
           #print "field",field
           if not field:
               return 1
           if field=="":
               return 1
           return 0
   
       def ZSQLsearchOptions(self,fieldname=""):
           """return HTML Fragment with search options"""
       
           ret="""<select name="-op_%s">
       <option value="bw">begins with</option>             <!-- begins with / beginnt mit, "Wort*" -->
       <option value="ew">ends with</option>
       <option value="ct" selected>contains</option>               <!-- contains / enthaellt, "Wort" -->
       <option value="eq">equals</option>                  <!-- equals / ist, =Wort -->
   </select>"""%fieldname
           return ret
       
       def ZSQLInlineSearch(self,storename=None,**argv):
         """inlinesearch"""          """inlinesearch"""
         qs=[]          qs=[]
           if storename:
               """store"""
           else:
               storename="foundCount"
               
                   
                           
           #print "INLINE:",argv
         for a in argv.keys():          for a in argv.keys():
             qs.append(a+"="+urllib.quote(str(argv[a])))              qs.append(a+"="+urllib.quote(str(argv[a])))
           #return []  
           return self.parseQueryString(string.join(qs,","),"_",storename=storename)
   
       def ZSQLInlineSearch2(self,query):
           """inlinesearch"""
           qs=[]
           
       
   
           #print "INLINE:",query
   
         return self.parseQueryString(string.join(qs,","),"_")          return self.search(var=query)
           
     def ZSQLAdd(self):      def ZSQLAdd(self):
         """Neuer Eintrag"""          """Neuer Eintrag"""
Line 41  class ZSQLExtendFolder(Persistent, Impli Line 140  class ZSQLExtendFolder(Persistent, Impli
         valueList=[]          valueList=[]
         for x in addList.keys():          for x in addList.keys():
             keyList.append("\""+x+"\"")              keyList.append("\""+x+"\"")
             valueList.append("\'"+addList[x]+"\'")              valueList.append(libpq.PgQuoteString(addList[x]))
   
         keyString=string.join(keyList,",")          keyString=string.join(keyList,",")
         valueString=string.join(valueList,",")          valueString=string.join(valueList,",")
Line 50  class ZSQLExtendFolder(Persistent, Impli Line 149  class ZSQLExtendFolder(Persistent, Impli
         self.search(var=queryString)          self.search(var=queryString)
         return self.REQUEST.RESPONSE.redirect(format)          return self.REQUEST.RESPONSE.redirect(format)
                   
     def ZSQLChange(self):      def ZSQLChange(self,**argv):
           """Ändern von Einträgen"""
           #qs=self.REQUEST['QUERY_STRING']
           # very bad hack
           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,"&")
   
       
           #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 ZSQLChange_old(self):
         """Ändern von Einträgen"""          """Ändern von Einträgen"""
         qs=self.REQUEST['QUERY_STRING']          qs=self.REQUEST['QUERY_STRING']
         #print "CHANGE QS",self.REQUEST          #print "CHANGE QS",self.REQUEST
Line 65  class ZSQLExtendFolder(Persistent, Impli Line 198  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]+"=\'"+identify.split("=")[1]+"\'"                  identify=identify.split("=")[0]+"="+libpq.PgQuoteString(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+"\"=\'"+urllib.unquote(value)+"\'")                  changeList.append("\""+name+"\"="+libpq.PgQuoteString(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.search(var=queryString)
         return self.REQUEST.RESPONSE.redirect(format)          return self.REQUEST.RESPONSE.redirect(format)
           
     def ZSQLFind(self,qs="",select="*"):      def ZSQLFind(self,qs="",select="oid,*",storename=None):
         """Find"""          """Find"""
   
   
         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("&"),",")
            else:             else:
                  
                qs=self.REQUEST.SESSION['query']                 qs=self.REQUEST.SESSION['query']
         else:          else:
               self.REQUEST['QUERY_STRING']=qs
             qs=string.join(qs.split("&"),",")              qs=string.join(qs.split("&"),",")
         return self.parseQueryString(qs,"-",select=select,storemax="yes")  
   
     def ZSQLFoundCount(self,founds):  
         try:  
             return len(founds)  
         except:  
             return 0  
   
     def parseQueryString(self,qs,iCT,storemax="no",select=None):          qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
         """analysierren den QueryString"""  
           if storename:
               """store"""
           else:
               storename="foundCount"
           #print "QS",qs
           ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)
           #print self.REQUEST.SESSION["foundCount"]
           
           return ret
   
       def ZSQLFoundCountLen(self,var):
           return len(var)
               
       def ZSQLFoundCount(self,qs="",select="*",storename=None):
           
          ##  if qs=="":
               
   ##             if self.REQUEST['QUERY_STRING']:
               
   ##                 qs=self.REQUEST['QUERY_STRING']
   ##                 qs=string.join(qs.split("&"),",")
   ##             else:
               
   ##                 qs=self.REQUEST.SESSION['query']
   ##         else:
   ##             qs=string.join(qs.split("&"),",")
   
   
   ##         temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
           if storename:
               """store"""
           else:
               storename="foundCount"
           
           return self.REQUEST.SESSION[storename]['count']
   
       def ZSQLRangeStart(self,storename=None):
           
           if storename:
               """store"""
           else:
               storename="foundCount"
           
           return self.REQUEST.SESSION[storename]['rangeStart']
       
       def ZSQLRangeSize(self,storename=None):
           
           if storename:
               """store"""
           else:
               storename="foundCount"
               
           return self.REQUEST.SESSION[storename]['rangeSize']
   
       def ZSQLRangeEnd(self,storename=None):
           
           if storename:
               """store"""
           else:
               storename="foundCount"
           
           return self.REQUEST.SESSION[storename]['rangeEnd']
       
       def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):
           """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 auswählen
           maxstr=""
         whereList=[]          whereList=[]
         sort=""          sort=""
         op="bw"          op="bw"
           opfields={}
           skip=""
           rangeStart=0
           limit=0
           searchFields={}
   
         if not select:          if not select:
             select="*"              select="oid,*"
           #print "Q",nostore,qs
           #check for op in the case of inline search
                   
         for q in qs.split(","):      splitted=qs.split(",")
       
               
           for q in splitted:
                   
                   name=re.sub("r'+'"," ",q.split("=")[0].lower())
             try:              try:
                       value=urllib.unquote(q.split("=",1)[1])
                   except:
                       value=""
                   if name[0:3]==iCT+"op":
                       op=value
   
                       field=name[4:]
                       opfields[field]=op
                       #print "HI",op,field
       #print opfieldsa
           #now analyse the querystring
           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=urllib.unquote(q.split("=",1)[1])
               except:
                   value=""
                   
               #value=libpq.PgQuoteString(value)
               
   
                 if name==iCT+"lop":                  if name==iCT+"lop":
                     lop=value                      lop=value
Line 119  class ZSQLExtendFolder(Persistent, Impli Line 350  class ZSQLExtendFolder(Persistent, Impli
                 elif name==iCT+"select":                  elif name==iCT+"select":
                     select=value                      select=value
                 elif name==iCT+"max":                  elif name==iCT+"max":
                     max=str(value)                  maxstr="LIMIT "+str(value)
                   limit=str(value)
               elif name==iCT+"skip":
                   skip="OFFSET "+str(value)
                   rangeStart=str(value)
                 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                      sort="ORDER BY "+value
                 elif name==iCT+"token":                  elif name==iCT+"token":
                   if not nostore=="yes":
                     self.REQUEST.SESSION['token']=value                      self.REQUEST.SESSION['token']=value
   
                 elif name==iCT+"op":                  elif name==iCT+"op":
                     op=value                      op=value
   
   
   
                 elif (not name[0]==iCT) and (not len(value)==0):                  elif (not name[0]==iCT) and (not len(value)==0):
                   
           #print "OP",op,name
                   value=value.lower()
   
                   searchFields[name]=value
                   
                   if opfields.has_key(name):
                       op=opfields[name]
           else:
               op="ct"
           name="LOWER("+name+")"    
                     if op=="ct":                      if op=="ct":
                         whereList.append(name+"~\'.*"+value+".*\'")                      whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
                     elif op=="gt":                      elif op=="gt":
                         whereList.append(name+">\'"+value+"\'")                      whereList.append(name+">"+libpq.PgQuoteString(value))
                     elif op=="lt":                      elif op=="lt":
                         whereList.append(name+"<\'"+value+"\'")                      whereList.append(name+"<"+libpq.PgQuoteString(value))
                     elif op=="eq":                      elif op=="eq":
                         whereList.append(name+"=\'"+value+"\'")                      whereList.append(name+"="+libpq.PgQuoteString(value))
                     elif op=="bw":                      elif op=="bw":
                         whereList.append(name+"~\'"+value+".*\'")                      whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))
                     elif op=="ew":                      elif op=="ew":
                         whereList.append(name+"~\'.*"+value+"\'")                      whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))
                     op="ct"                      op="ct"
             except:              
                 print "END"                      #except:
               #    print "END",value,name,Exception       
         if len(whereList)>0:          if len(whereList)>0:
             where="WHERE "+string.join(whereList," "+lop+" ")              where="WHERE "+string.join(whereList," "+lop+" ")
         else:          else:
             where=""              where=""
         #print "QE",table          #print "QE",table
                   
         query="SELECT %s FROM %s %s %s"%(select,table,where,sort)          query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
   
           if not nostore=="yes":
               
               self.REQUEST.SESSION['qs']=opfields
           #print "IAMHERE again:", query
   
           if storename:
               query2="SELECT count(*) FROM %s %s"%(table,where)
               #print "storing",query2
               #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
               if not self.REQUEST.SESSION.has_key(storename):
                   self.REQUEST.SESSION[storename]={}
               if self.REQUEST.SESSION[storename].has_key('queryString2'):
                   #print "HI",storename
                   if not self.REQUEST.SESSION[storename]['queryString2']==query2:
                       #print "HOOOOO",storename
                       self.REQUEST.SESSION[storename]['queryString2']=query2
                       self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count
                       #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
                   
               else:
                   self.REQUEST.SESSION[storename]['queryString2']=query2
                   self.REQUEST.SESSION[storename]['count']=self.search(var=query2)[0].count
                   #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
               
               
               self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
               if limit=="all":
                   self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
               else:
                   self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
               self.REQUEST.SESSION[storename]['rangeSize']=limit
               self.REQUEST.SESSION[storename]['searchFields']=searchFields
               
       #print "Q",query            
         return self.search(var=query)          return self.search(var=query)
           
       
     def ZSQLSearch(self):      def ZSQLSearch(self):
         """To be done"""          """To be done"""
         rq=self.REQUEST['QUERY_STRING']          rq=self.REQUEST['QUERY_STRING']
Line 181  class ZSQLExtendFolder(Persistent, Impli Line 465  class ZSQLExtendFolder(Persistent, Impli
             return(int(string))              return(int(string))
         except:          except:
             return 0              return 0
     def prevLink(self,html):  
       def getZSQLSearchFieldsList(self,storename="foundCount"):
           """get searchfieldList"""
           #print self.REQUEST.SESSION[storename]['searchFields'].keys()
           return  self.REQUEST.SESSION[storename]['searchFields'].keys()
   
       def getZSQLSearchFields(self,storename="foundCount"):
           """get searchfield"""
           #print "SF",self.REQUEST.SESSION[storename]['searchFields']
           return  self.REQUEST.SESSION[storename]['searchFields']
   
                                                   
       def nextLink(self,html,storename="foundCount"):
           """nextLink"""
           try:
               limit=self.REQUEST.SESSION[storename]['rangeSize']
               newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
           except:
               limit=0
               newRangeStart=0
               
           if newRangeStart>self.REQUEST.SESSION[storename]['count']:
               newRangeStart=self.REQUEST.SESSION[storename]['count']-10
   
           
           #create new query string
           
           if self.REQUEST['QUERY_STRING']=="":
               qs=self.REQUEST.SESSION['query']
               
               queries=string.split(qs,",")
               
               
           else:
               qs=self.REQUEST['QUERY_STRING']
               queries=string.split(qs,"&")
               
               
               
           newquery=[]
   
           skipFound=0
           
           for query in queries:
               #print query.split("=")[0]
               if query[0]=="_" : query[0]="-"
   
               if query.split("=")[0].lower()=="-skip":
                   skipFound=1
                   query="-skip=%i"%newRangeStart
               newquery.append(query)
   
           if skipFound==0 :
               query="-skip=%i"%newRangeStart
               newquery.append(query)
                   
           newquerystring=string.join(newquery,"&")
       
           return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
               
           
       def prevLink(self,html,storename="foundCount"):
           """prev link"""
           try:
               limit=self.REQUEST.SESSION[storename]['rangeSize']
               newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
           except:
               limit=0
               newRangeStart=0
   
           #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
           
           if newRangeStart<0:
                   newRangeStart=0
   
           #create new query string
           
           if self.REQUEST['QUERY_STRING']=="":
               qs=self.REQUEST.SESSION['query']
               #qs=re.sub(r'_','-',qs) #aendern für query
               queries=string.split(qs,",")
               
               
           else:
               qs=self.REQUEST['QUERY_STRING']
               queries=string.split(qs,"&")
               
               
               
           newquery=[]
           
           skipFound=0
   
           for query in queries:
               #print query.split("=")[0]
   
               if query[0]=="_" : query[0]="-"
               
               if query.split("=")[0].lower()=="-skip":
                   #print"HI"
                   query="-skip=%i"%newRangeStart
                   skipFound=1
               newquery.append(query)
   
           if skipFound==0 :
               query="-skip=%i"%newRangeStart
               newquery.append(query)
               
           newquerystring=string.join(newquery,"&")
   
           return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
   
   
       
       def prevLink_old(self,html):
         """prev link"""          """prev link"""
         if self.REQUEST['QUERY_STRING']=="":          if self.REQUEST['QUERY_STRING']=="":
             qs=self.REQUEST.SESSION['query']              qs=self.REQUEST.SESSION['query']
Line 206  class ZSQLExtendFolder(Persistent, Impli Line 604  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(self,html):      def nextLink_old(self,html):
         """prev link"""          """prev link"""
         if self.REQUEST['QUERY_STRING']=="":          if self.REQUEST['QUERY_STRING']=="":
             qs=self.REQUEST.SESSION['query']              qs=self.REQUEST.SESSION['query']
Line 236  class ZSQLExtendFolder(Persistent, Impli Line 634  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)
           
     def ZSQLrangeStart(self):  
         if self.REQUEST['QUERY_STRING']=="":  
             qs=self.REQUEST.SESSION['query']  
         else:  
             qs=self.REQUEST['QUERY_STRING']  
         offset=re.search(r'offset\=(.*)\,',qs.lower())  
         if not offset:  
             offset=1  
         return offset  
 #    def search(self,**argv):  
 #        """to be done"""  
   
   
   
 manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())  manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
Removed from v.1.1.1.1  
changed lines
  Added in v.1.14

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