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

Diff for /ZSQLExtend/ZSQLExtend.py between versions 1.1 and 1.19

version 1.1, 2003/11/28 15:03:10 version 1.19, 2004/06/11 15:13:20
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
   from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   
   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 content_html(self):
           """template fuer content"""
           
           try:
               obj=getattr(self,"ZSQLBibliography_template")
               return obj()
           except:
               pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
               pt.content_type="text/html"
               return pt()
   
           
       def getWeight(self):
           """getLabe"""
           try:
               return self.weight
           except:
               return ""
   
       def getLabel(self):
           """getLabe"""
           try:
               return self.label
           except:
               return ""
   
       def getDescription(self):
           """getLabe"""
           try:
               return self.description
           except:
               return ""
   
       manage_options=Folder.manage_options+(
           {'label':'Main Config','action':'changeZSQLExtendForm'},
          )
   
       def changeZSQLExtendForm(self):
           """change folder config"""
           pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)
           return pt()
   
   
       def changeZSQLExtend(self,label,description,weight=0,REQUEST=None):
           """change it"""
   
           self.weight=weight
           self.label=label
           self.description=description
           
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
   
       def formatAscii(self,str,url=None):
           """ersetze ascii umbrueche durch <br>"""
           #url=None
           if url and str:
               
               retStr=""
               words=str.split("\n")
               
               for word in words:
                   strUrl=url%word
                   #print "str",strUrl
                   retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
               str=retStr
           if str:
               return re.sub(r"[\n]","<br/>",str)
           else:
               return ""
           
       def getSAttribute(self,obj,atribute,pref=''):
           """get Attribute or emptystring"""
           
           #print "obj",obj
           try:
               return pref+getattr(obj,atribute)
           except:
               return ""
           
       def getS(self,str):
           """make none to empty string"""
           if str:
               return str
           else:
               return ""
   
       def actualPath(self,url=None):
       """path"""
   
           if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
               host=self.REQUEST['HTTP_HOST']
           else:
               host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
       if not url:
           return "http://"+host+self.REQUEST['PATH_TRANSLATED']
           else:
           temp=self.REQUEST[url].split("/")
           temp[2]=host
           return string.join(temp,"/")
   
       def getRequest(self):
       """request"""
       return self.REQUEST
   
       def lowerEnd(self,path):
           """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 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,field)
               else:
                   ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field,field)
           return ret
   
   
       def ZSQLOptionsFromCRList(self,fieldname,listField):
           """generate select oprions form a cr seperated list"""
           fields=listField.split("\n")
           ret="""<select name="%s">
               """%fieldname
           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,start=None):
           """generate select oprions form a cr seperated list"""
           
           ret="""<select name="%s">
               """%fieldname
           if start:
           if start==' ':
           start=''
               ret+="""<option value="%s">%s</option>"""%(start,start)
           for result in results:
               field=getattr(result,fieldName)
               ret+="""<option value="%s">%s</option>"""%(field,field)
           ret+="""</select>"""
           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=[]
           
   
         return self.parseQueryString(string.join(qs,","),"_")  
           #print "INLINE:",query
           
           return self.search(var=query)
           
     def ZSQLAdd(self):      def ZSQLAdd(self):
         """Neuer Eintrag"""          """Neuer Eintrag"""
Line 41  class ZSQLExtendFolder(Persistent, Impli Line 235  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 244  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 293  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,**argv):
         """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("&"),",")
                  for field in argv.keys():
                      qs+=",-%s=%s"%(field,argv[field])
                  #print qs
            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 int(self.REQUEST.SESSION[storename]['rangeStart'])+1
       
       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=""
                   #print "Hi",name[0:3],q
                   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 449  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.ZSQLQuery(query)
   
       def ZSQLQuery(self,query):
           """query"""
         return self.search(var=query)          return self.search(var=query)
           
     def ZSQLSearch(self):      def ZSQLSearch(self):
