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

Diff for /ECHO_content/VLPExtension.py between versions 1.43 and 1.70

version 1.43, 2005/03/01 11:30:57 version 1.70, 2008/08/05 16:17:46
Line 16  import xml.dom.minidom Line 16  import xml.dom.minidom
 import urllib  import urllib
 import xmlrpclib  import xmlrpclib
 import vlp_xmlhelpers  import vlp_xmlhelpers
   import sys
   import os
   from stat import *
 from types import *  from types import *
 from Globals import package_home  from Globals import package_home
   import transaction
   
   
 def lemmatize(str):  def lemmatize(str):
Line 44  def makeXML(str): Line 47  def makeXML(str):
                   </page>"""%str                    </page>"""%str
                   
                                     
   def checkXMLfrag(str):
       """checks and returns str as XML fragment"""
       
       xmltempl = """<?xml version="1.0" encoding="utf-8" ?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
       <txt>%s</txt>"""
       try:
           dom=xml.dom.minidom.parseString(xmltempl%str)
           return str
       except:
           str=str.replace("& ","&amp; ")
   
       dom=xml.dom.minidom.parseString(xmltempl%str)
       return str
       
                        
                   
 def getText(nodelist):  def getText(nodelist):
   
Line 142  def manage_addSendMailForm(self, id, toA Line 160  def manage_addSendMailForm(self, id, toA
   
           
 class VLP_essay(Folder):  class VLP_essay(Folder):
     """classe für VLP essays"""      """classe fr VLP essays"""
   
     meta_type="VLP_essay"      meta_type="VLP_essay"
   
Line 214  class VLP_essay(Folder): Line 232  class VLP_essay(Folder):
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
       def getPageList(self):
           """returns sorted list of (id,object) of page objects"""
   
           def sortFind(x,y):
               return cmp(x[0],y[0])
           
   #        pages=[]
   #        pagestmp=self.ZopeFind(self,obj_metatypes=['DTML Document','File'])
   #        for page in pagestmp:
   #            if not (page[1].getId()[0]=="."):
   #                pages.append(page)
   
           pages = self.objectItems(['DTML Document','File'])                        
           pages.sort(sortFind)
           
           
       def getPageXMLfrag(self, pageNum=None, pageId=None, pageObj=None):
           """returns XML fragment of page with id"""
           if pageNum is not None:
               pl = self.getPageList()
               pageObj = pl[int(pageNum)-1][1]
               
           if pageId is not None:
               pageObj = getattr(self, pageId, None)
               
           if pageObj is not None:
               txt = ""
               data = pageObj.data
               while data is not None:
                   txt += data
                   if isinstance(data, str):
                       data = None
                   else:
                       data = data.next
           
               xml = checkXMLfrag(txt)
               return xml
   
   
     def getPage(self,pagenum):      def getPage(self,pagenum):
         """gibt essay page mit num aus"""          """gibt essay page mit num aus"""
Line 227  class VLP_essay(Folder): Line 283  class VLP_essay(Folder):
                           
         pages.sort(sortFind)          pages.sort(sortFind)
         #print str(pages[int(pagenum)][1]())          #print str(pages[int(pagenum)][1]())
         if pages[int(pagenum)-1][1].meta_type=='File':  
                   
           if pages[int(pagenum)-1][1].meta_type=='File':
         #return makeXML(str(pages[int(pagenum)-1][1]))          #return makeXML(str(pages[int(pagenum)-1][1]))
         #txt=pages[int(pagenum)-1][1].data.decode('utf-8')          #txt=pages[int(pagenum)-1][1].data.decode('utf-8')
         txt=pages[int(pagenum)-1][1].data          txt=pages[int(pagenum)-1][1].data
         #print txt.encode('utf-8')          #print txt.encode('utf-8')
           
         return self.xml2html(makeXML(txt),quote="no")          return self.xml2html(makeXML(txt),quote="no")
         else:          else:
           
           
   
         return self.xml2html(makeXML(pages[int(pagenum)-1][1]()),quote="no")          return self.xml2html(makeXML(pages[int(pagenum)-1][1]()),quote="no")
                   
     def nextPage(self,pagenum,url):      def nextPage(self,pagenum,url):
Line 259  class VLP_essay(Folder): Line 311  class VLP_essay(Folder):
             retstr=url+"?p="+str(int(pagenum)+1)              retstr=url+"?p="+str(int(pagenum)+1)
             return retstr              return retstr
                   
       def lastURL(self,pagenum,url):
           # teste ob performance ok, sonst in variable
           pages=len(self.ZopeFind(self,obj_metatypes=['DTML Document','File'])) 
           
           return url+"?p="+str(pages)
               
     def previousURL(self,pagenum,url):      def previousURL(self,pagenum,url):
                   
         if int(pagenum)-1 > 0:          if int(pagenum)-1 > 0:
Line 342  class VLP_subcollection(ECHO_collection) Line 400  class VLP_subcollection(ECHO_collection)
     """ subcollection of elements"""      """ subcollection of elements"""
   
     meta_type="VLP_subcollection"      meta_type="VLP_subcollection"
           
           def getVLPSubcollectionToc(self,type):
               
               #different ordering depending on the type
               if(type == "(Collection)"):
                  sort= "shortreference"
               else:
                  sort = "startpages"
              
              #content of journals also displayed if not online
              
               if (type == "(JournalVolume)"):
                  online =""
               else:
                  online ="AND online = 1"
               sort=self.collectionSort(type)
           
               item = [x for x in self.ZSQLSimpleSearch("""SELECT * FROM vl_literature 
                                    WHERE volumeid ~ '%s\\\\M' """%self.getId()
                                    + """ %s AND not referenceType='%s' """%(online,type)
                                    + """ORDER BY """ + sort)]
           
               tocItem = [x for x in self.ZSQLSimpleSearch("""SELECT * FROM vl_literature 
                                    WHERE reference = '%s' """%self.getId()
                                    + """AND online = 1 AND referenceType='%s' """%type
                                    + """ORDER BY """ + sort)]
               
               
   
               return tocItem+item
               
           def checkForFrontMatter(self,item):
                   """Teste ob Frontmatter exists"""
                   if not item==self.getId():
                           return False
                   
                   if self.ZopeFind(self,obj_ids=[self.getId()]):
                           return True
                   else:
                           return False
                   
     def generateSubCollectionFromDB(self):      def generateSubCollectionFromDB(self):
         """erzeuge subcollection"""          """erzeuge subcollection"""
         for item in self.ZSQLSimpleSearch("select * from vl_literature where volumeid like '%s'"%self.id):          for item in self.ZSQLSimpleSearch("select * from vl_literature where volumeid like '%s'"%self.id):
             manage_addECHO_link(self,item.reference,item.titlerefdisplay,item.titlerefdisplay)              manage_addECHO_link(self,item.reference,item.titlerefdisplay,item.titlerefdisplay)
   
   
     def index_html(self):      def index_html(self):
         """erzeuge darstellung"""          """erzeuge darstellung"""
   
Line 377  class VLP_collection(ECHO_collection): Line 477  class VLP_collection(ECHO_collection):
         )          )
   
   
     def generateSubCollections(self):  
       def generateSubCollections(self,errorsTXT="",forceUpdate=False,RESPONSE=None):
         """erzeuge subcollectionen"""          """erzeuge subcollectionen"""
         founds=self.ZSQLSimpleSearch("select * from vl_literature where referencetype in ('(Book)','(Collection)','(Journal)','(Library)')")          logging.debug("generateSubCollections")
           founds=self.ZSQLSimpleSearch("select * from vl_literature where referencetype in ('(Edited Book)','(Book)','(Collection)','(JournalVolume)','(Generic Container)')")
                   
         self.REQUEST.RESPONSE.write("<html><body>\n")          if RESPONSE is not None:
               RESPONSE.setHeader('Content-Type','text/html')
               self.REQUEST.RESPONSE.write("<h2>Create Subcollections</h2>\n")
         for found in founds:          for found in founds:
                           try:
             foundCol=self.ZopeFind(self,obj_ids=[found.reference])                  litid = str(found.reference)
                   foundCol=self.ZopeFind(self,obj_ids=[litid])
             if foundCol:              if foundCol:
                       col = foundCol[0][1]
                       logging.debug("generateSubCollections: subcollection %s exists (%s)"%(col.getId(),found.reference))
                       if (col.title != found.titlerefdisplay) or (col.label != found.titlerefdisplay):
                           # subcollection seems to have changed    
                           logging.debug("generateSubCollections: subcollection has changed, recreating!")
                 self.manage_delObjects([foundCol[0][0]])                  self.manage_delObjects([foundCol[0][0]])
                           manage_addVLP_subCollection(self,litid,found.titlerefdisplay,found.titlerefdisplay)
                   else:
                       logging.debug("generateSubCollections: creating new subcollection %s"%found.reference)
                       manage_addVLP_subCollection(self,litid,found.titlerefdisplay,found.titlerefdisplay)
                   
                   #teste ob es Images auf dem Server gibt mit gleichem Namen (frontmatter)
                   if os.path.exists(os.path.join(self.vlp_basis,litid)):
                       logging.debug("generateSubCollections: found frontmatter in %s"%litid)
                       obj=getattr(self,litid)
                       if not self.ZopeFind(obj,obj_ids=[litid]):
                           metalink=self.REQUEST['URL1']+"/"+litid+"/"+litid+"/index_meta"
                           newObj=VLP_resource(litid,'',metalink,litid,litid,litid,'generated','book','','','','','','')
                           obj._setObject(litid,newObj)
                           
             manage_addVLP_subCollection(self,found.reference,found.titlerefdisplay,found.titlerefdisplay)                      genObj=getattr(obj,litid)
             #getattr(self,found.reference).generateSubCollectionFromDB()                      genObj.createIndexFile(forceUpdate=forceUpdate)
   
             self.REQUEST.RESPONSE.write("<p>%s</p>\n"%found.reference)                  if RESPONSE is not None:
                       self.REQUEST.RESPONSE.write("<p>%s</p>\n"%litid)
   
               except:
                   error=sys.exc_info()[0:2]
                   logging.error("generateSubCollections: ERROR in %s"%litid)
                   if RESPONSE is not None:
                       RESPONSE.write("<p>(ERROR (%s): %s %s)</p>\n"%(litid,error[0],error[1]))
                   #logging.error("generateSubCollections: %s %s"%error)
                   #self.REQUEST.RESPONSE.write("(ERROR (%s): %s %s)\n"%(litid,repr(error[0]),repr(error[1])))
                   errorsTXT+="<p>ERROR: No subcollection of %s (ERROR: %s %s)</p>\n"%(litid,error[0],error[1])
                   #errorsTXT+="<p>No subcollection of %s  "%litid+"(ERROR: %s %s)</p>"%error
   
           return errorsTXT
                   
     def VLP_path_configForm(self):      def VLP_path_configForm(self):
         """change pt"""          """change pt"""
         path=PageTemplateFile(os.path.join(package_home(globals()),'vlp','ChangeVLPPath.zpt')).__of__(self)          pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','ChangeVLPPath.zpt')).__of__(self)
         return pt()          return pt()
   
     def VLP_path_config(self,path,RESPONSE=None):      def VLP_path_config(self,path,RESPONSE=None):
         """config"""          """config"""
         self.path=path          self.vlp_basis=path
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
   
     def updateCollection(self,RESPONSE=None):      def updateCollection(self,forceUpdate=False,RESPONSE=None):
         """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""          """liest verzeichnisse aus dem pfad und legt sie dann als objekte in den ordner"""
         files=os.listdir(self.path)          errorsTXT="<h2>Errors</h2>"
         for fileName in files:          if RESPONSE is not None:
               RESPONSE.setHeader('Content-Type','text/html')
               RESPONSE.write("<html><body>")
                           
           files=os.listdir(self.vlp_basis)
           for fileName in files:
             if fileName[0:3]=="lit":              if fileName[0:3]=="lit":
                   
                 metalink=self.REQUEST['URL1']+"/"+fileName+"/index_meta"                  metalink=self.REQUEST['URL1']+"/"+fileName+"/index_meta"
                   try:
         if not hasattr(self,fileName):          if not hasattr(self,fileName):
                           # create new resource
                           logging.debug("updateCollection: new %s"%fileName)
                           if RESPONSE is not None:
                               RESPONSE.write("<p>new: %s</p>\n"%fileName)
             newObj=VLP_resource(fileName,'',metalink,fileName,fileName,fileName,'generated','book','','','','','','')              newObj=VLP_resource(fileName,'',metalink,fileName,fileName,fileName,'generated','book','','','','','','')
             self._setObject(fileName,newObj)              self._setObject(fileName,newObj)
                 RESPONSE.write("got: %s\n"%fileName)                  
                       if RESPONSE is not None:
                           RESPONSE.write("<p>got: %s "%fileName)
                 genObj=getattr(self,fileName)                  genObj=getattr(self,fileName)
                 genObj.createIndexFile()                      logging.debug("updateCollection: inspecting %s"%fileName)
                       # create index
                       if hasattr(genObj,'createIndexFile'):
                           try:
                               logging.debug("updateCollection: creating index for %s"%fileName)
                               msg = genObj.createIndexFile(forceUpdate=forceUpdate)
                               if msg and RESPONSE is not None:
                                   RESPONSE.write(msg)
                           except:
                               error=sys.exc_info()[0:2]
                               if RESPONSE is not None:
                                   RESPONSE.write("(ERROR (%s): %s %s) "%(fileName,error[0],error[1]))
                               errorsTXT+="<p>ERROR creating index for %s "%fileName+"(ERROR: %s %s)</p>\n"%error
   
                       # update pageSizeSum for subcollections
                       if genObj.meta_type=="VLP_subcollection":
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')                              RESPONSE.write(" is subcollection")
                           logging.debug("updateCollection: %s is subcollection"%fileName)
                           genObj.pageSizeSum=getattr(genObj,fileName).getPageSizeSum()
                       else:
                           genObj.pageSizeSum=genObj.getPageSizeSum()
   
                       if RESPONSE is not None:
                           RESPONSE.write("</p>\n")
                          
                   except:
                       error=sys.exc_info()[0:2]
                       logging.error("updateCollection: ERROR in %s (%s %s)"%(fileName,error[0],error[1]))
                       if RESPONSE is not None:
                           RESPONSE.write("<p>(ERROR (%s): %s %s)</p>\n"%(fileName,error[0],error[1]))
                       errorsTXT+="<p>File not created:%s  (ERROR: %s %s)</p>\n"%(fileName,error[0],error[1])
                               
           # update subcollections    
           errorsTXT+=self.generateSubCollections(forceUpdate=forceUpdate,RESPONSE=RESPONSE)
           errorsTXT+="\n"
           if RESPONSE is not None:
               RESPONSE.write(errorsTXT)
               RESPONSE.write("</body></html>")
   
     def updateCollectionMD(self,RESPONSE=None):      def updateCollectionMD(self,RESPONSE=None):
         """updateMD"""          """updateMD"""
         files=os.listdir(self.path)          files=os.listdir(self.vlp_basis)
         for fileName in files:          for fileName in files:
             if fileName[0:3]=="lit":              if fileName[0:3]=="lit":
                 genObj=getattr(self,fileName)                  genObj=getattr(self,fileName)
Line 478  class VLP_resource(ECHO_resource,Cacheab Line 658  class VLP_resource(ECHO_resource,Cacheab
   
     meta_type="VLP_resource"      meta_type="VLP_resource"
   
     vlp_basis="/mpiwg/online/permanent/vlp"      #vlp_basis="/mpiwg/online/permanent/vlp"
   
           
     referencetypes=[]      referencetypes=[]
Line 493  class VLP_resource(ECHO_resource,Cacheab Line 673  class VLP_resource(ECHO_resource,Cacheab
   
     def getImagePath(self):      def getImagePath(self):
         """Pfad zu den Images"""          """Pfad zu den Images"""
               
         if os.path.isdir(os.path.join(self.vlp_basis,self.resourceID,'pageimg')):          if os.path.isdir(os.path.join(self.vlp_basis,self.resourceID,'pageimg')):
             return os.path.join(self.vlp_basis,self.resourceID,'pageimg')              return os.path.join(self.vlp_basis,self.resourceID,'pageimg')
         elif os.path.isdir(os.path.join(self.vlp_basis,self.resourceID,'pagesHi')):              elif os.path.isdir(os.path.join(self.vlp_basis,self.resourceID,'pages')):
             return os.path.join(self.vlp_basis,self.resourceID,'pagesHi')                      return os.path.join(self.vlp_basis,self.resourceID,'pages')
         else:          else:
             return "<error>no images </error>"              return "<error>no images </error>"
           
Line 570  class VLP_resource(ECHO_resource,Cacheab Line 751  class VLP_resource(ECHO_resource,Cacheab
   
         if self.REQUEST.get('p',None):          if self.REQUEST.get('p',None):
             #self.REQUEST.set('pn',self.file2page(self.REQUEST.get('p',None)))              #self.REQUEST.set('pn',self.file2page(self.REQUEST.get('p',None)))
         self.REQUEST.RESPONSE.redirect(self.REQUEST['URL']+"?pn="+self.file2page(self.REQUEST.get('p',None)))              params = "pn=%s"%self.file2page(self.REQUEST.get('p',None))
               mk = self.REQUEST.get('mk',None)
               if mk:
                   params += "&mk=%s"%mk
               self.REQUEST.RESPONSE.redirect(self.REQUEST['URL']+'?'+params)
                         
     if hasattr(self,'libraryTemplate.html'):      if hasattr(self,'libraryTemplate.html'):
         return getattr(self,'libraryTemplate.html')()          return getattr(self,'libraryTemplate.html')()
Line 624  class VLP_resource(ECHO_resource,Cacheab Line 808  class VLP_resource(ECHO_resource,Cacheab
                           
         return 0          return 0
           
       def getPageSizeSum(self):
               """generate average page size"""
   
               #size of hi resolution
               files=[]
               try:
                       pathHi=os.path.join(self.vlp_basis,self.resourceID,'pages')
                       files=os.listdir(pathHi)
                       hi=0
                       for f in files:
                               hi+=os.stat(os.path.join(pathHi,f))[ST_SIZE]
   
               except:
                       hi=0
   
               #size of hi resolution
               try:
                       pathHi=os.path.join(self.vlp_basis,self.resourceID,'pagesLo')
                       files=os.listdir(pathHi)
                       lo=0
                       for f in files:
                               lo+=os.stat(os.path.join(pathHi,f))[ST_SIZE]
   
               except:
                       lo=0
   
               
               return (hi,lo,len(files))
                       
   
       def getPageWeights(self):
               """average Page sizes in kBytes"""
       
               res=getattr(self,'pageSizeSum',(0,0,1))
               return (res[0]/(1024*res[2]),res[1]/(1024*res[2]))
                               
               
               
     def dir2index(self):      def dir2index(self):
         """dir to index"""          """dir to index"""
   
     excludeNames=['Icon']      excludeNames=['Icon']
           
           
         def calculateName(str):          def calculateName(str):
         name=os.path.splitext(str[1:])[0]          name=os.path.splitext(str[1:])[0]
             ret="%s: %s"%(str[0],name)              ret="%s: %s"%(str[0],name)
Line 638  class VLP_resource(ECHO_resource,Cacheab Line 861  class VLP_resource(ECHO_resource,Cacheab
             ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pageimg'))              ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pageimg'))
             self.imagePath='pageimg'              self.imagePath='pageimg'
         except:          except:
             ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pagesHi'))              ret=os.listdir(os.path.join(self.vlp_basis,self.resourceID,'pages'))
             self.imagePath='pagesHi'              self.imagePath='pages'
         temp=[]          temp=[]
     ret.sort()      ret.sort()
         for x in ret:          for x in ret:
             if (not (x[0]==".")) and (not x[0:4] in excludeNames):              if (not (x[0] in ('.',':'))) and (not x[0:4] in excludeNames):
                   
                 temp.append((calculateName(x),os.path.splitext(x)[0]))                  temp.append((calculateName(x),os.path.splitext(x)[0]))
         return temp          return temp
   
Line 652  class VLP_resource(ECHO_resource,Cacheab Line 874  class VLP_resource(ECHO_resource,Cacheab
     def firstPage(self,url=None):      def firstPage(self,url=None):
         """showlink to the first image"""          """showlink to the first image"""
         if self.REQUEST.get('pn','1')=="1": #erste seinte dann kein a tag          if self.REQUEST.get('pn','1')=="1": #erste seinte dann kein a tag
             return """<img src="../../images/first.gif" alt="first" width="14" height="14" border="0"><br>first"""              return """<img src="/images/first.gif" alt="first" width="14" height="14" border="0"><br>first"""
   
         else:          else:
         ws=self.REQUEST.get('ws','1')          ws=self.REQUEST.get('ws','1')
         return """<a href=%s>          return """<a href=%s>
                          <img src="../../images/first.gif" alt="first" width="14" height="14" border="0"><br>first                           <img src="/images/first.gif" alt="first" width="14" height="14" border="0"><br>first
                          </a>                           </a>
                          """%(self.REQUEST['URL']+"?pn=1&ws=%s"%ws)                           """%(self.REQUEST['URL']+"?pn=1&ws=%s"%ws)
   
Line 668  class VLP_resource(ECHO_resource,Cacheab Line 890  class VLP_resource(ECHO_resource,Cacheab
             ln=len(pages)              ln=len(pages)
                   
         if (self.REQUEST.get('pn')==str(ln)) or (ln==1): #letzte seite dann kein a tag oder nur eine Seite          if (self.REQUEST.get('pn')==str(ln)) or (ln==1): #letzte seite dann kein a tag oder nur eine Seite
             return """<img src="../../images/last.gif" alt="last" width="14" height="14" border="0"><br>last"""              return """<img src="/images/last.gif" alt="last" width="14" height="14" border="0"><br>last"""
   
         else:          else:
         ws=self.REQUEST.get('ws','1')          ws=self.REQUEST.get('ws','1')
         return """<a href=%s>          return """<a href=%s>
                  <img src="../../images/last.gif" alt="last" width="14" height="14" border="0"><br>last                           <img src="/images/last.gif" alt="last" width="14" height="14" border="0"><br>last
                          </a>                           </a>
                          """%(self.REQUEST['URL']+"?pn="+str(ln)+"&ws="+ws)                           """%(self.REQUEST['URL']+"?pn="+str(ln)+"&ws="+ws)
                           
Line 683  class VLP_resource(ECHO_resource,Cacheab Line 905  class VLP_resource(ECHO_resource,Cacheab
   
         nn = int(self.REQUEST.get('pn','1'))-1          nn = int(self.REQUEST.get('pn','1'))-1
         if nn < 1: #letzte  seite dann kein a tag          if nn < 1: #letzte  seite dann kein a tag
             return """<img src="../../images/lisePrev.gif" alt="prev" width="14" height="14" border="0"><br>prev"""              return """<img src="/images/lisePrev.gif" alt="prev" width="14" height="14" border="0"><br>prev"""
   
         else:          else:
         ws=self.REQUEST.get('ws','1')          ws=self.REQUEST.get('ws','1')
         return """<a href=%s>          return """<a href=%s>
                          <img src="../../images/lisePrev.gif" alt="prev" width="14" height="14" border="0"><br>prev                           <img src="/images/lisePrev.gif" alt="prev" width="14" height="14" border="0"><br>prev
                          </a>                           </a>
                          """%(self.REQUEST['URL']+"?pn="+str(nn)+"&ws="+ws)                           """%(self.REQUEST['URL']+"?pn="+str(nn)+"&ws="+ws)
   
Line 700  class VLP_resource(ECHO_resource,Cacheab Line 922  class VLP_resource(ECHO_resource,Cacheab
   
         nn = int(self.REQUEST.get('pn','1'))+1          nn = int(self.REQUEST.get('pn','1'))+1
         if (nn>int(ln)) or (ln==1): #letzte  seite dann kein a tag          if (nn>int(ln)) or (ln==1): #letzte  seite dann kein a tag
             return """<img src="../../images/liseNext.gif" alt="next" width="14" height="14" border="0"><br>next"""              return """<img src="/images/liseNext.gif" alt="next" width="14" height="14" border="0"><br>next"""
   
         else:          else:
         ws=self.REQUEST.get('ws','1')          ws=self.REQUEST.get('ws','1')
         return """<a href=%s>          return """<a href=%s>
                          <img src="../../images/liseNext.gif" alt="next" width="14" height="14" border="0"><br>next                           <img src="/images/liseNext.gif" alt="next" width="14" height="14" border="0"><br>next
                          </a>                           </a>
                          """%(self.REQUEST['URL']+"?pn="+str(nn)+"&ws="+ws)                           """%(self.REQUEST['URL']+"?pn="+str(nn)+"&ws="+ws)
                   
Line 713  class VLP_resource(ECHO_resource,Cacheab Line 935  class VLP_resource(ECHO_resource,Cacheab
     def readIndexFile(self,url=None):      def readIndexFile(self,url=None):
         """reads the indexfile. presently url not None isn't implemented. In the future url can be defined."""          """reads the indexfile. presently url not None isn't implemented. In the future url can be defined."""
     if not url:      if not url:
             url=self.absolute_url()+"/index.xml"              urlTmp=self.absolute_url()+"/index.xml"
   
     if self.ZCacheable_isCachingEnabled():      if self.ZCacheable_isCachingEnabled():
                           
             result = self.ZCacheable_get(view_name=url)              result = self.ZCacheable_get(view_name=urlTmp)
             if result is not None:              if result is not None:
                 # Got a cached value.                  # Got a cached value.
                 return result                  return result
   
         pagelist=[]          pagelist=[]
         
         fh=ECHO_helpers.urlopen(url)          if not url:
   
               xmlTxt=getattr(self,'index.xml')()
               dom=xml.dom.minidom.parseString(xmlTxt)
           else:            
               fh=ECHO_helpers.urlopen(urlTmp)
         dom=xml.dom.minidom.parse(fh)          dom=xml.dom.minidom.parse(fh)
                   
                   
Line 734  class VLP_resource(ECHO_resource,Cacheab Line 961  class VLP_resource(ECHO_resource,Cacheab
         fileName=page.getAttribute('file')          fileName=page.getAttribute('file')
             pagelist.append((pageNum,text,fileName))              pagelist.append((pageNum,text,fileName))
   
     self.ZCacheable_set(pagelist,view_name=url)          self.ZCacheable_set(pagelist,view_name=urlTmp)
         return pagelist           return pagelist 
   
     def getFileName(self):      def getFileName(self):
Line 746  class VLP_resource(ECHO_resource,Cacheab Line 973  class VLP_resource(ECHO_resource,Cacheab
        pageinfo=self.readIndexFile()[pn-1]         pageinfo=self.readIndexFile()[pn-1]
        return pageinfo[2]         return pageinfo[2]
         
     def createIndexFile(self,RESPONSE=None):      def createIndexFile(self,forceUpdate=False,RESPONSE=None):
         """create index file"""          """create index file"""
           logging.debug("createindexfile of %s"%self.id)
   
           if hasattr(self,'index.xml'):
               # index exists
               zt=getattr(self,'index.xml')
               if not forceUpdate:
                   # check if directory is newer (self.imagePath sould be set by now)
                   imgdir = os.path.join(self.vlp_basis, self.resourceID, self.imagePath)
                   dirtime = os.path.getmtime(imgdir)
                   zttime = zt.bobobase_modification_time()
                   logging.debug("createindexfile: dir %s of %s index of %s"%(imgdir,dirtime,zttime))
                   if dirtime < zttime:
                       # nothing to do
                       logging.debug("createindexfile: dir %s older than index"%(imgdir))
                       return "index is up to date"
                   
         pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','index_template.zpt')).__of__(self)()          else:
               # create new index template
   
           
         if not hasattr(self,'index.xml'):  
             zt=ZopePageTemplate('index.xml')              zt=ZopePageTemplate('index.xml')
             self._setObject('index.xml',zt)              self._setObject('index.xml',zt)
         else:  
             zt=getattr(self,'index.xml')  
               
                           
           # fill index template
           pt=PageTemplateFile(os.path.join(package_home(globals()),'vlp','index_template.zpt')).__of__(self)()
           #logging.debug("createindexfile uses %s"%pt)
         zt.pt_edit(pt, 'text/xml')          zt.pt_edit(pt, 'text/xml')
           transaction.get().commit()
   
         if RESPONSE is not None:          if RESPONSE is not None:
             RESPONSE.redirect('manage_main')              RESPONSE.redirect('manage_main')
Removed from v.1.43  
changed lines
  Added in v.1.70

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