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

Diff for /ECHO_content/ECHO_xslt.py between versions 1.1 and 1.4

version 1.1, 2005/04/07 21:01:10 version 1.4, 2005/10/23 09:46:26
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
   import threading
   from ECHO_helpers import *
   import sys
   import urllib
   import urlparse
   
   
   
 from Globals import package_home  from Globals import package_home
   
   
 import os.path  import os.path
   
 import urllib  import urllib
Line 19  except: Line 28  except:
     print "4suite has to be installed"      print "4suite has to be installed"
   
   
   class getXML(Implicit):
       """get XML thread"""
   
       def set(self,qs,xsl,result):
           """set"""
      
           self._v_qs=qs
           self.xsl=xsl
           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):
           """wait"""
           return True
       
       def run(self):
           """call it"""
           xml=""
           
           try:
         
               urlH=urllib.urlopen(self._v_qs)
               xml=urlH.read()
               urlH.close()
               xsltproc=Processor()
               document = InputSource.DefaultFactory.fromString(xml)
               
               stylesheet = InputSource.DefaultFactory.fromUri(self.xsl)
               
               xsltproc.appendStylesheet(stylesheet)
               
           
               #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):
   
           return self.result
   
   
       
 class ECHO_xslt(ECHO_pageTemplate):  class ECHO_xslt(ECHO_pageTemplate):
     """ECHO_xslt classe"""      """ECHO_xslt classe"""
   
     meta_type="ECHO_xslt"      meta_type="ECHO_xslt"
   
       results={}
       manage_options=ECHO_pageTemplate.manage_options+(
        {'label':'Change xml-ressource','action':'change_ECHO_xsltForm'},)
        
       def refreshTxt(self):
           """txt fuer refresh"""
           return """ 2;url=%s?repeat=%s """%(self.absolute_url(),self.threadName)
   
     def xslt(self):      def xslt(self):
           """xslt"""
   
           return self.document_src()
   
       def change_ECHO_xsltForm(self):
           """change form"""
           pt=zptFile(self, 'zpt/ChangeECHO_xsltForm.zpt')
           return pt()
   
       def addChanges(self,cgiUrl,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 RESPONSE:
               RESPONSE.redirect("manage_main")
           
       def index_html(self,repeat=None):
         """standard ausgabe"""          """standard ausgabe"""
   
         self.cgiUrl="http://nausikaa2.mpiwg-berlin.mpg.de/cgi-bin/search/q1"          threadName=repeat
           
           if not threadName or threadName=="":
               
               #abwaertskompatibilitŠt mit altem nivht konfigurierbaren prototypen
               
               if getattr(self,'cgiUrl','')=='':
                   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"
               self._v_xmltrans=getXML().__of__(self)
               #self._xmltrans.start()
               thread=Thread(target=self._v_xmltrans)
               thread.start()
               self._v_xmltrans.set(qs,xsl,None)
               self._v_xmltrans.run()
   
         #urlH=urllib.urlopen(qs)  
         #xml=urlH.read()  
         #urlH.close()  
         #print xml  
         #return xml  
           
         xsltproc=Processor()              self.threadName=thread.getName()[0:]
         document = InputSource.DefaultFactory.fromUri(qs)              wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
         stylesheet = InputSource.DefaultFactory.fromUri(self.absolute_url())              if wait_template:
         xsltproc.appendStylesheet(stylesheet)                  return wait_template[0][1]()
               pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self)
               return pt()
               #_v_xmltrans.run()
   
         html=xsltproc.run(document)          else:
               
               if (self._v_xmltrans.getResult()==None):
   
                   wait_template=self.aq_parent.ZopeFind(self.aq_parent,obj_ids=['wait_template'])
                   if wait_template:
                       return wait_template[0][1]()
                                           
         return html                  pt=PageTemplateFile(os.path.join(package_home(globals()),'zpt','xsltWait.zpt')).__of__(self)
                   return pt()
               else:
                   return self._v_xmltrans.getResult()
   
   
 def manage_addECHO_xsltForm(self):  def manage_addECHO_xsltForm(self):
Line 55  def manage_addECHO_xsltForm(self): Line 181  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 70  def manage_addECHO_xslt(self, id, label, Line 196  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 82  def manage_addECHO_xslt(self, id, label, Line 209  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)
                   
Removed from v.1.1  
changed lines
  Added in v.1.4

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