Line 181  class ZSQLExtendFolder(Persistent, Impli Line 567  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 706  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 736  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']=="":  manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
             qs=self.REQUEST.SESSION['query']  
   def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
                        createPublic=0,
                        createUserF=0,
                        REQUEST=None):
       """Add a new Folder object with id *id*.
   
       If the 'createPublic' and 'createUserF' parameters are set to any true
       value, an 'index_html' and a 'UserFolder' objects are created respectively
       in the new folder.
       """
       
       
       ob=ZSQLExtendFolder()
       ob.id=str(id)
       ob.title=title
       self._setObject(id, ob)
       ob=self._getOb(id)
       setattr(ob,'label',label)
       setattr(ob,'description',description)
       
       checkPermission=getSecurityManager().checkPermission
   
       if createUserF:
           if not checkPermission('Add User Folders', ob):
               raise Unauthorized, (
                     'You are not authorized to add User Folders.'
                     )
           ob.manage_addUserFolder()
   
       if createPublic:
           if not checkPermission('Add Page Templates', ob):
               raise Unauthorized, (
                     'You are not authorized to add Page Templates.'
                     )
           ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
               id='index_html', title='')
   
       if REQUEST is not None:
           return self.manage_main(self, REQUEST, update_menu=1)
   
   
   
   class ZSQLBibliography(Folder,ZSQLExtendFolder):
       """Bibliography"""
       meta_type="ZSQLBibliography"
       def getLabel(self):
           try:
               return self.label
           except:
               return ""
   
       def getDescription(self):
           try:
               return self.description
           except:
               return ""
               
       def changeZSQLBibliographyForm(self):
           """change folder config"""
           pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)
           return pt()
   
   
       def content_html(self):
           """template fuer content"""
           
           try:
               obj=getattr(self,"ZSQLBibliography_template")
               return obj()
           except:
               pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
               pt.content_type="text/html"
               return pt()
   
       def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):
           """change it"""
           self.tableName=tableName
           self.label=label
           self.description=description
           
           if REQUEST is not None:
               return self.manage_main(self, REQUEST)
   
       manage_options=Folder.manage_options+(
           {'label':'Main Config','action':'changeZSQLBibliographyForm'},
          )
   
   
       def getFieldLabel(self,fields,field):
           """get labels"""
           try:
               ret =fields[0][field]
               if ret == "":
                   return field
         else:          else:
             qs=self.REQUEST['QUERY_STRING']                  return ret
         offset=re.search(r'offset\=(.*)\,',qs.lower())          except:
         if not offset:              return field
             offset=1  
         return offset  
 #    def search(self,**argv):  
 #        """to be done"""  
   
       def getFieldValue(self,found,field):
           """get value"""
           try:
               ret=getattr(found,field)
               if ret == "":
                   return None
               else:
                   return ret
           except:
               return None
   
       def findLabelsFromMapping(self,referenceType):
           """gib hash mit label -> generic zurueck"""
           self.referencetypes=self.ZopeFind(self.standardMD)
           bibdata={}
           retdata={}
           fieldlist=self.standardMD.fieldList
           
       for referenceTypeF in self.referencetypes:
           #print referenceType,referenceTypeF[1].title
           if referenceTypeF[1].title == referenceType: 
               bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
               bibdata['data']=referenceTypeF[1]
               self.fields=bibdata[referenceType]
                           for field in fieldlist:
                               retdata[field]=referenceTypeF[1].getValue(field)[1]
   
           return retdata,fieldlist
   
   
 manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())  
   
 def manage_addZSQLExtendFolder(self, id, title='',  manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
   
   def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
                      createPublic=0,                       createPublic=0,
                      createUserF=0,                       createUserF=0,
                      REQUEST=None):                       REQUEST=None):
Line 266  def manage_addZSQLExtendFolder(self, id, Line 885  def manage_addZSQLExtendFolder(self, id,
     """      """
           
           
     ob=ZSQLExtendFolder()      ob=ZSQLBibliography()
     ob.id=str(id)      ob.id=str(id)
     ob.title=title      ob.title=title
     self._setObject(id, ob)      self._setObject(id, ob)
     ob=self._getOb(id)      ob=self._getOb(id)
       setattr(ob,'tableName',tableName)
       setattr(ob,'label',label)
       setattr(ob,'description',description)
   
     checkPermission=getSecurityManager().checkPermission      checkPermission=getSecurityManager().checkPermission
   
Line 293  def manage_addZSQLExtendFolder(self, id, Line 915  def manage_addZSQLExtendFolder(self, id,
         return self.manage_main(self, REQUEST, update_menu=1)          return self.manage_main(self, REQUEST, update_menu=1)
   
           
   
       
Removed from v.1.1  
changed lines
  Added in v.1.19

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