File:  [Repository] / ZSQLExtend / ZSQLExtend.py
Revision 1.29: download - view: text, annotated - select for diffs - revision graph
Wed Jul 28 15:13:00 2004 UTC (19 years, 10 months ago) by dwinter
Branches: MAIN
CVS tags: HEAD
added session variable come_from_search in ZSQLSearch

    1: from OFS.Folder import Folder
    2: from Globals import Persistent
    3: from Acquisition import Implicit
    4: from Globals import DTMLFile
    5: import urllib
    6: import re
    7: import string
    8: from pyPgSQL import libpq
    9: from AccessControl import getSecurityManager
   10: import os.path
   11: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
   12: 
   13: from Products.ZSQLMethods.SQL import SQLConnectionIDs
   14: import Shared.DC.ZRDB.DA
   15: 
   16: def showSQLConnectionIDs(self):
   17:     return SQLConnectionIDs(self)
   18: 
   19: class ZSQLExtendFolder(Folder,Persistent, Implicit):
   20:     """Folder"""
   21:     meta_type="ZSQLExtendFolder"
   22: 
   23:     def content_html(self):
   24:         """template fuer content"""
   25:         
   26:         try:
   27:             obj=getattr(self,"ZSQLBibliography_template")
   28:             return obj()
   29:         except:
   30:             pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt',content_type='text/htm').__of__(self)
   31:             pt.content_type="text/html"
   32:             
   33:             return pt()
   34: 
   35:         
   36:     def getWeight(self):
   37:         """getLabe"""
   38:         try:
   39:             return self.weight
   40:         except:
   41:             return ""
   42: 
   43:     def getLabel(self):
   44:         """getLabe"""
   45:         try:
   46:             return self.label
   47:         except:
   48:             return ""
   49: 
   50:     def getDescription(self):
   51:         """getLabe"""
   52:         try:
   53:             return self.description
   54:         except:
   55:             return ""
   56: 
   57:     manage_options=Folder.manage_options+(
   58:         {'label':'Main Config','action':'changeZSQLExtendForm'},
   59:        )
   60: 
   61:     def changeZSQLExtendForm(self):
   62:         """change folder config"""
   63:         pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLExtendForm.zpt').__of__(self)
   64:         return pt()
   65: 
   66: 
   67:     def changeZSQLExtend(self,label,description,weight=0,REQUEST=None,connection_id=None):
   68:         """change it"""
   69:         self.connection_id=connection_id
   70:         self.weight=weight
   71:         self.label=label
   72:         self.description=description
   73:         
   74:         if REQUEST is not None:
   75:             return self.manage_main(self, REQUEST)
   76: 
   77:     def formatAscii(self,str,url=None):
   78:         """ersetze ascii umbrueche durch <br>"""
   79:         #url=None
   80:         if url and str:
   81:             
   82:             retStr=""
   83:             words=str.split("\n")
   84:             
   85:             for word in words:
   86:                 strUrl=url%word
   87:                 #print "str",strUrl
   88:                 retStr+="""<a href="%s">%s</a><br/>"""%(strUrl,word)
   89:             str=retStr
   90:         if str:
   91:             return re.sub(r"[\n]","<br/>",str)
   92:         else:
   93:             return ""
   94:         
   95:     def getSAttribute(self,obj,atribute,pref=''):
   96:         """get Attribute or emptystring"""
   97:         
   98:         #print "obj",obj
   99:         try:
  100:             return pref+getattr(obj,atribute)
  101:         except:
  102:             return ""
  103:         
  104:     def getS(self,str):
  105:         """make none to empty string"""
  106:         if str:
  107:             return str
  108:         else:
  109:             return ""
  110: 
  111:     def actualPath(self,url=None):
  112: 	"""path"""
  113: 
  114:         if self.REQUEST['HTTP_X_FORWARDED_SERVER']=='':
  115:             host=self.REQUEST['HTTP_HOST']
  116:         else:
  117:             host=self.REQUEST['HTTP_X_FORWARDED_SERVER']
  118: 	if not url:
  119: 		return "http://"+host+self.REQUEST['PATH_TRANSLATED']
  120:     	else:
  121: 		temp=self.REQUEST[url].split("/")
  122: 		temp[2]=host
  123: 		return string.join(temp,"/")
  124: 
  125:     def getRequest(self):
  126: 	"""request"""
  127: 	return self.REQUEST
  128: 
  129:     def lowerEnd(self,path):
  130:         """oinly for demo"""
  131:         return os.path.splitext(path)[0]+".jpg"
  132:         
  133:     def ZSQLisEmpty(self,field):
  134:         """Teste ob Treffer leer"""
  135:         #print "field",field
  136:         if not field:
  137:             return 1
  138:         if field=="":
  139:             return 1
  140:         return 0
  141: 
  142:     def ZSQLsearchOptions(self,fieldname=""):
  143:         """return HTML Fragment with search options"""
  144: 	
  145:         ret="""<select name="-op_%s">
  146: 	<option value="bw">begins with</option>          	<!-- begins with / beginnt mit, "Wort*" -->
  147: 	<option value="ew">ends with</option>
  148:    	<option value="ct" selected>contains</option>          		<!-- contains / enthaellt, "Wort" -->
  149:     <option value="eq">equals</option>          		<!-- equals / ist, =Wort -->
  150: </select>"""%fieldname
  151:         return ret
  152: 
  153:     def ZSQLSelectionFromCRList(self,fieldname,listField,boxType="checkbox",checked=None):
  154:         """generate select oprions form a cr seperated list"""
  155:         fields=listField.split("\n")
  156:         ret=""
  157:         for field in fields:
  158:             if checked and (field in checked.split("\n")):
  159:                 ret+="""<input name="%s" type="%s" value="%s" checked>%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
  160:             else:
  161:                 ret+="""<input name="%s" type="%s" value="%s">%s"""%(fieldname,boxType,field.encode('utf-8'),field.encode('utf-8'))
  162:         return ret
  163: 
  164: 
  165:     def ZSQLOptionsFromCRList(self,fieldname,listField):
  166:         """generate select oprions form a cr seperated list"""
  167:         fields=listField.split("\n")
  168:         ret="""<select name="%s">
  169:             """%fieldname
  170:         for field in fields:
  171:             ret+="""<option value="%s">%s</option>"""%(field.encode('utf-8'),field.encode('utf-8'))
  172:         ret+="""</select>"""
  173:         return ret
  174: 
  175:     def ZSQLOptionsFromSearchList(self,fieldname,results,fieldName,valueName=None,start=None):
  176:         """generate select oprions form a cr seperated list"""
  177:         if not valueName:
  178:             valueName=fieldName
  179:             
  180:         ret="""<select name="%s">
  181:             """%fieldname
  182:         if start:
  183: 	    if start==' ':
  184: 		start=''
  185:             ret+="""<option value="%s">%s</option>"""%(start,start)
  186:         for result in results:
  187:             field=getattr(result,fieldName)
  188:             fieldValue=getattr(result,valueName)
  189:             ret+="""<option value="%s">%s</option>"""%(field,fieldValue)
  190:         ret+="""</select>"""
  191:         return ret
  192: 
  193:             
  194:     def ZSQLInlineSearchU(self,storename=None,**argv):
  195:         """one element if exists"""
  196:         qs=[]
  197:         if storename:
  198:             """store"""
  199:         else:
  200:             storename="foundCount"
  201:             
  202:     
  203: 
  204:         #print "INLINE:",argv
  205:         for a in argv.keys():
  206:             qs.append(a+"="+urllib.quote(str(argv[a])))
  207:         #return []  
  208:         ret = self.parseQueryString(string.join(qs,","),"_",storename=storename)
  209: 
  210:         try:
  211:             return ret[0]
  212:         except:
  213:             return None
  214:         
  215:     def ZSQLInlineSearch(self,storename=None,**argv):
  216:         """inlinesearch"""
  217:         qs=[]
  218:         if storename:
  219:             """store"""
  220:         else:
  221:             storename="foundCount"
  222:             
  223:     
  224: 
  225:         #print "INLINE:",argv
  226:         for a in argv.keys():
  227:             qs.append(a+"="+urllib.quote(str(argv[a])))
  228:         #return []  
  229:         return self.parseQueryString(string.join(qs,","),"_",storename=storename)
  230: 
  231:     def ZSQLInlineSearch2(self,query):
  232:         """inlinesearch"""
  233:         qs=[]
  234:         
  235:     
  236: 
  237:         #print "INLINE:",query
  238:         return self.ZSQLSimpleSearch(query)
  239:         
  240: 
  241:     def ZSQLSimpleSearch(self,query=None):
  242:         """ returrn SQLSearch"""
  243:         if not query:
  244:             query=self.query
  245:            
  246:         if self.search.meta_type=="Z SQL Method":
  247:             return self.search(var=query)
  248:         else:
  249:             if self.aq_parent.aq_parent.search.meta_type=="Z SQL Method":
  250:                 return self.aq_parent.aq_parent.search(var=query)
  251:             else:
  252:                 return []
  253:     
  254:         
  255:         
  256:     def ZSQLAdd(self):
  257:         """Neuer Eintrag"""
  258:         qs=self.REQUEST['QUERY_STRING']
  259:         addList={}
  260:         for q in qs.split("&"):
  261:             name=re.sub("r'+'"," ",q.split("=")[0].lower())
  262:             value=q.split("=")[1]
  263: 	    value=re.sub(r'\+'," ",value)
  264: 	    value=urllib.unquote(value)	
  265:             if name=="-table":
  266:                 table=urllib.unquote(value)
  267:             elif name=="-format":
  268:                 format=urllib.unquote(value)
  269:             elif (not name[0]=="-") and (not len(value)==0):
  270:                 addList[urllib.unquote(name)]=urllib.unquote(value)
  271: 
  272:         keyList=[]
  273:         valueList=[]
  274:         for x in addList.keys():
  275:             keyList.append("\""+x+"\"")
  276:             valueList.append(libpq.PgQuoteString(addList[x]))
  277: 
  278:         keyString=string.join(keyList,",")
  279:         valueString=string.join(valueList,",")
  280:         
  281:         queryString="INSERT INTO %s (%s) VALUES (%s)"%(table,keyString,valueString)
  282:         self.ZSQLSimpleSearch(queryString)
  283:         return self.REQUEST.RESPONSE.redirect(format)
  284:         
  285:     def ZSQLChange(self,**argv):
  286:         """Ändern von Einträgen"""
  287:         #qs=self.REQUEST['QUERY_STRING']
  288:         # very bad hack
  289:         qs_temp=[]
  290:     
  291:         for a in self.REQUEST.form.keys():
  292:             qs_temp.append(a+"="+urllib.quote(str(self.REQUEST.form[a])))
  293: 
  294:         qs=string.join(qs_temp,"&")
  295: 
  296:     
  297:         #print "CHANGE QS",self.REQUEST
  298:         #return self.REQUEST
  299:         changeList=[]
  300:         for q in qs.split("&"):
  301:             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
  302:             value=q.split("=")[1]
  303:             value=re.sub(r'\+'," ",value)
  304: 	    value=urllib.unquote(value)
  305: 	    if name=="-table":
  306:                 table=urllib.unquote(value)
  307:             elif name=="-identify":
  308:                 identify=urllib.unquote(value)
  309:                 identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
  310:             elif name=="-format":
  311:                 format=urllib.unquote(value)
  312:             elif (not name[0]=="-") and (not len(value)==0):
  313:                 changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
  314:         changeString=string.join(changeList,",")
  315:         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
  316:         self.ZSQLSimpleSearch(queryString)
  317:         return self.REQUEST.RESPONSE.redirect(format)
  318: 
  319:     def ZSQLChange_old(self):
  320:         """Ändern von Einträgen"""
  321:         qs=self.REQUEST['QUERY_STRING']
  322:         #print "CHANGE QS",self.REQUEST
  323:         #return self.REQUEST
  324:         changeList=[]
  325:         for q in qs.split("&"):
  326:             name=urllib.unquote(re.sub("r'+'"," ",q.split("=")[0].lower()))
  327:             value=q.split("=")[1]
  328:             value=re.sub(r'\+'," ",value)
  329: 	    value=urllib.unquote(value)
  330: 	    if name=="-table":
  331:                 table=urllib.unquote(value)
  332:             elif name=="-identify":
  333:                 identify=urllib.unquote(value)
  334:                 identify=identify.split("=")[0]+"="+libpq.PgQuoteString(identify.split("=")[1])
  335:             elif name=="-format":
  336:                 format=urllib.unquote(value)
  337:             elif (not name[0]=="-") and (not len(value)==0):
  338:                 changeList.append("\""+name+"\"="+libpq.PgQuoteString(urllib.unquote(value)))
  339:         changeString=string.join(changeList,",")
  340:         queryString="UPDATE %s SET %s WHERE %s"%(table,changeString,identify)
  341:         self.ZSQLSimpleSearch(queryString)
  342:         return self.REQUEST.RESPONSE.redirect(format)
  343:     
  344:     def ZSQLFind(self,qs="",select="oid,*",storename=None,**argv):
  345:         """Find"""
  346: 
  347:         def delEmpty(list):
  348:             ret=[]
  349:             for x in list:
  350:                 splitted=x.split("=")
  351:                 if (len(splitted)>1) and not (splitted[1]==' '):
  352:                     ret.append(x)
  353:             return ret
  354:         
  355:         self.REQUEST.SESSION['come_from_search']="no" # zurücksetzen
  356:         if qs=="":
  357:            if self.REQUEST['QUERY_STRING']:
  358:                qs=self.REQUEST['QUERY_STRING']
  359:                
  360:                
  361:                qs=string.join(qs.split("&"),",")
  362:                
  363:                for field in argv.keys():
  364:                    
  365:                    qs+=",-%s=%s"%(field,argv[field])
  366:                #print qs
  367:            else:
  368:                
  369:                qs=self.REQUEST.SESSION.get('query','')
  370:                
  371:                for field in argv.keys():
  372:                    #print field
  373:                    qs+=",-%s=%s"%(field,argv[field])
  374:                
  375:         else:
  376:             self.REQUEST['QUERY_STRING']=qs
  377: 
  378:             qs=string.join(qs.split("&"),",")
  379:             
  380:         
  381:         
  382:         qs=re.sub("\\+"," ",qs)# Austauschen da Leerzeichen bei http-get durch + ersetzt wird, generell sollte alles auf post umgeschrieben werden. vom search formular.
  383: 
  384:         qs=string.join(delEmpty(qs.split(",")),",")
  385: 
  386:         if storename:
  387:             """store"""
  388:         else:
  389:             storename="foundCount"
  390: 
  391: 
  392:         
  393:         ret=self.parseQueryString(qs,"-",select=select,storemax="yes",storename=storename)
  394:         #print self.REQUEST.SESSION["foundCount"]
  395:         
  396:         
  397:         return ret
  398: 
  399:     def ZSQLFoundCountLen(self,var):
  400:         return len(var)
  401:             
  402:     def ZSQLFoundCount(self,qs="",select="*",storename=None):
  403:         
  404:        ##  if qs=="":
  405:             
  406: ##             if self.REQUEST['QUERY_STRING']:
  407:             
  408: ##                 qs=self.REQUEST['QUERY_STRING']
  409: ##                 qs=string.join(qs.split("&"),",")
  410: ##             else:
  411:             
  412: ##                 qs=self.REQUEST.SESSION['query']
  413: ##         else:
  414: ##             qs=string.join(qs.split("&"),",")
  415: 
  416: 
  417: ##         temp= self.parseQueryString(qs,"-",select=select,storemax="yes",nostore="yes")
  418:         if storename:
  419:             """store"""
  420:         else:
  421:             storename="foundCount"
  422:         
  423:         return self.REQUEST.SESSION[storename]['count']
  424: 
  425:     def ZSQLRangeStart(self,storename=None):
  426:         
  427:         if storename:
  428:             """store"""
  429:         else:
  430:             storename="foundCount"
  431:         
  432:         return int(self.REQUEST.SESSION[storename]['rangeStart'])+1
  433:     
  434:     def ZSQLRangeSize(self,storename=None):
  435:         
  436:         if storename:
  437:             """store"""
  438:         else:
  439:             storename="foundCount"
  440:             
  441:         return self.REQUEST.SESSION[storename]['rangeSize']
  442: 
  443:     def ZSQLRangeEnd(self,storename=None):
  444:         
  445:         if storename:
  446:             """store"""
  447:         else:
  448:             storename="foundCount"
  449:         
  450:         return str(min(int(self.REQUEST.SESSION[storename]['rangeEnd']),int(self.REQUEST.SESSION[storename]['count'])))
  451:     
  452:     def parseQueryString(self,qs,iCT,storemax="no",select=None,nostore=None,storename=None):
  453:         """analysieren den QueryString"""
  454:         #print "NO",nostore
  455:         lop="AND" # standardsuche mit and
  456:         max="ALL" #standard alle auswählen
  457:         maxstr=""
  458:         whereList=[]
  459:         sort=""
  460:         op="bw"
  461:         opfields={}
  462:         skip=""
  463:         rangeStart=0
  464:         limit=0
  465:         searchFields={}
  466:         
  467:         if not select:
  468:             select="oid,*"
  469:         #print "Q",nostore,qs
  470:         #check for op in the case of inline search
  471:         
  472: 	splitted=qs.split(",")
  473: 	
  474:             
  475:         for q in splitted:
  476:                 
  477:                 name=re.sub("r'+'"," ",q.split("=")[0].lower())
  478:                 try:
  479:                     value=urllib.unquote(q.split("=",1)[1])
  480:                 except:
  481:                     value=""
  482:                 #print "Hi",name[0:3],q
  483:                 if name[0:3]==iCT+"op":
  484:                     op=value
  485: 
  486:                     field=name[4:]
  487:                     opfields[field]=op
  488:                     #print "HI",op,field
  489: 	#print opfieldsa
  490:         #now analyse the querystring
  491:         for q in qs.split(","):
  492:             
  493:             
  494:             #try:
  495: 
  496:             name=re.sub("r'+'"," ",q.split("=")[0].lower())
  497:             try:
  498:                 value=urllib.unquote(q.split("=",1)[1])
  499:             except:
  500:                 value=""
  501:                 
  502:             #value=libpq.PgQuoteString(value)
  503:             
  504:             
  505:             if name==iCT+"lop":
  506:                 lop=value
  507:             elif name==iCT+"table":
  508:                 table=value
  509:             elif name==iCT+"select":
  510:                 select=value
  511:             elif name==iCT+"max":
  512:                 maxstr="LIMIT "+str(value)
  513:                 limit=str(value)
  514:             elif name==iCT+"skip":
  515:                 skip="OFFSET "+str(value)
  516:                 rangeStart=str(value)
  517:             elif name==iCT+"join":
  518:                 whereList.append(value)
  519:             elif name==iCT+"sort":
  520:                 sort="ORDER BY "+value
  521:             elif name==iCT+"token":
  522:                 if not nostore=="yes":
  523:                     self.REQUEST.SESSION['token']=value
  524: 
  525:             elif name==iCT+"op":
  526:                 op=value
  527: 
  528: 
  529: 
  530:             elif (not name[0]==iCT) and (not len(value)==0):
  531:                 
  532: 		#print "OP",op,name
  533:                 value=value.lower()
  534: 
  535:                 searchFields[name]=value
  536:                 
  537:                 if opfields.has_key(name):
  538:                     op=opfields[name]
  539: 		else:
  540: 		    op="ct"
  541: 		name="LOWER("+name+")"    
  542:                 if op=="ct":
  543:                     whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value+"%"))
  544:                 elif op=="gt":
  545:                     whereList.append(name+">"+libpq.PgQuoteString(value))
  546:                 elif op=="lt":
  547:                     whereList.append(name+"<"+libpq.PgQuoteString(value))
  548:                 elif op=="eq":
  549:                     whereList.append(name+"="+libpq.PgQuoteString(value))
  550:                 elif op=="bw":
  551:                     whereList.append(name+" LIKE "+libpq.PgQuoteString(value+"%"))
  552:                 elif op=="ew":
  553:                     whereList.append(name+" LIKE "+libpq.PgQuoteString("%"+value))
  554:                 op="ct"
  555:             
  556:             #except:
  557:             #    print "END",value,name,Exception       
  558:         if len(whereList)>0:
  559:             where="WHERE "+string.join(whereList," "+lop+" ")
  560:         else:
  561:             where=""
  562:         #print "QE",table
  563:         
  564:         query="SELECT %s FROM %s %s %s %s %s"%(select,table,where,sort,maxstr,skip)
  565:         
  566:         if not nostore=="yes":
  567:             
  568:             self.REQUEST.SESSION['qs']=opfields
  569:         #print "IAMHERE again:", query
  570: 
  571:         if storename:
  572:             query2="SELECT count(*) FROM %s %s"%(table,where)
  573:             #print "storing",query2
  574:             #print "QUERYSTRING:",self.REQUEST.SESSION[storename]['queryString2']
  575:             if not self.REQUEST.SESSION.has_key(storename):
  576:                 self.REQUEST.SESSION[storename]={}
  577:             if self.REQUEST.SESSION[storename].has_key('queryString2'):
  578:                 #print "HI",storename
  579:                 if not self.REQUEST.SESSION[storename]['queryString2']==query2:
  580:                     #print "HOOOOO",storename
  581:                     self.REQUEST.SESSION[storename]['queryString2']=query2
  582:                     self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
  583:                     #print "QUERY",query2,"::::",self.REQUEST.SESSION[storename]['queryString2']
  584:                 
  585:             else:
  586:                 self.REQUEST.SESSION[storename]['queryString2']=query2
  587:                 self.REQUEST.SESSION[storename]['count']=self.ZSQLSimpleSearch(query2)[0].count
  588:                 #print "QUERYNEW",self.REQUEST.SESSION[storename]['queryString2']
  589:             
  590:             
  591:             self.REQUEST.SESSION[storename]['rangeStart']=rangeStart
  592:             if limit=="all":
  593:                 self.REQUEST.SESSION[storename]['rangeEnd']=self.REQUEST.SESSION[storename]['count']
  594:             else:
  595:                 self.REQUEST.SESSION[storename]['rangeEnd']=int(rangeStart)+int(limit)
  596:             self.REQUEST.SESSION[storename]['rangeSize']=limit
  597:             self.REQUEST.SESSION[storename]['searchFields']=searchFields
  598:             
  599:         
  600:         return self.ZSQLQuery(query)
  601: 
  602:     def ZSQLQuery(self,query):
  603:         """query"""
  604:         return self.ZSQLSimpleSearch(query)
  605:     
  606:     def ZSQLSearch(self):
  607:         """To be done"""
  608:         rq=self.REQUEST['QUERY_STRING']
  609:         querys=rq.split("&")
  610:         
  611: 
  612:         for querytemp in querys:
  613:             query=querytemp.split("=")
  614:             try:
  615:                 if query[0].lower()=="-format":
  616:                     formatfile=query[1]
  617:             except:
  618:                 """nothing"""
  619:         #print formatfile        
  620:         self.REQUEST.SESSION['query']=string.join(self.REQUEST['QUERY_STRING'].split("&"),",")
  621:         self.REQUEST.SESSION['come_from_search']="yes"
  622:         
  623:         return self.REQUEST.RESPONSE.redirect(urllib.unquote(formatfile))
  624: 
  625:     
  626:     def ZSQLint(self,string):
  627:         try:
  628: 
  629:             return(int(string))
  630:         except:
  631:             return 0
  632: 
  633:     def getZSQLSearchFieldsList(self,storename="foundCount"):
  634:         """get searchfieldList"""
  635:         #print self.REQUEST.SESSION[storename]['searchFields'].keys()
  636:         return  self.REQUEST.SESSION[storename]['searchFields'].keys()
  637: 
  638:     def getZSQLSearchFields(self,storename="foundCount"):
  639:         """get searchfield"""
  640:         #print "SF",self.REQUEST.SESSION[storename]['searchFields']
  641:         return  self.REQUEST.SESSION[storename]['searchFields']
  642: 
  643:                                                 
  644:     def nextLink(self,html,storename="foundCount"):
  645:         """nextLink"""
  646:         try:
  647:             limit=self.REQUEST.SESSION[storename]['rangeSize']
  648:             if int(limit)==0 :
  649:                 limit="1"
  650:             newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])+int(limit)
  651:         except:
  652:             limit=1
  653:             newRangeStart=0
  654:             
  655:         if newRangeStart>=self.REQUEST.SESSION[storename]['count']:
  656:             #newRangeStart=self.REQUEST.SESSION[storename]['count']-1
  657:             return ""
  658:         
  659:         #create new query string
  660:         
  661:         if self.REQUEST['QUERY_STRING']=="":
  662:             qs=self.REQUEST.SESSION['query']
  663:             
  664:             queries=string.split(qs,",")
  665:             
  666:             
  667:         else:
  668:             qs=self.REQUEST['QUERY_STRING']
  669:             queries=string.split(qs,"&")
  670:             
  671:             
  672:             
  673:         newquery=[]
  674: 
  675:         skipFound=0
  676:         
  677:         for query in queries:
  678:             
  679:             #print query.split("=")[0]
  680:             if query[0]=="_" : query[0]="-"
  681: 
  682:             if query.split("=")[0].lower()=="-skip":
  683: 
  684:                 skipFound=1
  685:                 query="-skip=%i"%newRangeStart
  686:             newquery.append(query)
  687: 
  688:         if skipFound==0 :
  689:             query="-skip=%i"%newRangeStart
  690:             newquery.append(query)
  691:                 
  692:         newquerystring=string.join(newquery,"&")
  693: 	
  694:         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
  695:             
  696:         
  697:     def prevLink(self,html,storename="foundCount"):
  698:         """prev link"""
  699:         try:
  700:             limit=self.REQUEST.SESSION[storename]['rangeSize']
  701:             if int(limit)==0 :
  702:                 limit="1"
  703:             newRangeStart=int(self.REQUEST.SESSION[storename]['rangeStart'])-int(limit)
  704:         except:
  705:             limit=1
  706:             newRangeStart=0
  707:         if newRangeStart <0:
  708:             return ""
  709: 
  710:         #print "limit",limit,newRangeStart,int(self.REQUEST.SESSION[storename]['rangeStart'])
  711:         
  712:         if newRangeStart<0:
  713:                 newRangeStart=0
  714: 
  715:         #create new query string
  716:         
  717:         if self.REQUEST['QUERY_STRING']=="":
  718:             qs=self.REQUEST.SESSION['query']
  719:             #qs=re.sub(r'_','-',qs) #aendern für query
  720:             queries=string.split(qs,",")
  721:             
  722:             
  723:         else:
  724:             qs=self.REQUEST['QUERY_STRING']
  725:             queries=string.split(qs,"&")
  726:             
  727:             
  728:             
  729:         newquery=[]
  730:         
  731:         skipFound=0
  732: 
  733:         for query in queries:
  734:             #print query.split("=")[0]
  735: 
  736:             if query[0]=="_" : query[0]="-"
  737:             
  738:             if query.split("=")[0].lower()=="-skip":
  739:                 #print"HI"
  740:                 query="-skip=%i"%newRangeStart
  741:                 skipFound=1
  742:             newquery.append(query)
  743: 
  744:         if skipFound==0 :
  745:             query="-skip=%i"%newRangeStart
  746:             newquery.append(query)
  747:             
  748:         newquerystring=string.join(newquery,"&")
  749: 
  750:         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
  751: 
  752: 
  753:     
  754:     def prevLink_old(self,html):
  755:         """prev link"""
  756:         if self.REQUEST['QUERY_STRING']=="":
  757:             qs=self.REQUEST.SESSION['query']
  758:         else:
  759:             qs=self.REQUEST['QUERY_STRING']
  760:         max=re.search(r'max\=(.*)\,',qs.lower())
  761:         offset=re.search(r'offset\=(.*)\,',qs.lower())
  762:         if not offset:
  763:             offsetnew=0
  764:         else:
  765:             offsetnew=int(offset)-max
  766:             if offsetnew<0:
  767:                 offsetnew=0
  768:         queries=string.split(qs,",")
  769:         newquery=[]
  770:         if offset:
  771:             for query in queries:
  772:                 if query.split("=")[0].lower()=="offset":
  773:                     query="-offset=%i"%offsetnew
  774:                 newquery.append(query)
  775:                 newquerystring=string.join(newquery,"&")
  776:         else:
  777:             queries.append("-offset=%i"%offsetnew)
  778:             newquerystring=string.join(queries,"&")
  779:         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
  780:         
  781:     def nextLink_old(self,html):
  782:         """prev link"""
  783:         if self.REQUEST['QUERY_STRING']=="":
  784:             qs=self.REQUEST.SESSION['query']
  785:         else:
  786:             qs=self.REQUEST['QUERY_STRING']
  787:         max=re.search(r'max\=(.*)\,',qs.lower())
  788:     
  789:         offset=re.search(r'offset\=(.*)\,',qs.lower())
  790:         if not offset:
  791:             offsetnew=1
  792:         else:
  793:             offsetnew=int(offset)+int(max)
  794:             if offsetnew<0:
  795:                 offsetnew=0
  796:         queries=string.split(qs,",")
  797:         newquery=[]
  798:         if offset:
  799:             for query in queries:
  800: 
  801:                 if query.split("=")[0].lower()=="-offset":
  802:                     query="-offset=%i"%offsetnew
  803:                 newquery.append(query)
  804:                 newquerystring=string.join(newquery,"&")
  805:         else:
  806:             queries.append("-offset=%i"%offsetnew)
  807:             newquerystring=string.join(queries,"&")
  808:         
  809:         return "<a href='%s'>%s</a>"%(self.actualPath()+"?"+newquerystring,html)
  810:         
  811:     
  812: manage_addZSQLExtendFolderForm=DTMLFile('ZSQLExtendFolderAdd', globals())
  813: 
  814: def manage_addZSQLExtendFolder(self, id, title='', label='', description='',
  815:                      createPublic=0,
  816:                      createUserF=0,
  817:                      connection_id=None,
  818:                      REQUEST=None):
  819:     """Add a new Folder object with id *id*.
  820: 
  821:     If the 'createPublic' and 'createUserF' parameters are set to any true
  822:     value, an 'index_html' and a 'UserFolder' objects are created respectively
  823:     in the new folder.
  824:     """
  825:     
  826:     
  827:     ob=ZSQLExtendFolder()
  828:     ob.id=str(id)
  829:     ob.title=title
  830:     self._setObject(id, ob)
  831:     ob=self._getOb(id)
  832:     setattr(ob,'label',label)
  833:     setattr(ob,'description',description)
  834:     setattr(ob,'connection_id',connection_id)
  835:     
  836:     checkPermission=getSecurityManager().checkPermission
  837: 
  838:     if createUserF:
  839:         if not checkPermission('Add User Folders', ob):
  840:             raise Unauthorized, (
  841:                   'You are not authorized to add User Folders.'
  842:                   )
  843:         ob.manage_addUserFolder()
  844: 
  845:     if createPublic:
  846:         if not checkPermission('Add Page Templates', ob):
  847:             raise Unauthorized, (
  848:                   'You are not authorized to add Page Templates.'
  849:                   )
  850:         ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
  851:             id='index_html', title='')
  852: 
  853:     if REQUEST is not None:
  854:         return self.manage_main(self, REQUEST, update_menu=1)
  855: 
  856: 
  857: 
  858: class ZSQLBibliography(Folder,ZSQLExtendFolder):
  859:     """Bibliography"""
  860:     meta_type="ZSQLBibliography"
  861:     def getLabel(self):
  862:         try:
  863:             return self.label
  864:         except:
  865:             return ""
  866: 
  867:     def getDescription(self):
  868:         try:
  869:             return self.description
  870:         except:
  871:             return ""
  872:             
  873:     def changeZSQLBibliographyForm(self):
  874:         """change folder config"""
  875:         pt=PageTemplateFile('Products/ZSQLExtend/zpt/changeZSQLBibliographyForm.zpt').__of__(self)
  876:         return pt()
  877: 
  878: 
  879:     def content_html(self):
  880:         """template fuer content"""
  881:         
  882:         try:
  883:             obj=getattr(self,"ZSQLBibliography_template")
  884:             return obj()
  885:         except:
  886:             pt=PageTemplateFile('Products/ZSQLExtend/zpt/ZSQLBibliography_template_standard.zpt').__of__(self)
  887:             pt.content_type="text/html"
  888:             return pt()
  889: 
  890:     def changeZSQLBibliography(self,tableName,label,description,REQUEST=None):
  891:         """change it"""
  892:         self.tableName=tableName
  893:         self.label=label
  894:         self.description=description
  895:         
  896:         if REQUEST is not None:
  897:             return self.manage_main(self, REQUEST)
  898: 
  899:     manage_options=Folder.manage_options+(
  900:         {'label':'Main Config','action':'changeZSQLBibliographyForm'},
  901:        )
  902: 
  903: 
  904:     def getFieldLabel(self,fields,field):
  905:         """get labels"""
  906:         try:
  907:             ret =fields[0][field]
  908:             if ret == "":
  909:                 return field
  910:             else:
  911:                 return ret
  912:         except:
  913:             return field
  914:         
  915:     def getFieldValue(self,found,field):
  916:         """get value"""
  917:         try:
  918:             ret=getattr(found,field)
  919:             if ret == "":
  920:                 return None
  921:             else:
  922:                 return ret
  923:         except:
  924:             return None
  925: 
  926:     def findTagsFromMapping(self,referenceType):
  927:         """gib hash mit label -> generic zurueck"""
  928:         self.referencetypes=self.ZopeFind(self.standardMD)
  929:         bibdata={}
  930:         retdata={}
  931:         fieldlist=self.standardMD.fieldList
  932:         
  933: 	for referenceTypeF in self.referencetypes:
  934: 		#print referenceType,referenceTypeF[1].title
  935: 		if referenceTypeF[1].title == referenceType: 
  936: 			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
  937: 			bibdata['data']=referenceTypeF[1]
  938: 			self.fields=bibdata[referenceType]
  939:                         for field in fieldlist:
  940: 		            if referenceTypeF[1].getValue(field)[0]==None:
  941: 				retdata[field]=field
  942: 			    else:
  943:                                 retdata[field]=referenceTypeF[1].getValue(field)[0]
  944: 
  945:         return retdata,fieldlist
  946:         
  947:     def findLabelsFromMapping(self,referenceType):
  948:         """gib hash mit label -> generic zurueck"""
  949:         self.referencetypes=self.ZopeFind(self.standardMD)
  950:         bibdata={}
  951:         retdata={}
  952:         fieldlist=self.standardMD.fieldList
  953:         
  954: 	for referenceTypeF in self.referencetypes:
  955: 		#print referenceType,referenceTypeF[1].title
  956: 		if referenceTypeF[1].title == referenceType: 
  957: 			bibdata[referenceTypeF[1].title]=referenceTypeF[1].fields
  958: 			bibdata['data']=referenceTypeF[1]
  959: 			self.fields=bibdata[referenceType]
  960:                         for field in fieldlist:
  961:                             retdata[field]=referenceTypeF[1].getValue(field)[1]
  962: 
  963:         return retdata,fieldlist
  964: 
  965:     def createIndexTag(self,tag,content):
  966:         """creste tag"""
  967:         if content:
  968:             ret="""<%s>%s</%s>"""%(tag,content,tag)
  969:             return ret
  970:         else:
  971:             return ""
  972:     
  973:     def getMetaDataXML2(self):
  974:         """crate index meta"""
  975: 
  976:         fn=os.path.splitext(self.REQUEST['fn'])[0]+"."
  977:         self.REQUEST['fn']=fn
  978: 
  979:         pt=PageTemplateFile('Products/ZSQLExtend/zpt/record2.xml').__of__(self)
  980:         pt.content_type="text/xml"
  981:         return pt()
  982: 
  983:     def getMetaDataXML(self):
  984:         """crate index meta"""
  985:         pt=PageTemplateFile('Products/ZSQLExtend/zpt/record.xml').__of__(self)
  986:         pt.content_type="text/xml"
  987:         return pt()
  988: 
  989:     def getMetaDatasXML(self):
  990:         """index"""
  991:         ret="""<?xml version="1.0" ?>
  992: 	             <index>"""
  993:         for found in self.ZSQLSimpleSearch("select oid from %s limit ALL"%self.tableName):
  994:             link=self.absolute_url()+"/"+"record.html?oid=%i"%found.oid
  995:             metalink=self.absolute_url()+"/"+"getMetaDataXML?oid=%i"%found.oid
  996:             
  997:             ret+="""<resource resourceLink="%s" metaLink="%s"/>\n"""%(link,metalink)
  998:             
  999:         return ret+"\n</index>"
 1000: 
 1001:     
 1002: manage_addZSQLBibliographyForm=DTMLFile('ZSQLBibliographyAdd', globals())
 1003: 
 1004: def manage_addZSQLBibliography(self, id, tableName,label,description,title='',
 1005:                      createPublic=0,
 1006:                      createUserF=0,
 1007:                      REQUEST=None):
 1008:     """Add a new Folder object with id *id*.
 1009: 
 1010:     If the 'createPublic' and 'createUserF' parameters are set to any true
 1011:     value, an 'index_html' and a 'UserFolder' objects are created respectively
 1012:     in the new folder.
 1013:     """
 1014:     
 1015:     
 1016:     ob=ZSQLBibliography()
 1017:     ob.id=str(id)
 1018:     ob.title=title
 1019:     self._setObject(id, ob)
 1020:     ob=self._getOb(id)
 1021:     setattr(ob,'tableName',tableName)
 1022:     setattr(ob,'label',label)
 1023:     setattr(ob,'description',description)
 1024:     
 1025:     checkPermission=getSecurityManager().checkPermission
 1026: 
 1027:     if createUserF:
 1028:         if not checkPermission('Add User Folders', ob):
 1029:             raise Unauthorized, (
 1030:                   'You are not authorized to add User Folders.'
 1031:                   )
 1032:         ob.manage_addUserFolder()
 1033: 
 1034:     if createPublic:
 1035:         if not checkPermission('Add Page Templates', ob):
 1036:             raise Unauthorized, (
 1037:                   'You are not authorized to add Page Templates.'
 1038:                   )
 1039:         ob.manage_addProduct['PageTemplates'].manage_addPageTemplate(
 1040:             id='index_html', title='')
 1041: 
 1042:     if REQUEST is not None:
 1043:         return self.manage_main(self, REQUEST, update_menu=1)
 1044: 
 1045:     
 1046: 
 1047:     

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