version 1.2, 2005/04/10 11:37:03
|
version 1.11, 2006/09/14 14:31:53
|
Line 1
|
Line 1
|
### XSLT Class ### |
### XSLT Class ### |
### setzt 4 suite vorraus ### |
### setzt 4 suite vorraus ### |
|
from Acquisition import Implicit |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Products.PageTemplates.PageTemplateFile import PageTemplateFile |
from Globals import DTMLFile |
from Globals import DTMLFile |
from ECHO_Nav import ECHO_pageTemplate |
from ECHO_Nav import ECHO_pageTemplate |
from threading import Thread,Timer |
from threading import Thread,Timer |
|
import threading |
|
from ECHO_helpers import * |
|
import ECHO_language |
|
import sys |
|
import urllib |
|
import urlparse |
|
from Ft.Xml.Domlette import Print, PrettyPrint |
|
from StringIO import StringIO |
|
from types import * |
from Globals import package_home |
from Globals import package_home |
|
import transaction |
|
|
import os.path |
import os.path |
|
|
Line 14 import urllib
|
Line 23 import urllib
|
|
|
try: |
try: |
from Ft.Xml.Xslt.Processor import Processor |
from Ft.Xml.Xslt.Processor import Processor |
from Ft.Xml import InputSource |
from Ft.Xml import InputSource, EMPTY_NAMESPACE,Parse |
|
from Ft.Xml.Domlette import NonvalidatingReader |
except: |
except: |
print "4suite has to be installed" |
print "4suite has to be installed" |
|
|
|
|
class getXML: |
class getXML(Implicit): |
"""get XML thread""" |
"""get XML thread""" |
|
|
def __init__(self,qs,xsl): |
def set(self,qs,xsl,result): |
|
"""set""" |
|
|
self.qs=qs |
self._v_qs=qs |
self.xsl=xsl |
self.xsl=xsl |
self.result=None |
self.result=None |
|
|
|
# def acquireLock(self): |
|
# |
|
# lock=getattr(self, "_v_lock", None) |
|
# if not lock: |
|
# self._v_lock=threading.Lock() |
|
# lock=self._v_lock |
|
# lock.acquire() |
|
# |
|
# def releaseLock(self): |
|
# # acquire() should have been called |
|
# # about one second before. This means the volatile lock |
|
# # should still be there |
|
# |
|
# self._v_lock.release() |
|
# |
|
|
def __call__(self): |
def __call__(self): |
|
"""wait""" |
|
return True |
|
|
urlH=urllib.urlopen(self.qs) |
def run(self): |
xml=urlH.read() |
"""call it""" |
urlH.close() |
xml="" |
|
|
|
try: |
|
|
|
urlH=urllib.urlopen(self._v_qs) |
|
xml=urlH.read() |
|
urlH.close() |
xsltproc=Processor() |
xsltproc=Processor() |
document = InputSource.DefaultFactory.fromString(xml) |
document = InputSource.DefaultFactory.fromString(xml) |
|
|
stylesheet = InputSource.DefaultFactory.fromUri(self.xsl) |
stylesheet = InputSource.DefaultFactory.fromUri(self.xsl) |
|
|
xsltproc.appendStylesheet(stylesheet) |
xsltproc.appendStylesheet(stylesheet) |
|
|
self.result=xsltproc.run(document) |
|
|
#print self.xsl |
|
#print xsltproc.run(document) |
|
tmp=xsltproc.run(document) |
|
|
|
self.result=tmp[0:] |
|
|
|
|
|
except: |
|
|
|
self.result="<html>error: %s %s<br>"%sys.exc_info()[0:2] |
|
self.result+=xml |
|
self.result+="</html>" |
|
|
|
|
|
|
def getResult(self): |
def getResult(self): |
|
|
return self.result |
return self.result |
|
|
|
from ZODB import DB |
|
from ZODB.FileStorage import FileStorage |
|
class ECHO_cache: |
|
def __init__(self): |
|
"""init the storage""" |
|
self.storage=FileStorage("/var/tmp/echo_cache.fs") |
|
self.db=DB(self.storage) |
|
self.connection=self.db.open() |
|
self.root=self.connection.root() |
|
|
|
def deleteObject(self,name,pn=None): |
|
"""delete an object from cache""" |
|
fileStore=self.root.get(name,None) |
|
if fileStore: |
|
if not pn: |
|
del(self.root[name]) |
|
else: |
|
if self.root[name].get(pn,None): |
|
del(self.root[name][pn]) |
|
|
|
|
|
def storeObject(self,name,pn,object): |
|
"""store an object""" |
|
|
|
if not self.root.get(name,None): |
|
self.root[name]={} |
|
|
|
|
class ECHO_xslt(ECHO_pageTemplate): |
#following is necessary to make clear that object has really changed for ZODB |
|
tmp=self.root[name] |
|
tmp[pn]=object |
|
self.root[name]=tmp |
|
transaction.get().commit() |
|
return True |
|
|
|
def retrieveObject(self,name,pn): |
|
"""retrieve it""" |
|
|
|
fileStore=self.root.get(name,None) |
|
if not fileStore: |
|
return None |
|
else: |
|
return self.root[name].get(pn,None) |
|
|
|
|
|
class ECHO_xslt(ECHO_pageTemplate,ECHO_language.ECHO_language): |
"""ECHO_xslt classe""" |
"""ECHO_xslt classe""" |
|
|
meta_type="ECHO_xslt" |
meta_type="ECHO_xslt" |
|
|
|
cache=ECHO_cache() # cache for analysed pages |
|
caching="yes" |
|
|
|
appendQueryString=True # add query string to the cgiUrl can be changed with addChanges |
|
|
|
passURL=False #use url from querystring parameter fn to retrieve the text and not the url in cgi-url can be changed with addChanges |
|
|
|
|
|
results={} |
|
manage_options=ECHO_pageTemplate.manage_options+( |
|
{'label':'Change xml-ressource','action':'change_ECHO_xsltForm'},) |
|
|
def refreshTxt(self): |
def refreshTxt(self): |
"""txt fuer refresh""" |
"""txt fuer refresh""" |
return """ 2;url=%s?repeat=%s """%(self.absolute_url(),self.threadName) |
return """ 2;url=%s?repeat=%s """%(self.absolute_url(),self.threadName) |
|
|
def xslt(self): |
def xslt(self): |
"""xslt""" |
"""xslt""" |
return self.pt_render() |
|
|
|
|
return self.document_src() |
|
|
|
def change_ECHO_xsltForm(self): |
|
"""change form""" |
|
pt=zptFile(self, 'zpt/ChangeECHO_xsltForm.zpt') |
|
return pt() |
|
|
|
def addChanges(self,cgiUrl,appendQueryString=False,passURL=False,caching=False,RESPONSE=None): |
|
"""change the xslt, ueberschriebt addChanges in ECHO_PageTemplate""" |
|
|
|
if urlparse.urlparse(cgiUrl)[0]=="":#relative url in absolute |
|
self.cgiUrl=urlparse.urljoin(self.absolute_url(), cgiUrl) |
|
else: |
|
self.cgiUrl=cgiUrl |
|
|
|
if appendQueryString: |
|
self.appendQueryString=True |
|
else: |
|
self.appendQueryString=False |
|
|
|
if passURL: |
|
self.passURL=True |
|
else: |
|
self.passURL=False |
|
|
|
if caching: |
|
self.caching="yes" |
|
else: |
|
self.caching="No" |
|
|
|
|
|
if RESPONSE: |
|
RESPONSE.redirect("manage_main") |
|
|
def index_html(self,repeat=None): |
def index_html(self,repeat=None): |
"""standard ausgabe""" |
"""standard ausgabe""" |
threadName=repeat |
|
|
|
|
threadName=repeat |
|
|
if not threadName or threadName=="": |
if not threadName or threadName=="": |
|
|
|
#abwaertskompatibilitt mit altem nivht konfigurierbaren prototypen |
|
|
|
if getattr(self,'cgiUrl','')=='': |
self.cgiUrl="http://medea.mpiwg-berlin.mpg.de/cgi-bin/search/q1" |
self.cgiUrl="http://medea.mpiwg-berlin.mpg.de/cgi-bin/search/q1" |
|
|
qs="%s?%s"%(self.cgiUrl,self.REQUEST['QUERY_STRING']) |
qs="%s%s"%(self.cgiUrl,self.REQUEST['QUERY_STRING']) |
xsl=self.absolute_url()+"/xslt" |
xsl=self.absolute_url()+"/xslt" |
self.xmltrans=getXML(qs,xsl) |
self._v_xmltrans=getXML().__of__(self) |
thread=Thread(target=self.xmltrans) |
#self._xmltrans.start() |
|
thread=Thread(target=self._v_xmltrans) |
thread.start() |
thread.start() |
|
self._v_xmltrans.set(qs,xsl,None) |
|
self._v_xmltrans.run() |
|
|
|
|
self.threadName=thread.getName()[0:] |
self.threadName=thread.getName()[0:] |
wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template']) |
wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template']) |
Line 86 class ECHO_xslt(ECHO_pageTemplate):
|
Line 226 class ECHO_xslt(ECHO_pageTemplate):
|
return wait_template[0][1]() |
return wait_template[0][1]() |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self) |
return pt() |
return pt() |
#xmltrans.run() |
#_v_xmltrans.run() |
|
|
else: |
else: |
|
|
if (self.xmltrans.getResult()==None): |
if (self._v_xmltrans.getResult()==None): |
killThread(self.xmltrans) |
|
|
wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template']) |
|
if wait_template: |
|
return wait_template[0][1]() |
|
|
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self) |
pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self) |
return pt() |
return pt() |
else: |
else: |
return self.xmltrans.getResult() |
return self._v_xmltrans.getResult() |
|
|
|
|
|
def getText(self): |
|
"""print nur den text""" |
|
qs,baseUri=self.getTextInput() |
|
self.REQUEST.RESPONSE.redirect(qs) |
|
|
|
def deleteCache(self): |
|
"""deletefrom cache""" |
|
fn=self.REQUEST['fn'] |
|
self.cache.deleteObject(fn) |
|
|
|
def getPageLex(self,_pn="1",_id=None,_caching=None): |
|
"""getpage mit lexikalischer analyse und xslt transform |
|
if _caching=yes dann wird die lwxikalisch analysierte seite in einem cache abgespeichert |
|
""" |
|
|
|
if not _caching: |
|
_caching=self.caching |
|
|
|
fn=self.REQUEST['fn'] |
|
|
|
if not _id: |
|
fromCache=self.cache.retrieveObject(fn,_pn) |
|
|
|
if fromCache and _caching=="yes": |
|
|
|
txt = fromCache |
|
else: |
|
txt=self.tagLex(nr=_pn) |
|
|
|
self.cache.storeObject(fn,_pn,txt[0:]) |
|
|
|
else: |
|
txt=self.tagLex(id=_id) |
|
|
|
xsl=self.xslt() |
|
|
|
xsltproc=Processor() |
|
if type(txt)==UnicodeType: |
|
document = InputSource.DefaultFactory.fromString(txt.encode('utf-8')) |
|
else: |
|
document = InputSource.DefaultFactory.fromString(txt) |
|
stylesheet = InputSource.DefaultFactory.fromString(xsl) |
|
xsltproc.appendStylesheet(stylesheet) |
|
tmp=xsltproc.run(document) |
|
#bugfix for digilib images which doesn't accept & |
|
tmp=tmp.replace("&","&") |
|
return tmp[0:] |
|
|
|
def getTextInput(self): |
|
"""get the text |
|
wie der text geholt wird liegt an der konfiguration, |
|
is appendQueryString gesetzt, dann wir jeweils der Querystring an vorgebenen url gesetzt, erwartet wird fn= |
|
fr den Pfad, is passURL gesetzt, dann wird falls fn= eine vollstndige url enthlt, diese anstelle der in cgiurl definierten genommen. |
|
""" |
|
|
|
if getattr(self,'passURL',False) and self.REQUEST.has_key('fn') and (urlparse.urlparse(self.REQUEST['fn'])[0]=='http'): |
|
qs=self.REQUEST['fn'] |
|
baseUri=qs |
|
elif getattr(self,'pappendQueryString',True): |
|
qs="%s%s"%(self.cgiUrl,self.REQUEST['QUERY_STRING']) |
|
baseUri=self.cgiUrl |
|
else: |
|
qs="%s"%(self.cgiUrl) |
|
baseUri=self.cgiUrl |
|
|
|
#fact= InputSource.DefaultFactory.fromUri(qs) |
|
return qs,baseUri |
|
#return InputSource.InputSource(fact) |
|
#xmlt=urllib.urlopen(qs).read() |
|
|
|
def getPage(self,_pn="-1",_id=None,REQUEST=None,_caching=None): |
|
"""get a page from an xml""" |
|
|
|
if not _caching: |
|
_caching=self.caching |
|
|
|
pn=int(_pn)-1 |
|
if pn<0 and (not _id): |
|
if REQUEST: |
|
return "Sorry, pagenumbers have to be greater than 0" |
|
else: |
|
return None |
|
|
|
xmlt,self.baseUri=self.getTextInput() |
|
|
|
#get the text from cache, if existing |
|
fromCache=self.cache.retrieveObject(self.baseUri,"-1") |
|
if fromCache and _caching=="yes": |
|
|
|
txt = fromCache |
|
else: |
|
|
|
txt=urllib.urlopen(xmlt).read() |
|
|
|
self.cache.storeObject(self.baseUri,"-1",txt) |
|
|
|
dom=NonvalidatingReader.parseString(txt,self.baseUri) |
|
|
|
#pb should have a namespache |
|
|
|
pbs=dom.xpath("//mpiwg:pb",explicitNss={'mpiwg':'http://www.mpiwg-berlin.mpg.de/namespace'}) |
|
|
|
if len(pbs)==0: # versuche nochmal ohne |
|
pbs=dom.xpath("//pb") |
|
|
|
if _id: |
|
#suche wieviele pb for der id |
|
|
|
|
|
idpb=dom.xpath("//*[@id='%s']/preceding::node()/mpiwg:pb"%_id,explicitNss={'html':'http://test.de','mpiwg':'http://www.mpiwg-berlin.mpg.de/namespace'}) |
|
if len(idpb)==0: |
|
idpb=dom.xpath("//*[@id='%s']/preceding::node()/pb"%_id) |
|
|
|
if len(idpb)==0: |
|
k=0 |
|
for node in dom.xpath("//*[@id='%s']//preceding::node()"%_id,explicitNss={'html':'http://test.de','mpiwg':'http://www.mpiwg-berlin.mpg.de/namespace'}): |
|
if getattr(node,'tagName',"")=="mpiwg:pb": |
|
k+=1 |
|
else: |
|
k=len(idpb) |
|
pn=k-1 #-1 wegen Seitenzahlzaehlung startet mit 0 |
|
|
|
if pn > len(pbs): |
|
if REQUEST: |
|
return "Sorry, pagenumber %s does not exit"%(pn+1) |
|
else: |
|
return None |
|
|
|
beginNode=pbs[pn] #take the n'th pb |
|
|
|
if not (pn==len(pbs)-1): # nicht die letzte Seite |
|
endNode=pbs[pn+1] |
|
else: |
|
endNode=None |
|
|
|
deleteNodes=beginNode.xpath('preceding::node()') |
|
if endNode: |
|
deleteNodes+=endNode.xpath('following::node()') |
|
for node in deleteNodes: |
|
try: |
|
parent=node.xpath("..") |
|
|
|
if parent: |
|
parent[0].removeChild(node) |
|
except: |
|
zLOG.LOG("ECHO_Resource (getAccessRightMD)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2]) |
|
strio = StringIO() |
|
PrettyPrint(dom,strio) |
|
xmlstr = strio.getvalue() |
|
|
|
return xmlstr |
|
|
|
|
def killThread(thread): |
|
print "killing" |
|
del thread |
|
|
|
def manage_addECHO_xsltForm(self): |
def manage_addECHO_xsltForm(self): |
"""Form for adding""" |
"""Form for adding""" |
Line 111 def manage_addECHO_xsltForm(self):
|
Line 404 def manage_addECHO_xsltForm(self):
|
from urllib import quote |
from urllib import quote |
|
|
|
|
def manage_addECHO_xslt(self, id, label, weight= 0,contentType=0,title=None, text=None, |
def manage_addECHO_xslt(self, id, label, weight= 0,contentType=0,title=None, text=None, cgiUrl=None, |
REQUEST=None, submit=None): |
REQUEST=None, submit=None): |
"Add a Page Template with optional file content." |
"Add a Page Template with optional file content." |
|
|
Line 126 def manage_addECHO_xslt(self, id, label,
|
Line 419 def manage_addECHO_xslt(self, id, label,
|
if title: |
if title: |
ob.pt_setTitle(title) |
ob.pt_setTitle(title) |
return ob |
return ob |
|
setattr(ob,'cgiUrl',cgiUrl) |
else: |
else: |
file = REQUEST.form.get('file') |
file = REQUEST.form.get('file') |
headers = getattr(file, 'headers', None) |
headers = getattr(file, 'headers', None) |
Line 138 def manage_addECHO_xslt(self, id, label,
|
Line 432 def manage_addECHO_xslt(self, id, label,
|
ob = getattr(self, id) |
ob = getattr(self, id) |
setattr(ob,'weight',weight) |
setattr(ob,'weight',weight) |
setattr(ob,'label',label) |
setattr(ob,'label',label) |
|
setattr(ob,'cgiUrl',cgiUrl) |
if title: |
if title: |
ob.pt_setTitle(title) |
ob.pt_setTitle(title) |
|
|