1: ### XSLT Class ###
2: ### setzt 4 suite vorraus ###
3: from Acquisition import Implicit
4: from Products.PageTemplates.PageTemplateFile import PageTemplateFile
5: from Globals import DTMLFile
6: from ECHO_Nav import ECHO_pageTemplate
7: from threading import Thread,Timer
8: import threading
9: from ECHO_helpers import *
10: import ECHO_language
11: import sys
12: import urllib
13: import urlparse
14: from Ft.Xml.Domlette import Print, PrettyPrint
15: from StringIO import StringIO
16: from types import *
17: from Globals import package_home
18: import transaction
19:
20: import os.path
21:
22: import urllib
23:
24: try:
25: from Ft.Xml.Xslt.Processor import Processor
26: from Ft.Xml import InputSource, EMPTY_NAMESPACE,Parse
27: except:
28: print "4suite has to be installed"
29:
30:
31: class getXML(Implicit):
32: """get XML thread"""
33:
34: def set(self,qs,xsl,result):
35: """set"""
36:
37: self._v_qs=qs
38: self.xsl=xsl
39: self.result=None
40:
41: # def acquireLock(self):
42: #
43: # lock=getattr(self, "_v_lock", None)
44: # if not lock:
45: # self._v_lock=threading.Lock()
46: # lock=self._v_lock
47: # lock.acquire()
48: #
49: # def releaseLock(self):
50: # # acquire() should have been called
51: # # about one second before. This means the volatile lock
52: # # should still be there
53: #
54: # self._v_lock.release()
55: #
56:
57: def __call__(self):
58: """wait"""
59: return True
60:
61: def run(self):
62: """call it"""
63: xml=""
64:
65: try:
66:
67: urlH=urllib.urlopen(self._v_qs)
68: xml=urlH.read()
69: urlH.close()
70: xsltproc=Processor()
71: document = InputSource.DefaultFactory.fromString(xml)
72:
73: stylesheet = InputSource.DefaultFactory.fromUri(self.xsl)
74:
75: xsltproc.appendStylesheet(stylesheet)
76:
77:
78: #print self.xsl
79: #print xsltproc.run(document)
80: tmp=xsltproc.run(document)
81:
82: self.result=tmp[0:]
83:
84:
85: except:
86:
87: self.result="<html>error: %s %s<br>"%sys.exc_info()[0:2]
88: self.result+=xml
89: self.result+="</html>"
90:
91:
92:
93: def getResult(self):
94:
95: return self.result
96:
97: from ZODB import DB
98: from ZODB.FileStorage import FileStorage
99: class ECHO_cache:
100: def __init__(self):
101: """init the storage"""
102: self.storage=FileStorage("/var/tmp/echo_cache.fs")
103: self.db=DB(self.storage)
104: self.connection=self.db.open()
105: self.root=self.connection.root()
106:
107: def deleteObject(self,name,pn=None):
108: """delete an object from cache"""
109: fileStore=self.root.get(name,None)
110: if fileStore:
111: if not pn:
112: del(self.root[name])
113: else:
114: if self.root[name].get(pn,None):
115: del(self.root[name][pn])
116:
117:
118: def storeObject(self,name,pn,object):
119: """store an object"""
120:
121: if not self.root.get(name,None):
122: self.root[name]={}
123:
124:
125: #following is necessary to make clear that object has really changed for ZODB
126: tmp=self.root[name]
127: tmp[pn]=object
128: self.root[name]=tmp
129: transaction.get().commit()
130: return True
131:
132: def retrieveObject(self,name,pn):
133: """retrieve it"""
134:
135: fileStore=self.root.get(name,None)
136: if not fileStore:
137: return None
138: else:
139: return self.root[name].get(pn,None)
140:
141:
142: class ECHO_xslt(ECHO_pageTemplate,ECHO_language.ECHO_language):
143: """ECHO_xslt classe"""
144:
145: meta_type="ECHO_xslt"
146:
147: cache=ECHO_cache()
148:
149: results={}
150: manage_options=ECHO_pageTemplate.manage_options+(
151: {'label':'Change xml-ressource','action':'change_ECHO_xsltForm'},)
152:
153: def refreshTxt(self):
154: """txt fuer refresh"""
155: return """ 2;url=%s?repeat=%s """%(self.absolute_url(),self.threadName)
156:
157: def xslt(self):
158: """xslt"""
159:
160: return self.document_src()
161:
162: def change_ECHO_xsltForm(self):
163: """change form"""
164: pt=zptFile(self, 'zpt/ChangeECHO_xsltForm.zpt')
165: return pt()
166:
167: def addChanges(self,cgiUrl,RESPONSE=None):
168: """change the xslt, ueberschriebt addChanges in ECHO_PageTemplate"""
169: if urlparse.urlparse(cgiUrl)[0]=="":#relative url in absolute
170: self.cgiUrl=urlparse.urljoin(self.absolute_url(), cgiUrl)
171: else:
172: self.cgiUrl=cgiUrl
173:
174: if RESPONSE:
175: RESPONSE.redirect("manage_main")
176:
177: def index_html(self,repeat=None):
178: """standard ausgabe"""
179:
180: threadName=repeat
181:
182: if not threadName or threadName=="":
183:
184: #abwaertskompatibilitt mit altem nivht konfigurierbaren prototypen
185:
186: if getattr(self,'cgiUrl','')=='':
187: self.cgiUrl="http://medea.mpiwg-berlin.mpg.de/cgi-bin/search/q1"
188:
189: qs="%s%s"%(self.cgiUrl,self.REQUEST['QUERY_STRING'])
190: xsl=self.absolute_url()+"/xslt"
191: self._v_xmltrans=getXML().__of__(self)
192: #self._xmltrans.start()
193: thread=Thread(target=self._v_xmltrans)
194: thread.start()
195: self._v_xmltrans.set(qs,xsl,None)
196: self._v_xmltrans.run()
197:
198:
199: self.threadName=thread.getName()[0:]
200: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
201: if wait_template:
202: return wait_template[0][1]()
203: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self)
204: return pt()
205: #_v_xmltrans.run()
206:
207: else:
208:
209: if (self._v_xmltrans.getResult()==None):
210:
211: wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
212: if wait_template:
213: return wait_template[0][1]()
214:
215: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self)
216: return pt()
217: else:
218: return self._v_xmltrans.getResult()
219:
220:
221:
222: def deleteCache(self):
223: """deletefrom cache"""
224: fn=self.REQUEST['fn']
225: self.cache.deleteObject(fn)
226:
227: def getPageLex(self,_pn="1",_caching="yes"):
228: """getpage mit lexikalischer analyse und xslt transform
229: if _caching=yes dann wird die lwxikalisch analysierte seite in einem cache abgespeichert
230: """
231:
232: fn=self.REQUEST['fn']
233:
234:
235: fromCache=self.cache.retrieveObject(fn,_pn)
236:
237: if fromCache and _caching=="yes":
238: print "retrieve",fn,_pn
239: txt = fromCache
240: else:
241: txt=self.tagLex(nr=_pn)
242: print "store",fn,_pn
243: self.cache.storeObject(fn,_pn,txt[0:])
244:
245: xsl=self.xslt()
246:
247: xsltproc=Processor()
248: if type(txt)==UnicodeType:
249: document = InputSource.DefaultFactory.fromString(txt.encode('utf-8'))
250: else:
251: document = InputSource.DefaultFactory.fromString(txt)
252: stylesheet = InputSource.DefaultFactory.fromString(xsl)
253: xsltproc.appendStylesheet(stylesheet)
254: tmp=xsltproc.run(document)
255:
256: return tmp[0:]
257:
258:
259: def getPage(self,_pn,REQUEST=None):
260: """get a page from an xml"""
261: pn=int(_pn)-1
262: if pn<0:
263: if REQUEST:
264: return "Sorry, pagenumbers have to be greater than 0"
265: else:
266: return None
267: impl=xml.dom.getDOMImplementation()
268: newDoc=impl.createDocument(EMPTY_NAMESPACE,None,None
269: )
270: root=newDoc.createElement('page')
271: newDoc.appendChild(root)
272:
273:
274: qs="%s%s"%(self.cgiUrl,self.REQUEST['QUERY_STRING'])
275:
276:
277:
278: xmlt=urllib.urlopen(qs).read()
279: dom=Parse(xmlt)
280:
281: pbs=dom.xpath("//pb")
282: if pn > len(pbs):
283: if REQUEST:
284: return "Sorry, pagenumber %s does not exit"%pn+1
285: else:
286: return None
287:
288: beginNode=pbs[pn] #take the n'th pb
289:
290: if not (pn==len(pbs)-1): # nicht die letzte Seite
291: endNode=pbs[pn+1]
292: else:
293: endNode=None
294:
295:
296: # follower=beginNode.xpath('following::node()')
297: # #root.appendChild(beginNode)
298: # found=[]
299: #
300: # for node in endNode.xpath('preceding::node()'):
301: # if node in follower:
302: # found.append(node)
303: #
304:
305:
306: #rempove all children of parents which are also in the list
307: # for x in found:
308: # for child in x.xpath(".//*"):
309: # try:
310: #
311: # nr=found.index(child)
312: #
313: # del(found[nr])
314: # except:
315: # pass
316: #
317: # found.append(endNode)
318: #
319: deleteNodes=beginNode.xpath('preceding::node()')
320: if endNode:
321: deleteNodes+=endNode.xpath('following::node()')
322: for node in deleteNodes:
323: try:
324: parent=node.xpath("..")
325:
326: if parent:
327: parent[0].removeChild(node)
328: except:
329: zLOG.LOG("ECHO_Resource (getAccessRightMD)", zLOG.INFO,"%s (%s)"%sys.exc_info()[0:2])
330: strio = StringIO()
331: PrettyPrint(dom,strio)
332: xmlstr = strio.getvalue()
333:
334: return xmlstr
335:
336:
337:
338: def manage_addECHO_xsltForm(self):
339: """Form for adding"""
340: pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','AddECHO_xslt.zpt')).__of__(self)
341: return pt()
342:
343: from urllib import quote
344:
345:
346: def manage_addECHO_xslt(self, id, label, weight= 0,contentType=0,title=None, text=None, cgiUrl=None,
347: REQUEST=None, submit=None):
348: "Add a Page Template with optional file content."
349:
350:
351: id = str(id)
352: if REQUEST is None:
353: self._setObject(id, ECHO_xslt(id, text))
354: ob = getattr(self, id)
355: setattr(ob,'weight',weight)
356: setattr(ob,'label',label)
357: setattr(ob,'contentType',contentType)
358: if title:
359: ob.pt_setTitle(title)
360: return ob
361: setattr(ob,'cgiUrl',cgiUrl)
362: else:
363: file = REQUEST.form.get('file')
364: headers = getattr(file, 'headers', None)
365: if headers is None or not file.filename:
366: zpt = ECHO_xslt(id)
367: else:
368: zpt = ECHO_xslt(id, file, headers.get('contentType'))
369:
370: self._setObject(id, zpt)
371: ob = getattr(self, id)
372: setattr(ob,'weight',weight)
373: setattr(ob,'label',label)
374: setattr(ob,'cgiUrl',cgiUrl)
375: if title:
376: ob.pt_setTitle(title)
377:
378: try:
379: u = self.DestinationURL()
380: except AttributeError:
381: u = REQUEST['URL1']
382:
383: if submit == " Add and Edit ":
384: u = "%s/%s" % (u, quote(id))
385: REQUEST.RESPONSE.redirect(u+'/manage_main')
386: return ''
387:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvs/cvsweb/icons/back.gif){kind=icon}
Return to ECHO_xslt.py CVS log ![[TXT]](/cvs/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvs/cvsweb/icons/dir.gif){kind=icon}
Up to [Repository] / ECHO_content